poc

func NewDefaultPoCConfig ¶

func NewDefaultPoCConfig() *PocConfig

func WithAppendCookie ¶

func WithAppendCookie(key, value string) PocConfigOption

appendCookie 是一个请求选项参数，用于改变请求报文，添加 Cookie 请求头中的值 Example: ``` poc.Get("https://pie.dev/get", poc.appendCookie("aaa", "bbb")) // 向 pie.dev 发起请求，添加cookie键值对aaa:bbb ```

func WithAppendHeader ¶

func WithAppendHeader(key, value string) PocConfigOption

appendHeader 是一个请求选项参数，用于改变请求报文，添加请求头 Example: ``` poc.Post("https://pie.dev/post", poc.appendHeader("AAA", "BBB")) // 向 pie.dev 发起请求，添加AAA请求头的值为BBB ```

func WithAppendHeaderIfNotExist ¶

func WithAppendHeaderIfNotExist(key, value string) PocConfigOption

func WithAppendHeaders ¶

func WithAppendHeaders(headers map[string]string) PocConfigOption

appendHeaders 是一个请求选项参数，用于改变请求报文，添加请求头 Example: ``` poc.Post("https://pie.dev/post", poc.appendHeaders({"AAA": "BBB","CCC": "DDD"})) // 向 pie.dev 发起请求，添加AAA请求头的值为BBB ```

func WithAppendHttpPacketFormEncoded ¶

func WithAppendHttpPacketFormEncoded(key, value string) PocConfigOption

appendFormEncoded 是一个请求选项参数，用于改变请求报文，添加请求体中的表单 Example: ``` poc.Post("https://pie.dev/post", poc.appendFormEncoded("aaa", "bbb")) // 向 pie.dev 发起请求，添加POST请求表单，其中aaa为键，bbb为值 ```

func WithAppendHttpPacketPath ¶

func WithAppendHttpPacketPath(path string) PocConfigOption

appendPath 是一个请求选项参数，用于改变请求报文，在现有请求路径后添加请求路径 Example: ``` poc.Get("https://yaklang.com/docs", poc.appendPath("/api/poc")) // 向 yaklang.com 发起请求，实际上请求路径为/docs/api/poc ```

func WithAppendHttpPacketUploadFile ¶

func WithAppendHttpPacketUploadFile(fieldName, fileName string, fileContent interface{}, contentType ...string) PocConfigOption

appendUploadFile 是一个请求选项参数，用于改变请求报文，添加请求体中的上传的文件，其中第一个参数为表单名，第二个参数为文件名，第三个参数为文件内容，第四个参数是可选参数，为文件类型(Content-Type) Example: ``` poc.Post("https://pie.dev/post", poc.appendUploadFile("file", "phpinfo.php", "<?php phpinfo(); ?>", "image/jpeg"))// 向 pie.dev 发起请求，添加POST请求表单，其文件名为phpinfo.php，内容为<?php phpinfo(); ?>，文件类型为image/jpeg ```

func WithAppendPostParam ¶

func WithAppendPostParam(key, value string) PocConfigOption

appendPostParam 是一个请求选项参数，用于改变请求报文，添加 POST 请求参数 Example: ``` poc.Post("https://pie.dev/post", poc.appendPostParam("a", "b")) // 向 pie.dev 发起请求，添加POST请求参数a，值为b ```

func WithAppendQueryParam ¶

func WithAppendQueryParam(key, value string) PocConfigOption

appendQueryParam 是一个请求选项参数，用于改变请求报文，添加 GET 请求参数 Example: ``` poc.Get("https://pie.dev/get", poc.appendQueryParam("a", "b")) // 向 pie.dev 发起请求，添加GET请求参数a，值为b ```

func WithBody ¶

func WithBody(i any) PocConfigOption

body 是一个请求选项参数，用于指定请求的 body，需要传入一个任意类型的参数，如果不是 string 或者 bytes 会抛出日志并忽略。 Example: ``` poc.Post("https://www.example.com", poc.body("a=b")) // 向 www.example.com 发起请求，请求的 body 为 a=b ```

func WithBodyStreamReaderHandler ¶ added in v1.3.2

func WithBodyStreamReaderHandler(i func(r []byte, closer io.ReadCloser)) PocConfigOption

stream 是一个请求选项参数，可以设置一个回调函数，如果 body 读取了，将会复制一份给这个流，在这个流中处理 body 是不会影响最终结果的，一般用于处理较长的 chunk 数据

func WithClientHelloSpec ¶

func WithClientHelloSpec(spec *utls.ClientHelloSpec) PocConfigOption

not export

func WithConnPool ¶ added in v1.3.1

func WithConnPool(b bool) PocConfigOption

connPool 是一个请求选项参数，用于指定是否使用连接池，默认不使用连接池 Example: ``` rsp, req, err = poc.HTTP(x`POST /post HTTP/1.1 Content-Type: application/json Host: pie.dev

{"key": "asd"}`, poc.connPool(true)) // 使用连接池发送请求，这在发送多个请求时非常有用 ```

func WithConnectTimeout ¶ added in v1.3.1

func WithConnectTimeout(f float64) PocConfigOption

connectTimeout 是一个请求选项参数，用于指定连接超时时间，默认为15秒 Example: ``` poc.Get("https://www.example.com", poc.timeout(15)) // 向 www.baidu.com 发起请求，读取超时时间为15秒 ```

func WithContext ¶ added in v1.3.1

func WithContext(ctx context.Context) PocConfigOption

context 是一个请求选项参数，用于指定请求的上下文 Example: ``` ctx = context.New() poc.Get("https://exmaple.com", poc.withContext(ctx)) // 向 example.com 发起请求，使用指定的上下文 ```

func WithCookieFull ¶

func WithCookieFull(c string, values ...any) PocConfigOption

cookie 是一个请求选项参数，用于改变请求报文，添加 Cookie 请求头中的值 Example: ``` poc.Get("https://pie.dev/get", poc.cookie("a=b; c=d")) // 向 pie.dev 发起请求，添加Cookie请求头，其值为a=b; c=d poc.Get("https://pie.dev/get", poc.cookie("a", "b")) // 向 pie.dev 发起请求，添加Cookie请求头，其值为a=b ```

func WithDNSNoCache ¶ added in v1.3.1

func WithDNSNoCache(b bool) PocConfigOption

dnsNoCache 是一个请求选项参数，用于指定请求时不使用DNS缓存，默认使用DNS缓存 Example: ``` // 向 example.com 发起请求，不使用DNS缓存 poc.Get("https://exmaple.com", poc.dnsNoCache(true)) ```

func WithDNSServers ¶ added in v1.3.1

func WithDNSServers(servers ...string) PocConfigOption

dnsServer 是一个请求选项参数，用于指定请求所使用的DNS服务器，默认使用系统自带的DNS服务器 Example: ``` // 向 example.com 发起请求，使用指定的DNS服务器 poc.Get("https://exmaple.com", poc.dnsServer("8.8.8.8", "1.1.1.1")) ```

func WithDeleteCookie ¶

func WithDeleteCookie(key string) PocConfigOption

deleteCookie 是一个请求选项参数，用于改变请求报文，删除 Cookie 中的值 Example: ``` poc.HTTP(`GET /get HTTP/1.1 Content-Type: application/json Cookie: aaa=bbb; ccc=ddd Host: pie.dev

`, poc.deleteCookie("aaa"))// 向 pie.dev 发起请求，删除Cookie中的aaa ```

func WithDeleteForm ¶

func WithDeleteForm(key string) PocConfigOption

deleteForm 是一个请求选项参数，用于改变请求报文，删除 POST 请求表单 Example: ``` poc.HTTP(`POST /post HTTP/1.1 Host: pie.dev Content-Type: multipart/form-data; boundary=------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Length: 308

--------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Disposition: form-data; name="aaa"

bbb --------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Disposition: form-data; name="ccc"

ddd --------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm--`, poc.deleteForm("aaa")) // 向 pie.dev 发起请求，删除POST请求表单aaa ```

func WithDeleteHeader ¶

func WithDeleteHeader(key string) PocConfigOption

deleteHeader 是一个请求选项参数，用于改变请求报文，删除请求头 Example: ``` poc.HTTP(`GET /get HTTP/1.1 Content-Type: application/json AAA: BBB Host: pie.dev

`, poc.deleteHeader("AAA"))// 向 pie.dev 发起请求，删除AAA请求头 ```

func WithDeletePostParam ¶

func WithDeletePostParam(key string) PocConfigOption

deletePostParam 是一个请求选项参数，用于改变请求报文，删除 POST 请求参数 Example: ``` poc.HTTP(`POST /post HTTP/1.1 Content-Type: application/json Content-Length: 7 Host: pie.dev

a=b&c=d`, poc.deletePostParam("a")) // 向 pie.dev 发起请求，删除POST请求参数a ```

func WithDeleteQueryParam ¶

func WithDeleteQueryParam(key string) PocConfigOption

deleteQueryParam 是一个请求选项参数，用于改变请求报文，删除 GET 请求参数 Example: ``` poc.HTTP(`GET /get?a=b&c=d HTTP/1.1 Content-Type: application/json Host: pie.dev

`, poc.deleteQueryParam("a")) // 向 pie.dev 发起请求，删除GET请求参数a ```

func WithEnableRandomChunked ¶

func WithEnableRandomChunked(b bool) PocConfigOption

randomChunked 是一个请求选项参数，用于启用随机分块传输，默认不启用 Example: ``` data = ` POST /post HTTP/1.1 Host: pie.dev Content-Type: multipart/form-data; boundary=------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Length: 308

--------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Disposition: form-data; name="aaa"

bbb --------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Disposition: form-data; name="ccc"

ddd --------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm-- `

poc.HTTP(data,poc.randomChunked(true),poc.randomChunkedLength(10,25),poc.randomChunkedDelay(50,200))~ ```

func WithFixQueryEscape ¶

func WithFixQueryEscape(b bool) PocConfigOption

fixQueryEscape 是一个请求选项参数，用于指定是否修复查询参数中的 URL 编码，默认为 false 即会自动修复URL编码 Example: ``` poc.HTTP(poc.BasicRequest(), poc.fixQueryEscape(true)) // 向 example.com 发起请求，如果查询参数中的 URL 编码不正确或不存在也不会自动修复URL编码 ```

func WithForceHTTP2 ¶

func WithForceHTTP2(isHttp2 bool) PocConfigOption

http2 是一个请求选项参数，用于指定是否使用 http2 协议，默认为 false 即使用http1协议 Example: ``` poc.Get("https://www.example.com", poc.http2(true), poc.https(true)) // 向 www.example.com 发起请求，使用 http2 协议 ```

func WithForceHTTPS ¶

func WithForceHTTPS(isHttps bool) PocConfigOption

https 是一个请求选项参数，用于指定是否使用 https 协议，默认为 false 即使用 http 协议 Example: ``` poc.HTTP(poc.BasicRequest(), poc.https(true)) // 向 example.com 发起请求，使用 https 协议 ```

func WithFromPlugin ¶

func WithFromPlugin(b string) PocConfigOption

func WithGmTLSPrefer ¶

func WithGmTLSPrefer() PocConfigOption

func WithGmTls ¶

func WithGmTls() PocConfigOption

func WithGmTlsOnly ¶

func WithGmTlsOnly() PocConfigOption

func WithHost ¶

func WithHost(h string) PocConfigOption

host 是一个请求选项参数，用于指定实际请求的 host，如果没有设置该请求选项，则会依据原始请求报文中的Host字段来确定实际请求的host Example: ``` poc.HTTP(poc.BasicRequest(), poc.host("yaklang.com")) // 实际上请求 yaklang.com ```

func WithJSON ¶

func WithJSON(i any) PocConfigOption

json 是一个请求选项参数，用于指定请求的 body 为 json 格式，需要传入一个任意类型的参数，会自动转换为 json 格式 Example: ``` poc.Post("https://www.example.com", poc.json({"a": "b"})) // 向 www.example.com 发起请求，请求的 body 为 {"a": "b"} 并自动设置 Content-Type 为 application/json ```

func WithJSRedirect ¶

func WithJSRedirect(b bool) PocConfigOption

jsRedirect 是一个请求选项参数，用于指定是否跟踪JS重定向，默认为false即不会自动跟踪JS重定向 Example: ``` poc.HTTP(poc.BasicRequest(), poc.redirectTimes(5), poc.jsRedirect(true)) // 向 www.baidu.com 发起请求，如果响应重定向到其他链接也会自动跟踪JS重定向，最多进行5次重定向 ```

func WithMITMRule ¶

func WithMITMRule(b bool) PocConfigOption

mitmRule 是一个请求选项参数，用于指定是否使用MITM规则，默认为false即不会使用MITM规则，使用规则可以完成流量染色，附加tag与提取数据的功能 Example: ``` poc.Get("https://exmaple.com", poc.save(true), poc.mitmReplacer(true)) ```

func WithNoBodyBuffer ¶

func WithNoBodyBuffer(b bool) PocConfigOption

noBodyBuffer 是一个请求选项参数，用于指定是否禁用响应体缓冲，设置为 true 时可以避免大文件下载时的内存占用 通常与 WithBodyStreamReaderHandler 配合使用，用于流式处理大文件 Example: ``` poc.Get("https://example.com/large-file.zip",

poc.noBodyBuffer(true),
poc.bodyStreamHandler(func(header, body) {
    // 流式处理响应体，不会将整个文件读入内存
    io.Copy(file, body)
}))

```

func WithNoFixContentLength ¶

func WithNoFixContentLength(b bool) PocConfigOption

noFixContentLength 是一个请求选项参数，用于指定是否修复响应报文中的 Content-Length 字段，默认为 false 即会自动修复Content-Length字段 Example: ``` poc.HTTP(poc.BasicRequest(), poc.noFixContentLength()) // 向 example.com 发起请求，如果响应报文中的Content-Length字段不正确或不存在 也不会自动修复 ```

func WithNoRedirect ¶

func WithNoRedirect(b bool) PocConfigOption

noRedirect 是一个请求选项参数，用于指定是否跟踪重定向，默认为 false 即会自动跟踪重定向 Example: ``` poc.HTTP(poc.BasicRequest(), poc.noRedirect()) // 向 example.com 发起请求，如果响应重定向到其他链接也不会自动跟踪重定向 ```

func WithParams ¶

func WithParams(i interface{}) PocConfigOption

params 是一个请求选项参数，用于在请求时使用传入的值，需要注意的是，它可以很方便地使用 `str.f()`或 f-string 代替 Example: rsp, req, err = poc.HTTP(x`POST /post HTTP/1.1 Content-Type: application/json Host: pie.dev

{"key": "{{params(a)}}"}`, poc.params({"a":"bbb"})) // 实际上发送的POST参数为{"key": "bbb"}

func WithPassword ¶ added in v1.3.3

func WithPassword(password string) PocConfigOption

password 是一个请求选项参数，用于指定认证时的密码 Example: ``` poc.Get("https://www.example.com", poc.username("admin"), poc.password("admin")) ```

func WithPort ¶

func WithPort(port int) PocConfigOption

port 是一个请求选项参数，用于指定实际请求的端口，如果没有设置该请求选项，则会依据原始请求报文中的Host字段来确定实际请求的端口 Example: ``` poc.HTTP(poc.BasicRequest(), poc.host("yaklang.com"), poc.port(443), poc.https(true)) // 实际上请求 yaklang.com 的443端口 ```

func WithPostData ¶

func WithPostData(i string) PocConfigOption

postData 是一个请求选项参数，用于指定请求的 body 为 post 数据，需要传入一个任意类型的参数，会自动转换为 post 数据 输入是原始字符串，不会修改 Content-Type Example: ``` poc.Post("https://www.example.com", poc.postData("a=b")) // 向 www.example.com 发起请求，请求的 body 为 a=b ```

func WithPostParams ¶

func WithPostParams(i any) PocConfigOption

postParams 是一个请求选项参数，用于指定请求的 body 为 post 数据，需要传入一个任意类型的参数，会自动转换为 post 数据 输入是 map 类型，会自动转换为 post 数据，同时会自动设置 Content-Type 为 application/x-www-form-urlencoded Example: ``` poc.Post("https://www.example.com", poc.postParams({"a": "b"})) // 向 www.example.com 发起请求，请求的 body 为 a=b 并自动设置 Content-Type 为 application/x-www-form-urlencoded ```

func WithProxy ¶

func WithProxy(proxies ...string) PocConfigOption

proxy 是一个请求选项参数，用于指定请求使用的代理，可以指定多个代理，默认会使用系统代理 Example: ``` poc.HTTP(poc.BasicRequest(), poc.proxy("http://127.0.0.1:7890")) // 向 example.com 发起请求，使用 http://127.0.0.1:7890 代理 ```

func WithQuery ¶

func WithQuery(i any) PocConfigOption

query 是一个请求选项参数，用于指定请求的 query 参数，需要传入一个任意类型的参数，会自动转换为 query 参数 如果输入的是 map 类型，则会自动转换为 query 参数，例如：{"a": "b"} 转换为 a=b 如果输入的是其他，会把字符串结果直接作为 query 设置 Example: ``` poc.Get("https://www.example.com", poc.query({"a": "b"})) // 向 www.example.com 发起请求，请求的 query 为 a=b, url 为 https://www.example.com?a=b poc.Get("https://www.example.com", poc.query("a=b")) // 向 www.example.com 发起请求，请求的 query 为 a=b, url 为 https://www.example.com?a=b poc.Get("https://www.example.com", poc.query("abc")) // 向 www.example.com 发起请求，请求的 query 为 a=b, url 为 https://www.example.com?abc ```

func WithRandomChunkedDelay ¶

func WithRandomChunkedDelay(min, max int) PocConfigOption

randomChunkedDelay是一个请求选项参数，用于设置随机分块传输的分块延迟范围，默认最小延迟为50毫秒，最大延迟为100毫秒 Example: ``` data = ` POST /post HTTP/1.1 Host: pie.dev Content-Type: multipart/form-data; boundary=------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Length: 308

--------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Disposition: form-data; name="aaa"

bbb --------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Disposition: form-data; name="ccc"

ddd --------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm-- `

poc.HTTP(data,poc.randomChunked(true),poc.randomChunkedLength(10,25),poc.randomChunkedDelay(50,200))~ ```

func WithRandomChunkedLength ¶

func WithRandomChunkedLength(min, max int) PocConfigOption

randomChunkedLength 是一个请求选项参数，用于设置随机分块传输的分块长度范围，默认最小长度为10，最大长度为25 Example: ``` data = ` POST /post HTTP/1.1 Host: pie.dev Content-Type: multipart/form-data; boundary=------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Length: 308

--------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Disposition: form-data; name="aaa"

bbb --------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Disposition: form-data; name="ccc"

ddd --------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm-- `

poc.HTTP(data,poc.randomChunked(true),poc.randomChunkedLength(10,25),poc.randomChunkedDelay(50,200))~ ```

func WithRandomChunkedResultHandler ¶

func WithRandomChunkedResultHandler(f func(id int, chunkRaw []byte, totalTime time.Duration, chunkSendTime time.Duration)) PocConfigOption

randomChunkedResultHandler 是一个请求选项参数，用于设置随机分块传输的结果处理函数 处理函数接受四个参数，id为分块的ID，chunkRaw为分块的原始数据，totalTime为总耗时，chunkSendTime为分块发送的耗时 Example: ``` data = ` POST /post HTTP/1.1 Host: pie.dev Content-Type: multipart/form-data; boundary=------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Length: 308

--------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Disposition: form-data; name="aaa"

bbb --------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm Content-Disposition: form-data; name="ccc"

ddd --------------------------OFHnlKtUimimGcXvRSxgCZlIMAyDkuqsxeppbIFm-- `

poc.HTTP(data,poc.randomChunked(true), poc.randomChunkedLength(10,25), poc.randomChunkedDelay(50,200),

poc.randomChunkedResultHandler(func(id,data,totalTime,chunkTime){
	print(sprintf("id:%v\tdata:%s\ttotalTime:%vms\tdelay:%vms\n", id,data,totalTime,chunkTime))
}))~

```

func WithRandomJA3 ¶

func WithRandomJA3(b bool) PocConfigOption

func WithRedirect ¶

func WithRedirect(i func(current *http.Request, vias []*http.Request) bool) PocConfigOption

redirect 是一个请求选项参数，用于设置旧风格的 redirectHandler 函数，如果设置了该选项，则会在重定向时调用该函数，如果该函数返回 true，则会继续重定向，否则不会重定向。其第一个参数为当前的请求，第二个参数为既往的多个请求 Example: ``` poc.HTTP(poc.BasicRequest(), poc.redirect(func(current, vias) { return true })) // 向 example.com 发起请求，使用自定义 redirectHandler 函数，如果该函数返回 true，则会继续重定向，否则不会重定向 ```

func WithRedirectHandler ¶

func WithRedirectHandler(i func(isHttps bool, req, rsp []byte) bool) PocConfigOption

redirectHandler 是一个请求选项参数，用于作为重定向处理函数，如果设置了该选项，则会在重定向时调用该函数，如果该函数返回 true，则会继续重定向，否则不会重定向。其第一个参数为是否使用 https 协议，第二个参数为原始请求报文，第三个参数为原始响应报文 Example: ``` count = 3 poc.Get("https://pie.dev/redirect/5", poc.redirectHandler(func(https, req, rsp) { count-- return count >= 0 })) // 向 pie.edv 发起请求，使用自定义 redirectHandler 函数，使用 count 控制，进行最多3次重定向 ```

func WithRedirectTimes ¶

func WithRedirectTimes(t int) PocConfigOption

redirectTimes 是一个请求选项参数，用于指定最大重定向次数，默认为5次 Example: ``` poc.HTTP(poc.BasicRequest(), poc.redirectTimes(5)) // 向 example.com 发起请求，如果响应重定向到其他链接，则会自动跟踪重定向最多5次 ```

func WithReplaceAllHttpPacketHeaders ¶ added in v1.3.1

func WithReplaceAllHttpPacketHeaders(headers map[string]string) PocConfigOption

replaceAllHeaders 是一个请求选项参数，用于改变请求报文，修改修改所有请求头 Example: ``` poc.Get("https://pie.dev/get", poc.replaceHeader("AAA", "BBB")) // 向 pie.dev 发起请求，修改AAA请求头的值为BBB，这里没有AAA请求头，所以会增加该请求头 ```

func WithReplaceAllHttpPacketPostParams ¶

func WithReplaceAllHttpPacketPostParams(values map[string]string) PocConfigOption

replaceAllPostParams 是一个请求选项参数，用于改变请求报文，修改所有POST请求参数，如果不存在则会增加，其接收一个map[string]string类型的参数，其中key为POST请求参数名，value为POST请求参数值 Example: ``` poc.Post("https://pie.dev/post", poc.replaceAllPostParams({"a":"b", "c":"d"})) // 向 pie.dev 发起请求，添加POST请求参数a，值为b，POST请求参数c，值为d ```

func WithReplaceAllHttpPacketPostParamsWithoutEscape ¶ added in v1.3.1

func WithReplaceAllHttpPacketPostParamsWithoutEscape(values map[string]string) PocConfigOption

replaceAllPostParamsWithoutEscape 是一个请求选项参数，用于改变请求报文，修改所有POST请求参数，如果不存在则会增加，其接收一个map[string]string类型的参数，其中key为POST请求参数名，value为POST请求参数值 与 poc.replaceAllPostParams 类似，但是不会将参数值进行转义 Example: ``` poc.Post("https://pie.dev/post", poc.replaceAllPostParamsWithoutEscape({"a":"{{}}", "c":"%%"})) // 向 pie.dev 发起请求，添加POST请求参数a，值为{{}}，POST请求参数c，值为%% ```

func WithReplaceAllHttpPacketQueryParams ¶

func WithReplaceAllHttpPacketQueryParams(values map[string]string) PocConfigOption

replaceAllQueryParams 是一个请求选项参数，用于改变请求报文，修改所有 GET 请求参数，如果不存在则会增加，其接收一个map[string]string 类型的参数，其中 key 为请求参数名，value 为请求参数值 Example: ``` poc.Get("https://pie.dev/get", poc.replaceAllQueryParams({"a":"b", "c":"d"})) // 向 pie.dev 发起请求，添加GET请求参数a，值为b，添加GET请求参数c，值为d ```

func WithReplaceAllHttpPacketQueryParamsWithoutEscape ¶ added in v1.3.1

func WithReplaceAllHttpPacketQueryParamsWithoutEscape(values map[string]string) PocConfigOption

replaceAllQueryParamsWithoutEscape 是一个请求选项参数，用于改变请求报文，修改所有 GET 请求参数，如果不存在则会增加，其接收一个map[string]string 类型的参数，其中 key 为请求参数名，value 为请求参数值 与 poc.replaceAllQueryParams 类似，但是不会将参数值进行转义 Example: ``` poc.Get("https://pie.dev/get", poc.replaceAllQueryParamsWithoutEscape({"a":"{{}}", "c":"%%"})) // 向 pie.dev 发起请求，添加GET请求参数a，值为{{}}，添加GET请求参数c，值为%% ```

func WithReplaceFullHttpPacketPostParamsWithoutEscape ¶ added in v1.3.3

func WithReplaceFullHttpPacketPostParamsWithoutEscape(values map[string][]string) PocConfigOption

func WithReplaceFullHttpPacketQueryParamsWithoutEscape ¶ added in v1.3.3

func WithReplaceFullHttpPacketQueryParamsWithoutEscape(values map[string][]string) PocConfigOption

func WithReplaceHttpPacketBasicAuth ¶

func WithReplaceHttpPacketBasicAuth(username, password string) PocConfigOption

replaceBasicAuth 是一个请求选项参数，用于改变请求报文，修改 Authorization 请求头为基础认证的密文，如果不存在则会增加，实际上是replaceHeader("Authorization", codec.EncodeBase64(username + ":" + password))的简写 Example: ``` poc.Get("https://pie.dev/basic-auth/admin/password", poc.replaceBasicAuth("admin", "password")) // 向 pie.dev 发起请求进行基础认证，会得到200响应状态码 ```

func WithReplaceHttpPacketBody ¶

func WithReplaceHttpPacketBody(body []byte, chunk bool) PocConfigOption

replaceBody 是一个请求选项参数，用于改变请求报文，修改请求体内容，第一个参数为修改后的请求体内容，第二个参数为是否分块传输 Example: ``` poc.Post("https://pie.dev/post", poc.replaceBody("a=b", false)) // 向 pie.dev 发起请求，修改请求体内容为a=b ```

func WithReplaceHttpPacketCookie ¶

func WithReplaceHttpPacketCookie(key, value string) PocConfigOption

replaceCookie 是一个请求选项参数，用于改变请求报文，修改Cookie请求头中的值，如果不存在则会增加 Example: ``` poc.Get("https://pie.dev/get", poc.replaceCookie("aaa", "bbb")) // 向 pie.dev 发起请求，这里没有aaa的cookie值，所以会增加 ```

func WithReplaceHttpPacketCookies ¶ added in v1.3.2

func WithReplaceHttpPacketCookies(cookies any) PocConfigOption

replaceAllCookies 是一个请求选项参数，用于改变请求报文，修改所有Cookie请求头中的值 Example: ``` poc.Get("https://pie.dev/get", poc.replaceAllCookies({"aaa":"bbb", "ccc":"ddd"})) // 向 pie.dev 发起请求，修改aaa的cookie值为bbb，修改ccc的cookie值为ddd ```

func WithReplaceHttpPacketFirstLine ¶

func WithReplaceHttpPacketFirstLine(firstLine string) PocConfigOption

replaceFirstLine 是一个请求选项参数，用于改变请求报文，修改第一行（即请求方法，请求路径，协议版本） Example: ``` poc.Get("https://exmaple.com", poc.replaceFirstLine("GET /test HTTP/1.1")) // 向 example.com 发起请求，修改请求报文的第一行，请求/test路径 ```

func WithReplaceHttpPacketFormEncoded ¶ added in v1.3.2

func WithReplaceHttpPacketFormEncoded(key, value string) PocConfigOption

replaceFormEncoded 是一个请求选项参数，用于改变请求报文，修改请求体中的表单，如果不存在则会增加 Example: ``` poc.Post("https://pie.dev/post", poc.replaceFormEncoded("aaa", "bbb")) // 向 pie.dev 发起请求，添加POST请求表单，其中aaa为键，bbb为值 ```

func WithReplaceHttpPacketHeader ¶

func WithReplaceHttpPacketHeader(key, value string) PocConfigOption

replaceHeader 是一个请求选项参数，用于改变请求报文，修改修改请求头，如果不存在则会增加 Example: ``` poc.Get("https://pie.dev/get", poc.replaceHeader("AAA", "BBB")) // 向 pie.dev 发起请求，修改AAA请求头的值为BBB，这里没有AAA请求头，所以会增加该请求头 ```

func WithReplaceHttpPacketHost ¶

func WithReplaceHttpPacketHost(host string) PocConfigOption

replaceHost 是一个请求选项参数，用于改变请求报文，修改Host请求头，如果不存在则会增加，实际上是replaceHeader("Host", host)的简写 Example: ``` poc.Get("https://yaklang.com/", poc.replaceHost("www.yaklang.com")) // 向 yaklang.com 发起请求，修改Host请求头的值为 www.yaklang.com ```

func WithReplaceHttpPacketMethod ¶

func WithReplaceHttpPacketMethod(method string) PocConfigOption

replaceMethod 是一个请求选项参数，用于改变请求报文，修改请求方法 Example: ``` poc.Options("https://exmaple.com", poc.replaceMethod("GET")) // 向 example.com 发起请求，修改请求方法为GET ```

func WithReplaceHttpPacketPath ¶

func WithReplaceHttpPacketPath(path string) PocConfigOption

replacePath 是一个请求选项参数，用于改变请求报文，修改请求路径 Example: ``` poc.Get("https://pie.dev/post", poc.replacePath("/get")) // 向 pie.dev 发起请求，实际上请求路径为/get ```

func WithReplaceHttpPacketPostParam ¶

func WithReplaceHttpPacketPostParam(key, value string) PocConfigOption

replacePostParam 是一个请求选项参数，用于改变请求报文，修改 POST 请求参数，如果不存在则会增加 Example: ``` poc.Post("https://pie.dev/post", poc.replacePostParam("a", "b")) // 向 pie.dev 发起请求，添加POST请求参数a，值为b ```

func WithReplaceHttpPacketQueryParam ¶

func WithReplaceHttpPacketQueryParam(key, value string) PocConfigOption

replaceQueryParam 是一个请求选项参数，用于改变请求报文，修改 GET 请求参数，如果不存在则会增加 Example: ``` poc.Get("https://pie.dev/get", poc.replaceQueryParam("a", "b")) // 向 pie.dev 发起请求，添加GET请求参数a，值为b ```

func WithReplaceHttpPacketQueryParamRaw ¶

func WithReplaceHttpPacketQueryParamRaw(rawQuery string) PocConfigOption

func WithReplaceHttpPacketRandomUserAgent ¶ added in v1.3.1

func WithReplaceHttpPacketRandomUserAgent() PocConfigOption

replaceRandomUserAgent 是一个请求选项参数，用于改变请求报文，修改 User-Agent 请求头为随机的常见请求头 Example: ``` poc.Get("https://pie.dev/basic-auth/admin/password", poc.replaceRandomUserAgent()) // 向 pie.dev 发起请求，修改 User-Agent 请求头为随机的常见请求头 ```

func WithReplaceHttpPacketUploadFile ¶ added in v1.3.2

func WithReplaceHttpPacketUploadFile(formName, fileName string, fileContent []byte, contentType ...string) PocConfigOption

replaceUploadFile 是一个请求选项参数，用于改变请求报文，修改请求体中的上传的文件，其中第一个参数为表单名，第二个参数为文件名，第三个参数为文件内容，第四个参数是可选参数，为文件类型(Content-Type)，如果不存在则会增加 Example: ``` poc.Post("https://pie.dev/post", poc.replaceUploadFile("file", "phpinfo.php", "<?php phpinfo(); ?>", "application/x-php")) // 向 pie.dev 发起请求，添加POST请求上传文件，其中file为表单名，phpinfo.php为文件名，<?php phpinfo(); ?>为文件内容，application/x-php为文件类型 ```

func WithReplaceHttpPacketUserAgent ¶ added in v1.3.1

func WithReplaceHttpPacketUserAgent(ua string) PocConfigOption

replaceUserAgent 是一个请求选项参数，用于改变请求报文，修改 User-Agent 请求头，实际上是replaceHeader("User-Agent", userAgent)的简写 Example: ``` poc.Get("https://pie.dev/basic-auth/admin/password", poc.replaceUserAgent("yak-http-client")) // 向 pie.dev 发起请求，修改 User-Agent 请求头为 yak-http-client ```

func WithRetryInStatusCode ¶

func WithRetryInStatusCode(codes ...int) PocConfigOption

retryInStatusCode 是一个请求选项参数，用于指定在某些响应状态码的情况下重试，需要搭配 retryTimes 使用 Example: ``` poc.HTTP(poc.BasicRequest(), poc.retryTimes(5), poc.retryInStatusCode(500, 502)) // 向 example.com 发起请求，如果响应状态码500或502则进行重试，最多进行5次重试 ```

func WithRetryMaxWaitTime ¶

func WithRetryMaxWaitTime(f float64) PocConfigOption

retryMaxWaitTime 是一个请求选项参数，用于指定重试时最大等待时间，需要搭配 retryTimes 使用，默认为2秒 Example: ``` poc.HTTP(poc.BasicRequest(), poc.retryTimes(5), poc.retryNotInStatusCode(200), poc.retryWaitTime(2)) // 向 example.com 发起请求，如果响应状态码不等于200则进行重试，最多进行5次重试，重试时最多等待2秒 ```

func WithRetryNotInStausCode ¶

func WithRetryNotInStausCode(codes ...int) PocConfigOption

retryNotInStatusCode 是一个请求选项参数，用于指定非某些响应状态码的情况下重试，需要搭配 retryTimes 使用 Example: ``` poc.HTTP(poc.BasicRequest(), poc.retryTimes(5), poc.retryNotInStatusCode(200)) // 向 example.com 发起请求，如果响应状态码不等于200则进行重试，最多进行5次重试 ```

func WithRetryTimes ¶

func WithRetryTimes(t int) PocConfigOption

retryTimes 是一个请求选项参数，用于指定请求失败时的重试次数，需要搭配 retryInStatusCode 或 retryNotInStatusCode 使用，来设置在什么响应码的情况下重试 Example: ``` poc.HTTP(poc.BasicRequest(), poc.retryTimes(5), poc.retryInStatusCode(500, 502)) // 向 example.com 发起请求，如果响应状态码500或502则进行重试，最多进行5次重试 ```

func WithRetryWaitTime ¶

func WithRetryWaitTime(f float64) PocConfigOption

retryWaitTime 是一个请求选项参数，用于指定重试时最小等待时间，需要搭配 retryTimes 使用，默认为0.1秒 Example: ``` poc.HTTP(poc.BasicRequest(), poc.retryTimes(5), poc.retryNotInStatusCode(200), poc.retryWaitTime(0.1)) // 向 example.com 发起请求，如果响应状态码不等于200则进行重试，最多进行5次重试，重试时最小等待0.1秒 ```

func WithRuntimeId ¶

func WithRuntimeId(r string) PocConfigOption

func WithSNI ¶ added in v1.3.1

func WithSNI(sni string) PocConfigOption

sni 是一个请求选项参数，用于指定使用 tls(https) 协议时的 服务器名称指示(SNI) Example: ``` poc.Get("https://www.example.com", poc.sni("google.com")) ```

func WithSave ¶

func WithSave(b bool) PocConfigOption

save 是一个请求选项参数，用于指定是否将此次请求的记录保存在数据库中，默认为true即会保存到数据库 Example: ``` poc.Get("https://exmaple.com", poc.save(true)) // 向 example.com 发起请求，会将此次请求保存到数据库中 ```

func WithSaveHandler ¶

func WithSaveHandler(f ...func(response *lowhttp.LowhttpResponse)) PocConfigOption

saveHandler 是一个请求选项参数，用于设置在将此次请求存入数据库之前的回调函数 Example: ```

poc.Get("https://exmaple.com", poc.save(func(resp){
	resp.Tags = append(resp.Tags,"test")
})) // 向 example.com 发起请求，添加test tag

```

func WithSaveSync ¶

func WithSaveSync(b bool) PocConfigOption

saveSync 是一个请求选项参数，用于指定是否将此次请求的记录保存在数据库中，且同步保存，默认为false即会异步保存到数据库 Example: ``` poc.Get("https://exmaple.com", poc.save(true), poc.saveSync(true)) // 向 example.com 发起请求，会将此次请求保存到数据库中，且同步保存 ```

func WithSession ¶

func WithSession(i interface{}) PocConfigOption

session 是一个请求选项参数，用于指定请求的session，参数可以是任意类型的值，用此值做标识符从而找到唯一的session。使用session进行请求时会自动管理cookie，这在登录后操作的场景非常有用 Example: ``` poc.Get("https://pie.dev/cookies/set/AAA/BBB", poc.session("test")) // 向 pie.dev 发起第一次请求，这会设置一个名为AAA，值为BBB的cookie rsp, req, err = poc.Get("https://pie.dev/cookies", poc.session("test")) // 向 pie.dev 发起第二次请求，这个请求会输出所有的cookies，可以看到第一次请求设置的cookie已经存在了 ```

func WithSource ¶

func WithSource(i string) PocConfigOption

source 是一个请求选项参数，用于在请求记录保存到数据库时标识此次请求的来源 Example: ``` poc.Get("https://exmaple.com", poc.save(true), poc.source("test")) // 向 example.com 发起请求，会将此次请求保存到数据库中，指示此次请求的来源为test ```

func WithTimeout ¶

func WithTimeout(f float64) PocConfigOption

timeout 是一个请求选项参数，用于指定读取超时时间，默认为15秒 Example: ``` poc.Get("https://www.example.com", poc.timeout(15)) // 向 www.baidu.com 发起请求，读取超时时间为15秒 ```

func WithUserAgent ¶

func WithUserAgent(ua string) PocConfigOption

ua 是一个请求选项参数，用于改变请求报文，添加 User-Agent 请求头中的值 Example: ``` poc.Get("https://pie.dev/get", poc.ua("Mozilla/5.0")) // 向 pie.dev 发起请求，添加User-Agent请求头，其值为Mozilla/5.0 ```

func WithUsername ¶ added in v1.3.3

func WithUsername(username string) PocConfigOption

username 是一个请求选项参数，用于指定认证时的用户名 Example: ``` poc.Get("https://www.example.com", poc.username("admin"), poc.password("admin")) ```

func WithWebsocket ¶

func WithWebsocket(w bool) PocConfigOption

websocket 是一个请求选项参数，用于允许将链接升级为 websocket，此时发送的请求应该为 websocket 握手请求 Example: ``` rsp, req, err = poc.HTTP(`GET / HTTP/1.1 Connection: Upgrade Upgrade: websocket Sec-Websocket-Version: 13 Sec-Websocket-Extensions: permessage-deflate; client_max_window_bits Host: echo.websocket.events Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-US;q=0.7 Sec-Websocket-Key: L31R1As+71fwuXqhwhABuA==`,

poc.proxy("http://127.0.0.1:7890"), poc.websocketFromServer(func(rsp, cancel) {
	    dump(rsp)
	}), poc.websocketOnClient(func(c) {
	    c.WriteText("123")
	}), poc.websocket(true),

) time.Sleep(100) ```

func WithWebsocketClientHandler ¶

func WithWebsocketClientHandler(w func(c *lowhttp.WebsocketClient)) PocConfigOption

websocketOnClient 是一个请求选项参数，它接收一个回调函数，这个函数有一个参数，是WebsocketClient结构体，通过该结构体可以向服务端发送数据 Example: ``` rsp, req, err = poc.HTTP(`GET / HTTP/1.1 Connection: Upgrade Upgrade: websocket Sec-Websocket-Version: 13 Sec-Websocket-Extensions: permessage-deflate; client_max_window_bits Host: echo.websocket.events Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-US;q=0.7 Sec-Websocket-Key: L31R1As+71fwuXqhwhABuA==`,

poc.proxy("http://127.0.0.1:7890"), poc.websocketFromServer(func(rsp, cancel) {
	    dump(rsp)
	}), poc.websocketOnClient(func(c) {
	    c.WriteText("123")
	}), poc.websocket(true),

) time.Sleep(100) ```

func WithWebsocketHandler ¶

func WithWebsocketHandler(w func(i []byte, cancel func())) PocConfigOption

websocketFromServer 是一个请求选项参数，它接收一个回调函数，这个函数有两个参数，其中第一个参数为服务端发送的数据，第二个参数为取消函数，调用将会强制断开 websocket Example: ``` rsp, req, err = poc.HTTP(`GET / HTTP/1.1 Connection: Upgrade Upgrade: websocket Sec-Websocket-Version: 13 Sec-Websocket-Extensions: permessage-deflate; client_max_window_bits Host: echo.websocket.events Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-US;q=0.7 Sec-Websocket-Key: L31R1As+71fwuXqhwhABuA==`,

poc.proxy("http://127.0.0.1:7890"), poc.websocketFromServer(func(rsp, cancel) {
	    dump(rsp)
	}), poc.websocketOnClient(func(c) {
	    c.WriteText("123")
	}), poc.websocket(true),

) time.Sleep(100) ```

func WithWebsocketStrictMode ¶

func WithWebsocketStrictMode(b bool) PocConfigOption

websocketStrictMode 是一个请求选项参数，它用于控制是否启用严格模式，如果启用严格模式，则会遵循 RFC 6455 规范 Example: ``` rsp, req, err = poc.HTTP(`GET / HTTP/1.1 Connection: Upgrade Upgrade: websocket Sec-Websocket-Version: 13 Sec-Websocket-Extensions: permessage-deflate; client_max_window_bits Host: echo.websocket.events Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-US;q=0.7 Sec-Websocket-Key: L31R1As+71fwuXqhwhABuA==`, poc.proxy("http://127.0.0.1:7890"), poc.websocketStrictMode(true))

time.Sleep(100) ```