[331] | 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("", "", "", "", ¶ms, 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 */
|
---|