在校园网、小区网等环境中，运营商的光猫通常会被 Technical Report - 069（TR069）和远程维护系统（RMS）远程管理，这些系统会在你不知情的情况下修改你的光猫配置，甚至会在你不知情的情况下重置你的光猫，导致你的网络配置失效，甚至设备全部失联。因此，屏蔽这些远程管理机制是非常有必要的。
然而，不幸地是，新版本的光猫早已修复了一切可以删除 TR069 和 RMS的漏洞，包括但不限于：
uart_en=0本文将介绍一种全新的思路：通过故意制造 IP 冲撞，使得 RMS 服务访问异常，从而达到光猫不能正常拉取远程配置的目的。本方法不仅可以防止配置被远程修改，还能防止局端修改你的光猫超级管理员密码，以实现权限的固化，以解决我在 V2EX 提出的这个问题。
通常来说，如果我们划分了另一个网段，流量是需要通过网关来进行路由的。例如 LAN 网段为 172.20.0.0/24，然后我们在家庭 PVE 服务器上创建了一个用于虚拟机的 172.20.1.0/24 网段，其中 PVE 服务器的网卡的 IP 为 172.20.0.3 ，为了能够使得 LAN 的设备能直接访问虚拟机的 IP 段 172.20.1.0/24，就需要在网关设备上添加一个静态路由，指向 172.20.1.0/24，如下图。
诚然，这样做确实可以实现 LAN 的设备能直接访问虚拟机的 IP 段而不需要设置代理，但是这样做有一个缺点：所有访问虚拟机的流量都需要经过网关处理！这就导致了网关的 CPU 负载会变高，而且网关的网络带宽也会被内网访问虚拟机的流量占用。
注意到 PVE 服务器的网卡的 IP 为 172.20.0.3，和 LAN 位于同一网段，有没有什么办法可以直接让 LAN 的设备访问 172.20.1.0/24 段时，直接到达 172.20.0.3 而不要经过网关？
答案是有的，那就是静态路由主动推送。这个功能在 OpenWRT 上可以通过直接在 LUCI 上设置来实现，而在其他 Linux 发行版上可以通过修改 /etc/dnsmasq.conf 来实现。
本文将分享一些校园网的白嫖思路（WireGuard / SoftEther VPN Server基于 UDP 53 端口的 VPN 三层白嫖、Socks 5 白嫖+科学上网二合一的四层白嫖），也就是不花一分钱就和一般用户一样使用校园网。
2023/2/23: 更新各平台配置NAT命令和L2TP方法，并根据先前在评论区的答复介绍可以直接放弃的一些不可行的思路
下面列出的思路均要求使用一个校园网的服务器作为中转，因此，需要能够在不需要付费、认证后就能上网的网络环境（一般为办公区或实验室网络）下放一个电脑（树莓派也行）；或者有任意学校服务器的使用权。
整体思路就是找个在学校里面地方搭个服务器中转流量
原理：UDP 53 是 DNS 协议所用端口，由于门户（Portal）认证为了实现 HTTP 劫持跳转到登录页面，必须使得浏览器能够正常地进行 DNS 解析，因此在不认证、不付费的情况下也会放行 UDP 53 端口的流量。
特点：不需要校园网认证，不需要购买校园网，不需要校园网账号。此外由于 VPN 自带加密，因此可以克服开放 Wi-Fi 网络通信完全不加密的缺陷。
下面所列出的两个思路均是三层（IP）级的 VPN 方法，可以转发所有三层报文，因此支持 ICMP 协议（可以用ping）。
注意：使用 UDP 53 端口需要所在网络没有DNS劫持的问题，如果你所在的网络存在DNS劫持（例如，OpenWRT的DHCP/DNS下的”DNS重定向”功能就是DNS劫持），则该方法会失败。
我特别推荐此方案。WireGuard 是几乎无状态的VPN协议，切换网络零感知，不需要重新连接VPN，对于经常睡眠-唤醒的电脑特别有用。睡眠唤醒后可以立刻上网。此外 WireGuard 在 Linux 和 Windows 操作系统上均是纯内核态的实现，性能极其高。
方法：搭建一个 wireguard 服务端，然后端口监听在 53 上
搭建 Linux 服务端的教程很多，一键包也很多。但若要搭建 Windows 服务端，请一定要阅读我之前的这篇文章。
缺点：搭建确实有些复杂，另外配置文件对于不懂计算机网络的人来说实在是晦涩难懂
本文分为两节，分别是如何在 Windows 上利用 Hyper-V 交换机实现对 VLAN 的支持；以及如何利用 Hyper-V 交换机功能创建多块虚拟网卡，实现单线多拨叠加网速。可以只使用 Hyper-V 交换机而不使用 Hyper-V 虚拟机，所以这不会影响你电脑的性能。以上功能均不需要网卡驱动支持。
效果图：
ℹ️ 使用 Hyper-V 功能需要 Windows 10 专业版 或以上版本，如果你使用的是家庭版，可以通过断网更改产品密钥、再通过KMS服务器激活的方式原地升级到专业版。
在本科学历日渐贬值时代，读研基本成了一个日常话题，然而考研成本甚高，即使是不参与线下培训班、纯网课也往往需要花费万元以上。正好老早就有线下好友吐槽我博客技术文太多 哪有那么多啊，我真的从来都不写复杂技术的文章的啊，乘着手上的拟录取通知还热乎，今天就来分享分享如何用超低成本考研。
我的考研开销情况：
| 类目 | 花费（人民币/元） | 备注 |
|---|---|---|
| 书本 | 249.65 | 126.41（13本书，pdd）+ 123.24（5本书，正版） |
| 初试报名费 | 180 | |
| 耗材（纸、笔等） | 25 | 有优惠券那就买纸罢 |
| 网课 | 0 | |
| 复试费 | 0 | 目标院校不收复试费，另外收费院校的复试通知被我鸽了 |
| 总计 | 454.65 | 这个开销可以更小，至少可以再少 100 |
生草的是，学信网上关于考研开销的调查表甚至没有这么低的选项。
有一个虚拟机运行在 VMWare workstation 中，如何让这个虚拟机桥接到宿主机的网络上的某个 VLAN？
只有一个网口的单臂软路由，同时宿主机为 Windows，虚拟机软件为 VMware Workstation，在虚拟机中运行 OpenWrt
需要在一个网口上，利用 VLAN 实现虚拟 WAN 口上的 PPPoE 拨号和 虚拟 LAN 口上的上网服务。
今天无意翻阅 Scanner 类时，发现了一个很坑的地方：
// 摘抄自 Scanner JDK15 源码
public final class Scanner implements Iterator<String>, Closeable {
....
// Internal matcher used for finding delimiters
private Matcher matcher;
// Pattern used to delimit tokens
private Pattern delimPattern;
// Pattern found in last hasNext operation
private Pattern hasNextPattern;
private Pattern integerPattern;
private String digits = "0123456789abcdefghijklmnopqrstuvwxyz";
private String non0Digit = "[\\p{javaDigit}&&[^0]]";
private int SIMPLE_GROUP_INDEX = 5;
private String buildIntegerPatternString() {
String radixDigits = digits.substring(0, radix);
// \\p{javaDigit} is not guaranteed to be appropriate
// here but what can we do? The final authority will be
// whatever parse method is invoked, so ultimately the
// Scanner will do the right thing
String digit = "((?i)["+radixDigits+"\\p{javaDigit}])";
String groupedNumeral = "("+non0Digit+digit+"?"+digit+"?("+
groupSeparator+digit+digit+digit+")+)";
// digit++ is the possessive form which is necessary for reducing
// backtracking that would otherwise cause unacceptable performance
String numeral = "(("+ digit+"++)|"+groupedNumeral+")";
String javaStyleInteger = "([-+]?(" + numeral + "))";
String negativeInteger = negativePrefix + numeral + negativeSuffix;
String positiveInteger = positivePrefix + numeral + positiveSuffix;
return "("+ javaStyleInteger + ")|(" +
positiveInteger + ")|(" +
negativeInteger + ")";
}
private Pattern integerPattern() {
if (integerPattern == null) {
integerPattern = patternCache.forName(buildIntegerPatternString());
}
return integerPattern;
}
public int nextInt(int radix) {
// Check cached result
if ((typeCache != null) && (typeCache instanceof Integer)
&& this.radix == radix) {
int val = ((Integer)typeCache).intValue();
useTypeCache();
return val;
}
setRadix(radix);
clearCaches();
// Search for next int
try {
String s = next(integerPattern());
if (matcher.group(SIMPLE_GROUP_INDEX) == null)
s = processIntegerToken(s);
return Integer.parseInt(s, radix);
} catch (NumberFormatException nfe) {
position = matcher.start(); // don't skip bad token
throw new InputMismatchException(nfe.getMessage());
}
}
....
}
可见，Java 的 Scanner 是基于正则表达式实现的，这意味着 Scanner 的效率 相当低。如果在蓝桥杯之类的算法竞赛用 Scanner，会有很大一部分CPU时间会浪费在 Scanner 的正则解析上，就很可能跑出 TLE
这篇文章不探讨如何快速读取大型一般二进制文件，关注重点在于在低 JDK 版本下，如何快速解析文本，而非 “快速“ 读取文件。快速读取一般二进制大文件请考虑：
StringTokenizer 是一个自 Java 1.0 就被引入的类，用于以标识符分隔字符串，也就是解析文本
Scanner 之所以复杂，主要在于它假定所有输入数据都是任意的、类型是不确定的，同时 Scanner 还要兼顾处理输入流，所以不得不使用正则表达式去进行处理。
由于算法竞赛的给定数据的类型都是已知的，我们可以直接使用 StringTokenizer 去代替 Scanner
有报告显示，StringTokenizer 结合 BufferedReader 读入流的性能甚至高于 C 语言的 scanf()
StringTokenizer 有三个常用构造方法
Constructs a string tokenizer for the specified string. The tokenizer uses the default delimiter set, which is “ \t\n\r\f”: the space character, the tab character, the newline character, the carriage-return character, and the form-feed character. Delimiter characters themselves will not be treated as tokens.
Params: str – a string to be parsed.
Throws: NullPointerException – if str is null
public StringTokenizer(String str) {
this(str, " \t\n\r\f", false);
}
Constructs a string tokenizer for the specified string. The characters in the delim argument are the delimiters for separating tokens. Delimiter characters themselves will not be treated as tokens.
Note that if delim is null, this constructor does not throw an exception. However, trying to invoke other methods on the resulting StringTokenizer may result in a NullPointerException.
Params: str – a string to be parsed.
delim – the delimiters.
Throws: NullPointerException – if str is null
public StringTokenizer(String str, String delim) {
this(str, delim, false);
}
public String nextToken()
返回每一段被分隔的字符串 (token)，等效于 Scanner.next()， 返回结果是否包含分隔符取决于你的构造参数
如果没有更多 token，会抛出 java.util.NoSuchElementException
public boolean hasMoreTokens()
true 表示有更多，可以安全地调用 nextToken()
问题来了，StringTokenizer 好像并没有 Scanner 的 nextInt() nextLong() 之类的东西，怎么办？
现场写个类去解析他！
import java.util.StringTokenizer;
public class ExtendedStringTokenizer extends StringTokenizer {
public ExtendedStringTokenizer(String str) {
super(str);
}
public long nextLong() {
return Long.parseLong(this.nextToken());
}
public double nextDouble() {
return Double.parseDouble(this.nextToken());
}
public int nextInt() {
return Integer.parseInt(nextToken());
}
}
只需继承一下 StringTokenizer，寥寥几行代码便可搞定
注意：此处 nextInt() nextLong() 不允许输入为小数，否则会引发解析错误。如果确实需要处理小数，可以考虑在解析前使用 indexOf() 和 substring() 截去小数。
现在知道如何解析字符串了，但是怎么从流中读入字符串呢？
假设现在我们有了一个 InputStream inputStream，这个 InputStream 可以是：
System.inFileInputStream("FileName")由于算法竞赛的 JDK 版本一般很低，无法使用 NIO
这是性能最好的，并且是典型的空间换时间的方案。
以蓝桥杯竞赛为例，通常提供高达 512 MB 的算法运行内存空间，这个时候可以直接把整个流全部读入后解析。
DataInputStream stream = new DataInputStream(inputStream);
ExtendedStringTokenizer tokenizer = new ExtendedStringTokenizer(new String(stream.readAllBytes()));
注： Java 1.7 以上可以使用 Files.readString(Path.of("filename")) 直接读入整个文件到字符串
有读者可能注意到了这里并没有直接使用 DataInputStream 提供的 readInt() readDouble() 等方法，这里有一点需要理解：
例如，下面代码：
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream("5 1234567 2".getBytes());
DataInputStream dataInputStream = new DataInputStream(byteArrayInputStream);
System.out.println(dataInputStream.readLong());
System.out.println(dataInputStream.readLong());
System.out.println(dataInputStream.readLong());
输出：
3828113774942106934
Exception in thread "main" java.io.EOFException
根本不是我们想要的。
上面的说法是为了告诉你不要用它，事实上，更准确的说，readInt() readDouble() 是把一串二进制字节当作一个整体读入，用于处理二进制文件。与我们今天要做的事情（读取文本）一点关系都没有。
Reader 是专用于处理字符流的类，相对的，Stream 处理的是字节流
逐行读入时，使用 BufferedReader 包装 InputStreamReader， InputStreamReader 包装 InputStream 可以有效提升性能
// 注：BufferedReader 可以提供第二个参数，类型为 int，表示缓冲区容量，提供一个较大的容量可以更快
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while ((line = reader.readLine()) != null) {
ExtendedStringTokenizer tokenizer = new ExtendedStringTokenizer(line);
// TODO: your code
}
如果读取目标是文件，可以用 new FileReader("filename") 代替 new InputStreamReader(inputStream)
由于 StringTokenizer 只是一个简单的小对象，所以循环反复创建的开销还是很小的。但还是比一次性读入慢了很多
注意：
System.in标准输入流不一定不提供 EOF，若用户在终端上按下Ctrl+D或通过其他方式输入等效内容，则System.in会将此视作一个 EOF。但若用户一直不按Ctrl+D那就是无限等待输入了。
由于这种流不提供 EOF，我们没法直接全部读入，直接全部读入会造成永久阻塞。
但是，这种流肯定会告诉我们输入数据有多少行，我们可以用行数作为依据判断是否还要继续读。
假设第一行告诉我们后续输入有多少行：
// 注：BufferedReader 可以提供第二个参数，类型为 int，表示缓冲区容量，提供一个较大的容量可以更快
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
ExtendedStringTokenizer initTokenizer = new ExtendedStringTokenizer(reader.readLine());
int lineNum = initTokenizer.nextInt();
for (int i = 0; i < lineNum; i++) {
// TODO: your code
ExtendedStringTokenizer tokenizer = new ExtendedStringTokenizer(reader.readLine());
}
如果读取目标是文件，可以用 new FileReader("filename") 代替 new InputStreamReader(inputStream)
如果输入数据，一个字符（注意不是字节）就是一个整体，那么还可以逐字符读取：
所用方法：
public int read()
读一个字符，并返回它。如果读到了 EOF 则返回 -1
例如：读取一个 ASCII 编码的、读取目标为数字、有换行符的文件到一个二维数组，每一个数字都是一个整体，每次换行就读取到数组的下一行。
var reader = new BufferedReader(new FileReader(PATH), 1 << 16);
byte[][] maze = new byte[100][100]; //读取的结果位于 0~9 之间，byte省空间
int lineCode = 0; // 也是实际有效行数
int colCode = 0; // 实际有效列数
int token;
while ((token = reader.read()) != -1) {
if (token >= '0' && token <= '9') {
maze[lineCode][colCode] = (byte) (token - '0');
colCode++;
} else if (token == '\n') {
lineCode++;
if (colCode == 0) {
colNum = colCode;
}
colCode = 0;
}
}
对于多个数字是一个整体的，当然也可以使用自行读取一组数据到缓冲区，然后自行解析。然而，编写解析代码所花费的时间可能远不如使用 StringTokenizer 划算，而且这样操作带来的性能提升实际上也非常有限。
所用 Reader 方法：
public int read()
public int read(char cbuf[], int off, int len) throws IOException
后者为：从流中读取指定长度(len)的字符流，并从偏移量(off)开始装入你的数组 cbuf[]，返回实际读取的有效长度（实际长度小于等于 len）
当然也可以使用前文提到的 DataInputStream
toCharArray() 后遍历就我个人在 LeetCode 的刷题经验，当字符串编码为 Latin 时，直接 String.charAt() 会比 toCharArray() 后遍历更快（事实上在 JDK 源代码也可以找到相关依据）。
若对此有疑问，请阅读 toCharArray() 的源代码，并与 String.charAt() 进行对比，可见：
toCharArray() 会创建一个新字符数组，然后逐字符拷贝，并与 0xFF 进行与运算，这比 System.arraycopy() 直接数组拷贝的性能低很多。charAt() 也会进行一次与运算，但却不需要逐字拷贝而是直接访问 String 内部的字符数组。这是 Hyper-V 导致的，可以卸载 Hyper-V 平台解决它。
具体参考：
这是 Hyper-V 平台导致的，只要装了 Hyper-V 平台就会这样，暂时没找到关闭办法。
先卸载 Hyper-V 平台、沙盒、容器、虚拟机平台、虚拟机监控程序平台。
如果之后需要使用这些功能可以重启后再启用。
执行：wsl --shutdown 强制停止 WSL 后再试。
升级最新的 15.5.5 可以兼容 Hyper-V 了。
似乎是一个 Bug，当剪贴板有图片时进入虚拟机就会导致卡死。
关于这个，我在 VMWare 社区发了个帖子：Workstation and Player GUI freezed when host clipboard has image on Windows 10
打开手心输入法的安装目录，对所有的 exe：
属性 -- 兼容性选项 -- 更改所有用户的设置 -- 更改高 DPI 设置 -- 高 DPI 缩放替代 -- 选择 “应用程序”
另外可以禁用掉手心输入法的开机启动，没有任何其他影响
我保留了一份 网易云音乐 UWP 版 Appx Bundle 存档，可以在这里下载：kenvix/NeteaseMusicUWP
这个沙雕版本正好和 Windows 10 2004 同时发布，就写到一起了
如果你开启了系统代理，请排除以下地址：
mobile.pipe.aria.microsoft.com
login.windows.net
此外，如果你使用 OneDrive for Business 还需要排除掉你的 SharePoint 域名，例如 example-my.sharepoint.com
最近在学习 Kotlin 这门编程语言，不得不感叹 Kotlin 这语言是真的骚。
interface BotUser {
val id: Long
val name: String
val description: String
companion object {
operator fun invoke(
id: Long,
name: String = "",
description: String = ""
): BotUser {
return BotUserImpl(id, name, description)
}
}
}
class BotUserImpl(...) { ... }
如果你这样做的话，可以让接口或者抽象类仿佛看起来能够被实例化一样（看似调用“构造方法”，实际上是调用了 invoke() ）。
用途：项目中途将某个类抽象为一个接口，并将原有类作为此接口的默认实现，这样可以做到源代码的兼容（对 Java 代码以及二进制仍不兼容，毕竟本质不同）。
代码来自我的项目 “MoeCraftBotNG”
一般可以重载 get() set() 来使对象能够按数组、字典一样去操作。
为对象编写 contains() 方法时（判断某个元素是否“属于”此对象），可以顺便为此方法加个 operator 关键字可以让 in 关键字支持这个对象
然而操作符重载还是慎用为妙，众所周知这个特性就是被 C++ 玩坏的，当你 java 甚至以不支持操作符重载为荣。好在 Kotlin 在这方面也比较节制。
如果想让你的 suspend 函数被 Java 用户友善地调用，防止你被人砍，你可以：
用 Kotlin 编写一个类：
class Coroutines {
/**
* 获取在 Java 代码中调用 Kotlin Suspend 函数所需的最后一个参数 (Continuation)
* @param onFinished 当suspend函数执行完毕后所调用的回调。若 Throwable 不为 null 则说明执行失败。否则为执行成功
* @param dispatcher 协程执行线程的类型。可以为 Dispatchers.Default(CPU密集型) Dispatchers.Main(主线程) Dispatchers.IO(IO密集型)
*/
@JvmOverloads
fun <R> getContinuation(onFinished: BiConsumer<R?, Throwable?>, dispatcher: CoroutineDispatcher = Default): Continuation<R> {
return object : Continuation<R> {
override val context: CoroutineContext
get() = dispatcher
override fun resumeWith(result: Result<R>) {
//注意 Result 是 inline class，不可直接给出去
onFinished.accept(result.getOrNull(), result.exceptionOrNull())
}
}
}
}
kotlin suspend 函数的调用难点在于最后一个参数，这个参数是 suspend 函数自动生成的，但是在 Java 方面处理起来却十分棘手。你可以提供这样的一个类来生成最后一个参数的值。
然后在 Java 中，就可以这样调用了：
Coroutines coroutines = new Coroutines();
//假设一个 suspend fun login(username: String, password: String): RequestResult，位于 object UserUtils
UserUtils.INSTANCE.login("user", "pass", coroutines.getContinuation(
(result, throwable) -> {
//suspend fun执行结束的回调
System.out.println("Coroutines finished");
System.out.println("Result: " + result);
System.out.println("Exception: " + throwable);
}
)
);
另外，也可以使用 org.jetbrains.kotlinx:kotlinx-coroutines-jdk8，这个库可以让 suspend fun 返回 CompletableFuture<> 以便在 java 使用
fun doSomethingAsync(): CompletableFuture<List<MyClass>> =
GlobalScope.future { doSomething() } //返回 CompletableFuture 包装的 suspend fun doSomething()
Kotlin 有很多实用的内置函数，只提几个。
run() 字面意思，用于执行一个任意代码块，并返回代码块的返回值
run() 有两种，签名如下：
public inline fun <R> run(block: () -> R): R
public inline fun <T, R> T.run(block: T.() -> R): R
第一种 run() 在为构造函数委托传递参数时特别有用，例如有一个类和两个次构造函数
class ManagedJavaProperties(val inputStream: InputStream, val outputStream: OutputStream? = null) {
constructor(file: File): this(file.inputStream(), file.outputStream())
constructor(fileName: String): this(???) //需要进行处理才能委托给其他构造函数
}
第二个次构造函数中需要对 fileName 进行一些处理，此时需要 run() 登场了：
class ... {
constructor(fileName: String): this(
kotlin.run {
val file = File(fileName)
if (!file.exists()) {
file.createNewFile()
}
file
}
)
}
第二种 run() 则是将调用者当作 this 传递给 lambda，除此之外和第一种完全相同
run() 也可以用于防止代码块内变量污染当前作用域。（类似于 Java 的 { } ）
Kotlin 的 @Suppress 注解不仅可以抑制警告，还可以抑制任何错误。具体的错误名字可以到 kotlin 编译器项目按错误提示寻找。
默认情况下，Windows 10 资源管理器的功能区对绝大多数文本格式的不可用的，即使能够使用（例如 .js .cpp .txt 等格式），“编辑”按钮所对应的编辑器也是废物一般的记事本（用记事本写代码？）,使得这个“编辑”按钮显得华而不实。为了让编辑文本更加方便、充分利用这个“编辑”按钮，本文将介绍如何通过修改注册表以为为所有格式激活“编辑”按钮并修改文本文件“编辑”按钮的编辑器
Windows10 功能区的“编辑”按钮可用与否取决于注册表中HKEY_CLASSES_ROOT中对应的格式下的shell项是否存在edit子项，若edit项存在，则该按钮可用
只需增加edit子项并设置启动命令行即可激活编辑按钮或达到更改编辑器的目的
Windows Registry Editor Version 5.00
[HKEY_CLASSES_ROOT\*\shell]
[HKEY_CLASSES_ROOT\*\shell\edit]
[HKEY_CLASSES_ROOT\*\shell\edit\command]
@="\"编辑器路径\" \"%1\""
[HKEY_CLASSES_ROOT\txtfile\shell]
[HKEY_CLASSES_ROOT\txtfile\shell\edit]
[HKEY_CLASSES_ROOT\txtfile\shell\edit\command]
@="\"编辑器路径\" \"%1\""
将上述代码中的 编辑器路径 替换为你的编辑器的路径，然后将上述代码保存为 1.reg ，双击导入即可
注：本文章撰写于2013-03-05，考虑到部分博客仍然在使用这种方法，故于2018-07-31人力导入。
我不推荐在AI技术已经如此发达的今天继续使用这种方法防御垃圾评论。
这是打√的验证机制，打√至少比原生的验证码方便，比滑动条减少文件加载。只要能防住机器刷评论就行。手工垃圾评论不怕。现在把方法无偿分享出来，供各位有需要的emer使用。