android socket编程

最新推荐文章于 2023-12-27 17:11:30 发布

weixin_30497527

最新推荐文章于 2023-12-27 17:11:30 发布

阅读量155

点赞数

文章标签：移动开发数据结构与算法 java

原文链接：http://www.cnblogs.com/xl19862005/archive/2012/06/27/2566210.html

版权

转载时请注明出处和作者

文章出处：http://www.cnblogs.com/xl19862005

作者：Xandy

注明：以下部分内容来自 Linux下Socket编程

1 关于socket

关于socket百度百科里有这样的解释：通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。Socket正如其英文原意那样，象一个多孔插座。一台主机犹如布满各种插座的房间，每个插座有一个编号，有的插座提供220伏交流电，有的提供110伏交流电，有的则提供有线电视节目。客户软件将插头插到不同编号的插座，就可以得到不同的服务。

至此，我们对socket进行了直观的描述。抽象出来，socket实质上提供了进程通信的端点。进程通信之前，双方首先必须各自创建一个端点，否则是没有办法建立联系并相互通信的。正如打电话之前，双方必须各自拥有一台电话机一样。在网间网内部，每一个socket用一个半相关描述：

（协议，本地地址，本地端口）

　　一个完整的socket有一个本地唯一的socket号，由操作系统分配。

　　最重要的是，socket 是面向客户/服务器模型而设计的，针对客户和服务器程序提供不同的socket 系统调用。客户随机申请一个socket （相当于一个想打电话的人可以在任何一台入网电话上拨号呼叫），系统为之分配一个socket号；服务器拥有全局公认的 socket ，任何客户都可以向它发出连接请求和信息请求（相当于一个被呼叫的电话拥有一个呼叫方知道的电话号码）。

socket利用客户/服务器模式巧妙地解决了进程之间建立通信连接的问题。服务器socket 半相关为全局所公认非常重要。不妨考虑一下，两个完全随机的用户进程之间如何建立通信？假如通信双方没有任何一方的socket 固定，就好比打电话的双方彼此不知道对方的电话号码，要通话是不可能的。

网络的socket数据传输是一种特殊的I/O，socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该socket实现的。

2 常见socket类型

常用的socket类型有两种：

·流式socket （SOCK_STREAM）。流式是一种面向连接的socket，针对于面向连接的TCP服务应用。

·数据报式socket（SOCK_DGRAM）。数据报式socket是一种无连接的socket，对应于无连接的UDP服务应用。

3 Linux下socket编程

3.1 socket建立

socket为了建立socket连接，程序可以调用socket函数，该函数返回一个类似于文件描述符的句柄。socket函数原型为：int socket(int domain,int type,int protocol);domain指明所使用的协议族，通常为PF_INET，(其与addrinfo 里的 AF_INET在现在看来是相同的。只是历史上人们曾构想将AF（地址家族address family）与PF(protocol family 协议家族)分开，但实际上这种区分并未真正推广，所以现在AF_INET和PF_INET具有相同的意义。其中AF_INET是基于IPv4而PF_INET基于IPv6）表示互联网协议族（TCP/IP协议族）；type参数指定socket的类型：SOCK_STREAM 或SOCK_DGRAM，socket接口还定义了原始socket（SOCK_RAW），允许程序使用低层协议；protocol通常赋值0。socket（）调用返回一个整型socket描述符，你可以在后面的调用使用它。socket描述符是一个指向内部数据结构的指针，它指向描述符表入口。调用socket函数时，socket执行体将建立一个socket，实际上"建立一个socket"意味着为一个socket数据结构分配存储空间。socket执行体为你管理描述符表。两个网络程序之间的一个网络连接包括五种信息：通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。socket数据结构中包含这五种信息。

3.2 socket配置

通过socket调用返回一个socket描述符后，在使用socket进行网络传输以前，必须配置该socket。面向连接的socket客户端通过调用connect函数在socket数据结构中保存本地和远端信息。无连接socket的客户端和服务端以及面向连接socket的服务端通过调用 bind函数来配置本地信息。

bind函数将socket与本机上的一个端口相关联，随后你就可以在该端口监听服务请求。bind函数原型为：

int bind(int sockfd,struct sockaddr *my_addr, int addrlen);

sockfd是调用socket函数返回的socket描述符,my_addr是一个指向包含有本机IP地址及端口号等信息的sockaddr类型的指针；addrlen常被设置为sizeof(struct sockaddr)。

struct sockaddr结构类型是用来保存socket信息的：

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同样大小 */

};

这个结构更方便使用。sin_zero用来将sockaddr_in结构填充到与struct sockaddr同样的长度，可以用bzero()或memset()函数将其置为零。指向sockaddr_in 的指针和指向sockaddr的指针可以相互转换，这意味着如果一个函数所需参数类型是sockaddr时，你可以在函数调用的时候将一个指向 sockaddr_in的指针转换为指向sockaddr的指针；或者相反。

使用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地址。

注意在使用bind函数是需要将sin_port和sin_addr转换成为网络字节优先顺序；而sin_addr则不需要转换。

计算机数据存储有两种字节优先顺序：高位字节优先和低位字节优先。Internet上数据以高位字节优先顺序在网络上传输，所以对于在内部是以低位字节优先方式存储数据的机器，在Internet上传输数据时就需要进行转换，否则就会出现数据不一致。

下面是几个字节顺序转换函数：

·htonl()：把32位值从主机字节序转换成网络字节序

·htons()：把16位值从主机字节序转换成网络字节序

·ntohl()：把32位值从网络字节序转换成主机字节序

·ntohs()：把16位值从网络字节序转换成主机字节序

Bind()函数在成功被调用时返回0；出现错误时返回"-1"并将errno置为相应的错误号。需要注意的是，在调用bind函数时一般不要将端口号置为小于1024的值，因为1到1024是保留端口号，你可以选择大于1024中的任何一个没有被占用的端口号。

3.3 连接建立

面向连接的客户程序使用connect函数来配置socket并与远端服务器建立一个TCP连接，其函数原型为：

int connect(int sockfd, struct sockaddr *serv_addr,int addrlen);

Sockfd 是socket函数返回的socket描述符；serv_addr是包含远端主机IP地址和端口号的指针；addrlen是远端地质结构的长度。connect函数在出现错误时返回-1，并且设置errno为相应的错误码。进行客户端程序设计无须调用bind()，因为这种情况下只需知道目的机器的IP地址，而客户通过哪个端口与服务器建立连接并不需要关心，socket执行体为你的程序自动选择一个未被占用的端口，并通知你的程序数据什么时候到达端口。

connect函数启动和远端主机的直接连接。只有面向连接的客户程序使用socket时才需要将此socket与远端主机相连。无连接协议从不建立直接连接。面向连接的服务器也从不启动一个连接，它只是被动的在协议端口监听客户的请求。

listen函数使socket处于被动的监听模式，并为该socket建立一个输入数据队列，将到达的服务请求保存在此队列中，直到程序处理它们。

int listen(int sockfd， int backlog);

sockfd 是socket系统调用返回的socket 描述符；backlog指定在请求队列中允许的最大请求数，进入的连接请求将在队列中等待accept()它们（参考下文）。backlog对队列中等待服务的请求的数目进行了限制，大多数系统缺省值为20。如果一个服务请求到来时，输入队列已满，该socket将拒绝连接请求，客户将收到一个出错信息。

当出现错误时listen函数返回-1，并置相应的errno错误码。

accept()函数让服务器接收客户的连接请求。在建立好输入队列后，服务器就调用accept函数，然后睡眠并等待客户的连接请求。

int accept(int sockfd, void *addr, int *addrlen);

sockfd是被监听的socket描述符，addr通常是一个指向sockaddr_in变量的指针，该变量用来存放提出连接请求服务的主机的信息（某台主机从某个端口发出该请求）；addrten通常为一个指向值为sizeof(struct sockaddr_in)的整型指针变量。出现错误时accept函数返回-1并置相应的errno值。

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

3.4 数据传输

send()和recv()这两个函数用于面向连接的socket上进行数据传输。

send()函数原型为：

int send(int sockfd, const void *msg, int len, int flags);

sockfd是你想用来传输数据的socket描述符；msg是一个指向要发送数据的指针；len是以字节为单位的数据的长度；flags一般情况下置为0（关于该参数的用法可参照man手册）。

send()函数返回实际上发送出的字节数，可能会少于你希望发送的数据。在程序中应该将send()的返回值与欲发送的字节数进行比较。当send()返回值与len不匹配时，应该对这种情况进行处理。

char *msg = "Hello!";

int len, bytes_sent;

……

len = strlen(msg);

bytes_sent = send(sockfd, msg,len,0);

……

recv()函数原型为：

int recv(int sockfd,void *buf,int len,unsigned int flags);

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

sendto()和recvfrom()用于在无连接的数据报socket方式下进行数据传输。由于本地socket并没有与远端机器建立连接，所以在发送数据时应指明目的地址。

sendto()函数原型为：

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服务。但在发送或接收数据报时，内核会自动为之加上目地和源地址信息。

3.5 结束传输

当所有的数据操作结束以后，你可以调用close()函数来释放该socket，从而停止在该socket上的任何数据操作：

close(sockfd);

你也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输，而一个方向上的数据传输继续进行。如你可以关闭某socket的写操作而允许继续在该socket上接受数据，直至读入所有数据。

int shutdown(int sockfd,int how);

Sockfd是需要关闭的socket的描述符。参数 how允许为shutdown操作选择以下几种方式：

·0-------不允许继续接收数据

·1-------不允许继续发送数据

·2-------不允许继续发送和接收数据，

·均为允许则调用close ()

shutdown在操作成功时返回0，在出现错误时返回-1并置相应errno。

3.6 socket (TCP)编程实例

3.6.1 服务器端：tcp_server.c

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

 

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[BUFSIZ];  //数据传送的缓冲区

       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);

      

       /*等待客户端连接请求到达*/

       if((client_sockfd=accept(server_sockfd,(struct sockaddr *)&remote_addr,&sin_size))<0)

       {

              perror("accept");

              return 1;

       }

       printf("accept client %s\n",inet_ntoa(remote_addr.sin_addr));

       len=send(client_sockfd,"Welcome to my server\n",21,0);//发送欢迎信息

      

       /*接收客户端的数据并将其发送给客户端--recv返回接收到的字节数，send返回发送的字节数*/

       while((len=recv(client_sockfd,buf,BUFSIZ,0))>0)

       {

              buf[len]='\0';

              printf("%s\n",buf);

              if(send(client_sockfd,buf,len,0)<0)

              {

                     perror("write");

                     return 1;

              }

       }

       close(client_sockfd);

       close(server_sockfd);

        return 0;

}

3.6.2 客户端：tcp_client.c

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

 

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

{

       int client_sockfd;

       int len;

       struct sockaddr_in remote_addr; //服务器端网络地址结构体

       char buf[BUFSIZ];  //数据传送的缓冲区

       memset(&remote_addr,0,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("socket");

              return 1;

       }

      

       /*将套接字绑定到服务器的网络地址上*/

       if(connect(client_sockfd,(struct sockaddr *)&remote_addr,sizeof(struct sockaddr))<0)

       {

              perror("connect");

              return 1;

       }

       printf("connected to server\n");

       len=recv(client_sockfd,buf,BUFSIZ,0);//接收服务器端信息

         buf[len]='\0';

       printf("%s",buf); //打印服务器端信息

      

       /*循环的发送接收信息并打印接收信息--recv返回接收到的字节数，send返回发送的字节数*/

       while(1)

       {

              printf("Enter string to send:");

              scanf("%s",buf);

              if(!strcmp(buf,"quit"))

                     break;

              len=send(client_sockfd,buf,strlen(buf),0);

              len=recv(client_sockfd,buf,BUFSIZ,0);

              buf[len]='\0';

              printf("received:%s\n",buf);

       }

       close(client_sockfd);//关闭套接字

    return 0;

}

3.7 socket (UDP)编程实例

3.7.1 服务器端：udp_server.c

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

 

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

{

       int server_sockfd;

       int len;

       struct sockaddr_in my_addr;   //服务器网络地址结构体

         struct sockaddr_in remote_addr; //客户端网络地址结构体

       int sin_size;

       char buf[BUFSIZ];  //数据传送的缓冲区

       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(6001); //服务器端口号

      

       /*创建服务器端套接字--IPv4协议，面向无连接通信，UDP协议*/

       if((server_sockfd=socket(PF_INET,SOCK_DGRAM,0))<0)

       { 

              perror("socket");

              return 1;

       }

 

        /*将套接字绑定到服务器的网络地址上*/

       if (bind(server_sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))<0)

       {

              perror("bind");

              return 1;

       }

       sin_size=sizeof(struct sockaddr_in);

       printf("waiting for a packet...\n");

      

       /*接收客户端的数据并将其发送给客户端--recvfrom是无连接的*/

       if((len=recvfrom(server_sockfd,buf,BUFSIZ,0,(struct  sockaddr *)&remote_addr,&sin_size))<0)

       {

              perror("recvfrom");

              return 1;

       }

       printf("received packet from %s:\n",inet_ntoa(remote_addr.sin_addr));

       buf[len]='/0';

       printf("contents: %s\n",buf);

       close(server_sockfd);

    return 0;

}

3.7.2 客户端：udp_client.c

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

 

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

{

       int client_sockfd;

       int len;

        struct sockaddr_in remote_addr; //服务器端网络地址结构体

       int sin_size;

       char buf[BUFSIZ];  //数据传送的缓冲区

       memset(&remote_addr,0,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(6001); //服务器端口号

 

         /*创建客户端套接字--IPv4协议，面向无连接通信，UDP协议*/

       if((client_sockfd=socket(PF_INET,SOCK_DGRAM,0))<0)

       { 

              perror("socket");

              return 1;

       }

       strcpy(buf,"This is a test message");

       printf("sending: '%s'\n",buf);

       sin_size=sizeof(struct sockaddr_in);

      

       /*向服务器发送数据包*/

       if((len=sendto(client_sockfd,buf,strlen(buf),0,(struct sockaddr *)&remote_addr,sizeof(struct sockaddr)))<0)

       {

              perror("recvfrom");

              return 1;

       }

       close(client_sockfd);

       return 0;

}

4 android下socket编程

在android下，socket编程主要有两部分：一是本地(native)socket编程；另外一个是java中的socket编程。

4.1 本地(native)socket编程

android的本地方法实现中很多都继承了linux的特性，所以在socket编程方面，很多都和上面讲的linux下socket编程方法类似。值得一提的是android在线程间通信时，除了用binder机制或者framework层与native层间交换数据时用的jni这些常见的方法外，还可以用socket通讯，下面就主要来讲讲如何通过socket让native与framework或者app之间进行通讯！

先提一下研究socket在线程间通讯的背景。目前正在做一个GPIO口的LED测试项目，原理比较简单，就是每一个空着的GPIO口上都挂了一个LED灯，用来检测GPIO口是否通路，内核中的驱动也比较简单，不再提及，我们主要来看看HAL中是如何来处理与底层和framework或者app之间的关系的！

为了绕开常规封装HAL层SO库，然后通过jni或者native java调用SO库这种繁琐的过程，我用HAL封装成了一个可执行文件，然后在init.rc里将这个可执行文件封装成service，最后用socket关键字创建一个Uinx域的名为/dev/socket/《service name》的套接字，并传递它的文件描述符给已启动的进程的方式启动socket server端。

先来看看这个可执行文件中的main函数：

int socketMain(int fd)

{

    int door_sock = -1;

 

       // Socket to listen on for incomming app connections

       if ((door_sock = android_get_control_socket(GPIOLED_SOCKET)) < 0)

       {

              LOGE("Obtaining file descriptor socket '%s' failed: %s",

                           GPIOLED_SOCKET, strerror(errno));

              exit(1);

       }

 

       //listen :backlog = have connected teams + will connect teams

       //队列数的总和，在这里只允许一个连接

       if (listen(door_sock, 1) < 0)

       {

              LOGE("Unable to listen on fd '%d' for socket '%s': %s",

                           door_sock, GPIOLED_SOCKET, strerror(errno));

              exit(1);

       }

 

       while(1)

       {

        fd_set read_fds;

        struct timeval to;

        int rc = 0;

 

              to.tv_sec = (60 * 60);

              to.tv_usec = 0;

             

              FD_ZERO(&read_fds);

              FD_SET(door_sock, &read_fds);

             

              if (gpioSock != -1)

                     FD_SET(gpioSock, &read_fds);

             

              if ((rc = select(door_sock + 1, &read_fds, NULL, NULL, &to)) < 0)

              {

                     LOGE("select() failed (%s)", strerror(errno));

                     sleep(1);

                     continue;

              }

             

              if (!rc)

                     continue;

             

              if (FD_ISSET(door_sock, &read_fds))

              {

                     struct sockaddr addr;

                     socklen_t alen;

             

                     alen = sizeof(addr);

             

                     if (gpioSock != -1)

                     {

                            LOGE("Dropping duplicate app connection");

                            int tmp = accept(door_sock, &addr, &alen);

                            close(tmp);

                            continue;

                     }

             

                     if ((gpioSock = accept(door_sock, &addr, &alen)) < 0)

                            LOGE("Unable to accept app connection (%s)",strerror(errno));

                    

                     LOGI("Accepted connection from app");

              }

             

              if (FD_ISSET(gpioSock, &read_fds))

              {

                     LOGI("process cmd from app");

                     if ((rc = processAppCommand(fd,gpioSock)) < 0)

                     {

                            if (rc == -ECONNRESET)

                            {

                                   LOGE("app disconnected");

                                   close(gpioSock);

                                   gpioSock = -1;

                            }

                            else

                                   LOGE("Error processing app command (%s)",strerror(errno));

                     }

                     else

                            sendMsgToApp(gpioSock);

              }

       }

}

这里主要要说明的是如下这几个函数：

·static inline int android_get_control_socket(const char *name)

它的解释如下：

android_get_control_socket - simple helper function to get the file descriptor of our init-managed Unix domain socket. `name' is the name of the socket, as given in init.rc. Returns -1 on error.

这里需要说明的是传入的name是在init.rc里面通过socket关键字修饰的字符串，在我的这个工程里，init.rc里有如下定义：

#Xandy add socket for gpio test

service gpiotest /system/bin/logwrapper /system/bin/gpiotest -s

              user root

              socket gpiotest stream 666

其中/system/bin/gpiotest这个文件就是前面提到的可执行文件！

·#include<sys/socket.h>

int listen(int sockfd, int backlog)

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

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

参数sockfd

被listen函数作用的套接字，sockfd之前由socket函数返回。在被socket函数返回的套接字fd之时，它是一个主动连接的套接字，也就是此时系统假设用户会对这个套接字调用connect函数，期待它主动与其它进程连接，然后在服务器编程中，用户希望这个套接字可以接受外来的连接请求，也就是被动等待用户来连接。由于系统默认时认为一个套接字是主动连接的，所以需要通过某种方式来告诉系统，用户进程通过系统调用listen来完成这件事。

参数backlog

这个参数涉及到一些网络的细节。在进程正理一个一个连接请求的时候，可能还存在其它的连接请求。因为TCP连接是一个过程，所以可能存在一种半连接的状态，有时由于同时尝试连接的用户过多，使得服务器进程无法快速地完成连接请求。如果这个情况出现了，服务器进程希望内核如何处理呢？内核会在自己的进程空间里维护一个队列以跟踪这些完成的连接但服务器进程还没有接手处理或正在进行的连接，这样的一个队列内核不可能让其任意大，所以必须有一个大小的上限。这个backlog告诉内核使用这个数值作为上限。

毫无疑问，服务器进程不能随便指定一个数值，内核有一个许可的范围。这个范围是实现相关的。很难有某种统一，一般这个值会小30以内。

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

·#include<sys/socket.h>

int accept(int sockfd, struct sockaddr* addr, socklen_t* len)

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

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

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

参数sockfd

参数sockfd就是上面解释中的监听套接字，这个套接字用来监听一个端口，当有一个客户与服务器连接时，它使用这个一个端口号，而此时这个端口号正与这个套接字关联。当然客户不知道套接字这些细节，它只知道一个地址和一个端口号。

参数addr

这是一个结果参数，它用来接受一个返回值，这返回值指定客户端的地址，当然这个地址是通过某个地址结构来描述的，用户应该知道这一个什么样的地址结构。如果对客户的地址不感兴趣，那么可以把这个值设置为NULL。

参数len

如同大家所认为的，它也是结果的参数，用来接受上述addr的结构的大小的，它指明addr结构所占有的字节个数。同样的，它也可以被设置为NULL。

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

至此，如果连接没有问题，就可以用linux下的read/write来写socket进行读写了！

4.2 java socket编程

关于java中的socket编程，这里不再过多说明，网上类似的文章和资料已经够多了，这里主要提一下，用上面的方法建立的socket server端，如果java中的client端要对它进行正常的读写时，涉及的主要代码如下：

LocalSocket ls =null;

LocalSocketAddress lsa;

ls = new LocalSocket();

lsa = new LocalSocketAddress(SOCKET_NAME,LocalSocketAddress.Namespace.RESERVED);

ls.connect(l);

要注意的是上面代码中的SOCKET_NAME正是在前面init.rc里面定义的！

关于socket编程，要讲的还有很多，希望在日后的工作学习中不断更进！

转载于:https://www.cnblogs.com/xl19862005/archive/2012/06/27/2566210.html