From 7b82f4299997faa16da295037ffa897e54eb8521 Mon Sep 17 00:00:00 2001 From: "jk7744.park" Date: Mon, 26 Oct 2015 15:44:19 +0900 Subject: [PATCH] tizen 2.4 release --- CMakeLists.txt | 52 + LICENSE.Apache-2.0 | 202 + NOTICE | 3 + README | 0 config/storage_adaptor_config.ini | 7 + inc/storage-adaptor-log.h | 192 + inc/storage-adaptor.h | 2210 +++++++++++ packaging/storage-adaptor.spec | 53 + src/storage-adaptor.c | 7571 +++++++++++++++++++++++++++++++++++++ storage-adaptor.manifest | 13 + storage-adaptor.pc.in | 10 + 11 files changed, 10313 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 LICENSE.Apache-2.0 create mode 100644 NOTICE create mode 100644 README create mode 100644 config/storage_adaptor_config.ini create mode 100644 inc/storage-adaptor-log.h create mode 100644 inc/storage-adaptor.h create mode 100644 packaging/storage-adaptor.spec create mode 100644 src/storage-adaptor.c create mode 100644 storage-adaptor.manifest create mode 100644 storage-adaptor.pc.in diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..1812787 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,52 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(storage-adaptor C) + +set(BUILD_TYPE "DEBUG") + +# variable holds path to config files +set(CONFIG_FILES_PATH "" CACHE FILEPATH "Path to coniguration files") + +include_directories(${CMAKE_BINARY_DIR}) + +file(GLOB SRCS src/*.c) + +if(BUILD_TYPE STREQUAL "DEBUG") + message("DEBUG build!") + set(BUILD_TYPE_FLAGS "") + add_definitions(-DDEBUG_ADAPTOR_PARAMS) +elseif(BUILD_TYPE STREQUAL "RELEASE") + message("RELEASE build!") + set(BUILD_TYPE_FLAGS "-DRELEASE") +else() + message(FATAL_ERROR "####\nBUILD_TYPE should be DEBUG or RELEASE! Have: ${BUILD_TYPE} . Aborting.\n####") +endif(BUILD_TYPE STREQUAL "DEBUG") + +set(PREFIX "/usr") +set(BINDIR "${PREFIX}/bin") +set(LIBDIR "${PREFIX}/lib") + +include_directories(${CMAKE_SOURCE_DIR}/inc) + +include(FindPkgConfig) +pkg_check_modules(pkgs REQUIRED + glib-2.0 + dlog + plugin-config + libsmack) + +foreach(flag ${pkgs_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +endforeach(flag) + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror -std=gnu99 -D_GNU_SOURCE") +SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") +SET(CMAKE_C_FLAGS_RELEASE "-O2") + +ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS} ) +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS} -ldl -lm) +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${LIBDIR}) + +INSTALL(FILES ${CMAKE_SOURCE_DIR}/inc/storage-adaptor.h DESTINATION /usr/include/storage-adaptor/) + +CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/storage-adaptor.pc.in ${CMAKE_SOURCE_DIR}/storage-adaptor.pc @ONLY) +INSTALL(FILES ${CMAKE_SOURCE_DIR}/storage-adaptor.pc DESTINATION ${LIBDIR}/pkgconfig) diff --git a/LICENSE.Apache-2.0 b/LICENSE.Apache-2.0 new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/LICENSE.Apache-2.0 @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed 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. diff --git a/NOTICE b/NOTICE new file mode 100644 index 0000000..579ba56 --- /dev/null +++ b/NOTICE @@ -0,0 +1,3 @@ +Copyright (c) Samsung Electronics Co., Ltd. All rights reserved. +Except as noted, this software is licensed under Apache License, Version 2. +Please, see the LICENSE.Apache-2.0 file for Apache License terms and conditions. diff --git a/README b/README new file mode 100644 index 0000000..e69de29 diff --git a/config/storage_adaptor_config.ini b/config/storage_adaptor_config.ini new file mode 100644 index 0000000..61e81dc --- /dev/null +++ b/config/storage_adaptor_config.ini @@ -0,0 +1,7 @@ +[general] +ip=127.0.0.1 +connection_port=5001 +listener_port=5123 +[developer] +app_id=temp +app_key=temp diff --git a/inc/storage-adaptor-log.h b/inc/storage-adaptor-log.h new file mode 100644 index 0000000..12b946b --- /dev/null +++ b/inc/storage-adaptor-log.h @@ -0,0 +1,192 @@ +/* +* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* +* Licensed 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 __STORAGE_ADAPTOR_LOG_H__ +#define __STORAGE_ADAPTOR_LOG_H__ + +/** + * HOW TO USE IT: + * First you need to set platform logging on the device: + * + * # dlogctrl set platformlog 1 + * + * After reboot you are able to see logs from this application, when you launch dlogutil with a proper filter e.g.: + * + * # dlogutil STORAGE_ADAPTOR:D + * + * You may use different logging levels as: D (debug), I (info), W (warning), E (error) or F (fatal). + * Higher level messages are included by default e.g. dlogutil CLOUDBOX:W prints warnings but also errors and fatal messages. + */ + +#include +#include + +/* These defines must be located before #include */ +#define TIZEN_ENGINEER_MODE +// TODO: Investigate why this macro is defined somewhere else +#ifndef TIZEN_DEBUG_ENABLE +#define TIZEN_DEBUG_ENABLE +#endif + +#ifdef LOG_TAG +#undef LOG_TAG +#endif +/* Literal to filter logs from dlogutil */ +#define LOG_TAG "STORAGE_ADAPTOR" + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + /** + * Colors of font + */ +#define FONT_COLOR_RESET "\033[0m" +#define FONT_COLOR_BLACK "\033[30m" /* Black */ +#define FONT_COLOR_RED "\033[31m" /* Red */ +#define FONT_COLOR_GREEN "\033[32m" /* Green */ +#define FONT_COLOR_YELLOW "\033[33m" /* Yellow */ +#define FONT_COLOR_BLUE "\033[34m" /* Blue */ +#define FONT_COLOR_PURPLE "\033[35m" /* Purple */ +#define FONT_COLOR_CYAN "\033[36m" /* Cyan */ +#define FONT_COLOR_WHITE "\033[37m" /* White */ +#define FONT_COLOR_BOLDBLACK "\033[1m\033[30m" /* Bold Black */ +#define FONT_COLOR_BOLDRED "\033[1m\033[31m" /* Bold Red */ +#define FONT_COLOR_BOLDGREEN "\033[1m\033[32m" /* Bold Green */ +#define FONT_COLOR_BOLDYELLOW "\033[1m\033[33m" /* Bold Yellow */ +#define FONT_COLOR_BOLDBLUE "\033[1m\033[34m" /* Bold Blue */ +#define FONT_COLOR_BOLDPURPLE "\033[1m\033[35m" /* Bold Purple */ +#define FONT_COLOR_BOLDCYAN "\033[1m\033[36m" /* Bold Cyan */ +#define FONT_COLOR_BOLDWHITE "\033[1m\033[37m" /* Bold White */ + + /** + * Gets thread ID + */ +#define storage_adaptor_gettid() syscall(__NR_gettid) + +/** + * @brief Macro for returning value if expression is satisfied + * @param[in] expr Expression to be checked + * @param[out] val Value to be returned when expression is true + */ +#define storage_adaptor_retv_if(expr, val) do { \ + if(expr) { \ + LOGE(FONT_COLOR_PURPLE"[%d]"FONT_COLOR_RESET, storage_adaptor_gettid()); \ + return (val); \ + } \ + } while (0) + +/** + * @brief Prints debug messages + * @param[in] fmt Format of data to be displayed + * @param[in] args Arguments to be displayed + */ +#define storage_adaptor_debug(fmt, arg...) do { \ + LOGD(FONT_COLOR_GREEN"[%d]"fmt""FONT_COLOR_RESET, storage_adaptor_gettid(), ##arg); \ + } while (0) + +/** + * @brief Prints info messages + * @param[in] fmt Format of data to be displayed + * @param[in] args Arguments to be displayed + */ +#define storage_adaptor_info(fmt, arg...) do { \ + LOGI(FONT_COLOR_BLUE"[%d]"fmt""FONT_COLOR_RESET, storage_adaptor_gettid() ,##arg); \ + } while (0) + +/** + * @brief Prints warning messages + * @param[in] fmt Format of data to be displayed + * @param[in] args Arguments to be displayed + */ +#define storage_adaptor_warning(fmt, arg...) do { \ + LOGW(FONT_COLOR_YELLOW"[%d]"fmt""FONT_COLOR_RESET,storage_adaptor_gettid(), ##arg); \ + } while (0) + +/** + * @brief Prints error messages + * @param[in] fmt Format of data to be displayed + * @param[in] args Arguments to be displayed + */ +#define storage_adaptor_error(fmt, arg...) do { \ + LOGE(FONT_COLOR_RED"[%d]"fmt""FONT_COLOR_RESET,storage_adaptor_gettid(), ##arg); \ + } while (0) + +/** + * @brief Prints fatal messages + * @param[in] fmt Format of data to be displayed + * @param[in] args Arguments to be displayed + */ +#define storage_adaptor_fatal(fmt, arg...) do { \ + LOGF(FONT_COLOR_BOLDRED"[%d]"fmt""FONT_COLOR_RESET,storage_adaptor_gettid(), ##arg); \ + } while (0) + +/** + * @brief Prints debug message on entry to particular function + * @param[in] fmt Format of data to be displayed + * @param[in] args Arguments to be displayed + */ +#define storage_adaptor_debug_func(fmt, arg...) do { \ + LOGD(FONT_COLOR_CYAN"[%d]"fmt""FONT_COLOR_RESET, storage_adaptor_gettid(), ##arg); \ + } while (0) + +/** + * @brief Prints debug message on entry to particular function + * @param[in] fmt Format of data to be displayed + * @param[in] args Arguments to be displayed + */ +#define storage_adaptor_debug_secure(fmt, arg...) do { \ + SECURE_LOGD(FONT_COLOR_CYAN"[%d]"fmt""FONT_COLOR_RESET, storage_adaptor_gettid(), ##arg); \ + } while (0) + +#define storage_adaptor_check_param_equal(compare, val, ret_val, exception_handling) {\ + if ( compare == val ) {\ + LOGD(FONT_COLOR_PURPLE "[%d]" "Parameter Check catched (equal) \n : Expected(%p) Value(%p)" FONT_COLOR_RESET, storage_adaptor_gettid(), __LINE__, compare, val);\ + exception_handling;\ + return ret_val;\ + }\ +} + +#define plugin_req_enter() do { \ + storage_adaptor_info("[ENTER] plugin API call -)) -)) -)) -)) -)) -)) -)) -)) -)) -))"); \ + } while (0) + +#define plugin_req_exit(ret, plugin, error) do { \ + storage_adaptor_info("[EXIT] plugin API called (%d) ((- ((- ((- ((- ((- ((- ((- ((- ((- ((-", (int)(ret)); \ + if ((error)) { \ + if ((*error)) { \ + storage_adaptor_error("plugin issued error (%lld) (%s)", (long long int)((*error)->code), (char *)((*error)->msg)); \ + char *tem = g_strdup_printf("[PLUGIN_ERROR] URI(%s), MSG(%s)", (char *)((plugin)->handle->plugin_uri), (char *)((*error)->msg)); \ + if (tem) { \ + free((*error)->msg); \ + (*error)->msg = tem; \ + } \ + } \ + } \ + } while (0) + +#define plugin_req_exit_void() do { \ + storage_adaptor_info("[EXIT] plugin API called ((- ((- ((- ((- ((- ((- ((- ((- ((- ((-"); \ + } while (0) + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* __STORAGE_ADAPTOR_LOG_H__ */ diff --git a/inc/storage-adaptor.h b/inc/storage-adaptor.h new file mode 100644 index 0000000..1d79a1e --- /dev/null +++ b/inc/storage-adaptor.h @@ -0,0 +1,2210 @@ +/* +* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* +* Licensed 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 __STORAGE_ADAPTOR_H__ +#define __STORAGE_ADAPTOR_H__ + +#ifndef EXPORT_API +#define EXPORT_API __attribute__((visibility("default"))) +#endif + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** + * Storage adaptor error code + */ +typedef enum storage_error_code_e +{ + STORAGE_ADAPTOR_ERROR_NONE = 0, + STORAGE_ADAPTOR_ERROR_LAUNCH = 1, /**< 1 ~ 99: internal error*/ + STORAGE_ADAPTOR_ERROR_INIT = 2, + STORAGE_ADAPTOR_ERROR_DEINIT = 3, + STORAGE_ADAPTOR_ERROR_CREATE = 4, + STORAGE_ADAPTOR_ERROR_DESTROY = 5, + STORAGE_ADAPTOR_ERROR_START = 6, + STORAGE_ADAPTOR_ERROR_STOP = 7, + STORAGE_ADAPTOR_ERROR_CONNECT = 8, + STORAGE_ADAPTOR_ERROR_DISCONNECT = 9, + STORAGE_ADAPTOR_ERROR_NOT_FOUND = 10, + STORAGE_ADAPTOR_ERROR_CORRUPTED = 11, + STORAGE_ADAPTOR_ERROR_UNSUPPORTED = 12, + STORAGE_ADAPTOR_ERROR_INVALID_HANDLE = 13, + STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT = 14, + STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT_TYPE = 15, + STORAGE_ADAPTOR_ERROR_NOT_AUTHORIZED = 16, + STORAGE_ADAPTOR_ERROR_ADAPTOR_INTERNAL = 17, + STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL = 18, + STORAGE_ADAPTOR_ERROR_SERVER_INTERNAL = 19, + STORAGE_ADAPTOR_ERROR_DBUS = 20, + STORAGE_ADAPTOR_ERROR_CALLBACK_TIME_OUT = 21, + STORAGE_ADAPTOR_ERROR_MAX +} storage_error_code_t; + +/** + * Storage adaptor error code + */ +typedef enum _storage_plugin_internal_error_code_e +{ + STORAGE_PLUGIN_ERROR_HTTP_BAD_REQUEST = 400, + STORAGE_PLUGIN_ERROR_HTTP_UNAUTHORIZED = 401, + STORAGE_PLUGIN_ERROR_HTTP_FORBIDDEN = 403, + STORAGE_PLUGIN_ERROR_HTTP_NOT_FOUND = 404, + STORAGE_PLUGIN_ERROR_HTTP_METHOD_NOT_ALLOWED = 405, + STORAGE_PLUGIN_ERROR_HTTP_BAD_GATEWAY = 502, + STORAGE_PLUGIN_ERROR_HTTP_SERVICE_UNAVAILBLE = 503, + STORAGE_PLUGIN_ERROR_HTTP_INSUFFICIENT_STORAGE = 507, + STORAGE_PLUGIN_ERROR_HTTP_ETC = 598, + STORAGE_PLUGIN_ERROR_HTTP_UNKNOWN = 599, + + STORAGE_PLUGIN_ERROR_CURL_COULDNT_CONNECT = 601, + STORAGE_PLUGIN_ERROR_CURL_TIMEOUT = 602, + STORAGE_PLUGIN_ERROR_CURL_ETC = 698, + STORAGE_PLUGIN_ERROR_CURL_UNKNOWN = 699, + + STORAGE_PLUGIN_ERROR_FILE_OPEN_FAILED = 701, + STORAGE_PLUGIN_ERROR_FILE_NOT_EXIST = 702, + STORAGE_PLUGIN_ERROR_FILE_TRANSFER_CANCELED = 703, + STORAGE_PLUGIN_ERROR_FILE_AREADY_EXIST = 704, // EEXIST + STORAGE_PLUGIN_ERROR_FILE_ACCESS_DENIED = 705, // EACCES + STORAGE_PLUGIN_ERROR_FILE_ETC = 798, + STORAGE_PLUGIN_ERROR_FILE_UNKNOWN = 799, + + STORAGE_PLUGIN_ERROR_MEMORY_ALLOCATION_FAILED = 801, + STORAGE_PLUGIN_ERROR_MEMORY_ETC = 898, + STORAGE_PLUGIN_ERROR_MEMORY_UNKNOWN = 899, + + STORAGE_PLUGIN_ERROR_THREAD_CREATE_FAILED = 901, + STORAGE_PLUGIN_ERROR_THREAD_STOPPED = 902, + STORAGE_PLUGIN_ERROR_THREAD_ETC = 908, + STORAGE_PLUGIN_ERROR_THREAD_UNNOWN = 909, + STORAGE_PLUGIN_ERROR_ETC = 998, + STORAGE_PLUGIN_ERROR_UNKNOWN = 999, +} storage_plugin_internal_error_code_e; + +/** + * Storage adaptor status code + */ +typedef enum _storage_adaptor_transfer_state_e +{ + STORAGE_ADAPTOR_TRANSFER_STATE_IN_PROGRESS = 1, + STORAGE_ADAPTOR_TRANSFER_STATE_FINISHED = 2, + STORAGE_ADAPTOR_TRANSFER_STATE_CANCELED = 3, // canceled by request + STORAGE_ADAPTOR_TRANSFER_STATE_FAILED = 4, // canceled by system + + STORAGE_ADAPTOR_TRANSFER_STATE_RESUME, // not use this version yet (Next feature) + STORAGE_ADAPTOR_TRANSFER_STATE_PAUSED, // not use this version yet (Next feature) + + // Private feature + STORAGE_ADAPTOR_TRANSFER_STATUS_PROGRESS = 1, + STORAGE_ADAPTOR_TRANSFER_STATUS_RESUME = 1, + STORAGE_ADAPTOR_TRANSFER_STATUS_PAUSE = 2, + STORAGE_ADAPTOR_TRANSFER_STATUS_CANCEL = 3, // canceled by request + STORAGE_ADAPTOR_TRANSFER_STATUS_STOPPED = 4, // canceled by system + STORAGE_ADAPTOR_TRANSFER_STATUS_FINISHED = 5 +} storage_adaptor_transfer_state_e; + +typedef storage_adaptor_transfer_state_e storage_adaptor_transfer_status_e; + +typedef enum +{ + STORAGE_ADAPTOR_FILE_ACCESS_READ = O_RDONLY, + STORAGE_ADAPTOR_FILE_ACCESS_WRITE = O_WRONLY|O_CREAT|O_EXCL, +} storage_adaptor_file_access_mode_e; + +/** + * Storage adaptor content type + */ +typedef enum _storage_adaptor_content_type_e +{ + STORAGE_ADAPTOR_CONTENT_TYPE_DEFAULT = -1, // initalize value + + STORAGE_ADAPTOR_CONTENT_TYPE_IMGAE = 160, + STORAGE_ADAPTOR_CONTENT_TYPE_VIDEO = 161, + STORAGE_ADAPTOR_CONTENT_TYPE_SOUND = 162, + STORAGE_ADAPTOR_CONTENT_TYPE_MUSIC = 163, + STORAGE_ADAPTOR_CONTENT_TYPE_OTHER = 164, + STORAGE_ADAPTOR_CONTENT_TYPE_DOCUMENT = 165, + STORAGE_ADAPTOR_CONTENT_TYPE_THUMBNAIL = 166, + + STORAGE_ADAPTOR_CONTENT_TYPE_CHUNK_MASK = 320, + STORAGE_ADAPTOR_CONTENT_TYPE_IMGAE_CHUNK = 480, + STORAGE_ADAPTOR_CONTENT_TYPE_VIDEO_CHUNK = 481, + STORAGE_ADAPTOR_CONTENT_TYPE_SOUND_CHUNK = 482, + STORAGE_ADAPTOR_CONTENT_TYPE_MUSIC_CHUNK = 483, + STORAGE_ADAPTOR_CONTENT_TYPE_OTHER_CHUNK = 484, + STORAGE_ADAPTOR_CONTENT_TYPE_DOCUMENT_CHUNK = 485, + STORAGE_ADAPTOR_CONTENT_TYPE_THUMBNAIL_CHUNK = 486, + + STORAGE_ADAPTOR_CONTENT_TYPE_FOLDER = 1024, + STORAGE_ADAPTOR_CONTENT_TYPE_METADATA = 2048, +} storage_adaptor_content_type_e; + + +/** + * Storage adaptor plugin handle + */ +typedef struct storage_adaptor_plugin_s *storage_adaptor_plugin_h; + +/** + * Storage adaptor + */ +typedef struct storage_adaptor_s *storage_adaptor_h; + +/** + * Storage adaptor plugin context structure + */ +typedef struct storage_adaptor_plugin_context_s +{ + // Context variables + int context_id; + storage_adaptor_plugin_h plugin_handle; + + // User define (input by service-adaptor) + char *app_id; + char *app_secret; + char *access_token; + char *cid; + char *uid; + char *service_name; + + // Plugin define (input by plugin) + char *plugin_uri; // mandatory (package id) + void *plugin_data; // optional +} storage_adaptor_plugin_context_t; +typedef struct storage_adaptor_plugin_context_s *storage_adaptor_plugin_context_h; + +/** + * Structure for error code from server + */ +typedef struct storage_adaptor_error_code_s +{ + int64_t code; + char *msg; +} storage_adaptor_error_code_t; +typedef struct storage_adaptor_error_code_s *storage_adaptor_error_code_h; + +typedef struct _storage_adaptor_media_meta_s +{ + char *mime_type; + char *title; + char *album; + char *artist; + char *genere; + char *recorded_date; + int width; + int height; + int duration; + char *copyright; + char *track_num; + char *description; + char *composer; + char *year; + int bitrate; + int samplerate; + int channel; + char *extra_media_meta; +} storage_adaptor_media_meta_s; + +typedef struct _storage_adaptor_cloud_meta_s +{ + char *service_name; + unsigned long long usage_byte; + unsigned long long quota_byte; + char *extra_cloud_meta; +} storage_adaptor_cloud_meta_s; + +// private only!! +/** + * Structure Storage File Share token Infomation + */ +typedef struct storage_adaptor_file_share_token_s +{ + char *public_token; + char *auth_code; +} storage_adaptor_file_share_token_t; +typedef struct storage_adaptor_file_share_token_s *storage_adaptor_file_share_token_h; + +/** + * Structure Storage File Infomation + */ +typedef struct storage_adaptor_file_info_s +{ + // Common + char *plugin_uri; /**< specifies plugin name generated file_info */ + char *object_id; /**< specifies file object id be used in storage */ + char *storage_path; /**< specifies file path in storage */ + unsigned long long file_size; /**< specifies file size (recomend byte)*/ + int file_info_index; /**< specifies file info index (wide use; e.g : chunk upload, multi download)*/ + + // private only!! + int revision; + unsigned long long timestamp; + char *type; + int deleted; + unsigned long long expired_time; + unsigned int download_count; + unsigned int max_download_count; + char *tag; + storage_adaptor_file_share_token_h file_share_token; + + + // public defined + unsigned long long created_time; /**< specifies timestamp */ + unsigned long long modified_time; /**< specifies timestamp */ + storage_adaptor_content_type_e content_type; + + storage_adaptor_media_meta_s *media_meta; + storage_adaptor_cloud_meta_s *cloud_meta; + char *extra_file_info; /**< specifies content name in metadata */ +} storage_adaptor_file_info_t; +typedef struct storage_adaptor_file_info_s *storage_adaptor_file_info_h; + +/** + * Storage adaptor plugin listener + */ +typedef struct storage_adaptor_plugin_listener_s *storage_adaptor_plugin_listener_h; + +/** + * Storage adaptor plugin handle + */ +typedef struct storage_adaptor_plugin_handle_s +{ + // Mandatory functions to handle plugin in adaptor + storage_error_code_t (*create_context)(storage_adaptor_plugin_context_h *context, + const char *app_id, + const char *app_secret, + const char *access_token, + const char *cid, + const char *uid); + storage_error_code_t (*destroy_context)(storage_adaptor_plugin_context_h context); + storage_error_code_t (*destroy_handle)(struct storage_adaptor_plugin_handle_s *handle); + storage_error_code_t (*set_listener)(storage_adaptor_plugin_listener_h listener); + storage_error_code_t (*unset_listener)(void); + // Mandatory end + + // Optional + + storage_error_code_t (*open_file) (storage_adaptor_plugin_context_h context, // Do Not define from plugin (TBD) + const char *file_path, + storage_adaptor_file_access_mode_e mode, + int *file_descriptor, + storage_adaptor_error_code_h *error); + + storage_error_code_t (*close_file) (storage_adaptor_plugin_context_h context, // Do Not define from plugin (TBD) + int file_descriptor, + storage_adaptor_error_code_h *error); + + storage_error_code_t (*start_upload_task)(storage_adaptor_plugin_context_h context, + int src_file_descriptor, // read only opened + const char *upload_dir_path, + const char *file_name, + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data); + + storage_error_code_t (*start_download_task)(storage_adaptor_plugin_context_h context, + const char *storage_dir_path, + const char *file_name, + int dst_file_descriptor, // write only opened + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data); + + storage_error_code_t (*start_download_thumb_task)(storage_adaptor_plugin_context_h context, + const char *storage_dir_path, + const char *file_name, + int dst_file_descriptor, // write only opened + int thumbnail_size, // level (defined plugin SPEC) + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data); + + storage_error_code_t (*cancel_upload_task)(storage_adaptor_plugin_context_h context, + int file_descriptor, + storage_adaptor_error_code_h *error); + + storage_error_code_t (*cancel_download_task)(storage_adaptor_plugin_context_h context, + int file_descriptor, + storage_adaptor_error_code_h *error); + + storage_error_code_t (*cancel_download_thumb_task)(storage_adaptor_plugin_context_h context, + int file_descriptor, + storage_adaptor_error_code_h *error); + + // common (yet) + storage_error_code_t (*set_server_info)(storage_adaptor_plugin_context_h context, + GHashTable *server_info, + void *request, + storage_adaptor_error_code_h *error, + void *response); + // Optional end + // common + storage_error_code_t (*get_root_folder_path)(storage_adaptor_plugin_context_h context, + void *request, + char **root_folder_path, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*list)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*make_directory)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*upload_file_sync)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const int publish, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*download_file_sync)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *download_file_local_path, + void *request, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*download_thumbnail)(storage_adaptor_plugin_context_h context, + const char *folder_path, + const char *file_name, + const char *download_path, + int thumbnail_size, + void *request, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*delete_file)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*remove_directory)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*move_file)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *dest_parent_folder_storage_path, + const char *new_file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*move_directory)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + const char *dest_parent_folder_storage_path, + const char *new_folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*set_transfer_state)(storage_adaptor_plugin_context_h context, + void *transfer_request_id, + storage_adaptor_transfer_state_e state, + void *request, + storage_adaptor_error_code_h *error, + void *response); + + // common + storage_error_code_t (*get_transfer_state)(storage_adaptor_plugin_context_h context, + void *transfer_request_id, + void *request, + storage_adaptor_transfer_state_e *state, + storage_adaptor_error_code_h *error, + void *response); + + + storage_error_code_t (*upload_file_async)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const int publish, + void *request, + void *transfer_request_id); + + storage_error_code_t (*download_file_async)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *download_file_local_path, + void *request, + void *transfer_request_id); + + storage_error_code_t (*download_file_sync_by_public_token)(storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + const char *download_file_local_path, + void *request, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*download_file_async_by_public_token)(storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + const char *download_file_local_path, + void *request, + void *transfer_request_id); + + storage_error_code_t (*get_transfer_progress)(storage_adaptor_plugin_context_h context, + void *transfer_request_id, + void *request, + unsigned long long *progress_size_byte, + unsigned long long *total_size_byte, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*set_meta)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const void *meta_data, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*get_meta)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + void **meta_data, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*start_mupload)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const unsigned long long chunk_size_byte, + void *request, + char **mupload_key, + int *chunk_count, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*upload_mupload)(storage_adaptor_plugin_context_h context, + const char *mupload_key, + const int chunk_number, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*end_mupload)(storage_adaptor_plugin_context_h context, + const char *mupload_key, + const int publish, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*list_mupload)(storage_adaptor_plugin_context_h context, + const char *mupload_key, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*cancel_mupload)(storage_adaptor_plugin_context_h context, + const char *mupload_key, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*start_transaction)(storage_adaptor_plugin_context_h context, + void *request, + char **tx_key, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*upload_file_transaction)(storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*set_dir_transaction)(storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*delete_file_transaction)(storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*delete_dir_transaction)(storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*end_transaction)(storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_count, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*list_transaction)(storage_adaptor_plugin_context_h context, + const char *tx_key, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*cancel_transaction)(storage_adaptor_plugin_context_h context, + const char *tx_key, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*multi_file_upload)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char **upload_file_local_path_list, + const int upload_list_len, + void *request, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*multi_file_download)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name_list, + const int file_name_list_len, + const char *download_folder_local_path, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*get_timestamp)(storage_adaptor_plugin_context_h context, + void *request, + unsigned long long *timestamp, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*get_file_info_by_public_token)(storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*auth_public_authcode_by_public_token)(storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + void *request, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*redirect_url_by_public_token)(storage_adaptor_plugin_context_h context, + const char *public_token, + void *request, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*create_resuming_upload_url)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const unsigned long long x_upload_content_length, + void *request, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*create_resuming_chunk_upload_url)(storage_adaptor_plugin_context_h context, + const char *mupload_key, + const int chunk_number, + const unsigned long long x_upload_content_length, + void *request, + char **rupload_key, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*resuming_upload)(storage_adaptor_plugin_context_h context, + const char *rupload_key, + const char *content_range, + const unsigned long long content_length, + void *request, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*delete_multi_file_in_folder)(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char **file_name_list, + const int file_name_list_len, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*get_policy)(storage_adaptor_plugin_context_h context, + void *request, + char ***allowed_extension, + int *allowed_extension_len, + storage_adaptor_error_code_h *error, + void *response); + + storage_error_code_t (*get_quota)(storage_adaptor_plugin_context_h context, + void *request, + unsigned long long *total_usage, + unsigned long long *total_quota, + storage_adaptor_error_code_h *error, + void *response); + + // Optional end + + // Mandatory + char *plugin_uri; // get from config file + // Mandatory end + +} storage_adaptor_plugin_handle_t; +typedef struct storage_adaptor_plugin_handle_s *storage_adaptor_plugin_handle_h; + +/** + * Callback function variable for service adaptor + */ + +// private feature +typedef void (*storage_adaptor_service_download_file_async_reply_cb)(void *transfer_request_id, + char *download_file_local_path, + storage_adaptor_error_code_h error, + void *response); + +typedef void (*storage_adaptor_service_upload_file_async_reply_cb)(void *transfer_request_id, + storage_adaptor_file_info_h file_info, + storage_adaptor_error_code_h error, + void *response); + +typedef void (*storage_adaptor_service_file_transfer_progress_reply_cb)(void *transfer_request_id, + unsigned long long progress_size_byte, + unsigned long long total_size_byte, + storage_adaptor_error_code_h error, + void *response); + +// public feature +typedef void (*storage_adaptor_service_download_state_changed_reply_cb)(long long int file_descriptor, + storage_adaptor_transfer_state_e state, + storage_adaptor_error_code_h error, + void *user_data); + +typedef void (*storage_adaptor_service_upload_state_changed_reply_cb)(long long int file_descriptor, + storage_adaptor_transfer_state_e state, + storage_adaptor_file_info_h file_info, + storage_adaptor_error_code_h error, + void *user_data); + +typedef void (*storage_adaptor_service_task_progress_reply_cb)(long long int file_descriptor, + unsigned long long progress_size_byte, + unsigned long long total_size_byte); + + + +/** + * Storage adaptor listener for service adaptor + * Listener is used by service adaptor + */ +typedef struct storage_adaptor_listener_s +{ +// private feature + void (*download_file_async_reply)(void *transfer_request_id, + char *download_file_local_path, + storage_adaptor_error_code_h error, + void *response); + + void (*upload_file_async_reply)(void *transfer_request_id, + storage_adaptor_file_info_h file_info, + storage_adaptor_error_code_h error, + void *response); + + void (*file_transfer_progress_reply)(void *transfer_request_id, + unsigned long long progress_size_byte, + unsigned long long total_size_byte, + storage_adaptor_error_code_h error, + void *response); + +// public feature + void (*download_state_changed_reply)(long long int file_descriptor, + storage_adaptor_transfer_state_e state, + storage_adaptor_error_code_h error, + void *user_data); + + void (*upload_state_changed_reply)(long long int file_descriptor, + storage_adaptor_transfer_state_e state, + storage_adaptor_file_info_h file_info, + storage_adaptor_error_code_h error, + void *user_data); + + void (*task_progress_reply)(long long int file_descriptor, + unsigned long long progress_size_byte, + unsigned long long total_size_byte); + +} storage_adaptor_listener_t; +typedef struct storage_adaptor_listener_s *storage_adaptor_listener_h; + +/** + * Callback function variables for plugins + * These callbacks are expected to be support by plugins + */ +// private feature +typedef void (*storage_adaptor_plugin_download_file_async_reply_cb)(void *transfer_request_id, + char *download_file_local_path, + storage_adaptor_error_code_h error, + void *response); + +typedef void (*storage_adaptor_plugin_upload_file_async_reply_cb)(void *transfer_request_id, + storage_adaptor_file_info_h file_info, + storage_adaptor_error_code_h error, + void *response); + +typedef void (*storage_adaptor_plugin_file_transfer_progress_reply_cb)(void *transfer_request_id, + unsigned long long progress_size_byte, + unsigned long long total_size_byte, + storage_adaptor_error_code_h error, + void *response); + +// public feature +typedef void (*storage_adaptor_plugin_download_state_changed_reply_cb)(int file_descriptor, + storage_adaptor_transfer_state_e state, + storage_adaptor_error_code_h error, + void *user_data); + +typedef void (*storage_adaptor_plugin_upload_state_changed_reply_cb)(int file_descriptor, + storage_adaptor_transfer_state_e state, + storage_adaptor_file_info_h file_info, + storage_adaptor_error_code_h error, + void *user_data); + +typedef void (*storage_adaptor_plugin_task_progress_reply_cb)(int file_descriptor, + unsigned long long progress_size_byte, + unsigned long long total_size_byte, + storage_adaptor_error_code_h error, + void *user_data); + +/** + * Storage adaptor listener for plugins + * Listener is used by plugins + */ +typedef struct storage_adaptor_plugin_listener_s +{ +// private feature + storage_adaptor_plugin_download_file_async_reply_cb storage_adaptor_download_file_async_reply; + storage_adaptor_plugin_upload_file_async_reply_cb storage_adaptor_upload_file_async_reply; + storage_adaptor_plugin_file_transfer_progress_reply_cb storage_adaptor_file_transfer_progress_reply; + +// public feature + storage_adaptor_plugin_download_state_changed_reply_cb storage_adaptor_download_state_changed_reply; + storage_adaptor_plugin_upload_state_changed_reply_cb storage_adaptor_upload_state_changed_reply; + storage_adaptor_plugin_task_progress_reply_cb storage_adaptor_task_progress_reply; +} storage_adaptor_plugin_listener_t; + +/** + * Loads plugin from selected path + */ +int storage_adaptor_load_plugin(storage_adaptor_h, + const char *plugin_path); + +// For 3rd party plugin packages +int storage_adaptor_load_plugin_from_package(storage_adaptor_h adaptor, + const char *package_id, + const char *plugin_path); + +/** + * Unloads selected plugin + */ +int storage_adaptor_unload_plugin(storage_adaptor_h, + storage_adaptor_plugin_h); + +/** + * Gets plugin name + */ +void storage_adaptor_get_plugin_uri(storage_adaptor_plugin_h plugin, + char **plugin_uri); + +/** + * Refresh access token + */ +EXPORT_API +storage_error_code_t storage_adaptor_refresh_access_token(storage_adaptor_plugin_context_h context, + const char *new_access_token); + +/** + * Refresh access token + */ +EXPORT_API +storage_error_code_t storage_adaptor_refresh_uid(storage_adaptor_plugin_context_h context, + const char *new_uid); + +/** + * Create error code + */ +EXPORT_API +storage_adaptor_error_code_h storage_adaptor_create_error_code(const int64_t code, + const char *msg); + +/** + * Destroy error code + */ +EXPORT_API +void storage_adaptor_destroy_error_code(storage_adaptor_error_code_h *error_code); + +/** + * Creates storage adaptor + */ +EXPORT_API +storage_adaptor_h storage_adaptor_create(const char *plugins_dir); + +/** + * Destroys storage adaptor + * Destroys storage adaptor. If storage adaptor was started it is stopped first. + */ +EXPORT_API +void storage_adaptor_destroy(storage_adaptor_h adaptor); + +/** + * Starts storage adaptor + * Starts storage adaptor and loads plugins that were found in plugins search dir + * specified in storage_adaptor_create + */ +EXPORT_API +int storage_adaptor_start(storage_adaptor_h adaptor); + +/** + * Stops storage adaptor. + */ +EXPORT_API +int storage_adaptor_stop(storage_adaptor_h adaptor); + +/** + * Registers plugin state listener + */ +EXPORT_API +int storage_adaptor_register_listener(storage_adaptor_h, + storage_adaptor_listener_h); + +/** + * Unregisters plugin state listener + */ +EXPORT_API +int storage_adaptor_unregister_listener(storage_adaptor_h, + storage_adaptor_listener_h); + +/** + * Creates plugin context. + */ +EXPORT_API +storage_adaptor_plugin_context_h storage_adaptor_create_plugin_context(storage_adaptor_plugin_h plugin, + const char *app_id, + const char *app_secret, + const char *access_token, + const char *cid, + const char *uid, + const char *service_name); + +/** + * Destroys plugin context. + */ +EXPORT_API +void storage_adaptor_destroy_plugin_context(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h); + +/** + * Gets plugin with specified unique name + */ +EXPORT_API +storage_adaptor_plugin_h storage_adaptor_get_plugin_by_name(storage_adaptor_h adaptor, + const char *plugin_uri); + +/** + * Gets plugins + */ +EXPORT_API +GList *storage_adaptor_get_plugins(storage_adaptor_h adaptor); + +//////////////////////////////////////////////////////////// +// Adaptor Util Functions +//////////////////////////////////////////////////////////// +EXPORT_API +storage_adaptor_file_info_h storage_adaptor_create_file_info(void); + +EXPORT_API +int storage_adaptor_destroy_file_info(storage_adaptor_file_info_h *file_info); + + +//////////////////////////////////////////////////////////// +// Adaptor Plugin call Functions +//////////////////////////////////////////////////////////// + + +EXPORT_API +storage_error_code_t storage_adaptor_open_file(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *file_path, + storage_adaptor_file_access_mode_e mode, + long long int *file_uid, + storage_adaptor_error_code_h *error); + +EXPORT_API +storage_error_code_t storage_adaptor_close_file(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + long long int file_uid, + storage_adaptor_error_code_h *error); + +EXPORT_API +storage_error_code_t storage_adaptor_start_upload_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + long long int src_file_descriptor, // read only opened + const char *upload_dir_path, + const char *file_name, + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data); + +EXPORT_API +storage_error_code_t storage_adaptor_start_download_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *storage_dir_path, + const char *file_name, + long long int dst_file_descriptor, // write only opened + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data); + +EXPORT_API +storage_error_code_t storage_adaptor_start_download_thumb_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *storage_dir_path, + const char *file_name, + long long int dst_file_descriptor, // write only opened + int thumbnail_size, // level (defined plugin SPEC) + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data); + +EXPORT_API +storage_error_code_t storage_adaptor_cancel_upload_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + long long int file_uid, + storage_adaptor_error_code_h *error); + +EXPORT_API +storage_error_code_t storage_adaptor_cancel_download_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + long long int file_uid, + storage_adaptor_error_code_h *error); + +EXPORT_API +storage_error_code_t storage_adaptor_cancel_download_thumb_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + long long int file_uid, + storage_adaptor_error_code_h *error); + +/** +* @brief Set server information for Storage Plugin +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] server_info specifies server information for Storage Plugin +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_set_server_info(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + GHashTable *server_info, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Makes a directory at cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies path to locate the folder you want to create +* @param[in] folder_name specifies folder name to be created at cloud +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_make_directory(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Removes a directory at cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies parent folder path of folder you want to delete +* @param[in] folder_name specifies folder name to be deleted from cloud +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_remove_directory(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Requests folder and file list in a folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies parent folder path of folder you want to get list +* @param[in] folder_name specifies folder name you want to get list +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_list(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Uploads a file to cloud (Sync) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to upload +* @param[in] file_name specifies file name to be uploaded to cloud +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* @param[in] publish specifies Allow to share file with no authentication +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_upload_file_sync(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const int publish, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Uploads a file to cloud (Async) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to upload +* @param[in] file_name specifies file name to be uploaded to cloud +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* @param[in] publish specifies Allow to share file with no authentication +* @param[in] request specifies optional parameter +* @param[out] transfer_request_id specifies +* @param[out] error specifies error code +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_upload_file_async(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const int publish, + void *request, + void *transfer_request_id, + storage_adaptor_error_code_h *error); + +/** +* @brief Downloads a file to local (Sync) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to download +* @param[in] file_name specifies file name to be downloaded to local +* @param[in] download_file_local_path specifies local path to download +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_download_file_sync(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *download_file_local_path, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Downloads a file to local (Async) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to download +* @param[in] file_name specifies file name to be downloaded to local +* @param[in] download_file_local_path specifies local path to download +* @param[in] request specifies optional parameter +* @param[out] transfer_request_id specifies +* @param[out] error specifies error code +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_download_file_async(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *download_file_local_path, + void *request, + void *transfer_request_id, + storage_adaptor_error_code_h *error); + +/** +* @brief Downloads a thumbnail to local (Sync) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to download +* @param[in] file_name specifies file name to be downloaded to local +* @param[in] download_file_local_path specifies local path to download +* @param[in] thumbnail_size specifies thumbnail_size +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_download_thumbnail(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *folder_path, + const char *file_name, + const char *download_path, + int thumbnail_size, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Removes a file at cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to delete +* @param[in] file_name specifies file name to be deleted from cloud +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_delete_file(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Sets metadata of file at cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to set meta data +* @param[in] file_name specifies file name to be updated meta data +* @param[in] meta_data specifies meta data (A pair of Key, Value) +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_set_meta(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const void *meta_data, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Gets metatdata of file at cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to get meta data +* @param[in] file_name specifies file name +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] meta_data specifies meta data (A pair of Key, Value) +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_get_meta(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + void **meta_data, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Set up Multi Channel Upload +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to upload +* @param[in] file_name specifies file name to be uploaded to cloud +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* @param[in] chunk_size_byte specifies size of chunk +* @param[in] request specifies optional parameter +* @param[out] mupload_key specifies Multi Channel Upload key +* @param[out] chunk_count specifies total number of chunks +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_start_mupload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const unsigned long long chunk_size_byte, + void *request, + char **mupload_key, + int *chunk_count, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Uploads a chunk to cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] mupload_key specifies Multi Channel Upload key +* @param[in] chunk_number specifies number of chunk (Starting at 1) +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_upload_mupload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *mupload_key, + const int chunk_number, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Ends Multi channel Upload +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] mupload_key specifies Multi Channel Upload key +* @param[in] publish specifies Allow to share file with no authentication +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_end_mupload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *mupload_key, + const int publish, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Requests list of chunks uploaded +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] mupload_key specifies Multi Channel Upload key +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_list_mupload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *mupload_key, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Cancels all operations +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] mupload_key specifies Multi Channel Upload key +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_cancel_mupload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *mupload_key, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Starts Transaction +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] request specifies optional parameter +* @param[out] tx_key specifies Transaction key +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_start_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *request, + char **tx_key, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Uploads a file +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] tx_seq specifies Transaction sequesnce (Starting at 1) +* @param[in] parent_folder_storage_path specifies folder path of file you want to upload +* @param[in] file_name specifies file name to be uploaded to cloud +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_upload_file_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Updates a folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] tx_seq specifies Transaction sequesnce (Starting at 1) +* @param[in] parent_folder_storage_path specifies folder path of folder you want to update +* @param[in] folder_name specifies folder name to be updated +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_set_dir_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Removes a file +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] tx_seq specifies Transaction sequesnce (Starting at 1) +* @param[in] parent_folder_storage_path specifies folder path of file you want to delete +* @param[in] file_name specifies file name to be deleted from cloud +* @param[in] request specifies optional parameter +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_delete_file_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Removes a folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] tx_seq specifies Transaction sequesnce (Starting at 1) +* @param[in] parent_folder_storage_path specifies folder path of folder you want to delete +* @param[in] folder_name specifies folder name to be deleted +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_delete_dir_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Ends Transaction +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] tx_count specifies Transaction order count +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_end_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_count, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Requests Transaction list +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_list_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Cancels all transactions +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_cancel_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Uploads multiple files to cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of files you want to upload +* @param[in] upload_file_local_path_list specifies local path list of the files to be uploaded +* @param[in] upload_list_len specifies total number of files to be uploaded +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_multi_file_upload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char **upload_file_local_path_list, + const int upload_list_len, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Downloads multiple files in a folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of files you want to download +* @param[in] file_name_list specifies file name list to be downloaded +* @param[in] file_name_list_len specifies total number of files to be downloaded +* @param[in] download_folder_local_path specifies local folder path to download files +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_multi_file_download(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name_list, + const int file_name_list_len, + const char *download_folder_local_path, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Requests current server timestamp +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] request specifies optional parameter +* @param[out] timestamp specifies server timestamp +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_get_timestamp(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *request, + unsigned long long *timestamp, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Requests a file info by public token +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] public_token specifies token for Download, Get API + (when terminal upload file and add publish=true parameter, ors return public_token) +* @param[in] auth_code specifies Authentication code for public APIs +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_get_file_info_by_public_token(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Downloads a file by public token (Sync) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] public_token specifies token for Download, Get API + (when terminal upload file and add publish=true parameter, ors return public_token) +* @param[in] auth_code specifies Authentication code for public APIs +* @param[in] download_file_local_path specifies local path to download +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_download_file_sync_by_public_token(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + const char *download_file_local_path, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Downloads a file by public token (Async) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] public_token specifies token for Download, Get API + (when terminal upload file and add publish=true parameter, ors return public_token) +* @param[in] auth_code specifies Authentication code for public APIs +* @param[in] download_file_local_path specifies local path to download +* @param[in] request specifies optional parameter +* @param[out] transfer_request_id specifies +* @param[out] error specifies error code +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_download_file_async_by_public_token(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + const char *download_file_local_path, + void *request, + void *transfer_request_id, + storage_adaptor_error_code_h *error); + +/** +* @brief Authenticates public auth code +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] public_token specifies token for Download, Get API + (when terminal upload file and add publish=true parameter, ors return public_token) +* @param[in] auth_code specifies Authentication code for public APIs +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_auth_public_authcode_by_public_token(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Removes multiple files in a folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of files you want to delete +* @param[in] file_name_list specifies file name list to be deleted +* @param[in] file_name_list_len specifies total number of files to be deleted +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_delete_multi_file_in_folder(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char **file_name_list, + const int file_name_list_len, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Requests policy for upload +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] request specifies optional parameter +* @param[out] allowed_extension specifies +* @param[out] allowed_extension_len specifies length of allowed_extension +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_get_policy(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *request, + char ***allowed_extension, + int *allowed_extension_len, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Requests quota of user +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] request specifies optional parameter +* @param[out] total_usage specifies total usage of user +* @param[out] total_quota specifies total quota of user +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_get_quota(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *request, + unsigned long long *total_usage, + unsigned long long *total_quota, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Requests Redirect URL mapped with public token (Not yet supported) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] public_token specifies token for Download, Get API + (when terminal upload file and add publish=true parameter, ors return public_token) +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_redirect_url_by_public_token(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *public_token, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Creates Upload URL (Not yet supported) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of files you want to upload +* @param[in] file_name specifies file name to be uploaded +* @param[in] x_upload_content_length specifies length of content +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_create_resuming_upload_url(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const unsigned long long x_upload_content_length, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Creates chunk Upload URL (Not yet supported) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] mupload_key specifies Multi Channel Upload key +* @param[in] chunk_number specifies number of chunk (Starting at 1) +* @param[in] x_upload_content_length specifies length of content +* @param[in] request specifies optional parameter +* @param[out] rupload_key specifies Resuming Upload key +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_create_resuming_chunk_upload_url(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *mupload_key, + const int chunk_number, + const unsigned long long x_upload_content_length, + void *request, + char **rupload_key, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Resumes Upload (Not yet supported) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] rupload_key specifies Resuming Upload key +* @param[in] content_range specifies range of content +* @param[in] content_length specifies length of content +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_resuming_upload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *rupload_key, + const char *content_range, + const unsigned long long content_length, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Move a folder into destination folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies parent folder path of folder you want to move +* @param[in] folder_name specifies folder name to be moved +* @param[in] dest_parent_folder_storage_path specifies new parent folder path +* @param[in] new_folder_name specifies new folder name +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_move_directory(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + const char *dest_parent_folder_storage_path, + const char *new_folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Move a file into destination folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to move +* @param[in] file_name specifies file name to be moved +* @param[in] dest_parent_folder_storage_path specifies new folder path +* @param[in] new_file_name specifies new file name +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_move_file(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *dest_parent_folder_storage_path, + const char *new_file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Get progress of file transfer request +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] transfer_request_id specifies unique id for file transfer request +* @param[in] request specifies optional parameter +* @param[out] progress_size specifies current progress size +* @param[out] total_size specifies total size to transfer +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_get_transfer_progress(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *transfer_request_id, + void *request, + unsigned long long *progress_size_byte, + unsigned long long *total_size_byte, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Get state of file transfer request +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] transfer_request_id specifies unique id for file transfer request +* @param[in] request specifies optional parameter +* @param[out] state specifies current state of transfer request +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_get_transfer_state(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *transfer_request_id, + void *request, + storage_adaptor_transfer_state_e *state, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Set state of file transfer request +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] transfer_request_id specifies unique id for file transfer request +* @param[in] state specifies state to set +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_set_transfer_state(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *transfer_request_id, + storage_adaptor_transfer_state_e state, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +/** +* @brief Requests root folder path +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] request specifies optional parameter +* @param[out] root_folder_path specifies root folder path +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_get_root_folder_path(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *request, + char **root_folder_path, + storage_adaptor_error_code_h *error, + void *response); + +#ifdef __cplusplus +} +#endif + +#endif /* __STORAGE_ADAPTOR_H__ */ diff --git a/packaging/storage-adaptor.spec b/packaging/storage-adaptor.spec new file mode 100644 index 0000000..4e5c698 --- /dev/null +++ b/packaging/storage-adaptor.spec @@ -0,0 +1,53 @@ +Name: storage-adaptor +Summary: Storage Adaptor +Version: 1.0.0 +Release: 1 +Group: Social & Content +License: Apache-2.0 +Source0: %{name}-%{version}.tar.gz +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(glib-2.0) +BuildRequires: pkgconfig(plugin-config) +BuildRequires: pkgconfig(libsmack) + +BuildRequires: cmake + +%description +Storage Adaptor: Service Adaptor. + +%package -n storage-adaptor-devel +Summary: Headers for storage adaptor +Group: Development/Libraries +Requires: storage-adaptor = %{version}-%{release} + +%description -n storage-adaptor-devel +This package contains the header and pc files. + +%prep +%setup -q + +%build +export PREFIX="/usr/apps/storage-adaptor" +export CFLAGS+=" -fPIC" +export LDFLAGS+=" -Wl,--rpath=$(PREFIX)/lib -Wl,--as-needed -Wl,--hash-style=both" +export NAME=%{name} +export VERSION=%{version} + +cmake . -DCMAKE_INSTALL_PREFIX="$PREFIX" + +make %{?jobs:-j%jobs} + +%install +rm -rf %{buildroot} +%make_install + +%files +%manifest storage-adaptor.manifest +%defattr(-,root,root,-) +%{_libdir}/libstorage-adaptor.so + +%files -n storage-adaptor-devel +%defattr(-,root,root,-) +%{_includedir}/storage-adaptor/*.h +%{_libdir}/pkgconfig/storage-adaptor.pc + diff --git a/src/storage-adaptor.c b/src/storage-adaptor.c new file mode 100644 index 0000000..5e123ce --- /dev/null +++ b/src/storage-adaptor.c @@ -0,0 +1,7571 @@ +/* +* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved +* +* Licensed 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "storage-adaptor.h" +#include "storage-adaptor-log.h" + +#define PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE 40960 +#define PLUGIN_MESSAGE_LISTENER_CMD_APPEND_FD "append;" +#define PLUGIN_MESSAGE_LISTENER_CMD_STOP "stop;" + +#define STORAGE_PLUGIN_INTERFACE_CREATE_CONTEXT "create_context" +#define STORAGE_PLUGIN_INTERFACE_DESTROY_CONTEXT "destroy_context" +#define STORAGE_PLUGIN_INTERFACE_MAKE_DIRECTORY "make_directory" +#define STORAGE_PLUGIN_INTERFACE_GET_LIST "get_list" +#define STORAGE_PLUGIN_INTERFACE_REMOVE_DIRECTORY "remove_directory" +#define STORAGE_PLUGIN_INTERFACE_UPLOAD_FILE_SYNC "upload_file_sync" +#define STORAGE_PLUGIN_INTERFACE_DOWNLOAD_FILE_SYNC "download_file_sync" +#define STORAGE_PLUGIN_INTERFACE_DELETE_FILE "delete_file" +#define STORAGE_PLUGIN_INTERFACE_MOVE_DIRECTORY "move_directory" +#define STORAGE_PLUGIN_INTERFACE_MOVE_FILE "move_file" +#define STORAGE_PLUGIN_INTERFACE_SET_TRANSFER_STATE "set_transfer_state" +#define STORAGE_PLUGIN_INTERFACE_GET_TRANSFER_STATE "get_transfer_state" +#define STORAGE_PLUGIN_INTERFACE_GET_ROOT_FOLDER_PATH "get_root_folder_path" + +/* for 2.4 public functions */ +#define STORAGE_PLUGIN_INTERFACE_START_UPLOAD_TASK "start_upload_task" +#define STORAGE_PLUGIN_INTERFACE_START_DOWNLOAD_TASK "start_download_task" +#define STORAGE_PLUGIN_INTERFACE_START_DOWNLOAD_THUMB_TASK "start_download_thumb_task" +#define STORAGE_PLUGIN_INTERFACE_CANCEL_UPLOAD_TASK "cancel_upload_task" +#define STORAGE_PLUGIN_INTERFACE_CANCEL_DOWNLOAD_TASK "cancel_download_task" +#define STORAGE_PLUGIN_INTERFACE_CANCEL_DOWNLOAD_THUMB_TASK "cancel_download_thumb_task" + +#define STORAGE_PLUGIN_CALLBACK_DOWNLOAD_FILE_ASYNC_CB "download_async_cb" +#define STORAGE_PLUGIN_CALLBACK_UPLOAD_FILE_ASYNC_CB "upload_async_cb" +#define STORAGE_PLUGIN_CALLBACK_PROGRESS_CB "progress_cb" + +#define IF_IS_PLUGIN_THAN_RETURN_NULL() do {if (!g_process_identity) return NULL; } while (0) +#define SAFE_ADD_STRING(x) (x) ? (x) : ("") + +typedef enum { + PLUGIN_TYPE_INHOUSE = 0, + PLUGIN_TYPE_3RD_PARTY = 1, +} storage_plugin_type_e; + + +#ifndef FORK_PLUGIN_ARCHITECTURE +GHashTable *g_file_uid_list = NULL; +#endif + +/** + * Storage adaptor plugin + */ +typedef struct storage_adaptor_plugin_s { + storage_adaptor_h adaptor; /* Adaptor */ + char *path; /* Plugin library path */ + storage_adaptor_plugin_handle_h handle; /* Plugin handle */ + void *dl_handle; /* Plugin library handle */ + int ref_counter; /* Plugin reference counter */ + GMutex ref_counter_mutex; /* Plugin reference counter mutex */ + storage_adaptor_plugin_listener_h plugin_listener; /* Plugin callback listener */ + GMutex plugin_listener_mutex; /* Plugin callback listener mutex */ + + GMutex message_mutex; + storage_plugin_type_e type; + int pid; + int rd; + int wd; + GList *contexts; + GMutex contexts_mutex; +} storage_adaptor_plugin_t; + +/** + * Storage adaptor + */ +typedef struct storage_adaptor_s { + GMutex storage_adaptor_mutex; /* Adaptor mutex */ + int started; /* Started flag */ + char *plugins_dir; /* Plugins directory path */ + GList *plugins; /* List of loaded plugins */ + GMutex plugins_mutex; /* Plugin list mutex */ + GList *adaptor_listeners; /* List of vservice channel listener (for now not effective) */ + GMutex adaptor_listeners_mutex; /* Listener list mutex */ + + int rd_cmd[2]; + GList *rd_list; + GMutex rd_mutex; + pthread_t plugin_listener; +} storage_adaptor_t; + +static int g_process_identity = -1; + +static storage_adaptor_plugin_h g_child_plugin = NULL; + +/** + * Creates plugin + */ +static storage_adaptor_plugin_h storage_adaptor_create_plugin(const char *plugin_path); + +/** + * Destroys plugin and deletes all resources associated with it + */ +static void storage_adaptor_destroy_plugin(storage_adaptor_plugin_h plugin); + +/** + * Loads plugins from selected directory + */ +static int storage_adaptor_load_plugins_from_directory(storage_adaptor_h adaptor, + const char *dir_path); + +/** + * Checks if plugin is loaded by selected plugin adaptor + */ +static int storage_adaptor_has_plugin(storage_adaptor_h adaptor, + storage_adaptor_plugin_h plugin); + +/* TDB Temp */ + +#define GET_PLUGIN_PID() getpid() + +int _get_plugin_fd_from_file_uid(long long int file_uid) +{ + return ((int) (0xffff & file_uid)); +} + +long long int _get_file_uid_from_plugin_fd(int plugin_fd) +{ + long long int plugin_section = 0LL; + #ifdef FORK_PLUGIN_ARCHITECTURE + /* TODO it must be changed to another index (not support 64bit) */ + plugin_section = ((long long int) GET_PLUGIN_PID()) << (sizeof(int)*8); + #endif + + return (plugin_section | (long long int)plugin_fd); +} + +/** + * Increases adaptor's plugin references counter + */ +void storage_adaptor_plugin_ref(storage_adaptor_plugin_h); + +/** + * Decreases adaptor's plugin references counter + */ +void storage_adaptor_plugin_unref(storage_adaptor_plugin_h); + + +/* /////////////////////////////////////////////////////////////////////////////// + ///////////// Internal function prototype (for forked plugin) /////////////// + /////////////////////////////////////////////////////////////////////////////// */ + + +/* To be used by adaptor */ +void *_storage_adaptor_plugin_message_collector(void *data); +void __storage_adaptor_transfer_message(const char *msg); +int __storage_adaptor_parse_message_cmd(storage_adaptor_h adaptor, char *msg); +void _storage_adaptor_send_cmd_add_fd(storage_adaptor_h adaptor, int fd); +void _storage_adaptor_send_cmd_stop_listen(storage_adaptor_h adaptor); + +static int storage_adaptor_send_message_to_plugin_sync(storage_adaptor_plugin_h plugin, + plugin_message_h send_message, + plugin_message_h *receive_message); + +/* To be used by adaptor (virtual plugin handle) */ +storage_adaptor_plugin_handle_h __storage_adaptor_create_3rd_party_plugin_handle(const char *plugin_uri); + +storage_error_code_t storage_plugin_send_create_context(storage_adaptor_plugin_context_h *context, + const char *app_id, + const char *app_secret, + const char *access_token, + const char *cid, + const char *uid); + +storage_error_code_t storage_plugin_send_destroy_context(storage_adaptor_plugin_context_h context); + +storage_error_code_t storage_plugin_send_set_server_info(storage_adaptor_plugin_context_h context, + GHashTable *server_info, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_make_directory(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_remove_directory(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_get_list(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_upload_file_sync(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const int publish, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_download_file_sync(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *download_file_local_path, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_delete_file(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_move_directory(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + const char *dest_parent_folder_storage_path, + const char *new_folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_move_file(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *dest_parent_folder_storage_path, + const char *new_file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_set_transfer_state(storage_adaptor_plugin_context_h context, + void *transfer_request_id, + storage_adaptor_transfer_state_e state, + void *request, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_get_transfer_state(storage_adaptor_plugin_context_h context, + void *transfer_request_id, + void *request, + storage_adaptor_transfer_state_e *state, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_get_root_folder_path(storage_adaptor_plugin_context_h context, + void *request, + char **root_folder_path, + storage_adaptor_error_code_h *error, + void *response); + +storage_error_code_t storage_plugin_send_start_upload_task(storage_adaptor_plugin_context_h context, + int fd, + const char *upload_dir, + const char *file_path, + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data); + +storage_error_code_t storage_plugin_send_start_download_task(storage_adaptor_plugin_context_h context, + const char *storage_dir, + const char *file_path, + int fd, + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data); + +storage_error_code_t storage_plugin_send_start_download_thumb_task(storage_adaptor_plugin_context_h context, + const char *storage_dir, + const char *file_path, + int fd, + int thumbnail_size, + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data); + +storage_error_code_t storage_plugin_send_cancel_upload_task(storage_adaptor_plugin_context_h context, + int fd, + storage_adaptor_error_code_h *error); + +storage_error_code_t storage_plugin_send_cancel_download_task(storage_adaptor_plugin_context_h context, + int fd, + storage_adaptor_error_code_h *error); + +storage_error_code_t storage_plugin_send_cancel_download_thumb_task(storage_adaptor_plugin_context_h context, + int fd, + storage_adaptor_error_code_h *error); + +/* To be used by forked plugin */ +void *_storage_plugin_request_collector(void *data); +storage_adaptor_plugin_context_h __storage_plugin_get_context_by_context_id(storage_adaptor_plugin_h plugin, int context_id); +void __storage_plugin_progress_command(storage_adaptor_plugin_h plugin, char *order, char **result); + + +storage_adaptor_file_info_h _get_file_info_from_message_array(plugin_message_array_h message_array, int index); + +int _message_array_set_file_info(plugin_message_array_h message_array, int index, storage_adaptor_file_info_h file_info); + +/** + * Definition of callback function variables for vservice channel (= infra adaptor) (example) + */ +/* private feature */ +storage_adaptor_service_download_file_async_reply_cb _service_adaptor_download_file_async_reply = NULL; +storage_adaptor_service_upload_file_async_reply_cb _service_adaptor_upload_file_async_reply = NULL; +storage_adaptor_service_file_transfer_progress_reply_cb _service_adaptor_file_transfer_progress_reply = NULL; + +/* public feature */ +storage_adaptor_service_download_state_changed_reply_cb _service_adaptor_download_state_changed_reply = NULL; +storage_adaptor_service_upload_state_changed_reply_cb _service_adaptor_upload_state_changed_reply = NULL; +storage_adaptor_service_task_progress_reply_cb _service_adaptor_task_progress_reply = NULL; + +/** + * Gets a message from plugin (callback) when a sms message is received (sample) + */ +/* private feature */ +void storage_adaptor_download_file_async_reply_cb(void *request_id, + char *download_file_local_path, + storage_adaptor_error_code_h error, + void *response) +{ + if (NULL != _service_adaptor_download_file_async_reply) { + _service_adaptor_download_file_async_reply(request_id, + download_file_local_path, error, response); + } +} + +void storage_adaptor_upload_file_async_reply_cb(void *request_id, + storage_adaptor_file_info_h file_info, + storage_adaptor_error_code_h error, + void *response) +{ + if (NULL != _service_adaptor_upload_file_async_reply) { + _service_adaptor_upload_file_async_reply(request_id, + file_info, error, response); + } +} + +void storage_adaptor_file_transfer_progress_reply_cb(void *request_id, + unsigned long long progress_size_byte, + unsigned long long total_size_byte, + storage_adaptor_error_code_h error, + void *response) +{ + if (NULL != _service_adaptor_file_transfer_progress_reply) { + _service_adaptor_file_transfer_progress_reply(request_id, + progress_size_byte, total_size_byte, error, response); + } +} + +/* public feature */ +void storage_adaptor_download_state_changed_reply_cb(int file_descriptor, + storage_adaptor_transfer_state_e state, + storage_adaptor_error_code_h error, + void *user_data) +{ + if ((state == STORAGE_ADAPTOR_TRANSFER_STATE_FINISHED) + || (state == STORAGE_ADAPTOR_TRANSFER_STATE_CANCELED) + || (state == STORAGE_ADAPTOR_TRANSFER_STATE_FAILED)) { + close(file_descriptor); + } + + if (NULL != _service_adaptor_download_state_changed_reply) { + long long int file_uid = _get_file_uid_from_plugin_fd(file_descriptor); + _service_adaptor_download_state_changed_reply(file_uid, + state, error, user_data); + } +} + +void storage_adaptor_upload_state_changed_reply_cb(int file_descriptor, + storage_adaptor_transfer_state_e state, + storage_adaptor_file_info_h file_info, + storage_adaptor_error_code_h error, + void *user_data) +{ + if ((state == STORAGE_ADAPTOR_TRANSFER_STATE_FINISHED) + || (state == STORAGE_ADAPTOR_TRANSFER_STATE_CANCELED) + || (state == STORAGE_ADAPTOR_TRANSFER_STATE_FAILED)) { + close(file_descriptor); + } + + if (NULL != _service_adaptor_upload_state_changed_reply) { + long long int file_uid = _get_file_uid_from_plugin_fd(file_descriptor); + _service_adaptor_upload_state_changed_reply(file_uid, + state, file_info, error, user_data); + } +} + +void storage_adaptor_task_progress_reply_cb(int file_descriptor, + unsigned long long progress_size_byte, + unsigned long long total_size_byte, + storage_adaptor_error_code_h error, + void *user_data) +{ + if (NULL != _service_adaptor_task_progress_reply) { + long long int file_uid = _get_file_uid_from_plugin_fd(file_descriptor); + _service_adaptor_task_progress_reply(file_uid, + progress_size_byte, total_size_byte); + } +} + +/* //------------------------------------------------------------------------ + // Functions implementations + //------------------------------------------------------------------------ */ + +/* ////////////////////////////////////////////////////////// + // Adaptor Defined Plugin Function + ////////////////////////////////////////////////////////// */ + +storage_error_code_t storage_plugin_open_file(storage_adaptor_plugin_context_h context, + const char *file_path, + storage_adaptor_file_access_mode_e mode, + int *file_descriptor, + storage_adaptor_error_code_h *error) +{ + storage_error_code_t ret = STORAGE_ADAPTOR_ERROR_NONE; + + if ((NULL == file_descriptor) || (NULL == file_path)) { + if (NULL != error) { + *error = storage_adaptor_create_error_code((int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + "Invalid parameter"); + } + ret = STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + } else { + int fd; + if (STORAGE_ADAPTOR_FILE_ACCESS_READ == mode) { + fd = open(file_path, mode); + } else if (STORAGE_ADAPTOR_FILE_ACCESS_WRITE == mode) { + fd = open(file_path, mode, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH); + } else { + if (NULL != error) { + *error = storage_adaptor_create_error_code((int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + "Invalid parameter (file mode)"); + } + ret = STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + return ret; + } + + if (fd < 0) { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + int64_t error_code; + if (EEXIST == errno) { + error_code = (int64_t) STORAGE_PLUGIN_ERROR_FILE_AREADY_EXIST; + } else if (EACCES == errno) { + error_code = (int64_t) STORAGE_PLUGIN_ERROR_FILE_ACCESS_DENIED; + } else { + error_code = (int64_t) STORAGE_PLUGIN_ERROR_FILE_OPEN_FAILED; + } + if (NULL != error) { + *error = storage_adaptor_create_error_code(error_code, + "File open failed"); + } + } else { + *file_descriptor = fd; + } + } + return ret; +} + +storage_error_code_t storage_plugin_close_file(storage_adaptor_plugin_context_h context, + int file_descriptor, + storage_adaptor_error_code_h *error) +{ + storage_error_code_t ret = STORAGE_ADAPTOR_ERROR_NONE; + + int r = close(file_descriptor); + if (r) { + storage_adaptor_debug("close ret : %d", r); + } + + return ret; +} + + +/* ////////////////////////////////////////////////////// + // Mandatory: External adaptor management function + ////////////////////////////////////////////////////// */ +storage_adaptor_h storage_adaptor_create(const char *plugins_dir) +{ + if (NULL == plugins_dir) { + storage_adaptor_error("Invalid argument""(plugins_dir: %p", plugins_dir); + return NULL; + } + + storage_adaptor_h storage_adaptor = (storage_adaptor_h) malloc(sizeof(storage_adaptor_t)); + + if (NULL == storage_adaptor) { + storage_adaptor_error("Critical : Memory allocation failed"); + return NULL; + } + + /* for forked plugin */ + if (pipe(storage_adaptor->rd_cmd) == -1) { + free(storage_adaptor); + return NULL; + } + g_mutex_init(&storage_adaptor->rd_mutex); + storage_adaptor->rd_list = NULL; + + storage_adaptor->started = 0; + storage_adaptor->plugins_dir = strdup(plugins_dir); + + g_mutex_init(&storage_adaptor->storage_adaptor_mutex); + g_mutex_init(&storage_adaptor->plugins_mutex); + g_mutex_init(&storage_adaptor->adaptor_listeners_mutex); + + g_mutex_lock(&storage_adaptor->adaptor_listeners_mutex); + storage_adaptor->adaptor_listeners = NULL; + g_mutex_unlock(&storage_adaptor->adaptor_listeners_mutex); + + g_mutex_lock(&storage_adaptor->plugins_mutex); + storage_adaptor->plugins = NULL; + g_mutex_unlock(&storage_adaptor->plugins_mutex); + + #ifndef FORK_PLUGIN_ARCHITECTURE + g_file_uid_list = g_hash_table_new_full(g_int_hash, g_int_equal, NULL, free); + #endif + + return storage_adaptor; +} + +void storage_adaptor_destroy(storage_adaptor_h adaptor) +{ + if (NULL == adaptor) { + storage_adaptor_error("Invalid argument""(adaptor: %p)", adaptor); + return ; + } + + g_mutex_lock(&adaptor->storage_adaptor_mutex); + if (0 != adaptor->started) { + storage_adaptor_error("Storage adaptor is running. Forcing stop before destroy"); + storage_adaptor_stop(adaptor); + } + + g_mutex_lock(&adaptor->plugins_mutex); + if (NULL != adaptor->plugins) { + g_list_free_full(adaptor->plugins, (GDestroyNotify) storage_adaptor_plugin_unref); + adaptor->plugins = NULL; + } + g_mutex_unlock(&adaptor->plugins_mutex); + + g_mutex_lock(&adaptor->adaptor_listeners_mutex); + if (NULL != adaptor->adaptor_listeners) { + g_list_free(adaptor->adaptor_listeners); + adaptor->adaptor_listeners = NULL; + } + g_mutex_unlock(&adaptor->adaptor_listeners_mutex); + + _service_adaptor_download_file_async_reply = NULL; + _service_adaptor_upload_file_async_reply = NULL; + _service_adaptor_file_transfer_progress_reply = NULL; + _service_adaptor_download_state_changed_reply = NULL; + _service_adaptor_upload_state_changed_reply = NULL; + _service_adaptor_task_progress_reply = NULL; + + free(adaptor->plugins_dir); + adaptor->plugins_dir = NULL; + + g_mutex_unlock(&adaptor->storage_adaptor_mutex); + + #ifndef FORK_PLUGIN_ARCHITECTURE + g_hash_table_destroy(g_file_uid_list); + #endif + + /* For forked plugin */ + g_list_free(adaptor->rd_list); + close(adaptor->rd_cmd[0]); + close(adaptor->rd_cmd[1]); + + free(adaptor); +} + +int storage_adaptor_start(storage_adaptor_h adaptor) +{ + storage_adaptor_debug("Starting storage adaptor"); + if (NULL == adaptor) { + storage_adaptor_error("Invalid argument""(adaptor: %p)", adaptor); + return STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + } + + g_mutex_lock(&adaptor->storage_adaptor_mutex); + int result = STORAGE_ADAPTOR_ERROR_NONE; + if (0 != adaptor->started) { + storage_adaptor_error("Storage adaptor is already started"); + result = STORAGE_ADAPTOR_ERROR_START; + } else { + adaptor->started = 1; + + pthread_t pid; + if (pthread_create(&pid, NULL, _storage_adaptor_plugin_message_collector, (void *)adaptor)) { + adaptor->started = 0; + storage_adaptor_error("Could not create 3rd party plugin listener"); + result = STORAGE_ADAPTOR_ERROR_NOT_FOUND; + } else if (STORAGE_ADAPTOR_ERROR_NONE != (result = storage_adaptor_load_plugins_from_directory(adaptor, adaptor->plugins_dir))) { + _storage_adaptor_send_cmd_stop_listen(adaptor); + adaptor->started = 0; + storage_adaptor_error("Could not load plugins from directory"); + result = STORAGE_ADAPTOR_ERROR_NOT_FOUND; + } else { + adaptor->plugin_listener = pid; + storage_adaptor_info("Storage adaptor started successfully"); + } + } + g_mutex_unlock(&adaptor->storage_adaptor_mutex); + + return result; +} + +int storage_adaptor_stop(storage_adaptor_h adaptor) +{ + if (NULL == adaptor) { + storage_adaptor_error("Invalid argument""(adaptor: %p)", adaptor); + return STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + } + + g_mutex_lock(&adaptor->storage_adaptor_mutex); + + /* For forked plugin */ + storage_adaptor_debug("stop plugin listener"); + _storage_adaptor_send_cmd_stop_listen(adaptor); + pthread_join(adaptor->plugin_listener, NULL); + + int result = STORAGE_ADAPTOR_ERROR_NONE; + if (0 == adaptor->started) { + result = STORAGE_ADAPTOR_ERROR_START; + } else { + if (NULL != adaptor->plugins) { + g_mutex_lock(&adaptor->plugins_mutex); + g_list_free_full(adaptor->plugins, (GDestroyNotify) storage_adaptor_plugin_unref); + adaptor->plugins = NULL; + g_mutex_unlock(&adaptor->plugins_mutex); + } + adaptor->started = 0; + storage_adaptor_debug("Storage adaptor stopped"); + } + + g_mutex_unlock(&adaptor->storage_adaptor_mutex); + return result; +} + +int storage_adaptor_register_listener(storage_adaptor_h adaptor, + storage_adaptor_listener_h listener) +{ + if ((NULL == adaptor) || (NULL == listener)) { + storage_adaptor_error("Invalid argument""(adaptor: %p, listener: %p)", adaptor, listener); + return STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + } + + g_mutex_lock(&adaptor->adaptor_listeners_mutex); + + adaptor->adaptor_listeners = g_list_append(adaptor->adaptor_listeners, listener); + + g_mutex_unlock(&adaptor->adaptor_listeners_mutex); + + _service_adaptor_download_file_async_reply = + (storage_adaptor_service_download_file_async_reply_cb) listener->download_file_async_reply; + _service_adaptor_upload_file_async_reply = + (storage_adaptor_service_upload_file_async_reply_cb) listener->upload_file_async_reply; + _service_adaptor_file_transfer_progress_reply = + (storage_adaptor_service_file_transfer_progress_reply_cb) listener->file_transfer_progress_reply; + _service_adaptor_download_state_changed_reply = + (storage_adaptor_service_download_state_changed_reply_cb) listener->download_state_changed_reply; + _service_adaptor_upload_state_changed_reply = + (storage_adaptor_service_upload_state_changed_reply_cb) listener->upload_state_changed_reply; + _service_adaptor_task_progress_reply = + (storage_adaptor_service_task_progress_reply_cb) listener->task_progress_reply; + + return STORAGE_ADAPTOR_ERROR_NONE; +} + +int storage_adaptor_unregister_listener(storage_adaptor_h adaptor, + storage_adaptor_listener_h listener) +{ + if ((NULL == adaptor) || (NULL == listener)) { + storage_adaptor_error("Invalid argument""(adaptor: %p, listener: %p)", adaptor, listener); + return STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + } + + g_mutex_lock(&adaptor->adaptor_listeners_mutex); + + if (NULL == g_list_find(adaptor->adaptor_listeners, listener)) { + g_mutex_unlock(&adaptor->adaptor_listeners_mutex); + storage_adaptor_error("Could not find listener"); + return STORAGE_ADAPTOR_ERROR_NOT_FOUND; + } + + adaptor->adaptor_listeners = g_list_remove(adaptor->adaptor_listeners, listener); + + g_mutex_unlock(&adaptor->adaptor_listeners_mutex); + + _service_adaptor_download_file_async_reply = NULL; + _service_adaptor_upload_file_async_reply = NULL; + _service_adaptor_file_transfer_progress_reply = NULL; + _service_adaptor_download_state_changed_reply = NULL; + _service_adaptor_upload_state_changed_reply = NULL; + _service_adaptor_task_progress_reply = NULL; + + return STORAGE_ADAPTOR_ERROR_NONE; +} + +/* ///////////////////////////////////////////////////////////// + // Plugin create / destroy / ref. count / get plugin name + ///////////////////////////////////////////////////////////// */ +static storage_adaptor_plugin_h storage_adaptor_create_plugin(const char *plugin_path) +{ + if (NULL == plugin_path) { + storage_adaptor_error("Invalid argument (plugin_path is null)"); + return NULL; + } + + void *dl_handle = dlopen(plugin_path, RTLD_LAZY); + if (NULL == dl_handle) { + storage_adaptor_error("Could not load plugin %s: %s", plugin_path, dlerror()); + return NULL; + } + + storage_adaptor_plugin_handle_h (*get_adaptee_handle)(void) = NULL; + + get_adaptee_handle = (storage_adaptor_plugin_handle_h (*)(void)) (dlsym(dl_handle, "create_plugin_handle")); + if (NULL == get_adaptee_handle) { + dlclose(dl_handle); + storage_adaptor_error("Could not get function pointer to create_plugin_handle"); + return NULL; + } + + plugin_req_enter(); + storage_adaptor_plugin_handle_h handle = get_adaptee_handle(); + plugin_req_exit_void(); + + if (NULL == handle) { + dlclose(dl_handle); + storage_adaptor_error("Could not get adaptee handle"); + return NULL; + } + /* TBD not fixed */ + handle->open_file = storage_plugin_open_file; + handle->close_file = storage_plugin_close_file; + + storage_adaptor_plugin_h plugin = (storage_adaptor_plugin_h) calloc(1, sizeof(storage_adaptor_plugin_t)); + if (NULL == plugin) { + dlclose(dl_handle); + storage_adaptor_error("Could not create plugin object"); + return NULL; + } + + storage_adaptor_plugin_listener_h listener = + (storage_adaptor_plugin_listener_h) calloc(1, sizeof(storage_adaptor_plugin_listener_t)); + + if (NULL == listener) { + free(plugin); + dlclose(dl_handle); + storage_adaptor_error("Could not create listener object"); + return NULL; + } + + plugin->path = g_strdup(plugin_path); + plugin->handle = handle; + plugin->dl_handle = dl_handle; + plugin->ref_counter = 0; + + plugin->type = PLUGIN_TYPE_INHOUSE; + + g_mutex_init(&plugin->ref_counter_mutex); + g_mutex_init(&plugin->plugin_listener_mutex); + g_mutex_init(&plugin->contexts_mutex); + plugin->contexts = NULL; + + listener->storage_adaptor_download_file_async_reply = storage_adaptor_download_file_async_reply_cb; + listener->storage_adaptor_upload_file_async_reply = storage_adaptor_upload_file_async_reply_cb; + listener->storage_adaptor_file_transfer_progress_reply = storage_adaptor_file_transfer_progress_reply_cb; + listener->storage_adaptor_download_state_changed_reply = storage_adaptor_download_state_changed_reply_cb; + listener->storage_adaptor_upload_state_changed_reply = storage_adaptor_upload_state_changed_reply_cb; + listener->storage_adaptor_task_progress_reply = storage_adaptor_task_progress_reply_cb; + + + plugin_req_enter(); + plugin->handle->set_listener(listener); + plugin_req_exit_void(); + + g_mutex_lock(&plugin->plugin_listener_mutex); + plugin->plugin_listener = listener; + g_mutex_unlock(&plugin->plugin_listener_mutex); + + return plugin; +} + +static void storage_adaptor_destroy_plugin(storage_adaptor_plugin_h plugin) +{ + if (NULL == plugin) { + storage_adaptor_error("Invalid argument""(plugin: %p)", plugin); + return; + } + + if (NULL != plugin->handle) { + plugin->handle->destroy_handle(plugin->handle); + + g_mutex_lock(&plugin->plugin_listener_mutex); + + plugin_req_enter(); + plugin->handle->unset_listener(); + plugin_req_exit_void(); + + g_mutex_unlock(&plugin->plugin_listener_mutex); + + plugin->handle = NULL; + } + + if (NULL != plugin->dl_handle) { + dlclose(plugin->dl_handle); + plugin->dl_handle = NULL; + } + + free(plugin->path); + plugin->path = NULL; + + free(plugin); +} + +static int storage_adaptor_load_plugins_from_directory(storage_adaptor_h adaptor, + const char *dir_path) +{ + char *plugin_path = NULL; + DIR *dir = NULL; + struct dirent dir_entry, *result = NULL; + + storage_adaptor_debug("Starting load plugins from directory"); + + if ((NULL == adaptor) || (NULL == dir_path)) { + storage_adaptor_error("Invalid argument""(adaptor: %p, dir_path: %p)", adaptor, dir_path); + return STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + } + + dir = opendir(dir_path); + if (NULL == dir) { + storage_adaptor_error("Could not open dir path (%s)", dir_path); + return STORAGE_ADAPTOR_ERROR_NOT_FOUND; + } + + int ret = STORAGE_ADAPTOR_ERROR_NONE; + while (0 == (readdir_r(dir, &dir_entry, &result))) { + + if (NULL == result) { + storage_adaptor_error("Could not open directory %s", plugin_path); + break; + } + + if (dir_entry.d_type & DT_DIR) { + continue; + } + + plugin_path = g_strconcat(dir_path, "/", dir_entry.d_name, NULL); + storage_adaptor_plugin_h plugin = storage_adaptor_create_plugin(plugin_path); + + if (NULL != plugin) { + storage_adaptor_debug("Loaded plugin: %s", plugin_path); + plugin->adaptor = adaptor; + storage_adaptor_plugin_ref(plugin); + g_mutex_lock(&adaptor->plugins_mutex); + adaptor->plugins = g_list_append(adaptor->plugins, plugin); + g_mutex_unlock(&adaptor->plugins_mutex); + } else { + storage_adaptor_error("Could not load plugin %s", plugin_path); + } + + g_free(plugin_path); + plugin_path = NULL; + } + + storage_adaptor_debug("End load plugins from directory"); + closedir(dir); + return ret; +} + +static int storage_adaptor_has_plugin(storage_adaptor_h adaptor, + storage_adaptor_plugin_h plugin) +{ + if ((NULL == adaptor) || (NULL == plugin)) { + storage_adaptor_error("Invalid argument""(adaptor: %p, plugin: %p)", adaptor, plugin); + return 0; + } + + int result = 0; + + g_mutex_lock(&adaptor->plugins_mutex); + if (NULL != g_list_find(adaptor->plugins, plugin)) { + result = 1; + } + g_mutex_unlock(&adaptor->plugins_mutex); + + return result; +} + +void storage_adaptor_plugin_ref(storage_adaptor_plugin_h plugin) +{ + if (NULL == plugin) { + storage_adaptor_error("Invalid argument""(plugin: %p)", plugin); + return; + } + + g_mutex_lock(&plugin->ref_counter_mutex); + plugin->ref_counter = plugin->ref_counter + 1; + if (NULL != plugin->handle) { + storage_adaptor_info("plugin name : %s, ref_counter: %d", + plugin->handle->plugin_uri, plugin->ref_counter); + } else { + storage_adaptor_info("ref_counter: %d", plugin->ref_counter); + } + g_mutex_unlock(&plugin->ref_counter_mutex); +} + +void storage_adaptor_plugin_unref(storage_adaptor_plugin_h plugin) +{ + if (NULL == plugin) { + storage_adaptor_error("Invalid argument""(plugin: %p)", plugin); + return ; + } + + int should_destroy = 0; + + g_mutex_lock(&plugin->ref_counter_mutex); + plugin->ref_counter = plugin->ref_counter - 1; + if (NULL != plugin->handle) { + storage_adaptor_info("plugin name : %s, ref_counter: %d", + plugin->handle->plugin_uri, plugin->ref_counter); + } else { + storage_adaptor_info("ref_counter: %d", plugin->ref_counter); + } + if (0 >= plugin->ref_counter) { + should_destroy = 1; + } + g_mutex_unlock(&plugin->ref_counter_mutex); + + if (should_destroy) { + storage_adaptor_debug("Plugin is being destroyed"); + storage_adaptor_destroy_plugin(plugin); + } +} + +/* For 3rd party plugin packages */ +int storage_adaptor_load_plugin_from_package(storage_adaptor_h adaptor, + const char *package_id, + const char *plugin_path) +{ + int adaptor_fd[2]; + int plugin_fd[2]; + + if (pipe(adaptor_fd) == -1) { + storage_adaptor_debug("pipe creation error, can not load plugin package"); + } else if (pipe(plugin_fd) == -1) { + close(adaptor_fd[0]); + close(adaptor_fd[1]); + storage_adaptor_debug("pipe creation error[2], can not load plugin package"); + } else { + g_process_identity = fork(); + if (0 == g_process_identity) { /* child */ + storage_adaptor_debug_func("[CHILD PROCESS] forked success (PID : %d, id : %d)", (int)getpid()); +/* storage_adaptor_info("set uid : %d", setuid(5000)); */ + /* TODO remove temp code */ +/* change_smack_rule("org.tizen.tui4"); */ +/* smack_set_label_for_self(package_id); */ + + storage_adaptor_plugin_h plugin = NULL; + plugin = storage_adaptor_create_plugin(plugin_path); + if (NULL == plugin) { + storage_adaptor_error("[CHILD PROCESS] Load plugin failed"); + exit(1); + } + g_child_plugin = plugin; + plugin->rd = plugin_fd[0]; + close(plugin_fd[1]); + plugin->wd = adaptor_fd[1]; + close(adaptor_fd[0]); + void *temp = _storage_plugin_request_collector((void *)plugin); + storage_adaptor_debug_func("[CHILD PROCESS] exit %p", temp); + exit(0); + } else if (0 < g_process_identity) { /* parent */ + storage_adaptor_debug_func("[PARENT PROCESS] forked success (PID : %d)", (int)getpid()); + storage_adaptor_plugin_h _plugin = (storage_adaptor_plugin_h) calloc(1, sizeof(storage_adaptor_plugin_t)); + if (NULL == _plugin) { + storage_adaptor_error("[PARENT PROCESS] memory allocation failed"); + exit(1); + } + + _plugin->ref_counter = 0; + g_mutex_init(&_plugin->ref_counter_mutex); + g_mutex_init(&_plugin->message_mutex); + + _plugin->handle = __storage_adaptor_create_3rd_party_plugin_handle(package_id); + + _plugin->type = PLUGIN_TYPE_3RD_PARTY; + _plugin->pid = g_process_identity; + _plugin->rd = adaptor_fd[0]; + close(adaptor_fd[1]); + _plugin->wd = plugin_fd[1]; + close(plugin_fd[0]); + + _storage_adaptor_send_cmd_add_fd(adaptor, _plugin->rd); + + _plugin->adaptor = adaptor; + storage_adaptor_plugin_ref(_plugin); + g_mutex_lock(&adaptor->plugins_mutex); + adaptor->plugins = g_list_append(adaptor->plugins, _plugin); + g_mutex_unlock(&adaptor->plugins_mutex); + } else { + close(adaptor_fd[0]); + close(adaptor_fd[1]); + close(plugin_fd[0]); + close(plugin_fd[1]); + storage_adaptor_debug("fork error, can not load plugin package"); + } + } + + return 0; +} + +/* ////////////////////////////////////////////////////// + // Plugin context create / destroy + ////////////////////////////////////////////////////// */ +storage_adaptor_plugin_context_h storage_adaptor_create_plugin_context(storage_adaptor_plugin_h plugin, + const char *app_id, + const char *app_secret, + const char *access_token, + const char *cid, + const char *uid, + const char *service_name) +{ + storage_adaptor_debug("Starting storage_adaptor_create_plugin_context"); + + if (NULL == plugin) { + storage_adaptor_error("Invalid argument""(plugin: %p)", plugin); + return NULL; + } + + if (NULL != plugin->handle) { + storage_adaptor_plugin_context_h plugin_context = NULL; + + if (plugin->type == PLUGIN_TYPE_3RD_PARTY) { + plugin_context = (storage_adaptor_plugin_context_h) calloc(1, sizeof(storage_adaptor_plugin_context_t)); + if (NULL == plugin_context) { + return NULL; + } + plugin_context->plugin_handle = plugin; + } + + plugin_req_enter(); + plugin->handle->create_context(&plugin_context, SAFE_ADD_STRING(app_id), SAFE_ADD_STRING(app_secret), + SAFE_ADD_STRING(access_token), SAFE_ADD_STRING(cid), SAFE_ADD_STRING(uid)); + plugin_req_exit_void(); + + if (NULL == plugin_context) { + storage_adaptor_error("Create context failed"); + return NULL; + } + + /* For forked plugin */ + g_mutex_lock(&plugin->contexts_mutex); + plugin->contexts = g_list_append(plugin->contexts, (gpointer)plugin_context); + g_mutex_unlock(&plugin->contexts_mutex); + + plugin_context->plugin_uri = strdup(plugin->handle->plugin_uri); + plugin_context->service_name = strdup(service_name ? service_name : ""); + return plugin_context; + } else { + storage_adaptor_error("Plugin handle is null"); + } + + storage_adaptor_debug("End storage_adaptor_create_plugin_context"); + return NULL; +} + +void storage_adaptor_destroy_plugin_context(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h plugin_context) +{ + if ((NULL == plugin) || (NULL == plugin_context)) { + storage_adaptor_error("Invalid argument""(plugin: %p, plugin_context: %p)", plugin, plugin_context); + return; + } + + free(plugin_context->plugin_uri); + plugin_context->plugin_uri = NULL; +/* free(plugin_context->service_name); */ +/* plugin_context->service_name = NULL; */ + + if (NULL != plugin->handle) { + plugin_req_enter(); + plugin->handle->destroy_context(plugin_context); + plugin_req_exit_void(); + } else { + storage_adaptor_error("Plugin handle is null"); + } +} + +/* ////////////////////////////////////////////////////// + // Get plugin by plugin name + ////////////////////////////////////////////////////// */ +storage_adaptor_plugin_h storage_adaptor_get_plugin_by_name(storage_adaptor_h adaptor, + const char *plugin_uri) +{ + storage_adaptor_debug("Starting storage_adaptor_get_plugin_by_name"); + + if ((NULL == adaptor) || (NULL == plugin_uri)) { + storage_adaptor_error("Invalid argument""(adaptor: %p, plugin_uri: %p)", adaptor, plugin_uri); + return NULL; + } + + storage_adaptor_plugin_h plugin = NULL; + g_mutex_lock(&adaptor->plugins_mutex); + int count = g_list_length(adaptor->plugins); + int i = 0; + for (i = 0; i < count; i++) { + storage_adaptor_plugin_h temp_plugin = g_list_nth_data(adaptor->plugins, i); + if (NULL != temp_plugin) { + if (0 == strcmp(temp_plugin->handle->plugin_uri, plugin_uri)) { + storage_adaptor_plugin_ref(temp_plugin); + plugin = temp_plugin; + g_mutex_unlock(&adaptor->plugins_mutex); + return plugin; + } + } + } + g_mutex_unlock(&adaptor->plugins_mutex); + + return plugin; +} + +/* ////////////////////////////////////////////////////// + // Plugin load / unload / get plugin list + ////////////////////////////////////////////////////// */ +int storage_adaptor_load_plugin(storage_adaptor_h adaptor, + const char *plugin_path) +{ + if ((NULL == adaptor) || (NULL == plugin_path)) { + storage_adaptor_error("Invalid argument""(adaptor: %p, plugin_path: %p)", adaptor, plugin_path); + return STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + } + + if (0 == adaptor->started) { + storage_adaptor_error("Storage adaptor is not started"); + return STORAGE_ADAPTOR_ERROR_START; + } + + storage_adaptor_plugin_h plugin = storage_adaptor_create_plugin(plugin_path); + if (NULL == plugin) { + storage_adaptor_error("Could not load plugin %s", plugin_path); + return STORAGE_ADAPTOR_ERROR_CREATE; + } + + plugin->adaptor = adaptor; + storage_adaptor_plugin_ref(plugin); + + g_mutex_lock(&adaptor->plugins_mutex); + adaptor->plugins = g_list_append(adaptor->plugins, plugin); + g_mutex_unlock(&adaptor->plugins_mutex); + + return STORAGE_ADAPTOR_ERROR_NONE; +} + +int storage_adaptor_unload_plugin(storage_adaptor_h adaptor, + storage_adaptor_plugin_h plugin) +{ + if ((NULL == adaptor) || (NULL == plugin)) { + storage_adaptor_error("Invalid argument""(adaptor: %p, plugin: %p)", adaptor, plugin); + return STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + } + + if (0 == adaptor->started) { + storage_adaptor_error("Storage adaptor is not started"); + return STORAGE_ADAPTOR_ERROR_START; + } + + if (!storage_adaptor_has_plugin(adaptor, plugin)) { + storage_adaptor_error("Storage adaptor has no plugin"); + return STORAGE_ADAPTOR_ERROR_NOT_FOUND; + } + + plugin->adaptor = NULL; + + g_mutex_lock(&adaptor->plugins_mutex); + adaptor->plugins = g_list_remove(adaptor->plugins, plugin); + g_mutex_unlock(&adaptor->plugins_mutex); + + storage_adaptor_plugin_unref(plugin); + + return STORAGE_ADAPTOR_ERROR_NONE; +} + +GList *storage_adaptor_get_plugins(storage_adaptor_h adaptor) +{ + if (NULL == adaptor) { + storage_adaptor_error("Invalid argument""(adaptor: %p)", adaptor); + return NULL; + } + + GList *plugins = NULL; + + g_mutex_lock(&adaptor->plugins_mutex); + int plugins_count = g_list_length(adaptor->plugins); + int i = 0; + for (i = 0; i < plugins_count; i++) { + storage_adaptor_plugin_h plugin = g_list_nth_data(adaptor->plugins, i); + if (NULL != plugin) { + storage_adaptor_plugin_ref(plugin); + plugins = g_list_append(plugins, plugin); + } + } + g_mutex_unlock(&adaptor->plugins_mutex); + + return plugins; +} + +/* //////////////////////////////////////////////////////////// + // Adaptor Etc Functions + //////////////////////////////////////////////////////////// */ + +/* Get plugin name by plugin */ +void storage_adaptor_get_plugin_uri(storage_adaptor_plugin_h plugin, + char **plugin_uri) +{ + if ((NULL == plugin) || (NULL == plugin_uri)) { + storage_adaptor_error("Invalid argument""(plugin: %p)", plugin); + return; + } + if ((NULL != plugin->handle) && (NULL != plugin->handle->plugin_uri)) { + *plugin_uri = strdup(plugin->handle->plugin_uri); + } +} + +/** + * Refresh access token + */ +EXPORT_API +storage_error_code_t storage_adaptor_refresh_access_token(storage_adaptor_plugin_context_h context, + const char *new_access_token) +{ + if ((NULL == context) || (NULL == new_access_token) || (0 >= strlen(new_access_token))) { + return STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + } + storage_adaptor_debug_secure("New access token : %s", new_access_token); + + free(context->access_token); + context->access_token = NULL; + context->access_token = strdup(new_access_token); + + return STORAGE_ADAPTOR_ERROR_NONE; +} + + +EXPORT_API +storage_error_code_t storage_adaptor_refresh_uid(storage_adaptor_plugin_context_h context, + const char *new_uid) +{ + if ((NULL == context) || (NULL == new_uid) || (0 >= strlen(new_uid))) { + return STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT; + } + storage_adaptor_debug_secure("New uid : %s", new_uid); + + free(context->uid); + context->uid = NULL; + context->uid = strdup(new_uid); + + return STORAGE_ADAPTOR_ERROR_NONE; +} + + + +storage_adaptor_error_code_h storage_adaptor_create_error_code(const int64_t code, + const char *msg) +{ + if (NULL == msg) { + return NULL; + } + storage_adaptor_error_code_h error_code = + (storage_adaptor_error_code_h) calloc(1, sizeof(storage_adaptor_error_code_t)); + if (NULL != error_code) { + error_code->code = code; + error_code->msg = strdup(msg); + } + + return error_code; +} + +void storage_adaptor_destroy_error_code(storage_adaptor_error_code_h *error_code) +{ + if ((NULL != error_code) && (NULL != (*error_code))) { + free((*error_code)->msg); + (*error_code)->msg = NULL; + free(*error_code); + *error_code = NULL; + } + +} + +storage_adaptor_file_info_h storage_adaptor_create_file_info(void) +{ + storage_adaptor_file_info_h _file_info = NULL; + _file_info = (storage_adaptor_file_info_h) calloc(1, sizeof(storage_adaptor_file_info_t)); + + storage_adaptor_media_meta_s *_media_meta = NULL; + _media_meta = (storage_adaptor_media_meta_s *) calloc(1, sizeof(storage_adaptor_media_meta_s)); + + storage_adaptor_cloud_meta_s *_cloud_meta = NULL; + _cloud_meta = (storage_adaptor_cloud_meta_s *) calloc(1, sizeof(storage_adaptor_cloud_meta_s)); + + if ((NULL == _file_info) || (NULL == _media_meta) || (NULL == _cloud_meta)) { + free(_file_info); + free(_media_meta); + free(_cloud_meta); + + return NULL; + } + + _media_meta->mime_type = NULL; + _media_meta->title = NULL; + _media_meta->album = NULL; + _media_meta->artist = NULL; + _media_meta->genere = NULL; + _media_meta->recorded_date = NULL; + _media_meta->width = -1; + _media_meta->height = -1; + _media_meta->duration = -1; + _media_meta->copyright = NULL; + _media_meta->track_num = NULL; + _media_meta->description = NULL; + _media_meta->composer = NULL; + _media_meta->year = NULL; + _media_meta->bitrate = -1; + _media_meta->samplerate = -1; + _media_meta->channel = -1; + _media_meta->extra_media_meta = NULL; + + _cloud_meta->service_name = NULL; + _cloud_meta->usage_byte = 0ULL; + _cloud_meta->quota_byte = 0ULL; + _cloud_meta->extra_cloud_meta = NULL; + + _file_info->plugin_uri = NULL; + _file_info->object_id = NULL; + _file_info->storage_path = NULL; + _file_info->file_size = 0ULL; + + /* private only!! */ + _file_info->revision = -1; + _file_info->timestamp = 0ULL; + _file_info->type = NULL; + _file_info->deleted = -1; + _file_info->expired_time = 0ULL; + _file_info->download_count = -0U; + _file_info->max_download_count = -0U; + _file_info->file_info_index = -1; + _file_info->tag = NULL; + _file_info->file_share_token = NULL; + + /* public */ + _file_info->created_time = 0ULL; + _file_info->modified_time = 0ULL; + _file_info->file_info_index = -1; + _file_info->content_type = STORAGE_ADAPTOR_CONTENT_TYPE_DEFAULT; + _file_info->media_meta = _media_meta; + _file_info->cloud_meta = _cloud_meta; + _file_info->extra_file_info = NULL; + + return _file_info; +} + +int storage_adaptor_destroy_file_info(storage_adaptor_file_info_h *file_info) +{ + if (NULL == file_info) { + return 1; + } + + if (NULL == *file_info) { + return 0; + } + storage_adaptor_file_info_h _file_info = *file_info; + + free(_file_info->plugin_uri); + free(_file_info->object_id); + free(_file_info->storage_path); + free(_file_info->extra_file_info); + free(_file_info->type); + free(_file_info->tag); + + storage_adaptor_media_meta_s *_media_meta = _file_info->media_meta; + + if (NULL != _media_meta) { + free(_media_meta->mime_type); + free(_media_meta->title); + free(_media_meta->album); + free(_media_meta->artist); + free(_media_meta->genere); + free(_media_meta->recorded_date); + free(_media_meta->copyright); + free(_media_meta->track_num); + free(_media_meta->description); + free(_media_meta->composer); + free(_media_meta->year); + free(_media_meta->extra_media_meta); + } + + storage_adaptor_cloud_meta_s *_cloud_meta = _file_info->cloud_meta; + + if (NULL != _cloud_meta) { + free(_cloud_meta->service_name); + free(_cloud_meta->extra_cloud_meta); + } + + + if (NULL != _file_info->file_share_token) { + free(_file_info->file_share_token->public_token); + _file_info->file_share_token->public_token = NULL; + + free(_file_info->file_share_token->auth_code); + _file_info->file_share_token->auth_code = NULL; + + free(_file_info->file_share_token); + } + + _file_info->plugin_uri = NULL; + _file_info->object_id = NULL; + _file_info->storage_path = NULL; + _file_info->revision = -1; + _file_info->timestamp = 0ULL; + _file_info->type = NULL; + _file_info->file_size = 0ULL; + _file_info->deleted = -1; + _file_info->expired_time = 0ULL; + _file_info->download_count = 0U; + _file_info->max_download_count = 0U; + _file_info->file_info_index = -1; + _file_info->tag = NULL; + _file_info->file_share_token = NULL; + + + free((*file_info)->media_meta); + free((*file_info)->cloud_meta); + free(*file_info); + *file_info = NULL; + + return STORAGE_ADAPTOR_ERROR_NONE; +} + +void __assign_error_code(storage_adaptor_error_code_h *error, const int64_t code, const char *msg) +{ + if (NULL != error) { + *error = storage_adaptor_create_error_code(code, msg); + } +} + +/* //////////////////////////////////////////////////////////// + // Adaptor Plugin call Functions + //////////////////////////////////////////////////////////// */ + + + +/* ////////////////////// Public feature //////////////////////////// */ + +EXPORT_API +storage_error_code_t storage_adaptor_open_file(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *file_path, + storage_adaptor_file_access_mode_e mode, + long long int *file_uid, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, file_uid, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (file_uid)")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->open_file, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (open file)")); + + int plugin_fd = 0; + storage_error_code_t ret = plugin->handle->open_file(context, file_path, mode, &plugin_fd, error); + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + *file_uid = _get_file_uid_from_plugin_fd(plugin_fd); + + #ifndef FORK_PLUGIN_ARCHITECTURE + long long int *buf = (long long int *) calloc(1, sizeof(long long int)); + if (NULL != buf) { + *buf = *file_uid; + g_hash_table_insert(g_file_uid_list, (void *)&plugin_fd, (void *)buf); + } + #endif + + #ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("plugin fd (%d), file uid(%lld)", plugin_fd, *file_uid); + #endif + } + + return ret; +} + +EXPORT_API +storage_error_code_t storage_adaptor_close_file(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + long long int file_uid, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->close_file, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (close file)")); + + int plugin_fd = _get_plugin_fd_from_file_uid(file_uid); + storage_error_code_t ret = plugin->handle->close_file(context, plugin_fd, error); + + #ifndef FORK_PLUGIN_ARCHITECTURE + g_hash_table_remove(g_file_uid_list, (void *)&plugin_fd); + #endif + + #ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("plugin fd (%d), file uid(%lld)", plugin_fd, file_uid); + #endif + + return ret; +} + +EXPORT_API +storage_error_code_t storage_adaptor_start_upload_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + long long int src_file_descriptor, /* read only opened */ + const char *upload_dir_path, + const char *file_name, + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->start_upload_task, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (start_upload_task)")); + + storage_error_code_t ret = STORAGE_ADAPTOR_ERROR_NONE; + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s START ==========", __FUNCTION__); + storage_adaptor_debug_func("[in] file_uid (%lld)", src_file_descriptor); + storage_adaptor_debug_func("[in] path (%s / %s)", upload_dir_path, file_name); + storage_adaptor_debug_func("[in] need progress (%d)", need_progress ? 1 : 0); +#endif + + int plugin_fd = _get_plugin_fd_from_file_uid(src_file_descriptor); + plugin_req_enter(); + ret = plugin->handle->start_upload_task(context, plugin_fd, + upload_dir_path, file_name, need_progress, error, user_data); + plugin_req_exit(ret, plugin, error); + + return ret; +} + +EXPORT_API +storage_error_code_t storage_adaptor_start_download_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *storage_dir_path, + const char *file_name, + long long int dst_file_descriptor, /* write only opened */ + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->start_download_task, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (start_download_task)")); + + storage_error_code_t ret = STORAGE_ADAPTOR_ERROR_NONE; + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s START ==========", __FUNCTION__); + storage_adaptor_debug_func("[in] file_uid (%lld)", dst_file_descriptor); + storage_adaptor_debug_func("[in] path (%s / %s)", storage_dir_path, file_name); + storage_adaptor_debug_func("[in] need progress (%d)", need_progress ? 1 : 0); +#endif + + int plugin_fd = _get_plugin_fd_from_file_uid(dst_file_descriptor); + plugin_req_enter(); + ret = plugin->handle->start_download_task(context, storage_dir_path, file_name, + plugin_fd, need_progress, error, user_data); + plugin_req_exit(ret, plugin, error); + + return ret; +} + +EXPORT_API +storage_error_code_t storage_adaptor_start_download_thumb_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *storage_dir_path, + const char *file_name, + long long int dst_file_descriptor, /* write only opened */ + int thumbnail_size, /* level (defined plugin SPEC) */ + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->start_download_thumb_task, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (start_download_thumb_task)")); + + storage_error_code_t ret = STORAGE_ADAPTOR_ERROR_NONE; + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s START ==========", __FUNCTION__); + storage_adaptor_debug_func("[in] file_uid (%lld)", dst_file_descriptor); + storage_adaptor_debug_func("[in] path (%s / %s)", storage_dir_path, file_name); + storage_adaptor_debug_func("[in] need progress (%d)", need_progress ? 1 : 0); +#endif + + int plugin_fd = _get_plugin_fd_from_file_uid(dst_file_descriptor); + plugin_req_enter(); + ret = plugin->handle->start_download_thumb_task(context, storage_dir_path, file_name, + plugin_fd, thumbnail_size, need_progress, error, user_data); + plugin_req_exit(ret, plugin, error); + + return ret; +} + + +EXPORT_API +storage_error_code_t storage_adaptor_cancel_upload_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + long long int file_uid, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->cancel_upload_task, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (cancel_upload_task)")); + + storage_error_code_t ret = STORAGE_ADAPTOR_ERROR_NONE; + + int plugin_fd = _get_plugin_fd_from_file_uid(file_uid); + plugin_req_enter(); + ret = plugin->handle->cancel_upload_task(context, plugin_fd, error); + plugin_req_exit(ret, plugin, error); + + return ret; +} + +EXPORT_API +storage_error_code_t storage_adaptor_cancel_download_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + long long int file_uid, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->cancel_download_task, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (cancel_download_task)")); + + storage_error_code_t ret = STORAGE_ADAPTOR_ERROR_NONE; + + int plugin_fd = _get_plugin_fd_from_file_uid(file_uid); + plugin_req_enter(); + ret = plugin->handle->cancel_download_task(context, plugin_fd, error); + plugin_req_exit(ret, plugin, error); + + return ret; + +} + +EXPORT_API +storage_error_code_t storage_adaptor_cancel_download_thumb_task(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + long long int file_uid, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->cancel_download_thumb_task, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (cancel_download_thumb_task)")); + + storage_error_code_t ret = STORAGE_ADAPTOR_ERROR_NONE; + + int plugin_fd = _get_plugin_fd_from_file_uid(file_uid); + plugin_req_enter(); + ret = plugin->handle->cancel_download_thumb_task(context, plugin_fd, error); + plugin_req_exit(ret, plugin, error); + + return ret; + +} + +/* ////////////////////// Common feature //////////////////////////// */ + +/** +* @brief Set server information for Storage Plugin +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] server_info specifies server information for Storage Plugin +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +EXPORT_API +storage_error_code_t storage_adaptor_set_server_info(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + GHashTable *server_info, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->set_server_info, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (set_server_info)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s START ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] server_info [addr(%p)]", server_info); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->set_server_info( + context, server_info, request, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Makes a directory at cloud +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies path to locate the folder you want to create +* @param[in] folder_name specifies folder name to be created at cloud +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_make_directory(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->make_directory, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (make_directory)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s START ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] folder_name (%s)", folder_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->make_directory( + context, parent_folder_storage_path, folder_name, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Removes a directory at cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies parent folder path of folder you want to delete +* @param[in] folder_name specifies folder name to be deleted from cloud +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_remove_directory(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->remove_directory, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (remove_directory)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] folder_name (%s)", folder_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->remove_directory(context, parent_folder_storage_path, + folder_name, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Requests folder and file list in a folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies parent folder path of folder you want to get list +* @param[in] folder_name specifies folder name you want to get list +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_list(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->list, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (list)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] folder_name (%s)", folder_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->list(context, parent_folder_storage_path, + folder_name, request, file_info_list, file_info_list_len, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + storage_adaptor_debug_func("[out] file_info_list_len (%d)", *file_info_list_len); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Uploads a file to cloud (Sync) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to upload +* @param[in] file_name specifies file name to be uploaded to cloud +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* @param[in] publish specifies Allow to share file with no authentication +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_upload_file_sync(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const int publish, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->upload_file_sync, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (upload_file_sync)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] upload_file_local_path (%s)", upload_file_local_path); + storage_adaptor_debug_func("[in] publish (%d)", publish); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->upload_file_sync(context, parent_folder_storage_path, + file_name, upload_file_local_path, publish, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + if ((1 == publish) && (NULL != (*file_info)->file_share_token)) { + storage_adaptor_debug_func("[out] file_info->file_share_token->public_token (%s)", + (*file_info)->file_share_token->public_token); + storage_adaptor_debug_func("[out] file_info->file_share_token->auth_code (%s)", + (*file_info)->file_share_token->auth_code); + } + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Downloads a file to local (Sync) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to download +* @param[in] file_name specifies file name to be downloaded to local +* @param[in] download_file_local_path specifies local path to download +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_download_file_sync(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *download_file_local_path, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->download_file_sync, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (download_file_sync)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] download_file_local_path (%s)", download_file_local_path); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->download_file_sync(context, parent_folder_storage_path, + file_name, download_file_local_path, request, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +storage_error_code_t storage_adaptor_download_thumbnail(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *folder_path, + const char *file_name, + const char *download_path, + int thumbnail_size, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->download_thumbnail, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (download_thumbnail)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] folder_path (%s)", folder_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] download_path (%s)", download_path); + storage_adaptor_debug_func("[in] thumbnail_size (%d)", thumbnail_size); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->download_thumbnail(context, folder_path, + file_name, download_path, thumbnail_size, request, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + + + +/** +* @brief Removes a file at cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to delete +* @param[in] file_name specifies file name to be deleted from cloud +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_delete_file(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->delete_file, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (delete_file)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->delete_file(context, parent_folder_storage_path, + file_name, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Move a folder into destination folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies parent folder path of folder you want to move +* @param[in] folder_name specifies folder name to be moved +* @param[in] dest_parent_folder_storage_path specifies new parent folder path +* @param[in] new_folder_name specifies new folder name +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_move_directory(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + const char *dest_parent_folder_storage_path, + const char *new_folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->move_directory, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (move_directory)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] folder_name (%s)", folder_name); + storage_adaptor_debug_func("[in] dest_parent_folder_storage_path (%s)", dest_parent_folder_storage_path); + storage_adaptor_debug_func("[in] new_folder_name (%s)", new_folder_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->move_directory(context, parent_folder_storage_path, + folder_name, dest_parent_folder_storage_path, new_folder_name, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Move a file into destination folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to move +* @param[in] file_name specifies file name to be moved +* @param[in] dest_parent_folder_storage_path specifies new folder path +* @param[in] new_file_name specifies new file name +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_move_file(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *dest_parent_folder_storage_path, + const char *new_file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->move_file, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (move_file)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] dest_parent_folder_storage_path (%s)", dest_parent_folder_storage_path); + storage_adaptor_debug_func("[in] new_file_name (%s)", new_file_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->move_file(context, parent_folder_storage_path, + file_name, dest_parent_folder_storage_path, new_file_name, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Get state of file transfer request +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] transfer_request_id specifies unique id for file transfer request +* @param[in] request specifies optional parameter +* @param[out] state specifies current state of transfer request +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_get_transfer_state(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *transfer_request_id, + void *request, + storage_adaptor_transfer_state_e *state, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->get_transfer_state, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (get_transfer_state)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->get_transfer_state(context, transfer_request_id, + request, state, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != state) { + storage_adaptor_debug_func("[out] state (%d)", *state); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Set state of file transfer request +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] transfer_request_id specifies unique id for file transfer request +* @param[in] state specifies state to set +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_set_transfer_state(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *transfer_request_id, + storage_adaptor_transfer_state_e state, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->set_transfer_state, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (set_transfer_state)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] state(%d)", state); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->set_transfer_state(context, transfer_request_id, + state, request, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +storage_error_code_t storage_adaptor_get_root_folder_path(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *request, + char **root_folder_path, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, root_folder_path, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (root_folder_path)")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->get_root_folder_path, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (get_root_folder_path)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) uid(%s)]", + context->app_id, context->access_token, context->uid); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->get_root_folder_path(context, request, root_folder_path, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != *root_folder_path) { + storage_adaptor_debug_func("[out] root_folder_path (%s)", *root_folder_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/* ////////////////////// Private feature //////////////////////////// */ + +/** +* @brief Uploads a file to cloud (Async) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to upload +* @param[in] file_name specifies file name to be uploaded to cloud +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* @param[in] publish specifies Allow to share file with no authentication +* @param[in] request specifies optional parameter +* @param[out] transfer_request_id specifies +* @param[out] error specifies error code +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_upload_file_async(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const int publish, + void *request, + void *transfer_request_id, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->upload_file_async, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (upload_file_async)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] upload_file_local_path (%s)", upload_file_local_path); + storage_adaptor_debug_func("[in] publish (%d)", publish); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->upload_file_async(context, parent_folder_storage_path, + file_name, upload_file_local_path, publish, request, transfer_request_id); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Downloads a file to local (Async) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to download +* @param[in] file_name specifies file name to be downloaded to local +* @param[in] download_file_local_path specifies local path to download +* @param[in] request specifies optional parameter +* @param[out] transfer_request_id specifies +* @param[out] error specifies error code +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_download_file_async(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *download_file_local_path, + void *request, + void *transfer_request_id, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->download_file_async, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (download_file_async)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] download_file_local_path (%s)", download_file_local_path); + storage_adaptor_debug_func("[in] request (addr : %p)", request); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->download_file_async(context, parent_folder_storage_path, + file_name, download_file_local_path, request, transfer_request_id); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + + +/** +* @brief Sets metadata of file at cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to set meta data +* @param[in] file_name specifies file name to be updated meta data +* @param[in] meta_data specifies meta data (A pair of Key, Value) +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_set_meta(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const void *meta_data, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->set_meta, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (set_meta)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->set_meta(context, parent_folder_storage_path, + file_name, meta_data, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Gets metatdata of file at cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to get meta data +* @param[in] file_name specifies file name +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] meta_data specifies meta data (A pair of Key, Value) +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_get_meta(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + void **meta_data, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->get_meta, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (get_meta)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->get_meta(context, parent_folder_storage_path, + file_name, request, file_info, meta_data, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Set up Multi Channel Upload +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of file you want to upload +* @param[in] file_name specifies file name to be uploaded to cloud +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* @param[in] chunk_size_byte specifies size of chunk +* @param[in] request specifies optional parameter +* @param[out] mupload_key specifies Multi Channel Upload key +* @param[out] chunk_count specifies total number of chunks +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_start_mupload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const unsigned long long chunk_size, + void *request, + char **mupload_key, + int *chunk_count, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + storage_adaptor_check_param_equal(NULL, plugin->handle->start_mupload, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (start_mupload)")); + + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] chunk_size (%llu)", chunk_size); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->start_mupload(context, parent_folder_storage_path, + file_name, upload_file_local_path, chunk_size, request, mupload_key, chunk_count, + file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Uploads a chunk to cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] mupload_key specifies Multi Channel Upload key +* @param[in] chunk_number specifies number of chunk (Starting at 1) +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_upload_mupload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *mupload_key, + const int chunk_number, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->upload_mupload, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (upload_mupload)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] mupload_key (%s)", mupload_key); + storage_adaptor_debug_func("[in] chunk_number (%d)", chunk_number); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->upload_mupload(context, mupload_key, + chunk_number, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Ends Multi channel Upload +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] mupload_key specifies Multi Channel Upload key +* @param[in] publish specifies Allow to share file with no authentication +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_end_mupload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *mupload_key, + const int publish, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->end_mupload, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (end_mupoad)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] mupload_key (%s)", mupload_key); + storage_adaptor_debug_func("[in] publish (%d)", publish); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->end_mupload(context, mupload_key, + publish, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Requests list of chunks uploaded +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] mupload_key specifies Multi Channel Upload key +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_list_mupload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *mupload_key, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->list_mupload, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (list_mupload)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] mupload_key (%s)", mupload_key); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->list_mupload(context, mupload_key, + request, file_info_list, file_info_list_len, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != file_info_list_len) { + storage_adaptor_debug_func("[out] file_info_list_len (%d)", *file_info_list_len); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Cancels all operations +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] mupload_key specifies Multi Channel Upload key +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_cancel_mupload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *mupload_key, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->cancel_mupload, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (cancel_mupload)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] mupload_key (%s)", mupload_key); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->cancel_mupload(context, mupload_key, + request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Starts Transaction +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] request specifies optional parameter +* @param[out] tx_key specifies Transaction key +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_start_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *request, + char **tx_key, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->start_transaction, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (start_transacion)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->start_transaction(context, request, + tx_key, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != tx_key) { + storage_adaptor_debug_func("[out] tx_key (%s)", *tx_key); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Uploads a file +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] tx_seq specifies Transaction sequesnce (Starting at 1) +* @param[in] parent_folder_storage_path specifies folder path of file you want to upload +* @param[in] file_name specifies file name to be uploaded to cloud +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_upload_file_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->upload_file_transaction, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (upload_file_transaction)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] tx_key (%s)", tx_key); + storage_adaptor_debug_func("[in] tx_seq (%d)", tx_seq); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] upload_file_local_path (%s)", upload_file_local_path); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->upload_file_transaction(context, tx_key, + tx_seq, parent_folder_storage_path, file_name, upload_file_local_path, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Updates a folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] tx_seq specifies Transaction sequesnce (Starting at 1) +* @param[in] parent_folder_storage_path specifies folder path of folder you want to update +* @param[in] folder_name specifies folder name to be updated +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_set_dir_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->set_dir_transaction, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (set_dir_transaction)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] tx_key (%s)", tx_key); + storage_adaptor_debug_func("[in] tx_seq (%d)", tx_seq); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] folder_name (%s)", folder_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->set_dir_transaction(context, tx_key, + tx_seq, parent_folder_storage_path, folder_name, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Removes a file +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] tx_seq specifies Transaction sequesnce (Starting at 1) +* @param[in] parent_folder_storage_path specifies folder path of file you want to delete +* @param[in] file_name specifies file name to be deleted from cloud +* @param[in] request specifies optional parameter +* @param[in] upload_file_local_path specifies local path of the file to be uploaded +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_delete_file_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->delete_file_transaction, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (delete_file_transaction)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] tx_key (%s)", tx_key); + storage_adaptor_debug_func("[in] tx_seq (%d)", tx_seq); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name (%s)", file_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->delete_file_transaction(context, tx_key, + tx_seq, parent_folder_storage_path, file_name, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Removes a folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] tx_seq specifies Transaction sequesnce (Starting at 1) +* @param[in] parent_folder_storage_path specifies folder path of folder you want to delete +* @param[in] folder_name specifies folder name to be deleted +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_delete_dir_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_seq, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->delete_dir_transaction, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (delete_dir_transaction)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] tx_key (%s)", tx_key); + storage_adaptor_debug_func("[in] tx_seq (%d)", tx_seq); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] folder_name (%s)", folder_name); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->delete_dir_transaction(context, tx_key, + tx_seq, parent_folder_storage_path, folder_name, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Ends Transaction +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] tx_count specifies Transaction order count +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_end_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + const int tx_count, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->end_transaction, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (end_transaction)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] tx_key (%s)", tx_key); + storage_adaptor_debug_func("[in] tx_count (%d)", tx_count); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->end_transaction(context, tx_key, + tx_count, request, file_info_list, file_info_list_len, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != file_info_list_len) { + storage_adaptor_debug_func("[out] file_info_list_len (%d)", *file_info_list_len); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Requests Transaction list +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_list_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->list_transaction, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (list_transaction)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] tx_key (%s)", tx_key); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->list_transaction(context, tx_key, + request, file_info_list, file_info_list_len, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != file_info_list_len) { + storage_adaptor_debug_func("[out] file_info_list_len (%d)", *file_info_list_len); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Cancels all transactions +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] tx_key specifies Transaction key +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a negative error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_cancel_transaction(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *tx_key, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->cancel_transaction, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (cancel_transaction)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] tx_key (%s)", tx_key); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->cancel_transaction(context, tx_key, + request, file_info_list, file_info_list_len, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != file_info_list_len) { + storage_adaptor_debug_func("[out] file_info_list_len (%d)", *file_info_list_len); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Uploads multiple files to cloud +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of files you want to upload +* @param[in] upload_file_local_path_list specifies local path list of the files to be uploaded +* @param[in] upload_list_len specifies total number of files to be uploaded +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_multi_file_upload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char **upload_file_local_path_list, + const int upload_list_len, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->multi_file_upload, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (multi_file_upload)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] upload_list_len (%d)", upload_list_len); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->multi_file_upload(context, parent_folder_storage_path, + upload_file_local_path_list, upload_list_len, request, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Downloads multiple files in a folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of files you want to download +* @param[in] file_name_list specifies file name list to be downloaded +* @param[in] file_name_list_len specifies total number of files to be downloaded +* @param[in] download_folder_local_path specifies local folder path to download files +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_multi_file_download(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name_list, + const int file_name_list_len, + const char *download_folder_local_path, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->multi_file_download, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (multi_file_download)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] download_list_len (%d)", file_name_list_len); + storage_adaptor_debug_func("[in] download_folder_local_path (%s)", download_folder_local_path); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->multi_file_download(context, parent_folder_storage_path, + file_name_list, file_name_list_len, download_folder_local_path, request, file_info_list, + file_info_list_len, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != file_info_list_len) { + storage_adaptor_debug_func("[out] file_info_list_len (%d)", *file_info_list_len); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Requests current server timestamp +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] request specifies optional parameter +* @param[out] timestamp specifies server timestamp +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_get_timestamp(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *request, + unsigned long long *timestamp, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->get_timestamp, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (get_timestamp)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->get_timestamp(context, request, + timestamp, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != timestamp) { + storage_adaptor_debug_func("[out] timestamp (%llu)", *timestamp); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Requests a file info by public token +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] public_token specifies token for Download, Get API + (when terminal upload file and add publish=true parameter, or +* @param[in] auth_code specifies Authentication code for public APIs +* @param[in] request specifies optional parameter +* @param[out] file_info specifies Storage Adaptor File Info handle +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_get_file_info_by_public_token(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->get_file_info_by_public_token, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (get_file_info_by_public_token)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] public_token (%s)", public_token); + storage_adaptor_debug_func("[in] auth_code (%s)", auth_code); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->get_file_info_by_public_token(context, public_token, + auth_code, request, file_info, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != file_info) && (NULL != (*file_info))) { + storage_adaptor_debug_func("[out] file_info->storage_path (%s)", (*file_info)->storage_path); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Downloads a file by public token (Sync) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] public_token specifies token for Download, Get API + (when terminal upload file and add publish=true parameter, or +* @param[in] auth_code specifies Authentication code for public APIs +* @param[in] download_file_local_path specifies local path to download +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_download_file_sync_by_public_token(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + const char *download_file_local_path, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->download_file_sync_by_public_token, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (download_file_sync_by_public_token)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] public_token (%s)", public_token); + storage_adaptor_debug_func("[in] auth_code (%s)", auth_code); + storage_adaptor_debug_func("[in] download_file_local_path (%s)", download_file_local_path); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->download_file_sync_by_public_token(context, public_token, + auth_code, download_file_local_path, request, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Downloads a file by public token (Async) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] public_token specifies token for Download, Get API + (when terminal upload file and add publish=true parameter, or +* @param[in] auth_code specifies Authentication code for public APIs +* @param[in] download_file_local_path specifies local path to download +* @param[in] request specifies optional parameter +* @param[out] transfer_request_id specifies +* @param[out] error specifies error code +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_download_file_async_by_public_token(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + const char *download_file_local_path, + void *request, + void *transfer_request_id, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->download_file_async_by_public_token, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (download_file_async_by_public_token)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] public_token (%s)", public_token); + storage_adaptor_debug_func("[in] auth_code (%s)", auth_code); + storage_adaptor_debug_func("[in] download_file_local_path (%s)", download_file_local_path); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->download_file_async_by_public_token(context, public_token, + auth_code, download_file_local_path, request, transfer_request_id); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + storage_adaptor_debug_func("[out] request_id [addr(%p)]", transfer_request_id); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Authenticates public auth code +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] public_token specifies token for Download, Get API + (when terminal upload file and add publish=true parameter, or +* @param[in] auth_code specifies Authentication code for public APIs +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_auth_public_authcode_by_public_token(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *public_token, + const char *auth_code, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->auth_public_authcode_by_public_token, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (auth_public_authcode_by_public_token)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] public_token (%s)", public_token); + storage_adaptor_debug_func("[in] auth_code (%s)", auth_code); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->auth_public_authcode_by_public_token(context, public_token, + auth_code, request, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Removes multiple files in a folder +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of files you want to delete +* @param[in] file_name_list specifies file name list to be deleted +* @param[in] file_name_list_len specifies total number of files to be deleted +* @param[in] request specifies optional parameter +* @param[out] file_info_list specifies Storage Adaptor File Info handle +* @param[out] file_info_list_len specifies length of the file_info_list +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_delete_multi_file_in_folder(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char **file_name_list, + const int file_name_list_len, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->delete_multi_file_in_folder, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (delete_multi_file_in_folder)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path (%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name_list_len (%d)", file_name_list_len); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->delete_multi_file_in_folder(context, parent_folder_storage_path, + file_name_list, file_name_list_len, request, file_info_list, file_info_list_len, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != file_info_list_len) { + storage_adaptor_debug_func("[out] file_info_list_len (%d)", *file_info_list_len); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Requests policy for upload +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] request specifies optional parameter +* @param[out] allowed_extension specifies +* @param[out] allowed_extension_len specifies length of allowed_extension +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_get_policy(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *request, + char ***allowed_extension, + int *allowed_extension_len, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->get_policy, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (get_policy)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->get_policy(context, request, + allowed_extension, allowed_extension_len, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != allowed_extension_len) { + storage_adaptor_debug_func("[out] allowed_extension_len (%d)", *allowed_extension_len); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Requests quota of user +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] request specifies optional parameter +* @param[out] total_usage specifies total usage of user +* @param[out] total_quota specifies total quota of user +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_get_quota(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *request, + unsigned long long *total_usage, + unsigned long long *total_quota, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->get_quota, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (get_quota)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->get_quota(context, request, + total_usage, total_quota, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != total_usage) { + storage_adaptor_debug_func("[out] total_usage (%llu)", *total_usage); + } + if (NULL != total_quota) { + storage_adaptor_debug_func("[out] total_quota (%llu)", *total_quota); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Requests Redirect URL mapped with public token (Not yet supported) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] public_token specifies token for Download, Get API + (when terminal upload file and add publish=true parameter, or +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_redirect_url_by_public_token(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *public_token, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->redirect_url_by_public_token, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (redirect_url_by_public_token)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] public_token (%s)", public_token); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->redirect_url_by_public_token(context, public_token, + request, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Creates Upload URL (Not yet supported) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] parent_folder_storage_path specifies folder path of files you want to upload +* @param[in] file_name specifies file name to be uploaded +* @param[in] x_upload_content_length specifies length of content +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_create_resuming_upload_url(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const unsigned long long x_upload_content_length, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->create_resuming_upload_url, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (create_resuming_upload_url)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] parent_folder_storage_path(%s)", parent_folder_storage_path); + storage_adaptor_debug_func("[in] file_name(%s)", file_name); + storage_adaptor_debug_func("[in] x_upload_content_length(%llu)", x_upload_content_length); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->create_resuming_upload_url(context, parent_folder_storage_path, + file_name, x_upload_content_length, request, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Creates chunk Upload URL (Not yet supported) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] mupload_key specifies Multi Channel Upload key +* @param[in] chunk_number specifies number of chunk (Starting at 1) +* @param[in] x_upload_content_length specifies length of content +* @param[in] request specifies optional parameter +* @param[out] rupload_key specifies Resuming Upload key +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_create_resuming_chunk_upload_url(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *mupload_key, + const int chunk_number, + const unsigned long long x_upload_content_length, + void *request, + char **rupload_key, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->create_resuming_chunk_upload_url, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (create_resuming_chunk_upload_url)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] mupload_key(%s)", mupload_key); + storage_adaptor_debug_func("[in] chunk_number(%d)", chunk_number); + storage_adaptor_debug_func("[in] x_upload_content_length(%llu)", x_upload_content_length); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->create_resuming_chunk_upload_url(context, mupload_key, + chunk_number, x_upload_content_length, request, rupload_key, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != rupload_key) { + storage_adaptor_debug_func("[out] rupload_key (%s)", *rupload_key); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Resumes Upload (Not yet supported) +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] rupload_key specifies Resuming Upload key +* @param[in] content_range specifies range of content +* @param[in] content_length specifies length of content +* @param[in] request specifies optional parameter +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_resuming_upload(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + const char *rupload_key, + const char *change_range, + const unsigned long long content_length, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->resuming_upload, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (resuming_upload)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] rupload_key(%s)", rupload_key); + storage_adaptor_debug_func("[in] change_range(%d)", change_range); + storage_adaptor_debug_func("[in] content_length(%llu)", content_length); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->resuming_upload(context, rupload_key, + change_range, content_length, request, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + +/** +* @brief Get progress of file transfer request +* +* @param[in] plugin specifies Storage Adaptor Plugin handle +* @param[in] context specifies Storage Adaptor Plugin Context handle +* @param[in] transfer_request_id specifies unique id for file transfer request +* @param[in] request specifies optional parameter +* @param[out] progress_size specifies current progress size +* @param[out] total_size specifies total size to transfer +* @param[out] error specifies error code +* @param[out] response specifies optional parameter +* @return 0 on success, otherwise a positive error value +* @retval error code defined in storage_error_code_t - STORAGE_ADAPTOR_ERROR_NONE if Successful +*/ +storage_error_code_t storage_adaptor_get_transfer_progress(storage_adaptor_plugin_h plugin, + storage_adaptor_plugin_context_h context, + void *transfer_request_id, + void *request, + unsigned long long *progress_size_byte, + unsigned long long *total_size_byte, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (plugin)")); + + storage_adaptor_check_param_equal(NULL, plugin, STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_ARGUMENT, "Invalid argument (context)")); + + storage_adaptor_check_param_equal(NULL, plugin->handle, STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_INVALID_HANDLE, "Invalid plugin handle")); + + + storage_adaptor_check_param_equal(NULL, plugin->handle->get_transfer_progress, STORAGE_ADAPTOR_ERROR_UNSUPPORTED, + __assign_error_code(error, (int64_t) STORAGE_ADAPTOR_ERROR_UNSUPPORTED, "Plugin does not support this API (get_transfer_progress)")); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("========== %s ==========", __FUNCTION__); + storage_adaptor_debug_secure("[in] Context [app_id(%s) access_token(%s) cid(%s) uid(%s)]", + context->app_id, context->access_token, context->cid, context->uid); + storage_adaptor_debug_func("[in] tansfer_request_id [addr(%p)]", transfer_request_id); + storage_adaptor_debug_func("[in] request [addr(%p)]", request); +#endif + + plugin_req_enter(); + storage_error_code_t ret = plugin->handle->get_transfer_progress(context, transfer_request_id, + request, progress_size_byte, total_size_byte, error, response); + plugin_req_exit(ret, plugin, error); + +#ifdef DEBUG_ADAPTOR_PARAMS + storage_adaptor_debug_func("[out] return code (%d)", ret); + if (NULL != progress_size_byte) { + storage_adaptor_debug_func("[out] progress size : %10llubyte", *progress_size_byte); + } + if (NULL != total_size_byte) { + storage_adaptor_debug_func("[out] total size : %10llubyte", *total_size_byte); + } + if ((NULL != error) && (NULL != *error)) { + storage_adaptor_debug_func("[out] error->code (%llu)", (*error)->code); + storage_adaptor_debug_func("[out] error->msg (%s)", (*error)->msg); + } + storage_adaptor_debug_func("[out] response [addr(%p)]", response); + storage_adaptor_debug_func("========== %s END ==========", __FUNCTION__); +#endif + + return ret; +} + + + + + + + + + + + + + + +/* /////////////////////////////////////////////////////////////////////////////// + /////////////////////////////////////////////////////////////////////////////// + //////////// Internal function description (for forked plugin) ////////////// + /////////////////////////////////////////////////////////////////////////////// + /////////////////////////////////////////////////////////////////////////////// */ + +void *_storage_adaptor_plugin_message_collector(void *data) +{ + storage_adaptor_h adaptor = (storage_adaptor_h) data; + + storage_adaptor_info("3rd party plugin listener run"); + int i, lagest_fd = -1; + fd_set read_set; + struct timeval tv; + tv.tv_sec = 10L; /* TODO change to define or meaningful value */ + char msg_buf[PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE] = {0, }; + int buf_size, rcv_len; + GList *dead_list = NULL; + + while (1) { + /* Clears and sets fds for select */ + FD_ZERO(&read_set); + FD_SET(adaptor->rd_cmd[0], &read_set); + lagest_fd = adaptor->rd_cmd[0]; + + /* Sets plugin fds for select */ + for (i = 0; i < g_list_length(adaptor->rd_list); i++) { + int fd = (int) g_list_nth_data(adaptor->rd_list, i); + FD_SET(fd, &read_set); + if (lagest_fd < fd) { + lagest_fd = fd; + } + } + + /* Select with timeout (for avoid blocking issue) */ + int stmt = select((lagest_fd + 1), &read_set, NULL, NULL, &tv); + IF_IS_PLUGIN_THAN_RETURN_NULL(); + if (stmt == 0) { +/* storage_adaptor_debug("select refrech by timeout(%ld sec) [id : %d]", tv.tv_sec, g_process_identity); */ + if (0L >= tv.tv_sec) { +/* storage_adaptor_debug("Resets selector timeout sec"); */ + tv.tv_sec = 10L; + } + IF_IS_PLUGIN_THAN_RETURN_NULL(); + } else if (stmt > 0) { + /* Checking message queue with Plugin processes. */ + for (i = 0; i < g_list_length(adaptor->rd_list); i++) { + IF_IS_PLUGIN_THAN_RETURN_NULL(); + int fd = (int) g_list_nth_data(adaptor->rd_list, i); + if (FD_ISSET(fd, &read_set)) { + IF_IS_PLUGIN_THAN_RETURN_NULL(); + /* pre-read buf size */ + rcv_len = read(fd, &buf_size, sizeof(int)); + if (0 >= rcv_len) { + storage_adaptor_debug("Child process dead (Remove from listening queue)"); + dead_list = g_list_append(dead_list, (gpointer)fd); + continue; + } + /* allocates and read buf data */ + memset(msg_buf, 0, PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE); + buf_size %= (PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE - 1); + rcv_len = read(fd, msg_buf, buf_size); + storage_adaptor_debug("read message [%s][%d]", msg_buf, rcv_len); + + if (0 < rcv_len) { + /* transfer data to adaptor */ + __storage_adaptor_transfer_message(msg_buf); + } else { + storage_adaptor_debug("Child process dead (Remove from listening queue)"); + dead_list = g_list_append(dead_list, (gpointer)fd); + } + } + } + + /* Checking message queue with Adaptor internal command. */ + IF_IS_PLUGIN_THAN_RETURN_NULL(); + if (FD_ISSET(adaptor->rd_cmd[0], &read_set)) { + int fd = adaptor->rd_cmd[0]; + IF_IS_PLUGIN_THAN_RETURN_NULL(); + /* pre-read buf size */ + rcv_len = read(fd, &buf_size, sizeof(int)); + + if (0 >= rcv_len) { + storage_adaptor_debug("Parent process dead : Listener break"); + break; + } + + /* allocates and read buf data */ + memset(msg_buf, 0, PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE); + buf_size %= (PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE - 1); + rcv_len = read(fd, msg_buf, buf_size); + storage_adaptor_debug("read message [%s][%d]", msg_buf, rcv_len); + + if (0 >= rcv_len) { + storage_adaptor_debug("Parent process dead : Listener break"); + break; + } + + /* parse cmd message (e.g. append read_fd / change timeout sec / stop listener) */ + int cmd_ret = __storage_adaptor_parse_message_cmd(adaptor, msg_buf); + if (0 > cmd_ret) { + storage_adaptor_info("3rd party plugin listener stopped by adaptor cmd"); + break; + } + } + + /* Remove fd with disconnected plugin. */ + for (i = 0; i < g_list_length(dead_list); i++) { + adaptor->rd_list = g_list_remove(adaptor->rd_list, (gpointer) g_list_nth_data(dead_list, i)); + } + g_list_free(dead_list); + dead_list = NULL; + } else { + storage_adaptor_error("plugin message listener error (errno : %d)", errno); + } + } + storage_adaptor_info("3rd party plugin listener stopped"); + + return data; +} + +void __storage_adaptor_transfer_message(const char *msg) +{ + plugin_message_h t_msg = NULL; + int ret = 0; + ret = plugin_message_deserialize(msg, &t_msg); + if (!ret) { + pmnumber req_type, req_id; + ret = plugin_message_get_value_number(t_msg, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, &req_type); + if (!ret && (PLUGIN_MESSAGE_TYPE_FUNCTION == req_type)) { + storage_adaptor_debug("Message function type : function"); + ret = plugin_message_get_value_number(t_msg, PLUGIN_MESSAGE_ELEMENT_REQUEST_ID, &req_id); + if (!ret) { + storage_adaptor_debug("Send plugin data to requester"); + int hooked_fd = (int) req_id; + int len = strlen(msg); + ret = write(hooked_fd, &len, sizeof(int)); + ret = write(hooked_fd, msg, sizeof(char) * len); + } else { + storage_adaptor_debug("Couldn't get request id"); + } + } else if (!ret && (PLUGIN_MESSAGE_TYPE_CALLBACK == req_type)) { + storage_adaptor_debug("Message function type : callback"); + /*TODO call callback function */ + char *callback_name = NULL; + ret = plugin_message_get_value_string(t_msg, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, &callback_name); + storage_adaptor_error("Callback name : %s", callback_name); + if (NULL == callback_name) { + storage_adaptor_error("Function name parsing error"); + } else if (0 == strncmp(STORAGE_PLUGIN_CALLBACK_DOWNLOAD_FILE_ASYNC_CB, + callback_name, + strlen(STORAGE_PLUGIN_CALLBACK_DOWNLOAD_FILE_ASYNC_CB))) { + pmnumber fd, state, ret_code; + char *ret_msg = NULL; + int param_idx = 1; + storage_adaptor_error_code_h error = NULL; + ret = plugin_message_get_value_number(t_msg, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + ret = plugin_message_get_value_string(t_msg, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_msg); + if (NULL != ret_msg) { + error = storage_adaptor_create_error_code((int64_t) ret_code, ret_msg); + } + ret = plugin_message_get_param_number(t_msg, param_idx++, &fd); + ret = plugin_message_get_param_number(t_msg, param_idx++, &state); + + storage_adaptor_download_state_changed_reply_cb((int)fd, (storage_adaptor_transfer_state_e)state, error, NULL); + storage_adaptor_destroy_error_code(&error); + } else if (0 == strncmp(STORAGE_PLUGIN_CALLBACK_UPLOAD_FILE_ASYNC_CB, + callback_name, + strlen(STORAGE_PLUGIN_CALLBACK_UPLOAD_FILE_ASYNC_CB))) { + pmnumber fd, state, ret_code; + char *ret_msg = NULL; + int param_idx = 1; + storage_adaptor_error_code_h error = NULL; + storage_adaptor_file_info_h file_info = NULL; + ret = plugin_message_get_value_number(t_msg, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + ret = plugin_message_get_value_string(t_msg, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_msg); + if (NULL != ret_msg) { + error = storage_adaptor_create_error_code((int64_t) ret_code, ret_msg); + } + ret = plugin_message_get_param_number(t_msg, param_idx++, &fd); + ret = plugin_message_get_param_number(t_msg, param_idx++, &state); + + plugin_message_array_h file_info_message = NULL; + ret = plugin_message_get_param_array(t_msg, param_idx++, &file_info_message); + if ((0 == ret) && (NULL != file_info_message)) { + file_info = _get_file_info_from_message_array(file_info_message, param_idx++); + } + + storage_adaptor_upload_state_changed_reply_cb((int)fd, + (storage_adaptor_transfer_state_e)state, file_info, error, NULL); + + storage_adaptor_destroy_file_info(&file_info); + plugin_message_array_destroy(file_info_message); + storage_adaptor_destroy_error_code(&error); + } else if (0 == strncmp(STORAGE_PLUGIN_CALLBACK_PROGRESS_CB, + callback_name, + strlen(STORAGE_PLUGIN_CALLBACK_PROGRESS_CB))) { + pmnumber fd, progress, total, ret_code; + char *ret_msg = NULL; + int param_idx = 1; + storage_adaptor_error_code_h error = NULL; + ret = plugin_message_get_value_number(t_msg, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + ret = plugin_message_get_value_string(t_msg, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_msg); + if (NULL != ret_msg) { + error = storage_adaptor_create_error_code((int64_t) ret_code, ret_msg); + } + ret = plugin_message_get_param_number(t_msg, param_idx++, &fd); + ret = plugin_message_get_param_number(t_msg, param_idx++, &progress); + ret = plugin_message_get_param_number(t_msg, param_idx++, &total); + + storage_adaptor_task_progress_reply_cb((int)fd, + (unsigned long long)progress, (unsigned long long)total, error, NULL); + storage_adaptor_destroy_error_code(&error); + } else { + storage_adaptor_error("Invalid callback name : %s", callback_name); + } + free(callback_name); + } else { + storage_adaptor_warning("Received message parsing fail."); + } + plugin_message_destroy(t_msg); + } +} + +int __storage_adaptor_parse_message_cmd(storage_adaptor_h adaptor, char *msg) +{ + char *cmd_data = NULL; + if (0 == strncmp(PLUGIN_MESSAGE_LISTENER_CMD_APPEND_FD, msg, strlen(PLUGIN_MESSAGE_LISTENER_CMD_APPEND_FD))) { + cmd_data = msg + strlen(PLUGIN_MESSAGE_LISTENER_CMD_APPEND_FD); + int fd = atoi(cmd_data); + + adaptor->rd_list = g_list_append(adaptor->rd_list, (gpointer)fd); + } else if (0 == strncmp(PLUGIN_MESSAGE_LISTENER_CMD_STOP, msg, strlen(PLUGIN_MESSAGE_LISTENER_CMD_STOP))) { + return -1; + } + + return 0; +} + + +void _storage_adaptor_send_cmd_add_fd(storage_adaptor_h adaptor, int fd) +{ + char cmd_buf[256] = {0, }; + snprintf(cmd_buf, 255, "%s%d", PLUGIN_MESSAGE_LISTENER_CMD_APPEND_FD, fd); + int len = strlen(cmd_buf); + int wr_ret; + + g_mutex_lock(&adaptor->rd_mutex); + wr_ret = write(adaptor->rd_cmd[1], &len, sizeof(int)); + wr_ret = write(adaptor->rd_cmd[1], cmd_buf, sizeof(char) * len); + g_mutex_unlock(&adaptor->rd_mutex); + storage_adaptor_debug("writed (%d)(%s)", wr_ret, cmd_buf); +} + +void _storage_adaptor_send_cmd_stop_listen(storage_adaptor_h adaptor) +{ + char cmd_buf[256] = {0, }; + snprintf(cmd_buf, 255, "%s", PLUGIN_MESSAGE_LISTENER_CMD_STOP); + int len = strlen(cmd_buf); + int wr_ret; + + g_mutex_lock(&adaptor->rd_mutex); + wr_ret = write(adaptor->rd_cmd[1], &len, sizeof(int)); + wr_ret = write(adaptor->rd_cmd[1], cmd_buf, sizeof(char) * len); + g_mutex_unlock(&adaptor->rd_mutex); + storage_adaptor_debug("writed (%d)(%s)", wr_ret, cmd_buf); +} + +static int storage_adaptor_send_message_to_plugin_sync(storage_adaptor_plugin_h plugin, + plugin_message_h send_message, + plugin_message_h *receive_message) +{ + int io_ret = 0; + int wfd = plugin->wd; + int sync_hook[2]; + + if (pipe(sync_hook) != -1) { + char read_buf[PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE] = {0, }; + + plugin_message_set_value_number(send_message, PLUGIN_MESSAGE_ELEMENT_REQUEST_ID, (pmnumber) sync_hook[1]); + char *stream = NULL; + io_ret = plugin_message_serialize(send_message, &stream); + int len = strlen(stream); + + g_mutex_lock(&plugin->message_mutex); + io_ret = write(wfd, &len, sizeof(len)); + io_ret = write(wfd, stream, sizeof(char) * len); + g_mutex_unlock(&plugin->message_mutex); + free(stream); + stream = NULL; + len = 0; + + io_ret = read(sync_hook[0], &len, sizeof(len)); + memset(read_buf, 0, PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE); + len %= (PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE - 1); + if (0 < len) { + io_ret = read(sync_hook[0], read_buf, len); + } + storage_adaptor_debug("io ret : %d", io_ret); + close(sync_hook[0]); + close(sync_hook[1]); + + plugin_message_h _rcv; + if (0 < strlen(read_buf)) { + io_ret = plugin_message_deserialize(read_buf, &_rcv); + if (!io_ret) { + *receive_message = _rcv; + } + } + } else { + io_ret = -1; + } + + return io_ret; +} + +storage_adaptor_plugin_handle_h __storage_adaptor_create_3rd_party_plugin_handle(const char *plugin_uri) +{ + storage_adaptor_plugin_handle_h handle = (storage_adaptor_plugin_handle_h) calloc(1, sizeof(storage_adaptor_plugin_handle_t)); + + if (NULL == handle) { + return handle; + } + + handle->create_context = storage_plugin_send_create_context; + handle->destroy_context = storage_plugin_send_destroy_context; + handle->set_server_info = storage_plugin_send_set_server_info; + handle->make_directory = storage_plugin_send_make_directory; + handle->remove_directory = storage_plugin_send_remove_directory; + handle->list = storage_plugin_send_get_list; + handle->upload_file_sync = storage_plugin_send_upload_file_sync; + handle->download_file_sync = storage_plugin_send_download_file_sync; + handle->delete_file = storage_plugin_send_delete_file; + handle->move_directory = storage_plugin_send_move_directory; + handle->move_file = storage_plugin_send_move_file; + handle->set_transfer_state = storage_plugin_send_set_transfer_state; + handle->get_transfer_state = storage_plugin_send_get_transfer_state; + handle->get_root_folder_path = storage_plugin_send_get_root_folder_path; + + handle->start_upload_task = storage_plugin_send_start_upload_task; + handle->start_download_task = storage_plugin_send_start_download_task; + handle->start_download_thumb_task = storage_plugin_send_start_download_thumb_task; + handle->cancel_upload_task = storage_plugin_send_cancel_upload_task; + handle->cancel_download_task = storage_plugin_send_cancel_download_task; + handle->cancel_download_thumb_task = storage_plugin_send_cancel_download_thumb_task; + + handle->plugin_uri = strdup(plugin_uri); + + return handle; +} + +storage_adaptor_file_info_h _get_file_info_from_message_array(plugin_message_array_h message_array, int index) +{ + storage_adaptor_file_info_h file_info = NULL; + + if (NULL == message_array) { + return file_info; + } + +/* + //TODO + _media_meta->mime_type = NULL; + _media_meta->title = NULL; + _media_meta->album = NULL; + _media_meta->artist = NULL; + _media_meta->genere = NULL; + _media_meta->recorded_date = NULL; + _media_meta->width = -1; + _media_meta->height = -1; + _media_meta->duration = -1; + _media_meta->copyright = NULL; + _media_meta->track_num = NULL; + _media_meta->description = NULL; + _media_meta->composer = NULL; + _media_meta->year = NULL; + _media_meta->bitrate = -1; + _media_meta->samplerate = -1; + _media_meta->channel = -1; + _media_meta->extra_media_meta = NULL; + + _cloud_meta->service_name = NULL; + _cloud_meta->usage_byte = 0ULL; + _cloud_meta->quota_byte = 0ULL; + _cloud_meta->extra_cloud_meta = NULL; +*/ + + char *plugin_uri = NULL; + char *object_id = NULL; + char *storage_path = NULL; + pmnumber file_size = 0LL; + pmnumber created_time = 0LL; + pmnumber modified_time = 0LL; + pmnumber file_info_index = -1LL; + pmnumber content_type = (pmnumber)STORAGE_ADAPTOR_CONTENT_TYPE_DEFAULT; + char *extra_file_info = NULL; + + int ret = 0; + ret = plugin_message_array_get_element(message_array, index, &plugin_uri, &object_id, &storage_path, + &file_size, &created_time, &modified_time, &file_info_index, &content_type, &extra_file_info); + + if (0 == ret) { + file_info = storage_adaptor_create_file_info(); + + if (NULL != file_info) { + file_info->plugin_uri = plugin_uri; + file_info->object_id = object_id; + file_info->storage_path = storage_path; + file_info->file_size = (unsigned long long) file_size; + file_info->created_time = (unsigned long long) created_time; + file_info->modified_time = (unsigned long long) modified_time; + file_info->file_info_index = (long long int) file_info_index; + file_info->content_type = (int) content_type; + file_info->extra_file_info = extra_file_info; + } else { + free(plugin_uri); + free(object_id); + free(extra_file_info); + } + } + + return file_info; +} + +int _message_array_set_file_info(plugin_message_array_h message_array, int index, storage_adaptor_file_info_h file_info) +{ + int ret = STORAGE_ADAPTOR_ERROR_NONE; + if ((NULL == message_array) || (NULL == file_info)) { + return -1; + } + +/* + //TODO + _media_meta->mime_type = NULL; + _media_meta->title = NULL; + _media_meta->album = NULL; + _media_meta->artist = NULL; + _media_meta->genere = NULL; + _media_meta->recorded_date = NULL; + _media_meta->width = -1; + _media_meta->height = -1; + _media_meta->duration = -1; + _media_meta->copyright = NULL; + _media_meta->track_num = NULL; + _media_meta->description = NULL; + _media_meta->composer = NULL; + _media_meta->year = NULL; + _media_meta->bitrate = -1; + _media_meta->samplerate = -1; + _media_meta->channel = -1; + _media_meta->extra_media_meta = NULL; + + _cloud_meta->service_name = NULL; + _cloud_meta->usage_byte = 0ULL; + _cloud_meta->quota_byte = 0ULL; + _cloud_meta->extra_cloud_meta = NULL; +*/ + + char *plugin_uri = SAFE_ADD_STRING(file_info->plugin_uri); + char *object_id = SAFE_ADD_STRING(file_info->object_id); + char *storage_path = SAFE_ADD_STRING(file_info->storage_path); + pmnumber file_size = (pmnumber) file_info->file_size; + pmnumber created_time = (pmnumber) file_info->created_time; + pmnumber modified_time = (pmnumber) file_info->modified_time; + pmnumber file_info_index = (pmnumber) file_info->file_info_index; + pmnumber content_type = (pmnumber) file_info->content_type; + char *extra_file_info = SAFE_ADD_STRING(file_info->extra_file_info); + + ret = plugin_message_array_add_element(message_array, plugin_uri, object_id, storage_path, + file_size, created_time, modified_time, file_info_index, content_type, extra_file_info); + + return ret; +} + + + +/* TODO change */ +void change_smack_rule(const char *smack_label) +{ + int ret = 0; + char *label = NULL; + + storage_adaptor_info("smack_label : %s\n", smack_label); + + /* Check self process smack */ + smack_new_label_from_self(&label); + storage_adaptor_info("now label(%s)\n", label); + free(label); + label = NULL; + + /* Change smack label */ + ret = smack_set_label_for_self(smack_label); + storage_adaptor_info("set label self(%d)\n", ret); + + /* Check self process smack */ + smack_new_label_from_self(&label); + storage_adaptor_info("now label(%s)\n", label); + free(label); + label = NULL; +} + + +storage_error_code_t storage_plugin_send_create_context(storage_adaptor_plugin_context_h *context, + const char *app_id, + const char *app_secret, + const char *access_token, + const char *cid, + const char *uid) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = (*context)->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + (*context)->context_id = (int) (intptr_t)(*context); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) (*context)->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_CREATE_CONTEXT); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, app_id); + plugin_message_set_param_string(message, param_index++, app_secret); + plugin_message_set_param_string(message, param_index++, access_token); + plugin_message_set_param_string(message, param_index++, cid); + plugin_message_set_param_string(message, param_index++, uid); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Create context successed"); + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Create context failed (%d)(%s)", ret, ret_msg); + free(ret_msg); + ret_msg = NULL; + + free(*context); + (*context) = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_destroy_context(storage_adaptor_plugin_context_h context) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_DESTROY_CONTEXT); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Destroy context successed"); + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Destroy context failed (%d)(%s)", ret, ret_msg); + free(ret_msg); + ret_msg = NULL; + + storage_adaptor_debug("Force release memory by adaptor process"); + free(context->access_token); + free(context); + context = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_set_server_info(storage_adaptor_plugin_context_h context, + GHashTable *server_info, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + return STORAGE_ADAPTOR_ERROR_UNSUPPORTED; +} + +storage_error_code_t storage_plugin_send_make_directory(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_MAKE_DIRECTORY); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, parent_folder_storage_path); + plugin_message_set_param_string(message, param_index++, folder_name); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Make directory successed"); + + if (NULL != file_info) { + storage_adaptor_debug("Get file info"); + int param_idx = 1; + int param_ret; + plugin_message_array_h file_info_message = NULL; + param_ret = plugin_message_get_param_array(result_message, param_idx++, &file_info_message); + if ((0 == param_ret) && (NULL != file_info_message)) { + *file_info = _get_file_info_from_message_array(file_info_message, param_idx++); + } + plugin_message_array_destroy(file_info_message); + } + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Make directory failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + + +storage_error_code_t storage_plugin_send_remove_directory(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_REMOVE_DIRECTORY); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, parent_folder_storage_path); + plugin_message_set_param_string(message, param_index++, folder_name); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Remove directory successed"); + + if (NULL != file_info) { + storage_adaptor_debug("Get file info"); + int param_idx = 1; + int param_ret; + plugin_message_array_h file_info_message = NULL; + param_ret = plugin_message_get_param_array(result_message, param_idx++, &file_info_message); + if ((0 == param_ret) && (NULL != file_info_message)) { + *file_info = _get_file_info_from_message_array(file_info_message, param_idx++); + } + plugin_message_array_destroy(file_info_message); + } + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Remove directory failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_get_list(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + void *request, + storage_adaptor_file_info_h **file_info_list, + int *file_info_list_len, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_REMOVE_DIRECTORY); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, parent_folder_storage_path); + plugin_message_set_param_string(message, param_index++, folder_name); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Get list successed"); + + int param_ret; + pmnumber len; + param_ret = plugin_message_get_param_number(result_message, 2, &len); + if ((0 == ret) && (NULL != file_info_list) && (len > 0LL)) { + storage_adaptor_debug("Get file info"); + plugin_message_array_h file_info_message = NULL; + param_ret = plugin_message_get_param_array(result_message, 1, &file_info_message); + if ((0 == param_ret) && (NULL != file_info_message)) { + int i, l = (int) len; + *file_info_list = (storage_adaptor_file_info_h *) calloc(l, sizeof(storage_adaptor_file_info_h)); + if (NULL != *file_info_list) { + for (i = 0; i < l; i++) { + (*file_info_list)[i] = _get_file_info_from_message_array(file_info_message, (i+1)); + } + if (NULL != file_info_list_len) { + *file_info_list_len = l; + } + } + plugin_message_array_destroy(file_info_message); + } + } + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Get list failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + + +storage_error_code_t storage_plugin_send_upload_file_sync(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *upload_file_local_path, + const int publish, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_UPLOAD_FILE_SYNC); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, parent_folder_storage_path); + plugin_message_set_param_string(message, param_index++, file_name); + plugin_message_set_param_string(message, param_index++, upload_file_local_path); + plugin_message_set_param_number(message, param_index++, (pmnumber) publish); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Upload sync successed"); + + if (NULL != file_info) { + storage_adaptor_debug("Get file info"); + int param_idx = 1; + int param_ret; + plugin_message_array_h file_info_message = NULL; + param_ret = plugin_message_get_param_array(result_message, param_idx++, &file_info_message); + if ((0 == param_ret) && (NULL != file_info_message)) { + *file_info = _get_file_info_from_message_array(file_info_message, param_idx++); + } + plugin_message_array_destroy(file_info_message); + } + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Upload sync failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + + +storage_error_code_t storage_plugin_send_download_file_sync(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *download_file_local_path, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_DOWNLOAD_FILE_SYNC); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, parent_folder_storage_path); + plugin_message_set_param_string(message, param_index++, file_name); + plugin_message_set_param_string(message, param_index++, download_file_local_path); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Download sync successed"); + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Download sync failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_delete_file(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_DELETE_FILE); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, parent_folder_storage_path); + plugin_message_set_param_string(message, param_index++, file_name); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Delete file successed"); + + if (NULL != file_info) { + storage_adaptor_debug("Get file info"); + int param_idx = 1; + int param_ret; + plugin_message_array_h file_info_message = NULL; + param_ret = plugin_message_get_param_array(result_message, param_idx++, &file_info_message); + if ((0 == param_ret) && (NULL != file_info_message)) { + *file_info = _get_file_info_from_message_array(file_info_message, param_idx++); + } + plugin_message_array_destroy(file_info_message); + } + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Delete file failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_move_directory(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *folder_name, + const char *dest_parent_folder_storage_path, + const char *new_folder_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_MOVE_DIRECTORY); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, parent_folder_storage_path); + plugin_message_set_param_string(message, param_index++, folder_name); + plugin_message_set_param_string(message, param_index++, dest_parent_folder_storage_path); + plugin_message_set_param_string(message, param_index++, new_folder_name); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Move directory successed"); + + if (NULL != file_info) { + storage_adaptor_debug("Get file info"); + int param_idx = 1; + int param_ret; + plugin_message_array_h file_info_message = NULL; + param_ret = plugin_message_get_param_array(result_message, param_idx++, &file_info_message); + if ((0 == param_ret) && (NULL != file_info_message)) { + *file_info = _get_file_info_from_message_array(file_info_message, param_idx++); + } + plugin_message_array_destroy(file_info_message); + } + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Move directory failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_move_file(storage_adaptor_plugin_context_h context, + const char *parent_folder_storage_path, + const char *file_name, + const char *dest_parent_folder_storage_path, + const char *new_file_name, + void *request, + storage_adaptor_file_info_h *file_info, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_MOVE_FILE); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, parent_folder_storage_path); + plugin_message_set_param_string(message, param_index++, file_name); + plugin_message_set_param_string(message, param_index++, dest_parent_folder_storage_path); + plugin_message_set_param_string(message, param_index++, new_file_name); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Move file successed"); + + if (NULL != file_info) { + storage_adaptor_debug("Get file info"); + int param_idx = 1; + int param_ret; + plugin_message_array_h file_info_message = NULL; + param_ret = plugin_message_get_param_array(result_message, param_idx++, &file_info_message); + if ((0 == param_ret) && (NULL != file_info_message)) { + *file_info = _get_file_info_from_message_array(file_info_message, param_idx++); + } + plugin_message_array_destroy(file_info_message); + } + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Move file failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_set_transfer_state(storage_adaptor_plugin_context_h context, + void *transfer_request_id, + storage_adaptor_transfer_state_e state, + void *request, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_SET_TRANSFER_STATE); + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_number(message, param_index++, (pmnumber)(intptr_t)transfer_request_id); + plugin_message_set_param_number(message, param_index++, (pmnumber)state); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Set transfer state successed"); + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Set transfer state failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_get_transfer_state(storage_adaptor_plugin_context_h context, + void *transfer_request_id, + void *request, + storage_adaptor_transfer_state_e *state, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_GET_TRANSFER_STATE); + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_number(message, param_index++, (pmnumber)(intptr_t)transfer_request_id); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Get transfer state successed"); + pmnumber st; + plugin_message_get_param_number(message, 1, &st); + if (NULL != state) { + *state = (storage_adaptor_transfer_state_e)st; + } + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Get transfer state failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_get_root_folder_path(storage_adaptor_plugin_context_h context, + void *request, + char **root_folder_path, + storage_adaptor_error_code_h *error, + void *response) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_GET_ROOT_FOLDER_PATH); + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + +/* int param_index = 1; */ + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if (0 == ret) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Get root folder path successed"); + char *path = NULL; + plugin_message_get_param_string(message, 1, &path); + if (NULL != root_folder_path) { + *root_folder_path = path; + } + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Get root folder path failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +/* ///////////// for 2.4 public API */ +storage_error_code_t storage_plugin_send_start_upload_task(storage_adaptor_plugin_context_h context, + int fd, + const char *upload_dir, + const char *file_path, + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_START_UPLOAD_TASK); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_number(message, param_index++, (pmnumber)fd); + plugin_message_set_param_string(message, param_index++, upload_dir); + plugin_message_set_param_string(message, param_index++, file_path); + plugin_message_set_param_bool(message, param_index++, need_progress); + + param_index = 1; + plugin_message_set_opt_param_number(message, param_index++, (pmnumber)(intptr_t)user_data); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if ((0 == ret) && (NULL != result_message)) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Upload file async successed"); + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Upload file async failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_start_download_task(storage_adaptor_plugin_context_h context, + const char *storage_dir, + const char *file_path, + int fd, + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_START_DOWNLOAD_TASK); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, storage_dir); + plugin_message_set_param_string(message, param_index++, file_path); + plugin_message_set_param_number(message, param_index++, (pmnumber)fd); + plugin_message_set_param_bool(message, param_index++, need_progress); + + param_index = 1; + plugin_message_set_opt_param_number(message, param_index++, (pmnumber)(intptr_t)user_data); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if ((0 == ret) && (NULL != result_message)) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Download file async successed"); + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Download file async failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_start_download_thumb_task(storage_adaptor_plugin_context_h context, + const char *storage_dir, + const char *file_path, + int fd, + int thumbnail_size, + bool need_progress, + storage_adaptor_error_code_h *error, + void *user_data) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_START_DOWNLOAD_THUMB_TASK); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_string(message, param_index++, storage_dir); + plugin_message_set_param_string(message, param_index++, file_path); + plugin_message_set_param_number(message, param_index++, (pmnumber)fd); + plugin_message_set_param_number(message, param_index++, (pmnumber)thumbnail_size); + plugin_message_set_param_bool(message, param_index++, need_progress); + + param_index = 1; + plugin_message_set_opt_param_number(message, param_index++, (pmnumber)(intptr_t)user_data); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if ((0 == ret) && (NULL != result_message)) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Download thumbnail async successed"); + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Download thumbnail async failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_cancel_upload_task(storage_adaptor_plugin_context_h context, + int fd, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_CANCEL_UPLOAD_TASK); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_number(message, param_index++, (pmnumber)fd); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if ((0 == ret) && (NULL != result_message)) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Upload file async successed"); + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Upload file async failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_cancel_download_task(storage_adaptor_plugin_context_h context, + int fd, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_CANCEL_DOWNLOAD_TASK); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_number(message, param_index++, (pmnumber)fd); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if ((0 == ret) && (NULL != result_message)) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Cancel upload file successed"); + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Cancel upload file failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +storage_error_code_t storage_plugin_send_cancel_download_thumb_task(storage_adaptor_plugin_context_h context, + int fd, + storage_adaptor_error_code_h *error) +{ + storage_adaptor_plugin_h plugin = NULL; + plugin = context->plugin_handle; + + int ret = 0; + plugin_message_h message = NULL; + ret = plugin_message_create(&message); + + if (ret == 0) { + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, + (pmnumber) context->context_id); + plugin_message_set_value_string(message, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, + STORAGE_PLUGIN_INTERFACE_CANCEL_DOWNLOAD_THUMB_TASK); + + plugin_message_set_value_number(message, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, + (pmnumber) PLUGIN_MESSAGE_TYPE_FUNCTION); + + int param_index = 1; + plugin_message_set_param_number(message, param_index++, (pmnumber)fd); + + plugin_message_h result_message = NULL; + ret = storage_adaptor_send_message_to_plugin_sync(plugin, message, &result_message); + + if ((0 == ret) && (NULL != result_message)) { + pmnumber ret_code; + plugin_message_get_value_number(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, &ret_code); + + ret = (int) ret_code; + char *ret_msg = NULL; + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + storage_adaptor_debug("Cancel download thumbnail successed"); + } else { + plugin_message_get_value_string(result_message, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, &ret_msg); + storage_adaptor_debug("Cancel download thumbnail failed (%d)(%s)", ret, ret_msg); + if (NULL != error) { + storage_adaptor_error_code_h error_code = storage_adaptor_create_error_code(ret, ret_msg); + *error = error_code; + } + free(ret_msg); + ret_msg = NULL; + } + plugin_message_destroy(result_message); + } + } else { + ret = STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL; + } + plugin_message_destroy(message); + + return ret; +} + +void storage_plugin_receive_download_state_changed_cb(int file_descriptor, + storage_adaptor_transfer_state_e state, + storage_adaptor_error_code_h error, + void *user_data) +{ + int ret = 0; + plugin_message_h m_callback = NULL; + + if ((0 != plugin_message_create(&m_callback)) || (NULL == m_callback)) { + LOGE("[%s/%d] Callback message create failed", __FUNCTION__, __LINE__); + return; + } + + const char *func_name = STORAGE_PLUGIN_CALLBACK_DOWNLOAD_FILE_ASYNC_CB; + + plugin_message_set_value_string(m_callback, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, func_name); + plugin_message_set_value_number(m_callback, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, PLUGIN_MESSAGE_TYPE_CALLBACK); + + if (NULL == error) { + plugin_message_set_value_number(m_callback, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)STORAGE_ADAPTOR_ERROR_NONE); + } else { + LOGD("[%s/%d] Callback's error value (%lld, %s)", __FUNCTION__, __LINE__, (long long int)error->code, error->msg); + plugin_message_set_value_number(m_callback, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, (pmnumber)error->code); + plugin_message_set_value_string(m_callback, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, error->msg); + } + + int param_idx = 1; + plugin_message_set_param_number(m_callback, param_idx++, (pmnumber)file_descriptor); + plugin_message_set_param_number(m_callback, param_idx++, (pmnumber)state); + + char *result = NULL; + int rcv_len; + + ret = plugin_message_serialize(m_callback, &result); + + if ((0 == ret) && (NULL != result)) { + LOGD("[%s/%d] Send callback data message to adaptor", __FUNCTION__, __LINE__); + int res_len = strlen(result); + rcv_len = write(g_child_plugin->wd, &res_len, sizeof(int)); + rcv_len = write(g_child_plugin->wd, result, sizeof(char) * res_len); + if (rcv_len <= 0) { + LOGE("[%s/%d] pipe socket writing error", __FUNCTION__, __LINE__); + } + } else { + LOGE("[%s/%d] Callback data message serialization failed", __FUNCTION__, __LINE__); + } + + plugin_message_destroy(m_callback); +} + +void storage_plugin_receive_upload_state_changed_cb(int file_descriptor, + storage_adaptor_transfer_state_e state, + storage_adaptor_file_info_h file_info, + storage_adaptor_error_code_h error, + void *user_data) +{ + int ret = 0; + plugin_message_h m_callback = NULL; + + if ((0 != plugin_message_create(&m_callback)) || (NULL == m_callback)) { + LOGE("[%s/%d] Callback message create failed", __FUNCTION__, __LINE__); + return; + } + + const char *func_name = STORAGE_PLUGIN_CALLBACK_UPLOAD_FILE_ASYNC_CB; + + plugin_message_set_value_string(m_callback, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, func_name); + plugin_message_set_value_number(m_callback, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, PLUGIN_MESSAGE_TYPE_CALLBACK); + + if (NULL == error) { + plugin_message_set_value_number(m_callback, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)STORAGE_ADAPTOR_ERROR_NONE); + } else { + LOGD("[%s/%d] Callback's error value (%lld, %s)", __FUNCTION__, __LINE__, (long long int)error->code, error->msg); + plugin_message_set_value_number(m_callback, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, (pmnumber)error->code); + plugin_message_set_value_string(m_callback, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, error->msg); + } + + int param_idx = 1; + plugin_message_set_param_number(m_callback, param_idx++, (pmnumber)file_descriptor); + plugin_message_set_param_number(m_callback, param_idx++, (pmnumber)state); + + if (NULL != file_info) { + LOGD("Insert file info to pipe message"); + int param_ret; + plugin_message_array_h file_info_message = NULL; + char message_array_type[20] = {0, }; + snprintf(message_array_type, 19, "%c%c%c%c%c%c%c%c%c", PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_STRING); + param_ret = plugin_message_array_create(message_array_type, &file_info_message); + if (0 == param_ret) { + _message_array_set_file_info(file_info_message, 1, file_info); + param_ret = plugin_message_set_param_array(m_callback, param_idx++, file_info_message); + plugin_message_array_destroy(file_info_message); + } + } + + char *result = NULL; + + ret = plugin_message_serialize(m_callback, &result); + + if ((0 == ret) && (NULL != result)) { + LOGD("[%s/%d] Send callback data message to adaptor", __FUNCTION__, __LINE__); + int res_len = strlen(result); + int rcv_len = write(g_child_plugin->wd, &res_len, sizeof(int)); + rcv_len = write(g_child_plugin->wd, result, sizeof(char) * res_len); + if (rcv_len <= 0) { + LOGE("[%s/%d] pipe socket writing error", __FUNCTION__, __LINE__); + } + } else { + LOGE("[%s/%d] Callback data message serialization failed", __FUNCTION__, __LINE__); + } + + plugin_message_destroy(m_callback); + +} + +void storage_plugin_receive_file_progress_cb(int file_descriptor, + unsigned long long progress_size_byte, + unsigned long long total_size_byte, + storage_adaptor_error_code_h error, + void *user_data) +{ + int ret = 0; + plugin_message_h m_callback = NULL; + + if ((0 != plugin_message_create(&m_callback)) || (NULL == m_callback)) { + LOGE("[%s/%d] Callback message create failed", __FUNCTION__, __LINE__); + return; + } + + const char *func_name = STORAGE_PLUGIN_CALLBACK_PROGRESS_CB; + + plugin_message_set_value_string(m_callback, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, func_name); + plugin_message_set_value_number(m_callback, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, PLUGIN_MESSAGE_TYPE_CALLBACK); + + if (NULL == error) { + plugin_message_set_value_number(m_callback, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)STORAGE_ADAPTOR_ERROR_NONE); + } else { + LOGD("[%s/%d] Callback's error value (%lld, %s)", __FUNCTION__, __LINE__, (long long int)error->code, error->msg); + plugin_message_set_value_number(m_callback, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, (pmnumber)error->code); + plugin_message_set_value_string(m_callback, PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, error->msg); + } + + int param_idx = 1; + plugin_message_set_param_number(m_callback, param_idx++, (pmnumber)file_descriptor); + plugin_message_set_param_number(m_callback, param_idx++, (pmnumber)progress_size_byte); + plugin_message_set_param_number(m_callback, param_idx++, (pmnumber)total_size_byte); + + char *result = NULL; + + ret = plugin_message_serialize(m_callback, &result); + + if ((0 == ret) && (NULL != result)) { + LOGD("[%s/%d] Send callback data message to adaptor", __FUNCTION__, __LINE__); + int res_len = strlen(result); + int rcv_len = write(g_child_plugin->wd, &res_len, sizeof(int)); + rcv_len = write(g_child_plugin->wd, result, sizeof(char) * res_len); + if (rcv_len <= 0) { + LOGE("[%s/%d] pipe socket writing error", __FUNCTION__, __LINE__); + } + } else { + LOGE("[%s/%d] Callback data message serialization failed", __FUNCTION__, __LINE__); + } + + plugin_message_destroy(m_callback); + +} + + +/* For forked plugin */ +void *_storage_plugin_request_collector(void *data) +{ + storage_adaptor_plugin_h plugin = (storage_adaptor_plugin_h) data; + + int rcv_len, buf_size; + char msg_buf[PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE] = {0, }; + + while (1) { + /* pre-read buf size */ + rcv_len = read(plugin->rd, &buf_size, sizeof(int)); + + if (rcv_len <= 0) { + LOGD("shutdown by adaptor disconnected"); + return NULL; + } + + /* allocates and read buf data */ + memset(msg_buf, 0, PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE); + buf_size %= (PLUGIN_MESSAGE_PROTOCOL_MAX_BUF_SIZE - 1); + rcv_len = read(plugin->rd, msg_buf, buf_size); + LOGD("read message [%s][len: %d]", msg_buf, rcv_len); + + if (rcv_len <= 0) { + LOGD("shutdown by adaptor disconnected"); + return NULL; + } + + char *result = NULL; + __storage_plugin_progress_command(plugin, msg_buf, &result); + + if (NULL != result) { + int res_len = strlen(result); + rcv_len = write(plugin->wd, &res_len, sizeof(int)); + rcv_len = write(plugin->wd, result, sizeof(char) * res_len); + } + /* transfer data to adaptor */ + } + return data; +} + +storage_adaptor_plugin_context_h __storage_plugin_get_context_by_context_id(storage_adaptor_plugin_h plugin, int context_id) +{ + if (NULL == plugin) { + return NULL; + } + + /* For forked plugin */ + storage_adaptor_plugin_context_h ctx = NULL; + int i, len; + len = g_list_length(plugin->contexts); + + for (i = 0; i < len; i++) { + ctx = (storage_adaptor_plugin_context_h) g_list_nth_data(plugin->contexts, i); + + if (context_id == ctx->context_id) { + return ctx; + } + } + return NULL; +} + +void __storage_plugin_progress_command(storage_adaptor_plugin_h plugin, char *order, char **result) +{ + int ret = 0; + plugin_message_h m_order = NULL; + plugin_message_h m_result = NULL; + + if ((NULL == order) || (plugin_message_deserialize(order, &m_order))) { + LOGE("[%s/%d] Message parse error", __FUNCTION__, __LINE__); + return; + } else if (plugin_message_create(&m_result)) { + plugin_message_destroy(m_order); + m_order = NULL; + + LOGE("[%s/%d] Message parse error", __FUNCTION__, __LINE__); + return; + } + + char *func_name = NULL; + int context_id = 0; + + pmnumber ctx, req, type; + + plugin_message_get_value_number(m_order, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, &ctx); + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_CONTEXT_ID, ctx); + plugin_message_get_value_number(m_order, PLUGIN_MESSAGE_ELEMENT_REQUEST_ID, &req); + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_REQUEST_ID, req); + plugin_message_get_value_string(m_order, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, &func_name); + plugin_message_set_value_string(m_result, PLUGIN_MESSAGE_ELEMENT_FUNCTION_NAME, func_name); + plugin_message_get_value_number(m_order, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, &type); + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_MESSAGE_TYPE, type); + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)STORAGE_ADAPTOR_ERROR_NONE); + context_id = (int) ctx; + storage_adaptor_plugin_context_h context = __storage_plugin_get_context_by_context_id(plugin, context_id); + + storage_adaptor_error_code_h error_code = NULL; + storage_adaptor_file_info_h file_info = NULL; + + if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_CREATE_CONTEXT, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_CREATE_CONTEXT))) { + LOGD(">>>>>> %s func start", func_name); + char *app_id = NULL; + char *app_secret = NULL; + char *access_token = NULL; + char *cid = NULL; + char *uid = NULL; + char *service_name = NULL; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &app_id); + plugin_message_get_param_string(m_order, param_idx++, &app_secret); + plugin_message_get_param_string(m_order, param_idx++, &access_token); + plugin_message_get_param_string(m_order, param_idx++, &cid); + plugin_message_get_param_string(m_order, param_idx++, &uid); + + LOGD("Call library function"); + context = storage_adaptor_create_plugin_context(plugin, + app_id, app_secret, access_token, cid, uid, ""); + + if (NULL == context) { + LOGE("[%s<%s>/%d] Could not create context", __FUNCTION__, func_name, __LINE__); +/* error_code = storage_adaptor_create_error_code((int64_t)STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL, */ +/* "Could not create context"); */ + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)STORAGE_ADAPTOR_ERROR_PLUGIN_INTERNAL); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + "Could not create context"); + } else { + LOGD("[%s<%s>/%d] Created context successfuly", __FUNCTION__, func_name, __LINE__); + context->context_id = context_id; + + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)STORAGE_ADAPTOR_ERROR_NONE); + } + + + free(app_id); + free(app_secret); + free(access_token); + free(uid); + free(service_name); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_DESTROY_CONTEXT, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_DESTROY_CONTEXT))) { + LOGD(">>>>>> %s func start", func_name); + if (NULL == context) { + LOGE("[%s<%s>/%d] Could not found context", __FUNCTION__, func_name, __LINE__); + } else { + LOGD("[%s<%s>/%d] function success", __FUNCTION__, func_name, __LINE__); + storage_adaptor_destroy_plugin_context(plugin, context); + + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)STORAGE_ADAPTOR_ERROR_NONE); + } + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_MAKE_DIRECTORY, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_MAKE_DIRECTORY))) { + LOGD(">>>>>> %s func start", func_name); + char *parent_path = NULL; + char *folder_path = NULL; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &folder_path); + + LOGD("Call library function"); + ret = plugin->handle->make_directory(context, parent_path, folder_path, + NULL, &file_info, &error_code, NULL); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + int param_idx = 1; + + if (NULL != file_info) { + LOGD("Insert file info to pipe message"); + int param_ret; + plugin_message_array_h file_info_message = NULL; + char message_array_type[20] = {0, }; + snprintf(message_array_type, 19, "%c%c%c%c%c%c%c%c%c", PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_STRING); + param_ret = plugin_message_array_create(message_array_type, &file_info_message); + if (0 == param_ret) { + _message_array_set_file_info(file_info_message, 1, file_info); + param_ret = plugin_message_set_param_array(m_result, param_idx++, file_info_message); + plugin_message_array_destroy(file_info_message); + } + } + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(folder_path); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_REMOVE_DIRECTORY, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_REMOVE_DIRECTORY))) { + LOGD(">>>>>> %s func start", func_name); + char *parent_path = NULL; + char *folder_path = NULL; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &folder_path); + + LOGD("Call library function"); + ret = plugin->handle->remove_directory(context, parent_path, folder_path, + NULL, &file_info, &error_code, NULL); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + int param_idx = 1; + + if (NULL != file_info) { + LOGD("Insert file info to pipe message"); + int param_ret; + plugin_message_array_h file_info_message = NULL; + char message_array_type[20] = {0, }; + snprintf(message_array_type, 19, "%c%c%c%c%c%c%c%c%c", PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_STRING); + param_ret = plugin_message_array_create(message_array_type, &file_info_message); + if (0 == param_ret) { + _message_array_set_file_info(file_info_message, 1, file_info); + param_ret = plugin_message_set_param_array(m_result, param_idx++, file_info_message); + plugin_message_array_destroy(file_info_message); + } + } + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(folder_path); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_GET_LIST, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_GET_LIST))) { + LOGD(">>>>>> %s func start", func_name); + char *parent_path = NULL; + char *folder_path = NULL; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &folder_path); + + storage_adaptor_file_info_h *file_list = NULL; + int file_list_len = 0; + LOGD("Call library function"); + ret = plugin->handle->list(context, parent_path, folder_path, + NULL, &file_list, &file_list_len, &error_code, NULL); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + int param_idx = 1; + + if ((NULL != file_list) && (0 < file_list_len)) { + LOGD("Insert file list to pipe message (length : %d)", file_list_len); + int param_ret, i; + plugin_message_array_h file_info_message = NULL; + char message_array_type[20] = {0, }; + snprintf(message_array_type, 19, "%c%c%c%c%c%c%c%c%c", PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_STRING); + param_ret = plugin_message_array_create(message_array_type, &file_info_message); + if (0 == param_ret) { + for (i = 0; i < file_list_len; i++) { + _message_array_set_file_info(file_info_message, (i + 1), file_list[i]); + storage_adaptor_destroy_file_info(&(file_list[i])); + } + free(file_list); + file_list = NULL; + param_ret = plugin_message_set_param_array(m_result, param_idx++, file_info_message); + param_ret = plugin_message_set_param_number(m_result, param_idx++, (pmnumber)file_list_len); + plugin_message_array_destroy(file_info_message); + } + } + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(folder_path); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_UPLOAD_FILE_SYNC, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_UPLOAD_FILE_SYNC))) { + LOGD(">>>>>> %s func start", func_name); + char *parent_path = NULL; + char *folder_path = NULL; + char *local_path = NULL; + pmnumber publish; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &folder_path); + plugin_message_get_param_string(m_order, param_idx++, &local_path); + plugin_message_get_param_number(m_order, param_idx++, &publish); + + LOGD("Call library function"); + ret = plugin->handle->upload_file_sync(context, parent_path, folder_path, local_path, (int)publish, + NULL, &file_info, &error_code, NULL); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + int param_idx = 1; + + if (NULL != file_info) { + LOGD("Insert file info to pipe message"); + int param_ret; + plugin_message_array_h file_info_message = NULL; + char message_array_type[20] = {0, }; + snprintf(message_array_type, 19, "%c%c%c%c%c%c%c%c%c", PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_STRING); + param_ret = plugin_message_array_create(message_array_type, &file_info_message); + if (0 == param_ret) { + _message_array_set_file_info(file_info_message, 1, file_info); + param_ret = plugin_message_set_param_array(m_result, param_idx++, file_info_message); + plugin_message_array_destroy(file_info_message); + } + } + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(folder_path); + free(local_path); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_DOWNLOAD_FILE_SYNC, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_DOWNLOAD_FILE_SYNC))) { + LOGD(">>>>>> %s func start", func_name); + char *parent_path = NULL; + char *folder_path = NULL; + char *local_path = NULL; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &folder_path); + plugin_message_get_param_string(m_order, param_idx++, &local_path); + + LOGD("Call library function"); + ret = plugin->handle->download_file_sync(context, parent_path, folder_path, local_path, + NULL, &error_code, NULL); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(folder_path); + free(local_path); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_DELETE_FILE, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_DELETE_FILE))) { + LOGD(">>>>>> %s func start", func_name); + char *parent_path = NULL; + char *folder_path = NULL; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &folder_path); + + LOGD("Call library function"); + ret = plugin->handle->delete_file(context, parent_path, folder_path, + NULL, &file_info, &error_code, NULL); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + int param_idx = 1; + + if (NULL != file_info) { + LOGD("Insert file info to pipe message"); + int param_ret; + plugin_message_array_h file_info_message = NULL; + char message_array_type[20] = {0, }; + snprintf(message_array_type, 19, "%c%c%c%c%c%c%c%c%c", PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_STRING); + param_ret = plugin_message_array_create(message_array_type, &file_info_message); + if (0 == param_ret) { + _message_array_set_file_info(file_info_message, 1, file_info); + param_ret = plugin_message_set_param_array(m_result, param_idx++, file_info_message); + plugin_message_array_destroy(file_info_message); + } + } + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(folder_path); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_MOVE_DIRECTORY, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_MOVE_DIRECTORY))) { + LOGD(">>>>>> %s func start", func_name); + char *parent_path = NULL; + char *folder_path = NULL; + char *dst_parent_path = NULL; + char *dst_folder_path = NULL; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &folder_path); + plugin_message_get_param_string(m_order, param_idx++, &dst_parent_path); + plugin_message_get_param_string(m_order, param_idx++, &dst_folder_path); + + LOGD("Call library function"); + ret = plugin->handle->move_directory(context, parent_path, folder_path, dst_parent_path, dst_folder_path, + NULL, &file_info, &error_code, NULL); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + int param_idx = 1; + + if (NULL != file_info) { + LOGD("Insert file info to pipe message"); + int param_ret; + plugin_message_array_h file_info_message = NULL; + char message_array_type[20] = {0, }; + snprintf(message_array_type, 19, "%c%c%c%c%c%c%c%c%c", PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_STRING); + param_ret = plugin_message_array_create(message_array_type, &file_info_message); + if (0 == param_ret) { + _message_array_set_file_info(file_info_message, 1, file_info); + param_ret = plugin_message_set_param_array(m_result, param_idx++, file_info_message); + plugin_message_array_destroy(file_info_message); + } + } + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(folder_path); + free(dst_parent_path); + free(dst_folder_path); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_MOVE_FILE, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_MOVE_FILE))) { + LOGD(">>>>>> %s func start", func_name); + char *parent_path = NULL; + char *file_path = NULL; + char *dst_parent_path = NULL; + char *dst_file_path = NULL; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &file_path); + plugin_message_get_param_string(m_order, param_idx++, &dst_parent_path); + plugin_message_get_param_string(m_order, param_idx++, &dst_file_path); + + LOGD("Call library function"); + ret = plugin->handle->move_file(context, parent_path, file_path, dst_parent_path, dst_file_path, + NULL, &file_info, &error_code, NULL); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + int param_idx = 1; + + if (NULL != file_info) { + LOGD("Insert file info to pipe message"); + int param_ret; + plugin_message_array_h file_info_message = NULL; + char message_array_type[20] = {0, }; + snprintf(message_array_type, 19, "%c%c%c%c%c%c%c%c%c", PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_STRING, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_NUM, + PLUGIN_DATA_TYPE_STRING); + param_ret = plugin_message_array_create(message_array_type, &file_info_message); + if (0 == param_ret) { + _message_array_set_file_info(file_info_message, 1, file_info); + param_ret = plugin_message_set_param_array(m_result, param_idx++, file_info_message); + plugin_message_array_destroy(file_info_message); + } + } + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(file_path); + free(dst_parent_path); + free(dst_file_path); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_START_UPLOAD_TASK, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_START_UPLOAD_TASK))) { + LOGD(">>>>>> %s func start", func_name); + pmnumber fd, user_data; + char *parent_path = NULL; + char *file_name = NULL; + bool need_progress = false; + + int param_idx = 1; + plugin_message_get_param_number(m_order, param_idx++, &fd); + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &file_name); + plugin_message_get_param_bool(m_order, param_idx++, &need_progress); + + param_idx = 1; + plugin_message_get_param_number(m_order, param_idx++, &user_data); + + LOGD("Call library function"); + ret = plugin->handle->start_upload_task(context, (int)fd, parent_path, file_name, need_progress, + &error_code, (void *)(intptr_t)user_data); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(file_name); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_START_DOWNLOAD_TASK, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_START_DOWNLOAD_TASK))) { + LOGD(">>>>>> %s func start", func_name); + pmnumber fd, user_data; + char *parent_path = NULL; + char *file_name = NULL; + bool need_progress = false; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &file_name); + plugin_message_get_param_number(m_order, param_idx++, &fd); + plugin_message_get_param_bool(m_order, param_idx++, &need_progress); + + param_idx = 1; + plugin_message_get_param_number(m_order, param_idx++, &user_data); + + LOGD("Call library function"); + ret = plugin->handle->start_download_task(context, parent_path, file_name, (int)fd, need_progress, + &error_code, (void *)(intptr_t)user_data); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(file_name); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_START_DOWNLOAD_THUMB_TASK, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_START_DOWNLOAD_THUMB_TASK))) { + LOGD(">>>>>> %s func start", func_name); + pmnumber fd, thumb_size, user_data; + char *parent_path = NULL; + char *file_name = NULL; + bool need_progress = false; + + int param_idx = 1; + plugin_message_get_param_string(m_order, param_idx++, &parent_path); + plugin_message_get_param_string(m_order, param_idx++, &file_name); + plugin_message_get_param_number(m_order, param_idx++, &fd); + plugin_message_get_param_number(m_order, param_idx++, &thumb_size); + plugin_message_get_param_bool(m_order, param_idx++, &need_progress); + + param_idx = 1; + plugin_message_get_param_number(m_order, param_idx++, &user_data); + + LOGD("Call library function"); + ret = plugin->handle->start_download_thumb_task(context, parent_path, file_name, (int)fd, (int)thumb_size, need_progress, + &error_code, (void *)(intptr_t)user_data); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + free(parent_path); + free(file_name); + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_CANCEL_UPLOAD_TASK, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_CANCEL_UPLOAD_TASK))) { + LOGD(">>>>>> %s func start", func_name); + pmnumber fd; + + int param_idx = 1; + plugin_message_get_param_number(m_order, param_idx++, &fd); + + LOGD("Call library function"); + ret = plugin->handle->cancel_upload_task(context, (int)fd, &error_code); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_CANCEL_DOWNLOAD_TASK, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_CANCEL_DOWNLOAD_TASK))) { + LOGD(">>>>>> %s func start", func_name); + pmnumber fd; + + int param_idx = 1; + plugin_message_get_param_number(m_order, param_idx++, &fd); + + LOGD("Call library function"); + ret = plugin->handle->cancel_download_task(context, (int)fd, &error_code); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + LOGD("<<<<<< %s func end", func_name); + } else if (0 == strncmp(STORAGE_PLUGIN_INTERFACE_CANCEL_DOWNLOAD_THUMB_TASK, + func_name, strlen(STORAGE_PLUGIN_INTERFACE_CANCEL_DOWNLOAD_THUMB_TASK))) { + LOGD(">>>>>> %s func start", func_name); + pmnumber fd; + + int param_idx = 1; + plugin_message_get_param_number(m_order, param_idx++, &fd); + + LOGD("Call library function"); + ret = plugin->handle->cancel_download_thumb_task(context, (int)fd, &error_code); + + if (STORAGE_ADAPTOR_ERROR_NONE == ret) { + LOGD("API success"); + + plugin_message_set_value_number(m_result, PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } else if (NULL != error_code) { + LOGD("API failed, error_code[%lld / %s]", (long long int)error_code->code, error_code->msg); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)error_code->code); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + error_code->msg ? error_code->msg : ""); + free(error_code->msg); + free(error_code); + } else { + LOGD("API failed ret_code[%d]", ret); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, (pmnumber)ret); + } + + LOGD("<<<<<< %s func end", func_name); + } else { /* TODO Next */ + LOGD(">>>>>> %s func start", func_name); + plugin_message_set_value_number(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_CODE, + (pmnumber)STORAGE_ADAPTOR_ERROR_UNSUPPORTED); + plugin_message_set_value_string(m_result, + PLUGIN_MESSAGE_ELEMENT_RESULT_MESSAGE, + "Unsupported operation"); + LOGD("<<<<<< %s func end", func_name); + } + + storage_adaptor_destroy_file_info(&file_info); + free(func_name); + + char *result_data = NULL; + plugin_message_serialize(m_result, &result_data); + plugin_message_destroy(m_result); + plugin_message_destroy(m_order); + + *result = result_data; +} diff --git a/storage-adaptor.manifest b/storage-adaptor.manifest new file mode 100644 index 0000000..57e24b4 --- /dev/null +++ b/storage-adaptor.manifest @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/storage-adaptor.pc.in b/storage-adaptor.pc.in new file mode 100644 index 0000000..72adc91 --- /dev/null +++ b/storage-adaptor.pc.in @@ -0,0 +1,10 @@ +prefix=@PREFIX@ +libdir=@PREFIX@/lib +includedir=@PREFIX@/include + +Name: @NAME@ +Description: storage adaptor API +Requires: glib-2.0 dlog +Version: @VERSION@ +Libs: -L${libdir} -lstorage-adaptor -pthread +Cflags: -I${includedir}/storage-adaptor -- 2.7.4