精华内容
下载资源
问答
  • TCP服务器

    千次阅读 2018-06-28 16:44:58
    (1)创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器) int socket(int domain, int type, int protocol); socket()打开⼀个网络通讯端口,如果成功的话就像open()⼀样返回⼀个文件描述符 应⽤程序可以像读写...

    所需API如下:
    (1)创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
    int socket(int domain, int type, int protocol);

    • socket()打开⼀个网络通讯端口,如果成功的话就像open()⼀样返回⼀个文件描述符
    • 应⽤程序可以像读写⽂件⼀样用read/write在网络上收发数据
    • 如果socket()调用出错则返回-1
    • 对于IPv4, family参数指定为AF_INET
    • 对于TCP协议,type参数指定为SOCK_STREAM,表示面向字节流的传输协议
    • protocol参数指定为0即可

    (2)绑定端口号 (TCP/UDP, 服务器)
    int bind(int socket, const struct sockaddr *address, socklen_t address_len);

    • 服务器程序所监听的网络地址和端口号通常是固定不变的,客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接;服务器需要调⽤bind绑定⼀个固定的网络地址和端口号
    • bind()成功返回0,失败返回-1
    • bind()的作用是将参数socket和address绑定在⼀起, 使socket这个用于网络通讯的文件描述符监听address所描述的地址和端口号
    • struct sockaddr *是⼀个通用指针类型,address参数实际上可以接受多种协议的sockaddr结构体,而它们的长度各不相同,所以需要第三个参数address_len指定结构体的⻓度

    (3)开始监听socket (TCP, 服务器)
    int listen(int socket, int backlog);

    • listen()声明socket处于监听状态,并且最多允许有backlog个客户端处于连接等待状态,如果接收到更多的连接请求就忽略,这里设置不会太⼤(⼀般是5)
    • listen()成功返回0,失败返回-1

    (4)接收请求 (TCP, 服务器)
    int accept(int socket, struct sockaddr* address, socklen_t* address_len);

    • 三次握⼿完成后,服务器调⽤accept()接受连接
    • 如果服务器调用accept()时还没有客户端的连接请求,就阻塞等待直到有客户端连接上来
    • address是⼀个传出参数,accept()返回时传出客户端的地址和端⼝号
    • 如果给address参数传NULL,表示不关心客户端的地址;
    • address_len参数是⼀个传⼊传出参数(value-result argument),传⼊的是调⽤者提供的,缓冲区address的长度以避免缓冲区溢出问题,传出的是客户端地址结构体的实际⻓度(有可能没有占满调⽤者提供的缓冲区)

    (5)建立连接 (TCP, 客户端)
    int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

    • 客户端需要调⽤connect()连接服务器
    • connect和bind的参数形式⼀致,区别在于bind的参数是自己的地址,而connect的参数是对方的地址
    • connect()成功返回0,出错返回-1

    server.c

    ///////////////////////////////////////////////////////////////
    //服务器基本流程:
    //1.从socket中读取数据(Request)
    //2.根据 Request 计算生成 Response
    //3.把 Response 写回客户端
    //由于目前实现的是 echo_server, 计算生成 Response 步骤就省略了
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    
    typedef struct sockaddr sockaddr;
    typedef struct sockaddr_in sockaddr_in;
    
    void ProcessConnect(int new_sock){
        //完成一次连接的处理
        //需要循环的来处理客户端发送的数据
        while(1){
            //子进程
            //a)从客户端读取数据
            char buf[1024] = {0};
            ssize_t read_size = read(new_sock, buf, sizeof(buf) - 1);
            if(read_size < 0){
                perror("read");
                continue;
            }
            if(read_size == 0){
                //TCP中,如果read的返回值是0,说明对端关闭了连接
                printf("[client %d] disconnect!\n", new_sock);
                close(new_sock);
                return;
            }
            buf[read_size] = '\0';
            //b)根据请求计算响应(省略)
            printf("[client %d] %s\n", new_sock, buf);
            //c)把响应写回到客户端
            write(new_sock, buf, strlen(buf));
        }
    }
    
    //./server [ip] [port]
    int main(int argc, char* argv[]){
        if(argc != 3){
            printf("Usage ./server [ip] [port]\n");
            return 1;
        }
        //1.创建 socket
        int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
        if(listen_sock < 0){
            perror("socket");
            return 1;
        }
        //2.绑定端口号
        sockaddr_in server;
        server.sin_family = AF_INET;
        server.sin_addr.s_addr = inet_addr(argv[1]);
        server.sin_port = htons(atoi(argv[2]));
        int ret = bind(listen_sock, (sockaddr*)&server, sizeof(server));
        if(ret < 0){
            perror("bind");
            return 1;
        }
        //3.使用 listen 允许服务器被客户端连接
        ret = listen(listen_sock, 5);
        if(ret < 0){
            perror("listen");
            return 1;
        }
        //4.服务器初始化完成,进入事件循环
        printf("Server Init OK!\n");
        while(1){
            //把小板凳上的顾客请到屋里吃饭
            sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int new_sock = accept(listen_sock, (sockaddr*)&peer, &len);
            if(new_sock < 0){
                perror("accept");
                continue;
            }
            printf("[client %d] connect!\n", new_sock);
            ProcessConnect(new_sock);
        }
        return 0;
    }

    描述

    client.c

    /////////////////////////////////////////////////////////////
    //1.从标准输入读入字符串
    //2.把读入的字符串发送给服务器
    //3.尝试从服务器读取响应数据
    //4.把响应结果打印到标准输出上
    ////////////////////////////////////////////////////////////
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    
    typedef struct sockaddr sockaddr;
    typedef struct sockaddr_in sockaddr_in;
    
    int main(int argc, char* argv[]){
        if(argc != 3){
            printf("Usage ./server [ip] [port]\n");
            return 1;
        }
        //1.创建 socket
        int fd = socket(AF_INET, SOCK_STREAM, 0);
        if(fd < 0){
            perror("socket");
            return 1;
        }
        //2.获取连接
        sockaddr_in server_addr;
        server_addr.sin_family = AF_INET;
        server_addr.sin_addr.s_addr = inet_addr(argv[1]);
        server_addr.sin_port = htons(atoi(argv[2]));
        int ret = connect(fd, (sockaddr*)&server_addr, sizeof(server_addr));
        if(ret < 0){
            perror("connect");
            return 1;
        }
        //3.进入循环
        while(1){
            //a)从标准输入读入字符串
            char buf[1024] = {0};
            ssize_t read_size = read(0, buf, sizeof(buf) - 1);
            if(read_size < 0){
                perror("read");
                return 1;
            }
            if(read_size == 0){
                printf("read done!\n");
                return 0;
            }
            buf[read_size] = '\0';
            //b)把读入的字符串发送给服务器
            write(fd, buf, strlen(buf));
            //c)尝试从服务器读取响应数据
            char buf_resp[1024] = {0};
            read_size = read(fd, buf_resp, sizeof(buf_resp) - 1);
            if(read_size < 0){
                perror("read");
                return 1;
            }
            if(read_size == 0){
                printf("server close socket!\n");
                return 0;
            }
            buf_resp[read_size] = '\0';
            //d)把响应结果打印到标准输出上
            printf("server resp: %s\n", buf_resp);
        }
        return 0;
    }

    由于客户端不需要固定的端⼝号,因此不必调⽤bind(),客户端的端⼝号由内核⾃动分配
    注意:

    • 客户端不是不允许调⽤bind(),只是没有必要调⽤bind()固定⼀个端⼝号。否则如果在同⼀台机器上启动多个客户端, 就会出现端⼝号被占⽤导致不能正确建⽴连接;
    • 服务器也不是必须调⽤bind(),但如果服务器不调⽤bind(),内核会⾃动给服务器分配监听端⼝,每次启动服务器时端⼝号都不⼀样,客户端要连接服务器就会遇到⿇烦
      描述

    若再启动⼀个客户端,尝试连接服务器,发现第⼆个客户端不能正确的和服务器进⾏通信。
    分析原因:是因为我们accept了⼀个请求之后就在⼀直while循环尝试read,没有继续调⽤到accept,导致不能接受新的请求。
    改进方法有两个,可以采用多进程和多线程版本。

    server_fork.c

    ///////////////////////////////////////////////////////////////
    //服务器基本流程:
    //1.从socket中读取数据(Request)
    //2.根据 Request 计算生成 Response
    //3.把 Response 写回客户端
    //由于目前实现的是 echo_server, 计算生成 Response 步骤就省略了
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/wait.h>
    #include <sys/socket.h>
    #include <signal.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    
    typedef struct sockaddr sockaddr;
    typedef struct sockaddr_in sockaddr_in;
    
    void ProcessConnect(int new_sock, sockaddr_in* peer){
        ////////////////////////////////////////////////////////////
        //在这个函数中进行创建子进程来处理客户端的请求
        ////////////////////////////////////////////////////////////
        //完成一次连接的处理
        //需要循环的来处理客户端发送的数据
        while(1){
            int ret = fork();
            if(ret < 0){
                perror("fork");
                return;
            }
            if(ret > 0){
                //父进程
                //此处一定要考虑到僵尸进程的问题
                //此处使用wait和waitpid都是不行的
                //比较简单的方案就是忽略SIGCHLD信号
                signal(SIGCHLD, SIG_IGN);
                //此处还需要注意!!!
                //文件描述符需要父子进程都关闭
                close(new_sock);
                return;
            }
            //子进程
            //a)从客户端读取数据
            char buf[1024] = {0};
            ssize_t read_size = read(new_sock, buf, sizeof(buf) - 1);
            if(read_size < 0){
                perror("read");
                continue;
            }
            if(read_size == 0){
                //TCP中,如果read的返回值是0,说明对端关闭了连接
                printf("[client %s:%d] disconnect!\n", inet_ntoa(peer->sin_addr), ntohs(peer->sin_port));
                close(new_sock);
                //此处需要注意!!!
                //不能直接让函数返回,而是让子进程直接退出
                //如果是函数返回,子进程接下来也会尝试进行 accept
                //这样的动作是没有必要的,父进程已经负责了 accept
                //子进程只要做好自己的事情,把对应的客户端服务好就可以了
                exit(0);
            }
            buf[read_size] = '\0';
            //b)根据请求计算响应(省略)
            printf("[client %s:%d] %s\n", inet_ntoa(peer->sin_addr), ntohs(peer->sin_port),  buf);
            //c)把响应写回到客户端
            write(new_sock, buf, strlen(buf));
        }
    }
    
    //./server [ip] [port]
    int main(int argc, char* argv[]){
        if(argc != 3){
            printf("Usage ./server [ip] [port]\n");
            return 1;
        }
        //1.创建 socket
        int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
        if(listen_sock < 0){
            perror("socket");
            return 1;
        }
        //2.绑定端口号
        sockaddr_in server;
        server.sin_family = AF_INET;
        server.sin_addr.s_addr = inet_addr(argv[1]);
        server.sin_port = htons(atoi(argv[2]));
        int ret = bind(listen_sock, (sockaddr*)&server, sizeof(server));
        if(ret < 0){
            perror("bind");
            return 1;
        }
        //3.使用 listen 允许服务器被客户端连接
        ret = listen(listen_sock, 5);
        if(ret < 0){
            perror("listen");
            return 1;
        }
        //4.服务器初始化完成,进入事件循环
        printf("Server Init OK!\n");
        while(1){
            //把小板凳上的顾客请到屋里吃饭
            sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int new_sock = accept(listen_sock, (sockaddr*)&peer, &len);
            if(new_sock < 0){
                perror("accept");
                continue;
            }
            printf("[client %s:%d] connect!\n", inet_ntoa(peer.sin_addr), ntohs(peer.sin_port));
            ProcessConnect(new_sock, &peer);
        }
        return 0;
    }

    客户端1
    客户端2
    服务器端

    server_thread.c

    ///////////////////////////////////////////////////////////////
    //服务器基本流程:
    //1.从socket中读取数据(Request)
    //2.根据 Request 计算生成 Response
    //3.把 Response 写回客户端
    //由于目前实现的是 echo_server, 计算生成 Response 步骤就省略了
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <pthread.h>
    
    typedef struct sockaddr sockaddr;
    typedef struct sockaddr_in sockaddr_in;
    
    void* ThreadEntry(void* arg){
        int64_t new_sock = (int64_t)arg;
        while(1){
            //a)从客户端读取数据
            char buf[1024] = {0};
            ssize_t read_size = read(new_sock, buf, sizeof(buf) - 1);
            if(read_size < 0){
                perror("read");
                continue;
            }
            if(read_size == 0){
                //TCP中,如果read的返回值是0,说明对端关闭了连接
                printf("[client %lu] disconnect!\n", new_sock);
                close(new_sock);
                return NULL;
            }
            buf[read_size] = '\0';
            //b)根据请求计算响应(省略)
            printf("[client %lu] %s\n", new_sock, buf);
            //c)把响应写回到客户端
            write(new_sock, buf, strlen(buf));
        }
        return NULL;
    }
    
    void ProcessConnect(int64_t new_sock){
        //////////////////////////////////////////////////////
        //此处需要创建线程来完成和客户端的交互
        //////////////////////////////////////////////////////
        //完成一次连接的处理
        //需要循环的来处理客户端发送的数据
        pthread_t tid;
        pthread_create(&tid, NULL, ThreadEntry, (void*)new_sock);
        pthread_detach(tid);
    }
    
    //./server [ip] [port]
    int main(int argc, char* argv[]){
        if(argc != 3){
            printf("Usage ./server [ip] [port]\n");
            return 1;
        }
        //1.创建 socket
        int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
        if(listen_sock < 0){
            perror("socket");
            return 1;
        }
        //2.绑定端口号
        sockaddr_in server;
        server.sin_family = AF_INET;
        server.sin_addr.s_addr = inet_addr(argv[1]);
        server.sin_port = htons(atoi(argv[2]));
        int ret = bind(listen_sock, (sockaddr*)&server, sizeof(server));
        if(ret < 0){
            perror("bind");
            return 1;
        }
        //3.使用 listen 允许服务器被客户端连接
        ret = listen(listen_sock, 5);
        if(ret < 0){
            perror("listen");
            return 1;
        }
        //4.服务器初始化完成,进入事件循环
        printf("Server Init OK!\n");
        while(1){
            //把小板凳上的顾客请到屋里吃饭
            sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int new_sock = accept(listen_sock, (sockaddr*)&peer, &len);
            if(new_sock < 0){
                perror("accept");
                continue;
            }
            printf("[client %d] connect!\n", new_sock);
            ProcessConnect(new_sock);
        }
        return 0;
    }

    客户端1
    客户端2
    服务器端

    >详细代码请参考Git<

    展开全文
  • nodejs创建TCP服务器

    千次阅读 2018-01-03 22:21:34
    使用telnet连接TCP服务器3. 使用net创建TCP客户端 注意:步骤2和步骤3任选其一即可正文1.使用net模块创建TCP服务器 新建项目文件夹 新建tcp.js文件 var net = require('net');const PORT = 18001; const HOST =...

    说明:创建环境centos7

    主要步骤

    1. 使用net模块创建TCP服务器
    
    2. 使用telnet连接TCP服务器
    
    3. 使用net创建TCP客户端
    

    注意:步骤2和步骤3任选其一即可

    正文

    1.使用net模块创建TCP服务器

    新建项目文件夹

    新建tcp.js文件

    var net = require('net');
    
    const PORT = 18001;
    const HOST = '127.0.0.1';
    
    
    var clientHandler = function(socket){
    
        //客户端发送数据的时候触发data事件
      socket.on('data', function dataHandler(data) {//data是客户端发送给服务器的数据
        console.log(socket.remoteAddress, socket.remotePort, 'send', data.toString());
            //服务器向客户端发送消息
        socket.write('server received\n');
      });
    
        //当对方的连接断开以后的事件
      socket.on('close', function(){
        console.log(socket.remoteAddress, socket.remotePort, 'disconnected');
      })
    };
    
    //创建TCP服务器的实例
    //传入的参数是:监听函数clientHandler
    var app = net.createServer(clientHandler);
    
    app.listen(PORT, HOST);
    console.log('tcp server running on tcp://', HOST, ':', PORT);

    clientHandler工作原理:

    //当创建tcp服务后,把clientHandler添加到connection事件中

    //connection在当有客户端连接到服务器的时候触发

    //当connection触发以后,会执行clientHandler

    //传入的参数是socket实例

    node tcp.js             //启动服务器端

    2.使用telnet连接TCP服务器

    新建命令行窗口

    yum install telnet      //安装telnet
    telnet localhost 18001  //用telnet进行连接,启动客户端

    3.使用net创建TCP客户端

    新建tcpClient.js文件

    var net = require('net');
    
    const HOST = '127.0.0.1';
    const PORT = 18001;
    
    var tcpClient = net.Socket();
    
    tcpClient.connect(PORT, HOST, function(){
       console.log('connect success.');
       tcpClient.write('this is tcp client by Node.js');//服务器向客户端发送消息
    });
    
    //监听服务器端发过来的数据
    tcpClient.on('data', function(data){
       console.log('received: ', data.toString());
    });
    node tcpClient.js             //启动客户端
    展开全文
  • jmeter测试TCP服务器/模拟发送TCP请求

    千次阅读 2019-05-22 18:41:05
    jmeter测试TCP服务器/模拟发送TCP请求 jmeter测试TCP服务器,使用TCP采样器模拟发送TCP请求。 TCP采样器:打开一个到指定服务器的TCP / IP连接,然后发送指定文本并等待响应。 jmeter模拟发送TCP请求的方法: 1.新建...

    转载:https://blog.csdn.net/ytc15259815042/article/details/44219851

    jmeter测试TCP服务器/模拟发送TCP请求

    jmeter测试TCP服务器,使用TCP采样器模拟发送TCP请求。

    TCP采样器:打开一个到指定服务器的TCP / IP连接,然后发送指定文本并等待响应。

    jmeter模拟发送TCP请求的方法:

    1.新建线程组,然后在线程组中新建TCP采样器

    jmeter-tcp

    TCP采样器中填写服务器地址、端口和“要发送的文本”,其它选项根据需要选填:

    re_use connection表示重复发送连接请求

    close connection 关闭连接

    如果TCP请求需要用户名/密码,可以在登录配置中填写

    2.新建“察看结果树”监视器,查看发送的请求和响应的结果。如果需要发送16进制报文这个地方会失败。

    jmeter发送16进制TCP报文的方法:

    很多TCP服务器报文为16进制,并且多数不能转换成文本发送,而jmeter默认发送文本。

    jmeter.properties中修改tcp.handler=BinaryTCPClientImpl ,启动jmeter重新发送,抓包查看既是16进制的tcp报文。

    另一个方法:可以在工作台新建–非测试元件–Property Display,Property Display中修改jmeter.properties只对当前进程有效。

    转载请注明出处:6san.com
    原文地址: http://www.6san.com/716/

    展开全文
  • Netty一(TCP服务器

    千次阅读 2019-01-08 21:57:55
    Netty—TCP服务器 一.概述 Netty一个高性能IO工具包,主要用于开发HTTP服务器,HTTPS服务器,WebSocket服务器,TCP服务器,UDP服务器和在JVM管道。用Netty开发的服务器可单独运行(即:在main()函数里调用),不需要...

    Netty—TCP服务器

    一.概述

    Netty一个高性能IO工具包,主要用于开发HTTP服务器,HTTPS服务器,WebSocket服务器,TCP服务器,UDP服务器和在JVM管道。用Netty开发的服务器可单独运行(即:在main()函数里调用),不需要部署在类似tomcat的容器里。Netty使用单线程并发模型,并围绕非阻塞NIO设计,所以性能较高。

    二.TCP服务器

    public class NerryTcpServer {
    	public static void main(String[] args) {
    		EventLoopGroup group = new NioEventLoopGroup();
    		ServerBootstrap bootstrap = new ServerBootstrap();
    
    		bootstrap.group(group);
    		bootstrap.channel(NioServerSocketChannel.class);
    
    		bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
    			@Override
    			protected void initChannel(SocketChannel socketChannel) throws Exception {
    				socketChannel.pipeline().addLast(new NettyServerHandler());
    			}
    		});
    
    		try {
    			ChannelFuture channelFuture = bootstrap.bind(8899).sync();
    			channelFuture.channel().closeFuture().sync();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		} finally {
    			group.shutdownGracefully();
    		}
    	}
    }
    
    class NettyServerHandler extends SimpleChannelInboundHandler<String> {
    	@Override
    	protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
    		System.out.println("客户端消息:" + msg);
    		ctx.channel().writeAndFlush("服务器消息:hello word");
    	}
    
    	@Override
    	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    		super.exceptionCaught(ctx, cause);
    		cause.printStackTrace();
    		ctx.channel().close();
    	}
    }
    
    

    二.TCP客户端

    public class NettyTcpClient {
    	public static void main(String[] args) {
            EventLoopGroup group = new NioEventLoopGroup();
            Bootstrap bootstrap = new Bootstrap();
    
            bootstrap.group(group);
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.handler(new ChannelInitializer(){
    			@Override
    			protected void initChannel(Channel channel) throws Exception {
    				channel.pipeline().addLast(new NettyClientHandler());
    			}        	
            });
    
            try {
                ChannelFuture channelFuture = bootstrap.connect("localhost", 8899).sync();
                channelFuture.channel().closeFuture().sync();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                group.shutdownGracefully();
            }
        }
    }
    
    class NettyClientHandler  extends SimpleChannelInboundHandler<String> {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {       
            System.out.println("服务端消息:" + msg);
            ctx.channel().writeAndFlush("客户端消息:hello word");
        }
    }
    
    展开全文
  • TCP服务器与客户端

    千次阅读 2018-07-13 23:53:34
    1、生活中的“打电话”实例(TCP) (1)买个手机 (2)插上手机卡 (3)设计手机为正常接听状态(即能够响铃) (4)静静的等着别人拨打 (5)挂断手机,结束通话2、tcp服务器 (1)socket创建一个套接字 ...
  • Tcp客户端与Tcp服务器端之间的连接

    千次阅读 2018-05-16 22:21:48
    Tcp客户端 Tcp服务器端 socket socket connect(建立连接) bind listen ...
  • python 使用socket模拟tcp客户端和tcp服务器端#coding=utf-8 ''' 服务器端代码''' import socket #创建套接字tcp tcpServerSocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM) address = ('',8080) tcp...
  • 建立TCP 服务器的系统调用

    千次阅读 多人点赞 2018-08-05 11:48:47
    建立TCP服务器连接的过程中主要通过以下系统调用序列来获取某些函数,这些系统调用主要包括:socket(),bind(),listen(),accept(),send()和recv()。 如下图所示, TCP应用程序进行的普通调用序列:...
  • 基于 Erlang/OTP 搭建TCP服务器

    千次阅读 多人点赞 2013-10-22 21:50:29
    这两天在研究erlang如何构建TCP服务器,看到一篇文章,基于Erlang OTP构建一个TCP服务器,里面讲述了两种混合型Socket的实现方法,着实让人欢欣鼓舞。本文将结合这两篇文章,继续讨论Erlang/OTP 构建TCP服务器的具体...
  • QT 学习 (TCP服务器通信)

    千次阅读 2019-01-01 10:23:41
    QT编写TCP服务器通信总结: TCP服务器通信 , QT提供了服务器类QTcpServer和客户端类QTcpSocket 程序源码下载:https://download.csdn.net/download/dianzishi123/10849989 说明:上传的源码是最初始的,文档下的源码会...
  • TCP服务器和客户端交互

    千次阅读 2015-08-17 10:52:19
    一、实验目的 学习和掌握Linux下的TCP服务器基本原理和基本编程方法,体会TCP与UDP编程的不同,UDP编程:...编写Linux下TCP服务器套接字程序,程序运行时服务器等待客户的连接,一旦连接成功,
  • Socket之TCP服务器【Python】

    千次阅读 2019-01-11 19:17:39
    创建TCP服务器 首先,我们先创建一段通用TCP服务器的一般伪代码,然后对这些伪代码进行描述。这仅仅是我们设计网络通信服务器的一种模式,只要熟悉了这种设计模式,我们就可以根据自己的需要修改伪代码来操作服务器...
  • 小弟刚刚学习网络这块,现在使用单片机+串口WIFI做TCP服务器,手机做TCP客户端。想问一下,TCP服务器可以直接发送html或者JPG格式的数据给TCP客户端么,可以的话应该怎么操作呢? 如果不行的话,又应该补充些什么呢...
  • python使用socket创建tcp服务器和客户端。 服务器端为一个时间戳服务器,在接收到客户端发来的数据后,自动回复。 客户端,等待用户输入,回车后向服务器发送用户输入的内容。 分别在python2.7和python3.6下测试...
  • Swoole 快速起步:创建 TCP 服务器

    千次阅读 2019-09-22 16:15:43
    TCP 协议 (Transport Control Protocol) 属于传输层,在经过三...TCP 服务器脚本 1. 创建脚本:server.php <?php // 创建 Server 对象,监听 127.0.0.1:9501端口 $serv = new Swoole\Server("127.0.0.1", 950...
  • C#异步TCP服务器完整实现

    千次阅读 2017-06-23 17:08:23
    C#异步TCP服务器完整实现 时间 2013-04-14 19:33:00 博客园精华区 原文 http://www.cnblogs.com/gaochundong/archive/2013/04/14/csharp_async_tcp_server.html 主题 TCP/IP C# TCP异步Socket...
  • python实现多线程TCP服务器框架

    千次阅读 2020-01-09 10:52:38
    python实现TCP服务器框架的步骤 导入模块 创建套接字 设置地址可以重用 绑定端口 设置监听,套接字由主动变为被动 接收客户端连接 接受客户端发送的信息 解码数据并输出 关闭和当前客户端的连接 # 1.导入模块 ...
  • 最近几天学了TCP后就不仅仅想让其可以再局域网为生效,想让其在广域网访问,因此就将TCP服务器放在阿里云服务器上,就出现了下面的情况 显示bind错误,但是查看8080端口时,显示没被使用,这就让我有点懵逼了,最后...
  • 通过 AT 指令实现 ESP8266 模块和 TCP服务器的数据传输 一,总体介绍: 这篇博文主要讲解如何通过串口调试工具发送AT指令给esp8266-01,实现8266和服务器通讯。这里使用网络调试助手模拟出来一个TCP服务器,然后...
  • 基于select模型的TCP服务器

    千次阅读 2016-07-29 20:36:01
    之前的一篇博文是基于TCP的服务器和客户机程序,今天在这我要实现一个基于select模型的TCP服务器(仅实现了服务器)。 socket套接字编程提供了很多模型来使服务器高效的接受客户端的请求,select就是其中之一。 ...
  • ESP8266连接TCP服务器基本步骤

    千次阅读 2018-01-22 17:27:14
    /*连接TCP服务器基本步骤*/ //测试ESP8266是否正常连接 AT //设置为STA模式 AT+CWMODE=1 //连接AP AT+CWJAP="ssid","password"  //单连接模式 AT+CIPMUX=0 //透传模式 AT+CIPMODE=1 //建立...
  • TCP 服务器三种模式的简单实现

    千次阅读 2017-07-14 11:37:55
     今天我们来介绍TCP 服务器的三种模式的实现:单用户服务器,多进程多用户服务器,多线程多用户服务器。 要实现一个服务器,不仅要有服务端,还要有客户端,所以本文三种服务器服务器端代码和客户端这样两块代码...
  • 并发TCP服务器和并发UDP服务器

    千次阅读 2013-06-06 12:38:06
     在UNP(UNIX网络编程第1卷--中文版)书上的第46页说明了并发TCP服务器的工作流程,但fork()出来的子进程端口号和父进程端口号相同(书上的ftp服务器都是21)。  在UNP(UNIX网络编程第1卷--中文版)书上的第525页...
  • QT TCP服务器接收不到数据的问题

    千次阅读 2020-02-16 21:34:43
    在QT中编写TCP服务器的程序时,出现了一个小问题。 服务器给客户端发送数据正常,但服务器始终接收不到客户端发来的数据。readyRead信号和槽函数返回值也为true。 解决办法 readyRead信号需要放在...
  • Qt下实现线程中的TCP服务器

    千次阅读 2019-03-15 09:23:43
    TCP服务器的代码实现比UDP略为复杂一点,因为TCP的服务端需要生成与管理一个额外的QTcpServer对象。为了支持多线程,用moveToThread方法把服务器放在一个单独的线程中。 代码之路 用MyTcpServer类实现TCPserver,供...
  • STM32移植lwip之建立tcp服务器

    千次阅读 多人点赞 2016-11-03 16:38:25
    本篇目标:在之前能ping通pc机的工程基础上搭建tcp连接,并可以收发数据,在网络调试工具上显示材料准备: 基础工程:修改后能ping通pc机...搭建TCP服务器之前已经能够让pc机ping通stm32了,说明PHY网卡已经正确工作了
  • 本文通过python3+PyQt5实现《python Qt GUI快速编程》第18章的例子Building Services application。本例分别创建一个TCP客户端和TCP服务器,采用PyQt的QtNetwork模块,而不是Python标准库或Twisted网络引擎。
  • 求指教基于mfc的Modbus/TCP服务器协议,只要能读写数据功能,我用的vc6.0

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 88,403
精华内容 35,361
关键字:

tcp服务器