tests/libgit2/online/clone.c

   1 #include "clar_libgit2.h"
   2
   3 #include "git2/clone.h"
   4 #include "git2/cred_helpers.h"
   5 #include "remote.h"
   6 #include "futils.h"
   7 #include "refs.h"
   8
   9 #define LIVE_REPO_URL "http://github.com/libgit2/TestGitRepository"
  10 #define LIVE_EMPTYREPO_URL "http://github.com/libgit2/TestEmptyRepository"
  11 #define BB_REPO_URL "https://libgit2-test@bitbucket.org/libgit2-test/testgitrepository.git"
  12 #define BB_REPO_URL_WITH_PASS "https://libgit2-test:YT77Ppm2nq8w4TYjGS8U@bitbucket.org/libgit2-test/testgitrepository.git"
  13 #define BB_REPO_URL_WITH_WRONG_PASS "https://libgit2-test:wrong@bitbucket.org/libgit2-test/testgitrepository.git"
  14 #define GOOGLESOURCE_REPO_URL "https://chromium.googlesource.com/external/github.com/sergi/go-diff"
  15
  16 #define SSH_REPO_URL "ssh://github.com/libgit2/TestGitRepository"
  17
  18 static git_repository *g_repo;
  19 static git_clone_options g_options;
  20
  21 static char *_remote_url = NULL;
  22 static char *_remote_user = NULL;
  23 static char *_remote_pass = NULL;
  24 static char *_remote_sslnoverify = NULL;
  25 static char *_remote_ssh_pubkey = NULL;
  26 static char *_remote_ssh_privkey = NULL;
  27 static char *_remote_ssh_passphrase = NULL;
  28 static char *_remote_ssh_fingerprint = NULL;
  29 static char *_remote_proxy_scheme = NULL;
  30 static char *_remote_proxy_host = NULL;
  31 static char *_remote_proxy_user = NULL;
  32 static char *_remote_proxy_pass = NULL;
  33 static char *_remote_proxy_selfsigned = NULL;
  34 static char *_remote_expectcontinue = NULL;
  35 static char *_remote_redirect_initial = NULL;
  36 static char *_remote_redirect_subsequent = NULL;
  37
  38 static int _orig_proxies_need_reset = 0;
  39 static char *_orig_http_proxy = NULL;
  40 static char *_orig_https_proxy = NULL;
  41 static char *_orig_no_proxy = NULL;
  42
  43 static int ssl_cert(git_cert *cert, int valid, const char *host, void *payload)
  44 {
  45         GIT_UNUSED(cert);
  46         GIT_UNUSED(host);
  47         GIT_UNUSED(payload);
  48
  49         if (_remote_sslnoverify != NULL)
  50                 valid = 1;
  51
  52         return valid ? 0 : GIT_ECERTIFICATE;
  53 }
  54
  55 void test_online_clone__initialize(void)
  56 {
  57         git_checkout_options dummy_opts = GIT_CHECKOUT_OPTIONS_INIT;
  58         git_fetch_options dummy_fetch = GIT_FETCH_OPTIONS_INIT;
  59
  60         g_repo = NULL;
  61
  62         memset(&g_options, 0, sizeof(git_clone_options));
  63         g_options.version = GIT_CLONE_OPTIONS_VERSION;
  64         g_options.checkout_opts = dummy_opts;
  65         g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
  66         g_options.fetch_opts = dummy_fetch;
  67         g_options.fetch_opts.callbacks.certificate_check = ssl_cert;
  68
  69         _remote_url = cl_getenv("GITTEST_REMOTE_URL");
  70         _remote_user = cl_getenv("GITTEST_REMOTE_USER");
  71         _remote_pass = cl_getenv("GITTEST_REMOTE_PASS");
  72         _remote_sslnoverify = cl_getenv("GITTEST_REMOTE_SSL_NOVERIFY");
  73         _remote_ssh_pubkey = cl_getenv("GITTEST_REMOTE_SSH_PUBKEY");
  74         _remote_ssh_privkey = cl_getenv("GITTEST_REMOTE_SSH_KEY");
  75         _remote_ssh_passphrase = cl_getenv("GITTEST_REMOTE_SSH_PASSPHRASE");
  76         _remote_ssh_fingerprint = cl_getenv("GITTEST_REMOTE_SSH_FINGERPRINT");
  77         _remote_proxy_scheme = cl_getenv("GITTEST_REMOTE_PROXY_SCHEME");
  78         _remote_proxy_host = cl_getenv("GITTEST_REMOTE_PROXY_HOST");
  79         _remote_proxy_user = cl_getenv("GITTEST_REMOTE_PROXY_USER");
  80         _remote_proxy_pass = cl_getenv("GITTEST_REMOTE_PROXY_PASS");
  81         _remote_proxy_selfsigned = cl_getenv("GITTEST_REMOTE_PROXY_SELFSIGNED");
  82         _remote_expectcontinue = cl_getenv("GITTEST_REMOTE_EXPECTCONTINUE");
  83         _remote_redirect_initial = cl_getenv("GITTEST_REMOTE_REDIRECT_INITIAL");
  84         _remote_redirect_subsequent = cl_getenv("GITTEST_REMOTE_REDIRECT_SUBSEQUENT");
  85
  86         if (_remote_expectcontinue)
  87                 git_libgit2_opts(GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE, 1);
  88
  89         _orig_proxies_need_reset = 0;
  90 }
  91
  92 void test_online_clone__cleanup(void)
  93 {
  94         if (g_repo) {
  95                 git_repository_free(g_repo);
  96                 g_repo = NULL;
  97         }
  98         cl_fixture_cleanup("./foo");
  99         cl_fixture_cleanup("./initial");
 100         cl_fixture_cleanup("./subsequent");
 101
 102         git__free(_remote_url);
 103         git__free(_remote_user);
 104         git__free(_remote_pass);
 105         git__free(_remote_sslnoverify);
 106         git__free(_remote_ssh_pubkey);
 107         git__free(_remote_ssh_privkey);
 108         git__free(_remote_ssh_passphrase);
 109         git__free(_remote_ssh_fingerprint);
 110         git__free(_remote_proxy_scheme);
 111         git__free(_remote_proxy_host);
 112         git__free(_remote_proxy_user);
 113         git__free(_remote_proxy_pass);
 114         git__free(_remote_proxy_selfsigned);
 115         git__free(_remote_expectcontinue);
 116         git__free(_remote_redirect_initial);
 117         git__free(_remote_redirect_subsequent);
 118
 119         if (_orig_proxies_need_reset) {
 120                 cl_setenv("HTTP_PROXY", _orig_http_proxy);
 121                 cl_setenv("HTTPS_PROXY", _orig_https_proxy);
 122                 cl_setenv("NO_PROXY", _orig_no_proxy);
 123
 124                 git__free(_orig_http_proxy);
 125                 git__free(_orig_https_proxy);
 126                 git__free(_orig_no_proxy);
 127         }
 128
 129         git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, NULL, NULL);
 130 }
 131
 132 void test_online_clone__network_full(void)
 133 {
 134         git_remote *origin;
 135
 136         cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 137         cl_assert(!git_repository_is_bare(g_repo));
 138         cl_git_pass(git_remote_lookup(&origin, g_repo, "origin"));
 139
 140         cl_assert_equal_i(GIT_REMOTE_DOWNLOAD_TAGS_AUTO, origin->download_tags);
 141
 142         git_remote_free(origin);
 143 }
 144
 145 void test_online_clone__network_bare(void)
 146 {
 147         git_remote *origin;
 148
 149         g_options.bare = true;
 150
 151         cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 152         cl_assert(git_repository_is_bare(g_repo));
 153         cl_git_pass(git_remote_lookup(&origin, g_repo, "origin"));
 154
 155         git_remote_free(origin);
 156 }
 157
 158 void test_online_clone__empty_repository(void)
 159 {
 160         git_reference *head;
 161
 162         cl_git_pass(git_clone(&g_repo, LIVE_EMPTYREPO_URL, "./foo", &g_options));
 163
 164         cl_assert_equal_i(true, git_repository_is_empty(g_repo));
 165         cl_assert_equal_i(true, git_repository_head_unborn(g_repo));
 166
 167         cl_git_pass(git_reference_lookup(&head, g_repo, GIT_HEAD_FILE));
 168         cl_assert_equal_i(GIT_REFERENCE_SYMBOLIC, git_reference_type(head));
 169         cl_assert_equal_s("refs/heads/master", git_reference_symbolic_target(head));
 170
 171         git_reference_free(head);
 172 }
 173
 174 static void checkout_progress(const char *path, size_t cur, size_t tot, void *payload)
 175 {
 176         bool *was_called = (bool*)payload;
 177         GIT_UNUSED(path); GIT_UNUSED(cur); GIT_UNUSED(tot);
 178         (*was_called) = true;
 179 }
 180
 181 static int fetch_progress(const git_indexer_progress *stats, void *payload)
 182 {
 183         bool *was_called = (bool*)payload;
 184         GIT_UNUSED(stats);
 185         (*was_called) = true;
 186         return 0;
 187 }
 188
 189 void test_online_clone__can_checkout_a_cloned_repo(void)
 190 {
 191         git_str path = GIT_STR_INIT;
 192         git_reference *head, *remote_head;
 193         bool checkout_progress_cb_was_called = false,
 194                   fetch_progress_cb_was_called = false;
 195
 196         g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
 197         g_options.checkout_opts.progress_cb = &checkout_progress;
 198         g_options.checkout_opts.progress_payload = &checkout_progress_cb_was_called;
 199         g_options.fetch_opts.callbacks.transfer_progress = &fetch_progress;
 200         g_options.fetch_opts.callbacks.payload = &fetch_progress_cb_was_called;
 201
 202         cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 203
 204         cl_git_pass(git_str_joinpath(&path, git_repository_workdir(g_repo), "master.txt"));
 205         cl_assert_equal_i(true, git_fs_path_isfile(git_str_cstr(&path)));
 206
 207         cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
 208         cl_assert_equal_i(GIT_REFERENCE_SYMBOLIC, git_reference_type(head));
 209         cl_assert_equal_s("refs/heads/master", git_reference_symbolic_target(head));
 210
 211         cl_git_pass(git_reference_lookup(&remote_head, g_repo, "refs/remotes/origin/HEAD"));
 212         cl_assert_equal_i(GIT_REFERENCE_SYMBOLIC, git_reference_type(remote_head));
 213         cl_assert_equal_s("refs/remotes/origin/master", git_reference_symbolic_target(remote_head));
 214
 215         cl_assert_equal_i(true, checkout_progress_cb_was_called);
 216         cl_assert_equal_i(true, fetch_progress_cb_was_called);
 217
 218         git_reference_free(remote_head);
 219         git_reference_free(head);
 220         git_str_dispose(&path);
 221 }
 222
 223 static int remote_mirror_cb(git_remote **out, git_repository *repo,
 224                             const char *name, const char *url, void *payload)
 225 {
 226         int error;
 227         git_remote *remote;
 228
 229         GIT_UNUSED(payload);
 230
 231         if ((error = git_remote_create_with_fetchspec(&remote, repo, name, url, "+refs/*:refs/*")) < 0)
 232                 return error;
 233
 234         *out = remote;
 235         return 0;
 236 }
 237
 238 void test_online_clone__clone_mirror(void)
 239 {
 240         git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
 241         git_reference *head;
 242
 243         bool fetch_progress_cb_was_called = false;
 244
 245         opts.fetch_opts.callbacks.transfer_progress = &fetch_progress;
 246         opts.fetch_opts.callbacks.payload = &fetch_progress_cb_was_called;
 247
 248         opts.bare = true;
 249         opts.remote_cb = remote_mirror_cb;
 250
 251         cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo.git", &opts));
 252
 253         cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
 254         cl_assert_equal_i(GIT_REFERENCE_SYMBOLIC, git_reference_type(head));
 255         cl_assert_equal_s("refs/heads/master", git_reference_symbolic_target(head));
 256
 257         cl_assert_equal_i(true, fetch_progress_cb_was_called);
 258
 259         git_reference_free(head);
 260         git_repository_free(g_repo);
 261         g_repo = NULL;
 262
 263         cl_fixture_cleanup("./foo.git");
 264 }
 265
 266 static int update_tips(const char *refname, const git_oid *a, const git_oid *b, void *payload)
 267 {
 268         int *callcount = (int*)payload;
 269         GIT_UNUSED(refname); GIT_UNUSED(a); GIT_UNUSED(b);
 270         *callcount = *callcount + 1;
 271         return 0;
 272 }
 273
 274 void test_online_clone__custom_remote_callbacks(void)
 275 {
 276         int callcount = 0;
 277
 278         g_options.fetch_opts.callbacks.update_tips = update_tips;
 279         g_options.fetch_opts.callbacks.payload = &callcount;
 280
 281         cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 282         cl_assert(callcount > 0);
 283 }
 284
 285 void test_online_clone__custom_headers(void)
 286 {
 287         char *empty_header = "";
 288         char *unnamed_header = "this is a header about nothing";
 289         char *newlines = "X-Custom: almost OK\n";
 290         char *conflict = "Accept: defined-by-git";
 291         char *ok = "X-Custom: this should be ok";
 292
 293         g_options.fetch_opts.custom_headers.count = 1;
 294
 295         g_options.fetch_opts.custom_headers.strings = &empty_header;
 296         cl_git_fail(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 297
 298         g_options.fetch_opts.custom_headers.strings = &unnamed_header;
 299         cl_git_fail(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 300
 301         g_options.fetch_opts.custom_headers.strings = &newlines;
 302         cl_git_fail(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 303
 304         g_options.fetch_opts.custom_headers.strings = &conflict;
 305         cl_git_fail(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 306
 307         /* Finally, we got it right! */
 308         g_options.fetch_opts.custom_headers.strings = &ok;
 309         cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 310 }
 311
 312 static int cred_failure_cb(
 313         git_credential **cred,
 314         const char *url,
 315         const char *username_from_url,
 316         unsigned int allowed_types,
 317         void *data)
 318 {
 319         GIT_UNUSED(cred); GIT_UNUSED(url); GIT_UNUSED(username_from_url);
 320         GIT_UNUSED(allowed_types); GIT_UNUSED(data);
 321         return -172;
 322 }
 323
 324 void test_online_clone__cred_callback_failure_return_code_is_tunnelled(void)
 325 {
 326         git__free(_remote_url);
 327         git__free(_remote_user);
 328
 329         _remote_url = git__strdup("https://github.com/libgit2/non-existent");
 330         _remote_user = git__strdup("libgit2test");
 331
 332         g_options.fetch_opts.callbacks.credentials = cred_failure_cb;
 333
 334         cl_git_fail_with(-172, git_clone(&g_repo, _remote_url, "./foo", &g_options));
 335 }
 336
 337 static int cred_count_calls_cb(git_credential **cred, const char *url, const char *user,
 338                                unsigned int allowed_types, void *data)
 339 {
 340         size_t *counter = (size_t *) data;
 341
 342         GIT_UNUSED(url); GIT_UNUSED(user); GIT_UNUSED(allowed_types);
 343
 344         if (allowed_types == GIT_CREDENTIAL_USERNAME)
 345                 return git_credential_username_new(cred, "foo");
 346
 347         (*counter)++;
 348
 349         if (*counter == 3)
 350                 return GIT_EUSER;
 351
 352         return git_credential_userpass_plaintext_new(cred, "foo", "bar");
 353 }
 354
 355 void test_online_clone__cred_callback_called_again_on_auth_failure(void)
 356 {
 357         size_t counter = 0;
 358
 359         git__free(_remote_url);
 360         git__free(_remote_user);
 361
 362         _remote_url = git__strdup("https://gitlab.com/libgit2/non-existent");
 363         _remote_user = git__strdup("libgit2test");
 364
 365         g_options.fetch_opts.callbacks.credentials = cred_count_calls_cb;
 366         g_options.fetch_opts.callbacks.payload = &counter;
 367
 368         cl_git_fail_with(GIT_EUSER, git_clone(&g_repo, _remote_url, "./foo", &g_options));
 369         cl_assert_equal_i(3, counter);
 370 }
 371
 372 static int cred_default(
 373         git_credential **cred,
 374         const char *url,
 375         const char *user_from_url,
 376         unsigned int allowed_types,
 377         void *payload)
 378 {
 379         GIT_UNUSED(url);
 380         GIT_UNUSED(user_from_url);
 381         GIT_UNUSED(payload);
 382
 383         if (!(allowed_types & GIT_CREDENTIAL_DEFAULT))
 384                 return 0;
 385
 386         return git_credential_default_new(cred);
 387 }
 388
 389 void test_online_clone__credentials(void)
 390 {
 391         /* Remote URL environment variable must be set.
 392          * User and password are optional.
 393          */
 394         git_credential_userpass_payload user_pass = {
 395                 _remote_user,
 396                 _remote_pass
 397         };
 398
 399         if (!_remote_url)
 400                 clar__skip();
 401
 402         if (cl_is_env_set("GITTEST_REMOTE_DEFAULT")) {
 403                 g_options.fetch_opts.callbacks.credentials = cred_default;
 404         } else {
 405                 g_options.fetch_opts.callbacks.credentials = git_credential_userpass;
 406                 g_options.fetch_opts.callbacks.payload = &user_pass;
 407         }
 408
 409         cl_git_pass(git_clone(&g_repo, _remote_url, "./foo", &g_options));
 410         git_repository_free(g_repo); g_repo = NULL;
 411         cl_fixture_cleanup("./foo");
 412 }
 413
 414 void test_online_clone__credentials_via_custom_headers(void)
 415 {
 416         const char *creds = "libgit2-test:YT77Ppm2nq8w4TYjGS8U";
 417         git_str auth = GIT_STR_INIT;
 418
 419         cl_git_pass(git_str_puts(&auth, "Authorization: Basic "));
 420         cl_git_pass(git_str_encode_base64(&auth, creds, strlen(creds)));
 421         g_options.fetch_opts.custom_headers.count = 1;
 422         g_options.fetch_opts.custom_headers.strings = &auth.ptr;
 423
 424         cl_git_pass(git_clone(&g_repo, "https://bitbucket.org/libgit2-test/testgitrepository.git", "./foo", &g_options));
 425
 426         git_str_dispose(&auth);
 427 }
 428
 429 void test_online_clone__bitbucket_style(void)
 430 {
 431         git_credential_userpass_payload user_pass = {
 432                 "libgit2-test", "YT77Ppm2nq8w4TYjGS8U"
 433         };
 434
 435         g_options.fetch_opts.callbacks.credentials = git_credential_userpass;
 436         g_options.fetch_opts.callbacks.payload = &user_pass;
 437
 438         cl_git_pass(git_clone(&g_repo, BB_REPO_URL, "./foo", &g_options));
 439         git_repository_free(g_repo); g_repo = NULL;
 440         cl_fixture_cleanup("./foo");
 441 }
 442
 443 void test_online_clone__bitbucket_uses_creds_in_url(void)
 444 {
 445         git_credential_userpass_payload user_pass = {
 446                 "libgit2-test", "wrong"
 447         };
 448
 449         g_options.fetch_opts.callbacks.credentials = git_credential_userpass;
 450         g_options.fetch_opts.callbacks.payload = &user_pass;
 451
 452         /*
 453          * Correct user and pass are in the URL; the (incorrect) creds in
 454          * the `git_credential_userpass_payload` should be ignored.
 455          */
 456         cl_git_pass(git_clone(&g_repo, BB_REPO_URL_WITH_PASS, "./foo", &g_options));
 457         git_repository_free(g_repo); g_repo = NULL;
 458         cl_fixture_cleanup("./foo");
 459 }
 460
 461 void test_online_clone__bitbucket_falls_back_to_specified_creds(void)
 462 {
 463         git_credential_userpass_payload user_pass = {
 464                 "libgit2-test", "libgit2"
 465         };
 466
 467         g_options.fetch_opts.callbacks.credentials = git_credential_userpass;
 468         g_options.fetch_opts.callbacks.payload = &user_pass;
 469
 470         /*
 471          * TODO: as of March 2018, bitbucket sporadically fails with
 472          * 403s instead of replying with a 401 - but only sometimes.
 473          */
 474         cl_skip();
 475
 476         /*
 477          * Incorrect user and pass are in the URL; the (correct) creds in
 478          * the `git_credential_userpass_payload` should be used as a fallback.
 479          */
 480         cl_git_pass(git_clone(&g_repo, BB_REPO_URL_WITH_WRONG_PASS, "./foo", &g_options));
 481         git_repository_free(g_repo); g_repo = NULL;
 482         cl_fixture_cleanup("./foo");
 483 }
 484
 485 void test_online_clone__googlesource(void)
 486 {
 487         cl_git_pass(git_clone(&g_repo, GOOGLESOURCE_REPO_URL, "./foo", &g_options));
 488         git_repository_free(g_repo); g_repo = NULL;
 489         cl_fixture_cleanup("./foo");
 490 }
 491
 492 static int cancel_at_half(const git_indexer_progress *stats, void *payload)
 493 {
 494         GIT_UNUSED(payload);
 495
 496         if (stats->received_objects > (stats->total_objects/2))
 497                 return 4321;
 498         return 0;
 499 }
 500
 501 void test_online_clone__can_cancel(void)
 502 {
 503         g_options.fetch_opts.callbacks.transfer_progress = cancel_at_half;
 504
 505         cl_git_fail_with(4321,
 506                 git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
 507 }
 508
 509 static int cred_cb(git_credential **cred, const char *url, const char *user_from_url,
 510                    unsigned int allowed_types, void *payload)
 511 {
 512         GIT_UNUSED(url); GIT_UNUSED(user_from_url); GIT_UNUSED(payload);
 513
 514         if (allowed_types & GIT_CREDENTIAL_USERNAME)
 515                 return git_credential_username_new(cred, _remote_user);
 516
 517         if (allowed_types & GIT_CREDENTIAL_SSH_KEY)
 518                 return git_credential_ssh_key_new(cred,
 519                         _remote_user, _remote_ssh_pubkey,
 520                         _remote_ssh_privkey, _remote_ssh_passphrase);
 521
 522         git_error_set(GIT_ERROR_NET, "unexpected cred type");
 523         return -1;
 524 }
 525
 526 static int check_ssh_auth_methods(git_credential **cred, const char *url, const char *username_from_url,
 527                                   unsigned int allowed_types, void *data)
 528 {
 529         int *with_user = (int *) data;
 530         GIT_UNUSED(cred); GIT_UNUSED(url); GIT_UNUSED(username_from_url); GIT_UNUSED(data);
 531
 532         if (!*with_user)
 533                 cl_assert_equal_i(GIT_CREDENTIAL_USERNAME, allowed_types);
 534         else
 535                 cl_assert(!(allowed_types & GIT_CREDENTIAL_USERNAME));
 536
 537         return GIT_EUSER;
 538 }
 539
 540 void test_online_clone__ssh_auth_methods(void)
 541 {
 542         int with_user;
 543
 544 #ifndef GIT_SSH
 545         clar__skip();
 546 #endif
 547         g_options.fetch_opts.callbacks.credentials = check_ssh_auth_methods;
 548         g_options.fetch_opts.callbacks.payload = &with_user;
 549         g_options.fetch_opts.callbacks.certificate_check = NULL;
 550
 551         with_user = 0;
 552         cl_git_fail_with(GIT_EUSER,
 553                 git_clone(&g_repo, SSH_REPO_URL, "./foo", &g_options));
 554
 555         with_user = 1;
 556         cl_git_fail_with(GIT_EUSER,
 557                 git_clone(&g_repo, "ssh://git@github.com/libgit2/TestGitRepository", "./foo", &g_options));
 558 }
 559
 560 static int custom_remote_ssh_with_paths(
 561         git_remote **out,
 562         git_repository *repo,
 563         const char *name,
 564         const char *url,
 565         void *payload)
 566 {
 567         int error;
 568
 569         GIT_UNUSED(payload);
 570
 571         if ((error = git_remote_create(out, repo, name, url)) < 0)
 572                 return error;
 573
 574         return 0;
 575 }
 576
 577 void test_online_clone__ssh_with_paths(void)
 578 {
 579         char *bad_paths[] = {
 580                 "/bin/yes",
 581                 "/bin/false",
 582         };
 583         char *good_paths[] = {
 584                 "/usr/bin/git-upload-pack",
 585                 "/usr/bin/git-receive-pack",
 586         };
 587         git_strarray arr = {
 588                 bad_paths,
 589                 2,
 590         };
 591
 592 #ifndef GIT_SSH
 593         clar__skip();
 594 #endif
 595         if (!_remote_url || !_remote_user || strncmp(_remote_url, "ssh://", 5) != 0)
 596                 clar__skip();
 597
 598         g_options.remote_cb = custom_remote_ssh_with_paths;
 599         g_options.fetch_opts.callbacks.transport = git_transport_ssh_with_paths;
 600         g_options.fetch_opts.callbacks.credentials = cred_cb;
 601         g_options.fetch_opts.callbacks.payload = &arr;
 602         g_options.fetch_opts.callbacks.certificate_check = NULL;
 603
 604         cl_git_fail(git_clone(&g_repo, _remote_url, "./foo", &g_options));
 605
 606         arr.strings = good_paths;
 607         cl_git_pass(git_clone(&g_repo, _remote_url, "./foo", &g_options));
 608 }
 609
 610 static int cred_foo_bar(git_credential **cred, const char *url, const char *username_from_url,
 611                                   unsigned int allowed_types, void *data)
 612
 613 {
 614         GIT_UNUSED(url); GIT_UNUSED(username_from_url); GIT_UNUSED(allowed_types); GIT_UNUSED(data);
 615
 616         return git_credential_userpass_plaintext_new(cred, "foo", "bar");
 617 }
 618
 619 void test_online_clone__ssh_cannot_change_username(void)
 620 {
 621 #ifndef GIT_SSH
 622         clar__skip();
 623 #endif
 624         g_options.fetch_opts.callbacks.credentials = cred_foo_bar;
 625
 626         cl_git_fail(git_clone(&g_repo, "ssh://git@github.com/libgit2/TestGitRepository", "./foo", &g_options));
 627 }
 628
 629 static int ssh_certificate_check(git_cert *cert, int valid, const char *host, void *payload)
 630 {
 631         git_cert_hostkey *key;
 632         git_oid expected = {{0}}, actual = {{0}};
 633
 634         GIT_UNUSED(valid);
 635         GIT_UNUSED(payload);
 636
 637         cl_assert(_remote_ssh_fingerprint);
 638
 639         cl_git_pass(git_oid_fromstrp(&expected, _remote_ssh_fingerprint));
 640         cl_assert_equal_i(GIT_CERT_HOSTKEY_LIBSSH2, cert->cert_type);
 641         key = (git_cert_hostkey *) cert;
 642
 643         /*
 644          * We need to figure out how long our input was to check for
 645          * the type. Here we abuse the fact that both hashes fit into
 646          * our git_oid type.
 647          */
 648         if (strlen(_remote_ssh_fingerprint) == 32 && key->type & GIT_CERT_SSH_MD5) {
 649                 memcpy(&actual.id, key->hash_md5, 16);
 650         } else  if (strlen(_remote_ssh_fingerprint) == 40 && key->type & GIT_CERT_SSH_SHA1) {
 651                 memcpy(&actual, key->hash_sha1, 20);
 652         } else {
 653                 cl_fail("Cannot find a usable SSH hash");
 654         }
 655
 656         cl_assert(!memcmp(&expected, &actual, 20));
 657
 658         cl_assert_equal_s("localhost", host);
 659
 660         return GIT_EUSER;
 661 }
 662
 663 void test_online_clone__ssh_cert(void)
 664 {
 665         g_options.fetch_opts.callbacks.certificate_check = ssh_certificate_check;
 666
 667         if (!_remote_ssh_fingerprint)
 668                 cl_skip();
 669
 670         cl_git_fail_with(GIT_EUSER, git_clone(&g_repo, _remote_url, "./foo", &g_options));
 671 }
 672
 673 static char *read_key_file(const char *path)
 674 {
 675         FILE *f;
 676         char *buf;
 677         long key_length;
 678
 679         if (!path || !*path)
 680                 return NULL;
 681
 682         cl_assert((f = fopen(path, "r")) != NULL);
 683         cl_assert(fseek(f, 0, SEEK_END) != -1);
 684         cl_assert((key_length = ftell(f)) != -1);
 685         cl_assert(fseek(f, 0, SEEK_SET) != -1);
 686         cl_assert((buf = malloc(key_length)) != NULL);
 687         cl_assert(fread(buf, key_length, 1, f) == 1);
 688         fclose(f);
 689
 690         return buf;
 691 }
 692
 693 static int ssh_memory_cred_cb(git_credential **cred, const char *url, const char *user_from_url,
 694                    unsigned int allowed_types, void *payload)
 695 {
 696         GIT_UNUSED(url); GIT_UNUSED(user_from_url); GIT_UNUSED(payload);
 697
 698         if (allowed_types & GIT_CREDENTIAL_USERNAME)
 699                 return git_credential_username_new(cred, _remote_user);
 700
 701         if (allowed_types & GIT_CREDENTIAL_SSH_KEY)
 702         {
 703                 char *pubkey = read_key_file(_remote_ssh_pubkey);
 704                 char *privkey = read_key_file(_remote_ssh_privkey);
 705
 706                 int ret = git_credential_ssh_key_memory_new(cred, _remote_user, pubkey, privkey, _remote_ssh_passphrase);
 707
 708                 if (privkey)
 709                         free(privkey);
 710                 if (pubkey)
 711                         free(pubkey);
 712                 return ret;
 713         }
 714
 715         git_error_set(GIT_ERROR_NET, "unexpected cred type");
 716         return -1;
 717 }
 718
 719 void test_online_clone__ssh_memory_auth(void)
 720 {
 721 #ifndef GIT_SSH_MEMORY_CREDENTIALS
 722         clar__skip();
 723 #endif
 724         if (!_remote_url || !_remote_user || !_remote_ssh_privkey || strncmp(_remote_url, "ssh://", 5) != 0)
 725                 clar__skip();
 726
 727         g_options.fetch_opts.callbacks.credentials = ssh_memory_cred_cb;
 728
 729         cl_git_pass(git_clone(&g_repo, _remote_url, "./foo", &g_options));
 730 }
 731
 732 static int fail_certificate_check(git_cert *cert, int valid, const char *host, void *payload)
 733 {
 734         GIT_UNUSED(cert);
 735         GIT_UNUSED(valid);
 736         GIT_UNUSED(host);
 737         GIT_UNUSED(payload);
 738
 739         return GIT_ECERTIFICATE;
 740 }
 741
 742 void test_online_clone__certificate_invalid(void)
 743 {
 744         g_options.fetch_opts.callbacks.certificate_check = fail_certificate_check;
 745
 746         cl_git_fail_with(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options),
 747                 GIT_ECERTIFICATE);
 748
 749 #ifdef GIT_SSH
 750         cl_git_fail_with(git_clone(&g_repo, "ssh://github.com/libgit2/TestGitRepository", "./foo", &g_options),
 751                 GIT_ECERTIFICATE);
 752 #endif
 753 }
 754
 755 static int succeed_certificate_check(git_cert *cert, int valid, const char *host, void *payload)
 756 {
 757         GIT_UNUSED(cert);
 758         GIT_UNUSED(valid);
 759         GIT_UNUSED(payload);
 760
 761         cl_assert_equal_s("github.com", host);
 762
 763         return 0;
 764 }
 765
 766 void test_online_clone__certificate_valid(void)
 767 {
 768         g_options.fetch_opts.callbacks.certificate_check = succeed_certificate_check;
 769
 770         cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options));
 771 }
 772
 773 void test_online_clone__start_with_http(void)
 774 {
 775         g_options.fetch_opts.callbacks.certificate_check = succeed_certificate_check;
 776
 777         cl_git_pass(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options));
 778 }
 779
 780 static int called_proxy_creds;
 781 static int proxy_cred_cb(git_credential **out, const char *url, const char *username, unsigned int allowed, void *payload)
 782 {
 783         GIT_UNUSED(url);
 784         GIT_UNUSED(username);
 785         GIT_UNUSED(allowed);
 786         GIT_UNUSED(payload);
 787
 788         called_proxy_creds = 1;
 789         return git_credential_userpass_plaintext_new(out, _remote_proxy_user, _remote_proxy_pass);
 790 }
 791
 792 static int proxy_cert_cb(git_cert *cert, int valid, const char *host, void *payload)
 793 {
 794         char *colon;
 795         size_t host_len;
 796
 797         GIT_UNUSED(cert);
 798         GIT_UNUSED(valid);
 799         GIT_UNUSED(payload);
 800
 801         cl_assert(_remote_proxy_host);
 802
 803         if ((colon = strchr(_remote_proxy_host, ':')) != NULL)
 804                 host_len = (colon - _remote_proxy_host);
 805         else
 806                 host_len = strlen(_remote_proxy_host);
 807
 808         if (_remote_proxy_selfsigned != NULL &&
 809             strlen(host) == host_len &&
 810             strncmp(_remote_proxy_host, host, host_len) == 0)
 811                 valid = 1;
 812
 813         return valid ? 0 : GIT_ECERTIFICATE;
 814 }
 815
 816 void test_online_clone__proxy_credentials_request(void)
 817 {
 818         git_str url = GIT_STR_INIT;
 819
 820         if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass)
 821                 cl_skip();
 822
 823         cl_git_pass(git_str_printf(&url, "%s://%s/",
 824                 _remote_proxy_scheme ? _remote_proxy_scheme : "http",
 825                 _remote_proxy_host));
 826
 827         g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED;
 828         g_options.fetch_opts.proxy_opts.url = url.ptr;
 829         g_options.fetch_opts.proxy_opts.credentials = proxy_cred_cb;
 830         g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb;
 831         called_proxy_creds = 0;
 832         cl_git_pass(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options));
 833         cl_assert(called_proxy_creds);
 834
 835         git_str_dispose(&url);
 836 }
 837
 838 void test_online_clone__proxy_credentials_in_url(void)
 839 {
 840         git_str url = GIT_STR_INIT;
 841
 842         if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass)
 843                 cl_skip();
 844
 845         cl_git_pass(git_str_printf(&url, "%s://%s:%s@%s/",
 846                 _remote_proxy_scheme ? _remote_proxy_scheme : "http",
 847                 _remote_proxy_user, _remote_proxy_pass, _remote_proxy_host));
 848
 849         g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED;
 850         g_options.fetch_opts.proxy_opts.url = url.ptr;
 851         g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb;
 852         called_proxy_creds = 0;
 853         cl_git_pass(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options));
 854         cl_assert(called_proxy_creds == 0);
 855
 856         git_str_dispose(&url);
 857 }
 858
 859 void test_online_clone__proxy_credentials_in_environment(void)
 860 {
 861         git_str url = GIT_STR_INIT;
 862
 863         if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass)
 864                 cl_skip();
 865
 866         _orig_http_proxy = cl_getenv("HTTP_PROXY");
 867         _orig_https_proxy = cl_getenv("HTTPS_PROXY");
 868         _orig_no_proxy = cl_getenv("NO_PROXY");
 869         _orig_proxies_need_reset = 1;
 870
 871         g_options.fetch_opts.proxy_opts.type = GIT_PROXY_AUTO;
 872         g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb;
 873
 874         cl_git_pass(git_str_printf(&url, "%s://%s:%s@%s/",
 875                 _remote_proxy_scheme ? _remote_proxy_scheme : "http",
 876                 _remote_proxy_user, _remote_proxy_pass, _remote_proxy_host));
 877
 878         cl_setenv("HTTP_PROXY", url.ptr);
 879         cl_setenv("HTTPS_PROXY", url.ptr);
 880         cl_setenv("NO_PROXY", NULL);
 881
 882         cl_git_pass(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options));
 883
 884         git_str_dispose(&url);
 885 }
 886
 887 void test_online_clone__proxy_credentials_in_url_https(void)
 888 {
 889         git_str url = GIT_STR_INIT;
 890
 891         if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass)
 892                 cl_skip();
 893
 894         cl_git_pass(git_str_printf(&url, "%s://%s:%s@%s/",
 895                 _remote_proxy_scheme ? _remote_proxy_scheme : "http",
 896                 _remote_proxy_user, _remote_proxy_pass, _remote_proxy_host));
 897
 898         g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED;
 899         g_options.fetch_opts.proxy_opts.url = url.ptr;
 900         g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb;
 901         g_options.fetch_opts.callbacks.certificate_check = ssl_cert;
 902         called_proxy_creds = 0;
 903         cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options));
 904         cl_assert(called_proxy_creds == 0);
 905
 906         git_str_dispose(&url);
 907 }
 908
 909 void test_online_clone__proxy_auto_not_detected(void)
 910 {
 911         g_options.fetch_opts.proxy_opts.type = GIT_PROXY_AUTO;
 912
 913         cl_git_pass(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options));
 914 }
 915
 916 void test_online_clone__proxy_cred_callback_after_failed_url_creds(void)
 917 {
 918         git_str url = GIT_STR_INIT;
 919
 920         if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass)
 921                 cl_skip();
 922
 923         cl_git_pass(git_str_printf(&url, "%s://invalid_user_name:INVALID_pass_WORD@%s/",
 924                 _remote_proxy_scheme ? _remote_proxy_scheme : "http",
 925                 _remote_proxy_host));
 926
 927         g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED;
 928         g_options.fetch_opts.proxy_opts.url = url.ptr;
 929         g_options.fetch_opts.proxy_opts.credentials = proxy_cred_cb;
 930         g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb;
 931         called_proxy_creds = 0;
 932         cl_git_pass(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options));
 933         cl_assert(called_proxy_creds);
 934
 935         git_str_dispose(&url);
 936 }
 937
 938 void test_online_clone__azurerepos(void)
 939 {
 940         cl_git_pass(git_clone(&g_repo, "https://libgit2@dev.azure.com/libgit2/test/_git/test", "./foo", &g_options));
 941         cl_assert(git_fs_path_exists("./foo/master.txt"));
 942 }
 943
 944 void test_online_clone__path_whitespace(void)
 945 {
 946         cl_git_pass(git_clone(&g_repo, "https://libgit2@dev.azure.com/libgit2/test/_git/spaces%20in%20the%20name", "./foo", &g_options));
 947         cl_assert(git_fs_path_exists("./foo/master.txt"));
 948 }
 949
 950 void test_online_clone__redirect_default_succeeds_for_initial(void)
 951 {
 952         git_clone_options options = GIT_CLONE_OPTIONS_INIT;
 953
 954         if (!_remote_redirect_initial || !_remote_redirect_subsequent)
 955                 cl_skip();
 956
 957         cl_git_pass(git_clone(&g_repo, _remote_redirect_initial, "./initial", &options));
 958 }
 959
 960 void test_online_clone__redirect_default_fails_for_subsequent(void)
 961 {
 962         git_clone_options options = GIT_CLONE_OPTIONS_INIT;
 963
 964         if (!_remote_redirect_initial || !_remote_redirect_subsequent)
 965                 cl_skip();
 966
 967         cl_git_fail(git_clone(&g_repo, _remote_redirect_subsequent, "./fail", &options));
 968 }
 969
 970 void test_online_clone__redirect_none(void)
 971 {
 972         git_clone_options options = GIT_CLONE_OPTIONS_INIT;
 973
 974         if (!_remote_redirect_initial)
 975                 cl_skip();
 976
 977         options.fetch_opts.follow_redirects = GIT_REMOTE_REDIRECT_NONE;
 978
 979         cl_git_fail(git_clone(&g_repo, _remote_redirect_initial, "./fail", &options));
 980 }
 981
 982 void test_online_clone__redirect_initial_succeeds_for_initial(void)
 983 {
 984         git_clone_options options = GIT_CLONE_OPTIONS_INIT;
 985
 986         if (!_remote_redirect_initial || !_remote_redirect_subsequent)
 987                 cl_skip();
 988
 989         options.fetch_opts.follow_redirects = GIT_REMOTE_REDIRECT_INITIAL;
 990
 991         cl_git_pass(git_clone(&g_repo, _remote_redirect_initial, "./initial", &options));
 992 }
 993
 994 void test_online_clone__redirect_initial_fails_for_subsequent(void)
 995 {
 996         git_clone_options options = GIT_CLONE_OPTIONS_INIT;
 997
 998         if (!_remote_redirect_initial || !_remote_redirect_subsequent)
 999                 cl_skip();
1000
1001         options.fetch_opts.follow_redirects = GIT_REMOTE_REDIRECT_INITIAL;
1002
1003         cl_git_fail(git_clone(&g_repo, _remote_redirect_subsequent, "./fail", &options));
1004 }