Linux学习笔记-----网络编程套接字

最新推荐文章于 2024-04-29 17:10:37 发布
最新推荐文章于 2024-04-29 17:10:37 发布
阅读量256 收藏
点赞数 1
分类专栏： linux学习笔记 文章标签： 网络 linux 网络通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41219243/article/details/116901501
版权

 

目录

 

一 、概念

（一）端口号概念

（二）套接字概念

（三）套接字（socket）编程接口

（四）sockaddr结构

（五）网络字节序

二、基于UDP的相关理解

（一）UDP协议

（二）编写简单的UDP服务端和客户端

（三）小结

三、基于TCP的相关理解

（一）TCP协议

（二）编写单执行流的TCP服务端和客户端

  (三）编写多进程的TCP服务端和客户端

（四）编写多线程的TCP服务端和客户端​

（五）小结

一 、概念

（一）端口号概念

  • 端口号标定该主机上互联网中唯一一个进程。
  • 进程ID是每个进程都有的，但是端口号只有是网络进程才给指派端口号。
  • 一个端口号用来标识一个进程，一个进程可以绑定多个端口号。一个进程可以同时拥有端口和pid。
  • 传输层协议(TCP和UDP)的数据段中有两个端口号, 分别叫做源端口号和目的端口号. 就是在描述 "数据是谁发的, 要发给谁"。

（二）套接字概念

  • 所谓套接字(Socket)，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象，套接字编程本质是进程间通信。
  • IP号标定唯一主机，IP+端口号（PORT，16位bit）标识全网内唯一一个进程，也叫套接字。
  • 创建套接字，实际上是创建两套资源，第一套是通讯需要的网卡相关的资源，第二个是需要和文件系统挂钩的相关文件资源。

（三）套接字（socket）编程接口

  • socket返回值是一个文件描述符，数值默认是3，一个进程可以打开多个套接字，描述套接字的数据结构struct socket，进程和套接字是用过文件描述符表关联起来。

// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)

  • int socket(int domain, int type, int protocol);
  • domain相当于采用哪种协议一般选择ipv4，type 一般使用SOCK_STREM对应的是TCP （面向字节流的，面向链接的） SOCK_DFRM（面向用户数据报是UDP，无链接的）返回值是int型，成功返回一个文件描述符。

 

// 绑定端口号 (TCP/UDP, 服务器)

//所谓绑定就是在a.填充进当前服务器的ip地址和端口号b.不同套接字的操作方法不一样，他要初始化底层的函数指针让它指向不同的标准方法。

  • int bind(int socket, const struct sockaddr *address,socklen_t address_len);

 

// 开始监听socket (TCP, 服务器)

  • int listen(int socket, int backlog);
  • backlog代表是底层链接队列长度是多少，一般不要设置太大。

 

// 接收请求 (TCP, 服务器)

  • int accept(int socket, struct sockaddr* address,socklen_t* address_len);
  • accept里的sockfd（lsock拉客的人）专注于从底层获取链接上来，返回值sockfd（服务员）专注于通信

 

// 建立连接 (TCP, 客户端)

  • int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
     

（四）sockaddr结构

  • socketaddr数据结构表示套接字的数据结构。

  • 有三类套接字，第一种是基于流式的，第二种是域间的（基于AF_INET叫做协议组），第三种是原始套接字。

（五）网络字节序

  • 默认网络跑的数据都是大端序列的。当发的是小端数据时，就需要转成大端。为了解决大小端问题，就引入网络字节序。网络是大端，本质是一种共识。
  • 网络字节顺序是TCP/IP中规定好的一种数据表示格式，它与具体的CPU类型、操作系统等无关，从而可以保证数据在不同主机之间传输时能够被正确解释。网络字节顺序采用big-endian（大端）排序方式。

为使网络程序具有可移植性,使同样的C代码在大端和小端计算机上编译后都能正常运行,可以调用以下库函数做网络字节序和主机字节序的转换：

  • 头文件：#include<arpa/inet.h>
  • htons把unsigned short类型从主机序转换到网络序。
  • htonl 把unsigned long类型从主机序转换到网络序。
  • ntohs 把unsigned short类型从网络序转换到主机序。
  • ntohl 把unsigned long类型从网络序转换到主机序。

二、基于UDP的相关理解

（一）UDP协议

  • 传输层协议
  • 无连接
  • 不可靠传输
  • 面向数据报
     

（二）编写简单的UDP服务端和客户端

//服务器 .hpp
#pragma once


#include <iostream>
#include <string>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>


  class udpServer{ 
    private:
        std::string ip;
        int port;
        int sock;
   public:
        udpServer(std::string _ip="127.0.0.1", int _port=8080)
            :ip(_ip), port(_port)
        {}
        void initServer()
        {
            sock = socket(AF_INET, SOCK_DGRAM, 0);
            std::cout << "sock: " << sock << std::endl;
            struct sockaddr_in local;
            local.sin_family = AF_INET;
            local.sin_port = htons(port);
            local.sin_addr.s_addr = inet_addr(ip.c_str());


            if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0){
                std::cerr << "bind error!\n" << std::endl;
                exit(1);
            }
        }


        void start()
        {
            char msg[64];
            for(;;){
                msg[0] = '\0';
                struct sockaddr_in end_point;
                socklen_t len = sizeof(end_point);
                ssize_t s = recvfrom(sock, msg, sizeof(msg)-1,0, (struct sockaddr*)&end_point, &len);
                if(s > 0){
                    msg[s] = '\0';
                    std::cout <<"client# " << msg << std::endl;
                    std::string echo_string = msg;
                    echo_string += " [server echo!]";
                    sendto(sock, echo_string.c_str(), echo_string.size(), 0, (struct sockaddr*)&end_point, len);
                }
            }
        }
        ~udpServer()
        {
            close(sock);
        }
};

//服务器端.cc
#include "udpClient.hpp"

int main()
{
    udpClient uc;
    uc.initClient();
    uc.start();

    return 0;
}
[lvhao@VM-0-12-centos lesson9]$ cat udpServer.cc
#include "udpServer.hpp"

int main()
{
    udpServer *up = new udpServer();

    up->initServer();
    up->start();

    delete up;
}



//客户端 .hpp
#pragma once


#include <iostream>
#include <string>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>


class udpClient{
    private:
        std::string ip;
        int port;
        int sock;
    public:
        udpClient(std::string _ip="127.0.0.1", int _port=8080)
            :ip(_ip), port(_port)
        {}
        void initClient()
        {
            sock = socket(AF_INET, SOCK_DGRAM, 0);
            std::cout << "sock: " << sock << std::endl;
        }


        void start()
        {
            std::string msg;
            struct sockaddr_in peer;
            peer.sin_family = AF_INET;
            peer.sin_port = htons(port);
            peer.sin_addr.s_addr = inet_addr(ip.c_str());


            for(;;){
                std::cout << "Please Enter# ";
                std::cin >> msg;
                if(msg == "quit"){
                    break;
                }

                sendto(sock, msg.c_str(), msg.size(), 0, (struct sockaddr*)&peer, sizeof(peer));

                char echo[128];
                ssize_t s = recvfrom(sock, echo, sizeof(echo)-1, 0, nullptr, nullptr);
                if(s >0){
                    echo[s] = 0;
                    std::cout << "server# " << echo << std::endl;
                }
            }
        }
        ~udpClient()
        {
            close(sock);
        }
};

//客户端.cc
#include "udpClient.hpp"

int main()
{
    udpClient uc;
    uc.initClient();
    uc.start();

    return 0;
}

//Makefile
.PHONY:all
all:udpClient udpServer

udpClient:udpClient.cc
	g++ -o $@ $^ -std=c++11
udpServer:udpServer.cc
	g++ -o $@ $^

.PHONY:clean
clean:
	rm -f udpClient udpServer

（三）小结

  • 想要删掉错输的信息按住ctrl+backspace。
  • netstat -nlup查看绑定的ip和端口号。
  • 服务器创建：第一步创建了套接字数据结构，如果没有ip和端口号就无法定位，无法定位就没办法通信，第二步需要在创建sockaddr_in数据结构从而填充协议族，在填充端口号，在填充ip地址，进而在进行相关动作的一个绑定。
  • 服务器端的ip和port不能轻易被更改，必须是确定的，众所周知的。http：80，https：443 ssh：22 MySQL：3306。
  • 客户端给别人发消息就必须知道别人的ip和端口号，这就需要创捷结构填入别人的ip和端口号。
  • 127.0.0.1本地环回，通常用来进行网络通信代码的本地测试，一般跑通说明代码在本地环境以及代码基本没有大问题。
  • 服务器绑定ip为0时等价于绑定公网ip，一般不会这么写。
  • 客户端不需要强bind（绑定）

a.你在进行bind的时候，很容易冲突！客户端无法启动！

b.客户端需要唯一性，但是不需要明确必须是哪个端口号。但是需要ip和port（端口）。client udp，recv和cend，系统会自动进行ip和端口号的绑定！

三、基于TCP的相关理解

（一）TCP协议

  • TCP属于传输层的传输控制协议，比较复杂，管的事多，而UDP则较为简单。
  • 传输层协议
  • 有连接
  • 可靠传输
  • 面向字节流

（二）编写单执行流的TCP服务端和客户端

//服务器hpp
#pragma once

#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <string>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define BACKLOG 5
class tcpServer{
    private:
        int port;
        int lsock; //监听套接字
    public:
        tcpServer(int _port)
            :port(_port), lsock(-1)
        {}
        void initServer()
        {
            lsock = socket(AF_INET, SOCK_STREAM, 0);
            if(lsock < 0){
                std::cerr << "socket error" << std::endl;
                exit(2);
            }
            struct sockaddr_in local;
            local.sin_family = AF_INET;
            local.sin_port = htons(port);
            local.sin_addr.s_addr = htonl(INADDR_ANY);


            if(bind(lsock, (struct sockaddr*)&local, sizeof(local)) < 0){
                std::cerr << "bind error" << std::endl;
                exit(3);
            }


            if(listen(lsock, BACKLOG) < 0){
                std::cerr << "bind error" << std::endl;
                exit(4);
            }
        }
        void service(int sock)
        {
            char buffer[1024];
            while(true){
                //read or write -> ok!
                size_t s = recv(sock, buffer, sizeof(buffer)-1, 0);
                if(s > 0){
                    buffer[s] = 0;
                    std::cout << "client# " << buffer << std::endl;
                    send(sock, buffer, strlen(buffer), 0);
                }
                else if(s == 0){
                    std::cout << "client quit ...." << std::endl;
                    break;
                }
                else {
                    std::cout << "recv client data error..." << std::endl;
                    break;
                }
            }
            close(sock);
        }
        void start()
        {
            sockaddr_in endpoint;
            while(true){
                socklen_t len = sizeof(endpoint);
                int sock = accept(lsock, (struct sockaddr*)&endpoint, &len);
                if(sock < 0){
                    std::cerr << "accept error" << std::endl;
                    continue;
                }
                std::string cli_info = inet_ntoa(endpoint.sin_addr);
                cli_info += ":";
                cli_info += std::to_string(ntohs(endpoint.sin_port));
                std::cout << "get a new link ..." << cli_info << " sock: " << sock <<std::endl;
                service(sock);
            }
        }
        ~tcpServer()
        {}
};

//服务器.cc
#include "tcpServer.hpp"
static void Usage(std::string proc)
{
    std::cout << "Usage: " << std::endl;
    std::cout << '\t' << proc << " port" << std::endl;
}

int main(int argc, char *argv[])
{
    if(argc != 2){
        Usage(argv[0]);
        exit(1);
    }
    tcpServer * tp = new tcpServer(atoi(argv[1]));
    tp->initServer();
    tp->start();
    delete tp;
    return 0;
}

//客户端  .hpp

#pragma  once
#include <iostream>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

class tcpClient{
    private:
        std::string svr_ip;
        int svr_port;
        int sock;
    public:
        tcpClient(std::string _ip="127.0.0.1", int _port = 8080)
            :svr_ip(_ip),svr_port(_port)
        {}
        void initClient()
        {
            sock = socket(AF_INET, SOCK_STREAM, 0);
            if(sock < 0){
                std::cerr << "socket error" << std::endl;
                exit(2);
            }
            struct sockaddr_in svr;
            svr.sin_family = AF_INET;
            svr.sin_port = htons(svr_port);
            svr.sin_addr.s_addr = inet_addr(svr_ip.c_str());


            if(connect(sock, (struct sockaddr*)&svr, sizeof(svr)) != 0){
                std::cerr << "connect error" << std::endl;
            }
            //connect success;
        }
        void start()
        {
            char msg[64];
            while(true){
                std::cout << "Please Enter Message# ";
                fflush(stdout);
                size_t s = read(0, msg, sizeof(msg)-1);
                if(s > 0){
                    msg[s-1] = 0;
                    send(sock, msg, strlen(msg), 0);
                    size_t ss = recv(sock, msg, sizeof(msg)-1, 0);
                    if(ss > 0){
                        msg[ss] = 0;
                        std::cout << "server echo # " << msg << std::endl;
                    }
                }
            }
        }
        ~tcpClient()
        {
            close(sock);
        }
};
//客户端  .cc
#include "tcpClient.hpp"

static void Usage(std::string proc)
{
    std::cout << "Usage: \n" << "\t";
    std::cout << proc << " svr_ip svr_port" << std::endl;
}
int main(int argc, char *argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        exit(1);
    }
    tcpClient *tc = new tcpClient(argv[1], atoi(argv[2]));
    tc->initClient();
    tc->start();
    delete tc;
    return 0;
}



FLAG=-std=c++11

.PHONY:all
all:tcpClient tcpServer

tcpClient:tcpClient.cc
	g++ -o $@ $^ $(FLAG) -static
tcpServer:tcpServer.cc
	g++ -o $@ $^ $(FLAG)

.PHONY:clean
clean:
	rm -f tcpClient tcpServer

  (三）编写多进程的TCP服务端和客户端

//服务器 .hpp
#pragma once
#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <string>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>


#define BACKLOG 5


class tcpServer{
    private:
        int port;
        int lsock; //监听套接字
    public:
        tcpServer(int _port)
            :port(_port), lsock(-1)
        {}
        void initServer()
        {
            //设置信号  为默认忽略，当子进程要退出时发送信号，系统默认回收。
            signal(SIGCHLD, SIG_IGN);    
            lsock = socket(AF_INET, SOCK_STREAM, 0);
            if(lsock < 0){
                std::cerr << "socket error" << std::endl;
                exit(2);
            }
            struct sockaddr_in local;
            local.sin_family = AF_INET;
            local.sin_port = htons(port);
            local.sin_addr.s_addr = htonl(INADDR_ANY);


            if(bind(lsock, (struct sockaddr*)&local, sizeof(local)) < 0){
                std::cerr << "bind error" << std::endl;
                exit(3);
            }


            if(listen(lsock, BACKLOG) < 0){
                std::cerr << "bind error" << std::endl;
                exit(4);
            }
        }
        void service(int sock)
        {
            char buffer[1024];
            while(true){
                size_t s = recv(sock, buffer, sizeof(buffer)-1, 0);
                if(s > 0){
                    buffer[s] = 0;
                    std::cout << "client# " << buffer << std::endl;


                    send(sock, buffer, strlen(buffer), 0);
                }
                else if(s == 0){
                    std::cout << "client quit ...." << std::endl;
                    break;
                }
                else {
                    std::cout << "recv client data error..." << std::endl;
                    break;
                }
            }
            close(sock);
        }
        void start()
        {
            sockaddr_in endpoint;
            while(true){
                socklen_t len = sizeof(endpoint);
                int sock = accept(lsock, (struct sockaddr*)&endpoint, &len);
                if(sock < 0){
                    std::cerr << "accept error" << std::endl;
                    continue;
                }
                std::string cli_info = inet_ntoa(endpoint.sin_addr);
                cli_info += ":";
                cli_info += std::to_string(ntohs(endpoint.sin_port));


                std::cout << "get a new link ..." << cli_info << " sock: " << sock <<std::endl;


                pid_t id = fork();
                //child
                if(id == 0){
                    close(lsock);
                    service(sock);
                    exit(0);
                }
                close(sock);
            }
        }
        ~tcpServer()
        {}
};

//服务器.cc
#include "tcpServer.hpp"


static void Usage(std::string proc)
{
    std::cout << "Usage: " << std::endl;
    std::cout << '\t' << proc << " port" << std::endl;
}


int main(int argc, char *argv[])
{
    if(argc != 2){
        Usage(argv[0]);
        exit(1);
    }


    tcpServer * tp = new tcpServer(atoi(argv[1]));
    tp->initServer();
    tp->start();


    delete tp;
    return 0;
}
//客户端.hpp
#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

class tcpClient{
    private:
        std::string svr_ip;
        int svr_port;
        int sock;
    public:
        tcpClient(std::string _ip="127.0.0.1", int _port = 8080)
            :svr_ip(_ip),svr_port(_port)
        {}
        void initClient()
        {
            sock = socket(AF_INET, SOCK_STREAM, 0);
            if(sock < 0){
                std::cerr << "socket error" << std::endl;
                exit(2);
            }
            struct sockaddr_in svr;
            svr.sin_family = AF_INET;
            svr.sin_port = htons(svr_port);
            svr.sin_addr.s_addr = inet_addr(svr_ip.c_str());
            if(connect(sock, (struct sockaddr*)&svr, sizeof(svr)) != 0){
                std::cerr << "connect error" << std::endl;
            }
        }
        void start()
        {
            char msg[64];
            while(true){
                std::cout << "Please Enter Message# ";
                fflush(stdout);
                size_t s = read(0, msg, sizeof(msg)-1);
                if(s > 0){
                    msg[s-1] = 0;
                    send(sock, msg, strlen(msg), 0);
                    size_t ss = recv(sock, msg, sizeof(msg)-1, 0);
                    if(ss > 0){
                        msg[ss] = 0;
                        std::cout << "server echo # " << msg << std::endl;
                    }
                    else if(ss == 0){
                        break;
                    }
                    else{
                        break;
                    }
                }
            }
        }
        ~tcpClient()
        {
            close(sock);
        }
};
//客户端.cc
#include "tcpClient.hpp"
static void Usage(std::string proc)
{
    std::cout << "Usage: \n" << "\t";
    std::cout << proc << " svr_ip svr_port" << std::endl;
}
int main(int argc, char *argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        exit(1);
    }
    tcpClient *tc = new tcpClient(argv[1], atoi(argv[2]));
    tc->initClient();
    tc->start();
    delete tc;
    return 0;
}



（四）编写多线程的TCP服务端和客户端

//服务器.hpp
#pragma once
#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <string>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <pthread.h>


#define BACKLOG 5


class tcpServer{
    private:
        int port;
        int lsock; //监听套接字
    public:
        tcpServer(int _port)
            :port(_port), lsock(-1)
        {}
        void initServer()
        {
            signal(SIGCHLD, SIG_IGN);
            lsock = socket(AF_INET, SOCK_STREAM, 0);
            if(lsock < 0){
                std::cerr << "socket error" << std::endl;
                exit(2);
            }
            struct sockaddr_in local;
            local.sin_family = AF_INET;
            local.sin_port = htons(port);
            local.sin_addr.s_addr = htonl(INADDR_ANY);


            if(bind(lsock, (struct sockaddr*)&local, sizeof(local)) < 0){
                std::cerr << "bind error" << std::endl;
                exit(3);
            }


            if(listen(lsock, BACKLOG) < 0){
                std::cerr << "bind error" << std::endl;
                exit(4);
            }
        }
        static void service(int sock)
        {
            char buffer[1024];
            while(true){
                size_t s = recv(sock, buffer, sizeof(buffer)-1, 0);
                if(s > 0){
                    buffer[s] = 0;
                    std::cout << "client# " << buffer << std::endl;


                    send(sock, buffer, strlen(buffer), 0);
                }
                else if(s == 0){
                    std::cout << "client quit ...." << std::endl;
                    break;
                }
                else {
                    std::cout << "recv client data error..." << std::endl;
                    break;
                }
            }
            close(sock);
        }
        static void *serviceRoutine(void *arg)
        {
            pthread_detach(pthread_self());
            std::cout << "create a new thread for IO" << std::endl;
            int *p = (int*)arg;
            int sock = *p;
            service(sock);
            delete p;
        
        }
        void start()
        {
            sockaddr_in endpoint;
            while(true){
                socklen_t len = sizeof(endpoint);
                int sock = accept(lsock, (struct sockaddr*)&endpoint, &len);
                if(sock < 0){
                    std::cerr << "accept error" << std::endl;
                    continue;
                }
                std::string cli_info = inet_ntoa(endpoint.sin_addr);
                cli_info += ":";
                cli_info += std::to_string(ntohs(endpoint.sin_port));


                std::cout << "get a new link ..." << cli_info << " sock: " << sock <<std::endl;


             pthread_t tid;
             int *p = new int(sock);
             pthread_create(&tid, nullptr, serviceRoutine, (void*)p); 
            }
        }
        ~tcpServer()
        {}
};
//服务器.cc
#include "tcpServer.hpp"


static void Usage(std::string proc)
{
    std::cout << "Usage: " << std::endl;
    std::cout << '\t' << proc << " port" << std::endl;
}


int main(int argc, char *argv[])
{
    if(argc != 2){
        Usage(argv[0]);
        exit(1);
    }


    tcpServer * tp = new tcpServer(atoi(argv[1]));
    tp->initServer();
    tp->start();


    delete tp;
    return 0;
}
//客户端.hpp
#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>






class tcpClient{
    private:
        std::string svr_ip;
        int svr_port;
        int sock;
    public:
        tcpClient(std::string _ip="127.0.0.1", int _port = 8080)
            :svr_ip(_ip),svr_port(_port)
        {}
        void initClient()
        {
            sock = socket(AF_INET, SOCK_STREAM, 0);
            if(sock < 0){
                std::cerr << "socket error" << std::endl;
                exit(2);
            }
            struct sockaddr_in svr;
            svr.sin_family = AF_INET;
            svr.sin_port = htons(svr_port);
            svr.sin_addr.s_addr = inet_addr(svr_ip.c_str());


            if(connect(sock, (struct sockaddr*)&svr, sizeof(svr)) != 0){
                std::cerr << "connect error" << std::endl;
            }
        }
        void start()
        {
            char msg[64];
            while(true){
                std::cout << "Please Enter Message# ";
                fflush(stdout);
                size_t s = read(0, msg, sizeof(msg)-1);
                if(s > 0){
                    msg[s-1] = 0;
                    send(sock, msg, strlen(msg), 0);
                    size_t ss = recv(sock, msg, sizeof(msg)-1, 0);
                    if(ss > 0){
                        msg[ss] = 0;
                        std::cout << "server echo # " << msg << std::endl;
                    }
                    else if(ss == 0){
                        break;
                    }
                    else{
                        break;
                    }
                }
            }
        }
        ~tcpClient()
        {
            close(sock);
        }
};

//客户端.cc
#include "tcpClient.hpp"


void Usage(std::string proc)
{
    std::cout << "Usage: \n" << "\t";
    std::cout << proc << " svr_ip svr_port" << std::endl;
}


int main(int argc, char *argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        exit(1);
    }
    tcpClient *tc = new tcpClient(argv[1], atoi(argv[2]));


    tc->initClient();
    tc->start();


    delete tc;
    return 0;
}

（五）小结

  • 工程上一般很少使用ip，只使用端口号，一般填INADDR_ANY（可以理解代表该机器的全部IP），这个宏表示本地任意IP地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个IP地址，这样设置可以在所有的IP地址上监听，知道与某个客户端建立了连接时才确定下来到底用哪个IP地址。
  • tcp绑定后，必须让tcp设置成监听状态，TCP允许在任何时刻链接我，不连接不能进行发送但是UDP可以，所以UDP叫做无链接。UDP相当于标定了IP和端口号，并没有进行连接他俩。
  • 192.168.1.2.3是字符串风格的四字节 点分十进制方案。inet_ntoa四字节IP转换成点分十进制。inet_addr四字节字符串风格的IP地址转化成四字节网络序列IP。
  • telnet登录一个服务器所需要的命令要进行交互输入ctrl+上尖括号。
  • +static代码只要系统一样，代码则不依赖任何第三方库就可以跑。
  • 客户端和服务器都需要-std=c++11时我们需要FLAG=-std=c++11；  后面直接$(FLAG);
  • sz -E+文件名+rz   就是从linux发送到windows。
  • cp -rf +需要拷贝的文件夹+拷贝成那个名字的文件夹在当前路径拷贝一个文件夹。

 

 

 

 

ishao97
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Linux网络编程socket编程学习
05-09
很详细的介绍了网络套接字socket的C/S模型TCP协议的服务器端和客户端的程序函数以及编写过程；重点介绍多路I/O转接服务器的实现，包括select函数poll函数epoll函数；最后介绍了UDP协议的服务器编写和本地套接字的...
linux学习笔记--网络编程
watson_pillow的博客
01-18 2096
目录概念协议网络应用设计模式分层模型协议格式TCP状态网络名词socket编程套接字字节序函数socketbindlistenacceptconnectC/S模型serverclient封装高并发服务器进程方式线程方式多路ioselectpollepoll线程池UDPCS模型广播组播本地套接字domain socket 黑马教程的视频学习记录 概念 协议 网络应用设计模式 B/S C/S 分层模型 OSI七层，TCP/IP四层 协议格式 数据包 以太网帧 ARP数据 IP UDP: 无连接的不可靠报文传输
Linux学习笔记-B站韩顺平
热门推荐
m0_52041525的博客
02-26 1万+
linux 是一个开源、免费的操作系统，其稳定性、安全性、处理多并发已经得到业界的认可，
c语言网络套接字讲解,C语言学习笔记-网络与套接字
weixin_31143391的博客
05-20 1336
所有程序都需要编写检查错误的代码一.基础知识客户端与服务器之间将展开一段结构化对话，叫协议。在C语言中，如果写一个与网络通信的程序，就需要新的数据流-套接字，套接字是双向的，既可以输入也可以输出1.使用socket()函数创建一个套接字数据流#include int xxxx = socket(PF_INET, SOCK_STREAM, 0);xxxx是套接字名字套接字与客户端程序通信，服务器需要...
【套接字-Socket】学习笔记（更新中）
最新发布
weixin_43627638的博客
04-29 849
目前在各种体系的计算机中所采用的字节存储机制主要有：Big-Endian（大端）和Little-Endian（小端）。因此，计算机操作系统为应用程序与TCP/IP协议的交互提供了称为套接字(Socket)的接口，可以。当应用层（用户）通过传输层进行数据通信时，TCP协议或者UDP协议可能会需要同时为多个进程提供。在Socket中已经提供了封装好的数据转换接口，包括从主机字节序到网络字节序的转换函数。，也就是说多个连接或者进程需要通过同一个协议端口进行数据的传输。从网络字节序到主机字节序的转换函数。
linux网络编程学习笔记(3)——套接字选项编程
Biao
01-07 1358
在进行网络编程的时候，经常需要査看或者设置套接字的某些特性，例如设置地址复用、读写数据的超时时间、对读缓冲区的大小进行调整等操作。获得套接字选项设置情况 的函数是getsockopt()，设置套接字选项的函数为setsockopt()。 功能描述： 获取或者设置与某个套接字关联的选项。选项可能存在于多层协议中，它们总会出现在最上面的套接字层。当操作套接字选项时，选项位于的层和选......
网络编程课堂笔记
11-03
Unix TCP/IP 分层协议以及基于Linux的socket套接字网络编程学习笔记。
linux网络编程学习笔记
05-15
listen函数将 bind 的文件描述符变为监听套接字.返回的情况和 b ind 一样. accept int accept(int sockfd, struct sockaddr *addr,int *addrlen) sockfd：是 listen后的文件描述符. addr,addrlen是用来给...
百度地图开发java源码-TCP-IP-NetworkNote:《TCP/IP网络编程》(韩-尹圣雨)学习笔记
06-06
理解网络编程和套接字 linux 头文件 #include windows 头文件 #include 基于linux平台的实现 网络编程结束连接请求的套接字创建过程为 1. 调用socket函数创建套接字 int socket(int domain,int type ,int protocol...
百度地图毕业设计源码-TCP-IP-NetworkNote::blue_book:《TCP/IP网络编程》(韩-尹圣雨)学习笔记
06-06
章：理解网络编程和套接字 本章代码，在中可以找到，直接点连接可能进不去。 1.1 理解网络编程和套接字 1.1.1构建打电话套接字 以电话机打电话的方式来理解套接字。 调用 socket 函数（安装电话机）时进行的对话： ...
Linux下新用户创建、登录以及删除操作小白学习分享
qq_41219243的博客
01-23 2816
一提到Linux用户，不得不提到一个超级用户和普通用户的概念 **超级用户（root）**它是可以在linux系统下做任何事情，不受限制。它只能有一个。 普通用户则是在linux下做有限的事情。它可以有多个。 **一、创建新普通用户 **当我们在第一次使用linux时最开始都是只有一个超级用户（root），而普通用户则是用过超级用户进行创建而形成的，所以我们首先来在超级用户下进行创建一个普通用户 **1.**首先进入linux系统中输入指令 whoami 显示root则表示当前用户为超级用户，接下来我
Linux学习笔记-----vim下多行代码注释与取消
qq_41219243的博客
05-19 1730
一、注释多行代码 1.将光标打到多行代码起始处，比如这里我需要注释73-81行代码，我将光标打到73行处。 2.按下Ctrl+V进入VISUAL BLOCK模式，这里我们使用h（左） j （下） k（上） l（右）这四个键来进行操作，一定不要使用键盘的箭头，亲测无效。如下，我们使用j （下）键走到81行。 3.接着按下大写的I 键或者按Shift+i （两个效果一样，都是大写I）切换到输入模式，直接输入注释符号//，再按下Esc就可完成注释了。 二、取消注释多行代...
Linux学习笔记-----fork()函数理解
qq_41219243的博客
03-06 412
一、认识fork函数 1.含义：在linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程，它没有任何参数。 2.返回值：它有两个返回值，它的返回值是给调用后的父进程返回子进程的pid，如果调用成功，给子进程返回0值，可以把fork函数理解成一个单链表，它一方面可以显示自己，另一方面可以指向下一个结点，如果该节点为空则返回0.如果该进程创建失败，则返回-1. 3.用法：一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子
Linux学习笔记-----文件权限更改
qq_41219243的博客
01-25 281
一.用echo指令给文件写入新的内容 1.当我们使用echo指令对txt文件连续写入全新的内容时，我们不能使用>号，而应该使用>>，>相当于在原内容覆盖该内容，而>>则是增添新内容。 如下图 二、目录读（r）、写（w）、进入（x）权限说明 1.目录的读权限，含义是允许查看目录下的文件file。 2.目录的写权限，含义是是否允许特定角色在指定目录下创建文件file。 3.目录的x表示是否可以进入该目录。 说明：当一个目录不具有x权限时，就算该目录下的文件具有读写权限也无
Linux学习笔记-----进程间通信（管道及共享内存）
qq_41219243的博客
04-06 249
要让两个不同进程通信，前提条件是让两个进程看到同一资源。 对于进程间要相互通信，我们引入管道和共享内存概念 管道是Unix中最古老的进程间通信的形式，要让两个不同进程通信，前提条件是让两个进程看到同一资源。管道的生命周期是随进程的。 共享内存是进程通信中最快的，ipc的生命周期随内核，共享内存底层不提供任何的互斥机制。 一、匿名管道 匿名管道用于进程之间通信，且仅限于本地父子进程之间通信（兄弟、爷孙之间都可以，只要有亲缘关系），结构简单，类似于一根非水平状态的水管，一端进水另一端出水(单工)。相对于命.
Linux学习笔记-----多线程
qq_41219243的博客
05-02 219
一、线程概念 （一）什么是线程？ 在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”。 在Linux系统中，Linux中,没有真正意义上的线程，线程是用进程模拟的，在CPU眼中，看到的PCB都要比传统的进程更加轻量化。 透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流。 线程:调度的基本单位,线程是进程里面的执行流，并且线程在进程的地址空间内运行。进程:线程 1 : n （二）创建一个.
Linux学习笔记-----系统文件基础I/O接口及文件系统
qq_41219243的博客
04-01 200
一、系统文件I/O接口 （一）open函数 功能：进行打开文件操作 函数头文件： #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> 函数接口： int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode); pathname: 要打开或创建的目标文件 flag
Linux学习笔记-----进程信号
qq_41219243的博客
04-19 160
一、信号概念 1.信号是进程之间事件异步通知的一种方式，属于软中断。 2.在一个bash（终端）中，只允许有一个前台进程。 3.所有信号都必须经过操作系统的手发出。 4.用kill-l可以查看系统定义的信号列表。 5.普通信号可以发送多次，但是只进入一次，所以有可能丢失。 6.实时信号实时性比较强，来了立即处理，信号不会丢失，在系统层面采用链表进行管理。 Ctrl-C 产生的信号只能发给前台进程。一个命令后面加个&可以放到后台运行,这样Shell不必等待进程结束就可以接受新的命令,启动新的进程
linux学习笔记-b站韩顺平
09-12
B站上的韩顺平老师的《Linux学习笔记》系列课程非常值得推荐。通过这个课程，我学到了很多关于Linux操作系统的知识和技能。 首先，韩老师在课程中详细介绍了Linux的基本概念和特点。我清楚地了解到Linux是一个开源...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ishao97

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值