编写linux c socket 遇到的各种坑

最新推荐文章于 2024-11-11 20:18:26 发布
原创 最新推荐文章于 2024-11-11 20:18:26 发布 · 785 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

最近在使用linux c 编写一个tcp 的客户端和服务端，期间遇到了各种坑，现在将其记录下来，以备日后爬坑。

1、第一个是关于局部变量，局部变量在c语言中的特性是：自动存储期/块作用域/无链接。

我在编写socket服务端的时候，使用了thread，在获得一个新链接的时候，创建一个线程来执行socket的发送和接受。

代码如下：


void SendAndRecv(int *sockFd)
{
    if (*sockFd == -1)
    {
        printf("send and recv error:%d\n", errno);
        return;
    }

    printf("send and recv *sockFd is:%d\n", *sockFd);

    char buf[BUF_SIZE];
    int recvOffset = 0; //buffer recv address
    printf("accept success\n");
    // getchar();
    int recvSize;
    while (1)
    {
        send(*sockFd, "HELLO SERVER", 13, 0);

        send(*sockFd, PACK_END, 1, 0);

        // printf("Offset is %d\n",recvOffset);

        if (recvOffset >= BUF_SIZE)//out off buf
        {
            recvOffset = 0;
            continue;
        }

        recvSize = recv(*sockFd, &buf[recvOffset], BUF_SIZE - recvOffset, 0);

        if (recvSize <= 0)
        {
            printf("recv size is %d,socket [%d] is end!\n", recvSize,*sockFd);
            break;
        }

        //change to for round,beacuse i did not konw when the pack end come in
        int i = recvOffset + recvSize - 1;
        for (; i >= recvOffset; i--)
        {
            if (buf[i] == PACK_END[0]) //find pack end
            {
                break;
            }
        }

        if (i == recvOffset - 1) //not find pack end
        {
            recvOffset += recvSize;
            continue;
        }

        // buf[i] = '\0';
        // printf("recv msg:%s\n", buf);

        //find package end
        if (i < recvOffset + recvSize - 1) //0xFF not the end
        {
            memcpy(buf, &buf[i + 1], recvOffset + recvSize - 1 - i);
            recvOffset = recvOffset + recvSize - 1 - i;
            // continue;
        }
        else
        {
            //0xFF is the end
            recvOffset = 0;
        }

        memset(&buf[recvOffset], 0, BUF_SIZE - recvOffset);
    }

    shutdown(*sockFd, SHUT_RDWR);
    close(*sockFd);
}

void Accept(int *sockFd)
{

    if (*sockFd == -1)
    {
        printf("listen error,*sockFd is -1\n");
        return;
    }

    printf("*sockFd is :%d\n", *sockFd);

    struct sockaddr_in clientAddr;

    int sinSize = sizeof(struct sockaddr_in);

    while (1)
    {

        int newFd = accept(*sockFd, (struct sockaddr *)&clientAddr, &sinSize);

        if (newFd == -1)
        {
            printf("accept error:%d\n", errno);
            return;
        }

        //print client message
        printf("client addr:%s,client port:%d\n",
               inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));

        //run send and recv
        int retThread;
        pthread_t threadSendAndRecv;

        if (threadNumber >= 5) //复用thread
            threadNumber = 0;

        retThread = pthread_create(&(threadRun[threadNumber++]), NULL, (void *)&SendAndRecv, (void *)&newFd);
        if (retThread == -1)
        {
            printf("Accept error:%d\n", errno);
            return;
        }
    }

    //run next accept
    // Accept(sockFd);
    //when I am running Accept method again,
    //why the stack avaiable do not miss?
    //beasuse the last Accept is not game over?
    //I think this is the right answer.
}

在监听到新的连接时，将使用pthread创建一个新的线程，来处理发送接收的任务，使用void*指针来传递newFd（socket的编码）。在运行的过程中发现，一个while循环结束之后，之前循环的newFd并没有被回收，这与c语言的局部变量删除机制有冲突。（冲突的地方在于，理论上，一个while循环结束之后，之前的newFd将被回收，SendAndRecv中的*sockFd将因为找不到地址而出错）

那么问题出在哪里呢？

猜测1：一个函数中所有定义的变量都会在函数结束的时候统一回收。

猜测2：使用pthread函数后，编译器会执行特殊处理，让newFd存在的时间加长。

下面是验证的代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{

    int *p;
    for (int i = 0; i < 10; i++) //i的存在期应该是for循环内
    {
        p = &i;
        printf("addr:%d,num:%d\n", &i, *p);
    }

    printf("*p,addr:%d,number:%d\n", p, *p);

    return 0;
}

结果如下：


addr:-6940,num:0
addr:-6940,num:1
addr:-6940,num:2
addr:-6940,num:3
addr:-6940,num:4
addr:-6940,num:5
addr:-6940,num:6
addr:-6940,num:7
addr:-6940,num:8
addr:-6940,num:9
*p,addr:-6940,number:10

从上面的执行结果可以看出来，i并没有在for循环结束之后回收，会存在于函数main()的整个生存期。

所以猜测1可能是对的。

继续验证上面的猜测，代码如下：

#include <stdio.h>
#include <stdlib.h>

int *p;

void print()
{

    for (int i = 0; i < 10; i++) //i的存在期应该是for循环内
    {
        p = &i;
        printf("addr:%d,num:%d\n", &i, *p);
    }

    printf("*p,addr:%d,number:%d\n", p, *p);
}

int main()
{

    print();

    printf("*p,addr:%d,number:%d\n", p, *p);
    
    print();
    printf("*p,addr:%d,number:%d\n", p, *p);
    
    return 0;
}

运行结果如下：

addr:1708207980,num:0
addr:1708207980,num:1
addr:1708207980,num:2
addr:1708207980,num:3
addr:1708207980,num:4
addr:1708207980,num:5
addr:1708207980,num:6
addr:1708207980,num:7
addr:1708207980,num:8
addr:1708207980,num:9
*p,addr:1708207980,number:10
*p,addr:1708207980,number:10
addr:1708207980,num:0
addr:1708207980,num:1
addr:1708207980,num:2
addr:1708207980,num:3
addr:1708207980,num:4
addr:1708207980,num:5
addr:1708207980,num:6
addr:1708207980,num:7
addr:1708207980,num:8
addr:1708207980,num:9
*p,addr:1708207980,number:10
*p,addr:1708207980,number:10

从上图中看出来，运行的print()函数分配的i的地址是一致的。

猜测如下：编译器优化了代码，判断了整个代码的流程。也可能是c语言的机制，在程序运行的时候，分配好了程序的堆栈，第一个函数print()结束后，回收了i的内存空间，在第二次执行的时候，再度分配。

下面验证，究竟是那种方式！

代码如下：（其实就是增加一个变量）

void print()
{

    for (int i = 0; i < 10; i++) //i的存在期应该是for循环内
    {
        // p = &i;
        printf("addr:%d,num:%d\n", &i, i);
    }

    // printf("*p,addr:%d,number:%d\n", p, *p);
}

int main()
{

    print();

    // printf("*p,addr:%d,number:%d\n", p, *p);

    int c=2000;
    printf("c:addr:%d,num:%d",&c,c);
    
    print();
    // printf("*p,addr:%d,number:%d\n", p, *p);
    
    return 0;
}

结果如下：

addr:642349804,num:0
addr:642349804,num:1
addr:642349804,num:2
addr:642349804,num:3
addr:642349804,num:4
addr:642349804,num:5
addr:642349804,num:6
addr:642349804,num:7
addr:642349804,num:8
addr:642349804,num:9
c:addr:642349836,num:2000addr:642349804,num:0
addr:642349804,num:1
addr:642349804,num:2
addr:642349804,num:3
addr:642349804,num:4
addr:642349804,num:5
addr:642349804,num:6
addr:642349804,num:7
addr:642349804,num:8
addr:642349804,num:9

上面的代码去掉了全局指针变量*p，发现print中i的地址和main函数中c的地址一致，那说明函数执行完成后，会局部变量，下一次使用的时候继续分配。

下面是将*p添加上去，得到的结果。

#include <stdio.h>
#include <stdlib.h>

int *p;

void print()
{

    for (int i = 0; i < 10; i++) //i的存在期应该是for循环内
    {
        p = &i;
        printf("addr:%d,num:%d\n", &i, i);
    }

    printf("*p,addr:%d,number:%d\n", p, *p);
}

int main()
{

    print();

    // printf("*p,addr:%d,number:%d\n", p, *p);

    int c=2000;
    printf("c:addr:%d,num:%d",&c,c);
    
    print();
    // printf("*p,addr:%d,number:%d\n", p, *p);
    
    return 0;
}

结果：

addr:286303564,num:0
addr:286303564,num:1
addr:286303564,num:2
addr:286303564,num:3
addr:286303564,num:4
addr:286303564,num:5
addr:286303564,num:6
addr:286303564,num:7
addr:286303564,num:8
addr:286303564,num:9
*p,addr:286303564,number:10
c:addr:286303596,num:2000addr:286303564,num:0
addr:286303564,num:1
addr:286303564,num:2
addr:286303564,num:3
addr:286303564,num:4
addr:286303564,num:5
addr:286303564,num:6
addr:286303564,num:7
addr:286303564,num:8
addr:286303564,num:9
*p,addr:286303564,number:10

加上*p和去掉*p的执行结果一致！所以上面的猜测中第二种是正确的，即函数执行完成后，所有非静态局部变量都会被回收，与是否是指针无关系，并且在下一次需要分配内存的时候，继续从回收的位置处分配，并且内存中的数据不会被设置为0，和回收前的数据一致！！！

这便是变量需要初始化的原因。

所以socketServer.c代码中传递newFw的方案有问题，会导致同一时间只有一个socketclient 可以发送数据。

修改方案：将0xFF作为结尾的方案取消，以空字符'\0'作为结尾。将socket的分段和粘连同时考虑进去，便有了下面的代码：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <pthread.h>   //线程
#include <arpa/inet.h> //格式转换

#define PORT 8000
#define BACKLISTENER 10
#define BUF_SIZE 0x2000

#define MESSAGE "HELLO SERVER"

const char PACK_END[1] = {0xFF};

// pthread_t threadAccept;
//can not use const int BACKLISTENER,
//because in the complier time, c lanage can not know what the const variable is.

static pthread_t threadRun[BACKLISTENER]; //use in this file,can not use in other files
static int sockNum[BACKLISTENER];

static int indexNum = 0;

void SendAndRecv(int *sockFd)
{
    if (*sockFd == -1)
    {
        printf("send and recv error:%d\n", errno);
        return;
    }

    printf("send and recv *sockFd is:%d\n", *sockFd);

    char sendChars[14];
    memcpy(sendChars,MESSAGE,sizeof(MESSAGE));
    memcpy(&sendChars[13],PACK_END,1);

    char buf[BUF_SIZE];
    int recvOffset = 0; //buffer recv address

    int recvSize;
    // int sendSize;

    int packStart = 0;
    while (1)
    {
        send(*sockFd,sendChars,sizeof(sendChars),0);

        if (recvOffset >= BUF_SIZE) //out off buf
        {
            recvOffset = 0;
            continue;
        }

        recvSize = recv(*sockFd, &buf[recvOffset], BUF_SIZE - recvOffset, 0);

        if (recvSize <= 0)
        {
            printf("recv size is %d,socket [%d] is end!\n", recvSize, *sockFd);
            break;
        }

        //change to for round,beacuse i did not konw when the pack end come in

        for (int i = recvOffset; i < recvOffset + recvSize; i++)
        {
            if (buf[i] == PACK_END[0])
            {
                buf[i] = '\0';
                printf("start:%d,end:%d package:%s\n", packStart, i, &buf[packStart]);
                packStart = i + 1; //next package start
            }
            else if (buf[i] == '\0')
            {
                buf[i] = ' ';
            }
        }

        if (packStart == recvOffset + recvSize)
        {
            recvOffset = 0;
        }
        else
        {
            memcpy(buf, &buf[packStart], recvOffset + recvSize - packStart);
            recvOffset = recvOffset + recvSize - packStart;
        }

        packStart = 0;

        memset(&buf[recvOffset], 0, BUF_SIZE - recvOffset);
    }

    close(*sockFd);
}

void Accept(int *sockFd)
{

    if (*sockFd == -1)
    {
        printf("listen error,*sockFd is -1\n");
        return;
    }

    printf("*sockFd is :%d\n", *sockFd);

    struct sockaddr_in clientAddr;

    int sinSize = sizeof(struct sockaddr_in);

    while (1)
    {

        sockNum[indexNum] = accept(*sockFd, (struct sockaddr *)&clientAddr, &sinSize);

        if (sockNum[indexNum] == -1)
        {
            printf("accept error:%d\n", errno);
            return;
        }

        //print client message
        printf("client addr:%s,client port:%d\n",
               inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));

        //run send and recv
        int retThread;

        if (indexNum >= BACKLISTENER) //复用thread
            indexNum = 0;

        retThread = pthread_create(&(threadRun[indexNum]), NULL, (void *)&SendAndRecv, (void *)&sockNum[indexNum]);
        if (retThread == -1)
        {
            printf("Accept error:%d\n", errno);
            return;
        }

        indexNum++;
    }
}

int main()
{
    // printf("HELLO MY JOB");
    int sockFd, newFd; //SOCKET句柄，连接后句柄
    struct sockaddr_in serverAddr;
    struct sockaddr_in clientAddr;
    int sinSize;

    sockFd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockFd == -1)
    {
        printf("socket() failed:%d\n", errno);
        return -1;
    }

    serverAddr.sin_family = AF_INET;                //传输协议
    serverAddr.sin_port = htons(PORT);              //端口号
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY); //监听所有IP
    memset(&(serverAddr.sin_zero), 0, sizeof(serverAddr.sin_zero));

    if (bind(sockFd, (struct sockaddr *)&serverAddr, sizeof(struct sockaddr)) < 0)
    {
        printf("bind error:%d\n", errno);
        return -1;
    }

    listen(sockFd, BACKLISTENER);

    int retThread;        //返回值
    pthread_t threadBody; //thread对象

    retThread = pthread_create(&threadBody, NULL, (void *)&Accept, (void *)&sockFd); //创建一个thread
    if (retThread != 0)
    {
        printf("创建thread对象失败\n");
        return -1;
    }

    printf("Enter any key to exit!\n");
    getchar();

    // shutdown(sockFd, SHUT_RDWR);

    close(sockFd);

    printf("socket listen is end!\n");

    return 0;
}

 

记录TCP/UDP 对接其他公司(c语言) socket 方式 的坑
qq_36170500的博客
04-30 375
记录TCP/UDP 对接其他公司(c语言) socket 方式 的坑 先说明下业务情景： 其他公司做的是 服务端 ，©语言的方式通过socket。来进行数据传出。通过两种协议tcp/udp 。而我这边做的是客户端 ，用的是java开发。 这两者均有坑。再此记录， 1.TCP的坑 客户端 我编写的 代码： public static String sendTCPRequestNew(String I...
Socket所遇到的坑
冰糖的博客
03-07 2520
本文记录使用Socket通信时所遇到坑，不断更新。目前记录三个问题： 建立Socket连接 使用输入流和输出流进行通信 使用心跳保持Socket连接 建立Socket连接Socket连接需要一个ServerSocket充当服务器，还有许多Socket作为客户端来连接ServerSocket. 在Eclipse中代码如下：服务器端： Socket socket;
socket 编程遇到的坑（基于计算机网络的实践）
deepsprings的博客
04-14 358
前言： 对于《计算机网络》来说，实现网络互接和文件传输，不必要关注底层，只需要关注到传输本身。如果从一处传输到另一处，只需关注ip和端口即可，也就是嵌套字socket。 借用Python中的socket模块，理解网络传输的过程和实现。 1. 基本内容 《计算机网络基础》参考： 计算机网络基础之总结 基本配置：ubuntu + 阿里云ECS服务器 一个小例子 # server.py...
C语言 网络编程_socket编程“陷阱识别”
albertlee0329的博客
11-04 255
socket网络编程遇到的坑，bind函数和accept函数
关于SOCKET通信遇到的问题小结
chitun9294的博客
10-19 248
最近在做点通信方面的东西。由于好久不碰C了，还真遇到了几个坑爹的问题。全是我自己犯的低级错误，把它记下来。防止忘记。 1. 对于数据接收recvfrom操作设置为阻塞模式无效 我需要在阻塞模式下进行数据传输，同时设定超时机制。但问题是我通过setsockopt一级ioctlsocket...
Linux课程设计 C语言编写的基于socket的斗地主.zip
04-06
可移植性好：C语言编写的程序可以在多种操作系统和硬件平台上运行，因此，学习C语言可以帮助学生掌握跨平台编程的技能，提高程序的可移植性。 效率高：C语言具有高效性，它可以直接访问硬件资源，执行效率高。在...
linux下C语言SOCKET编程客户端、服务器端代码
11-04
本篇文章将深入探讨Linux下的C语言SOCKET编程，包括客户端和服务器端的实现。 首先，我们要理解SOCKET的基本概念。在计算机网络中，SOCKET是一种进程间通信（IPC）机制，它允许通过网络连接的两台机器上的进程相互...
C语言linux socket编程.zip
06-13
在IT领域，网络编程是不可或缺的一部分，特别是在操作系统如Linux中，C语言因其高效性和灵活性，常被用于编写底层网络应用程序。本压缩包“C语言Linux Socket编程.zip”可能包含了一系列教程或示例代码，旨在帮助...
raw_loop.zip_RAW_linux raw socket_raw socket
09-23
在压缩包中的文件`raw_loop.c`很可能是一个C语言编写的程序，用于演示如何创建和使用raw sockets进行环回测试。环回测试通常是验证程序能否正确发送和接收数据，不涉及网络传输，数据直接在本地操作系统内完成。 ...
linux下 socket tcp Server c语言编写（分别实现单进程，多进程，多线程）
jelly_gemini的博客
08-05 9011
TCP 迭代服务器接受一个客户端的连接，然后处理，完成了这个客户的所有请求后，断开连接。TCP 迭代服务器一次只能处理一个客户端的请求，只有在这个客户的所有请求满足后，服务器才可以继续后面的请求。如果有一个客户端占住服务器不放时，其它的客户机都不能工作了，因此，TCP 服务器一般很少用迭代服务器模型的。tcp服务器端框架 1.创建tcp套接字 2. 绑定套接字 3. 监听套接字 4.
Linux socket编程的“坑点”-客户端
u013705518的博客
09-27 228
一、Linux socket编程的框架。 Linux系统内建了TCP/IP协议栈，套接字网络编程只需要调用相关的API接口。在服务器端，创建套接字、设置套接字选项（可选）、绑定网络参数后，就可以监听客户端的连接请求，等待客户端连接进来。在客户端，创建套接字、设置套接字选项（可选）、初始化IP、端口号等网络参数后，就可以连接服务器，如果服务器接受连接，就可以进行双向数据通讯，过程如下图所示。 二、几个重要的“坑点”与解决办法。 心跳包应该采用主动式。教科书建议的都是被动式心跳，判断网...
socket编程中容易出现的5个错误
weixin_34184561的博客
11-23 1510
一.概述： Socket API 是网络应用程序开发中实际应用的标准 API。尽管该 API 简单，但是开发新手可能会经历一些常见的问题。本文识别一些最常见的隐患并显示如何避免它们。 以下为IBM文档中的一些内容。 隐患 1．忽略返回状态 第一个隐患很明显，但它是开发新手最容易犯的一个错误。如果您忽略函数的返回状态，当它们失败或部分成功的时候，您...
C/C++ tcp编程
吠鸟的博客
07-12 439
C/C++ tcp编程
C语言socket()函数解析（创建套接字）af地址族，ip地址类型（Address Family）INET（Inetnet）PF（Protocol Family）
Dontla的博客
03-20 1999
文章目录Linux 下的 socket() 函数1) af 为地址族（Address Family），也就是 IP 地址类型2) type 为数据传输方式/套接字类型3) protocol 表示传输协议在Windows下创建socket 不管是 Windows 还是 Linux，都使用 socket() 函数来创建套接字。socket() 在两个平台下的参数是相同的，不同的是返回值。 在《socket是什么》一节中我们讲到了 Windows 和 Linux 在对待 socket 方面的区别。 Linux 中
linux C/C++ socket编程
qq_37026934的博客
09-04 4442
socket
Linux使用C语言实现Socket编程
qq_61585528的博客
04-11 1783
Linux使用C语言实现Socket编程
在Linux中用C语言实现Socket通信
weixin_40763897的博客
01-28 2220
stdio.h ： 这个文件头文件是标准的输入输出，StandardInputOutput。这个头文件主要涉及文件相关的输入输出操作。典型的方法printf() ， scanf()，getc(), putc()。怎么理解这里文件呢？在Linux，有一个基本的原则，键盘、显示等这些操作都会作为文件来对待。事实上，键盘输入是默认的stdin文件流，显示输出是默认的stdout文件流。StandardL。
Linux C/C++ Socket 编程
最新发布
Jackey_Song的博客
11-11 1434
null null null null
linux 网络编程socket
Qurry的博客
01-27 4456
Socket=（IP地址：端口号），套接字的表示方法是点分十进制的lP地址后面写上端口号，中间用冒号或逗号隔开。每一个传输层连接唯一地被通信两端的两个端点所确定。
Linux下的C语言Socket编程初学者指南
"C语言SOCKET编程指南是一个针对Linux平台的socket基础开发教程，适合初学者，涵盖了从基本概念到实际编程的各种知识点，包括socket的创建、连接、监听、接受、发送和接收数据等核心函数的使用。" 本文档旨在为初学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值