LINUX网络编程基础流程

LINUX中的网络编程是通过SOCKET接口来进行的

Socket（套接字）
Socket相当于进行网络通信两端的插座，只要对方的Socket和自己的Socket有通信联接，双方就可以发送和接收数据了。其定义类似于文件句柄的定义

 

                         TCP协议socket流程图

 

基本套接字调用

创建套接字--socket();
绑定本机端口--bind();
建立连接--connect(),accept();
侦听端口--listen();
数据传输--send(),recv();
输入/输出多路复用--select();
关闭套接字--closesocket();

 

客户机/服务器模式在操作过程中采取的是主动请求方式：
基于TCP的socket编程步骤：

服务器端：
1、 创建套接字；
使用socket()
#include<sys/types.h>
#include<sys/socket.h>
int socket(int domain，int type，int protocol)
建立服务器端的socket套接字

2、 绑定套接字到一个IP地址和一个端口上；
使用bind()
#include<sys/types.h>
#include<sys/socket.h>

int bind(int sockfd,struct sockaddr * myaddr,int addrlen)；

3、 将套接字设置为监听模式，以等待连接请求；
使用listen()
#include<sys/socket,h>
int listen(int sockfd，int backlog)

4、请求到来后，接受连接请求，并返回一个与此次连接对应的套接字；
使用accept()
#include<sys/socket.h>
int accept(int sockfd，struct sockaddr * addr，int * addrlen)
此时新建连接，并创建新的Socket套接字，此时addr为客户端的addr信息。

5、 用返回的套接字和客户端进行通信；
使用recv()和send()
int read(int fd，char * buf，int len)
int write(int fd，char * buf，int len)

6、 关闭当前的连接，进入等待状态，继续等待客户端的连接；
使用close()
#include<unistd.h>
int close(int sockfd)；

7、 关闭服务器端的套接字描述符；
使用close()
#include<unistd.h>
int close(int sockfd)；

客户端：
1、 创建客户端套接字；
使用socket()
#include<sys/types.h>
#include<sys/socket.h>
int socket(int domain，int type，int protocol)

2、 向服务器发出连接请求；
使用connect()
#include<sys/types.h>
#include<sys/socket.h>
int connect（int sockfd，struct sockaddr * servaddr，int addrlen）
其中参数servaddr指定远程服务器的套接字地址，包括服务器的IP地址和端口号

3、 和服务器端进行网络通信；
使用recv()和send()
int read(int fd，char * buf，int len)
int write(int fd，char * buf，int len)

4、 关闭套接字；
使用close()
#include<unistd.h>
int close(int sockfd)；

 

以下有一个实例，分为客户端和服务器端

服务器端首先建立SOCKET，然后调用本地端口的绑定，接着开始与客户建立联系，并接收客户端发送的消息。客户端则在建立socket之后调用connect函数来建立连接

 

 

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

void process(int fd)
{
    char buff[10000];
    int received;
    int help,read_bytes;

    received = 5000;
    //memset ( buff, '.', received );
    while((read_bytes = read(fd, buff, received)) == 0)
    {
        printf("The client is disconnected!/n");
        exit(0);
    }

   
    if (read_bytes < 0)
    {
        perror("read");
        exit(1);
    }

    printf("%d bytes have received on socket %d/n", read_bytes, fd);
    printf("message from client: %s/n", buff);

   
    printf("write back to client..../n");
    write(fd, buff, strlen(buff));
    printf("write ok!/n");

}

int main(void)
{
    int sockfd ,newsockfd;
    struct sockaddr_in myaddr, peer;

    int addrlen1,addrlen2;

    if ((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0 )
    {
        perror("socket");
        exit(1);
    }

    addrlen1 = sizeof(myaddr);

    myaddr.sin_family = AF_INET;
    myaddr.sin_port = htons(10000);
    myaddr.sin_addr.s_addr = INADDR_ANY;
   
    if (bind(sockfd, &myaddr , addrlen1) < 0 )
    {
        perror("bind");
        exit(1);
    }

    if (listen(sockfd, 5 ))
    {
        perror("listen");
        exit(1);
    }

    for (;;)
    {
        addrlen2 = sizeof(peer);

        printf("waiting for connect.../n");
        newsockfd = accept(sockfd, &peer , &addrlen2);

        if ( newsockfd < 0)
     {
            perror("accept");
            exit(1);
     }

        if (fork() == 0)
     {
            close(sockfd);

           
            printf("connection on socket %d from %s/n", newsockfd,
            inet_ntoa(peer.sin_addr.s_addr));
      
            while(1) 
                process(newsockfd);

            close(newsockfd);
            exit(0);

     }
     
        close(newsockfd);
    }
}

 

 

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

int main(int argc, char *argv[])
{
    int sockfd ,newsockfd, help, sent;
    int read_bytes;
        int i;
 
    struct sockaddr_in peer;
    struct hostent *serverhost;
    char buff[5000];

    if(argc != 5)
    {
        fprintf(stderr, "Usage: ./client -i <hostname> -p <port>/n");
        exit(1);
    }

    printf("server: %s,/tport: %s./n", argv[2], argv[4]);

    if(strcmp(argv[1], "-i") != 0)
    {
        printf("first argument must be: -i/n");
        //fprintf(stderr, "Usage: ./client -i <hostname> -p <port>/n");
        exit(1);
    }

    if(strcmp(argv[3], "-p") != 0)
    {
        printf("third argument must be: -p/n");
        exit(1);
    }

    if ((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0 )
    {
        perror("socket");
        exit(1);
    }

    if((serverhost = gethostbyname(argv[2])) == 0)
    {
        perror("gethostbyname");
        exit(1);
    }

    peer.sin_family = AF_INET;
    peer.sin_port = htons(atoi(argv[4]));
    peer.sin_addr = *(struct in_addr*)serverhost->h_addr_list[0];

    if (connect(sockfd, &peer, sizeof(peer)) < 0 )
    {
        perror("connect");
        exit(1);
    }

   

    while(1)
    {
        printf("input message to  send: /n");
        gets(buff);
        printf("message length: %d/n", strlen(buff));
        write(sockfd, buff, strlen(buff));

        printf("waiting for server's response.../n");
        read_bytes = read(sockfd, buff, strlen(buff));

        puts(buff);
    }
    close(sockfd);
}