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); }