进程间的通信

这个解释的好像更好一点

socket主要包含通信协议，本地协议地址，本地主机端口，远端主机地址，远端主机端口。

1、建立socket
int socket(int domain, int type, int protocol);
domain:使用的协议族，通常为PF_INET,表示互联网协议族
type：指定socket类型SOCKET_STREAM(面向连接的流式socket)SOCKET_DGRAM(面向无连接的数据报式socket)
protocol：通常为0

函数返回类似文件描述符的整数值

2、配置socket
connect函数：面向连接的客户端需要调用它来在socket数据结构中保存本地和远端信息
bind函数：无连接的服务器端、客户端，面向连接的服务器端通过调用它来配置本地信息

int bind(int sockfd,struct sockaddr *my_addr, int addrlen);
bind函数将socket与本机上的一个端口相关联，然后程序就可以在该端口监听服务请求。
sockfd:socket建立的描述符
my_addr：指向包含本地ip地址及端口等信息的sockaddr类型的指针
addrlen：通常被设置为sizeof(struct sockaddr)

一些数据结构：
struct sockaddr {
unsigned short sa_family; /* 地址族， AF_xxx */
char sa_data[14]; /* 14 字节的协议地址 */
};
sa_family一般为AF_INET，代表Internet（TCP/IP）地址族；sa_data则包含该socket的IP地址和端口号。
　　 另外还有一种结构类型：
　　 struct sockaddr_in {
　　 short int sin_family; /* 地址族 */
　　 unsigned short int sin_port; /* 端口号 */
　　 struct in_addr sin_addr; /* IP地址 */
　　 unsigned char sin_zero[8]; /* 填充0 以保持与        struct sockaddr同样大小 */
　　 };

端口及ip赋值：
使用bind函数时，可以用下面的赋值实现自动获得本机IP地址和随机获取一个没有被占用的端口号：
　　 my_addr.sin_port = 0; /* 系统随机选择一个未被使用的端口号 */
　　 my_addr.sin_addr.s_addr = INADDR_ANY; /* 填入本机IP地址 */
通过将my_addr.sin_port置为0，函数会自动为你选择一个未占用的端口来使用。同样，通过将my_addr.sin_addr.s_addr置为INADDR_ANY，系统会自动填入本机IP地址。


3、建立连接
面向连接的客户程序使用connect函数配置socket并与远端服务器建立一个TCP连接。
int connect(int sockfd, struct sockaddr *serv_addr,int addrlen);
connect函数启动与远端主机的直接连接，只有面向连接的客户程序使用socket时才需要将此socket与远端主机相连。面向连接的服务器端也从不启动一个连接，只是被动的在协议端口监听客户的请求。

所以使用listen函数使socket处于被动的监听模式。并为该socket建立一个输入数据队列，将到达的服务器请求保存在此队列中，直到程序处理他们。
int listen(int sockfd, int backlog);
backlog就是指请求队列中允许的最大请求数，进入的连接请求将在队列中使用accept来处理。
accept()函数让服务器接收客户的连接请求，在建立好输入队列后，服务器就调用accept函数，然后睡眠，并等待客户的连接请求。

int accept(int sockfd, void *addr, int *addrlen);
sockfd:被监听的socket描述符，addr通常是一个指向sockaddr_in变量的指针，该变量用来存放提出连接请求的服务器的主机信息;

首先，当accept函数监视的 socket收到连接请求时，socket执行体将建立一个新的socket，执行体将这个新socket和请求连接进程的地址联系起来，收到服务请求的 初始socket仍可以继续在以前的 socket上监听，同时可以在新的socket描述符上进行数据传输操作。

4、数据传输
//send和recv用于面向连接的socket上进行数据传输
int send(int sockfd, const void *msg, int len, int flags);
Sockfd是你想用来传输数据的socket描述符；msg是一个指向要发送数据的指针；Len是以字节为单位的数据的长度；flags一般情况下置为0（关于该参数的用法可参照man手册）。

int recv(int sockfd,void *buf,int len,unsigned int flags);
Sockfd是接受数据的socket描述符；buf 是存放接收数据的缓冲区；len是缓冲的长度。Flags也被置为0。Recv()返回实际上接收的字节数，当出现错误时，返回-1并置相应的errno值。

//sendto和recvfrom用于在无连接的数据包socket方式下进行数据传输

 int sendto(int sockfd, const void *msg,int len,unsigned int flags,const
struct sockaddr *to, int tolen);
　　该函数比send()函数多了两个参数，to表示目地机的IP地址和端口号信息，而tolen常常被赋值为sizeof (struct sockaddr)。Sendto 函数也返回实际发送的数据字节长度或在出现发送错误时返回-1。
　　 Recvfrom()函数原型为：
　　 int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr*from,int *fromlen);
　 　 from是一个struct sockaddr类型的变量，该变量保存源机的IP地址及端口号。fromlen常置为sizeof (struct sockaddr)。当recvfrom()返回时，fromlen包含实际存入from中的数据字节数。Recvfrom()函数返回接收到的字节数或 当出现错误时返回-1，并置相应的errno。
如果你对数据报socket调用了connect()函数时，你也可以利用send()和recv()进行数据传输，但该socket仍然是数据报socket，并且利用传输层的UDP服务。但在发送或接收数据报时，内核会自动为之加上目地和源地址信息。

5、结束传输
当所有的数据操作结束以后，你可以调用close()函数来释放该socket，从而停止在该socket上的任何数据操作：
close(sockfd);
　　你也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输，而一个方向上的数据传输继续进行。如你可以关闭某socket的写操作而允许继续在该socket上接受数据，直至读入所有数据。
　　 int shutdown(int sockfd,int how);
　　 Sockfd是需要关闭的socket的描述符。参数 how允许为shutdown操作选择以下几种方式：
　　 ·0-------不允许继续接收数据
　　 ·1-------不允许继续发送数据
　　 ·2-------不允许继续发送和接收数据，
　　 ·均为允许则调用close ()

[cpp] view plain copy
//服务器端代码socket_server.c  
#include <stdio.h>  
#include <stdlib.h>  
#include <errno.h>  
#include <string.h>  
#include <sys/types.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
#include <sys/wait.h>  
  
#define SERVPORT 3333  
#define BACKLOG 10  
  
int main()  
{  
    int sockfd, client_fd;  
    struct sockaddr_in my_addr;  
    struct sockaddr_in remote_addr;  
    if((sockfd=socket(AF_INET,SOCK_STREAM,0)) == -1)  
    {  
        perror("socket创建出错！");  
        exit(1);  
    }  
  
    //设置my_addr  
    my_addr.sin_family = AF_INET;  
    my_addr.sin_port = htons(SERVPORT);  
    my_addr.sin_addr.s_addr = INADDR_ANY;  
    bzero(&(my_addr.sin_zero), 8);  
  
    //服务器绑定部分信息  
    if(bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1)  
    {  
        perror("bind出错!");  
        exit(1);  
    }  
  
    //开始监听  
    if(listen(sockfd, BACKLOG) == -1)  
    {  
        perror("listen出错！");  
        exit(1);  
    }  
  
    while(1)  
    {  
        int sin_size;  
        sin_size = sizeof(struct sockaddr_in);  
        //一直在监听，从未被放弃。就是直到接收到数据以后才返回值  
        //准确的说这里应该是监听到了来客户端的连接  
        if((client_fd = accept(sockfd, (struct sockaddr*)&remote_addr, &sin_size)) == -1)  
        {  
            perror("accept出错");  
            continue;  
        }  
  
        printf("received a connection from %s", inet_ntoa(remote_addr.sin_addr));  
  
        //accept接收到一个连接服务请求时，将生成一个新的socket  
        //准确的理解应该是如果有一个客户端连接到了服务器，服务器立马创建一个子进程给客户端一个响应  
        if(!fork())  
        {  
            if(send(client_fd, "Hello, you are connected!", 26, 0) == -1)  
            perror("send出错！");  
            close(client_fd);  
            exit(0);  
        }  
  
        close(client_fd);  
  
    }  
}  


[cpp] view plain copy
//客户端代码socket_client.c  
#include <stdio.h>   
#include <stdlib.h>  
#include <errno.h>  
#include <string.h>  
#include <netdb.h>  
#include <sys/types.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
  
#define SERVPORT 3333  
#define MAXDATASIZE 100  
  
int main(int argc, char *argv[])  
{  
    int sockfd, recvbytes;  
    char buf[MAXDATASIZE];  
    struct hostent *host;  
    struct sockaddr_in serv_addr;  
  
    if(argc < 2)  
    {  
        fprintf(stderr, "please enter the server''s hostname!");  
        exit(1);  
    }  
      
    //得到接收数据的ip地址  
    if((host = gethostbyname(argv[1]))==NULL)  
    {  
        herror("gethostbyname 出错！");  
        exit(1);  
    }  
  
    //创建socket  
    if((sockfd = socket(AF_INET, SOCK_STREAM,0)) == -1)  
    {  
        perror("socket出错！");  
        exit(1);  
    }  
  
    serv_addr.sin_family = AF_INET;  
    serv_addr.sin_port = htons(SERVPORT);  
    serv_addr.sin_addr = *((struct in_addr*)host->h_addr);  
    bzero(&(serv_addr.sin_zero), 8);  
      
    //面向连接的socket通信要用connect在客户端首先连接  
    if(connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr)) == -1)  
    {  
        perror("connect 出错！");  
        exit(1);  
    }  
      
    //用于接收服务器的反馈信息  
    if((recvbytes = recv(sockfd, buf, MAXDATASIZE, 0)) == -1)  
    {  
        perror("recv出错！");  
        exit(1);  
    }  
  
    buf[recvbytes] = '\0';  
    printf("Received:%s\n", buf);  
    close(sockfd);  
}  
执行方式：
开启服务器端：
[cpp] view plain copy
[root@localhost ~]# ./server  
开启客户端：
[cpp] view plain copy
[root@localhost ~]# ./client localhost.localdomain  
Received:Hello, you are connected!  

服务器输出：

[cpp] view plain copy
received a connection from 127.0.0.1