网络编程之TCP与UDP

最新推荐文章于 2018-02-27 09:19:27 发布
最新推荐文章于 2018-02-27 09:19:27 发布
阅读量921 收藏 2
点赞数
分类专栏： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenjiayi_yun/article/details/22897137
版权

1、TCP与UDP的区别


Tcp是一种面向连接的，可靠的字节流服务。（设有数据包编号与差错控制机制。）
特点：
由于网络的复杂性，传输信息时，数据包可能会丢失，差错控制中的确认机制在接收到数据包是发送确认信息，若是数据包丢失，则回发数据包编号，让对方重新发送；
由于网络的复杂性，传输信息时有多种网络传送途径可以选择，数据包被接收的顺序与发送顺序不同，可以根据数据包的编号，将数据包重组。
优点：
网络连接是以点对点的形式，加上上述特点，保证了数据的安全性，数据包不会中途被劫。
缺点：耗费资源很多。


UDP是无连接的，不可靠的数据协议报。通讯双方发送数据后不知道对方是否已经收到数据，是否正常收到数据（没有类似TCP的差错控制和数据包编号机制）。
特点：通讯速度比较快，不需要TCP的三次握手。
1）多播：
与发送主机的子网相同的主机，都会在自己的端口收到主机发出来的UDP消息（发送到（包括本机）所有在这个网络地址的主机上，例如192.168.0.255，则在192.168.0.的主机都会收到）。消息会被复制并发到每个主机的网卡上去，网卡收到消息后提交给操作系统去处理，操作系统发现有程序在端口接收UDP数据则把消息转给相应的程序去处理，如果没有程序接收来自该端口的UDP消息，则操作系统丢弃该消息。
2）单播：
则消息只会从主机发到特定的主机上，主机的网卡收到消息后转给操作系统去处理，操作系统再把此消息转给相应程序去处理，如果没有程序处理就丢弃该包。
3）组播：
则消息只会从主机发到加入了规定组的主机的端口。象广播一样，组播消息一样会被复制发到网络所有主机的网卡上，但只有宣布加入这个组的主机的网卡才会把数据提交给操作系统去处理。如果没有加入组，则网卡直接将数据丢弃。要想接收组播消息的主机必须运行命令加入组。



2、TCP和UDP编程

基本模式如图：



（1）UDP广播

在UDP方式下，将目标地址设为：255.255.255.255 或 192.168.1.255（192.168.1网段内），端口号配置正确，就可以发送广播。
客户端： 
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/stat.h>
#include<errno.h>
#include <pthread.h>

#define RET_OK 0
#define RET_ERR -1

#define LISTEN_QUEUE_NUM 5
#define BUFFER_SIZE 256

#define ECHO_PORT 2029

int sockfd;
struct sockaddr_in servaddr,recvaddr;
pthread_t t1;

void rev()
{
    int ret;
    char buffer[BUFFER_SIZE];
    uint32_t len=sizeof(recvaddr);
    while(1)
    {
        if((ret=recvfrom(sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&recvaddr,&len))<0)//监听地址中的socket读事件
        {
            perror("ERROR reading from socket");
            break;
        }
        buffer[ret]=0;
        printf("[form:%s:%u]%s\n",inet_ntoa(recvaddr.sin_addr),ntohs(recvaddr.sin_port), buffer);
    }
}

int main(int argc,char **argv)
{
	int opt=1;
	int ret=RET_OK;
	char buffer[BUFFER_SIZE];
	struct hostent *server;
	
	if(argc<2)
	{
	    fprintf(stderr,"usage &s hostname\n",argv[0]);
	    return RET_ERR;
	}
	
	if((server=gethostbyname(argv[1]))==NULL)
	{
	    herror("gethostbyname.");
	    return RET_ERR;
	}
	
	if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
	{
	    herror("ERROR opening socket");
	    return RET_ERR;
	}
	
	//设置广播套接字
	if((setsockopt(sockfd,SOL_SOCKET,SO_BROADCAST,&opt,sizeof(opt)))<0)
	{
	    perror("ERROR setsockopt");
	    goto failed;
	}
	
	memset(&servaddr,0,sizeof(servaddr));//服务器地址
	
	servaddr.sin_family=AF_INET;//设为IPv4
	servaddr.sin_addr.s_addr=*(uint32_t *)server->h_addr;//地址转换,32位大端字序，或者INADDR_BROADCAST
	servaddr.sin_port=htons((uint16_t)ECHO_PORT);//设定端口,16位大端字序转换
	
	pthread_create(&t1, NULL, (void*)rev, NULL);
	
	while(1)//不断发送数据到指定地址端口
	{
	    printf("Enter the message : ");
	    if(fgets(buffer,sizeof(buffer)-1,stdin)==NULL)break;
	    if((ret=sendto(sockfd,buffer,strlen(buffer)+1,0,(struct sockaddr*)&servaddr,sizeof(servaddr)))<0)
	    {
	        perror("ERROR writing to socket");
	        break;
	    }
	    
	}
	
failed:
	close(sockfd);
	return ret<0?RET_ERR:RET_OK;
}



服务器端： 
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/stat.h>
#include<errno.h>


#define RET_OK 0
#define RET_ERR -1


#define LISTEN_QUEUE_NUM 5
#define BUFFER_SIZE 256

#define ECHO_PORT 2029

int main(int agrc,char **argv)
{
	int sockfd,opt=1;
	uint32_t len;
	struct sockaddr_in cliaddr;
	uint8_t buffer[BUFFER_SIZE];
	int ret=RET_OK;
	
	if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
	{
	  perror("ERROR opening socket");
	  return RET_ERR;
	}
	
	//SO_REUSEADDR允许重用本地址
	if((ret=setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)))<0)
	{
	  perror("ERROR setsockopt");
	  goto failed;
	}
	
	memset(&cliaddr,0,sizeof(cliaddr));
	cliaddr.sin_family=AF_INET;
	cliaddr.sin_addr.s_addr=INADDR_ANY;//监听所有地址发来的指定端口
	cliaddr.sin_port=htons(ECHO_PORT);
	
	if((ret=bind(sockfd,(struct sockaddr*)&cliaddr,sizeof(cliaddr)))<0)//绑定地址（udp不绑定也是可以的）
	{
	  perror("ERROR on binding");
	  goto failed;
	}
	
	do//不断接收数据并返回相同的数据
	{
	  len=sizeof(cliaddr);
	  if((ret=recvfrom(sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&cliaddr,&len))>0)
	  {
	      buffer[ret] = 0;
	      printf("[%s:%d]%s",inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port),buffer);
	      ret=sendto(sockfd,buffer,ret,0,(struct sockaddr*)&cliaddr,len);
	  }
	}while(ret>=0);
	
failed:
  close(sockfd);
  return 0;
}

运行过程：用ifconfig eth0 设置ip,并查看广播地址作为client.c的参数运行
运行结果：多个服务器可以同时接收来自客户端的信息


（2）UDP指定地址接受

UDP，client中使用connect指定接受地址。

指定接收数据的地址，其他IP地址的数据拒绝接收。


sendto,recvfrom可以用write和read代替.


客户端代码：

int sockfd;
struct sockaddr_in servaddr,recvaddr;
pthread_t t1;

void rev()
{
    int ret;
    char buffer[BUFFER_SIZE];
    uint32_t len=sizeof(recvaddr);
    while(1)
    {
        if((ret=read(sockfd,buffer,sizeof(buffer)-1,0))<0)
        {
            perror("ERROR reading from socket");
            break;
        }
        buffer[ret]=0;
        printf("[form:%s:%u]%s\n",inet_ntoa(recvaddr.sin_addr),ntohs(recvaddr.sin_port), buffer);
        //printf("Server echo message: %s\n",buffer);
    }
}


int main(int argc,char **argv)
{
  int opt=1;
  int ret=RET_OK;
  char buffer[BUFFER_SIZE];
  struct hostent *server;


  if(argc<2)
  {
      fprintf(stderr,"usage &s hostname\n",argv[0]);
      return RET_ERR;
  }
  
  if((server=gethostbyname(argv[1]))==NULL)
  {
      herror("gethostbyname.");
      return RET_ERR;
  }
  
  if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
  {
      herror("ERROR opening socket");
      return RET_ERR;
  }

  memset(&servaddr,0,sizeof(servaddr));//申请信息表空间

  servaddr.sin_family=AF_INET;//设为IPv4
  servaddr.sin_addr.s_addr=*(uint32_t *)server->h_addr;//地址转换,32位大端字序
  servaddr.sin_port=htons((uint16_t)ECHO_PORT);//设定端口,16位大端字序转换

  if((ret=connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)))<0) //创建连接
  {
      perror("ERROR connecting");
      goto failed;
  }
  pthread_create(&t1, NULL, (void*)rev, NULL);

  while(1)
  {
      printf("Enter the message : ");
      if(fgets(buffer,sizeof(buffer)-1,stdin)==NULL)break;
      if((ret=write(sockfd,buffer,strlen(buffer)+1,))<0)
      {
          perror("ERROR writing to socket");
          break;
      }
  }
  
failed:
  close(sockfd);
  return ret<0?RET_ERR:RET_OK;
}

（3）UDP单播

在发送函数中指定udp包发送的具体地址。
客户端： 
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/stat.h>
#include<errno.h>
#include <pthread.h>

#define RET_OK 0
#define RET_ERR -1

#define LISTEN_QUEUE_NUM 5
#define BUFFER_SIZE 256

#define ECHO_PORT 2029

int sockfd;
struct sockaddr_in servaddr,recvaddr;
pthread_t t1;

void rev()
{
  int ret;
  char buffer[BUFFER_SIZE];
  uint32_t len=sizeof(recvaddr);
  while(1)
  {
    if((ret=recvfrom(sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&recvaddr,&len))<0)
    {
        perror("ERROR reading from socket");
        break;
    }
    buffer[ret]=0;
    printf("[form:%s:%u]%s\n",inet_ntoa(recvaddr.sin_addr),ntohs(recvaddr.sin_port), buffer)；
  }
}

int main(int argc,char **argv)
{
  int opt=1;
  int ret=RET_OK;
  char buffer[BUFFER_SIZE];
  struct hostent *server;

  if(argc<2)
  {
    fprintf(stderr,"usage &s hostname\n",argv[0]);
    return RET_ERR;
  }
  
  if((server=gethostbyname(argv[1]))==NULL)
  {
    herror("gethostbyname.");
    return RET_ERR;
  }
  
  if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
  {
      herror("ERROR opening socket");
      return RET_ERR;
  }
  memset(&servaddr,0,sizeof(servaddr));//申请信息表空间

  servaddr.sin_family=AF_INET;//设为IPv4
  servaddr.sin_addr.s_addr=*(uint32_t *)server->h_addr;//地址转换,32位大端字序
  servaddr.sin_port=htons((uint16_t)ECHO_PORT);//设定端口,16位大端字序转换

  pthread_create(&t1, NULL, (void*)rev, NULL);

  while(1)
  {
    printf("Enter the message : ");
    if(fgets(buffer,sizeof(buffer)-1,stdin)==NULL)break;
    if((ret=sendto(sockfd,buffer,strlen(buffer)+1,0,(struct sockaddr*)&servaddr,sizeof(servaddr)))<0)
    {
      perror("ERROR writing to socket");
      break;
    }
  }
failed:
  close(sockfd);
  return ret<0?RET_ERR:RET_OK;
}

服务器端同上；
运行过程：./client ip地址；
运行结果：一个服务器终端可以接收数据。

（4）支持多人聊天和私聊的客户端 

跟具字符串格式判断使用发送的是具体地址还是广播地址。 

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

#define RET_OK 0
#define RET_ERR -1

#define LISTEN_QUEUE_NUM 5
#define BUFFER_SIZE 256

#define ECHO_PORT 2029

struct sockaddr_in recvaddr;
char buffer[BUFFER_SIZE];

void recv2(void* sockfd)
{
 uint32_t len=sizeof(recvaddr);
 int ret;
 while(1)
 { 
  if((ret=recvfrom((int)sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&recvaddr,&len))<0)
  {
   perror("ERROR reading from socket");
   break;
  }
  buffer[ret]=0;
  printf("Server echo message: %s\n",buffer);
 }
}

int main(int argc,char **argv)
{
 int sockfd;
 pthread_t t1;
 int ret=RET_OK;
 struct sockaddr_in servaddr,tempaddr;
 struct hostent *server;
 char tempbuf[BUFFER_SIZE],buf[BUFFER_SIZE];
<span style="white-space:pre">	</span>
 if(argc<2)
 {
   fprintf(stderr,"usage &s hostname\n",argv[0]);
   return RET_ERR;
 }
 if((server=gethostbyname(argv[1]))==NULL)
 {
   herror("gethostbyname.");
   return RET_ERR;
 }
 if((sockfd=socket(AF_INET,SOCK_DGRAM, IPPROTO_UDP))<0)
 {
   herror("ERROR opening socket");
   return RET_ERR;
 }
 memset(&servaddr,0,sizeof(servaddr));//申请信息表空间
<span style="white-space:pre">	</span>
 servaddr.sin_family=AF_INET;//设为IPv4
 servaddr.sin_addr.s_addr=*(uint32_t *)server->h_addr;//地址转换,32位大端字序
 servaddr.sin_port=htons((uint16_t)ECHO_PORT);//设定端口,16位大端字序转换
<span style="white-space:pre">	</span>
 pthread_create(&t1,NULL,(void *)recv2,(void *)sockfd);
 while(1)
 {
   printf("Enter the message : ");
   if(fgets(buffer,sizeof(buffer)-1,stdin)==NULL)break;
<span style="white-space:pre">	</span>
   if(strstr(buffer,":") && strstr(buffer,"@"))  /*私人聊天*/
   {
     tempaddr.sin_family=AF_INET;                
     tempaddr.sin_addr.s_addr=inet_addr(strtok(buffer,":"));//地址
     tempaddr.sin_port=htons(atoi(strtok(NULL,"@")) )；
     char *del=":@";
     strcpy(tempbuf,strtok(NULL,del))；
     if((ret=sendto(sockfd,tempbuf,strlen(tempbuf),0,(struct sockaddr*)&tempaddr,sizeof(tempaddr)))<0)
     {
 <span style="white-space:pre">	</span>perror("ERROR writing to socket");
 <span style="white-space:pre">	</span>break;
     }           
   }
   else/*多人聊天*/
   {
    if((ret=sendto(sockfd,buffer,strlen(buffer),0,(struct sockaddr*)&servaddr,sizeof(servaddr)))<0)
    {
      perror("ERROR writing to socket");
      break;
    }
   }
 }
<span style="white-space:pre">	</span>  
 close(sockfd);
 return ret<0?RET_ERR:RET_OK;
}

服务器端同上

（5） TCP半双工聊天

服务器每接受一个连接，返回数据后就关闭连接。（这个模式实用性觉得很小）
客户端阻塞发送和接收。
客户端：
  
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/wait.h>
#include<sys/stat.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<unistd.h>
#include<errno.h>
#include<signal.h>

#define RET_OK 0
#define RET_ERR -1

#define LISTEN_QUEUE_NUM 5
#define BUFFER_SIZE 256

#define ECHO_PORT 2029

int main(int argc,char **argv)
{
  int sockfd,ret=RET_OK;
  struct sockaddr_in servaddr;
  struct hostent *server;

  char buffer[BUFFER_SIZE];

  if(argc<2)
  {
      fprintf(stderr,"usage %s hostname\n",argv[0]);
      return RET_ERR;
  }
  if((server=gethostbyname(argv[1]))==NULL) //由域名获取IP地址
  {
      herror("gethostbyname.");
      return RET_ERR;
  }
  if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0) //创建套接字
  {
      perror("ERROR opening socket");
      return RET_ERR;
  }

  memset(&servaddr,0,sizeof(servaddr));//申请信息表空间

  servaddr.sin_family=AF_INET;//设为IPv4
  servaddr.sin_addr.s_addr=*(uint32_t *)server->h_addr;//地址转换,32位大端字序
  servaddr.sin_port=htons((uint16_t)ECHO_PORT);//设定端口,16位大端字序转换

  if((ret=connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)))<0) //创建连接
  {
      perror("ERROR connecting");
      goto failed;
  }
  while(1)
  {
    printf("\tEnter the message:");
    if(fgets(buffer,sizeof(buffer)-1,stdin)==NULL) //输入字符到buffer指针
    {
			break;
    }
    if((ret=write(sockfd,buffer,strlen(buffer)))<0)   //把buffer的内容 写入strlen(buffer)的字节到sockfd的socket中
    {
      perror("ERROR write to socket");
      break;
    }
    if((ret=read(sockfd,buffer,sizeof(buffer)-1))<0)//读取到buffer中
    {
      perror("ERROR read from socket");
      break;
    }
    else
    {
      buffer[ret]='\0';
      printf("\tServer echo message: %s\n",buffer);
    }
    if(ret==0)
    {
      printf("Server disconnect\n");
      break;
    }
  }
  
failed:
  close(sockfd);
  return ret<0?RET_ERR:RET_OK;
}


服务器端：
  
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/wait.h>
#include<sys/stat.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<unistd.h>
#include<errno.h>
#include<signal.h>

#define RET_OK 0
#define RET_ERR -1

#define LISTEN_QUEUE_NUM 5
#define BUFFER_SIZE 256
#define ECHO_PORT 2029
char buffer[BUFFER_SIZE];
从socket读一行数据到缓冲区
static int my_readline(int fd,void *buf,unsigned len)
{
  int n,rc;
  char c,*ptr;
  ptr=buf;
  for(n=1;n<len;n++)
  {
	again:
    if((rc=read(fd,&c,1))==1)
    {
      *ptr++=c;
      if(c=='\n')break;
    }
    else if(rc==0)
    {
      if(n==1)return 0;
      else break;
    }else
    {
      if(errno==EINTR)goto again;
      return -1;
    }
  }
  *ptr=0;
  return n;
}

static int proc_echo(int sockfd)
{
  int ret;
  while(1)
  {
    if((ret=my_readline(sockfd,buffer,sizeof(buffer)-1))<0)
    {
        perror("read");
        return -1;
    }else if(ret==0)
    {
        printf("client disconnect.\n");
        return 0;
    }
    buffer[ret]='\0';
    printf("client echo message:  %s\n",buffer);
    printf("\tEnter message:\n ");
    fflush(stdout);
    if(fgets(buffer,sizeof(buffer),stdin)==NULL) //输入字符到buffer指针
    {
			break;
    }
    if((ret=write(sockfd,buffer,strlen(buffer)))<0)    //把buffer的内容 写入strlen(buffer)的字节到nsock的socket中
    {
      perror("ERROR write to socket");
      break;
    }
  }
    
  return -1;
}

int main(int argc,char **argv)
{
  int sockfd,nsock,ret=0;
  uint32_t len;
  struct sockaddr_in servaddr,cliaddr;
  if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0) 
  {
    perror("ERROR opening socket");
    return RET_ERR;
  }
  memset(&servaddr,0,sizeof(servaddr));

  servaddr.sin_family=AF_INET;
  servaddr.sin_addr.s_addr=INADDR_ANY;
  servaddr.sin_port=htons(ECHO_PORT);

  if((ret=bind(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr)))<0)
  {
    perror("ERROR on binding");
    goto failed;
  }

  if((ret=listen(sockfd,LISTEN_QUEUE_NUM))!=0)
  { 
   perror("ERROR on listen");
    goto failed;
  }    
  printf("\tserver is listening>>>\n");
  while(1)
  {
    len=sizeof(cliaddr);
    if((nsock=accept(sockfd,(struct sockaddr*)&cliaddr,(uint32_t*)&len))<0)
    {
      perror("accept");    
      break;        
    }
    printf("\tclient connect success!!!\n");
    proc_echo(nsock);
    close(nsock);
  }
  
failed:
  close(sockfd);
  return ret<0?RET_ERR:RET_OK;
}

运行：
./ser, server is listening>>>
./cli 服务器地址；
Enter:  ......
服务器：读出数据，并从键盘接收数据回发给客户；（此时客户端阻塞直到收到服务器的回信）.

（6）TCP全双工通信

服务器每接受一个连接后，创建线程来处理数据收发业务。
客户端的读写业务分别在两个不同的线程内。

服务器与客户端可以异步发送信息

客户端：

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

#define RET_OK 0
#define RET_ERR -1

#define LISTEN_QUEUE_NUM 5
#define BUFFER_SIZE 256
#define ECHO_PORT 2029

static void proc_echo(void *sockfd)
{
  int ret;
  char buffer[BUFFER_SIZE];  
  while(1)
  {
    if((ret=read((int)sockfd,buffer,sizeof(buffer)-1))<0)//读取到buffer中
    {
      perror("ERROR read from socket");
      break;
    }
    if(ret==0)
    {
      printf("Server disconnect\n");
      //pthread_cancel(t2);
      break;
    }

    buffer[ret]='\0';
    printf("\tServer echo message: %s\n",buffer);
  }
}

int main(int argc,char **argv)
{
  int sockfd,ret=RET_OK;
  pthread_t t2;
  struct sockaddr_in servaddr;
  struct hostent *server;
  char buffer[BUFFER_SIZE] ;

  if(argc<2)
  {
    fprintf(stderr,"usage %s hostname\n",argv[0]);
    return RET_ERR;
  }
  if((server=gethostbyname(argv[1]))==NULL) //由域名获取IP地址
  {
    herror("gethostbyname.");
    return RET_ERR;
  }
  if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0) //创建套接字
  {
    perror("ERROR opening socket");
    return RET_ERR;
  }

  memset(&servaddr,0,sizeof(servaddr));//申请信息表空间

  servaddr.sin_family=AF_INET;//设为IPv4
  servaddr.sin_addr.s_addr=*(uint32_t *)server->h_addr;//地址转换,32位大端字序
  servaddr.sin_port=htons((uint16_t)ECHO_PORT);//设定端口,16位大端字序转换

  if((ret=connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)))<0) //创建连接
  {
    perror("ERROR connecting");
    goto failed;
  }
  pthread_create(&t2,NULL,(void *)proc_echo,(void*)sockfd);
  while(1)
  {
    printf("\tEnter the message:\n");
    if(fgets(buffer,sizeof(buffer)-1,stdin)==NULL)//输入字符到buffer指针
    {
        break;
    }
    if((ret=write(sockfd,buffer,strlen(buffer)))<0)//把buffer的内容 写入strlen(buffer)的字节到sockfd的socket中
    {
        perror("ERROR write to socket");
        break;
    }
  }

failed:
  close(sockfd);
  return ret<0?RET_ERR:RET_OK;
}

服务器端：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/wait.h>
#include<sys/stat.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<unistd.h>
#include<errno.h>
#include<signal.h>
#include <pthread.h>
#include"echo_net.h"

#define BUFFER_SIZE 256

static int my_readline(int fd,void *buf,unsigned len)
{
  int n,rc;
  char c,*ptr;
  ptr=buf;
  for(n=1;n<len;n++)
  {
    again:
    if((rc=read(fd,&c,1))==1)
    {
      *ptr++=c;
      if(c=='\n')break;
    }else if(rc==0)
    {
      if(n==1)return 0;
      else break;
    }else
    {
      if(errno==EINTR)goto again;
      return -1;
    }
  }
  *ptr=0;
  return n;
}

static void proc_echo_2(void *sockfd)
{
    int ret;
    char buffer[BUFFER_SIZE];	
    char readBuf[BUFFER_SIZE];
    while(1)
    {
	//消息接收
        if((ret=my_readline(sockfd,readBuf,sizeof(buf)-1))<0)
        {
            perror("read");
            return -1;
        }else if(ret==0)
        {
            printf("client disconnect.\n");
            pthread_cancel(t2);    
            return 0;
        }
        buf[ret]='\0';
        printf("client echo message:  %s",readBuf);
        fflush(stdout); 
	//消息发送
        printf("\tEnter message:\n ");
        if(fgets(buffer,sizeof(buffer),stdin)==NULL) //输入字符到buffer指针
        {
	   printf("没有输入字符");
           continue;
        }
        if((ret=write((int)sockfd,buffer,strlen(buffer)))<0)    //把buffer的内容 写入strlen(buffer)的字节到nsock的socket中
        {
             perror("ERROR write to socket");
             break;
        }
    }
    close(nsock);
}

int main(int argc,char **argv)
{
    int sockfd,nsock,ret=0;
    int opt;pthread_t t2;
    char buf[32];
    uint32_t len;
    
    struct sockaddr_in servaddr,cliaddr;
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
    {
        perror("ERROR opening socket");
        return RET_ERR;
    }
    //SO_REUSEADDR允许重用本地址
    if((ret=setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)))<0)
    {
      perror("ERROR setsockopt");
      return RET_ERR;
    }

    memset(&servaddr,0,sizeof(servaddr));

    servaddr.sin_family=AF_INET;
    servaddr.sin_addr.s_addr=INADDR_ANY;
    servaddr.sin_port=htons(ECHO_PORT);

    if((ret=bind(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr)))<0)
    {
      perror("ERROR on binding");
      goto failed;
    }

    if((ret=listen(sockfd,LISTEN_QUEUE_NUM))!=0)
    {
	perror("ERROR on listen");
	goto failed;
   }
		
    printf("\tserver is listening>>>\n");
    while(1)
    {
        len=sizeof(cliaddr);
        if((nsock=accept(sockfd,(struct sockaddr*)&cliaddr,(uint32_t*)&len))<0)
        {
              perror("accept");
              break;
        }
        printf("\tclient connect success!!!\n");
    		//printf("\tclient id =%s\n",inet_ntoa(cliaddr.sin_addr));
        printf("client id =%s\n",
                inet_ntop(cliaddr.sin_family,&cliaddr.sin_addr,buf,sizeof(buf)));
        printf("\tport =%d\n",ntohs(cliaddr.sin_port));
        pthread_create(&t2,NULL,(void *)proc_echo_2,(void*)sockfd);
        proc_echo(nsock);
    }

failed:
	close(sockfd);
	return ret<0?RET_ERR:RET_OK;
}


（7） TCP I/O复用之select

复用io，非阻塞监听事件。
服务器非阻塞监听socket读事件，处理并返回给客户端。
客户端非阻塞监听socket读事件和标准输入事件，并处理。

客户端： 
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/stat.h>
#include<errno.h>

#define RET_OK 0
#define RET_ERR -1

#define LISTEN_QUEUE_NUM 5
#define BUFFER_SIZE 256

#define ECHO_PORT 2029

int main(int argc,char **argv)
{
  int maxfd=0;
  fd_set rset,set;
  int nfound,bytesread;
  int sockfd;
  int ret=RET_OK;
  struct sockaddr_in servaddr;
  struct hostent *server;
  char buffer[BUFFER_SIZE];

  if(argc<2)
  {
      fprintf(stderr,"usage &s hostname\n",argv[0]);
      return RET_ERR;
  }
  
  if((server=gethostbyname(argv[1]))==NULL)
  {
      herror("gethostbyname.");
      return RET_ERR;
  }
  
  if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
  {
      herror("ERROR opening socket");
      return RET_ERR;
  }

  memset(&servaddr,0,sizeof(servaddr));//申请信息表空间

  servaddr.sin_family=AF_INET;//设为IPv4
  servaddr.sin_addr.s_addr=*(uint32_t *)server->h_addr;//地址转换,32位大端字序
  servaddr.sin_port=htons((uint16_t)ECHO_PORT);//设定端口,16位大端字序转换

  if(connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
  {
      perror("ERROR connect");
      return RET_ERR;
  }

  maxfd=fileno(stdin);//获取标准读的文件描述符
  FD_ZERO(&set);
  FD_SET(sockfd,&set);//把连接socket加入文件描述符集
  FD_SET(maxfd,&set);//把标准输入输出描述符加入文件描述符集
  maxfd=(maxfd>sockfd?maxfd:sockfd)+1;//监听数是最大的文件描述符+1

  while(1)
  {
    rset=set;
    if((nfound=select(maxfd,&rset,(fd_set*)0,(fd_set*)0,NULL))<0)
    {
        if(errno==EINTR)
        {
            fprintf(stderr,"interrupted system call\n");
            continue;
        }
        perror("select");
        exit(1);
    }
    
    if(FD_ISSET(fileno(stdin),&rset))//如果是标准输入事件，则输入字符到缓冲区，发送缓冲区数据
    {
      if(fgets(buffer,sizeof(buffer)-1,stdin)==NULL)
      {
        if(ferror(stdin))
        {
            perror("stdin");
            return -1;
        }
        return 0;
      }
      if(write(sockfd,buffer,strlen(buffer))<0)
      {    
        perror("ERROR writing");
        return -1;
      }
    }
    if(FD_ISSET(sockfd,&rset))//如果是socket读事件（这里socket只有读事件，监听的是读文件描述符集），则读取socket缓冲区的数据到缓存
    {
      if((bytesread=read(sockfd,buffer,sizeof(buffer)))<0)
      {    
        perror("ERROR read");
        exit(1);
      }else if(bytesread==0)//如果有读事件而读缓冲区是0字节，表示对端已关闭socket
      {
        fprintf(stderr,"server disconnect\n");
        exit(0);
      }
            
      buffer[bytesread]=0;//最后加上结束符
      printf("buffer: %s",buffer);//输出读取socket的数据
    }
  }
  return 0;
}



服务器端： 
#include<sys/types.h>
#include<ctype.h>
#include<strings.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<netdb.h>
#include<arpa/inet.h>
#include<errno.h>
#include<sys/time.h>
#include<stdio.h>
#include<string.h>
#include<sys/select.h>
#include<stdlib.h>
#include<signal.h>
#include<sys/wait.h>

#define RET_OK 0
#define RET_ERR -1
#define LISTEN_QUEUE_NUM 5
#define BUFFER_SIZE 256
#define ECHO_PORT 2029

int main(int argc,char **argv)
{
  struct sockaddr_in servaddr,remote;
  int request_sock,new_sock;
  int nfound,fd,maxfd,bytesread;
  uint32_t addrlen;
  fd_set rset,set;
  struct timeval timeout;
  char buf[BUFFER_SIZE];

  if((request_sock=socket(AF_INET,SOCK_STREAM, IPPROTO_TCP))<0)
  {
      perror("ERROR opening socket");
      return RET_ERR;
  }
  memset(&servaddr,0,sizeof(servaddr));

  servaddr.sin_family=AF_INET;
  servaddr.sin_addr.s_addr=INADDR_ANY;
  servaddr.sin_port=htons((uint16_t)ECHO_PORT);

  if(bind(request_sock,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)//绑定socket到地址（设置socket监听方式）
  {
      perror("ERROR on binding");
      return RET_ERR;
  }
  if(listen(request_sock,LISTEN_QUEUE_NUM)<0)//开始监听socket
  {
      perror("ERROR on listen");
      return RET_ERR;
  }

  FD_ZERO(&set);
  FD_SET(request_sock,&set);
  maxfd=request_sock;
  while(1)
  {
    rset=set;
    timeout.tv_sec=0;
    timeout.tv_usec=50000000;.//最大50ms监听超时时间
    if((nfound=select(maxfd+1,&rset,(fd_set*)0,(fd_set*)0,&timeout))<0)//非阻塞监听读事件（设置了最大监听事件描述符）
    {
      perror("select");
      return -1;
    }
    else if(nfound==0)//没有触发事件则继续监听
    { 
      fflush(stdout);
      continue;
    }

    if(FD_ISSET(request_sock,&rset))
    {
      addrlen=sizeof(remote);
      if((new_sock=accept(request_sock,(struct sockaddr*)&remote,&addrlen))<0)
      {
          perror("accept");
          return -1;
      }
      printf("connection from host %s,port %d,socket %d\r\n",inet_ntoa(remote.sin_addr),ntohs(remote.sin_port),new_sock);
      FD_SET(new_sock,&set);//接收新的连接后，把连接加入需要监听的文件描述符集
      if(new_sock > maxfd)maxfd=new_sock;
      FD_CLR(request_sock,&rset);
      nfound--;
    }

    for(fd=0;fd<=maxfd&&nfound>0;fd++)
    {
      if(FD_ISSET(fd,&rset))
      {
        nfound--;
        if((bytesread=read(fd,buf,sizeof(buf)-1))<0)
        {
            perror("read");
        }
        if(bytesread==0)//对端关闭了
        {
            fprintf(stderr,"server: end of file on %d\r\n",fd);
            FD_CLR(fd,&set);
            close(fd);
            continue;
        }
        buf[bytesread]=0;
        printf("%s: %d bytes from %d: %s\n",argv[0],bytesread,fd,buf);
        
        if(write(fd,buf,bytesread)<0)//echo 业务，把读到的数据返回给客户端
        {
            perror("echo");//写入有误
            FD_CLR(fd,&set);//减少需要监听的socket
            close(fd);
        }
      }
    }
  }
  return 0;
}



(8)TCP I/O复用之poll

使用poll监听的复用io
服务器非阻塞监听复用io事件，处理socket事件
客户端阻塞发送和接收数据

poll与select的区别：
1）遍历的文件描述符的范围不一样（前者是poll数组，后者是文件描述符集，文件描述符集是以最大的文件描述符为最大数组成员）
2）需要监听的文件描述符可以注册各自需要的事件

客户端：
  
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/time.h>
#include<netinet/in.h>
#include<errno.h>
#include<ctype.h>
#include<netdb.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/select.h>
#include<sys/poll.h>

#define RET_OK 0
#define RET_ERR -1
#define LISTEN_QUEUE_NUM 5

#define BUFFER_SIZE 256
#define ECHO_PORT   2029

int main(int argc, char **argv)
{
  int sock;
  struct sockaddr_in servaddr;
  struct hostent *server;
  static struct pollfd cpoll[2];
  int nfound, bytesread;
  char buf[BUFFER_SIZE];

  if(argc < 2)
  {
      fprintf(stderr, "usage %s hostname\n", argv[0]);
      return RET_ERR;
  }
  if((server = gethostbyname(argv[1])) == NULL)
  {
      perror("gethostbyname. ");
      return RET_ERR;
  }

  /*setup socket*/
  if((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)//tcp socket
  {
      perror("socket");
      return -1;
  }

  /*fillup ip address structure*/
  memset(&servaddr, 0, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = *(uint32_t *) server->h_addr;
  servaddr.sin_port = htons((uint16_t) ECHO_PORT);

  /*connect to server*/
  if(connect(sock, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) //连接到对端
  {
      perror("connect");
      return -1;
  }
  //加入需要监听的文件描述符以及相关的事件
  /*fill up poll struct*/
  cpoll[0].fd = fileno(stdin);//加入监听描述符
  cpoll[0].events = POLLIN;//加入监听事件
  cpoll[1].fd = sock;//加入监听描述符
  cpoll[1].events = POLLIN;//加入监听事件

  while (1)
  {
    if ((nfound = poll(cpoll, 2, -1)) < 0)//阻塞监听poll数组事件（socket事件），（在没有别的业务的情况下可以阻塞接收）
    {
      if (errno == EINTR)//是中断事件的错误，则忽略
      {
        fprintf(stderr, "interruptedb system call\n");
        continue;
      }
      perror("select");
      exit(1);
    }
    
    if (cpoll[0].revents & (POLLIN | POLLERR))//检查输入设备的读事件
    {
      if(fgets(buf, sizeof(buf), stdin) == NULL) //从标准输入设备描述符的缓冲区读取数据到用户缓冲区
      {
        if (ferror(stdin))
        {
            perror("stdin");
            return -1;
        }
        return 0;
      }
      /*write to socket*/
      if (write(sock, buf, strlen(buf)) < 0)
      {
          perror("write");
          return -1;
      }
    }

    if(cpoll[1].revents & (POLLIN | POLLERR))//检查socket的读事件
    {
      if((bytesread = read(sock, buf, sizeof(buf))) < 0)//从socket的缓冲区读取数据到用户缓冲区
      {
        perror("read");
        exit(1);
      }
      else if(bytesread == 0)//对端关闭，则关闭socket
      {
        fprintf(stderr, "server disconnect\n");
        exit(0);
      }
      buf[bytesread] = 0;
      printf("%s\n", buf);
    }
  }
  
  return 0;
}




服务器端： 
#include<sys/types.h>
#include<ctype.h>
#include<strings.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<netdb.h>
#include<arpa/inet.h>
#include<ctype.h>
#include<errno.h>
#include<sys/time.h>
#include<stdio.h>
#include<string.h>
#include<sys/poll.h>
#include<stdlib.h>

#define LISTEN_QUEUE_NUM 5
#define MAX_CONNECT 1024

#define BUFFER_SIZE 256
#define ECHO_PORT 2029

static struct pollfd clipoll[MAX_CONNECT];
int max = 0;//poll数组中的最大的当前使用的文件描述符

static void poll_init()//初始化poll结构数组
{
  int i;
  for (i = 0; i < MAX_CONNECT; i++)
   clipoll[i].fd = -1;
}

static int poll_alloc()//获取一个没用的poll结构数组空槽的下标，找不到则返回-1
{
    int i;
    for (i = 0; i < MAX_CONNECT; i++)
    {
        if (clipoll[i].fd < 0)
        return i;
    }
    return -1;
}


static void update_max()//获取在使用的文件描述符在poll数组中的下标中的最大的一个
{
    int i;
    max = 0;
    for (i = 0; i < MAX_CONNECT; i++)
    {
        if (clipoll[i].fd > 0)
        max = i;
    }
}

static int poll_free(int i)//释放pollfd结构数组的一个成员
{
    close(clipoll[i].fd);
    clipoll[i].fd = -1;
    clipoll[i].events = 0;
    clipoll[i].revents = 0;
    update_max();
}

static int poll_set_item(int fd, uint32_t events)//加入一个需要监听的文件描述符（和相关事件）到poll数组的一个空槽中
{
  int i;
  if ((i = poll_alloc()) < 0)//获取一个pollfd结构，加入文件描述符，和对应的事件
    return -1;
  clipoll[i].fd = fd;
  clipoll[i].events = events;
  clipoll[i].revents = 0;//清空读事件
  if (i > max)
   max = i;
  return 0;
}

int main(int argc, char **argv)
{
  struct sockaddr_in servaddr, remote;
  int request_sock, new_sock;
  int nfound, i, bytesread;
  uint32_t addrlen;
  char buf[BUFFER_SIZE];
  /*setup socket*/
  if ((request_sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
  {
      perror("socket");
      return -1;
  }
  /*fill up ip address structure*/
  memset(&servaddr, 0, sizeof(servaddr));
  servaddr.sin_family = AF_INET;//协议簇
  servaddr.sin_addr.s_addr = INADDR_ANY;//监听所有地址
  servaddr.sin_port = htons(ECHO_PORT);//监听端口
  if (bind(request_sock, (struct sockaddr *) &servaddr, sizeof(servaddr)) <  0)//设置socket监听方式（绑定socket到地址）
  {
    perror("bind");
    return -1;
  }
  if (listen(request_sock, LISTEN_QUEUE_NUM) < 0)//开始socket监听事件
  {
    perror("listen");
    return -1;
  }
  poll_init(); //初始化poll数组
  poll_set_item(request_sock, POLLIN);//把需要监听的socket（和其读事件）加入到poll数组
  while (1)
  {
    if ((nfound = poll(clipoll, max + 1, 50)) < 0)//非阻塞监听poll文件描述符的事件（max是poll数组中的在使用的文件描述符最大的下标），超时时间为50ms
    {
      if (errno == EINTR)//忽略中断的错误
      {
        printf("interruptedb system call\n");
        continue;
      }
      perror("poll");
      return -1;
    }
    else if(nfound == 0)//没有监听到发生事件的文件描述符
    {
      fflush(stdout);
      continue;
    }
    
    if (clipoll[0].revents & (POLLIN | POLLERR))//第一个是监听socket，若其发送了读事件，则接受新连接
    {
      addrlen = sizeof(remote);
      if ((new_sock = accept(request_sock, (struct sockaddr *) &remote,    &addrlen)) < 0)
      {
          perror("accept");
          return -1;
      }
      printf("connection fromm host %s,port %d, socket %d\r\n",
              inet_ntoa(remote.sin_addr), ntohs(remote.sin_port), new_sock);
      if (poll_set_item(new_sock, POLLIN) < 0)//加入新的连接到poll数组
          fprintf(stderr, "Too many connects\r\n");
      nfound--;
    }
    for (i = 1; i <= max && nfound > 0; i++)//遍历检查通信socket是否有触发事件
    {
      if (clipoll[i].fd >= 0 && clipoll[i].revents & (POLLIN | POLLERR))//poll数组的socket文件描述符有读事件
      {
        nfound--;
        if((bytesread = read(clipoll[i].fd, buf, sizeof(buf) - 1)) < 0)//读取socket 的数据到用户缓冲区
        {
            perror("read");
            poll_free(i);
            continue;
        }
        if(bytesread == 0)//对端关闭了
        {
            fprintf(stderr, "server: end of file on %d\r\n", clipoll[i].fd);
            poll_free(i);
            continue;
        }
        buf[bytesread] = 0;
        printf("%s:%d bytes from %d :%s\n", argv[0], bytesread,
        clipoll[i].fd, buf);
        if (write(clipoll[i].fd, buf, bytesread) != bytesread)//echo业务，返回读取的数据到对端
        {
            perror("echo");
            poll_free(i);//写错误（表示对端关闭了）则关闭socket
            continue;
        }
      }
    }
  }
  
  return 0;
}






风云来
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python网络编程之TCP与UDP协议套接字用法示例
09-20
主要介绍了Python网络编程之TCP与UDP协议套接字用法,结合实例形式较为详细的分析了Python网络编程中TCP与UDP协议客户端、服务器端相关实现及使用技巧,需要的朋友可以参考下
UDP socket_read接收数据导致错误Resource temporarily unavailable
orangeholic的专栏
12-10 9008
项目中经常用到PHP用UDP调用C++服务，我们这边的PHP 请求方法封装如下，一直没有问题出现，今天接入新的服务出现了问题        public static function request($reqBuffer,$host,$port) { $socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
网络编程-TCP与UDP
微微一笑
02-27 5492
1.定义区别TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送；UDP则不为IP提供可靠...
Linux网络编程-TCP&UDP测试工具.zip
12-08
TCP&UDP测试工具
java网络编程使用tcp、udp实现多用户对话
01-10
课程大作业，java网络编程模拟实现多用户对话，包含客户端、服务器
C#网络编程入门之UDP
01-27
UDP和TCP是网络通讯常用的两个传输协议，C#一般可以通过Socket来实现UDP和TCP通讯，由于.NET框架通过UdpClient、TcpListener 、TcpClient这几个类对Socket进行了封装，使其使用更加方便，本文就通过这几个封装过的类...
解码websocket （c++）
陈嘉怡的专栏
07-23 5499
websocket 是web常用的协议，可用来支持自定义协议。 以下是用c++根据websocket握手协议websocket协议格式来处理websocket 协议解码 （1）第一步，websocket升级协议 判断是否是http协议，并且是websocket的升级握手协议 E_CODEC_STATUS CodecWebSocketJson::Decode(tagConnectionAt...
套接字的recv返回错误和处理
陈嘉怡的专栏
04-05 5400
extern ssize_t recv(int __fd,void *__buf,size_t __n,int __flags);
URL转义意义和其c++实现
陈嘉怡的专栏
12-25 4625
URL中的字符只能是ASCII字符，但是ASCII字符比较少，而URL则常常包含ASCII字符集以外的字符，如非英语字符、汉字、特殊符号等等，所以要对URL进行转换。这个过程就叫做URL编码，或者叫URL转义，实质上就是将包含非ASCII字符的URL转换为有效的ASCII字符格式。 在进行URL编码时，每一个非ASCII字符都被替换为“%hh”格式，其中hh为两位十六进制数，它对应于该字符在
select的套接字数量的限制
陈嘉怡的专栏
03-26 4159
在很多比较各种网络模型的文章中，但凡提到select模型时，都会说select受限于轮询的套接字数量，这个 数量也就是系统头文件中定义的FD_SETSIZE值(例如64)。但事实上这个算不上真的限制。 C语言的偏方： 在C语言的世界里存在一个关于结构体的偏门技巧，例如：   typedef struct _str_type {     int _len;     c
网卡收发模式及使用
陈嘉怡的专栏
12-29 3806
RSS receive side scaling，网卡多队列，需要硬件支持。网卡接收到网络数据包后，要发送一个硬件中断，通知CPU取数据包。默认配置，都是由CPU0去做。 RPS receive packet steering，向某个CPU发送一个软中断，来接收数据包，并递交给应用程序。 RFS receive flow streering，维护两种hash表，实现将软中断分散到多颗C
TCP协议分析
陈嘉怡的专栏
04-04 2686
TCP提供了一种面向连接的、可靠的字节流服务，在连接双方在通信前需要预先建立一条连接。 TCP特点如下(提供了协议规则来保障通信链路的可靠性)：
TCP time_wait 的存在意义
陈嘉怡的专栏
04-24 2594
近来网站随着访问量的增加，服务器的压力也随之上升，一个很明显的状况便是服务端产生了大量的TIME_WAIT状态，它究竟是什么、对系统有何影响、为什么很多人对它如此敏感？  Google一下TIME_WAIT会有成千上万的文章，但总是别人的，今天自己整理一下对TIME_WAIT的认识。  TCP连接的终止  TCP建立一个连接至少需要交换三个分组，也因此称之为TCP的三路握手（three-
网络协议消息分片
陈嘉怡的专栏
12-05 2357
很多人对网络大消息分片比较困惑，主要是一般情况下应用层消息不会超出发送窗口缓存（可以设置64k字节）。但实际上tcp/ip协议对所有超出分片字节的网络消息都会进行分片、编号。在应用层的自定义协议，使用tcp协议的情况下，大消息分片要编号，依赖tcp协议向上提供的有序特性并检查编号的递增性，（否则不是同一个消息，有可能是对端网络连接断开等原因），需要有结束标记。
http压力测试
陈嘉怡的专栏
12-28 2182
简介 Siege是一个压力测试和评测工具，设计用于WEB开发这评估应用在压力下的承受能力：可以根据配置对一个WEB站点进行多用户的并发访问，记录每个用户所有请求过程的相应时间，并在一定数量的并发访问下重复进行。 Siege是一个多线程http负载测试和基准测试工具。 Siege：这是Linux系统下的一个测试工具，完全使用C语言实现，可以对HTTP和FTP服务器进行负载和性能测试。通过使用S
游戏服务器之多线程发送
陈嘉怡的专栏
02-11 1575
本文讨论的游戏架构设计中，分为两进程(逻辑服务器进程和数据服务器进程)，其中逻辑服务器进程包含多个逻辑网关，单个逻辑网关中含4类线程，发送线程是其中一种并在一个逻辑网关中存在多个，用来处理发送业务。
Linux网络基础与编程
最新发布
03-06
多年前写的一个Linux网络socket编程。用来做新员工培训的。对网络编程感兴趣的可以下载。当然，有些内容是通过现场讲出来的，比较容易理解。PDF资源可能相对单薄，如有需要，可以关注博主进行咨询。讲了TCP、UDP、三次握手相关的内容。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值