基本套接字总结（@function）

最近学习了下UNIX下的网络编程。为了以后查询方便，总结在这里。

首先套接字的地址定义：

　　　IPv4地址和IPv6地址定义见<netinet/in.h>头文件定义。为了能够顺利转换不同的套接字内容，可以查看<sys/socket.h>中定义的通用套接字struct sockaddr;在使用过成中我们可以将struct sockaddr_in 和 sockaddr_in6直接强制转换成struct sockaddr.

连接过程中我们需要人工指定对应网络地址。而不同的主机实现中存在不同的数据格式（big-endian OR little-endian),我们需要通过如下转换函数来保证数据转换过程中的正确性。

函数列表如下：　　　

#include <netinet/in.h>

//from host byte order to network byte order

uint16_t htons(uint16_t  host16bitvalue)
//servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  

uint32_t htonl(uint32_t  host32bitvalue)



//from network byte order to host byte order

uint16_t ntohs(uint16_t  host16bitvalue)

uint16_t ntohl(uint16_t  host16bitvalue)

 地址转换函数使用：

#include <arpa/inet.h>



int inet_pton(int family, const char* strptr, void *addrptr);　　//成功返回1，格式错误返回0，出错返回-1
//示例：：Inet_pton(AF_INET, argv[1], &serveraddr.sin_addr); const char* inet_ntop(int family, const void*addrptr, char *strptr, size_t len); //len参数指出缓存区的大小，避免出现溢出

 

基本TCP套接字编程示例程序如下（这里我们read,write等系统IO操作来实现网络回射服务）：

其中涉及到的网络编程函数包括：socket(),bind(),bzero(),inet_pton(), listen(),connect(),accept()

服务过程中socket()指定所要进行操作的网络服务是什么， socket(指定协议族， 操作类型， 采用协议)

协议族包括：AF_INET:Pv4；　　AF_INET6:IPv6;　　AF_LOCAL:UNIX域协议；　　AF_ROUTE:路由套接字；　　AF_KEY:密钥套接字

操作类型：SOCK_STREAM:字节流;　　SOCK_DGRAM:数据报;　　SOCK_SEQPACKET:有序分组;　　SOCK_RAW:原始套接字

采用协议：IPPROTO_TCP...._UDP...._SCTP

 

需要注意的问题：

　　Fork子进程后，connfd和listenfd的引用次数变成2，所以需要在子进程和父进程中同时关闭才能保证完全关闭。

　　多个子进程并发后，会在服务器上产生大量的僵死进程，从而使得大量的服务器资源浪费。为此我们需要捕获僵死进程的信号SIGCHLD，并做相应的处理。因为UNIX中信号不排队的设计，采用wait处理完第一个僵死进程的信号后其余的进程信号丢失。从而清理不彻底。为此，这里采用waitpid函数进行处理。

首先，服务器程序：

#include "unp.h"

#include <stdio.h>

#include <stdlib.h>



void str_echo(int sockfd);

Sigfunc* signal1(int signo, Sigfunc* func);

void sig_child(int signo);

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

    int listenfd, connfd;

    char buff[MAXLINE];

    pid_t childpid;

    socklen_t clilen;



    struct sockaddr_in cliaddr, servaddr;



    //<sys/socket.h>

    //int socket(int family, int type, int protocal);

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(struct sockaddr_in));

    servaddr.sin_family = AF_INET;

    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    servaddr.sin_port = htons(SERV_PORT);



    Bind(listenfd, (SA*) &servaddr, sizeof(servaddr));



    Listen(listenfd, LISTENQ);





    //working with the 

    signal1(SIGCHLD, sig_child);



    while(1){

        clilen = sizeof(cliaddr);

        connfd = Accept(listenfd, (SA*)&cliaddr, &clilen);

        if ((childpid = Fork()) == 0){

            Close(listenfd);

            str_echo(connfd);

            exit(0);

        }

        Close(connfd);

    }



    return 0;

}





void str_echo(int sockfd){

    ssize_t n;

    char buf[MAXLINE];

again:

    while((n = read(sockfd, buf, MAXLINE) ) > 0)

        Write(sockfd, buf, n);

    if (n < 0 && errno == EINTR)

        goto again;

    else if (n < 0)

        err_sys("str_echo: read error");



}



Sigfunc* signal1(int signo, Sigfunc* func){

    struct sigaction act, oact;

    act.sa_handler = func;

    sigemptyset(&act.sa_mask);

    act.sa_flags = 0;

    if ( signo == SIGALRM){

#ifdef SA_INTERRUPT

        //设定中断,使该信号处理过程中能够中断:

        act.sa_flags |= SA_INTERRUPT;

#endif

    }else{

#ifdef    SA_RESTART

        //信号处理，设置SA_RESTART标志，使得内核对失败的

        //系统调用自动重启。

        act.sa_flags |= SA_RESTART;

#endif

    }

    

    if (sigaction(signo, &act, &oact) < 0){

        return SIG_ERR;

    }

    return (oact.sa_handler);

}





void sig_child(int signo){

    pid_t pid;

    int stat;

    /***********************************************

#inlcude <sys/wait.h>

        这里使用wait函数只能处理第一个返回的僵死进程，因为其UNIX系统信号实现

        中信号是不进行排队的。所以我们采用waitpid

        并且设定最后的选项为WNOHANG.表示内核在没有进程时不仅行阻塞。

        ***********************************************/

    //  --- pid = wait(&stat);

    while(( pid = waitpid(-1, &stat, WNOHANG)) > 0)

        printf("child %d terminated.\n", pid);

    return;

}

客户端程序：

#include "unp.h"

#include <stdio.h>

#include <stdlib.h>



int str_cli1(FILE *fp, int sockfd);



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

    int sockfd[5];

    struct sockaddr_in serveraddr;

    int i;



    if (argc < 2)

        err_quit("Use: clisocket <IPaddress>");

    for (i = 0; i <5; ++i){



        sockfd[i] = Socket(AF_INET, SOCK_STREAM,0);



        bzero(&serveraddr, sizeof(struct sockaddr_in));

        serveraddr.sin_family = AF_INET;

        serveraddr.sin_port = htons(SERV_PORT);

        Inet_pton(AF_INET, argv[1], &serveraddr.sin_addr);



        Connect(sockfd[i], (SA*)&serveraddr, sizeof(serveraddr));



    }



    str_cli(stdin, sockfd[0]);

    exit(0);

}





int str_cli1(FILE *fp, int sockfd){

    char sendline[MAXLINE], recvline[MAXLINE];



    while(Fgets(sendline, MAXLINE, fp) != NULL){

        Writen(sockfd, sendline, strlen(sendline));



        if (Readline(sockfd, recvline, MAXLINE) == 0)

            err_quit("str_cli: server terminated prematurely");

        Fputs(recvline, stdout);

    }

}