linux伪终端 telnet源码

最新推荐文章于 2021-05-07 22:08:23 发布
最新推荐文章于 2021-05-07 22:08:23 发布
阅读量3.4k 收藏 7
点赞数
文章标签： linux 终端 buffer struct thread socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq250941970/article/details/6722256
版权

 

pty_fun.cpp 

#include "pty_fun.h"

int ptym_open(char *pts_name, int pts_namesz)
{
	char *ptr;
	char fdm;
	/*
	 *return the name of the master device so that on failure
	 *the caller can print an error message. Null terminate to
	 *handle case where string lenth > pts_namesz
	 * */

	strncpy(pts_name, "/dev/ptmx", pts_namesz);
	pts_name[pts_namesz - 1] = '\0';

	fdm = posix_openpt(O_RDWR);
	if (fdm < 0)
		return OPEN_PTY_ERR;
	if (grantpt(fdm) < 0)
	{
		close(fdm);
		return GRANT_PTY_ERR;
	}
	if (unlockpt(fdm) < 0)
	{
		close(fdm);
		return UNLOCK_PTY_ERR;
	}
	if ((ptr = ptsname(fdm)) == NULL)
	{
		close(fdm);
		return GET_PTYS_NAME_ERR;
	}
	strncpy(pts_name, ptr, pts_namesz);
	pts_name[pts_namesz - 1] = '\0';

	return fdm;

}

int ptys_open(char *pts_name)
{
	int fds;
	if ((fds = open(pts_name, O_RDWR)) < 0)
		return OPEN_PTYS_ERR;
	return fds;
}

int pty_fork(int *ptrfdm, char *slave_name, int slave_namesz,
		const struct termios *slave_termiors,
		const struct winsize *slave_winsize, pid_t *ppid)
{
	int fdm, fds;
	pid_t pid;
	char pts_name[20];

	if ((fdm = ptym_open(pts_name, sizeof(pts_name))) < 0)
	{
		return fdm;
	}

	if (slave_name != NULL)
	{
		strncpy(slave_name, pts_name, slave_namesz);
		slave_name[slave_namesz - 1] = '\0';
	}

	if ((pid = fork()) < 0)
	{
		return FORK_ERR;
	}
	else if (pid == 0)
	{
		if (setsid() < 0)
		{
			return SETSID_ERR;
		}
		if ((fds = ptys_open(pts_name)) < 0)
		{
			close(fdm);
			return OPEN_PTYS_ERR;
		}
#ifdef TIOCSCTTY
		if (ioctl(fds, TIOCSCTTY, (char *) 0) < 0)
			return TIOCSCTTY_ERR;
#endif
//		if (slave_termiors != NULL)
//		{
//			if (tcsetattr(fds, TCSANOW, slave_termiors) < 0)
//				return INIT_ATTR_ERR;
//		}
//		if (slave_winsize != NULL)
//		{
//			if (ioctl(fds, TIOCSWINSZ, slave_winsize) < 0)
//				return INIT_ATTR_ERR;
//		}

		if (dup2(fds, STDIN_FILENO) != STDIN_FILENO)
			return DUP_STDIN_ERR;
		if (dup2(fds, STDOUT_FILENO) != STDOUT_FILENO)
			return DUP_STDOUT_ERR;
		if (dup2(fds, STDERR_FILENO) != STDERR_FILENO)
			return DUP_STDERR_ERR;
		if (fds != STDIN_FILENO && fds != STDOUT_FILENO && fds != STDERR_FILENO)
		{
			close(fds);
		}
		*ppid = 0;
		return 0;

	}
	else
	{
		*ptrfdm =fdm;
		*ppid = pid;
		return 0;
	}
}

 

 

pty_fun.h

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <linux/limits.h>
#include <features.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <fcntl.h>

//master pty
#ifndef OPEN_PTY_ERR
#define OPEN_PTY_ERR -1
#endif

#ifndef GRANT_PTY_ERR
#define GRANT_PTY_ERR -2
#endif

#ifndef UNLOCK_PTY_ERR
#define UNLOCK_PTY_ERR -3
#endif

#ifndef GET_PTYS_NAME_ERR
#define GET_PTYS_NAME_ERR -4
#endif

//pty slave
#ifndef OPEN_PTYS_ERR
#define OPEN_PTYS_ERR -5
#endif

#ifndef FORK_ERR
#define FORK_ERR -6
#endif

#ifndef SETSID_ERR
#define SETSID_ERR -7
#endif

#ifndef TIOCSCTTY_ERR
#define TIOCSCTTY_ERR -8
#endif

#ifndef INIT_ATTR_ERR
#define INIT_ATTR_ERR -9
#endif

#ifndef DUP_STDIN_ERR
#define DUP_STDIN_ERR -10
#endif

#ifndef DUP_STDOUT_ERR
#define DUP_STDOUT_ERR -11
#endif

#ifndef DUP_STDERR_ERR
#define DUP_STDERR_ERR -12
#endif




int ptym_open(char *pts_name, int pts_namesz);

int ptys_open(char *pts_name);

int pty_fork(int *ptrfdm, char *slave_name, int slave_namesz,
		const struct termios *slave_termiors,
		const struct winsize *slave_winsize, pid_t *ppid);


telnetserver.cpp

 

#include <stdarg.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <resolv.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <signal.h>
#include <getopt.h>
#include <pthread.h>

#include "pty_fun.h"

#define DEFAULTIP         "127.0.0.1"
#define DEFAULTPORT       "20013"
#define DEFAULTBACK       "10"
#define DEFAULTDIR        "/root"
#define DEFAULTLOG        "/tmp/telnet-server.log"
#define PTY_NAME_SIZE     20
#define MAX_BUFSIZE       512

typedef struct thread_arg
{
	int pty;
	int sockfd;
} thread_arg;

void prterrmsg(char *msg);
#define prterrmsg(msg)        { perror(msg); abort(); }
void wrterrmsg(char *msg);
#define wrterrmsg(msg)        { fputs(msg, logfp); fputs(strerror(errno), logfp);fflush(logfp); abort(); }

void prtinfomsg(char *msg);
#define prtinfomsg(msg)        { fputs(msg, stdout);  }
void wrtinfomsg(char *msg);
#define wrtinfomsg(msg)        {  fputs(msg, logfp); fflush(logfp);}

#define MAXBUF        1024

char buffer[MAXBUF + 1];
char *host = 0;
char *port = 0;
char *back = 0;
char *dirroot = 0;
char *logdir = 0;
unsigned char daemon_y_n = 0;
FILE *logfp;

#define MAXPATH        150

/*------------------------------------------------------
 *--- AllocateMemory - 分配空间并把d所指的内容复制
 *------------------------------------------------------
 */
void AllocateMemory(char **s, int l, char *d)
{
	*s = malloc(l + 1);
	bzero(*s, l + 1);
	memcpy(*s, d, l);
}

/*------------------------------------------------------
 *--- getoption - 分析取出程序的参数
 *------------------------------------------------------
 */
void getoption(int argc, char **argv)
{
	int c, len;
	char *p = 0;

	opterr = 0;
	while (1)
	{
		int option_index = 0;
		static struct option long_options[] =
		{
		{ "host", 1, 0, 0 },
		{ "port", 1, 0, 0 },
		{ "back", 1, 0, 0 },
		{ "dir", 1, 0, 0 },
		{ "log", 1, 0, 0 },
		{ "daemon", 0, 0, 0 },
		{ 0, 0, 0, 0 } };
		/* 本程序支持如一些参数：
		 * --host IP地址 或者 -H IP地址
		 * --port 端口 或者 -P 端口
		 * --back 监听数量 或者 -B 监听数量
		 * --dir 服务默认目录 或者 -D 服务默认目录
		 * --log 日志存放路径 或者 -L 日志存放路径
		 * --daemon 使程序进入后台运行模式
		 */
		c = getopt_long(argc, argv, "H:P:B:D:L", long_options, &option_index);
		if (c == -1 || c == '?')
			break;

		if (optarg)
			len = strlen(optarg);
		else
			len = 0;

		if ((!c && !(strcasecmp(long_options[option_index].name, "host"))) || c
				== 'H')
			p = host = malloc(len + 1);
		else if ((!c && !(strcasecmp(long_options[option_index].name, "port")))
				|| c == 'P')
			p = port = malloc(len + 1);
		else if ((!c && !(strcasecmp(long_options[option_index].name, "back")))
				|| c == 'B')
			p = back = malloc(len + 1);
		else if ((!c && !(strcasecmp(long_options[option_index].name, "dir")))
				|| c == 'D')
			p = dirroot = malloc(len + 1);
		else if ((!c && !(strcasecmp(long_options[option_index].name, "log")))
				|| c == 'L')
			p = logdir = malloc(len + 1);
		else if ((!c
				&& !(strcasecmp(long_options[option_index].name, "daemon"))))
		{
			daemon_y_n = 1;
			continue;
		}
		else
			break;
		bzero(p, len + 1);
		memcpy(p, optarg, len);
	}
}

void *thread_recv_add_write_pyt(void *arg)
{
	int ret, sockfd, pty;
	char buffer[MAX_BUFSIZE];
	thread_arg *arg1 = (thread_arg*) arg;

	sockfd = arg1->sockfd;
	pty = arg1->pty;

	while (1)
	{
		memset(buffer, 0, MAX_BUFSIZE);
		ret = recv(sockfd, buffer, MAX_BUFSIZE, 0);
		if (ret < 0)
		{
			continue;
		}
		printf("%s", buffer);
		write(pty, buffer, strlen(buffer));
	}
}

void read_write_pty(int pty, int sockfd)
{
	char buffer[MAX_BUFSIZE];
	int ret;
	//	pthread_t thread_t;
	//	pthread_attr_t attr;
	//	thread_arg arg;
	//	arg.pty = pty;
	//	arg.sockfd = sockfd;
	//
	//	if ((ret = pthread_create(&thread_t, &attr, thread_recv_add_write_pyt,
	//			(void*) &arg)))
	//	{
	//		perror("thread create recieve message and write to pty err:\n");
	//	}

	pid_t pid;
	if ((pid = fork()) < 0)
	{
		perror("");
		exit(1);
	}
	else if (pid == 0)
	{
		while (1)
		{
			memset(buffer, 0, MAX_BUFSIZE);
			ret = recv(sockfd, buffer, MAX_BUFSIZE - 1, 0);
			if (ret < 0)
			{
				continue;
			}
			//printf("%s", buffer);
			write(pty, buffer, strlen(buffer));
		}
	}

	memset(buffer, 0, MAX_BUFSIZE);

	while (ret = read(pty, buffer, MAX_BUFSIZE - 1))
	{
		buffer[ret - 1] = 0; //read是读不到字符串结束符的，需要自己添加，否则printf会出错
		if (ret <= 0)
		{
			break;
		}
		fflush(stdout);//这步很重要，std中经常有数据滞留在存储区中需要此函数刷新
		printf("%s", buffer);//打印出结果
		send(sockfd, buffer, strlen(buffer), 0);
		memset(buffer, 0, MAX_BUFSIZE);
	}
	return;
}

int main(int argc, char **argv)
{
	struct sockaddr_in addr;
	int sock_fd, addrlen;

	/* 获得程序工作的参数，如 IP 、端口、监听数、网页根目录、目录存放位置等 */
	getoption(argc, argv);

	if (!host)
	{
		addrlen = strlen(DEFAULTIP);
		AllocateMemory(&host, addrlen, DEFAULTIP);
	}
	if (!port)
	{
		addrlen = strlen(DEFAULTPORT);
		AllocateMemory(&port, addrlen, DEFAULTPORT);
	}
	if (!back)
	{
		addrlen = strlen(DEFAULTBACK);
		AllocateMemory(&back, addrlen, DEFAULTBACK);
	}
	if (!dirroot)
	{
		addrlen = strlen(DEFAULTDIR);
		AllocateMemory(&dirroot, addrlen, DEFAULTDIR);
	}
	if (!logdir)
	{
		addrlen = strlen(DEFAULTLOG);
		AllocateMemory(&logdir, addrlen, DEFAULTLOG);
	}

	/* fork() 两次处于后台工作模式下 */
	if (daemon_y_n)
	{
		if (fork())
			exit(0);
		if (fork())
			exit(0);
		close(0), close(1), close(2);
		logfp = fopen(logdir, "a+");
		if (!logfp)
			exit(0);
	}

	/* 处理子进程退出以免产生僵尸进程 */
	signal(SIGCHLD, SIG_IGN);

	/* 创建 socket */
	if ((sock_fd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
	{
		if (!daemon_y_n)
		{
			prterrmsg("socket()");
		}
		else
		{
			wrterrmsg("socket()");
		}
	}

	/* 设置端口快速重用 */
	addrlen = 1;

	addr.sin_family = AF_INET;
	addr.sin_port = htons(atoi(port));
	addr.sin_addr.s_addr = htonl(INADDR_ANY);
	addrlen = sizeof(struct sockaddr_in);

	setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &addrlen, sizeof(addrlen));
	/* 绑定地址、端口等信息 */
	if (bind(sock_fd, (struct sockaddr *) &addr, addrlen) < 0)
	{
		if (!daemon_y_n)
		{
			prterrmsg("bind()");
		}
		else
		{
			wrterrmsg("bind()");
		}
	}

	/* 开启临听 */
	if (listen(sock_fd, atoi(back)) < 0)
	{
		if (!daemon_y_n)
		{
			prterrmsg("listen()");
		}
		else
		{
			wrterrmsg("listen()");
		}
	}

	printf("host=%s port=%s back=%s dirroot=%s logdir=%s %s是后台工作模式(进程ID：%d)\n",
			host, port, back, dirroot, logdir, daemon_y_n ? "" : "不", getpid());

	while (1)
	{
		int new_fd;
		addrlen = sizeof(struct sockaddr_in);
		/* 接受新连接请求 */
		new_fd = accept(sock_fd, (struct sockaddr *) &addr, &addrlen);
		if (new_fd < 0)
		{
			if (!daemon_y_n)
			{
				prterrmsg("accept()");
			}
			else
			{
				wrterrmsg("accept()");
			}
			break;
		}
		bzero(buffer, MAXBUF + 1);
		sprintf(buffer, "连接来自于: %s:%d\n", inet_ntoa(addr.sin_addr), ntohs(
				addr.sin_port));
		if (!daemon_y_n)
		{
			prtinfomsg(buffer);
		}
		else
		{
			wrtinfomsg(buffer);
		}
		/* 产生一个子进程去处理请求，当前进程继续等待新的连接到来 */
		if (!fork())
		{
			int ret, ptrfdm;
			char slave_name[PTY_NAME_SIZE];
			struct termios slave_termiors;
			struct winsize slave_winsize;
			pid_t ppid;

			ret = -1;
			ptrfdm = -1;
			memset(slave_name, 0, PTY_NAME_SIZE);
			ppid = -1;

			ret = pty_fork(&ptrfdm, slave_name, PTY_NAME_SIZE, &slave_termiors,
					&slave_winsize, &ppid);

			if (ret < 0)
			{
				printf("pty_fork err ! ret = %d", ret);
				return -1;
			}

			if (ppid < 0)
			{
				printf("pty_fork err !");
				return -1;
			}
			else if (ppid == 0)
			{
				execl("/bin/bash", "bash", NULL);
			}
			else
			{
				read_write_pty(ptrfdm, new_fd);

			}
		}
		close(new_fd);
	}
	close(sock_fd);
	return 0;
}



 

qq250941970
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
telnet 协议以及源码解析
Learning
04-22 1837
将asic码的普通字符与控制字符分开传送。 https://www.cnblogs.com/binarylei/p/8964646.html
telnet源码分析
09-16 2988
telnet是一个telnet客户端程序 下载地址：http://www.busybox.net/ 解压缩后进入busybox目录 make defconfig make make install 然后会生成 _install 目录，里面就是编译好的可执行文件 源码
telnetd源代码分析之输入一个字符的四个阶段
linux-0.11调试教程
12-20 1805
telnetd源代码分析之输入一个字符的四个阶段
telnet源码（客户端，服务端，linux系统）
03-27
telnet源码包， 包括客户端，服务端，编译没有问题，测试可以使用，对于像了解telnet有很大帮助
Linux下安装telnet-server服务
我的代码空间
12-15 7894
Linux下安装telnet-server服务 一、telnet分为客户端和服务器端程序，所以，首先查看本机是否安装有telnet server服务，        命令为：rpm –qa | grep telnet       从图中可以看出，本机没有安装telnet server   二、检查Linux系统版本，搜索相应的rpm安装包，获取下载地址         检查版本命令
linux下telnet源代码
12-06
Linux下的telnet是一个远程登录协议的客户端实现，它允许用户通过网络连接到远程主机并进行交互。这个程序的源代码提供了深入理解TCP/IP网络通信、命令行接口设计以及Linux系统编程的机会。在本文中，我们将深入探讨...
linux下完整的telnet 客户端实现源码
01-12
这个“linux下完整的telnet客户端实现源码”提供了在CentOS 6.5环境下编译和运行telnet客户端的完整流程。 首先，telnet协议基于TCP/IP，它使用了应用层的23号端口进行通信。客户端源码通常包括解析telnet协议的...
linux下的telnet客户端完整实现源码（c语言）
04-08
在实际使用这个源码时，你需要先解压文件，然后在终端中进入源码目录，通过`make`命令编译源码。编译成功后，可以运行生成的可执行文件，连接到指定的远程服务器。例如，如果服务器的IP是`192.168.1.1`，端口是`23`...
qt telnet 源码 v2.1
最新发布
07-28
QT Telnet 源码 V2.1 是一个基于 Qt 框架实现的 Telnet 客户端软件，用于连接和支持 Telnet 协议的远程服务器。Qt 是一个广泛使用的跨平台应用程序开发框架，支持多种操作系统，如 Windows、Linux 和 macOS。这个...
Linux伪终端 telnet源码
敏于思，慎于行
11-29 1334
pty_fun.cpp  #include "pty_fun.h"     int ptym_open(char *pts_name, int pts_namesz)  {      char *ptr;      char fdm;      /*      *return the name of the master device so that on failure      *
telnet服务器源码
08-25
telnet服务器源码，本人已经用过，不错的资源
Telnet服务器端最简单实例源码
04-09
一个Telnet服务器端完整的最简单实例源码在VC++6.0、7.0、8.0下测试通过Made by Lei FANE-mail: ielnaf@qq.com
telnet 客户端服务器源码
03-05
绝密资源, unix平台 telnet客户端服务器源码.
telnet服务器
09-07
可以实现Telnet服务器功能的C语言源代码，可以实现客户端掉线重连后继续发送数据、多个客户端同时登陆的功能。无伪终端，仅用来发送命令！！！本质上为TCP并发服务器，本地编译或者交叉编译之后直接运行可执行文件即可，供TCP网络编程新手学习使用。
linux安装telnet和ssh的安装
08-31
linux系统安装telnet和ssh的详细步骤和方法。
c语言简单实现telnet客户端
热门推荐
一去二三里...的博客
04-10 1万+
#include #define DO 0xfd #define WONT 0xfc #define WILL 0xfb #define DONT 0xfe #define CMD 0xff #define CMD_ECHO 1 #define CMD_WINDOW_SIZE 31 #define IAC 255 #define SB 250 #define SE 240 #define BU
linux远程终端源码,Linux源码分析报告——字符终端设备
weixin_39539733的博客
05-07 121
《Linux源码分析报告——字符终端设备》由会员分享，可在线阅读，更多相关《Linux源码分析报告——字符终端设备(6页珍藏版)》请在人人文库网上搜索。1、源码分析报告字符终端设备字符终端设备的打开操作当我们需要使用一个字符终端设备的时候，首先需要打开它。而打开这一动作，在下面通常是由一些守护进程所发起的，比如当我们在登录到一个虚终端的时候，通常是由一个进程来打开这个虚终端(从 的的版本开始，开始...
用C自己编写telnet服务器
Elta学习
03-15 2337
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #in
linux如何打开telnet终端窗口
06-06
首先需要确认你的Linux系统是否已经安装了telnet客户端程序。如果没有安装，可以使用以下命令安装： ``` sudo apt-get update sudo apt-get install telnet ``` 安装完成后，可以使用以下命令打开telnet终端窗口：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值