Telnet Client连接过程：
- TCP连接telnet server 23端口
- NVT扩展自动协商
- 用户名+密码登录
- 通过telnet server端命令行交互
- 退出登录
概述
Telnet 协议是 TCP/IP 协议族中应用最广泛的协议。
它允许用户(Telnet 客户端)通过一个协商过程来与一个远程设备进行通信。
Telnet 协议是基于网络虚拟终端 NVT(Network Virtual Termina1)的实现，NVT 是虚拟设备，连接双方(客户机和服务器)都必须把它们的物理终端和 NVT 进行相互转换。
操作协商
只要客户机或服务器要发送命令序列而不是数据流，它就在数据流中插入一个特殊的保留字符，该保留字符叫做“解释为命令”（IAC ，Interpret As Command) 字符。当接收方在一个入数据流中发现 IAC 字符时，它就把后继的字节处理为一个命令序列。
双方在进行Telnet连接时，要进行选项协商。
比如：使用字符方式、窗口的大小，终端的类型都要进行协商。而协商是通过TELNET所支持的命令来实现的。
协商完成，telnet server才返回登录信息，否则无法登录。
本文协商过程通过程序的一个函数实现自动化。
VxWorks下telnet client实现代码
#include "string.h"
#include "stdio.h"
#include "vxWorks.h"
#include "sockLib.h"
#include "telnetLib.h"
#include "inetLib.h"
#include "stdioLib.h"
#include "strLib.h"
#include "hostLib.h"
#include "ioLib.h"
// telnet server 地址及端口
#define TELNET_SERVER_NAME "172.18.101.193"
#define TELNET_SERVER_PORT 23
// telnet NVT扩展选项协商，常用命令定义，命令与数值的对应关系
#define DO '\xFD'
#define WONT '\xFC'
#define WILL '\xFB'
#define DONT '\xFE'
#define IAC '\xFF'
#define SB '\xFA'
#define SE '\xF0'
#define CMD_WINDOW_SIZE 31
// 定义缓冲buffer长度，最大message长度，字符串最大长度
#define BUFFER_SIZE 20480
#define MAX_MSG_LENGTH 20480
#define STRING_MAX_SIZE 20480
// 全局变量
char go_string[STRING_MAX_SIZE];
char dealed_string[STRING_MAX_SIZE];
char back_string[STRING_MAX_SIZE];
// TCP client 主动连接：输入TCP服务端地址和端口，返回client_socket
int tcp_client_conn(char *server_name, int port)
{
struct sockaddr_in server_addr;
int client_socket;
/*创建套接字*/
client_socket = socket(AF_INET, SOCK_STREAM, 0);
if (client_socket < 0)
{
printf("Create Socket Failed! \n");
return -1;
}
// 填充server地址信息
bzero((char *)&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
if (((server_addr.sin_addr.s_addr = inet_addr(server_name)) == ERROR) &&
((server_addr.sin_addr.s_addr = hostGetByName(server_name)) == ERROR))
{
printf("Get Server Address Error! \n");
return -1;
}
server_addr.sin_port = htons(port);
server_addr.sin_len = sizeof(server_addr);
/* connect to server */
if (connect(client_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == ERROR)
{
printf("Connet to Server Error! \n");
return -1;
}
return client_socket;
}
// 连接telnet server，自动协商过程
void negotiate(int client_socket)
{
char buffer[BUFFER_SIZE];
int count = 0;
while (1)
{
bzero(buffer, BUFFER_SIZE);
// 读一个字节
if (recv(client_socket, buffer, 1, 0) < 0)
{
printf("Receive Data Failed! \n");
return;
}
if (buffer[0] == IAC)
{
// read 2 more bytes
if (recv(client_socket, buffer + 1, 2, 0) < 0)
{
printf("Receive Data Failed! \n");
return;
}
// TAC协商窗口大小
if (buffer[1] == DO && buffer[2] == CMD_WINDOW_SIZE)
{
char tmp1[10] = {IAC, WILL, CMD_WINDOW_SIZE};
if (send(client_socket, tmp1, 3, 0) < 0)
{
printf("Send Data Failed! \n");
return;
}
char tmp2[10] = {IAC, SB, CMD_WINDOW_SIZE, 0, 80, 0, 24, IAC, SE};
if (send(client_socket, tmp2, 9, 0) < 0)
{
printf("Send Data Failed! \n");
return;
}
continue;
}
// 处理一个IAC协商命令
int i;
for (i = 0; i < 3; i++)
{
if (buffer[i] == DO)
{
buffer[i] = WONT;
}
else if (buffer[i] == WILL)
{
buffer[i] = DO;
}
}
if (send(client_socket, buffer, 3, 0) < 0)
{
printf("Send Data Failed! \n");
return;
}
}
//结束循环条件，IAC协商结束
if (buffer[0] == '\n')
{
count += 1;
}
if (count == 2)
{
break;
}
}
}
// TCP client 接收服务端返回的数据
void tcp_client_receive_data(int client_socket)
{
char receive_buffer[BUFFER_SIZE];
int length;
// 接受服务器返回的状态信息
bzero(receive_buffer, BUFFER_SIZE);
if ((length = recv(client_socket, receive_buffer, MAX_MSG_LENGTH, 0)) == ERROR)
{
printf("Client Recieve Data Failed! \n");
return;
}
bzero(back_string, STRING_MAX_SIZE);
strncpy(back_string, receive_buffer, (strlen(receive_buffer) > STRING_MAX_SIZE ? STRING_MAX_SIZE : strlen(receive_buffer)));
printf("receive data from equipment: %s \n", back_string);
}
// TCP client 发送处理后的数据到目标TCP
void tcp_client_send_data(int client_socket)
{
char send_buffer[BUFFER_SIZE];
/* send request to server */
bzero(send_buffer, BUFFER_SIZE);
strncpy(send_buffer, dealed_string, strlen(dealed_string));
// buffer发送长度+1，目的带上'\0'结束符，strlen()函数读取到'\0'结束
int ret = send(client_socket, send_buffer, (strlen(send_buffer) + 1), 0);
if (ret == ERROR)
{
printf("Send Data to Server Error! \n");
return;
}
printf("send data to equipment: %s \n", send_buffer);
}
// telnet操作，命令数据处理
void telnet_deal_data(char *go_string, char *dealed_string)
{
bzero(dealed_string, STRING_MAX_SIZE);
strncpy(dealed_string, go_string, (strlen(go_string) > STRING_MAX_SIZE ? STRING_MAX_SIZE : strlen(go_string)));
// 命令结尾增加\n
dealed_string[strlen(dealed_string)] = '\n';
}
// telnet登录，输入用户名，接收password
void telnet_login_receive_password(int telnet_socket)
{
// recv当次接收的数据长度
int filled = 0;
// recv接收的全部数据的长度
int length = 0;
char buffer[BUFFER_SIZE];
bzero(buffer, BUFFER_SIZE);
// telnet登录：输入用户名后，接收全部返回数据
// 网络环境不同，执行情况不同，全部数据有可能一次接收到，也有可能两次才能全部接收到
while (1)
{
if ((filled = recv(telnet_socket, buffer + length, MAX_MSG_LENGTH, 0)) == ERROR)
{
printf("Accept Data Failed! \n");
return;
}
length += filled;
// 判断是否全部接收完返回数据
// 接收完全部数据，结束循环，即结束接收数据
if (buffer[length - 2 < 0 ? 0 : length - 2] == ':')
{
break;
}
}
bzero(back_string, STRING_MAX_SIZE);
strncpy(back_string, buffer, (strlen(buffer) > STRING_MAX_SIZE ? STRING_MAX_SIZE : strlen(buffer)));
printf("receive data from equipment: %s \n", buffer);
}
// telnet 登录成功，接收telnet server返回数据
// 环境不同，执行情况也会不同，全部数据可能一次接收完，也可能两次接收完，或者三次接收完
int telnet_login_whether_success_receive_data(int telnet_socket)
{
// 登录成功接收三次数据，telnet server连续三次send
// recv单次接收字节流长度filled
int filled = 0;
// recv接收的全部数据的长度length
int length = 0;
// telnet server 是否登录成功
int whether;
char buffer[BUFFER_SIZE];
bzero(buffer, BUFFER_SIZE);
while (1)
{
if ((filled = recv(telnet_socket, buffer + length, MAX_MSG_LENGTH, 0)) == ERROR)
{
printf("Accept Data Failed! \n");
return -1;
}
length += filled;
// 判断是否全部接收完返回数据
// 数据结尾部分：[xxxx@localhost ~]$
if (buffer[length - 3 < 0 ? 0 : length - 3] == ']')
{
// 接收完全部数据，结束接收
// 收到登录成功的全部数据，whether=1
whether = 1;
break;
}
if (buffer[length - 2 < 0 ? 0 : length - 2] == ':')
{
// 接收完全部数据，结束接收
// 收到登录失败的全部数据，whether=0
whether = 0;
break;
}
// 只接收最后一次send的全部数据
// bzero(buffer, BUFFER_SIZE);
}
bzero(back_string, STRING_MAX_SIZE);
strncpy(back_string, buffer, (strlen(buffer) > STRING_MAX_SIZE ? STRING_MAX_SIZE : strlen(buffer)));
printf("receive data from equipment: %s \n", buffer);
return whether;
}
// telnet发送命令到telnet server，命令结尾必须带'\n'
void send_cmd(int telnet_socket, char *cmd)
{
char buffer[BUFFER_SIZE];
bzero(buffer, BUFFER_SIZE);
strncpy(buffer, cmd, (strlen(cmd) > BUFFER_SIZE ? BUFFER_SIZE : strlen(cmd)));
if (send(telnet_socket, buffer, (strlen(buffer) + 1), 0) < 0)
{
printf("Send cmd Failed! \n");
return;
}
}
// telnet login 登录到server
void telnet_login(int telnet_socket)
{
// 是否登录成功，用户名和密码是否正确
int whether;
// localhost login:
tcp_client_receive_data(telnet_socket);
while (1)
{
// 控制端的用户名
strcpy(go_string, "username");
telnet_deal_data(go_string, dealed_string);
tcp_client_send_data(telnet_socket);
// calos@Password:
telnet_login_receive_password(telnet_socket);
// 控制端的密码
strcpy(go_string, "password");
telnet_deal_data(go_string, dealed_string);
tcp_client_send_data(telnet_socket);
// 判断是否登录成功
whether = telnet_login_whether_success_receive_data(telnet_socket);
if (whether)
{
// 登录成功 [xxxx@localhost ~]$
break;
}
// 登录失败，继续登录
}
}
// telnet返回数据处理，telnet server有时候一次返回全部数据，有时候两次甚至多次返回全部数据
void telnet_receive_data_add_deal(int telnet_socket)
{
char receive_buffer[BUFFER_SIZE];
// 做数据处理的temp_buffer
char temp_buffer[BUFFER_SIZE];
// 第一次出现某字符的位置location=&receive_buffer+字符的偏移地址
char *location;
// 第一次出现某字符的偏移地址
int location_number;
// 当次recv数据的长度
int filled = 0;
// recv全部数据的长度
int length = 0;
// 循环接收全部的返回数据
bzero(receive_buffer, BUFFER_SIZE);
while (1)
{
// 接受telnet server返回数据
if ((filled = recv(telnet_socket, receive_buffer + length, MAX_MSG_LENGTH, 0)) == ERROR)
{
printf("Client Recieve Data Failed! \n");
return;
}
length += filled;
// 判断telnet server返回数据是否全部收到
if (receive_buffer[length - 3 < 0 ? 0 : length - 3] == ']')
{
break;
}
}
// 只取第二次返回数据，针对一次性接收完数据的，需要去除第一次send的数据
// 第一次send的数据：xxxx\r\n
location = strchr(receive_buffer, '\n');
// 计算偏移地址
location_number = location - receive_buffer + 1;
bzero(temp_buffer, BUFFER_SIZE);
strncpy(temp_buffer, receive_buffer + location_number, BUFFER_SIZE);
bzero(receive_buffer, BUFFER_SIZE);
strncpy(receive_buffer, temp_buffer, BUFFER_SIZE);
bzero(back_string, STRING_MAX_SIZE);
strncpy(back_string, receive_buffer, (strlen(receive_buffer) > STRING_MAX_SIZE ? STRING_MAX_SIZE : strlen(receive_buffer)));
printf("receive data from equipment: %s \n", back_string);
}
// 当前设备操作结束条件：控制端输入END，结束当前设备操作
int finish_equipment_operation(int sock)
{
char buffer[BUFFER_SIZE];
bzero(buffer, BUFFER_SIZE);
strncpy(buffer, go_string, (strlen(go_string) > BUFFER_SIZE ? BUFFER_SIZE : strlen(go_string)));
if (strcmp(buffer, "END") == 0)
{
close(sock);
return 1;
}
else
{
return 0;
}
}
int main(void)
{
int telnet_socket = tcp_client_conn(TELNET_SERVER_NAME, TELNET_SERVER_PORT);
if (telnet_socket < 0)
{
return -1;
}
// telnet 自动协商
negotiate(telnet_socket);
// 登录
telnet_login(telnet_socket);
//命令回显
while (1)
{
// 输入需要执行的命令到go_string
strcpy(go_string, "ll");
telnet_deal_data(go_string, dealed_string);
send_cmd(telnet_socket, dealed_string);
telnet_receive_data_add_deal(telnet_socket);
// 设备操作结束条件
if (finish_equipment_operation(telnet_socket))
{
break;
}
}
// 异常退出，关闭socket
close(telnet_socket);
return 0;
}
