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         abstract_pkg_t *ab_pkg;
 304
 305         pkg = pkg_new();
 306
 307         if (str_starts_with(url, "http://")
 308             || str_starts_with(url, "ftp://")) {
 309                 char *tmp_file;
 310                 char *file_basec = xstrdup(url);
 311                 char *file_base = basename(file_basec);
 312
 313                 sprintf_alloc(&tmp_file, "%s/%s", conf->tmp_dir, file_base);
 314                 err = opkg_download(url, tmp_file, NULL, NULL, 0);
 315                 if (err)
 316                         return err;
 317
 318                 err = pkg_init_from_file(pkg, tmp_file);
 319                 if (err)
 320                         return err;
 321
 322                 free(tmp_file);
 323                 free(file_basec);
 324
 325         } else if (strcmp(&url[strlen(url) - 4], OPKG_PKG_EXTENSION) == 0
 326                    || strcmp(&url[strlen(url) - 4], IPKG_PKG_EXTENSION) == 0
 327                    || strcmp(&url[strlen(url) - 4], DPKG_PKG_EXTENSION) == 0) {
 328
 329                 err = pkg_init_from_file(pkg, url);
 330                 if (err)
 331                         return err;
 332                 opkg_msg(DEBUG2, "Package %s provided by hand (%s).\n",
 333                          pkg->name, pkg_get_string(pkg, PKG_LOCAL_FILENAME));
 334                 pkg->provided_by_hand = 1;
 335
 336         } else {
 337                 ab_pkg = ensure_abstract_pkg_by_name(url);
 338
 339                 if (!(ab_pkg->state_flag & SF_NEED_DETAIL)) {
 340                         opkg_msg(DEBUG, "applying abpkg flag to %s\n", ab_pkg->name);
 341                         ab_pkg->state_flag |= SF_NEED_DETAIL;
 342                 }
 343
 344                 pkg_deinit(pkg);
 345                 free(pkg);
 346                 return 0;
 347         }
 348
 349         pkg->dest = conf->default_dest;
 350         pkg->state_want = SW_INSTALL;
 351         pkg->state_flag |= SF_PREFER;
 352         hash_insert_pkg(pkg, 1);
 353
 354         if (namep) {
 355                 *namep = xstrdup(pkg->name);
 356         }
 357         return 0;
 358 }
 359
 360 int opkg_verify_file(char *text_file, char *sig_file)
 361 {
 362 #if defined HAVE_USIGN
 363         int status = -1;
 364         int pid;
 365
 366         if (conf->check_signature == 0)
 367                 return 0;
 368
 369         pid = fork();
 370         if (pid < 0)
 371                 return -1;
 372
 373         if (!pid) {
 374                 execl("/usr/sbin/opkg-key", "opkg-key", "verify", sig_file,
 375                       text_file, NULL);
 376                 exit(255);
 377         }
 378
 379         waitpid(pid, &status, 0);
 380         if (!WIFEXITED(status) || WEXITSTATUS(status))
 381                 return -1;
 382
 383         return 0;
 384 #elif defined HAVE_GPGME
 385         if (conf->check_signature == 0)
 386                 return 0;
 387         int status = -1;
 388         gpgme_ctx_t ctx;
 389         gpgme_data_t sig, text, key;
 390         gpgme_error_t err;
 391         gpgme_verify_result_t result;
 392         gpgme_signature_t s;
 393         char *trusted_path = NULL;
 394
 395         gpgme_check_version(NULL);
 396
 397         err = gpgme_new(&ctx);
 398
 399         if (err)
 400                 return -1;
 401
 402         sprintf_alloc(&trusted_path, "%s/%s", conf->offline_root,
 403                       "/etc/opkg/trusted.gpg");
 404         err = gpgme_data_new_from_file(&key, trusted_path, 1);
 405         free(trusted_path);
 406         if (err) {
 407                 return -1;
 408         }
 409         err = gpgme_op_import(ctx, key);
 410         if (err) {
 411                 gpgme_data_release(key);
 412                 return -1;
 413         }
 414         gpgme_data_release(key);
 415
 416         err = gpgme_data_new_from_file(&sig, sig_file, 1);
 417         if (err) {
 418                 gpgme_release(ctx);
 419                 return -1;
 420         }
 421
 422         err = gpgme_data_new_from_file(&text, text_file, 1);
 423         if (err) {
 424                 gpgme_data_release(sig);
 425                 gpgme_release(ctx);
 426                 return -1;
 427         }
 428
 429         err = gpgme_op_verify(ctx, sig, text, NULL);
 430
 431         result = gpgme_op_verify_result(ctx);
 432         if (!result)
 433                 return -1;
 434
 435         /* see if any of the signitures matched */
 436         s = result->signatures;
 437         while (s) {
 438                 status = gpg_err_code(s->status);
 439                 if (status == GPG_ERR_NO_ERROR)
 440                         break;
 441                 s = s->next;
 442         }
 443
 444         gpgme_data_release(sig);
 445         gpgme_data_release(text);
 446         gpgme_release(ctx);
 447
 448         return status;
 449 #elif defined HAVE_OPENSSL
 450         X509_STORE *store = NULL;
 451         PKCS7 *p7 = NULL;
 452         BIO *in = NULL, *indata = NULL;
 453
 454         // Sig check failed by default !
 455         int status = -1;
 456
 457         openssl_init();
 458
 459         // Set-up the key store
 460         if (!
 461             (store =
 462              setup_verify(conf->signature_ca_file, conf->signature_ca_path))) {
 463                 opkg_msg(ERROR, "Can't open CA certificates.\n");
 464                 goto verify_file_end;
 465         }
 466         // Open a BIO to read the sig file
 467         if (!(in = BIO_new_file(sig_file, "rb"))) {
 468                 opkg_msg(ERROR, "Can't open signature file %s.\n", sig_file);
 469                 goto verify_file_end;
 470         }
 471         // Read the PKCS7 block contained in the sig file
 472         p7 = PEM_read_bio_PKCS7(in, NULL, NULL, NULL);
 473         if (!p7) {
 474                 opkg_msg(ERROR, "Can't read signature file %s (Corrupted ?).\n",
 475                          sig_file);
 476                 goto verify_file_end;
 477         }
 478 #if defined(HAVE_PATHFINDER)
 479         if (conf->check_x509_path) {
 480                 if (!pkcs7_pathfinder_verify_signers(p7)) {
 481                         opkg_msg(ERROR, "pkcs7_pathfinder_verify_signers: "
 482                                  "Path verification failed.\n");
 483                         goto verify_file_end;
 484                 }
 485         }
 486 #endif
 487
 488         // Open the Package file to authenticate
 489         if (!(indata = BIO_new_file(text_file, "rb"))) {
 490                 opkg_msg(ERROR, "Can't open file %s.\n", text_file);
 491                 goto verify_file_end;
 492         }
 493         // Let's verify the autenticity !
 494         if (PKCS7_verify(p7, NULL, store, indata, NULL, PKCS7_BINARY) != 1) {
 495                 // Get Off My Lawn!
 496                 opkg_msg(ERROR, "Verification failure.\n");
 497         } else {
 498                 // Victory !
 499                 status = 0;
 500         }
 501
 502 verify_file_end:
 503         BIO_free(in);
 504         BIO_free(indata);
 505         PKCS7_free(p7);
 506         X509_STORE_free(store);
 507
 508         return status;
 509 #else
 510         /* mute `unused variable' warnings. */
 511         (void)sig_file;
 512         (void)text_file;
 513         (void)conf;
 514         return 0;
 515 #endif
 516 }
 517
 518 #if defined(HAVE_OPENSSL) || defined(HAVE_SSLCURL)
 519 static void openssl_init(void)
 520 {
 521         static int init = 0;
 522
 523         if (!init) {
 524                 OPENSSL_config(NULL);
 525                 OpenSSL_add_all_algorithms();
 526                 ERR_load_crypto_strings();
 527                 init = 1;
 528         }
 529 }
 530
 531 #endif
 532
 533 #if defined HAVE_OPENSSL
 534 static X509_STORE *setup_verify(char *CAfile, char *CApath)
 535 {
 536         X509_STORE *store = NULL;
 537         X509_LOOKUP *lookup = NULL;
 538
 539         if (!(store = X509_STORE_new())) {
 540                 // Something bad is happening...
 541                 goto end;
 542         }
 543         // adds the X509 file lookup method
 544         lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file());
 545         if (lookup == NULL) {
 546                 goto end;
 547         }
 548         // Autenticating against one CA file
 549         if (CAfile) {
 550                 if (!X509_LOOKUP_load_file(lookup, CAfile, X509_FILETYPE_PEM)) {
 551                         // Invalid CA => Bye bye
 552                         opkg_msg(ERROR, "Error loading file %s.\n", CAfile);
 553                         goto end;
 554                 }
 555         } else {
 556                 X509_LOOKUP_load_file(lookup, NULL, X509_FILETYPE_DEFAULT);
 557         }
 558
 559         // Now look into CApath directory if supplied
 560         lookup = X509_STORE_add_lookup(store, X509_LOOKUP_hash_dir());
 561         if (lookup == NULL) {
 562                 goto end;
 563         }
 564
 565         if (CApath) {
 566                 if (!X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM)) {
 567                         opkg_msg(ERROR, "Error loading directory %s.\n",
 568                                  CApath);
 569                         goto end;
 570                 }
 571         } else {
 572                 X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
 573         }
 574
 575         // All right !
 576         ERR_clear_error();
 577         return store;
 578
 579 end:
 580
 581         X509_STORE_free(store);
 582         return NULL;
 583
 584 }
 585
 586 #endif
 587
 588 #ifdef HAVE_CURL
 589 void opkg_curl_cleanup(void)
 590 {
 591         if (curl != NULL) {
 592                 curl_easy_cleanup(curl);
 593                 curl = NULL;
 594         }
 595 }
 596
 597 static CURL *opkg_curl_init(curl_progress_func cb, void *data)
 598 {
 599
 600         if (curl == NULL) {
 601                 curl = curl_easy_init();
 602
 603 #ifdef HAVE_SSLCURL
 604                 openssl_init();
 605
 606                 if (conf->ssl_engine) {
 607
 608                         /* use crypto engine */
 609                         if (curl_easy_setopt
 610                             (curl, CURLOPT_SSLENGINE,
 611                              conf->ssl_engine) != CURLE_OK) {
 612                                 opkg_msg(ERROR,
 613                                          "Can't set crypto engine '%s'.\n",
 614                                          conf->ssl_engine);
 615
 616                                 opkg_curl_cleanup();
 617                                 return NULL;
 618                         }
 619                         /* set the crypto engine as default */
 620                         if (curl_easy_setopt
 621                             (curl, CURLOPT_SSLENGINE_DEFAULT, 1L) != CURLE_OK) {
 622                                 opkg_msg(ERROR,
 623                                          "Can't set crypto engine '%s' as default.\n",
 624                                          conf->ssl_engine);
 625
 626                                 opkg_curl_cleanup();
 627                                 return NULL;
 628                         }
 629                 }
 630
 631                 /* cert & key can only be in PEM case in the same file */
 632                 if (conf->ssl_key_passwd) {
 633                         if (curl_easy_setopt
 634                             (curl, CURLOPT_SSLKEYPASSWD,
 635                              conf->ssl_key_passwd) != CURLE_OK) {
 636                                 opkg_msg(DEBUG,
 637                                          "Failed to set key password.\n");
 638                         }
 639                 }
 640
 641                 /* sets the client certificate and its type */
 642                 if (conf->ssl_cert_type) {
 643                         if (curl_easy_setopt
 644                             (curl, CURLOPT_SSLCERTTYPE,
 645                              conf->ssl_cert_type) != CURLE_OK) {
 646                                 opkg_msg(DEBUG,
 647                                          "Failed to set certificate format.\n");
 648                         }
 649                 }
 650                 /* SSL cert name isn't mandatory */
 651                 if (conf->ssl_cert) {
 652                         curl_easy_setopt(curl, CURLOPT_SSLCERT, conf->ssl_cert);
 653                 }
 654
 655                 /* sets the client key and its type */
 656                 if (conf->ssl_key_type) {
 657                         if (curl_easy_setopt
 658                             (curl, CURLOPT_SSLKEYTYPE,
 659                              conf->ssl_key_type) != CURLE_OK) {
 660                                 opkg_msg(DEBUG, "Failed to set key format.\n");
 661                         }
 662                 }
 663                 if (conf->ssl_key) {
 664                         if (curl_easy_setopt
 665                             (curl, CURLOPT_SSLKEY, conf->ssl_key) != CURLE_OK) {
 666                                 opkg_msg(DEBUG, "Failed to set key.\n");
 667                         }
 668                 }
 669
 670                 /* Should we verify the peer certificate ? */
 671                 if (conf->ssl_dont_verify_peer) {
 672                         /*
 673                          * CURLOPT_SSL_VERIFYPEER default is nonzero (curl => 7.10)
 674                          */
 675                         curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
 676                 } else {
 677 #ifdef HAVE_PATHFINDER
 678                         if (conf->check_x509_path) {
 679                                 if (curl_easy_setopt
 680                                     (curl, CURLOPT_SSL_CTX_FUNCTION,
 681                                      curl_ssl_ctx_function) != CURLE_OK) {
 682                                         opkg_msg(DEBUG,
 683                                                  "Failed to set ssl path verification callback.\n");
 684                                 } else {
 685                                         curl_easy_setopt(curl,
 686                                                          CURLOPT_SSL_CTX_DATA,
 687                                                          NULL);
 688                                 }
 689                         }
 690 #endif
 691                 }
 692
 693                 /* certification authority file and/or path */
 694                 if (conf->ssl_ca_file) {
 695                         curl_easy_setopt(curl, CURLOPT_CAINFO,
 696                                          conf->ssl_ca_file);
 697                 }
 698                 if (conf->ssl_ca_path) {
 699                         curl_easy_setopt(curl, CURLOPT_CAPATH,
 700                                          conf->ssl_ca_path);
 701                 }
 702 #endif
 703
 704                 curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
 705                 curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
 706                 if (conf->http_proxy || conf->ftp_proxy) {
 707                         char *userpwd;
 708                         sprintf_alloc(&userpwd, "%s:%s", conf->proxy_user,
 709                                       conf->proxy_passwd);
 710                         curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, userpwd);
 711                         free(userpwd);
 712                 }
 713         }
 714
 715         curl_easy_setopt(curl, CURLOPT_NOPROGRESS, (cb == NULL));
 716         if (cb) {
 717                 curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, data);
 718                 curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, cb);
 719         }
 720
 721         return curl;
 722
 723 }
 724 #endif