int guac_telnet_client_free_handler(guac_client* client) {
guac_telnet_client* telnet_client = (guac_telnet_client*) client->data;
/* Close telnet connection */
if (telnet_client->socket_fd != -1)
close(telnet_client->socket_fd);
/* Clean up recording, if in progress */
if (telnet_client->recording != NULL)
guac_common_recording_free(telnet_client->recording);
/* Kill terminal */
guac_terminal_free(telnet_client->term);
/* Wait for and free telnet session, if connected */
if (telnet_client->telnet != NULL) {
pthread_join(telnet_client->client_thread, NULL);
telnet_free(telnet_client->telnet);
}
/* Free settings */
if (telnet_client->settings != NULL)
guac_telnet_settings_free(telnet_client->settings);
free(telnet_client);
return 0;
}
static void _event_handler(telnet_t *telnet, telnet_event_t *ev,
void *user_data) {
struct user_t *user = (struct user_t*)user_data;
switch (ev->type) {
/* data received */
case TELNET_EV_DATA:
_input(user, ev->data.buffer, ev->data.size);
break;
/* data must be sent */
case TELNET_EV_SEND:
_send(user->sock, ev->data.buffer, ev->data.size);
break;
/* enable compress2 if accepted by client */
case TELNET_EV_DO:
if (ev->neg.telopt == TELNET_TELOPT_COMPRESS2)
telnet_begin_compress2(telnet);
break;
/* error */
case TELNET_EV_ERROR:
close(user->sock);
user->sock = -1;
if (user->name != 0) {
_message(user->name, "** HAS HAD AN ERROR **");
free(user->name);
user->name = 0;
}
telnet_free(user->telnet);
break;
default:
/* ignore */
break;
}
}
/*
* Close a Telnet session and free the associated resources.
*/
static void
telnet_shutdown(ndesc_t *nd, telnet_t *tp)
{
if (tp != NULL)
{
telnet_flush(tp);
telnet_free(tp);
}
(void)close(nd_fd(nd));
nd_detach(nd);
}
static void _event_handler(telnet_t *telnet, telnet_event_t *ev, void *user_data)
{
struct user_t *user = (struct user_t*)user_data;
switch(ev->type)
{
case TELNET_EV_DATA:
printf("TELNET_EV_DATA\n");
break;
case TELNET_EV_SEND:
printf("TELNET_EV_SEND\n");
_send(user->sock, ev->data.buffer, ev->data.size);
break;
case TELNET_EV_SUBNEGOTIATION:
printf("TELNET_EV_SUBNEGOTIANTION\n");
if(ev->sub.telopt == TELNET_TELOPT_NAWS)
{
user->width = (ev->sub.buffer[0] * 256) + (unsigned char)ev->sub.buffer[1];
user->height = (ev->sub.buffer[2] * 256) + (unsigned char)ev->sub.buffer[3];
telnet_printf(telnet, "client width is x: %d and y: %d\n", user->width, user->height);
printf("client width is x: %d and y: %d\n", user->width, user->height);
_draw(user->width, user->height, telnet);
}
break;
case TELNET_EV_WILL:
printf("client will\n");
break;
case TELNET_EV_WONT:
printf("client wont\n");
break;
case TELNET_EV_ERROR:
close(user->sock);
user->sock = -1;
telnet_free(user->telnet);
printf("TELNET_EV_ERROR\n");
break;
default:
break;
}
}
int main(int argc, char** argv) {
FILE *fh;
telnet_t *telnet;
char buffer[4096];
size_t len;
/* check for a requested input file */
if (argc != 2) {
fprintf(stderr, "Usage: telnet-test [test file]\n");
return 1;
}
/* open requested file */
if ((fh = fopen(argv[1], "rt")) == NULL) {
fprintf(stderr, "Failed to open %s: %s\n",
argv[1], strerror(errno));
return 2;
}
/* create telnet parser instance */
if ((telnet = telnet_init(telopts, event_print, 0,
NULL)) == 0) {
fprintf(stderr, "Failed to initialize libtelnet: %s\n",
strerror(errno));
return 3;
}
/* read input until we hit EOF or marker */
while (fgets(buffer, sizeof(buffer), fh) != NULL && strcmp(buffer, "%%\n") != 0) {
if (buffer[0] != '#') {
len = strlen(buffer);
decode(buffer, &len);
telnet_recv(telnet, buffer, len);
}
}
/* clean up */
telnet_free(telnet);
fclose(fh);
return 0;
}
static void _event_handler(telnet_t *telnet, telnet_event_t *ev, void *user_data)
{
struct user_t *user = (struct user_t*)user_data;
switch(ev->type)
{
case TELNET_EV_DATA:
printf("TELNET_EV_DATA\n");
break;
case TELNET_EV_SEND:
printf("TELNET_EV_SEND\n");
_send(user->sock, ev->data.buffer, ev->data.size);
break;
case TELNET_EV_SUBNEGOTIATION:
printf("TELNET_EV_SUBNEGOTIANTION\n");
if(ev->sub.telopt == TELNET_TELOPT_NAWS)
printf("NAWS subnegotiation has %d bytes\n", ev->data.size);
telnet_printf(telnet, "NAWS subnegotiation has %d bytes\n", ev->data.size);
break;
case TELNET_EV_WILL:
printf("client will\n");
break;
case TELNET_EV_WONT:
printf("client wont\n");
break;
case TELNET_EV_ERROR:
close(user->sock);
user->sock = -1;
telnet_free(user->telnet);
printf("TELNET_EV_ERROR\n");
break;
default:
break;
}
}
int main (int argc, char** argv) {
const char* default_port = "23";
struct sigaction sa;
int i;
/* process command line args */
for (i = 1; i < argc; ++i) {
/* help */
if (strcmp(argv[i], "-h") == 0) {
printf(
"CLC %s by Sean Middleditch <*****@*****.**>\n"
"This program has been released into the PUBLIC DOMAIN.\n\n"
"Usage:\n"
" clc [-h] <host> [<port>]\n\n"
"Options:\n"
" -h display help\n", CLC_VERSION
);
return 0;
}
/* other unknown option */
if (argv[i][0] == '-') {
fprintf(stderr, "Unknown option %s.\nUse -h to see available options.\n", argv[i]);
exit(1);
}
/* if host is unset, this is the host */
if (host == NULL) {
host = argv[i];
/* otherwise, it's a port */
} else {
port = argv[i];
}
}
/* ensure we have a host */
if (host == NULL) {
fprintf(stderr, "No host was given.\nUse -h to see command format.\n");
exit(1);
}
/* set default port if none was given */
if (port == NULL)
port = default_port;
/* cleanup on any failure */
atexit(cleanup);
/* set terminal defaults */
memset(&terminal, 0, sizeof(struct TERMINAL));
terminal.state = TERM_ASCII;
terminal.flags = TERM_FLAGS_DEFAULT;
terminal.color = TERM_COLOR_DEFAULT;
/* initial telnet handler */
telnet = telnet_init(telnet_telopts, telnet_event, 0, 0);
/* connect to server */
sock = do_connect(host, port);
if (sock == -1) {
fprintf(stderr, "Failed to connect to %s:%s\n", host, port);
exit(1);
}
printf("Connected to %s:%s\n", host, port);
/* set initial banner */
snprintf(banner, sizeof(banner), "CLC - %s:%s (connected)", host, port);
/* configure curses */
initscr();
start_color();
nonl();
cbreak();
noecho();
win_main = newwin(LINES-2, COLS, 0, 0);
win_banner = newwin(1, COLS, LINES-2, 0);
win_input = newwin(1, COLS, LINES-1, 0);
idlok(win_main, TRUE);
scrollok(win_main, TRUE);
nodelay(win_input, FALSE);
keypad(win_input, TRUE);
use_default_colors();
init_pair(COLOR_RED, COLOR_RED, -1);
init_pair(COLOR_BLUE, COLOR_BLUE, -1);
init_pair(COLOR_GREEN, COLOR_GREEN, -1);
init_pair(COLOR_CYAN, COLOR_CYAN, -1);
init_pair(COLOR_MAGENTA, COLOR_MAGENTA, -1);
init_pair(COLOR_YELLOW, COLOR_YELLOW, -1);
init_pair(COLOR_WHITE, COLOR_WHITE, -1);
init_pair(TERM_COLOR_DEFAULT, -1, -1);
wbkgd(win_main, COLOR_PAIR(TERM_COLOR_DEFAULT));
wclear(win_main);
init_pair(10, COLOR_WHITE, COLOR_BLUE);
wbkgd(win_banner, COLOR_PAIR(10));
wclear(win_banner);
init_pair(11, -1, -1);
wbkgd(win_input, COLOR_PAIR(11));
wclear(win_input);
redraw_display();
/* set signal handlers */
memset(&sa, 0, sizeof(sa));
sa.sa_handler = handle_signal;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGWINCH, &sa, NULL);
/* initial edit buffer */
memset(&editbuf, 0, sizeof(struct EDITBUF));
/* setup poll info */
struct pollfd fds[2];
fds[0].fd = 1;
fds[0].events = POLLIN;
fds[1].fd = sock;
fds[1].events = POLLIN;
/* main loop */
while (running) {
/* poll sockets */
if (poll(fds, 2, -1) == -1) {
if (errno != EAGAIN && errno != EINTR) {
endwin();
fprintf(stderr, "poll() failed: %s\n", strerror(errno));
return 1;
}
}
/* resize event? */
if (have_sigwinch) {
have_sigwinch = 0;
redraw_display();
}
/* escape? */
if (have_sigint) {
exit(0);
}
/* input? */
if (fds[0].revents & POLLIN) {
int key = wgetch(win_input);
if (key != ERR)
on_key(key);
}
/* process input data */
if (fds[1].revents & POLLIN) {
char buffer[2048];
int ret = recv(sock, buffer, sizeof(buffer), 0);
if (ret == -1) {
if (errno != EAGAIN && errno != EINTR) {
endwin();
fprintf(stderr, "recv() failed: %s\n", strerror(errno));
return 1;
}
} else if (ret == 0) {
running = 0;
} else {
recv_bytes += ret;
telnet_recv(telnet, buffer, ret);
}
}
/* flush output */
paint_banner();
wnoutrefresh(win_main);
wnoutrefresh(win_banner);
wnoutrefresh(win_input);
doupdate();
}
/* final display, pause */
sock = -1;
autobanner = 1;
paint_banner();
wnoutrefresh(win_banner);
doupdate();
wgetch(win_input);
/* clean up */
endwin();
printf("Disconnected.\n");
/* free memory (so Valgrind leak detection is useful) */
telnet_free(telnet);
return 0;
}
int main(int argc, char *argv[])
{
int listen_sock;
struct sockaddr_in addr;
//telnet_t *telnet;
//struct sockaddr_in client_addr;
socklen_t addrlen;
int rs;
struct pollfd pfd[2];
char buffer[512];
memset(&pfd, 0, sizeof(pfd));
if((listen_sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("cant open socket\n");
exit(errno);
}
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, (void*)&rs, sizeof(rs));
rs = 1;
//bzero(&self, sizeof(self));
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(MY_PORT);
addr.sin_addr.s_addr = INADDR_ANY;
if( bind(listen_sock, (struct sockaddr*)&addr, sizeof(addr)) != 0 )
{
perror("cant bind");
exit(errno);
}
if( listen(listen_sock, 20) != 0 )
{
perror("cant listen");
exit(errno);
}
pfd[1].fd = listen_sock;
pfd[1].events = POLLIN;
while(1)
{
if(user.sock != -1)
{
pfd[0].fd = user.sock;
pfd[0].events = POLLIN;
}
else
{
pfd[0].fd = -1;
pfd[0].events = 0;
}
rs = poll(pfd, 2, -1);
if(rs == -1 && errno == EINTR)
{
printf("Poll failed\n");
return 1;
}
if(pfd[1].revents & POLLIN)
{
addrlen = sizeof(addr);
if((rs = accept(listen_sock, (struct sockaddr*)&addr, &addrlen)) == -1)
{
fprintf(stderr, "accept() failed %d.\n", errno);
return 1;
}
printf("Connected client: %s:%d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
user.sock = rs;
user.telnet = telnet_init(telopts, _event_handler, 0, &user);
telnet_negotiate(user.telnet, TELNET_DO, TELNET_TELOPT_NAWS);
}
if(pfd[0].revents & POLLIN)
{
if( (rs = recv(user.sock, buffer, sizeof(buffer), 0)) > 0)
{
telnet_recv(user.telnet, buffer, sizeof(buffer));
}
else if(rs == 0)
{
printf("connection closed\n");
close(user.sock);
telnet_free(user.telnet);
user.sock = -1;
break;
}
else if(errno != EINTR)
{
fprintf(stderr, "recv() failed\n");
exit(1);
}
}
//send(clientfd, "Hello, world!", sizeof("Hello, world!"), 0);
}
close(listen_sock);
return 0;
}
int main(int argc, char **argv) {
char buffer[512];
int rs;
int sock;
struct sockaddr_in addr;
struct pollfd pfd[2];
struct addrinfo *ai;
struct addrinfo hints;
struct termios tios;
/* check usage */
if (argc != 3) {
fprintf(stderr, "Usage:\n ./telnet-client <host> <port>\n");
return 1;
}
/* look up server host */
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
if ((rs = getaddrinfo(argv[1], argv[2], &hints, &ai)) != 0) {
fprintf(stderr, "getaddrinfo() failed for %s: %s\n", argv[1],
gai_strerror(rs));
return 1;
}
/* create server socket */
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
fprintf(stderr, "socket() failed: %s\n", strerror(errno));
return 1;
}
/* bind server socket */
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
fprintf(stderr, "bind() failed: %s\n", strerror(errno));
return 1;
}
/* connect */
if (connect(sock, ai->ai_addr, ai->ai_addrlen) == -1) {
fprintf(stderr, "connect() failed: %s\n", strerror(errno));
return 1;
}
/* free address lookup info */
freeaddrinfo(ai);
/* get current terminal settings, set raw mode, make sure we
* register atexit handler to restore terminal settings
*/
tcgetattr(STDOUT_FILENO, &orig_tios);
atexit(_cleanup);
tios = orig_tios;
cfmakeraw(&tios);
tcsetattr(STDOUT_FILENO, TCSADRAIN, &tios);
/* set input echoing on by default */
do_echo = 1;
/* initialize telnet box */
telnet = telnet_init(telopts, _event_handler, 0, &sock);
/* initialize poll descriptors */
memset(pfd, 0, sizeof(pfd));
pfd[0].fd = STDIN_FILENO;
pfd[0].events = POLLIN;
pfd[1].fd = sock;
pfd[1].events = POLLIN;
/* loop while both connections are open */
while (poll(pfd, 2, -1) != -1) {
/* read from stdin */
if (pfd[0].revents & POLLIN) {
if ((rs = read(STDIN_FILENO, buffer, sizeof(buffer))) > 0) {
_input(buffer, rs);
} else if (rs == 0) {
break;
} else {
fprintf(stderr, "recv(server) failed: %s\n",
strerror(errno));
exit(1);
}
}
/* read from client */
if (pfd[1].revents & POLLIN) {
if ((rs = recv(sock, buffer, sizeof(buffer), 0)) > 0) {
telnet_recv(telnet, buffer, rs);
} else if (rs == 0) {
break;
} else {
fprintf(stderr, "recv(client) failed: %s\n",
strerror(errno));
exit(1);
}
}
}
/* clean up */
telnet_free(telnet);
close(sock);
return 0;
}
TelnetConnection::~TelnetConnection() {
if (mTelnet)
telnet_free(mTelnet);
}
int main(int argc, char **argv) {
char buffer[512];
short listen_port;
int listen_sock;
int rs;
int i;
struct sockaddr_in addr;
socklen_t addrlen;
struct pollfd pfd[MAX_USERS + 1];
/* initialize Winsock */
#if defined(_WIN32)
WSADATA wsd;
WSAStartup(MAKEWORD(2, 2), &wsd);
#endif
/* check usage */
if (argc != 2) {
fprintf(stderr, "Usage:\n ./telnet-chatd <port>\n");
return 1;
}
/* initialize data structures */
memset(&pfd, 0, sizeof(pfd));
memset(users, 0, sizeof(users));
for (i = 0; i != MAX_USERS; ++i)
users[i].sock = -1;
/* parse listening port */
listen_port = (short)strtol(argv[1], 0, 10);
/* create listening socket */
if ((listen_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
fprintf(stderr, "socket() failed: %s\n", strerror(errno));
return 1;
}
/* reuse address option */
rs = 1;
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, (void*)&rs, sizeof(rs));
/* bind to listening addr/port */
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(listen_port);
if (bind(listen_sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
fprintf(stderr, "bind() failed: %s\n", strerror(errno));
return 1;
}
/* listen for clients */
if (listen(listen_sock, 5) == -1) {
fprintf(stderr, "listen() failed: %s\n", strerror(errno));
return 1;
}
printf("LISTENING ON PORT %d\n", listen_port);
/* initialize listening descriptors */
pfd[MAX_USERS].fd = listen_sock;
pfd[MAX_USERS].events = POLLIN;
/* loop for ever */
for (;;) {
/* prepare for poll */
for (i = 0; i != MAX_USERS; ++i) {
if (users[i].sock != -1) {
pfd[i].fd = users[i].sock;
pfd[i].events = POLLIN;
} else {
pfd[i].fd = -1;
pfd[i].events = 0;
}
}
/* poll */
rs = poll(pfd, MAX_USERS + 1, -1);
if (rs == -1 && errno != EINTR) {
fprintf(stderr, "poll() failed: %s\n", strerror(errno));
return 1;
}
/* new connection */
if (pfd[MAX_USERS].revents & POLLIN) {
/* acept the sock */
addrlen = sizeof(addr);
if ((rs = accept(listen_sock, (struct sockaddr *)&addr,
&addrlen)) == -1) {
fprintf(stderr, "accept() failed: %s\n", strerror(errno));
return 1;
}
printf("Connection received.\n");
/* find a free user */
for (i = 0; i != MAX_USERS; ++i)
if (users[i].sock == -1)
break;
if (i == MAX_USERS) {
printf(" rejected (too many users)\n");
_send(rs, "Too many users.\r\n", 14);
close(rs);
}
/* init, welcome */
users[i].sock = rs;
users[i].telnet = telnet_init(telopts, _event_handler, 0,
&users[i]);
telnet_negotiate(users[i].telnet, TELNET_WILL,
TELNET_TELOPT_COMPRESS2);
telnet_printf(users[i].telnet, "Enter name: ");
}
/* read from client */
for (i = 0; i != MAX_USERS; ++i) {
/* skip users that aren't actually connected */
if (users[i].sock == -1)
continue;
if (pfd[i].revents & POLLIN) {
if ((rs = recv(users[i].sock, buffer, sizeof(buffer), 0)) > 0) {
telnet_recv(users[i].telnet, buffer, rs);
} else if (rs == 0) {
printf("Connection closed.\n");
close(users[i].sock);
if (users[i].name != 0) {
_message(users[i].name, "** HAS DISCONNECTED **");
free(users[i].name);
users[i].name = 0;
}
telnet_free(users[i].telnet);
users[i].sock = -1;
break;
} else if (errno != EINTR) {
fprintf(stderr, "recv(client) failed: %s\n",
strerror(errno));
exit(1);
}
}
}
}
/* not that we can reach this, but GCC will cry if it's not here */
return 0;
}
