Linux系统环境下的Socket编程详细解析

天下无乱

版主

Rank: 7 Rank: 7 Rank: 7

1^# 大中小发表于 2007-7-7 00:39 只看该作者

Linux系统环境下的Socket编程详细解析

什么是Socket 6 a" i, Y9 o7 O8 q6 `

Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。 " t, C5 H5 l0 N/ o' z: E
) N& d* q2 Z: b  @
Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解Socket了。网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。常用的Socket类型有两种：流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。 1 f0 f9 W4 @6 v

Socket建立 : O$ \/ {. m7 |7 W4 v) E& ~
9 T) U+ t* X% r2 I! V! m0 d% u! f
为了建立Socket，程序可以调用Socket函数，该函数返回一个类似于文件描述符的句柄。socket函数原型为：
) b: [% j7 O7 d) H2 `7 _1 L
int socket(int domain, int type, int protocol); / J, N% h- v: D

domain指明所使用的协议族，通常为PF_INET，表示互联网协议族（TCP/IP协议族）；type参数指定socket的类型：SOCK_STREAM 或SOCK_DGRAM，Socket接口还定义了原始Socket（SOCK_RAW），允许程序使用低层协议；protocol通常赋值"0"。Socket()调用返回一个整型socket描述符，你可以在后面的调用使用它。
4 S# [1 f. ?. e; b- A, B2 F$ k
Socket描述符是一个指向内部数据结构的指针，它指向描述符表入口。调用Socket函数时，socket执行体将建立一个Socket，实际上"建立一个Socket"意味着为一个Socket数据结构分配存储空间。 % G8 b0 _6 J  c

Socket执行体为你管理描述符表。 0 r( i/ t: M6 F) n

两个网络程序之间的一个网络连接包括五种信息：通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。Socket数据结构中包含这五种信息。

Socket配置
! T9 D" c. f9 F1 b4 s5 E
通过socket调用返回一个socket描述符后，在使用socket进行网络传输以前，必须配置该socket。面向连接的socket客户端通过调用Connect函数在socket数据结构中保存本地和远端信息。无连接socket的客户端和服务端以及面向连接socket的服务端通过调用bind函数来配置本地信息。
Bind函数将socket与本机上的一个端口相关联，随后你就可以在该端口监听服务请求。Bind函数原型为： 5 H+ c- x+ Z8 j- y

int bind(int sockfd,struct sockaddr *my_addr, int addrlen); ( B9 G. |8 H1 |5 x" ~" j& [

Sockfd是调用socket函数返回的socket描述符,my_addr是一个指向包含有本机IP地址及端口号等信息的sockaddr类型的指针；addrlen常被设置为sizeof(struct sockaddr)。 * M* Y/ s# t  Z- R0 {' [
struct sockaddr结构类型是用来保存socket信息的：
struct sockaddr {
unsigned short sa_family; /* 地址族， AF_xxx */ * K6 F1 v& e& z7 Q
char sa_data[14]; /* 14 字节的协议地址 */ ( M- j2 q3 G% p9 L. @/ v3 V3 ]
}; $ ]& J7 B! d2 J* K+ e5 [4 M! Y
sa_family一般为AF_INET，代表Internet（TCP/IP）地址族；sa_data则包含该socket的IP地址和端口号。 ' |% p2 f/ w* o% g0 r
另外还有一种结构类型： , F0 g7 g# I  c2 a! |
struct sockaddr_in {
short int sin_family; /* 地址族 */
unsigned short int sin_port; /* 端口号 */ - z- j( J7 n6 b5 t
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的指针；或者相反。 : b+ ^3 L+ t% z# L) S, ^
使用bind函数时，可以用下面的赋值实现自动获得本机IP地址和随机获取一个没有被占用的端口号： 7 D% @7 Y$ L* @8 O  g% |, d* F
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则不需要转换。
3 m( A: H, r  J2 j  A7 B9 X& H
计算机数据存储有两种字节优先顺序：高位字节优先和低位字节优先。Internet上数据以高位字节优先顺序在网络上传输，所以对于在内部是以低位字节优先方式存储数据的机器，在Internet上传输数据时就需要进行转换，否则就会出现数据不一致。 5 w3 W3 r6 o1 X8 U7 I

下面是几个字节顺序转换函数： 1 e, X4 H9 t* }
·htonl()：把32位值从主机字节序转换成网络字节序
·htons()：把16位值从主机字节序转换成网络字节序 6 B6 c7 [' F1 g1 z, r4 t( \4 F# n8 S
·ntohl()：把32位值从网络字节序转换成主机字节序 ; G9 E0 T8 @7 F1 e
·ntohs()：把16位值从网络字节序转换成主机字节序 5 |6 _  h" S, ]9 E' B3 }

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

连接建立 7 O% w; G3 q2 t8 r/ {0 J

面向连接的客户程序使用Connect函数来配置socket并与远端服务器建立一个TCP连接，其函数原型为： 6 K, b" j6 |. r$ G4 R9 [
int connect(int sockfd, struct sockaddr *serv_addr,int addrlen); - U. A( T+ d( Z8 R! s: H! e) M
Sockfd是socket函数返回的socket描述符；serv_addr是包含远端主机IP地址和端口号的指针；addrlen是远端地质结构的长度。Connect函数在出现错误时返回-1，并且设置errno为相应的错误码。进行客户端程序设计无须调用bind()，因为这种情况下只需知道目的机器的IP地址，而客户通过哪个端口与服务器建立连接并不需要关心，socket执行体为你的程序自动选择一个未被占用的端口，并通知你的程序数据什么时候到打断口。
( k7 t/ r2 L+ w) U2 p, U6 c; h' V) S
Connect函数启动和远端主机的直接连接。只有面向连接的客户程序使用socket时才需要将此socket与远端主机相连。无连接协议从不建立直接连接。面向连接的服务器也从不启动一个连接，它只是被动的在协议端口监听客户的请求。 : F& G4 b  ^* s, y/ D5 l( n) @
8 T  L# @9 ]) o0 z  c9 Z5 c
Listen函数使socket处于被动的监听模式，并为该socket建立一个输入数据队列，将到达的服务请求保存在此队列中，直到程序处理它们。
1 |6 F/ v' z, d* n! {0 Y
int listen(int sockfd， int backlog); , G1 ]# j  X; H8 F
Sockfd是Socket系统调用返回的socket 描述符；backlog指定在请求队列中允许的最大请求数，进入的连接请求将在队列中等待accept()它们（参考下文）。Backlog对队列中等待服务的请求的数目进行了限制，大多数系统缺省值为20。如果一个服务请求到来时，输入队列已满，该socket将拒绝连接请求，客户将收到一个出错信息。 $ w$ J  ]. d" K: Z
当出现错误时listen函数返回-1，并置相应的errno错误码。 1 R% N. V& p- D9 [

accept()函数让服务器接收客户的连接请求。在建立好输入队列后，服务器就调用accept函数，然后睡眠并等待客户的连接请求。
% N* D$ B$ O/ q
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描述符上进行数据传输操作。 ' Z: W: S  k2 i
/ `% ]2 D5 p1 \+ `! i/ S8 e
数据传输 % ~1 c% m& K5 I4 N
Send()和recv()这两个函数用于面向连接的socket上进行数据传输。
Send()函数原型为：
int send(int sockfd, const void *msg, int len, int flags);
Sockfd是你想用来传输数据的socket描述符；msg是一个指向要发送数据的指针；Len是以字节为单位的数据的长度；flags一般情况下置为0（关于该参数的用法可参照man手册）。 9 [, w: X; A7 @" O# |( ^
Send()函数返回实际上发送出的字节数，可能会少于你希望发送的数据。在程序中应该将send()的返回值与欲发送的字节数进行比较。当send()返回值与len不匹配时，应该对这种情况进行处理。
char *msg = "Hello!";
int len, bytes_sent;
…… " R) t( V4 Z! o/ A3 r% d5 ]
len = strlen(msg);
bytes_sent = send(sockfd, msg,len,0);
……
recv()函数原型为： 7 ^  b' b; R) P) e/ p' Q: T, s
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()函数原型为： 8 r5 M: G% z/ h4 Z7 v
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()函数原型为： 3 Q3 v. N" W' _/ V3 U
int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen); % q- c7 O+ I2 T2 X" Q) |* f0 L! B
from是一个struct sockaddr类型的变量，该变量保存源机的IP地址及端口号。fromlen常置为sizeof (struct sockaddr)。当recvfrom()返回时，fromlen包含实际存入from中的数据字节数。Recvfrom()函数返回接收到的字节数或当出现错误时返回-1，并置相应的errno。 9 M* K- J5 m# f7 Z! o; b
如果你对数据报socket调用了connect()函数时，你也可以利用send()和recv()进行数据传输，但该socket仍然是数据报socket，并且利用传输层的UDP服务。但在发送或接收数据报时，内核会自动为之加上目地和源地址信息。
: v; |$ [$ E8 R1 x( t
结束传输 ' s5 W6 x9 [2 F
当所有的数据操作结束以后，你可以调用close()函数来释放该socket，从而停止在该socket上的任何数据操作：
close(sockfd);
你也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输，而一个方向上的数据传输继续进行。如你可以关闭某socket的写操作而允许继续在该socket上接受数据，直至读入所有数据。 1 R: E& f! |- L& p$ Y: M( Y& I. O
int shutdown(int sockfd,int how);
Sockfd是需要关闭的socket的描述符。参数 how允许为shutdown操作选择以下几种方式：   a1 @) g& Q5 \7 v( c: S) j
·0-------不允许继续接收数据
·1-------不允许继续发送数据
·2-------不允许继续发送和接收数据，
·均为允许则调用close () . n8 n$ }; {1 @" e4 w! f
shutdown在操作成功时返回0，在出现错误时返回-1并置相应errno。 0 j# z9 }. s: ^- f; I, Y

面向连接的Socket实例
代码实例中的服务器通过socket连接向客户端发送字符串"Hello, you are connected!"。只要在服务器上运行该服务器软件，在客户端运行客户软件，客户端就会收到该字符串。 $ t; h% Q9 E, O# i  N% a% U
该服务器软件代码如下： 7 a8 a" ^4 A& D; C6 [! ]
& _* X9 K$ V: W5 }6 w, C
. b& W, j1 T) e, `) [4 Z/ v
2 Y: x, N6 }# a
' f; V! n* Y' p. C
/ j6 L( l* m- j& ~3 O8 ~

#include <stdio.h>
#include <stdlib.h> ! h$ d) Z- P2 T5 p6 J8 h! {
#include <errno.h>
#include <string.h> : b' t* n' F6 k
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#define SERVPORT 3333 /*服务器监听端口号 */ $ X; Y$ F' k0 @
#define BACKLOG 10 /* 最大同时连接请求数 */ * Y8 {! B" i5 ]9 m
main()
{ 4 N0 c  R5 h, f+ f  b  T* s
int sockfd,client_fd; /*sock_fd：监听socket；client_fd：数据传输socket */ 0 m8 Y1 `2 e# b+ K. m$ p: h8 H) G, C
　struct sockaddr_in my_addr; /* 本机地址信息 */
　struct sockaddr_in remote_addr; /* 客户端地址信息 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
　　perror("socket创建出错！"); exit(1);
} * O) G* C0 t  h; l1 i2 t
my_addr.sin_family=AF_INET; 2 e" `9 c3 R. B( ?" W, T
　my_addr.sin_port=htons(SERVPORT);
　my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&;amp;(my_addr.sin_zero),8);
　if (bind(sockfd, (struct sockaddr *)&;amp;my_addr, sizeof(struct sockaddr)) \
　　 == -1) {
perror("bind出错！"); 4 C. O& |; I7 C6 ^
exit(1);
} 9 R4 Y+ B1 w0 o1 B  h
　if (listen(sockfd, BACKLOG) == -1) {
perror("listen出错！"); - i6 [/ F8 o( k
exit(1); + y: R& }0 [7 F# H
}
while(1) { ' m, b. o5 n: [9 l( u+ q
　　sin_size = sizeof(struct sockaddr_in); 6 `" c7 r/ W( f5 b' \( c/ C
　　if ((client_fd = accept(sockfd, (struct sockaddr *)&;amp;remote_addr, \   }. Z1 k/ x( o( I
　　&;amp;sin_size)) == -1) { 9 w9 e% C/ g" R+ W! `3 v
perror("accept出错");
continue;
} 2 w+ y/ g- R: ]# E
　　printf("received a connection from %s\n", inet_ntoa(remote_addr.sin_addr));   A; W+ ~) @* y: l4 P
　 if (!fork()) { /* 子进程代码段 */ 4 r/ |0 q4 i7 B5 g( L* u, d! U
　　 if (send(client_fd, "Hello, you are connected!\n", 26, 0) == -1)
　　 perror("send出错！");
close(client_fd); ! K9 Q1 s; _& b, K: M9 _) A6 Y7 N0 V
exit(0);
} ) L/ t) Q! P$ _$ f( w: L
　　close(client_fd);
　　}
　}
}

服务器的工作流程是这样的：首先调用socket函数创建一个Socket，然后调用bind函数将其与本机地址以及一个本地端口号绑定，然后调用listen在相应的socket上监听，当accpet接收到一个连接服务请求时，将生成一个新的socket。服务器显示该客户机的IP地址，并通过新的socket向客户端发送字符串"Hello，you are connected!"。最后关闭该socket。 ; f1 K2 N3 w/ H9 ^7 |& U
) P  C% g" o6 p; O- p
代码实例中的fork()函数生成一个子进程来处理数据传输部分，fork()语句对于子进程返回的值为0。所以包含fork函数的if语句是子进程代码部分，它与if语句后面的父进程代码部分是并发执行的。 3 [7 t* h9 k0 N) M7 b
- g1 ?8 X1 p: f* v/ x- a6 A- h  z& D
客户端程序代码如下： 4 O$ L# i" b4 [) u/ `& Y: y
" f0 M! y: X3 J" `
9 N6 T+ ]! _+ E; N
5 _! K5 |" X7 I# t. Q/ ]

#include <stdio.h>
#include <stdlib.h>
#include <errno.h> $ Y9 p- X) [4 z) m3 I
#include <string.h> & V, z0 q" y( l5 C- \* M8 d8 N3 k
#include <sys/types.h>
#include <netinet/in.h> & e6 J2 V' A# i) [% E' Z" x0 k
#include <sys/socket.h> 7 P! H( d* e9 A
#include <sys/wait.h> # w9 `( g! E* K) P4 }1 v8 F3 T+ ~
#define SERVPORT 3333 /*服务器监听端口号 */ ; a% F9 Y9 y4 e; f- i- U
#define BACKLOG 10 /* 最大同时连接请求数 */
main()
{ 4 R, c  ~! G9 y0 k
int sockfd,client_fd; /*sock_fd：监听socket；client_fd：数据传输socket */ 6 ^9 b5 t3 z# k. C1 O9 m, p
　struct sockaddr_in my_addr; /* 本机地址信息 */ & B  w4 K8 R9 s- t- h9 h
　struct sockaddr_in remote_addr; /* 客户端地址信息 */ 9 Y7 s0 v9 X3 [* t5 j( e
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
　　perror("socket创建出错！"); exit(1);
} % H7 `, K6 p/ S' Q" @; ?. i1 I
my_addr.sin_family=AF_INET; / x/ `2 l5 w5 z% B8 `
　my_addr.sin_port=htons(SERVPORT);
　my_addr.sin_addr.s_addr = INADDR_ANY; & A' r: _& h; f  E5 j
bzero(&;amp;(my_addr.sin_zero),8); ) d! _) w; d. k0 f* i) e
　if (bind(sockfd, (struct sockaddr *)&;amp;my_addr, sizeof(struct sockaddr)) \
　　 == -1) { ! ^! T* B9 c: @4 R/ v6 N# O
perror("bind出错！");
exit(1);
}
　if (listen(sockfd, BACKLOG) == -1) { 5 q* R# P& G9 @, U" c+ Y
perror("listen出错！"); 8 r; I2 w1 z. p- D' K7 S
exit(1);
} * d; S  H- W2 ^; Q" k
while(1) {
　　sin_size = sizeof(struct sockaddr_in);
　　if ((client_fd = accept(sockfd, (struct sockaddr *)&;amp;remote_addr, \ $ a9 d$ v* m4 c  E* [
　　&;amp;sin_size)) == -1) { ) D% ]. o9 |& E1 G; e# C4 T
perror("accept出错");
continue;
}
　　printf("received a connection from %s\n", inet_ntoa(remote_addr.sin_addr));
　 if (!fork()) { /* 子进程代码段 */ 2 J7 k5 ^% H+ e% w. T* i
　　 if (send(client_fd, "Hello, you are connected!\n", 26, 0) == -1)
　　 perror("send出错！");
close(client_fd);
exit(0);
}
　　close(client_fd); + i  r( e& T/ U4 P8 s6 P
　　}
　}
} 9 I3 s$ Z8 J# W& {7 ]$ G: {

#include<stdio.h> 3 T5 }" n- b: A* h4 _/ T, f
#include <stdlib.h> * H' N5 Y  B3 b* n8 W8 H
#include <errno.h> 9 e1 B; f. S" \& c  _/ j8 j
#include <string.h> 8 s* q2 i. t' p/ x% \
#include <netdb.h> ; n& H7 F* l: ?, Y
#include <sys/types.h> ( \: I1 r8 e# f9 h4 n9 ?1 [
#include <netinet/in.h> 4 H. j: G6 e6 F. X/ D  z* G* G
#include <sys/socket.h>
#define SERVPORT 3333 0 I/ {1 A( W$ [( o
#define MAXDATASIZE 100 /*每次最大数据传输量 */
main(int argc, char *argv[]){
　int sockfd, recvbytes; 8 n' q' r4 h  A5 {
　char buf[MAXDATASIZE];
　struct hostent *host;
　struct sockaddr_in serv_addr;   T. I- R4 r7 Q4 ?6 z/ v
　if (argc < 2) {
fprintf(stderr,"Please enter the server's hostname!\n"); * F) V3 O9 K, y
exit(1); 9 J; A5 X: j: E4 Z3 M7 s
}
　if((host=gethostbyname(argv[1]))==NULL) { 0 ?2 A2 G7 ~/ q" c
herror("gethostbyname出错！"); ( a! }( x& o1 S7 l1 h( \
exit(1);
}
　if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){ 6 R; e9 [/ i; \5 o! s
perror("socket创建出错！"); / |) C2 C1 x! a  m) B: w. x
exit(1); + G) s: L* A; X# |  e: }
} 3 u% a. I8 W1 ]% |! @6 `
　serv_addr.sin_family=AF_INET;
　serv_addr.sin_port=htons(SERVPORT);
　serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
　bzero(&;amp;(serv_addr.sin_zero),8); . Y/ |/ C0 O$ N# h2 d+ a& U
　if (connect(sockfd, (struct sockaddr *)&;amp;serv_addr, \
　　 sizeof(struct sockaddr)) == -1) { 8 q5 t: Q$ H0 B7 P: r
perror("connect出错！");
exit(1);
} 7 ~7 Y8 f) F+ C) Y
　if ((recvbytes=recv(sockfd, buf, MAXDATASIZE, 0)) ==-1) {
perror("recv出错！");
exit(1); : U6 C' `3 @2 g- W' S
}
　buf[recvbytes] = '\0';
　printf("Received: %s",buf); / n* C" j# @0 b' d3 \2 \) [/ f
　close(sockfd); - _$ D: x, X6 I6 ]$ M% i
}

客户端程序首先通过服务器域名获得服务器的IP地址，然后创建一个socket，调用connect函数与服务器建立连接，连接成功之后接收从服务器发送过来的数据，最后关闭socket。 . C' [5 S- K! O% Q! z7 Q" T

函数gethostbyname()是完成域名转换的。由于IP地址难以记忆和读写，所以为了方便，人们常常用域名来表示主机，这就需要进行域名和IP地址的转换。函数原型为：
struct hostent *gethostbyname(const char *name);
函数返回为hosten的结构类型，它的定义如下：
struct hostent { & r+ s4 \; {9 M. ]6 `+ x$ v
char *h_name; /* 主机的官方域名 */
char **h_aliases; /* 一个以NULL结尾的主机别名数组 */
int h_addrtype; /* 返回的地址类型，在Internet环境下为AF-INET */
int h_length; /* 地址的字节长度 */
char **h_addr_list; /* 一个以0结尾的数组，包含该主机的所有地址*/ / ~; S; c$ A7 `1 u, s3 s- r6 q
}; ) l, X  b8 w( M' u( b* x
#define h_addr h_addr_list[0] /*在h-addr-list中的第一个地址*/
当 gethostname()调用成功时，返回指向struct hosten的指针，当调用失败时返回-1。当调用gethostbyname时，你不能使用perror()函数来输出错误信息，而应该使用herror()函数来输出。
  o6 Z7 q5 w. M3 p
无连接的客户/服务器程序的在原理上和连接的客户/服务器是一样的，两者的区别在于无连接的客户/服务器中的客户一般不需要建立连接，而且在发送接收数据时，需要指定远端机的地址。   ^: [$ l( ?  B$ {$ {5 T( a

阻塞和非阻塞
阻塞函数在完成其指定的任务以前不允许程序调用另一个函数。例如，程序执行一个读数据的函数调用时，在此函数完成读操作以前将不会执行下一程序语句。当服务器运行到accept语句时，而没有客户连接服务请求到来，服务器就会停止在accept语句上等待连接服务请求的到来。这种情况称为阻塞（blocking）。而非阻塞操作则可以立即完成。比如，如果你希望服务器仅仅注意检查是否有客户在等待连接，有就接受连接，否则就继续做其他事情，则可以通过将Socket设置为非阻塞方式来实现。非阻塞socket在没有客户在等待时就使accept调用立即返回。 2 w. P4 B6 V$ _' r" [# T3 W
#include
#include
…… 4 j7 ^2 q1 v* e7 Q% h# M2 r
sockfd = socket(AF_INET,SOCK_STREAM,0); 2 I5 U3 X5 m; W; x3 s0 j4 n
fcntl(sockfd,F_SETFL,O_NONBLOCK)；
…… 5 M# j. \2 M; Q) I
通过设置socket为非阻塞方式，可以实现"轮询"若干Socket。当企图从一个没有数据等待处理的非阻塞Socket读入数据时，函数将立即返回，返回值为-1，并置errno值为EWOULDBLOCK。但是这种"轮询"会使CPU处于忙等待方式，从而降低性能，浪费系统资源。而调用select()会有效地解决这个问题，它允许你把进程本身挂起来，而同时使系统内核监听所要求的一组文件描述符的任何活动，只要确认在任何被监控的文件描述符上出现活动，select()调用将返回指示该文件描述符已准备好的信息，从而实现了为进程选出随机的变化，而不必由进程本身对输入进行测试而浪费CPU开销。Select函数原型为: % m! o8 K* @1 ?( n! m% M' @4 u
int select(int numfds,fd_set *readfds,fd_set *writefds， / ~- g1 p5 ~# \4 H3 Q* L* o( Q( o9 N' Z
fd_set *exceptfds,struct timeval *timeout); 6 T- S. ~# h' C+ o2 v: I  @/ }
其中readfds、writefds、exceptfds分别是被select()监视的读、写和异常处理的文件描述符集合。如果你希望确定是否可以从标准输入和某个socket描述符读取数据，你只需要将标准输入的文件描述符0和相应的sockdtfd加入到readfds集合中；numfds的值是需要检查的号码最高的文件描述符加1，这个例子中numfds的值应为sockfd 1；当select返回时，readfds将被修改，指示某个文件描述符已经准备被读取，你可以通过FD_ISSSET()来测试。为了实现fd_set中对应的文件描述符的设置、复位和测试，它提供了一组宏： * }" t  u! M2 y! w4 i; r+ v
FD_ZERO(fd_set *set)----清除一个文件描述符集； 1 x0 T- W0 ^7 n# ^1 \; d9 {
FD_SET(int fd,fd_set *set)----将一个文件描述符加入文件描述符集中；
FD_CLR(int fd,fd_set *set)----将一个文件描述符从文件描述符集中清除； ! U; `% c0 j: Z! H( m9 T, W% }4 w6 E. n0 V
FD_ISSET(int fd,fd_set *set)----试判断是否文件描述符被置位。
Timeout参数是一个指向struct timeval类型的指针，它可以使select()在等待timeout长时间后没有文件描述符准备好即返回。struct timeval数据结构为：
struct timeval { ) P- M  q. d* y% i
int tv_sec; /* seconds */
int tv_usec; /* microseconds */
};
( V4 I8 p+ O# ?0 b3 `  g0 z
POP3客户端实例 - g- D& e* E4 L2 T( \8 M$ _

下面的代码实例基于POP3的客户协议，与邮件服务器连接并取回指定用户帐号的邮件。与邮件服务器交互的命令存储在字符串数组POPMessage中，程序通过一个do-while循环依次发送这些命令。
# v( M  i2 {7 X; K3 r2 a

# i+ B  i0 f/ p; o

$ g& T# t. j7 s/ p- {4 r1 N
#include<stdio.h> * d1 T/ j: v; p. r' T$ |* P5 U+ S4 m
#include <stdlib.h> : M! Y/ u; M4 j2 A0 g. b6 N  F
#include <errno.h>
#include <string.h> 7 p. J+ h% w( ~  _7 h6 O: A
#include <netdb.h> 5 N& m+ w# L9 K% G& _/ a
#include <sys/types.h> & g; Z% G) ?+ n
#include <netinet/in.h> $ E4 M9 N( g. r, Q6 L' t
#include <sys/socket.h>
#define POP3SERVPORT 110
#define MAXDATASIZE 4096

main(int argc, char *argv[]){
int sockfd; 9 r; }0 b2 b5 u, Q/ C4 [' |
struct hostent *host;
struct sockaddr_in serv_addr; : x( s  K7 T  [4 J1 L! ?6 ^% W. [
char *POPMessage[]={
"USER userid\r\n",
"PASS password\r\n", ( p7 Q+ X1 O* ~; |
"STAT\r\n", " K1 E! }3 Y4 b! q, s( ~$ e8 y6 U, F
"LIST\r\n",
"RETR 1\r\n", ! E. q: d! ]# o: {& W( ?4 a
"DELE 1\r\n", 1 u1 r% [0 x+ n
"QUIT\r\n",
NULL
}; ; w& H& l0 f, Y' ~% K( E- D
int iLength;
int iMsg=0; 5 M# R; I8 P; V2 Y: b7 X
int iEnd=0;
char buf[MAXDATASIZE];

if((host=gethostbyname("your.server"))==NULL) { : l$ T+ d$ c/ Z1 f, q4 X6 P! W1 q
perror("gethostbyname error"); & u# M8 p' n& \
exit(1); $ g% O+ m; i/ ]& m# y) u7 W
} ) V0 s1 w5 e7 z
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){ ! o2 p9 S6 U& x. b0 W1 z# d
perror("socket error");
exit(1);
}
serv_addr.sin_family=AF_INET; 9 ]" R* U2 L. b: D$ U7 E0 y
serv_addr.sin_port=htons(POP3SERVPORT); ) T. b" C* O" k1 j! n9 d0 a
serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
bzero(&;amp;(serv_addr.sin_zero),8);
if (connect(sockfd, (struct sockaddr *)&;amp;serv_addr,sizeof(struct sockaddr))==-1){ 6 m6 K1 f8 A4 m' }7 s3 V' N
perror("connect error");
exit(1); % Q8 I% R" v3 N( ?9 w
}

do { : S$ L% ~8 `& b. E1 N; {8 O/ Y3 d
send(sockfd,POPMessage[iMsg],strlen(POPMessage[iMsg]),0);
printf("have sent: %s",POPMessage[iMsg]); 0 ]+ t% Z7 N+ e6 I$ F" b
5 w) Z5 b* Z8 |" v) E
iLength=recv(sockfd,buf iEnd,sizeof(buf)-iEnd,0); * s; v  t' [+ H
iEnd =iLength;
buf[iEnd]='\0';
printf("received: %s,%d\n",buf,iMsg); 8 \3 e; l) `) ~  I7 n) H* c

iMsg  ;
} while (POPMessage[iMsg]); 1 p+ K* Y" b9 d/ T
$ L5 o( g- D8 u  `4 p7 ~- S& Y
close(sockfd);
}

点击图标进入精品网摘收藏欢迎大家加入网络收藏夹

TOP

‹‹ 上一主题 | 下一主题 ››