Socket網絡編程

Socket編程
套接字概念
Socket本身有“插座”的意思，在Linux環境下，用於表示進程間網絡通信的特殊文件類型。本質爲內核藉助緩衝區形成的僞文件。
既然是文件，那麼理所當然的，我們可以使用文件描述符引用套接字。與管道類似的，Linux系統將其封裝成文件的目的是爲了
統一接口，使得讀寫套接字和讀寫文件的操作一致。區別是管道主要應用於本地進程間通信，而套接字多應用於網絡進程間數據的傳遞。
套接字的內核實現較爲複雜，不宜在學習初期深入學習。
在TCP/IP協議中，“IP地址+TCP或UDP端口號”唯一標識網絡通訊中的一個進程。“IP地址+端口號”就對應一個socket。欲建立連接的兩個
進程各自有一個socket來標識，那麼這兩個socket組成的socket pair就唯一標識一個連接。因此可以用Socket來描述網絡連接的一對一關係。
套接字通信原理如下圖所示：

套接字通訊原理示意
在網絡通信中，套接字一定是成對出現的。一端的發送緩衝區對應對端的接收緩衝區。我們使用同一個文件描述符索發送緩衝區和接收緩衝區。
TCP/IP協議最早在BSD UNIX上實現，爲TCP/IP協議設計的應用層編程接口稱爲socket API。本章的主要內容是socket API，主要介紹TCP
協議的函數接口，最後介紹UDP協議和UNIX Domain Socket的函數接口。

網絡編程接口
預備知識
網絡字節序
我們已經知道，內存中的多字節數據相對於內存地址有大端和小端之分，磁盤文件中的多字節數據相對於文件中的偏移地址也有大端小
端之分。網絡數據流同樣有大端小端之分，那麼如何定義網絡數據流的地址呢？發送主機通常將發送緩衝區中的數據按內存地址從低到
高的順序發出，接收主機把從網絡上接到的字節依次保存在接收緩衝區中，也是按內存地址從低到高的順序保存，因此，網絡數據流的
地址應這樣規定：先發出的數據是低地址，後發出的數據是高地址。
TCP/IP協議規定，網絡數據流應採用大端字節序，即低地址高字節。例如上一節的UDP段格式，地址0-1是16位的源端口號，如果這個
端口號是1000（0x3e8），則地址0是0x03，地址1是0xe8，也就是先發0x03，再發0xe8，這16位在發送主機的緩衝區中也應該是低地
址存0x03，高地址存0xe8。但是，如果發送主機是小端字節序的，這16位被解釋成0xe803，而不是1000。因此，發送主機把1000填
到發送緩衝區之前需要做字節序的轉換。同樣地，接收主機如果是小端字節序的，接到16位的源端口號也要做字節序的轉換。如果主
機是大端字節序的，發送和接收都不需要做轉換。同理，32位的IP地址也要考慮網絡字節序和主機字節序的問題。
爲使網絡程序具有可移植性，使同樣的C代碼在大端和小端計算機上編譯後都能正常運行，可以調用以下庫函數做網絡字節序和主機字節序的轉換。
#include <arpa/inet.h>

uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
h表示host，n表示network，l表示32位長整數，s表示16位短整數。
如果主機是小端字節序，這些函數將參數做相應的大小端轉換然後返回，如果主機是大端字節序，這些函數不做轉換，將參數原封不動地返回。
IP地址轉換函數
早期：
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int inet_aton(const char *cp, struct in_addr *inp);
in_addr_t inet_addr(const char *cp);
char *inet_ntoa(struct in_addr in);
只能處理IPv4的ip地址
不可重入函數
注意參數是struct in_addr
現在：
#include <arpa/inet.h>
int inet_pton(int af, const char *src, void *dst);
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
支持IPv4和IPv6
可重入函數
其中inet_pton和inet_ntop不僅可以轉換IPv4的in_addr，還可以轉換IPv6的in6_addr。
因此函數接口是void *addrptr。
sockaddr數據結構
strcut sockaddr 很多網絡編程函數誕生早於IPv4協議，那時候都使用的是sockaddr結構體,爲了向前兼容，現在sockaddr退化成了（void *）
的作用，傳遞一個地址給函數，至於這個函數是sockaddr_in還是sockaddr_in6，由地址族確定，然後函數內部再強制類型轉化爲所需的地址類型。


sockaddr數據結構
struct sockaddr {
sa_family_t sa_family; /* address family, AF_xxx */
char sa_data[14];/* 14 bytes of protocol address */
};
使用 sudo grep -r "struct sockaddr_in {"  /usr 命令可查看到struct sockaddr_in結構體的定義。
一般其默認的存儲位置：/usr/include/linux/in.h 文件中。
struct sockaddr_in {
__kernel_sa_family_t sin_family; /* Address family */  地址結構類型
__be16 sin_port;/* Port number */端口號
struct in_addr sin_addr;/* Internet address */ IP地址
/* Pad to size of `struct sockaddr'. */
unsigned char __pad[__SOCK_SIZE__ - sizeof(short int) -
sizeof(unsigned short int) - sizeof(struct in_addr)];
};


struct in_addr { /* Internet address. */
__be32 s_addr;
};


struct sockaddr_in6 {
unsigned short int sin6_family; /* AF_INET6 */
__be16 sin6_port; /* Transport layer port # */
__be32 sin6_flowinfo; /* IPv6 flow information */
struct in6_addr sin6_addr;/* IPv6 address */
__u32 sin6_scope_id; /* scope id (new in RFC2553) */
};


struct in6_addr {
union {
__u8 u6_addr8[16];
__be16 u6_addr16[8];
__be32 u6_addr32[4];
} in6_u;
#define s6_addr in6_u.u6_addr8
#define s6_addr16 in6_u.u6_addr16
#define s6_addr32in6_u.u6_addr32
};


#define UNIX_PATH_MAX 108
struct sockaddr_un {
__kernel_sa_family_t sun_family; /* AF_UNIX */
char sun_path[UNIX_PATH_MAX]; /* pathname */
};


Pv4和IPv6的地址格式定義在netinet/in.h中，IPv4地址用sockaddr_in結構體表示，包括16位端口號和32位IP地址，
IPv6地址用sockaddr_in6結構體表示，包括16位端口號、128位IP地址和一些控制字段。UNIX Domain Socket的地址
格式定義在sys/un.h中，用sock-addr_un結構體表示。各種socket地址結構體的開頭都是相同的，前16位表示整個
結構體的長度（並不是所有UNIX的實現都有長度字段，如Linux就沒有），後16位表示地址類型。IPv4、IPv6和
Unix Domain Socket的地址類型分別定義爲常數AF_INET、AF_INET6、AF_UNIX。這樣，只要取得某種sockaddr結構體的首地址，
不需要知道具體是哪種類型的sockaddr結構體，就可以根據地址類型字段確定結構體中的內容。因此，socket API可以接受各
種類型的sockaddr結構體指針做參數，例如bind、accept、connect等函數，這些函數的參數應該設計成void *類型以便接受
各種類型的指針，但是sock API的實現早於ANSI C標準化，那時還沒有void *類型，因此這些函數的參數都用struct sockaddr *類型表示，
在傳遞參數之前要強制類型轉換一下，例如：
struct sockaddr_in servaddr;
bind(listen_fd, (struct sockaddr *)&servaddr, sizeof(servaddr));/* initialize servaddr */
網絡套接字函數
socket模型創建流程圖


socket API
socket函數
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
domain:
AF_INET 這是大多數用來產生socket的協議，使用TCP或UDP來傳輸，用IPv4的地址
AF_INET6 與上面類似，不過是來用IPv6的地址
AF_UNIX 本地協議，使用在Unix和Linux系統上，一般都是當客戶端和服務器在同一臺及其上的時候使用
type:
SOCK_STREAM 這個協議是按照順序的、可靠的、數據完整的基於字節流的連接。這是一個使用最多的socket類型，這個socket是使用TCP來進行傳輸。
SOCK_DGRAM 這個協議是無連接的、固定長度的傳輸調用。該協議是不可靠的，使用UDP來進行它的連接。
SOCK_SEQPACKET該協議是雙線路的、可靠的連接，發送固定長度的數據包進行傳輸。必須把這個包完整的接受才能進行讀取。
SOCK_RAW socket類型提供單一的網絡訪問，這個socket類型使用ICMP公共協議。（ping、traceroute使用該協議）
SOCK_RDM 這個類型是很少使用的，在大部分的操作系統上沒有實現，它是提供給數據鏈路層使用，不保證數據包的順序
protocol:
傳0 表示使用默認協議。
返回值：
成功：返回指向新創建的socket的文件描述符，失敗：返回-1，設置errno
socket()打開一個網絡通訊端口，如果成功的話，就像open()一樣返回一個文件描述符，應用程序可以像讀寫
文件一樣用read/write在網絡上收發數據，如果socket()調用出錯則返回-1。對於IPv4，domain參數指定爲AF_INET。
對於TCP協議，type參數指定爲SOCK_STREAM，表示面向流的傳輸協議。如果是UDP協議，則type參數指定爲SOCK_DGRAM，
表示面向數據報的傳輸協議。protocol參數的介紹從略，指定爲0即可。
bind函數
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockfd：
socket文件描述符
addr:
構造出IP地址加端口號
addrlen:
sizeof(addr)長度
返回值：
成功返回0，失敗返回-1, 設置errno
服務器程序所監聽的網絡地址和端口號通常是固定不變的，客戶端程序得知服務器程序的地址和端口號後就可以向
服務器發起連接，因此服務器需要調用bind綁定一個固定的網絡地址和端口號。
bind()的作用是將參數sockfd和addr綁定在一起，使sockfd這個用於網絡通訊的文件描述符監聽addr所描述的地址和端口號。
前面講過，struct sockaddr *是一個通用指針類型，addr參數實際上可以接受多種協議的sockaddr結構體，而它們的
長度各不相同，所以需要第三個參數addrlen指定結構體的長度。如：
struct sockaddr_in servaddr;
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(6666);
首先將整個結構體清零，然後設置地址類型爲AF_INET，網絡地址爲INADDR_ANY，這個宏表示本地的任意IP地址，
因爲服務器可能有多個網卡，每個網卡也可能綁定多個IP地址，這樣設置可以在所有的IP地址上監聽，直到與某
個客戶端建立了連接時才確定下來到底用哪個IP地址，端口號爲6666。
listen函數
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int listen(int sockfd, int backlog);
sockfd:
socket文件描述符
backlog:
排隊建立3次握手隊列和剛剛建立3次握手隊列的鏈接數和
查看系統默認backlog
cat /proc/sys/net/ipv4/tcp_max_syn_backlog
典型的服務器程序可以同時服務於多個客戶端，當有客戶端發起連接時，服務器調用的accept()返回並接受這個連接，
如果有大量的客戶端發起連接而服務器來不及處理，尚未accept的客戶端就處於連接等待狀態，listen()聲明sockfd處
於監聽狀態，並且最多允許有backlog個客戶端處於連接待狀態，如果接收到更多的連接請求就忽略。listen()成功返回0，失敗返回-1。
accept函數
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
sockdf:
socket文件描述符
addr:
傳出參數，返回鏈接客戶端地址信息，含IP地址和端口號
addrlen:
傳入傳出參數（值-結果）,傳入sizeof(addr)大小，函數返回時返回真正接收到地址結構體的大小
返回值：
成功返回一個新的socket文件描述符，用於和客戶端通信，失敗返回-1，設置errno
三方握手完成後，服務器調用accept()接受連接，如果服務器調用accept()時還沒有客戶端的連接請求，
就阻塞等待直到有客戶端連接上來。addr是一個傳出參數，accept()返回時傳出客戶端的地址和端口號。
addrlen參數是一個傳入傳出參數（value-result argument），傳入的是調用者提供的緩衝區addr的長度以避免緩衝區溢出問題，
傳出的是客戶端地址結構體的實際長度（有可能沒有佔滿調用者提供的緩衝區）。如果給addr參數傳NULL，表示不關心客戶端的地址。
我們的服務器程序結構是這樣的：
while (1) {
cliaddr_len = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
n = read(connfd, buf, MAXLINE);
......
close(connfd);
}
整個是一個while死循環，每次循環處理一個客戶端連接。由於cliaddr_len是傳入傳出參數，每次調用accept()之前應該重新賦初值。
accept()的參數listenfd是先前的監聽文件描述符，而accept()的返回值是另外一個文件描述符connfd，之後與客戶端之間就通過這
個connfd通訊，最後關閉connfd斷開連接，而不關閉listenfd，再次回到循環開頭listenfd仍然用作accept的參數。
accept()成功返回一個文件描述符，出錯返回-1。
connect函數
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockdf:
socket文件描述符
addr:
傳入參數，指定服務器端地址信息，含IP地址和端口號
addrlen:
傳入參數,傳入sizeof(addr)大小
返回值：
成功返回0，失敗返回-1，設置errno
客戶端需要調用connect()連接服務器，connect和bind的參數形式一致，區別在於bind的參數是自己的地址，
而connect的參數是對方的地址。connect()成功返回0，出錯返回-1。
C/S模型-TCP
下圖是基於TCP協議的客戶端/服務器程序的一般流程：


TCP協議通訊流程
服務器調用socket()、bind()、listen()完成初始化後，調用accept()阻塞等待，處於監聽端口的狀態，客戶端調用socket()初始化後，
調用connect()發出SYN段並阻塞等待服務器應答，服務器應答一個SYN-ACK段，客戶端收到後從connect()返回，同時應答一個ACK段，服務器收到後從accept()返回。
數據傳輸的過程：
建立連接後，TCP協議提供全雙工的通信服務，但是一般的客戶端/服務器程序的流程是由客戶端主動發起請求，服務器被動處理請求，
一問一答的方式。因此，服務器從accept()返回後立刻調用read()，讀socket就像讀管道一樣，如果沒有數據到達就阻塞等待，
這時客戶端調用write()發送請求給服務器，服務器收到後從read()返回，對客戶端的請求進行處理，在此期間客戶端調用read()阻塞等
待服務器的應答，服務器調用write()將處理結果發回給客戶端，再次調用read()阻塞等待下一條請求，客戶端收到後從read()返回，發送下一條請求，如此循環下去。
如果客戶端沒有更多的請求了，就調用close()關閉連接，就像寫端關閉的管道一樣，服務器的read()返回0，這樣服務器就知道客戶
端關閉了連接，也調用close()關閉連接。注意，任何一方調用close()後，連接的兩個傳輸方向都關閉，不能再發送數據了。
如果一方調用shutdown()則連接處於半關閉狀態，仍可接收對方發來的數據。
在學習socket API時要注意應用程序和TCP協議層是如何交互的： 應用程序調用某個socket函數時TCP協議層完成什麼動作，
比如調用connect()會發出SYN段 應用程序如何知道TCP協議層的狀態變化，比如從某個阻塞的socket函數返回就表明TCP協議收到了某些段，
再比如read()返回0就表明收到了FIN段
server
下面通過最簡單的客戶端/服務器程序的實例來學習socket API。
server.c的作用是從客戶端讀字符，然後將每個字符轉換爲大寫並回送給客戶端。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


#define MAXLINE 80
#define SERV_PORT 6666


int main(void)
{
struct sockaddr_in servaddr, cliaddr;
socklen_t cliaddr_len;
int listenfd, connfd;
char buf[MAXLINE];
char str[INET_ADDRSTRLEN];
int i, n;


listenfd = socket(AF_INET, SOCK_STREAM, 0);


bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);


bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
listen(listenfd, 20);


printf("Accepting connections ...\n");
while (1) {
cliaddr_len = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
n = read(connfd, buf, MAXLINE);
printf("received from %s at PORT %d\n",
inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
ntohs(cliaddr.sin_port));
for (i = 0; i < n; i++)
buf[i] = toupper(buf[i]);
write(connfd, buf, n);
close(connfd);
}
return 0;
}
client
client.c的作用是從命令行參數中獲得一個字符串發給服務器，然後接收服務器返回的字符串並打印。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>


#define MAXLINE 80
#define SERV_PORT 6666


int main(int argc, char *argv[])
{
struct sockaddr_in servaddr;
char buf[MAXLINE];
int sockfd, n;
char *str;


if (argc != 2) {
fputs("usage: ./client message\n", stderr);
exit(1);
}
str = argv[1];


sockfd = socket(AF_INET, SOCK_STREAM, 0);


bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
servaddr.sin_port = htons(SERV_PORT);


connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));


write(sockfd, str, strlen(str));


n = read(sockfd, buf, MAXLINE);
printf("Response from server:\n");
write(STDOUT_FILENO, buf, n);
close(sockfd);


return 0;
}
由於客戶端不需要固定的端口號，因此不必調用bind()，客戶端的端口號由內核自動分配。注意，客戶端不是不允許調用bind()，
只是沒有必要調用bind()固定一個端口號，服務器也不是必須調用bind()，但如果服務器不調用bind()，內核會自動給服務器
分配監聽端口，每次啓動服務器時端口號都不一樣，客戶端要連接服務器就會遇到麻煩。
客戶端和服務器啓動後可以使用netstat命令查看鏈接情況：
netstat -apn|grep 6666
出錯處理封裝函數
上面的例子不僅功能簡單，而且簡單到幾乎沒有什麼錯誤處理，我們知道，系統調用不能保證每次都成功，必須進行出錯處理，
這樣一方面可以保證程序邏輯正常，另一方面可以迅速得到故障信息。
爲使錯誤處理的代碼不影響主程序的可讀性，我們把與socket相關的一些系統函數加上錯誤處理代碼包裝成新的函數，做成一個模塊wrap.c：
wrap.c
#include <stdlib.h>
#include <errno.h>
#include <sys/socket.h>
void perr_exit(const char *s)
{
perror(s);
exit(1);
}
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
int n;
again:
if ( (n = accept(fd, sa, salenptr)) < 0) {
if ((errno == ECONNABORTED) || (errno == EINTR))
goto again;
else
perr_exit("accept error");
}
return n;
}
int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = bind(fd, sa, salen)) < 0)
perr_exit("bind error");
return n;
}
int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = connect(fd, sa, salen)) < 0)
perr_exit("connect error");
return n;
}
int Listen(int fd, int backlog)
{
int n;
if ((n = listen(fd, backlog)) < 0)
perr_exit("listen error");
return n;
}
int Socket(int family, int type, int protocol)
{
int n;
if ( (n = socket(family, type, protocol)) < 0)
perr_exit("socket error");
return n;
}
ssize_t Read(int fd, void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = read(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = write(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
int Close(int fd)
{
int n;
if ((n = close(fd)) == -1)
perr_exit("close error");
return n;
}
ssize_t Readn(int fd, void *vptr, size_t n)
{
size_t nleft;
ssize_t nread;
char *ptr;


ptr = vptr;
nleft = n;


while (nleft > 0) {
if ( (nread = read(fd, ptr, nleft)) < 0) {
if (errno == EINTR)
nread = 0;
else
return -1;
} else if (nread == 0)
break;
nleft -= nread;
ptr += nread;
}
return n - nleft;
}


ssize_t Writen(int fd, const void *vptr, size_t n)
{
size_t nleft;
ssize_t nwritten;
const char *ptr;


ptr = vptr;
nleft = n;


while (nleft > 0) {
if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
if (nwritten < 0 && errno == EINTR)
nwritten = 0;
else
return -1;
}
nleft -= nwritten;
ptr += nwritten;
}
return n;
}


static ssize_t my_read(int fd, char *ptr)
{
static int read_cnt;
static char *read_ptr;
static char read_buf[100];


if (read_cnt <= 0) {
again:
if ((read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
if (errno == EINTR)
goto again;
return -1;
} else if (read_cnt == 0)
return 0;
read_ptr = read_buf;
}
read_cnt--;
*ptr = *read_ptr++;
return 1;
}


ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
ssize_t n, rc;
char c, *ptr;
ptr = vptr;


for (n = 1; n < maxlen; n++) {
if ( (rc = my_read(fd, &c)) == 1) {
*ptr++ = c;
if (c == '\n')
break;
} else if (rc == 0) {
*ptr = 0;
return n - 1;
} else
return -1;
}
*ptr = 0;
return n;
}
wrap.h
#ifndef __WRAP_H_
#define __WRAP_H_
void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
#endif
高併發服務器


多進程併發服務器
使用多進程併發服務器時要考慮以下幾點：
1.父進程最大文件描述個數(父進程中需要close關閉accept返回的新文件描述符)
2.系統內創建進程個數(與內存大小相關)
3.進程創建過多是否降低整體服務性能(進程調度)
server
/* server.c */
#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
#include "wrap.h"


#define MAXLINE 80
#define SERV_PORT 800


void do_sigchild(int num)
{
while (waitpid(0, NULL, WNOHANG) > 0)
;
}
int main(void)
{
struct sockaddr_in servaddr, cliaddr;
socklen_t cliaddr_len;
int listenfd, connfd;
char buf[MAXLINE];
char str[INET_ADDRSTRLEN];
int i, n;
pid_t pid;


struct sigaction newact;
newact.sa_handler = do_sigchild;
sigemptyset(&newact.sa_mask);
newact.sa_flags = 0;
sigaction(SIGCHLD, &newact, NULL);


listenfd = Socket(AF_INET, SOCK_STREAM, 0);


bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);


Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));


Listen(listenfd, 20);


printf("Accepting connections ...\n");
while (1) {
cliaddr_len = sizeof(cliaddr);
connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);


pid = fork();
if (pid == 0) {
Close(listenfd);
while (1) {
n = Read(connfd, buf, MAXLINE);
if (n == 0) {
printf("the other side has been closed.\n");
break;
}
printf("received from %s at PORT %d\n",
inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
ntohs(cliaddr.sin_port));
for (i = 0; i < n; i++)
buf[i] = toupper(buf[i]);
Write(connfd, buf, n);
}
Close(connfd);
return 0;
} else if (pid > 0) {
Close(connfd);
} else
perr_exit("fork");
}
Close(listenfd);
return 0;
}
client
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include "wrap.h"


#define MAXLINE 80
#define SERV_PORT 6666


int main(int argc, char *argv[])
{
struct sockaddr_in servaddr;
char buf[MAXLINE];
int sockfd, n;


sockfd = Socket(AF_INET, SOCK_STREAM, 0);


bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
servaddr.sin_port = htons(SERV_PORT);


Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));


while (fgets(buf, MAXLINE, stdin) != NULL) {
Write(sockfd, buf, strlen(buf));
n = Read(sockfd, buf, MAXLINE);
if (n == 0) {
printf("the other side has been closed.\n");
break;
} else
Write(STDOUT_FILENO, buf, n);
}
Close(sockfd);
return 0;
}


多線程併發服務器
在使用線程模型開發服務器時需考慮以下問題：
1.調整進程內最大文件描述符上限
2.線程如有共享數據，考慮線程同步
3.服務於客戶端線程退出時，退出處理。（退出值，分離態）
4.系統負載，隨着鏈接客戶端增加，導致其它線程不能及時得到CPU
server
/* server.c */
#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>


#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 6666


struct s_info {
struct sockaddr_in cliaddr;
int connfd;
};
void *do_work(void *arg)
{
int n,i;
struct s_info *ts = (struct s_info*)arg;
char buf[MAXLINE];
char str[INET_ADDRSTRLEN];
/* 可以在創建線程前設置線程創建屬性,設爲分離態,哪種效率高內？ */
pthread_detach(pthread_self());
while (1) {
n = Read(ts->connfd, buf, MAXLINE);
if (n == 0) {
printf("the other side has been closed.\n");
break;
}
printf("received from %s at PORT %d\n",
inet_ntop(AF_INET, &(*ts).cliaddr.sin_addr, str, sizeof(str)),
ntohs((*ts).cliaddr.sin_port));
for (i = 0; i < n; i++)
buf[i] = toupper(buf[i]);
Write(ts->connfd, buf, n);
}
Close(ts->connfd);
}


int main(void)
{
struct sockaddr_in servaddr, cliaddr;
socklen_t cliaddr_len;
int listenfd, connfd;
int i = 0;
pthread_t tid;
struct s_info ts[256];


listenfd = Socket(AF_INET, SOCK_STREAM, 0);


bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);


Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
Listen(listenfd, 20);


printf("Accepting connections ...\n");
while (1) {
cliaddr_len = sizeof(cliaddr);
connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
ts[i].cliaddr = cliaddr;
ts[i].connfd = connfd;
/* 達到線程最大數時，pthread_create出錯處理, 增加服務器穩定性 */
pthread_create(&tid, NULL, do_work, (void*)&ts[i]);
i++;
}
return 0;
}
client
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 6666
int main(int argc, char *argv[])
{
struct sockaddr_in servaddr;
char buf[MAXLINE];
int sockfd, n;


sockfd = Socket(AF_INET, SOCK_STREAM, 0);


bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
servaddr.sin_port = htons(SERV_PORT);


Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));


while (fgets(buf, MAXLINE, stdin) != NULL) {
Write(sockfd, buf, strlen(buf));
n = Read(sockfd, buf, MAXLINE);
if (n == 0)
printf("the other side has been closed.\n");
else
Write(STDOUT_FILENO, buf, n);
}
Close(sockfd);
return 0;
}