TCP/IP網絡編程之網絡編程和套接字

時間 2019-11-20

原文原文鏈接

網絡編程和套接字編程

網絡編程又稱爲套接字編程，就是編寫一段程序，使得兩臺連網的計算機彼此之間能夠交換數據。那麼，這兩臺計算機用什麼傳輸數據呢？首先，須要物理鏈接，將一臺臺獨立的計算機經過物理線路鏈接在一塊兒，造成一個網絡，使得數據能夠經過物理介質進行傳輸，這一點咱們不用過多去關注。咱們只須要考慮，如何編寫數據傳輸的程序。編寫數據傳輸的數據，其實說難也難說簡單也簡單，說它簡單，是由於操做系統爲咱們提供了「套接字」（socket）的部件，咱們能夠經過套接字完成數據在網絡中的傳輸，實現兩臺計算機互相交換數據，即使咱們並不懂socket的原理，這是它的簡單之處。可是說它難，是如何使用socket編寫高性能的數據傳輸程序，這是它的難點數組

那麼，爲何要用「套接字」這個詞呢？「套接字」包含鏈接的含義，就像咱們把插頭插到插座上就能得到電力供給，一樣，爲了與遠程計算機進行數據傳輸，就須要鏈接到因特網，而編程中的「套接字」就是用來鏈接網絡的工具　　bash

既然是傳輸數據，那麼就有發送方和接收方，對於套接字來講，發送和接收是有區別的，咱們先來討論用於接收的套接字的建立過程服務器

1.調用socket函數網絡

#include <sys/socket.h>
int socket(int domain, int type, int protocol);

建立套接字，成功時返回文件描述符，失敗時返回-1dom

2.調用bind函數socket

#include <sys/socket.h>
int bind(int sockfd, struct sockaddr *myaddr, socklen_t addrlen);

調用bind函數給套接字分配IP地址和端口，成功時返回0，失敗時返回-1tcp

3.調用listen函數函數

#include <sys/socket.h>
int listen(int sockfd, int backlog);

將套接字轉化爲可接收鏈接的狀態，成功時返回0，失敗時返回-1工具

4.調用accept函數

#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

等待數據傳輸，成功時返回文件描述符，失敗時返回-1

網絡編程中接收鏈接請求的套接字建立過程以下：

調用socket函數建立套接字
調用bind函數分配IP地址和端口號
調用listen函數轉爲可接收請求狀態
調用accept函數受理鏈接請求

編寫服務端/客戶端套接字

服務器端（server）是可以受理鏈接請求的程序，下面構建服務端程序以驗證以前提到的函數調用過程，該服務端程序收到鏈接請求後向請求者返回「Hello world!」答覆

hello_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

void error_handling(char *message);

int main(int argc, char *argv[])
{
    int serv_sock;
    int clnt_sock;

    struct sockaddr_in serv_addr;
    struct sockaddr_in clnt_addr;
    socklen_t clnt_addr_size;

    char message[] = "Hello world!";

    if (argc != 2)
    {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    serv_sock = socket(AF_INET, SOCK_STREAM, 0); //<1>
    if (serv_sock == -1)
        error_handling("sock() error");

    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(atoi(argv[1]));

    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) //<2>
        error_handling("bind() error");

    if (listen(serv_sock, 5) == -1) //<3>
        error_handling("listen() error");

    clnt_addr_size = sizeof(clnt_addr);
    clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size); //<4>
    if (clnt_sock == -1)
        error_handling("accept() error");

    write(clnt_sock, message, sizeof(message)); //<5>
    close(clnt_sock);
    close(serv_sock);

    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

<1>：調用socket函數建立套接字
<2>：調用bind函數分配IP地址和端口號
<3>：調用listen函數將套接字轉爲可接收鏈接狀態
<4>：調用accept函數受理鏈接請求，若是在沒有鏈接請求的狀況下調用該函數，則不會返回，直到有鏈接請求爲止
<5>：write函數用於傳輸數據，若程序通過<4>處執行到本行，則說明已有鏈接請求

編譯並運行hello_server.c，建立等待鏈接請求的服務器端

# gcc hello_server.c -o hello_server
# ls
hello_server  hello_server.c
# ./hello_server 8500

服務器端建立的套接字又稱爲服務器端套接字或監聽套接字，接下來介紹的套接字是用於請求鏈接服務器端的客戶端套接字

#include <sys/socket.h>
int connect(int sock_fd, struct sockaddr *serv_addr, socklen_t addrlen);

connect爲客戶端用於請求鏈接的函數，成功時返回0，失敗時返回-1

客戶端只有「調用socket函數建立套接字」和「調用connect函數向服務器端發送鏈接請求」這兩個步驟。所以，比服務器端簡單

hello_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

void error_handling(char *message);

int main(int argc, char *argv[])
{
    int sock;
    struct sockaddr_in serv_addr;
    char message[30];
    int str_len;

    if (argc != 3)
    {
        printf("Usage: %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    sock = socket(AF_INET, SOCK_STREAM, 0); //<1>
    if (sock == -1)
        error_handling("sock() error");

    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_addr.sin_port = htons(atoi(argv[2]));

    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) //<2>
        error_handling("connect() error!");

    str_len = read(sock, message, sizeof(message) - 1);
    if (str_len == -1)
        error_handling("read() error!");

    printf("Message from server: %s\n", message);
    close(sock);

    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

<1>：建立套接字，但此時套接字並不立刻分爲服務器端和客戶端，若是下面的代碼調用的是bind、listen函數，則是服務器端套接字。若是是connect函數，則是客戶端套接字
<2>：調用connect函數向服務器端發送鏈接請求

編譯並運行hello_client.c

# gcc hello_client.c -o hello_client
# ls
hello_client  hello_client.c  hello_server  hello_server.c
# ./hello_client 127.0.0.1 8500
Message from server: Hello world!

基於Linux的文件操做

對於Linux而言，socket操做與文件操做沒有區別。在Linux世界裏，socket也被認爲是文件的一種，所以在網絡數據傳輸過程當中天然可使用文件I/O的相關函數，若是想使用Linux提供的文件I/O函數，首先應該理解好文件描述符的概念

表1-1 分配給標準輸入輸出及標準錯誤的文件描述符
文件描述符	對象
0	標準輸入：Standard Input
1	標準輸出：Standard Output
2	標準錯誤：Standard Error

文件和套接字通常通過建立過程纔會被分配文件描述符，表1-1中的3種輸入輸出對象即便未通過特殊的建立過程，程序開始運行後也會被自動分配文件描述符，後面還會講解其使用方法和含義

打開文件

首先介紹打開文件以讀寫數據的函數。調用此函數時需傳遞兩個參數：第一個參數是打開的目標文件名及路徑信息，第二個參數是文件打開模式（文件特性信息）

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *path, int flag);//成功時返回文件描述符，失敗時返回-1

path：文件名的字符串地址
flag：文件打開模式

表1-2 文件打開模式
打開模式	含義
O_CREAT	必要時建立文件
O_TRUNC	刪除所有現有數據
O_APPEND	維持現有數據，並將新數據追加到其後
O_RDONLY	只讀打開
O_WRONLY	只寫打開
O_RDWR	讀寫打開

若是flag須要傳遞多個參數，則經過位或運算（OR）符組合並傳遞

關閉文件

文件有打開，天然也有關閉。文件是系統中的一種資源，若是咱們只打開文件，卻不關閉，其餘程序就不能使用此資源。且文件打開後，可能有一些操做被緩衝在內存中，若不正常關閉，緩衝在內存中的數據就不能真正寫入到文件中，可能形成數據丟失，下面介紹關閉文件時調用的函數

#include <unistd.h>
int close(int fd);//成功時返回文件描述符，失敗時返回-1

fd：須要關閉的文件或套接字的文件描述符

若調用此函數的同時傳遞文件描述符參數，則關閉相應文件。另外須要注意的是，此函數不只能夠關閉文件，還能夠關閉套接字。這再次證實Linux操做系統不區分文件與套接字的特色

將數據寫入文件

接下來介紹的write函數用於向文件輸出數據。固然，Linux中不區分文件與套接字，所以，經過套接字向其餘計算機傳輸數據時也會調用到該函數

include <unistd.h>
ssize_t write(int fd, const void *buf, size_t nbytes);//成功時返回寫入的字節數，失敗時返回-1

fd：顯示數據傳輸對象的文件描述符
buf：保存要傳輸數據的緩衝地址值
nbytes：要傳輸數據的字節數

此函數定義中，size_t是經過typedef聲明的unsigned int類型。對ssize_t來講，size_t前面多加一個s表明signed，即ssize_t是經過typedef聲明的signed int類型

咱們來看下面一段程序， low_open.c將完成建立新文件並保存數據

low_open.c

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void error_handling(char *message);
int main(void)
{
    int fd;
    char buf[] = "Let's go!\n";
    fd = open("data.txt", O_CREAT | O_WRONLY | O_TRUNC); //<1>
    if (fd == -1)
        error_handling("open() error");
    printf("file descriptor:%d\n", fd);
    if (write(fd, buf, sizeof(buf)) == -1) //<2>
        error_handling("write() error!");
    close(fd);
    return 0;
}
void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

<1>：文件打開模式爲O_CREAT、O_WRONLY和O_TRUNC的組合，所以將建立空文件，並只能寫。若存在data.txt文件，則清空文件的所有數據
<2>：向對應於fd中保存的文件描述符的文件傳輸buf中保存的數據

編譯並運行low_open.c

# gcc low_open.c -o low_open
# ls
low_open  low_open.c
# ./low_open 
file descriptor:3
# ls
data.txt  low_open  low_open.c
# cat data.txt 
Let's go!

讀取文件中的數據

與以前的write函數相對應，read函數是用來接收數據的

include <unistd.h>
ssize_t read(int fd, void *buf, size_t nbytes);//成功時返回接收的字節數（但遇到文件結尾則返回0），失敗時返回-1

fd：顯示數據接收對象的文件描述符
buf：要保存接收數據的緩衝地址值
nbytes：要接收數據的最大字節數

下面，咱們經過low_read.c來讀取data.txt中保存的數據

low_read.c

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#define BUF_SIZE 100
void error_handling(char *message);
int main(void)
{
    int fd;
    char buf[BUF_SIZE];
    fd = open("data.txt", O_RDONLY); //<1>
    if (fd == -1)
        error_handling("open()error");
    printf("file descriptor:%d\n", fd);
    if (read(fd, buf, sizeof(buf)) == -1) //<2>
        error_handling("read()error");
    printf("file data:%s", buf);
    close(fd);
    return 0;
}
void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

<1>：打開文件data.txt
<2>：調用read函數向第10行中聲明的數組buf保存讀入的數據

編譯並運行low_read.c

# gcc low_read.c -o low_read
[root@bogon tcp_ip]# ls
data.txt  low_open  low_open.c  low_read  low_read.c
[root@bogon tcp_ip]# ./low_read 
file descriptor:3
file data:Let's go!

文件描述符與套接字

下面將同時建立文件和套接字，並用整數形態比較返回的文件描述符值

fd_seri.c

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>
int main(void)
{
    int fd1, fd2, fd3;
    fd1 = socket(PF_INET, SOCK_STREAM, 0);
    fd2 = open("test.dat", O_CREAT | O_WRONLY | O_TRUNC);
    fd3 = socket(PF_INET, SOCK_DGRAM, 0);
    printf("file descriptor 1:%d\n", fd1);
    printf("file descriptor 2:%d\n", fd2);
    printf("file descriptor 3:%d\n", fd3);
    close(fd1);
    close(fd2);
    close(fd3);
    return 0;
}

第8~10行：建立1個文件和2個套接字
第11~13行：輸出以前建立的文件描述符的整數值

編譯並運行fd_seri.c

# gcc fd_seri.c -o fd_seri
# ./fd_seri 
file descriptor 1:3
file descriptor 2:4
file descriptor 3:5

從輸出的文件描述符整數值能夠看出，描述符從3開始由小到大的順序編號，由於0、一、2是分配給標準I/O的描述符

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。