接下来讲解一下用`unshare`和`clone`来创建NetWork NameSpace,先讲解一下这两个API:

***unshare***

`unshare`用于将当前进程分离（unshare）出指定的命名空间（namespace）。它允许进程创建独立于父进程的命名空间，从而实现进程在不同命名空间中运行的隔离。

```c

#include <sched.h>

int unshare(int flags);
```

- `flags`：指定要分离的命名空间类型，可以使用以下标志的按位或运算进行组合：
  - `CLONE_NEWNS`：分离挂载命名空间（Mount Namespace）。
  - `CLONE_NEWUTS`：分离UTS命名空间。
  - `CLONE_NEWIPC`：分离IPC命名空间。
  - `CLONE_NEWPID`：分离PID命名空间。
  - `CLONE_NEWNET`：分离网络命名空间。
  - `CLONE_NEWUSER`：分离用户命名空间。
  - `CLONE_NEWCGROUP`：分离控制组命名空间。
  - `CLONE_NEWTIME`：分离时间命名空间（自Linux 5.6起可用）。

成功调用`unshare`函数会将当前进程分离出指定的命名空间，并创建一个新的独立命名空间。在新的命名空间中，进程可以执行与父进程隔离的操作，例如挂载文件系统、更改主机名、配置网络接口等。

`unshare`函数只分离命名空间，具体的命名空间配置需要在调用`unshare`之后进行，例如使用`mount`函数挂载文件系统、`sethostname`函数设置主机名等。

***clone***

`clone`用于创建一个新的进程，并可以选择性地与父进程共享或分离多个资源，包括进程空间、文件系统、信号处理等。



```c

#include <sched.h>

int clone(int (*fn)(void *), void *child_stack, int flags, void *arg, ...);
```

- `fn`：指向子进程要执行的函数的指针。该函数应该具有 `int` 类型的返回值，接受一个 `void*` 类型的参数。
- `child_stack`：指向子进程栈的指针。子进程会在一个新的栈空间中执行，`child_stack` 指向该栈的顶部。栈应该是独立分配的，并且具有足够的空间来容纳子进程执行所需的栈帧。
- `flags`：用于指定创建子进程时的行为和资源共享方式的标志位，可以使用以下标志的按位或运算进行组合：
  - `CLONE_CHILD_CLEARTID`：子进程在调用`exec`函数或退出时，会将`tid`置为0。
  - `CLONE_CHILD_SETTID`：子进程在调用`exec`函数或退出时，会将`tid`置为子进程ID。
  - `CLONE_FILES`：子进程与父进程共享文件描述符表。
  - `CLONE_FS`：子进程与父进程共享文件系统信息。
  - `CLONE_IO`：子进程与父进程共享I/O上下文。
  - `CLONE_NEWIPC`：子进程创建一个新的IPC命名空间。
  - `CLONE_NEWNET`：子进程创建一个新的网络命名空间。
  - `CLONE_NEWNS`：子进程创建一个新的挂载命名空间。
  - `CLONE_NEWPID`：子进程创建一个新的PID命名空间。
  - `CLONE_NEWUTS`：子进程创建一个新的UTS命名空间。
  - `CLONE_NEWUSER`：子进程创建一个新的用户命名空间。
  - `CLONE_NEWCGROUP`：子进程创建一个新的控制组命名空间。
  - `CLONE_PARENT`：子进程的父进程为调用`clone`的进程。
  - `CLONE_PARENT_SETTID`：子进程的父进程ID会存储在`ptid`中。
  - `CLONE_PTRACE`：子进程与父进程共享`ptrace`。
  - `CLONE_SETTLS`：子进程的线程局部存储与父进程相同。
  - `CLONE_SIGHAND`：子进程与父进程共享信号处理程序。
  - `CLONE_SYSVSEM`：子进程与父进程共享System V信号量。
  - `CLONE_THREAD`：子进程创建为与父进程共享线程组的线程。
  - `CLONE_UNTRACED`：子进程创建后不会受到`ptrace`跟踪。
  - `CLONE_VFORK`：子进程使用父进程的页表直到调用`exec`或者调用`_exit`退出。
  - `CLONE_VM`：子进程与父进程共享内存空间。
- `arg`：传递给子进程函数的参数。


`clone` 函数创建一个新的进程，并在子进程中执行指定的函数。子进程的执行流程会从 `fn` 指向的函数开始。`child_stack` 参数指定子进程的栈空间，`flags` 参数用于指定资源的共享方式。子进程创建成功后，`clone` 函数会返回子进程的进程ID。

接下来是调用示例:

```c
#define _GNU_SOURCE
#include <stdio.h>
#include <sched.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define STACK_SIZE 65536

static int child_func(void *arg) {
    // 在子进程中，进行需要在独立网络命名空间中运行的操作
    printf("Child process: PID=%ld\n", (long) getpid());

    // 在子进程中，可以进行网络相关的操作，例如配置网络接口、设置IP地址等

    sleep(10); // 模拟子进程在网络命名空间中的操作

    printf("Child process: Exiting\n");
    return 0;
}

int main() {
    printf("Parent process: PID=%ld\n", (long) getpid());

    // 为子进程分配栈空间
    char *stack = malloc(STACK_SIZE);
    if (stack == NULL) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }

    // 使用clone创建子进程，并指定CLONE_NEWNET标志来创建独立网络命名空间
    pid_t child_pid = clone(child_func, stack + STACK_SIZE, CLONE_NEWNET | SIGCHLD, NULL);
    if (child_pid == -1) {
        perror("clone");
        exit(EXIT_FAILURE);
    }

    // 在父进程中，可以继续进行其他操作

    sleep(5); // 模拟父进程的操作

    printf("Parent process: Waiting for child process to exit...\n");
    waitpid(child_pid, NULL, 0); // 等待子进程退出

    printf("Parent process: Exiting\n");
    return 0;
}
```

```c
#define _GNU_SOURCE
#include <stdio.h>
#include <sched.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    printf("Parent process: PID=%ld\n", (long) getpid());

    printf("Parent process: Creating a new network namespace...\n");

    // 创建独立的网络命名空间
    if (unshare(CLONE_NEWNET) == -1) {
        perror("unshare");
        exit(EXIT_FAILURE);
    }

    printf("Parent process: In the new network namespace\n");

    // 在新的网络命名空间中，可以进行网络相关的操作，例如配置网络接口、设置IP地址等

    sleep(10); // 模拟在网络命名空间中的操作

    printf("Parent process: Exiting\n");
    return 0;
}
```


以上程序经过运行测试，必须要用root权限才能创建`namespace`。

创建NameSpace

我们可以很简单得用`github.com/gorilla/websocket`来实现一个websocket，先用GET请求进行握手，然后直接升级协议
```go
var upgrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		// 允许所有的跨域请求
		return true
	},
}
```
我们先来获取一个用于升级协议的对象。
```go
func echoHandler(w http.ResponseWriter, r *http.Request) {
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Println("WebSocket upgrade error:", err)
		return
	}
	defer conn.Close()




	for {
		// 读取客户端发送的消息
		_, message, err := conn.ReadMessage()
		if err != nil {
			log.Println("WebSocket read error:", err)
			break
		}

		// 打印接收到的消息
		log.Printf("Received message from client: %s", message)

		// 发送消息给客户端
		err = conn.WriteMessage(websocket.TextMessage, message)
		if err != nil {
			log.Println("WebSocket write error:", err)
			break
		}
	}
}
```

定义一个简单的处理函数

```go
    http.HandleFunc("/echo", echoHandler)//默认处理GET请求
	log.Fatal(http.ListenAndServe(":8080", nil))
```

开始监听这个服务


接下来实现一个简单的客户端，建立起一个简单的websocket链接
```go
package main

import (
	"fmt"
	"log"
	"net/url"
	"os"
	"os/signal"
	"time"

	"github.com/gorilla/websocket"
)

func main() {
	interrupt := make(chan os.Signal, 1)
	signal.Notify(interrupt, os.Interrupt)

	u := url.URL{Scheme: "ws", Host: "localhost:3000", Path: "/ws"}
	log.Printf("connecting to %s", u.String())

	c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
	if err != nil {
		log.Fatal("WebSocket dial error:", err)
	}
	defer c.Close()

	done := make(chan struct{})
	go func() {
		defer close(done)
		for {
			_, message, err := c.ReadMessage()
			if err != nil {
				log.Println("WebSocket read error:", err)
				return
			}
			log.Printf("Received message from server: %s", message)
		}
	}()

	ticker := time.NewTicker(time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-done:
			return
		case t := <-ticker.C:
			message := []byte(fmt.Sprintf("Message sent at %v", t))
			err := c.WriteMessage(websocket.TextMessage, message)
			if err != nil {
				log.Println("WebSocket write error:", err)
				return
			}
			log.Printf("Sent message to server: %s", message)
		case <-interrupt:
			log.Println("Interrupt signal received")
			err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
			if err != nil {
				log.Println("WebSocket close error:", err)
				return
			}
			select {
			case <-done:
			case <-time.After(time.Second):
			}
			return
		}
	}
}

```
利用这个定时器来触发消息发送，运行这两个程序，可以实现双向通信，可以看到他们不断发送信息，你可以着手实现自己的业务逻辑。

gin框架中使用也很简单就是，把request和response从Context中取出就行。

```go
func SendWs(c *gin.Context) {
	ws, err := websocket.Upgrade(c.Writer, c.Request, nil, 1024, 1024)
	if err != nil {

		c.JSON(http.StatusBadRequest, gin.H{"error": "协议升级失败！"})
		return
	}

	for {
		// 读取客户端发送的消息
		_, msg, err := ws.ReadMessage()
		if err != nil {

			break
		}

		// 处理接收到的消息
		// 这里可以根据业务逻辑进行处理
		fmt.Println("收到:", string(msg))

		rep := "收到啦奥特曼！"
		// 回复消息给客户端
		err = ws.WriteMessage(websocket.TextMessage, []byte(rep))
		if err != nil {
			// 处理回复消息失败的情况
			break
		}
	}

	// 关闭WebSocket连接
	ws.Close()
}

```

可以看到，我们利用了`websocker.Upgrader`来升级协议，不是使用升级协议的那个对象，其实底层也是一样
```go
func Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header, readBufSize, writeBufSize int) (*Conn, error) {
	u := Upgrader{ReadBufferSize: readBufSize, WriteBufferSize: writeBufSize}
	u.Error = func(w http.ResponseWriter, r *http.Request, status int, reason error) {
		// don't return errors to maintain backwards compatibility
	}
	u.CheckOrigin = func(r *http.Request) bool {
		// allow all connections by default
		return true
	}
	return u.Upgrade(w, r, responseHeader)
}

```

只是设置了缓冲区大小，原来是直接创建对象的时候设置。

我们看一下这个`Upgrade`方法
```go
func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header) (*Conn, error) {
    // 定义错误消息
    const badHandshake = "websocket: the client is not using the websocket protocol: "

    // 检查 'Connection' 头是否包含 'upgrade' 标记
    if !tokenListContainsValue(r.Header, "Connection", "upgrade") {
        return u.returnError(w, r, http.StatusBadRequest, badHandshake+"'upgrade' token not found in 'Connection' header")
    }

    // 检查 'Upgrade' 头是否包含 'websocket' 标记
    if !tokenListContainsValue(r.Header, "Upgrade", "websocket") {
        return u.returnError(w, r, http.StatusBadRequest, badHandshake+"'websocket' token not found in 'Upgrade' header")
    }

    // 检查请求方法是否为 GET
    if r.Method != http.MethodGet {
        return u.returnError(w, r, http.StatusMethodNotAllowed, badHandshake+"request method is not GET")
    }

    // 检查 'Sec-Websocket-Version' 头是否为 13（WebSocket 版本）
    if !tokenListContainsValue(r.Header, "Sec-Websocket-Version", "13") {
        return u.returnError(w, r, http.StatusBadRequest, "websocket: unsupported version: 13 not found in 'Sec-Websocket-Version' header")
    }

    // 检查是否存在 'Sec-Websocket-Extensions' 头，不支持应用程序特定的扩展
    if _, ok := responseHeader["Sec-Websocket-Extensions"]; ok {
        return u.returnError(w, r, http.StatusInternalServerError, "websocket: application specific 'Sec-WebSocket-Extensions' headers are unsupported")
    }

    // 验证请求的来源是否被允许，可以通过 Upgrader.CheckOrigin 配置
    checkOrigin := u.CheckOrigin
    if checkOrigin == nil {
        checkOrigin = checkSameOrigin
    }
    if !checkOrigin(r) {
        return u.returnError(w, r, http.StatusForbidden, "websocket: request origin not allowed by Upgrader.CheckOrigin")
    }

    // 从请求头中获取 'Sec-Websocket-Key'，该键用于生成响应头的 'Sec-WebSocket-Accept'
    challengeKey := r.Header.Get("Sec-Websocket-Key")
    if challengeKey == "" {
        return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'Sec-WebSocket-Key' header is missing or blank")
    }

    // 选择子协议（Subprotocol）用于通信，如果有多个可选的子协议
    subprotocol := u.selectSubprotocol(r, responseHeader)

    // 协商 PMCE（Per-Message Compression Extension），用于数据传输时的数据压缩
    var compress bool
    if u.EnableCompression {
        for _, ext := range parseExtensions(r.Header) {
            if ext[""] != "permessage-deflate" {
                continue
            }
            compress = true
            break
        }
    }

    // 使用 http.Hijacker 接口获取底层连接
    h, ok := w.(http.Hijacker)
    if !ok {
        return u.returnError(w, r, http.StatusInternalServerError, "websocket: response does not implement http.Hijacker")
    }
    var brw *bufio.ReadWriter
    netConn, brw, err := h.Hijack()
    if err != nil {
        return u.returnError(w, r, http.StatusInternalServerError, err.Error())
    }

    // 如果有数据在握手完成前发送，关闭连接
    if brw.Reader.Buffered() > 0 {
        netConn.Close()
        return nil, errors.New("websocket: client sent data before handshake is complete")
    }

    var br *bufio.Reader
    if u.ReadBufferSize == 0 && bufioReaderSize(netConn, brw.Reader) > 256 {
        // 重用 hijacked 缓冲读取器作为连接读取器
        br = brw.Reader
    }

    buf := bufioWriterBuffer(netConn, brw.Writer)

    var writeBuf []byte
    if u.WriteBufferPool == nil && u.WriteBufferSize == 0 && len(buf) >= maxFrameHeaderSize+256 {
        // 重用 hijacked 写入缓冲作为连接缓冲
        writeBuf = buf
    }

    // 创建新的 Conn 对象表示 WebSocket 连接
    c := newConn(netConn, true, u.ReadBufferSize, u.WriteBufferSize, u.WriteBufferPool, br, writeBuf)
    c.subprotocol = subprotocol

    // 如果启用压缩，设置压缩和解压缩方法
    if compress {
        c.newCompressionWriter = compressNoContextTakeover
        c.newDecompressionReader = decompressNoContextTakeover
    }

    // 使用 hijacked 缓冲区和连接缓冲区作为头部
    p := buf
    if len(c.writeBuf) > len(p) {
        p = c.writeBuf
    }
    p = p[:0]

    // 构建 WebSocket 握手响应头部
    p = append(p, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "...)
    p = append(p, computeAcceptKey(challengeKey)...)
    p = append(p, "\r\n"...)
    if c.subprotocol != "" {
        p = append(p, "Sec-WebSocket-Protocol: "...)
        p = append(p, c.subprotocol...)
        p = append(p, "\r\n"...)
    }
    if compress {
        p = append(p, "Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover; client_no_context_takeover\r\n"...)
    }
    for k, vs := range responseHeader {
        if k == "Sec-Websocket-Protocol" {
            continue
        }
        for _, v := range vs {
            p = append(p, k...)
            p = append(p, ": "...)
            for i := 0; i < len(v); i++ {
                b := v[i]
                if b <= 31 {
                    // 防止响应分割
                    b = ' '
                }
                p = append(p, b)
            }
            p = append(p, "\r\n"...)
        }
    }
    p = append(p, "\r\n"...)

    // 清除 HTTP 服务器设置的截止日期
    netConn.SetDeadline(time.Time{})

    // 如果设置了握手超时，设置写入截止日期
    if u.HandshakeTimeout > 0 {
        netConn.SetWriteDeadline(time.Now().Add(u.HandshakeTimeout))
    }

    // 发送 WebSocket 握手响应头部到客户端
    if _, err = netConn.Write(p); err != nil {
        netConn.Close()
        return nil, err
    }

    // 如果设置了握手超时，取消写入截止日期
    if u.HandshakeTimeout > 0 {
        netConn.SetWriteDeadline(time.Time{})
    }

    return c, nil
}

```

主要做了一下事情
- 检查请求头中的Connection和Upgrade字段是否包含正确的值。
检查请求方法是否为GET。

- 检查请求头中的Sec-Websocket-Version字段是否为支持的版本。
- 检查响应头中是否包含非法的Sec-Websocket-Extensions字段。
- 检查请求来源是否通过CheckOrigin函数的验证。
- 获取握手请求中的Sec-Websocket-Key字段，用于生成响应头中的Sec-WebSocket-Accept字段。
- 选择子协议。
- 根据是否启用压缩，选择合适的压缩算法。
- 使用http.Hijacker接口将http.ResponseWriter转换为底层的网络连接。
- 创建*Conn对象，并设置相关属性，如缓冲区大小、子协议等。
- 构造握手响应头，并发送给客户端。
- 返回升级完成的*Conn对象。


最近拿着获取到的的对象进行通信。

websocket

最近在学习x86_64汇编，简单的写了个hello world,用strace跟踪和c语言对比，发现果然还是汇编简单粗暴
```
section .data
    hello db 'Hello, World!',0  ; 字符串以null结尾

section .text
    global _start

_start:
    ; 调用write系统调用 (syscall) 来写入字符串到标准输出 (文件描述符 1)
    mov rax, 1             ; 系统调用号: 1 (write)
    mov rdi, 1             ; 文件描述符: 1 (标准输出)
    mov rsi, hello         ; 字符串的地址
    mov rdx, 13            ; 字符串的长度
    syscall


    ; 调用exit系统调用 (syscall) 来退出程序
    mov rax, 60            ; 系统调用号: 60 (exit)
    xor rdi, rdi           ; 退出码: 0
    syscall
```

接下来需要下载asm汇编器和ld链接器，一般这两个ubuntu会预装，或者gcc顺带着
```
sudo apt-get updata
sudo apt-get install nasm


nasm -v

sudo apt install binutils
ld -v
```
接下来需要用汇编器将汇编代码装换成二进制文件,再用链接器连接到同一个执行文件
```
nasm -f elf64 -o hello.o hello.asm

ld -o hello hello.o
```
接下来直接执行`./hello` 

![image.png](/static/img/14573ba6028b7bbb00642034c5ad7e11.image.webp)


execve是用来执行一个新程序的系统调用,可以看到，整个过程就执行了一个write和一个exit ,我们来就看一下c语言

![image.png](/static/img/ee71cbfe079a114ecf1432820b8a9791.image.webp)

这里面主要是调用一些动态库（用mmap），最后还是调用write 来进行写入。
