src/agent/download-agent-interface.c

   1 /*
   2  * Download Agent
   3  *
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jungki Kwak <jungki.kwak@samsung.com>, Keunsoon Lee <keunsoon.lee@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  * @file                download-agent-interface.c
  21  * @brief               Interface  for Download Agent.
  22  * @author              Keunsoon Lee(keunsoon.lee@samsung.com)
  23  * @author              Jungki Kwak(jungki.kwak@samsung.com)
  24  ***/
  25
  26 #include "download-agent-interface.h"
  27 #include "download-agent-debug.h"
  28 #include "download-agent-utils.h"
  29 #include "download-agent-http-mgr.h"
  30 #include "download-agent-http-misc.h"
  31 #include "download-agent-client-mgr.h"
  32 #include "download-agent-dl-mgr.h"
  33 #include "download-agent-basic.h"
  34 #include "download-agent-file.h"
  35 #include "download-agent-installation.h"
  36
  37 int da_init(
  38         da_client_cb_t *da_client_callback,
  39         da_download_managing_method download_method)
  40 {
  41         da_result_t ret = DA_RESULT_OK;
  42
  43         DA_LOG_FUNC_START(Default);
  44
  45         if (!da_client_callback) {
  46                 ret = DA_ERR_INVALID_ARGUMENT;
  47                 return ret;
  48         }
  49
  50         ret = init_log_mgr();
  51         if (ret != DA_RESULT_OK)
  52                 goto ERR;
  53
  54         ret = init_client_app_mgr();
  55         if (ret != DA_RESULT_OK)
  56                 goto ERR;
  57
  58         ret = reg_client_app(da_client_callback, download_method);
  59         if (ret != DA_RESULT_OK)
  60                 goto ERR;
  61
  62         ret = init_http_mgr();
  63         if (ret != DA_RESULT_OK)
  64                 goto ERR;
  65
  66         ret = init_download_mgr();
  67         if (ret != DA_RESULT_OK)
  68                 goto ERR;
  69
  70         ret = create_temp_saved_dir();
  71         if (ret != DA_RESULT_OK)
  72                 goto ERR;
  73
  74 ERR:
  75         if (DA_RESULT_OK != ret)
  76                 da_deinit();
  77
  78         DA_LOG_CRITICAL(Default, "Return ret = %d", ret);
  79
  80         return ret;
  81 }
  82
  83 /* TODO:: deinit should clean up all the clients... */
  84 int da_deinit()
  85 {
  86         da_result_t ret = DA_RESULT_OK;
  87         char *client_dir_path = DA_NULL;
  88
  89         DA_LOG_FUNC_START(Default);
  90         if (DA_FALSE == is_this_client_available()) {
  91                 ret = DA_ERR_INVALID_CLIENT;
  92                 return ret;
  93         }
  94
  95         deinit_http_mgr();
  96         deinit_download_mgr();
  97
  98         ret = get_client_download_path(&client_dir_path);
  99         if (ret == DA_RESULT_OK) {
 100                 ret = clean_files_from_dir(client_dir_path);
 101
 102                 if (client_dir_path) {
 103                         free(client_dir_path);
 104                         client_dir_path = DA_NULL;
 105                 }
 106         }
 107
 108         dereg_client_app();
 109         DA_LOG(Default, "====== da_deinit EXIT =====");
 110
 111         return ret;
 112 }
 113
 114 int da_start_download(
 115         const char *url,
 116         da_handle_t *da_dl_req_id)
 117 {
 118         da_result_t ret = DA_RESULT_OK;
 119
 120         DA_LOG_FUNC_START(Default);
 121
 122         DA_LOG(Default, "url = %s", url);
 123
 124         *da_dl_req_id = DA_INVALID_ID;
 125
 126         if (DA_FALSE == is_this_client_available()) {
 127                 ret = DA_ERR_INVALID_CLIENT;
 128                 goto ERR;
 129         }
 130
 131         if (DA_FALSE == is_valid_url(url, &ret))
 132                 goto ERR;
 133
 134         ret = start_download(url, da_dl_req_id);
 135         if (ret != DA_RESULT_OK)
 136                 goto ERR;
 137
 138 ERR:
 139         DA_LOG_CRITICAL(Default, "Return: Dl req id = %d, ret = %d", *da_dl_req_id, ret);
 140         return ret;
 141 }
 142
 143 int da_start_download_with_extension(
 144         const char              *url,
 145         da_handle_t     *da_dl_req_id,
 146         ...
 147 )
 148 {
 149         da_result_t ret = DA_RESULT_OK;
 150         va_list argptr;
 151         char *property_name = NULL;
 152         int req_header_count = 0;
 153         int i = 0;
 154
 155         extension_data_t extension_data;
 156
 157         DA_LOG_FUNC_START(Default);
 158
 159         DA_LOG(Default, "url = %s", url);
 160
 161         *da_dl_req_id = DA_INVALID_ID;
 162         extension_data.request_header= NULL;
 163         extension_data.request_header_count = NULL;
 164         extension_data.install_path = NULL;
 165         extension_data.file_name = NULL;
 166         extension_data.user_data = NULL;
 167
 168         if (DA_FALSE == is_this_client_available()) {
 169                 ret = DA_ERR_INVALID_CLIENT;
 170                 goto ERR;
 171         }
 172
 173         if (DA_FALSE == is_valid_url(url, &ret))
 174                 goto ERR;
 175
 176         va_start(argptr, da_dl_req_id);
 177         property_name = va_arg(argptr, char*);
 178
 179         // FIXME How about changing type for property_name enum?
 180         if (!property_name) {
 181                 DA_LOG_ERR(Default, "No property input!");
 182                 ret = DA_ERR_INVALID_ARGUMENT;
 183         } else {
 184                 while (property_name && (ret == DA_RESULT_OK)) {
 185                         DA_LOG_VERBOSE(Default, "property_name = [%s]", property_name);
 186
 187                         if (!strncmp(property_name, DA_FEATURE_USER_DATA, strlen(DA_FEATURE_USER_DATA))) {
 188                                 extension_data.user_data = va_arg(argptr, void*);
 189                                 if (extension_data.user_data) {
 190                                         property_name = va_arg(argptr, char*);
 191                                 } else {
 192                                         DA_LOG_ERR(Default, "No property value for DA_FEATURE_USER_DATA!");
 193                                         ret = DA_ERR_INVALID_ARGUMENT;
 194                                 }
 195                         } else if (!strncmp(property_name, DA_FEATURE_INSTALL_PATH, strlen(DA_FEATURE_INSTALL_PATH))) {
 196                                 extension_data.install_path = va_arg(argptr, const char*);
 197                                 if (extension_data.install_path) {
 198                                         property_name = va_arg(argptr, char*);
 199                                 } else {
 200                                         DA_LOG_ERR(Default, "No property value for DA_FEATURE_INSTALL_PATH!");
 201                                         ret = DA_ERR_INVALID_ARGUMENT;
 202                                 }
 203                         } else if (!strncmp(property_name, DA_FEATURE_FILE_NAME, strlen(DA_FEATURE_FILE_NAME))) {
 204                                 extension_data.file_name = va_arg(argptr, const char*);
 205                                 if (extension_data.file_name) {
 206                                         property_name = va_arg(argptr, char*);
 207                                 } else {
 208                                         DA_LOG_ERR(Default, "No property value for DA_FEATURE_FILE_NAME!");
 209                                         ret = DA_ERR_INVALID_ARGUMENT;
 210                                 }
 211                         } else if (!strncmp(property_name, DA_FEATURE_REQUEST_HEADER, strlen(DA_FEATURE_REQUEST_HEADER))) {
 212                                 extension_data.request_header = va_arg(argptr, const char **);
 213                                 extension_data.request_header_count = va_arg(argptr, const int *);
 214                                 if (extension_data.request_header &&
 215                                                 extension_data.request_header_count) {
 216                                         property_name = va_arg(argptr, char *);
 217                                 } else {
 218                                         DA_LOG_ERR(Default, "No property value for DA_FEATURE_REQUEST_HEADER!");
 219                                         ret = DA_ERR_INVALID_ARGUMENT;
 220                                 }
 221                         } else {
 222                                 DA_LOG_ERR(Default, "Unknown property name; [%s]", property_name);
 223                                 ret = DA_ERR_INVALID_ARGUMENT;
 224                         }
 225                 }
 226         }
 227
 228         va_end(argptr);
 229
 230         if (ret != DA_RESULT_OK)
 231                 goto ERR;
 232
 233         if (extension_data.request_header_count) {
 234                 DA_LOG_VERBOSE(Default, "input request_header_count = [%d]",
 235                         *(extension_data.request_header_count));
 236                 for (i = 0; i < *(extension_data.request_header_count); i++)
 237                 {
 238                         if (extension_data.request_header[i]) {
 239                                 req_header_count++;
 240                                 DA_LOG_VERBOSE(Default, "request_header = [%s]",
 241                                         extension_data.request_header[i]);
 242                         }
 243                 }
 244                 DA_LOG(Default, "actual request_header_count = [%d]", req_header_count);
 245                 if (*(extension_data.request_header_count) != req_header_count) {
 246                         DA_LOG_ERR(Default, "Request header count is not matched with number of request header array");
 247                         extension_data.request_header = NULL;
 248                         extension_data.request_header_count = NULL;
 249                 }
 250         }
 251
 252         if (extension_data.install_path)
 253                 DA_LOG_VERBOSE(Default, "install path = [%s]", extension_data.install_path);
 254
 255         if (extension_data.file_name)
 256                 DA_LOG_VERBOSE(Default, "file_name = [%s]", extension_data.file_name);
 257
 258         ret = start_download_with_extension(url, da_dl_req_id, &extension_data);
 259
 260 ERR:
 261         DA_LOG_CRITICAL(Default, "Return: Dl req id = %d, ret = %d", *da_dl_req_id, ret);
 262         return ret;
 263 }
 264
 265 int da_cancel_download(da_handle_t da_dl_req_id)
 266 {
 267         da_result_t ret = DA_RESULT_OK;
 268
 269         DA_LOG_FUNC_START(Default);
 270
 271         DA_LOG_VERBOSE(Default, "Cancel for dl_req_id = %d", da_dl_req_id);
 272
 273         if (DA_FALSE == is_this_client_available()) {
 274                 ret = DA_ERR_INVALID_CLIENT;
 275                 goto ERR;
 276         }
 277
 278         ret = cancel_download(da_dl_req_id);
 279
 280 ERR:
 281         DA_LOG_CRITICAL(Default, "Return: Cancel id = %d, ret = %d", da_dl_req_id, ret);
 282         return ret;
 283 }
 284
 285 int da_suspend_download(da_handle_t da_dl_req_id)
 286 {
 287         da_result_t ret = DA_RESULT_OK;
 288
 289         DA_LOG_FUNC_START(Default);
 290
 291         DA_LOG_VERBOSE(Default, "Suspend for dl_req_id = %d", da_dl_req_id);
 292
 293         if (DA_FALSE == is_this_client_available()) {
 294                 ret = DA_ERR_INVALID_CLIENT;
 295                 goto ERR;
 296         }
 297         ret = suspend_download(da_dl_req_id);
 298
 299 ERR:
 300         DA_LOG_CRITICAL(Default, "Return: Suspend id = %d, ret = %d", da_dl_req_id, ret);
 301         return ret;
 302 }
 303
 304 int da_resume_download(da_handle_t da_dl_req_id)
 305 {
 306         da_result_t ret = DA_RESULT_OK;
 307
 308         DA_LOG_FUNC_START(Default);
 309
 310         DA_LOG_VERBOSE(Default, "Resume for dl_req_id = %d", da_dl_req_id);
 311
 312         if (DA_FALSE == is_this_client_available()) {
 313                 ret = DA_ERR_INVALID_CLIENT;
 314                 goto ERR;
 315         }
 316         ret = resume_download(da_dl_req_id);
 317
 318 ERR:
 319         DA_LOG_CRITICAL(Default, "Return: Resume id = %d, ret = %d", da_dl_req_id, ret);
 320         return ret;
 321 }
 322