├── .gitignore
├── .gitmodules
├── src
    ├── func.h
    ├── main.cpp
    ├── fills.hpp
    └── func.cpp
├── LICENSE
├── makefile
├── README.md
└── config_template.json


/.gitignore:
--------------------------------------------------------------------------------
1 | /**/*.out
2 | /.vscode/
3 | /out
4 | /src/include/myBase64/*
5 | /src/lib/
6 | /test.cpp
7 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "3rdparty/myBase64"]
2 | 	path = 3rdparty/myBase64
3 | 	url = https://github.com/leafee98/myBase64.git
4 | 	branch = stable
5 | 


--------------------------------------------------------------------------------
/src/func.h:
--------------------------------------------------------------------------------
 1 | # pragma once
 2 | 
 3 | #include <string>
 4 | #include <json/json.h>
 5 | 
 6 | struct run_param {
 7 |     std::string template_file;
 8 |     std::string output_file;
 9 |     std::string vmess_link;
10 |     bool display_help;
11 |     bool display_ps;
12 |     bool display_link;
13 | 
14 |     run_param();
15 | };
16 | 
17 | extern const std::string VMESS_SCHEMA;
18 | 
19 | void print_usage();
20 | void display_ps(const run_param & runp);
21 | void display_link(const run_param & runp);
22 | 
23 | bool parse_parameters(int argc, char * argv[], run_param & runp);
24 | std::string check_files(const run_param & runp);
25 | 
26 | Json::Value decode_vmess(const std::string & vmess_link);
27 | Json::Value read_template(const std::string & template_file);
28 | 
29 | std::string unicode_to_utf8(const std::string & str);
30 | void write_output(const run_param & runp, const Json::Value & output_json,
31 |         const Json::Value vmess_json);
32 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Leafee
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "fills.hpp"
 2 | #include "func.h"
 3 | #include <json/json.h>
 4 | #include <iostream>
 5 | #include <string>
 6 | 
 7 | int main(int argc, char * argv[]) {
 8 |     run_param runp;
 9 | 
10 |     if (! parse_parameters(argc, argv, runp))
11 |         return EXIT_FAILURE;
12 | 
13 |     if (runp.display_help) {
14 |         print_usage();
15 |         return EXIT_SUCCESS;
16 |     }
17 | 
18 |     if (runp.display_link) {
19 |         display_link(runp);
20 |         return EXIT_SUCCESS;
21 |     }
22 | 
23 |     if (runp.display_ps) {
24 |         display_ps(runp);
25 |         return EXIT_SUCCESS;
26 |     }
27 | 
28 |     std::string check_result = check_files(runp);
29 |     if (check_result.size() > 0) {
30 |         std::cerr << check_result;
31 |         return EXIT_FAILURE;
32 |     }
33 | 
34 |     Json::Value vmess_json = decode_vmess(runp.vmess_link);
35 |     if (vmess_json == Json::Value::nullSingleton) {
36 |         std::cerr << "unsupported schema or not the vmess 2rd version\n";
37 |         return EXIT_FAILURE;
38 |     }
39 | 
40 |     Json::Value template_json = read_template(runp.template_file);
41 |     Json::Value output_json = fill_config(template_json, vmess_json);
42 |     write_output(runp, output_json, vmess_json);
43 |     
44 |     return EXIT_SUCCESS;
45 | }
46 | 


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
 1 | .PHONY : help
 2 | help :
 3 | 	@echo "    gitSubModule         update submodule of git"
 4 | 	@echo "    dependency           copy dependency from submodule"
 5 | 	@echo "    build                build the project"
 6 | 	@echo "    install              install the binary file and template file"
 7 | 	@echo "    all                  build and install the project"
 8 | 	@echo "    clean                clean files created by build"
 9 | 
10 | .PHONY : gitSubModule
11 | gitSubModule :
12 | 	git submodule init
13 | 	git submodule update
14 | 
15 | .PHONY : dependency
16 | dependency : gitSubModule
17 | 	make --directory=./3rdparty/myBase64/ all
18 | 	[ -d ./src/lib/ ] || mkdir -p ./src/lib
19 | 	cp ./3rdparty/myBase64/out/libmyBase64.a ./src/lib/libmyBase64.a
20 | 	[ -d ./src/include/myBase64 ] || mkdir -p ./src/include/myBase64
21 | 	cp ./3rdparty/myBase64/src/myBase64.h ./src/include/myBase64/myBase64.h
22 | 
23 | .PHONY : clean
24 | clean :
25 | 	make --directory=./3rdparty/myBase64/ clean
26 | 	rm -rf ./out/
27 | 
28 | .PHONY : build
29 | build : dependency
30 | 	[ -d ./out/ ] || mkdir ./out/
31 | 	g++ --std=c++17 ./src/main.cpp ./src/func.cpp -o ./out/parsevmess -L./src/lib -lmyBase64 -ljsoncpp
32 | 
33 | .PHONY : install
34 | install : build
35 | 	install ./out/parsevmess /usr/bin/
36 | 	[ -f /etc/v2ray/config_template.json ] || install ./config_template.json /etc/v2ray/
37 | 
38 | .PHONY : all
39 | all : build install
40 | 
41 | .PHONY : uninstall
42 | uninstall :
43 | 	rm /usr/bin/parsevmess
44 | 	rm /etc/v2ray/config_template.json
45 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ParseVmess
 2 | 
 3 | 把Vmess链接导入到配置模板生成可用的配置
 4 | 
 5 | ⚠⚠ This is a practice project when I'm learning cpp, and shouldn't be used
 6 | for purpose other than practice, not to mention in product environment. ⚠⚠
 7 | 
 8 | ⚠⚠ 这只是一个学习 cpp 时的练习项目，不应该以练习以外为目的来使用，更不应该用于生产环境。 ⚠⚠
 9 | 
10 | ## 编译
11 | 
12 | 请**预先安装jsoncpp的依赖项**,
13 | 如arch Linux的发行版可以使用`pacman -S jsoncpp`进行安装.
14 | 
15 | 在依赖项安装正确的前提下,
16 | 可以在克隆整个项目以后使用`make all`进行编译,
17 | `makefile`中会递归克隆子模块.
18 | 
19 | ## 使用
20 | 
21 | 几乎完全重写了整个代码,
22 | 重写后的项目在以命令行参数的形式接收vmess链接和制定输入输出位置.
23 | 
24 | 使用时需要有配置模板文件,
25 | 配置模板与普通的v2ray配置文件类似,
26 | 可以根据自己需要进行修改,
27 | 但是outbound的第一个对象会被vmess分享链接的内容覆盖,
28 | 其他项的内容则会保留.
29 | 
30 | 程序帮助如下:
31 | 
32 | ```
33 | usage:
34 |         parsevmess [-t <template file>] [-o <output file>] <vmess link>
35 |                    [-h] [-p] [-e]
36 |     -t, --template <template file>
37 |               Specify where the template file is.
38 |               Use /etc/v2ray/config_template.json if not specified.
39 |     -o, --output <output file>
40 |               Specify where to output the filled the config.
41 |               Use /etc/v2ray/config.json if not specified.
42 |               If specified dash(-), will print to stdout.
43 |     -e, --export
44 |               Export the vmess link used by <output file> now.
45 |               Take care that this option is only display the vmess link
46 |               stored as comment in <output file>.
47 |     -p, --ps
48 |               Display the ps of vmess link now using.
49 |               Take care that this option is only display the ps
50 |               stored as comment in <output file>.
51 |               This is DEFAULT option if no parameter specified
52 |     -h, --help
53 |               Display this help
54 | 
55 |     <vmess link>
56 |               Specify the vmesslink to be used..
57 | ```
58 | 
59 | ## 安装
60 | 
61 | 可以使用`make all`或者`make insall`来安装文件到合适的位置.
62 | 
63 | 如果需要卸载, 可以执行`make uninstall`.
64 | 
65 | 注意在安装和卸载时, 可能需要使用sudo权限.
66 | 
67 | ## 进度
68 | 
69 | 已经基本完成vmess分享链接的支持, 如果有发现任何bug, 可以提issue告知.
70 | 
71 | ## Vmess协议标准
72 | 
73 | 遵循v2rayNg所使用的分享链接格式[分享链接格式说明(ver 2)](https://github.com/2dust/v2rayN/wiki/%E5%88%86%E4%BA%AB%E9%93%BE%E6%8E%A5%E6%A0%BC%E5%BC%8F%E8%AF%B4%E6%98%8E(ver-2))
74 | 
75 | ## 使用和借鉴的开源项目
76 | 
77 | 1. 用于解析json的[jsoncpp](https://github.com/open-source-parsers/jsoncpp)
78 | 2. 用于base64解码的(本人实现的)[myBase64](https://github.com/leafee98/myBase64)
79 | 3. `src/fills.cpp`中关于vmess分享链接的行为借鉴自[boypt/vmess2json](https://github.com/boypt/vmess2json)
80 | 
81 | ## 许可
82 | 
83 | [MIT](/LICENSE)
84 | 


--------------------------------------------------------------------------------
/config_template.json:
--------------------------------------------------------------------------------
  1 | // you can modify this template as you need,
  2 | // but the first element of "outbound" will be overwrote by the program.
  3 | 
  4 | {
  5 |   "log": {
  6 |     "access": "",
  7 |     "error": "",
  8 |     "loglevel": "warning"
  9 |   },
 10 |   "inbounds": [{
 11 |     "port": 10080,
 12 |     "listen": "127.0.0.1",
 13 |     "tag": "socks-inbound",
 14 |     "protocol": "socks",
 15 |     "settings": {
 16 |       "auth": "noauth",
 17 |       "udp": true,
 18 |       "ip": "127.0.0.1"
 19 |     },
 20 |     "sniffing": {
 21 |       "enabled": true,
 22 |       "destOverride": ["http", "tls"]
 23 |     }
 24 |   }
 25 |   ],
 26 |   "outbounds": [
 27 |     {
 28 |       "tag": "proxy",
 29 |       "protocol": "vmess",
 30 |       "settings": {
 31 |         "vnext": [
 32 |           {
 33 |             "address": null,
 34 |             "port": null,
 35 |             "users": [
 36 |               {
 37 |                 "id": null,
 38 |                 "alterId": null,
 39 |                 "email": null,
 40 |                 "security": null
 41 |               }
 42 |             ]
 43 |           }
 44 |         ],
 45 |         "servers": null,
 46 |         "response": null
 47 |       },
 48 |       "streamSettings": {
 49 |         "network": null
 50 |       },
 51 |       "mux": {
 52 |         "enabled": true
 53 |       }
 54 |     },
 55 |     {
 56 |       "tag": "direct",
 57 |       "protocol": "freedom",
 58 |       "settings": {}
 59 |     },
 60 |     {
 61 |       "tag": "blocked",
 62 |       "protocol": "blackhole",
 63 |       "settings": {}
 64 |     }
 65 |   ],
 66 | 
 67 |   "routing": {
 68 |     "domainStrategy": "IPOnDemand",
 69 |     "rules":[
 70 |       {
 71 |         "type": "field",
 72 |         "ip": ["geoip:private"],
 73 |         "outboundTag": "direct"
 74 |       },
 75 |       {
 76 |         "type": "field",
 77 |         "domain": ["geosite:category-ads"],
 78 |         "outboundTag": "blocked"
 79 |       }
 80 |     ]
 81 |   },
 82 | 
 83 |   "dns": {
 84 |     "hosts": {
 85 |       "domain:v2ray.com": "www.vicemc.net"
 86 |     },
 87 |     "servers": [
 88 |       "1.1.1.1",
 89 |       {
 90 |         "address": "114.114.114.114",
 91 |         "port": 53,
 92 |         "domains": [
 93 |           "geosite:cn"
 94 |         ]
 95 |       },
 96 |       "8.8.8.8",
 97 |       "localhost"
 98 |     ]
 99 |   },
100 | 
101 |   "policy": {
102 |     "levels": {
103 |       "0": {
104 |         "uplinkOnly": 0,
105 |         "downlinkOnly": 0
106 |       }
107 |     },
108 |     "system": {
109 |       "statsInboundUplink": false,
110 |       "statsInboundDownlink": false
111 |     }
112 |   },
113 | 
114 |   "stats":{},
115 | 
116 |   "other": {}
117 | }
118 | 


--------------------------------------------------------------------------------
/src/fills.hpp:
--------------------------------------------------------------------------------
  1 | //
  2 | // There are five functions(fill_tcp_http, fill_kcp, fill_ws, fill_h2, fill_quic)
  3 | // refer to https://github.com/boypt/vmess2json. The license of origin 
  4 | // repository is MIT.
  5 | //
  6 | 
  7 | #pragma once
  8 | 
  9 | #include <json/json.h>
 10 | #include <sstream>
 11 | 
 12 | Json::Value load_template(const std::string & type);
 13 | Json::Value & fill_config(Json::Value & config, const Json::Value & vmess);
 14 | Json::Value & fill_basic(Json::Value & config, const Json::Value & vmess);
 15 | Json::Value & fill_streamSetting(Json::Value & config, const Json::Value & vmess);
 16 | 
 17 | Json::Value & fill_tcp_http(Json::Value & config, const Json::Value & vmess);
 18 | Json::Value & fill_kcp(Json::Value & config, const Json::Value & vmess);
 19 | Json::Value & fill_ws(Json::Value & config, const Json::Value & vmess);
 20 | Json::Value & fill_h2(Json::Value & config, const Json::Value & vmess);
 21 | Json::Value & fill_quic(Json::Value & config, const Json::Value & vmess);
 22 | 
 23 | Json::Value & fill_config(Json::Value & config, const Json::Value & vmess) {
 24 |     fill_basic(config, vmess);
 25 |     fill_streamSetting(config, vmess);
 26 |     return config;
 27 | }
 28 | 
 29 | Json::Value & fill_basic(Json::Value & config, const Json::Value & vmess) {
 30 |     Json::Value & vnext = config["outbounds"][0]["settings"]["vnext"];
 31 |     vnext[0]["address"] = vmess["add"];
 32 |     vnext[0]["port"] = std::stoi(vmess["port"].asString());
 33 |     vnext[0]["users"][0]["id"] = vmess["id"];
 34 |     vnext[0]["users"][0]["alterId"] = std::stoi(vmess["aid"].asString());
 35 | 
 36 |     Json::Value & streamSettings = config["outbounds"][0]["streamSettings"];
 37 |     streamSettings["network"] = vmess["net"];
 38 |     if (vmess["tls"] == "tls") {
 39 |         streamSettings["security"] = "tls";
 40 |         streamSettings["tlsSettings"]["allowInsecure"] = true;
 41 |         streamSettings["tlsSettings"]["serverName"] = vmess["host"];
 42 |     }
 43 | 
 44 |     return config;
 45 | }
 46 | 
 47 | Json::Value & fill_streamSetting(Json::Value & config, const Json::Value & vmess) {
 48 |     std::string vmessNet = vmess["net"].asString();
 49 |     config["outbounds"][0]["streamSettings"]["network"] = vmessNet;
 50 |     if (vmessNet == "tcp") {
 51 |         if (vmess["type"] == "http")
 52 |             return fill_tcp_http(config, vmess);
 53 |         return config;
 54 |     } else if (vmessNet == "kcp") {
 55 |         return fill_kcp(config, vmess);
 56 |     } else if (vmessNet == "ws") {
 57 |         return fill_ws(config, vmess);
 58 |     } else if (vmessNet == "h2") {
 59 |         return fill_h2(config, vmess);
 60 |     } else if (vmessNet == "quic") {
 61 |         return fill_quic(config, vmess);
 62 |     } else {
 63 |         // alert error.
 64 |         return config;
 65 |     }
 66 | }
 67 | 
 68 | Json::Value & fill_tcp_http(Json::Value & config, const Json::Value & vmess) {
 69 |     Json::Value tcps(load_template("http"));
 70 | 
 71 |     tcps["header"]["type"] = vmess["type"];
 72 | 
 73 |     if (vmess["host"] != "") {
 74 |         std::string host;
 75 |         std::stringstream sstream(vmess["host"].asString());
 76 |         for (int i = 0; std::getline(sstream, host, ','); ++i)
 77 |             tcps["header"]["request"]["headers"]["Host"][i] = host;
 78 |     }
 79 | 
 80 |     if (vmess["path"] != "")
 81 |         tcps["header"]["request"]["path"][0] = vmess["path"];
 82 | 
 83 |     config["outbounds"][0]["streamSettings"]["tcpSettings"] = tcps;
 84 |     return config;
 85 | }
 86 | 
 87 | Json::Value & fill_kcp(Json::Value & config, const Json::Value & vmess) {
 88 |     Json::Value kcps(load_template("kcp"));
 89 |     
 90 |     kcps["header"]["type"] = vmess["type"];
 91 | 
 92 |     config["outbounds"][0]["streamSettings"]["kcpSettings"] = kcps;
 93 |     return config;
 94 | }
 95 | 
 96 | Json::Value & fill_ws(Json::Value & config, const Json::Value & vmess) {
 97 |     Json::Value wss(load_template("ws"));
 98 | 
 99 |     wss["path"] = vmess["path"];
100 |     wss["headers"]["Host"] = vmess["host"];
101 | 
102 |     config["outbounds"][0]["streamSettings"]["wsSettings"] = wss;
103 |     return config;
104 | }
105 | 
106 | Json::Value & fill_h2(Json::Value & config, const Json::Value & vmess) {
107 |     Json::Value h2s(load_template("h2"));
108 | 
109 |     h2s["path"] = vmess["path"];
110 |     h2s["host"][0] = vmess["host"];
111 | 
112 |     config["outbounds"][0]["streamSettings"]["httpSettings"] = h2s;
113 |     return config;
114 | }
115 | 
116 | Json::Value & fill_quic(Json::Value & config, const Json::Value & vmess) {
117 |     Json::Value quics(load_template("quic"));
118 | 
119 |     quics["header"]["type"] = vmess["type"];
120 |     quics["security"] = vmess["host"];
121 |     quics["key"] = vmess["path"];
122 | 
123 |     config["outbounds"][0]["streamSettings"]["quicSettings"] = quics;
124 |     return config;
125 | }
126 | 
127 | Json::Value load_template(const std::string & type) {
128 |     static std::string http_template = R"(
129 |         {
130 |             "header": {
131 |                 "type": "http",
132 |                 "request": {
133 |                     "version": "1.1",
134 |                     "method": "GET",
135 |                     "path": [
136 |                         "/"
137 |                     ],
138 |                     "headers": {
139 |                         "Host": [
140 |                             "www.cloudflare.com",
141 |                             "www.amazon.com"
142 |                         ],
143 |                         "User-Agent": [
144 |                             "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
145 |                             "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36",
146 |                             "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36",
147 |                             "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:57.0) Gecko/20100101 Firefox/57.0"
148 |                         ],
149 |                         "Accept": [
150 |                             "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8"
151 |                         ],
152 |                         "Accept-language": [
153 |                             "zh-CN,zh;q=0.8,en-US;q=0.6,en;q=0.4"
154 |                         ],
155 |                         "Accept-Encoding": [
156 |                             "gzip, deflate, br"
157 |                         ],
158 |                         "Cache-Control": [
159 |                             "no-cache"
160 |                         ],
161 |                         "Pragma": "no-cache"
162 |                     }
163 |                 }
164 |             }
165 |         }
166 |     )";
167 | 
168 |     static std::string kcp_template = R"(
169 |         {
170 |             "mtu": 1350,
171 |             "tti": 50,
172 |             "uplinkCapacity": 12,
173 |             "downlinkCapacity": 100,
174 |             "congestion": false,
175 |             "readBufferSize": 2,
176 |             "writeBufferSize": 2,
177 |             "header": {
178 |                 "type": "wechat-video"
179 |             }
180 |         }
181 |     )";
182 | 
183 |     static std::string ws_template = R"(
184 |         {
185 |             "connectionReuse": true,
186 |             "path": "/path",
187 |             "headers": {
188 |                 "Host": "host.host.host"
189 |             }
190 |         }
191 |     )";
192 | 
193 |     static std::string h2_template = R"(
194 |         {
195 |             "host": [
196 |                 "host.com"
197 |             ],
198 |             "path": "/host"
199 |         }
200 |     )";
201 | 
202 |     static std::string quic_template = R"(
203 |         {
204 |             "security": "none",
205 |             "key": "",
206 |             "header": {
207 |                 "type": "none"
208 |             }
209 |         }
210 |     )";
211 | 
212 |     Json::Value result_json;
213 |     if (type == "http") {
214 |         std::stringstream(http_template) >> result_json;
215 |     } else if (type == "kcp") {
216 |         std::stringstream(kcp_template) >> result_json;
217 |     } else if (type == "ws") {
218 |         std::stringstream(ws_template) >> result_json;
219 |     } else if (type == "h2") {
220 |         std::stringstream(h2_template) >> result_json;
221 |     } else if (type == "quic") {
222 |         std::stringstream(quic_template) >> result_json;
223 |     } else {
224 |         std::stringstream("") >> result_json;
225 |     }
226 |     return result_json;
227 | }


--------------------------------------------------------------------------------
/src/func.cpp:
--------------------------------------------------------------------------------
  1 | #include "func.h"
  2 | 
  3 | #include <string>
  4 | #include <iostream>
  5 | #include <fstream>
  6 | #include <regex>
  7 | #include <filesystem>
  8 | #include "include/myBase64/myBase64.h"
  9 | 
 10 | const std::string VMESS_SCHEMA = R"(vmess://)";
 11 | 
 12 | run_param::run_param() 
 13 |     : display_help(false)
 14 |     , display_link(false)
 15 |     , display_ps(false)
 16 |     {}
 17 | 
 18 | void print_usage() {
 19 |     std::cerr
 20 |     << "usage:\n"
 21 |     << "        parsevmess [-t <template file>] [-o <output file>] <vmess link>\n"
 22 |     << "                   [-h] [-p] [-e]\n"
 23 |     << "    -t, --template <template file>\n"
 24 |     << "              Specify where the template file is.\n"
 25 |     << "              Use /etc/v2ray/config_template.json if not specified.\n"
 26 |     << "    -o, --output <output file>\n"
 27 |     << "              Specify where to output the filled the config.\n"
 28 |     << "              Use /etc/v2ray/config.json if not specified.\n"
 29 |     << "              If specified dash(-), will print to stdout.\n"
 30 |     << "    -e, --export\n"
 31 |     << "              Export the vmess link used by <output file> now.\n"
 32 |     << "              Take care that this option is only display the vmess link\n"
 33 |     << "              stored as comment in <output file>.\n"
 34 |     << "    -p, --ps\n"
 35 |     << "              Display the ps of vmess link now using.\n"
 36 |     << "              Take care that this option is only display the ps\n"
 37 |     << "              stored as comment in <output file>.\n"
 38 |     << "              This is DEFAULT option if no parameter specified\n"
 39 |     << "    -h, --help\n"
 40 |     << "              Display this help\n"
 41 |     << "\n"
 42 |     << "    <vmess link>\n"
 43 |     << "              Specify the vmesslink to be used.\n";
 44 | }
 45 | 
 46 | void display_ps(const run_param & runp) {
 47 |     static std::regex reg(R"(// ps: (.*))");
 48 |     std::ifstream fin(runp.output_file, std::ios::in);
 49 |     std::string line;
 50 |     std::getline(fin, line, '\n');
 51 |     std::smatch m;
 52 |     if (std::regex_search(line, m, reg)) {
 53 |         std::string result = m[1].str();
 54 | 
 55 |         if (*result.begin() == '"')
 56 |             result.erase(0, 1);
 57 |         if (*result.rbegin() == '"')
 58 |             result.erase(result.size() - 1, result.size());
 59 | 
 60 |         std::cout << result << '\n';
 61 |     } else
 62 |         std::cerr << "Output file format error\n"
 63 |                     "Only support displaying ps stored as comment.\n";
 64 | }
 65 | 
 66 | void display_link(const run_param & runp) {
 67 |     std::ifstream fin(runp.output_file, std::ios::in);
 68 |     std::string line;
 69 | 
 70 |     // get the second line
 71 |     std::getline(fin, line, '\n');
 72 |     std::getline(fin, line, '\n');
 73 | 
 74 |     line.erase(0, 3);
 75 |     std::cout << line << '\n';
 76 | }
 77 | 
 78 | bool parse_parameters(int argc, char * argv[], run_param & runp) {
 79 |     bool normal = true;
 80 |     try {
 81 |         for (int i = 1; i < argc; ++i) {
 82 |             if (runp.template_file.size() == 0
 83 |                     && (!strcmp(argv[i], "-t")
 84 |                             || !strcmp(argv[i], "--template"))) {
 85 |                 runp.template_file = argv[++i];
 86 |             } else if (runp.output_file.size() == 0
 87 |                     && (!strcmp(argv[i], "-o")
 88 |                             || !strcmp(argv[i], "--output"))) {
 89 |                 runp.output_file = argv[++i];
 90 |             } else if (runp.display_help == false
 91 |                     && (!strcmp(argv[i], "-h")
 92 |                             || !strcmp(argv[i], "--help"))) {
 93 |                 runp.display_help = true;
 94 |             } else if (runp.display_link == false
 95 |                     && (!strcmp(argv[i], "-e")
 96 |                             || !strcmp(argv[i], "--export"))) {
 97 |                 runp.display_link = true;
 98 |             } else if (runp.display_ps == false
 99 |                     && (!strcmp(argv[i], "-p")
100 |                             || !strcmp(argv[i], "--ps"))) {
101 |                 runp.display_ps = true;
102 |             } else {
103 |                 if (std::strncmp(argv[i], argv[i], VMESS_SCHEMA.size()) == 0
104 |                         && runp.vmess_link.size() == 0) {
105 |                     runp.vmess_link = argv[i];
106 |                 } else {
107 |                     std::cerr << "invalid or duplicate parameter: "
108 |                             << argv[i] << "\nuse parseVmess --help for help\n";
109 |                     normal = false;
110 |                 }
111 |             }
112 |         }
113 | 
114 |         if (runp.template_file.size() == 0)
115 |             runp.template_file = "/etc/v2ray/config_template.json";
116 |         if (runp.output_file.size() == 0)
117 |             runp.output_file = "/etc/v2ray/config.json";
118 | 
119 |         // if no action specified, display ps
120 |         if (runp.vmess_link.size() == 0) {
121 |             runp.display_ps = true;
122 |         }
123 |     } catch (const std::out_of_range & oor) {
124 |         normal = false;
125 |         std::cerr << "invalid parameters, use 'parseVmess --help' for help\n";
126 |     }
127 |     return normal;
128 | }
129 | 
130 | std::string check_files(const run_param & runp) {
131 |     std::string check_result;
132 | 
133 |     std::filesystem::path template_path(runp.template_file);
134 |     if (std::filesystem::exists(template_path)) {
135 |         std::ifstream file_input(runp.template_file, std::ios::in);
136 |         if (! file_input.good()) {
137 |             check_result.append("template file not readable. template path: ")
138 |                     .append(runp.template_file).append("\n");
139 |         }
140 |         file_input.close();
141 |     } else {
142 |         check_result.append("template file not exists. template path: ")
143 |                 .append(runp.template_file).append("\n");
144 |     }
145 | 
146 |     if (runp.output_file == "-")
147 |         return check_result;
148 | 
149 |     std::filesystem::path output_path(runp.output_file);
150 |     if (std::filesystem::exists(output_path)) {
151 |         std::ofstream file_output(runp.output_file, std::ios::in);
152 |         if (! file_output.good()) {
153 |             check_result.append("output file is not writable. output path: ")
154 |                     .append(runp.output_file).append("\n");
155 |         }
156 |         file_output.close();
157 |     }
158 | 
159 |     return check_result;
160 | }
161 | 
162 | Json::Value decode_vmess(const std::string & vmess_link) {
163 |     if (strncmp(VMESS_SCHEMA.c_str(), vmess_link.c_str(),
164 |                 VMESS_SCHEMA.size()) == 0) {
165 |         std::string vmess_content =
166 |                 myBase64::decode(vmess_link.substr(VMESS_SCHEMA.size()));
167 |         Json::Value vmess_json;
168 |         std::stringstream(vmess_content) >> vmess_json;
169 |         if (vmess_json["v"] == "2") {
170 |             return vmess_json;
171 |         }
172 |     }
173 |     return Json::Value::nullSingleton;
174 | }
175 | 
176 | Json::Value read_template(const std::string & template_file) {
177 |     std::fstream file_input(template_file, std::ios::in);
178 |     std::string template_content = std::string(
179 |             std::istreambuf_iterator<char>(file_input),
180 |             std::istreambuf_iterator<char>());
181 |     file_input.close();
182 |     Json::Value template_json;
183 |     std::stringstream(template_content) >> template_json;
184 |     return template_json;
185 | }
186 | 
187 | std::string unicode_to_utf8(const std::string & str) {
188 |     std::string res;
189 |     setlocale(LC_ALL, "");
190 | 
191 |     auto is_escape_unicode = [](std::string::const_iterator _begin,
192 |             std::string::const_iterator _end) {
193 |         if (_end - _begin != 6)
194 |             return false;
195 |         if (*_begin != '\\' || *(_begin + 1) != 'u')
196 |             return false;
197 |         
198 |         bool result = true;
199 |         for (auto it = _begin + 2; result && it != _end; ++it) {
200 |             if (isdigit(*it))
201 |                 continue;
202 |             char c = tolower(*it);
203 |             if (c < 'a' && c > 'f')
204 |                 result = false;
205 |         }
206 |         return result;
207 |     };
208 |     auto hex_to_digit = [](char c) {
209 |         if (isdigit(c)) return c - '0';
210 |         else            return c - 'a' + 10;
211 |     };
212 |     for (std::string::const_iterator it = str.begin(); it != str.end(); ++it) {
213 |         if (*it == '\\'
214 |                 && is_escape_unicode(it,
215 |                         (it + 6 < str.end() ? it + 6 : str.end()))
216 |                 ) {
217 |             auto t = it + 2;
218 |             int num = 0;
219 |             for (int i = 0; i < 4; ++i, ++t)
220 |                 num *= 16, num += hex_to_digit(*t);
221 |             std::string tmp(MB_CUR_MAX, '\0');
222 |             wctomb(nullptr, 0);             // try to shift squences
223 |             int len = wctomb(&tmp[0], (wchar_t)num);
224 | 
225 |             res.append(tmp, 0, len);
226 | 
227 |             it += 5; // take care of '++it' in for loop
228 |         } else {
229 |             res += *it;
230 |         }
231 |     }
232 | 
233 |     return res;
234 | }
235 | 
236 | void write_output(const run_param & runp, const Json::Value & output_json,
237 |         const Json::Value vmess_json) {
238 |     Json::StreamWriterBuilder wbuilder;
239 |     wbuilder["commentStyle"] = "None";
240 |     std::unique_ptr<Json::StreamWriter> pwriter(wbuilder.newStreamWriter());
241 | 
242 |     std::stringstream ss;
243 |     std::string output_str, vmess_ps;
244 | 
245 |     pwriter->write(output_json, &ss); output_str = ss.str(); ss.str("");
246 |     pwriter->write(vmess_json["ps"], &ss); vmess_ps = ss.str(); ss.str("");
247 | 
248 |     output_str = unicode_to_utf8(output_str);
249 |     vmess_ps = unicode_to_utf8(vmess_ps);
250 | 
251 |     if (runp.output_file == "-") {
252 |         std::cerr << "// ps: " << vmess_ps << '\n';
253 |         std::cout << "// " << runp.vmess_link << '\n';
254 |         std::cout << output_str;
255 |     } else {
256 |         std::ofstream file_output(runp.output_file, std::ios::out);
257 |         std::cerr << "// ps: " << vmess_ps << '\n';
258 |         file_output << "// ps: " << vmess_ps << '\n';
259 |         file_output << "// " << runp.vmess_link << '\n';
260 |         file_output << output_str;
261 |         file_output.close();
262 |     }
263 | }


--------------------------------------------------------------------------------