Telnet client server session with negotiation - c++

Question

I am trying to write a code for Telnet client server session which sends negotiations between them. Like WILL, WON'T,DO , DON'T. I wrote a basic client-server program using socket programming.
It would be of great help if I could know how to modify client/server as a telnet client server with negotiations. Following is the code:
enter code here
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
char buf1[] = {0xff, 0xfb, 0x18, 0xff, 0xfb, 0x1f};
char buf2[] = {0xff, 0xfc, 0x20, 0xff, 0xfc, 0x23, 0xff, 0xfb, 0x27};
char buf3[] = {0xff, 0xfa, 0x1f, 0x00, 0x78, 0x00, 0x32, 0xff, 0xf0};
char buf4[] = {0xff, 0xfa, 0x27, 0x00, 0xff, 0xf0, 0xff, 0xfa, 0x18, 0x00, 0x41, 0x4e, 0x53, 0x49, 0xff, 0xf0};
char buf5[] = {0xff, 0xfd, 0x03};
char buf6[] = {0xff, 0xfb, 0x01, 0xff, 0xfe, 0x05, 0xff, 0xfc, 0x21};
char buf7[] = {0xff, 0xfc, 0x01};
char buf8[] = {0xff, 0xfd, 0x01};
void read (int sock)
{
char buffer[256];
/* Now read server response */
memset(buffer, 0, sizeof(buffer));
int n = recv( sock, buffer, 255, 0 );
if (n < 0)
{
perror("ERROR reading from socket");
return;
}
printf("%d bytes received buffer is: %s\n", n, buffer);
for (int i = 0; i < n; i++)
printf("%2x ", buffer[i]);
printf("\n");
}
void mwrite (int sock, char * buf, int size)
{
int n = send( sock, buf, size, 0 );
if (n < 0)
{
perror("ERROR writing to socket");
return;
}
printf("Bytes Sent: %d\n", n);
}
int main(int argc, char *argv[])
{
int sockfd, portno, n;
struct sockaddr_in serv_addr;
struct hostent *server;
char buffer[256];
if (argc < 3) {
fprintf(stderr,"usage %s hostname port\n", argv[0]);
return(0);
}
portno = atoi(argv[2]);
/* Create a socket point */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
{
perror("ERROR opening socket");
return(1);
}
server = gethostbyname(argv[1]);
if (server == NULL)
{fprintf(stderr,"ERROR no such host \n");
exit(0);}
//printf("host %s, port %d\n", host.c_str(), portno);
bzero((char *) &serv_addr , sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr, (char*)&serv_addr.sin_addr.s_addr, server->h_length);
//serv_addr.sin_addr.s_addr = inet_addr( host.c_str() ); // ( "127.0.0.1" );
serv_addr.sin_port = htons( portno );
/* Now connect to the server */
if (connect( sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr) ) < 0)
{
perror("ERROR connecting");
return(1);
}
printf("Please enter the message=");
bzero(buffer,256);
fgets(buffer,255,stdin);
n= write(sockfd,buffer,strlen(buffer));
if(n<0)
printf("ERROR writing in socket %d len %d", n, strlen(buffer));
bzero(buffer,256);
n = read(sockfd, buffer, 255);
if(n<0)
perror("ERROR reading from socket");
printf("%s\n",buffer);
close(sockfd);
return 0;
buffer[0] = 0x0d;
buffer[1] = 0x0a;
mwrite ( sockfd, buffer, 2);
printf("read 1 ");
read(sockfd);
mwrite( sockfd, buf1, sizeof(buf1));
sleep(2);
mwrite( sockfd, buf2, sizeof(buf2));
printf("read 2 ");
read(sockfd);
mwrite( sockfd, buf3, sizeof(buf3));
printf("read 3a ");
read(sockfd);
sleep(2);
mwrite( sockfd, buf4, sizeof(buf4));
printf("read 3b ");
read(sockfd);
mwrite( sockfd, buf5, sizeof(buf5));
sleep(2);
mwrite( sockfd, buf6, sizeof(buf6));
printf("read 4 ");
read(sockfd);
mwrite( sockfd, buf7, sizeof(buf7));
sleep(2);
mwrite( sockfd, buf8, sizeof(buf8));
read(sockfd);
mwrite ( sockfd, buffer, 2);
read(sockfd);
return 0;
}
Server.cpp
enter code here :
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
void error(char *msg)
{
perror(msg);
exit(1);
}
int main(int argc, char *argv[])
{
int sockfd, newsockfd, portno;
//unsigned clilen;
socklen_t clilen;
char buffer[256];
struct sockaddr_in serv_addr, cli_addr;
int n;
if (argc < 2)
{
fprintf(stderr,"ERROR, no port provided\n");
exit(1);
}
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
{
error("ERROR opening socket");
}
bzero((char *) &serv_addr, sizeof(serv_addr));
portno = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);
if (bind(sockfd, (struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0)
{
error("ERROR on binding");
}
listen(sockfd,5);
clilen = sizeof(cli_addr);
newsockfd = accept(sockfd,(struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0)
{
error("ERROR on accept");
}
bzero(buffer,256);
n = read(newsockfd,buffer,255);
if (n < 0)
{
error("ERROR reading from socket");
}
printf("Here is the message: %s\n",buffer);
n = write(newsockfd,"I got your message",18);
if (n < 0)
{
error("ERROR writing to socket");
}
return 0;
}
Thanks in advance.

Answer 1

[It started to be too much for comments, so I write as an answer instead.]
As for your problem, it's actually not a single problem but two intermingled problems: Buffering and negotiation. You need buffering because TCP is a streaming protocol, a receive call might receive only a part of a telnet message, and a send call might send only a part of a telnet message. The second problem is the negotiation, for which you need a so-called state machine. And you need one state per option.
You also need to read and understand RFC854 and RFC855. See the Telnet Wikipedia article for a comprehensive list of RFC's.
For the option negotiation, WILL and WONT is responded by DO or DONT. You should generally not send a DO or DONT unless you already received a WILL or WONT. For starters, until you implemented proper handing of the options, I recommend you always answer with DONT whenever you get a WILL (and or course a WONT) message. Don't send WILL or WONT unless you really need to negotiate about an option.
More implementation-wise, I recommend four state tables, one each for WILL, WONT, DO and DONT that you have sent. Those tables contain simple boolean values that tells you if you have sent the corresponding message to the peer. These four table assumes that any unrecognized option you receive is replied with a DONT or WONT.
If you send a WILL then you mark that in the corresponding state-table, so that when you receive a DO or DONT for the option you know that it was you that initiated the negotiation.