精华内容
下载资源
问答
  • 这是本人基于c++开发的TCP通讯的轮子,并且封装成,兼容window和linux,方便使用,包含.cpp和.h两个文件,亲测可用,注释详细,欢迎参考
  • 嵌入式Linux实现TCP/IP通信 2016年03月27日 11:18:55 蓝鸟云 阅读数:1930 标签: 嵌入式 linux TCP IP 通信 更多 个人分类: 嵌入式Linux 版权声明:本文为博主原创文章,未经博主允许不得转载。 ...

    嵌入式Linux实现TCP/IP通信
    2016年03月27日 11:18:55 蓝鸟云 阅读数:1930 标签: 嵌入式 linux TCP IP 通信 更多
    个人分类: 嵌入式Linux
    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/yongz12/article/details/50990759
    实现client向server发送数据。

    server里面的rev要用nsockfd

    client里面的send用sockfd

    tcp_server代码:

    #include <stdlib.h>
    #include <stdio.h>
    #include <errno.h>
    #include <string.h>
    #include <sys/types.h>
    #include <netinet/in.h>
    #include <sys/wait.h>
    #include <sys/socket.h>
    #include <unistd.h>
    #include <arpa/inet.h>

    #define PORT 8088 // The port which is communicate with server
    #define BACKLOG 10

    #define LENGTH 512 // Buffer length
    int main ()
    {
    int iR;
    int sockfd; // Socket file descriptor
    int nsockfd; // New Socket file descriptor
    int num;
    int sin_size; // to store struct size
    char sdbuf[LENGTH]; // Send buffer
    char revbuf[LENGTH]; // Receive buffer
    struct sockaddr_in addr_local;
    struct sockaddr_in addr_remote;
    // char sendstr[16]= {“123456789 abcde”};

    	/* Get the Socket file descriptor */  
    	if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 )  
    	{   
        	printf ("ERROR: Failed to obtain Socket Despcritor.\n");
        	return (0);
    	} else {
        	printf ("OK: Obtain Socket Despcritor sucessfully.\n");
    	}
    
    	/* Fill the local socket address struct */
    	addr_local.sin_family = AF_INET;           	// Protocol Family
    	addr_local.sin_port = htons (PORT);         	// Port number
    	addr_local.sin_addr.s_addr  = htonl (INADDR_ANY);  // AutoFill local address
    	memset (addr_local.sin_zero,0,8);          		// Flush the rest of struct
    
    	/*  Blind a special Port */
    	if( bind(sockfd, (struct sockaddr*)&addr_local, sizeof(struct sockaddr)) == -1 )
    	{  
    	  	printf ("ERROR: Failed to bind Port %d.\n",PORT);
        	return (0);
    	} else {
        	printf("OK: Bind the Port %d sucessfully.\n",PORT);
    	}
    
    	/*  Listen remote connect/calling */
    	if(listen(sockfd,BACKLOG) == -1)    
    	{  
        	printf ("ERROR: Failed to listen Port %d.\n", PORT);
        	return (0);
    	} else {
        	printf ("OK: Listening the Port %d sucessfully.\n", PORT);
    	}
    
    	while(1)
    	{  
        	sin_size = sizeof(struct sockaddr_in);  
        
        	/*  Wait a connection, and obtain a new socket file despriptor for single connection */
        	if ((nsockfd = accept(sockfd, (struct sockaddr *)&addr_remote, (socklen_t *__restrict)&sin_size)) == -1)
        	{  
            	printf ("ERROR: Obtain new Socket Despcritor error.\n");
            	continue;
        	} else {
            	printf ("OK: Server has got connect from %s.\n", inet_ntoa(addr_remote.sin_addr)); 
        	}
        
    	
        	/* Child process */
        	if(!fork())                    
        	{  
            	
            	    while (strcmp(revbuf,"exit") != 0)
            	    { 
    				//接收数据
    				memset (revbuf,0,LENGTH);
    				
    				if((num = recv(nsockfd, revbuf, LENGTH, 0))>0)
    				{
    					printf ("OK: Receviced numbytes = %d\n", num);
    					revbuf[num] = '\0';
    					printf ("OK: Receviced string is: %s\n", revbuf);
    				}
    				
    				
            	    }
         	}  
    		
         	close(nsockfd);  
         	while(waitpid(-1, NULL, WNOHANG) > 0);   
    
     }    
    

    }

    tcp_client代码:
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <errno.h>
    #include <string.h>
    #include <netdb.h>
    #include <sys/types.h>
    #include <netinet/in.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>

    #define PORT 8088 // The port which is communicate with server
    #define LENGTH 256 // Buffer length

    int main(int argc, char *argv[])
    {
    int iR; //
    int nsockfd; // New Socket file descriptor
    int sockfd; // Socket file descriptor
    int num; // Counter of received bytes
    char revbuf[LENGTH]; // Receive buffer
    char sdbuf[LENGTH]; // Send buffer
    struct sockaddr_in remote_addr; // Host address information

    	/* Check parameters number */
    	if (argc != 2)                     
    	{    
        	printf ("Usage: client HOST IP (ex: ./client 192.168.7.239).\n");
        	return (0);
    	}
    
    	/* Get the Socket file descriptor */
    	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    	{
        	printf("ERROR: Failed to obtain Socket Descriptor!\n");
        	return (0);
    	}
    
    	/* Fill the socket address struct */
    	remote_addr.sin_family = AF_INET;              	// Protocol Family
    	remote_addr.sin_port = htons(PORT);           		// Port number
    	inet_pton(AF_INET, argv[1], &remote_addr.sin_addr); 	// Net Address
    	memset (remote_addr.sin_zero,0,8);                 	// Flush the rest of struct
    
    	/* Try to connect the remote */
    	if (nsockfd=connect(sockfd, (struct sockaddr *)&remote_addr,  sizeof(struct sockaddr)) == -1) 
    	{
        	printf ("ERROR: Failed to connect to the host!\n");
        	return (0);
    	} else {
        	printf ("OK: Have connected to the %s\n",argv[1]);
    	}
    
    	
        
    		/* Try to connect the server */
    		printf("You can enter string to send, and press 'exit' to end the connect.\n");
    		 
    		while(strcmp(sdbuf,"exit") != 0)
    		{      
    			
    			/* 发送数据------------ */
    			iR=(int)scanf("%s",sdbuf);
    			if(iR>512)break;
    			if((num=send(sockfd,sdbuf,strlen(sdbuf),0))==-1)
    			{
    				printf("ERROR:Fail to send string\n");
    				close(nsockfd);
    				exit(1);
    			}
    			printf("OK:Sent %d bytes sucessful,please enter again.\n",num);
    		}
    		
    	
    	
    	printf("Exit connect,Byebye!\n");
    	close (sockfd);
    	return (0);
    

    }

    开发板上执行tcp_client,主机上执行tcp_server
    在Linux系统上编译tcp_client指令:arm-none-linux-gnueabi-gcc tcp_client.c -o client

    编译tcp_server指令:gcc tcp_server.c -o tcp_server

    展开全文
  • 前段时间做项目用到了网络通讯,自己造了TCP通讯的轮子,能同时在window和linux下运行,并且封装成,方便以后使用,考虑到自己也一直在互联网上获取资源,现在也把我做的轮子也分享给大家,欢迎参考~ 完整代码附...

    前段时间做项目用到了网络通讯,自己造了TCP通讯的轮子,能同时在window和linux下运行,并且封装成类,方便以后使用,考虑到自己也一直在互联网上获取资源,现在也把我做的轮子也分享给大家,欢迎参考~

    完整代码附在下面,如果大家不想复制,可直接从这下载:https://download.csdn.net/download/qq_18108083/10798550

    (1) XTcp.h

    #ifndef XTCP_H
    #define XTCP_H
    
    #include <string>
    
    class XTcp
    {
    public:
    	int CreateSocket();				 //创建套接字
    	bool Bind(unsigned short port);  //绑定端口号
    	bool Listen(unsigned short num); //监听端口号
    	bool SetBlock(bool isblock);  //设置阻塞模式  (希望只有在connect的时候是非阻塞的,而接收数据时候是阻塞的)
    	bool Connect(const char *ip = "192.168.0.123", unsigned short port = 8000, int sec = 3);
    	bool Connect(int sec = 3);
    	XTcp Accept();                   //返回XTcp对象,接收连接
    	void Close();							//关闭连接
    	int Recv(char *buf, int size);          //接收数据
    	int Send(const char *buf, int size);	//发送数据
    	int SetRecvTimeout(int sec = 1);			 //设置udp接收超时
    	int SetSendTimeout(int sec = 1);		     //设置udp发送超时
    
    
    	char clientip[16];						//存放接收到的client ip
    	unsigned short clientport = 0;			//存放接收到的client port
    
    	XTcp(unsigned short port = 8000);
        XTcp(char *ip,unsigned short port);
    	virtual ~XTcp();
    
    
    private:
    	char tcp_serverip[16] = "";   //tcp_serverip 服务端ip
    	int tsock = 0;							//tcp客户端的socket,create自动生成
    	unsigned short tport = 0;				//接收main函数中的参数  要传入Connect
    };
    
    #endif

    (2) XTcp.cpp

    #include "XTcp.h"
    #include <iostream>
    #include "string.h"
    
    #ifdef WIN32
    #include <Windows.h>
    #define socklen_t int
    #else
    #include <arpa/inet.h>
    #define closesocket close    //宏定义替换函数
    #include <unistd.h>
    #include <fcntl.h>
    #include <pthread.h>
    
    #define strcpy_s strcpy
    #endif
    
    XTcp::XTcp(unsigned short port)
    {
    	//初始化动态链接库
    	//引用lib库
    #ifdef WIN32  //linux下不用初始化网络库
    	static bool first = true;
    	if (first)
    	{
    		first = false;						 //只在首次进入时初始化网络库
    		WSADATA ws;					         //加载Socket库   项目属性-链接器-输入加上 ws2_32.lib
    		WSAStartup(MAKEWORD(2, 2), &ws);     //动态库引用加1    
    	}
    
    #endif
    	tport = port;  //接收main函数的参数   //
    }
    
    XTcp::XTcp(char *ip,unsigned short port)
    {
    	//初始化动态链接库
    	//引用lib库
    #ifdef WIN32  //linux下不用初始化网络库
    	static bool first = true;
    	if (first)
    	{
    		first = false;						 //只在首次进入时初始化网络库
    		WSADATA ws;					         //加载Socket库   项目属性-链接器-输入加上 ws2_32.lib
    		WSAStartup(MAKEWORD(2, 2), &ws);     //动态库引用加1    
    	}
    
    #endif
    	strcpy(tcp_serverip,ip);   			//tcp_serverip 服务端ip
    	tport = port;  //接收main函数的参数   //
    }
    
    
    
    XTcp::~XTcp()
    {
    	delete this;
    }
    
    
    int XTcp::CreateSocket()				 //创建套接字
    {
    	//创建socket (TCP/IP协议 TCP)
    	tsock = socket(AF_INET, SOCK_STREAM, 0);    //直接创建socket返回给XTcp的成员函数
    	if (tsock == -1)
    	{
    		printf("create tcp socket failed.\n");
    		return -1;
    	}
    	else
    	{
    		printf("create tcp socket successed.\n");
    		return tsock;
    	}
    }
    
    bool XTcp::Bind(unsigned short port)  //绑定并监听端口号(服务端用)
    {
    	sockaddr_in saddr;              //数据结构
    	saddr.sin_family = AF_INET;     //协议
    	saddr.sin_port = htons(port);   //端口,主机字节序(小端方式)转换成网络字节序(大端方式)             
    	saddr.sin_addr.s_addr = htonl(INADDR_ANY);   //绑定IP到广播地址INADDR_ANY 0.0.0.0  为了兼容linux   
    
    	if (bind(tsock, (sockaddr*)&saddr, sizeof(saddr)) != 0)  
    	{
    		printf("tcp bind port %d failed.\n", port);
    		return false;
    	}
    	printf("tcp bind port %d success.\n", port);
    	return true;
    }
    
    bool XTcp::Listen(unsigned short num) //监听端口号
    {
    	int re = listen(tsock, 10);   //套接字,最大请求队列的长度   进入阻塞状态
    	if(!re)
    	{
    		printf("tcp socket listen start.\n");
    		return false;
    	}
    	else
    	{
    		printf("tcp socket listen failed.\n");
    		return true;
    	}
    }
    
    bool XTcp::SetBlock(bool isblock)  //设置阻塞模式  (希望只有在connect的时候是非阻塞的,而接收数据时候是阻塞的)
    {
    	if (tsock <= 0)
    	{		
    		printf("set tcp socket block failed.\n");
    		return false;
    	}
    #ifdef WIN32
    	unsigned long ul = 0;
    	if (!isblock) ul = 1;
    	ioctlsocket(tsock, FIONBIO, &ul);    //设置socket的模式(0 阻塞模式,1 非阻塞模式<connect就立即返回>)
    #else
    	int flags = fcntl(tsock, F_GETFL, 0);  //获取socket的属性
    	if (flags < 0)return false; //获取属性出错
    	if (isblock)
    	{
    		flags = flags&~O_NONBLOCK;  //把非阻塞这位设为0
    	}
    	else
    	{
    		flags = flags | O_NONBLOCK; //把非阻塞这位设为1
    	}
    	if (fcntl(tsock, F_SETFL, flags))return false;  //把标准位设回去
    #endif
    
    	if (isblock==0)
    		printf("set tcp socket not block success.\n");
    	if (isblock==1)
    		printf("set tcp socket block success.\n");
    
    	return true;
    }
    
    bool XTcp::Connect(const char *ip, unsigned short port , int sec)
    {
    	if (tsock <= 0)	return false;
    
    	sockaddr_in saddr;   //设置连接对象的结构体
    	saddr.sin_family = AF_INET;
    	saddr.sin_port = htons(port);
    	saddr.sin_addr.s_addr = inet_addr(ip);  //字符串转整型
    
    	SetBlock(false);    //将socket改成非阻塞模式,此时它会立即返回  所以通过fd_set
    	fd_set rfds, wfds;	    //文件句柄数组,在这个数组中,存放当前每个文件句柄的状态
    
    	if (connect(tsock, (sockaddr*)&saddr, sizeof(saddr)) != 0)   //此时connect马上返回,状态为未成功连接
    	{
    
    	    FD_ZERO(&rfds);  //首先把文件句柄的数组置空
    	    FD_ZERO(&wfds);  
    	    FD_SET(tsock, &rfds);   //把sock的网络句柄加入到该句柄数组中
    	    FD_SET(tsock, &wfds); 
    
    
    		timeval tm;  //超时参数的结构体
    		tm.tv_sec = sec;
    		tm.tv_usec = 0;
    
    		int selres = select(tsock + 1, &rfds, &wfds, NULL, &tm);   //(阻塞函数)(监听的文件句柄的最大值加1,可读序列文件列表,可写的序列文件列表,错误处理,超时)使用select监听文件序列set是否有可读可写,这里监听set数组(里面只有sock),只要其中的句柄有一个变得可写(在这里是sock连接成功了以后就会变得可写,就返回),就返回
    		switch (selres)
    		{
    
    			case -1:
                        printf("select error\n");  
    					return false;
                case 0:  
                   		printf("select time out\n");  
    					return false;
    			default:
    					if (FD_ISSET(tsock, &rfds) || FD_ISSET(tsock, &wfds)) 
    					{
    							connect(tsock, (sockaddr*)&saddr, sizeof(saddr));    //再次连接一次进行确认
    							int err = errno;  
    							if  (err == EISCONN||err == EINPROGRESS)     //已经连接到该套接字 或 套接字为非阻塞套接字,且连接请求没有立即完成
    							{  
    					    		printf("connect %s : %d finished(success).\n",ip,port);  
    							    SetBlock(true);   //成功之后重新把sock改成阻塞模式,以便后面发送/接收数据
    							    return true;
    							}  
    							else  
    							{  
    							    printf("connect %s : %d finished(failed). errno = %d\n",ip,port,errno);  
    							   // printf("FD_ISSET(sock_fd, &rfds): %d\n FD_ISSET(sock_fd, &wfds): %d\n", FD_ISSET(sock_fd, &rfds) , FD_ISSET(sock_fd, &wfds));  
    							    return false;
    							}  
    					}
    					else
    						{
    							    printf("connect %s : %d finished(failed).",ip,port);  
    							    return false;
    						}
    		}
    
    	}
    	else  //连接正常
    	{
    		SetBlock(true);   //成功之后重新把sock改成阻塞模式,以便后面发送/接收数据
    		printf("connect %s : %d finished(success).\n",ip,port);  
    		return true;
    		}
    }
    
    bool XTcp::Connect(int sec)
    {
    	if (tsock <= 0)	return false;
    
    	sockaddr_in saddr;   //设置连接对象的结构体
    	saddr.sin_family = AF_INET;
    	saddr.sin_port = htons(tport);
    	saddr.sin_addr.s_addr = inet_addr(tcp_serverip);  //字符串转整型
    
    	SetBlock(false);    //将socket改成非阻塞模式,此时它会立即返回  所以通过fd_set
    	fd_set rfds, wfds;	    //文件句柄数组,在这个数组中,存放当前每个文件句柄的状态
    
    	if (connect(tsock, (sockaddr*)&saddr, sizeof(saddr)) != 0)   //此时connect马上返回,状态为未成功连接
    	{
    
    	    FD_ZERO(&rfds);  //首先把文件句柄的数组置空
    	    FD_ZERO(&wfds);  
    	    FD_SET(tsock, &rfds);   //把sock的网络句柄加入到该句柄数组中
    	    FD_SET(tsock, &wfds); 
    
    
    		timeval tm;  //超时参数的结构体
    		tm.tv_sec = sec;
    		tm.tv_usec = 0;
    
    		int selres = select(tsock + 1, &rfds, &wfds, NULL, &tm);   //(阻塞函数)(监听的文件句柄的最大值加1,可读序列文件列表,可写的序列文件列表,错误处理,超时)使用select监听文件序列set是否有可读可写,这里监听set数组(里面只有sock),只要其中的句柄有一个变得可写(在这里是sock连接成功了以后就会变得可写,就返回),就返回
    		switch (selres)
    		{
    
    			case -1:
                        printf("select error\n");  
    					return false;
                case 0:  
                   		printf("select time out\n");  
    					return false;
    			default:
    					if (FD_ISSET(tsock, &rfds) || FD_ISSET(tsock, &wfds)) 
    					{
    							connect(tsock, (sockaddr*)&saddr, sizeof(saddr));    //再次连接一次进行确认
    							int err = errno;  
    							if  (err == EISCONN||err == EINPROGRESS)     //已经连接到该套接字 或 套接字为非阻塞套接字,且连接请求没有立即完成
    							{  
    							    printf("connect %s : %d finished(success).\n",tcp_serverip,tport);  
    							    SetBlock(true);   //成功之后重新把sock改成阻塞模式,以便后面发送/接收数据
    							    return true;
    							}  
    							else  
    							{  
    							    printf("connect %s : %d finished(failed). errno = %d\n",tcp_serverip,tport,errno);  
    							   // printf("FD_ISSET(sock_fd, &rfds): %d\n FD_ISSET(sock_fd, &wfds): %d\n", FD_ISSET(sock_fd, &rfds) , FD_ISSET(sock_fd, &wfds));  
    							    return false;
    							}  
    					}
    					else
    						{
    							    printf("connect %s : %d finished(failed).",tcp_serverip,tport);  
    							    return false;
    						}
    		}
    
    	}
    	else  //连接正常
    	{
    		printf("connect %s : %d finished(success).\n",tcp_serverip,tport);  
    		SetBlock(true);   //成功之后重新把sock改成阻塞模式,以便后面发送/接收数据
    		return true;
    	}
    }
    
    
    XTcp XTcp::Accept()                   //返回XTcp对象,接收连接
    {
    	XTcp tcp;     //先定义一个XTcp对象,一会返回它
    
    	sockaddr_in caddr;
    	socklen_t len = sizeof(caddr);
    
    	tcp.tsock = accept(tsock, (sockaddr*)&caddr, &len);  //(阻塞)接收连接  ,会创建一个新的socket,一般扔到一个单独线程与这个客户端进行单独通信,之前的sock只用来建立连接
    	if (tcp.tsock <= 0)	return tcp;   //出错
    	printf("accept client %d\n", tcp.tsock);
    	char *ip = inet_ntoa(caddr.sin_addr);				 //解析出IP地址  ,转换到字符串
    
    	strcpy_s(tcp.clientip, ip);
    	tcp.clientport = ntohs(caddr.sin_port);		 //解析出端口,转换成主机字节序
    	printf("client ip is %s,port is %d\n", tcp.clientip, tcp.clientport);  //打印ip和端口
    	return tcp;
    
    }
    
    void XTcp::Close()                    //关闭连接
    {
    	if (tsock <= 0) return;  //socket出错
    	closesocket(tsock);		//已宏定义
    	tsock = 0;
    }
    
    int XTcp::Recv(char *buf, int size)                      //接收数据
    {
    	return recv(tsock, buf, size, 0);
    }
    
    int XTcp::Send(const char *buf, int size)					     //发送数据
    {
    	int sendedSize = 0;   //已发送成功的长度
    	while (sendedSize != size)   //若没发送完成,则从断点开始继续发送 直到完成
    	{
    		int len = send(tsock, buf + sendedSize, size - sendedSize, 0);
    		if (len <= 0)break;
    		sendedSize += len;
    	}
    	return sendedSize;
    }
    
    int XTcp::SetRecvTimeout(int sec)   //设置tcp接收超时
    {
    #ifdef WIN32
    	int tcp_rev_time = sec * 1000;
    	if (setsockopt(tsock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tcp_rev_time, sizeof(int))<0)
    	{
    		printf("set tcp receive failed.\n");
    		return -1;
    	}
    	printf("set tcp recv timeout success. %d seconds.\n", sec);
    	return 0;
    #else
    	struct timeval tcp_rev_time;
    	tcp_rev_time.tv_sec = sec;
    	tcp_rev_time.tv_usec = 0;
    	if (setsockopt(tsock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tcp_rev_time, sizeof(tcp_rev_time))<0)
    	{
    		printf("set tcp receive failed.\n");
    		return -1;
    	}
    	printf("set tcp recv timeout success. %d seconds.\n", sec);
    	return 0;
    #endif
    }
    
    int XTcp::SetSendTimeout(int sec)   //设置tcp发送超时
    {
    #ifdef WIN32
    	int tcp_send_time = sec;
    	if (setsockopt(tsock, SOL_SOCKET, SO_SNDTIMEO, (char *)&tcp_send_time, sizeof(int))<0)
    	{
    		printf("set tcp send failed.\n");
    		return -1;
    	}
    	return 0;
    	printf("set tcp recv timeout success. %d seconds.\n", sec);
    #else
    	struct timeval tcp_send_time;
    	tcp_send_time.tv_sec = sec;
    	tcp_send_time.tv_usec = 0;
    	if (setsockopt(tsock, SOL_SOCKET, SO_SNDTIMEO, (char *)&tcp_send_time, sizeof(tcp_send_time))<0)
    	{
    		printf("set tcp send failed.\n");
    		return -1;
    	}
    	printf("set tcp recv timeout success. %d seconds.\n", sec);
    	return 0;
    #endif
    }

     

    展开全文
  • netstat命令用于显示网络状态,利用netstat指令可以查询整个linux系统的网络情况。 常用功能 netstat是控制台命令,常用于监控TCP/IP网络,可以显示路由表、实际的网络连接以及每一个网络接口设备的状态信息。 ...

    netstat命令

    netstat命令用于显示网络状态,利用netstat指令可以查询整个linux系统的网络情况。

    常用功能
    netstat是控制台命令,常用于监控TCP/IP网络,可以显示路由表、实际的网络连接以及每一个网络接口设备的状态信息。
    netstat用于显示与IP、TCP、UDP和ICMP协议相关的统计数据,一般用于检验本机各端口的网络连接情况。

    基本语法
    netstat [选项]

    选项说明
    -a(all):显示所有连线中的Socket,默认不显示LISTEN相关;
    -t(tcp):仅显示tcp相关的选项,TCP传输协议的连线状况;
    -u(udp) :仅显示udp相关的选项,UDP传输协议的连线状况;
    -c(continuous):持续列出网络状态;
    -g(groups):显示多重广播功能群组组员名单;
    在这里插入图片描述
    -i(interfaces) :显示网络界面信息表单;
    -l(listening):列出在监听(listening)的服务socket;
    -r(route):显示Routing tables;
    在这里插入图片描述
    -s(statistice):显示网络工作信息统计表;
    -v(verbose):显示指令执行过程;
    在这里插入图片描述

    显示详细的网络状况

    netstat -a
    

    在这里插入图片描述
    各参数说明:
    Proto:连接使用的协议;
    Recv-Q:接收队列;
    Send-Q:发送队列;
    Local Address:本地地址;
    Foreign Address:外部地址;
    state:socket状态;

    显示所有TCP端口

    netstat -at
    

    显示所有UDP端口

    netstat -au
    

    只显示监听端口

    netstat -l
    

    输出中不显示主机、端口和用户名

    netstat -n
    

    当不想显示主机、端口和用户名时,可以使用这一命令,将会使用数字代替。

    展开全文
  • ACE_linuxTCP通信

    2015-01-16 22:01:00
    1.涉及 ACE_INET_Addr//ACE网络地址ACE_SOCK_Acceptor//ACE网络服务器...TCP通讯 传输控制协议TCP(Transmission Control Protocol):TCP提供可靠的、面向连接的运输服务,用于高可靠性数据的传输。TCP协议的...

    1.涉及类

    ACE_INET_Addr//ACE网络地址
    ACE_SOCK_Acceptor//ACE网络服务器
    ACE_SOCK_Connector//ACE网络客户端
    ACE_SOCK_Stream//ACE数据流

    2.简介

    TCP通讯

    传输控制协议TCP(Transmission Control Protocol):TCP提供可靠的、面向连接的运输服务,用于高可靠性数据的传输。TCP协议的可靠性是指保证每个tcp报文能按照发送顺序到达客户端。

    Tcp通信过程一般为如下步骤:

    a) 服务器绑定端口,等待客户端连接。

    b) 客户端通过服务器的ip和服务器绑定的端口连接服务器。

    c) 服务器和客户端通过网络建立一条数据通路,通过这条数据通路进行数据交互。

    3.示例代码

     1 #include <iostream>
     2 #include "ace/SOCK_Acceptor.h"
     3 using namespace std;
     4 
     5 const int  SERVER_PORT = 3000 ;
     6 int main(int argc, char *argv[]) 
     7 {
     8     char buffer[1024];
     9     ssize_t bc=0;            //接收的字节数
    10     ACE_SOCK_Stream peer;//SOCK_IO,和客户端的数据通路
    11     ACE_Time_Value timeout(100, 0);//TCP接受超时时间
    12 
    13     //Socket创建,绑定,监听
    14     ACE_INET_Addr addr(SERVER_PORT);
    15     ACE_SOCK_Acceptor acceptor;
    16     if(acceptor.open(addr) != 0)     //绑定端口
    17     {
    18         cout<<"bind port fail!"<<endl;
    19         return -1;
    20     }
    21     cout<<"server ready. "<<endl;
    22 
    23     while(true)
    24     {
    25         if (acceptor.accept(peer) != -1)    //建立和客户端的连接
    26         {
    27             std::cout<<"client connect. "<<std::endl;
    28             while(true)
    29             {
    30 
    31                 if((bc=peer.recv(buffer,1024,&timeout))<=0)    //接收数据(超时或对端断开break)
    32                 {
    33                     break;  
    34                 }
    35                 buffer[bc]='\0';
    36                 cout<<"[server rev]:>"<<buffer<<endl;
    37                 if(strcmp(buffer, "quit") == 0)  
    38                 {
    39                     break;  
    40                 }
    41                 do
    42                 {
    43                     cout<<"[server cin]:>";
    44                     cin.getline(buffer,1024);
    45                 }while(strlen(buffer)<=0); 
    46                 peer.send(buffer, strlen(buffer));    //发送数据
    47 
    48             }
    49             peer.close ();
    50         }
    51     }
    52 
    53     return 0; 
    54 }
    server.cpp
     1 #include <ace/SOCK_Connector.h> 
     2 
     3 #include <string>
     4 #include <iostream>
     5 using namespace std;
     6 
     7 const int  SERVER_PORT = 3000 ;
     8 
     9 int main(int argc, char *argv[]) 
    10 {
    11     char buffer[1024];
    12     ssize_t bc=0;            //接收的字节数
    13 
    14     ACE_INET_Addr addr(3000,"192.168.237.128");
    15     ACE_Time_Value timeout(100,0);
    16     ACE_SOCK_Stream peer;
    17     ACE_SOCK_Connector connector;
    18     if(connector.connect(peer,addr,&timeout) != 0)
    19     {
    20         cout<<"connection failed !"<<endl;
    21         return -1;
    22     }
    23     cout<<"conneced !"<<endl;
    24 
    25     while(true)
    26     {
    27         do
    28         {
    29             cout<<"[client cin]:>";
    30             cin.getline(buffer,1024);
    31         }while(strlen(buffer)<=0); 
    32         peer.send(buffer, strlen(buffer));    //发送数据
    33 
    34         if((bc=peer.recv(buffer,1024,&timeout))<=0)    //接收数据(超时或对端断开break)
    35         {
    36             break;  
    37         }
    38         buffer[bc]='\0';
    39         cout<<"[client rev]:>"<<buffer<<endl;
    40         if(strcmp(buffer, "quit") == 0)  
    41         {
    42             break;  
    43         }
    44     }
    45     peer.close();
    46 
    47     return 0; 
    48 }
    client.cpp

     

    ok!

    转载于:https://www.cnblogs.com/book-gary/p/4229852.html

    展开全文
  • 这个工程是基于TCP长连接的包模式的网络通讯框架。 在TCP连接中,按照一个一个的包方式进行数据传输, 框架实现了可以同时侦听多个端口, 每个数据包既可以不压缩传输,也能支持zlib压缩和blowfish加密传输。 服务端...
  • Linux网络编程一步一步学-异步通讯聊天程序select  作者:周立发2007-01-25 21:31分类:默认分类标签: 什么是异步通讯? 就是通讯任意一方可以任意发送消息,有消息来到时会收到系统提示去接收消息。 这里要...
  • Linux网络通信—Socket(TCP实现) 一、socket概述 为了简化开发通信程序的工作,由Berkely学校开发了一套网络通信程序的API函数标准。 二、SOCKET分类 流式套接字(SOCK_STREAM) 流式的套接字可以提供可靠的、...
  • python实现socket通讯(TCP) 分类: Linux Script2010-10-27 15:49 6457人阅读 评论(0) 收藏 举报  Server:   [python] view plaincopyprint? # server    ...
  • TCP/IP协议的元组 四元组:源IP地址,目的IP地址、源端口号,目的端口号 五元组:源IP地址,目的IP地址、源端口号,目的端口号、协议号 七元组:源IP地址,目的IP地址、源端口号,目的端口号、协议号、服务类型及...
  • 转载请注明出处: ,谢谢! 内容提要 本节主要学习网络通信基础,主要涉及的内容是: TCP/IP协议簇基础:两个模型 IPv4协议基础:IP地址分类与表示,子网...显然是通过标准的通讯协议,但是,整个网络连接的过程相当复杂,包
  • Synapse TCP/IP Library v24一套通信和函数库

    千次下载 热门讨论 2002-04-04 00:00:00
    支持Winsock或基于阻塞模式的Libc通讯,支持TCP、UDP、ICMP和RAW协议; 支持ASN.1编码和解码; 支持DNS; 支持标准ISO编码(ISO-8859-x),Windows编码(CP-125x),KOI8-R和Unicode(UCS-4, UCS-2, UTF...
  • 通用通讯接口,SWGCI32 基于TCP/IP 传输协议。 SWGCI32 分为二个部分:Client 端和Server 端 1. Client 端的动态库名为SWGCI32c.dll,负责命令的发送与应答返回值的分发; 2. Server 端的动态库名为SWGCI32s.dll,...
  • 通用通讯接口,SWGCI32 基于TCP/IP 传输协议。 SWGCI32 分为二个部分:Client 端和Server 端 1. Client 端的动态库名为SWGCI32c.dll,负责命令的发送与应答返回值的分发; 2. Server 端的动态库名为SWGCI32s.dll...
  • tcpsocket服务器linux内核通讯linux TCP协议是端到端的传输控制协议,之所以是“端到端”的协议,是因为”路由“是由IP协议负责的,TCP协议负责为两个通信端点提供可靠性保证,这个可靠性不是指一个端点发送的...
  • linux服务器tcp通讯活动ssh 问题起因: 自己开发了一个服务器和客户端,通过短连接的方式来进行通讯,由于过于频繁的创建连接,导致系统连接数量被占用,不能及时释放。看了一下18888,当时吓到了。 现象
  • 在.NET中,SocketAsyncEventArgs很适合用来编写高效网络通讯程序,这个的主要功能是可以避免重复分配大量的异步套接字 I/O 内进行同步的对象。 IOCP网络编程模型也叫完成端口,完成端口会充分利用Windows内核来...
  • TCP/IP协议与网络编程技术

    热门讨论 2010-03-12 17:09:10
    打开国内外各大知名网站的招聘页面,都可以看到类似于“熟悉TCP/IP协议、掌握socket通讯开发”等字样的要求。本书就是为了满足读者在这方面知识的需求而编写的一本TCP/IP协议与基于TCP/IP编程方面的书籍。 本书有...
  • linux网络入门基础

    2017-12-27 20:13:59
    网络: 计算机网络是由计算机和通讯组成,我们研究的是通讯。发展的三个阶段:简单联接(主机-终端) 网络化联接(主机-主机) 网络间互联 计算机网络分类:按地域分类:局域网城域网广域网 按拓扑分类:总线型星型...
  • Linux-网络运维基础

    2021-03-14 17:42:37
    文章目录1.1 网络通讯模型介绍1.1.1 两种模型对应关系1.1.2 TCP/IP三次握手1.1.3 常见网络端口1.2 IP协议IP数据包头包含信息1.2.1 IP地址分类1.2.2 变长子网掩码以及子网规划1.3 ICMP协议 - ping命令使用协议1.4 ...
  • linux基础--网络知识

    2020-06-30 21:02:31
    文章目录一.网络部分之网络硬件1.交换机1.1 概念1.2 实现通讯2.路由器2.1概念2.2实现通讯...网络层次模型2.1.OSI七层模型2.1.1七层模型结构2.1.2实现通讯2.2TCP/IP模型三.网络部分之网络协议1.TCP协议1.1报文结构1.2tc
  • Linux 网络基础和Socket

    2016-07-07 15:13:50
    一、TCP/ IP 协议 1、TCP/IP 协议是互联网基础 ...流式的套接字可以提供可靠的、面向连接的通讯流。它使用了TCP协议。TCP 保证了数据传输的正确性和顺序性。 (2)、数据报套接字(SOCK_DGRAM) 数据报套接字定义了一
  • 文章目录网络基础网络中使用到的三种设备IP地址和IP地址的分类数据在局域网中如何传输数据跨网段传输基于TCP的网络...网络通讯采用的协议是TCP/IP协议簇。 分别有: osi七层模型 TCP/IP协议分为四层或者五层: 应...
  • 1. Connection主要负责与Server端的通讯和应答返回值的分发; 2. Command主要负责命令参数编辑,提交及返回值读取操作; 3. Command执行请求可以阻塞等待应答返回值,也可以非阻塞立即返回,通过连接 ...
  • 1. Connection主要负责与Server端的通讯和应答返回值的分发; 2. Command主要负责命令参数编辑,提交及返回值读取操作; 3. Command执行请求可以阻塞等待应答返回值,也可以非阻塞立即返回,通过连接 ...
  • Linux从入门到精通

    2010-04-25 19:58:09
    B.2 在类Linux-like操作系统下制作软盘 C 包清单 C.1 应用 C.1.1 通讯 C.1.2 数据库 C.1.3 编辑器 C.1.4 模拟器 C.1.5 工程 C.1.6 图形 C.1.7 邮件 C.1.8 数学 C.1.9 网络 C.1.10 新闻 C.1.11 项目 C....
  • 网络通讯大部分是基于TCP/IP的,而TCP/IP是基于IP地址的,所以计算机在网络上进行通讯时只能识别如“202.96.134.133”之的IP地址,而不能认识域名。我们无法记住10个以上IP地址的网站,所以我们访问网站时,更多...
  • 本书通过55个精彩的实例,全面剖析了在Linux下编写网络应用程序的方法,并阐述了网络协议架构和开发规范。为了适应不同读者的需要,本书从最基本的Linux系统操作到网络技术的基本理念,逐步深入至Linux/UNIX下具体的...
  • B.2 在类Linux-like操作系统下制作软盘 C 包清单 C.1 应用 C.1.1 通讯 C.1.2 数据库 C.1.3 编辑器 C.1.4 模拟器 C.1.5 工程 C.1.6 图形 C.1.7 邮件 C.1.8 数学 C.1.9 网络 C.1.10 新闻 C.1.11 项目 C....

空空如也

空空如也

1 2 3 4 5
收藏数 85
精华内容 34
关键字:

linuxtcp通讯类

linux 订阅