自学教程：C++ transport_disconnect函数代码示例

static const struct ref *clone_local(const char *src_repo,				     const char *dest_repo){	const struct ref *ret;	struct strbuf src = STRBUF_INIT;	struct strbuf dest = STRBUF_INIT;	struct remote *remote;	struct transport *transport;	if (option_shared)		add_to_alternates_file(src_repo);	else {		strbuf_addf(&src, "%s/objects", src_repo);		strbuf_addf(&dest, "%s/objects", dest_repo);		copy_or_link_directory(&src, &dest);		strbuf_release(&src);		strbuf_release(&dest);	}	remote = remote_get(src_repo);	transport = transport_get(remote, src_repo);	ret = transport_get_remote_refs(transport);	transport_disconnect(transport);	return ret;}

static int add_refs_from_alternate(struct alternate_object_database *e, void *unused){	char *other;	size_t len;	struct remote *remote;	struct transport *transport;	const struct ref *extra;	e->name[-1] = '/0';	other = xstrdup(make_absolute_path(e->base));	e->name[-1] = '/';	len = strlen(other);	while (other[len-1] == '/')		other[--len] = '/0';	if (len < 8 || memcmp(other + len - 8, "/objects", 8))		return 0;	/* Is this a git repository with refs? */	memcpy(other + len - 8, "/refs", 6);	if (!is_directory(other))		return 0;	other[len - 8] = '/0';	remote = remote_get(other);	transport = transport_get(remote, other);	for (extra = transport_get_remote_refs(transport);	     extra;	     extra = extra->next) {		add_extra_ref(".have", extra->old_sha1, 0);	}	transport_disconnect(transport);	free(other);	return 0;}

void freerdp_disconnect(freerdp* instance){	rdpRdp* rdp;	rdp = (rdpRdp*) instance->rdp;	transport_disconnect(rdp->transport);}

BOOL rdp_client_reconnect(rdpRdp* rdp){	UINT32 i;	transport_disconnect(rdp->transport);	mcs_free(rdp->mcs);	nego_free(rdp->nego);	license_free(rdp->license);	transport_free(rdp->transport);	/* Reset virtual channel status */	for (i = 0; i < rdp->mcs->channelCount; i++)	{		rdp->mcs->channels[i].joined = FALSE;	}	rdp->transport = transport_new(rdp->settings);	rdp->license = license_new(rdp);	rdp->nego = nego_new(rdp->transport);	rdp->mcs = mcs_new(rdp->transport);	rdp->transport->layer = TRANSPORT_LAYER_TCP;	return rdp_client_connect(rdp);}

static int refs_from_alternate_cb(struct alternate_object_database *e,				  void *data){	char *other;	size_t len;	struct remote *remote;	struct transport *transport;	const struct ref *extra;	struct alternate_refs_data *cb = data;	e->name[-1] = '/0';	other = xstrdup(real_path(e->base));	e->name[-1] = '/';	len = strlen(other);	while (other[len-1] == '/')		other[--len] = '/0';	if (len < 8 || memcmp(other + len - 8, "/objects", 8))		return 0;	/* Is this a git repository with refs? */	memcpy(other + len - 8, "/refs", 6);	if (!is_directory(other))		return 0;	other[len - 8] = '/0';	remote = remote_get(other);	transport = transport_get(remote, other);	for (extra = transport_get_remote_refs(transport);	     extra;	     extra = extra->next)		cb->fn(extra, cb->data);	transport_disconnect(transport);	free(other);	return 0;}

static const struct ref *clone_local(const char *src_repo,				     const char *dest_repo){	const struct ref *ret;	struct remote *remote;	struct transport *transport;	if (option_shared) {		struct strbuf alt = STRBUF_INIT;		strbuf_addf(&alt, "%s/objects", src_repo);		add_to_alternates_file(alt.buf);		strbuf_release(&alt);	} else {		struct strbuf src = STRBUF_INIT;		struct strbuf dest = STRBUF_INIT;		strbuf_addf(&src, "%s/objects", src_repo);		strbuf_addf(&dest, "%s/objects", dest_repo);		copy_or_link_directory(&src, &dest, src_repo, src.len);		strbuf_release(&src);		strbuf_release(&dest);	}	remote = remote_get(src_repo);	transport = transport_get(remote, src_repo);	ret = transport_get_remote_refs(transport);	transport_disconnect(transport);	if (0 <= option_verbosity)		printf(_("done./n"));	return ret;}

static int add_one_reference(struct string_list_item *item, void *cb_data){	char *ref_git;	struct strbuf alternate = STRBUF_INIT;	struct remote *remote;	struct transport *transport;	const struct ref *extra;	/* Beware: real_path() and mkpath() return static buffer */	ref_git = xstrdup(real_path(item->string));	if (is_directory(mkpath("%s/.git/objects", ref_git))) {		char *ref_git_git = xstrdup(mkpath("%s/.git", ref_git));		free(ref_git);		ref_git = ref_git_git;	} else if (!is_directory(mkpath("%s/objects", ref_git)))		die(_("reference repository '%s' is not a local directory."),		    item->string);	strbuf_addf(&alternate, "%s/objects", ref_git);	add_to_alternates_file(alternate.buf);	strbuf_release(&alternate);	remote = remote_get(ref_git);	transport = transport_get(remote, ref_git);	for (extra = transport_get_remote_refs(transport); extra;	     extra = extra->next)		add_extra_ref(extra->name, extra->old_sha1, 0);	transport_disconnect(transport);	free(ref_git);	return 0;}

static void setup_reference(const char *repo){	const char *ref_git;	char *ref_git_copy;	struct remote *remote;	struct transport *transport;	const struct ref *extra;	ref_git = make_absolute_path(option_reference);	if (is_directory(mkpath("%s/.git/objects", ref_git)))		ref_git = mkpath("%s/.git", ref_git);	else if (!is_directory(mkpath("%s/objects", ref_git)))		die("reference repository '%s' is not a local directory.",		    option_reference);	ref_git_copy = xstrdup(ref_git);	add_to_alternates_file(ref_git_copy);	remote = remote_get(ref_git_copy);	transport = transport_get(remote, ref_git_copy);	for (extra = transport_get_remote_refs(transport); extra;	     extra = extra->next)		add_extra_ref(extra->name, extra->old_sha1, 0);	transport_disconnect(transport);	free(ref_git_copy);}

static int push_with_options(struct transport *transport, int flags){	int err;	int nonfastforward;	transport_set_verbosity(transport, verbosity, progress);	if (receivepack)		transport_set_option(transport,				     TRANS_OPT_RECEIVEPACK, receivepack);	if (thin)		transport_set_option(transport, TRANS_OPT_THIN, "yes");	if (verbosity > 0)		fprintf(stderr, _("Pushing to %s/n"), transport->url);	err = transport_push(transport, refspec_nr, refspec, flags,			     &nonfastforward);	if (err != 0)		error(_("failed to push some refs to '%s'"), transport->url);	err |= transport_disconnect(transport);	if (!err)		return 0;	if (nonfastforward && advice_push_nonfastforward) {		fprintf(stderr, _("To prevent you from losing history, non-fast-forward updates were rejected/n"				"Merge the remote changes (e.g. 'git pull') before pushing again.  See the/n"				"'Note about fast-forwards' section of 'git push --help' for details./n"));	}	return 1;}

int nego_tcp_disconnect(rdpNego* nego){    if (nego->tcp_connected)        transport_disconnect(nego->transport);    nego->tcp_connected = 0;    return 1;}

boolean freerdp_disconnect(freerdp* instance){	rdpRdp* rdp;	rdp = instance->context->rdp;	transport_disconnect(rdp->transport);	return true;}

BOOL freerdp_disconnect(freerdp* instance){	rdpRdp* rdp;	rdp = instance->context->rdp;	transport_disconnect(rdp->transport);	return TRUE;}

BOOL nego_transport_disconnect(rdpNego* nego){	if (nego->TcpConnected)		transport_disconnect(nego->transport);	nego->TcpConnected = FALSE;	nego->SecurityConnected = FALSE;	return TRUE;}

int nego_transport_disconnect(rdpNego* nego){	if (nego->tcp_connected)		transport_disconnect(nego->transport);	nego->tcp_connected = FALSE;	nego->security_connected = FALSE;	return 1;}

static int run_remote_archiver(int argc, const char **argv,			       const char *remote, const char *exec,			       const char *name_hint){	char buf[LARGE_PACKET_MAX];	int fd[2], i, len, rv;	struct transport *transport;	struct remote *_remote;	_remote = remote_get(remote);	if (!_remote->url[0])		die(_("git archive: Remote with no URL"));	transport = transport_get(_remote, _remote->url[0]);	transport_connect(transport, "git-upload-archive", exec, fd);	/*	 * Inject a fake --format field at the beginning of the	 * arguments, with the format inferred from our output	 * filename. This way explicit --format options can override	 * it.	 */	if (name_hint) {		const char *format = archive_format_from_filename(name_hint);		if (format)			packet_write(fd[1], "argument --format=%s/n", format);	}	for (i = 1; i < argc; i++)		packet_write(fd[1], "argument %s/n", argv[i]);	packet_flush(fd[1]);	len = packet_read_line(fd[0], buf, sizeof(buf));	if (!len)		die(_("git archive: expected ACK/NAK, got EOF"));	if (buf[len-1] == '/n')		buf[--len] = 0;	if (strcmp(buf, "ACK")) {		if (len > 5 && !prefixcmp(buf, "NACK "))			die(_("git archive: NACK %s"), buf + 5);		die(_("git archive: protocol error"));	}	len = packet_read_line(fd[0], buf, sizeof(buf));	if (len)		die(_("git archive: expected a flush"));	/* Now, start reading from fd[0] and spit it out to stdout */	rv = recv_sideband("archive", fd[0], 1);	rv |= transport_disconnect(transport);	return !!rv;}

static int push_with_options(struct transport *transport, struct refspec *rs,			     int flags){	int err;	unsigned int reject_reasons;	transport_set_verbosity(transport, verbosity, progress);	transport->family = family;	if (receivepack)		transport_set_option(transport,				     TRANS_OPT_RECEIVEPACK, receivepack);	transport_set_option(transport, TRANS_OPT_THIN, thin ? "yes" : NULL);	if (!is_empty_cas(&cas)) {		if (!transport->smart_options)			die("underlying transport does not support --%s option",			    CAS_OPT_NAME);		transport->smart_options->cas = &cas;	}	if (verbosity > 0)		fprintf(stderr, _("Pushing to %s/n"), transport->url);	err = transport_push(the_repository, transport,			     rs, flags, &reject_reasons);	if (err != 0) {		fprintf(stderr, "%s", push_get_color(PUSH_COLOR_ERROR));		error(_("failed to push some refs to '%s'"), transport->url);		fprintf(stderr, "%s", push_get_color(PUSH_COLOR_RESET));	}	err |= transport_disconnect(transport);	if (!err)		return 0;	if (reject_reasons & REJECT_NON_FF_HEAD) {		advise_pull_before_push();	} else if (reject_reasons & REJECT_NON_FF_OTHER) {		advise_checkout_pull_push();	} else if (reject_reasons & REJECT_ALREADY_EXISTS) {		advise_ref_already_exists();	} else if (reject_reasons & REJECT_FETCH_FIRST) {		advise_ref_fetch_first();	} else if (reject_reasons & REJECT_NEEDS_FORCE) {		advise_ref_needs_force();	}	return 1;}

static int fetch_one(struct remote *remote, int argc, const char **argv){	int i;	static const char **refs = NULL;	int ref_nr = 0;	int exit_code;	if (!remote)		die("Where do you want to fetch from today?");	transport = transport_get(remote, NULL);	transport_set_verbosity(transport, verbosity, progress);	if (upload_pack)		set_option(TRANS_OPT_UPLOADPACK, upload_pack);	if (keep)		set_option(TRANS_OPT_KEEP, "yes");	if (depth)		set_option(TRANS_OPT_DEPTH, depth);	if (argc > 0) {		int j = 0;		refs = xcalloc(argc + 1, sizeof(const char *));		for (i = 0; i < argc; i++) {			if (!strcmp(argv[i], "tag")) {				char *ref;				i++;				if (i >= argc)					die("You need to specify a tag name.");				ref = xmalloc(strlen(argv[i]) * 2 + 22);				strcpy(ref, "refs/tags/");				strcat(ref, argv[i]);				strcat(ref, ":refs/tags/");				strcat(ref, argv[i]);				refs[j++] = ref;			} else				refs[j++] = argv[i];		}		refs[j] = NULL;		ref_nr = j;	}	sigchain_push_common(unlock_pack_on_signal);	atexit(unlock_pack);	exit_code = do_fetch(transport,			parse_fetch_refspec(ref_nr, refs), ref_nr);	transport_disconnect(transport);	transport = NULL;	return exit_code;}

static int do_push(const char *repo, int flags){	int i, errs;	struct remote *remote = remote_get(repo);	if (!remote)		die("bad repository '%s'", repo);	if (remote->mirror)		flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);	if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) && refspec)		return -1;	if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==				(TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {		return error("--all and --mirror are incompatible");	}	if (!refspec		&& !(flags & TRANSPORT_PUSH_ALL)		&& remote->push_refspec_nr) {		refspec = remote->push_refspec;		refspec_nr = remote->push_refspec_nr;	}	errs = 0;	for (i = 0; i < remote->url_nr; i++) {		struct transport *transport =			transport_get(remote, remote->url[i]);		int err;		if (receivepack)			transport_set_option(transport,					     TRANS_OPT_RECEIVEPACK, receivepack);		if (thin)			transport_set_option(transport, TRANS_OPT_THIN, "yes");		if (verbose)			fprintf(stderr, "Pushing to %s/n", remote->url[i]);		err = transport_push(transport, refspec_nr, refspec, flags);		err |= transport_disconnect(transport);		if (!err)			continue;		error("failed to push some refs to '%s'", remote->url[i]);		errs++;	}	return !!errs;}

void cape_exit(void){	struct assembly *assembly;	qb_map_iter_t *iter;	qb_enter();	iter = qb_map_iter_create(assembly_map);	while ((qb_map_iter_next(iter, (void **)&assembly)) != NULL) {		transport_disconnect(assembly);	}	qb_map_iter_free(iter);	qb_leave();}

static voidnode_recover_restart(void * inst){	struct assembly *a = (struct assembly *)inst;	qb_enter();	transport_disconnect(a);	node_op_history_clear(a);	instance_create(a);	qb_leave();}

void transport_free(rdpTransport* transport){	if (!transport)		return;	transport_disconnect(transport);	if (transport->ReceiveBuffer)		Stream_Release(transport->ReceiveBuffer);	StreamPool_Free(transport->ReceivePool);	CloseHandle(transport->connectedEvent);	DeleteCriticalSection(&(transport->ReadLock));	DeleteCriticalSection(&(transport->WriteLock));	free(transport);}

static voidlshd_line_handler(struct transport_connection *connection,		  uint32_t length, const uint8_t *line){  verbose("Client version string: %ps/n", length, line);  /* Line must start with "SSH-2.0-" (we may need to allow "SSH-1.99"     as well). */  if (length < 8 || 0 != memcmp(line, "SSH-2.0-", 4))    {      transport_disconnect(connection, 0, "Bad version string.");      return;    }  connection->kex.version[0] = ssh_format("%ls", length, line);  connection->line_handler = NULL;}

BOOL freerdp_disconnect(freerdp* instance){	rdpRdp* rdp;	rdp = instance->context->rdp;	transport_disconnect(rdp->transport);	IFCALL(instance->PostDisconnect, instance);	if (instance->update->pcap_rfx)	{		instance->update->dump_rfx = FALSE;		pcap_close(instance->update->pcap_rfx);		instance->update->pcap_rfx = NULL;	}	return TRUE;}

static int push_with_options(struct transport *transport, int flags){	int err;	unsigned int reject_reasons;	transport_set_verbosity(transport, verbosity, progress);	if (receivepack)		transport_set_option(transport,				     TRANS_OPT_RECEIVEPACK, receivepack);	if (thin)		transport_set_option(transport, TRANS_OPT_THIN, "yes");	if (verbosity > 0)		fprintf(stderr, _("Pushing to %s/n"), transport->url);	err = transport_push(transport, refspec_nr, refspec, flags,			     &reject_reasons);	if (err != 0)		error(_("failed to push some refs to '%s'"), transport->url);	err |= transport_disconnect(transport);	if (!err)		return 0;	if (reject_reasons & REJECT_NON_FF_HEAD) {		advise_pull_before_push();	} else if (reject_reasons & REJECT_NON_FF_OTHER) {		if (default_matching_used)			advise_use_upstream();		else			advise_checkout_pull_push();	} else if (reject_reasons & REJECT_ALREADY_EXISTS) {		advise_ref_already_exists();	} else if (reject_reasons & REJECT_FETCH_FIRST) {		advise_ref_fetch_first();	} else if (reject_reasons & REJECT_NEEDS_FORCE) {		advise_ref_needs_force();	}	return 1;}

static int push_with_options(struct transport *transport, int flags){	int err;	int nonfastforward;	transport_set_verbosity(transport, verbosity, progress);	if (receivepack)		transport_set_option(transport,				     TRANS_OPT_RECEIVEPACK, receivepack);	if (thin)		transport_set_option(transport, TRANS_OPT_THIN, "yes");	if (verbosity > 0)		fprintf(stderr, _("Pushing to %s/n"), transport->url);	err = transport_push(transport, refspec_nr, refspec, flags,			     &nonfastforward);	if (err != 0)		error(_("failed to push some refs to '%s'"), transport->url);	err |= transport_disconnect(transport);	if (!err)		return 0;	switch (nonfastforward) {	default:		break;	case NON_FF_HEAD:		advise_pull_before_push();		break;	case NON_FF_OTHER:		if (default_matching_used)			advise_use_upstream();		else			advise_checkout_pull_push();		break;	}	return 1;}

static int run_remote_archiver(int argc, const char **argv,			       const char *remote, const char *exec){	char buf[LARGE_PACKET_MAX];	int fd[2], i, len, rv;	struct transport *transport;	struct remote *_remote;	_remote = remote_get(remote);	if (!_remote->url[0])		die(_("git archive: Remote with no URL"));	transport = transport_get(_remote, _remote->url[0]);	transport_connect(transport, "git-upload-archive", exec, fd);	for (i = 1; i < argc; i++)		packet_write(fd[1], "argument %s/n", argv[i]);	packet_flush(fd[1]);	len = packet_read_line(fd[0], buf, sizeof(buf));	if (!len)		die(_("git archive: expected ACK/NAK, got EOF"));	if (buf[len-1] == '/n')		buf[--len] = 0;	if (strcmp(buf, "ACK")) {		if (len > 5 && !prefixcmp(buf, "NACK "))			die(_("git archive: NACK %s"), buf + 5);		die(_("git archive: protocol error"));	}	len = packet_read_line(fd[0], buf, sizeof(buf));	if (len)		die(_("git archive: expected a flush"));	/* Now, start reading from fd[0] and spit it out to stdout */	rv = recv_sideband("archive", fd[0], 1);	rv |= transport_disconnect(transport);	return !!rv;}

static const struct ref *clone_local(const char *src_repo,				     const char *dest_repo){	const struct ref *ret;	char src[PATH_MAX];	char dest[PATH_MAX];	struct remote *remote;	struct transport *transport;	if (option_shared)		add_to_alternates_file(src_repo);	else {		snprintf(src, PATH_MAX, "%s/objects", src_repo);		snprintf(dest, PATH_MAX, "%s/objects", dest_repo);		copy_or_link_directory(src, dest);	}	remote = remote_get(src_repo);	transport = transport_get(remote, src_repo);	ret = transport_get_remote_refs(transport);	transport_disconnect(transport);	return ret;}

int cmd_ls_remote(int argc, const char **argv, const char *prefix){	int i;	const char *dest = NULL;	int nongit;	unsigned flags = 0;	const char *uploadpack = NULL;	const char **pattern = NULL;	struct remote *remote;	struct transport *transport;	const struct ref *ref;	setup_git_directory_gently(&nongit);	for (i = 1; i < argc; i++) {		const char *arg = argv[i];		if (*arg == '-') {			if (!prefixcmp(arg, "--upload-pack=")) {				uploadpack = arg + 14;				continue;			}			if (!prefixcmp(arg, "--exec=")) {				uploadpack = arg + 7;				continue;			}			if (!strcmp("--tags", arg) || !strcmp("-t", arg)) {				flags |= REF_TAGS;				continue;			}			if (!strcmp("--heads", arg) || !strcmp("-h", arg)) {				flags |= REF_HEADS;				continue;			}			if (!strcmp("--refs", arg)) {				flags |= REF_NORMAL;				continue;			}			usage(ls_remote_usage);		}		dest = arg;		i++;		break;	}	if (!dest)		usage(ls_remote_usage);	if (argv[i]) {		int j;		pattern = xcalloc(sizeof(const char *), argc - i + 1);		for (j = i; j < argc; j++) {			int len = strlen(argv[j]);			char *p = xmalloc(len + 3);			sprintf(p, "*/%s", argv[j]);			pattern[j - i] = p;		}	}	remote = nongit ? NULL : remote_get(dest);	if (remote && !remote->url_nr)		die("remote %s has no configured URL", dest);	transport = transport_get(remote, remote ? remote->url[0] : dest);	if (uploadpack != NULL)		transport_set_option(transport, TRANS_OPT_UPLOADPACK, uploadpack);	ref = transport_get_remote_refs(transport);	if (transport_disconnect(transport))		return 1;	for ( ; ref; ref = ref->next) {		if (!check_ref_type(ref, flags))			continue;		if (!tail_match(pattern, ref->name))			continue;		printf("%s	%s/n", sha1_to_hex(ref->old_sha1), ref->name);	}	return 0;}

//.........这里部分代码省略.........	if (option_depth)		transport_set_option(transport, TRANS_OPT_DEPTH,				     option_depth);	if (option_single_branch)		transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");	transport_set_verbosity(transport, option_verbosity, option_progress);	if (option_upload_pack)		transport_set_option(transport, TRANS_OPT_UPLOADPACK,				     option_upload_pack);	if (transport->smart_options && !option_depth)		transport->smart_options->check_self_contained_and_connected = 1;	refs = transport_get_remote_refs(transport);	if (refs) {		mapped_refs = wanted_peer_refs(refs, refspec);		/*		 * transport_get_remote_refs() may return refs with null sha-1		 * in mapped_refs (see struct transport->get_refs_list		 * comment). In that case we need fetch it early because		 * remote_head code below relies on it.		 *		 * for normal clones, transport_get_remote_refs() should		 * return reliable ref set, we can delay cloning until after		 * remote HEAD check.		 */		for (ref = refs; ref; ref = ref->next)			if (is_null_sha1(ref->old_sha1)) {				complete_refs_before_fetch = 0;				break;			}		if (!is_local && !complete_refs_before_fetch)			transport_fetch_refs(transport, mapped_refs);		remote_head = find_ref_by_name(refs, "HEAD");		remote_head_points_at =			guess_remote_head(remote_head, mapped_refs, 0);		if (option_branch) {			our_head_points_at =				find_remote_branch(mapped_refs, option_branch);			if (!our_head_points_at)				die(_("Remote branch %s not found in upstream %s"),				    option_branch, option_origin);		}		else			our_head_points_at = remote_head_points_at;	}	else {		if (option_branch)			die(_("Remote branch %s not found in upstream %s"),					option_branch, option_origin);		warning(_("You appear to have cloned an empty repository."));		mapped_refs = NULL;		our_head_points_at = NULL;		remote_head_points_at = NULL;		remote_head = NULL;		option_no_checkout = 1;		if (!option_bare)			install_branch_config(0, "master", option_origin,					      "refs/heads/master");	}	write_refspec_config(src_ref_prefix, our_head_points_at,			remote_head_points_at, &branch_top);	if (is_local)		clone_local(path, git_dir);	else if (refs && complete_refs_before_fetch)		transport_fetch_refs(transport, mapped_refs);	update_remote_refs(refs, mapped_refs, remote_head_points_at,			   branch_top.buf, reflog_msg.buf, transport, !is_local);	update_head(our_head_points_at, remote_head, reflog_msg.buf);	transport_unlock_pack(transport);	transport_disconnect(transport);	if (option_dissociate)		dissociate_from_references();	junk_mode = JUNK_LEAVE_REPO;	err = checkout();	strbuf_release(&reflog_msg);	strbuf_release(&branch_top);	strbuf_release(&key);	strbuf_release(&value);	junk_mode = JUNK_LEAVE_ALL;	free(refspec);	return err;}

static void freerdp_peer_disconnect(freerdp_peer* client){	rdpTransport* transport = client->context->rdp->transport;	transport_disconnect(transport);}