Linux网络编程

最新推荐文章于 2024-09-11 15:16:48 发布
最新推荐文章于 2024-09-11 15:16:48 发布
阅读量162 收藏
点赞数
分类专栏： Github 文章标签： linux udp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48673014/article/details/119886926
版权

ARP

情况一：我与小胖位于同一子网。我向小胖的ip地址发起arp请求，小胖收到回应，告诉我他的mac地址，然后我向该mac地址发送hello即可。
情况二：我与小胖不在同一子网。由于不在同一子网，我需要向我的网关发送arp请求，网关告诉我mac地址，然后我向告诉网关：“向小胖的ip发hello”。剩下的事情，我就不用管了，如果网络可达，那么小胖就会收到我发的hello。

判断主机大小端

#include <iostream>
using namespace std;
int main()
{
    union
    {
        short value;
        char s[2];
    } t;
    t.value = 0x0102;
    if (t.s[0] == 0x01)
        cout << "大端" << endl;
    else if (t.s[0] == 0x02)
        cout << "小端" << endl;
    return 0;
}

IP地址转换

#include <iostream>
#include <stdio.h>
#include <arpa/inet.h>
using namespace std;
int main()
{
    char addr[] = "192.168.1.1";
    unsigned int num = 0;
    inet_pton(AF_INET, addr, &num);
    unsigned char *p = (unsigned char *)&num;
    printf("%d %d %d %d\n", *p, *(p + 1), *(p + 2), *(p + 3));
    char show[16] = {0};
    const char *res = inet_ntop(AF_INET, &num, show, sizeof(show));
    cout << res << endl;
    return 0;
}

例：server和client的通信
server

#include <stdio.h>
#include <arpa/inet.h>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <cstring>
#include <unistd.h>
using namespace std;
void show(sockaddr_in caddr)
{
    char cIP[16] = {0};
    inet_ntop(AF_INET, &caddr.sin_addr.s_addr, cIP, sizeof(cIP));
    unsigned short clientPort = ntohs(caddr.sin_port);
    cout << cIP << ":" << clientPort << endl;
    return;
}
int rcv(int opfd)
{
    char rcvbuf[1024] = {0};
    int len = read(opfd, rcvbuf, sizeof(rcvbuf));
    if (len == -1)
    {
        perror("read");
        exit(-1);
    }
    else if (len > 0)
        cout << rcvbuf << endl;
    else
    {
        cout << "client closed..." << endl;
        return 0;
    }
}
void sd(int opfd)
{
    char sdbuf[1024] = {0};
    cin >> sdbuf;
    write(opfd, sdbuf, strlen(sdbuf));
}
int main()
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd == -1)
    {
        perror("socket");
        exit(-1);
    }
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    inet_pton(AF_INET, "172.24.24.44", (void *)&saddr.sin_addr.s_addr);
    //saddr.sin_addr.s_addr = INADDR_ANY; // 0.0.0.0
    saddr.sin_port = htons(9999);
    int ret = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if (ret == -1)
    {
        perror("bind");
        exit(-1);
    }
    ret = listen(lfd, 8);
    if (ret == -1)
    {
        perror("litsen");
        exit(-1);
    }
    struct sockaddr_in caddr;
    socklen_t len = sizeof(caddr);
    int opfd = accept(lfd, (struct sockaddr *)&caddr, &len);
    if (opfd == -1)
    {
        perror("accept");
        exit(-1);
    }
    show(caddr);
    pid_t pid = fork();
    if (pid > 0)
        while (rcv(opfd));
    else if (pid == 0)
    {
        while (1)
            sd(opfd);
    }
    close(opfd);
    close(lfd);
    return 0;
}

client

#include <stdio.h>
#include <arpa/inet.h>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <cstring>
#include <unistd.h>
using namespace std;
void sd(int fd)
{
    char buf[1024] = {0};
    cin >> buf;
    write(fd, buf, sizeof(buf));
    return;
}
int rcv(int fd)
{
    char rcvbuf[1024] = {0};
    int len = read(fd, rcvbuf, sizeof(rcvbuf));
    if (len == -1)
    {
        perror("read");
        exit(-1);
    }
    else if (len > 0)
        cout << rcvbuf << endl;
    else
    {
        cout << "client closed..." << endl;
        return false;
    }
    return true;
}
int main()
{
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd == -1)
    {
        perror("socket");
        exit(0);
    }
    struct sockaddr_in saddr;
    saddr.sin_port = htons(9999);
    inet_pton(AF_INET, "172.24.24.44", &saddr.sin_addr.s_addr);
    saddr.sin_family = AF_INET;
    int res = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
    if (res == -1)
    {
        perror("conn");
        exit(-1);
    }
    pid_t pid = fork();
    if (pid > 0)
    {
        while (1)
            sd(fd);
    }
    else if (pid == 0)
    {
        while (rcv(fd))
            ;
    }
    close(fd);
    return 0;
}

多进程实现并发服务器

#include <stdio.h>
#include <arpa/inet.h>
#include <iostream>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <string>
#include <cstring>
#include <wait.h>
using namespace std;
void recyclechild(int arg)
{
    while (1)
    {
        int ret = waitpid(-1, NULL, WNOHANG);
        if (ret == -1)
            break;
        else if (ret == 0)
            break;
        else
            cout << ret << "recycled" << endl;
    }
}
int main()
{
    struct sigaction act;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    act.sa_handler = recyclechild;
    sigaction(SIGCHLD, &act, NULL);
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd == -1)
    {
        perror("link");
        exit(-1);
    }
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    saddr.sin_addr.s_addr = INADDR_ANY;
    int res = bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if (res == -1)
    {
        perror("bind");
        exit(-1);
    }
    res = listen(lfd, 128);
    if (res == -1)
    {
        perror("listen");
        exit(-1);
    }
    while (1)
    {
        struct sockaddr_in caddr;
        socklen_t len = sizeof(caddr);
        int cfd = accept(lfd, (struct sockaddr *)&caddr, &len);
        if (cfd == -1)
        {
            if (errno == EINTR)
                continue;
            perror("accept");
            exit(-1);
        }
        pid_t pid = fork();
        if (pid == 0)
        {
            char cIP[16];
            inet_ntop(AF_INET, &caddr.sin_addr.s_addr, cIP, sizeof(cIP));
            unsigned short cPort = ntohs(caddr.sin_port);
            cout << cIP << ':' << cPort << endl;
            char buf[1024] = {0};
            int len = 0;
            while (len = read(cfd, buf, sizeof(buf)) > 0)
            {
                cout << buf << endl;
                write(cfd, "recieved", strlen("recieved"));
            }
            if (len == 0)
                cout << "client " << cIP << ':' << cPort << " closed..." << endl;
            else
                perror("read");
            close(cfd);
            exit(0);
        }
        else if (pid == -1)
        {
            perror("fork");
            exit(-1);
        }
    }
    close(lfd);
    return 0;
}

select完成IO多路复用

#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <cstring>
#include <string>
using namespace std;
int main()
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = INADDR_ANY;
    bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    listen(lfd, 8);

    fd_set rdset, tmp;
    FD_ZERO(&rdset);
    FD_SET(lfd, &rdset);
    int maxfd = lfd;
    while (1)
    {
        tmp = rdset;
        int res = select(maxfd + 1, &tmp, NULL, NULL, NULL);
        if (res == -1)
        {
            perror("select");
            exit(-1);
        }
        else if (res == 0)
            continue;
        else
        {
            if (FD_ISSET(lfd, &tmp))
            {
                int cfd;
                struct sockaddr_in caddr;
                unsigned int len = sizeof(caddr);
                cfd = accept(lfd, (struct sockaddr *)&caddr, &len);
                FD_SET(cfd, &rdset);
                maxfd = max(maxfd, cfd);
            }
            for (int i = lfd + 1; i <= maxfd; ++i)
            {
                if (FD_ISSET(i, &tmp))
                {
                    char buf[1024] = {0};
                    int len = read(i, buf, sizeof(buf));
                    if (len == -1)
                    {
                        perror("read");
                        exit(-1);
                    }
                    else if (len == 0)
                    {
                        cout << "closed..." << endl;
                        close(i);
                        FD_CLR(i, &rdset);
                    }
                    else
                    {
                        cout << buf << endl;
                        write(i, "recieved!", strlen("recieved!") + 1);
                    }
                }
            }
        }
    }
    close(lfd);
    return 0;
}

epoll服务端

#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <cstring>
#include <string>
#include <sys/epoll.h>
using namespace std;
int main()
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in saddr;
    saddr.sin_port = htons(9999);
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = INADDR_ANY;
    bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
    listen(lfd, 8);

    int epfd = epoll_create(1);

    struct epoll_event epev;
    epev.events = EPOLLIN;
    epev.data.fd = lfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &epev);
    struct epoll_event epevs[1024];
    while (1)
    {
        int ret = epoll_wait(epfd, epevs, 1024, -1);
        if (ret == -1)
        {
            perror("epoll");
            exit(-1);
        }
        cout << ret << endl;
        for (int i = 0; i < ret; ++i)
        {
            int curfd = epevs[i].data.fd;
            if (epevs[i].data.fd == lfd)
            {
                int cfd;
                struct sockaddr_in caddr;
                unsigned int len = sizeof(caddr);
                cfd = accept(lfd, (struct sockaddr *)&caddr, &len);
                epev.events = EPOLLIN;
                epev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);
            }
            else
            {
                char buf[1024] = {0};
                int len = read(curfd, buf, sizeof(buf));
                if (len == -1)
                {
                    perror("read");
                    exit(-1);
                }
                else if (len == 0)
                {
                    cout << "closed..." << endl;
                    close(curfd);
                    epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
                }
                else
                {
                    cout << buf << endl;
                    write(curfd, "recieved!", strlen("recieved!") + 1);
                }
            }
        }
    }
    close(epfd);
    close(lfd);
    return 0;
}

udp通信server

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <cstring>
#include <arpa/inet.h>
#include <iostream>
using namespace std;
int main()
{
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    struct sockaddr_in addr;
    addr.sin_port = htons(9999);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    bind(fd, (struct sockaddr *)&addr, sizeof(addr));
    while (1)
    {
        char buf[1024] = {0};
        char ipbuf[16] = {0};
        struct sockaddr_in caddr;
        socklen_t len = sizeof(caddr);
        recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *)&caddr, &len);
        cout << inet_ntop(AF_INET, &caddr.sin_addr.s_addr, ipbuf, sizeof(ipbuf)) << ':' << caddr.sin_port << endl;
        cout << buf << endl;
        sendto(fd, buf, strlen(buf) + 1, 0, (struct sockaddr *)&caddr, len);
    }
    close(fd);
    return 0;
}

udp通信client

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <cstring>
#include <arpa/inet.h>
#include <iostream>
using namespace std;
int main()
{
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    struct sockaddr_in addr;
    addr.sin_port = htons(9999);
    addr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr.s_addr);
    socklen_t len = sizeof(addr);
    //bind(fd, (struct sockaddr *)&addr, sizeof(addr));
    int cnt = 0;
    while (1)
    {
        char buf[1024] = {0};
        sprintf(buf, "hello:%d\n", ++cnt);
        sendto(fd, buf, strlen(buf) + 1, 0, (struct sockaddr *)&addr, len);
        recvfrom(fd, buf, sizeof(buf), 0, NULL, NULL);
        cout << buf << endl;
        sleep(1);
    }
    close(fd);
    return 0;
}
ShilongLi01
关注
专栏目录
linux 网络编程
qq_39855356的博客
09-16 4931
linux系统编程-网络编程
嵌入式linux网关,嵌入式linux中，用程序设置IP，子网掩码，网关。
weixin_40008946的博客
05-05 387
最近有个项目，要求在程序中，对嵌入式linux系统设置网卡的IP地址，子网掩码，网关，虽说直接调用系统自带的ifconfig，route等命令可以实现但总觉得不够优雅，于是写了个利用ioctl直接设置的程序，供大家参考。#include #include #include #include #include #include #include #include //...
socket编程学习（addr设置）
03-03 2719
sockaddr结构体 struct sockaddr{ 　　sa_family_tsa_family;　//地址族，最常用的是"AF_INET"(IPV4)和"AF_INET6"(IPV6);　 　　char sa_data[14]；　　 //包含套接字中的目标地址和端口信息; }； sockaddr的缺陷：sa_data把目标地址和端口信息混在一起了 sockaddr_in 结构体 sockaddr_in结构体解决了sockaddr的缺陷，把port和addr 分开储存在两...
Linux套接字编程之sockaddr与sockaddr_in网络套接字,sockaddr_un进程间通信本地套接字
$好记性还是要多记录$
04-27 1275
sockaddr struct sockaddr { unsigned short sa_family; /* address family, AF_xxx */ char sa_data[14]; /* 14 bytes of protocol address */ }; sa_family是地址家族，一般都是“AF_xxx”的形式。好像通...
linux程序改ip地址吗,如何在Linux中从C设置IP地址
weixin_30252651的博客
05-03 172
通过使用strace和ifconfig，我发现可以通过以下方式设置IP地址：#include #include #include #include int main(int argc, const char *argv[]) {struct ifreq ifr;const char * name = "eth1";int fd = socket(PF_INET, SOCK_DGRAM, IPPRO...
Day386&387.Nio概述&Nio的Channel通道 -NIO
阿昌爱Java
09-10 1234
Java NIO 概述 Java NIO（New IO 或 Non Blocking IO）是从Java 1.4 版本开始引入的一个新的IO API，可以替代标准的 Java IO API。NIO 支持面向缓冲区的、基于通道的 IO 操作。NIO 将以更加高效的方式进行文件的读写操作。 1.1 阻塞 IO 通常在进行同步 I/O 操作时，如果读取数据，代码会阻塞直至有可供读取的数据。同样，写入调用将会阻塞直至数据能够写入。传统的 Server/Client 模式会基于 TPR（Thread per Requ
linux网络编程
m0_72749070的博客
09-03 5568
自学笔记整理，如有不对，请指正
Linux网络编程（2024超级详细、Linux）
嵌入式学习者(学生)
01-05 2312
本文是作者在学习linux网络编程的时候所写的学习笔记，同时方便巩固自己学习的知识和网友们一起分享，尚若发现有什么不对的地方，欢迎指正。
Linux网络编程，包括tcp/upd，select/poll/epoll/pdf
04-14
linux网络编程 pdf # Linux网络编程基础 Linux网络编程是指在Linux操作系统上开发网络应用程序的过程。它主要涉及到TCP/UDP协议以及select/poll/epoll等多路复用技术。 TCP/UDP协议是网络通信的基础，其中TCP协议...
Linux 网络编程
08-30
Linux网络编程是Linux开发中的一个重要领域，它允许程序员编写代码来实现网络通信功能。Linux作为一款功能强大的开源操作系统，提供了丰富的网络编程接口和工具，为开发者提供了强大的支持来构建网络服务和应用。在...
Linux网络编程（第2版）随书源代码.rar
06-24
《Linux网络编程（第2版）》是一本深入探讨Linux环境下网络编程的权威书籍，它为读者揭示了网络通信的核心原理和技术。随书附带的源代码是学习和实践网络编程的重要参考资料，可以帮助读者更直观地理解书中的理论...
linux 网络编程.pdf
01-27
linux 网络编程.pdf
Linux 进程控制
2302_77289177的博客
09-08 1295
Linux 进程控制
高效诊断Linux性能问题
Tiger93的博客
09-08 567
诊断Linux性能问题
【Linux】ldd常见问题
最新发布
zclinux的博客
09-11 956
当你自己编译程序时，可以通过。
Linux和C语言（Day10）
weixin_65095004的博客
09-10 1059
实现特定功能的代码块定义函数： 存储类型 数据类型 函数名(参数列表){ 实现特定功能的代码块 }
Linux之MySQL主从复制
2302_79087378的博客
09-08 1497
MySQL的主从复制（）是一种数据复制解决方案，将主数据库的DDL（数据定义语言）和DML（数据操纵语言）操作通过二进制日志传到从库服务器中，然后在从库上对这些日志重新执行（也叫重做），从而是的从库和主库的数据保存同步。MySQL支持将数据从一个MySQL服务器（主服务器）复制到一个或多个其他MySQL服务器（从服务器），从库同时也可以作为其他从服务器的主库，实现链状复制。MySQL主从复制的优点主要包含以下三个方面：主库出现问题，可以快速切换到从库提供服务；实现读写分离，降低主库的访问压力；
Linux 中 Tail 命令的 9 个实用示例
冷冻工厂
09-09 1189
但是，我们可以使用 -n 选项，它允许我们限制要在屏幕上打印的行数，如图所示。tail 命令是一个命令行工具，它与 head 命令类似，用于读取文件内容，并将一个或多个文件的最后 10 行显示在屏幕上。在前面的示例中，我们看到该命令在处理多个文件时启用显示标题。在这里，我们可以看到上面的命令显示了 /var/log/secure 文件的最后十行。在这里，我们可以使用加号 (+) 和 -n 选项，这允许我们控制给定文件的起点。在这种情况下，我们可以在命令中使用 -f 选项，这使我们能够实时监视文件的更改。
深入探索Linux网络编程
"《Linux网络编程.pdf》是一本详尽介绍Linux网络编程的书籍，涵盖了从网络历史到操作系统模型，再到具体的编程实践等多个方面。书中深入浅出地讲解了Linux和Unix的发展，以及它们在网络编程中的重要性。" 在第一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值