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

static voidprocess_rename(u_int32_t id){	char *oldpath, *newpath;	int r, status;	struct stat sb;	if ((r = sshbuf_get_cstring(iqueue, &oldpath, NULL)) != 0 ||	    (r = sshbuf_get_cstring(iqueue, &newpath, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("request %u: rename", id);	logit("rename old /"%s/" new /"%s/"", oldpath, newpath);	status = SSH2_FX_FAILURE;	if (lstat(oldpath, &sb) == -1)		status = errno_to_portable(errno);	else if (S_ISREG(sb.st_mode)) {		/* Race-free rename of regular files */		if (link(oldpath, newpath) == -1) {			if (errno == EOPNOTSUPP || errno == ENOSYS#ifdef EXDEV			    || errno == EXDEV#endif#ifdef LINK_OPNOTSUPP_ERRNO			    || errno == LINK_OPNOTSUPP_ERRNO#endif			    ) {				struct stat st;				/*				 * fs doesn't support links, so fall back to				 * stat+rename.  This is racy.				 */				if (stat(newpath, &st) == -1) {					if (rename(oldpath, newpath) == -1)						status =						    errno_to_portable(errno);					else						status = SSH2_FX_OK;				}			} else {				status = errno_to_portable(errno);			}		} else if (unlink(oldpath) == -1) {			status = errno_to_portable(errno);			/* clean spare link */			unlink(newpath);		} else			status = SSH2_FX_OK;	} else if (stat(newpath, &sb) == -1) {		if (rename(oldpath, newpath) == -1)			status = errno_to_portable(errno);		else			status = SSH2_FX_OK;	}	send_status(id, status);	free(oldpath);	free(newpath);}

/* Import regular and PAM environment from subprocess */static voidimport_environments(struct sshbuf *b){	char *env;	u_int n, i, num_env;	int r;	debug3("PAM: %s entering", __func__);#ifndef UNSUPPORTED_POSIX_THREADS_HACK	/* Import variables set by do_pam_account */	if ((r = sshbuf_get_u32(b, &n)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	if (n > INT_MAX)		fatal("%s: invalid PAM account status %u", __func__, n);	sshpam_account_status = (int)n;	if ((r = sshbuf_get_u32(b, &n)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	sshpam_password_change_required(n != 0);	/* Import environment from subprocess */	if ((r = sshbuf_get_u32(b, &num_env)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	if (num_env > 1024)		fatal("%s: received %u environment variables, expected <= 1024",		    __func__, num_env);	sshpam_env = xcalloc(num_env + 1, sizeof(*sshpam_env));	debug3("PAM: num env strings %d", num_env);	for(i = 0; i < num_env; i++) {		if ((r = sshbuf_get_cstring(b, &(sshpam_env[i]), NULL)) != 0)			fatal("%s: buffer error: %s", __func__, ssh_err(r));	}	sshpam_env[num_env] = NULL;	/* Import PAM environment from subprocess */	if ((r = sshbuf_get_u32(b, &num_env)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug("PAM: num PAM env strings %d", num_env);	for (i = 0; i < num_env; i++) {		if ((r = sshbuf_get_cstring(b, &env, NULL)) != 0)			fatal("%s: buffer error: %s", __func__, ssh_err(r));#ifdef HAVE_PAM_PUTENV		/* Errors are not fatal here */		if ((r = pam_putenv(sshpam_handle, env)) != PAM_SUCCESS) {			error("PAM: pam_putenv: %s",			    pam_strerror(sshpam_handle, r));		}#endif		/* XXX leak env? */	}#endif}

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_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 voidprocess_opendir(u_int32_t id){	DIR *dirp = NULL;	char *path;	int r, handle, status = SSH2_FX_FAILURE;	if ((r = sshbuf_get_cstring(iqueue, &path, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("request %u: opendir", id);	logit("opendir /"%s/"", path);	dirp = opendir(path);	if (dirp == NULL) {		status = errno_to_portable(errno);	} else {		handle = handle_new(HANDLE_DIR, path, 0, 0, dirp);		if (handle < 0) {			closedir(dirp);		} else {			send_handle(id, handle);			status = SSH2_FX_OK;		}	}	if (status != SSH2_FX_OK)		send_status(id, status);	free(path);}

static intdeserialise_identity1(struct sshbuf *ids, struct sshkey **keyp, char **commentp){	struct sshkey *key;	int r, keybits;	u_int32_t bits;	char *comment = NULL;	if ((key = sshkey_new(KEY_RSA1)) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((r = sshbuf_get_u32(ids, &bits)) != 0 ||	    (r = sshbuf_get_bignum1(ids, key->rsa->e)) != 0 ||	    (r = sshbuf_get_bignum1(ids, key->rsa->n)) != 0 ||	    (r = sshbuf_get_cstring(ids, &comment, NULL)) != 0)		goto out;	keybits = BN_num_bits(key->rsa->n);	/* XXX previously we just warned here. I think we should be strict */	if (keybits < 0 || bits != (u_int)keybits) {		r = SSH_ERR_KEY_BITS_MISMATCH;		goto out;	}	if (keyp != NULL) {		*keyp = key;		key = NULL;	}	if (commentp != NULL) {		*commentp = comment;		comment = NULL;	}	r = 0; out:	sshkey_free(key);	free(comment);	return r;}

static voidprocess_do_stat(u_int32_t id, int do_lstat){	Attrib a;	struct stat st;	char *name;	int r, status = SSH2_FX_FAILURE;	if ((r = sshbuf_get_cstring(iqueue, &name, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("request %u: %sstat", id, do_lstat ? "l" : "");	verbose("%sstat name /"%s/"", do_lstat ? "l" : "", name);	r = do_lstat ? lstat(name, &st) : stat(name, &st);	if (r < 0) {		status = errno_to_portable(errno);	} else {		stat_to_attrib(&st, &a);		send_attrib(id, &a);		status = SSH2_FX_OK;	}	if (status != SSH2_FX_OK)		send_status(id, status);	free(name);}

static voidprocess_realpath(u_int32_t id){	char resolvedname[PATH_MAX];	char *path;	int r;	if ((r = sshbuf_get_cstring(iqueue, &path, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	if (path[0] == '/0') {		free(path);		path = xstrdup(".");	}	debug3("request %u: realpath", id);	verbose("realpath /"%s/"", path);	if (realpath(path, resolvedname) == NULL) {		send_status(id, errno_to_portable(errno));	} else {		Stat s;		attrib_clear(&s.attrib);		s.name = s.long_name = resolvedname;		send_names(id, 1, &s);	}	free(path);}

static voidprocess_extended_hardlink(u_int32_t id){	char *oldpath, *newpath;	int r, status;	if ((r = sshbuf_get_cstring(iqueue, &oldpath, NULL)) != 0 ||	    (r = sshbuf_get_cstring(iqueue, &newpath, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("request %u: hardlink", id);	logit("hardlink old /"%s/" new /"%s/"", oldpath, newpath);	r = link(oldpath, newpath);	status = (r == -1) ? errno_to_portable(errno) : SSH2_FX_OK;	send_status(id, status);	free(oldpath);	free(newpath);}

intsshkey_xmss_deserialize_state(struct sshkey *k, struct sshbuf *b){	struct ssh_xmss_state *state = k->xmss_state;	treehash_inst *th;	u_int32_t i, lh, node;	size_t ls, lsl, la, lk, ln, lr;	char *magic;	int r;	if (state == NULL)		return SSH_ERR_INVALID_ARGUMENT;	if (k->xmss_sk == NULL)		return SSH_ERR_INVALID_ARGUMENT;	if ((state->treehash = calloc(num_treehash(state),	    sizeof(treehash_inst))) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((r = sshbuf_get_cstring(b, &magic, NULL)) != 0 ||	    (r = sshbuf_get_u32(b, &state->idx)) != 0 ||	    (r = sshbuf_get_string(b, &state->stack, &ls)) != 0 ||	    (r = sshbuf_get_u32(b, &state->stackoffset)) != 0 ||	    (r = sshbuf_get_string(b, &state->stacklevels, &lsl)) != 0 ||	    (r = sshbuf_get_string(b, &state->auth, &la)) != 0 ||	    (r = sshbuf_get_string(b, &state->keep, &lk)) != 0 ||	    (r = sshbuf_get_string(b, &state->th_nodes, &ln)) != 0 ||	    (r = sshbuf_get_string(b, &state->retain, &lr)) != 0 ||	    (r = sshbuf_get_u32(b, &lh)) != 0)		return r;	if (strcmp(magic, SSH_XMSS_K2_MAGIC) != 0)		return SSH_ERR_INVALID_ARGUMENT;	/* XXX check stackoffset */	if (ls != num_stack(state) ||	    lsl != num_stacklevels(state) ||	    la != num_auth(state) ||	    lk != num_keep(state) ||	    ln != num_th_nodes(state) ||	    lr != num_retain(state) ||	    lh != num_treehash(state))		return SSH_ERR_INVALID_ARGUMENT;	for (i = 0; i < num_treehash(state); i++) {		th = &state->treehash[i];		if ((r = sshbuf_get_u32(b, &th->h)) != 0 ||		    (r = sshbuf_get_u32(b, &th->next_idx)) != 0 ||		    (r = sshbuf_get_u32(b, &th->stackusage)) != 0 ||		    (r = sshbuf_get_u8(b, &th->completed)) != 0 ||		    (r = sshbuf_get_u32(b, &node)) != 0)			return r;		if (node < num_th_nodes(state))			th->node = &state->th_nodes[node];	}	POKE_U32(k->xmss_sk, state->idx);	xmss_set_bds_state(&state->bds, state->stack, state->stackoffset,	    state->stacklevels, state->auth, state->keep, state->treehash,	    state->retain, 0);	return 0;}

intmm_answer_authserv(int sock, struct sshbuf *m){	int r;	monitor_permit_authentications(1);	if ((r = sshbuf_get_cstring(m, &authctxt->service, NULL)) != 0 ||	    (r = sshbuf_get_cstring(m, &authctxt->style, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("%s: service=%s, style=%s",	    __func__, authctxt->service, authctxt->style);	if (strlen(authctxt->style) == 0) {		free(authctxt->style);		authctxt->style = NULL;	}	return (0);}

static intdeserialise_nullable_string(struct sshbuf *m, char **sp){	int r;	u_char flag;	*sp = NULL;	if ((r = sshbuf_get_u8(m, &flag)) != 0 ||	    (r = sshbuf_get_cstring(m, flag ? NULL : sp, NULL)) != 0)		return r;	return 0;}

static intmonitor_read_log(struct monitor *pmonitor){	struct sshbuf *logmsg;	u_int len, level;	u_char *p;	char *msg;	int r;	if ((logmsg = sshbuf_new()) == NULL)		fatal("%s: sshbuf_new failed", __func__);	/* Read length */	if ((r = sshbuf_reserve(logmsg, 4, &p)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	if (atomicio(read, pmonitor->m_log_recvfd, p, 4) != 4) {		if (errno == EPIPE) {			sshbuf_free(logmsg);			debug("%s: child log fd closed", __func__);			close(pmonitor->m_log_recvfd);			pmonitor->m_log_recvfd = -1;			return -1;		}		fatal("%s: log fd read: %s", __func__, strerror(errno));	}	if ((r = sshbuf_get_u32(logmsg, &len)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	if (len <= 4 || len > 8192)		fatal("%s: invalid log message length %u", __func__, len);	/* Read severity, message */	sshbuf_reset(logmsg);	if ((r = sshbuf_reserve(logmsg, len, &p)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	if (atomicio(read, pmonitor->m_log_recvfd, p, len) != len)		fatal("%s: log fd read: %s", __func__, strerror(errno));	/* Log it */	if ((r = sshbuf_get_u32(logmsg, &level)) != 0 ||	    (r = sshbuf_get_cstring(logmsg, &msg, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	if (log_level_name(level) == NULL)		fatal("%s: invalid log level %u (corrupted message?)",		    __func__, level);	do_log2(level, "%s [preauth]", msg);	sshbuf_free(logmsg);	free(msg);	return 0;}

char *buffer_get_cstring_ret(Buffer *buffer, u_int *length_ptr){	size_t len;	int ret;	char *value;	if ((ret = sshbuf_get_cstring(buffer, &value, &len)) != 0) {		error("%s: %s", __func__, ssh_err(ret));		return NULL;	}	if (length_ptr != NULL)		*length_ptr = len;  /* Safe: sshbuf never stores len > 2^31 */	return value;}

intsshkey_xmss_deserialize_enc_key(struct sshkey *k, struct sshbuf *b){	struct ssh_xmss_state *state = k->xmss_state;	size_t len;	int r;	if (state == NULL)		return SSH_ERR_INVALID_ARGUMENT;	if ((r = sshbuf_get_cstring(b, &state->enc_ciphername, NULL)) != 0 ||	    (r = sshbuf_get_string(b, &state->enc_keyiv, &len)) != 0)		return r;	state->enc_keyiv_len = len;	return 0;}

static voidprocess_rmdir(u_int32_t id){	char *name;	int r, status;	if ((r = sshbuf_get_cstring(iqueue, &name, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("request %u: rmdir", id);	logit("rmdir name /"%s/"", name);	r = rmdir(name);	status = (r == -1) ? errno_to_portable(errno) : SSH2_FX_OK;	send_status(id, status);	free(name);}

/* Decode attributes in buffer */intdecode_attrib(struct sshbuf *b, Attrib *a){	int r;	attrib_clear(a);	if ((r = sshbuf_get_u32(b, &a->flags)) != 0)		return r;	if (a->flags & SSH2_FILEXFER_ATTR_SIZE) {		if ((r = sshbuf_get_u64(b, &a->size)) != 0)			return r;	}	if (a->flags & SSH2_FILEXFER_ATTR_UIDGID) {		if ((r = sshbuf_get_u32(b, &a->uid)) != 0 ||		    (r = sshbuf_get_u32(b, &a->gid)) != 0)			return r;	}	if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) {		if ((r = sshbuf_get_u32(b, &a->perm)) != 0)			return r;	}	if (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME) {		if ((r = sshbuf_get_u32(b, &a->atime)) != 0 ||		    (r = sshbuf_get_u32(b, &a->mtime)) != 0)			return r;	}	/* vendor-specific extensions */	if (a->flags & SSH2_FILEXFER_ATTR_EXTENDED) {		char *type;		u_char *data;		size_t dlen;		u_int i, count;		if ((r = sshbuf_get_u32(b, &count)) != 0)			fatal("%s: buffer error: %s", __func__, ssh_err(r));		for (i = 0; i < count; i++) {			if ((r = sshbuf_get_cstring(b, &type, NULL)) != 0 ||			    (r = sshbuf_get_string(b, &data, &dlen)) != 0)				return r;			debug3("Got file attribute /"%.100s/" len %zu",			    type, dlen);			free(type);			free(data);		}	}	return 0;}

voidauth_debug_send(void){	struct ssh *ssh = active_state;		/* XXX */	char *msg;	int r;	if (auth_debug == NULL)		return;	while (sshbuf_len(auth_debug) != 0) {		if ((r = sshbuf_get_cstring(auth_debug, &msg, NULL)) != 0)			fatal("%s: sshbuf_get_cstring: %s",			    __func__, ssh_err(r));		ssh_packet_send_debug(ssh, "%s", msg);		free(msg);	}}

intmm_answer_pty_cleanup(int sock, struct sshbuf *m){	Session *s;	char *tty;	int r;	debug3("%s entering", __func__);	if ((r = sshbuf_get_cstring(m, &tty, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	if ((s = session_by_tty(tty)) != NULL)		mm_session_close(s);	sshbuf_reset(m);	free(tty);	return (0);}

static voidprocess_setstat(u_int32_t id){	Attrib a;	char *name;	int r, status = SSH2_FX_OK;	if ((r = sshbuf_get_cstring(iqueue, &name, NULL)) != 0 ||	    (r = decode_attrib(iqueue, &a)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug("request %u: setstat name /"%s/"", id, name);	if (a.flags & SSH2_FILEXFER_ATTR_SIZE) {		logit("set /"%s/" size %llu",		    name, (unsigned long long)a.size);		r = truncate(name, a.size);		if (r == -1)			status = errno_to_portable(errno);	}	if (a.flags & SSH2_FILEXFER_ATTR_PERMISSIONS) {		logit("set /"%s/" mode %04o", name, a.perm);		r = chmod(name, a.perm & 07777);		if (r == -1)			status = errno_to_portable(errno);	}	if (a.flags & SSH2_FILEXFER_ATTR_ACMODTIME) {		char buf[64];		time_t t = a.mtime;		strftime(buf, sizeof(buf), "%Y%m%d-%H:%M:%S",		    localtime(&t));		logit("set /"%s/" modtime %s", name, buf);		r = utimes(name, attrib_to_tv(&a));		if (r == -1)			status = errno_to_portable(errno);	}	if (a.flags & SSH2_FILEXFER_ATTR_UIDGID) {		logit("set /"%s/" owner %lu group %lu", name,		    (u_long)a.uid, (u_long)a.gid);		r = chown(name, a.uid, a.gid);		if (r == -1)			status = errno_to_portable(errno);	}	send_status(id, status);	free(name);}

static voidprocess_extended_statvfs(u_int32_t id){	char *path;	struct statvfs st;	int r;	if ((r = sshbuf_get_cstring(iqueue, &path, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("request %u: statvfs", id);	logit("statvfs /"%s/"", path);	if (statvfs(path, &st) != 0)		send_status(id, errno_to_portable(errno));	else		send_statvfs(id, &st);        free(path);}

static voidprocess_mkdir(u_int32_t id){	Attrib a;	char *name;	int r, mode, status = SSH2_FX_FAILURE;	if ((r = sshbuf_get_cstring(iqueue, &name, NULL)) != 0 ||	    (r = decode_attrib(iqueue, &a)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	mode = (a.flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ?	    a.perm & 07777 : 0777;	debug3("request %u: mkdir", id);	logit("mkdir name /"%s/" mode 0%o", name, mode);	r = mkdir(name, mode);	status = (r == -1) ? errno_to_portable(errno) : SSH2_FX_OK;	send_status(id, status);	free(name);}

static voidprocess_open(u_int32_t id){	u_int32_t pflags;	Attrib a;	char *name;	int r, handle, fd, flags, mode, status = SSH2_FX_FAILURE;	if ((r = sshbuf_get_cstring(iqueue, &name, NULL)) != 0 ||	    (r = sshbuf_get_u32(iqueue, &pflags)) != 0 || /* portable flags */	    (r = decode_attrib(iqueue, &a)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("request %u: open flags %d", id, pflags);	flags = flags_from_portable(pflags);	mode = (a.flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ? a.perm : 0666;	logit("open /"%s/" flags %s mode 0%o",	    name, string_from_portable(pflags), mode);	if (readonly &&	    ((flags & O_ACCMODE) == O_WRONLY ||	    (flags & O_ACCMODE) == O_RDWR)) {		verbose("Refusing open request in read-only mode");		status = SSH2_FX_PERMISSION_DENIED;	} else {		fd = open(name, flags, mode);		if (fd < 0) {			status = errno_to_portable(errno);		} else {			handle = handle_new(HANDLE_FILE, name, fd, flags, NULL);			if (handle < 0) {				close(fd);			} else {				send_handle(id, handle);				status = SSH2_FX_OK;			}		}	}	if (status != SSH2_FX_OK)		send_status(id, status);	free(name);}

/* parse buffer and return algorithm proposal */intkex_buf2prop(struct sshbuf *raw, int *first_kex_follows, char ***propp){	struct sshbuf *b = NULL;	u_char v;	u_int i;	char **proposal = NULL;	int r;	if ((proposal = calloc(PROPOSAL_MAX, sizeof(char *))) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((b = sshbuf_new()) == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	if ((r = sshbuf_putb(b, raw)) != 0 ||	    (r = sshbuf_consume(b, KEX_COOKIE_LEN)) != 0) /* skip cookie */		goto out;	/* extract kex init proposal strings */	for (i = 0; i < PROPOSAL_MAX; i++) {		if ((r = sshbuf_get_cstring(b, &(proposal[i]), NULL)) != 0)			goto out;		debug2("kex_parse_kexinit: %s", proposal[i]);	}	/* first kex follows / reserved */	if ((r = sshbuf_get_u8(b, &v)) != 0 ||	    (r = sshbuf_get_u32(b, &i)) != 0)		goto out;	if (first_kex_follows != NULL)		*first_kex_follows = i;	debug2("kex_parse_kexinit: first_kex_follows %d ", v);	debug2("kex_parse_kexinit: reserved %u ", i);	r = 0;	*propp = proposal; out:	if (r != 0 && proposal != NULL)		kex_prop_free(proposal);	sshbuf_free(b);	return r;}

static intdeserialise_identity2(struct sshbuf *ids, struct sshkey **keyp, char **commentp){	int r;	char *comment = NULL;	const u_char *blob;	size_t blen;	if ((r = sshbuf_get_string_direct(ids, &blob, &blen)) != 0 ||	    (r = sshbuf_get_cstring(ids, &comment, NULL)) != 0)		goto out;	if ((r = sshkey_from_blob(blob, blen, keyp)) != 0)		goto out;	if (commentp != NULL) {		*commentp = comment;		comment = NULL;	}	r = 0; out:	free(comment);	return r;}

static intdeserialise_array(struct sshbuf *m, char ***ap, size_t *np){	char **a = NULL;	size_t i, n = 0;	struct sshbuf *b = NULL;	u_int tmp;	int r = SSH_ERR_INTERNAL_ERROR;	if ((r = sshbuf_get_u32(m, &tmp)) != 0 ||	    (r = sshbuf_froms(m, &b)) != 0)		goto out;	if (tmp > INT_MAX) {		r = SSH_ERR_INVALID_FORMAT;		goto out;	}	n = tmp;	if (n > 0 && (a = calloc(n, sizeof(*a))) == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	for (i = 0; i < n; i++) {		if ((r = sshbuf_get_cstring(b, &a[i], NULL)) != 0)			goto out;	}	/* success */	r = 0;	*ap = a;	a = NULL;	*np = n;	n = 0; out:	for (i = 0; i < n; i++)		free(a[i]);	free(a);	sshbuf_free(b);	return r;}

static voidprocess_extended(u_int32_t id){	char *request;	int i, r;	if ((r = sshbuf_get_cstring(iqueue, &request, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	for (i = 0; extended_handlers[i].handler != NULL; i++) {		if (strcmp(request, extended_handlers[i].ext_name) == 0) {			if (!request_permitted(&extended_handlers[i]))				send_status(id, SSH2_FX_PERMISSION_DENIED);			else				extended_handlers[i].handler(id);			break;		}	}	if (extended_handlers[i].handler == NULL) {		error("Unknown extended request /"%.100s/"", request);		send_status(id, SSH2_FX_OP_UNSUPPORTED);	/* MUST */	}	free(request);}

static voidprocess_readlink(u_int32_t id){	int r, len;	char buf[PATH_MAX];	char *path;	if ((r = sshbuf_get_cstring(iqueue, &path, NULL)) != 0)		fatal("%s: buffer error: %s", __func__, ssh_err(r));	debug3("request %u: readlink", id);	verbose("readlink /"%s/"", path);	if ((len = readlink(path, buf, sizeof(buf) - 1)) == -1)		send_status(id, errno_to_portable(errno));	else {		Stat s;		buf[len] = '/0';		attrib_clear(&s.attrib);		s.name = s.long_name = buf;		send_names(id, 1, &s);	}	free(path);}

static intparse_option_list(struct sshbuf *oblob, struct passwd *pw,    u_int which, int crit,    int *cert_no_port_forwarding_flag,    int *cert_no_agent_forwarding_flag,    int *cert_no_x11_forwarding_flag,    int *cert_no_pty_flag,    int *cert_no_user_rc,    char **cert_forced_command,    int *cert_source_address_done){	struct ssh *ssh = active_state;		/* XXX */	char *command, *allowed;	const char *remote_ip;	char *name = NULL;	struct sshbuf *c = NULL, *data = NULL;	int r, ret = -1, result, found;	if ((c = sshbuf_fromb(oblob)) == NULL) {		error("%s: sshbuf_fromb failed", __func__);		goto out;	}	while (sshbuf_len(c) > 0) {		sshbuf_free(data);		data = NULL;		if ((r = sshbuf_get_cstring(c, &name, NULL)) != 0 ||		    (r = sshbuf_froms(c, &data)) != 0) {			error("Unable to parse certificate options: %s",			    ssh_err(r));			goto out;		}		debug3("found certificate option /"%.100s/" len %zu",		    name, sshbuf_len(data));		found = 0;		if ((which & OPTIONS_EXTENSIONS) != 0) {			if (strcmp(name, "permit-X11-forwarding") == 0) {				*cert_no_x11_forwarding_flag = 0;				found = 1;			} else if (strcmp(name,			    "permit-agent-forwarding") == 0) {				*cert_no_agent_forwarding_flag = 0;				found = 1;			} else if (strcmp(name,			    "permit-port-forwarding") == 0) {				*cert_no_port_forwarding_flag = 0;				found = 1;			} else if (strcmp(name, "permit-pty") == 0) {				*cert_no_pty_flag = 0;				found = 1;			} else if (strcmp(name, "permit-user-rc") == 0) {				*cert_no_user_rc = 0;				found = 1;			}		}		if (!found && (which & OPTIONS_CRITICAL) != 0) {			if (strcmp(name, "force-command") == 0) {				if ((r = sshbuf_get_cstring(data, &command,				    NULL)) != 0) {					error("Unable to parse /"%s/" "					    "section: %s", name, ssh_err(r));					goto out;				}				if (*cert_forced_command != NULL) {					error("Certificate has multiple "					    "force-command options");					free(command);					goto out;				}				*cert_forced_command = command;				found = 1;			}			if (strcmp(name, "source-address") == 0) {				if ((r = sshbuf_get_cstring(data, &allowed,				    NULL)) != 0) {					error("Unable to parse /"%s/" "					    "section: %s", name, ssh_err(r));					goto out;				}				if ((*cert_source_address_done)++) {					error("Certificate has multiple "					    "source-address options");					free(allowed);					goto out;				}				remote_ip = ssh_remote_ipaddr(ssh);				result = addr_match_cidr_list(remote_ip,				    allowed);				free(allowed);				switch (result) {				case 1:					/* accepted */					break;				case 0:					/* no match */					logit("Authentication tried for %.100s "					    "with valid certificate but not "					    "from a permitted host "					    "(ip=%.200s).", pw->pw_name,					    remote_ip);//.........这里部分代码省略.........

intssh_ed25519_verify(const struct sshkey *key,    const u_char *signature, size_t signaturelen,    const u_char *data, size_t datalen, u_int compat){	struct sshbuf *b = NULL;	char *ktype = NULL;	const u_char *sigblob;	u_char *sm = NULL, *m = NULL;	size_t len;	unsigned long long smlen = 0, mlen = 0;	int r, ret;	if (key == NULL ||	    sshkey_type_plain(key->type) != KEY_ED25519 ||	    key->ed25519_pk == NULL ||	    datalen >= INT_MAX - crypto_sign_ed25519_BYTES)		return SSH_ERR_INVALID_ARGUMENT;	if ((b = sshbuf_from(signature, signaturelen)) == NULL)		return SSH_ERR_ALLOC_FAIL;	if ((r = sshbuf_get_cstring(b, &ktype, NULL)) != 0 ||	    (r = sshbuf_get_string_direct(b, &sigblob, &len)) != 0)		goto out;	if (strcmp("ssh-ed25519", ktype) != 0) {		r = SSH_ERR_KEY_TYPE_MISMATCH;		goto out;	}	if (sshbuf_len(b) != 0) {		r = SSH_ERR_UNEXPECTED_TRAILING_DATA;		goto out;	}	if (len > crypto_sign_ed25519_BYTES) {		r = SSH_ERR_INVALID_FORMAT;		goto out;	}	if (datalen >= SIZE_MAX - len) {		r = SSH_ERR_INVALID_ARGUMENT;		goto out;	}	smlen = len + datalen;	mlen = smlen;	if ((sm = malloc(smlen)) == NULL || (m = malloc(mlen)) == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	memcpy(sm, sigblob, len);	memcpy(sm+len, data, datalen);	if ((ret = crypto_sign_ed25519_open(m, &mlen, sm, smlen,	    key->ed25519_pk)) != 0) {		debug2("%s: crypto_sign_ed25519_open failed: %d",		    __func__, ret);	}	if (ret != 0 || mlen != datalen) {		r = SSH_ERR_SIGNATURE_INVALID;		goto out;	}	/* XXX compare 'm' and 'data' ? */	/* success */	r = 0; out:	if (sm != NULL) {		explicit_bzero(sm, smlen);		free(sm);	}	if (m != NULL) {		explicit_bzero(m, smlen); /* NB mlen may be invalid if r != 0 */		free(m);	}	sshbuf_free(b);	free(ktype);	return r;}