Boolean ssh_pgp_next_packet_type(SshFileBuffer *filebuf, int *type)
{
unsigned char type_id;
Boolean fr;
fr = ssh_file_buffer_expand(filebuf, 1);
if (fr == FALSE)
return FALSE;
type_id = *(ssh_buffer_ptr(&(filebuf->buf)));
if (type != NULL)
{
if (type_id & 0x40)
{
/* New packet header format */
*type = type_id & 0x7f;
}
else
{
/* Old packet format header */
*type = (type_id & 0x7c) >> 2;
}
}
return TRUE;
}
void test_functions(int foo, ...)
{
va_list va;
unsigned char *cp;
ssh_buffer_clear(buffer);
ssh_buffer_clear(buffer);
va_start(va, foo);
if (ssh_encode_buffer_va(buffer, va) != 2)
ssh_fatal("test_functions: ssh_encode_buffer_va error");
va_end(va);
if (memcmp(ssh_buffer_ptr(buffer), "\100\103", 2) != 0)
ssh_fatal("test_functions: ssh_encode_buffer_va data error");
va_start(va, foo);
if (ssh_encode_array_alloc_va(NULL, va) != 2)
ssh_fatal("test_function: ssh_encode_array_alloc_va NULL error");
va_end(va);
va_start(va, foo);
if (ssh_encode_array_alloc_va(&cp, va) != 2)
ssh_fatal("test_functions: ssh_encode_array_alloc_va error");
va_end(va);
if (memcmp(cp, "\100\103", 2) != 0)
ssh_fatal("test_functions: ssh_encode_array_alloc_va data error");
ssh_xfree(cp);
}
void server1_read(SshStream stream)
{
int ret;
unsigned char buf[1024];
for (;;)
{
ret = ssh_stream_read(stream, buf, sizeof(buf));
if (ret < 0)
return;
if (ret == 0)
{
if (read_count != send_count)
ssh_fatal("server1_read eof received, read_count %ld send_count %ld",
read_count, send_count);
break;
}
if (memcmp(buf, ssh_buffer_ptr(&expect_buffer), ret) != 0)
ssh_fatal("server1_read data does not match");
ssh_buffer_consume(&expect_buffer, ret);
read_count += ret;
}
/* All data has been received. */
ssh_stream_destroy(stream);
exited1 = 1;
}
void encode_case(const char *name, const char *expect,
size_t expect_len, ...)
{
size_t len, i, bytes;
unsigned char ch, *cp;
va_list va;
ssh_buffer_clear(buffer);
len = rand() % 100;
ch = rand();
for (i = 0; i < len; i++)
ssh_buffer_append(buffer, &ch, 1);
va_start(va, expect_len);
bytes = ssh_encode_buffer_va(buffer, va);
if (bytes != expect_len || ssh_buffer_len(buffer) != len + expect_len)
ssh_fatal("test_encode: %s: unexpected length %d vs. %d",
name, bytes, len + expect_len);
cp = ssh_buffer_ptr(buffer);
if (memcmp(expect, cp + len, expect_len) != 0)
ssh_fatal("test_encode: %s: mismatch", name);
for (i = 0; i < len; i++)
if (cp[i] != ch)
ssh_fatal("test_encode: %s: beginning corrupted", name);
ssh_buffer_consume(buffer, len);
}
Boolean handler_output_outgoing(Handler c)
{
int len;
#ifdef DEBUG
ssh_debug("handler_output_outgoing");
#endif
#ifdef DUMP_PACKETS
buffer_dump(&c->outgoing);
#endif
while (ssh_buffer_len(&c->outgoing) > 0)
{
len = ssh_buffer_len(&c->outgoing);
len = ssh_stream_write(c->stream, ssh_buffer_ptr(&c->outgoing), len);
if (len == 0)
ssh_fatal("%s: handler_output: error writing to stream", c->side);
if (len < 0)
return FALSE;
ssh_buffer_consume(&c->outgoing, len);
}
if (c->outgoing_eof)
ssh_stream_output_eof(c->stream);
return TRUE;
}
static void
ssh_eap_md5_client_recv_msg(SshEapProtocol protocol,
SshEap eap,
SshBuffer buf)
{
SshEapMd5State state;
unsigned char *ucp = NULL;
state = ssh_eap_protocol_get_state(protocol);
if (state == NULL)
{
ssh_eap_discard_packet(eap, protocol, buf,
"EAP MD5 state uninitialized");
return;
}
if (state->challenge_buffer != NULL)
{
ssh_free(state->challenge_buffer);
state->challenge_buffer = NULL;
}
ucp = ssh_buffer_ptr(buf);
if (ucp == NULL || (ssh_buffer_len(buf) < 6))
{
ssh_eap_discard_packet(eap, protocol, buf,
"packet length incorrect for EAP MD5 packet");
return;
}
state->challenge_length = ucp[5];
/* Note that RFC 1994 requires the challenge to be at least one octet */
if (state->challenge_length == 0
|| (state->challenge_length + 6) > ssh_buffer_len(buf))
{
ssh_eap_discard_packet(eap, protocol, buf,
"EAP MD5 incorrect challenge length");
return;
}
state->challenge_buffer = ssh_malloc(state->challenge_length);
if (state->challenge_buffer == NULL)
{
ssh_eap_fatal(eap, protocol,
"Could not allocate buffer for challenge");
return;
}
memcpy(state->challenge_buffer, ucp + 6, state->challenge_length);
state->response_id = ssh_eap_packet_get_identifier(buf);
ssh_eap_protocol_request_token(eap, protocol->impl->id,
SSH_EAP_TOKEN_SHARED_SECRET);
}
/*
* Parse reply method. This doesn't do anything with SOCKS4.
*/
SocksError ssh_socks_client_parse_method(SshBuffer buffer,
SocksInfo *socksinfo)
{
size_t ret = 0L, len;
unsigned int version, method;
unsigned char *data;
data = ssh_buffer_ptr(buffer);
len = ssh_buffer_len(buffer);
if (len < 1)
return SSH_SOCKS_TRY_AGAIN;
version = *data;
if (version == 0)
version = 4;
if (version == 4)
return SSH_SOCKS_SUCCESS;
if (len < 2)
return SSH_SOCKS_TRY_AGAIN;
ret = ssh_decode_buffer(buffer,
SSH_DECODE_CHAR(&version),
SSH_DECODE_CHAR(&method),
SSH_FORMAT_END);
if (ret == 0)
{
SSH_DEBUG(2, ("Decoding method buffer failed."));
return SSH_SOCKS_ERROR_PROTOCOL_ERROR;
}
if (method != SSH_SOCKS5_AUTH_METHOD_NO_AUTH_REQD)
{
SSH_DEBUG(2, ("Server sent method 0x%x.", method));
if (method == SSH_SOCKS5_AUTH_METHOD_NO_ACCEPTABLE)
{
SSH_DEBUG(2, ("Server doesn't allow use without some authentication "
"(we don't implement any methods)."));
}
else
{
SSH_DEBUG(2, ("Server sent method that we don't support."));
return SSH_SOCKS_ERROR_PROTOCOL_ERROR;
}
return SSH_SOCKS_FAILED_AUTH;
}
if (socksinfo)
{
*socksinfo = ssh_calloc(1, sizeof(**socksinfo));
if (*socksinfo == NULL)
{
SSH_DEBUG(2, ("Couldn't allocate SshSocksInfo."));
return SSH_SOCKS_ERROR_INVALID_ARGUMENT;
}
(*socksinfo)->socks_version_number = version;
}
return SSH_SOCKS_SUCCESS;
}
void
t_sim_token_handler(SshEap eap,
SshUInt8 type,
SshBuffer buf,
SshEapToken token,
void *context)
{
SshEapToken tinput;
SshEapTokenType token_type;
SshUInt8 sim_buffer[1024];
int sim_len = 0;
SSH_ASSERT(buf != NULL);
tinput = (SshEapToken)ssh_buffer_ptr(buf);
token_type = ssh_eap_get_token_type_from_buf(buf);
switch (token_type)
{
case SSH_EAP_TOKEN_USERNAME:
ssh_eap_init_token_username(token,
user_buf,
user_len);
break;
case SSH_EAP_TOKEN_SIM_CHALLENGE:
sim_len = eap_read_sim_files(SSH_EAP_TYPE_SIM,
tinput->token.buffer.dptr,
tinput->token.buffer.len,
sim_buffer,
sizeof(sim_buffer));
/* Is there an error reading the file containing
the keys for this SIM authentication thingy. */
if (sim_len == -1)
{
SSH_DEBUG(SSH_D_ERROR, ("Could not read SIM keys. Please"
" re-check the existence of the "
"key file."));
token_type = SSH_EAP_TOKEN_NONE;
break;
}
token->token.buffer.dptr = sim_buffer;
token->token.buffer.len = sim_len;
token->type = SSH_EAP_TOKEN_SIM_CHALLENGE;
break;
default:
token_type = SSH_EAP_TOKEN_NONE;
break;
}
if (token_type != SSH_EAP_TOKEN_NONE)
ssh_eap_token(eap, type, token);
return;
}
static int
cm_debug_renderer_return(SshBuffer buffer, unsigned char *buf, int len)
{
int l = ssh_buffer_len(buffer);
if (l > len)
{
ssh_ustrncpy(buf, ssh_buffer_ptr(buffer), len - 1);
ssh_buffer_uninit(buffer);
return len + 1;
}
else
{
ssh_ustrncpy(buf, ssh_buffer_ptr(buffer), l);
ssh_buffer_uninit(buffer);
return l;
}
}
Boolean
ssh2_key_blob_encode(unsigned long magic,
const char *subject, const char *comment,
const unsigned char *key, size_t keylen,
unsigned char **encoded, size_t *encoded_len)
{
SshBufferStruct buffer;
char *base64;
unsigned int key_index;
/* Translate to index. */
switch (magic)
{
case SSH_KEY_MAGIC_PUBLIC: key_index = 0; break;
case SSH_KEY_MAGIC_PRIVATE: key_index = 1; break;
case SSH_KEY_MAGIC_PRIVATE_ENCRYPTED: key_index = 2; break;
default: return FALSE;
}
ssh_buffer_init(&buffer);
/* Add the head for the key. */
ssh_key_blob_dump_line_str(&buffer,
ssh2_pk_format_name_list[key_index].head);
ssh_key_blob_dump_lf(&buffer);
/* Handle key words. */
if (subject)
{
ssh_key_blob_dump_line_str(&buffer, "Subject: ");
ssh_key_blob_dump_line_str(&buffer, subject);
ssh_key_blob_dump_lf(&buffer);
}
if (comment)
{
ssh_key_blob_dump_line_str(&buffer, "Comment: ");
ssh_key_blob_dump_quoted_str(&buffer, 9, comment);
ssh_key_blob_dump_lf(&buffer);
}
/* Now add the base64 formatted stuff. */
base64 = (char *)ssh_buf_to_base64(key, keylen);
ssh_key_blob_dump_str(&buffer, base64);
ssh_key_blob_dump_lf(&buffer);
ssh_xfree(base64);
/* Add the tail for the key. */
ssh_key_blob_dump_line_str(&buffer,
ssh2_pk_format_name_list[key_index].tail);
ssh_key_blob_dump_lf(&buffer);
*encoded_len = ssh_buffer_len(&buffer);
*encoded = ssh_xmemdup(ssh_buffer_ptr(&buffer), ssh_buffer_len(&buffer));
ssh_buffer_uninit(&buffer);
return TRUE;
}
void test_functions_parse_compound(SshBuffer buffer, ...)
{
va_list va;
va_start(va, buffer);
if (ssh_decode_array_va(ssh_buffer_ptr(buffer), ssh_buffer_len(buffer), va)
!= 4)
ssh_fatal("test_functions_parse_compound error");
}
/*
* Inserts specified event into log file specified in context.
* event parameter specifies the audited event. Each element after event
* must start with a SshAuditformat type followed by arguments of the
* appropriate type, and the list must end with SSH_AUDIT_ARGUMENT_END.
*/
void ssh_audit_event(SshAuditContext context, SshAuditEvent event, ...)
{
size_t bytes;
va_list ap;
SshBuffer *audit_info, *formated_str;
char *audit_time;
if (context == NULL) return;
if ((event < 0) || (event > SSH_AUDIT_MAX_VALUE)) return;
/* Check if given event is allowed */
if (!context->ssh_audit_event_allowed[(int)event]) return;
/* Initialize a buffer for output string */
audit_info = ssh_buffer_allocate();
/* Start constructing string which will be inserted into audit log.*/
/* Start with inserting the name of the event.*/
/* then date and time */
audit_time = ssh_time_string(ssh_time());
ssh_buffer_append_cstrs(audit_info,
ssh_find_keyword_name(ssh_audit_event_title,
(int)event),
": ", audit_time, ": ",
NULL);
ssh_xfree(audit_time);
/* Handle the variable list*/
va_start(ap, event);
formated_str = ssh_format_audit_string(ap);
va_end(ap);
/* Insert given parameters into string*/
ssh_buffer_append(audit_info,
ssh_buffer_ptr(formated_str),
ssh_buffer_len(formated_str));
ssh_buffer_append(audit_info, (unsigned char *) "\0", 1);
/* Output the log message*/
ssh_send_log_message(context, ssh_buffer_ptr(audit_info));
ssh_buffer_free(formated_str);
ssh_buffer_free(audit_info);
}
void
t_aka_token_handler(SshEap eap,
SshUInt8 type,
SshBuffer buf,
SshEapToken token,
void *context)
{
SshEapTokenType token_type;
SshEapToken tinput;
SshUInt8 aka_buffer[1024];
int aka_len = 0;
SSH_ASSERT(buf != NULL);
token_type = ssh_eap_get_token_type_from_buf(buf);
tinput = (SshEapToken)ssh_buffer_ptr(buf);
switch (token_type)
{
case SSH_EAP_TOKEN_USERNAME:
ssh_eap_init_token_username(token,
user_buf,
user_len);
break;
case SSH_EAP_TOKEN_AKA_CHALLENGE:
aka_len = eap_read_sim_files(SSH_EAP_TYPE_AKA,
tinput->token.buffer.dptr,
tinput->token.buffer.len,
aka_buffer,
sizeof(aka_buffer));
/* Auth failed? Can be noted from the length. */
if (aka_len == 16)
token->type = SSH_EAP_TOKEN_AKA_SYNCH_REQ;
else if (aka_len > 16)
token->type = SSH_EAP_TOKEN_AKA_CHALLENGE;
else if (aka_len < 0)
token->type = SSH_EAP_TOKEN_AKA_AUTH_REJECT;
else
return;
token->token.buffer.dptr = aka_buffer;
token->token.buffer.len = aka_len;
break;
default:
token_type = SSH_EAP_TOKEN_NONE;
break;
}
if (token_type != SSH_EAP_TOKEN_NONE)
ssh_eap_token(eap, type, token);
return;
}
static int
ssh_appgw_http_unmarshal_int(SshBuffer buf, int *result)
{
if (ssh_buffer_len(buf) < 4)
{
*result = 0;
return 0;
}
*result = (int)(SSH_GET_32BIT(ssh_buffer_ptr(buf)));
ssh_buffer_consume(buf,4);
return 1;
}
static void
ssh_eap_md5_server_recv_msg(SshEapProtocol protocol,
SshEap eap,
SshBuffer buf)
{
SshEapMd5State state;
unsigned char *ucp = NULL;
state = ssh_eap_protocol_get_state(protocol);
if (state == NULL)
{
ssh_eap_discard_packet(eap, protocol, buf,
"eap md5 auth state not initialized");
return;
}
ucp = ssh_buffer_ptr(buf);
if (ucp == NULL || (ssh_buffer_len(buf) < 6))
{
ssh_eap_discard_packet(eap, protocol, buf,
"packet too short to be eap md5 response");
return;
}
state->response_length = ucp[5] & 0xFF;
if (state->response_length < 1
|| (state->response_length + 6) > ssh_buffer_len(buf))
{
ssh_eap_discard_packet(eap, protocol, buf,
"invalid ressponse value length");
return;
}
SSH_ASSERT(state->response_buffer == NULL);
state->response_buffer = ssh_malloc(state->response_length);
if (state->response_buffer == NULL)
{
ssh_eap_fatal(eap, protocol,
"Could not cache challenge response. Out of memory");
return;
}
memcpy(state->response_buffer, ucp + 6, state->response_length);
ssh_eap_protocol_request_token(eap, protocol->impl->id,
SSH_EAP_TOKEN_SHARED_SECRET);
}
void copy_writer(SshStreamNotification op, void *context)
{
int len;
int len2;
unsigned char buf[100];
if (op != SSH_STREAM_CAN_OUTPUT)
return;
for (;;)
{
len = ssh_buffer_len(testdata) - test_data_index;
len2 = ssh_rand() % 100000;
if (len <= 0)
{
if (ssh_rand() % 2 == 0)
ssh_stream_output_eof(ts1);
ssh_stream_destroy(ts1);
ts1 = NULL;
destroy_count++;
return;
}
if (len > len2)
len = len2;
len = ssh_stream_write(ts1, (unsigned char *)ssh_buffer_ptr(testdata) +
test_data_index, len);
if (len == 0)
{
if (ssh_rand() % 2 == 0)
ssh_stream_output_eof(ts1);
ssh_stream_destroy(ts1);
ts1 = NULL;
destroy_count++;
return; /* Eof while writing. */
}
if (len < 0)
return; /* Cannot write more at this time */
test_data_index += len;
if (ssh_rand() % 5 == 0)
{
len = ssh_stream_read(ts1, buf, sizeof(buf));
if (len == 0 && !reader_sent_eof)
ssh_fatal("copy_writer: read returned EOF when not sent");
if (len > 0)
ssh_fatal("copy_writer: read > 0");
}
}
}
/*
* Parse methods array. This doesn't do anything with SOCKS4.
*/
SocksError ssh_socks_server_parse_methods(SshBuffer buffer,
SocksInfo *socksinfo)
{
size_t ret = 0L, len;
unsigned int version, num_methods;
unsigned char *data;
data = ssh_buffer_ptr(buffer);
len = ssh_buffer_len(buffer);
if (len < 1)
return SSH_SOCKS_TRY_AGAIN;
version = *data;
if (version == 4)
goto return_success;
if (len < 2)
return SSH_SOCKS_TRY_AGAIN;
ret = ssh_decode_array(data, len,
SSH_DECODE_CHAR(&version),
SSH_DECODE_CHAR(&num_methods),
SSH_FORMAT_END);
if (ret == 0)
{
SSH_DEBUG(2, ("Decoding methods buffer failed."));
return SSH_SOCKS_ERROR_PROTOCOL_ERROR;
}
if (len < num_methods + 2)
return SSH_SOCKS_TRY_AGAIN;
ssh_buffer_consume(buffer, num_methods + 2);
return_success:
if (socksinfo)
{
*socksinfo = ssh_calloc(1, sizeof(**socksinfo));
if (*socksinfo == NULL)
{
SSH_DEBUG(2, ("Couldn't allocate SshSocksInfo."));
return SSH_SOCKS_ERROR_INVALID_ARGUMENT;
}
(*socksinfo)->socks_version_number = version;
}
return SSH_SOCKS_SUCCESS;
}
/* Handle the parsing of the single line string. */
static size_t
ssh_key_blob_get_line(const unsigned char *buf, size_t len,
char **string)
{
size_t i, step, keep;
SshBufferStruct buffer;
ssh_buffer_init(&buffer);
for (i = 0, step = 0, keep = 0; i < len; i++)
{
switch (buf[i])
{
case '\n':
/* End. */
step = i;
goto end;
case ' ':
case '\t':
case '\r':
if (ssh_buffer_len(&buffer) == 0)
{
keep = 0;
break;
}
keep = 1;
break;
default:
if (keep)
{
ssh_xbuffer_append(&buffer, (const unsigned char *)" ", 1);
keep = 0;
}
ssh_xbuffer_append(&buffer, &buf[i], 1);
break;
}
}
end:
/* Make a string. */
*string = ssh_xmalloc(ssh_buffer_len(&buffer) + 1);
memcpy(*string, ssh_buffer_ptr(&buffer), ssh_buffer_len(&buffer));
(*string)[ssh_buffer_len(&buffer)] = '\0';
ssh_buffer_uninit(&buffer);
return step;
}
void decode_case_bool(SshEncodingFormat fmt, Boolean value)
{
Boolean boo;
size_t bytes;
bytes = ssh_buffer_len(buffer);
if (bytes != ssh_decode_array(ssh_buffer_ptr(buffer), ssh_buffer_len(buffer),
fmt, NULL, SSH_FORMAT_END))
ssh_fatal("decode_case_bool: NULL decode bad len");
if (bytes != ssh_decode_buffer(buffer, fmt, &boo, SSH_FORMAT_END))
ssh_fatal("decode_case_bool: bad returned len");
if (boo != value)
ssh_fatal("decode_case_bool: bad value");
if (ssh_buffer_len(buffer) > 0)
ssh_fatal("decode_case_bool: data left");
}
void connect1_write(SshStream stream)
{
int len;
while (ssh_buffer_len(&send_buffer) > 0)
{
len = ssh_buffer_len(&send_buffer);
len = ssh_stream_write(stream, ssh_buffer_ptr(&send_buffer), len);
if (len < 0)
return;
if (len == 0)
ssh_fatal("connect1_write failed");
ssh_buffer_consume(&send_buffer, len);
}
ssh_stream_output_eof(stream);
ssh_stream_destroy(stream);
}
void decode_case_char(SshEncodingFormat fmt, unsigned char value)
{
unsigned int ch;
size_t bytes;
bytes = ssh_buffer_len(buffer);
if (bytes != ssh_decode_array(ssh_buffer_ptr(buffer), ssh_buffer_len(buffer),
fmt, NULL, SSH_FORMAT_END))
ssh_fatal("decode_case_char: NULL decode bad len");
if (bytes != ssh_decode_buffer(buffer, fmt, &ch, SSH_FORMAT_END))
ssh_fatal("decode_case_char: bad returned len");
if (ch != value)
ssh_fatal("decode_case_char: bad value");
if (ssh_buffer_len(buffer) > 0)
ssh_fatal("decode_case_char: data left");
}
SshBuffer *handler_input_expect_packet(Handler c, unsigned int expect_type)
{
SshBuffer *packet;
const unsigned char *cp;
unsigned int packet_type;
packet = handler_input_expect_cross(c, SSH_CROSS_PACKET);
if (!packet)
return NULL;
cp = ssh_buffer_ptr(packet);
packet_type = buffer_get_char(packet);
if (packet_type != expect_type)
ssh_fatal("%s: handler_input_expect_packet: got %d expected %d",
c->side, packet_type, expect_type);
return packet;
}
SshBuffer *handler_input_expect_cross(Handler c, unsigned int expect_type)
{
SshBuffer *packet;
const unsigned char *cp;
unsigned int packet_type;
packet = handler_input_cross(c);
if (!packet)
return NULL;
cp = ssh_buffer_ptr(packet);
packet_type = (unsigned int) cp[4];
if (packet_type != expect_type)
ssh_fatal("%s: handler_input_expect_cross: got %d expected %d",
c->side, packet_type, expect_type);
/* Remove cross-layer header and return the payload. */
ssh_buffer_consume(packet, 5);
return packet;
}
void decode_case_data(SshEncodingFormat fmt,
const char *value, size_t valuelen)
{
char buf[1024];
size_t bytes;
SSH_ASSERT(valuelen < sizeof(buf));
bytes = ssh_buffer_len(buffer);
if (bytes != ssh_decode_array(ssh_buffer_ptr(buffer), ssh_buffer_len(buffer),
fmt, NULL, valuelen, SSH_FORMAT_END))
ssh_fatal("decode_case_data: NULL decode bad len");
if (bytes != ssh_decode_buffer(buffer, fmt, buf, valuelen,
SSH_FORMAT_END))
ssh_fatal("decode_case_data: bad returned len");
if (memcmp(buf, value, valuelen) != 0)
ssh_fatal("decode_case_data: bad value");
if (ssh_buffer_len(buffer) > 0)
ssh_fatal("decode_case_data: data left");
}
void decode_case_str(SshEncodingFormat fmt, const char *value, size_t valuelen)
{
unsigned char *cp;
size_t len, bytes;
bytes = ssh_buffer_len(buffer);
if (bytes != ssh_decode_array(ssh_buffer_ptr(buffer), ssh_buffer_len(buffer),
fmt, NULL, NULL, SSH_FORMAT_END))
ssh_fatal("decode_case_str: NULL decode bad len");
if (bytes != ssh_decode_buffer(buffer, fmt, &cp, &len, SSH_FORMAT_END))
ssh_fatal("decode_case_str: bad returned len");
if (len != valuelen || memcmp(cp, value, len) != 0)
ssh_fatal("decode_case_str: bad cmp");
if (ssh_buffer_len(buffer) > 0)
ssh_fatal("decode_case_str: data left");
if (cp[len] != 0)
ssh_fatal("decode_case_str: not null terminated");
ssh_xfree(cp);
}
void
ssh_eap_get_token_data_from_buf(SshBuffer buf, void **data, size_t *data_len)
{
SshEapToken t;
*data = NULL;
*data_len = 0;
if (buf == NULL || ssh_buffer_len(buf) != sizeof(*t))
return;
t = (SshEapToken)ssh_buffer_ptr(buf);
if (t != NULL)
{
*data = t->token.buffer.dptr;
*data_len = (size_t)t->token.buffer.len;
}
}
SshEapTokenType
ssh_eap_get_token_type_from_buf(SshBuffer buf)
{
SshEapToken t;
if (buf == NULL)
{
return SSH_EAP_TOKEN_NONE;
}
if (ssh_buffer_len(buf) != sizeof(*t))
{
return SSH_EAP_TOKEN_NONE;
}
t = (SshEapToken)ssh_buffer_ptr(buf);
return (t != NULL) ? t->type : SSH_EAP_TOKEN_NONE;
}
void ssh_packet_impl_send_encode_va(SshStream up_stream,
SshPacketType type,
va_list va)
{
SshPacketImpl up;
/* Verify that it is a SshPacketImpl stream. */
if (ssh_stream_get_methods(up_stream) != &ssh_packet_impl_methods)
ssh_fatal("ssh_packet_impl_can_receive: not a SshPacketImpl stream");
/* Get the internal context. */
up = (SshPacketImpl)ssh_stream_get_context(up_stream);
/* Format the packet in a separate buffer. */
ssh_buffer_clear(&up->outgoing_packet);
ssh_packet_encode_va(&up->outgoing_packet, type, va);
/* Check that we don't overflow maximum buffer size. Drop the
packet if we would. */
if (ssh_buffer_len(&up->outgoing) + ssh_buffer_len(&up->outgoing_packet) >=
BUFFER_MAX_SIZE)
{
ssh_debug("ssh_packet_impl_send_encode_va: "
"flow control problems; outgoing packet dropped.");
return;
}
/* Append the packet to the outgoing buffer. */
if (ssh_buffer_append(&up->outgoing,
ssh_buffer_ptr(&up->outgoing_packet),
ssh_buffer_len(&up->outgoing_packet)) != SSH_BUFFER_OK)
{
return;
}
/* Restart reads by upper level. */
ssh_packet_impl_restart_input(up);
/* Sanity check that we didn't exceed max buffer size. */
if (ssh_buffer_len(&up->outgoing) > BUFFER_MAX_SIZE)
ssh_debug("ssh_packet_impl_send: buffer max size exceeded: size %ld",
(long)ssh_buffer_len(&up->outgoing));
}
void ssh_channel_start_remote_tcp_forward(SshCommon common,
const char *address_to_bind,
const char *port,
const char *connect_to_host,
const char *connect_to_port,
void (*completion)(Boolean ok,
void *context),
void *context)
{
SshRemoteTcpForward fwd;
SshBuffer buffer;
SshChannelTypeTcpForward ct;
SSH_DEBUG(5, ("requesting remote forwarding for port %s", port));
ct = ssh_channel_ftcp_ct(common);
/* Create a context for the forwarding. */
fwd = ssh_xcalloc(1, sizeof(*fwd));
fwd->common = common;
fwd->address_to_bind = ssh_xstrdup(address_to_bind);
fwd->port = ssh_xstrdup(port);
fwd->connect_to_host = ssh_xstrdup(connect_to_host);
fwd->connect_to_port = ssh_xstrdup(connect_to_port);
/* Add it to the list of remote forwardings. */
fwd->next = ct->remote_forwards;
ct->remote_forwards = fwd;
/* Send a forwarding request to the remote side. */
ssh_buffer_init(&buffer);
ssh_encode_buffer(&buffer,
SSH_FORMAT_UINT32_STR,
address_to_bind, strlen(address_to_bind),
SSH_FORMAT_UINT32, (SshUInt32) atol(port),
SSH_FORMAT_END);
ssh_conn_send_global_request(common->conn, "tcpip-forward",
ssh_buffer_ptr(&buffer), ssh_buffer_len(&buffer),
completion, context);
ssh_buffer_uninit(&buffer);
}
void
ssh_eap_build_and_send_reply_buf(SshEap eap,
SshUInt8 type,
const SshBuffer buf)
{
SshUInt8 *ptr;
SshUInt16 len;
if (buf == NULL)
{
len = 0;
ptr = NULL;
}
else
{
len = (SshUInt16)ssh_buffer_len(buf);
ptr = (len == 0 ? NULL : ssh_buffer_ptr(buf));
}
ssh_eap_build_and_send_reply(eap,type, ptr, len);
}
