网络编程基础

参考文章：http://www.cnblogs.com/songQQ/archive/2009/09/03/1559838.html

http://www.cnblogs.com/newlist/archive/2012/02/19/2358392.html

一、socket概述

1、socket定义

Linux中的网络编程是通过socket来进行的。常说的socket接口是一种特殊的I/O，它也是一种文件描述符。每一个socket都用一个半相关描述{协议，本地地址，本地端口}来表示；一个完整的套接字则用一个相关描述{协议，本地地址，本地端口，远程地址，远程端口}来实现。socket也有类似打开文件的函数调用，该函数返回一个整型的socket描述符，随后连接建立、数据传输都是通过socket来实现的。

在运行TCP/IP协议的计数机中，一般都支持软件虚拟的ip数据报自环接口loopback。如果试图和ip地址等于自己地址的计算机通信，数据不会发到网络上，而是通过内核实现的虚拟的自环接口loopback将数据自环到计算机本身。利用这一点，可以在一个计算机的多个进程之间进行通信。现在的许多软件设计，同一台计算机内的进程之间通信也使用socket方式，这使得系统有很大的灵活性，因为需要的时候，只要将两个进程分布到不同的计算机上就可以了，而不需要更改程序。socket只是进程之间通信的一种方法，其他方法还有很多。

2、socket类型

（1）流式socket（SCOK_STREAM）

流式套接字提供可靠的、面向连接的的通信流，使用TCP协议。

（2）数据报socket（SCOKET_DGRAM）

无连接的服务，使用UDP。

（3）原始socket

原始套接字允许对底层协议如IP或者ICMP进行直接访问，用于协议的开发。

3、下图表示了协议之间的关系

scoket的哪里？

二、地址及顺序处理

1、相关数据结构

struct scokaddr
{
    unsigned short sa_family;//地址族
    char sa_data[14];//14字节的协议地址，包含该socket的IP地址和端口号
};
struct scokaddr_in
{
    short int sin_family;//地址族
    unsigned short int sin_port;//端口号
    struct in_addr sin_addr;//IP地址
    unsigned char sin_zero[8];//填充0以保持与struct sockaddr同样大小
};

两个数据结构可以相互转化。

2、数据存储优先顺序

internet上数据以高位字节优先顺序在网络上传输，因此有时需要转换字节存储优先顺序，这里有四个函数。htons ntohs htonl ntohl ,分别实现了网络字节和主机的相互转化。其中h表示host，n表示net，s表示short用来转换端口号，l表示long用来转换IP地址。

3、地址格式转化

socket表示ip地址用二进制表示，用户喜欢用点分十进制表示。两个函数可以实现相互转化。inet_ntop、inet_pton分别是网络二进制转换为十进制、十进制转换为网络二进制。

4、名字地址转换

gethostbyname和gethostbyaddr分别是将主机名转化为IP地址，IP地址转换为主机名。

三、socket基础编程

scoket：建立一个socket连接，可指定socket类型等信息。

bind ：在套接口中，一个套接字只是用户程序与内核交互信息的枢纽，它自身没有太多的信息，也没有网络协议地址和端口号等信息，在进行网络通信的时候，必须把一个套接字与一个地址相关联，这个过程就是地址绑定的过程。许多时候内核会我们自动绑定一个地址，然而有时用户可能需要自己来完成这个绑定的过程，以满足实际应用的需要，最典型的情况是一个服务器进程需要绑定一个众所周知的地址或端口以等待客户来连接。这个事由bind的函数完成。

从bind函数功能我们很容易推测出这个函数的需要的参数与相应的返回值，如果此时大家已经对socket接口有点熟悉了：

#include<sys/socket.h>int bind(int sockfd, struct sockaddr* addr, socklen_t addrlen)

返回：0──成功， -1──失败

参数sockfd: 指定地址与哪个套接字绑定，这是一个由之前的socket函数调用返回的套接字。调用bind的函数之后，该套接字与一个相应的地址关联，发送到这个地址的数据可以通过这个套接字来读取与使用。
参数addr: 指定地址。这是一个地址结构，并且是一个已经经过填写的有效的地址结构。调用bind之后这个地址与参数sockfd指定的套接字关联，从而实现上面所说的效果。
参数addrlen: 正如大多数socket接口一样，内核不关心地址结构，当它复制或传递地址给驱动的时候，它依据这个值来确定需要复制多少数据。这已经成为socket接口中最常见的参数之一了。

bind函数并不是总是需要调用的，只有用户进程想与一个具体的地址或端口相关联的时候才需要调用这个函数。如果用户进程没有这个需要，那么程序可以依赖内核的自动的选址机制来完成自动地址选择，而不需要调用bind的函数，同时也避免不必要的复杂度。在一般情况下，对于服务器进程问题需要调用bind函数，对于客户进程则不需要调用bind函数。

listen：

listen函数使用主动连接套接口变为被连接套接口，使得一个进程可以接受其它进程的请求，从而成为一个服务器进程。在TCP服务器编程中listen函数把进程变为一个服务器，并指定相应的套接字变为被动连接。

listen函数在一般在调用bind之后-调用accept之前调用，它的函数原型是：

#include<sys/socket.h>int listen(int sockfd, int backlog)

返回：0──成功， -1──失败

参数sockfd: 被listen函数作用的套接字，sockfd之前由socket函数返回。在被socket函数返回的套接字fd之时，它是一个主动连接的套接字，也就是此时系统假设用户会对这个套接字调用connect函数，期待它主动与其它进程连接，然后在服务器编程中，用户希望这个套接字可以接受外来的连接请求，也就是被动等待用户来连接。由于系统默认时认为一个套接字是主动连接的，所以需要通过某种方式来告诉系统，用户进程通过系统调用listen来完成这件事。
参数backlog: 这个参数涉及到一些网络的细节。在进程正理一个一个连接请求的时候，可能还存在其它的连接请求。因为TCP连接是一个过程，所以可能存在一种半连接的状态，有时由于同时尝试连接的用户过多，使得服务器进程无法快速地完成连接请求。如果这个情况出现了，服务器进程希望内核如何处理呢？内核会在自己的进程空间里维护一个队列以跟踪这些完成的连接但服务器进程还没有接手处理或正在进行的连接，这样的一个队列内核不可能让其任意大，所以必须有一个大小的上限。这个backlog告诉内核使用这个数值作为上限。; 毫无疑问，服务器进程不能随便指定一个数值，内核有一个许可的范围。这个范围是实现相关的。很难有某种统一，一般这个值会小30以内。

当调用listen之后，服务器进程就可以调用accept来接受一个外来的请求。

connect：对于client端，不调用bind函数，可用connect函数代替了。

网络编程socket api存在一批核心接口，而这一批核心接口就是几个看似简单的函数，尽管实际上这些函数没有一个是简单。connect函数就是这些核心接口的一个函数，它完成主动连接的过程。

connect函数的功能是完成一个有连接协议的连接过程，对于TCP来说就是那个三路握手过程，它的函数原型：

#include<sys/socket.h> int connect(int sockfd, const struct sockaddr* server_addr, socklen_t addrlen)

返回：0──成功， -1──失败。

为了理解connect函数，我们需要对connect函数的功能进行介绍。connect函数的功能可以用一句话来概括，就是完成面向连接的协议的连接过程，它是主要连接的。面向连接的协议，在建立连接的时候总会有一方先发送数据，那么谁调用了connect谁就是先发送数据的一方。如此理解connect三个参数是容易了，我必需指定数据发送的地址，同时也必需指定数据从哪里发送，这正好是connect的前两个参数，而第三个参数是为第二个参数服务的。

参数sockfd: 指定数据发送的套接字，解决从哪里发送的问题。内核需要维护大量IO通道，所以用户必需通过这个参数告诉内核从哪个IO通道，此处就是从哪个socket接口中发送数据。sockfd是先前socket返回的值。
参数server_addr: 指定数据发送的目的地，也就是服务器端的地址。这里服务器是针对connect说的，因为connect是主动连接的一方调用的，所以相应的要存在一个被连接的一方，被动连接的一方需要调用listen以接受connect的连接请求，如此被动连接的一方就是服务器了。
参数addrlen: 指定server_addr结构体的长度。我们知道系统中存在大量的地址结构，但socket接口只是通过一个统一的结构来指定参数类型，所以需要指定一个长度，以使内核在进行参数复制的时候有个有个界限。

与所有的socket网络接口一样，connect总会在某个时候可能失败，此时它会返回-1，相应的errno会被设置，用户可能通过这个值确定是哪个错误。常见的错误有对方主机不可达或者超时错误，也可以是对方主机没有相应的进程在对应端口等待。

accept：

对于服务器编程中最重要的一步等待并接受客户的连接，那么这一步在编程中如何完成，accept函数就是完成这一步的。它从内核中取出已经建立的客户连接，然后把这个已经建立的连接返回给用户程序，此时用户程序就可以与自己的客户进行点到点的通信了。

accept函数等待并接受客户请求：

#include<sys/socket.h>int accept(int sockfd, struct sockaddr* addr, socklen_t* len)

返回：非负描述字——成功， -1——失败

accept默认会阻塞进程，直到有一个客户连接建立后返回，它返回的是一个新可用的套接字，这个套接字是连接套接字。此时我们需要区分两种套接字，一种套接字正如accept的参数sockfd，它是监听套接字，在调用listen函数之后，一个套接字会从主动连接的套接字变身为一个监听套接字；而accept返回是一个连接套接字，它代表着一个网络已经存在的点点连接。自然要问的是：为什么要有两种套接字？原因很简单，如果使用一个描述字的话，那么它的功能太多，使得使用很不直观，同时在内核确实产生了一个这样的新的描述字。

参数sockfd: 参数sockfd就是上面解释中的监听套接字，这个套接字用来监听一个端口，当有一个客户与服务器连接时，它使用这个一个端口号，而此时这个端口号正与这个套接字关联。当然客户不知道套接字这些细节，它只知道一个地址和一个端口号。
参数addr: 这是一个结果参数，它用来接受一个返回值，这返回值指定客户端的地址，当然这个地址是通过某个地址结构来描述的，用户应该知道这一个什么样的地址结构。如果对客户的地址不感兴趣，那么可以把这个值设置为NULL。
参数len: 如同大家所认为的，它也是结果的参数，用来接受上述addr的结构的大小的，它指明addr结构所占有的字节个数。同样的，它也可以被设置为NULL。

如果accept成功返回，则服务器与客户已经正确建立连接了，此时服务器通过accept返回的套接字来完成与客户的通信。

send ：

int send( SOCKET s, const char FAR *buf, int len, int flags );
不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。客户程序一般用send函数向服务器发送请求，而服务器则通常用send函数来向客户程序发送应答。
该函数的第一个参数指定发送端套接字描述符；
第二个参数指明一个存放应用程序要发送数据的缓冲区；
第三个参数指明实际要发送的数据的字节数；
第四个参数一般置0。
这里只描述同步Socket的send函数的执行流程。当调用该函数时，
（1）send先比较待发送数据的长度len和套接字s的发送缓冲的长度，
如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；
（2）如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么send就比较s的发送缓冲区的剩余空间和len
（3）如果len大于剩余空间大小，send就一直等待协议把s的发送缓冲中的数据发送完
（4）如果len小于剩余空间大小，send就仅仅把buf中的数据copy到剩余空间里（注意并不是send把s的发送缓冲中的数据传到连接的另一端的，而是协议传的，send仅仅是把buf中的数据copy到s的发送缓冲区的剩余空间里）。
如果send函数copy数据成功，就返回实际copy的字节数，如果send在copy数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send函数也返回SOCKET_ERROR。
要注意send函数把buf中的数据成功copy到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除send外的Socket函数在执
行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket函数就返回
SOCKET_ERROR）
注意：在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。
通过测试发现，异步socket的send函数在网络刚刚断开时还能发送返回相应的字节数，同时使用select检测也是可写的，但是过几秒钟之后，再send就会出错了，返回-1。select也不能检测出可写了。
recv：
int recv( SOCKET s, char FAR *buf, int len, int flags);
不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数据。该函数的第一个参数指定接收端套接字描述符；
第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据；
第三个参数指明buf的长度；
第四个参数一般置0。
这里只描述同步Socket的recv函数的执行流程。当应用程序调用recv函数时，
（1）recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR，
（2）如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有数据或者协议正在接收数据，那么recv就一直等待，直到协议把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据copy到buf中（注意协议接收到的数据可能大于buf的长度，所以
在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。recv函数仅仅是copy数据，真正的接收数据是协议来完成的），

如果recv在copy时出错，那么它返回SOCKET_ERROR；

如果recv函数在等待协议接收数据时网络中断了，那么它返回0。

默认 socket 是阻塞的解阻塞与非阻塞recv返回值没有区分，都是 <0 出错 =0 连接关闭 >0 接收到数据大小，

特别：

返回值<0时并且(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)的情况下认为连接是正常的，继续接收。

只是阻塞模式下recv会阻塞着接收数据，非阻塞模式下如果没有数据会返回，不会阻塞着读，因此需要循环读取）。

返回说明：
成功执行时，返回接收到的字节数。

另一端已关闭则返回0。

失败返回-1，

errno被设为以下的某个值
EAGAIN：套接字已标记为非阻塞，而接收操作被阻塞或者接收超时
EBADF：sock不是有效的描述词
ECONNREFUSE：远程主机阻绝网络连接
EFAULT：内存空间访问出错
EINTR：操作被信号中断
EINVAL：参数无效
ENOMEM：内存不足
ENOTCONN：与面向连接关联的套接字尚未被连接上
ENOTSOCK：sock索引的不是套接字当返回值是0时，为正常关闭连接；

recv函数返回其实际copy的字节数。如果recv在copy时出错，那么它返回SOCKET_ERROR；如果recv函数在等待协议接收数据时网络中断了，那么它返回0。
注意：在Unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

编程实例：

/*server.c*/
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<errno.h>
#include<string.h>
#include<unistd.h>
#include<netinet/in.h>
#define PORT 4321
#define BUFFER_SIZE 1024
#define MAX_QUE_CONN_NM 5
int main()
{
    struct sockaddr_in server_sockaddr,client_sockaddr;
    int sin_size,recvbytes;
    int sockfd,client_fd;
    char buf[BUFFER_SIZE];
    
    //建立socket链接
    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)
    {
        perror("socket");
        exit(1);
    }
    printf("socket is = %d
",sockfd);

    //设置sockaddr_in结构体中相关参数
    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_port = htons(PORT);
    server_sockaddr.sin_addr.s_addr = INADDR_ANY;
    bzero(&(server_sockaddr.sin_zero),8);
    
    int i =1;//允许重复使用本地地址与套接字进行绑定
    setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&i,sizeof(i));
    
    //绑定套接字
    if(bind(sockfd,(struct sockaddr *)&server_sockaddr,sizeof(struct sockaddr)) == -1)
    {
        perror("bind");
        exit(1);
    }
    printf("bind success
");

    //listen()
    if(listen(sockfd,MAX_QUE_CONN_NM) == -1)
    {
        perror("listen");
        exit(1);
    }
    printf("listen ......
");

    //accept()
    sin_size = sizeof(client_sockaddr);
    if((client_fd = accept(sockfd,(struct sockaddr *)&client_sockaddr,&sin_size)) == -1)
    {
        perror("accept");
        exit(1);
    }
    
    //recv()
    memset(buf,0,sizeof(buf));
    if((recvbytes = recv(client_fd,buf,BUFFER_SIZE,0)) == -1)
    {
        perror("recv");
        exit(1);
    }
    printf("received a message:%s
",buf);
    close(sockfd);
    exit(0);
}

/*client.c*/
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<errno.h>
#include<string.h>
#include<unistd.h>
#include<netinet/in.h>
#include<netdb.h>//一定要加上这个头文件，不然会报“提领指向不完全类型的指针”的错误
#define PORT 4321
#define BUFFER_SIZE 1024
int main(int argc,char *argv[])
{
    struct sockaddr_in serv_addr;
    int sendbytes,sockfd;
    struct hostent *host;
    char buf[BUFFER_SIZE];
    
    if(argc < 3)
    {
        fprintf(stderr,"USAGE: ./client Hostname(or ip address) Text
");
        exit(1);
    }
    
    //地址解析函数
    if((host = gethostbyname(argv[1])) == NULL)
    {
        perror("gethostbyname");
        exit(1);
    }
    
    memset(buf,0,sizeof(buf));
    sprintf(buf,"%s",argv[2]);
    //建立socket
    if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)
    {
        perror("socket");
        exit(1);
    }

    //设置sockaddr_in结构体中相关参数
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
    bzero(&(serv_addr.sin_zero),8);
    
    //connect()
    if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(struct sockaddr)) == -1)
    {
        perror("connect
");
        exit(1);
    }
    
    //send()
    if((sendbytes = send(sockfd,buf,strlen(buf),0)) == -1)
    {
        perror("send");
        exit(1);
    }
    close(sockfd);
    exit(0);
}