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