libopkg/opkg_download.c

   1 /* vi: set noexpandtab sw=4 sts=4: */
   2 /* opkg_download.c - the opkg package management system
   3
   4    Carl D. Worth
   5
   6    Copyright (C) 2001 University of Southern California
   7    Copyright (C) 2008 OpenMoko Inc
   8
   9    This program is free software; you can redistribute it and/or
  10    modify it under the terms of the GNU General Public License as
  11    published by the Free Software Foundation; either version 2, or (at
  12    your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful, but
  15    WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17    General Public License for more details.
  18 */
  19
  20 #include "config.h"
  21
  22 #include <sys/wait.h>
  23 #include <stdio.h>
  24 #include <unistd.h>
  25 #include <libgen.h>
  26
  27 #include "opkg_download.h"
  28 #include "opkg_message.h"
  29
  30 #include "sprintf_alloc.h"
  31 #include "xsystem.h"
  32 #include "file_util.h"
  33 #include "opkg_defines.h"
  34 #include "libbb/libbb.h"
  35
  36 #ifdef HAVE_CURL
  37 #include <curl/curl.h>
  38 #endif
  39
  40 #if defined(HAVE_SSLCURL) || defined(HAVE_OPENSSL)
  41 #include <openssl/conf.h>
  42 #include <openssl/evp.h>
  43 #include <openssl/err.h>
  44 #include <openssl/ssl.h>
  45 #endif
  46
  47 #if defined(HAVE_GPGME)
  48 #include <gpgme.h>
  49 #elif defined(HAVE_OPENSSL)
  50 #include <openssl/bio.h>
  51 #include <openssl/objects.h>
  52 #include <openssl/x509.h>
  53 #include <openssl/pem.h>
  54 #include <openssl/hmac.h>
  55 #endif
  56
  57 #ifdef HAVE_PATHFINDER
  58 #include "opkg_pathfinder.h"
  59 #endif
  60
  61 #if defined(HAVE_OPENSSL) || defined(HAVE_SSLCURL)
  62 static void openssl_init(void);
  63 #endif
  64
  65 #ifdef HAVE_OPENSSL
  66 static X509_STORE *setup_verify(char *CAfile, char *CApath);
  67 #endif
  68
  69 #ifdef HAVE_CURL
  70 /*
  71  * Make curl an instance variable so we don't have to instanciate it
  72  * each time
  73  */
  74 static CURL *curl = NULL;
  75 static CURL *opkg_curl_init(curl_progress_func cb, void *data);
  76 #endif
  77
  78 static int str_starts_with(const char *str, const char *prefix)
  79 {
  80         return (strncmp(str, prefix, strlen(prefix)) == 0);
  81 }
  82
  83 int
  84 opkg_download(const char *src, const char *dest_file_name,
  85               curl_progress_func cb, void *data, const short hide_error)
  86 {
  87         int err = 0;
  88
  89         char *src_basec = xstrdup(src);
  90         char *src_base = basename(src_basec);
  91         char *tmp_file_location;
  92
  93         opkg_msg(NOTICE, "Downloading %s\n", src);
  94
  95         if (str_starts_with(src, "file:")) {
  96                 const char *file_src = src + 5;
  97                 opkg_msg(INFO, "Copying %s to %s...", file_src, dest_file_name);
  98                 err = file_copy(file_src, dest_file_name);
  99                 opkg_msg(INFO, "Done.\n");
 100                 free(src_basec);
 101                 return err;
 102         }
 103
 104         sprintf_alloc(&tmp_file_location, "%s/%s", conf->tmp_dir, src_base);
 105         free(src_basec);
 106         err = unlink(tmp_file_location);
 107         if (err && errno != ENOENT) {
 108                 opkg_perror(ERROR, "Failed to unlink %s", tmp_file_location);
 109                 free(tmp_file_location);
 110                 return -1;
 111         }
 112
 113         if (conf->http_proxy) {
 114                 opkg_msg(DEBUG,
 115                          "Setting environment variable: http_proxy = %s.\n",
 116                          conf->http_proxy);
 117                 setenv("http_proxy", conf->http_proxy, 1);
 118         }
 119         if (conf->ftp_proxy) {
 120                 opkg_msg(DEBUG,
 121                          "Setting environment variable: ftp_proxy = %s.\n",
 122                          conf->ftp_proxy);
 123                 setenv("ftp_proxy", conf->ftp_proxy, 1);
 124         }
 125         if (conf->no_proxy) {
 126                 opkg_msg(DEBUG,
 127                          "Setting environment variable: no_proxy = %s.\n",
 128                          conf->no_proxy);
 129                 setenv("no_proxy", conf->no_proxy, 1);
 130         }
 131 #ifdef HAVE_CURL
 132         CURLcode res;
 133         FILE *file = fopen(tmp_file_location, "w");
 134
 135         curl = opkg_curl_init(cb, data);
 136         if (curl) {
 137                 curl_easy_setopt(curl, CURLOPT_URL, src);
 138                 curl_easy_setopt(curl, CURLOPT_WRITEDATA, file);
 139
 140                 res = curl_easy_perform(curl);
 141                 fclose(file);
 142                 if (res) {
 143                         long error_code;
 144                         curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE,
 145                                           &error_code);
 146                         opkg_msg(hide_error ? DEBUG2 : ERROR,
 147                                  "Failed to download %s: %s.\n", src,
 148                                  curl_easy_strerror(res));
 149                         free(tmp_file_location);
 150                         return -1;
 151                 }
 152
 153         } else {
 154                 free(tmp_file_location);
 155                 return -1;
 156         }
 157 #else
 158         {
 159                 int res;
 160                 const char *argv[8];
 161                 int i = 0;
 162
 163                 argv[i++] = "wget";
 164                 argv[i++] = "-q";
 165                 if (conf->http_proxy || conf->ftp_proxy) {
 166                         argv[i++] = "-Y";
 167                         argv[i++] = "on";
 168                 }
 169                 argv[i++] = "-O";
 170                 argv[i++] = tmp_file_location;
 171                 argv[i++] = src;
 172                 argv[i++] = NULL;
 173                 res = xsystem(argv);
 174
 175                 if (res) {
 176                         opkg_msg(ERROR,
 177                                  "Failed to download %s, wget returned %d.\n",
 178                                  src, res);
 179                         if (res == 4)
 180                                 opkg_msg(ERROR,
 181                                          "Check your network settings and connectivity.\n\n");
 182                         free(tmp_file_location);
 183                         return -1;
 184                 }
 185         }
 186 #endif
 187
 188         err = file_move(tmp_file_location, dest_file_name);
 189
 190         free(tmp_file_location);
 191
 192         return err;
 193 }
 194
 195 static int
 196 opkg_download_cache(const char *src, const char *dest_file_name,
 197                     curl_progress_func cb, void *data)
 198 {
 199         char *cache_name = xstrdup(src);
 200         char *cache_location, *p;
 201         int err = 0;
 202
 203         if (!conf->cache || str_starts_with(src, "file:")) {
 204                 err = opkg_download(src, dest_file_name, cb, data, 0);
 205                 goto out1;
 206         }
 207
 208         if (!file_is_dir(conf->cache)) {
 209                 opkg_msg(ERROR, "%s is not a directory.\n", conf->cache);
 210                 err = 1;
 211                 goto out1;
 212         }
 213
 214         for (p = cache_name; *p; p++)
 215                 if (*p == '/')
 216                         *p = ',';       /* looks nicer than | or # */
 217
 218         sprintf_alloc(&cache_location, "%s/%s", conf->cache, cache_name);
 219         if (file_exists(cache_location))
 220                 opkg_msg(NOTICE, "Copying %s.\n", cache_location);
 221         else {
 222                 /* cache file with funky name not found, try simple name */
 223                 free(cache_name);
 224                 char *filename = strrchr(dest_file_name, '/');
 225                 if (filename)
 226                         cache_name = xstrdup(filename + 1);     // strip leading '/'
 227                 else
 228                         cache_name = xstrdup(dest_file_name);
 229                 free(cache_location);
 230                 sprintf_alloc(&cache_location, "%s/%s", conf->cache,
 231                               cache_name);
 232                 if (file_exists(cache_location))
 233                         opkg_msg(NOTICE, "Copying %s.\n", cache_location);
 234                 else {
 235                         err = opkg_download(src, cache_location, cb, data, 0);
 236                         if (err) {
 237                                 (void)unlink(cache_location);
 238                                 goto out2;
 239                         }
 240                 }
 241         }
 242
 243         err = file_copy(cache_location, dest_file_name);
 244
 245 out2:
 246         free(cache_location);
 247 out1:
 248         free(cache_name);
 249         return err;
 250 }
 251
 252 int opkg_download_pkg(pkg_t * pkg, const char *dir)
 253 {
 254         int err;
 255         char *url;
 256         char *local_filename;
 257         char *stripped_filename;
 258         char *filename;
 259
 260         if (pkg->src == NULL) {
 261                 opkg_msg(ERROR,
 262                          "Package %s is not available from any configured src.\n",
 263                          pkg->name);
 264                 return -1;
 265         }
 266
 267         filename = pkg_get_string(pkg, PKG_FILENAME);
 268
 269         if (filename == NULL) {
 270                 opkg_msg(ERROR,
 271                          "Package %s does not have a valid filename field.\n",
 272                          pkg->name);
 273                 return -1;
 274         }
 275
 276         sprintf_alloc(&url, "%s/%s", pkg->src->value, filename);
 277
 278         /* The filename might be something like
 279            "../../foo.opk". While this is correct, and exactly what we
 280            want to use to construct url above, here we actually need to
 281            use just the filename part, without any directory. */
 282
 283         stripped_filename = strrchr(filename, '/');
 284         if (!stripped_filename)
 285                 stripped_filename = filename;
 286
 287         sprintf_alloc(&local_filename, "%s/%s", dir, stripped_filename);
 288         pkg_set_string(pkg, PKG_LOCAL_FILENAME, local_filename);
 289
 290         err = opkg_download_cache(url, local_filename, NULL, NULL);
 291         free(url);
 292
 293         return err;
 294 }
 295
 296 /*
 297  * Downloads file from url, installs in package database, return package name.
 298  */
 299 int opkg_prepare_url_for_install(const char *url, char **namep)
 300 {
 301         int err = 0;
 302         pkg_t *pkg;
 303
 304         pkg = pkg_new();
 305
 306         if (str_starts_with(url, "http://")
 307             || str_starts_with(url, "ftp://")) {
 308                 char *tmp_file;
 309                 char *file_basec = xstrdup(url);
 310                 char *file_base = basename(file_basec);
 311
 312                 sprintf_alloc(&tmp_file, "%s/%s", conf->tmp_dir, file_base);
 313                 err = opkg_download(url, tmp_file, NULL, NULL, 0);
 314                 if (err)
 315                         return err;
 316
 317                 err = pkg_init_from_file(pkg, tmp_file);
 318                 if (err)
 319                         return err;
 320
 321                 free(tmp_file);
 322                 free(file_basec);
 323
 324         } else if (strcmp(&url[strlen(url) - 4], OPKG_PKG_EXTENSION) == 0
 325                    || strcmp(&url[strlen(url) - 4], IPKG_PKG_EXTENSION) == 0
 326                    || strcmp(&url[strlen(url) - 4], DPKG_PKG_EXTENSION) == 0) {
 327
 328                 err = pkg_init_from_file(pkg, url);
 329                 if (err)
 330                         return err;
 331                 opkg_msg(DEBUG2, "Package %s provided by hand (%s).\n",
 332                          pkg->name, pkg_get_string(pkg, PKG_LOCAL_FILENAME));
 333                 pkg->provided_by_hand = 1;
 334
 335         } else {
 336                 pkg_deinit(pkg);
 337                 free(pkg);
 338                 return 0;
 339         }
 340
 341         pkg->dest = conf->default_dest;
 342         pkg->state_want = SW_INSTALL;
 343         pkg->state_flag |= SF_PREFER;
 344         hash_insert_pkg(pkg, 1);
 345
 346         if (namep) {
 347                 *namep = xstrdup(pkg->name);
 348         }
 349         return 0;
 350 }
 351
 352 int opkg_verify_file(char *text_file, char *sig_file)
 353 {
 354 #if defined HAVE_USIGN
 355         int status = -1;
 356         int pid;
 357
 358         if (conf->check_signature == 0)
 359                 return 0;
 360
 361         pid = fork();
 362         if (pid < 0)
 363                 return -1;
 364
 365         if (!pid) {
 366                 execl("/usr/sbin/opkg-key", "opkg-key", "verify", sig_file,
 367                       text_file, NULL);
 368                 exit(255);
 369         }
 370
 371         waitpid(pid, &status, 0);
 372         if (!WIFEXITED(status) || WEXITSTATUS(status))
 373                 return -1;
 374
 375         return 0;
 376 #elif defined HAVE_GPGME
 377         if (conf->check_signature == 0)
 378                 return 0;
 379         int status = -1;
 380         gpgme_ctx_t ctx;
 381         gpgme_data_t sig, text, key;
 382         gpgme_error_t err;
 383         gpgme_verify_result_t result;
 384         gpgme_signature_t s;
 385         char *trusted_path = NULL;
 386
 387         gpgme_check_version(NULL);
 388
 389         err = gpgme_new(&ctx);
 390
 391         if (err)
 392                 return -1;
 393
 394         sprintf_alloc(&trusted_path, "%s/%s", conf->offline_root,
 395                       "/etc/opkg/trusted.gpg");
 396         err = gpgme_data_new_from_file(&key, trusted_path, 1);
 397         free(trusted_path);
 398         if (err) {
 399                 return -1;
 400         }
 401         err = gpgme_op_import(ctx, key);
 402         if (err) {
 403                 gpgme_data_release(key);
 404                 return -1;
 405         }
 406         gpgme_data_release(key);
 407
 408         err = gpgme_data_new_from_file(&sig, sig_file, 1);
 409         if (err) {
 410                 gpgme_release(ctx);
 411                 return -1;
 412         }
 413
 414         err = gpgme_data_new_from_file(&text, text_file, 1);
 415         if (err) {
 416                 gpgme_data_release(sig);
 417                 gpgme_release(ctx);
 418                 return -1;
 419         }
 420
 421         err = gpgme_op_verify(ctx, sig, text, NULL);
 422
 423         result = gpgme_op_verify_result(ctx);
 424         if (!result)
 425                 return -1;
 426
 427         /* see if any of the signitures matched */
 428         s = result->signatures;
 429         while (s) {
 430                 status = gpg_err_code(s->status);
 431                 if (status == GPG_ERR_NO_ERROR)
 432                         break;
 433                 s = s->next;
 434         }
 435
 436         gpgme_data_release(sig);
 437         gpgme_data_release(text);
 438         gpgme_release(ctx);
 439
 440         return status;
 441 #elif defined HAVE_OPENSSL
 442         X509_STORE *store = NULL;
 443         PKCS7 *p7 = NULL;
 444         BIO *in = NULL, *indata = NULL;
 445
 446         // Sig check failed by default !
 447         int status = -1;
 448
 449         openssl_init();
 450
 451         // Set-up the key store
 452         if (!
 453             (store =
 454              setup_verify(conf->signature_ca_file, conf->signature_ca_path))) {
 455                 opkg_msg(ERROR, "Can't open CA certificates.\n");
 456                 goto verify_file_end;
 457         }
 458         // Open a BIO to read the sig file
 459         if (!(in = BIO_new_file(sig_file, "rb"))) {
 460                 opkg_msg(ERROR, "Can't open signature file %s.\n", sig_file);
 461                 goto verify_file_end;
 462         }
 463         // Read the PKCS7 block contained in the sig file
 464         p7 = PEM_read_bio_PKCS7(in, NULL, NULL, NULL);
 465         if (!p7) {
 466                 opkg_msg(ERROR, "Can't read signature file %s (Corrupted ?).\n",
 467                          sig_file);
 468                 goto verify_file_end;
 469         }
 470 #if defined(HAVE_PATHFINDER)
 471         if (conf->check_x509_path) {
 472                 if (!pkcs7_pathfinder_verify_signers(p7)) {
 473                         opkg_msg(ERROR, "pkcs7_pathfinder_verify_signers: "
 474                                  "Path verification failed.\n");
 475                         goto verify_file_end;
 476                 }
 477         }
 478 #endif
 479
 480         // Open the Package file to authenticate
 481         if (!(indata = BIO_new_file(text_file, "rb"))) {
 482                 opkg_msg(ERROR, "Can't open file %s.\n", text_file);
 483                 goto verify_file_end;
 484         }
 485         // Let's verify the autenticity !
 486         if (PKCS7_verify(p7, NULL, store, indata, NULL, PKCS7_BINARY) != 1) {
 487                 // Get Off My Lawn!
 488                 opkg_msg(ERROR, "Verification failure.\n");
 489         } else {
 490                 // Victory !
 491                 status = 0;
 492         }
 493
 494 verify_file_end:
 495         BIO_free(in);
 496         BIO_free(indata);
 497         PKCS7_free(p7);
 498         X509_STORE_free(store);
 499
 500         return status;
 501 #else
 502         /* mute `unused variable' warnings. */
 503         (void)sig_file;
 504         (void)text_file;
 505         (void)conf;
 506         return 0;
 507 #endif
 508 }
 509
 510 #if defined(HAVE_OPENSSL) || defined(HAVE_SSLCURL)
 511 static void openssl_init(void)
 512 {
 513         static int init = 0;
 514
 515         if (!init) {
 516                 OPENSSL_config(NULL);
 517                 OpenSSL_add_all_algorithms();
 518                 ERR_load_crypto_strings();
 519                 init = 1;
 520         }
 521 }
 522
 523 #endif
 524
 525 #if defined HAVE_OPENSSL
 526 static X509_STORE *setup_verify(char *CAfile, char *CApath)
 527 {
 528         X509_STORE *store = NULL;
 529         X509_LOOKUP *lookup = NULL;
 530
 531         if (!(store = X509_STORE_new())) {
 532                 // Something bad is happening...
 533                 goto end;
 534         }
 535         // adds the X509 file lookup method
 536         lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file());
 537         if (lookup == NULL) {
 538                 goto end;
 539         }
 540         // Autenticating against one CA file
 541         if (CAfile) {
 542                 if (!X509_LOOKUP_load_file(lookup, CAfile, X509_FILETYPE_PEM)) {
 543                         // Invalid CA => Bye bye
 544                         opkg_msg(ERROR, "Error loading file %s.\n", CAfile);
 545                         goto end;
 546                 }
 547         } else {
 548                 X509_LOOKUP_load_file(lookup, NULL, X509_FILETYPE_DEFAULT);
 549         }
 550
 551         // Now look into CApath directory if supplied
 552         lookup = X509_STORE_add_lookup(store, X509_LOOKUP_hash_dir());
 553         if (lookup == NULL) {
 554                 goto end;
 555         }
 556
 557         if (CApath) {
 558                 if (!X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM)) {
 559                         opkg_msg(ERROR, "Error loading directory %s.\n",
 560                                  CApath);
 561                         goto end;
 562                 }
 563         } else {
 564                 X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
 565         }
 566
 567         // All right !
 568         ERR_clear_error();
 569         return store;
 570
 571 end:
 572
 573         X509_STORE_free(store);
 574         return NULL;
 575
 576 }
 577
 578 #endif
 579
 580 #ifdef HAVE_CURL
 581 void opkg_curl_cleanup(void)
 582 {
 583         if (curl != NULL) {
 584                 curl_easy_cleanup(curl);
 585                 curl = NULL;
 586         }
 587 }
 588
 589 static CURL *opkg_curl_init(curl_progress_func cb, void *data)
 590 {
 591
 592         if (curl == NULL) {
 593                 curl = curl_easy_init();
 594
 595 #ifdef HAVE_SSLCURL
 596                 openssl_init();
 597
 598                 if (conf->ssl_engine) {
 599
 600                         /* use crypto engine */
 601                         if (curl_easy_setopt
 602                             (curl, CURLOPT_SSLENGINE,
 603                              conf->ssl_engine) != CURLE_OK) {
 604                                 opkg_msg(ERROR,
 605                                          "Can't set crypto engine '%s'.\n",
 606                                          conf->ssl_engine);
 607
 608                                 opkg_curl_cleanup();
 609                                 return NULL;
 610                         }
 611                         /* set the crypto engine as default */
 612                         if (curl_easy_setopt
 613                             (curl, CURLOPT_SSLENGINE_DEFAULT, 1L) != CURLE_OK) {
 614                                 opkg_msg(ERROR,
 615                                          "Can't set crypto engine '%s' as default.\n",
 616                                          conf->ssl_engine);
 617
 618                                 opkg_curl_cleanup();
 619                                 return NULL;
 620                         }
 621                 }
 622
 623                 /* cert & key can only be in PEM case in the same file */
 624                 if (conf->ssl_key_passwd) {
 625                         if (curl_easy_setopt
 626                             (curl, CURLOPT_SSLKEYPASSWD,
 627                              conf->ssl_key_passwd) != CURLE_OK) {
 628                                 opkg_msg(DEBUG,
 629                                          "Failed to set key password.\n");
 630                         }
 631                 }
 632
 633                 /* sets the client certificate and its type */
 634                 if (conf->ssl_cert_type) {
 635                         if (curl_easy_setopt
 636                             (curl, CURLOPT_SSLCERTTYPE,
 637                              conf->ssl_cert_type) != CURLE_OK) {
 638                                 opkg_msg(DEBUG,
 639                                          "Failed to set certificate format.\n");
 640                         }
 641                 }
 642                 /* SSL cert name isn't mandatory */
 643                 if (conf->ssl_cert) {
 644                         curl_easy_setopt(curl, CURLOPT_SSLCERT, conf->ssl_cert);
 645                 }
 646
 647                 /* sets the client key and its type */
 648                 if (conf->ssl_key_type) {
 649                         if (curl_easy_setopt
 650                             (curl, CURLOPT_SSLKEYTYPE,
 651                              conf->ssl_key_type) != CURLE_OK) {
 652                                 opkg_msg(DEBUG, "Failed to set key format.\n");
 653                         }
 654                 }
 655                 if (conf->ssl_key) {
 656                         if (curl_easy_setopt
 657                             (curl, CURLOPT_SSLKEY, conf->ssl_key) != CURLE_OK) {
 658                                 opkg_msg(DEBUG, "Failed to set key.\n");
 659                         }
 660                 }
 661
 662                 /* Should we verify the peer certificate ? */
 663                 if (conf->ssl_dont_verify_peer) {
 664                         /*
 665                          * CURLOPT_SSL_VERIFYPEER default is nonzero (curl => 7.10)
 666                          */
 667                         curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
 668                 } else {
 669 #ifdef HAVE_PATHFINDER
 670                         if (conf->check_x509_path) {
 671                                 if (curl_easy_setopt
 672                                     (curl, CURLOPT_SSL_CTX_FUNCTION,
 673                                      curl_ssl_ctx_function) != CURLE_OK) {
 674                                         opkg_msg(DEBUG,
 675                                                  "Failed to set ssl path verification callback.\n");
 676                                 } else {
 677                                         curl_easy_setopt(curl,
 678                                                          CURLOPT_SSL_CTX_DATA,
 679                                                          NULL);
 680                                 }
 681                         }
 682 #endif
 683                 }
 684
 685                 /* certification authority file and/or path */
 686                 if (conf->ssl_ca_file) {
 687                         curl_easy_setopt(curl, CURLOPT_CAINFO,
 688                                          conf->ssl_ca_file);
 689                 }
 690                 if (conf->ssl_ca_path) {
 691                         curl_easy_setopt(curl, CURLOPT_CAPATH,
 692                                          conf->ssl_ca_path);
 693                 }
 694 #endif
 695
 696                 curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
 697                 curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
 698                 if (conf->http_proxy || conf->ftp_proxy) {
 699                         char *userpwd;
 700                         sprintf_alloc(&userpwd, "%s:%s", conf->proxy_user,
 701                                       conf->proxy_passwd);
 702                         curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, userpwd);
 703                         free(userpwd);
 704                 }
 705         }
 706
 707         curl_easy_setopt(curl, CURLOPT_NOPROGRESS, (cb == NULL));
 708         if (cb) {
 709                 curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, data);
 710                 curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, cb);
 711         }
 712
 713         return curl;
 714
 715 }
 716 #endif