backend-lib/src/librpminternals.c

   1 /*
   2  * rpm-installer
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <stdarg.h>
  27 #include <unistd.h>
  28 #include <sys/wait.h>
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <regex.h>
  32 #include <dlog.h>
  33 /*rpm specific headers*/
  34 #include <rpmlib.h>
  35 #include <header.h>
  36 #include <rpmts.h>
  37 #include <rpmdb.h>
  38 #include <rpmlog.h>
  39 #include "librpminternals.h"
  40
  41 /* This is backend lib's filter string for dlogutil*/
  42 #define LOCAL_LOG_TAG    "librpm"
  43 int logging = 0x0004;
  44 #ifdef LOG_IN_FILE
  45 #define RPM_INSTALLER_LIBRPM_LOG_FILE "/tmp/librpm"
  46 FILE *logfile = NULL;
  47 #endif
  48
  49 void _librpm_print_msg(int type, int exetype, char *format, ...)
  50 {
  51         char buffer[FILENAME_MAX] = { 0 };
  52         char tbuffer[FILENAME_MAX] = { 0 };
  53
  54         int nbuffer;
  55         va_list args;
  56         va_start(args, format);
  57         nbuffer = vsnprintf(tbuffer, FILENAME_MAX, format, args);
  58         va_end(args);
  59
  60         switch (type) {
  61         case DEBUG_ERR:
  62                 LOG(LOG_ERROR, LOCAL_LOG_TAG, "%s", tbuffer);
  63                 break;
  64         case DEBUG_RESULT:
  65                 LOG(LOG_WARN, LOCAL_LOG_TAG, "%s", tbuffer);
  66                 break;
  67         case DEBUG_INFO:
  68                 LOG(LOG_DEBUG, LOCAL_LOG_TAG, "%s", tbuffer);
  69         default:
  70                 break;
  71         }
  72
  73         if (logging == 0)
  74                 return;
  75
  76         if (DEBUG_ERR == (logging & type)) {
  77                 nbuffer = snprintf(buffer, FILENAME_MAX, "ERROR:%s", tbuffer);
  78                 vfprintf(stderr, format, args);
  79         } else if (DEBUG_INFO == (logging & type)) {
  80                 nbuffer = snprintf(buffer, FILENAME_MAX, "INFO:%s", tbuffer);
  81                 vfprintf(stdout, format, args);
  82         } else if (DEBUG_RESULT == (logging & type)) {
  83                 nbuffer = snprintf(buffer, FILENAME_MAX, "RESULT:%s", tbuffer);
  84                 vfprintf(stdout, format, args);
  85         } else {
  86                 return;
  87         }
  88
  89 #ifdef LOG_IN_FILE
  90         if (logfile != NULL)
  91                 fwrite(buffer, sizeof(char), strlen(buffer), logfile);
  92 #endif                          /*LOG_IN_FILE */
  93 }
  94
  95 int _librpm_app_is_installed(char *pkgid)
  96 {
  97         rpmts ts = NULL;
  98         int ret = 0;
  99         Header hdr = NULL;
 100         int found = 0;
 101         rpmdbMatchIterator mi;
 102         rpmtd tn = NULL;
 103         rpmRC rc;
 104
 105         tn = rpmtdNew();
 106         ts = rpmtsCreate();
 107 /*
 108         hdr = headerNew();
 109 */
 110
 111         mi = rpmtsInitIterator(ts, RPMDBI_PACKAGES, NULL, 0);
 112         while (NULL != (hdr = rpmdbNextIterator(mi))) {
 113
 114                 hdr = headerLink(hdr);
 115                 rc = headerGet(hdr, RPMTAG_NAME, tn, HEADERGET_MINMEM);
 116                 if (strcmp(pkgid, rpmtdGetString(tn) ) == 0) {
 117                         found = 1;
 118                         break;
 119                 } else {
 120                         rpmtdReset(tn);
 121                         headerFree(hdr);
 122                 }
 123
 124         }
 125         if (found == 0) {
 126                 _librpm_print(DEBUG_INFO, "Package not found in DB\n");
 127                 ret = 0;
 128                 goto err;
 129         }
 130         else {
 131                  _librpm_print(DEBUG_INFO, "Package found in DB\n");
 132                 ret = 1;
 133                 goto err;
 134         }
 135 err:
 136         rpmtdFreeData(tn);
 137         rpmtdFree(tn);
 138         headerFree(hdr);
 139         rpmtsFree(ts);
 140         rpmdbFreeIterator(mi);
 141         return ret;
 142
 143 }
 144
 145 int _librpm_get_installed_package_info(char *pkgid,
 146                         package_manager_pkg_detail_info_t *pkg_detail_info)
 147 {
 148         rpmts ts = NULL;
 149         Header hdr = NULL;
 150         int found = 0;
 151         int ret = 0;
 152         rpmdbMatchIterator mi;
 153         rpmtd td, tn, tv, ta;
 154         rpmRC rc;
 155
 156         td = rpmtdNew();
 157         tn = rpmtdNew();
 158         tv = rpmtdNew();
 159         ta = rpmtdNew();
 160         ts = rpmtsCreate();
 161 /*
 162         hdr = headerNew();
 163 */
 164         mi = rpmtsInitIterator(ts, RPMDBI_PACKAGES, NULL, 0);
 165         while (NULL != (hdr = rpmdbNextIterator(mi))) {
 166
 167                 hdr = headerLink(hdr);
 168                 rc = headerGet(hdr, RPMTAG_NAME, tn, HEADERGET_MINMEM);
 169                 if (strcmp(pkgid, rpmtdGetString(tn) ) == 0) {
 170                         found = 1;
 171                         break;
 172                 } else {
 173                         rpmtdReset(tn);
 174                         headerFree(hdr);
 175                 }
 176
 177         }
 178
 179         /*Print the header info */
 180         if (found == 0) {
 181                 _librpm_print(DEBUG_ERR, "Package not found in DB\n");
 182                 ret = LIBRPM_ERROR;
 183                 goto err;
 184         }
 185         /*Name*/
 186         headerGet(hdr, RPMTAG_NAME, tn, HEADERGET_MINMEM);
 187         strncpy(pkg_detail_info->pkgid, rpmtdGetString(tn), PKG_NAME_STRING_LEN_MAX-1);
 188         /*Version*/
 189         headerGet(hdr, RPMTAG_VERSION, tv, HEADERGET_MINMEM);
 190         strncpy(pkg_detail_info->version, rpmtdGetString(tv), PKG_VERSION_STRING_LEN_MAX-1);
 191         /*Description*/
 192         headerGet(hdr, RPMTAG_DESCRIPTION, td, HEADERGET_MINMEM);
 193         strncpy(pkg_detail_info->pkg_description, rpmtdGetString(td), PKG_VALUE_STRING_LEN_MAX-1);
 194         /*Size*/
 195         headerGet(hdr, RPMTAG_SIZE, ta, HEADERGET_MINMEM);
 196         pkg_detail_info->app_size = rpmtdGetNumber(ta);
 197         ret = LIBRPM_SUCCESS;
 198
 199 err:
 200         headerFree(hdr);
 201         rpmtdFreeData(tn);
 202         rpmtdFree(tn);
 203         rpmtdFreeData(td);
 204         rpmtdFree(td);
 205         rpmtdFreeData(ta);
 206         rpmtdFree(ta);
 207         rpmtdFreeData(tv);
 208         rpmtdFree(tv);
 209         rpmdbFreeIterator(mi);
 210         rpmtsFree(ts);
 211
 212         return ret;
 213
 214 }
 215
 216 int _librpm_get_package_header_info(char *pkg_path,
 217                                 package_manager_pkg_detail_info_t *pkg_detail_info)
 218 {
 219         int i;
 220         int ret = 0;
 221         rpmts ts = NULL;
 222         rpmtd td = NULL;
 223         FD_t fd;
 224         rpmRC rc;
 225         Header hdr = NULL;
 226         rpmVSFlags vsflags = 0;
 227
 228         fd = Fopen(pkg_path, "r.ufdio");
 229         if ((!fd) || Ferror(fd)) {
 230                 _librpm_print(DEBUG_ERR, "Failed to open package file (%s)\n", Fstrerror(fd));
 231                 ret = LIBRPM_ERROR;
 232                 goto err;
 233         }
 234
 235         ts = rpmtsCreate();
 236         td = rpmtdNew();
 237         hdr = headerNew();
 238
 239         vsflags |= _RPMVSF_NODIGESTS;
 240         vsflags |= _RPMVSF_NOSIGNATURES;
 241         vsflags |= RPMVSF_NOHDRCHK;
 242         (void) rpmtsSetVSFlags(ts, vsflags);
 243
 244         rc = rpmReadPackageFile(ts, fd, pkg_path, &hdr);
 245         if (rc != RPMRC_OK) {
 246                 _librpm_print(DEBUG_ERR, "Could not read package file\n");
 247                 ret = LIBRPM_ERROR;
 248                 goto err;
 249         }
 250         Fclose(fd);
 251         /*Name*/
 252         headerGet(hdr, RPMTAG_NAME, td, HEADERGET_MINMEM);
 253         strncpy(pkg_detail_info->pkgid, rpmtdGetString(td), PKG_NAME_STRING_LEN_MAX-1);
 254         rpmtdReset(td);
 255         /*Version*/
 256         headerGet(hdr, RPMTAG_VERSION, td, HEADERGET_MINMEM);
 257         strncpy(pkg_detail_info->version, rpmtdGetString(td), PKG_VERSION_STRING_LEN_MAX-1);
 258         rpmtdReset(td);
 259         /*Description*/
 260         headerGet(hdr, RPMTAG_DESCRIPTION, td, HEADERGET_MINMEM);
 261         strncpy(pkg_detail_info->pkg_description, rpmtdGetString(td), PKG_VALUE_STRING_LEN_MAX-1);
 262         rpmtdReset(td);
 263         /*Size*/
 264         headerGet(hdr, RPMTAG_SIZE, td, HEADERGET_MINMEM);
 265         pkg_detail_info->app_size = rpmtdGetNumber(td);
 266
 267         ret = LIBRPM_SUCCESS;
 268 err:
 269         rpmtdFreeData(td);
 270         rpmtdFree(td);
 271         headerFree(hdr);
 272         rpmtsFree(ts);
 273         return ret;
 274
 275 }
 276
 277 long long _librpm_calculate_dir_size(char *dirname)
 278 {
 279         long long total = 0;
 280         long long ret = 0;
 281         int q = 0; /*quotient*/
 282         int r = 0; /*remainder*/
 283         DIR *dp = NULL;
 284         struct dirent *ep = NULL;
 285         struct stat fileinfo;
 286         char abs_filename[FILENAME_MAX] = { 0, };
 287         if (dirname == NULL) {
 288                 _librpm_print(DEBUG_ERR,
 289                                 "dirname is NULL");
 290                 return LIBRPM_ERROR;
 291         }
 292         dp = opendir(dirname);
 293         if (dp != NULL) {
 294                 while ((ep = readdir(dp)) != NULL) {
 295                         if (!strcmp(ep->d_name, ".") ||
 296                                 !strcmp(ep->d_name, "..")) {
 297                                 continue;
 298                         }
 299                         snprintf(abs_filename, FILENAME_MAX, "%s/%s", dirname,
 300                                  ep->d_name);
 301                         if (stat(abs_filename, &fileinfo) < 0)
 302                                 perror(abs_filename);
 303                         else {
 304                                 if (S_ISDIR(fileinfo.st_mode)) {
 305                                         total += fileinfo.st_size;
 306                                         if (strcmp(ep->d_name, ".")
 307                                             && strcmp(ep->d_name, "..")) {
 308                                                 ret = _librpm_calculate_dir_size
 309                                                     (abs_filename);
 310                                                 total = total + ret;
 311                                         }
 312                                 } else {
 313                                         /*It is a file. Calculate the actual
 314                                         size occupied (in terms of 4096 blocks)*/
 315                                 q = (fileinfo.st_size / BLOCK_SIZE);
 316                                 r = (fileinfo.st_size % BLOCK_SIZE);
 317                                 if (r) {
 318                                         q = q + 1;
 319                                 }
 320                                 total += q * BLOCK_SIZE;
 321                                 }
 322                         }
 323                 }
 324                 (void)closedir(dp);
 325         } else {
 326                 _librpm_print(DEBUG_ERR,
 327                              "Couldn't open the directory\n");
 328                 return -1;
 329         }
 330         return total;
 331
 332 }