http://git-wip-us.apache.org/repos/asf/celix/blob/18a5bf74/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_interface.c ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_interface.c b/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_interface.c deleted file mode 100644 index d217d65..0000000 --- a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_interface.c +++ /dev/null @@ -1,431 +0,0 @@ -/** - *Licensed to the Apache Software Foundation (ASF) under one - *or more contributor license agreements. See the NOTICE file - *distributed with this work for additional information - *regarding copyright ownership. The ASF licenses this file - *to you under the Apache License, Version 2.0 (the - *"License"); you may not use this file except in compliance - *with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - *Unless required by applicable law or agreed to in writing, - *software distributed under the License is distributed on an - *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - *specific language governing permissions and limitations - *under the License. - */ -#include "dyn_interface.h" - -#include <stdlib.h> -#include <string.h> - -#include "dyn_common.h" -#include "dyn_type.h" -#include "dyn_interface.h" - -DFI_SETUP_LOG(dynInterface); - -struct _dyn_interface_type { - struct namvals_head header; - struct namvals_head annotations; - struct types_head types; - struct methods_head methods; -}; - -static const int OK = 0; -static const int ERROR = 1; - -static int dynInterface_parseSection(dyn_interface_type *intf, FILE *stream); -static int dynInterface_parseAnnotations(dyn_interface_type *intf, FILE *stream); -static int dynInterface_parseTypes(dyn_interface_type *intf, FILE *stream); -static int dynInterface_parseMethods(dyn_interface_type *intf, FILE *stream); -static int dynInterface_parseHeader(dyn_interface_type *intf, FILE *stream); -static int dynInterface_parseNameValueSection(dyn_interface_type *intf, FILE *stream, struct namvals_head *head); -static int dynInterface_checkInterface(dyn_interface_type *intf); -static int dynInterface_getEntryForHead(struct namvals_head *head, const char *name, char **value); - -int dynInterface_parse(FILE *descriptor, dyn_interface_type **out) { - int status = OK; - - dyn_interface_type *intf = calloc(1, sizeof(*intf)); - if (intf != NULL) { - TAILQ_INIT(&intf->header); - TAILQ_INIT(&intf->annotations); - TAILQ_INIT(&intf->types); - TAILQ_INIT(&intf->methods); - - char peek = fgetc(descriptor); - while (peek == ':') { - ungetc(peek, descriptor); - status = dynInterface_parseSection(intf, descriptor); - if (status == OK) { - peek = fgetc(descriptor); - } else { - break; - } - } - - if (status == OK) { - status = dynCommon_eatChar(descriptor, EOF); - } - - if (status == OK) { - status = dynInterface_checkInterface(intf); - } - } else { - status = ERROR; - LOG_ERROR("Error allocating memory for dynamic interface\n"); - } - - if (status == OK) { - *out = intf; - } else if (intf != NULL) { - dynInterface_destroy(intf); - } - return status; -} - -static int dynInterface_checkInterface(dyn_interface_type *intf) { - int status = OK; - - //check header section - if (status == OK) { - bool foundType = false; - bool foundVersion = false; - bool foundName = false; - struct namval_entry *entry = NULL; - TAILQ_FOREACH(entry, &intf->header, entries) { - if (strcmp(entry->name, "type") == 0) { - foundType = true; - } else if (strcmp(entry->name, "version") == 0) { - foundVersion = true; - } else if (strcmp(entry->name, "name") == 0) { - foundName = true; - } - } - - if (!foundType || !foundVersion || !foundName) { - status = ERROR; - LOG_ERROR("Parse Error. There must be a header section with a type, version and name entry"); - } - - struct method_entry *mEntry = NULL; - TAILQ_FOREACH(mEntry, &intf->methods, entries) { - dyn_type *type = dynFunction_returnType(mEntry->dynFunc); - int descriptor = dynType_descriptorType(type); - if (descriptor != 'N') { - status = ERROR; - LOG_ERROR("Parse Error. Only method with a return type 'N' (native int) are supported. Got return type '%c'\n", descriptor); - break; - } - } - } - - return status; -} - -static int dynInterface_parseSection(dyn_interface_type *intf, FILE *stream) { - int status = OK; - char *sectionName = NULL; - - status = dynCommon_eatChar(stream, ':'); - - if (status == OK) { - status = dynCommon_parseName(stream, §ionName); - } - - if (status == OK) { - status = dynCommon_eatChar(stream, '\n'); - } - - if (status == OK) { - if (strcmp("header", sectionName) == 0) { - status = dynInterface_parseHeader(intf, stream); - } else if (strcmp("annotations", sectionName) == 0) { - status = dynInterface_parseAnnotations(intf, stream); - } else if (strcmp("types", sectionName) == 0) { - status = dynInterface_parseTypes(intf, stream); - } else if (strcmp("methods", sectionName) == 0) { - status = dynInterface_parseMethods(intf, stream); - } else { - status = ERROR; - LOG_ERROR("unsupported section '%s'", sectionName); - } - } - - if (sectionName != NULL) { - free(sectionName); - } - - return status; -} - -static int dynInterface_parseHeader(dyn_interface_type *intf, FILE *stream) { - return dynInterface_parseNameValueSection(intf, stream, &intf->header); -} - -static int dynInterface_parseAnnotations(dyn_interface_type *intf, FILE *stream) { - return dynInterface_parseNameValueSection(intf, stream, &intf->annotations); -} - -static int dynInterface_parseNameValueSection(dyn_interface_type *intf, FILE *stream, struct namvals_head *head) { - int status = OK; - - int peek = fgetc(stream); - while (peek != ':' && peek != EOF) { - ungetc(peek, stream); - - char *name; - char *value; - status = dynCommon_parseNameValue(stream, &name, &value); - - if (status == OK) { - status = dynCommon_eatChar(stream, '\n'); - } - - struct namval_entry *entry = NULL; - if (status == OK) { - entry = calloc(1, sizeof(*entry)); - if (entry != NULL) { - entry->name = name; - entry->value = value; - TAILQ_INSERT_TAIL(head, entry, entries); - } else { - status = ERROR; - LOG_ERROR("Error allocating memory for namval entry"); - } - } - - if (status != OK) { - if (name != NULL) { - free(name); - } - if (value != NULL) { - free(value); - } - if (entry != NULL) { - free(entry); - } - break; - } - peek = fgetc(stream); - } - ungetc(peek, stream); - - return status; -} - -static int dynInterface_parseTypes(dyn_interface_type *intf, FILE *stream) { - int status = OK; - - //expected input (Name)=<Type>\n - int peek = fgetc(stream); - while (peek != ':' && peek != EOF) { - ungetc(peek, stream); - - char *name; - status = dynCommon_parseName(stream, &name); - - if (status == OK) { - status = dynCommon_eatChar(stream, '='); - } - - dyn_type *type = NULL; - if (status == OK) { - dynType_parse(stream, name, &intf->types, &type); - } - if (name != NULL) { - free(name); - } - - if (status == OK) { - status = dynCommon_eatChar(stream, '\n'); - } - - struct type_entry *entry = NULL; - if (status == OK) { - entry = calloc(1, sizeof(*entry)); - if (entry != NULL) { - entry->type = type; - TAILQ_INSERT_TAIL(&intf->types, entry, entries); - } else { - status = ERROR; - LOG_ERROR("Error allocating memory for type entry"); - } - } - - if (status != OK) { - if (type != NULL) { - dynType_destroy(type); - } - if (entry != NULL) { - free(entry); - } - break; - } - peek = fgetc(stream); - } - ungetc(peek, stream); - - return status; -} - -static int dynInterface_parseMethods(dyn_interface_type *intf, FILE *stream) { - int status = OK; - - //expected input (Name)=<Method>\n - int peek = fgetc(stream); - int index = 0; - while (peek != ':' && peek != EOF) { - ungetc(peek, stream); - - char *id; - status = dynCommon_parseNameAlsoAccept(stream, "();[{}/", &id); - - if (status == OK) { - status = dynCommon_eatChar(stream, '='); - } - - - dyn_function_type *func = NULL; - if (status == OK) { - status = dynFunction_parse(stream, &intf->types, &func); - } - - if (status == OK) { - status = dynCommon_eatChar(stream, '\n'); - } - - struct method_entry *entry = NULL; - if (status == OK) { - entry = calloc(1, sizeof(*entry)); - if (entry != NULL) { - entry->index = index++; - entry->id = id; - entry->dynFunc = func; - entry->name = strndup(id, 1024); - if (entry->name != NULL) { - int i; - for (i = 0; i < 1024; i += 1) { - if (entry->name[i] == '\0') { - break; - } else if (entry->name[i] == '(') { - entry->name[i] = '\0'; - break; - } - } - } - TAILQ_INSERT_TAIL(&intf->methods, entry, entries); - } else { - status = ERROR; - LOG_ERROR("Error allocating memory for method entry"); - } - } - - if (status != OK) { - if (id != NULL) { - free(id); - } - if (func != NULL) { - dynFunction_destroy(func); - //TODO free strIdentier, name - } - if (entry != NULL) { - free(entry); - } - break; - } - peek = fgetc(stream); - } - ungetc(peek, stream); - - return status; -} - -void dynInterface_destroy(dyn_interface_type *intf) { - if (intf != NULL) { - dynCommon_clearNamValHead(&intf->header); - dynCommon_clearNamValHead(&intf->annotations); - - struct method_entry *mTmp = NULL; - struct method_entry *mInfo = TAILQ_FIRST(&intf->methods); - while (mInfo != NULL) { - mTmp = mInfo; - mInfo = TAILQ_NEXT(mInfo, entries); - - if (mTmp->id != NULL) { - free(mTmp->id); - } - if (mTmp->name != NULL) { - free(mTmp->name); - } - if (mTmp->dynFunc != NULL) { - dynFunction_destroy(mTmp->dynFunc); - } - free(mTmp); - } - - struct type_entry *tmp = NULL; - struct type_entry *tInfo = TAILQ_FIRST(&intf->types); - while (tInfo != NULL) { - tmp = tInfo; - tInfo = TAILQ_NEXT(tInfo, entries); - dynType_destroy(tmp->type); - free(tmp); - } - - free(intf); - } -} - -int dynInterface_getName(dyn_interface_type *intf, char **out) { - return dynInterface_getEntryForHead(&intf->header, "name", out); -} - -int dynInterface_getVersion(dyn_interface_type *intf, char **version) { - return dynInterface_getEntryForHead(&intf->header, "version", version); -} - -int dynInterface_getHeaderEntry(dyn_interface_type *intf, const char *name, char **value) { - return dynInterface_getEntryForHead(&intf->header, name, value); -} - -int dynInterface_getAnnotationEntry(dyn_interface_type *intf, const char *name, char **value) { - return dynInterface_getEntryForHead(&intf->annotations, name, value); -} - -static int dynInterface_getEntryForHead(struct namvals_head *head, const char *name, char **out) { - int status = OK; - char *value = NULL; - struct namval_entry *entry = NULL; - TAILQ_FOREACH(entry, head, entries) { - if (strcmp(name, entry->name) == 0) { - value = entry->value; - break; - } - } - if (value != NULL) { - *out = value; - } else { - status = ERROR; - LOG_WARNING("Cannot find '%s' in list", name); - } - return status; -} - -int dynInterface_methods(dyn_interface_type *intf, struct methods_head **list) { - int status = OK; - *list = &intf->methods; - return status; -} - -int dynInterface_nrOfMethods(dyn_interface_type *intf) { - int count = 0; - struct method_entry *entry = NULL; - TAILQ_FOREACH(entry, &intf->methods, entries) { - count +=1; - } - return count; -}
http://git-wip-us.apache.org/repos/asf/celix/blob/18a5bf74/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_interface.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_interface.h b/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_interface.h deleted file mode 100644 index 51a2f41..0000000 --- a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_interface.h +++ /dev/null @@ -1,63 +0,0 @@ -/** - *Licensed to the Apache Software Foundation (ASF) under one - *or more contributor license agreements. See the NOTICE file - *distributed with this work for additional information - *regarding copyright ownership. The ASF licenses this file - *to you under the Apache License, Version 2.0 (the - *"License"); you may not use this file except in compliance - *with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - *Unless required by applicable law or agreed to in writing, - *software distributed under the License is distributed on an - *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - *specific language governing permissions and limitations - *under the License. - */ -#ifndef __DYN_INTERFACE_H_ -#define __DYN_INTERFACE_H_ - -#include "dyn_common.h" -#include "dyn_type.h" -#include "dyn_function.h" -#include "dfi_log_util.h" - -DFI_SETUP_LOG_HEADER(dynInterface); - -/* Description string - * - * Descriptor (interface) = HeaderSection AnnotationSection TypesSection MethodsSection - * - * HeaderSection= - * ':header\n' [NameValue]* - * ':annotations\n' [NameValue]* - * ':types\n' [TypeIdValue]* - * ':methods\n' [MethodIdValue] - * - */ -typedef struct _dyn_interface_type dyn_interface_type; - -TAILQ_HEAD(methods_head, method_entry); -struct method_entry { - int index; - char *id; - char *name; - dyn_function_type *dynFunc; - - TAILQ_ENTRY(method_entry) entries; -}; - -int dynInterface_parse(FILE *descriptor, dyn_interface_type **out); -void dynInterface_destroy(dyn_interface_type *intf); - -int dynInterface_getName(dyn_interface_type *intf, char **name); -int dynInterface_getVersion(dyn_interface_type *intf, char **version); -int dynInterface_getHeaderEntry(dyn_interface_type *intf, const char *name, char **value); -int dynInterface_getAnnotationEntry(dyn_interface_type *intf, const char *name, char **value); -int dynInterface_methods(dyn_interface_type *intf, struct methods_head **list); -int dynInterface_nrOfMethods(dyn_interface_type *intf); - - -#endif http://git-wip-us.apache.org/repos/asf/celix/blob/18a5bf74/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_message.c ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_message.c b/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_message.c deleted file mode 100644 index c43412a..0000000 --- a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_message.c +++ /dev/null @@ -1,337 +0,0 @@ -/** - *Licensed to the Apache Software Foundation (ASF) under one - *or more contributor license agreements. See the NOTICE file - *distributed with this work for additional information - *regarding copyright ownership. The ASF licenses this file - *to you under the Apache License, Version 2.0 (the - *"License"); you may not use this file except in compliance - *with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - *Unless required by applicable law or agreed to in writing, - *software distributed under the License is distributed on an - *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - *specific language governing permissions and limitations - *under the License. - */ -#include "dyn_message.h" - -#include <stdlib.h> -#include <string.h> - -#include "dyn_common.h" -#include "dyn_type.h" - -DFI_SETUP_LOG(dynMessage); - -struct _dyn_message_type { - struct namvals_head header; - struct namvals_head annotations; - struct types_head types; - dyn_type *msgType; -}; - -static const int OK = 0; -static const int ERROR = 1; - -static int dynMessage_parseSection(dyn_message_type *msg, FILE *stream); -static int dynMessage_parseAnnotations(dyn_message_type *msg, FILE *stream); -static int dynMessage_parseTypes(dyn_message_type *msg, FILE *stream); -static int dynMessage_parseMessage(dyn_message_type *msg, FILE *stream); -static int dynMessage_parseHeader(dyn_message_type *msg, FILE *stream); -static int dynMessage_parseNameValueSection(dyn_message_type *msg, FILE *stream, struct namvals_head *head); -static int dynMessage_checkMessage(dyn_message_type *msg); -static int dynMessage_getEntryForHead(struct namvals_head *head, const char *name, char **value); - -int dynMessage_parse(FILE *descriptor, dyn_message_type **out) { - int status = OK; - - dyn_message_type *msg = calloc(1, sizeof(*msg)); - if (msg != NULL) { - TAILQ_INIT(&msg->header); - TAILQ_INIT(&msg->annotations); - TAILQ_INIT(&msg->types); - - char peek = fgetc(descriptor); - while (peek == ':') { - ungetc(peek, descriptor); - status = dynMessage_parseSection(msg, descriptor); - if (status == OK) { - peek = fgetc(descriptor); - } else { - break; - } - } - - if (status == OK) { - status = dynCommon_eatChar(descriptor, EOF); - } - - if (status == OK) { - status = dynMessage_checkMessage(msg); - } - } else { - status = ERROR; - LOG_ERROR("Error allocating memory for dynamic message\n"); - } - - if (status == OK) { - *out = msg; - } else if (msg != NULL) { - dynMessage_destroy(msg); - } - return status; -} - -static int dynMessage_checkMessage(dyn_message_type *msg) { - int status = OK; - - //check header section - if (status == OK) { - bool foundType = false; - bool foundVersion = false; - bool foundName = false; - struct namval_entry *entry = NULL; - TAILQ_FOREACH(entry, &msg->header, entries) { - if (strcmp(entry->name, "type") == 0) { - foundType = true; - } else if (strcmp(entry->name, "version") == 0) { - foundVersion = true; - } else if (strcmp(entry->name, "name") == 0) { - foundName = true; - } - } - - if (!foundType || !foundVersion || !foundName) { - status = ERROR; - LOG_ERROR("Parse Error. There must be a header section with a type, version and name entry"); - } - } - - return status; -} - -static int dynMessage_parseSection(dyn_message_type *msg, FILE *stream) { - int status = OK; - char *sectionName = NULL; - - status = dynCommon_eatChar(stream, ':'); - - if (status == OK) { - status = dynCommon_parseName(stream, §ionName); - } - - if (status == OK) { - status = dynCommon_eatChar(stream, '\n'); - } - - if (status == OK) { - if (strcmp("header", sectionName) == 0) { - status = dynMessage_parseHeader(msg, stream); - } else if (strcmp("annotations", sectionName) == 0) { - status = dynMessage_parseAnnotations(msg, stream); - } else if (strcmp("types", sectionName) == 0) { - status = dynMessage_parseTypes(msg, stream); - } else if (strcmp("message", sectionName) == 0) { - status = dynMessage_parseMessage(msg, stream); - } else { - status = ERROR; - LOG_ERROR("unsupported section '%s'", sectionName); - } - } - - if (sectionName != NULL) { - free(sectionName); - } - - return status; -} - -static int dynMessage_parseHeader(dyn_message_type *msg, FILE *stream) { - return dynMessage_parseNameValueSection(msg, stream, &msg->header); -} - -static int dynMessage_parseAnnotations(dyn_message_type *msg, FILE *stream) { - return dynMessage_parseNameValueSection(msg, stream, &msg->annotations); -} - -static int dynMessage_parseNameValueSection(dyn_message_type *msg, FILE *stream, struct namvals_head *head) { - int status = OK; - - int peek = fgetc(stream); - while (peek != ':' && peek != EOF) { - ungetc(peek, stream); - - char *name; - char *value; - status = dynCommon_parseNameValue(stream, &name, &value); - - if (status == OK) { - status = dynCommon_eatChar(stream, '\n'); - } - - struct namval_entry *entry = NULL; - if (status == OK) { - entry = calloc(1, sizeof(*entry)); - if (entry != NULL) { - entry->name = name; - entry->value = value; - TAILQ_INSERT_TAIL(head, entry, entries); - } else { - status = ERROR; - LOG_ERROR("Error allocating memory for namval entry"); - } - } - - if (status != OK) { - if (name != NULL) { - free(name); - } - if (value != NULL) { - free(value); - } - if (entry != NULL) { - free(entry); - } - break; - } - peek = fgetc(stream); - } - ungetc(peek, stream); - - return status; -} - -static int dynMessage_parseTypes(dyn_message_type *msg, FILE *stream) { - int status = OK; - - //expected input (Name)=<Type>\n - int peek = fgetc(stream); - while (peek != ':' && peek != EOF) { - ungetc(peek, stream); - - char *name; - status = dynCommon_parseName(stream, &name); - - if (status == OK) { - status = dynCommon_eatChar(stream, '='); - } - - dyn_type *type = NULL; - if (status == OK) { - dynType_parse(stream, name, &msg->types, &type); - } - if (name != NULL) { - free(name); - } - - if (status == OK) { - status = dynCommon_eatChar(stream, '\n'); - } - - struct type_entry *entry = NULL; - if (status == OK) { - entry = calloc(1, sizeof(*entry)); - if (entry != NULL) { - entry->type = type; - TAILQ_INSERT_TAIL(&msg->types, entry, entries); - } else { - status = ERROR; - LOG_ERROR("Error allocating memory for type entry"); - } - } - - if (status != OK) { - if (type != NULL) { - dynType_destroy(type); - } - if (entry != NULL) { - free(entry); - } - break; - } - peek = fgetc(stream); - } - ungetc(peek, stream); - - return status; -} - -static int dynMessage_parseMessage(dyn_message_type *msg, FILE *stream) { - int status = OK; - - //expected input <dynType>\n - char *name = NULL; - status = dynMessage_getName(msg, &name); - - if (status == OK) { - status = dynType_parse(stream, name, &(msg->types), &(msg->msgType)); - } - - return status; -} - -void dynMessage_destroy(dyn_message_type *msg) { - if (msg != NULL) { - dynCommon_clearNamValHead(&msg->header); - dynCommon_clearNamValHead(&msg->annotations); - - struct type_entry *tmp = NULL; - struct type_entry *tInfo = TAILQ_FIRST(&msg->types); - while (tInfo != NULL) { - tmp = tInfo; - tInfo = TAILQ_NEXT(tInfo, entries); - dynType_destroy(tmp->type); - free(tmp); - } - - if (msg->msgType != NULL) { - dynType_destroy(msg->msgType); - } - - free(msg); - } -} - -int dynMessage_getName(dyn_message_type *msg, char **out) { - return dynMessage_getEntryForHead(&msg->header, "name", out); -} - -int dynMessage_getVersion(dyn_message_type *msg, char **version) { - return dynMessage_getEntryForHead(&msg->header, "version", version); -} - -int dynMessage_getHeaderEntry(dyn_message_type *msg, const char *name, char **value) { - return dynMessage_getEntryForHead(&msg->header, name, value); -} - -int dynMessage_getAnnotationEntry(dyn_message_type *msg, const char *name, char **value) { - return dynMessage_getEntryForHead(&msg->annotations, name, value); -} - -static int dynMessage_getEntryForHead(struct namvals_head *head, const char *name, char **out) { - int status = OK; - char *value = NULL; - struct namval_entry *entry = NULL; - TAILQ_FOREACH(entry, head, entries) { - if (strcmp(name, entry->name) == 0) { - value = entry->value; - break; - } - } - if (value != NULL) { - *out = value; - } else { - status = ERROR; - LOG_WARNING("Cannot find '%s' in list", name); - } - return status; -} - -int dynMessage_getMessageType(dyn_message_type *msg, dyn_type **type) { - int status = OK; - *type = msg->msgType; - return status; -} http://git-wip-us.apache.org/repos/asf/celix/blob/18a5bf74/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_message.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_message.h b/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_message.h deleted file mode 100644 index b2f5f0e..0000000 --- a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_message.h +++ /dev/null @@ -1,53 +0,0 @@ -/** - *Licensed to the Apache Software Foundation (ASF) under one - *or more contributor license agreements. See the NOTICE file - *distributed with this work for additional information - *regarding copyright ownership. The ASF licenses this file - *to you under the Apache License, Version 2.0 (the - *"License"); you may not use this file except in compliance - *with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - *Unless required by applicable law or agreed to in writing, - *software distributed under the License is distributed on an - *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - *specific language governing permissions and limitations - *under the License. - */ -#ifndef __DYN_MESSAGE_H_ -#define __DYN_MESSAGE_H_ - -#include "dyn_common.h" -#include "dyn_type.h" -#include "dfi_log_util.h" - -DFI_SETUP_LOG_HEADER(dynMessage); - -/* Description string - * - * Descriptor (message) = HeaderSection AnnotationSection TypesSection MessageSection - * - * HeaderSection= - * ':header\n' [NameValue]* - * ':annotations\n' [NameValue]* - * ':types\n' [TypeIdValue]* - * ':message\n' [MessageIdValue] - * - */ -typedef struct _dyn_message_type dyn_message_type; - - -int dynMessage_parse(FILE *descriptor, dyn_message_type **out); -void dynMessage_destroy(dyn_message_type *msg); - -int dynMessage_getName(dyn_message_type *msg, char **name); -int dynMessage_getVersion(dyn_message_type *msg, char **version); -int dynMessage_getHeaderEntry(dyn_message_type *msg, const char *name, char **value); -int dynMessage_getAnnotationEntry(dyn_message_type *msg, const char *name, char **value); -int dynMessage_getMessageType(dyn_message_type *msg, dyn_type **type); - - - -#endif http://git-wip-us.apache.org/repos/asf/celix/blob/18a5bf74/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_type.c ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_type.c b/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_type.c deleted file mode 100644 index c47c8c6..0000000 --- a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_type.c +++ /dev/null @@ -1,1144 +0,0 @@ -/** - *Licensed to the Apache Software Foundation (ASF) under one - *or more contributor license agreements. See the NOTICE file - *distributed with this work for additional information - *regarding copyright ownership. The ASF licenses this file - *to you under the Apache License, Version 2.0 (the - *"License"); you may not use this file except in compliance - *with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - *Unless required by applicable law or agreed to in writing, - *software distributed under the License is distributed on an - *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - *specific language governing permissions and limitations - *under the License. - */ -#include "dyn_type.h" - -#include <stdlib.h> -#include <string.h> -#include <assert.h> -#include <errno.h> - -#include "dyn_common.h" - -DFI_SETUP_LOG(dynType) - -static int dynType_parseWithStream(FILE *stream, const char *name, dyn_type *parent, struct types_head *refTypes, dyn_type **result); -static void dynType_clear(dyn_type *type); -static void dynType_clearComplex(dyn_type *type); -static void dynType_clearSequence(dyn_type *type); -static void dynType_clearTypedPointer(dyn_type *type); - -static struct type_entry *dynType_allocTypeEntry(void); - -static ffi_type * dynType_ffiTypeFor(int c); -static dyn_type * dynType_findType(dyn_type *type, char *name); -static int dynType_parseAny(FILE *stream, dyn_type *type); -static int dynType_parseComplex(FILE *stream, dyn_type *type); -static int dynType_parseNestedType(FILE *stream, dyn_type *type); -static int dynType_parseReference(FILE *stream, dyn_type *type); -static int dynType_parseRefByValue(FILE *stream, dyn_type *type); -static int dynType_parseSequence(FILE *stream, dyn_type *type); -static int dynType_parseSimple(int c, dyn_type *type); -static int dynType_parseTypedPointer(FILE *stream, dyn_type *type); -static void dynType_prepCif(ffi_type *type); -static unsigned short dynType_getOffset(dyn_type *type, int index); - -static void dynType_printAny(char *name, dyn_type *type, int depth, FILE *stream); -static void dynType_printComplex(char *name, dyn_type *type, int depth, FILE *stream); -static void dynType_printSequence(char *name, dyn_type *type, int depth, FILE *stream); -static void dynType_printSimple(char *name, dyn_type *type, int depth, FILE *stream); -static void dynType_printTypedPointer(char *name, dyn_type *type, int depth, FILE *stream); -static void dynType_printDepth(int depth, FILE *stream); - -static void dynType_printTypes(dyn_type *type, FILE *stream); -static void dynType_printComplexType(dyn_type *type, FILE *stream); -static void dynType_printSimpleType(dyn_type *type, FILE *stream); - -static int dynType_parseText(FILE *stream, dyn_type *type); -void dynType_freeComplexType(dyn_type *type, void *loc); -void dynType_deepFree(dyn_type *type, void *loc, bool alsoDeleteSelf); -void dynType_freeSequenceType(dyn_type *type, void *seqLoc); - -static int dynType_parseMetaInfo(FILE *stream, dyn_type *type); - -struct generic_sequence { - uint32_t cap; - uint32_t len; - void *buf; -}; - -TAILQ_HEAD(meta_properties_head, meta_entry); -struct meta_entry { - char *name; - char *value; - TAILQ_ENTRY(meta_entry) entries; -}; - - -struct _dyn_type { - char *name; - char descriptor; - int type; - ffi_type *ffiType; - dyn_type *parent; - struct types_head *referenceTypes; //NOTE: not owned - struct types_head nestedTypesHead; - struct meta_properties_head metaProperties; - union { - struct { - struct complex_type_entries_head entriesHead; - ffi_type structType; //dyn_type.ffiType points to this - dyn_type **types; //based on entriesHead for fast access - } complex; - struct { - ffi_type seqType; //dyn_type.ffiType points to this - dyn_type *itemType; - } sequence; - struct { - dyn_type *typedType; - } typedPointer; - struct { - dyn_type *ref; - } ref; - }; -}; - -static const int OK = 0; -static const int ERROR = 1; -static const int MEM_ERROR = 2; -static const int PARSE_ERROR = 3; - -int dynType_parse(FILE *descriptorStream, const char *name, struct types_head *refTypes, dyn_type **type) { - return dynType_parseWithStream(descriptorStream, name, NULL, refTypes, type); -} - -int dynType_parseWithStr(const char *descriptor, const char *name, struct types_head *refTypes, dyn_type **type) { - int status = OK; - FILE *stream = fmemopen((char *)descriptor, strlen(descriptor), "r"); - if (stream != NULL) { - status = dynType_parseWithStream(stream, name, NULL, refTypes, type); - if (status == OK) { - int c = fgetc(stream); - if (c != '\0' && c != EOF) { - status = PARSE_ERROR; - LOG_ERROR("Expected EOF got %c", c); - } - } - fclose(stream); - } else { - status = ERROR; - LOG_ERROR("Error creating mem stream for descriptor string. %s", strerror(errno)); - } - return status; -} - -static int dynType_parseWithStream(FILE *stream, const char *name, dyn_type *parent, struct types_head *refTypes, dyn_type **result) { - int status = OK; - dyn_type *type = calloc(1, sizeof(*type)); - if (type != NULL) { - type->parent = parent; - type->type = DYN_TYPE_INVALID; - type->referenceTypes = refTypes; - TAILQ_INIT(&type->nestedTypesHead); - TAILQ_INIT(&type->metaProperties); - if (name != NULL) { - type->name = strdup(name); - if (type->name == NULL) { - status = MEM_ERROR; - LOG_ERROR("Error strdup'ing name '%s'\n", name); - } - } - if (status == OK) { - status = dynType_parseAny(stream, type); - } - if (status == OK) { - *result = type; - } else { - dynType_destroy(type); - } - } else { - status = MEM_ERROR; - LOG_ERROR("Error allocating memory for type"); - } - return status; -} - -static int dynType_parseAny(FILE *stream, dyn_type *type) { - int status = OK; - - int c = fgetc(stream); - switch(c) { - case 'T' : - status = dynType_parseNestedType(stream, type); - if (status == OK) { - status = dynType_parseAny(stream, type); - } - break; - case 'L' : - status = dynType_parseReference(stream, type); - break; - case 'l' : - status = dynType_parseRefByValue(stream, type); - break; - case '{' : - status = dynType_parseComplex(stream, type); - break; - case '[' : - status = dynType_parseSequence(stream, type); - break; - case '*' : - status = dynType_parseTypedPointer(stream, type); - break; - case 't' : - status = dynType_parseText(stream, type); - break; - case '#' : - status = dynType_parseMetaInfo(stream, type); - if (status == OK) { - status = dynType_parseAny(stream, type); - } - break; - default : - status = dynType_parseSimple(c, type); - break; - } - - return status; -} - -static int dynType_parseMetaInfo(FILE *stream, dyn_type *type) { - int status = OK; - char *name = NULL; - char *value = NULL; - - struct meta_entry *entry = calloc(1, sizeof(*entry)); - if (entry == NULL) { - status = ERROR; - } - - if (status == OK) { - status = dynCommon_parseName(stream, &name); - } - - if (status == OK) { - status = dynCommon_eatChar(stream, '='); - } - - if (status == OK) { - status = dynCommon_parseName(stream, &value); - } - - if (status == OK) { - status = dynCommon_eatChar(stream, ';'); - } - - if (status == OK) { - entry->name = name; - entry->value = value; - TAILQ_INSERT_TAIL(&type->metaProperties, entry, entries); - LOG_DEBUG("Added meta properties '%s':'%s'", name, value) - } else { - free(name); - free(value); - free(entry); - } - - return status; -} - -static int dynType_parseText(FILE *stream, dyn_type *type) { - int status = OK; - type->type = DYN_TYPE_TEXT; - type->descriptor = 't'; - type->ffiType = &ffi_type_pointer; - return status; -} - -static int dynType_parseComplex(FILE *stream, dyn_type *type) { - int status = OK; - type->type = DYN_TYPE_COMPLEX; - type->descriptor = '{'; - type->ffiType = &type->complex.structType; - TAILQ_INIT(&type->complex.entriesHead); - - int c = fgetc(stream); - struct complex_type_entry *entry = NULL; - while (c != ' ' && c != '}') { - ungetc(c,stream); - entry = calloc(1, sizeof(*entry)); - if (entry != NULL) { - entry->type = calloc(1, sizeof(*entry->type)); - } - if (entry != NULL && entry->type != NULL) { - entry->type->parent = type; - entry->type->type = DYN_TYPE_INVALID; - TAILQ_INIT(&entry->type->nestedTypesHead); - TAILQ_INIT(&entry->type->metaProperties); - TAILQ_INSERT_TAIL(&type->complex.entriesHead, entry, entries); - status = dynType_parseAny(stream, entry->type); - } else { - if (entry != NULL) { - free(entry); - } - status = MEM_ERROR; - LOG_ERROR("Error allocating memory for type"); - } - c = fgetc(stream); - } - - entry = TAILQ_FIRST(&type->complex.entriesHead); - char *name = NULL; - while (c == ' ' && entry != NULL) { - status = dynCommon_parseName(stream, &name); - if (status == OK) { - entry->name = name; - entry = TAILQ_NEXT(entry, entries); - } else { - break; - } - c = getc(stream); - } - - int count = 0; - TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) { - count +=1; - } - - if (status == OK) { - type->complex.structType.type = FFI_TYPE_STRUCT; - type->complex.structType.elements = calloc(count + 1, sizeof(ffi_type)); - if (type->complex.structType.elements != NULL) { - type->complex.structType.elements[count] = NULL; - int index = 0; - TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) { - type->complex.structType.elements[index++] = dynType_ffiType(entry->type); - } - } else { - status = MEM_ERROR; - //T\nODO log: error allocating memory - } - } - - if (status == OK) { - type->complex.types = calloc(count, sizeof(dyn_type *)); - if (type != NULL) { - int index = 0; - TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) { - type->complex.types[index++] = entry->type; - } - } else { - status = MEM_ERROR; - LOG_ERROR("Error allocating memory for type") - } - } - - if (status == OK) { - dynType_prepCif(type->ffiType); - } - - - return status; -} - -static int dynType_parseNestedType(FILE *stream, dyn_type *type) { - int status = OK; - char *name = NULL; - struct type_entry *entry = NULL; - - entry = dynType_allocTypeEntry(); - if (entry != NULL) { - entry->type->parent = type; - entry->type->type = DYN_TYPE_INVALID; - TAILQ_INIT(&entry->type->nestedTypesHead); - TAILQ_INIT(&entry->type->metaProperties); - TAILQ_INSERT_TAIL(&type->nestedTypesHead, entry, entries); - status = dynCommon_parseName(stream, &name); - entry->type->name = name; - } else { - status = MEM_ERROR; - LOG_ERROR("Error allocating entry"); - } - - if (status == OK) { - int c = fgetc(stream); - if (c != '=') { - status = PARSE_ERROR; - LOG_ERROR("Error parsing nested type expected '=' got '%c'", c); - } - } - - if (status == OK) { - status = dynType_parseAny(stream, entry->type); - int c = fgetc(stream); - if (c != ';') { - status = PARSE_ERROR; - LOG_ERROR("Expected ';' got '%c'\n", c); - } - } - - return status; -} - -static int dynType_parseReference(FILE *stream, dyn_type *type) { - int status = OK; - type->type = DYN_TYPE_TYPED_POINTER; - type->descriptor = '*'; - - type->ffiType = &ffi_type_pointer; - type->typedPointer.typedType = NULL; - - dyn_type *subType = calloc(1, sizeof(*subType)); - - if (subType != NULL) { - type->typedPointer.typedType = subType; - subType->parent = type; - subType->type = DYN_TYPE_INVALID; - TAILQ_INIT(&subType->nestedTypesHead); - TAILQ_INIT(&subType->metaProperties); - status = dynType_parseRefByValue(stream, subType); - } else { - status = MEM_ERROR; - LOG_ERROR("Error allocating memory for subtype\n"); - } - - return status; -} - -static int dynType_parseRefByValue(FILE *stream, dyn_type *type) { - int status = OK; - type->type = DYN_TYPE_REF; - type->descriptor = 'l'; - - char *name = NULL; - status = dynCommon_parseName(stream, &name); - if (status == OK) { - dyn_type *ref = dynType_findType(type, name); - if (ref != NULL) { - type->ref.ref = ref; - } else { - status = PARSE_ERROR; - LOG_ERROR("Error cannot find type '%s'", name); - } - free(name); - } - - if (status == OK) { - int c = fgetc(stream); - if (c != ';') { - status = PARSE_ERROR; - LOG_ERROR("Error expected ';' got '%c'", c); - } - } - - return status; -} - -static struct type_entry *dynType_allocTypeEntry(void) { - struct type_entry *entry = calloc(1, sizeof(*entry)); - if (entry != NULL) { - entry->type = calloc(1, sizeof(*entry->type)); - if (entry->type == NULL) { - free(entry); - entry = NULL; - } - } - return entry; -} - -static ffi_type *seq_types[] = {&ffi_type_uint32, &ffi_type_uint32, &ffi_type_pointer, NULL}; - -static int dynType_parseSequence(FILE *stream, dyn_type *type) { - int status = OK; - type->type = DYN_TYPE_SEQUENCE; - type->descriptor = '['; - - type->sequence.seqType.elements = seq_types; - type->sequence.seqType.type = FFI_TYPE_STRUCT; - type->sequence.seqType.size = 0; - type->sequence.seqType.alignment = 0; - - status = dynType_parseWithStream(stream, NULL, type, NULL, &type->sequence.itemType); - - if (status == OK) { - type->ffiType = &type->sequence.seqType; - dynType_prepCif(&type->sequence.seqType); - } - - return status; -} - -static int dynType_parseSimple(int c, dyn_type *type) { - int status = OK; - ffi_type *ffiType = dynType_ffiTypeFor(c); - if (ffiType != NULL) { - type->type = DYN_TYPE_SIMPLE; - type->descriptor = c; - type->ffiType = ffiType; - } else { - status = PARSE_ERROR; - LOG_ERROR("Error unsupported type '%c'", c); - } - - return status; -} - -static int dynType_parseTypedPointer(FILE *stream, dyn_type *type) { - int status = OK; - type->type = DYN_TYPE_TYPED_POINTER; - type->descriptor = '*'; - type->ffiType = &ffi_type_pointer; - - status = dynType_parseWithStream(stream, NULL, type, NULL, &type->typedPointer.typedType); - - return status; -} - -static void dynType_prepCif(ffi_type *type) { - ffi_cif cif; - ffi_type *args[1]; - args[0] = type; - ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1, &ffi_type_uint, args); -} - -void dynType_destroy(dyn_type *type) { - if (type != NULL) { - dynType_clear(type); - free(type); - } -} - -static void dynType_clear(dyn_type *type) { - struct type_entry *entry = TAILQ_FIRST(&type->nestedTypesHead); - struct type_entry *tmp = NULL; - while (entry != NULL) { - tmp = entry; - entry = TAILQ_NEXT(entry, entries); - if (tmp->type != NULL) { - dynType_destroy(tmp->type); - tmp->type = NULL; - } - free(tmp); - } - - struct meta_entry *mEntry = TAILQ_FIRST(&type->metaProperties);; - struct meta_entry *next = NULL; - while (mEntry != NULL) { - next = TAILQ_NEXT(mEntry, entries); - if (mEntry != NULL) { - free(mEntry->name); - free(mEntry->value); - free(mEntry); - } - mEntry = next; - } - - switch (type->type) { - case DYN_TYPE_COMPLEX : - dynType_clearComplex(type); - break; - case DYN_TYPE_SEQUENCE : - dynType_clearSequence(type); - break; - case DYN_TYPE_TYPED_POINTER : - dynType_clearTypedPointer(type); - break; - } - - if (type->name != NULL) { - free(type->name); - } -} - -static void dynType_clearComplex(dyn_type *type) { - assert(type->type == DYN_TYPE_COMPLEX); - struct complex_type_entry *entry = TAILQ_FIRST(&type->complex.entriesHead); - struct complex_type_entry *tmp = NULL; - while (entry != NULL) { - dynType_destroy(entry->type); - if (entry->name != NULL) { - free(entry->name); - } - tmp = entry; - entry = TAILQ_NEXT(entry, entries); - free(tmp); - } - if (type->complex.types != NULL) { - free(type->complex.types); - } - if (type->complex.structType.elements != NULL) { - free(type->complex.structType.elements); - } -} - -static void dynType_clearSequence(dyn_type *type) { - assert(type->type == DYN_TYPE_SEQUENCE); - if (type->sequence.itemType != NULL) { - dynType_destroy(type->sequence.itemType); - } -} - -static void dynType_clearTypedPointer(dyn_type *type) { - assert(type->type == DYN_TYPE_TYPED_POINTER); - if (type->typedPointer.typedType != NULL) { - dynType_destroy(type->typedPointer.typedType); - } -} - -int dynType_alloc(dyn_type *type, void **bufLoc) { - assert(type->type != DYN_TYPE_REF); - assert(type->ffiType->size != 0); - int status = OK; - - void *inst = calloc(1, type->ffiType->size); - if (inst != NULL) { - if (type->type == DYN_TYPE_TYPED_POINTER) { - void *ptr = NULL; - dyn_type *sub = NULL; - status = dynType_typedPointer_getTypedType(type, &sub); - if (status == OK) { - status = dynType_alloc(sub, &ptr); - if (status == OK) { - *(void **)inst = ptr; - } - } - } - *bufLoc = inst; - } else { - status = MEM_ERROR; - LOG_ERROR("Error allocating memory for type '%c'", type->descriptor); - } - - return status; -} - - -int dynType_complex_indexForName(dyn_type *type, const char *name) { - assert(type->type == DYN_TYPE_COMPLEX); - int i = 0; - int index = -1; - struct complex_type_entry *entry = NULL; - TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) { - if (strcmp(name, entry->name) == 0) { - index = i; - } - i +=1; - } - return index; -} - -int dynType_complex_dynTypeAt(dyn_type *type, int index, dyn_type **result) { - assert(type->type == DYN_TYPE_COMPLEX); - dyn_type *sub = type->complex.types[index]; - if (sub->type == DYN_TYPE_REF) { - sub = sub->ref.ref; - } - *result = sub; - return 0; -} - -int dynType_complex_setValueAt(dyn_type *type, int index, void *start, void *in) { - assert(type->type == DYN_TYPE_COMPLEX); - char *loc = ((char *)start) + dynType_getOffset(type, index); - size_t size = type->complex.structType.elements[index]->size; - memcpy(loc, in, size); - return 0; -} - -int dynType_complex_valLocAt(dyn_type *type, int index, void *inst, void **result) { - assert(type->type == DYN_TYPE_COMPLEX); - char *l = (char *)inst; - void *loc = (void *)(l + dynType_getOffset(type, index)); - *result = loc; - return 0; -} - -int dynType_complex_entries(dyn_type *type, struct complex_type_entries_head **entries) { - assert(type->type == DYN_TYPE_COMPLEX); - int status = OK; - *entries = &type->complex.entriesHead; - return status; -} - -//sequence -int dynType_sequence_alloc(dyn_type *type, void *inst, uint32_t cap) { - assert(type->type == DYN_TYPE_SEQUENCE); - int status = OK; - struct generic_sequence *seq = inst; - if (seq != NULL) { - size_t size = dynType_size(type->sequence.itemType); - seq->buf = calloc(cap, size); - if (seq->buf != NULL) { - seq->cap = cap; - seq->len = 0;; - } else { - seq->cap = 0; - status = MEM_ERROR; - LOG_ERROR("Error allocating memory for buf") - } - } else { - status = MEM_ERROR; - LOG_ERROR("Error allocating memory for seq") - } - return status; -} - -void dynType_free(dyn_type *type, void *loc) { - dynType_deepFree(type, loc, true); -} - -void dynType_deepFree(dyn_type *type, void *loc, bool alsoDeleteSelf) { - if (loc != NULL) { - dyn_type *subType = NULL; - char *text = NULL; - switch (type->type) { - case DYN_TYPE_COMPLEX : - dynType_freeComplexType(type, loc); - break; - case DYN_TYPE_SEQUENCE : - dynType_freeSequenceType(type, loc); - break; - case DYN_TYPE_TYPED_POINTER: - dynType_typedPointer_getTypedType(type, &subType); - dynType_deepFree(subType, *(void **)loc, true); - break; - case DYN_TYPE_TEXT : - text = *(char **)loc; - free(text); - break; - } - - if (alsoDeleteSelf) { - free(loc); - } - } -} - -void dynType_freeSequenceType(dyn_type *type, void *seqLoc) { - struct generic_sequence *seq = seqLoc; - dyn_type *itemType = dynType_sequence_itemType(type); - void *itemLoc = NULL; - int i; - for (i = 0; i < seq->len; i += 1) { - dynType_sequence_locForIndex(type, seqLoc, i, &itemLoc); - dynType_deepFree(itemType, itemLoc, false); - } - free(seq->buf); -} - -void dynType_freeComplexType(dyn_type *type, void *loc) { - struct complex_type_entry *entry = NULL; - int index = 0; - void *entryLoc = NULL; - TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) { - dynType_complex_valLocAt(type, index++, loc, &entryLoc); - dynType_deepFree(entry->type, entryLoc, false); - } -} - - -uint32_t dynType_sequence_length(void *seqLoc) { - struct generic_sequence *seq = seqLoc; - return seq->len; -} - -int dynType_sequence_locForIndex(dyn_type *type, void *seqLoc, int index, void **out) { - assert(type->type == DYN_TYPE_SEQUENCE); - int status = OK; - - struct generic_sequence *seq = seqLoc; - char *valLoc = seq->buf; - - size_t itemSize = dynType_size(type->sequence.itemType); - - if (index >= seq->cap) { - status = ERROR; - LOG_ERROR("Requested index (%i) is greater than capacity (%u) of sequence", index, seq->cap); - } - - if (index >= seq->len) { - LOG_WARNING("Requesting index (%i) outsize defined length (%u) but within capacity", index, seq->len); - } - - if (status == OK) { } - int i; - for (i = 0; i < seq->cap; i += 1) { - if (index == i) { - break; - } else { - valLoc += itemSize; - } - } - - (*out) = valLoc; - - return status; -} - -int dynType_sequence_increaseLengthAndReturnLastLoc(dyn_type *type, void *seqLoc, void **valLoc) { - assert(type->type == DYN_TYPE_SEQUENCE); - int status = OK; - struct generic_sequence *seq = seqLoc; - - int lastIndex = seq->len; - if (seq->len < seq->cap) { - seq->len += 1; - } else { - status = ERROR; - LOG_ERROR("Cannot increase sequence length beyond capacity (%u)", seq->cap); - } - - if (status == OK) { - status = dynType_sequence_locForIndex(type, seqLoc, lastIndex, valLoc); - } - - return status; -} - -dyn_type * dynType_sequence_itemType(dyn_type *type) { - assert(type->type == DYN_TYPE_SEQUENCE); - dyn_type *itemType = type->sequence.itemType; - if (itemType->type == DYN_TYPE_REF) { - itemType = itemType->ref.ref; - } - return itemType; -} - -void dynType_simple_setValue(dyn_type *type, void *inst, void *in) { - size_t size = dynType_size(type); - memcpy(inst, in, size); -} - - -int dynType_descriptorType(dyn_type *type) { - return type->descriptor; -} - -const char * dynType_getMetaInfo(dyn_type *type, const char *name) { - const char *result = NULL; - struct meta_entry *entry = NULL; - TAILQ_FOREACH(entry, &type->metaProperties, entries) { - LOG_DEBUG("Checking '%s'", entry->name); - if (strcmp(entry->name, name) == 0) { - result = entry->value; - break; - } - } - return result; -} - -ffi_type *dynType_ffiType(dyn_type *type) { - if (type->type == DYN_TYPE_REF) { - return type->ref.ref->ffiType; - } - return type->ffiType; -} - -static ffi_type * dynType_ffiTypeFor(int c) { - ffi_type *type = NULL; - switch (c) { - case 'Z' : - type = &ffi_type_uint8; - break; - case 'F' : - type = &ffi_type_float; - break; - case 'D' : - type = &ffi_type_double; - break; - case 'B' : - type = &ffi_type_sint8; - break; - case 'b' : - type = &ffi_type_uint8; - break; - case 'S' : - type = &ffi_type_sint16; - break; - case 's' : - type = &ffi_type_uint16; - break; - case 'I' : - type = &ffi_type_sint32; - break; - case 'i' : - type = &ffi_type_uint32; - break; - case 'J' : - type = &ffi_type_sint64; - break; - case 'j' : - type = &ffi_type_sint64; - break; - case 'N' : - type = &ffi_type_sint; - break; - case 'P' : - type = &ffi_type_pointer; - break; - case 'V' : - type = &ffi_type_void; - break; - } - return type; -} - -static dyn_type * dynType_findType(dyn_type *type, char *name) { - dyn_type *result = NULL; - - struct type_entry *entry = NULL; - if (type->referenceTypes != NULL) { - TAILQ_FOREACH(entry, type->referenceTypes, entries) { - LOG_DEBUG("checking ref type '%s' with name '%s'", entry->type->name, name); - if (strcmp(name, entry->type->name) == 0) { - result = entry->type; - break; - } - } - } - - if (result == NULL) { - struct type_entry *nEntry = NULL; - TAILQ_FOREACH(nEntry, &type->nestedTypesHead, entries) { - LOG_DEBUG("checking nested type '%s' with name '%s'", nEntry->type->name, name); - if (strcmp(name, nEntry->type->name) == 0) { - result = nEntry->type; - break; - } - } - } - - if (result == NULL && type->parent != NULL) { - result = dynType_findType(type->parent, name); - } - - return result; -} - -static unsigned short dynType_getOffset(dyn_type *type, int index) { - assert(type->type == DYN_TYPE_COMPLEX); - unsigned short offset = 0; - - ffi_type *ffiType = &type->complex.structType; - int i; - for (i = 0; i <= index && ffiType->elements[i] != NULL; i += 1) { - size_t size = ffiType->elements[i]->size; - unsigned short alignment = ffiType->elements[i]->alignment; - int alignment_diff = offset % alignment; - if (alignment_diff > 0) { - offset += (alignment - alignment_diff); - } - if (i < index) { - offset += size; - } - } - - return offset; -} - -size_t dynType_size(dyn_type *type) { - dyn_type *rType = type; - if (type->type == DYN_TYPE_REF) { - rType = type->ref.ref; - } - return rType->ffiType->size; -} - -int dynType_type(dyn_type *type) { - return type->type; -} - - -int dynType_typedPointer_getTypedType(dyn_type *type, dyn_type **out) { - assert(type->type == DYN_TYPE_TYPED_POINTER); - int status = 0; - - dyn_type *typedType = type->typedPointer.typedType; - if (typedType->type == DYN_TYPE_REF) { - typedType = typedType->ref.ref; - } - - *out = typedType; - return status; -} - - -int dynType_text_allocAndInit(dyn_type *type, void *textLoc, const char *value) { - assert(type->type == DYN_TYPE_TEXT); - int status = 0; - const char *str = strdup(value); - char const **loc = textLoc; - if (str != NULL) { - *loc = str; - } else { - status = ERROR; - LOG_ERROR("Cannot allocate memory for string"); - } - return status; -} - - - - - -void dynType_print(dyn_type *type, FILE *stream) { - if (type != NULL) { - dynType_printTypes(type, stream); - - fprintf(stream, "main type:\n"); - dynType_printAny("root", type, 0, stream); - } else { - fprintf(stream, "invalid type\n"); - } -} - -static void dynType_printDepth(int depth, FILE *stream) { - int i; - for (i = 0; i < depth; i +=1 ) { - fprintf(stream, "\t"); - } -} - -static void dynType_printAny(char *name, dyn_type *type, int depth, FILE *stream) { - dyn_type *toPrint = type; - if (toPrint->type == DYN_TYPE_REF) { - toPrint = toPrint->ref.ref; - } - switch(toPrint->type) { - case DYN_TYPE_COMPLEX : - dynType_printComplex(name, toPrint, depth, stream); - break; - case DYN_TYPE_SIMPLE : - dynType_printSimple(name, toPrint, depth, stream); - break; - case DYN_TYPE_SEQUENCE : - dynType_printSequence(name, toPrint, depth, stream); - break; - case DYN_TYPE_TYPED_POINTER : - dynType_printTypedPointer(name, toPrint, depth, stream); - break; - default : - fprintf(stream, "TODO Unsupported type %i\n", toPrint->type); - break; - } -} - -static void dynType_printComplex(char *name, dyn_type *type, int depth, FILE *stream) { - if (type->name == NULL) { - dynType_printDepth(depth, stream); - fprintf(stream, "%s: complex type (anon), size is %zu, alignment is %i, descriptor is '%c'. fields:\n", name, type->ffiType->size, type->ffiType->alignment, type->descriptor); - - struct complex_type_entry *entry = NULL; - TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) { - dynType_printAny(entry->name, entry->type, depth + 1, stream); - } - - dynType_printDepth(depth, stream); - fprintf(stream, "}\n"); - } else { - dynType_printDepth(depth, stream); - fprintf(stream, "%s: complex type ('%s'), size is %zu, alignment is %i, descriptor is '%c'.\n", name, type->name, type->ffiType->size, type->ffiType->alignment, type->descriptor); - } -} - -static void dynType_printSequence(char *name, dyn_type *type, int depth, FILE *stream) { - dynType_printDepth(depth, stream); - fprintf(stream, "sequence, size is %zu, alignment is %i, descriptor is '%c'. fields:\n", type->ffiType->size, type->ffiType->alignment, type->descriptor); - - dynType_printDepth(depth + 1, stream); - fprintf(stream, "cap: simple type, size is %zu, alignment is %i.\n", type->sequence.seqType.elements[0]->size, type->sequence.seqType.elements[0]->alignment); - - dynType_printDepth(depth + 1, stream); - fprintf(stream, "len: simple type, size is %zu, alignment is %i.\n", type->sequence.seqType.elements[1]->size, type->sequence.seqType.elements[1]->alignment); - - dynType_printDepth(depth + 1, stream); - fprintf(stream, "buf: array, size is %zu, alignment is %i. points to ->\n", type->sequence.seqType.elements[2]->size, type->sequence.seqType.elements[2]->alignment); - dynType_printAny("element", type->sequence.itemType, depth + 1, stream); -} - -static void dynType_printSimple(char *name, dyn_type *type, int depth, FILE *stream) { - dynType_printDepth(depth, stream); - fprintf(stream, "%s: simple type, size is %zu, alignment is %i, descriptor is '%c'.\n", name, type->ffiType->size, type->ffiType->alignment, type->descriptor); -} - -static void dynType_printTypedPointer(char *name, dyn_type *type, int depth, FILE *stream) { - dynType_printDepth(depth, stream); - fprintf(stream, "%s: typed pointer, size is %zu, alignment is %i, points to ->\n", name, type->ffiType->size, type->ffiType->alignment); - char *subName = NULL; - if (name != NULL) { - char buf[128]; - snprintf(buf, 128, "*%s", name); - subName = buf; - } - dynType_printAny(subName, type->typedPointer.typedType, depth + 1, stream); -} - -static void dynType_printTypes(dyn_type *type, FILE *stream) { - - dyn_type *parent = type->parent; - struct type_entry *pentry = NULL; - while (parent != NULL) { - TAILQ_FOREACH(pentry, &parent->nestedTypesHead, entries) { - if (pentry->type == type) { - return; - } - } - parent = parent->parent; - } - - struct type_entry *entry = NULL; - TAILQ_FOREACH(entry, &type->nestedTypesHead, entries) { - dyn_type *toPrint = entry->type; - if (toPrint->type == DYN_TYPE_REF) { - toPrint = toPrint->ref.ref; - } - - switch(toPrint->type) { - case DYN_TYPE_COMPLEX : - dynType_printComplexType(toPrint, stream); - break; - case DYN_TYPE_SIMPLE : - dynType_printSimpleType(toPrint, stream); - break; - default : - printf("TODO Print Type\n"); - break; - } - } - - - struct complex_type_entry *centry = NULL; - switch(type->type) { - case DYN_TYPE_COMPLEX : - TAILQ_FOREACH(centry, &type->complex.entriesHead, entries) { - dynType_printTypes(centry->type, stream); - } - break; - case DYN_TYPE_SEQUENCE : - dynType_printTypes(type->sequence.itemType, stream); - break; - case DYN_TYPE_TYPED_POINTER : - dynType_printTypes(type->typedPointer.typedType, stream); - break; - } -} - -static void dynType_printComplexType(dyn_type *type, FILE *stream) { - fprintf(stream, "type '%s': complex type, size is %zu, alignment is %i, descriptor is '%c'. fields:\n", type->name, type->ffiType->size, type->ffiType->alignment, type->descriptor); - - struct complex_type_entry *entry = NULL; - TAILQ_FOREACH(entry, &type->complex.entriesHead, entries) { - dynType_printAny(entry->name, entry->type, 2, stream); - } - - fprintf(stream, "}\n"); -} - -static void dynType_printSimpleType(dyn_type *type, FILE *stream) { - fprintf(stream, "\ttype '%s': simple type, size is %zu, alignment is %i, descriptor is '%c'\n", type->name, type->ffiType->size, type->ffiType->alignment, type->descriptor); -} - http://git-wip-us.apache.org/repos/asf/celix/blob/18a5bf74/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_type.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_type.h b/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_type.h deleted file mode 100644 index b2b84ef..0000000 --- a/remote_services/remote_service_admin_dfi/dynamic_function_interface/dyn_type.h +++ /dev/null @@ -1,157 +0,0 @@ -/** - *Licensed to the Apache Software Foundation (ASF) under one - *or more contributor license agreements. See the NOTICE file - *distributed with this work for additional information - *regarding copyright ownership. The ASF licenses this file - *to you under the Apache License, Version 2.0 (the - *"License"); you may not use this file except in compliance - *with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - *Unless required by applicable law or agreed to in writing, - *software distributed under the License is distributed on an - *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - *specific language governing permissions and limitations - *under the License. - */ - -#ifndef _DYN_TYPE_H_ -#define _DYN_TYPE_H_ - -#include <stdio.h> -#include <sys/queue.h> -#include <stdbool.h> - -#include <ffi.h> -#include <stdint.h> - -#include "dfi_log_util.h" - -#if defined(BSD) || defined(__APPLE__) -#include "memstream/open_memstream.h" -#include "memstream/fmemopen.h" -#endif - -/* Description string - * - * Type = [TypeDef]* (MetaInfo)* (SimpleType | ComplexType | SequenceType | TypedPointer | PointerReference ) [TypeDef]* - * Name = alpha[(alpha|numeric)*] - * SPACE = ' ' - * - * SimplesTypes (based on java bytecode method signatures) - * //Java based: - * B char - * C (not supported) - * D double - * F float - * I int32_t - * J int64_t - * S int16_t - * V void - * Z boolean - * //Extended - * b unsigned char - * i uint32_t - * j uint62_t - * s uint64_t - * P untyped pointer (void *) - * t char* string - * N native int - * - * ComplexTypes (Struct) - * {[Type]+ [(Name)(SPACE)]+} - * - * ReferenceByValue - * l(name); - * - * PointerReference -> note shortcut for *l(name); - * L(Name); - * - * TypeDef - * T(Name)=Type; - * - * SequenceType - * [(Type) - * - * TypedPointer - * *(Type) - * - * MetaInfo TODO - * #Name=Value; - * - * - * - * examples - * "{DDII a b c d}" -> struct { double a; double b; int c; int d; }; - * "{DD{FF c1 c2} a b c}" -> struct { double a; double b; struct c { float c1; float c2; }; }; - * - * - */ - -#define DYN_TYPE_INVALID 0 -#define DYN_TYPE_SIMPLE 1 -#define DYN_TYPE_COMPLEX 2 -#define DYN_TYPE_SEQUENCE 3 -#define DYN_TYPE_TYPED_POINTER 4 -#define DYN_TYPE_TEXT 5 -#define DYN_TYPE_REF 6 - -typedef struct _dyn_type dyn_type; - -TAILQ_HEAD(types_head, type_entry); -struct type_entry { - dyn_type *type; - TAILQ_ENTRY(type_entry) entries; -}; - -TAILQ_HEAD(complex_type_entries_head, complex_type_entry); -struct complex_type_entry { - dyn_type *type; - char *name; - TAILQ_ENTRY(complex_type_entry) entries; -}; - -//logging -DFI_SETUP_LOG_HEADER(dynType); - -//generic -int dynType_parse(FILE *descriptorStream, const char *name, struct types_head *refTypes, dyn_type **type); -int dynType_parseWithStr(const char *descriptor, const char *name, struct types_head *refTypes, dyn_type **type); -void dynType_destroy(dyn_type *type); - -int dynType_alloc(dyn_type *type, void **bufLoc); -void dynType_free(dyn_type *type, void *loc); - -void dynType_print(dyn_type *type, FILE *stream); -size_t dynType_size(dyn_type *type); -int dynType_type(dyn_type *type); -int dynType_descriptorType(dyn_type *type); -ffi_type * dynType_ffiType(dyn_type *type); -const char * dynType_getMetaInfo(dyn_type *type, const char *name); - -//complexType -int dynType_complex_indexForName(dyn_type *type, const char *name); -int dynType_complex_dynTypeAt(dyn_type *type, int index, dyn_type **subType); -int dynType_complex_setValueAt(dyn_type *type, int index, void *inst, void *in); -int dynType_complex_valLocAt(dyn_type *type, int index, void *inst, void **valLoc); -int dynType_complex_entries(dyn_type *type, struct complex_type_entries_head **entries); - -//sequence -int dynType_sequence_alloc(dyn_type *type, void *inst, uint32_t cap); -int dynType_sequence_locForIndex(dyn_type *type, void *seqLoc, int index, void **valLoc); -int dynType_sequence_increaseLengthAndReturnLastLoc(dyn_type *type, void *seqLoc, void **valLoc); -dyn_type * dynType_sequence_itemType(dyn_type *type); -uint32_t dynType_sequence_length(void *seqLoc); - -//typed pointer -int dynType_typedPointer_getTypedType(dyn_type *type, dyn_type **typedType); - -//text -int dynType_text_allocAndInit(dyn_type *type, void *textLoc, const char *value); - -//simple -void dynType_simple_setValue(dyn_type *type, void *inst, void *in); - -#endif http://git-wip-us.apache.org/repos/asf/celix/blob/18a5bf74/remote_services/remote_service_admin_dfi/dynamic_function_interface/json_rpc.c ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_dfi/dynamic_function_interface/json_rpc.c b/remote_services/remote_service_admin_dfi/dynamic_function_interface/json_rpc.c deleted file mode 100644 index e13c8ef..0000000 --- a/remote_services/remote_service_admin_dfi/dynamic_function_interface/json_rpc.c +++ /dev/null @@ -1,335 +0,0 @@ -/** - *Licensed to the Apache Software Foundation (ASF) under one - *or more contributor license agreements. See the NOTICE file - *distributed with this work for additional information - *regarding copyright ownership. The ASF licenses this file - *to you under the Apache License, Version 2.0 (the - *"License"); you may not use this file except in compliance - *with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - *Unless required by applicable law or agreed to in writing, - *software distributed under the License is distributed on an - *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - *specific language governing permissions and limitations - *under the License. - */ -#include "json_rpc.h" -#include "json_serializer.h" -#include "dyn_type.h" -#include "dyn_interface.h" -#include <jansson.h> -#include <assert.h> -#include <stdint.h> -#include <string.h> - - -static int OK = 0; -static int ERROR = 1; - -DFI_SETUP_LOG(jsonRpc); - -typedef void (*gen_func_type)(void); - -struct generic_service_layout { - void *handle; - gen_func_type methods[]; -}; - -int jsonRpc_call(dyn_interface_type *intf, void *service, const char *request, char **out) { - int status = OK; - - dyn_type* returnType = NULL; - - LOG_DEBUG("Parsing data: %s\n", request); - json_error_t error; - json_t *js_request = json_loads(request, 0, &error); - json_t *arguments = NULL; - const char *sig; - if (js_request) { - if (json_unpack(js_request, "{s:s}", "m", &sig) != 0) { - LOG_ERROR("Got json error '%s'\n", error.text); - } else { - arguments = json_object_get(js_request, "a"); - } - } else { - LOG_ERROR("Got json error '%s' for '%s'\n", error.text, request); - return 0; - } - - LOG_DEBUG("Looking for method %s\n", sig); - struct methods_head *methods = NULL; - dynInterface_methods(intf, &methods); - struct method_entry *entry = NULL; - struct method_entry *method = NULL; - TAILQ_FOREACH(entry, methods, entries) { - if (strcmp(sig, entry->id) == 0) { - method = entry; - break; - } - } - - if (method == NULL) { - status = ERROR; - LOG_ERROR("Cannot find method with sig '%s'", sig); - } - - if (status == OK) { - LOG_DEBUG("RSA: found method '%s'\n", entry->id); - returnType = dynFunction_returnType(method->dynFunc); - } - - void (*fp)(void) = NULL; - void *handle = NULL; - if (status == OK) { - struct generic_service_layout *serv = service; - handle = serv->handle; - fp = serv->methods[method->index]; - } - - dyn_function_type *func = NULL; - int nrOfArgs = 0; - if (status == OK) { - nrOfArgs = dynFunction_nrOfArguments(entry->dynFunc); - func = entry->dynFunc; - } - - void *args[nrOfArgs]; - - json_t *value = NULL; - - int i; - int index = 0; - - void *ptr = NULL; - void *ptrToPtr = &ptr; - - for (i = 0; i < nrOfArgs; i += 1) { - dyn_type *argType = dynFunction_argumentTypeForIndex(func, i); - enum dyn_function_argument_meta meta = dynFunction_argumentMetaForIndex(func, i); - if (meta == DYN_FUNCTION_ARGUMENT_META__STD) { - value = json_array_get(arguments, index++); - status = jsonSerializer_deserializeJson(argType, value, &(args[i])); - } else if (meta == DYN_FUNCTION_ARGUMENT_META__PRE_ALLOCATED_OUTPUT) { - dynType_alloc(argType, &args[i]); - } else if (meta == DYN_FUNCTION_ARGUMENT_META__OUTPUT) { - args[i] = &ptrToPtr; - } else if (meta == DYN_FUNCTION_ARGUMENT_META__HANDLE) { - args[i] = &handle; - } - - if (status != OK) { - break; - } - } - json_decref(js_request); - - if (status == OK) { - if (dynType_descriptorType(returnType) != 'N') { - //NOTE To be able to handle exception only N as returnType is supported - LOG_ERROR("Only interface methods with a native int are supported. Found type '%c'", (char)dynType_descriptorType(returnType)); - status = ERROR; - } - } - - ffi_sarg returnVal = 1; - - if (status == OK) { - dynFunction_call(func, fp, (void *) &returnVal, args); - } - - int funcCallStatus = (int)returnVal; - if (funcCallStatus != 0) { - LOG_WARNING("Error calling remote endpoint function, got error code %i", funcCallStatus); - } - - json_t *jsonResult = NULL; - for(i = 0; i < nrOfArgs; i += 1) { - dyn_type *argType = dynFunction_argumentTypeForIndex(func, i); - enum dyn_function_argument_meta meta = dynFunction_argumentMetaForIndex(func, i); - if (meta == DYN_FUNCTION_ARGUMENT_META__STD) { - dynType_free(argType, args[i]); - } - } - - if (funcCallStatus == 0 && status == OK) { - for (i = 0; i < nrOfArgs; i += 1) { - dyn_type *argType = dynFunction_argumentTypeForIndex(func, i); - enum dyn_function_argument_meta meta = dynFunction_argumentMetaForIndex(func, i); - if (meta == DYN_FUNCTION_ARGUMENT_META__PRE_ALLOCATED_OUTPUT) { - if (status == OK) { - status = jsonSerializer_serializeJson(argType, args[i], &jsonResult); - } - dynType_free(argType, args[i]); - } else if (meta == DYN_FUNCTION_ARGUMENT_META__OUTPUT) { - if (ptr != NULL) { - dyn_type *typedType = NULL; - if (status == OK) { - status = dynType_typedPointer_getTypedType(argType, &typedType); - } - if (dynType_descriptorType(typedType) == 't') { - status = jsonSerializer_serializeJson(typedType, (void*) &ptr, &jsonResult); - free(ptr); - } else { - dyn_type *typedTypedType = NULL; - if (status == OK) { - status = dynType_typedPointer_getTypedType(typedType, &typedTypedType); - } - - status = jsonSerializer_serializeJson(typedTypedType, ptr, &jsonResult); - - if (status == OK) { - dynType_free(typedTypedType, ptr); - } - } - - } else { - LOG_DEBUG("Output ptr is null"); - } - } - - if (status != OK) { - break; - } - } - } - - char *response = NULL; - if (status == OK) { - LOG_DEBUG("creating payload\n"); - json_t *payload = json_object(); - if (funcCallStatus == 0) { - if (jsonResult == NULL) { - //ignore -> no result - } else { - LOG_DEBUG("Setting result payload"); - json_object_set_new(payload, "r", jsonResult); - } - } else { - LOG_DEBUG("Setting error payload"); - json_object_set_new(payload, "e", json_integer(funcCallStatus)); - } - response = json_dumps(payload, JSON_DECODE_ANY); - json_decref(payload); - LOG_DEBUG("status ptr is %p. response is '%s'\n", status, response); - } - - if (status == OK) { - *out = response; - } else { - free(response); - } - - return status; -} - -int jsonRpc_prepareInvokeRequest(dyn_function_type *func, const char *id, void *args[], char **out) { - int status = OK; - - - LOG_DEBUG("Calling remote function '%s'\n", id); - json_t *invoke = json_object(); - json_object_set_new(invoke, "m", json_string(id)); - - json_t *arguments = json_array(); - json_object_set_new(invoke, "a", arguments); - - int i; - int nrOfArgs = dynFunction_nrOfArguments(func); - for (i = 0; i < nrOfArgs; i +=1) { - dyn_type *type = dynFunction_argumentTypeForIndex(func, i); - enum dyn_function_argument_meta meta = dynFunction_argumentMetaForIndex(func, i); - if (meta == DYN_FUNCTION_ARGUMENT_META__STD) { - json_t *val = NULL; - - int rc = jsonSerializer_serializeJson(type, args[i], &val); - if (rc == 0) { - json_array_append_new(arguments, val); - } else { - status = ERROR; - break; - } - } else { - //skip handle / output types - } - } - - char *invokeStr = json_dumps(invoke, JSON_DECODE_ANY); - json_decref(invoke); - - if (status == OK) { - *out = invokeStr; - } - - return status; -} - -int jsonRpc_handleReply(dyn_function_type *func, const char *reply, void *args[]) { - int status = OK; - - json_error_t error; - json_t *replyJson = json_loads(reply, JSON_DECODE_ANY, &error); - if (replyJson == NULL) { - status = ERROR; - LOG_ERROR("Error parsing json '%s', got error '%s'", reply, error.text); - } - - json_t *result = NULL; - if (status == OK) { - result = json_object_get(replyJson, "r"); //TODO check - if (result == NULL) { - status = ERROR; - LOG_ERROR("Cannot find r entry in json reply '%s'", reply); - } - } - - if (status == OK) { - int nrOfArgs = dynFunction_nrOfArguments(func); - int i; - for (i = 0; i < nrOfArgs; i += 1) { - dyn_type *argType = dynFunction_argumentTypeForIndex(func, i); - enum dyn_function_argument_meta meta = dynFunction_argumentMetaForIndex(func, i); - if (meta == DYN_FUNCTION_ARGUMENT_META__PRE_ALLOCATED_OUTPUT) { - void *tmp = NULL; - void **out = (void **) args[i]; - - size_t size = 0; - - if (dynType_descriptorType(argType) == 't') { - status = jsonSerializer_deserializeJson(argType, result, &tmp); - size = strnlen(((char *) *(char**) tmp), 1024 * 1024); - memcpy(*out, *(void**) tmp, size); - } else { - dynType_typedPointer_getTypedType(argType, &argType); - status = jsonSerializer_deserializeJson(argType, result, &tmp); - size = dynType_size(argType); - memcpy(*out, tmp, size); - } - - dynType_free(argType, tmp); - } else if (meta == DYN_FUNCTION_ARGUMENT_META__OUTPUT) { - dyn_type *subType = NULL; - - dynType_typedPointer_getTypedType(argType, &subType); - - if (dynType_descriptorType(subType) == 't') { - void ***out = (void ***) args[i]; - status = jsonSerializer_deserializeJson(subType, result, *out); - } else { - dyn_type *subSubType = NULL; - dynType_typedPointer_getTypedType(subType, &subSubType); - void ***out = (void ***) args[i]; - status = jsonSerializer_deserializeJson(subSubType, result, *out); - } - } else { - //skip - } - } - } - - json_decref(replyJson); - - return status; -} http://git-wip-us.apache.org/repos/asf/celix/blob/18a5bf74/remote_services/remote_service_admin_dfi/dynamic_function_interface/json_rpc.h ---------------------------------------------------------------------- diff --git a/remote_services/remote_service_admin_dfi/dynamic_function_interface/json_rpc.h b/remote_services/remote_service_admin_dfi/dynamic_function_interface/json_rpc.h deleted file mode 100644 index 1cc1464..0000000 --- a/remote_services/remote_service_admin_dfi/dynamic_function_interface/json_rpc.h +++ /dev/null @@ -1,37 +0,0 @@ -/** - *Licensed to the Apache Software Foundation (ASF) under one - *or more contributor license agreements. See the NOTICE file - *distributed with this work for additional information - *regarding copyright ownership. The ASF licenses this file - *to you under the Apache License, Version 2.0 (the - *"License"); you may not use this file except in compliance - *with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - *Unless required by applicable law or agreed to in writing, - *software distributed under the License is distributed on an - *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - *specific language governing permissions and limitations - *under the License. - */ -#ifndef __JSON_RPC_H_ -#define __JSON_RPC_H_ - -#include <jansson.h> -#include "dfi_log_util.h" -#include "dyn_type.h" -#include "dyn_function.h" -#include "dyn_interface.h" - -//logging -DFI_SETUP_LOG_HEADER(jsonRpc); - -int jsonRpc_call(dyn_interface_type *intf, void *service, const char *request, char **out); - - -int jsonRpc_prepareInvokeRequest(dyn_function_type *func, const char *id, void *args[], char **out); -int jsonRpc_handleReply(dyn_function_type *func, const char *reply, void *args[]); - -#endif
