src/package_info.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22
  23 #include <package-manager.h>
  24 #include <pkgmgr-info.h>
  25 #include <tzplatform_config.h>
  26
  27 #include "package_info.h"
  28 #include "package_manager.h"
  29 #include "package_manager_internal.h"
  30
  31 struct package_info_s {
  32         char *package;
  33         pkgmgrinfo_pkginfo_h pkgmgr_pkginfo;
  34 };
  35
  36 struct package_cert_info_s {
  37         char *package;
  38         pkgmgrinfo_certinfo_h pkgmgrinfo_certinfo;
  39 };
  40
  41 typedef struct _foreach_app_context_ {
  42         package_info_app_cb callback;
  43         void *user_data;
  44 } foreach_app_context_s;
  45
  46 API int package_info_create(const char *package, package_info_h *package_info)
  47 {
  48         package_info_h package_info_created;
  49         pkgmgrinfo_pkginfo_h pkgmgr_pkginfo;
  50
  51         if (package == NULL || package_info == NULL)
  52                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
  53
  54         if (pkgmgrinfo_pkginfo_get_pkginfo(package, &pkgmgr_pkginfo) != PKGMGR_R_OK)
  55                 return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
  56
  57         package_info_created = calloc(1, sizeof(struct package_info_s));
  58
  59         if (package_info_created == NULL) {
  60                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgr_pkginfo);
  61                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
  62         }
  63
  64         package_info_created->package = strdup(package);
  65
  66         if (package_info_created->package == NULL) {
  67                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgr_pkginfo);
  68                 free(package_info_created);
  69                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
  70         }
  71
  72         package_info_created->pkgmgr_pkginfo = pkgmgr_pkginfo;
  73
  74         *package_info = package_info_created;
  75
  76         return PACKAGE_MANAGER_ERROR_NONE;
  77 }
  78
  79 static int package_info_foreach_app_cb(const pkgmgrinfo_appinfo_h handle, void *user_data)
  80 {
  81         char *appid = NULL;
  82         pkgmgrinfo_app_component comp;
  83         foreach_app_context_s *foreach_app_context = user_data;
  84         int ret = 0;
  85         bool r;
  86
  87         if (handle == NULL || foreach_app_context == NULL) {
  88                 package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
  89                 return PKGMGR_R_EINVAL;
  90         }
  91
  92         ret = pkgmgrinfo_appinfo_get_appid(handle, &appid);
  93         if (ret < 0)
  94                 return PKGMGR_R_ERROR;
  95
  96         ret = pkgmgrinfo_appinfo_get_component(handle, &comp);
  97         if (ret < 0)
  98                 return PKGMGR_R_ERROR;
  99
 100         r = foreach_app_context->callback(comp, appid, foreach_app_context->user_data);
 101
 102         return (r == true) ? PKGMGR_R_OK : PKGMGR_R_ERROR;
 103 }
 104
 105 API int package_info_foreach_app_from_package(package_info_h package_info, package_info_app_component_type_e comp_type, package_info_app_cb callback, void *user_data)
 106 {
 107         foreach_app_context_s foreach_app_context = {
 108                 .callback = callback,
 109                 .user_data = user_data,
 110         };
 111
 112         if (package_info == NULL || callback == NULL)
 113                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 114
 115         if (comp_type == PACKAGE_INFO_ALLAPP)
 116                 pkgmgrinfo_appinfo_get_list(package_info->pkgmgr_pkginfo, PMINFO_ALL_APP, package_info_foreach_app_cb, &foreach_app_context);
 117         if (comp_type == PACKAGE_INFO_UIAPP)
 118                 pkgmgrinfo_appinfo_get_list(package_info->pkgmgr_pkginfo, PMINFO_UI_APP, package_info_foreach_app_cb, &foreach_app_context);
 119         if (comp_type == PACKAGE_INFO_SERVICEAPP)
 120                 pkgmgrinfo_appinfo_get_list(package_info->pkgmgr_pkginfo, PMINFO_SVC_APP, package_info_foreach_app_cb, &foreach_app_context);
 121         return PACKAGE_MANAGER_ERROR_NONE;
 122 }
 123
 124 API int package_info_destroy(package_info_h package_info)
 125 {
 126         if (package_info == NULL)
 127                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 128
 129         free(package_info->package);
 130
 131         pkgmgrinfo_pkginfo_destroy_pkginfo(package_info->pkgmgr_pkginfo);
 132
 133         free(package_info);
 134
 135         return PACKAGE_MANAGER_ERROR_NONE;
 136 }
 137
 138 API int package_info_get_package(package_info_h package_info, char **package)
 139 {
 140         char *package_dup;
 141
 142         if (package_info == NULL || package == NULL)
 143                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 144
 145         package_dup = strdup(package_info->package);
 146
 147         if (package_dup == NULL)
 148                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 149
 150         *package = package_dup;
 151
 152         return PACKAGE_MANAGER_ERROR_NONE;
 153 }
 154
 155 API int package_info_get_main_app_id(package_info_h package_info, char **main_app_id)
 156 {
 157         char *mainappid_dup;
 158         char *pkg_info_value;
 159
 160         if (package_info == NULL || main_app_id == NULL)
 161                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 162
 163         if (pkgmgrinfo_pkginfo_get_mainappid(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 164                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 165
 166         mainappid_dup = strdup(pkg_info_value);
 167         if (mainappid_dup == NULL)
 168                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 169
 170         *main_app_id = mainappid_dup;
 171
 172         return PACKAGE_MANAGER_ERROR_NONE;
 173 }
 174
 175 API int package_info_get_label(package_info_h package_info, char **label)
 176 {
 177         char *pkg_info_value = NULL;
 178         char *label_dup = NULL;
 179
 180         if (package_info == NULL || label == NULL)
 181                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 182
 183         if (pkgmgrinfo_pkginfo_get_label(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 184                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 185
 186         if (!pkg_info_value)
 187                 goto END;
 188
 189         label_dup = strdup(pkg_info_value);
 190
 191         if (label_dup == NULL)
 192                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 193
 194 END:
 195         *label = label_dup;
 196
 197         return PACKAGE_MANAGER_ERROR_NONE;
 198 }
 199
 200 API int package_info_get_icon(package_info_h package_info, char **path)
 201 {
 202         char *pkg_info_value = NULL;
 203         char *icon_dup = NULL;
 204
 205         if (package_info == NULL || path == NULL)
 206                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 207
 208         if (pkgmgrinfo_pkginfo_get_icon(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 209                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 210
 211         if (!pkg_info_value)
 212                 goto END;
 213
 214         icon_dup = strdup(pkg_info_value);
 215
 216         if (icon_dup == NULL)
 217                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 218
 219 END:
 220         *path = icon_dup;
 221
 222         return PACKAGE_MANAGER_ERROR_NONE;
 223 }
 224
 225 API int package_info_get_version(package_info_h package_info, char **version)
 226 {
 227         char *pkg_info_value = NULL;
 228         char *ver_dup = NULL;
 229
 230         if (package_info == NULL || version == NULL)
 231                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 232
 233         if (pkgmgrinfo_pkginfo_get_version(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 234                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 235
 236         if (!pkg_info_value)
 237                 goto END;
 238
 239         ver_dup = strdup(pkg_info_value);
 240
 241         if (ver_dup == NULL)
 242                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 243
 244 END:
 245         *version = ver_dup;
 246
 247         return PACKAGE_MANAGER_ERROR_NONE;
 248 }
 249
 250 API int package_info_get_type(package_info_h package_info, char **type)
 251 {
 252         char *pkg_info_value = NULL;
 253         char *type_dup = NULL;
 254
 255         if (package_info == NULL || type == NULL)
 256                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 257
 258         if (pkgmgrinfo_pkginfo_get_type(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 259                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 260
 261         if (!pkg_info_value)
 262                 goto END;
 263
 264         type_dup = strdup(pkg_info_value);
 265
 266         if (type_dup == NULL)
 267                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 268
 269 END:
 270         *type = type_dup;
 271
 272         return PACKAGE_MANAGER_ERROR_NONE;
 273 }
 274
 275 API int package_info_get_installed_storage(package_info_h package_info, package_info_installed_storage_type_e *storage)
 276 {
 277         int ret = 0;
 278         pkgmgrinfo_installed_storage pkg_info_value;
 279
 280         if (package_info == NULL || storage == NULL)
 281                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 282
 283         ret = pkgmgrinfo_pkginfo_get_installed_storage(package_info->pkgmgr_pkginfo, &pkg_info_value);
 284         if (ret < 0)
 285                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 286
 287         if (pkg_info_value == PMINFO_INTERNAL_STORAGE)
 288                 *storage = PACKAGE_INFO_INTERNAL_STORAGE;
 289         else if (pkg_info_value == PMINFO_EXTERNAL_STORAGE)
 290                 *storage = PACKAGE_INFO_EXTERNAL_STORAGE;
 291
 292         return PACKAGE_MANAGER_ERROR_NONE;
 293 }
 294
 295 API int package_info_get_root_path(package_info_h package_info, char **path)
 296 {
 297         char *pkg_info_value = NULL;
 298         char *path_dup = NULL;
 299
 300         if (package_info == NULL || path == NULL)
 301                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 302
 303         if (pkgmgrinfo_pkginfo_get_root_path(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 304                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 305
 306         if (!pkg_info_value)
 307                 goto END;
 308
 309         path_dup = strdup(pkg_info_value);
 310
 311         if (path_dup == NULL)
 312                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 313
 314 END:
 315         *path = path_dup;
 316
 317         return PACKAGE_MANAGER_ERROR_NONE;
 318 }
 319
 320 API int package_info_get_tep_name(package_info_h package_info, char **name)
 321 {
 322         char *tepname_tmp = NULL;
 323         int retval = 0;
 324
 325         if (package_info == NULL || package_info->package == NULL || name == NULL)
 326                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 327
 328         retval = check_privilege(PRIVILEGE_PACKAGE_MANAGER_ADMIN);
 329         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 330                 return retval;
 331
 332         if (pkgmgrinfo_pkginfo_get_tep_name(package_info->pkgmgr_pkginfo, &tepname_tmp) != PMINFO_R_OK)
 333                 return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
 334
 335         if (tepname_tmp != NULL)
 336                 *name = strdup(tepname_tmp);
 337
 338         if (*name == NULL)
 339                 return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 340
 341         return PACKAGE_MANAGER_ERROR_NONE;
 342 }
 343
 344 API int package_info_is_system_package(package_info_h package_info, bool *system)
 345 {
 346         bool pkg_info_value = false;
 347
 348         if (package_info == NULL || system == NULL)
 349                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 350
 351         if (pkgmgrinfo_pkginfo_is_system(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 352                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 353
 354         *system = pkg_info_value;
 355
 356         return PACKAGE_MANAGER_ERROR_NONE;
 357 }
 358
 359 API int package_info_is_removable_package(package_info_h package_info, bool *removable)
 360 {
 361         bool pkg_info_value = false;
 362
 363         if (package_info == NULL || removable == NULL)
 364                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 365
 366         if (pkgmgrinfo_pkginfo_is_removable(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 367                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 368
 369         *removable = pkg_info_value;
 370
 371         return PACKAGE_MANAGER_ERROR_NONE;
 372 }
 373
 374 API int package_info_is_preload_package(package_info_h package_info, bool *preload)
 375 {
 376         bool pkg_info_value = false;
 377
 378         if (package_info == NULL || preload == NULL)
 379                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 380
 381         if (pkgmgrinfo_pkginfo_is_preload(package_info->pkgmgr_pkginfo, &pkg_info_value) != PKGMGR_R_OK)
 382                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 383
 384         *preload = pkg_info_value;
 385
 386         return PACKAGE_MANAGER_ERROR_NONE;
 387 }
 388
 389 API int package_info_is_equal(package_info_h lhs, package_info_h rhs, bool *equal)
 390 {
 391         if (lhs == NULL || rhs == NULL || equal == NULL)
 392                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 393
 394         if (!strcmp(lhs->package, rhs->package))
 395                 *equal = true;
 396         else
 397                 *equal = false;
 398
 399         return PACKAGE_MANAGER_ERROR_NONE;
 400 }
 401
 402 API int package_info_is_accessible(package_info_h package_info, bool *accessible)
 403 {
 404         int ret = 0;
 405         bool pkg_info_value = false;
 406
 407         if (package_info == NULL || accessible == NULL)
 408                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 409
 410         ret = pkgmgrinfo_pkginfo_is_accessible(package_info->pkgmgr_pkginfo, &pkg_info_value);
 411         if (ret < 0)
 412                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 413
 414
 415         *accessible = pkg_info_value;
 416
 417         return PACKAGE_MANAGER_ERROR_NONE;
 418 }
 419
 420 API int package_info_get_installed_time(package_info_h package_info, int *installed_time)
 421 {
 422         int ret;
 423         int time_value;
 424
 425         if (package_info == NULL || installed_time == NULL)
 426                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 427
 428         ret = pkgmgrinfo_pkginfo_get_installed_time(package_info->pkgmgr_pkginfo, &time_value);
 429         if (ret < 0)
 430                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 431
 432         *installed_time = time_value;
 433
 434         return PACKAGE_MANAGER_ERROR_NONE;
 435 }
 436
 437 API int package_info_clone(package_info_h *clone, package_info_h package_info)
 438 {
 439         int retval;
 440
 441         if (clone == NULL || package_info == NULL)
 442                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 443
 444         retval = package_info_create(package_info->package, clone);
 445
 446         if (retval != PACKAGE_MANAGER_ERROR_NONE)
 447                 return package_manager_error(retval, __FUNCTION__, NULL);
 448
 449         return PACKAGE_MANAGER_ERROR_NONE;
 450 }
 451
 452 API int package_info_foreach_cert_info(package_info_h package_info, package_info_cert_info_cb callback, void *user_data)
 453 {
 454         int retval;
 455         pkgmgrinfo_certinfo_h handle = NULL;
 456         int i = 0;
 457         const char *cert_value = NULL;
 458
 459         if (package_info == NULL || callback == NULL)
 460                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 461
 462         retval = pkgmgrinfo_pkginfo_create_certinfo(&handle);
 463         if (retval != PMINFO_R_OK)
 464                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 465
 466         retval = pkgmgrinfo_pkginfo_load_certinfo(package_info->package, handle, getuid());
 467         if (retval != PMINFO_R_OK) {
 468                 pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 469                 return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 470         }
 471
 472         for (i = 0; i <= PACKAGE_INFO_DISTRIBUTOR2_SIGNER_CERT; i++) {
 473                 retval = pkgmgrinfo_pkginfo_get_cert_value(handle, i, &cert_value);
 474                 if (retval != PMINFO_R_OK) {
 475                         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 476                         return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
 477                 }
 478
 479                 if (cert_value && strncmp(cert_value, "(null)", strlen("(null)"))) {
 480                         retval = callback(package_info, (package_cert_type_e)i, cert_value, user_data);
 481                         if (!retval)
 482                                 break;
 483                 }
 484
 485                 cert_value = NULL;
 486         }
 487
 488         pkgmgrinfo_pkginfo_destroy_certinfo(handle);
 489
 490         return PACKAGE_MANAGER_ERROR_NONE;
 491 }
 492
 493 API int package_info_foreach_privilege_info(package_info_h package_info, package_info_privilege_info_cb callback, void *user_data)
 494 {
 495         int ret = 0;
 496
 497         if (package_info == NULL || callback == NULL)
 498                 return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 499
 500         ret = pkgmgrinfo_pkginfo_foreach_privilege(package_info->pkgmgr_pkginfo, (pkgmgrinfo_pkg_privilege_list_cb)callback, user_data);
 501
 502         return ret;
 503 }
 504
 505 int package_info_create_with_pkginfo(pkgmgrinfo_pkginfo_h pkg_handle, package_info_h *package_info)
 506 {
 507         package_info_h pkg_info = NULL;
 508         char *pkg_name = NULL;
 509
 510         pkgmgrinfo_pkginfo_get_pkgid(pkg_handle, &pkg_name);
 511         if (pkg_name == NULL)
 512                 return PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
 513
 514         pkg_info = calloc(1, sizeof(struct package_info_s));
 515         if (pkg_info == NULL)
 516                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 517
 518         pkg_info->package = strdup(pkg_name);
 519         if (pkg_info->package == NULL) {
 520                 free(pkg_info);
 521                 return PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY;
 522         }
 523
 524         pkg_info->pkgmgr_pkginfo = pkg_handle;
 525         *package_info = pkg_info;
 526
 527         return PACKAGE_MANAGER_ERROR_NONE;
 528 }
 529
 530 int package_info_destroy_handle(package_info_h handle)
 531 {
 532         if (handle == NULL)
 533                 return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
 534
 535         free(handle->package);
 536         free(handle);
 537
 538         return PACKAGE_MANAGER_ERROR_NONE;
 539 }