shinys000114/libssh
1
0
Fork 0
mirror of https://git.libssh.org/projects/libssh.git synced 2026-02-11 18:50:28 +09:00
Code Issues Packages Projects Releases Wiki Activity

agent: Reformat the rest of the file

Browse Source 
Signed-off-by: Jakub Jelen <jjelen@redhat.com>
Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
This commit is contained in:
Jakub Jelen
2025-08-01 12:04:29 +02:00
parent cc667021e5
commit 737f9ecc3c
1 changed files with 206 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

386
src/agent.c
View File

@@ -67,87 +67,95 @@
(((x) == SSH_AGENT_FAILURE) || ((x) == SSH_COM_AGENT2_FAILURE) || \ (((x) == SSH_AGENT_FAILURE) || ((x) == SSH_COM_AGENT2_FAILURE) || \
((x) == SSH2_AGENT_FAILURE)) ((x) == SSH2_AGENT_FAILURE))
static uint32_t atomicio(struct ssh_agent_struct *agent, void *buf, uint32_t n, int do_read) { static uint32_t
char *b = buf; atomicio(struct ssh_agent_struct *agent, void *buf, uint32_t n, int do_read)
uint32_t pos = 0; {
ssize_t res; char *b = buf;
ssh_pollfd_t pfd; uint32_t pos = 0;
ssh_channel channel = agent->channel; ssize_t res;
socket_t fd; ssh_pollfd_t pfd;
ssh_channel channel = agent->channel;
socket_t fd;
/* Using a socket ? */ /* Using a socket ? */
if (channel == NULL) { if (channel == NULL) {
fd = ssh_socket_get_fd(agent->sock); fd = ssh_socket_get_fd(agent->sock);
pfd.fd = fd; pfd.fd = fd;
pfd.events = do_read ? POLLIN : POLLOUT; pfd.events = do_read ? POLLIN : POLLOUT;
while (n > pos) { while (n > pos) {
if (do_read) { if (do_read) {
res = recv(fd, b + pos, n - pos, 0); res = recv(fd, b + pos, n - pos, 0);
} else { } else {
res = send(fd, b + pos, n - pos, 0); res = send(fd, b + pos, n - pos, 0);
} }
switch (res) { switch (res) {
case -1: case -1:
if (errno == EINTR) { if (errno == EINTR) {
continue; continue;
} }
#ifdef EWOULDBLOCK #ifdef EWOULDBLOCK
if (errno == EAGAIN || errno == EWOULDBLOCK) { if (errno == EAGAIN || errno == EWOULDBLOCK) {
#else #else
if (errno == EAGAIN) { if (errno == EAGAIN) {
#endif #endif
(void) ssh_poll(&pfd, 1, -1); (void)ssh_poll(&pfd, 1, -1);
continue; continue;
} }
return 0; return 0;
case 0: case 0:
/* read returns 0 on end-of-file */ /* read returns 0 on end-of-file */
errno = do_read ? 0 : EPIPE; errno = do_read ? 0 : EPIPE;
return pos; return pos;
default: default:
pos += (uint32_t) res; pos += (uint32_t)res;
}
} }
} return pos;
return pos;
} else { } else {
/* using an SSH channel */ /* using an SSH channel */
while (n > pos){ while (n > pos) {
if (do_read) if (do_read) {
res = ssh_channel_read(channel,b + pos, n-pos, 0); res = ssh_channel_read(channel, b + pos, n - pos, 0);
else } else {
res = ssh_channel_write(channel, b+pos, n-pos); res = ssh_channel_write(channel, b + pos, n - pos);
if (res == SSH_AGAIN) }
continue; if (res == SSH_AGAIN) {
if (res == SSH_ERROR) continue;
return 0; }
pos += (uint32_t)res; if (res == SSH_ERROR) {
} return 0;
return pos; }
pos += (uint32_t)res;
}
return pos;
} }
} }
ssh_agent ssh_agent_new(struct ssh_session_struct *session) { ssh_agent ssh_agent_new(struct ssh_session_struct *session)
ssh_agent agent = NULL; {
ssh_agent agent = NULL;
agent = malloc(sizeof(struct ssh_agent_struct)); agent = malloc(sizeof(struct ssh_agent_struct));
if (agent == NULL) { if (agent == NULL) {
return NULL; return NULL;
} }
ZERO_STRUCTP(agent); ZERO_STRUCTP(agent);
agent->count = 0; agent->count = 0;
agent->sock = ssh_socket_new(session); agent->sock = ssh_socket_new(session);
if (agent->sock == NULL) { if (agent->sock == NULL) {
SAFE_FREE(agent); SAFE_FREE(agent);
return NULL; return NULL;
} }
agent->channel = NULL; agent->channel = NULL;
return agent; return agent;
} }
static void agent_set_channel(struct ssh_agent_struct *agent, ssh_channel channel){ static void agent_set_channel(struct ssh_agent_struct *agent,
agent->channel = channel; ssh_channel channel)
{
agent->channel = channel;
} }
/** /**
@@ -168,15 +176,19 @@ static void agent_set_channel(struct ssh_agent_struct *agent, ssh_channel channe
* @returns SSH_OK in case of success * @returns SSH_OK in case of success
* SSH_ERROR in case of an error * SSH_ERROR in case of an error
*/ */
int ssh_set_agent_channel(ssh_session session, ssh_channel channel){ int ssh_set_agent_channel(ssh_session session, ssh_channel channel)
if (!session) {
return SSH_ERROR; if (!session) {
if (!session->agent){ return SSH_ERROR;
ssh_set_error(session, SSH_REQUEST_DENIED, "Session has no active agent"); }
return SSH_ERROR; if (!session->agent) {
} ssh_set_error(session,
agent_set_channel(session->agent, channel); SSH_REQUEST_DENIED,
return SSH_OK; "Session has no active agent");
return SSH_ERROR;
}
agent_set_channel(session->agent, channel);
return SSH_OK;
} }
/** @brief sets the SSH agent socket. /** @brief sets the SSH agent socket.
@@ -187,64 +199,72 @@ int ssh_set_agent_channel(ssh_session session, ssh_channel channel){
* @returns SSH_OK in case of success * @returns SSH_OK in case of success
* SSH_ERROR in case of an error * SSH_ERROR in case of an error
*/ */
int ssh_set_agent_socket(ssh_session session, socket_t fd){ int ssh_set_agent_socket(ssh_session session, socket_t fd)
if (!session) {
return SSH_ERROR; if (!session) {
if (!session->agent){ return SSH_ERROR;
ssh_set_error(session, SSH_REQUEST_DENIED, "Session has no active agent"); }
return SSH_ERROR; if (!session->agent) {
} ssh_set_error(session,
SSH_REQUEST_DENIED,
"Session has no active agent");
return SSH_ERROR;
}
ssh_socket_set_fd(session->agent->sock, fd); ssh_socket_set_fd(session->agent->sock, fd);
return SSH_OK; return SSH_OK;
} }
/** /**
* @} * @}
*/ */
void ssh_agent_close(struct ssh_agent_struct *agent) { void ssh_agent_close(struct ssh_agent_struct *agent)
if (agent == NULL) { {
return; if (agent == NULL) {
} return;
}
ssh_socket_close(agent->sock); ssh_socket_close(agent->sock);
} }
void ssh_agent_free(ssh_agent agent) { void ssh_agent_free(ssh_agent agent)
if (agent) { {
if (agent->ident) { if (agent) {
SSH_BUFFER_FREE(agent->ident); if (agent->ident) {
SSH_BUFFER_FREE(agent->ident);
}
if (agent->sock) {
ssh_agent_close(agent);
ssh_socket_free(agent->sock);
}
SAFE_FREE(agent);
} }
if (agent->sock) {
ssh_agent_close(agent);
ssh_socket_free(agent->sock);
}
SAFE_FREE(agent);
}
} }
static int agent_connect(ssh_session session) { static int agent_connect(ssh_session session)
const char *auth_sock = NULL; {
const char *auth_sock = NULL;
if (session == NULL || session->agent == NULL) {
return -1;
}
if (session->agent->channel != NULL) {
return 0;
}
auth_sock = session->opts.agent_socket ? session->opts.agent_socket
: getenv("SSH_AUTH_SOCK");
if (auth_sock && *auth_sock) {
if (ssh_socket_unix(session->agent->sock, auth_sock) < 0) {
return -1;
}
return 0;
}
if (session == NULL || session->agent == NULL) {
return -1; return -1;
}
if (session->agent->channel != NULL)
return 0;
auth_sock = session->opts.agent_socket ?
session->opts.agent_socket : getenv("SSH_AUTH_SOCK");
if (auth_sock && *auth_sock) {
if (ssh_socket_unix(session->agent->sock, auth_sock) < 0) {
return -1;
}
return 0;
}
return -1;
} }
#if 0 #if 0
@@ -268,61 +288,66 @@ static int agent_decode_reply(struct ssh_session_struct *session, int type) {
#endif #endif
static int agent_talk(struct ssh_session_struct *session, static int agent_talk(struct ssh_session_struct *session,
struct ssh_buffer_struct *request, struct ssh_buffer_struct *reply) { struct ssh_buffer_struct *request,
uint32_t len = 0; struct ssh_buffer_struct *reply)
uint8_t tmpbuf[4]; {
uint8_t *payload = tmpbuf; uint32_t len = 0;
char err_msg[SSH_ERRNO_MSG_MAX] = {0}; uint8_t tmpbuf[4];
uint8_t *payload = tmpbuf;
char err_msg[SSH_ERRNO_MSG_MAX] = {0};
len = ssh_buffer_get_len(request); len = ssh_buffer_get_len(request);
SSH_LOG(SSH_LOG_TRACE, "Request length: %" PRIu32, len); SSH_LOG(SSH_LOG_TRACE, "Request length: %" PRIu32, len);
PUSH_BE_U32(payload, 0, len); PUSH_BE_U32(payload, 0, len);
/* send length and then the request packet */ /* send length and then the request packet */
if (atomicio(session->agent, payload, 4, 0) == 4) { if (atomicio(session->agent, payload, 4, 0) == 4) {
if (atomicio(session->agent, ssh_buffer_get(request), len, 0) if (atomicio(session->agent, ssh_buffer_get(request), len, 0) != len) {
!= len) { SSH_LOG(SSH_LOG_TRACE,
SSH_LOG(SSH_LOG_TRACE, "atomicio sending request failed: %s", "atomicio sending request failed: %s",
strerror(errno)); ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
return -1; return -1;
}
} else {
SSH_LOG(SSH_LOG_TRACE,
"atomicio sending request length failed: %s",
ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
return -1;
} }
} else {
SSH_LOG(SSH_LOG_TRACE,
"atomicio sending request length failed: %s",
ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
return -1;
}
/* wait for response, read the length of the response packet */ /* wait for response, read the length of the response packet */
if (atomicio(session->agent, payload, 4, 1) != 4) { if (atomicio(session->agent, payload, 4, 1) != 4) {
SSH_LOG(SSH_LOG_TRACE, "atomicio read response length failed: %s", SSH_LOG(SSH_LOG_TRACE,
strerror(errno)); "atomicio read response length failed: %s",
return -1; ssh_strerror(errno, err_msg, SSH_ERRNO_MSG_MAX));
} return -1;
}
len = PULL_BE_U32(payload, 0); len = PULL_BE_U32(payload, 0);
if (len > 256 * 1024) { if (len > 256 * 1024) {
ssh_set_error(session, SSH_FATAL, ssh_set_error(session,
"Authentication response too long: %" PRIu32, len); SSH_FATAL,
return -1; "Authentication response too long: %" PRIu32,
} len);
SSH_LOG(SSH_LOG_TRACE, "Response length: %" PRIu32, len); return -1;
}
SSH_LOG(SSH_LOG_TRACE, "Response length: %" PRIu32, len);
payload = ssh_buffer_allocate(reply, len); payload = ssh_buffer_allocate(reply, len);
if (payload == NULL) { if (payload == NULL) {
SSH_LOG(SSH_LOG_DEBUG, "Not enough space"); SSH_LOG(SSH_LOG_DEBUG, "Not enough space");
return -1; return -1;
} }
if (atomicio(session->agent, payload, len, 1) != len) { if (atomicio(session->agent, payload, len, 1) != len) {
SSH_LOG(SSH_LOG_DEBUG, SSH_LOG(SSH_LOG_DEBUG,
"Error reading response from authentication socket."); "Error reading response from authentication socket.");
/* Rollback the unused space */ /* Rollback the unused space */
ssh_buffer_pass_bytes_end(reply, len); ssh_buffer_pass_bytes_end(reply, len);
return -1; return -1;
} }
return 0; return 0;
} }
uint32_t ssh_agent_get_ident_count(struct ssh_session_struct *session) uint32_t ssh_agent_get_ident_count(struct ssh_session_struct *session)
@@ -471,22 +496,23 @@ ssh_key ssh_agent_get_next_ident(struct ssh_session_struct *session,
return key; return key;
} }
int ssh_agent_is_running(ssh_session session) { int ssh_agent_is_running(ssh_session session)
if (session == NULL || session->agent == NULL) { {
return 0; if (session == NULL || session->agent == NULL) {
} return 0;
if (ssh_socket_is_open(session->agent->sock)) {
return 1;
} else {
if (agent_connect(session) < 0) {
return 0;
} else {
return 1;
} }
}
return 0; if (ssh_socket_is_open(session->agent->sock)) {
return 1;
} else {
if (agent_connect(session) < 0) {
return 0;
} else {
return 1;
}
}
return 0;
} }
ssh_string ssh_agent_sign_data(ssh_session session, ssh_string ssh_agent_sign_data(ssh_session session,