X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fpkgmgrinfo_pkginfo.c;h=413b566d8000e4e05a9636edf1cddb19cb7dd429;hb=0351902ae4693aa31e73fe53d509e66683aa904d;hp=3a2c3a6e7b5112c17ad2f047b04e922a750edb9d;hpb=0a199f703ce5d584ffb77c6d71bd2ae8b1d100b9;p=platform%2Fcore%2Fappfw%2Fpkgmgr-info.git diff --git a/src/pkgmgrinfo_pkginfo.c b/src/pkgmgrinfo_pkginfo.c index 3a2c3a6..413b566 100644 --- a/src/pkgmgrinfo_pkginfo.c +++ b/src/pkgmgrinfo_pkginfo.c @@ -86,6 +86,16 @@ static void __destroy_each_node(gpointer data, gpointer user_data) node = NULL; } +static void __destroy_metadata_node(gpointer data) +{ + pkgmgrinfo_metadata_node_x *node = (pkgmgrinfo_metadata_node_x *)data; + if (node->key) + free(node->key); + if (node->value) + free(node->value); + free(node); +} + static void __cleanup_pkginfo(pkgmgr_pkginfo_x *data) { ret_if(data == NULL); @@ -107,7 +117,7 @@ long long _pkgmgr_calculate_dir_size(char *dirname) int q = 0; /*quotient*/ int r = 0; /*remainder*/ DIR *dp = NULL; - struct dirent ep, *result; + struct dirent *ep; struct stat fileinfo; char abs_filename[FILENAME_MAX] = { 0, }; retvm_if(dirname == NULL, PMINFO_R_ERROR, "dirname is NULL"); @@ -118,22 +128,20 @@ long long _pkgmgr_calculate_dir_size(char *dirname) return -1; } - for (ret = readdir_r(dp, &ep, &result); - ret == 0 && result != NULL; - ret = readdir_r(dp, &ep, &result)) { - if (!strcmp(ep.d_name, ".") || - !strcmp(ep.d_name, "..")) { + for (ep = readdir(dp); ep != NULL; ep = readdir(dp)) { + if (!strcmp(ep->d_name, ".") || + !strcmp(ep->d_name, "..")) { continue; } snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname, - ep.d_name); + ep->d_name); if (lstat(abs_filename, &fileinfo) < 0) perror(abs_filename); else { if (S_ISDIR(fileinfo.st_mode)) { total += fileinfo.st_size; - if (strcmp(ep.d_name, ".") - && strcmp(ep.d_name, "..")) { + if (strcmp(ep->d_name, ".") + && strcmp(ep->d_name, "..")) { ret = _pkgmgr_calculate_dir_size (abs_filename); total = total + ret; @@ -220,7 +228,7 @@ static const char join_privilege_info[] = " ON pi.package=package_privilege_info.package"; static int _get_filtered_query(pkgmgrinfo_filter_x *filter, - const char *locale, char **query, GList **bind_params) + const char *locale, uid_t uid, char **query, GList **bind_params) { int joined = 0; char buf[MAX_QUERY_LEN] = { '\0' }; @@ -232,19 +240,19 @@ static int _get_filtered_query(pkgmgrinfo_filter_x *filter, if (filter == NULL) return PMINFO_R_OK; - len += strlen(" WHERE 1=1 "); strncat(buf, " WHERE 1=1 ", MAX_QUERY_LEN - len - 1); + len += strlen(" WHERE 1=1 "); for (list = filter->list; list; list = list->next) { - joined |= __get_filter_condition(list->data, &condition, + joined |= __get_filter_condition(list->data, uid, &condition, bind_params); if (condition == NULL) continue; - len += strlen(" AND "); strncat(buf, " AND ", MAX_QUERY_LEN - len - 1); + len += strlen(" AND "); - len += strlen(condition); strncat(buf, condition, sizeof(buf) - len - 1); + len += strlen(condition); free(condition); condition = NULL; } @@ -306,20 +314,40 @@ static int __bind_params(sqlite3_stmt *stmt, GList *params) return PMINFO_R_OK; } +static bool __check_package_storage_status(pkgmgrinfo_filter_x *tmp_filter) +{ + GSList *tmp_list = NULL; + pkgmgrinfo_node_x *tmp_node = NULL; + int property = -1; + + property = _pminfo_pkginfo_convert_to_prop_bool(PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE); + for (tmp_list = tmp_filter->list; tmp_list != NULL; + tmp_list = g_slist_next(tmp_list)) { + tmp_node = (pkgmgrinfo_node_x *)tmp_list->data; + if (property == tmp_node->prop) { + if (strcmp(tmp_node->value, "true") == 0) + return true; + else + return false; + } + } + return true; +} + static int _pkginfo_get_packages(uid_t uid, const char *locale, pkgmgrinfo_filter_x *filter, int flag, GHashTable *packages) { static const char query_raw[] = - "SELECT DISTINCT pi.package, pi.package_version, " - "pi.install_location, pi.package_removable, " - "pi.package_preload, pi.package_readonly, pi.package_update, " - "pi.package_appsetting, pi.package_system, pi.package_type, " - "pi.package_size, pi.installed_time, pi.installed_storage, " - "pi.storeclient_id, pi.mainapp_id, pi.package_url, " - "pi.root_path, pi.csc_path, pi.package_nodisplay, " - "pi.package_api_version, pi.package_support_disable, " - "pi.package_tep_name, pi.package_zip_mount_file, pi.external_path, " - "pi.package_support_mode"; + "SELECT DISTINCT pi.package, pi.installed_storage, pi.external_path"; + static const char query_basic[] = + ", pi.package_version, pi.install_location, " + "pi.package_removable, pi.package_preload, pi.package_readonly, " + "pi.package_update, pi.package_appsetting, pi.package_system, " + "pi.package_type, pi.package_size, pi.installed_time, " + "pi.storeclient_id, pi.mainapp_id, pi.package_url, pi.root_path, " + "pi.csc_path, pi.package_nodisplay, pi.package_api_version, " + "pi.package_support_disable, pi.package_tep_name, " + "pi.package_zip_mount_file, pi.package_support_mode"; static const char query_author[] = ", pi.author_name, pi.author_email, pi.author_href"; static const char query_label[] = @@ -346,16 +374,18 @@ static int _pkginfo_get_packages(uid_t uid, const char *locale, author_x *author = NULL; GList *bind_params = NULL; sqlite3 *db; - sqlite3_stmt *stmt; + sqlite3_stmt *stmt = NULL; pkgmgrinfo_filter_x *tmp_filter = NULL; + bool is_check_storage = true; + const uid_t global_user_uid = GLOBAL_USER; dbpath = getUserPkgParserDBPathUID(uid); if (dbpath == NULL) return PMINFO_R_ERROR; - ret = sqlite3_open_v2(dbpath, &db, SQLITE_OPEN_READONLY, NULL); + ret = __open_db(dbpath, &db, SQLITE_OPEN_READONLY); if (ret != SQLITE_OK) { - _LOGD("failed to open db: %d", ret); + _LOGD("failed to open db(%s): %d", dbpath, ret); free(dbpath); return PMINFO_R_ERROR; } @@ -371,8 +401,14 @@ static int _pkginfo_get_packages(uid_t uid, const char *locale, } } + is_check_storage = __check_package_storage_status(tmp_filter); + query_len = strlen(query_raw); snprintf(query, MAX_QUERY_LEN - 1, "%s", query_raw); + if (flag & PMINFO_APPINFO_GET_BASICINFO) { + strncat(query, query_basic, MAX_QUERY_LEN - query_len - 1); + query_len += strlen(query_basic); + } if (flag & PMINFO_PKGINFO_GET_AUTHOR) { strncat(query, query_author, MAX_QUERY_LEN - query_len - 1); query_len += strlen(query_author); @@ -396,7 +432,7 @@ static int _pkginfo_get_packages(uid_t uid, const char *locale, strncat(query, query_from_clause, MAX_QUERY_LEN - query_len - 1); query_len += strlen(query_from_clause); - ret = _get_filtered_query(tmp_filter, locale, &constraints, &bind_params); + ret = _get_filtered_query(tmp_filter, locale, uid, &constraints, &bind_params); if (ret != PMINFO_R_OK) { LOGE("Failed to get WHERE clause"); goto catch; @@ -422,53 +458,48 @@ static int _pkginfo_get_packages(uid_t uid, const char *locale, info = calloc(1, sizeof(package_x)); if (info == NULL) { LOGE("out of memory"); - sqlite3_finalize(stmt); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; + ret = PMINFO_R_ERROR; + goto catch; } idx = 0; _save_column_str(stmt, idx++, &info->package); - if (g_hash_table_contains(packages, - (gconstpointer)info->package)) { - free(info->package); - free(info); - continue; - } - _save_column_str(stmt, idx++, &info->version); - _save_column_str(stmt, idx++, &info->installlocation); - _save_column_str(stmt, idx++, &info->removable); - _save_column_str(stmt, idx++, &info->preload); - _save_column_str(stmt, idx++, &info->readonly); - _save_column_str(stmt, idx++, &info->update); - _save_column_str(stmt, idx++, &info->appsetting); - _save_column_str(stmt, idx++, &info->system); - _save_column_str(stmt, idx++, &info->type); - _save_column_str(stmt, idx++, &info->package_size); - _save_column_str(stmt, idx++, &info->installed_time); _save_column_str(stmt, idx++, &info->installed_storage); - _save_column_str(stmt, idx++, &info->storeclient_id); - _save_column_str(stmt, idx++, &info->mainapp_id); - _save_column_str(stmt, idx++, &info->package_url); - _save_column_str(stmt, idx++, &info->root_path); - _save_column_str(stmt, idx++, &info->csc_path); - _save_column_str(stmt, idx++, &info->nodisplay_setting); - _save_column_str(stmt, idx++, &info->api_version); - _save_column_str(stmt, idx++, &info->support_disable); - _save_column_str(stmt, idx++, &info->tep_name); - _save_column_str(stmt, idx++, &info->zip_mount_file); _save_column_str(stmt, idx++, &info->external_path); - _save_column_str(stmt, idx++, &info->support_mode); + + if (flag & PMINFO_APPINFO_GET_BASICINFO) { + _save_column_str(stmt, idx++, &info->version); + _save_column_str(stmt, idx++, &info->installlocation); + _save_column_str(stmt, idx++, &info->removable); + _save_column_str(stmt, idx++, &info->preload); + _save_column_str(stmt, idx++, &info->readonly); + _save_column_str(stmt, idx++, &info->update); + _save_column_str(stmt, idx++, &info->appsetting); + _save_column_str(stmt, idx++, &info->system); + _save_column_str(stmt, idx++, &info->type); + _save_column_str(stmt, idx++, &info->package_size); + _save_column_str(stmt, idx++, &info->installed_time); + _save_column_str(stmt, idx++, &info->storeclient_id); + _save_column_str(stmt, idx++, &info->mainapp_id); + _save_column_str(stmt, idx++, &info->package_url); + _save_column_str(stmt, idx++, &info->root_path); + _save_column_str(stmt, idx++, &info->csc_path); + _save_column_str(stmt, idx++, &info->nodisplay_setting); + _save_column_str(stmt, idx++, &info->api_version); + _save_column_str(stmt, idx++, &info->support_disable); + _save_column_str(stmt, idx++, &info->tep_name); + _save_column_str(stmt, idx++, &info->zip_mount_file); + _save_column_str(stmt, idx++, &info->support_mode); + } + info->for_all_users = - strdup((uid != GLOBAL_USER) ? "false" : "true"); + strdup((uid != global_user_uid) ? "false" : "true"); if (flag & PMINFO_PKGINFO_GET_AUTHOR) { /* TODO : author should be retrieved at package_localized_info */ author = calloc(1, sizeof(author_x)); if (author == NULL) { - pkgmgrinfo_basic_free_package(info); - sqlite3_finalize(stmt); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; + ret = PMINFO_R_ERROR; + goto catch; } _save_column_str(stmt, idx++, &author->text); _save_column_str(stmt, idx++, &author->email); @@ -481,10 +512,8 @@ static int _pkginfo_get_packages(uid_t uid, const char *locale, _save_column_str(stmt, idx++, &tmp_record); if (_add_label_info_into_list(locale, tmp_record, &info->label)) { - pkgmgrinfo_basic_free_package(info); - sqlite3_finalize(stmt); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; + ret = PMINFO_R_ERROR; + goto catch; } } @@ -492,10 +521,8 @@ static int _pkginfo_get_packages(uid_t uid, const char *locale, tmp_record = NULL; _save_column_str(stmt, idx++, &tmp_record); if (_add_icon_info_into_list(locale, tmp_record, &info->icon)) { - pkgmgrinfo_basic_free_package(info); - sqlite3_finalize(stmt); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; + ret = PMINFO_R_ERROR; + goto catch; } } @@ -504,24 +531,21 @@ static int _pkginfo_get_packages(uid_t uid, const char *locale, _save_column_str(stmt, idx++, &tmp_record); if (_pkginfo_add_description_info_into_list(locale, tmp_record, &info->description)) { - pkgmgrinfo_basic_free_package(info); - sqlite3_finalize(stmt); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; + ret = PMINFO_R_ERROR; + goto catch; } } if (flag & PMINFO_PKGINFO_GET_PRIVILEGE) { if (_pkginfo_get_privilege(db, info->package, &info->privileges)) { - pkgmgrinfo_basic_free_package(info); - sqlite3_finalize(stmt); - sqlite3_close_v2(db); - return PMINFO_R_ERROR; + ret = PMINFO_R_ERROR; + goto catch; } } - if (__pkginfo_check_installed_storage(info) != PMINFO_R_OK) { + if (is_check_storage && + __pkginfo_check_installed_storage(info) != PMINFO_R_OK) { ret = PMINFO_R_ERROR; pkgmgrinfo_basic_free_package(info); info = NULL; @@ -546,7 +570,8 @@ catch: g_list_free_full(bind_params, free); sqlite3_close_v2(db); - sqlite3_finalize(stmt); + if (stmt) + sqlite3_finalize(stmt); return ret; } @@ -581,6 +606,7 @@ static int _pkginfo_get_filtered_foreach_pkginfo(uid_t uid, ret = pkgmgrinfo_pkginfo_filter_create((void *)&tmp_filter); if (ret != PMINFO_R_OK) { _LOGE("Failed to create filter"); + g_hash_table_destroy(list); return PMINFO_R_ERROR; } } @@ -589,10 +615,11 @@ static int _pkginfo_get_filtered_foreach_pkginfo(uid_t uid, pkgmgrinfo_pkginfo_filter_add_bool(tmp_filter, PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false); - ret = _pkginfo_get_packages(uid, locale, filter, flag, list); + ret = _pkginfo_get_packages(uid, locale, tmp_filter, + flag | PMINFO_PKGINFO_GET_BASICINFO, list); if (ret == PMINFO_R_OK && uid != GLOBAL_USER) - ret = _pkginfo_get_packages(GLOBAL_USER, locale, filter, - flag, list); + ret = _pkginfo_get_packages(GLOBAL_USER, locale, tmp_filter, + flag | PMINFO_PKGINFO_GET_BASICINFO, list); if (ret != PMINFO_R_OK) { g_hash_table_destroy(list); @@ -640,7 +667,6 @@ static int _pkgmgrinfo_get_pkginfo(const char *pkgid, uid_t uid, list = g_hash_table_new(g_str_hash, g_str_equal); if (list == NULL) { - pkgmgrinfo_pkginfo_filter_destroy(filter); free(locale); return PMINFO_R_ERROR; } @@ -677,8 +703,6 @@ static int _pkgmgrinfo_get_pkginfo(const char *pkgid, uid_t uid, *handle = info; return ret; - - } API int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char *pkgid, uid_t uid, @@ -833,6 +857,13 @@ API int pkgmgrinfo_pkginfo_get_usr_all_pkginfo(const char *pkgid, uid_t uid, return PMINFO_R_ERROR; } + ret = pkgmgrinfo_pkginfo_filter_add_bool(filter, + PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE, false); + if (ret != PMINFO_R_OK) { + pkgmgrinfo_pkginfo_filter_destroy(filter); + return PMINFO_R_ERROR; + } + ret = _pkgmgrinfo_get_pkginfo(pkgid, uid, filter, handle); pkgmgrinfo_pkginfo_filter_destroy(filter); @@ -855,13 +886,25 @@ API int pkgmgrinfo_pkginfo_get_all_pkginfo(const char *pkgid, API int pkgmgrinfo_pkginfo_get_usr_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb, int flag, void *user_data, uid_t uid) { + int ret; + pkgmgrinfo_pkginfo_filter_h filter; + if (pkg_list_cb == NULL) { LOGE("invalid parameter"); return PMINFO_R_EINVAL; } - return _pkginfo_get_filtered_foreach_pkginfo(uid, NULL, flag, + /* create an empty filter */ + ret = pkgmgrinfo_pkginfo_filter_create(&filter); + if (ret != PMINFO_R_OK) + return ret; + + ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter, flag, pkg_list_cb, user_data); + + pkgmgrinfo_pkginfo_filter_destroy(filter); + + return ret; } API int pkgmgrinfo_pkginfo_get_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb, @@ -874,13 +917,25 @@ API int pkgmgrinfo_pkginfo_get_list_full(pkgmgrinfo_pkg_list_cb pkg_list_cb, API int pkgmgrinfo_pkginfo_get_usr_list(pkgmgrinfo_pkg_list_cb pkg_list_cb, void *user_data, uid_t uid) { + int ret; + pkgmgrinfo_pkginfo_filter_h filter; + if (pkg_list_cb == NULL) { LOGE("invalid parameter"); return PMINFO_R_EINVAL; } - return _pkginfo_get_filtered_foreach_pkginfo(uid, NULL, + /* create an empty filter */ + ret = pkgmgrinfo_pkginfo_filter_create(&filter); + if (ret != PMINFO_R_OK) + return ret; + + ret = _pkginfo_get_filtered_foreach_pkginfo(uid, filter, PMINFO_PKGINFO_GET_ALL, pkg_list_cb, user_data); + + pkgmgrinfo_pkginfo_filter_destroy(filter); + + return ret; } API int pkgmgrinfo_pkginfo_get_list(pkgmgrinfo_pkg_list_cb pkg_list_cb, @@ -1044,6 +1099,24 @@ API int pkgmgrinfo_pkginfo_get_zip_mount_file(pkgmgrinfo_pkginfo_h handle, char return PMINFO_R_OK; } +API int pkgmgrinfo_pkginfo_get_external_image_path(pkgmgrinfo_pkginfo_h handle, char **ext_image_path) +{ + pkgmgr_pkginfo_x *info = (pkgmgr_pkginfo_x *)handle; + + retvm_if(handle == NULL, PMINFO_R_EINVAL, "pkginfo handle is NULL\n"); + retvm_if(ext_image_path == NULL, PMINFO_R_EINVAL, "Argument supplied to hold return value is NULL\n"); + + if (info->pkg_info == NULL) + return PMINFO_R_ERROR; + + if (info->pkg_info->external_path == NULL) + return PMINFO_R_ENOENT; + + *ext_image_path = (char *)info->pkg_info->external_path; + + return PMINFO_R_OK; +} + API int pkgmgrinfo_pkginfo_get_install_location(pkgmgrinfo_pkginfo_h handle, pkgmgrinfo_install_location *location) { char *val; @@ -1576,7 +1649,7 @@ API int pkgmgrinfo_pkginfo_filter_create(pkgmgrinfo_pkginfo_filter_h *handle) retvm_if(handle == NULL, PMINFO_R_EINVAL, "Filter handle output parameter is NULL\n"); - filter = (pkgmgrinfo_filter_x*)calloc(1, sizeof(pkgmgrinfo_filter_x)); + filter = (pkgmgrinfo_filter_x *)calloc(1, sizeof(pkgmgrinfo_filter_x)); if (filter == NULL) { _LOGE("Out of Memory!!!"); return PMINFO_R_ERROR; @@ -1598,6 +1671,8 @@ API int pkgmgrinfo_pkginfo_filter_destroy(pkgmgrinfo_pkginfo_filter_h handle) g_slist_free(filter->list); } + g_slist_free_full(filter->list_metadata, __destroy_metadata_node); + free(filter); return PMINFO_R_OK; @@ -1770,6 +1845,7 @@ API int pkgmgrinfo_pkginfo_usr_filter_count(pkgmgrinfo_pkginfo_filter_h handle, PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false); if (ret != PMINFO_R_OK) { free(locale); + g_hash_table_destroy(list); return PMINFO_R_ERROR; } } @@ -1841,3 +1917,126 @@ API int pkgmgrinfo_pkginfo_foreach_privilege(pkgmgrinfo_pkginfo_h handle, } return PMINFO_R_OK; } + +int __compare_package_version(const char *version, int *major, + int *minor, int *macro, int *nano) +{ + char *version_temp = NULL; + char *major_str = NULL; + char *minor_str = NULL; + char *macro_str = NULL; + char *nano_str = NULL; + char *save_str = NULL; + + if (version == NULL || major == NULL || minor == NULL || + macro == NULL || nano == NULL) { + return PMINFO_R_EINVAL; + } + + version_temp = strdup(version); + if (version_temp == NULL) { + LOGE("Out of memory"); + return PMINFO_R_ERROR; + } + + major_str = strtok_r(version_temp, ".", &save_str); + if (major_str == NULL) { + _LOGE("major version is NULL"); + free(version_temp); + return PMINFO_R_ERROR; + } + + minor_str = strtok_r(NULL, ".", &save_str); + if (minor_str == NULL) { + _LOGE("minor version is NULL"); + free(version_temp); + return PMINFO_R_ERROR; + } + + *major = atoi(major_str); + *minor = atoi(minor_str); + *macro = 0; + *nano = 0; + macro_str = strtok_r(NULL, ".", &save_str); + if (macro_str == NULL) { + _LOGD("macro version is NULL"); + } else { + *macro = atoi(macro_str); + nano_str = strtok_r(NULL, ".", &save_str); + if (nano_str) { + *nano = atoi(nano_str); + _LOGD("nano version exists"); + } + } + _LOGD("version = [%s] -> major = [%d], minor = [%d]," \ + " macro = [%d], nano = [%d]", version, *major, + *minor, *macro, *nano); + + free(version_temp); + + return PMINFO_R_OK; +} + +API int pkgmgrinfo_compare_package_version(const char *current_version, + const char *target_version, + pkgmgrinfo_version_compare_type *res) +{ + int ret = 0; + int current_version_major = 0; + int current_version_minor = 0; + int current_version_macro = 0; + int current_version_nano = 0; + int target_version_major = 0; + int target_version_minor = 0; + int target_version_macro = 0; + int target_version_nano = 0; + + if (current_version == NULL || target_version == NULL || + res == NULL) { + _LOGE("Invalid parameter"); + return PMINFO_R_EINVAL; + } + + ret = __compare_package_version(target_version, + &target_version_major, &target_version_minor, + &target_version_macro, &target_version_nano); + if (ret < 0) { + _LOGE("Failed to compare target version(%d)", ret); + return PMINFO_R_ERROR; + } + + ret = __compare_package_version(current_version, + ¤t_version_major, ¤t_version_minor, + ¤t_version_macro, ¤t_version_nano); + if (ret < 0) { + _LOGE("Failed to compare current version(%d)", ret); + return PMINFO_R_ERROR; + } + + _LOGD("new[%d.%d.%d.%d] old[%d.%d.%d.%d]", target_version_major, + target_version_minor, target_version_macro, + target_version_nano, current_version_major, + current_version_minor, current_version_macro, + target_version_nano); + + if (target_version_major > current_version_major) + *res = PMINFO_VERSION_NEW; + else if (target_version_major < current_version_major) + *res = PMINFO_VERSION_OLD; + else if (target_version_minor > current_version_minor) + *res = PMINFO_VERSION_NEW; + else if (target_version_minor < current_version_minor) + *res = PMINFO_VERSION_OLD; + else if (target_version_macro > current_version_macro) + *res = PMINFO_VERSION_NEW; + else if (target_version_macro < current_version_macro) + *res = PMINFO_VERSION_OLD; + else if (target_version_nano > current_version_nano) + *res = PMINFO_VERSION_NEW; + else if (target_version_nano < current_version_nano) + *res = PMINFO_VERSION_OLD; + else + *res = PMINFO_VERSION_SAME; + + return PMINFO_R_OK; +}