int git_transport_ssh_with_paths(git_transport **out, git_remote *owner, void *payload) { #ifdef GIT_SSH git_strarray *paths = (git_strarray *) payload; git_transport *transport; transport_smart *smart; ssh_subtransport *t; int error; git_smart_subtransport_definition ssh_definition = { git_smart_subtransport_ssh, 0, /* no RPC */ NULL, }; if (paths->count != 2) { giterr_set(GITERR_SSH, "invalid ssh paths, must be two strings"); return GIT_EINVALIDSPEC; } if ((error = git_transport_smart(&transport, owner, &ssh_definition)) < 0) return error; smart = (transport_smart *) transport; t = (ssh_subtransport *) smart->wrapped; t->cmd_uploadpack = git__strdup(paths->strings[0]); GITERR_CHECK_ALLOC(t->cmd_uploadpack); t->cmd_receivepack = git__strdup(paths->strings[1]); GITERR_CHECK_ALLOC(t->cmd_receivepack); *out = transport; return 0; #else GIT_UNUSED(owner); GIT_UNUSED(payload); assert(out); *out = NULL; giterr_set(GITERR_INVALID, "Cannot create SSH transport. Library was built without SSH support"); return -1; #endif }
GIT_INLINE(int) attr_cache_lock(git_attr_cache *cache) { GIT_UNUSED(cache); /* avoid warning if threading is off */ if (git_mutex_lock(&cache->lock) < 0) { giterr_set(GITERR_OS, "Unable to get attr cache lock"); return -1; } return 0; }
static int cred_cb(git_cred **cred, const char *url, const char *user_from_url, unsigned int allowed_types, void *payload) { const char *remote_user = cl_getenv("GITTEST_REMOTE_USER"); const char *pubkey = cl_getenv("GITTEST_REMOTE_SSH_PUBKEY"); const char *privkey = cl_getenv("GITTEST_REMOTE_SSH_KEY"); const char *passphrase = cl_getenv("GITTEST_REMOTE_SSH_PASSPHRASE"); GIT_UNUSED(url); GIT_UNUSED(user_from_url); GIT_UNUSED(payload); if (allowed_types & GIT_CREDTYPE_USERNAME) return git_cred_username_new(cred, remote_user); if (allowed_types & GIT_CREDTYPE_SSH_KEY) return git_cred_ssh_key_new(cred, remote_user, pubkey, privkey, passphrase); giterr_set(GITERR_NET, "unexpected cred type"); return -1; }
static int interrupt_cb(const char *reference_name, void *payload) { int *count = (int *)payload; GIT_UNUSED(reference_name); (*count)++; return (*count == 11); }
static int _ssh_close(git_smart_subtransport *subtransport) { ssh_subtransport *t = (ssh_subtransport *) subtransport; assert(!t->current_stream); GIT_UNUSED(t); return 0; }
static int checkout_cancel_cb( git_checkout_notify_t why, const char *path, const git_diff_file *b, const git_diff_file *t, const git_diff_file *w, void *payload) { struct checkout_cancel_at *ca = payload; GIT_UNUSED(why); GIT_UNUSED(b); GIT_UNUSED(t); GIT_UNUSED(w); ca->count++; if (!strcmp(path, ca->filename)) return ca->error; return 0; }
static int tag_list_cb(const char *tag_name, git_oid *oid, void *data) { tag_filter_data *filter = (tag_filter_data *)data; GIT_UNUSED(oid); if (!*filter->pattern || p_fnmatch(filter->pattern, tag_name + GIT_REFS_TAGS_DIR_LEN, 0) == 0) return git_vector_insert(filter->taglist, git__strdup(tag_name + GIT_REFS_TAGS_DIR_LEN)); return 0; }
static int count_me(const git_config_entry *entry, void *payload) { int *n = (int *) payload; GIT_UNUSED(entry); (*n)++; return 0; }
static int rebase_init_merge( git_rebase *rebase, git_repository *repo, const git_annotated_commit *branch, const git_annotated_commit *upstream, const git_annotated_commit *onto) { git_reference *head_ref = NULL; git_commit *onto_commit = NULL; git_buf reflog = GIT_BUF_INIT; git_buf state_path = GIT_BUF_INIT; int error; GIT_UNUSED(upstream); if ((error = git_buf_joinpath(&state_path, repo->path_repository, REBASE_MERGE_DIR)) < 0) goto done; rebase->state_path = git_buf_detach(&state_path); GITERR_CHECK_ALLOC(rebase->state_path); if (branch->ref_name) { rebase->orig_head_name = git__strdup(branch->ref_name); GITERR_CHECK_ALLOC(rebase->orig_head_name); } else { rebase->head_detached = 1; } rebase->onto_name = git__strdup(rebase_onto_name(onto)); GITERR_CHECK_ALLOC(rebase->onto_name); rebase->quiet = rebase->options.quiet; git_oid_cpy(&rebase->orig_head_id, git_annotated_commit_id(branch)); git_oid_cpy(&rebase->onto_id, git_annotated_commit_id(onto)); if ((error = rebase_setupfiles(rebase)) < 0 || (error = git_buf_printf(&reflog, "rebase: checkout %s", rebase_onto_name(onto))) < 0 || (error = git_commit_lookup( &onto_commit, repo, git_annotated_commit_id(onto))) < 0 || (error = git_checkout_tree(repo, (git_object *)onto_commit, &rebase->options.checkout_options)) < 0 || (error = git_reference_create(&head_ref, repo, GIT_HEAD_FILE, git_annotated_commit_id(onto), 1, reflog.ptr)) < 0) goto done; done: git_reference_free(head_ref); git_commit_free(onto_commit); git_buf_free(&reflog); git_buf_free(&state_path); return error; }
static int default_remote_create( git_remote **out, git_repository *repo, const char *name, const char *url, void *payload) { GIT_UNUSED(payload); return git_remote_create(out, repo, name, url); }
int p_mkdir(const char *path, mode_t mode) { git_win32_path buf; GIT_UNUSED(mode); if (utf8_to_16_with_errno(buf, path) < 0) return -1; return _wmkdir(buf); }
int cb_status__single(const char *p, unsigned int s, void *payload) { status_entry_single *data = (status_entry_single *)payload; GIT_UNUSED(p); data->count++; data->status = s; return 0; }
static int checkout_conflict_count_cb( git_checkout_notify_t why, const char *path, const git_diff_file *b, const git_diff_file *t, const git_diff_file *w, void *payload) { size_t *n = payload; GIT_UNUSED(why); GIT_UNUSED(path); GIT_UNUSED(b); GIT_UNUSED(t); GIT_UNUSED(w); (*n)++; return 0; }
int p_mkdir(const char *path, mode_t mode) { git_win32_path buf; GIT_UNUSED(mode); if (git_win32_path_from_utf8(buf, path) < 0) return -1; return _wmkdir(buf); }
static int checkout_notify_cb( git_checkout_notify_t why, const char *path, const git_diff_file *baseline, const git_diff_file *target, const git_diff_file *workdir, void *payload) { struct update_submodule_cb_payload *update_payload = payload; GIT_UNUSED(why); GIT_UNUSED(path); GIT_UNUSED(baseline); GIT_UNUSED(target); GIT_UNUSED(workdir); update_payload->checkout_notify_called = 1; return 0; }
int aborting_progress_cb( git_stash_apply_progress_t progress, void *payload) { GIT_UNUSED(payload); if (progress == GIT_STASH_APPLY_PROGRESS_ANALYZE_MODIFIED) return -44; return 0; }
// callback: tries the access_token passed in through the payload ONCE // and returns GIT_EAUTH if called for a second time int cb_cred_access_token(git_cred **out, const char *url, const char *username_from_url, unsigned int allowed_types, void *payload) { GIT_UNUSED(url); GIT_UNUSED(username_from_url); if (allowed_types & GIT_CREDTYPE_USERPASS_PLAINTEXT) { struct credentials_s *credentials = payload; if (credentials->count > 0) { git_error_set_str(GIT_ERROR_CALLBACK, "Invalid token"); return GIT_EAUTH; } else { credentials->count++; return git_cred_userpass_plaintext_new(out, "x-access-token", credentials->access_token); } } return GIT_PASSTHROUGH; }
int git_tls_stream_new(git_stream **out, const char *host, const char *port) { if (tls_ctor) return tls_ctor(out, host, port); #ifdef GIT_SECURE_TRANSPORT return git_stransport_stream_new(out, host, port); #elif defined(GIT_OPENSSL) return git_openssl_stream_new(out, host, port); #elif defined(GIT_MBEDTLS) return git_mbedtls_stream_new(out, host, port); #else GIT_UNUSED(out); GIT_UNUSED(host); GIT_UNUSED(port); giterr_set(GITERR_SSL, "there is no TLS stream available"); return -1; #endif }
static int notify_cb__basic( const git_diff *diff_so_far, const git_diff_delta *delta_to_add, const char *matched_pathspec, void *payload) { basic_payload *exp = (basic_payload *)payload; basic_payload *e; GIT_UNUSED(diff_so_far); GIT_UNUSED(matched_pathspec); for (e = exp; e->path; e++) { if (strcmp(e->path, delta_to_add->new_file.path) == 0) { cl_assert_equal_i(e->t, delta_to_add->status); return 0; } } cl_assert(0); return GIT_ENOTFOUND; }
static int winhttp_uploadpack( winhttp_subtransport *t, winhttp_stream *s) { GIT_UNUSED(t); s->service = upload_pack_service; s->service_url = upload_pack_service_url; s->verb = post_verb; return 0; }
static int winhttp_receivepack_ls( winhttp_subtransport *t, winhttp_stream *s) { GIT_UNUSED(t); s->service = receive_pack_service; s->service_url = receive_pack_ls_service_url; s->verb = get_verb; return 0; }
static int cb_status__expected_path(const char *p, unsigned int s, void *payload) { const char *expected_path = (const char *)payload; GIT_UNUSED(s); if (payload == NULL) cl_fail("Unexpected path"); cl_assert_equal_s(expected_path, p); return 0; }
ssize_t openssl_write(git_stream *stream, const char *data, size_t len, int flags) { openssl_stream *st = (openssl_stream *) stream; int ret; GIT_UNUSED(flags); if ((ret = SSL_write(st->ssl, data, len)) <= 0) { return ssl_set_error(st->ssl, ret); } return ret; }
static void net_set_error(const char *str) { int size, error = WSAGetLastError(); LPSTR err_str = NULL; size = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0, error, 0, (LPSTR)&err_str, 0, 0); GIT_UNUSED(size); giterr_set(GITERR_NET, "%s: %s", str, err_str); LocalFree(err_str); }
void cl_fake_home_cleanup(void *payload) { char *restore = _cl_restore_home; _cl_restore_home = NULL; GIT_UNUSED(payload); if (restore) { cl_git_pass(git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, restore)); git__free(restore); } }
static int checkout_create_the_new( void *cb_data, const git_diff_delta *delta, float progress) { int error = 0; struct checkout_diff_data *data = cb_data; git_checkout_opts *opts = data->checkout_opts; bool do_checkout = false, do_notify = false; GIT_UNUSED(progress); data->stats->processed++; if (delta->status == GIT_DELTA_MODIFIED || delta->status == GIT_DELTA_TYPECHANGE) { if ((opts->checkout_strategy & GIT_CHECKOUT_OVERWRITE_MODIFIED) != 0) do_checkout = true; else if (opts->skipped_notify_cb != NULL) do_notify = !data->create_submodules; } else if (delta->status == GIT_DELTA_DELETED && (opts->checkout_strategy & GIT_CHECKOUT_CREATE_MISSING) != 0) do_checkout = true; if (do_notify) { if (opts->skipped_notify_cb( delta->old_file.path, &delta->old_file.oid, delta->old_file.mode, opts->notify_payload)) { giterr_clear(); error = GIT_EUSER; } } if (do_checkout) { bool is_submodule = S_ISGITLINK(delta->old_file.mode); if (is_submodule) data->found_submodules = true; if (!is_submodule && !data->create_submodules) error = checkout_blob(data, &delta->old_file); else if (is_submodule && data->create_submodules) error = checkout_submodule(data, &delta->old_file); } if (error) data->error = error; return error; }
static int remote_mirror_cb(git_remote **out, git_repository *repo, const char *name, const char *url, void *payload) { int error; git_remote *remote; GIT_UNUSED(payload); if ((error = git_remote_create_with_fetchspec(&remote, repo, name, url, "+refs/*:refs/*")) < 0) return error; *out = remote; return 0; }
static int failing_chunked_source_cb( char *content, size_t max_length, void *payload) { int *count = (int *)payload; GIT_UNUSED(max_length); (*count)--; if (*count == 0) return -1234; strcpy(content, textual_content); return (int)strlen(textual_content); }
static ssize_t stransport_write(git_stream *stream, const char *data, size_t len, int flags) { stransport_stream *st = (stransport_stream *) stream; size_t data_len, processed; OSStatus ret; GIT_UNUSED(flags); data_len = len; if ((ret = SSLWrite(st->ctx, data, data_len, &processed)) != noErr) return stransport_error(ret); return processed; }
static bool can_link(const char *src, const char *dst, int link) { #ifdef GIT_WIN32 GIT_UNUSED(src); GIT_UNUSED(dst); GIT_UNUSED(link); return false; #else struct stat st_src, st_dst; if (!link) return false; if (p_stat(src, &st_src) < 0) return false; if (p_stat(dst, &st_dst) < 0) return false; return st_src.st_dev == st_dst.st_dev; #endif }