推荐两篇Linux下的Socket文章

逃离我推掉我的手 2022-09-21 11:42 286阅读 0赞

[Linux Socket][]  
[Linux下Socket编程][Linux_Socket]

[HTTP 协议的简介][HTTP]

HTTP 协议的简介   
  
　　HTTP协议是一种超文本传输协议（Hypertext Transfer Protocol），工作于网络应用层，自1990年起广泛应用于WWW 的全球信息服务，HTTP协议的详细说明可以在网上查阅RFC2518、RFC2616等文档。   
  
  
　　HTTP 协议老的标准是HTTP/1.0，目前最通用的标准是HTTP/1.1。HTTP/1.1是在HTTP/1.0基础上的升级，增加了一些功能，全面兼容HTTP/1.0。HTTP/1.0不支持文件断点续传，如果服务器使用HTTP/1.0，“网络蚂蚁”的任何多线程下载程序都只能按单线程下载；好在目前的Web服务器绝大多数都采用了HTTP/1.1，所以，下面将基于HTTP/1.1进行介绍。   
  
　　HTTP协议的相关重要命令   
  
　　基于HTTP的浏览器浏览网页、下载文件时，工作原理类似客户机/服务器模式：浏览器向Web服务器发出一个HTTP请求行；Web服务器在收到有效的请求后，返回一个状态行或多个响应标题、一个空白行和相关文档。根据这一工作原理，下载程序必须实现向服务器发送请求和获取服务器响应状态的功能。   
  
　　1.向服务器发送 GET请求命令   
  
　　一个HTTP请求由一个请求行、可选数目的请求标题、一个空白行，以及在POST情况下的一些额外的数据组成。请求行的格式是：   
  
　　请求方法　URI　 HTTP/版本号   
  
　　GET 命令是浏览器常用的文档请求方法，在程序中间使用   
  
　　GET　URI　 HTTP/1.1   
  
　　向Web服务器发送请求行（行号3），Java 代码如下：   
  
  
．．．．   
clientSocket = new Socket(host, port);//打开要下载文件服务器的Socket   
outStream = new PrintStream(clientSocket.getOutputStream());   
．．．．   
outStream.println(“GET”+uri+“ HTTP/1.1”);   
outStream.println(“Host:”+host);   
outStream.println(“Accept:\*/\* ”);   
outStream.println(“Referer:”);   
outStream.println();   
．．．．   
  
  
　　注：第4行给出URL中的主机名和端口号，第5行说明客户端接收所有MIME类型，第7行方送一个空白行，表明请求行结束。   
  
　　2.获取服务器响应状态   
  
　　在发送HTTP请求行以后，程序就可以读取服务器的响应状态了。HTTP响应状态行包括：HTTP 状态码和一些HTTP响应标题。   
  
　　1) HTTP状态码   
  
　　HTTP状态码格式是 HTTP/版本信息的数字表示。状态码例子如下：   
  
　　HTTP/1.0 200 OK // 表示服务器支持HTTP/1.0 协议，成功   
  
　　HTTP/1.1 200 OK // 表示服务器支持HTTP/1.1 协议，成功   
  
　　HTTP/1.0 404 Not Found // 表示服务器支持HTTP/1.0 协议，访问文件没有找到   
  
　　在程序中间，如果读到“HTTP/1.1 200 OK”这样的字符串，表明欲下载文件存在、该服务器支持断点续传，可以使用多线程下载。如果读到“HTTP/1.0 200 OK”这样的字符串，表明欲下载文件存在、但该服务器不支持断点续传，只可以使用单线程下载。   
  
  
．．．．．   
while ((line=inStream.readLine()) != null)　//将服务器响应状态读到line   
．．．．．．．．   
if(line.substring(0,7).equals(“HTTP/1.”) )　//判断是否支持HTTP/1.1   
\{ if(line.charAt(7)==‘0’)   
\{   
System.out.println(“server use http/1.0”);   
threadcount=1;   
\}   
if(!(line.substring(9,12)).equals(“200”)) //判断请求是否成功   
\{ System.out.println(“ERROR:”+line);   
return false;   
\}   
\}   
  
　　2) 读取重要的响应标题，获得要下载文档的文件长度   
  
　　如果HTTP状态码表明访问成功，服务器会回送一些标题行，我们最关注的是Content-Length　这一行，比如，如果服务器回送“Content-Length:1000”，表明请求文件的长度是１０００字节，所以读取这一行信息，可以得到文件的长度信息：   
  
  
．．．．   
if(line.substring(0,15).equals(“Content-Length:”) )   
\{ filelength=Long.parseLong(line.substring(15).trim());   
System.out.println(“file length:” +filelength);   
\}   
．．．．．．   
  
　　向服务器发送断点续传请求   
  
　　如上所述，如果服务器支持HTTP/1.1，再次向服务器发送GET请求：   
  
  
．．．．．   
outStream.println(“GET ”+uri+“HTTP/1.1 ”);   
outStream.println(“Host:”+host);   
outStream.println(“Accept:\*/\* ”);   
outStream.println(“RANGE:bytes=”+(fileblocklength)\*thisthreadid+“-”);   
outStream.println();   
．．．．．   
  
　　第4行是关键，“RANGE:bytes=”是HTTP/1.1新增内容，HTTP/1.0每次传送文件都是从文件头开始，即０字节处开始，“RANGE:bytes=XXXX”表示要求服务器从文件XXXX字节处开始传送，这就是我们平时所说的断点续传！   
  
　　分割文件，多线程下载   
  
　　使用多线程编程技术，同时启动多个线程，根据线程个数，计算文件分割位置，向服务器发送几个不同的下载断点，同时接受数据并写入文件，就可以实现多线程下载了。   
  
  
.....   
raf=new RandomAccessFile(file,“rw”);//以随机存取方式打开文件   
.....   
synchronized(raf) //按同步方式把各个线程得到数据分别写入文件   
\{ raf.seek(thisthreadid\*(filelength/threadcount)+k\*buflength);   
raf.write(readbytes);   
......   
\}   
......   
  
下面是用PHP模拟的POST中的构造Http协议部分  
  $request = "POST /happy/member.php HTTP/1.1/r/n";  
  $request .= "Pragma: no cache/r/n";  
  $request .= "Host: phpx.com/r/n";  
  $request .= "User-Agent: " . $\_SERVER\['HTTP\_USER\_AGENT'\] . "/r/n";  
  $request .= "Accept: \*/\*/r/n";  
  $request .= "Accept-Language: " . $\_SERVER\['HTTP\_ACCEPT\_LANGUAGE'\] . "/r/n";  
  $request .= "Keep-Alive: 300/r/n";  
  $request .= "Connection: keep-alive/r/n";  
  $request .= "Cache-Control: max-age=0/r/n";  
  $request .= "Content-Type: application/x-www-form-urlencoded/r/n";  
  $request .= "Content-Length: $lenght/r/n";  
  $request .= "/r/n";  
  $request .= $postValues;  
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝  
下面是响应成功返回的信息  
HTTP/1.1 200 OK  
Date: Fri, 05 Nov 2004 01:06:59 GMT  
Server: Apache  
Set-Cookie: bblastvisit=1099616819; expires=Sat, 05-Nov-2005 01:06:59 GMT; path=/  
Set-Cookie: bbuserid=17027; expires=Sat, 05-Nov-2005 01:06:59 GMT; path=/  
Set-Cookie: bbpassword=3332def6f45e948bd403276b3b2002d4; expires=Sat, 05-Nov-2005 01:06:59 GMT; path=/  
Set-Cookie: sessionhash=53a2b0ee3798fe2ca15342541b62f823; path=/  
Content-Length: 3325  
Keep-Alive: timeout=5, max=100  
Connection: Keep-Alive  
Content-Type: text/html; charset=GB2312  
..........................................

# [Linux下Socket编程][Linux_Socket 1] #

# **什么是Socket**    　　 Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。   　 　 Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解Socket了。网络的 Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返 回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。常用的Socket类型有两种：流式Socket （SOCK\_STREAM）和数据报式Socket（SOCK\_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据 报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。  **Socket建立**    　　为了建立Socket，程序可以调用Socket函数，该函数返回一个类似于文件描述符的句柄。socket函数原型为：   　　 int socket(int domain, int type, int protocol);   　 　 domain指明所使用的协议族，通常为PF\_INET，表示互联网协议族（TCP/IP协议族）；type参数指定socket的类型： SOCK\_STREAM 或SOCK\_DGRAM，Socket接口还定义了原始Socket（SOCK\_RAW），允许程序使用低层协议；protocol通常赋值"0"。 Socket()调用返回一个整型socket描述符，你可以在后面的调用使用它。   　　 Socket描述符是一个指向内部数据结构的指针，它指向描述符表入口。调用Socket函数时，socket执行体将建立一个Socket，实际上"建立一个Socket"意味着为一个Socket数据结构分配存储空间。Socket执行体为你管理描述符表。   　　两个网络程序之间的一个网络连接包括五种信息：通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。Socket数据结构中包含这五种信息。  **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中的任何一个没有被占用的端口号。  **连接建立**    　　面向连接的客户程序使用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描述符上进行数据传输操作。  **数据传输**    　　 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服务。但在发送或接收数据报时，内核会自动为之加上目地和源地址信息。  **结束传输**    　　当所有的数据操作结束以后，你可以调用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。  **Socket编程实例**    　　 代码实例中的服务器通过socket连接向客户端发送字符串"Hello, you are connected!"。只要在服务器上运行该服务器软件，在客户端运行客户软件，客户端就会收到该字符串。   　　 该服务器软件代码如下：   \#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 /\* 最大同时连接请求数 \*/   main()   \{   　 int sockfd,client\_fd; /\*sock\_fd：监听socket；client\_fd：数据传输socket \*/   　 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.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) \{   　　 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/n", inet\_ntoa(remote\_addr.sin\_addr));   　 　if (!fork()) \{ /\* 子进程代码段 \*/   　　 　 if (send(client\_fd, "Hello, you are connected!/n", 26, 0) == -1)   　　 　 perror("send出错！");   　 　 　close(client\_fd);   　 　 　exit(0);   　 　\}   　　 close(client\_fd);   　　 \}   　 \}   \}   　 　服务器的工作流程是这样的：首先调用socket函数创建一个Socket，然后调用bind函数将其与本机地址以及一个本地端口号绑定，然后调用 listen在相应的socket上监听，当accpet接收到一个连接服务请求时，将生成一个新的socket。服务器显示该客户机的IP地址，并通过 新的socket向客户端发送字符串"Hello，you are connected!"。最后关闭该socket。   　　代码实例中的fork()函数生成一个子进程来处理数据传输部分，fork()语句对于子进程返回的值为0。所以包含fork函数的if语句是子进程代码部分，它与if语句后面的父进程代码部分是并发执行的。  客户端程序代码如下：   \#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 /\*每次最大数据传输量 \*/   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!/n");   exit(1);   \}   　 if((host=gethostbyname(argv\[1\]))==NULL) \{   herror("gethostbyname出错！");   exit(1);   \}   　 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);   　 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",buf);   　 close(sockfd);   \}   　　客户端程序首先通过服务器域名获得服务器的IP地址，然后创建一个socket，调用connect函数与服务器建立连接，连接成功之后接收从服务器发送过来的数据，最后关闭socket。   　　函数gethostbyname()是完成域名转换的。由于IP地址难以记忆和读写，所以为了方便，人们常常用域名来表示主机，这就需要进行域名和IP地址的转换。函数原型为：   　　 struct hostent \*gethostbyname(const char \*name);   　　 函数返回为hosten的结构类型，它的定义如下：   　　 struct hostent \{   　 char \*h\_name; /\* 主机的官方域名 \*/   　　 char \*\*h\_aliases; /\* 一个以NULL结尾的主机别名数组 \*/   　　 int h\_addrtype; /\* 返回的地址类型，在Internet环境下为AF-INET \*/   　　 int h\_length; /\* 地址的字节长度 \*/   　　 char \*\*h\_addr\_list; /\* 一个以0结尾的数组，包含该主机的所有地址\*/   　　 \};   　　 \#define h\_addr h\_addr\_list\[0\] /\*在h-addr-list中的第一个地址\*/   　　 当 gethostname()调用成功时，返回指向struct hosten的指针，当调用失败时返回-1。当调用gethostbyname时，你不能使用perror()函数来输出错误信息，而应该使用herror()函数来输出。  　　无连接的客户/服务器程序的在原理上和连接的客户/服务器是一样的，两者的区别在于无连接的客户/服务器中的客户一般不需要建立连接，而且在发送接收数据时，需要指定远端机的地址。  阻塞和非阻塞   　 　阻塞函数在完成其指定的任务以前不允许程序调用另一个函数。例如，程序执行一个读数据的函数调用时，在此函数完成读操作以前将不会执行下一程序语句。当 服务器运行到accept语句时，而没有客户连接服务请求到来，服务器就会停止在accept语句上等待连接服务请求的到来。这种情况称为阻塞 （blocking）。而非阻塞操作则可以立即完成。比如，如果你希望服务器仅仅注意检查是否有客户在等待连接，有就接受连接，否则就继续做其他事情，则 可以通过将Socket设置为非阻塞方式来实现。非阻塞socket在没有客户在等待时就使accept调用立即返回。   　　 \#include <unistd.h>   　　 \#include <fcntl.h>   　　 ……   sockfd = socket(AF\_INET,SOCK\_STREAM,0);   fcntl(sockfd,F\_SETFL,O\_NONBLOCK)；   ……   　 　通过设置socket为非阻塞方式，可以实现"轮询"若干Socket。当企图从一个没有数据等待处理的非阻塞Socket读入数据时，函数将立即返 回，返回值为-1，并置errno值为EWOULDBLOCK。但是这种"轮询"会使CPU处于忙等待方式，从而降低性能，浪费系统资源。而调用 select()会有效地解决这个问题，它允许你把进程本身挂起来，而同时使系统内核监听所要求的一组文件描述符的任何活动，只要确认在任何被监控的文件 描述符上出现活动，select()调用将返回指示该文件描述符已准备好的信息，从而实现了为进程选出随机的变化，而不必由进程本身对输入进行测试而浪费 CPU开销。Select函数原型为:   int select(int numfds,fd\_set \*readfds,fd\_set \*writefds，   fd\_set \*exceptfds,struct timeval \*timeout);   　 　其中readfds、writefds、exceptfds分别是被select()监视的读、写和异常处理的文件描述符集合。如果你希望确定是否可以 从标准输入和某个socket描述符读取数据，你只需要将标准输入的文件描述符0和相应的sockdtfd加入到readfds集合中；numfds的值 是需要检查的号码最高的文件描述符加1，这个例子中numfds的值应为sockfd+1；当select返回时，readfds将被修改，指示某个文件 描述符已经准备被读取，你可以通过FD\_ISSSET()来测试。为了实现fd\_set中对应的文件描述符的设置、复位和测试，它提供了一组宏：   　　 FD\_ZERO(fd\_set \*set)----清除一个文件描述符集；   　　 FD\_SET(int fd,fd\_set \*set)----将一个文件描述符加入文件描述符集中；   　　 FD\_CLR(int fd,fd\_set \*set)----将一个文件描述符从文件描述符集中清除；   　　 FD\_ISSET(int fd,fd\_set \*set)----试判断是否文件描述符被置位。   　　 Timeout参数是一个指向struct timeval类型的指针，它可以使select()在等待timeout长时间后没有文件描述符准备好即返回。struct timeval数据结构为：   　　 struct timeval \{   　　 int tv\_sec; /\* seconds \*/   　　 int tv\_usec; /\* microseconds \*/   \};  POP3客户端实例   　　下面的代码实例基于POP3的客户协议，与邮件服务器连接并取回指定用户帐号的邮件。与邮件服务器交互的命令存储在字符串数组POPMessage中，程序通过一个do-while循环依次发送这些命令。   \#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 POP3SERVPORT 110   \#define MAXDATASIZE 4096  main(int argc, char \*argv\[\])\{   int sockfd;   struct hostent \*host;   struct sockaddr\_in serv\_addr;   char \*POPMessage\[\]=\{   "USER userid/r/n",   "PASS password/r/n",   "STAT/r/n",   "LIST/r/n",   "RETR 1/r/n",   "DELE 1/r/n",   "QUIT/r/n",   NULL   \};   int iLength;   int iMsg=0;   int iEnd=0;   char buf\[MAXDATASIZE\];  if((host=gethostbyname("your.server"))==NULL) \{   perror("gethostbyname error");   exit(1);   \}   if ((sockfd = socket(AF\_INET, SOCK\_STREAM, 0)) == -1)\{   perror("socket error");   exit(1);   \}   serv\_addr.sin\_family=AF\_INET;   serv\_addr.sin\_port=htons(POP3SERVPORT);   serv\_addr.sin\_addr = \*((struct in\_addr \*)host->h\_addr);   bzero(&(serv\_addr.sin\_zero),8);   if (connect(sockfd, (struct sockaddr \*)&serv\_addr,sizeof(struct sockaddr))==-1)\{   perror("connect error");   exit(1);   \}  do \{   send(sockfd,POPMessage\[iMsg\],strlen(POPMessage\[iMsg\]),0);   printf("have sent: %s",POPMessage\[iMsg\]);  iLength=recv(sockfd,buf+iEnd,sizeof(buf)-iEnd,0);   iEnd+=iLength;   buf\[iEnd\]='/0';   printf("received: %s,%d/n",buf,iMsg);  iMsg++;   \} while (POPMessage\[iMsg\]);  close(sockfd);   \}      #

# [linux socket 编程][linux socket]    #

<table> 
 <tbody> 
  <tr> 
   <td align="center"><span style="">socket</span></td> 
  </tr> 
 </tbody> 
</table>

### 目 录 ###

1.  [socket][]
    
    1.  [socket()][socket 1]
    2.  [bind()][bind]
    3.  [connect()][connect]
    4.  [listen()][listen]
    5.  [accept()][accept]
    6.  [send() 和recv()][send_ _recv]
    7.  [sendto() 和recvfrom()][sendto_ _recvfrom]
    8.  [close() 和shutdown()][close_ _shutdown]
    9.  [getpeername()][getpeername]
    10. [gethostname()][gethostname]

--------------------

**socket**  
[\[目录\]][Link 1]

--------------------

**socket()**

我们使用系统调用socket()来获得文件描述符：  
\#include<sys/types.h>  
\#include<sys/socket.h>  
int socket(int domain,int type,int protocol);  
第一个参数domain设置为“AF\_INET”。  
第二个参数是套接口的类型：SOCK\_STREAM或  
SOCK\_DGRAM。第三个参数设置为0。  
系统调用socket()只返回一个套接口描述符，如果出错，则返回-1。

[\[目录\]][Link 1]

--------------------

**bind()**

一旦你有了一个套接口以后，下一步就是把套接口绑定到本地计算机的某一个端口上。但如果你只想使用connect()则无此必要。  
下面是系统调用bind()的使用方法：  
\#include<sys/types.h>  
\#include<sys/socket.h>  
intbind(int sockfd,struct sockaddr\*my\_addr,int addrlen);  
第一个参数sockfd是由socket()调用返回的套接口文件描述符。  
第二个参数my\_addr是指向数据结构sockaddr的指针。数据结构sockaddr中包括了关于你的地址、端口和IP地址的信息。  
第三个参数addrlen可以设置成sizeof(structsockaddr)。  
下面是一个例子：  
\#include<string.h>  
\#include<sys/types.h>  
\#include<sys/socket.h>  
\#defineMYPORT3490  
main()  
\{  
int sockfd;  
struct sockaddr\_inmy\_addr;  
sockfd=socket(AF\_INET,SOCK\_STREAM,0);/\*do someerror checking!\*/  
my\_addr.sin\_family=AF\_INET;/\*hostbyteorder\*/  
my\_addr.sin\_port=htons(MYPORT);/\*short,network byte order\*/  
my\_addr.sin\_addr.s\_addr=inet\_addr("132.241.5.10");  
bzero(&(my\_addr.sin\_zero),8);/\*zero the rest of the struct\*/  
/\*don't forget your error checking for bind():\*/  
bind(sockfd,(struct sockaddr\*)&my\_addr,sizeof(struct sockaddr));  
...  
如果出错，bind()也返回-1。  
如果你使用connect()系统调用，那么你不必知道你使用的端口号。当你调用connect()时，它检查套接口是否已经绑定，如果没有，它将会分配一个空闲的端口。

[\[目录\]][Link 1]

--------------------

**connect()**

系统调用connect()的用法如下：  
\#include<sys/types.h>  
\#include<sys/socket.h>  
int connect(int sockfd,struct sockaddr\* serv\_addr,int addrlen);  
第一个参数还是套接口文件描述符，它是由系统调用socket()返回的。  
第二个参数是serv\_addr是指向数据结构sockaddr的指针，其中包括目的端口和IP地址。  
第三个参数可以使用sizeof(structsockaddr)而获得。  
下面是一个例子：  
\#include<string.h>  
\#include<sys/types.h>  
\#include<sys/socket.h>  
\#defineDEST\_IP"132.241.5.10"  
\#defineDEST\_PORT23  
main()  
\{  
intsockfd;  
structsockaddr\_indest\_addr;/\*will hold the destination addr\*/  
sockfd=socket(AF\_INET,SOCK\_STREAM,0);/\*do some error checking!\*/  
dest\_addr.sin\_family=AF\_INET;/\*hostbyteorder\*/  
dest\_addr.sin\_port=htons(DEST\_PORT);/\*short,network byte order\*/  
dest\_addr.sin\_addr.s\_addr=inet\_addr(DEST\_IP);  
bzero(&(dest\_addr.sin\_zero),8);/\*zero the rest of the struct\*/  
/\*don'tforgettoerrorchecktheconnect()!\*/  
connect(sockfd,(structsockaddr\*)&dest\_addr,sizeof(struct sockaddr));  
...  
同样，如果出错，connect()将会返回-1。

[\[目录\]][Link 1]

--------------------

**listen()**  
如果你希望不连接到远程的主机，也就是说你希望等待一个进入的连接请求，然后再处理它们。这样，你通过首先调用listen()，然后再调用accept()来实现。  
系统调用listen()的形式如下：  
intl isten(int sockfd,int backlog);  
第一个参数是系统调用socket()返回的套接口文件描述符。  
第二个参数是进入队列中允许的连接的个数。进入的连接请求在使用系统调用accept()应答之前要在进入队列中等待。这个值是队列中最多可以拥有的请求的个数。大多数系统的缺省设置为20。你可以设置为5或者10。当出错时，listen()将会返回-1值。  
当然，在使用系统调用listen()之前，我们需要调用bind()绑定到需要的端口，否则系统内核将会让我们监听一个随机的端口。所以，如果你希望监听一个端口，下面是应该使用的系统调用的顺序：  
socket();  
bind();  
listen();  
/\*accept()goeshere\*/

[\[目录\]][Link 1]

--------------------

**accept()**  
系统调用accept()比较起来有点复杂。在远程的主机可能试图使用connect()连接你使用  
listen()正在监听的端口。但此连接将会在队列中等待，直到使用accept()处理它。调用accept()  
之后，将会返回一个全新的套接口文件描述符来处理这个单个的连接。这样，对于同一个连接  
来说，你就有了两个文件描述符。原先的一个文件描述符正在监听你指定的端口，新的文件描  
述符可以用来调用send()和recv()。  
调用的例子如下：  
\#include<sys/socket.h>  
intaccept(intsockfd,void\*addr,int\*addrlen);  
第一个参数是正在监听端口的套接口文件描述符。第二个参数addr是指向本地的数据结构  
sockaddr\_in的指针。调用connect()中的信息将存储在这里。通过它你可以了解哪个主机在哪个  
端口呼叫你。第三个参数同样可以使用sizeof(structsockaddr\_in)来获得。  
如果出错，accept()也将返回-1。下面是一个简单的例子：  
\#include<string.h>  
\#include<sys/types.h>  
\#include<sys/socket.h>  
\#defineMYPORT3490/\*theportuserswillbeconnectingto\*/  
\#defineBACKLOG10/\*howmanypendingconnectionsqueuewillhold\*/  
main()  
\{   
intsockfd,new\_fd;/\*listenonsock\_fd,newconnectiononnew\_fd\*/  
structsockaddr\_inmy\_addr;/\*myaddressinformation\*/  
structsockaddr\_intheir\_addr;/\*connector'saddressinformation\*/  
intsin\_size;  
sockfd=socket(AF\_INET,SOCK\_STREAM,0);/\*dosomeerrorchecking!\*/  
my\_addr.sin\_family=AF\_INET;/\*hostbyteorder\*/  
my\_addr.sin\_port=htons(MYPORT);/\*short,networkbyteorder\*/  
my\_addr.sin\_addr.s\_addr=INADDR\_ANY;/\*auto-fillwithmyIP\*/  
bzero(&(my\_addr.sin\_zero),8);/\*zerotherestofthestruct\*/  
/\*don'tforgetyourerrorcheckingforthesecalls:\*/  
bind(sockfd,(structsockaddr\*)&my\_addr,sizeof(structsockaddr));  
listen(sockfd,BACKLOG);  
sin\_size=sizeof(structsockaddr\_in);  
new\_fd=accept(sockfd,&their\_addr,&sin\_size);  
...  
下面，我们将可以使用新创建的套接口文件描述符new\_fd来调用send()和recv()。

[\[目录\]][Link 1]

--------------------

**send() 和recv()**  
系统调用send()的用法如下：  
int send(int sockfd,const void\* msg,int len,int flags);  
第一个参数是你希望给发送数据的套接口文件描述符。它可以是你通过socket()系统调用返回的，也可以是通过accept()系统调用得到的。  
第二个参数是指向你希望发送的数据的指针。  
第三个参数是数据的字节长度。第四个参数标志设置为0。  
下面是一个简单的例子：  
char\*msg="Beejwashere!";  
intlen,bytes\_sent;  
..  
len=strlen(msg);  
bytes\_sent=send(sockfd,msg,len,0);  
...  
系统调用send()返回实际发送的字节数，这可能比你实际想要发送的字节数少。如果返回的字节数比要发送的字节数少，你在以后必须发送剩下的数据。当send()出错时，将返回-1。  
系统调用recv()的使用方法和send()类似：  
int recv(int sockfd,void\* buf,int len,unsigned int flags);  
第一个参数是要读取的套接口文件描述符。  
第二个参数是保存读入信息的地址。  
第三个参数是缓冲区的最大长度。第四个参数设置为0。  
系统调用recv()返回实际读取到缓冲区的字节数，如果出错则返回-1。  
这样使用上面的系统调用，你可以通过数据流套接口来发送和接受信息。

[\[目录\]][Link 1]

--------------------

**sendto() 和recvfrom()**  
因为数据报套接口并不连接到远程的主机上，所以在发送数据包之前，我们必须首先给出目的地址，请看：  
int sendto(int sockfd,const void\* msg,int len,unsigned int flags,  
conststruct sockaddr\*to,inttolen);  
除了两个参数以外，其他的参数和系统调用send()时相同。  
参数to是指向包含目的IP地址和端口号的数据结构sockaddr的指针。  
参数tolen可以设置为sizeof(structsockaddr)。  
系统调用sendto()返回实际发送的字节数，如果出错则返回-1。  
系统调用recvfrom()的使用方法也和recv()的十分近似：  
int recvfrom(int sockfd,void\* buf,int len,unsigned int flags  
struct sockaddr\* from,int\* fromlen);  
参数from是指向本地计算机中包含源IP地址和端口号的数据结构sockaddr的指针。  
参数fromlen设置为sizeof(struct sockaddr)。  
系统调用recvfrom()返回接收到的字节数，如果出错则返回-1。

[\[目录\]][Link 1]

--------------------

**close() 和shutdown()**  
你可以使用close()调用关闭连接的套接口文件描述符：  
close(sockfd);  
这样就不能再对此套接口做任何的读写操作了。  
使用系统调用shutdown()，可有更多的控制权。它允许你在某一个方向切断通信，或者切断双方的通信：  
int shutdown(int sockfd,int how);  
第一个参数是你希望切断通信的套接口文件描述符。第二个参数how值如下：  
0—Furtherreceivesaredisallowed  
1—Furthersendsaredisallowed  
2—Furthersendsandreceivesaredisallowed(likeclose())  
shutdown()如果成功则返回0，如果失败则返回-1。

[\[目录\]][Link 1]

--------------------

**getpeername()**  
这个系统的调用十分简单。它将告诉你是谁在连接的另一端：  
\#include<sys/socket.h>  
int getpeername(int sockfd,struct sockaddr\* addr,int\* addrlen);  
第一个参数是连接的数据流套接口文件描述符。  
第二个参数是指向包含另一端的信息的数据结构sockaddr的指针。  
第三个参数可以设置为sizeof(structsockaddr)。  
如果出错，系统调用将返回-1。  
一旦你获得了它们的地址，你可以使用inet\_ntoa()或者gethostbyaddr()来得到更多的信息。

[\[目录\]][Link 1]

--------------------

**gethostname()**

系统调用gethostname()比系统调用getpeername()还简单。它返回程序正在运行的计算机的名字。系统调用gethostbyname()可以使用这个名字来决定你的机器的IP地址。  
下面是一个例子：  
\#include<unistd.h>  
int gethostname(char\*hostname,size\_tsize);  
如果成功，gethostname将返回0。如果失败，它将返回-1。

#     #

[Linux Socket]: http://blog.csdn.net/fengyv/archive/2006/04/12/659980.aspx
[Linux_Socket]: http://blog.csdn.net/aobai219/archive/2007/05/05/1596964.aspx
[HTTP]: http://blog.csdn.net/bjbs_270/archive/2004/11/05/168155.aspx
[Linux_Socket 1]: http://blog.csdn.net/aobai219/article/details/1596964
[linux socket]: http://blog.csdn.net/fengyv/article/details/659980
[socket]: http://blog.csdn.net/fengyv/article/details/659980#I272
[socket 1]: http://blog.csdn.net/fengyv/article/details/659980#I273
[bind]: http://blog.csdn.net/fengyv/article/details/659980#I274
[connect]: http://blog.csdn.net/fengyv/article/details/659980#I275
[listen]: http://blog.csdn.net/fengyv/article/details/659980#I276
[accept]: http://blog.csdn.net/fengyv/article/details/659980#I277
[send_ _recv]: http://blog.csdn.net/fengyv/article/details/659980#I278
[sendto_ _recvfrom]: http://blog.csdn.net/fengyv/article/details/659980#I279
[close_ _shutdown]: http://blog.csdn.net/fengyv/article/details/659980#I280
[getpeername]: http://blog.csdn.net/fengyv/article/details/659980#I281
[gethostname]: http://blog.csdn.net/fengyv/article/details/659980#I282
[Link 1]: http://blog.csdn.net/fengyv/article/details/659980#Content