HTTP响应状态码405表示"Method Not Allowed"，指示服务器不允许使用请求中指定的HTTP方法。

当收到HTTP响应状态码405时，说明发送的请求使用了服务器不支持的HTTP方法。常见的HTTP方法包括GET、POST、PUT、DELETE等。服务器可能会限制对某些资源的特定HTTP方法的访问。

要解决这个问题，您可以采取以下几个步骤：

1. 确认使用的HTTP方法：检查您发送请求时使用的HTTP方法是否正确。确保使用的HTTP方法是服务器允许的方法之一。

2. 检查请求URL：确认请求的URL是否正确。确保URL对应的资源存在，并且使用的HTTP方法是允许的。

3. 检查服务器配置：检查服务器端的配置是否正确。有时服务器可能会配置特定URL或资源只能使用特定的HTTP方法。您可以与服务器管理员或开发人员联系，以确认服务器配置是否符合您的预期。

可能使用post方法去请求GET路由什么什么的

HTTP请求响应码--405

HTTP 400 状态码是客户端错误的一种表示，它表示服务器无法理解或处理客户端发送的请求。HTTP 400 错误通常与请求中的语法问题、无效的参数或格式错误等相关。

以下是一些常见的情况，可能导致服务器返回 HTTP 400 状态码：

1. 语法错误：请求中存在语法错误，例如无效的请求行、请求头或请求体格式不正确。

2. 无效的参数：请求中包含了无效的参数，或者参数的值不符合服务器的预期。

3. 缺少必需参数：请求缺少了服务器所需的必需参数，导致服务器无法正确处理请求。

4. 参数格式错误：请求中的参数格式不符合服务器的要求，例如日期格式、数字格式等错误。

5. 请求体解析失败：如果请求包含请求体，并且服务器无法解析请求体的内容，可能会导致 HTTP 400 错误。

HTTP 400 错误可能会附带一些额外的信息，如错误消息或错误代码，以提供更具体的错误描述。这些信息通常包含在响应的主体或响应头中。

遇到 HTTP 400 错误时，建议检查请求的语法、参数和格式是否正确，并确保请求符合服务器的要求。

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

HTTP请求响应码--400

我们来写一个简单的SSE服务端，SSE全名`Server-Send-Event`服务端五秒钟向客户端推送一条消息，SSE建立连接主要有接下来几个过程

- 设置`Content-Type`为`text/event-stream`
- s设置`keeplive`
- 禁用浏览器缓存

代码如下
```go

// 设置响应头，指定内容类型为text/event-stream
w.Header().Set("Content-Type", "text/event-stream")
// 设置连接保持活跃，以便服务器可以持续向客户端发送事件
w.Header().Set("Connection", "keep-alive")
// 禁用缓存
w.Header().Set("Cache-Control", "no-cache")

```
接下来就是用`GET`请求进行握手，像`WebSocket`一样，中间要检查一次客户端是否支持`SSE`,因为它是新标准，按理说主流浏览器都已支持，握手之后，客户端和服务端就会保持一个长连接，服务端可以主动给客户端推送信息，但是客户端不能像服务端推送信息，他只能收信息。
```go
package main

import (
	"fmt"
	"net/http"
	"time"
)

func main() {
	http.HandleFunc("/events", eventHandler)
	http.ListenAndServe(":8080", nil)
}

func eventHandler(w http.ResponseWriter, r *http.Request) {
	// 设置响应头，指定内容类型为text/event-stream
	w.Header().Set("Content-Type", "text/event-stream")
	// 设置连接保持活跃，以便服务器可以持续向客户端发送事件
	w.Header().Set("Connection", "keep-alive")
	// 禁用缓存
	w.Header().Set("Cache-Control", "no-cache")
	// 将响应写入到HTTP响应流
	flusher, ok := w.(http.Flusher)
	if !ok {
		http.Error(w, "Streaming unsupported!", http.StatusInternalServerError)
		return
	}

	// 模拟每5秒向客户端推送一条消息
	ticker := time.NewTicker(5 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-ticker.C:
			// 生成要发送的消息
			message := fmt.Sprintf("Message received at: %s\n", time.Now().Format("2006-01-02 15:04:05"))
			// 将消息写入响应流
			fmt.Fprintf(w, "data: %s\n\n", message)
			// 刷新响应流，将数据发送给客户端
			flusher.Flush()
		case <-r.Context().Done():
			// 如果客户端关闭连接，则终止循环
			return
		}
	}
}
```

有一些IM系统利用SSE来进行和客户端的长连接，负责消息下行通道，，上行通道有一个维持一两分钟的短连接来进行，这样可以减少资源的占用，主流做法是上行通道和下行通道各维持一个长链接（通常是`websockt`）,对于高并发的场景，可能很浪费资源。

客户端也很简单，就是发送一个`GET`请求握手，之后在一个死循环里等待消息到来。
```go
package main

import (
	"bufio"
	"fmt"
	"log"
	"net/http"
	"strings"
	"time"
)

func main() {
	client := &http.Client{}
	req, err := http.NewRequest("GET", "http://localhost:8080/events", nil)
	if err != nil {

		log.Fatal("Failed to create request:", err)
	}


	req.Header.Set("Accept", "text/event-stream")

	resp, err := client.Do(req)
	if err != nil {
		log.Fatal("Failed to connect to SSE server:", err)
	}
	defer resp.Body.Close()


	if resp.StatusCode != http.StatusOK {
		log.Fatal("SSE server returned an error:", resp.Status)
	}

	reader := bufio.NewReader(resp.Body)
	for {
		event, err := readSSEEvent(reader)
		if err != nil {
			log.Fatal("Failed to read SSE event:", err)
		}


		fmt.Println(event.Data)



		time.Sleep(2 * time.Second)
	}
}


func readSSEEvent(reader *bufio.Reader) (*Event, error) {
	event := &Event{}

	for {
		line, err := reader.ReadString('\n')
		if err != nil {
			return nil, err
		}


		line = strings.TrimSuffix(line, "\n")

		if line == "" {
			break
		}

		event.Data = line

	}

	return event, nil
}


type Event struct {
	Data string
}
```

这就是全部代码。接下来基于`SSE`实现一个发布订阅系统。


SSE简单示例

接下来是一个用`github.com/afocus/captcha`库生成验证码的示例
```go
package main

import (
	"image/color"
	"image/png"
	"net/http"

	"github.com/afocus/captcha"
)

var cap *captcha.Captcha

func main() {

	cap = captcha.New()

	if err := cap.SetFont("comic.ttf"); err != nil {
		panic(err.Error())
	}

	/*
	   //We can load font not only from localfile, but also from any []byte slice
	   	fontContenrs, err := ioutil.ReadFile("comic.ttf")
	   	if err != nil {
	   		panic(err.Error())
	   	}

	   	err = cap.AddFontFromBytes(fontContenrs)
	   	if err != nil {
	   		panic(err.Error())
	   	}
	*/

	cap.SetSize(150, 100)
	cap.SetDisturbance(captcha.HIGH)
	cap.SetFrontColor(color.RGBA{255, 255, 255, 255})
	cap.SetBkgColor(color.RGBA{255, 0, 0, 255}, color.RGBA{0, 0, 255, 255}, color.RGBA{0, 153, 0, 255})

	http.HandleFunc("/r", func(w http.ResponseWriter, r *http.Request) {
		img, str := cap.Create(6, captcha.ALL)
		png.Encode(w, img)
		println(str)
	})

	http.HandleFunc("/c", func(w http.ResponseWriter, r *http.Request) {
		str := r.URL.RawQuery
		img := cap.CreateCustom(str)
		png.Encode(w, img)
	})

	http.ListenAndServe(":8085", nil)

}
```
除却这些代码，还需要包含特定字体

![image.png](/static/img/e1c0e26d1c54f6351e1ed10fae087ba8.image.webp)
包含字体的.ttf文件，切记，这个库大小超过150 x 150,生成的验证码会出现不可识别的情况，所以适合生成小型验证码需求


小型验证码图片生成

接下来讲解一下用`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`。