快捷導(dǎo)航

新手socket編程入門詳解指南

更新時間：2019年05月20日 15:40:46 作者：Hosea14

本文，將一步一步引導(dǎo)初學(xué)者來學(xué)習(xí)socket，所有編程思路都結(jié)合在socket API里面，以及提供socket的疑問和基礎(chǔ)知識點，同時在最后給出多個例程，下面可以和小編一起學(xué)習(xí)

開發(fā)環(huán)境

運行平臺：Ubantu 14.04 LTS

疑問引導(dǎo)

問題1：頭文件的疑問：

#include <sys/socket.h>與#include <linux/socket.h>有何區(qū)別？

解答：

1. 使用diff查看：adc分別表示添加、刪除、修改

2. 其實是路徑的不同導(dǎo)致有不同的socke.h文件

3. <sys/socket.h> 是 Internet Protocol family，也就是tcpip協(xié)議的應(yīng)用層接口

4. <linux/socket.h>目前暫時未弄懂，但不是接口函數(shù)，估計是系統(tǒng)函數(shù)。它應(yīng)該是被操作系統(tǒng)使用，猜測該文件在tcpip的傳輸層

問題2：大小端字節(jié)序問題：

1.c語言檢測：利用指針取值和取址的交叉應(yīng)用，為了增強網(wǎng)絡(luò)移植性

2. 而socket提供了字節(jié)序轉(zhuǎn)換函數(shù)：h：host；n：network；l：long32位；s：short16位

3. htonl：將主機的32位主機字節(jié)序（ip地址），轉(zhuǎn)換為網(wǎng)絡(luò)字節(jié)序（一列數(shù)據(jù)）。

問題3：就一個服務(wù)器、一個客戶端來說，有如下的對應(yīng)角色說法：

對象first	對象second
服務(wù)器	客戶端
監(jiān)聽者	廣播者
提供服務(wù)	請求服務(wù)

解析socket編程整體過程：

建立與刪除
服務(wù)器和客戶端通過同一的socket信道通信，而創(chuàng)建一個socket信道，提供socket連接。

int socket(int domain,int type,int protocol);

domain（域）：各個域以AF_XXX命令，意指地址族。決定使用何種的地址類型，確定通信特性：包括地址格式
type：確定套字節(jié)的類型，（還）可以自由增加類型。
常用：SOCK_STREAM （即：TCP）和 SOCK_DGRAM（即：UDP）
protocol：指定socket使用的傳輸協(xié)議編號，一般直接設(shè)置為0即可，以此表示為給定的域和套接字類型選擇默認的傳輸協(xié)議。
返回值：正確返回套接字處理代碼（我稱之為套接字文件描述符），錯誤返回-1。該數(shù)值將存儲使用。

服務(wù)器和客戶端通都可以，關(guān)閉socket通信IO

int shutdown(int s,int how);

s：代表socket_fd，需要關(guān)閉的套接字文件描述符
how：為一種方式
shutdown是使socket信道處于不活動狀態(tài)?？梢宰屧撔诺狸P(guān)閉寫端，而繼續(xù)接收該套接字讀端以此確定數(shù)據(jù)何時結(jié)束，然后再使用close來關(guān)閉這個信道。

連接關(guān)系

創(chuàng)建和銷毀或關(guān)閉IO之后，需要知道如何標識一個目標通信進程。
原因：網(wǎng)絡(luò)有多個計算機，某臺計算機上運行著多個程序（進程）。下面是兩層關(guān)系：
1）目標計算機的網(wǎng)絡(luò)地址
2）目標計算機上的目標進程的所代表的端口號

所以，目前你需要了解到的有下面幾點：

1. 字節(jié)序：直接看上面的問題2即可，簡單的轉(zhuǎn)換關(guān)系。
2. 地址格式：根據(jù)不同的因特網(wǎng)地址，在<netinet/in.h>定義不同的結(jié)構(gòu)體，部分socket函數(shù)參數(shù)調(diào)用。如下
3. 定義地址結(jié)構(gòu)體，根據(jù)實際裝入數(shù)值作為socket API實參
4. 地址進制轉(zhuǎn)換：對地址進行二進制與文本字符串格式之間的轉(zhuǎn)換。inet_ntop或inet_pton

綁定接著，對于服務(wù)端來說，需要綁定（關(guān)聯(lián)）地址和套接字。為給定的sockfd關(guān)聯(lián)一個sockaddr結(jié)構(gòu)數(shù)據(jù)。只有服務(wù)端將套接字綁定在（域）地址上，客戶端才能夠連接（connect）成功。

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

sockfd：套接字文件描述符，是socket返回的值
my_addr：（服務(wù)器）網(wǎng)絡(luò)地址信息
返回值：判斷是否正確綁定地址和套接字

連接在此之前，我們創(chuàng)建了套接字（socket）、建立連接基礎(chǔ)（bind）。那么，就這就是為了在通信之前，將socket信道連接起來。

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

sockfd：套接字文件描述符，是socket返回的值
serv_addr ：網(wǎng)絡(luò)地址信息
返回值：判斷是否正確連接，客戶端程序必須要能夠處理connect返回的錯誤。

到目前，你或許已經(jīng)發(fā)現(xiàn)了，connect函數(shù)的參數(shù)類型與個數(shù)都跟bind是一樣的（他們的值并不一樣，我所說的是形式），結(jié)合一起去理解，會更好。
畢竟，根據(jù)TCPIP協(xié)議，需要連接的信息：IP地址，端口號，就已經(jīng)足夠了。至于其余的MAC地址等等，在socket里面，我們不需要理會。

監(jiān)聽需要注意的是，這種連接，服務(wù)器還需要確定是哪個客戶端請求連接。所以，服務(wù)器首先進入運行請求客戶端（任意一個）連接的狀態(tài)，進入listen（監(jiān)聽）狀態(tài)。使用函數(shù)：

int listen(int s,int backlog);

s：服務(wù)器套接字描述符，是socket返回的值
backlog：指定同時能夠處理的最大連接要求
函數(shù)返回值：是否正確進入監(jiān)聽狀態(tài)

連接這時候，服務(wù)器已經(jīng)進入了listen狀態(tài)，然后緊接著調(diào)用：

int accept(int s,struct sockaddr * addr,int * addrlen);

s：服務(wù)器套接字描述符，是socket返回的值
addr：某一被連接的客戶端的套接字數(shù)據(jù)
addrlen：某一被連接的客戶端的套接字數(shù)據(jù)長度
返回：某一被連接的客戶端的文件描述符

讀取與發(fā)送數(shù)據(jù)

到目前為止，服務(wù)器和客戶端都已經(jīng)做好了雙向通信的基礎(chǔ)準備。
send與recv暫時不提及，讀者自己去查API

int recv(int s,void *buf,int len,unsigned int flags); 
int send(int s,const void * msg,int len,unsigned int falgs);

以下直接與代碼相關(guān)：

//常用包含頭文件 and socket編程的作用
#include <stdio.h> //
#include <stdlib.h> //
#include <errno.h> //errno錯誤信息變量
#include <unistd.h> //
#include <stddef.h> //

#include <sys/socket.h> //提供socket API
#include <sys/un.h> // 
#include <sys/types.h> //socket API參數(shù)的類型定義文件
#include <arpa/inet.h> //地址轉(zhuǎn)換函數(shù)
#include <netinet/in.h> //字節(jié)序函數(shù)（宏）、域地址類型定義

客戶端代碼：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <pthread.h>

#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

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, "192.168.191.6", &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;
}

服務(wù)器代碼：

#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

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 = inet_addr("192.168.191.6");
 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);
 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",
 (char *)inet_ntop(AF_INET,
 &cliaddr.sin_addr, str,
 sizeof(str)),
 (int)ntohs(cliaddr.sin_port));
 for (i = 0; i < n; i++)
 buf[i] = toupper(buf[i]);
 Write(connfd, buf, n);
 }
 Close(connfd);
 }
}

運行結(jié)果：

hhc@my:~/sharefile/socket/tcp$ ./server &
[1] 15371
hhc@my:~/sharefile/socket/tcp$ Accepting connections ...
hhc@my:~/sharefile/socket/tcp$ ./client
this is a test! 
received from 192.168.191.6 at PORT 53685
THIS IS A TEST!

個人封裝的socket接口函數(shù)：

#include "wrap.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;
}

void Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
 if (bind(fd, sa, salen) < 0)
 perr_exit("bind error");
}

void Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
 if (connect(fd, sa, salen) < 0)
 perr_exit("connect error");
}

void Listen(int fd, int backlog)
{
 if (listen(fd, backlog) < 0)
 perr_exit("listen error");
}

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

void Close(int fd)
{
 if (close(fd) == -1)
 perr_exit("close error");
}

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

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 = (ssize_t)1; n < (ssize_t)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;
}

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: