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

前端

技术

生活

关于我

进入NetlifyCMS

Spark1e的Github

前往Twitter

给spark1e发邮件

在博客中搜索……

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

### 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通道），只会影响本机能否听到声音。

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

Loopback + Studio One，不使用虚拟跳线

利用声卡的Loopback通道配合机架输出到YY

![usb版本跳线](/img/uploads/usb版本跳线.png)

如图，使用的是Banana版本，可以免费试用（定期会出现Donate弹窗，可以忽略），对于单一的USB麦克风，使用这个软件能够实现大部分的功能。

### 设置输入输出

左边HARDWARE INPUT是可选的输入硬件，输入硬件一般是独立的麦克风，或者耳机的麦克风，这里因为是USB设备，没有单独的ASIO驱动，所以在列表里要选择WDM或者MME，一般而言，WDM的延迟会更低一些。

右边HARDWARE OUTPUT是可选的输出，这里会控制你的所有音频监听设备，因此请注意建议先把下面 MASTER SECTION里能Mute的都先Mute掉，否则可能瞬间出现非常大的声音。

设置输出时，比如我现在有音响，耳机，两个设备，我可以设置A1为耳机输出，A2为音响输出，这时候如果我把A1的输出Mute解开，音频就会从耳机播放。同理对于音响的A2也是一样。

> 一般使用单麦克风的时候，无法录制立体声，这时候我们勾选这一路输入的mono，即可模拟出立体声（左右声道）的效果。

### 设置系统声音输出

为了让VoiceMeeter能够同时获得系统播放的声音（比如伴奏），需要将系统声音也指向VoiceMeeter。软件安装好之后会在系统声音设备里出现两个新的输入和输出——VAIO和AUX，这里暂时先不区别这两种的区别（Banana版，Potato版本会提供更多的），只把他们当作两个虚拟的设备。

我希望把系统声音指向到VoiceMeeter的VAIO，那么我需要在系统里将声音的默认播放设备改为VoiceMeeter Input (VAIO)，如图，设备左下角有个对勾表示设置默认成功：

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

同理，如果你的YY没有遵循系统的默认设置，你可以手工在列表里选成如图所示：

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

但是这个时候，通过耳机（A1）通道还是听不到系统声音，这是因为系统声音被指向了中间VIRTUAL INPUTS的左边VAIO中，如果你现在网页播放声音，能够看到中间出现电平变化，那么意味着VoiceMeeter收到了系统声音。

但是为什么耳机还不能听到呢，因为我们还没用引导VoiceMeeter收到的声音到系统。点亮VAIO的A1（耳机）输出，这个时候声音就来到了耳机。

### 规划跳线

跳线，就是通过配置线路，将合适的单路、多路声音汇总到一起，既可以汇总多个声音到输入，也可以汇总多个到输出，在使用USB麦克风的时候，我的规划是这样的：

![跳线step2-混合声音信号](/img/uploads/跳线step2-混合声音信号.jpg)

> 如果觉得延迟比较高，可以将系统声音直接输出到A1里，来获得更低的延迟。

> 本文还没有涉及接入机架的部分，可能会另起一篇文章来更新。

### 内录功能

右上角是VoiceMeeter的内录，即输入到VoiceMeeter的声音都可以被录入。录入后的回放，可以勾选右侧来选择输出到哪个设备。

之前用小雪球（Blue Snowball ICE）

VoiceMeeter用于麦克风跳线的简单记录

### JavaScript - Array

IE全系列不兼容`Array.prototype.find`，部分可能的旧版本也可能确实Array下的其他方法，提供一些polyfill供参考。

```javascript
// Polyfill for Array.prototype
(function () {
    if (!Array.prototype.find) {
        console.log("Polyfill 'array.find'");
        Array.prototype.find = function(callback) {
            if (this === null) {
              throw new TypeError('Array.prototype.find called on null or undefined');
            } else if (typeof callback !== 'function') {
              throw new TypeError('callback must be a function');
            }
            var list = Object(this);
            // Makes sures is always has an positive integer as length.
            var length = list.length >>> 0;
            var thisArg = arguments[1];
            for (var i = 0; i < length; i++) {
              var element = list[i];
              if ( callback.call(thisArg, element, i, list) ) {
                return element;
              }
            }
          };
    }
    if (!Array.prototype.filter) {
        console.log("Polyfill 'array.filter'");
        Array.prototype.filter = function (callbackFn) {
            var arr = [];
            for (var i = 0; i < this.length; i++) {
                if (callbackFn.call(this, this[i], i, this)) {
                    arr.push(this[i]);
                }
            }
            return arr;
        }
    }
    if (!Array.prototype.map) {
        console.log("Polyfill 'array.map'");
        Array.prototype.map = function (callbackFn) {
            var arr = [];
            for (var i = 0; i < this.length; i++) {
                /* call the callback function for every value of this array and push the returned value into our resulting array */
                arr.push(callbackFn(this[i], i, this));
            }
            return arr;
        }
    }
}())
```

> 如果你的环境允许，可以使用[polyfill.io](https://polyfill.io/v3/) 的工具来生成一个根据不同浏览器自动加载的polyfill包，但是请小心[供应链攻击](https://www.cloudflare.com/zh-cn/learning/security/what-is-a-supply-chain-attack/)

### CSS - Flex bug

#### using flex

flexbox 需要IE10+

#### `justify-content: center;`

需要在出现问题的容器上加上：

```css
flex-direction: column;
```

尽管无论是哪个轴，双center原则上应该是整个容器中心，但是IE下必须声明。

#### background image using data uri (SVG)

部分SVG特性不支持，保险起见，用URL链接吧。

> 不过base64的png url还可以。

2023年了，您还在兼容IE呢？

“被迫”兼容IE11遇到的一些问题和解决方案

不多说，直接先上代码，

```javascript
function copy2Clipboard(content) {
if (window.navigator && window.navigator.clipboard) {
  navigator.clipboard.writeText(content).then(() => {
    console.log('success')
  }, () => {
    console.log('failed')
    console.log(arguments)
  }).catch(e => {
    console.log(e)
  })
} else {
  var i = document.createElement("input")
  i.setAttribute("style", "position:absolute;z-index:-1;width:1px;height:1px;top:-1px;opacity:0;-webkit-user-select: text;")
  document.body.appendChild(i)
  i.value = content
  var t = i.contentEditable,
    n = i.readOnly,
    o = document.createRange();
  i.contentEditable = !0
  i.readOnly = !1
  o.selectNodeContents(i);
  var a = window.getSelection();
  a.removeAllRanges()
  a.addRange(o)
  i.setSelectionRange(0, 999999)
  i.contentEditable = t
  i.readOnly = n
  window.document.execCommand("Copy")
  i.blur()
  document.body.removeChild(i)
  i = null
}
}
```

### 坑

1. 部分浏览器对navigator.clipboard支持很差，建议用else的代码；
2. __Safari如果要访问剪贴板，需要在可信的HTTPS环境下执行，自签的证书是无法调用`execCommand`/`avigator.clipboard.writeText`的__


##### 附录：一个之前写的有注释的版本

```javascript
function copyToClipboard(text) {
    if (text === "") return;
    var ipt = document.createElement('input'); // maybe you need to change `input` to `textarea`
    ipt.setAttribute(
        'style',
        'position:absolute;z-index:-1;width:1px;height:1px;top:-1px;opacity:0;-webkit-user-select: text;'
    )
    document.body.appendChild(ipt)
    ipt.value = text
    // ipt.select()
    if (/iphone|ipad|ios/.test(navigator.userAgent.toLowerCase())) {
        var oldContentEditable = ipt.contentEditable
        var oldReadOnly = ipt.readOnly
        var range = document.createRange()

        ipt.contentEditable = true
        ipt.readOnly = false
        range.selectNodeContents(ipt)

        var s = window.getSelection()
        s.removeAllRanges()
        s.addRange(range)

        ipt.setSelectionRange(0, 999999) // A big number, to cover anything that could be inside the element.

        ipt.contentEditable = oldContentEditable
        ipt.readOnly = oldReadOnly
    } else {
        ipt.select()
    }
    window.document.execCommand('Copy')
    ipt.blur()
    document.body.removeChild(ipt)
    ipt = null
}
```

Spark1e

Category: all