Linux网络编程(TCP)

C语言中的网络编程:使用<sys/socket.h>进行TCP/UDP通信(三) 创建UDP套接字的过程与创建TCP套接字相似,只是在socket()函数中指定SOCK_DGRAM作为套接字类型。由于UDP是无连接的协议,无需调用listen()和accept()函数来等待连接请求和接受连接。 阅读详情

TCP

service.c
服务端

#include <stdlib.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
int main(void)
{
    int sfp,nfp;
    struct sockaddr_in s_add,c_add;
    int sin_size;
    unsigned short portnum=0x8888;
    char buff[100]={0};

    printf("Hello,welcome to my server !\r\n");
    sfp = socket(AF_INET, SOCK_STREAM, 0);
    if(-1 == sfp)
    {
        printf("socket fail ! \r\n");
        return -1;
    }
    printf("socket ok !\r\n");

    bzero(&s_add,sizeof(struct sockaddr_in));
    s_add.sin_family=AF_INET;
    s_add.sin_addr.s_addr=htonl(INADDR_ANY);
    s_add.sin_port=htons(portnum);

    if(-1 == bind(sfp,(struct sockaddr *)(&s_add), sizeof(struct sockaddr)))
    {
        printf("bind fail !\r\n");
        return -1;
    }
    printf("bind ok !\r\n");

    if(-1 == listen(sfp,5))
    {
        printf("listen fail !\r\n");
        return -1;
    }
    printf("listen ok\r\n");
    while(1)
    {
        sin_size = sizeof(struct sockaddr_in);

        nfp = accept(sfp, (struct sockaddr *)(&c_add), &sin_size);
        if(-1 == nfp)
        {
            printf("accept fail !\r\n");
            return -1;
        }
        read(nfp,buff,100);
        printf("received:%s\n", buff);

        if(-1 == write(nfp,buff,strlen(buff)+1))
        {
            printf("write fail!\r\n");
            return -1;
        }
        printf("write ok!\r\n");
        close(nfp);
    }
    close(sfp);
    return 0;
}

makefile:

server:server.o
    gcc -o server server.o
server.o:server.c
    gcc -c server.c -o server.o
clean:
    rm -f *.o server

=====================
客户端
client.c

#include <stdlib.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>

int main(void)
{
    int cfd;
    int recbytes;
    int sin_size;
    char buffer[1024]={0};   
    struct sockaddr_in s_add,c_add;
    unsigned short portnum=0x8888; 
    printf("Hello,welcome to client !\r\n");

    cfd = socket(AF_INET, SOCK_STREAM, 0);
    if(-1 == cfd)
    {
        printf("socket fail ! \r\n");
        return -1;
    }
    printf("socket ok !\r\n");

    bzero(&s_add,sizeof(struct sockaddr_in));
    s_add.sin_family=AF_INET;
    s_add.sin_addr.s_addr= inet_addr("127.0.0.1");
    s_add.sin_port=htons(portnum);
    printf("s_addr = %#x ,port : %#x\r\n",s_add.sin_addr.s_addr,s_add.sin_port);

    if(-1 == connect(cfd,(struct sockaddr *)(&s_add), sizeof(struct sockaddr)))
    {
        printf("connect fail !\r\n");
        return -1;
    }
    printf("connect ok !\r\n");
    write(cfd,"hello tcp socket", strlen("hello tcp socket")+1);

    if(-1 == (recbytes = read(cfd,buffer,1024)))
    {
        printf("read data fail !\r\n");
        return -1;
    }
    printf("read ok\r\nREC:\r\n");
    buffer[recbytes]='\0';
    printf("%s\r\n",buffer);
    getchar();
    close(cfd);
    return 0;
}

makefile:

client:client.o
    gcc -o client client.o
client.o:client.c
    gcc -c client.c -o client.o
clean:
    rm -f *.o client

UDP

a端
a.c

#include <stdio.h>
#include <stdlib.h>

#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>

int port=6789;
int main(int argc, char** argv) 
{
    int fd; //套接口描述字
    int i=0;
    char buf[80];
    struct sockaddr_in address;//处理网络通信的地址

    bzero(&address,sizeof(address));
    address.sin_family=AF_INET;
    address.sin_addr.s_addr=inet_addr("127.0.0.1");//这里不一样
    address.sin_port=htons(port);

    //创建一个 UDP socket

    fd=socket(AF_INET,SOCK_DGRAM,0);//IPV4 SOCK_DGRAM 数据报套接字(UDP协议)

    for(i=0;i<20;i++)
    {
        /*
        * sprintf(s, "%8d%8d", 123, 4567); //产生:" 123 4567" 
        * 将格式化后到 字符串存放到s当中
        */
        sprintf(buf,"hello udp socket %d",i);

        /*int PASCAL FAR sendto( SOCKET s, const char FAR* buf, int len, int flags,const struct sockaddr FAR* to, int tolen);  
        * s:一个标识套接口的描述字。 
        * buf:包含待发送数据的缓冲区。  
        * len:buf缓冲区中数据的长度。 
        * flags:调用方式标志位。  
        * to:(可选)指针,指向目的套接口的地址。 
        * tolen:to所指地址的长度。 
           */
        sendto(fd,buf,sizeof(buf),0,(struct sockaddr *)&address,sizeof(address));
        sleep(1);
    }

    sprintf(buf,"stop");
    sendto(fd,buf,sizeof(buf),0,(struct sockaddr *)&address,sizeof(address));//发送stop 命令
    close(fd);
    printf("Messages Sent,terminating\n");

    exit(0);

    return (EXIT_SUCCESS);
}

makefile:

client:a.o
    gcc -o client a.o
a.o:a.c
    gcc -c a.c -o a.o
clean:
    rm -f *.o client

=========================
b端
b.c

#include <stdio.h>
#include <stdlib.h>

#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

int port=6789;

int main(int argc, char** argv) 
{

    int sin_len;
    char message[256];

    int fd;
    struct sockaddr_in sin;
    printf("Waiting for data from sender \n");

    bzero(&sin,sizeof(sin));
    sin.sin_family=AF_INET;
    sin.sin_addr.s_addr=htonl(INADDR_ANY);
    sin.sin_port=htons(port);
    sin_len=sizeof(sin);

    fd=socket(AF_INET,SOCK_DGRAM,0);
    bind(fd,(struct sockaddr *)&sin,sizeof(sin));

    while(1)
    {
        recvfrom(fd,message,sizeof(message),0,(struct sockaddr *)&sin,&sin_len);
        printf("Response from server:%s\n",message);
        if(strncmp(message,"stop",4) == 0)//接受到的消息为 “stop”
        {

            printf("Sender has told me to end the connection\n");
            break;
        }
    }

    close(fd);
    exit(0);

    return (EXIT_SUCCESS);
}

makefile:

server:b.o
    gcc -o server b.o
b.o:b.c
    gcc -c b.c -o b.o
clean:
    rm -f *.o server

服务端select模型

服务器端
main.cpp

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

using namespace std;
bool g_bwillexit = false;
typedef struct _CmdParam
{
    char type;
    char quename[128];
    char conntype;
    
}CmdParam, *PCmdParam;

typedef struct _CmdReply
{
    char reply[20];
}CmdReply;

#define MYPORT 1234    // the port users will be connecting to
#define BACKLOG 1500    // how many pending connections queue will hold
#define BUF_SIZE 1024 

int fd_A[BACKLOG];    // 客户端连接套接字数组accepted connection fd
int conn_amount;    // current connection amount

int  writen(int s, char *buff, int len)
{ 
        
    int nLeft,idx, ret;   
    nLeft = len;   
    idx = 0;
    ret = 0;

    while(nLeft>0)
    {   
                if ((ret=send(s, &buff[idx], nLeft,0))== -1)
                {
                        break;
                } 
                nLeft -= ret;   
                idx += ret;
    }
    return idx;
}

int  readn(int s,char *buf,int len)
{
 
         int nRev = 0, recvCount = 0;
         int length = len;

         if(buf == NULL)
          return 0;

        while(length>0)
         {
                  nRev = recv(s,buf+recvCount,length, 0);
                  if(nRev == -1  || nRev == 0)
                  {
                          break;
                  }
                  length -= nRev;
                  recvCount += nRev;
         }
 
         return recvCount;
}

static void  GetMyProcPath(char *buff)
{
   char exec_name [1024] = {0};
   readlink ("/proc/self/exe", exec_name, 1024); 
   char *pSlash = strrchr(exec_name, '/');
   *pSlash = '\0';
   strcpy(buff, exec_name);
   return;
}


int main(int argc, char *argv[])
{
    int sock_fd, new_fd;  // listen on sock_fd, new connection on new_fd
    struct sockaddr_in server_addr;    // server address information
    struct sockaddr_in client_addr; // connector's address information
    socklen_t sin_size;
    int yes = 1;
    char buf[BUF_SIZE];
    int ret;
    int i;


    if ((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        printf("socket\n");
        exit(1);
    }

    if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
    {
        printf("setsockopt\n");
        exit(1);
    }
    
    server_addr.sin_family = AF_INET;         // host byte order
    server_addr.sin_port = htons(MYPORT);     // short, network byte order
    server_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
    memset(server_addr.sin_zero, '\0', sizeof(server_addr.sin_zero));

    if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) 
    {
        printf("bind error\n");
        exit(1);
    }

    if (listen(sock_fd, BACKLOG) == -1)
    {
        printf("listen\n");
        exit(1);
    }

    printf("listen port %d\n", MYPORT);

    fd_set fdsr;
    int maxsock;
    struct timeval tv;

    conn_amount = 0;
    sin_size = sizeof(client_addr);
    maxsock = sock_fd;
    while (g_bwillexit == false)
    {
        // initialize file descriptor set
        FD_ZERO(&fdsr);
        FD_SET(sock_fd, &fdsr);

        // timeout setting
        tv.tv_sec = 30;
        tv.tv_usec = 0;

        // add active connection to fd set
        for (i = 0; i < BACKLOG; i++)
        {
            if (fd_A[i] != 0)
            {
                FD_SET(fd_A[i], &fdsr);//fd_set fdsr;里面记录了每个客户端的套接字
            }
        }

        ret = select(maxsock + 1, &fdsr, NULL, NULL, &tv);//开始通过fdsr对每个套接字进行监听
        if (ret < 0)
        {
            printf("select error\n");
            break;
        }
         else if (ret == 0)
        {
            printf("timeout\n");
            continue;
        }

        // check every fd in the set
        // 处理已有的连接通信的,收发数据和断开连接
        for (i = 0; i < conn_amount; i++)
        {
            if (FD_ISSET(fd_A[i], &fdsr))//某个客户端套接字有响应
            {
                CmdParam cmd ={0};
                ret = readn(fd_A[i], (char *)&cmd, sizeof(cmd));
                if (ret <= 0)
                {   // client close
                    printf("client[%d] close\n", i);
                    close(fd_A[i]);
                    FD_CLR(fd_A[i], &fdsr);
                    fd_A[i] = fd_A[conn_amount-1];
                    fd_A[conn_amount-1]=0;
                    conn_amount--;
                }
                else
                {   // receive data
                    printf("read:%d byetes\n", ret);
                    if (cmd.type == 'c' && (cmd.conntype == 's' || cmd.conntype=='l'))
                    {
                        printf("c and (s or l) command received\n");
                        CmdReply reply = {0};
                        strcpy(reply.reply, "ok!");
                        writen(fd_A[i], (char *)&reply, sizeof(reply));
                    }
                    else  if (cmd.type == 'c')
                    {
                        printf("c command received\n");
                        CmdReply reply = {0};
                        strcpy(reply.reply, "ok!");
                        writen(fd_A[i], (char *)&reply, sizeof(reply));
                    }
                    else if (cmd.type == 'q')
                    {
                        printf("q command received\n");     
                    }
                    else
                    {
                        printf("unknown command received\n");
                        CmdReply reply = {0};
                        strcpy(reply.reply, "unknown cmd");
                        writen(fd_A[i], (char *)&reply, sizeof(reply));
                    }
              }
          }
     }

     // check whether a new connection comes
     // 接受处理新的客户端连接
     if (FD_ISSET(sock_fd, &fdsr))//sock_fd belongs to server
     {
            new_fd = accept(sock_fd, (struct sockaddr *)&client_addr, &sin_size);
            if (new_fd <= 0)
            {
                printf("accept error\n");
                continue;
            }

            // add to fd queue
            if (conn_amount < BACKLOG)
            {
                fd_A[conn_amount++] = new_fd;
                printf("new connection client[%d] %s:%d\n", conn_amount,
                        inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
                if (new_fd > maxsock)
                    maxsock = new_fd;
            }
            else
            {
                printf("max connections arrive, exit\n");
                CmdReply reply = {0};
                strcpy(reply.reply, "reject");
                writen(new_fd, (char *)&reply, sizeof(reply));
                close(new_fd);
            }
        }
   }
  // close other connections
  for (i = 0; i < BACKLOG; i++)
  {
        if (fd_A[i] != 0)
        {
            close(fd_A[i]);
        }
  }
  return 0;
  
}

makefile:

overpasspull_server:main.o
    g++ -g -o  overpasspull_server main.o
main.o:main.cpp
    g++ -g -c main.cpp -o main.o
clean:
    rm -f *.o overpass

=======================
客户端
main.cpp

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

#define MYPORT 1234    // the port users will be connecting to

#define BACKLOG 5     // how many pending connections queue will hold
#define BUF_SIZE 200

int  writen(int s, char *buff, int len)
{ 
        
    int nLeft,idx, ret;   
    nLeft = len;   
    idx = 0;
    ret = 0;

    while(nLeft>0)
    {   
                if ((ret=send(s, &buff[idx], nLeft,0))== -1)
                {
                        break;
                } 
                nLeft -= ret;   
                idx += ret;
    }
    return idx;
}

int  readn(int s,char *buf,int len)
{
 
         int nRev = 0, recvCount = 0;
         int length = len;

         if(buf == NULL)
          return 0;

        while(length>0)
         {
                  nRev = recv(s,buf+recvCount,length, 0);
                  if(nRev == -1  || nRev == 0)
                  {
                          break;
                  }
                  length -= nRev;
                  recvCount += nRev;
         }
 
         return recvCount;
}

#define MYPORT 1234
typedef struct _CmdParam
{
        char type;
        char quename[128];
        char conntype;

}CmdParam, *PCmdParam;
typedef struct _CmdReply
{
        char reply[20];
}CmdReply; 

int main(int argc, char *argv[])
{

    int sockfd,sock_dt; 
    printf("#####################################################\n"); 
    printf("socket test      by pafone   19th,April,2009\n"); 
    printf("#####################################################\n"); 
    struct sockaddr_in my_addr;//local ip info 
    struct sockaddr_in dest_addr; //destnation ip info 

    //int destport = atoi(argv[2]); 
    if(-1 == (sockfd = socket(AF_INET,SOCK_STREAM,0)) ) 
    { 
        printf("error in create socket\n"); 
        exit(0); 
    } 
    dest_addr.sin_family = AF_INET; 
    dest_addr.sin_port = htons(MYPORT); 
    dest_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); 
    //bzero(&dest_addr.sin_zero,0,8); 
    memset(&dest_addr.sin_zero,0,8); 
    //connect 
    if(-1 == connect(sockfd,(struct sockaddr*)&dest_addr,sizeof(struct sockaddr))) 
    { 
        printf("connect error\n"); 
        exit(0); 
    } 
    int n_send_len; 
    CmdParam cmd ={0};
    cmd.type = 'c';
    //strcpy(cmd.queueip, "10.200.193.169");
    strcpy(cmd.quename, "message_stream");
    //cmd.conntype = 's';
    cmd.conntype = 's';
    //strcpy(cmd.queueport, "3371");
    n_send_len = writen(sockfd, (char *)&cmd, sizeof(cmd));
    printf("%d bytes sent\n",n_send_len); 
    sleep(5);

    CmdReply reply = {0};

    int n_read_len = readn(sockfd, (char *)&reply, sizeof(reply));
    if (n_read_len)
    {
        printf("reply:%s, length:%d\n", reply.reply, n_read_len);
    }
    sleep(5);
    memset(&cmd, 0, sizeof(cmd));
    cmd.type = 'q';
    writen(sockfd, (char *)&cmd, sizeof(cmd));
    
    close(sockfd); 
    
    return 0;
}

makefile:

overpasspull_client:main.o
    g++ -g -o  overpasspull_client main.o
main.o:main.cpp
    g++ -g -c main.cpp -o main.o
clean:
    rm -f *.o overpass

服务端epoll模型

服务端
server.c

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

#define BUFFER_SIZE 40
#define MAX_EVENTS 10

int main(int argc, char * argv[])
{
    int server_sockfd;//服务器端套接字
    int client_sockfd;//客户端套接字
    int len;
    struct sockaddr_in my_addr;  //服务器网络地址结构体
    struct sockaddr_in remote_addr; //客户端网络地址结构体
    int sin_size;
    char buf[BUFFER_SIZE];  //数据传送的缓冲区
    memset (&my_addr ,0,sizeof(my_addr)); //数据初始化--清零
    my_addr.sin_family=AF_INET; //设置为IP通信
    my_addr.sin_addr.s_addr=INADDR_ANY;// 服务器IP地址--允许连接到所有本地地址上
    my_addr.sin_port=htons(8000); //服务器端口号
    //创建服务器端套接字--IPv4协议,面向连接通信,TCP协议
    if((server sockfd=socket(PF_INET, SOCK_STREAM,0))<0)
    {
        perror("socket");return 1 ;
    }
    //将套接字绑定到服务器的网络地址上
    if (bind(server_sockfd, (struct sockaddr *)&my_addr ,sizeof(struct sockaddr))<0)
    {
        perror("bind");
        return 1;
    }
    //监听连接请求--监听队列长度为5
    listen(server_sockfd,5);
    sin_size=sizeof(struct sockaddr_in) ;
    //创建一个epoll句柄
    int epoll_fd;
    epoll_fd=epoll_create (MAX_EVENTS);
    if(epoll_fd==-1)
    {
        perror("epoll_create failed");
        exit(EXIT_FAILURE) ;
    }
    struct epoll_event ev;//epoll事件结构体
    struct epoll_event events [MAX_EVENTS];//事件监听队列
    ev.events=EPOLLIN;
    ev.data.fd=server_sockfd;
    //向epoll注册server_sockfd监听事件
    if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD,server_sockfd,&ev)==-1)
    {

      perror("epll_ctl:server_sockfd register failed");
      exit(EXIT_FAILURE);
    }
    int nfds;//epoll监听事件发生的个数
    while(1)
    {
        //等待事件发生
        nfds=epoll_wait(epoll_fd,events ,MAX_EVENTS,-1);
        if(nfds==-1)
        {
            printf("start epoll_wait failed\n");
            break;
        }
        int i;
        for(i=0;i<nfds;i++)
        {
            //客户端有新的连接请求
            if(events[i].data.fd==server_sockfd)
            {
                //等待客户端连接请求到达
                if((client_sockfd=accept(server_sockfd, (struct sockaddr * )&remote_addr ,&sin_size))<0)
                {
                    printf("accept client_sockfd failed\n");
                    exit(EXIT_FAILURE);
                }
                //向epoll注册client_sockfd监听事件
                ev.events=EPOLLIN;
                ev.data.fd=client_sockfd;
                if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD,client_sockfd,&ev)==-1)
                {
                    printf("epoll_ctl:client_sockfd register failed\n");
                    exit(EXIT_FAILURE);
                    printf("accept client %s\n",inet_ntoa(remote_addr.sin_addr));
                }
                //客户端有数据发送过来
                else
                {
                    client_sockfd=events[i].data.fd;
                    len=recv(client_sockfd , buf , BUFFER_SIZE,0);
                    if(len<=0)
                    {
                        ev.events=EPOLLIN;
                        ev.data.fd=client_sockfd;
                        epoll_ctl(epoll_fd,EPOLL_CTL_DEL,client_sockfd ,&ev);
                        close(client_sockfd);
                        printf("client exit %d\n" ,client_sockfd);
                        break;
                    }
                    printf("receive from client:%s\n" ,buf) ;
                    send(client_spckfd,buf, BUFFER_SIZE,0);
                }
            }
        }
        return 0;
    }

=============================
客户端
client.c

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

#define BUFFER_SIZE 40

int main(int argc, char *argv[]){
    int client_sockfd;int len;
    struct sockaddr_in remote_addr; //服务器端网络地址结构体
    char buf[BUFFER_SIZE]; // 数据传送的缓冲区
    memset(&remote_addr ,θ ,sizeof(remote_addr)); //数据初始化--清零
    remote_addr.sin_family=AF_INET; //设置为IP通信
    remote_addr.sin_addr.s_addr=inet_addr("127.0.0.1");// 服务器IP地址
    remote_addr.sin_port=htons(8000); //服务器端口号
    //创建客户端套接字--IPv4协议,面向连接通信,TCP协议
    if((client_sockfd=socket(PF_INET , SOCK_STREAM,0))<0)
        {
            perror("client socket creation failed");
            exit(EXIT_FAILURE);
        }
    //将套接字绑定到服务器的网络地址上
    if(connect(client_sockfd, (struct sockaddr *)&remote_addr , sizeof(struct sockaddr))<0)
    {
        perror ("connect to server failed");
        exit(EXIT_FAILURE);
    }

    //循环监听服务器请求
    while(1)
        {
        printf("Please input the message:");
        scanf("%s" ,buf);
        //exit
        if(strcmp(buf,"exit")==0)
            {
            break;
            }
            send(client_sockfd, buf , BUFFER_SIZE,0);
            //接收服务端信息
            len=recv(client_sockfd, buf , BUFFER_SIZE,0);
            printf("receive from server :%s\n",buf);
            if(len<0)
            {
                perror("receive from server failed");
                exit(EXIT_FAILURE);
            }
        }
        close(client_sockfd);//关闭套接字
        return 0;
}

makefile:

.PHONY:all
all:server client
server:
    gcc server.c -o server
    gcc client.c -o client
clean:
    rm -f server client

Select与POLL区别

Select与POLL,EPOLL都是C种同步的10多路复用模型实现机制,它们的区别为:
1.select的句柄数目受限,在linux/posix_types.h头 文件有这样的声明: #define __FD_SETSIZE 1024表示select最多同时监听1024个fd(64位机默认是2048)。而epoll没有,它的限制是最大的打开文件句柄数目。select需要维护一个用来存放大量fd的数据结构,这样会使得用户空间和内核空间在传递该结构时复制开销大。

2.epoll不会随着FD的数目增长而降低效率,select采用轮询的方式扫描文件描述符,fd数量越多,性能越差; epoll维护 了一个队列,直接看队列是不是空就可以了。epoll只会对“活跃”的socket进行操作。这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的,那么只有活跃socket才会主动去调用callback函数(把这个句柄加入队列)

3.无论是select,poll还是epoll都需要内核把FD消息通知给用户空间,epoll使用mmap减少复制开销,加速内核与用户空间的消息传递。

4.poll本质上和select没有区别,它将用户传入的数组拷贝到内核空间,然后查询每个fd对应的设备状态,但没有最大连接数限制(基于链表来存储的)

C语言中的网络编程:使用<sys/socket.h>进行TCP/UDP通信(二) 是C语言网络编程中的核心头文件,它定义了创建、管理、关闭套接字所需的基本函数、数据类型和常量,为程序员提供了操作套接字的标准化接口。 阅读详情

相关推荐

Linux网络编程——SOCKET

一、预备知识 大端模式、小端模式 大端字节序(Big Endian):最高有效位存于最低内存地址处,最低有效位存于最高内存处; 小端字节序(Little Endian):最高有效位存于最高内存地址,最低有效位存于最低内存处。    网络字节序 我们已经知道,内存中的多字节数据相对于内存地址有大端和小端之分,磁盘文件中的多字节数据相对于文件中的偏移地址也有大端小端之分。网络数据流同样有大端小...

赵小厨的博客 594

c语言 socket网络编程

一、socket函数(创建一个新的socket) 1.头文件:#include <sys/types.h> –———— #include <sys/socket.h> 2.函数原型:int socket(int domain, int type, int protocol); 3.参数: 1)通信协议 AF_INET Ipv4 网络协议 AF_INET6 Ipv6 网络协议...

季春贰柒的博客 2958

Linux网络编程:TCP与UDP详解

本文深入探讨了Linux网络编程中的TCP和UDP协议,包括它们的基本概念、使用方法和通信过程。文章通过示例代码、时序图和异常情况处理,帮助读者全面理解TCP和UDP在服务器编程中的应用。

陆业聪 1954

Socket函数详解

#include ; #include ; int socket(int domain, int type, int protocol); domain 应该设置成 "AF_INET",socket 有两个最重要的选项是 AF_UNIX 和 IAF_INET。AF_UNIX 就象 UNIX 路径名一样识别 sockets。这种形式对于在同一台机器上的 IPC 很有用。而 AF_INET 使用象 192.9.200.10 这样被点号隔开的四个十进制数字

hw5230的博客 2389

Linux -TCP网络编程基础

Linux -TCP网络编程基础一.套接字编程基础知识1.套接字地址结构2.用户层和内核层交互过程二.TCP网络编程流程1.TCP网络编程架构2.创建网络插口函数socket()3.绑定一个地址端口对bind()4.监听本地端口listen5.接受一个网络请求accept()6.连接目标网络服务器connect()7.写入数据函数write()8.读取数据函数read()9.关闭套接字函数close()三.服务器/客户端的简单例子1.例子功能描述2.服务器网络程序3.服务器读取和显示字符串4.客户端的网络程

weixin_50866517的博客 1618

Linux环境下QT框架的TCP网络编程实践

本文还有配套的精品资源,点击获取 简介:QT框架在Linux下进行GUI和网络编程非常强大,本实例将深入探讨如何使用QT进行TCP通信。通过创建 tcpServer 和 tcpClient 示例项目,我们将学习TCP连接原理、数据传输、错误处理、异步编程和多线程等关键技术点,从而理解并实践TCP编程。 1. QT框架在Linux下的TC...

weixin_35516273的博客 1959

Linux网络编程之TCP

Linux网络编程之TCP

Xpccccc的博客 2309

过程挖掘(Process Mining)1——始于颜值

下周开始每周1-2篇的过程挖掘分享 过程挖掘是什么? 过程挖掘与过程管理的关系? 过程挖掘与数据挖掘的关系? 管理学还是计算机科学?

hyhy12580的博客 6236

嵌入式Linux网络编程——TCP/UDP

优快云仅用于增加百度收录权重,排版未优化,日常不维护。请访问:www.hceng.cn 查看、评论。 本博文对应地址: https://hceng.cn/2017/12/30/嵌入式Linux网络编程——TCP_UDP/#more 本文主要记录TCP/UDP网络编程的基础知识,采用TCP/UDP实现宿主机和目标机之间的网络通信。 回想去年校招那会,笔试题老是出现TCP/UDP相关的内容。 那时...

hceng_linux 2164

【obj To 3DTiles 进阶实战】 从零配置地理坐标系与扩展属性元数据

本文详细解析了如何将OBJ模型转换为3DTiles格式,重点介绍了地理坐标系配置与属性元数据扩展的实战技巧。通过obj23dtiles工具,开发者可以精准定位模型经纬高坐标,并添加结构化属性表,实现城市规划模型在数字孪生平台的高效应用。

weixin_27215337的博客 369

主流仿真软件Sigrity/HFSS/Siwave/Hyperlynx/ADS差异

在电子设计自动化(EDA)领域,各种仿真软件如Cadence Sigrity、Mentor Graphics的HyperLynx、Keysight的ADS以及ANSYS的SIwave等,都广泛应用于不同的应用场景中。综上所述,这些EDA仿真软件在各自的应用场景中发挥着重要作用,帮助工程师在设计阶段就能够评估和优化电子产品的性能,提高设计的可靠性和效率。:Sigrity由全球最大的EDA公司Cadence推出,Cadence还推出了Orcad和Allegro等著名软件。:由安捷伦(现是德科技)公司开发。

Geektec的专栏 9410

Linux 网络编程——TCP

一、TCP通信步骤 TCP服务器部分: 1、调用函数socket(),创建一个socket 2、设置sockaddr_in信息,如要连接服务器的IP和端口等属性 3、调用函数bind(),绑定IP地址、端口等信息到socket上 4、调用函数listen(),设置允许的最大连接数 5、调用函数accept(),等待来自客户端的连接请求 6、调用函数send() 和 recv(

阿修罗道 2682

【项目典型案例】-2-任意帧/特定帧CAN唤醒对ECU首帧/启动时间的影响

任意帧/特定帧CAN唤醒对ECU启动时间的影响

「汽车电子助手」的博客 1948

Linux网络编程系列之TCP协议编程

Linux网络编程系列之TCP,TCP的简单介绍和使用

AABond的博客 1852

学 Simulink—— 基于高频方波电压注入的表贴式永磁电机无感控制仿真

本文手把手教授基于Simulink的高频方波电压注入法实现表贴式永磁同步电机(SPMSM)无传感器控制。针对表贴式电机微弱凸极特性(Lq/Ld≈1.05-1.15),详解方波注入相比正弦注入的优势:通过5kHz方波(PWM频率半值)集中能量提升信噪比,并采用相邻周期电流直接相减的零延迟分离技术。系统架构包含高频注入器、无滤波器信号分离模块、锁相环观测器和磁饱和极性辨识等关键环节,提供参数设置经验(如注入幅值10-15%Vdc)和典型性能指标(位置误差<0.2rad)。特别强调工程实现要点:PWM同步时

xiaoheshang_123的博客 168

【WRF数据准备】基于GEE下载静态地理数据(叶面积指数LAI及绿色植被率Fpar)及二进制转化

基于GEE下载静态地理数据(叶面积指数LAI及绿色植被率Fpar)及二进制转化

WW、forever的博客 166

【Linux网络】Socket编程:TCP网络编程

本文介绍了基于TCP协议的网络编程实现,重点讲解了TCP服务器初始化的三个关键步骤:socket创建、bind绑定和listen监听。与UDP不同,TCP需要listen系统调用来建立连接队列,这是由TCP面向连接的特性决定的。文章通过代码示例展示了如何封装InetAddr类来简化地址处理,并对比了TCP和UDP在通信方式上的本质差异:TCP类似电话通话需要建立连接,而UDP则像寄送明信片无需连接。最后解释了为什么UDP不需要listen而TCP需要,为后续深入学习TCP协议打下基础。

2402_82670467的博客 1668

华为OD机试 - 计算数列位置N的值 - 模拟法(Python/JS/C/C++ 新系统 100分)

本专栏收录于《华为OD机试真题(Python/JS/C/C++)》。刷的越多,抽中的概率越大,私信哪吒,备注华为OD,加入华为OD刷题交流群,每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景,发现新题目,随时更新。输入 M,N 两个数,则按照以下规则形成一个数列。数列的前 M 个元素的值为 1 到 M从 M+1 个元素开始,计算逻辑为如果其前 M 个元素中,存在值相同的元素,则该位置上的数值等于前 M 个数中最大数值与最小数值之和。如果其前 M 个元素中,

学Java,找哪吒 508

Linux网络之----TCP网络编程

这个跟UDP是一样的,这里就介绍一下三个参数传什么参数吧第三个依旧传0。

2401_85878549的博客 1185

2026.2.3:OpenClaw国内安装教程,国内网络使用,服务器部署,对接飞书

本文介绍了如何创建飞书应用并接入OpenClaw机器人的完整流程。主要内容包括:1)在飞书开放平台创建企业自建应用,添加机器人能力并开通相关权限;2)在Windows11系统上安装OpenClaw,完成配置文件的修改(需将bind改为"lan");3)配置MiniMax国内接口地址,重启gateway服务。整个过程涵盖了应用创建、权限设置、软件安装、服务配置等关键步骤,为开发者提供了详细的飞书机器人接入指南。

拥抱具身智能,昇腾Ascend C 4002

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

Linux网络编程 TCP

server #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> #include <netdb.h> #include <unistd.h> #include <errno.h> #include <signal.h> #include <sys/wait.h> #inc...

m0_59474046的博客 3442

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Linux 网络编程 TCP/UDP编程

在TCP/IP协议族中,有很多种协议。TCP/IP协议群中的核心协议被设计运行在网络层和传输层,它们为网络中的各主机提供通信服务,也为模型的最高层--应用层中的协议提供服务。其中的TCP和UDP协议就是应用在传输层的协议。...

分享 1854

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Linux网络编程 ——TCP套接字通信

TCP 提供了一种 可靠、面向连接、字节流、传输层的服务,采用 三次握手 建立一个连接。采用 四次挥手 来关闭一个连接。

weixin_43412762的博客 2366

Linux编程——网络编程(TCP)、TCP与UDP区别

tcp协议 (传输控制协议)特征:1.流式套接字2.数据连续,顺序发送3.可靠传输,应答机制(保障数据可靠传输),数据发送丢包后启动自动重传机制4.有链路(服务器和客户端会先打通一条通路,建立连接,连接server和client,互联网传输节点状态信息可以保存)5.全双工通信6.机制复杂7.双缓冲区,收发互不影响。

2301_81517435的博客 1213

【Linux】socket网络编程之TCP

TCP网络编程,有启动服务器的多种版本,一篇详细学习

s_little_monster的博客 8678

【Linux网络编程】传输层中的TCP和UDP(TCP篇)

本篇博客将会介绍TCP底层,了解TCP机制

m0_74215144的博客 1772
上一篇: Linux后台开发系列之「12.必须掌握的 5 个底层 IO 函数」
下一篇: Linux后台开发系列之「13.标准 IO 库」
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值