src/tool_metalink.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at https://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22 #include "tool_setup.h"
  23
  24 #ifdef USE_METALINK
  25
  26 #include <sys/stat.h>
  27 #include <stdlib.h>
  28
  29 #ifdef HAVE_FCNTL_H
  30 #  include <fcntl.h>
  31 #endif
  32
  33 #undef HAVE_NSS_CONTEXT
  34
  35 #ifdef USE_OPENSSL
  36 #  include <openssl/md5.h>
  37 #  include <openssl/sha.h>
  38 #elif defined(USE_GNUTLS_NETTLE)
  39 #  include <nettle/md5.h>
  40 #  include <nettle/sha.h>
  41 #  define MD5_CTX    struct md5_ctx
  42 #  define SHA_CTX    struct sha1_ctx
  43 #  define SHA256_CTX struct sha256_ctx
  44 #elif defined(USE_GNUTLS)
  45 #  include <gcrypt.h>
  46 #  define MD5_CTX    gcry_md_hd_t
  47 #  define SHA_CTX    gcry_md_hd_t
  48 #  define SHA256_CTX gcry_md_hd_t
  49 #elif defined(USE_NSS)
  50 #  include <nss.h>
  51 #  include <pk11pub.h>
  52 #  define MD5_CTX    void *
  53 #  define SHA_CTX    void *
  54 #  define SHA256_CTX void *
  55 #  define HAVE_NSS_CONTEXT
  56    static NSSInitContext *nss_context;
  57 #elif defined(USE_POLARSSL)
  58 #  include <polarssl/md5.h>
  59 #  include <polarssl/sha1.h>
  60 #  include <polarssl/sha256.h>
  61 #  define MD5_CTX    md5_context
  62 #  define SHA_CTX    sha1_context
  63 #  define SHA256_CTX sha256_context
  64 #elif (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && \
  65               (__MAC_OS_X_VERSION_MAX_ALLOWED >= 1040)) || \
  66       (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && \
  67               (__IPHONE_OS_VERSION_MAX_ALLOWED >= 20000))
  68 /* For Apple operating systems: CommonCrypto has the functions we need.
  69    The library's headers are even backward-compatible with OpenSSL's
  70    headers as long as we define COMMON_DIGEST_FOR_OPENSSL first.
  71
  72    These functions are available on Tiger and later, as well as iOS 2.0
  73    and later. If you're building for an older cat, well, sorry. */
  74 #  define COMMON_DIGEST_FOR_OPENSSL
  75 #  include <CommonCrypto/CommonDigest.h>
  76 #elif defined(_WIN32)
  77 /* For Windows: If no other crypto library is provided, we fallback
  78    to the hash functions provided within the Microsoft Windows CryptoAPI */
  79 #  include <wincrypt.h>
  80 /* Custom structure in order to store the required provider and hash handle */
  81 struct win32_crypto_hash {
  82   HCRYPTPROV hCryptProv;
  83   HCRYPTHASH hHash;
  84 };
  85 /* Custom Microsoft AES Cryptographic Provider defines required for MinGW */
  86 #  ifndef ALG_SID_SHA_256
  87 #    define ALG_SID_SHA_256  12
  88 #  endif
  89 #  ifndef CALG_SHA_256
  90 #    define CALG_SHA_256 (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_256)
  91 #  endif
  92 #  define MD5_CTX    struct win32_crypto_hash
  93 #  define SHA_CTX    struct win32_crypto_hash
  94 #  define SHA256_CTX struct win32_crypto_hash
  95 #else
  96 #  error "Can't compile METALINK support without a crypto library."
  97 #endif
  98
  99 #define ENABLE_CURLX_PRINTF
 100 /* use our own printf() functions */
 101 #include "curlx.h"
 102
 103 #include "tool_getparam.h"
 104 #include "tool_paramhlp.h"
 105 #include "tool_cfgable.h"
 106 #include "tool_metalink.h"
 107 #include "tool_msgs.h"
 108
 109 #include "memdebug.h" /* keep this as LAST include */
 110
 111 /* Copied from tool_getparam.c */
 112 #define GetStr(str,val) do { \
 113   if(*(str)) { \
 114     free(*(str)); \
 115     *(str) = NULL; \
 116   } \
 117   if((val)) \
 118     *(str) = strdup((val)); \
 119   if(!(val)) \
 120     return PARAM_NO_MEM; \
 121 } WHILE_FALSE
 122
 123 #if defined(USE_OPENSSL)
 124 /* Functions are already defined */
 125 #elif defined(USE_GNUTLS_NETTLE)
 126
 127 static int MD5_Init(MD5_CTX *ctx)
 128 {
 129   md5_init(ctx);
 130   return 1;
 131 }
 132
 133 static void MD5_Update(MD5_CTX *ctx,
 134                        const unsigned char *input,
 135                        unsigned int inputLen)
 136 {
 137   md5_update(ctx, inputLen, input);
 138 }
 139
 140 static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
 141 {
 142   md5_digest(ctx, 16, digest);
 143 }
 144
 145 static int SHA1_Init(SHA_CTX *ctx)
 146 {
 147   sha1_init(ctx);
 148   return 1;
 149 }
 150
 151 static void SHA1_Update(SHA_CTX *ctx,
 152                         const unsigned char *input,
 153                         unsigned int inputLen)
 154 {
 155   sha1_update(ctx, inputLen, input);
 156 }
 157
 158 static void SHA1_Final(unsigned char digest[20], SHA_CTX *ctx)
 159 {
 160   sha1_digest(ctx, 20, digest);
 161 }
 162
 163 static int SHA256_Init(SHA256_CTX *ctx)
 164 {
 165   sha256_init(ctx);
 166   return 1;
 167 }
 168
 169 static void SHA256_Update(SHA256_CTX *ctx,
 170                           const unsigned char *input,
 171                           unsigned int inputLen)
 172 {
 173   sha256_update(ctx, inputLen, input);
 174 }
 175
 176 static void SHA256_Final(unsigned char digest[32], SHA256_CTX *ctx)
 177 {
 178   sha256_digest(ctx, 32, digest);
 179 }
 180
 181 #elif defined(USE_GNUTLS)
 182
 183 static int MD5_Init(MD5_CTX *ctx)
 184 {
 185   gcry_md_open(ctx, GCRY_MD_MD5, 0);
 186   return 1;
 187 }
 188
 189 static void MD5_Update(MD5_CTX *ctx,
 190                        const unsigned char *input,
 191                        unsigned int inputLen)
 192 {
 193   gcry_md_write(*ctx, input, inputLen);
 194 }
 195
 196 static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
 197 {
 198   memcpy(digest, gcry_md_read(*ctx, 0), 16);
 199   gcry_md_close(*ctx);
 200 }
 201
 202 static int SHA1_Init(SHA_CTX *ctx)
 203 {
 204   gcry_md_open(ctx, GCRY_MD_SHA1, 0);
 205   return 1;
 206 }
 207
 208 static void SHA1_Update(SHA_CTX *ctx,
 209                         const unsigned char *input,
 210                         unsigned int inputLen)
 211 {
 212   gcry_md_write(*ctx, input, inputLen);
 213 }
 214
 215 static void SHA1_Final(unsigned char digest[20], SHA_CTX *ctx)
 216 {
 217   memcpy(digest, gcry_md_read(*ctx, 0), 20);
 218   gcry_md_close(*ctx);
 219 }
 220
 221 static int SHA256_Init(SHA256_CTX *ctx)
 222 {
 223   gcry_md_open(ctx, GCRY_MD_SHA256, 0);
 224   return 1;
 225 }
 226
 227 static void SHA256_Update(SHA256_CTX *ctx,
 228                           const unsigned char *input,
 229                           unsigned int inputLen)
 230 {
 231   gcry_md_write(*ctx, input, inputLen);
 232 }
 233
 234 static void SHA256_Final(unsigned char digest[32], SHA256_CTX *ctx)
 235 {
 236   memcpy(digest, gcry_md_read(*ctx, 0), 32);
 237   gcry_md_close(*ctx);
 238 }
 239
 240 #elif defined(USE_NSS)
 241
 242 static int nss_hash_init(void **pctx, SECOidTag hash_alg)
 243 {
 244   PK11Context *ctx;
 245
 246   /* we have to initialize NSS if not initialized alraedy */
 247   if(!NSS_IsInitialized() && !nss_context) {
 248     static NSSInitParameters params;
 249     params.length = sizeof params;
 250     nss_context = NSS_InitContext("", "", "", "", &params, NSS_INIT_READONLY
 251         | NSS_INIT_NOCERTDB   | NSS_INIT_NOMODDB       | NSS_INIT_FORCEOPEN
 252         | NSS_INIT_NOROOTINIT | NSS_INIT_OPTIMIZESPACE | NSS_INIT_PK11RELOAD);
 253   }
 254
 255   ctx = PK11_CreateDigestContext(hash_alg);
 256   if(!ctx)
 257     return /* failure */ 0;
 258
 259   if(PK11_DigestBegin(ctx) != SECSuccess) {
 260     PK11_DestroyContext(ctx, PR_TRUE);
 261     return /* failure */ 0;
 262   }
 263
 264   *pctx = ctx;
 265   return /* success */ 1;
 266 }
 267
 268 static void nss_hash_final(void **pctx, unsigned char *out, unsigned int len)
 269 {
 270   PK11Context *ctx = *pctx;
 271   unsigned int outlen;
 272   PK11_DigestFinal(ctx, out, &outlen, len);
 273   PK11_DestroyContext(ctx, PR_TRUE);
 274 }
 275
 276 static int MD5_Init(MD5_CTX *pctx)
 277 {
 278   return nss_hash_init(pctx, SEC_OID_MD5);
 279 }
 280
 281 static void MD5_Update(MD5_CTX *pctx,
 282                        const unsigned char *input,
 283                        unsigned int input_len)
 284 {
 285   PK11_DigestOp(*pctx, input, input_len);
 286 }
 287
 288 static void MD5_Final(unsigned char digest[16], MD5_CTX *pctx)
 289 {
 290   nss_hash_final(pctx, digest, 16);
 291 }
 292
 293 static int SHA1_Init(SHA_CTX *pctx)
 294 {
 295   return nss_hash_init(pctx, SEC_OID_SHA1);
 296 }
 297
 298 static void SHA1_Update(SHA_CTX *pctx,
 299                         const unsigned char *input,
 300                         unsigned int input_len)
 301 {
 302   PK11_DigestOp(*pctx, input, input_len);
 303 }
 304
 305 static void SHA1_Final(unsigned char digest[20], SHA_CTX *pctx)
 306 {
 307   nss_hash_final(pctx, digest, 20);
 308 }
 309
 310 static int SHA256_Init(SHA256_CTX *pctx)
 311 {
 312   return nss_hash_init(pctx, SEC_OID_SHA256);
 313 }
 314
 315 static void SHA256_Update(SHA256_CTX *pctx,
 316                           const unsigned char *input,
 317                           unsigned int input_len)
 318 {
 319   PK11_DigestOp(*pctx, input, input_len);
 320 }
 321
 322 static void SHA256_Final(unsigned char digest[32], SHA256_CTX *pctx)
 323 {
 324   nss_hash_final(pctx, digest, 32);
 325 }
 326
 327 #elif defined(USE_POLARSSL)
 328
 329 static int MD5_Init(MD5_CTX *ctx)
 330 {
 331   md5_starts(ctx);
 332   return 1;
 333 }
 334
 335 static void MD5_Update(MD5_CTX *ctx,
 336                        const unsigned char *input,
 337                        unsigned int inputLen)
 338 {
 339   md5_update(ctx, input, inputLen);
 340 }
 341
 342 static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
 343 {
 344   md5_finish(ctx, digest);
 345 }
 346
 347 static int SHA1_Init(SHA_CTX *ctx)
 348 {
 349   sha1_starts(ctx);
 350   return 1;
 351 }
 352
 353 static void SHA1_Update(SHA_CTX *ctx,
 354                         const unsigned char *input,
 355                         unsigned int inputLen)
 356 {
 357   sha1_update(ctx, input, inputLen);
 358 }
 359
 360 static void SHA1_Final(unsigned char digest[20], SHA_CTX *ctx)
 361 {
 362   sha1_finish(ctx, digest);
 363 }
 364
 365 static int SHA256_Init(SHA256_CTX *ctx)
 366 {
 367   sha256_starts(ctx, 0); /* 0 = sha256 */
 368   return 1;
 369 }
 370
 371 static void SHA256_Update(SHA256_CTX *ctx,
 372                           const unsigned char *input,
 373                           unsigned int inputLen)
 374 {
 375   sha256_update(ctx, input, inputLen);
 376 }
 377
 378 static void SHA256_Final(unsigned char digest[32], SHA256_CTX *ctx)
 379 {
 380   sha256_finish(ctx, digest);
 381 }
 382
 383 #elif defined(_WIN32)
 384
 385 static void win32_crypto_final(struct win32_crypto_hash *ctx,
 386                                unsigned char *digest,
 387                                unsigned int digestLen)
 388 {
 389   unsigned long length;
 390   CryptGetHashParam(ctx->hHash, HP_HASHVAL, NULL, &length, 0);
 391   if(length == digestLen)
 392     CryptGetHashParam(ctx->hHash, HP_HASHVAL, digest, &length, 0);
 393   if(ctx->hHash)
 394     CryptDestroyHash(ctx->hHash);
 395   if(ctx->hCryptProv)
 396     CryptReleaseContext(ctx->hCryptProv, 0);
 397 }
 398
 399 static int MD5_Init(MD5_CTX *ctx)
 400 {
 401   if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL,
 402                          PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
 403     CryptCreateHash(ctx->hCryptProv, CALG_MD5, 0, 0, &ctx->hHash);
 404   }
 405   return 1;
 406 }
 407
 408 static void MD5_Update(MD5_CTX *ctx,
 409                        const unsigned char *input,
 410                        unsigned int inputLen)
 411 {
 412   CryptHashData(ctx->hHash, (unsigned char *)input, inputLen, 0);
 413 }
 414
 415 static void MD5_Final(unsigned char digest[16], MD5_CTX *ctx)
 416 {
 417   win32_crypto_final(ctx, digest, 16);
 418 }
 419
 420 static int SHA1_Init(SHA_CTX *ctx)
 421 {
 422   if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL,
 423                          PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
 424     CryptCreateHash(ctx->hCryptProv, CALG_SHA1, 0, 0, &ctx->hHash);
 425   }
 426   return 1;
 427 }
 428
 429 static void SHA1_Update(SHA_CTX *ctx,
 430                         const unsigned char *input,
 431                         unsigned int inputLen)
 432 {
 433   CryptHashData(ctx->hHash, (unsigned char *)input, inputLen, 0);
 434 }
 435
 436 static void SHA1_Final(unsigned char digest[20], SHA_CTX *ctx)
 437 {
 438   win32_crypto_final(ctx, digest, 20);
 439 }
 440
 441 static int SHA256_Init(SHA256_CTX *ctx)
 442 {
 443   if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL,
 444                          PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) {
 445     CryptCreateHash(ctx->hCryptProv, CALG_SHA_256, 0, 0, &ctx->hHash);
 446   }
 447   return 1;
 448 }
 449
 450 static void SHA256_Update(SHA256_CTX *ctx,
 451                           const unsigned char *input,
 452                           unsigned int inputLen)
 453 {
 454   CryptHashData(ctx->hHash, (unsigned char *)input, inputLen, 0);
 455 }
 456
 457 static void SHA256_Final(unsigned char digest[32], SHA256_CTX *ctx)
 458 {
 459   win32_crypto_final(ctx, digest, 32);
 460 }
 461
 462 #endif /* CRYPTO LIBS */
 463
 464 const digest_params MD5_DIGEST_PARAMS[] = {
 465   {
 466     (Curl_digest_init_func) MD5_Init,
 467     (Curl_digest_update_func) MD5_Update,
 468     (Curl_digest_final_func) MD5_Final,
 469     sizeof(MD5_CTX),
 470     16
 471   }
 472 };
 473
 474 const digest_params SHA1_DIGEST_PARAMS[] = {
 475   {
 476     (Curl_digest_init_func) SHA1_Init,
 477     (Curl_digest_update_func) SHA1_Update,
 478     (Curl_digest_final_func) SHA1_Final,
 479     sizeof(SHA_CTX),
 480     20
 481   }
 482 };
 483
 484 const digest_params SHA256_DIGEST_PARAMS[] = {
 485   {
 486     (Curl_digest_init_func) SHA256_Init,
 487     (Curl_digest_update_func) SHA256_Update,
 488     (Curl_digest_final_func) SHA256_Final,
 489     sizeof(SHA256_CTX),
 490     32
 491   }
 492 };
 493
 494 static const metalink_digest_def SHA256_DIGEST_DEF[] = {
 495   {"sha-256", SHA256_DIGEST_PARAMS}
 496 };
 497
 498 static const metalink_digest_def SHA1_DIGEST_DEF[] = {
 499   {"sha-1", SHA1_DIGEST_PARAMS}
 500 };
 501
 502 static const metalink_digest_def MD5_DIGEST_DEF[] = {
 503   {"md5", MD5_DIGEST_PARAMS}
 504 };
 505
 506 /*
 507  * The alias of supported hash functions in the order by preference
 508  * (basically stronger hash comes first). We included "sha-256" and
 509  * "sha256". The former is the name defined in the IANA registry named
 510  * "Hash Function Textual Names". The latter is widely (and
 511  * historically) used in Metalink version 3.
 512  */
 513 static const metalink_digest_alias digest_aliases[] = {
 514   {"sha-256", SHA256_DIGEST_DEF},
 515   {"sha256", SHA256_DIGEST_DEF},
 516   {"sha-1", SHA1_DIGEST_DEF},
 517   {"sha1", SHA1_DIGEST_DEF},
 518   {"md5", MD5_DIGEST_DEF},
 519   {NULL, NULL}
 520 };
 521
 522 digest_context *Curl_digest_init(const digest_params *dparams)
 523 {
 524   digest_context *ctxt;
 525
 526   /* Create digest context */
 527   ctxt = malloc(sizeof *ctxt);
 528
 529   if(!ctxt)
 530     return ctxt;
 531
 532   ctxt->digest_hashctx = malloc(dparams->digest_ctxtsize);
 533
 534   if(!ctxt->digest_hashctx) {
 535     free(ctxt);
 536     return NULL;
 537   }
 538
 539   ctxt->digest_hash = dparams;
 540
 541   if(dparams->digest_init(ctxt->digest_hashctx) != 1) {
 542     free(ctxt->digest_hashctx);
 543     free(ctxt);
 544     return NULL;
 545   }
 546
 547   return ctxt;
 548 }
 549
 550 int Curl_digest_update(digest_context *context,
 551                        const unsigned char *data,
 552                        unsigned int len)
 553 {
 554   (*context->digest_hash->digest_update)(context->digest_hashctx, data, len);
 555
 556   return 0;
 557 }
 558
 559 int Curl_digest_final(digest_context *context, unsigned char *result)
 560 {
 561   if(result)
 562     (*context->digest_hash->digest_final)(result, context->digest_hashctx);
 563
 564   free(context->digest_hashctx);
 565   free(context);
 566
 567   return 0;
 568 }
 569
 570 static unsigned char hex_to_uint(const char *s)
 571 {
 572   char buf[3];
 573   unsigned long val;
 574   buf[0] = s[0];
 575   buf[1] = s[1];
 576   buf[2] = 0;
 577   val = strtoul(buf, NULL, 16);
 578   return (unsigned char)(val&0xff);
 579 }
 580
 581 /*
 582  * Check checksum of file denoted by filename. The expected hash value
 583  * is given in hex_hash which is hex-encoded string.
 584  *
 585  * This function returns 1 if it succeeds or one of the following
 586  * integers:
 587  *
 588  * 0:
 589  *   Checksum didn't match.
 590  * -1:
 591  *   Could not open file; or could not read data from file.
 592  * -2:
 593  *   Hash algorithm not available.
 594  */
 595 static int check_hash(const char *filename,
 596                       const metalink_digest_def *digest_def,
 597                       const unsigned char *digest, FILE *error)
 598 {
 599   unsigned char *result;
 600   digest_context *dctx;
 601   int check_ok, flags, fd;
 602
 603   flags = O_RDONLY;
 604 #ifdef O_BINARY
 605   /* O_BINARY is required in order to avoid binary EOF in text mode */
 606   flags |= O_BINARY;
 607 #endif
 608
 609   fd = open(filename, flags);
 610   if(fd == -1) {
 611     fprintf(error, "Metalink: validating (%s) [%s] FAILED (%s)\n", filename,
 612             digest_def->hash_name, strerror(errno));
 613     return -1;
 614   }
 615
 616   dctx = Curl_digest_init(digest_def->dparams);
 617   if(!dctx) {
 618     fprintf(error, "Metalink: validating (%s) [%s] FAILED (%s)\n", filename,
 619             digest_def->hash_name, "failed to initialize hash algorithm");
 620     close(fd);
 621     return -2;
 622   }
 623
 624   result = malloc(digest_def->dparams->digest_resultlen);
 625   if(!result) {
 626     close(fd);
 627     Curl_digest_final(dctx, NULL);
 628     return -1;
 629   }
 630   while(1) {
 631     unsigned char buf[4096];
 632     ssize_t len = read(fd, buf, sizeof(buf));
 633     if(len == 0) {
 634       break;
 635     }
 636     else if(len == -1) {
 637       fprintf(error, "Metalink: validating (%s) [%s] FAILED (%s)\n", filename,
 638               digest_def->hash_name, strerror(errno));
 639       Curl_digest_final(dctx, result);
 640       close(fd);
 641       return -1;
 642     }
 643     Curl_digest_update(dctx, buf, (unsigned int)len);
 644   }
 645   Curl_digest_final(dctx, result);
 646   check_ok = memcmp(result, digest,
 647                     digest_def->dparams->digest_resultlen) == 0;
 648   /* sha*sum style verdict output */
 649   if(check_ok)
 650     fprintf(error, "Metalink: validating (%s) [%s] OK\n", filename,
 651             digest_def->hash_name);
 652   else
 653     fprintf(error, "Metalink: validating (%s) [%s] FAILED (digest mismatch)\n",
 654             filename, digest_def->hash_name);
 655
 656   free(result);
 657   close(fd);
 658   return check_ok;
 659 }
 660
 661 int metalink_check_hash(struct GlobalConfig *config,
 662                         metalinkfile *mlfile,
 663                         const char *filename)
 664 {
 665   int rv;
 666   fprintf(config->errors, "Metalink: validating (%s)...\n", filename);
 667   if(mlfile->checksum == NULL) {
 668     fprintf(config->errors,
 669             "Metalink: validating (%s) FAILED (digest missing)\n", filename);
 670     return -2;
 671   }
 672   rv = check_hash(filename, mlfile->checksum->digest_def,
 673                   mlfile->checksum->digest, config->errors);
 674   return rv;
 675 }
 676
 677 static metalink_checksum *new_metalink_checksum_from_hex_digest
 678 (const metalink_digest_def *digest_def, const char *hex_digest)
 679 {
 680   metalink_checksum *chksum;
 681   unsigned char *digest;
 682   size_t i;
 683   size_t len = strlen(hex_digest);
 684   digest = malloc(len/2);
 685   if(!digest)
 686     return 0;
 687
 688   for(i = 0; i < len; i += 2) {
 689     digest[i/2] = hex_to_uint(hex_digest + i);
 690   }
 691   chksum = malloc(sizeof(metalink_checksum));
 692   if(chksum) {
 693     chksum->digest_def = digest_def;
 694     chksum->digest = digest;
 695   }
 696   else
 697     free(digest);
 698   return chksum;
 699 }
 700
 701 static metalink_resource *new_metalink_resource(const char *url)
 702 {
 703   metalink_resource *res;
 704   res = malloc(sizeof(metalink_resource));
 705   if(res) {
 706     res->next = NULL;
 707     res->url = strdup(url);
 708     if(!res->url) {
 709       free(res);
 710       return NULL;
 711     }
 712   }
 713   return res;
 714 }
 715
 716 /* Returns nonzero if hex_digest is properly formatted; that is each
 717    letter is in [0-9A-Za-z] and the length of the string equals to the
 718    result length of digest * 2. */
 719 static int check_hex_digest(const char *hex_digest,
 720                             const metalink_digest_def *digest_def)
 721 {
 722   size_t i;
 723   for(i = 0; hex_digest[i]; ++i) {
 724     char c = hex_digest[i];
 725     if(!(('0' <= c && c <= '9') || ('a' <= c && c <= 'z') ||
 726          ('A' <= c && c <= 'Z'))) {
 727       return 0;
 728     }
 729   }
 730   return digest_def->dparams->digest_resultlen * 2 == i;
 731 }
 732
 733 static metalinkfile *new_metalinkfile(metalink_file_t *fileinfo)
 734 {
 735   metalinkfile *f;
 736   f = (metalinkfile*)malloc(sizeof(metalinkfile));
 737   if(!f)
 738     return NULL;
 739
 740   f->next = NULL;
 741   f->filename = strdup(fileinfo->name);
 742   if(!f->filename) {
 743     free(f);
 744     return NULL;
 745   }
 746   f->checksum = NULL;
 747   f->resource = NULL;
 748   if(fileinfo->checksums) {
 749     const metalink_digest_alias *digest_alias;
 750     for(digest_alias = digest_aliases; digest_alias->alias_name;
 751         ++digest_alias) {
 752       metalink_checksum_t **p;
 753       for(p = fileinfo->checksums; *p; ++p) {
 754         if(curl_strequal(digest_alias->alias_name, (*p)->type) &&
 755            check_hex_digest((*p)->hash, digest_alias->digest_def)) {
 756           f->checksum =
 757             new_metalink_checksum_from_hex_digest(digest_alias->digest_def,
 758                                                   (*p)->hash);
 759           break;
 760         }
 761       }
 762       if(f->checksum) {
 763         break;
 764       }
 765     }
 766   }
 767   if(fileinfo->resources) {
 768     metalink_resource_t **p;
 769     metalink_resource root, *tail;
 770     root.next = NULL;
 771     tail = &root;
 772     for(p = fileinfo->resources; *p; ++p) {
 773       metalink_resource *res;
 774       /* Filter by type if it is non-NULL. In Metalink v3, type
 775          includes the type of the resource. In curl, we are only
 776          interested in HTTP, HTTPS and FTP. In addition to them,
 777          Metalink v3 file may contain bittorrent type URL, which
 778          points to the BitTorrent metainfo file. We ignore it here.
 779          In Metalink v4, type was deprecated and all
 780          fileinfo->resources point to the target file. BitTorrent
 781          metainfo file URL may be appeared in fileinfo->metaurls.
 782       */
 783       if((*p)->type == NULL ||
 784          curl_strequal((*p)->type, "http") ||
 785          curl_strequal((*p)->type, "https") ||
 786          curl_strequal((*p)->type, "ftp") ||
 787          curl_strequal((*p)->type, "ftps")) {
 788         res = new_metalink_resource((*p)->url);
 789         if(res) {
 790           tail->next = res;
 791           tail = res;
 792         }
 793         else {
 794           tail = root.next;
 795
 796           /* clean up the linked list */
 797           while(tail) {
 798             res = tail->next;
 799             free(tail->url);
 800             free(tail);
 801             tail = res;
 802           }
 803           free(f->filename);
 804           free(f);
 805           return NULL;
 806         }
 807       }
 808     }
 809     f->resource = root.next;
 810   }
 811   return f;
 812 }
 813
 814 int parse_metalink(struct OperationConfig *config, struct OutStruct *outs,
 815                    const char *metalink_url)
 816 {
 817   metalink_error_t r;
 818   metalink_t* metalink;
 819   metalink_file_t **files;
 820   bool warnings = FALSE;
 821
 822   /* metlaink_parse_final deletes outs->metalink_parser */
 823   r = metalink_parse_final(outs->metalink_parser, NULL, 0, &metalink);
 824   outs->metalink_parser = NULL;
 825   if(r != 0) {
 826     return -1;
 827   }
 828   if(metalink->files == NULL) {
 829     fprintf(config->global->errors, "Metalink: parsing (%s) WARNING "
 830             "(missing or invalid file name)\n",
 831             metalink_url);
 832     metalink_delete(metalink);
 833     return -1;
 834   }
 835   for(files = metalink->files; *files; ++files) {
 836     struct getout *url;
 837     /* Skip an entry which has no resource. */
 838     if(!(*files)->resources) {
 839       fprintf(config->global->errors, "Metalink: parsing (%s) WARNING "
 840               "(missing or invalid resource)\n",
 841               metalink_url);
 842       continue;
 843     }
 844     if(config->url_get ||
 845        ((config->url_get = config->url_list) != NULL)) {
 846       /* there's a node here, if it already is filled-in continue to
 847          find an "empty" node */
 848       while(config->url_get && (config->url_get->flags & GETOUT_URL))
 849         config->url_get = config->url_get->next;
 850     }
 851
 852     /* now there might or might not be an available node to fill in! */
 853
 854     if(config->url_get)
 855       /* existing node */
 856       url = config->url_get;
 857     else
 858       /* there was no free node, create one! */
 859       url = new_getout(config);
 860
 861     if(url) {
 862       metalinkfile *mlfile = new_metalinkfile(*files);
 863       if(!mlfile)
 864         break;
 865
 866       if(!mlfile->checksum) {
 867         warnings = TRUE;
 868         fprintf(config->global->errors,
 869                 "Metalink: parsing (%s) WARNING (digest missing)\n",
 870                 metalink_url);
 871       }
 872       /* Set name as url */
 873       GetStr(&url->url, mlfile->filename);
 874
 875       /* set flag metalink here */
 876       url->flags |= GETOUT_URL | GETOUT_METALINK;
 877
 878       if(config->metalinkfile_list) {
 879         config->metalinkfile_last->next = mlfile;
 880         config->metalinkfile_last = mlfile;
 881       }
 882       else {
 883         config->metalinkfile_list = config->metalinkfile_last = mlfile;
 884       }
 885     }
 886   }
 887   metalink_delete(metalink);
 888   return (warnings) ? -2 : 0;
 889 }
 890
 891 size_t metalink_write_cb(void *buffer, size_t sz, size_t nmemb,
 892                          void *userdata)
 893 {
 894   struct OutStruct *outs = userdata;
 895   struct OperationConfig *config = outs->config;
 896   int rv;
 897
 898   /*
 899    * Once that libcurl has called back tool_write_cb() the returned value
 900    * is checked against the amount that was intended to be written, if
 901    * it does not match then it fails with CURLE_WRITE_ERROR. So at this
 902    * point returning a value different from sz*nmemb indicates failure.
 903    */
 904   const size_t failure = (sz && nmemb) ? 0 : 1;
 905
 906   if(!config)
 907     return failure;
 908
 909   rv = metalink_parse_update(outs->metalink_parser, buffer, sz * nmemb);
 910   if(rv == 0)
 911     return sz * nmemb;
 912   else {
 913     fprintf(config->global->errors, "Metalink: parsing FAILED\n");
 914     return failure;
 915   }
 916 }
 917
 918 /*
 919  * Returns nonzero if content_type includes mediatype.
 920  */
 921 static int check_content_type(const char *content_type, const char *media_type)
 922 {
 923   const char *ptr = content_type;
 924   size_t media_type_len = strlen(media_type);
 925   for(; *ptr && (*ptr == ' ' || *ptr == '\t'); ++ptr);
 926   if(!*ptr) {
 927     return 0;
 928   }
 929   return curl_strnequal(ptr, media_type, media_type_len) &&
 930     (*(ptr + media_type_len) == '\0' || *(ptr + media_type_len) == ' ' ||
 931      *(ptr + media_type_len) == '\t' || *(ptr + media_type_len) == ';');
 932 }
 933
 934 int check_metalink_content_type(const char *content_type)
 935 {
 936   return check_content_type(content_type, "application/metalink+xml");
 937 }
 938
 939 int count_next_metalink_resource(metalinkfile *mlfile)
 940 {
 941   int count = 0;
 942   metalink_resource *res;
 943   for(res = mlfile->resource; res; res = res->next, ++count);
 944   return count;
 945 }
 946
 947 static void delete_metalink_checksum(metalink_checksum *chksum)
 948 {
 949   if(chksum == NULL) {
 950     return;
 951   }
 952   Curl_safefree(chksum->digest);
 953   Curl_safefree(chksum);
 954 }
 955
 956 static void delete_metalink_resource(metalink_resource *res)
 957 {
 958   if(res == NULL) {
 959     return;
 960   }
 961   Curl_safefree(res->url);
 962   Curl_safefree(res);
 963 }
 964
 965 static void delete_metalinkfile(metalinkfile *mlfile)
 966 {
 967   metalink_resource *res;
 968   if(mlfile == NULL) {
 969     return;
 970   }
 971   Curl_safefree(mlfile->filename);
 972   delete_metalink_checksum(mlfile->checksum);
 973   for(res = mlfile->resource; res;) {
 974     metalink_resource *next;
 975     next = res->next;
 976     delete_metalink_resource(res);
 977     res = next;
 978   }
 979   Curl_safefree(mlfile);
 980 }
 981
 982 void clean_metalink(struct OperationConfig *config)
 983 {
 984   while(config->metalinkfile_list) {
 985     metalinkfile *mlfile = config->metalinkfile_list;
 986     config->metalinkfile_list = config->metalinkfile_list->next;
 987     delete_metalinkfile(mlfile);
 988   }
 989   config->metalinkfile_last = 0;
 990 }
 991
 992 void metalink_cleanup(void)
 993 {
 994 #ifdef HAVE_NSS_CONTEXT
 995   if(nss_context) {
 996     NSS_ShutdownContext(nss_context);
 997     nss_context = NULL;
 998   }
 999 #endif
1000 }
1001
1002 #endif /* USE_METALINK */