libopkg/release.c

   1 /* release.c - the opkg package management system
   2
   3    Copyright (C) 2010,2011 Javier Palacios
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2, or (at
   8    your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14 */
  15
  16 #include <unistd.h>
  17 #include <ctype.h>
  18
  19 #include "release.h"
  20 #include "opkg_utils.h"
  21 #include "libbb/libbb.h"
  22
  23 #include "opkg_download.h"
  24 #include "sprintf_alloc.h"
  25
  26 #include "release_parse.h"
  27
  28 #include "parse_util.h"
  29 #include "file_util.h"
  30
  31 static void
  32 release_init(release_t *release)
  33 {
  34      release->name = NULL;
  35      release->datestring = NULL;
  36      release->architectures = NULL;
  37      release->architectures_count = 0;
  38      release->components = NULL;
  39      release->components_count = 0;
  40      release->complist = NULL;
  41      release->complist_count = 0;
  42 }
  43
  44 release_t *
  45 release_new(void)
  46 {
  47      release_t *release;
  48
  49      release = xcalloc(1, sizeof(release_t));
  50      release_init(release);
  51
  52      return release;
  53 }
  54
  55 void
  56 release_deinit(release_t *release)
  57 {
  58     int i;
  59
  60     free(release->name);
  61     free(release->datestring);
  62
  63     for(i = 0; i < release->architectures_count; i++){
  64         free(release->architectures[i]);
  65     }
  66     free(release->architectures);
  67
  68     for(i = 0; i < release->components_count; i++){
  69         free(release->components[i]);
  70     }
  71     free(release->components);
  72
  73     for(i = 0; i < release->complist_count; i++){
  74         free(release->complist[i]);
  75     }
  76     free(release->complist);
  77
  78 }
  79
  80 int
  81 release_init_from_file(release_t *release, const char *filename)
  82 {
  83         int err = 0;
  84         FILE *release_file;
  85
  86         release_file = fopen(filename, "r");
  87         if (release_file == NULL) {
  88                 opkg_perror(ERROR, "Failed to open %s", filename);
  89                 return -1;
  90         }
  91
  92         err=release_parse_from_stream(release, release_file);
  93         if (!err) {
  94                 if (!release_arch_supported(release)) {
  95                         opkg_msg(ERROR, "No valid architecture found on Release file.\n");
  96                         err = -1;
  97                 }
  98         }
  99
 100         return err;
 101 }
 102
 103 const char *
 104 item_in_list(const char *comp, char **complist, const unsigned int count)
 105 {
 106      int i;
 107
 108      if (!complist)
 109           return comp;
 110
 111      for(i = 0; i < count; i++){
 112           if (strcmp(comp, complist[i]) == 0)
 113                     return complist[i];
 114      }
 115
 116      return NULL;
 117 }
 118
 119 int
 120 release_arch_supported(release_t *release)
 121 {
 122      nv_pair_list_elt_t *l;
 123
 124      list_for_each_entry(l , &conf->arch_list.head, node) {
 125           nv_pair_t *nv = (nv_pair_t *)l->data;
 126           if (item_in_list(nv->name, release->architectures, release->architectures_count)) {
 127                opkg_msg(DEBUG, "Arch %s (priority %s) supported for dist %s.\n",
 128                                nv->name, nv->value, release->name);
 129                return 1;
 130           }
 131      }
 132
 133      return 0;
 134 }
 135
 136 int
 137 release_comps_supported(release_t *release, const char *complist)
 138 {
 139      int ret = 1;
 140      int i;
 141
 142      if (complist) {
 143           release->complist = parse_list(complist, &release->complist_count, ' ', 1);
 144           for(i = 0; i < release->complist_count; i++){
 145                if (!item_in_list(release->complist[i], release->components, release->components_count)) {
 146                     opkg_msg(ERROR, "Component %s not supported for dist %s.\n",
 147                                     release->complist[i], release->name);
 148                     ret = 0;
 149                }
 150           }
 151      }
 152
 153      return ret;
 154 }
 155
 156 const char **
 157 release_comps(release_t *release, unsigned int *count)
 158 {
 159      char **comps = release->complist;
 160
 161      if (!comps) {
 162           comps = release->components;
 163           *count = release->components_count;
 164      } else {
 165           *count = release->complist_count;
 166      }
 167
 168      return (const char **)comps;
 169 }
 170
 171 int
 172 release_download(release_t *release, pkg_src_t *dist, char *lists_dir, char *tmpdir)
 173 {
 174      int ret = 0;
 175      unsigned int ncomp;
 176      const char **comps = release_comps(release, &ncomp);
 177      nv_pair_list_elt_t *l;
 178      int i;
 179
 180      for(i = 0; i < ncomp; i++){
 181           int err = 0;
 182           char *prefix;
 183
 184           sprintf_alloc(&prefix, "%s/dists/%s/%s/binary", dist->value, dist->name,
 185                         comps[i]);
 186
 187           list_for_each_entry(l , &conf->arch_list.head, node) {
 188                char *url;
 189                char *tmp_file_name, *list_file_name;
 190                char *subpath = NULL;
 191
 192                nv_pair_t *nv = (nv_pair_t *)l->data;
 193
 194                sprintf_alloc(&list_file_name, "%s/%s-%s-%s", lists_dir, dist->name, comps[i], nv->name);
 195
 196                sprintf_alloc(&tmp_file_name, "%s/%s-%s-%s%s", tmpdir, dist->name, comps[i], nv->name, ".gz");
 197
 198                sprintf_alloc(&subpath, "%s/binary-%s/%s", comps[i], nv->name, dist->gzip ? "Packages.gz" : "Packages");
 199
 200                if (dist->gzip) {
 201                sprintf_alloc(&url, "%s-%s/Packages.gz", prefix, nv->name);
 202                err = opkg_download(url, tmp_file_name, NULL, NULL, 1);
 203                if (!err) {
 204                     err = release_verify_file(release, tmp_file_name, subpath);
 205                     if (err) {
 206                          unlink (tmp_file_name);
 207                          unlink (list_file_name);
 208                     }
 209                }
 210                if (!err) {
 211                     FILE *in, *out;
 212                     opkg_msg(NOTICE, "Inflating %s.\n", url);
 213                     in = fopen (tmp_file_name, "r");
 214                     out = fopen (list_file_name, "w");
 215                     if (in && out) {
 216                          err = unzip (in, out);
 217                          if (err)
 218                               opkg_msg(INFO, "Corrumpt file at %s.\n", url);
 219                     } else
 220                          err = 1;
 221                     if (in)
 222                          fclose (in);
 223                     if (out)
 224                          fclose (out);
 225                     unlink (tmp_file_name);
 226                }
 227                free(url);
 228                }
 229
 230                if (err) {
 231                     sprintf_alloc(&url, "%s-%s/Packages", prefix, nv->name);
 232                     err = opkg_download(url, list_file_name, NULL, NULL, 1);
 233                     if (!err) {
 234                          err = release_verify_file(release, tmp_file_name, subpath);
 235                          if (err)
 236                               unlink (list_file_name);
 237                     }
 238                     free(url);
 239                }
 240
 241                free(tmp_file_name);
 242                free(list_file_name);
 243           }
 244
 245           if(err)
 246                ret = 1;
 247
 248           free(prefix);
 249      }
 250
 251      return ret;
 252 }
 253
 254 int
 255 release_get_size(release_t *release, const char *pathname)
 256 {
 257      const cksum_t *cksum;
 258
 259      if (release->md5sums) {
 260           cksum = cksum_list_find(release->md5sums, pathname);
 261           return cksum->size;
 262      }
 263
 264 #ifdef HAVE_SHA256
 265      if (release->sha256sums) {
 266           cksum = cksum_list_find(release->sha256sums, pathname);
 267           return cksum->size;
 268      }
 269 #endif
 270
 271      return -1;
 272 }
 273
 274 const char *
 275 release_get_md5(release_t *release, const char *pathname)
 276 {
 277      const cksum_t *cksum;
 278
 279      if (release->md5sums) {
 280           cksum = cksum_list_find(release->md5sums, pathname);
 281           return cksum->value;
 282      }
 283
 284      return '\0';
 285 }
 286
 287 #ifdef HAVE_SHA256
 288 const char *
 289 release_get_sha256(release_t *release, const char *pathname)
 290 {
 291      const cksum_t *cksum;
 292
 293      if (release->sha256sums) {
 294           cksum = cksum_list_find(release->sha256sums, pathname);
 295           return cksum->value;
 296      }
 297
 298      return '\0';
 299 }
 300 #endif
 301
 302 int
 303 release_verify_file(release_t *release, const char* file_name, const char *pathname)
 304 {
 305      struct stat f_info;
 306      char *f_md5 = NULL;
 307      const char *md5 = release_get_md5(release, pathname);
 308 #ifndef HAVE_SHA256
 309      char *f_sha256 = NULL;
 310      const char *sha256 = release_get_sha256(release, pathname);
 311 #endif
 312      int ret = 0;
 313
 314      if (stat(file_name, &f_info) || (f_info.st_size!=release_get_size(release, pathname))) {
 315           opkg_msg(ERROR, "Size verification failed for %s - %s.\n", release->name, pathname);
 316           ret = 1;
 317      } else {
 318
 319      f_md5 = file_md5sum_alloc(file_name);
 320 #ifdef HAVE_SHA256
 321      f_sha256 = file_sha256sum_alloc(file_name);
 322 #endif
 323
 324      if (md5 && strcmp(md5, f_md5)) {
 325           opkg_msg(ERROR, "MD5 verification failed for %s - %s.\n", release->name, pathname);
 326           ret = 1;
 327 #ifdef HAVE_SHA256
 328      } else if (sha256 && strcmp(sha256, f_sha256)) {
 329           opkg_msg(ERROR, "SHA256 verification failed for %s - %s.\n", release->name, pathname);
 330           ret = 1;
 331 #endif
 332      }
 333
 334      }
 335
 336      free(f_md5);
 337 #ifdef HAVE_SHA256
 338      free(f_sha256);
 339 #endif
 340
 341      return ret;
 342 }