TCP_IP网络编程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

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

int main(){
    int sockfd;
    int clnt_sock;

    struct sockaddr_in serv_addr;
    struct sockaddr_in clnt_addr;
	// 创建套接字
    sockfd = socket(PF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) exit(0);
    // 端口复用，防止address in use
    int one = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    // bind地址
    memset(&serv_addr, 0, sizeof(sockaddr_in)); 
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(8888);  
    if (bind(sockfd, ( struct sockaddr*)&serv_addr, sizeof(serv_addr))< 0) exit(0);
    // 开始监听客户端连入
    if (listen(sockfd, 1) < 0) exit(0);
	// 可以与客户端通信
    socklen_t clnt_addr_size;
    clnt_addr_size = sizeof(clnt_addr); 
    // 不能使用(socklen_t*)clnt_addr_size使用(socklen_t*)&clnt_addr_size
    clnt_sock = accept(sockfd, (struct sockaddr*)&clnt_addr, &clnt_addr_size); 
    if (clnt_sock < 0) exit(0);
    // 发送数据
    char message[] = "Hello!"; 
    write(clnt_sock, message, sizeof(message));

    close(clnt_sock);
    close(sockfd);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

int main(int argc, char* argv[]){
    int sock;
    struct sockaddr_in serv_addr;
    char message[30];
    int str_len;
	// 创建套接字
    sock = socket(PF_INET, SOCK_STREAM, 0);
    // connect连接
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8888);
    serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    connect(sock, ( sockaddr*)&serv_addr, sizeof(serv_addr));
	// 读取server数据
    str_len = read(sock, message, sizeof(message) - 1);

    printf("Message : %s\n", message);
    close(sock);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

/* Structure describing an Internet socket address.  */
struct sockaddr_in
  {
    __SOCKADDR_COMMON (sin_);
    in_port_t sin_port;			/* Port number.  uint16_t  16bits*/
    struct in_addr sin_addr;		/* Internet address.  uint32_t*/

    /* Pad to size of `struct sockaddr'.  8 = 16-2-2-4， 用于强制转换成sockaddr*/ 
    unsigned char sin_zero[sizeof (struct sockaddr) - // 16byte
			   __SOCKADDR_COMMON_SIZE -  // 2byte
			   sizeof (in_port_t) -  // 2
			   sizeof (struct in_addr)]; // 4
  };

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

in_addr_t inet_addr(const char *string);   // 点/数字符串形式的IP地址转换成整数型的IP地址
//成功时返回 32 位大端序整数型值，失败时返回 INADDR_NONE，以便存入是sockaddr_in中
int inet_aton(const char *string, struct in_addr *addr);  // more use
/*
成功时返回 1 ，失败时返回 0
string: 含有需要转换的IP地址信息的字符串地址值
addr: 保存转换结果的 in_addr 结构体变量的地址值
*/
char *inet_ntoa(struct in_addr adr);  // 网络字节序整数型IP地址转换成字符串形式
//成功时返回保存转换结果的字符串地址值，失败时返回 NULL 空指针

1
2
3
4
5
6
7
8
9

str_len = write(sock, message, strlen(message));
recv_len = 0;
while (recv_len < str_len)
{
    recv_cnt = read(sock, &message[recv_len], BUF_SIZE - 1);
    if (recv_cnt == -1)
        error_handling("read() error");
    recv_len += recv_cnt;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <sys/socket.h>
ssize_t sendto(int sock, void *buff, size_t nbytes, int flags,
               struct sockaddr *to, socklen_t addrlen);
/*
成功时返回发送的字节数，失败时返回 -1
sock: 用于传输数据的 UDP 套接字
buff: 保存待传输数据的缓冲地址值
nbytes: 待传输的数据长度，以字节为单位
flags: 可选项参数，若没有则传递 0
to: 存有目标地址的 sockaddr 结构体变量的地址值
addrlen: 传递给参数 to 的地址值结构体变量长度
调用 sendto 函数时自动给client分配IP和端口号
*/
ssize_t recvfrom(int sock, void *buff, size_t nbytes, int flags,
                 struct sockaddr *from, socklen_t *addrlen);
/*
成功时返回接收的字节数，失败时返回 -1
sock: 用于传输数据的 UDP 套接字
buff: 保存待传输数据的缓冲地址值
nbytes: 待传输的数据长度，以字节为单位
flags: 可选项参数，若没有则传递 0
from: 存有**发送端**地址信息的 sockaddr 结构体变量的地址值
addrlen: 保存参数 from 的结构体变量长度的变量地址值。
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <sys/socket.h>
int shutdown(int sock, int howto);
/*
成功时返回 0 ，失败时返回 -1
sock: 需要断开套接字文件描述符
howto: 传递断开方式信息
	SHUT_RD : 断开输入流 0
    SHUT_WR : 断开输出流 1
    SHUT_RDWR : 同时断开 I/O 流 2
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <netdb.h>
struct hostent *gethostbyname(const char *hostname);
/*
成功时返回 hostent 结构体地址，失败时返回 NULL 指针
*/

struct hostent
{
    char *h_name;       /* Official name of host.  官方域名*/
    char **h_aliases;   /* Alias list.  域名别称*/
    int h_addrtype;     /* Host address type.  IP地址*/
    int h_length;       /* Length of address.  IP地址长度*/
    char **h_addr_list; /* List of addresses from name server. 域名对应IP地址 */
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netdb.h>
void error_handling(char *message);

int main(int argc, char *argv[])
{
    int i;
    struct hostent *host;
    if (argc != 2)
    {
        printf("Usage : %s <addr>\n", argv[0]);
        exit(1);
    }
    // 把参数传递给函数，返回结构体
    host = gethostbyname(argv[1]);
    // IP to host
    // struct sockaddr_in addr;
    // memset(&addr, 0, sizeof(addr));
    // addr.sin_addr.s_addr = inet_addr(argv[1]);
    // host = gethostbyaddr((char *)&addr.sin_addr, 4, AF_INET);
    if (!host)
        printf("gethost... error");
    // 输出官方域名
    printf("Official name: %s \n", host->h_name);
    // Aliases 貌似是解析的 cname 域名？
    for (i = 0; host->h_aliases[i]; i++)
        printf("Aliases %d: %s \n", i + 1, host->h_aliases[i]);
    //看看是不是ipv4
    printf("Address type: %s \n",
           (host->h_addrtype == AF_INET) ? "AF_INET" : "AF_INET6");
    // 输出ip地址信息
    for (i = 0; host->h_addr_list[i]; i++)
        // 对in_addr*指针取值用*
        printf("IP addr %d: %s \n", i + 1,
               inet_ntoa(*(struct in_addr *)host->h_addr_list[i]));
    return 0;
}

1
2
3
4
5
6
7
8

#include <netdb.h>
struct hostent *gethostbyaddr(const char *addr, socklen_t len, int family);
/*
成功时返回 hostent 结构体变量地址值，失败时返回 NULL 指针
addr: 含有IP地址信息的 in_addr 结构体指针。为了同时传递 IPV4 地址之外的全部信息，该变量的类型声明为 char 指针
len: 向第一个参数传递的地址信息的字节数，IPV4时为 4 ，IPV6 时为16.
family: 传递地址族信息，ipv4 是 AF_INET ，IPV6是 AF_INET6
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include <sys/socket.h>
// 读取套接字可选项
int getsockopt(int sock, int level, int optname, void *optval, socklen_t *optlen);
/*
成功时返回 0 ，失败时返回 -1
sock: 用于查看选项套接字文件描述符
level: 要查看的可选项协议层
optname: 要查看的可选项名
optval: 保存查看结果的缓冲地址值
optlen: 向第四个参数传递的缓冲大小。调用函数后，该变量中保存通过第四个参数返回的可选项信息的字节数。
*/
#include <sys/socket.h>
// 更改可选项
int setsockopt(int sock, int level, int optname, const void *optval, socklen_t optlen);
/*
成功时返回 0 ，失败时返回 -1
sock: 用于更改选项套接字文件描述符
level: 要更改的可选项协议层
optname: 要更改的可选项名
optval: 保存更改结果的缓冲地址值
optlen: 向第四个参数传递的缓冲大小。调用函数后，该变量中保存通过第四个参数返回的可选项信息的字节数。
*/

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

int main(int argc, char *argv[])
{
    int tcp_sock, udp_sock;
    int sock_type;
    socklen_t optlen;
    int state;

    optlen = sizeof(sock_type);
    tcp_sock = socket(PF_INET, SOCK_STREAM, 0);
    udp_sock = socket(PF_INET, SOCK_DGRAM, 0);
    printf("SOCK_STREAM: %d\n", SOCK_STREAM);
    printf("SOCK_DGRAM: %d\n", SOCK_DGRAM);

    state = getsockopt(tcp_sock, SOL_SOCKET, SO_TYPE, (void *)&sock_type, &optlen);
    printf("Socket type one: %d \n", sock_type);

    state = getsockopt(udp_sock, SOL_SOCKET, SO_TYPE, (void *)&sock_type, &optlen);
    printf("Socket type two: %d \n", sock_type);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

/* Set socket FD's option OPTNAME at protocol level LEVEL
   to *OPTVAL (which is OPTLEN bytes long).
   Returns 0 on success, -1 for errors.  */
extern int setsockopt (int __fd, int __level, int __optname,
		       const void *__optval, socklen_t __optlen) __THROW;

/* Put the current value for socket FD's option OPTNAME at protocol level LEVEL
   into OPTVAL (which is *OPTLEN bytes long), and set *OPTLEN to the value's
   actual length.  Returns 0 on success, -1 for errors.  */
extern int getsockopt (int __fd, int __level, int __optname,
		       void *__restrict __optval,
		       socklen_t *__restrict __optlen) __THROW;

1
2
3

socklen_t optlen = sizeof(option);
int option = 1;
setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, (void *)&option, optlen);

1
2
3
4

#include <netinet/tcp.h>
#include <netinet/in.h>
int opt_val = 1; 
setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (void *)&opt_val, sizeof(opt_val));

1
2

opt_len = sizeof(opt_val); 
getsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (void *)&opt_val, &opt_len);

1
2

#include <unistd.h>
pid_t fork(void);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <stdio.h>
#include <unistd.h>
int gval = 10;
int main(int argc, char *argv[])
{
    pid_t pid;
    int lval = 20;
    gval++, lval += 5;
    // 先前gval=11, lval = 25
    pid = fork();
    if (pid == 0)  // 子进程操作val
        gval += 2, lval += 2;
    else  // 父进程操作
        gval -= 2, lval -= 2;
    if (pid == 0)
        printf("Child Proc: [%d,%d] \n", gval, lval);  // [13, 27]
    else
        printf("Parent Proc: [%d,%d] \n", gval, lval);  // [9, 23]
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <stdio.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
    pid_t pid = fork();
    if (pid == 0)
    {
        puts("Hi, I am a child Process");
    }
    else
    {
        printf("Child Process ID: %d \n", pid);
        sleep(30);  // 使子进程变僵尸，30s后再终止子进程
    }
    if (pid == 0)
        puts("End child proess");
    else
        puts("End parent process");
    return 0;
}

1
2
3
4
5

#include <sys/wait.h>
pid_t wait(int *statloc);
/*
成功时返回终止的子进程 ID ,失败时返回 -1
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char *argv[])
{
    int status;
    pid_t pid = fork(); //这里的子进程将在第13行通过 return 语句终止

    if (pid == 0)
    {
        return 3;
    }
    else
    {
        printf("Child PID: %d \n", pid);
        pid = fork(); //这里的子进程将在 21 行通过 exit() 函数终止
        if (pid == 0)
        {
            exit(7);
        }
        else
        {
            printf("Child PID: %d \n", pid);
            wait(&status);         //之间终止的子进程相关信息将被保存到 status 中，同时相关子进程被完全销毁
            if (WIFEXITED(status)) //通过 WIFEXITED 来验证子进程是否正常终止。如果正常终止，则调用 WEXITSTATUS 宏输出子进程返回值
                printf("Child send one: %d \n", WEXITSTATUS(status));

            wait(&status); //因为之前创建了两个进程，所以再次调用 wait 函数和宏
            if (WIFEXITED(status))
                printf("Child send two: %d \n", WEXITSTATUS(status));
            sleep(30);
        }
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *statloc, int options);
/*
成功时返回终止的子进程ID 或 0 ，失败时返回 -1
pid: 等待终止的目标子进程的ID,若传 -1，则与 wait 函数相同，可以等待任意子进程终止
statloc: 与 wait 函数的 statloc 参数具有相同含义
options: 传递头文件 sys/wait.h 声明的常量 WNOHANG ,即使没有终止的子进程也不会进入阻塞状态，而是返回 0 退出函数。
*/

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main(int argc, char *argv[]) {
    int status;
    pid_t pid = fork();
    if (pid == 0) {
        sleep(3); //用 sleep 推迟子进程的执行
        return 24;
    }
    else
    {
        //调用waitpid 传递参数 WNOHANG ，这样没有终止的子进程返回0
        while (!waitpid(-1, &status, WNOHANG)) {
            sleep(1);
            puts("sleep 3 sec.");
        }
        if (WIFEXITED(status))
            printf("Child send %d \n", WEXITSTATUS(status));
    }
    return 0;
}

1
2
3
4
5
6
7
8

#include <signal.h>
void (*signal(int signo, void (*func)(int)))(int);
/*
为了在产生信号时调用，返回之前注册的函数指针
函数名: signal
参数：int signo,void(*func)(int)
返回类型：参数类型为int型，返回 void 型函数指针
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
// 返回0或以秒为单位的距 SIGALRM 信号发生所剩时间
// 如果调用该函数的同时向它传递一个正整型参数，相应时间后（以秒为单位）将产生 SIGALRM 信号。
// 若向该函数传递为 0 ，则之前对 SIGALRM 信号的预约将取消。
// 如果通过该函数预约信号后未指定该信号对应的处理函数，
// 则（通过调用 signal 函数）终止进程，不做任何处理。

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void timeout(int sig) { //信号处理器
    if (sig == SIGALRM)
        puts("Time out!");
    alarm(2); //为了每隔 2 秒重复产生 SIGALRM 信号，在信号处理器中调用 alarm 函数
}
void keycontrol(int sig) { //信号处理器

    if (sig == SIGINT)
        puts("CTRL+C pressed");
}
int main(int argc, char *argv[]) {
    int i;
    signal(SIGALRM, timeout); //注册信号及相应处理函数，注释该行2s后输出alarm clock，终止进程
    signal(SIGINT, keycontrol);
    alarm(2); //预约 2 秒候发射 SIGALRM 信号
    for (i = 0; i < 3; i++)  {
        puts("wait...");
        sleep(100);  // sleep 100s
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oldact);
/*
成功时返回 0 ，失败时返回 -1
act: 对于第一个参数的信号处理函数（信号处理器）信息。
oldact: 通过此参数获取之前注册的信号处理函数指针，若不需要则传递 0
*/

// struct sigaction  // sigaction结构体
// {
//     void (*sa_handler)(int);  // 保存信号处理的函数指针值（地址值）
//     sigset_t sa_mask;  // 防止僵尸进程置0
//     int sa_flags;  // 可看源码的所有flag
// };

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void timeout(int sig) {
    if (sig == SIGALRM)
        puts("Time out!");
    alarm(2);
}
int main(int argc, char *argv[]) {
    int i;
    struct sigaction act;
    act.sa_handler = timeout;    // 保存函数指针
    sigemptyset(&act.sa_mask);   // sig empty set将 sa_mask 成员的所有位初始化成0
    act.sa_flags = 0;            //sa_flags 同样初始化成 0
    sigaction(SIGALRM, &act, 0); // 注册 SIGALRM 信号的处理器。
    
    alarm(2); //2 秒后发生 SIGALRM 信号
    for (int i = 0; i < 3; i++) {
        puts("wait...");
        sleep(100);
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
void read_childproc(int sig) {  // 销毁子进程
    int status;
    pid_t id = waitpid(-1, &status, WNOHANG);
    if (WIFEXITED(status))
    {
        printf("Removed proc id: %d \n", id);             //子进程的 pid
        printf("Child send: %d \n", WEXITSTATUS(status)); //子进程的返回值
    }
}
int main(int argc, char *argv[]) {
    pid_t pid;
    struct sigaction act;
    act.sa_handler = read_childproc;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGCHLD, &act, 0);

    pid = fork();
    if (pid == 0) {
        puts("Hi I'm child process 1");
        sleep(10);
        return 12;
    }
    else {
        printf("Child 1 proc id: %d\n", pid);
        pid = fork();
        if (pid == 0) {
            puts("Hi! I'm child process 2");
            sleep(10);
            exit(24);
        }
        else {
            int i;
            printf("Child 2 proc id: %d \n", pid);
            for (i = 0; i < 5; i++) {
                puts("wait");
                sleep(5);
            }
        }
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

while (1) {
    adr_sz = sizeof(clnt_adr);
    clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &adr_sz);
    if (clnt_sock == -1)
        continue;
    else
        puts("new client connected...");
    pid = fork(); //此时，父子进程分别带有一个套接字
    if (pid == -1) {  // 分配失败
        close(clnt_sock);
        continue;
    }
    if (pid == 0) { //子进程运行区域, 此部分向客户端提供回声服务
        close(serv_sock); //关闭服务器套接字，因为从父进程传递到了子进程
        while ((str_len = read(clnt_sock, buf, BUFSIZ)) != 0)
            write(clnt_sock, buf, str_len);
        close(clnt_sock);
        puts("client disconnected...");
        return 0;
    }
    else
        close(clnt_sock); //通过 accept 函数创建的套接字文件描述符已经复制给子进程，因此服务器端要销毁自己的
}