【Linux C socket】tcp socket 数据传输 简单示例

最新推荐文章于 2024-01-28 17:48:12 发布
最新推荐文章于 2024-01-28 17:48:12 发布
阅读量254 收藏 1
点赞数
文章标签： linux tcp/ip c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Loteria/article/details/129396319
版权

几种收发示例

1) 1 server – 1 client

仅有一条字符串消息（server收，client发）

server

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

#define BUF_LEN 32

int main(int argc, char *argv[])
{
    int server_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (server_fd < 0) {
        printf("create socket failed, errno : %s\n", strerror(errno));
        return -1;
    }

    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt));

    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(9000);    // port of server
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) != 0) {
        printf("bind failed, errno : %s\n", strerror(errno));
        return -1;
    }

    if (listen(server_fd, 1) != 0) {    // second param is max client num
        printf("listen failed, errno : %s\n", strerror(errno));
        return -1;
    }

    int sockaddr_in_size = sizeof(struct sockaddr_in);
    struct sockaddr_in client_addr;
    int client_fd = accept(server_fd, (struct sockaddr *)(&client_addr), (socklen_t *)(&sockaddr_in_size));
    if (client_fd < 0) {
        printf("accept failed, errno : %s\n", strerror(errno));
        return -1;
    }
    printf("accept succeed, [ip]:[port] is [%s]:[%d]\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

    char buf[BUF_LEN];
    memset(buf, 0, BUF_LEN);
    int recv_len = recv(client_fd, buf, BUF_LEN, 0);
    if (recv_len == 0) {
        printf("client closed abnormally, errno : %s\n", strerror(errno));
        return -1;
    } else if (recv_len < 0) {
        printf("recv data failed, errno : %s\n", strerror(errno));
        return -1;
    }
    printf("received data is : [%s]\n", buf);

    close(server_fd);
    return 0;
}

client

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

#define BUF_LEN 32

int main(int argc, char *argv[])
{
    int client_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (client_fd < 0) {
        printf("create socket failed, errno : %s\n", strerror(errno));
        return -1;
    }

    int opt = 1;
    setsockopt(client_fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt));

    struct sockaddr_in client_addr;
    bzero(&client_addr, sizeof(struct sockaddr_in));
    client_addr.sin_family = AF_INET;
    client_addr.sin_addr.s_addr = inet_addr("192.168.1.11");    // ip of client
    client_addr.sin_port = htons(9500);    // port of client
    if (bind(client_fd, (struct sockaddr *)&client_addr, sizeof(struct sockaddr)) != 0) {
        printf("bind failed, errno : %s\n", strerror(errno));
        return -1;
    }

    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr("192.168.1.10");    // ip of client
    server_addr.sin_port = htons(9000);    // port of server
    if (connect(client_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) != 0) {
        printf("connect failed, errno : %s\n", strerror(errno));
        return -1;
    }

    char buf[BUF_LEN];
    memset(buf, 0, BUF_LEN);
    snprintf(buf, BUF_LEN, "client fd is %d", client_fd);
    if (send(client_fd, buf, BUF_LEN, 0) <= 0) {
        printf("send data failed, errno : %s\n", strerror(errno));
        return -1;
    }

	sleep(1);
    close(client_fd);
    return 0;
}

循环发送多条数据（server收，client发）

server

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

#define BUF_LEN 32

struct Data {
    char ip_addr[BUF_LEN];
    int port;
};

int main(int argc, char *argv[])
{
    int server_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (server_fd < 0) {
        printf("create socket failed, errno : %s\n", strerror(errno));
        return -1;
    }

    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt));

    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(9000);    // port of server
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) != 0) {
        printf("bind failed, errno : %s\n", strerror(errno));
        return -1;
    }

    if (listen(server_fd, 1) != 0) {    // second param is max client num
        printf("listen failed, errno : %s\n", strerror(errno));
        return -1;
    }

    int sockaddr_in_size = sizeof(struct sockaddr_in);
    struct sockaddr_in client_addr;
    int client_fd = accept(server_fd, (struct sockaddr *)(&client_addr), (socklen_t *)(&sockaddr_in_size));
    if (client_fd < 0) {
        printf("accept failed, errno : %s\n", strerror(errno));
        return -1;
    }
    printf("accept succeed, [ip]:[port] is [%s]:[%d]\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

    while (1) {
        struct Data recv_data;
        memset(&recv_data, 0, sizeof(struct Data));
        int recv_len = recv(client_fd, &recv_data, sizeof(struct Data), 0);
        if (recv_len == 0) {
            printf("client closed abnormally, errno : %s\n", strerror(errno));
            return -1;
        } else if (recv_len < 0) {
            printf("recv data failed, errno : %s\n", strerror(errno));
            return -1;
        }
        printf("received data is : [%s][%d]\n", recv_data.ip_addr, recv_data.port);
    }

    close(server_fd);
    return 0;
}

client

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

#define BUF_LEN 32

struct Data {
    char ip_addr[BUF_LEN];
    int port;
};

int main(int argc, char *argv[])
{
    int client_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (client_fd < 0) {
        printf("create socket failed, errno : %s\n", strerror(errno));
        return -1;
    }

    int opt = 1;
    setsockopt(client_fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt));

    struct sockaddr_in client_addr;
    bzero(&client_addr, sizeof(struct sockaddr_in));
    client_addr.sin_family = AF_INET;
    client_addr.sin_addr.s_addr = inet_addr("192.168.1.11");    // ip of client
    client_addr.sin_port = htons(9500);    // port of client
    if (bind(client_fd, (struct sockaddr *)&client_addr, sizeof(struct sockaddr)) != 0) {
        printf("bind failed, errno : %s\n", strerror(errno));
        return -1;
    }

    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr("192.168.1.10");    // ip of server
    server_addr.sin_port = htons(9000);    // port of server
    if (connect(client_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) != 0) {
        printf("connect failed, errno : %s\n", strerror(errno));
        return -1;
    }

    while (1) {
        struct Data recv_data = { "192.168.1.11", 9500 };
        if (send(client_fd, &recv_data, sizeof(struct Data), 0) <= 0) {
            printf("send data failed, errno : %s\n", strerror(errno));
            return -1;
        }
        sleep(1);
    }

	sleep(1);
    close(client_fd);
    return 0;
}

server和client均可收发

server

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

#define BUF_LEN       32

struct Data {
    char ip_addr[BUF_LEN];
    int port;
};

int client_fd = 0;

void *recvThread(void *client_fd)
{
    int _client_fd = *((int *)client_fd);
    while (1) {
        struct Data recv_data;
        memset(&recv_data, 0, sizeof(struct Data));
        int recv_len = recv(_client_fd, &recv_data, sizeof(struct Data), 0);
        if (recv_len == 0) {
            printf("client closed abnormally, errno : %s\n", strerror(errno));
            pthread_exit(NULL);
        } else if (recv_len < 0) {
            printf("recv data failed, errno : %s\n", strerror(errno));
            pthread_exit(NULL);
        }
        printf("received data is : [%s][%d]\n", recv_data.ip_addr, recv_data.port);
    }
    pthread_exit(NULL);
}

void *acceptThread(void *server_fd)
{
    pthread_t thrRecv[CLIENT_NUM];
    int client_count = 0;
    while (1) {
        int _server_fd = *((int *)server_fd);
        int sockaddr_in_size = sizeof(struct sockaddr_in);
        struct sockaddr_in client_addr;
        client_fd = accept(_server_fd, (struct sockaddr *)(&client_addr), (socklen_t *)(&sockaddr_in_size));
        if (client_fd < 0) {
            printf("accept failed, errno : %s\n", strerror(errno));
            pthread_exit(NULL);
        }
        printf("accept succeed, [ip]:[port] is [%s]:[%d]\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

        thrRecv[client_count] = 0;
        pthread_create(&thrRecv[client_count], NULL, recvThread, &client_fd);
        pthread_join(thrRecv[client_count], NULL);
        client_count++;
    }
    pthread_exit(NULL);
}

int main(int argc, char *argv[])
{
    int server_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (server_fd < 0) {
        printf("create socket failed, errno : %s\n", strerror(errno));
        return -1;
    }

    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt));

    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(9000);    // port of server
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) != 0) {
        printf("bind failed, errno : %s\n", strerror(errno));
        return -1;
    }

    if (listen(server_fd, 1) != 0) {    // second param is max client num
        printf("listen failed, errno : %s\n", strerror(errno));
        return -1;
    }

    pthread_t thrAccept = 0;
    pthread_create(&thrAccept, NULL, acceptThread, &server_fd);

    while (1) {
        char send_buf[BUF_LEN] = "Msg from server.";
        while (client_fd == 0) { sleep(1); }
        if (send(client_fd, send_buf, BUF_LEN, 0) <= 0) {
            printf("send failed, errno : %s\n", strerror(errno));
            return -1;
        }
        sleep(1);
    }

    pthread_join(thrAccept, NULL);

    close(server_fd);
    return 0;
}

client

#include <stdio.h>
#include <sys/socket.h>
#include <errno.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

#define BUF_LEN 32

struct Data {
    char ip_addr[BUF_LEN];
    int port;
};

void *recvThread(void *client_fd)
{
    int _client_fd = *((int *)client_fd);
    while (1) {
        char recv_buf[BUF_LEN];
        memset(recv_buf, 0, BUF_LEN);
        int recv_len = recv(_client_fd, recv_buf, BUF_LEN, 0);
        if (recv_len == 0) {
            printf("server closed abnormally, errno : %s\n", strerror(errno));
            pthread_exit(NULL);
        } else if (recv_len < 0) {
            printf("recv data failed, errno : %s\n", strerror(errno));
            pthread_exit(NULL);
        }
        printf("received data is : [%s]\n", recv_buf);
    }
    pthread_exit(NULL);
}

int main(int argc, char *argv[])
{
    char client_ip[BUF_LEN];
    char server_ip[BUF_LEN];
    memcpy(client_ip, argv[1], strlen(argv[1]));
    memcpy(server_ip, argv[2], strlen(argv[2]));

    int client_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (client_fd < 0) {
        printf("create socket failed, errno : %s\n", strerror(errno));
        return -1;
    }

    int opt = 1;
    setsockopt(client_fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt));

    struct sockaddr_in client_addr;
    bzero(&client_addr, sizeof(struct sockaddr_in));
    client_addr.sin_family = AF_INET;
    client_addr.sin_addr.s_addr = inet_addr(client_ip);    // ip of client
    // client_addr.sin_addr.s_addr = inet_addr("192.168.1.11");    // ip of client
    client_addr.sin_port = htons(9500);    // port of client
    if (bind(client_fd, (struct sockaddr *)&client_addr, sizeof(struct sockaddr)) != 0) {
        printf("bind failed, errno : %s\n", strerror(errno));
        return -1;
    }

    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(server_ip);    // ip of server
    // server_addr.sin_addr.s_addr = inet_addr("192.168.1.10");    // ip of server
    server_addr.sin_port = htons(9000);    // port of server
    if (connect(client_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) != 0) {
        printf("connect failed, errno : %s\n", strerror(errno));
        return -1;
    }

    pthread_t thrRecv = 0;
    pthread_create(&thrRecv, NULL, recvThread, &client_fd);

    while (1) {
        struct Data recv_data = { "192.168.1.11", 9500 };
        if (send(client_fd, &recv_data, sizeof(struct Data), 0) <= 0) {
            printf("send data failed, errno : %s\n", strerror(errno));
            return -1;
        }
        sleep(1);
    }

	sleep(1);
    close(client_fd);
    return 0;
}

2) 1 server – n client

server

#include <stdio.h>
#include <sys/socket.h>
#include <errno.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

#define BUF_LEN       32
#define CLIENT_NUM    5

struct Data {
    char ip_addr[BUF_LEN];
    int port;
};

void *recvThread(void *client_fd)
{
    int _client_fd = *((int *)client_fd);
    while (1) {
        struct Data recv_data;
        memset(&recv_data, 0, sizeof(struct Data));
        int recv_len = recv(_client_fd, &recv_data, sizeof(struct Data), 0);
        if (recv_len == 0) {
            printf("client closed abnormally, errno : %s\n", strerror(errno));
            pthread_exit(NULL);
        } else if (recv_len < 0) {
            printf("recv data failed, errno : %s\n", strerror(errno));
            pthread_exit(NULL);
        }
        printf("received data is : [%s][%d]\n", recv_data.ip_addr, recv_data.port);
    }
    pthread_exit(NULL);
}

void *acceptThread(void *server_fd)
{
    pthread_t thrRecv[CLIENT_NUM];
    int client_count = 0;
    while (1) {
        int _server_fd = *((int *)server_fd);
        int sockaddr_in_size = sizeof(struct sockaddr_in);
        struct sockaddr_in client_addr;
        int client_fd = accept(_server_fd, (struct sockaddr *)(&client_addr), (socklen_t *)(&sockaddr_in_size));
        if (client_fd < 0) {
            printf("accept failed, errno : %s\n", strerror(errno));
            pthread_exit(NULL);
        }
        printf("accept succeed, [ip]:[port] is [%s]:[%d]\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

        thrRecv[client_count] = 0;
        pthread_create(&thrRecv[client_count], NULL, recvThread, &client_fd);
        pthread_join(thrRecv[client_count], NULL);
        client_count++;
    }
    pthread_exit(NULL);
}

int main(int argc, char *argv[])
{
    int server_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (server_fd < 0) {
        printf("create socket failed, errno : %s\n", strerror(errno));
        return -1;
    }

    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt));

    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(9000);    // port of server
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) != 0) {
        printf("bind failed, errno : %s\n", strerror(errno));
        return -1;
    }

    if (listen(server_fd, CLIENT_NUM) != 0) {    // second param is max client num
        printf("listen failed, errno : %s\n", strerror(errno));
        return -1;
    }

    pthread_t thrAccept = 0;
    pthread_create(&thrAccept, NULL, acceptThread, &server_fd);
    pthread_join(thrAccept, NULL);

    close(server_fd);
    return 0;
}

client

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

#define BUF_LEN 32

struct Data {
    char ip_addr[BUF_LEN];
    int port;
};

// ./client <client_ip> <server_ip>
int main(int argc, char *argv[])
{
    char client_ip[BUF_LEN];
    char server_ip[BUF_LEN];
    memcpy(client_ip, argv[1], strlen(argv[1]));
    memcpy(server_ip, argv[2], strlen(argv[2]));

    int client_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (client_fd < 0) {
        printf("create socket failed, errno : %s\n", strerror(errno));
        return -1;
    }

    int opt = 1;
    setsockopt(client_fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt));

    struct sockaddr_in client_addr;
    bzero(&client_addr, sizeof(struct sockaddr_in));
    client_addr.sin_family = AF_INET;
    client_addr.sin_addr.s_addr = inet_addr(client_ip);    // ip of client
    // client_addr.sin_addr.s_addr = inet_addr("192.168.1.11");    // ip of client
    client_addr.sin_port = htons(9500);    // port of client
    if (bind(client_fd, (struct sockaddr *)&client_addr, sizeof(struct sockaddr)) != 0) {
        printf("bind failed, errno : %s\n", strerror(errno));
        return -1;
    }

    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(struct sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr(server_ip);    // ip of server
    // server_addr.sin_addr.s_addr = inet_addr("192.168.1.10");    // ip of server
    server_addr.sin_port = htons(9000);    // port of server
    if (connect(client_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) != 0) {
        printf("connect failed, errno : %s\n", strerror(errno));
        return -1;
    }

    while (1) {
        struct Data recv_data;
        recv_data.port = 9500;
        memcpy(recv_data.ip_addr, client_ip, BUF_LEN);
        if (send(client_fd, &recv_data, sizeof(struct Data), 0) <= 0) {
            printf("send data failed, errno : %s\n", strerror(errno));
            return -1;
        }
        sleep(1);
    }

	sleep(1);
    close(client_fd);
    return 0;
}
Loteria
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在C中使用Socket实现多线程异步TCP消息发送
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
08-17 2291
详细介绍了在C中使用Socket实现多线程异步TCP消息发送。欢迎点赞收藏。谢谢
Socket 完整发送和高效接受数据流
m0_62197239的博客
01-03 2263
•readIdx表示读取位置；length表示缓冲区中数据长度。
Linux C语言网络编程(学习笔记二)：socket实现网络通信(tcp和udp)
ssz__的博客
04-25 4476
在日常应用中有很多关于socket网络通信的例子，例如局域网内打游戏，使用浏览器看视频，用QQ软件聊天等。可以说socket是底层抽象给应用层所使用的一套接口。网络通信的传输方式有两种，一种是基于TCP（数据可靠传输）,另一种是基于UDP（数据不可靠，一般用于实时视频传输）。
Linux下C语言实现TCP Socket编程
一步两步先生的博客
01-16 6697
TCP协议： TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的运输层（Transport layer）通信协议。 TCP服务器端和客户端流程： 具体函数： 具体实现： 服务器端： ser.c #include&lt;stdio.h&gt; #inc...
在Linux中用C语言实现Socket通信
最新发布
weixin_40763897的博客
01-28 1701
stdio.h ： 这个文件头文件是标准的输入输出，StandardInputOutput。这个头文件主要涉及文件相关的输入输出操作。典型的方法printf() ， scanf()，getc(), putc()。怎么理解这里文件呢？在Linux，有一个基本的原则，键盘、显示等这些操作都会作为文件来对待。事实上，键盘输入是默认的stdin文件流，显示输出是默认的stdout文件流。StandardL。
Linux下基于socket TCP的文件传输.zip
01-18
本文件压缩包包含了一份关于Linux下如何使用TCP socket进行文件传输的教程以及客户端和服务器端的源代码示例。 首先，我们来看“Linux下基于TCP的文件传输.doc”文档，该文档应该详细阐述了TCP文件传输的原理和步骤...
服务端向多客户端通信_C语言_sockettcp_socket_tcp_linux_
10-01
本教程将探讨如何使用C语言通过TCP Socket实现服务端与多个客户端之间的通信，特别是在Linux操作系统环境下。TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，常用于实现设备间的稳定...
Linux网络编程之socket文件传输示例
09-04
本示例主要展示了如何使用C语言通过Socket API 实现文件在客户端和服务器之间的传输，尤其对于Linux平台的C程序员具有实际指导意义。这里我们将深入探讨相关知识点： 1. **Socket 基础**： - Socket 是网络通信中...
C语言编写基于TCP和UDP协议的Socket通信程序示例
09-02
总结起来，C语言中的TCP和UDP Socket编程涉及到创建套接字、设置地址结构体、绑定、监听（TCP独有）、接收连接（TCP独有）、多线程处理（TCP示例中用于并发处理）以及数据的发送和接收。了解这些基础知识对于开发...
Linux C编程 socket——Tcp编程
weixin_43790540的博客
02-09 340
Linux C编程 socket——Tcp编程1、网络中的进程之间如何通信（socket套接字）2、什么是TCP/IP 、UDP3.Tcp编程的系统函数socket函数bind()函数网络字节序和主机字节序listen()、connect()函数accept()函数read()、write()等函数close 函数Tcp中建立链接的三次握手Tcp终止链接（四次握手释放）编程示例（tcp_serve...
Linux C Socket TCP编程介绍及实例
热门推荐
Leon
11-25 2万+
1、TCP网络编程主要流程 图1.1 注意：图1.1中可以看到close指向read并且标有结束连接的指示，可能有些人会有疑问，这个标注的意思是服务器在处理客户端的时候是循环读取的，如果客户端没有发送数据服务器处理客户端的线程是阻塞在read这里的，当客户端调用close后，服务器read就会立刻返回-1，这时服务器处理线程才会继续向下执行。如果客户端没有执行close而是直接异常退出，
1、Linux中的socket与TCP通信
qq_44918555的博客
07-26 1947
Linux网络编程的socket以及tcp通信
LINUX利用socket多线程文件传输,Linux C TCPSocket 传输文件简单实例-多线程实现
weixin_29721821的博客
05-09 739
在Linux下使用C语言TCPSocket实现简单文件传输，包括客户端和服务器端，其中，服务器端使用多线程实现同时接收多个客户端发送的文件。发送文件内容之前，首先需要将文件名和长度信息发送到服务器，为了便于区分，采用发送结构体的方式，设置标志位，1标识数据域为文件名，2标识数据域为文件内容，3标识发送结束，4标识发送文件长度。这样便可区分发送的内容。服务器端代码如下：/*多线程实现接收多个客户端的...
c语言tcp编程
测试
05-22 689
C语言tcp编程，Linux系统实现下面是TCP通信的demo： ##服务器端123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869...
linux c tcp 传输文件,Linux下使用socket传输文件的C语言简单实现
weixin_29807507的博客
04-29 439
简单的C语言实现，客户端通过TCP协议向服务器端请求传输的文件，服务器端收到请求后向客户端发送文件。服务器程序和客户端程序应当分别运行在两台计算机上。在运行服务器端的计算机终端执行：./file_server在运行客户端的计算终端上执行：./file_client ipaddr_server然后根据提示输入要传输的服务器上的文件，该文件必须在服务器的当前运行目录中，否则会提示找不到文件。直接上...
TCP协议发送和接收数据:基于TCP的Socket编程
qq_42383970的博客
06-19 8248
服务器端：在服务器端，创建一个ServerSocket对象，并指定一个端号，使用ServerSocket类的accept()方法使服务器处于阻塞状态，等待用户请求。接收: 创建TCP服务端的Socket对象 监听客户端对象 获取输入流，读取数据 释放资源客户端:通过指定一个InetAddress对象和一个端口号，创建一个Socket对象，通过这个对象，连接到服务器。 发送: 创建...
Linux C语言的Socket编程例子（TCP和UDP）
廖阿明的博客
06-04 1899
     套接字是一种进程间的通信的方法，不同于以往介绍的进程间通信方法的是，它并不局限于同一台计算机的资源，例如文件系统空间，共享内存或者消息队列。套接字可以认为是对管道概念的扩展——一台机器上的进程可以使用套接字与另一台机器上的进程通信。因此客户与服务器可以分散在网络中。同一台机器上的进程间也可以用套接字通信。套接字是一种通信机制，客户/服务器系统既可以在本地单机上运行，也可以在网络中运行。套...
linux下 socket tcp Server c语言编写（分别实现单进程，多进程，多线程）
wejack的专栏
09-28 1868
linux下socket tcp server c语言编写单进程、多进程、多线程三种实现
使用 Chrome.socket API 进行网络数据传输
以下是一个简单的示例代码，演示如何使用 Chrome Socket API 创建一个 TCP 套接字并连接到一个服务器： ```javascript chrome.socket.create('tcp', {}, function(socketId) { chrome.socket.connect(socketId, '...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值