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

intmm_answer_gss_accept_ctx(int sock, struct sshbuf *m){	gss_buffer_desc in;	gss_buffer_desc out = GSS_C_EMPTY_BUFFER;	OM_uint32 major, minor;	OM_uint32 flags = 0; /* GSI needs this */	size_t len;	u_char *p;	int r;	if ((r = sshbuf_get_string(m, &p, &len)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	in.value = p;	in.length = len;	major = ssh_gssapi_accept_ctx(gsscontext, &in, &out, &flags);	free(in.value);	sshbuf_reset(m);	if ((r = sshbuf_put_u32(m, major)) != 0 ||	    (r = sshbuf_put_string(m, out.value, out.length)) != 0 ||	    (r = sshbuf_put_u32(m, flags)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	mm_request_send(sock, MONITOR_ANS_GSSSTEP, m);	gss_release_buffer(&minor, &out);	if (major == GSS_S_COMPLETE) {		monitor_permit(mon_dispatch, MONITOR_REQ_GSSSTEP, 0);		monitor_permit(mon_dispatch, MONITOR_REQ_GSSUSEROK, 1);		monitor_permit(mon_dispatch, MONITOR_REQ_GSSCHECKMIC, 1);	}	return 0;}

static voidsend_status(u_int32_t id, u_int32_t status){	struct sshbuf *msg;	int r;	debug3("request %u: sent status %u", id, status);	if (log_level > SYSLOG_LEVEL_VERBOSE ||	    (status != SSH2_FX_OK && status != SSH2_FX_EOF))		logit("sent status %s", status_to_message(status));	if ((msg = sshbuf_new()) == NULL)		fatal("%s: sshbuf_new failed", __func__);	if ((r = sshbuf_put_u8(msg, SSH2_FXP_STATUS)) != 0 ||	    (r = sshbuf_put_u32(msg, id)) != 0 ||	    (r = sshbuf_put_u32(msg, status)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	if (version >= 3) {		if ((r = sshbuf_put_cstring(msg,		    status_to_message(status))) != 0 ||		    (r = sshbuf_put_cstring(msg, "")) != 0)			fatal("%s: buffer error: %s", __func__, ssh_err(r));	}	send_msg(msg);	sshbuf_free(msg);}

intkexgex_hash(    int hash_alg,    const char *client_version_string,    const char *server_version_string,    const u_char *ckexinit, size_t ckexinitlen,    const u_char *skexinit, size_t skexinitlen,    const u_char *serverhostkeyblob, size_t sbloblen,    int min, int wantbits, int max,    const BIGNUM *prime,    const BIGNUM *gen,    const BIGNUM *client_dh_pub,    const BIGNUM *server_dh_pub,    const BIGNUM *shared_secret,    u_char **hash, size_t *hashlen){	struct sshbuf *b;	static u_char digest[SSH_DIGEST_MAX_LENGTH];	int r;	if ((b = sshbuf_new()) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((r = sshbuf_put_cstring(b, client_version_string)) != 0 ||	    (r = sshbuf_put_cstring(b, server_version_string)) != 0 ||	    /* kexinit messages: fake header: len+SSH2_MSG_KEXINIT */	    (r = sshbuf_put_u32(b, ckexinitlen+1)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||	    (r = sshbuf_put(b, ckexinit, ckexinitlen)) != 0 ||	    (r = sshbuf_put_u32(b, skexinitlen+1)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||	    (r = sshbuf_put(b, skexinit, skexinitlen)) != 0 ||	    (r = sshbuf_put_string(b, serverhostkeyblob, sbloblen)) != 0 ||	    (min != -1 && (r = sshbuf_put_u32(b, min)) != 0) ||	    (r = sshbuf_put_u32(b, wantbits)) != 0 ||	    (max != -1 && (r = sshbuf_put_u32(b, max)) != 0) ||	    (r = sshbuf_put_bignum2(b, prime)) != 0 ||	    (r = sshbuf_put_bignum2(b, gen)) != 0 ||	    (r = sshbuf_put_bignum2(b, client_dh_pub)) != 0 ||	    (r = sshbuf_put_bignum2(b, server_dh_pub)) != 0 ||	    (r = sshbuf_put_bignum2(b, shared_secret)) != 0) {		sshbuf_free(b);		return r;	}#ifdef DEBUG_KEXDH	sshbuf_dump(b, stderr);#endif	if (ssh_digest_buffer(hash_alg, b, digest, sizeof(digest)) != 0) {		sshbuf_free(b);		return SSH_ERR_LIBCRYPTO_ERROR;	}	sshbuf_free(b);	*hash = digest;	*hashlen = ssh_digest_bytes(hash_alg);#ifdef DEBUG_KEXDH	dump_digest("hash", digest, *hashlen);#endif	return 0;}

/* * Encodes terminal modes for the terminal referenced by fd * or tiop in a portable manner, and appends the modes to a packet * being constructed. */voidssh_tty_make_modes(struct ssh *ssh, int fd, struct termios *tiop){	struct termios tio;	struct sshbuf *buf;	int r, ibaud, obaud;	if ((buf = sshbuf_new()) == NULL)		fatal("%s: sshbuf_new failed", __func__);	if (tiop == NULL) {		if (fd == -1) {			debug("%s: no fd or tio", __func__);			goto end;		}		if (tcgetattr(fd, &tio) == -1) {			logit("tcgetattr: %.100s", strerror(errno));			goto end;		}	} else		tio = *tiop;	/* Store input and output baud rates. */	obaud = speed_to_baud(cfgetospeed(&tio));	ibaud = speed_to_baud(cfgetispeed(&tio));	if ((r = sshbuf_put_u8(buf, TTY_OP_OSPEED)) != 0 ||	    (r = sshbuf_put_u32(buf, obaud)) != 0 ||	    (r = sshbuf_put_u8(buf, TTY_OP_ISPEED)) != 0 ||	    (r = sshbuf_put_u32(buf, ibaud)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	/* Store values of mode flags. */#define TTYCHAR(NAME, OP) /	if ((r = sshbuf_put_u8(buf, OP)) != 0 || /	    (r = sshbuf_put_u32(buf, tio.c_cc[NAME])) != 0) /		fatal("%s: buffer error: %s", __func__, ssh_err(r)); /#define SSH_TTYMODE_IUTF8 42  /* for SSH_BUG_UTF8TTYMODE */#define TTYMODE(NAME, FIELD, OP) /	if (OP == SSH_TTYMODE_IUTF8 && (datafellows & SSH_BUG_UTF8TTYMODE)) { /		debug3("%s: SSH_BUG_UTF8TTYMODE", __func__); /	} else if ((r = sshbuf_put_u8(buf, OP)) != 0 || /	    (r = sshbuf_put_u32(buf, ((tio.FIELD & NAME) != 0))) != 0) /		fatal("%s: buffer error: %s", __func__, ssh_err(r)); /#include "ttymodes.h"#undef TTYCHAR#undef TTYMODEend:	/* Mark end of mode data. */	if ((r = sshbuf_put_u8(buf, TTY_OP_END)) != 0 ||	    (r = sshpkt_put_stringb(ssh, buf)) != 0)		fatal("%s: packet error: %s", __func__, ssh_err(r));	sshbuf_free(buf);}

intkex_ecdh_hash(    const EVP_MD *evp_md,    const EC_GROUP *ec_group,    const char *client_version_string,    const char *server_version_string,    const u_char *ckexinit, size_t ckexinitlen,    const u_char *skexinit, size_t skexinitlen,    const u_char *serverhostkeyblob, size_t sbloblen,    const EC_POINT *client_dh_pub,    const EC_POINT *server_dh_pub,    const BIGNUM *shared_secret,    u_char **hash, size_t *hashlen){	struct sshbuf *b;	EVP_MD_CTX md;	static u_char digest[EVP_MAX_MD_SIZE];	int r;	if ((b = sshbuf_new()) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((r = sshbuf_put_cstring(b, client_version_string)) != 0 ||	    (r = sshbuf_put_cstring(b, server_version_string)) != 0 ||	    /* kexinit messages: fake header: len+SSH2_MSG_KEXINIT */	    (r = sshbuf_put_u32(b, ckexinitlen+1)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||	    (r = sshbuf_put(b, ckexinit, ckexinitlen)) != 0 ||	    (r = sshbuf_put_u32(b, skexinitlen+1)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||	    (r = sshbuf_put(b, skexinit, skexinitlen)) != 0 ||	    (r = sshbuf_put_string(b, serverhostkeyblob, sbloblen)) != 0 ||	    (r = sshbuf_put_ec(b, client_dh_pub, ec_group)) != 0 ||	    (r = sshbuf_put_ec(b, server_dh_pub, ec_group)) != 0 ||	    (r = sshbuf_put_bignum2(b, shared_secret)) != 0) {		sshbuf_free(b);		return r;	}#ifdef DEBUG_KEX	sshbuf_dump(b, stderr);#endif	if (EVP_DigestInit(&md, evp_md) != 1 ||	    EVP_DigestUpdate(&md, sshbuf_ptr(b), sshbuf_len(b)) != 1 ||	    EVP_DigestFinal(&md, digest, NULL) != 1) {		sshbuf_free(b);		return SSH_ERR_LIBCRYPTO_ERROR;	}	sshbuf_free(b);#ifdef DEBUG_KEX	dump_digest("hash", digest, EVP_MD_size(evp_md));#endif	*hash = digest;	*hashlen = EVP_MD_size(evp_md);	return 0;}

intkex_ecdh_hash(    int hash_alg,    const EC_GROUP *ec_group,    const char *client_version_string,    const char *server_version_string,    const u_char *ckexinit, size_t ckexinitlen,    const u_char *skexinit, size_t skexinitlen,    const u_char *serverhostkeyblob, size_t sbloblen,    const EC_POINT *client_dh_pub,    const EC_POINT *server_dh_pub,    const BIGNUM *shared_secret,    u_char *hash, size_t *hashlen){	struct sshbuf *b;	int r;	if (*hashlen < ssh_digest_bytes(hash_alg))		return SSH_ERR_INVALID_ARGUMENT;	if ((b = sshbuf_new()) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((r = sshbuf_put_cstring(b, client_version_string)) != 0 ||	    (r = sshbuf_put_cstring(b, server_version_string)) != 0 ||	    /* kexinit messages: fake header: len+SSH2_MSG_KEXINIT */	    (r = sshbuf_put_u32(b, ckexinitlen+1)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||	    (r = sshbuf_put(b, ckexinit, ckexinitlen)) != 0 ||	    (r = sshbuf_put_u32(b, skexinitlen+1)) != 0 ||	    (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||	    (r = sshbuf_put(b, skexinit, skexinitlen)) != 0 ||	    (r = sshbuf_put_string(b, serverhostkeyblob, sbloblen)) != 0 ||	    (r = sshbuf_put_ec(b, client_dh_pub, ec_group)) != 0 ||	    (r = sshbuf_put_ec(b, server_dh_pub, ec_group)) != 0 ||	    (r = sshbuf_put_bignum2(b, shared_secret)) != 0) {		sshbuf_free(b);		return r;	}#ifdef DEBUG_KEX	sshbuf_dump(b, stderr);#endif	if (ssh_digest_buffer(hash_alg, b, hash, *hashlen) != 0) {		sshbuf_free(b);		return SSH_ERR_LIBCRYPTO_ERROR;	}	sshbuf_free(b);	*hashlen = ssh_digest_bytes(hash_alg);#ifdef DEBUG_KEX	dump_digest("hash", hash, *hashlen);#endif	return 0;}

intmm_answer_rsa_keyallowed(int sock, struct sshbuf *m){	BIGNUM *client_n;	struct sshkey *key = NULL;	u_char *blob = NULL;	size_t blen = 0;	int r, allowed = 0;	debug3("%s entering", __func__);	auth_method = "rsa";	if (options.rsa_authentication && authctxt->valid) {		if ((client_n = BN_new()) == NULL)			fatal("%s: BN_new", __func__);		if ((r = sshbuf_get_bignum2(m, client_n)) != 0)			fatal("%s: buffer error: %s", __func__, ssh_err(r));		allowed = auth_rsa_key_allowed(authctxt->pw, client_n, &key);		BN_clear_free(client_n);	}	sshbuf_reset(m);	if ((r = sshbuf_put_u32(m, allowed)) != 0 ||	    (r = sshbuf_put_u32(m, forced_command != NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	/* clear temporarily storage (used by generate challenge) */	monitor_reset_key_state();	if (allowed && key != NULL) {		key->type = KEY_RSA;	/* cheat for key_to_blob */		if ((r = sshkey_to_blob(key, &blob, &blen)) != 0)			fatal("%s: key_to_blob failed: %s",			    __func__, ssh_err(r));		if ((r = sshbuf_put_string(m, blob, blen)) != 0)			fatal("%s: buffer error: %s", __func__, ssh_err(r));		/* Save temporarily for comparison in verify */		key_blob = blob;		key_bloblen = blen;		key_blobtype = MM_RSAUSERKEY;	}	if (key != NULL)		sshkey_free(key);	mm_request_send(sock, MONITOR_ANS_RSAKEYALLOWED, m);	monitor_permit(mon_dispatch, MONITOR_REQ_RSACHALLENGE, allowed);	monitor_permit(mon_dispatch, MONITOR_REQ_RSARESPONSE, 0);	return (0);}

static voidbuild_cert(struct sshbuf *b, const struct sshkey *k, const char *type,    const struct sshkey *sign_key, const struct sshkey *ca_key,    const char *sig_alg){	struct sshbuf *ca_buf, *pk, *principals, *critopts, *exts;	u_char *sigblob;	size_t siglen;	ca_buf = sshbuf_new();	ASSERT_PTR_NE(ca_buf, NULL);	ASSERT_INT_EQ(sshkey_putb(ca_key, ca_buf), 0);	/*	 * Get the public key serialisation by rendering the key and skipping	 * the type string. This is a bit of a hack :/	 */	pk = sshbuf_new();	ASSERT_PTR_NE(pk, NULL);	ASSERT_INT_EQ(sshkey_putb_plain(k, pk), 0);	ASSERT_INT_EQ(sshbuf_skip_string(pk), 0);	principals = sshbuf_new();	ASSERT_PTR_NE(principals, NULL);	ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gsamsa"), 0);	ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gregor"), 0);	critopts = sshbuf_new();	ASSERT_PTR_NE(critopts, NULL);	put_opt(critopts, "force-command", "/usr/local/bin/nethack");	put_opt(critopts, "source-address", "192.168.0.0/24,127.0.0.1,::1");	exts = sshbuf_new();	ASSERT_PTR_NE(exts, NULL);	put_opt(critopts, "permit-X11-forwarding", NULL);	ASSERT_INT_EQ(sshbuf_put_cstring(b, type), 0);	ASSERT_INT_EQ(sshbuf_put_cstring(b, "noncenoncenonce!"), 0); /* nonce */	ASSERT_INT_EQ(sshbuf_putb(b, pk), 0); /* public key serialisation */	ASSERT_INT_EQ(sshbuf_put_u64(b, 1234), 0); /* serial */	ASSERT_INT_EQ(sshbuf_put_u32(b, SSH2_CERT_TYPE_USER), 0); /* type */	ASSERT_INT_EQ(sshbuf_put_cstring(b, "gregor"), 0); /* key ID */	ASSERT_INT_EQ(sshbuf_put_stringb(b, principals), 0); /* principals */	ASSERT_INT_EQ(sshbuf_put_u64(b, 0), 0); /* start */	ASSERT_INT_EQ(sshbuf_put_u64(b, 0xffffffffffffffffULL), 0); /* end */	ASSERT_INT_EQ(sshbuf_put_stringb(b, critopts), 0); /* options */	ASSERT_INT_EQ(sshbuf_put_stringb(b, exts), 0); /* extensions */	ASSERT_INT_EQ(sshbuf_put_string(b, NULL, 0), 0); /* reserved */	ASSERT_INT_EQ(sshbuf_put_stringb(b, ca_buf), 0); /* signature key */	ASSERT_INT_EQ(sshkey_sign(sign_key, &sigblob, &siglen,	    sshbuf_ptr(b), sshbuf_len(b), sig_alg, 0), 0);	ASSERT_INT_EQ(sshbuf_put_string(b, sigblob, siglen), 0); /* signature */	free(sigblob);	sshbuf_free(ca_buf);	sshbuf_free(exts);	sshbuf_free(critopts);	sshbuf_free(principals);	sshbuf_free(pk);}

intmm_answer_gss_checkmic(int sock, struct sshbuf *m){	gss_buffer_desc gssbuf, mic;	OM_uint32 ret;	size_t len;	int r;	u_char *p;	if ((r = sshbuf_get_string(m, &p, &len)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	gssbuf.value = p;	gssbuf.length = len;	if ((r = sshbuf_get_string(m, &p, &len)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	mic.value = p;	mic.length = len;	ret = ssh_gssapi_checkmic(gsscontext, &gssbuf, &mic);	free(gssbuf.value);	free(mic.value);	sshbuf_reset(m);	if ((r = sshbuf_put_u32(m, ret)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	mm_request_send(sock, MONITOR_ANS_GSSCHECKMIC, m);	if (!GSS_ERROR(ret))		monitor_permit(mon_dispatch, MONITOR_REQ_GSSUSEROK, 1);	return 0;}

intmm_answer_bsdauthrespond(int sock, struct sshbuf *m){	char *response;	int r, authok;	if (authctxt->as == 0)		fatal("%s: no bsd auth session", __func__);	if ((r = sshbuf_get_cstring(m, &response, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	authok = options.challenge_response_authentication &&	    auth_userresponse(authctxt->as, response, 0);	authctxt->as = NULL;	debug3("%s: <%s> = <%d>", __func__, response, authok);	free(response);	sshbuf_reset(m);	if ((r = sshbuf_put_u32(m, authok)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("%s: sending authenticated: %d", __func__, authok);	mm_request_send(sock, MONITOR_ANS_BSDAUTHRESPOND, m);	if (compat20) {		auth_method = "keyboard-interactive";		auth_submethod = "bsdauth";	} else		auth_method = "bsdauth";	return (authok != 0);}

intmm_answer_sesskey(int sock, struct sshbuf *m){	BIGNUM *p;	int r, rsafail;	/* Turn off permissions */	monitor_permit(mon_dispatch, MONITOR_REQ_SESSKEY, 0);	if ((p = BN_new()) == NULL)		fatal("%s: BN_new", __func__);	if ((r = sshbuf_get_bignum2(m, p)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	rsafail = ssh1_session_key(p);	sshbuf_reset(m);	if ((r = sshbuf_put_u32(m, rsafail)) != 0 ||	    (r = sshbuf_put_bignum2(m, p)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	BN_clear_free(p);	mm_request_send(sock, MONITOR_ANS_SESSKEY, m);	/* Turn on permissions for sessid passing */	monitor_permit(mon_dispatch, MONITOR_REQ_SESSID, 1);	return (0);}

intmm_answer_authpassword(int sock, struct sshbuf *m){	static int call_count;	char *passwd;	int r, authenticated;	size_t plen;	if ((r = sshbuf_get_cstring(m, &passwd, &plen)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	/* Only authenticate if the context is valid */	authenticated = options.password_authentication &&	    auth_password(authctxt, passwd);	explicit_bzero(passwd, strlen(passwd));	free(passwd);	sshbuf_reset(m);	if ((r = sshbuf_put_u32(m, authenticated)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("%s: sending result %d", __func__, authenticated);	mm_request_send(sock, MONITOR_ANS_AUTHPASSWORD, m);	call_count++;	if (plen == 0 && call_count == 1)		auth_method = "none";	else		auth_method = "password";	/* Causes monitor loop to terminate if authenticated */	return (authenticated);}

static voidsend_statvfs(u_int32_t id, struct statvfs *st){	struct sshbuf *msg;	u_int64_t flag;	int r;	flag = (st->f_flag & ST_RDONLY) ? SSH2_FXE_STATVFS_ST_RDONLY : 0;	flag |= (st->f_flag & ST_NOSUID) ? SSH2_FXE_STATVFS_ST_NOSUID : 0;	if ((msg = sshbuf_new()) == NULL)		fatal("%s: sshbuf_new failed", __func__);	if ((r = sshbuf_put_u8(msg, SSH2_FXP_EXTENDED_REPLY)) != 0 ||	    (r = sshbuf_put_u32(msg, id)) != 0 ||	    (r = sshbuf_put_u64(msg, st->f_bsize)) != 0 ||	    (r = sshbuf_put_u64(msg, st->f_frsize)) != 0 ||	    (r = sshbuf_put_u64(msg, st->f_blocks)) != 0 ||	    (r = sshbuf_put_u64(msg, st->f_bfree)) != 0 ||	    (r = sshbuf_put_u64(msg, st->f_bavail)) != 0 ||	    (r = sshbuf_put_u64(msg, st->f_files)) != 0 ||	    (r = sshbuf_put_u64(msg, st->f_ffree)) != 0 ||	    (r = sshbuf_put_u64(msg, st->f_favail)) != 0 ||	    (r = sshbuf_put_u64(msg, FSID_TO_ULONG(st->f_fsid))) != 0 ||	    (r = sshbuf_put_u64(msg, flag)) != 0 ||	    (r = sshbuf_put_u64(msg, st->f_namemax)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	send_msg(msg);	sshbuf_free(msg);}

/* put algorithm proposal into buffer */intkex_prop2buf(struct sshbuf *b, char *proposal[PROPOSAL_MAX]){	u_int i;	int r;	sshbuf_reset(b);	/*	 * add a dummy cookie, the cookie will be overwritten by	 * kex_send_kexinit(), each time a kexinit is set	 */	for (i = 0; i < KEX_COOKIE_LEN; i++) {		if ((r = sshbuf_put_u8(b, 0)) != 0)			return r;	}	for (i = 0; i < PROPOSAL_MAX; i++) {		if ((r = sshbuf_put_cstring(b, proposal[i])) != 0)			return r;	}	if ((r = sshbuf_put_u8(b, 0)) != 0 ||	/* first_kex_packet_follows */	    (r = sshbuf_put_u32(b, 0)) != 0)	/* uint32 reserved */		return r;	return 0;}

intmm_answer_bsdauthquery(int sock, struct sshbuf *m){	char *name, *infotxt, **prompts;	u_int numprompts, *echo_on, success;	int r;	success = bsdauth_query(authctxt, &name, &infotxt, &numprompts,	    &prompts, &echo_on) < 0 ? 0 : 1;	sshbuf_reset(m);	if ((r = sshbuf_put_u32(m, success)) != 0 ||	    (success && (r = sshbuf_put_cstring(m, prompts[0])) != 0))		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("%s: sending challenge success: %u", __func__, success);	mm_request_send(sock, MONITOR_ANS_BSDAUTHQUERY, m);	if (success) {		free(name);		free(infotxt);		free(prompts);		free(echo_on);	}	return (0);}

static voidprocess_init(void){	struct sshbuf *msg;	int r;	if ((r = sshbuf_get_u32(iqueue, &version)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	verbose("received client version %u", version);	if ((msg = sshbuf_new()) == NULL)		fatal("%s: sshbuf_new failed", __func__);	if ((r = sshbuf_put_u8(msg, SSH2_FXP_VERSION)) != 0 ||	    (r = sshbuf_put_u32(msg, SSH2_FILEXFER_VERSION)) != 0 ||	    /* POSIX rename extension */	    (r = sshbuf_put_cstring(msg, "[email
C++ sshbuf_put_u8函数代码示例
C++ sshbuf_put_string函数代码示例