【计算机网络】—— Socket通信编程与传输协议分析

#include<WinSock2.h>
#include<iostream>
#define DEST_IP "127.0.0.1" //IP地址
#define DEST_PORT m     //端口 
using namespace std;
int m;
int main() {
  WORD mVersionRequested = MAKEWORD(2,2);
  WSADATA wsaData;
  if(WSAStartup(mVersionRequested,&wsaData) != 0){
    cout<<"初始化 WinSock 失败！"<<endl;
    return 0;
  }
  int start,stop;
  cout<<"请输入目的主机的扫描起始端口：";
  cin>>start;
  cout<<"请输入目的主机的扫描结束端口：";
  cin>>stop;
  for(m=start;m<=stop;m++){
    int sockfd,n;
    struct sockaddr_in dest_addr;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_port = htons(DEST_PORT);
    dest_addr.sin_addr.s_addr = inet_addr(DEST_IP);
    cout<<"正在扫描端口："<<m<<endl;
    n = connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr));
    if(n==-1){
      cout<<m<<"端口没有开启"<<endl;
    } 
    else{
      cout<<m<<"端口开启"<<endl;
    }
  }
  return 0;
}

class ScanPort:
    def __init__(self):
        self.ip = None
    def scan_port(self, port):
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            res = s.connect_ex((self.ip, port))
            if res == 0:  # 端口开启
                print('Ip:{} Port:{} IS OPEN\n'.format(self.ip, port))
            else:
                print('Ip:{} Port:{}: IS NOT OPEN\n'.format(self.ip, port))
        except Exception as e:
            print(e)
        finally:
            s.close()
    def start(self):
        remote_server = input("输入要扫描的远程主机:")
        self.ip = socket.gethostbyname(remote_server)
        ports = [i for i in range(1, 1025)]
        socket.setdefaulttimeout(0.5)
        # 开始时间
        t1 = datetime.now()
        # 设置多进程
        threads = []
        pool = ThreadPool(processes=8)
        pool.map(self.scan_port, ports)
        pool.close()
        pool.join()
        print('端口扫描已完成，耗时：', datetime.now() - t1)
ScanPort().start()

//客户端
#include <stdio.h>
#include <WinSock2.h> //windows socket的头文件
#include <Windows.h>
#include <iostream>
#include <thread>
#include <process.h>
#pragma comment(lib, "ws2_32.lib") //连接winsock2.h的静态库文件
using namespace std;
int main()
{
  //加载winsock库
  WSADATA wsadata;
  WSAStartup(MAKEWORD(2, 3), &wsadata);
  //客户端socket
  SOCKET clientSock = socket(PF_INET, SOCK_STREAM, 0);
  
  //初始化socket信息
  //memset:作用是在一段内存块中填充某个给定的值，它对较大的结构体或数组进行清零操作的一种最快方法。
  sockaddr_in clientAddr;
  memset(&clientAddr, 0, sizeof(SOCKADDR));
  
  //设置Socket的连接地址、方式和端口
  clientAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
  clientAddr.sin_family = PF_INET;
  clientAddr.sin_port = htons(2017);
  
  //建立连接
  connect(clientSock, (SOCKADDR*)&clientAddr, sizeof(SOCKADDR));
  cout << "已建立连接。" << endl;
  //发送消息
  char* s = new char[100];
  cout << "请输入你要发送的文字消息: ";
  cin >> s;
  send(clientSock, s, strlen(s) * sizeof(char) + 1, NULL);
  cout << "已发送:" << s << endl;
  //接收消息
  system("pause");
  char Buffer[MAXBYTE] = { 0 };
  recv(clientSock, Buffer, MAXBYTE, 0);
  cout << "通过端口:" << ntohs(clientAddr.sin_port) << "接收到:" << Buffer << endl;
  //关闭连接
  closesocket(clientSock);
  WSACleanup();
  cout << "客户端连接已关闭。" << endl;
  system("pause");
  return 0;
}

//服务器
#include <stdio.h>
#include <WinSock2.h> //windows socket的头文件
#include <Windows.h>
#include <iostream>
#include <thread>
#include <mutex>
#include <process.h>
#pragma comment(lib, "ws2_32.lib") //连接winsock2.h的静态库文件
using namespace std;
//mutex 每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。
//同一时刻，只能有一个线程持有该锁。
mutex m;
//定义结构体用来设置
typedef struct my_file
{
  SOCKET clientSocket;  //文件内部包含了一个SOCKET 用于和客户端进行通信
  sockaddr_in clientAddr; //用于保存客户端的socket地址
  int id;         //文件块的序号
}F;
DWORD WINAPI transmmit(const LPVOID arg)
{
  //实际上这里为了追求并发性不应该加锁，上锁是为了方便看输出
  m.lock();
  F* temp = (F*)arg;
  //获取文件的序号
  //int file_id = temp->id;
  //获取客户机的端口号
  //ntohs(temp -> clientAddr.sin_port); 
  cout << "测试开始,等待客户端发送消息..." << endl;
  //从客户端处接受数据
  char Buffer[MAXBYTE] = { 0 }; //缓冲区
  recv(temp->clientSocket, Buffer, MAXBYTE, 0); //recv方法 从客户端通过clientScocket接收
  cout << "线程" << temp->id << "从客户端的" << ntohs(temp->clientAddr.sin_port) << "号端口收到:" << Buffer << endl;
  //发送简单的字符串到客户端
  const char* s = "Server file";
  send(temp->clientSocket, s, strlen(s) * sizeof(char) + 1, NULL);
  cout << "线程" << temp->id << "通过客户端的" << ntohs(temp->clientAddr.sin_port) << "号端口发送:" << s << endl;
  m.unlock();
  return 0;
}
int main()
{
  //加载winsock库,第一个参数是winsocket load的版本号（2.3）
  WSADATA wsaData;
  WSAStartup(MAKEWORD(2, 3), &wsaData);
  
  //创建服务器端的socket（协议族， sokcet类型）
  SOCKET servSocket = socket(AF_INET, SOCK_STREAM, 0);//如果改成SOCK_DGRAM则使用UDP
  
  // 初始化socket信息
  sockaddr_in servAddr; //服务器的socket地址，包含sin_addr表示IP地址，sin_port保持端口号和sin_zero填充字节
  memset(&servAddr, 0, sizeof(SOCKADDR)); //初始化socket地址
  
  //设置Socket的连接地址、方式和端口，并绑定
  servAddr.sin_family = PF_INET;                //设置使用的协议族
  servAddr.sin_port = htons(2017);              //设置使用的端口
  servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");  //设置绑定的IP地址
  ::bind(servSocket, (SOCKADDR*)&servAddr, sizeof(SOCKADDR)); //将之前创建的servSocket和端口，IP地址绑定
  HANDLE hThread[20];   //获取句柄
  listen(servSocket, 20); //监听服务器端口，最多20个连接
  for (int i = 0; i < 20; i++)
  {
    F* temp = new F; //创建新的传输结构体
    sockaddr_in clntAddr;
    int nSize = sizeof(SOCKADDR);
    SOCKET clientSock = accept(servSocket, (SOCKADDR*)&clntAddr, &nSize);
    //temp数据成员赋值
    temp->clientSocket = clientSock;
    temp->id = i + 1;
    temp->clientAddr = clntAddr;
    //通过句柄创建子线程
    hThread[i] = CreateThread(NULL, 0, &transmmit, temp, 0, NULL);
  }
  //等待子线程完成
  WaitForMultipleObjects(20, hThread, TRUE, INFINITE);
  cout << WSAGetLastError() << endl; //查看错误信息
  //关闭socket，释放winsock
  closesocket(servSocket);
  WSACleanup();
  cout << "服务器连接已关闭。" << endl;
  system("pause");
  return 0;
}

# 导入 socket模块
import socket
# 创建一个socket对象
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = "连接者电脑的ipv4"
port = 7777
# host = "10.225.146.20"
# port = 8888
# 连接服务端
print("Socket通信客服端")
client.connect((host, port))
while True:
    send_msg = input("发送: ")
    # 设置退出条件
    if send_msg == "q":
        break
    send_msg = send_msg
    # 发送数据，编码
    client.send(send_msg.encode("utf-8"))
    # 接收服务端返回的数据
    msg = client.recv(1024)
    # 解码
    print("接收：%s" % msg.decode("utf-8"))
# 关闭客户端
client.close()

import socket
# 创建一个socket对象
socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = "自己电脑的ipv4"
port = 8888
# 10.225.150.102
# port = 8888
# 绑定地址
socket_server.bind((host, port))
# 设置监听
socket_server.listen(5)
# socket_server.accept()返回一个元组, 元素1为客户端的socket对象, 元素2为客户端的地址(ip地址，端口号)
client_socket, address = socket_server.accept()
print("Socket通信服务器端")
# while循环是为了让对话持续
while True:
    # 接收客户端的请求
    recvmsg = client_socket.recv(1024)
    # 把接收到的数据进行解码
    strData = recvmsg.decode("utf-8")
    # 设置退出条件
    if strData == 'q':
        break
    print("接收: %s" % strData)
    # 输入
    msg = input("发送: ")
    # 发送数据，需要进行编码
    client_socket.send(msg.encode("utf-8"))
# 关闭服务器端
socket_server.close()

package com.example.hello;
import java.io.*;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
public class Handler extends Thread{
    protected Socket socket;
    public  Handler(Socket socket) {
        this.socket=socket;
    }
    @Override
    public void run() {
        try(InputStream input=this.socket.getInputStream()){
            try(OutputStream output=this.socket.getOutputStream()) {
                handle(input,output);
            } catch (Exception e) {
            }
        } catch (Exception e) {
            try {
                this.socket.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
    private void handle(InputStream input, OutputStream output) throws IOException {
        BufferedReader reader=new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8)) ;
        BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(output,StandardCharsets.UTF_8));
        // 读取http请求
        boolean requestOk=false;
        String first=reader.readLine();
        if (first.startsWith("GET / HTTP/")) {
            requestOk=true;
        }
        for(;;){
            String header=reader.readLine();
            // 读取头部信息为空时,HTTP Header读取完毕
            if (header.isEmpty()) {
                break;
            }
            System.out.println(header);
        }
        System.out.println(requestOk ? "Response OK" : "Response Error");
        // 请求失败
        if (!requestOk) {
            // 发送错误响应:
            writer.write("HTTP/1.0 404 Not Found\r\n");
            writer.write("Content-Length: 0\r\n");
            writer.write("\r\n");
            writer.flush();
        }else {
            // 请求成功
            // 发送成功响应:
            String data = "<html><body><h1>Hello, world!</h1></body></html>";
            int length = data.getBytes(StandardCharsets.UTF_8).length;
            writer.write("HTTP/1.1 200 OK\r\n");
            writer.write("Connection: close\r\n");
            writer.write("Content-Type: text/html\r\n");
            writer.write("Content-Length: " + length + "\r\n");
            writer.write("\r\n"); // 空行标识Header和Body的分隔
            writer.write(data);
            writer.flush();
        }
    }
}

package com.example.hello;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class HttpServer {
    public static void main(String[] args) throws IOException {
        // 监听8888端口
        ServerSocket serverSocket=new ServerSocket(8888);
        System.out.println("server is running...");
        while(true){
            Socket socket=serverSocket.accept();// 监听
            System.out.println("connected from " + socket.getRemoteSocketAddress());
            Thread t = new Handler(socket);
            t.start();
        }
    }
}