static void
remmina_ssh_tunnel_close_all_channels (RemminaSSHTunnel *tunnel)
{
int i;
for (i = 0; i < tunnel->num_channels; i++)
{
close (tunnel->sockets[i]);
remmina_ssh_tunnel_buffer_free (tunnel->socketbuffers[i]);
channel_close (tunnel->channels[i]);
channel_free (tunnel->channels[i]);
}
g_free(tunnel->channels);
tunnel->channels = NULL;
g_free(tunnel->sockets);
tunnel->sockets = NULL;
g_free(tunnel->socketbuffers);
tunnel->socketbuffers = NULL;
tunnel->num_channels = 0;
tunnel->max_channels = 0;
if (tunnel->x11_channel)
{
channel_close (tunnel->x11_channel);
channel_free (tunnel->x11_channel);
tunnel->x11_channel = NULL;
}
}
void
test_body (void)
{
const gchar chunk[] = "This is a body text.";
const gchar *packet;
gsize packet_size;
gsize packed_size;
test_end_of_header();
channel_free();
reply_continue();
cut_assert_true(milter_server_context_body(context, chunk, strlen(chunk)));
pump_all_events();
milter_test_assert_state(BODY);
milter_test_assert_status(NOT_CHANGE);
milter_command_encoder_encode_body(encoder, &packet, &packet_size,
chunk, strlen(chunk), &packed_size);
milter_test_assert_packet(channel, packet, packet_size);
cut_assert_equal_uint(strlen(chunk), packed_size);
cut_assert_equal_uint(0, n_message_processed);
}
void
test_header (void)
{
const gchar name[] = "X-HEADER-NAME";
const gchar value[] = "MilterServerContext test";
const gchar *packet;
gsize packet_size;
test_data();
channel_free();
reply_continue();
cut_assert_true(milter_server_context_header(context, name, value));
pump_all_events();
milter_test_assert_state(HEADER);
milter_test_assert_status(NOT_CHANGE);
milter_command_encoder_encode_header(encoder,
&packet, &packet_size,
name, value);
milter_test_assert_packet(channel, packet, packet_size);
cut_assert_equal_uint(0, n_message_processed);
}
void
test_ofp_table_stats_reply_create_null(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct channel *channel = channel_alloc_ip4addr("127.0.0.1", "1000", 0x01);
struct pbuf_list *pbuf_list = NULL;
struct ofp_header xid_header;
ret = ofp_table_stats_reply_create(NULL, &pbuf_list, &tstats_list,
&xid_header);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (channel)");
ret = ofp_table_stats_reply_create(channel, NULL, &tstats_list,
&xid_header);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (pbuf)");
ret = ofp_table_stats_reply_create(channel, &pbuf_list, NULL, &xid_header);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (ofp_table_stats_list)");
ret = ofp_table_stats_reply_create(channel, &pbuf_list, &tstats_list,
NULL);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (xid_header)");
channel_free(channel);
}
void
test_quit (void)
{
const gchar *packet;
gsize packet_size;
test_end_of_message_without_chunk();
channel_free();
reply_continue();
cut_assert_true(milter_server_context_quit(context));
pump_all_events();
milter_test_assert_state(QUIT);
milter_test_assert_status(NOT_CHANGE);
milter_command_encoder_encode_quit(encoder, &packet, &packet_size);
milter_test_assert_packet(channel, packet, packet_size);
cut_assert_equal_uint(1, n_message_processed);
milter_test_assert_result("*****@*****.**",
RECIPIENTS("*****@*****.**", NULL),
HEADERS("X-HEADER-NAME",
"MilterServerContext test",
NULL),
20,
STATE(END_OF_MESSAGE_REPLIED),
STATUS(NOT_CHANGE),
HEADERS(NULL),
HEADERS(NULL),
FALSE);
}
void
test_ofp_queue_get_config_handle_null(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct channel *channel = channel_alloc_ip4addr("127.0.0.1", "1000", 0x01);
struct pbuf *pbuf = pbuf_alloc(65535);
struct ofp_header ofp_header;
struct ofp_error error;
ret = ofp_queue_get_config_request_handle(NULL, pbuf, &ofp_header, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (channel)");
ret = ofp_queue_get_config_request_handle(channel, NULL, &ofp_header, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (pbuf)");
ret = ofp_queue_get_config_request_handle(channel, pbuf, NULL, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (ofp_header)");
ret = ofp_queue_get_config_request_handle(channel, pbuf, &ofp_header, NULL);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (ofp_error)");
channel_free(channel);
pbuf_free(pbuf);
}
static Channel *
server_request_session(void)
{
Channel *c;
debug("input_session_request");
packet_check_eom();
if (no_more_sessions) {
packet_disconnect("Possible attack: attempt to open a session "
"after additional sessions disabled");
}
/*
* A server session has no fd to read or write until a
* CHANNEL_REQUEST for a shell is made, so we set the type to
* SSH_CHANNEL_LARVAL. Additionally, a callback for handling all
* CHANNEL_REQUEST messages is registered.
*/
c = channel_new("session", SSH_CHANNEL_LARVAL,
-1, -1, -1, /*window size*/0, CHAN_SES_PACKET_DEFAULT,
0, "server-session", 1);
if (session_open(the_authctxt, c->self) != 1) {
debug("session open failed, free channel %d", c->self);
channel_free(c);
return NULL;
}
channel_register_cleanup(c->self, session_close_by_channel, 0);
return c;
}
void
test_ofp_barrier_reply_create_null(void) {
lagopus_result_t ret;
struct barrier barrier;
struct event_manager *em = event_manager_alloc();
struct channel *channel =
channel_alloc_ip4addr("127.0.0.1", "1000", em, 0x01);
struct pbuf *pbuf;
ret = ofp_barrier_reply_create(NULL, &barrier,
&pbuf);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_INVALID_ARGS,
"ofp_barrier_reply_create error.");
ret = ofp_barrier_reply_create(channel, NULL,
&pbuf);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_INVALID_ARGS,
"ofp_barrier_reply_create error.");
ret = ofp_barrier_reply_create(channel, &barrier,
NULL);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_INVALID_ARGS,
"ofp_barrier_reply_create error.");
/* after. */
channel_free(channel);
event_manager_free(em);
}
void
test_ofp_role_request_handle_with_null_agument(void) {
/* Case of invlid argument.*/
struct channel *channel =
channel_alloc_ip4addr("127.0.0.1", "1000", 0x01);
struct pbuf pbuf;
struct ofp_header xid_header;
lagopus_result_t ret;
struct ofp_error error;
/* struct ofp_error error; */
ret = ofp_role_request_handle(NULL, &pbuf, &xid_header, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL should be treated as invalid arguments");
ret = ofp_role_request_handle(channel, NULL, &xid_header, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL should be treated as invalid arguments");
ret = ofp_role_request_handle(channel, &pbuf, NULL, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL should be treated as invalid arguments");
ret = ofp_role_request_handle(channel, &pbuf, &xid_header, NULL);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL should be treated as invalid arguments");
channel_free(channel);
}
void
test_ofp_get_async_request_handle_invalid_argument(void) {
/* Case of invalid argument.*/
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct event_manager *em = event_manager_alloc();
struct channel *channel = channel_alloc_ip4addr("127.0.0.1", "1000",
em, 0x01);
struct pbuf *pbuf = pbuf_alloc(65535);
struct ofp_header xid_header;
struct ofp_error ignored_error = {0, 0, {NULL}};
ret = ofp_get_async_request_handle(NULL, pbuf, &xid_header, &ignored_error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL checking is requred.");
ret = ofp_get_async_request_handle(channel, NULL, &xid_header,
&ignored_error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL checking is requred.");
ret = ofp_get_async_request_handle(channel, pbuf, NULL, &ignored_error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL checking is requred.");
ret = ofp_get_async_request_handle(channel, pbuf, &xid_header, NULL);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL checking is requred.");
channel_free(channel);
pbuf_free(pbuf);
event_manager_free(em);
}
static Channel *
server_request_session(struct ssh *ssh)
{
Channel *c;
int r;
debug("input_session_request");
if ((r = sshpkt_get_end(ssh)) != 0)
fatal("%s: %s", __func__, ssh_err(r));
if (no_more_sessions) {
ssh_packet_disconnect(ssh,
"Possible attack: attempt to open a session "
"after additional sessions disabled");
}
/*
* A server session has no fd to read or write until a
* CHANNEL_REQUEST for a shell is made, so we set the type to
* SSH_CHANNEL_LARVAL. Additionally, a callback for handling all
* CHANNEL_REQUEST messages is registered.
*/
c = channel_new(ssh, "session", SSH_CHANNEL_LARVAL,
-1, -1, -1, /*window size*/0, CHAN_SES_PACKET_DEFAULT,
0, "server-session", 1);
if (session_open(ssh, c->self) != 1) {
debug("session open failed, free channel %d", c->self);
channel_free(c);
return NULL;
}
channel_register_cleanup(c->self, session_close_by_channel, 0);
return c;
}
void
test_ofp_group_mod_handle_wrap_null(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct event_manager *em = event_manager_alloc();
struct channel *channel = channel_alloc_ip4addr("127.0.0.1", "1000",
em, 0x01);
struct pbuf *pbuf = pbuf_alloc(65535);
struct ofp_header xid_header;
struct ofp_error error;
ret = ofp_group_mod_handle(NULL, pbuf, &xid_header, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (channel)");
ret = ofp_group_mod_handle(channel, NULL, &xid_header, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (pbuf)");
ret = ofp_group_mod_handle(channel, pbuf, NULL, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (xid_header)");
ret = ofp_group_mod_handle(channel, pbuf, &xid_header, NULL);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (xid_header)");
channel_free(channel);
pbuf_free(pbuf);
event_manager_free(em);
}
void
test_ofp_role_reply_create_with_null_agument(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct channel *channel =
channel_alloc_ip4addr("127.0.0.1", "1000", 0x01);
struct pbuf *pbuf;
struct ofp_header xid_header;
struct ofp_role_request role_request;
role_request.role = OFPCR_ROLE_SLAVE;
role_request.generation_id = 0x01;
/* TODO add error as a 4th argument */
/* struct ofp_error error; */
ret = ofp_role_reply_create(NULL, &pbuf, &xid_header, &role_request);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL should be treated as invalid arguments");
ret = ofp_role_reply_create(channel, NULL, &xid_header, &role_request);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL should be treated as invalid arguments");
ret = ofp_role_reply_create(channel, &pbuf, NULL, &role_request);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL should be treated as invalid arguments");
channel_free(channel);
}
void
test_ofp_queue_get_config_reply_create_null(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct channel *channel = channel_alloc_ip4addr("127.0.0.1", "1000", 0x01);
struct pbuf *pbuf = pbuf_alloc(65535);
static struct packet_queue_list packet_queue_list;
struct ofp_header ofp_header;
ret = ofp_queue_get_config_reply_create(NULL, &pbuf, 0,
&packet_queue_list,
&ofp_header);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (channel)");
ret = ofp_queue_get_config_reply_create(channel, NULL, 0,
&packet_queue_list,
&ofp_header);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (pbuf)");
ret = ofp_queue_get_config_reply_create(channel, &pbuf, 0,
NULL, &ofp_header);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (packet_queue_list)");
ret = ofp_queue_get_config_reply_create(channel, &pbuf, 0,
&packet_queue_list,
NULL);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"NULL-check error. (ofp_header)");
channel_free(channel);
pbuf_free(pbuf);
}
void
test_ofp_queue_stats_request_handle_null(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct pbuf *pbuf = pbuf_alloc(65535);
struct ofp_header xid_header;
struct ofp_error error;
struct channel *channel = channel_alloc_ip4addr("127.0.0.1", "1000", 0x01);
ret = ofp_queue_stats_request_handle(NULL, pbuf, &xid_header, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"ofp_queue_stats_request_handle error.");
ret = ofp_queue_stats_request_handle(channel, NULL, &xid_header, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"ofp_queue_stats_request_handle error.");
ret = ofp_queue_stats_request_handle(channel, pbuf, NULL, &error);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"ofp_queue_stats_request_handle error.");
ret = ofp_queue_stats_request_handle(channel, pbuf, &xid_header, NULL);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"ofp_queue_stats_request_handle error.");
/* after. */
channel_free(channel);
pbuf_free(pbuf);
}
void
test_abort_and_quit (void)
{
const gchar *packet;
gsize packet_size;
test_envelope_recipient();
channel_free();
cut_assert_true(milter_server_context_abort(context));
pump_all_events();
milter_test_assert_state(ABORT);
milter_test_assert_status(ABORT);
cut_assert_true(milter_server_context_quit(context));
pump_all_events();
milter_test_assert_state(QUIT);
milter_test_assert_status(ABORT);
milter_command_encoder_encode_abort(encoder, &packet, &packet_size);
packet_string = g_string_new_len(packet, packet_size);
milter_command_encoder_encode_quit(encoder, &packet, &packet_size);
g_string_append_len(packet_string, packet, packet_size);
milter_test_assert_packet(channel, packet_string->str, packet_string->len);
}
int ssh_scp_close(ssh_scp scp){
char buffer[128];
int err;
if(scp->channel != NULL){
if(channel_send_eof(scp->channel) == SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
/* avoid situations where data are buffered and
* not yet stored on disk. This can happen if the close is sent
* before we got the EOF back
*/
while(!channel_is_eof(scp->channel)){
err=channel_read(scp->channel,buffer,sizeof(buffer),0);
if(err==SSH_ERROR)
break;
}
if(channel_close(scp->channel) == SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
channel_free(scp->channel);
scp->channel=NULL;
}
scp->state=SSH_SCP_NEW;
return SSH_OK;
}
/** Remove channels from monitoring of the EventLoop.
*
* The EventLoop calls this function on its own when sockets have been released
* using eventloop_socket_release(). You probably want to use that one instead.
*
* \param source SockEvtSource to remove and free
* \see eventloop_socket_release, channel_free
*/
void eventloop_socket_remove(SockEvtSource* source)
{
Channel* ch = (Channel*)source;
eventloop_socket_activate(source, 0);
/* Update the linked list */
if (self.channels == ch) {
self.channels = ch->next;
} else {
Channel* prev = self.channels;
Channel* p = prev->next;
while (p != NULL) {
if (p == ch) {
prev->next = ch->next;
p = NULL; /* We're done */
} else {
prev = p;
p = p->next;
}
}
}
channel_free(ch);
}
void
test_ofp_experimenter_reply_create_null(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
struct pbuf *pbuf = pbuf_alloc(65535);
struct ofp_header xid_header;
struct event_manager *em = event_manager_alloc();
struct channel *channel = channel_alloc_ip4addr("127.0.0.1", "1000",
em, 0x01);
struct ofp_experimenter_header exper_req;
ret = ofp_experimenter_reply_create(NULL, &pbuf, &xid_header, &exper_req);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"ofp_experimenter_reply_create error.");
ret = ofp_experimenter_reply_create(channel, NULL, &xid_header, &exper_req);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"ofp_experimenter_reply_create error.");
ret = ofp_experimenter_reply_create(channel, &pbuf, NULL, &exper_req);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"ofp_experimenter_reply_create error.");
ret = ofp_experimenter_reply_create(channel, &pbuf, &xid_header, NULL);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS, ret,
"ofp_experimenter_reply_create error.");
/* after. */
channel_free(channel);
event_manager_free(em);
pbuf_free(pbuf);
}
/** Test destroy cell queue with no interference from other queues. */
static void
test_cmux_destroy_cell_queue(void *arg)
{
circuitmux_t *cmux = NULL;
channel_t *ch = NULL;
circuit_t *circ = NULL;
cell_queue_t *cq = NULL;
packed_cell_t *pc = NULL;
tor_libevent_cfg cfg;
memset(&cfg, 0, sizeof(cfg));
tor_libevent_initialize(&cfg);
scheduler_init();
#ifdef ENABLE_MEMPOOLS
init_cell_pool();
#endif /* ENABLE_MEMPOOLS */
(void) arg;
cmux = circuitmux_alloc();
tt_assert(cmux);
ch = new_fake_channel();
ch->has_queued_writes = has_queued_writes;
ch->wide_circ_ids = 1;
circ = circuitmux_get_first_active_circuit(cmux, &cq);
tt_assert(!circ);
tt_assert(!cq);
circuitmux_append_destroy_cell(ch, cmux, 100, 10);
circuitmux_append_destroy_cell(ch, cmux, 190, 6);
circuitmux_append_destroy_cell(ch, cmux, 30, 1);
tt_int_op(circuitmux_num_cells(cmux), OP_EQ, 3);
circ = circuitmux_get_first_active_circuit(cmux, &cq);
tt_assert(!circ);
tt_assert(cq);
tt_int_op(cq->n, OP_EQ, 3);
pc = cell_queue_pop(cq);
tt_assert(pc);
tt_mem_op(pc->body, OP_EQ, "\x00\x00\x00\x64\x04\x0a\x00\x00\x00", 9);
packed_cell_free(pc);
pc = NULL;
tt_int_op(circuitmux_num_cells(cmux), OP_EQ, 2);
done:
circuitmux_free(cmux);
channel_free(ch);
packed_cell_free(pc);
#ifdef ENABLE_MEMPOOLS
free_cell_pool();
#endif /* ENABLE_MEMPOOLS */
}
void ssh_scp_free(ssh_scp scp){
if(scp->state != SSH_SCP_NEW)
ssh_scp_close(scp);
if(scp->channel)
channel_free(scp->channel);
SAFE_FREE(scp->location);
SAFE_FREE(scp->request_name);
SAFE_FREE(scp->warning);
SAFE_FREE(scp);
}
void
remmina_nx_session_free (RemminaNXSession *nx)
{
pthread_t thread;
if (nx->proxy_watch_source)
{
g_source_remove (nx->proxy_watch_source);
nx->proxy_watch_source = 0;
}
if (nx->proxy_pid)
{
kill (nx->proxy_pid, SIGTERM);
g_spawn_close_pid (nx->proxy_pid);
nx->proxy_pid = 0;
}
thread = nx->thread;
if (thread)
{
nx->running = FALSE;
pthread_cancel (thread);
pthread_join (thread, NULL);
nx->thread = 0;
}
if (nx->channel)
{
channel_close (nx->channel);
channel_free (nx->channel);
}
if (nx->server_sock >= 0)
{
close (nx->server_sock);
nx->server_sock = -1;
}
g_free (nx->server);
g_free (nx->error);
g_hash_table_destroy (nx->session_parameters);
g_string_free (nx->response, TRUE);
g_free (nx->version);
g_free (nx->session_id);
g_free (nx->proxy_cookie);
if (nx->session_list)
{
g_object_unref (nx->session_list);
nx->session_list = NULL;
}
if (nx->session)
{
ssh_free (nx->session);
nx->session = NULL;
}
g_free (nx);
}
static void
s_destroy_channel(struct channel *channel) {
if (channel != NULL) {
lagopus_result_t ret;
ret = channel_free(channel);
if (ret != LAGOPUS_RESULT_OK) {
lagopus_msg_fatal("channel_free error (%s)\n",
lagopus_error_get_string(ret));
}
}
}
static void
remmina_ssh_tunnel_remove_channel (RemminaSSHTunnel *tunnel, gint n)
{
channel_close (tunnel->channels[n]);
channel_free (tunnel->channels[n]);
close (tunnel->sockets[n]);
remmina_ssh_tunnel_buffer_free (tunnel->socketbuffers[n]);
tunnel->num_channels--;
tunnel->channels[n] = tunnel->channels[tunnel->num_channels];
tunnel->channels[tunnel->num_channels] = NULL;
tunnel->sockets[n] = tunnel->sockets[tunnel->num_channels];
tunnel->socketbuffers[n] = tunnel->socketbuffers[tunnel->num_channels];
}
void
test_connect_with_macro (void)
{
struct sockaddr_in address;
const gchar host_name[] = "mx.local.net";
const gchar ip_address[] = "192.168.123.123";
guint16 port;
const gchar *packet;
gsize packet_size;
test_negotiate();
channel_free();
reply_negotiate();
port = g_htons(50443);
address.sin_family = AF_INET;
address.sin_port = port;
inet_pton(AF_INET, ip_address, &(address.sin_addr));
macros = gcut_hash_table_string_string_new("G", "g",
"N", "n",
"U", "u",
NULL);
milter_protocol_agent_set_macros_hash_table(MILTER_PROTOCOL_AGENT(context),
MILTER_COMMAND_CONNECT,
macros);
milter_command_encoder_encode_define_macro(encoder,
&packet, &packet_size,
MILTER_COMMAND_CONNECT,
macros);
cut_assert_true(milter_server_context_connect(context, host_name,
(struct sockaddr *)&address,
sizeof(address)));
pump_all_events();
milter_test_assert_state(CONNECT);
milter_test_assert_status(NOT_CHANGE);
packet_string = g_string_new_len(packet, packet_size);
milter_command_encoder_encode_connect(encoder,
&packet, &packet_size,
host_name,
(const struct sockaddr *)&address,
sizeof(address));
g_string_append_len(packet_string, packet, packet_size);
milter_test_assert_packet(channel, packet_string->str, packet_string->len);
cut_assert_equal_uint(0, n_message_processed);
}
// Connect to a SSH server.
// When the connection is established, read data from stdin and send it to the server.
void client_pipe(char *host, int port)
{
ssh_session s = ssh_new();
ssh_options_set(s, SSH_OPTIONS_HOST, host);
ssh_options_set(s, SSH_OPTIONS_PORT, &port);
ssh_options_set(s, SSH_OPTIONS_USER, "xya");
//ssh_options_set(s, SSH_OPTIONS_LOG_VERBOSITY_STR, "5");
if(ssh_connect(s) != SSH_OK)
return session_error(s, "connect");
char *hash = pubkey_hash(ssh_get_pubkey(s));
if(authenticate(hash, 0))
{
session_event(s, "authenticated", hash);
free(hash);
}
else
{
free(hash);
exit(1);
}
int keytype;
ssh_string pub = publickey_from_file(s, "test-client-key.pub", &keytype);
if(!pub)
session_error(s, "open-public-key");
if(SSH_AUTH_SUCCESS != ssh_userauth_offer_pubkey(s, NULL, keytype, pub))
session_error(s, "offer-public-key");
ssh_private_key priv = privatekey_from_file(s, "test-client-key", keytype, NULL);
if(!priv)
session_error(s, "open-private-key");
if(SSH_AUTH_SUCCESS != ssh_userauth_pubkey(s, NULL, pub, priv))
session_error(s, "user-auth");
string_free(pub);
privatekey_free(priv);
ssh_channel chan = channel_new(s);
if(!chan)
session_error(s, "create-channel");
if(channel_open_session(chan) < 0)
session_error(s, "open-channel");
session_event(s, "channel-opened", NULL);
channel_from_file(chan, 0);
channel_free(chan);
ssh_disconnect(s);
ssh_finalize();
}
static void do_lost_connection(struct channel_t* channel)
{
UT_VERIFY_TRUE(0 != channel);
UT_VERIFY_TRUE(0 != channel->net);
/*通知回调函数，连接断开*/
channel->net->lost_func(channel->net, channel->index, channel->net->net_data, channel->channel_data);
/*关闭socket句柄*/
sock_close(channel->sock);
channel->sock = -1;
/*释放通道资源*/
channel_free(channel->net, channel);
/*从epoll中删除*/
epoll_ctl(channel->net->epoll_handle, EPOLL_CTL_DEL, channel->sock, 0);
FAIL:
return;
}
void
test_abort (void)
{
const gchar *packet;
gsize packet_size;
test_body();
channel_free();
cut_assert_true(milter_server_context_abort(context));
pump_all_events();
milter_test_assert_state(ABORT);
milter_test_assert_status(ABORT);
milter_command_encoder_encode_abort(encoder, &packet, &packet_size);
milter_test_assert_packet(channel, packet, packet_size);
}
static lagopus_result_t
channel_delete_internal(const char *key) {
lagopus_result_t ret;
struct channel *chan;
ret = lagopus_hashmap_find(&main_table, (void *)key, (void **)&chan);
if (ret != LAGOPUS_RESULT_OK) {
return ret;
}
channel_disable(chan);
ret = channel_free(chan);
if (ret != LAGOPUS_RESULT_OK) {
return ret;
}
return lagopus_hashmap_delete(&main_table, (void *)key, NULL, false);
}
void
packet_free(packet_t *pkt)
{
exthdr_t *eh;
if (pkt->refcnt-- > 0)
return;
while ((eh = STAILQ_FIRST(&pkt->extlist)) != NULL) {
STAILQ_REMOVE_HEAD(&pkt->extlist, next);
free(eh);
}
pkt->chan->refcnt--;
if (pkt->chan->refcnt == 0)
channel_free(pkt->chan);
free(pkt);
}
