一些关于前端、技术，和我的生活的文字

前端

技术

生活

关于我

进入NetlifyCMS

Spark1e的Github

前往Twitter

给spark1e发邮件

在博客中搜索……

Category: All - Page 1 | Spark1e的个人博客

一、从原来的Docker镜像导出“设置”

![qq截图20231107014719](/img/uploads/qq截图20231107014719.png)

可见这是一个完全导出的容器，容器名被改为了当时备份的时间tag，需要改成Docker Hub（或者其他注册表）上最新的镜像。

右键该容器，选择设置，导出，只导出设置，会生成一个.syno.json文件。

![qq截图20231107014755](/img/uploads/qq截图20231107014755.png)

![qq截图20231107014806](/img/uploads/qq截图20231107014806.png)

![qq截图20231107014848](/img/uploads/qq截图20231107014848.png)

二、更改镜像

在编辑前，我建议提前将对应镜像下载下来。

然后右键选择编辑，定位到"image"字段，手工改为registry的url和tag：

![qq截图20231107014913](/img/uploads/qq截图20231107014913.png)

![qq截图20231107015010](/img/uploads/qq截图20231107015010.png)

> 自Docker Hub无法正常拉取镜像后我自己做了一个油猴插件，在Hub页面可以选镜像：https://greasyfork.org/zh-CN/scripts/474200-docker-hub-mirrors

保存，然后删除掉旧容器，再选择导入设置，即可自动改为新镜像启动容器。

> 删除旧容器之前建议留存一份截图以防万一，还能手工恢复。

![qq截图20231107015504](/img/uploads/qq截图20231107015504.png)

利用群晖的Docker导出设置机制

群晖系统将完全备份的Docker容器改为最新镜像

> 过时的浏览器兼容URL对象：[https://github.com/JakeChampion/polyfill-library/blob/master/polyfills/URL/polyfill.js](https://github.com/JakeChampion/polyfill-library/blob/master/polyfills/URL/polyfill.js)

> 对本文反向，即无法正常显示IDN的情况转换成punycode：[https://github.com/mathiasbynens/punycode.js](https://github.com/mathiasbynens/punycode.js)

## 什么是IDN？

> 相关讨论：[https://www.xudongz.com/blog/2017/idn-phishing/](https://www.xudongz.com/blog/2017/idn-phishing/)

IDN全称：Internationalized Domain Names，本意是为了让URL更适配各个地方的本地语言，但是这也造成了IDN homograph attacks（IDN同形异义字攻击，下文称“同态攻击”）。

举例说明，这样一个域名：

```
// 为避免误点击，使用Code块
аpple.com
```

如果这样的URL展示在页面上，不仔细查看其前往的实际地址或者复制粘贴到地址栏，是无法发现其实际的URL为：`https://xn--pple-43d.com/`

这是因为这个URL中的`а`使用 Cyrillic（U + 0430）而不是ASCII“a”（U + 0041）。

## 如何防御这一类问题

### 浏览器自身防御机制

针对这种问题，浏览器自身有自己的策略，比如：

- Chrome：[link](https://chromium.googlesource.com/chromium/src/+/main/docs/idn.md)
- Firefox: [link](https://wiki.mozilla.org/IDN_Display_Algorithm)

在现代浏览器上，凡是赋予到link的dom上的href或者是URL对象的，都会被转换到实际的Punycode([wiki](https://en.wikipedia.org/wiki/Punycode))上，那么最简单的解决方案即：

```javascript
const suspiciousUrl = "аpple.com";
const c = new URL(suspiciousUrl);
if(c.href === suspiciousUrl) {
	console.log("secure url");
} else {
	console.log("suspicious detected ! original url is: " + c.href);
}
```

如何从前端角度防御恶意IDN攻击

### 星尘是什么VPS

Scaleway家的（原来的Online.net），如果不要IPv4，一台机器（1C1G10G SSD）可以做到0.5欧元/月以内，所以性价比还是很高的。

### Scaleway的API

> Github: [scaleway/scaleway-cli](https://github.com/scaleway/scaleway-cli/releases)

在Release下，下载你日常用的平台的二进制文件。

比如我使用Linux，下载好之后运行：

```
./scw init
```

会需要你使用网站上生成的API Key和Secret以及Organization ID进行初始化，过程中会询问你是否允许收集信息以及是否将当前机器的SSH key添加到信任列表，可以按需要添加。

### 调用API创建机器

直接提供命令：

```bash
./scw instance server create type=STARDUST1-S zone=nl-ams-1 image=debian_bookworm root-volume=l:10G name=scw-stardust-ams ip=none ipv6=true project-id=xxxx # 荷兰-Amsterdam-1区
./scw instance server create type=STARDUST1-S zone=fr-par-1 image=debian_bookworm root-volume=l:10G name=scw-stardust-par ip=none ipv6=true project-id=xxxx # 法国-Paris-1区
./scw instance server create type=STARDUST1-S zone=pl-waw-2 image=debian_bookworm root-volume=l:10G name=scw-stardust-par ip=none ipv6=true project-id=xxxx # 波兰-华沙-2区，未验证
```

上述命令创建的即IPv6 Only的机器。

虽然有点过时但现在很方便的方式

利用API创建Scaleway星尘VPS

### 0. 安装`warp-cli`

访问：[https://pkg.cloudflareclient.com/](https://pkg.cloudflareclient.com/) 根据不同的OS来安装对应的cli工具

### 1. 启用`warp-cli`

由于我们是通过shell来配置的，因此千万不能安装好 __直接register+connect，会导致失联__ ！

```bash
warp-cli register
warp-cli set-mode proxy
warp-cli set-proxy-port 23333 # 任意端口都可以
warp-cli connect
```

可以通过下面的命令来强制使用IPv4测试当前机器的IPv4连通性：

```bash
curl -4 ip.gs -x socks5://127.0.0.1:23333 # 端口与你配置的一致
```

> 如果测试没有问题，执行 `warp-cli enable-always-on` 来确保重启不会导致warp不自动启动。

### 2. 将warp暴露的代理端口作为系统IPv4代理

```bash
export ALL_PROXY=socks5://127.0.0.1:23333 # 可以在/etc/profile或者~/.bashrc等文件加上此行
curl -4 ip.sb # 测试是否生效
```

使用官方客户端会比第三方的wg-quick省心一些

利用Cloudflare官方客户但warp-cli让IPv6 only的设备访问IPv4

```bash
nano /etc/resolv.conf
```

如果进来以后前两行显示：

```conf
# This is /run/systemd/resolve/resolv.conf managed by man:systemd-resolved(8).
# Do not edit.
```

证明是由systemd托管的dns配置，正确修改：

```bash
nano /etc/systemd/resolved.conf
```

注意每行`DNS=`后只跟随一个IP地址，可以有多行DNS。

然后重启对应服务：

```bash
systemctl restart systemd-resolved.service
```

再查看 `/etc/resolv.conf` 里面的配置就已经生效了。

修改由systemd托管的DNS配置

### 蜗牛星际修复无法正常关机（断电）

> 原文：http://www.nasyun.com/thread-73228-1-1.html

进入到BIOS，找系统OS选项，改为Android（据说Windows8.x可能也可以）。

### UPS导致群晖进入安全模式不关机的问题

> 原文：https://wp.gxnas.com/10926.html

找控制面板-硬件和电源-不断电系统，安全模式里 __不建议__ 勾选同时关闭不断电系统，

同时修改synoups文件，`sudo vi /usr/syno/bin/synoups`，我的是166行，注释掉，改为`poweroff`，wq保存退出，然后测试断电后能否自动关机。

蜗牛星际修复无法正常关机（断电）以及UPS导致群晖进入安全模式不关机的问题

经常遇到一个重接口的项目因为加了一个页面就变成主要占比是HTML/JS/CSS的项目了，而我的项目重点应该是服务端语言，那么可以通过配置Linguist来实现。

在项目根目录（和 `.gitignore` 同级）增加一个 `.gitattributes` 文件，增加下面的配置：

```
*.js linguist-detectable=false
*.html linguist-detectable=false
*.css linguist-detectable=false
```

再push到Github即可。

> 如果想把某个语言的文件统计到另一个语言下也可以改为： `*.js linguist-language=TypeScript` ，不过这个例子不算恰当

忽略那些不重要的代码

Github修改代码的统计占比

> 尽管Gitea没有官方的恢复命令，但是官方文档提供了一份可以用来参考的基于dump文件的恢复步骤，[链接](https://docs.gitea.com/administration/backup-and-restore)

### 0. 为什么要迁移

##### 在PVE的LXC的优势

- 可以利用PVE的备份机制将整个LXC进行dump，万一出现Boom情况，可以基于整个dump立即还原LXC确保服务
- 一种轻量化的，与宿主几乎不混淆的容器服务，由于其IP也是由PVE主机进行控制，所以也不需要担心端口问题

##### PVE在LXC的问题

最大问题：二进制安装时是根据系统底层的内核版本来决定Alpine版本的，Alpine版本又决定了Gitea的二进制版本，也就意味着 __没有办法使用最新版本的Gitea__ ，1.20推出了新的Gitea Action，很想体验，那对于我现在的方案来说就基本无缘了……

### 1. 迁移准备工作

根据官方文档需要将现在运行的Gitea进行dump，进入到对应LXC容器，执行官方提供的dump命令：`su git && ./gitea dump -c /path/to/app.ini`

> 在我使用的时候没有git用户，因而是切到gitea目录进行操作的。正常情况下切换用户后应该当前目录在`/usr/bin`下，建议dump时输出到其他目录，我自己是切换到gitea的home目录再执行`/usr/bin/gitea dump -c /path/to/app.ini`

生成了dump文件之后，有一个小问题是我这个LXC的SSH是直接委托给了Gitea，宿主机的22端口被占用，没办法使用SCP方案，这里可以用Proxmox的工具来转移文件到外部（Proxmox宿主机）： `pct pull 111 /var/lib/gitea/gitea-dump-1692177100.zip /root/gitea-dump-1692177100.zip`

> 111是我的Gitea LXC的id，需要更换成你自己的。

### 2. 更换到Docker所在的机器上

这里我的迁移目标是群晖上的Docker，由于之前踩过几轮未知问题的坑，这次我选择同版本先小升级。

按照官方文档进行挂载目录，暴露端口，然后启动容器。

启动之后先不要进入到web界面，需要将备份的内容还原到docker的data目录：

```bash
docker cp gitea-dump-1692177100.zip  gitea:/tmp
```

复制后 __进入到容器内继续操作__

```bash
# reference: https://github.com/go-gitea/gitea/issues/23964
docker exec -u root -it -w /tmp  gitea /bin/bash
unzip gitea-dump-1692177100.zip
# restore the old file
cp --parents -rf data/* /data/gitea
cp --parents -rf repos/*  /data/git/repositories/
# must chown otherwise the gitea container can no be restarted
chown -R git:git /data
#  exit the gitea container
exit
```

到目前为止，还原了文件目录，但是还缺少数据库恢复(此步骤在官方文档上缺失)

```bash
# enter the   gitea container
docker exec -u root -it -w /tmp  gitea /bin/bash
# restore database, e.g. sqlite
# 此步骤耗时较长，如果瞬间结束，请检查$DATABASE_PATH变量，可能不存在值，需要手工指定为注释的命令版本
sqlite3 $DATABASE_PATH <gitea-db.sql
# sqlite3 /data/gitea/gitea.db <gitea-db.sql
```

执行完毕后，可以对比两边sql文件大小和db文件大小，如果相近证明还原完成。

最后一步，按照文档恢复钩子函数

```bash
# enter gitea  container with git user
docker exec -u git -it  gitea /bin/bash
# this command must be run by git user. 
/usr/local/bin/gitea -c '/data/gitea/conf/app.ini' admin regenerate hooks

# exit the gitea container
exit

# restart gitea container
docker restart gitea
```

### 最后一步

> 请务必检查Docker容器是否有对应目录的写入权限，尤其是群晖系统。

完成上面的还原，如果容器重启无异常，可以进入到web管理页面，会出现初始化，检查对应的目录是否是我们刚还原的目录，如果是的话，点击保存，会出现一个“即将写入到已经有内容的数据库”的确认，勾选相应的确认，我这边顺利进入了。

> 晚上会继续进行版本升级，切换host的操作，看看有没有新的问题。

对于官方文档做一点点补充

Gitea从包管理版迁移到Docker版

> 本文的应用环境是指在使用他人已编译好，且不方便自己重新再进行编译的Padavan路由系统下，如何添加软件。

> 本文涉及的frp故障排查版本为0.51.2，如果后续更新可能会有不同，仅供参考。

### Padavan添加软件

Padavan的系统（或者说目前刷路由器，非软路由，可用的系统里）大部分目录都是重启即丢失的。

> 但需要注意的是，由于Padavan系统的特殊性，关键目录以外的目录均为 tmpfs ，可以理解为是把数据暂存在内存上。因此在/etc/storage目录里所做的修改，如果没有执行保存脚本，就并没有真正的写入 Rom 里，重启之后文件还会丢失。 —— panFake的[文章](https://panfake.com/2019/01/padavan-settings-files-lost-after-reboot/)

那么我们的第一个目标就是把frp添加到/etc/storage目录下，并且烧录，使其重启可用。

#### 路由器还是能插U盘的更好一些

我的是红米AC2100，刷入Padavan后，SSH到路由器可见，可用空间大概也就几M，而最新版本的frp大概需要10M，空间严重不足。如果你的路由器能够插U盘，那么方案就变成了：

- 把frp放在U盘指定目录
- 路由器启动时自动挂载U盘
- 拷贝可执行文件到/tmp目录并启动（或者直接在U盘上启动）

不过上述方案不适合我，接下来介绍我的处理。

> 首要条件需要开启Padavan的SSH功能，这里不赘述，自行搜索。

#### [UPX](https://github.com/upx/upx)，好用

> 本文没有使用UPX的最新版，个人使用的[3.95](https://github.com/upx/upx/releases/tag/v3.95)

> 经过自己的测试，UPX运行的平台与需要修改的可执行文件平台无关，因此如果压缩有问题可能是你的原本的可执行文件的平台不对。

> 红米AC2100使用的是联发科的MT7621A，个人测试使用的frp版本应为misple版本。

利用UPX工具，使用`--best`参数，将frpc从10M压缩到了4M左右，如果你的空间还是不足，可以尝试压缩更旧版本的frpc，我自己压缩的0.39版本可以压缩到2M左右。

压缩好后将frpc和配置文件放在/etc/storage目录下，我自己放在了/etc/storage/frp/下，下文基于此。

放置好后建议先测试一下能否正常连接，因为每次重启后会还原到烧录的版本，如果配置的有问题，还需要重新烧录。

> 如果连接不上，是打不开frpc的管理面板的，我觉得这一点上frpc可以优化一下，至少可以判断是否启动成功。

> 如果路由器开启了防火墙，记得放行管理面板的端口和与服务端连接用的端口。不建议直接iptables，在管理面板里找Upnp配置即可。

如果测试没问题可以正常连接你的frps服务端，那么到系统设置里可以准备烧录了，这里借用一张恩山老哥的图片。

![微信图片_20230815105635](/img/uploads/微信图片_20230815105635.jpg)

选择“保存/etc/storage/内容到闪存”的提交，即可。

> 注意检查保存时的log，如果出现类似于：
> 
> Aug 18 02:37:15 Storage save: Save storage files to MTD partition "/dev/mtdblock6"
> 
> Aug 18 02:37:26 Storage save: Invalid storage final data size: 4240811
> 
> 一般是指/etc/storage容量不足

提交完毕，在系统设置 - 脚本，里找到“路由器启动时”（或者类似的字样），增加一行nohup启动脚本：

```bash
# 可执行文件更改为你自己的目录
nohup /etc/storage/frp/frpc -c /etc/storage/frp/frpc.ini >/dev/null 2>&1 &
```

> 选择输出到/dev/null是因为我在frpc.ini里配置了日志输出目录，建议输出到tmp避免闪存写满。

可以重启路由器测试frpc是否自动启动好并且连接上了。

### frp故障排除

然而我在测试时遭遇了frp用户最常见的错误：

```log
2023/08/14 13:53:31 [I] [service.go:296] EOF
```

EOF这种错误一般出现在读取返回体没有正确读取的情况，可能跟conn等都有关系，只有一个EOF这难排查。

找到frp的源码，在client/service.go下增加log

附上我自己debug用的service.go代码：

```go
// Copyright 2017 fatedier, fatedier@gmail.com
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package client

import (
	"context"
	"crypto/tls"
	"fmt"
	"io"
	"math/rand"
	"net"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"time"

	"github.com/fatedier/golib/crypto"
	libdial "github.com/fatedier/golib/net/dial"
	fmux "github.com/hashicorp/yamux"
	quic "github.com/quic-go/quic-go"

	"github.com/fatedier/frp/assets"
	"github.com/fatedier/frp/pkg/auth"
	"github.com/fatedier/frp/pkg/config"
	"github.com/fatedier/frp/pkg/msg"
	"github.com/fatedier/frp/pkg/transport"
	"github.com/fatedier/frp/pkg/util/log"
	utilnet "github.com/fatedier/frp/pkg/util/net"
	"github.com/fatedier/frp/pkg/util/util"
	"github.com/fatedier/frp/pkg/util/version"
	"github.com/fatedier/frp/pkg/util/xlog"
)

func init() {
	crypto.DefaultSalt = "frp"
	// TODO: remove this when we drop support for go1.19
	rand.Seed(time.Now().UnixNano())
}

// Service is a client service.
type Service struct {
	// uniq id got from frps, attach it in loginMsg
	runID string

	// manager control connection with server
	ctl   *Control
	ctlMu sync.RWMutex

	// Sets authentication based on selected method
	authSetter auth.Setter

	cfg         config.ClientCommonConf
	pxyCfgs     map[string]config.ProxyConf
	visitorCfgs map[string]config.VisitorConf
	cfgMu       sync.RWMutex

	// The configuration file used to initialize this client, or an empty
	// string if no configuration file was used.
	cfgFile string

	exit uint32 // 0 means not exit

	// service context
	ctx context.Context
	// call cancel to stop service
	cancel context.CancelFunc
}

func NewService(
	cfg config.ClientCommonConf,
	pxyCfgs map[string]config.ProxyConf,
	visitorCfgs map[string]config.VisitorConf,
	cfgFile string,
) (svr *Service, err error) {
	svr = &Service{
		authSetter:  auth.NewAuthSetter(cfg.ClientConfig),
		cfg:         cfg,
		cfgFile:     cfgFile,
		pxyCfgs:     pxyCfgs,
		visitorCfgs: visitorCfgs,
		ctx:         context.Background(),
		exit:        0,
	}
	return
}

func (svr *Service) GetController() *Control {
	svr.ctlMu.RLock()
	defer svr.ctlMu.RUnlock()
	return svr.ctl
}

func (svr *Service) Run(ctx context.Context) error {
	ctx, cancel := context.WithCancel(ctx)
	svr.ctx = xlog.NewContext(ctx, xlog.New())
	svr.cancel = cancel

	xl := xlog.FromContextSafe(svr.ctx)

	// set custom DNSServer
	if svr.cfg.DNSServer != "" {
		dnsAddr := svr.cfg.DNSServer
		if _, _, err := net.SplitHostPort(dnsAddr); err != nil {
			dnsAddr = net.JoinHostPort(dnsAddr, "53")
		}
		// Change default dns server for frpc
		net.DefaultResolver = &net.Resolver{
			PreferGo: true,
			Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
				return net.Dial("udp", dnsAddr)
			},
		}
	}

	// login to frps
	for {
		conn, cm, err := svr.login()
		if err != nil {
			xl.Warn("login to server failed: %v", err)

			// if login_fail_exit is true, just exit this program
			// otherwise sleep a while and try again to connect to server
			if svr.cfg.LoginFailExit {
				return err
			}
			util.RandomSleep(5*time.Second, 0.9, 1.1)
		} else {
			// login success
			ctl := NewControl(svr.ctx, svr.runID, conn, cm, svr.cfg, svr.pxyCfgs, svr.visitorCfgs, svr.authSetter)
			ctl.Run()
			svr.ctlMu.Lock()
			svr.ctl = ctl
			svr.ctlMu.Unlock()
			break
		}
	}

	go svr.keepControllerWorking()

	if svr.cfg.AdminPort != 0 {
		// Init admin server assets
		assets.Load(svr.cfg.AssetsDir)

		address := net.JoinHostPort(svr.cfg.AdminAddr, strconv.Itoa(svr.cfg.AdminPort))
		err := svr.RunAdminServer(address)
		if err != nil {
			log.Warn("run admin server error: %v", err)
		}
		log.Info("admin server listen on %s:%d", svr.cfg.AdminAddr, svr.cfg.AdminPort)
	}
	<-svr.ctx.Done()
	// service context may not be canceled by svr.Close(), we should call it here to release resources
	if atomic.LoadUint32(&svr.exit) == 0 {
		svr.Close()
	}
	return nil
}

func (svr *Service) keepControllerWorking() {
	xl := xlog.FromContextSafe(svr.ctx)
	maxDelayTime := 20 * time.Second
	delayTime := time.Second

	// if frpc reconnect frps, we need to limit retry times in 1min
	// current retry logic is sleep 0s, 0s, 0s, 1s, 2s, 4s, 8s, ...
	// when exceed 1min, we will reset delay and counts
	cutoffTime := time.Now().Add(time.Minute)
	reconnectDelay := time.Second
	reconnectCounts := 1

	for {
		<-svr.ctl.ClosedDoneCh()
		if atomic.LoadUint32(&svr.exit) != 0 {
			return
		}

		// the first three attempts with a low delay
		if reconnectCounts > 3 {
			util.RandomSleep(reconnectDelay, 0.9, 1.1)
			xl.Info("wait %v to reconnect", reconnectDelay)
			reconnectDelay *= 2
		} else {
			util.RandomSleep(time.Second, 0, 0.5)
		}
		reconnectCounts++

		now := time.Now()
		if now.After(cutoffTime) {
			// reset
			cutoffTime = now.Add(time.Minute)
			reconnectDelay = time.Second
			reconnectCounts = 1
		}

		for {
			if atomic.LoadUint32(&svr.exit) != 0 {
				return
			}

			xl.Info("try to reconnect to server...")
			conn, cm, err := svr.login()
			if err != nil {
				xl.Warn("reconnect to server error: %v, wait %v for another retry", err, delayTime)
				util.RandomSleep(delayTime, 0.9, 1.1)

				delayTime *= 2
				if delayTime > maxDelayTime {
					delayTime = maxDelayTime
				}
				continue
			}
			// reconnect success, init delayTime
			delayTime = time.Second

			ctl := NewControl(svr.ctx, svr.runID, conn, cm, svr.cfg, svr.pxyCfgs, svr.visitorCfgs, svr.authSetter)
			ctl.Run()
			svr.ctlMu.Lock()
			if svr.ctl != nil {
				svr.ctl.Close()
			}
			svr.ctl = ctl
			svr.ctlMu.Unlock()
			break
		}
	}
}

// login creates a connection to frps and registers it self as a client
// conn: control connection
// session: if it's not nil, using tcp mux
func (svr *Service) login() (conn net.Conn, cm *ConnectionManager, err error) {
	xl := xlog.FromContextSafe(svr.ctx)
	cm = NewConnectionManager(svr.ctx, &svr.cfg)

	if err = cm.OpenConnection(); err != nil {
		xl.Info("Throwed from line:249, the origin error msg is: ")
		xl.Info(err.Error())
		return nil, nil, err
	}

	defer func() {
		if err != nil {
			cm.Close()
		}
	}()

	conn, err = cm.Connect()
	if err != nil {
		xl.Info("Throwed from line:261, the origin error msg is: ")
		xl.Info(err.Error())
		return
	}

	loginMsg := &msg.Login{
		Arch:      runtime.GOARCH,
		Os:        runtime.GOOS,
		PoolCount: svr.cfg.PoolCount,
		User:      svr.cfg.User,
		Version:   version.Full(),
		Timestamp: time.Now().Unix(),
		RunID:     svr.runID,
		Metas:     svr.cfg.Metas,
	}

	// Add auth
	if err = svr.authSetter.SetLogin(loginMsg); err != nil {
		xl.Info("Throwed from line:280, the origin error msg is: ")
		xl.Info(err.Error())
		return
	}

	if err = msg.WriteMsg(conn, loginMsg); err != nil {
		xl.Info("Throwed from line:286, the origin error msg is: ")
		xl.Info(err.Error())
		return
	}

	var loginRespMsg msg.LoginResp
	_ = conn.SetReadDeadline(time.Now().Add(60 * time.Second))
	if err = msg.ReadMsgInto(conn, &loginRespMsg); err != nil {
		xl.Info("Throwed from line:294, the origin error msg is: ")
		xl.Info(err.Error())
		return
	}
	_ = conn.SetReadDeadline(time.Time{})

	if loginRespMsg.Error != "" {
		err = fmt.Errorf("%s", loginRespMsg.Error)
		xl.Error("%s", loginRespMsg.Error)
		return
	}

	svr.runID = loginRespMsg.RunID
	xl.ResetPrefixes()
	xl.AppendPrefix(svr.runID)

	xl.Info("login to server success, get run id [%s]", loginRespMsg.RunID)
	return
}

func (svr *Service) ReloadConf(pxyCfgs map[string]config.ProxyConf, visitorCfgs map[string]config.VisitorConf) error {
	svr.cfgMu.Lock()
	svr.pxyCfgs = pxyCfgs
	svr.visitorCfgs = visitorCfgs
	svr.cfgMu.Unlock()

	svr.ctlMu.RLock()
	ctl := svr.ctl
	svr.ctlMu.RUnlock()

	if ctl != nil {
		return svr.ctl.ReloadConf(pxyCfgs, visitorCfgs)
	}
	return nil
}

func (svr *Service) Close() {
	svr.GracefulClose(time.Duration(0))
}

func (svr *Service) GracefulClose(d time.Duration) {
	atomic.StoreUint32(&svr.exit, 1)

	svr.ctlMu.RLock()
	if svr.ctl != nil {
		svr.ctl.GracefulClose(d)
		svr.ctl = nil
	}
	svr.ctlMu.RUnlock()

	if svr.cancel != nil {
		svr.cancel()
	}
}

type ConnectionManager struct {
	ctx context.Context
	cfg *config.ClientCommonConf

	muxSession *fmux.Session
	quicConn   quic.Connection
}

func NewConnectionManager(ctx context.Context, cfg *config.ClientCommonConf) *ConnectionManager {
	return &ConnectionManager{
		ctx: ctx,
		cfg: cfg,
	}
}

func (cm *ConnectionManager) OpenConnection() error {
	xl := xlog.FromContextSafe(cm.ctx)

	// special for quic
	if strings.EqualFold(cm.cfg.Protocol, "quic") {
		var tlsConfig *tls.Config
		var err error
		sn := cm.cfg.TLSServerName
		if sn == "" {
			sn = cm.cfg.ServerAddr
		}
		if cm.cfg.TLSEnable {
			tlsConfig, err = transport.NewClientTLSConfig(
				cm.cfg.TLSCertFile,
				cm.cfg.TLSKeyFile,
				cm.cfg.TLSTrustedCaFile,
				sn)
		} else {
			tlsConfig, err = transport.NewClientTLSConfig("", "", "", sn)
		}
		if err != nil {
			xl.Warn("fail to build tls configuration, err: %v", err)
			return err
		}
		tlsConfig.NextProtos = []string{"frp"}

		conn, err := quic.DialAddr(
			cm.ctx,
			net.JoinHostPort(cm.cfg.ServerAddr, strconv.Itoa(cm.cfg.ServerPort)),
			tlsConfig, &quic.Config{
				MaxIdleTimeout:     time.Duration(cm.cfg.QUICMaxIdleTimeout) * time.Second,
				MaxIncomingStreams: int64(cm.cfg.QUICMaxIncomingStreams),
				KeepAlivePeriod:    time.Duration(cm.cfg.QUICKeepalivePeriod) * time.Second,
			})
		if err != nil {
			return err
		}
		cm.quicConn = conn
		return nil
	}

	if !cm.cfg.TCPMux {
		return nil
	}

	conn, err := cm.realConnect()
	if err != nil {
		return err
	}

	fmuxCfg := fmux.DefaultConfig()
	fmuxCfg.KeepAliveInterval = time.Duration(cm.cfg.TCPMuxKeepaliveInterval) * time.Second
	fmuxCfg.LogOutput = io.Discard
	fmuxCfg.MaxStreamWindowSize = 6 * 1024 * 1024
	session, err := fmux.Client(conn, fmuxCfg)
	if err != nil {
		return err
	}
	cm.muxSession = session
	return nil
}

func (cm *ConnectionManager) Connect() (net.Conn, error) {
	if cm.quicConn != nil {
		stream, err := cm.quicConn.OpenStreamSync(context.Background())
		if err != nil {
			return nil, err
		}
		return utilnet.QuicStreamToNetConn(stream, cm.quicConn), nil
	} else if cm.muxSession != nil {
		stream, err := cm.muxSession.OpenStream()
		if err != nil {
			return nil, err
		}
		return stream, nil
	}

	return cm.realConnect()
}

func (cm *ConnectionManager) realConnect() (net.Conn, error) {
	xl := xlog.FromContextSafe(cm.ctx)
	var tlsConfig *tls.Config
	var err error
	tlsEnable := cm.cfg.TLSEnable
	if cm.cfg.Protocol == "wss" {
		tlsEnable = true
	}
	if tlsEnable {
		sn := cm.cfg.TLSServerName
		if sn == "" {
			sn = cm.cfg.ServerAddr
		}

		tlsConfig, err = transport.NewClientTLSConfig(
			cm.cfg.TLSCertFile,
			cm.cfg.TLSKeyFile,
			cm.cfg.TLSTrustedCaFile,
			sn)
		if err != nil {
			xl.Warn("fail to build tls configuration, err: %v", err)
			return nil, err
		}
	}

	proxyType, addr, auth, err := libdial.ParseProxyURL(cm.cfg.HTTPProxy)
	if err != nil {
		xl.Error("fail to parse proxy url")
		return nil, err
	}
	dialOptions := []libdial.DialOption{}
	protocol := cm.cfg.Protocol
	switch protocol {
	case "websocket":
		protocol = "tcp"
		dialOptions = append(dialOptions, libdial.WithAfterHook(libdial.AfterHook{Hook: utilnet.DialHookWebsocket(protocol, "")}))
		dialOptions = append(dialOptions, libdial.WithAfterHook(libdial.AfterHook{
			Hook: utilnet.DialHookCustomTLSHeadByte(tlsConfig != nil, cm.cfg.DisableCustomTLSFirstByte),
		}))
		dialOptions = append(dialOptions, libdial.WithTLSConfig(tlsConfig))
	case "wss":
		protocol = "tcp"
		dialOptions = append(dialOptions, libdial.WithTLSConfigAndPriority(100, tlsConfig))
		// Make sure that if it is wss, the websocket hook is executed after the tls hook.
		dialOptions = append(dialOptions, libdial.WithAfterHook(libdial.AfterHook{Hook: utilnet.DialHookWebsocket(protocol, tlsConfig.ServerName), Priority: 110}))
	default:
		dialOptions = append(dialOptions, libdial.WithTLSConfig(tlsConfig))
	}

	if cm.cfg.ConnectServerLocalIP != "" {
		dialOptions = append(dialOptions, libdial.WithLocalAddr(cm.cfg.ConnectServerLocalIP))
	}
	dialOptions = append(dialOptions,
		libdial.WithProtocol(protocol),
		libdial.WithTimeout(time.Duration(cm.cfg.DialServerTimeout)*time.Second),
		libdial.WithKeepAlive(time.Duration(cm.cfg.DialServerKeepAlive)*time.Second),
		libdial.WithProxy(proxyType, addr),
		libdial.WithProxyAuth(auth),
	)
	conn, err := libdial.DialContext(
		cm.ctx,
		net.JoinHostPort(cm.cfg.ServerAddr, strconv.Itoa(cm.cfg.ServerPort)),
		dialOptions...,
	)
	return conn, err
}

func (cm *ConnectionManager) Close() error {
	if cm.quicConn != nil {
		_ = cm.quicConn.CloseWithError(0, "")
	}
	if cm.muxSession != nil {
		_ = cm.muxSession.Close()
	}
	return nil
}

```

修改后编译一个debug版本，再放到路由器内测试。

> https://github.com/fatedier/frp/blob/dev/package.sh 即这个项目的编译脚本，直接执行即可得到所需的比如misple版本。

可以看出错误位置在于：

```log
2023/08/14 13:53:31 [I] [service.go:295] Throwed from line:294, the origin error msg is:
2023/08/14 13:53:31 [I] [service.go:296] EOF
```

考虑到在参考其他人方案改为kcp模式时也会出现i/o deadline问题，这里我修改了读取的时间，从原来的10秒改为60秒：

```go
_ = conn.SetReadDeadline(time.Now().Add(60 * time.Second))
	if err = msg.ReadMsgInto(conn, &loginRespMsg); err != nil {
		xl.Info("Throwed from line:294, the origin error msg is: ")
		xl.Info(err.Error())
		return
	}
```

> 修改时间这个方式不一定是最后跑通的关键，建议先往后看。

修改后再编译执行，发现还是EOF，而且跟时间无关，日志仍然是秒报错。

```log
2023/08/14 14:27:41 [I] [root.go:220] start frpc service for config file [./frpc.ini]
2023/08/14 14:27:41 [I] [service.go:295] Throwed from line:294, the origin error msg is:
2023/08/14 14:27:41 [I] [service.go:296] EOF
2023/08/14 14:27:41 [W] [service.go:133] login to server failed: EOF
```

这个时候我（大概，可能，记不太清了）注意到了有这么一行[注释](https://github.com/fatedier/frp/blob/f1454e91f56508603e4c2e3c7bf37ccb534458c2/client/service.go#L244) 提到了Mux配置，我立即检查了我的服务端，发现我的服务端配置的`tcp_mux`选项([文档链接](https://github.com/fatedier/frp/blob/dev/README.md#tcp-stream-multiplexing))我设置成了false，而客户端默认没有使用时则为true，这里不匹配导致了conn的连接问题。

都更改为true之后，EOF问题解决，成功连接。

顺便记录排除frp报错EOF(i/o deadline)的过程

Padavan自己增加frp并排除故障

### 思路

利用Loopback，将原来两个不相交的通路重新定向：

![loopback2](/img/uploads/loopback2.jpg)

### 一些实验结果

![微信图片_20230804214412](/img/uploads/微信图片_20230804214412.png)

![微信图片_20230804214534](/img/uploads/微信图片_20230804214534.png)

![微信图片_20230804214842](/img/uploads/微信图片_20230804214842.png)

> 上面三个对比可以得出结论，定向到YY的声音主要取决于是否勾选该通道的监听。

![微信图片_20230804215114](/img/uploads/微信图片_20230804215114.png)

![微信图片_20230804215512](/img/uploads/微信图片_20230804215512.png)

![微信图片_20230804215332](/img/uploads/微信图片_20230804215332.png)

> 通过这三个对比之前的三个，对于YY等远端推流的软件而言，无所谓是否监听伴奏（loopback通道），只会影响本机能否听到声音。

> 如果不是推流，只是希望本机录歌的话，只需要两个通道，然后都勾选录制即可。或者直接将伴奏导入到音轨，避免二次内录。

Spark1e

Category: all