Boolean ssh_channel_start_local_tcp_forward(SshCommon common,
const char *address_to_bind,
const char *port,
const char *connect_to_host,
const char *connect_to_port)
{
SshLocalTcpForward fwd;
SshChannelTypeTcpDirect ct;
long portnumber;
SshUser user;
SSH_DEBUG(5, ("requesting local forwarding for port %s to %s:%s",
port, connect_to_host, connect_to_port));
portnumber = atol(port);
user = ssh_user_initialize(NULL, FALSE);
/* If user is not logged in as a privileged user, don't allow
forwarding of privileged ports. */
if (portnumber < 1024)
{
if (ssh_user_uid(user))
{
ssh_warning("Tried to forward " \
"privileged port %d as an ordinary user.",
portnumber);
return FALSE;
}
}
if (portnumber >= 65536)
{
ssh_warning("Tried to forward " \
"port above 65535 (%d).",
portnumber);
return FALSE;
}
ct = ssh_channel_dtcp_ct(common);
fwd = ssh_xcalloc(1, sizeof(*fwd));
fwd->common = common;
fwd->listener = ssh_tcp_make_listener(address_to_bind, port,
ssh_channel_dtcp_incoming_connection,
(void *)fwd);
if (!fwd->listener)
{
SSH_DEBUG(5, ("creating listener failed"));
ssh_xfree(fwd);
return FALSE;
}
fwd->port = ssh_xstrdup(port);
fwd->connect_to_host = ssh_xstrdup(connect_to_host);
fwd->connect_to_port = ssh_xstrdup(connect_to_port);
fwd->next = ct->local_forwards;
ct->local_forwards = fwd;
return TRUE;
}
int main(int argc, char* argv[])
{
t_tcpc_context pcontext = 0;
SshGetOptData pgetoptdata = 0;
int i;
SSH_TRACE(SSH_D_MY, ("%s", "main"));
pcontext = ssh_xmalloc(sizeof (*pcontext));
memset(pcontext, 0, sizeof (*pcontext));
pgetoptdata = ssh_xmalloc(sizeof (*pgetoptdata));
memset(pgetoptdata, 0, sizeof (*pgetoptdata));
ssh_getopt_init_data(pgetoptdata);
pcontext->pport_or_service = "23242";
while ((i = ssh_getopt(argc, argv, "p:h:d:D:G:t:", pgetoptdata)) != -1)
{
switch (i)
{
case 'p':
pcontext->pport_or_service = ssh_xstrdup(pgetoptdata->arg);
break;
case 'h':
pcontext->phost_name_or_address = ssh_xstrdup(pgetoptdata->arg);
break;
case 'd':
pcontext->pdata = ssh_xstrdup(pgetoptdata->arg);
break;
case 'D':
ssh_debug_set_module_level(SSH_DEBUG_MODULE, atoi(pgetoptdata->arg));
break;
case 'G':
ssh_debug_set_global_level(atoi(pgetoptdata->arg));
break;
case 't':
pcontext->timeout = atoi(pgetoptdata->arg);
break;
default:
SSH_NOTREACHED;
break;
}
}
ssh_xfree(pgetoptdata);
ssh_event_loop_initialize();
pcontext->pbuffer = ssh_buffer_allocate();
if (pcontext->phost_name_or_address)
{
ssh_tcp_connect(pcontext->phost_name_or_address,
pcontext->pport_or_service,
NULL,
t_tcpc_tcp_callback,
pcontext);
}
else
{
pcontext->ptcplistener =
ssh_tcp_make_listener(SSH_IPADDR_ANY_IPV4,
pcontext->pport_or_service,
NULL,
t_tcpc_tcp_callback,
pcontext);
}
ssh_event_loop_run();
ssh_name_server_uninit();
ssh_event_loop_uninitialize();
ssh_buffer_free(pcontext->pbuffer);
ssh_xfree(pcontext);
ssh_util_uninit();
return 0;
}
Boolean ssh_channel_remote_tcp_forward_request(const char *type,
const unsigned char *data,
size_t len,
void *context)
{
SshCommon common = (SshCommon)context;
char *address_to_bind;
SshUInt32 port;
char port_string[20];
SshRemoteTcpForward fwd;
SshChannelTypeTcpForward ct;
SSH_DEBUG(5, ("remote TCP/IP forwarding request received"));
ssh_log_event(common->config->log_facility,
SSH_LOG_INFORMATIONAL,
"Remote TCP/IP forwarding request received from host \"%s\", "\
"by authenticated user \"%s\".",
common->remote_host,
ssh_user_name(common->user_data));
ct = ssh_channel_ftcp_ct(common);
/* Don't allow a server to send remote forwarding requests to the client. */
if (common->client)
{
ssh_warning("Remote TCP/IP forwarding request from server denied.");
return FALSE;
}
/* Parse the request. */
if (ssh_decode_array(data, len,
SSH_FORMAT_UINT32_STR, &address_to_bind, NULL,
SSH_FORMAT_UINT32, &port,
SSH_FORMAT_END) != len)
{
SSH_DEBUG(0, ("bad data"));
return FALSE;
}
/* Convert port number to a string. */
snprintf(port_string, sizeof(port_string), "%ld", (unsigned long) port);
/* If user is not logged in as a privileged user, don't allow
forwarding of privileged ports. */
if (port < 1024)
{
if (ssh_user_uid(common->user_data))
{
SSH_TRACE(2, ("User \"%s\" not root, tried to forward " \
"privileged port %ld.",
ssh_user_name(common->user_data),
(unsigned long) port));
ssh_log_event(common->config->log_facility,
SSH_LOG_WARNING,
"User \"%s\" not root, tried to forward " \
"privileged port %ld.",
ssh_user_name(common->user_data),
(unsigned long) port);
return FALSE;
}
else
{
ssh_log_event(common->config->log_facility,
SSH_LOG_NOTICE,
"Privileged user \"%s\" forwarding a privileged port.",
ssh_user_name(common->user_data));
}
}
if (port >= 65536)
{
SSH_TRACE(2, ("User \"%s\" tried to forward " \
"port above 65535 (%ld).",
ssh_user_name(common->user_data), (unsigned long) port));
ssh_log_event(common->config->log_facility,
SSH_LOG_WARNING,
"User \"%s\" tried to forward " \
"port above 65535 (%ld).",
ssh_user_name(common->user_data), (unsigned long) port);
return FALSE;
}
/* Create a socket listener. */
fwd = ssh_xcalloc(1, sizeof(*fwd));
fwd->listener = ssh_tcp_make_listener(address_to_bind, port_string,
ssh_channel_ftcp_incoming_connection,
(void *)fwd);
if (fwd->listener == NULL)
{
ssh_debug("Creating remote listener for %s:%s failed.",
address_to_bind, port_string);
ssh_log_event(common->config->log_facility,
SSH_LOG_NOTICE,
"Creating remote listener for %s:%s failed.",
address_to_bind, port_string);
ssh_xfree(address_to_bind);
ssh_xfree(fwd);
return FALSE;
}
/* Fill the remaining fields. */
fwd->common = common;
fwd->address_to_bind = address_to_bind;
fwd->port = ssh_xstrdup(port_string);
fwd->connect_to_host = NULL;
fwd->connect_to_port = NULL;
/* Add to list of forwardings. */
fwd->next = ct->remote_forwards;
ct->remote_forwards = fwd;
ssh_log_event(common->config->log_facility,
SSH_LOG_INFORMATIONAL,
"Port %ld set up for remote forwarding.",
(unsigned long) port);
return TRUE;
}
int main(int ac, char **av)
{
char port[100];
int i;
TestCase *testcase;
int pass;
SshTime time_now;
time_now = ssh_time();
srandom(time_now);
for (pass = 0; pass < PASSES; pass++)
{
#ifdef DEBUG
ssh_debug("pass %d", pass);
#endif
random_state = ssh_random_allocate();
/* randomize it a bit */
ssh_random_add_noise(random_state, &time_now, sizeof(time_now));
ssh_buffer_init(&testdata);
for (i = 0; i < 100000; i++)
buffer_put_char(&testdata, ssh_random_get_byte(random_state));
ssh_event_loop_initialize();
for (i = 0; tests[i].name; i++)
{
testcase = &tests[i];
end_of_script_count = 0;
#ifdef DEBUG
ssh_debug("Running test %s", testcase->name);
#endif
snprintf(port, sizeof(port), "%d", (int)(35000 + random() % 1000));
#ifdef DEBUG
ssh_debug("Making listener, port %s...", port);
#endif
listener = ssh_tcp_make_listener("127.0.0.1", port,
listener_callback,
(void *)testcase);
if (!listener)
ssh_fatal("making listener failed");
#ifdef DEBUG
ssh_debug("Making connect...");
#endif
ssh_tcp_connect_with_socks("127.0.0.1", port, NULL, 2,
connect_callback, (void *)testcase);
#ifdef DEBUG
ssh_debug("Event loop running...");
#endif
ssh_event_loop_run();
#ifdef DEBUG
ssh_debug("Event loop exited...");
#endif
if (end_of_script_count != 2)
ssh_fatal("end_of_script_count %d, script end not reached.",
end_of_script_count);
/* Listener was destroyed in callback. */
}
ssh_event_loop_uninitialize();
ssh_buffer_uninit(&testdata);
ssh_random_free(random_state);
}
#ifdef DEBUG
ssh_debug("Exiting...");
#endif
return 0;
}
