├── websocket-terminal
    ├── dist
    │   └── .gitignore
    ├── package.json
    ├── index.html
    ├── webpack.config.js
    ├── src
    │   └── entry.js
    └── index.js
├── simple-sshd
    ├── .gitignore
    ├── Makefile
    ├── README.md
    └── server.cpp
├── websocket-terminal-cpp-server
    ├── exec.sh
    ├── frontend.hpp
    ├── pty.hpp
    ├── base64.hpp
    ├── Makefile
    ├── sha1.hpp
    ├── pty.cpp
    ├── frontend.html
    ├── http.hpp
    ├── ws.hpp
    ├── base64.cpp
    ├── http.cpp
    ├── frontend.h
    ├── main.cpp
    ├── sha1.cpp
    └── ws.cpp
├── Daemon
    ├── Daemon
    │   ├── Resources
    │   │   └── icon.ico
    │   ├── App.config
    │   ├── Properties
    │   │   ├── Settings.settings
    │   │   ├── Settings.Designer.cs
    │   │   ├── AssemblyInfo.cs
    │   │   ├── Resources.Designer.cs
    │   │   └── Resources.resx
    │   ├── App.xaml
    │   ├── App.xaml.cs
    │   ├── MainWindow.xaml
    │   ├── Daemon.csproj
    │   └── MainWindow.xaml.cs
    └── Daemon.sln
├── bandwidth
    ├── package.json
    ├── README.md
    └── index.js
├── reversi
    ├── package.json
    ├── dist
    │   └── index.html
    └── index.js
├── azure-ddns
    ├── package.json
    └── index.js
├── music-read-trans
    ├── package.json
    ├── webpack.config.js
    ├── index.html
    └── src
    │   └── entry.js
├── flac-player-sdl
    ├── README.md
    ├── Makefile
    └── main.cpp
├── pcap-port-statistics
    ├── README.md
    └── main.cpp
├── wav-decode
    ├── README.md
    ├── index.html
    └── main.js
├── README.md
├── bilibili-regular-block
    └── tv.bilibili.player.xml
└── .gitignore


/websocket-terminal/dist/.gitignore:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/simple-sshd/.gitignore:
--------------------------------------------------------------------------------
1 | *.o
2 | server
3 | ssh
4 | .vscode


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/exec.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | export TERM=xterm-256color
4 | 
5 | /bin/bash --login


--------------------------------------------------------------------------------
/Daemon/Daemon/Resources/icon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ntzyz/playground/HEAD/Daemon/Daemon/Resources/icon.ico


--------------------------------------------------------------------------------
/bandwidth/package.json:
--------------------------------------------------------------------------------
1 | {
2 |   "dependencies": {
3 |     "pcap": "https://github.com/mranney/node_pcap.git"
4 |   }
5 | }
6 | 


--------------------------------------------------------------------------------
/reversi/package.json:
--------------------------------------------------------------------------------
1 | {
2 |   "dependencies": {
3 |     "express": "^4.16.4",
4 |     "socket.io": "^2.2.0"
5 |   }
6 | }
7 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/frontend.hpp:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | extern unsigned char frontend_html[];
4 | extern unsigned int frontend_html_len;
5 | 


--------------------------------------------------------------------------------
/azure-ddns/package.json:
--------------------------------------------------------------------------------
1 | {
2 |   "dependencies": {
3 |     "azure-arm-dns": "^3.2.0",
4 |     "express": "^4.16.4",
5 |     "ms-rest-azure": "^2.6.0"
6 |   }
7 | }
8 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/pty.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | struct pty_t {
 4 |   bool ready = false;
 5 |   int master_fd;
 6 | 
 7 |   pty_t();
 8 |   void spawn();
 9 |   ~pty_t();
10 | };


--------------------------------------------------------------------------------
/music-read-trans/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "dependencies": {
 3 |     "vexflow": "^1.2.90",
 4 |     "webpack": "^4.41.6"
 5 |   },
 6 |   "devDependencies": {
 7 |     "webpack-cli": "^3.3.11"
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/flac-player-sdl/README.md:
--------------------------------------------------------------------------------
 1 | FLAC Player
 2 | ===========
 3 | 
 4 | Decode and playback flac files with FLAC and SDL.
 5 | 
 6 | ### Requirements
 7 | FLAC, SDL1.2
 8 | 
 9 | ### Compile
10 | ```
11 | make
12 | ```
13 | 


--------------------------------------------------------------------------------
/Daemon/Daemon/App.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8" ?>
2 | <configuration>
3 |     <startup> 
4 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
5 |     </startup>
6 | </configuration>


--------------------------------------------------------------------------------
/Daemon/Daemon/Properties/Settings.settings:
--------------------------------------------------------------------------------
1 | <?xml version='1.0' encoding='utf-8'?>
2 | <SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
3 |   <Profiles>
4 |     <Profile Name="(Default)" />
5 |   </Profiles>
6 |   <Settings />
7 | </SettingsFile>


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/base64.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | #include <vector>
 6 | 
 7 | using byte = unsigned char;
 8 | 
 9 | namespace base64 {
10 | 
11 | std::string encode(const std::vector<byte> &src);
12 | 
13 | }


--------------------------------------------------------------------------------
/pcap-port-statistics/README.md:
--------------------------------------------------------------------------------
 1 | Pcap port statistics
 2 | ====================
 3 | 
 4 | Collect all traffic data by port.
 5 | 
 6 | ### Requirements
 7 | 
 8 | libpcap
 9 | 
10 | ### Build
11 | 
12 | ```
13 | g++ -std=c++1z -o port_stat main.cpp -lpthread `pcap-config --libs` 
14 | ```


--------------------------------------------------------------------------------
/wav-decode/README.md:
--------------------------------------------------------------------------------
 1 | ### Description
 2 | 
 3 | A WAV decoder and player with oscilloscope visualizer in pure JavaScript.
 4 | 
 5 | [View demo(Chrome/Chromium only)](https://ntzyz.github.io/playground/wav-decode/)
 6 | 
 7 | ### API used
 8 | 1. XMLHttpRequest
 9 | 2. Promise
10 | 3. Yield
11 | 4. AudioContext
12 | 5. Canvas
13 | 


--------------------------------------------------------------------------------
/websocket-terminal/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "dependencies": {
 3 |     "css-loader": "^0.28.5",
 4 |     "express": "^4.15.4",
 5 |     "node-pty": "^0.7.0",
 6 |     "socket.io": "^2.0.3",
 7 |     "style-loader": "^0.18.2",
 8 |     "webpack": "^3.5.5",
 9 |     "webpack-dev-server": "^2.7.1",
10 |     "xterm": "^2.9.2"
11 |   }
12 | }
13 | 


--------------------------------------------------------------------------------
/simple-sshd/Makefile:
--------------------------------------------------------------------------------
 1 | CC = gcc
 2 | CCX = g++
 3 | CFLAGS = -Wall -O2 -std=c++11
 4 | OBJS = server.o
 5 | PROG = server
 6 | LDFLAGS = -lssh
 7 | 
 8 | all: $(PROG)
 9 | 
10 | $(PROG): $(OBJS)
11 | 	$(CCX) $(CFLAGS) $(OBJS) -o $@ $(LDFLAGS) $(LDLIBS)
12 | 
13 | server.o: server.cpp
14 | 	$(CCX) $(CFLAGS) -c server.cpp
15 | 
16 | clean:
17 | 	rm -f *.o $(PROG)
18 | 


--------------------------------------------------------------------------------
/websocket-terminal/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |   <head>
 3 |     <meta charset="utf-8">
 4 |     <style>
 5 |       body {
 6 |         margin: 1em;
 7 |         background: black;
 8 |       }
 9 |     </style>
10 |   </head>
11 |   <body>
12 |     <div id="terminal"></div>
13 |     <script type="text/javascript" src="./dist/bundle.js" charset="utf-8"></script>
14 |   </body>
15 | </html>
16 | 


--------------------------------------------------------------------------------
/websocket-terminal/webpack.config.js:
--------------------------------------------------------------------------------
 1 | const path = require('path');
 2 | 
 3 | module.exports = {
 4 |     entry: "./src/entry.js",
 5 |     output: {
 6 |         path: path.join(__dirname, 'dist'),
 7 |         filename: "bundle.js"
 8 |     },
 9 |     module: {
10 |         loaders: [
11 |             { test: /\.css$/, loader: "style-loader!css-loader" }
12 |         ]
13 |     }
14 | };
15 | 


--------------------------------------------------------------------------------
/music-read-trans/webpack.config.js:
--------------------------------------------------------------------------------
 1 | const path = require('path');
 2 | 
 3 | module.exports = {
 4 |   entry: "./src/entry.js",
 5 |   output: {
 6 |     path: path.join(__dirname, 'dist'),
 7 |     filename: "bundle.js"
 8 |   },
 9 |   devServer: {
10 |     contentBase: path.join(__dirname, '.'),
11 |     index: 'index.html',
12 |     compress: true,
13 |     port: 9000,
14 |     host: '0.0.0.0',
15 |   }
16 | };


--------------------------------------------------------------------------------
/Daemon/Daemon/App.xaml:
--------------------------------------------------------------------------------
 1 | <Application x:Class="Daemon.App"
 2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |              xmlns:local="clr-namespace:Daemon"
 5 |              StartupUri="MainWindow.xaml">
 6 |     <Application.Resources>
 7 |          
 8 |     </Application.Resources>
 9 | </Application>
10 | 


--------------------------------------------------------------------------------
/Daemon/Daemon/App.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Configuration;
 4 | using System.Data;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | using System.Windows;
 8 | 
 9 | namespace Daemon
10 | {
11 |     /// <summary>
12 |     /// Interaction logic for App.xaml
13 |     /// </summary>
14 |     public partial class App : Application
15 |     {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/Makefile:
--------------------------------------------------------------------------------
 1 | CC=gcc
 2 | CXX=g++
 3 | LD=gcc
 4 | 
 5 | TARGET=main
 6 | CFLAGS=-Wall -O0 -ggdb -static
 7 | LDFLAGS=-fPIC -lpthread -lm -lutil -static
 8 | OBJS=main.o sha1.o base64.o pty.o ws.o http.o frontend.o
 9 | 
10 | .PHONY: clean
11 | 
12 | $(TARGET): $(OBJS)
13 | 	$(CXX) -o $(TARGET) $(OBJS) $(LDFLAGS)
14 | 
15 | %.o: %.cpp
16 | 	$(CXX) $(CFLAGS) -c $< -o $@
17 | 
18 | frontend.cpp: frontend.html
19 | 	xxd -i frontend.html > frontend.cpp
20 | 
21 | clean:
22 | 	rm -rf $(OBJS) $(TARGET) frontend.cpp
23 | 


--------------------------------------------------------------------------------
/simple-sshd/README.md:
--------------------------------------------------------------------------------
 1 | simple sshd
 2 | ===========
 3 | 
 4 | A simple Secure Shell Server built with libssh.
 5 | ```
 6 | ntzyz@ntzyz-solaris ~ % ssh localhost -p 2022
 7 | ntzyz@localhost's password: 
 8 | PTY allocation request failed on channel 0
 9 | [NSH]$ 123
10 | ECHO: 123
11 | [NSH]$ ping
12 | Pong!
13 | [NSH]$ exit
14 | exiting...
15 | Connection to localhost closed.
16 | ```
17 | 
18 | #### Dependence
19 | libssh-dev
20 | 
21 | #### Build and run
22 | ```bash
23 | $ sudo apt install libssh-dev
24 | $ make
25 | $ ./server
26 | ```
27 | 


--------------------------------------------------------------------------------
/flac-player-sdl/Makefile:
--------------------------------------------------------------------------------
 1 | CC=gcc
 2 | CXX=g++
 3 | LD=gcc
 4 | 
 5 | SDL_CFLAGS=$(shell pkg-config sdl --cflags)
 6 | SDL_LDFLAGS=$(shell pkg-config sdl --libs)
 7 | FLAC_CFLAGS=$(shell pkg-config flac --cflags)
 8 | FLAC_LDFLAGS=$(shell pkg-config flac --libs)
 9 | 
10 | TARGET=main
11 | CFLAGS=-Wall -O0 -ggdb $(SDL_CFLAGS) $(FLAC_CFLAGS)
12 | LDFLAGS=-fPIC $(SDL_LDFLAGS) $(FLAC_LDFLAGS)
13 | OBJS=main.o
14 | 
15 | .PHONY: clean
16 | 
17 | $(TARGET): $(OBJS)
18 | 	$(CC) -o $(TARGET) $(OBJS) $(LDFLAGS)
19 | 
20 | %.o: %.c
21 | 	$(CC) $(CFLAGS) -c $< -o $@
22 | 
23 | clean:
24 | 	rm -rf $(OBJS) $(TARGET)


--------------------------------------------------------------------------------
/websocket-terminal/src/entry.js:
--------------------------------------------------------------------------------
 1 | import Terminal from 'xterm';
 2 | import 'xterm/src/xterm.css';
 3 | import io from 'socket.io-client';
 4 | 
 5 | Terminal.loadAddon('fit');
 6 | 
 7 | const socket = io(window.location.href);
 8 | 
 9 | const term = new Terminal({
10 |   cols: 80,
11 |   rows: 24,
12 | });
13 | term.open(document.getElementById('#terminal'));
14 | term.on('resize', size => {
15 |   socket.emit('resize', [size.cols, size.rows]);
16 | })
17 | 
18 | term.on('data', data => socket.emit('input', data));
19 | 
20 | socket.on('output', arrayBuffer => {
21 |   term.write(arrayBuffer);
22 | });
23 | 
24 | window.addEventListener('resize', () => {
25 |   term.fit()
26 | });
27 | term.fit()
28 | 


--------------------------------------------------------------------------------
/websocket-terminal/index.js:
--------------------------------------------------------------------------------
 1 | const express = require('express');
 2 | const site = express();
 3 | const http = require('http').Server(site);
 4 | const io = require('socket.io')(http);
 5 | const net = require('net');
 6 | const pty = require('node-pty');
 7 | 
 8 | site.use('/', express.static('.'));
 9 | 
10 | io.on('connection', function (socket) {
11 |   let ptyProcess = pty.spawn('bash', ['--login'], {
12 |     name: 'xterm-color',
13 |     cols: 80,
14 |     rows: 24,
15 |     cwd: process.env.HOME,
16 |     env: process.env
17 |   });
18 |   ptyProcess.on('data', data => socket.emit('output', data));
19 |   socket.on('input', data => ptyProcess.write(data));
20 |   socket.on('resize', size => {
21 |     console.log(size);
22 |     ptyProcess.resize(size[0], size[1])
23 |   });
24 | });
25 | 
26 | http.listen(8123);
27 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/sha1.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |     sha1.hpp - header of
 3 | 
 4 |     ============
 5 |     SHA-1 in C++
 6 |     ============
 7 | 
 8 |     100% Public Domain.
 9 | 
10 |     Original C Code
11 |         -- Steve Reid <steve@edmweb.com>
12 |     Small changes to fit into bglibs
13 |         -- Bruce Guenter <bruce@untroubled.org>
14 |     Translation to simpler C++ Code
15 |         -- Volker Diels-Grabsch <v@njh.eu>
16 |     Safety fixes
17 |         -- Eugene Hopkinson <slowriot at voxelstorm dot com>
18 | */
19 | 
20 | #ifndef SHA1_HPP
21 | #define SHA1_HPP
22 | 
23 | 
24 | #include <cstdint>
25 | #include <iostream>
26 | #include <string>
27 | 
28 | 
29 | class SHA1
30 | {
31 | public:
32 |     SHA1();
33 |     void update(const std::string &s);
34 |     void update(std::istream &is);
35 |     std::string final();
36 |     static std::string from_file(const std::string &filename);
37 | 
38 | private:
39 |     uint32_t digest[5];
40 |     std::string buffer;
41 |     uint64_t transforms;
42 | };
43 | 
44 | 
45 | #endif /* SHA1_HPP */
46 | 


--------------------------------------------------------------------------------
/Daemon/Daemon.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 14
 4 | VisualStudioVersion = 14.0.25420.1
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Daemon", "Daemon\Daemon.csproj", "{48455FF1-66AE-4245-B35B-021CE8AEFFE3}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{48455FF1-66AE-4245-B35B-021CE8AEFFE3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{48455FF1-66AE-4245-B35B-021CE8AEFFE3}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{48455FF1-66AE-4245-B35B-021CE8AEFFE3}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{48455FF1-66AE-4245-B35B-021CE8AEFFE3}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | EndGlobal
23 | 


--------------------------------------------------------------------------------
/bandwidth/README.md:
--------------------------------------------------------------------------------
 1 | ## Bandwidth
 2 | 
 3 | Find out who is consuming most of our bandwidth. Sample output:
 4 | 
 5 | ```
 6 | 172.16.10.1     0.00 B/s
 7 | 172.16.10.112   0.00 B/s
 8 | 172.16.10.170   0.00 B/s
 9 | 172.16.10.215   7.39 MB/s
10 | 172.16.10.247   0.00 B/s
11 | 172.16.10.41    0.00 B/s
12 | 172.16.10.81    0.00 B/s
13 | 224.0.0.1       0.00 B/s
14 | ```
15 | 
16 | ### Useage
17 | 
18 | If you believe your router is powerful enough to run node.js, just run it on your router:
19 | 
20 | 1. Install `python`, `git`, `git-http`, `node`, `gcc` with `opkg`.
21 | 2. Download the source code of `libpacp`, compile and install it.
22 | 3. Install node packages by `npm i`.
23 | 3. Run `index.js` with root privilege.
24 | 
25 | Or, you can:
26 | 
27 | 1. Install `iptables-mod-tee` on your OpenWrt/LEDE router.
28 | 2. Run `iptables -I FORWARD -j TEE --gateway $(echo $SSH_CLIENT | awk '{ print $1 }')` on your OpenWrt/LEDE router.
29 | 3. Run `index.js` with root privilege.
30 | 4. Run `iptables -D FORWARD -j TEE --gateway $(echo $SSH_CLIENT | awk '{ print $1 }')` on your OpenWrt/LEDE router.
31 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/pty.cpp:
--------------------------------------------------------------------------------
 1 | #include <string>
 2 | #include <cstring>
 3 | 
 4 | #include "pty.hpp"
 5 | #include <unistd.h>
 6 | #include <stdlib.h>
 7 | #include <fcntl.h>
 8 | #include <stdio.h>
 9 | #include <pty.h>
10 | #include <termios.h>
11 | 
12 | pty_t::pty_t () {
13 | }
14 | 
15 | void pty_t::spawn() {
16 |   struct winsize winp;
17 |   winp.ws_col = 80;
18 |   winp.ws_row = 24;
19 |   winp.ws_xpixel = 0;
20 |   winp.ws_ypixel = 0;
21 | 
22 |   pid_t pid = forkpty(&master_fd, nullptr, nullptr, &winp);
23 | 
24 |   if (pid == -1) {
25 |     perror("forkpty");
26 |     return;
27 |   } else if (pid == 0) { // master
28 |     char path[1024];
29 |     char *params[] = {
30 |       path,
31 |       nullptr
32 |     };
33 | 
34 |     getcwd(path, sizeof (path));
35 |     strcat(path, "/exec.sh");
36 | 
37 |     execvp(path, params);
38 |     perror("execvp");
39 |   } else {
40 |     int flags = fcntl(master_fd, F_GETFL, 0);
41 |     fcntl(master_fd, F_SETFL, flags | O_NONBLOCK);
42 | 
43 |     puts("pts created.");
44 |     ready = true;
45 |   }
46 | }
47 | 
48 | pty_t::~pty_t() {
49 |   close(master_fd);
50 |   puts("pts closed.");
51 | }


--------------------------------------------------------------------------------
/azure-ddns/index.js:
--------------------------------------------------------------------------------
 1 | const DnsManagementClient = require('azure-arm-dns');
 2 | const msRestAzure = require("ms-rest-azure");
 3 | const express = require('express');
 4 | const site = express();
 5 | 
 6 | const subscriptionId = '<---->';
 7 | const resourcesGroup = '<---->';
 8 | const zoneName = '<---->';
 9 | let dnsClient = null;
10 | 
11 | site.post('/update_dns', (req, res) => {
12 |   if (!req.query.ip_addr) {
13 |     res.send({ status: 'ok' });
14 |   } else {
15 |     dnsClient.recordSets.update(resourcesGroup, zoneName, 'prefix.', 'A', {
16 |       aRecords: [{
17 |         ipv4Address: req.query.ip_addr
18 |       }]
19 |     }).then((response) => {
20 |       res.send({
21 |         status: 'ok',
22 |         azure_response: response,
23 |       });
24 |     }).catch((error) => {
25 |       res.send({
26 |         status: 'error',
27 |         azure_error: error,
28 |       });
29 |     })
30 |   }
31 | });
32 | 
33 | msRestAzure.interactiveLogin({
34 |   domain: '<---->'
35 | }).then((creds) => {
36 |   dnsClient = new DnsManagementClient(creds, subscriptionId);
37 |   site.listen(3399, '127.0.0.1');
38 | }).catch((error) => {
39 |   console.error(error);
40 | })
41 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Playground
 2 | ==========
 3 | 
 4 | Codes for fun.
 5 | 
 6 | 1. [wav-decode](wav-decode): WAV decoder and player with oscilloscope visualizer in pure JavaScript.
 7 | 1. [simple-sshd](simple-sshd): Simple secure shell server.
 8 | 1. [bilibili-regular-block](bilibili-regular-block): Blocking some annoying danmaku with these regular expressions.
 9 | 1. [websocket-terminal](websocket-terminal): HTML5 remote terminal with xterm.js and WebSocket.
10 | 1. [Daemon](Daemon): Supervisor for processes like nginx & java.
11 | 1. [bandwidth](bandwidth): Simple bandwidth monitor utility.
12 | 1. [pcap-port-statistics](pcap-port-statistics): Collect all traffic data by port with libpcap.
13 | 1. [flac-player-sdl](flac-player-sdl): Decode and playback flac files with FLAC and SDL. 
14 | 1. [reversi](reversi): Simple(Stupid?) strategy board game called [Reversi](https://en.wikipedia.org/wiki/Reversi), requires at least two players.
15 | 1. [Azure DDNS](azure-ddns): HTTP Server allowing you to update DNS records on Azure. Use it with `/etc/ppp/ip-up.d/` and `cURL`.
16 | 1. [websocket-terminal-cpp-server](websocket-terminal-cpp-server): WebSocket Terminal written with C++ and Linux API, server only.
17 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/frontend.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="UTF-8">
 5 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |   <meta http-equiv="X-UA-Compatible" content="ie=edge">
 7 |   <script src="https://cdn.jsdelivr.net/npm/xterm@4.2.0/lib/xterm.min.js"></script>
 8 |   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/xterm@4.2.0/css/xterm.min.css">
 9 | </head>
10 | <body>
11 |   <div class="terminal" style="width: min-content; font-size: 12px;"></div>
12 |   <script>
13 |     const socket_url = `${location.protocol === 'http:' ? 'ws:' : 'wss:'}//${location.host}${location.pathname}`
14 |     const socket = new WebSocket(socket_url);
15 | 
16 |     socket.onopen =() => {
17 |       window.term = new Terminal({
18 |         cols: 80,
19 |         rows: 24,
20 |         fontFamily: 'SFMono-Regular,Consolas,Liberation Mono,Menlo,monospace',
21 |       });
22 | 
23 |       term.onData(data => socket.send(data));
24 | 
25 |       term.open(document.querySelector('.terminal'));
26 | 
27 |       socket.onmessage = (message) => {
28 |         term.write(message.data);
29 |       }
30 |     };
31 | 
32 |   </script>
33 | </body>
34 | </html>


--------------------------------------------------------------------------------
/Daemon/Daemon/Properties/Settings.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.42000
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace Daemon.Properties
12 | {
13 | 
14 | 
15 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
16 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
17 |     internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
18 |     {
19 | 
20 |         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
21 | 
22 |         public static Settings Default
23 |         {
24 |             get
25 |             {
26 |                 return defaultInstance;
27 |             }
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/http.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <map>
 5 | #include <vector>
 6 | #include <sstream>
 7 | #include <algorithm>
 8 | 
 9 | #include <cstring>
10 | #include <cstdint>
11 | 
12 | #include <sys/utsname.h>
13 | 
14 | struct http_request_t {
15 |   enum {
16 |     GET, POST, PUT, OPTIONS,
17 |     DELETE, UNKNOWN // etc
18 |   } request_method;
19 |   std::string request_path;
20 |   std::string http_version;
21 |   std::map<std::string, std::vector<std::string>> headers;
22 | 
23 |   http_request_t(const uint8_t *const, const ssize_t);
24 | 
25 |   void parse_http_method(std::stringstream &);
26 |   void parse_http_path(std::stringstream &);
27 |   void parse_http_version(std::stringstream &);
28 |   void parse_http_headers(std::stringstream &);
29 | };
30 | 
31 | struct http_response_t {
32 |   int status_code;
33 |   std::string status_text;
34 |   std::map<std::string, std::vector<std::string>> headers;
35 |   std::string body;
36 | 
37 |   http_response_t(const int);
38 | 
39 |   void http_status_code_to_status_text();
40 |   void initialize_response_headers();
41 |   void append_header_date();
42 |   void append_header_connection();
43 |   void append_header_server();
44 |   std::string to_response();
45 | };


--------------------------------------------------------------------------------
/wav-decode/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=1.0" />
 6 |   </head>
 7 |   <body>
 8 |     <select song>
 9 |       <option value="https://www.ntzyz.cn/audio4.wav">FELT - inside (19.1MB)</option>
10 |       <option value="https://www.ntzyz.cn/audio3.wav">人と事象が巡り逢う确率についての朝の考察 (20.4 MB)</option>
11 |       <option value="https://www.ntzyz.cn/audio.wav">DECO*27 - リバーシブル・キャンペーン (29.7 MB)</option>
12 |       <option value="https://www.ntzyz.cn/audio2.wav">Halsey - Castle (46.7 MB)</option>
13 |     </select>
14 |     <button start>start</button>
15 |     <span status>Ready ... </span>
16 |     <br />
17 |     <span>Oscilloscope sampling interval:</span>
18 |     <input interval type="text" value="32" placeholder="sampling interval"/>
19 |     <button onclick="if (wav) wav.sampleingInterval = document.querySelector('input[interval]').value; ">Update</button>
20 |     <div frame></div>
21 |     <canvas width="500" height="300" style="width: 500px; height: 300px; border: 1px solid black">Ahhh please use a better browser.</canvas>
22 |     <br>
23 |     <a href="https://github.com/ntzyz/playground/blob/master/wav-decode/main.js" target="_blank">View source on GitHub.</a>
24 |     <script src="main.js"></script>
25 |   </body>
26 | </html>
27 | 


--------------------------------------------------------------------------------
/bandwidth/index.js:
--------------------------------------------------------------------------------
 1 | const pcap = require('pcap')
 2 | const IPv4 = require('./node_modules/pcap/decode/ipv4');
 3 | const EthernetPacket = require('./node_modules/pcap/decode/ethernet_packet');
 4 | 
 5 | const session = pcap.createSession('br0');
 6 | const prefix = '172.16.10.';
 7 | 
 8 | const packet_size_map = {};
 9 | 
10 | session.on('packet', raw_packet => {
11 |   let packet;
12 |   try {
13 |     packet = pcap.decode.packet(raw_packet);
14 |   } catch (_) {
15 |     return;
16 |   }
17 |   if (packet.payload instanceof EthernetPacket &&
18 |     packet.payload.payload instanceof IPv4) {
19 |       let tcp_packet = packet.payload.payload;
20 |       let addr;
21 |       
22 |       if (tcp_packet.saddr.addr.join('.').indexOf(prefix) === 0) {
23 |         addr = tcp_packet.saddr.addr.join('.');
24 |       } else {
25 |         addr = tcp_packet.daddr.addr.join('.');
26 |       }
27 | 
28 |       packet_size_map[addr] = (packet_size_map[addr] || 0) + tcp_packet.length;
29 |     }
30 | });
31 | 
32 | // From https://github.com/cnCalc/serainTalk/blob/dev/web/src/utils/filters.js
33 | function fileSize (size) {
34 |   const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
35 |   let n = Math.max(Math.floor(Math.log(size) / Math.log(1024)), 0);
36 |   return `${(size / (1024 ** n)).toFixed(2)} ${units[n]}`;
37 | }
38 | 
39 | setInterval(() => {
40 |   process.stdout.write('\x1b[2J\x1b[H') // clear
41 |   Object.keys(packet_size_map).sort().forEach(addr => {
42 |     console.log(`${addr}\t${fileSize(packet_size_map[addr])}/s`);
43 |     packet_size_map[addr] = 0;
44 |   })
45 | }, 1000);
46 | 
47 | 


--------------------------------------------------------------------------------
/music-read-trans/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="UTF-8">
 5 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |   <style>
 7 |     #app {
 8 |       width: 500px;
 9 |       height: 300px;
10 |       border: 1px solid black;
11 |       margin-bottom: 8px;
12 |     }
13 | 
14 |     .input-row {
15 |       display: flex;
16 |       width: 500px;
17 |     }
18 | 
19 |     .input-row input {
20 |       width: 350px;
21 |       flex-grow: 1;
22 |     }
23 | 
24 |     .input-row > *:not(:last-child) {
25 |       margin-right: 8px;
26 |     }
27 | 
28 |     .input-row button {
29 |       width: 120px;
30 |       box-sizing: border-box;
31 |     }
32 | 
33 |     input[type="button"], button {
34 |       cursor:pointer; 
35 |       border: 1px solid #707070;
36 |       background-color: #F0F0F0;
37 |       border-radius: 4px;
38 |       box-shadow: inset 0 1px 2px #fff, inset 0 -0.7em #DDD;
39 |       padding: 3px 6px;
40 |     }
41 | 
42 |     input[type="button"]:hover, button:hover {
43 |       cursor:pointer;
44 |       background-color: #EAF6FD;
45 |       border: 1px solid #3C7FB1;
46 |       box-shadow: inset 0 1px 2px #fff, inset 0 -0.7em #BEE6FD, 0 0 3px #A7D9F5;
47 |     }
48 | 
49 |     html {
50 |       text-align: center;
51 |     }
52 | 
53 |     body {
54 |       text-align: left;;
55 |       width: min-content;
56 |       display: inline-block;
57 |       margin: 8px auto;
58 |     }
59 |   </style>
60 | </head>
61 | <body>
62 |   <div style="margin-bottom: 8px;">程序员小盆友是如何练习识谱的（不</div>
63 |   <div id="app"></div>
64 |   <div class="input-row">
65 |     <input type="text" placeholder="输入唱名（不需要关注八度）">
66 |     <button>让我康康对不对</button>
67 |   </div>
68 |   <pre></pre>
69 |   <script src="/bundle.js"></script>
70 | </body>
71 | </html>


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/ws.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <vector>
 5 | #include <memory>
 6 | #include <functional>
 7 | 
 8 | #include <cstring>
 9 | #include <cstdint>
10 | 
11 | #include <unistd.h>
12 | #include <sys/socket.h>
13 | 
14 | #include "pty.hpp"
15 | #include "http.hpp"
16 | #include "base64.hpp"
17 | #include "sha1.hpp"
18 | #include "frontend.hpp"
19 | 
20 | enum websocket_connection_stage_t {
21 |   handshaking,
22 |   established,
23 |   terminated,
24 |   unknown,
25 | };
26 | 
27 | struct websocket_frame_t {
28 |   using opcode_t = enum {
29 |     CONTINUATION_FRAME = 0x00,
30 |     TEXT_FRAME = 0x01,
31 |     BINARY_FRAME = 0x02,
32 |     CONNECTION_CLOSE_FRAME = 0x08,
33 |     PING_FRAME = 0x09,
34 |     PONG_FRAME = 0x0A,
35 |   };
36 | 
37 |   bool fin;
38 |   opcode_t opcode;
39 |   bool mask;
40 |   uint8_t mask_key[4] = { 0, 0, 0, 0 };
41 |   std::vector<uint8_t> payload;
42 | 
43 |   bool debug = false;
44 | 
45 |   websocket_frame_t(std::unique_ptr<uint8_t[]>, size_t);
46 | 
47 |   websocket_frame_t();
48 | 
49 |   void print_frame_info();
50 | 
51 |   std::unique_ptr<uint8_t[]> to_raw_frame(size_t *frame_size);
52 | };
53 | 
54 | struct websocket_context_t {
55 |   websocket_connection_stage_t stage = websocket_connection_stage_t::unknown;
56 |   int client_fd = -1;
57 | 
58 |   uint8_t *received_buffer = nullptr;
59 |   ssize_t received_buffer_capacity = -1;
60 |   ssize_t received_buffer_used = -1;
61 |   bool enable_builtin_webpages = false;
62 |   pty_t pty;
63 |   std::function<void(void)> regist_pty_session;
64 | 
65 |   ~websocket_context_t();
66 | 
67 |   void append_buffer(uint8_t *buffer, ssize_t buffer_size);
68 |   void process();
69 |   void process_handshake();
70 |   ssize_t next_valid_ws_frame_size();
71 |   void process_data();
72 | };


--------------------------------------------------------------------------------
/reversi/dist/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |   <meta charset="UTF-8">
 5 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |   <meta http-equiv="X-UA-Compatible" content="ie=edge">
 7 |   <title>Document</title>
 8 |   <script src="https://cdn.jsdelivr.net/npm/socket.io-client@2.2.0/dist/socket.io.js"></script>
 9 |   <style>
10 |     body {
11 |       background: gray;
12 |     }
13 |     td {
14 |       width: 20px;
15 |       height: 20px;
16 |       border: 1px solid darkgray;
17 |       border-radius: 10px;
18 |     }
19 |     td.white {
20 |       background: white;
21 |     }
22 |     td.black {
23 |       background: black;
24 |     }
25 |   </style>
26 | </head>
27 | <body>
28 |   <h1></h1>
29 |   <h2></h2>
30 |   <table class="board">
31 |     <thead></thead>
32 |     <tbody></tbody>
33 |   </table>
34 |   <script>
35 |     const socket = io(window.location.origin);
36 |     const boardElement = document.querySelector('.board > tbody');
37 |     const title = document.querySelector('h1');
38 |     const status = document.querySelector('h2');
39 |     let im = '';
40 | 
41 |     boardElement.onclick = function (e) {
42 |       socket.emit('op', [
43 |         Number(e.target.attributes['data-x'].value),
44 |         Number(e.target.attributes['data-y'].value),
45 |       ])
46 |     }
47 | 
48 |     socket.on('message', message => {
49 |       title.innerText = 'You are: ' + message;
50 |       im = message;
51 |     })
52 | 
53 |     socket.on('next_player', player => {
54 |       if (player === im) {
55 |         status.innerText = 'Now it\'s your turn';
56 |       } else {
57 |         status.innerText = 'Waiting...';
58 |       }
59 |     })
60 |     
61 |     socket.on('board', board => {
62 |       boardElement.innerHTML = board.map((row, x) => {
63 |         return '<tr>' + row.map((item, y) => {
64 |           switch (item) {
65 |             case 0: return '<td data-x="' + x + '" data-y="' + y + '"></td>';
66 |             case 1: return '<td data-x="' + x + '" data-y="' + y + '" class="white"></td>';
67 |             case 2: return '<td data-x="' + x + '" data-y="' + y + '" class="black"></td>';
68 |           }
69 |         }).join('') + '</tr>'
70 |       }).join('')
71 |     })
72 |   </script>
73 | </body>
74 | </html>


--------------------------------------------------------------------------------
/Daemon/Daemon/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Resources;
 3 | using System.Runtime.CompilerServices;
 4 | using System.Runtime.InteropServices;
 5 | using System.Windows;
 6 | 
 7 | // General Information about an assembly is controlled through the following 
 8 | // set of attributes. Change these attribute values to modify the information
 9 | // associated with an assembly.
10 | [assembly: AssemblyTitle("Daemon")]
11 | [assembly: AssemblyDescription("")]
12 | [assembly: AssemblyConfiguration("")]
13 | [assembly: AssemblyCompany("")]
14 | [assembly: AssemblyProduct("Daemon")]
15 | [assembly: AssemblyCopyright("Copyright ©  2017")]
16 | [assembly: AssemblyTrademark("")]
17 | [assembly: AssemblyCulture("")]
18 | 
19 | // Setting ComVisible to false makes the types in this assembly not visible 
20 | // to COM components.  If you need to access a type in this assembly from 
21 | // COM, set the ComVisible attribute to true on that type.
22 | [assembly: ComVisible(false)]
23 | 
24 | //In order to begin building localizable applications, set 
25 | //<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
26 | //inside a <PropertyGroup>.  For example, if you are using US english
27 | //in your source files, set the <UICulture> to en-US.  Then uncomment
28 | //the NeutralResourceLanguage attribute below.  Update the "en-US" in
29 | //the line below to match the UICulture setting in the project file.
30 | 
31 | //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
32 | 
33 | 
34 | [assembly: ThemeInfo(
35 |     ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
36 |                                      //(used if a resource is not found in the page, 
37 |                                      // or application resource dictionaries)
38 |     ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
39 |                                               //(used if a resource is not found in the page, 
40 |                                               // app, or any theme specific resource dictionaries)
41 | )]
42 | 
43 | 
44 | // Version information for an assembly consists of the following four values:
45 | //
46 | //      Major Version
47 | //      Minor Version 
48 | //      Build Number
49 | //      Revision
50 | //
51 | // You can specify all the values or you can default the Build and Revision Numbers 
52 | // by using the '*' as shown below:
53 | // [assembly: AssemblyVersion("1.0.*")]
54 | [assembly: AssemblyVersion("1.0.0.0")]
55 | [assembly: AssemblyFileVersion("1.0.0.0")]
56 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/base64.cpp:
--------------------------------------------------------------------------------
 1 | /* Public Domain from https://gist.github.com/ynov/aead6c4a4208e1808fb2, modified */
 2 | 
 3 | #include "base64.hpp"
 4 | 
 5 | #include <cstdint>
 6 | #include <cstring>
 7 | 
 8 | namespace base64 {
 9 |     
10 | static bool dlookupok = false;
11 | static char dlookup[256];
12 | const static char lookup[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
13 | const static char padchar = '=';
14 | 
15 | const char *getdlookup()
16 | {
17 |     if (!dlookupok) {
18 |         memset(dlookup, 0, sizeof(dlookup));
19 |         for (size_t i = 0; i < strlen(lookup); i++) {
20 |             dlookup[(int) lookup[i]] = i;
21 |         }
22 |     }
23 | 
24 |     dlookupok = true;
25 |     return dlookup;
26 | }
27 | 
28 | std::string encode(const std::vector<byte> &src)
29 | {
30 |     std::string encoded;
31 | 
32 |     int outputSize = 4 * ((src.size() / 3) + (src.size() % 3 > 0 ? 1 : 0));
33 |     encoded.reserve(outputSize);
34 | 
35 |     uint32_t tmp;
36 |     int i, padding;
37 |     int srcsz = src.size();
38 | 
39 |     for (i = 0; i < srcsz; i += 3) {
40 |         padding = (i + 3) - srcsz;
41 |         tmp = 0;
42 | 
43 |         switch (padding) {
44 |         case 2:
45 |             tmp |= (src[i] << 16);
46 |             break;
47 |         case 1:
48 |             tmp |= (src[i] << 16) | (src[i + 1] << 8);
49 |             break;
50 |         default:
51 |             tmp |= (src[i] << 16) | (src[i + 1] << 8) | (src[i + 2]);
52 |             break;
53 |         }
54 | 
55 |         encoded +=                         lookup[(tmp & 0xfc0000) >> 18];
56 |         encoded +=                         lookup[(tmp & 0x03f000) >> 12];
57 |         encoded += padding > 1 ? padchar : lookup[(tmp & 0x000fc0) >> 6];
58 |         encoded += padding > 0 ? padchar : lookup[(tmp & 0x00003f)];
59 |     }
60 | 
61 |     return encoded;
62 | }
63 | 
64 | std::vector<byte> decode(const std::string &src)
65 | {
66 |     const char *dlookup = getdlookup();
67 |     std::vector<byte> decoded;
68 | 
69 |     int outputSize = (src.size() / 4) * 3;
70 |     decoded.reserve(outputSize);
71 | 
72 |     char ch[4];
73 |     uint32_t tmp;
74 |     size_t i, j;
75 |     int padding = 0;
76 | 
77 |     for (i = 0; i < src.size(); i += 4) {
78 |         for (j = 0; j < 4; j++) {
79 |             if (src[i + j] == padchar) {
80 |                 ch[j] = '\0';
81 |                 padding++;
82 |             } else {
83 |                 ch[j] = dlookup[static_cast<int>(src[i + j])];
84 |             }
85 |         }
86 | 
87 |         tmp = 0;
88 |         tmp |= (ch[0] << 18) | (ch[1] << 12) | (ch[2] << 6) | ch[3];
89 | 
90 |         decoded.push_back((tmp & 0xff0000) >> 16);
91 |         decoded.push_back((tmp & 0xff00) >> 8);
92 |         decoded.push_back((tmp & 0xff));
93 |     }
94 | 
95 |     return decoded;
96 | }
97 | 
98 | }


--------------------------------------------------------------------------------
/bilibili-regular-block/tv.bilibili.player.xml:
--------------------------------------------------------------------------------
 1 | <filters>
 2 |   <!-- 呃。。 -->
 3 |   <item enabled="true">r=我是.+?党</item>
 4 |   <!-- 无意义的短数字 -->
 5 |   <item enabled="true">r=^\d{0,2}$</item>
 6 |   <!-- 精污 av 号 -->
 7 |   <item enabled="true">r=[aA][vV](170001|10388|10492)</item>
 8 |   <!--  -->
 9 |   <item enabled="true">r=←↓↗↘</item>
10 |   <!-- 红红火火恍恍惚惚 -->
11 |   <item enabled="true">r=[恍惚红火]{2}</item>
12 |   <!-- 午时已到以及其变种' -->
13 |   <item enabled="true">r=[无五午5][时十⑩屎01][已以一][到刀]</item>
14 |   <!--  -->
15 |   <item enabled="true">t=测试</item>
16 |   <!-- 第一第二，前十前一百，后一万，etc -->
17 |   <item enabled="true">r=^[第前后][0-9一二三四五六七八九零十百千]+.{0,6}[！!\?？]*$</item>
18 |   <!--  -->
19 |   <item enabled="true">t=厂下广卞</item>
20 |   <!-- "        注释两倍速        " -->
21 |   <item enabled="true">r=倍速 *$</item>
22 |   <!-- 难受，想哭 -->
23 |   <item enabled="true">t=香菇</item>
24 |   <!-- 好前！ -->
25 |   <item enabled="true">r=^[好]{0,}前[!！~]{0,}$</item>
26 |   <!--  -->
27 |   <item enabled="true">t=高级弹幕</item>
28 |   <!-- 部分 emoji -->
29 |   <item enabled="true">r=([\uE000-\uF8FF]|\uD83C[\uDF00-\uDFFF]|\uD83D[\uDC00-\uDDFF])</item>
30 |   <!-- 部分 emoji -->
31 |   <item enabled="true">r=[\uE000-\uF8FF]|\uD83C[\uDF00-\uDFFF]|\uD83D[\uDC00-\uDDFF]</item>
32 |   <!-- "       高级弹幕" -->
33 |   <item enabled="true">r=(^ {5,}| {5,}$)</item>
34 |   <!-- 新年大吉吧 -->
35 |   <item enabled="true">t=吉吧</item>
36 |   <!-- 拜个早年 -->
37 |   <item enabled="true">r=[拜|过|新|早](.*?)年</item>
38 |   <!-- 一口气1048576集 -->
39 |   <item enabled="true">r=一口气(.+?)集</item>
40 |   <!-- 我跟你讲，你头上都绿了 -->
41 |   <item enabled="true">r=我老婆</item>
42 |   <!-- WiFi -->
43 |   <item enabled="true">r=[Ww][Ii][Ff][Ii]</item>
44 |   <!-- 啊这个不说了…… -->
45 |   <item enabled="true">r=电光.+?信仰.+?长存</item>
46 |   <!-- 去nmd指挥部 -->
47 |   <item enabled="true">r=(空降|空难|盲降|降落|指挥部|坐标|\d+?[:：]\d+?)</item>
48 |   <!-- 罗列观点的撕逼…… -->
49 |   <item enabled="true">r=^(\d+?)[.。\ ]</item>
50 |   <!-- too young -->
51 |   <item enabled="true">t=膜法</item>
52 |   <!-- too simple -->
53 |   <item enabled="true">r=^\+\d*?s$</item>
54 |   <!-- 日常打卡 -->
55 |   <item enabled="true">r=^日常</item>
56 |   <!-- 前方xx福利 -->
57 |   <item enabled="true">r=^前方(.+?)福利$</item>
58 |   <!-- 刷日期。。 -->
59 |   <item enabled="true">r=^\d{2,4}[。\.\/\-\:：]\d{1,2}[。\.\/\-\:：]\d{1,2}</item>
60 |   <!-- 无脑RE0厨？ -->
61 |   <item enabled="true">r=[苹水]果摊</item>
62 |   <!-- 巧了，寡人屏蔽了 -->
63 |   <item enabled="true">r=巧了[，, ]</item>
64 |   <!-- 啊啊啊~我的右手！我的王之力！ -->
65 |   <item enabled="true">t=王之力</item>
66 |   <!-- http://www.bilibili.com/video/av6930969/ -->
67 |   <item enabled="true">t=做操</item>
68 |   <!-- 我管你刷了几周目啊…… -->
69 |   <item enabled="true">r=[一二三四五六七八九十百千万零负0-9a-zA-Z]+?周目</item>
70 |   <!-- 这个也是烦…… -->
71 |   <item enabled="true">r=(爱的|供养|再问|自杀).+?(爱的|供养|再问|自杀)</item>
72 |   <!-- 我哲♂学入宅 -->
73 |   <item enabled="true">r=.+?入的{0,1}宅</item>
74 |   <!-- 打这么多字不嫌长么…… -->
75 |   <item enabled="true">r=.{32,}</item>
76 |   <!-- 暴力接龙 -->
77 |   <item enabled="true">r=^[苟利国家生死以岂因祸福避趋之]$</item>
78 | </filters>
79 | 


--------------------------------------------------------------------------------
/Daemon/Daemon/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="Daemon.MainWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
 5 |         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 6 |         xmlns:local="clr-namespace:Daemon"
 7 |         mc:Ignorable="d"
 8 |         Title="MainWindow" Height="350" Width="525" Closing="Window_Closing" StateChanged="Window_StateChanged">
 9 |     <Grid>
10 |         <TabControl Margin="10,10,10,10.5">
11 |             <TabItem Header="Nginx">
12 |                 <Grid>
13 |                     <Label Content="应用程序：" HorizontalAlignment="Left" Margin="10,13,0,0" VerticalAlignment="Top"/>
14 |                     <TextBox x:Name="nginxCommand" Height="23" Margin="85,14,10,0" TextWrapping="Wrap" Text="ping" VerticalAlignment="Top" VerticalContentAlignment="Center"/>
15 |                     <TextBox x:Name="nginxArguments" Height="23" Margin="85,42,10,0" TextWrapping="Wrap" Text="-n 1 114.114.114.114" VerticalAlignment="Top" VerticalContentAlignment="Center"/>
16 |                     <Label Content="参数：" HorizontalAlignment="Left" Margin="34,40,0,0" VerticalAlignment="Top"/>
17 |                     <Button x:Name="btnNginx" Content="运行一次" Margin="0,0,10,10" Height="19" VerticalAlignment="Bottom" HorizontalAlignment="Right" Width="75" Click="btnNginx_Click"/>
18 |                 </Grid>
19 |             </TabItem>
20 |             <TabItem Header="Java">
21 |                 <Grid>
22 |                     <Label Content="应用程序：" HorizontalAlignment="Left" Margin="10,13,0,0" VerticalAlignment="Top"/>
23 |                     <TextBox x:Name="javaCommand" Height="23" Margin="85,14,10,0" TextWrapping="Wrap" Text="ping" VerticalAlignment="Top" VerticalContentAlignment="Center"/>
24 |                     <TextBox x:Name="javaArguments" Height="23" Margin="85,42,10,0" TextWrapping="Wrap" Text="-t 114.114.114.114" VerticalAlignment="Top" VerticalContentAlignment="Center"/>
25 |                     <Label Content="参数：" HorizontalAlignment="Left" Margin="34,40,0,0" VerticalAlignment="Top"/>
26 |                     <TextBox x:Name="javaStdout" Margin="85,70,10,34" TextWrapping="Wrap" IsReadOnly="True" FontFamily="Consolas"/>
27 |                     <Label Content="输出：" HorizontalAlignment="Left" Margin="34,66,0,0" VerticalAlignment="Top"/>
28 |                     <Button x:Name="btnJava" Content="运行" Margin="0,0,90,10" Click="btnJava_Click" Height="19" VerticalAlignment="Bottom" HorizontalAlignment="Right" Width="75"/>
29 |                     <Button x:Name="btnJavaAbort" Content="终止" Margin="0,0,10,10" Click="btnJavaAbort_Click" Height="19" VerticalAlignment="Bottom" HorizontalAlignment="Right" Width="75" IsEnabled="False"/>
30 |                     <Button x:Name="btnJavaLogClear" Content="清空输出" HorizontalAlignment="Right" Margin="0,0,170,10" Width="75" Click="btnJavaLogClear_Click" Height="19" VerticalAlignment="Bottom"/>
31 |                 </Grid>
32 |             </TabItem>
33 |         </TabControl>
34 | 
35 |     </Grid>
36 | </Window>
37 | 


--------------------------------------------------------------------------------
/Daemon/Daemon/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.42000
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace Daemon.Properties {
12 |     using System;
13 |     
14 |     
15 |     /// <summary>
16 |     ///   A strongly-typed resource class, for looking up localized strings, etc.
17 |     /// </summary>
18 |     // This class was auto-generated by the StronglyTypedResourceBuilder
19 |     // class via a tool like ResGen or Visual Studio.
20 |     // To add or remove a member, edit your .ResX file then rerun ResGen
21 |     // with the /str option, or rebuild your VS project.
22 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
23 |     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
24 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
25 |     internal class Resources {
26 |         
27 |         private static global::System.Resources.ResourceManager resourceMan;
28 |         
29 |         private static global::System.Globalization.CultureInfo resourceCulture;
30 |         
31 |         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
32 |         internal Resources() {
33 |         }
34 |         
35 |         /// <summary>
36 |         ///   Returns the cached ResourceManager instance used by this class.
37 |         /// </summary>
38 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
39 |         internal static global::System.Resources.ResourceManager ResourceManager {
40 |             get {
41 |                 if (object.ReferenceEquals(resourceMan, null)) {
42 |                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Daemon.Properties.Resources", typeof(Resources).Assembly);
43 |                     resourceMan = temp;
44 |                 }
45 |                 return resourceMan;
46 |             }
47 |         }
48 |         
49 |         /// <summary>
50 |         ///   Overrides the current thread's CurrentUICulture property for all
51 |         ///   resource lookups using this strongly typed resource class.
52 |         /// </summary>
53 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
54 |         internal static global::System.Globalization.CultureInfo Culture {
55 |             get {
56 |                 return resourceCulture;
57 |             }
58 |             set {
59 |                 resourceCulture = value;
60 |             }
61 |         }
62 |         
63 |         /// <summary>
64 |         ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
65 |         /// </summary>
66 |         internal static System.Drawing.Icon icon {
67 |             get {
68 |                 object obj = ResourceManager.GetObject("icon", resourceCulture);
69 |                 return ((System.Drawing.Icon)(obj));
70 |             }
71 |         }
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/pcap-port-statistics/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <pcap.h>
  2 | #include <net/ethernet.h>
  3 | #include <netinet/in.h>
  4 | #include <netinet/ip.h>
  5 | #include <netinet/tcp.h>
  6 | #include <stdio.h>
  7 | #include <stdlib.h>
  8 | #include <unistd.h>
  9 | #include <sys/socket.h>
 10 | #include <sys/types.h>
 11 | #include <arpa/inet.h>
 12 | 
 13 | #include <vector>
 14 | #include <thread>
 15 | #include <mutex>
 16 | 
 17 | #define PROMISCUOUS 0
 18 | #define NONPROMISCUOUS 1
 19 | 
 20 | std::mutex records_mutex;
 21 | std::vector<uint64_t> records(65536, 0);
 22 | std::string local_ipaddr("10.12.11.4"); // <-- replace it with your own IP address.
 23 | 
 24 | void callback(u_char *useless, const struct pcap_pkthdr *pkthdr, const u_char *packet)
 25 | {
 26 |   auto ep = reinterpret_cast<const struct ether_header *>(packet);
 27 |   auto ether_type = ntohs(ep->ether_type);
 28 | 
 29 |   if (ether_type != ETHERTYPE_IP) {
 30 |     return;
 31 |   }
 32 | 
 33 |   packet += sizeof(struct ether_header);
 34 |   auto ip_header = reinterpret_cast<const struct ip *>(packet);
 35 |   std::string src_addr(inet_ntoa(ip_header->ip_src));
 36 |   std::string dst_addr(inet_ntoa(ip_header->ip_dst));
 37 |   ssize_t payload_size = pkthdr->len - 16;
 38 | 
 39 |   if (ip_header->ip_p == IPPROTO_TCP) {
 40 |     packet += sizeof(struct ip);
 41 |     auto tcp_header = reinterpret_cast<const struct tcphdr *>(packet);
 42 |     uint16_t port = 0;
 43 | 
 44 |     if (src_addr == local_ipaddr) {
 45 |       port = ntohs(tcp_header->th_sport);
 46 |     } else if (dst_addr == local_ipaddr) {
 47 |       port = ntohs(tcp_header->th_dport);
 48 |     } else {
 49 |       // ICMP maybe? seems not need to care about it.
 50 |       return;
 51 |     }
 52 | 
 53 |     records_mutex.lock();
 54 |     records[port] += payload_size;
 55 |     records_mutex.unlock();
 56 |   } else if (ip_header->ip_p == IPPROTO_UDP) {
 57 |     // T.B.D
 58 |   }
 59 | }
 60 | 
 61 | void print_stat_entry() {
 62 |   for (;;) {
 63 |     sleep(60);
 64 |     system("clear");
 65 |     for (uint16_t port: {80, 443, 3389, /* etc */}) {
 66 |       if (records[port] != 0) {
 67 |         printf("%s:%d: %u byte(s)\n", local_ipaddr.c_str(), port, records[port]);
 68 |       }
 69 |     }
 70 |   }
 71 | }
 72 | 
 73 | int main(int argc, char **argv)
 74 | {
 75 |   char *dev;
 76 |   char *net;
 77 |   char *mask;
 78 |   char errbuf[PCAP_ERRBUF_SIZE];
 79 |   struct bpf_program fp;
 80 |   pcap_t *pcd; // packet caputre descriptor.
 81 |   bpf_u_int32 netp;
 82 |   bpf_u_int32 maskp;
 83 |   struct in_addr net_addr, mask_addr;
 84 | 
 85 |   dev = pcap_lookupdev(errbuf);
 86 |   if (dev == NULL)
 87 |   {
 88 |       printf("%s\n", errbuf);
 89 |       exit(1);
 90 |   }
 91 |   printf("DEV : %s\n", dev);
 92 | 
 93 |   // Get netmask
 94 |   if (pcap_lookupnet(dev, &netp, &maskp, errbuf) == -1) {
 95 |     fprintf(stderr, "%s\n", errbuf);
 96 |     return 1;
 97 |   }
 98 |   net_addr.s_addr = netp;
 99 |   net = inet_ntoa(net_addr);
100 |   printf("NET : %s\n", net);
101 |   mask_addr.s_addr = maskp;
102 |   mask = inet_ntoa(mask_addr);
103 |   printf("MASK : %s\n", mask);
104 | 
105 |   // Get packet capture descriptor.
106 |   pcd = pcap_open_live(dev, BUFSIZ, NONPROMISCUOUS, 1000, errbuf);
107 |   if (pcd == NULL) {
108 |     fprintf(stderr, "%s\n", errbuf);
109 |     return 1;
110 |   }
111 | 
112 |   // Set compile option.
113 |   if (pcap_compile(pcd, &fp, "tcp", 0, netp) == -1) {
114 |     fprintf(stderr, "compile error\n");
115 |     return 1; }
116 | 
117 |   // Set packet filter role by compile option.
118 |   if (pcap_setfilter(pcd, &fp) == -1) {
119 |     fprintf(stderr, "set filter error\n");
120 |     return 1;
121 |   }
122 | 
123 |   std::thread thread(print_stat_entry);
124 | 
125 |   // Capture packet. When packet captured, call callback function.
126 |   pcap_loop(pcd, 0, callback, NULL);
127 |   return 0;
128 | }
129 | 
130 | 


--------------------------------------------------------------------------------
/reversi/index.js:
--------------------------------------------------------------------------------
  1 | var express = require('express')
  2 | var app = express();
  3 | var server = require('http').Server(app);
  4 | var io = require('socket.io')(server);
  5 | 
  6 | server.listen(23333);
  7 | 
  8 | app.use('/', express.static('./dist'));
  9 | 
 10 | let waitingClient = null;
 11 | 
 12 | const EMPTY = 0;
 13 | const WHITE = 1;
 14 | const BLACK = 2;
 15 | 
 16 | class Game {
 17 |   constructor(firstPlayer, secondPlayer) {
 18 |     this.firstPlayer = firstPlayer;
 19 |     this.secondPlayer = secondPlayer;
 20 |     this.board = new Array(8).fill(0).map(row => new Array(8).fill(EMPTY));
 21 |     this.nextValidPlayer = BLACK;
 22 | 
 23 |     this.board[3][3] = this.board[4][4] = WHITE;
 24 |     this.board[3][4] = this.board[4][3] = BLACK;
 25 | 
 26 |     firstPlayer.emit('message', 'BLACK');
 27 |     secondPlayer.emit('message', 'WHITE');
 28 | 
 29 |     firstPlayer.emit('next_player', 'BLACK');
 30 |     secondPlayer.emit('next_player', 'BLACK');
 31 | 
 32 |     firstPlayer.emit('board', this.board);
 33 |     secondPlayer.emit('board', this.board);
 34 | 
 35 |     firstPlayer.on('op', this.createInputHandler(BLACK));
 36 |     secondPlayer.on('op', this.createInputHandler(WHITE));
 37 |   }
 38 | 
 39 |   createInputHandler(playerColor) {
 40 |     return function (payload) {
 41 |       console.log({payload, playerColor, nextValidPlayer: this.nextValidPlayer })
 42 | 
 43 |       if (this.nextValidPlayer !== playerColor) {
 44 |         return;
 45 |       }
 46 | 
 47 |       let [x, y] = payload;
 48 |       let changeCount = 0;
 49 | 
 50 |       if (this.board[x][y] !== EMPTY) {
 51 |         return;
 52 |       }
 53 | 
 54 |       let vectors = [
 55 |         [1, 0], [1, 1], [0, 1], [-1, 1],
 56 |         [-1, 0], [-1, -1], [0, -1], [1, -1]
 57 |       ];
 58 | 
 59 |       vectors.forEach(vector => {
 60 |         let cursor_x = x;
 61 |         let cursor_y = y;
 62 |         let valid = true;
 63 | 
 64 |         for (let i = 0;; i++) {
 65 |           cursor_x += vector[0];
 66 |           cursor_y += vector[1];
 67 | 
 68 |           if (cursor_x < 0 || cursor_y < 0 || cursor_x >= 8 || cursor_y >= 8) {
 69 |             valid = false;
 70 |             break;
 71 |           }
 72 | 
 73 |           if (this.board[cursor_x][cursor_y] === playerColor) {
 74 |             break;
 75 |           }
 76 | 
 77 |           if (this.board[cursor_x][cursor_y] === EMPTY) {
 78 |             valid = false;
 79 |             break;
 80 |           }
 81 |         }
 82 | 
 83 |         if (valid) {
 84 |           const end_x = cursor_x;
 85 |           const end_y = cursor_y;
 86 |           
 87 |           cursor_x = x;
 88 |           cursor_y = y;
 89 |   
 90 |           for (let i = 0;; i++) {
 91 |             cursor_x += vector[0];
 92 |             cursor_y += vector[1];
 93 | 
 94 |             if (cursor_x === end_x && cursor_y === end_y) {
 95 |               break;
 96 |             }
 97 | 
 98 |             this.board[cursor_x][cursor_y] = playerColor;
 99 |             changeCount++;
100 |           }
101 |         }
102 |       })
103 | 
104 |       if (changeCount !== 0) {
105 |         this.board[x][y] = playerColor;
106 | 
107 |         if (playerColor === WHITE) {
108 |           this.nextValidPlayer = BLACK;
109 |           this.firstPlayer.emit('next_player', 'BLACK');
110 |           this.secondPlayer.emit('next_player', 'BLACK');
111 |         }
112 |         if (playerColor === BLACK) {
113 |           this.nextValidPlayer = WHITE;
114 |           this.firstPlayer.emit('next_player', 'WHITE');
115 |           this.secondPlayer.emit('next_player', 'WHITE');
116 |         }
117 | 
118 |         this.firstPlayer.emit('board', this.board);
119 |         this.secondPlayer.emit('board', this.board);
120 | 
121 |       }
122 |     }.bind(this);
123 |   }
124 | }
125 | 
126 | io.on('connection', (socket) => {
127 |   if (waitingClient === null) {
128 |     waitingClient = socket;
129 |   } else {
130 |     new Game(waitingClient, socket);
131 |     waitingClient = null;
132 |   }
133 | });
134 | 
135 | 


--------------------------------------------------------------------------------
/Daemon/Daemon/Daemon.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  4 |   <PropertyGroup>
  5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  7 |     <ProjectGuid>{48455FF1-66AE-4245-B35B-021CE8AEFFE3}</ProjectGuid>
  8 |     <OutputType>WinExe</OutputType>
  9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 10 |     <RootNamespace>Daemon</RootNamespace>
 11 |     <AssemblyName>Daemon</AssemblyName>
 12 |     <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
 13 |     <FileAlignment>512</FileAlignment>
 14 |     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 15 |     <WarningLevel>4</WarningLevel>
 16 |     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
 17 |   </PropertyGroup>
 18 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 19 |     <PlatformTarget>AnyCPU</PlatformTarget>
 20 |     <DebugSymbols>true</DebugSymbols>
 21 |     <DebugType>full</DebugType>
 22 |     <Optimize>false</Optimize>
 23 |     <OutputPath>bin\Debug\</OutputPath>
 24 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 25 |     <ErrorReport>prompt</ErrorReport>
 26 |     <WarningLevel>4</WarningLevel>
 27 |   </PropertyGroup>
 28 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 29 |     <PlatformTarget>AnyCPU</PlatformTarget>
 30 |     <DebugType>pdbonly</DebugType>
 31 |     <Optimize>true</Optimize>
 32 |     <OutputPath>bin\Release\</OutputPath>
 33 |     <DefineConstants>TRACE</DefineConstants>
 34 |     <ErrorReport>prompt</ErrorReport>
 35 |     <WarningLevel>4</WarningLevel>
 36 |   </PropertyGroup>
 37 |   <PropertyGroup>
 38 |     <ApplicationIcon>Resources\icon.ico</ApplicationIcon>
 39 |   </PropertyGroup>
 40 |   <ItemGroup>
 41 |     <Reference Include="System" />
 42 |     <Reference Include="System.Data" />
 43 |     <Reference Include="System.Drawing" />
 44 |     <Reference Include="System.Windows.Forms" />
 45 |     <Reference Include="System.Xml" />
 46 |     <Reference Include="Microsoft.CSharp" />
 47 |     <Reference Include="System.Core" />
 48 |     <Reference Include="System.Xml.Linq" />
 49 |     <Reference Include="System.Data.DataSetExtensions" />
 50 |     <Reference Include="System.Net.Http" />
 51 |     <Reference Include="System.Xaml">
 52 |       <RequiredTargetFramework>4.0</RequiredTargetFramework>
 53 |     </Reference>
 54 |     <Reference Include="WindowsBase" />
 55 |     <Reference Include="PresentationCore" />
 56 |     <Reference Include="PresentationFramework" />
 57 |   </ItemGroup>
 58 |   <ItemGroup>
 59 |     <ApplicationDefinition Include="App.xaml">
 60 |       <Generator>MSBuild:Compile</Generator>
 61 |       <SubType>Designer</SubType>
 62 |     </ApplicationDefinition>
 63 |     <Page Include="MainWindow.xaml">
 64 |       <Generator>MSBuild:Compile</Generator>
 65 |       <SubType>Designer</SubType>
 66 |     </Page>
 67 |     <Compile Include="App.xaml.cs">
 68 |       <DependentUpon>App.xaml</DependentUpon>
 69 |       <SubType>Code</SubType>
 70 |     </Compile>
 71 |     <Compile Include="MainWindow.xaml.cs">
 72 |       <DependentUpon>MainWindow.xaml</DependentUpon>
 73 |       <SubType>Code</SubType>
 74 |     </Compile>
 75 |   </ItemGroup>
 76 |   <ItemGroup>
 77 |     <Compile Include="Properties\AssemblyInfo.cs">
 78 |       <SubType>Code</SubType>
 79 |     </Compile>
 80 |     <Compile Include="Properties\Resources.Designer.cs">
 81 |       <AutoGen>True</AutoGen>
 82 |       <DesignTime>True</DesignTime>
 83 |       <DependentUpon>Resources.resx</DependentUpon>
 84 |     </Compile>
 85 |     <Compile Include="Properties\Settings.Designer.cs">
 86 |       <AutoGen>True</AutoGen>
 87 |       <DependentUpon>Settings.settings</DependentUpon>
 88 |       <DesignTimeSharedInput>True</DesignTimeSharedInput>
 89 |     </Compile>
 90 |     <EmbeddedResource Include="Properties\Resources.resx">
 91 |       <Generator>ResXFileCodeGenerator</Generator>
 92 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
 93 |     </EmbeddedResource>
 94 |     <None Include="Properties\Settings.settings">
 95 |       <Generator>SettingsSingleFileGenerator</Generator>
 96 |       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
 97 |     </None>
 98 |     <AppDesigner Include="Properties\" />
 99 |   </ItemGroup>
100 |   <ItemGroup>
101 |     <None Include="App.config" />
102 |   </ItemGroup>
103 |   <ItemGroup>
104 |     <None Include="Resources\icon.ico" />
105 |   </ItemGroup>
106 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
107 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
108 |        Other similar extension points exist, see Microsoft.Common.targets.
109 |   <Target Name="BeforeBuild">
110 |   </Target>
111 |   <Target Name="AfterBuild">
112 |   </Target>
113 |   -->
114 | </Project>


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/http.cpp:
--------------------------------------------------------------------------------
  1 | #include "http.hpp"
  2 | 
  3 | static inline std::string &string_trim(std::string &s) {
  4 |   if (s.empty()) {
  5 |     return s;
  6 |   }
  7 | 
  8 |   s.erase(0, s.find_first_not_of("\r\n "));
  9 |   s.erase(s.find_last_not_of("\r\n ") + 1);
 10 | 
 11 |   return s;
 12 | }
 13 | 
 14 | http_request_t::http_request_t(const uint8_t *const raw_request,
 15 |                                const ssize_t raw_request_size) {
 16 |   uint8_t *buffer = new uint8_t[raw_request_size + 1];
 17 | 
 18 |   std::copy(raw_request, raw_request + raw_request_size, buffer);
 19 |   buffer[raw_request_size] = '\0';
 20 | 
 21 |   std::stringstream ss(reinterpret_cast<char *>(buffer));
 22 | 
 23 |   // HTTP Method
 24 |   parse_http_method(ss);
 25 | 
 26 |   // HTTP Path
 27 |   parse_http_path(ss);
 28 | 
 29 |   // HTTP Version
 30 |   parse_http_version(ss);
 31 | 
 32 |   // Other HTTP Headers
 33 |   parse_http_headers(ss);
 34 | 
 35 |   delete[] buffer;
 36 | }
 37 | 
 38 | void http_request_t::parse_http_method(std::stringstream &ss) {
 39 |   std::string method;
 40 | 
 41 |   ss >> method;
 42 | 
 43 |   if (method == "GET") {
 44 |     request_method = GET;
 45 |   } else {
 46 |     fprintf(stderr, "warning: unsupported http method: %s, continue anyway\n",
 47 |             method.c_str());
 48 |     request_method = UNKNOWN;
 49 |   }
 50 | }
 51 | 
 52 | void http_request_t::parse_http_path(std::stringstream &ss) {
 53 |   std::string path;
 54 | 
 55 |   ss >> path;
 56 | 
 57 |   if (path[0] != '/') {
 58 |     fprintf(stderr,
 59 |             "warning: http path dose not have the leading slash: %s, "
 60 |             "continue anyway\n",
 61 |             path.c_str());
 62 |   }
 63 | 
 64 |   request_path = path;
 65 | }
 66 | 
 67 | void http_request_t::parse_http_version(std::stringstream &ss) {
 68 |   std::string version;
 69 |   const char *http_version_prefix = "HTTP/";
 70 |   ss >> version;
 71 | 
 72 |   if (strstr(version.c_str(), http_version_prefix) == nullptr) {
 73 |     fprintf(stderr, "warning: http version is invalid: %s, continue anyway\n",
 74 |             version.c_str());
 75 |   }
 76 | 
 77 |   http_version = std::string(version.begin() + strlen(http_version_prefix),
 78 |                               version.end());
 79 | }
 80 | 
 81 | void http_request_t::parse_http_headers(std::stringstream &ss) {
 82 |   std::string line;
 83 | 
 84 |   while (std::getline(ss, line)) {
 85 |     string_trim(line);
 86 | 
 87 |     if (line.empty()) {
 88 |       continue;
 89 |     }
 90 | 
 91 |     std::string key(line.begin(), line.begin() + line.find(':'));
 92 |     std::string value(line.begin() + line.find(':') + 1, line.end());
 93 | 
 94 |     string_trim(key);
 95 |     string_trim(value);
 96 | 
 97 |     std::transform(key.begin(), key.end(), key.begin(),
 98 |                     [](auto ch) { return tolower(ch); });
 99 | 
100 |     auto header_map_it = headers.find(key);
101 | 
102 |     if (header_map_it == headers.end()) {
103 |       headers[key] = std::vector<std::string>({value});
104 |     } else {
105 |       header_map_it->second.push_back(value);
106 |     }
107 |   }
108 | }
109 | 
110 | http_response_t::http_response_t(const int _in_status_code)
111 |   : status_code(_in_status_code) {
112 |   http_status_code_to_status_text();
113 |   initialize_response_headers();
114 | };
115 | 
116 | void http_response_t::http_status_code_to_status_text() {
117 |   const char *p = "";
118 | 
119 |   switch (status_code) {
120 |   case 101:
121 |     p = "Switching Protocols";
122 |     break;
123 |   case 200:
124 |     p = "OK";
125 |     break;
126 |   case 400:
127 |     p = "Bad Request";
128 |     break;
129 |   }
130 | 
131 |   status_text = std::string(p);
132 | }
133 | 
134 | void http_response_t::initialize_response_headers() {
135 |   append_header_date();
136 |   append_header_connection();
137 |   append_header_server();
138 | }
139 | 
140 | void http_response_t::append_header_date() {
141 |   char temp[1000];
142 |   time_t now = time(nullptr);
143 |   struct tm tm = *gmtime(&now);
144 | 
145 |   strftime(temp, sizeof(temp), "%a, %d %b %Y %H:%M:%S %Z", &tm);
146 | 
147 |   headers["date"] = std::vector<std::string>({temp});
148 | }
149 | 
150 | void http_response_t::append_header_connection() {
151 |   if (status_code == 101) {
152 |     headers["connection"] = std::vector<std::string>({"upgrade"});
153 |     headers["upgrade"] = std::vector<std::string>({"websocket"});
154 |   } else {
155 |     headers["connection"] = std::vector<std::string>({"close"});
156 |   }
157 | }
158 | 
159 | void http_response_t::append_header_server() {
160 |   static bool uname_loaded = false;
161 |   static struct utsname uname_data;
162 |   static char server_name[1024];
163 | 
164 |   if (!uname_loaded) {
165 |     uname(&uname_data);
166 |     sprintf(server_name, "%s/%s", uname_data.sysname, uname_data.release);
167 |     uname_loaded = true;
168 |   }
169 | 
170 |   headers["server"] = std::vector<std::string>({server_name});
171 | }
172 | 
173 | std::string http_response_t::to_response() {
174 |   std::stringstream ss;
175 |   ss << "HTTP/1.1 " << status_code << " " << status_text << "\r\n";
176 | 
177 |   for (auto &header : headers) {
178 |     std::string field = header.first;
179 | 
180 |     for (auto it = field.begin(); it != field.end(); it++) {
181 |       if (it == field.begin() || (!isalpha(*it) && it + 1 != field.end())) {
182 |         *it = toupper(*it);
183 |       }
184 |     }
185 | 
186 |     for (auto &value : header.second) {
187 |       ss << field << ": " << value << "\r\n";
188 |     }
189 |   }
190 | 
191 |   ss << "\r\n";
192 |   ss << body;
193 | 
194 |   return ss.str();
195 | }


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/frontend.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | unsigned char frontend_html[] = {
 4 |   0x3c, 0x21, 0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45, 0x20, 0x68, 0x74,
 5 |   0x6d, 0x6c, 0x3e, 0x0a, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x0a, 0x3c,
 6 |   0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x6d, 0x65, 0x74,
 7 |   0x61, 0x20, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x22, 0x55,
 8 |   0x54, 0x46, 0x2d, 0x38, 0x22, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x6d, 0x65,
 9 |   0x74, 0x61, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x22, 0x76, 0x69, 0x65,
10 |   0x77, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65,
11 |   0x6e, 0x74, 0x3d, 0x22, 0x77, 0x69, 0x64, 0x74, 0x68, 0x3d, 0x64, 0x65,
12 |   0x76, 0x69, 0x63, 0x65, 0x2d, 0x77, 0x69, 0x64, 0x74, 0x68, 0x2c, 0x20,
13 |   0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x2d, 0x73, 0x63, 0x61, 0x6c,
14 |   0x65, 0x3d, 0x31, 0x2e, 0x30, 0x22, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x6d,
15 |   0x65, 0x74, 0x61, 0x20, 0x68, 0x74, 0x74, 0x70, 0x2d, 0x65, 0x71, 0x75,
16 |   0x69, 0x76, 0x3d, 0x22, 0x58, 0x2d, 0x55, 0x41, 0x2d, 0x43, 0x6f, 0x6d,
17 |   0x70, 0x61, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x22, 0x20, 0x63, 0x6f, 0x6e,
18 |   0x74, 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x69, 0x65, 0x3d, 0x65, 0x64, 0x67,
19 |   0x65, 0x22, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x73, 0x63, 0x72, 0x69, 0x70,
20 |   0x74, 0x20, 0x73, 0x72, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x73,
21 |   0x3a, 0x2f, 0x2f, 0x63, 0x64, 0x6e, 0x2e, 0x6a, 0x73, 0x64, 0x65, 0x6c,
22 |   0x69, 0x76, 0x72, 0x2e, 0x6e, 0x65, 0x74, 0x2f, 0x6e, 0x70, 0x6d, 0x2f,
23 |   0x78, 0x74, 0x65, 0x72, 0x6d, 0x40, 0x34, 0x2e, 0x32, 0x2e, 0x30, 0x2f,
24 |   0x6c, 0x69, 0x62, 0x2f, 0x78, 0x74, 0x65, 0x72, 0x6d, 0x2e, 0x6d, 0x69,
25 |   0x6e, 0x2e, 0x6a, 0x73, 0x22, 0x3e, 0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69,
26 |   0x70, 0x74, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x6c, 0x69, 0x6e, 0x6b, 0x20,
27 |   0x72, 0x65, 0x6c, 0x3d, 0x22, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 0x68,
28 |   0x65, 0x65, 0x74, 0x22, 0x20, 0x68, 0x72, 0x65, 0x66, 0x3d, 0x22, 0x68,
29 |   0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x63, 0x64, 0x6e, 0x2e, 0x6a,
30 |   0x73, 0x64, 0x65, 0x6c, 0x69, 0x76, 0x72, 0x2e, 0x6e, 0x65, 0x74, 0x2f,
31 |   0x6e, 0x70, 0x6d, 0x2f, 0x78, 0x74, 0x65, 0x72, 0x6d, 0x40, 0x34, 0x2e,
32 |   0x32, 0x2e, 0x30, 0x2f, 0x63, 0x73, 0x73, 0x2f, 0x78, 0x74, 0x65, 0x72,
33 |   0x6d, 0x2e, 0x6d, 0x69, 0x6e, 0x2e, 0x63, 0x73, 0x73, 0x22, 0x3e, 0x0a,
34 |   0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e, 0x0a, 0x3c, 0x62, 0x6f, 0x64,
35 |   0x79, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x64, 0x69, 0x76, 0x20, 0x63, 0x6c,
36 |   0x61, 0x73, 0x73, 0x3d, 0x22, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61,
37 |   0x6c, 0x22, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x77, 0x69,
38 |   0x64, 0x74, 0x68, 0x3a, 0x20, 0x6d, 0x69, 0x6e, 0x2d, 0x63, 0x6f, 0x6e,
39 |   0x74, 0x65, 0x6e, 0x74, 0x3b, 0x20, 0x66, 0x6f, 0x6e, 0x74, 0x2d, 0x73,
40 |   0x69, 0x7a, 0x65, 0x3a, 0x20, 0x31, 0x32, 0x70, 0x78, 0x3b, 0x22, 0x3e,
41 |   0x3c, 0x2f, 0x64, 0x69, 0x76, 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x73, 0x63,
42 |   0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f,
43 |   0x6e, 0x73, 0x74, 0x20, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x75,
44 |   0x72, 0x6c, 0x20, 0x3d, 0x20, 0x27, 0x77, 0x73, 0x3a, 0x2f, 0x2f, 0x27,
45 |   0x20, 0x2b, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
46 |   0x68, 0x6f, 0x73, 0x74, 0x20, 0x2b, 0x20, 0x27, 0x2f, 0x27, 0x3b, 0x0a,
47 |   0x20, 0x20, 0x20, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x20, 0x73, 0x6f,
48 |   0x63, 0x6b, 0x65, 0x74, 0x20, 0x3d, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x57,
49 |   0x65, 0x62, 0x53, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x28, 0x73, 0x6f, 0x63,
50 |   0x6b, 0x65, 0x74, 0x5f, 0x75, 0x72, 0x6c, 0x29, 0x3b, 0x0a, 0x0a, 0x20,
51 |   0x20, 0x20, 0x20, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x6f, 0x6e,
52 |   0x6f, 0x70, 0x65, 0x6e, 0x20, 0x3d, 0x28, 0x29, 0x20, 0x3d, 0x3e, 0x20,
53 |   0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x77, 0x69, 0x6e, 0x64,
54 |   0x6f, 0x77, 0x2e, 0x74, 0x65, 0x72, 0x6d, 0x20, 0x3d, 0x20, 0x6e, 0x65,
55 |   0x77, 0x20, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x28, 0x7b,
56 |   0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f, 0x6c,
57 |   0x73, 0x3a, 0x20, 0x38, 0x30, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
58 |   0x20, 0x20, 0x20, 0x72, 0x6f, 0x77, 0x73, 0x3a, 0x20, 0x32, 0x34, 0x2c,
59 |   0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x6e,
60 |   0x74, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x3a, 0x20, 0x27, 0x53, 0x46,
61 |   0x4d, 0x6f, 0x6e, 0x6f, 0x2d, 0x52, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72,
62 |   0x2c, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x61, 0x73, 0x2c, 0x4c, 0x69,
63 |   0x62, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x4d, 0x6f, 0x6e,
64 |   0x6f, 0x2c, 0x4d, 0x65, 0x6e, 0x6c, 0x6f, 0x2c, 0x6d, 0x6f, 0x6e, 0x6f,
65 |   0x73, 0x70, 0x61, 0x63, 0x65, 0x27, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20,
66 |   0x20, 0x20, 0x7d, 0x29, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
67 |   0x20, 0x74, 0x65, 0x72, 0x6d, 0x2e, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61,
68 |   0x28, 0x64, 0x61, 0x74, 0x61, 0x20, 0x3d, 0x3e, 0x20, 0x73, 0x6f, 0x63,
69 |   0x6b, 0x65, 0x74, 0x2e, 0x73, 0x65, 0x6e, 0x64, 0x28, 0x64, 0x61, 0x74,
70 |   0x61, 0x29, 0x29, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
71 |   0x74, 0x65, 0x72, 0x6d, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x28, 0x64, 0x6f,
72 |   0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79,
73 |   0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x28, 0x27, 0x2e, 0x74,
74 |   0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x27, 0x29, 0x29, 0x3b, 0x0a,
75 |   0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x6f, 0x63, 0x6b, 0x65,
76 |   0x74, 0x2e, 0x6f, 0x6e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20,
77 |   0x3d, 0x20, 0x28, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x29, 0x20,
78 |   0x3d, 0x3e, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
79 |   0x20, 0x74, 0x65, 0x72, 0x6d, 0x2e, 0x77, 0x72, 0x69, 0x74, 0x65, 0x28,
80 |   0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x64, 0x61, 0x74, 0x61,
81 |   0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x0a, 0x20,
82 |   0x20, 0x20, 0x20, 0x7d, 0x3b, 0x0a, 0x0a, 0x20, 0x20, 0x3c, 0x2f, 0x73,
83 |   0x63, 0x72, 0x69, 0x70, 0x74, 0x3e, 0x0a, 0x3c, 0x2f, 0x62, 0x6f, 0x64,
84 |   0x79, 0x3e, 0x0a, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e
85 | };
86 | unsigned int frontend_html_len = 970;
87 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | node_modules
  2 | /websocket-terminal/dist/*
  3 | ## Ignore Visual Studio temporary files, build results, and
  4 | ## files generated by popular Visual Studio add-ons.
  5 | ##
  6 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
  7 | 
  8 | # User-specific files
  9 | *.suo
 10 | *.user
 11 | *.userosscache
 12 | *.sln.docstates
 13 | 
 14 | # User-specific files (MonoDevelop/Xamarin Studio)
 15 | *.userprefs
 16 | 
 17 | # Build results
 18 | [Dd]ebug/
 19 | [Dd]ebugPublic/
 20 | [Rr]elease/
 21 | [Rr]eleases/
 22 | x64/
 23 | x86/
 24 | bld/
 25 | [Bb]in/
 26 | [Oo]bj/
 27 | [Ll]og/
 28 | 
 29 | # Visual Studio 2015 cache/options directory
 30 | .vs/
 31 | # Uncomment if you have tasks that create the project's static files in wwwroot
 32 | #wwwroot/
 33 | 
 34 | # MSTest test Results
 35 | [Tt]est[Rr]esult*/
 36 | [Bb]uild[Ll]og.*
 37 | 
 38 | # NUNIT
 39 | *.VisualState.xml
 40 | TestResult.xml
 41 | 
 42 | # Build Results of an ATL Project
 43 | [Dd]ebugPS/
 44 | [Rr]eleasePS/
 45 | dlldata.c
 46 | 
 47 | # .NET Core
 48 | project.lock.json
 49 | project.fragment.lock.json
 50 | artifacts/
 51 | **/Properties/launchSettings.json
 52 | 
 53 | *_i.c
 54 | *_p.c
 55 | *_i.h
 56 | *.ilk
 57 | *.meta
 58 | *.obj
 59 | *.pch
 60 | *.pdb
 61 | *.pgc
 62 | *.pgd
 63 | *.rsp
 64 | *.sbr
 65 | *.tlb
 66 | *.tli
 67 | *.tlh
 68 | *.tmp
 69 | *.tmp_proj
 70 | *.log
 71 | *.vspscc
 72 | *.vssscc
 73 | .builds
 74 | *.pidb
 75 | *.svclog
 76 | *.scc
 77 | 
 78 | # Chutzpah Test files
 79 | _Chutzpah*
 80 | 
 81 | # Visual C++ cache files
 82 | ipch/
 83 | *.aps
 84 | *.ncb
 85 | *.opendb
 86 | *.opensdf
 87 | *.sdf
 88 | *.cachefile
 89 | *.VC.db
 90 | *.VC.VC.opendb
 91 | 
 92 | # Visual Studio profiler
 93 | *.psess
 94 | *.vsp
 95 | *.vspx
 96 | *.sap
 97 | 
 98 | # TFS 2012 Local Workspace
 99 | $tf/
100 | 
101 | # Guidance Automation Toolkit
102 | *.gpState
103 | 
104 | # ReSharper is a .NET coding add-in
105 | _ReSharper*/
106 | *.[Rr]e[Ss]harper
107 | *.DotSettings.user
108 | 
109 | # JustCode is a .NET coding add-in
110 | .JustCode
111 | 
112 | # TeamCity is a build add-in
113 | _TeamCity*
114 | 
115 | # DotCover is a Code Coverage Tool
116 | *.dotCover
117 | 
118 | # Visual Studio code coverage results
119 | *.coverage
120 | *.coveragexml
121 | 
122 | # NCrunch
123 | _NCrunch_*
124 | .*crunch*.local.xml
125 | nCrunchTemp_*
126 | 
127 | # MightyMoose
128 | *.mm.*
129 | AutoTest.Net/
130 | 
131 | # Web workbench (sass)
132 | .sass-cache/
133 | 
134 | # Installshield output folder
135 | [Ee]xpress/
136 | 
137 | # DocProject is a documentation generator add-in
138 | DocProject/buildhelp/
139 | DocProject/Help/*.HxT
140 | DocProject/Help/*.HxC
141 | DocProject/Help/*.hhc
142 | DocProject/Help/*.hhk
143 | DocProject/Help/*.hhp
144 | DocProject/Help/Html2
145 | DocProject/Help/html
146 | 
147 | # Click-Once directory
148 | publish/
149 | 
150 | # Publish Web Output
151 | *.[Pp]ublish.xml
152 | *.azurePubxml
153 | # TODO: Comment the next line if you want to checkin your web deploy settings
154 | # but database connection strings (with potential passwords) will be unencrypted
155 | *.pubxml
156 | *.publishproj
157 | 
158 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
159 | # checkin your Azure Web App publish settings, but sensitive information contained
160 | # in these scripts will be unencrypted
161 | PublishScripts/
162 | 
163 | # NuGet Packages
164 | *.nupkg
165 | # The packages folder can be ignored because of Package Restore
166 | **/packages/*
167 | # except build/, which is used as an MSBuild target.
168 | !**/packages/build/
169 | # Uncomment if necessary however generally it will be regenerated when needed
170 | #!**/packages/repositories.config
171 | # NuGet v3's project.json files produces more ignorable files
172 | *.nuget.props
173 | *.nuget.targets
174 | 
175 | # Microsoft Azure Build Output
176 | csx/
177 | *.build.csdef
178 | 
179 | # Microsoft Azure Emulator
180 | ecf/
181 | rcf/
182 | 
183 | # Windows Store app package directories and files
184 | AppPackages/
185 | BundleArtifacts/
186 | Package.StoreAssociation.xml
187 | _pkginfo.txt
188 | 
189 | # Visual Studio cache files
190 | # files ending in .cache can be ignored
191 | *.[Cc]ache
192 | # but keep track of directories ending in .cache
193 | !*.[Cc]ache/
194 | 
195 | # Others
196 | ClientBin/
197 | ~$*
198 | *~
199 | *.dbmdl
200 | *.dbproj.schemaview
201 | *.jfm
202 | *.pfx
203 | *.publishsettings
204 | orleans.codegen.cs
205 | 
206 | # Since there are multiple workflows, uncomment next line to ignore bower_components
207 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
208 | #bower_components/
209 | 
210 | # RIA/Silverlight projects
211 | Generated_Code/
212 | 
213 | # Backup & report files from converting an old project file
214 | # to a newer Visual Studio version. Backup files are not needed,
215 | # because we have git ;-)
216 | _UpgradeReport_Files/
217 | Backup*/
218 | UpgradeLog*.XML
219 | UpgradeLog*.htm
220 | 
221 | # SQL Server files
222 | *.mdf
223 | *.ldf
224 | *.ndf
225 | 
226 | # Business Intelligence projects
227 | *.rdl.data
228 | *.bim.layout
229 | *.bim_*.settings
230 | 
231 | # Microsoft Fakes
232 | FakesAssemblies/
233 | 
234 | # GhostDoc plugin setting file
235 | *.GhostDoc.xml
236 | 
237 | # Node.js Tools for Visual Studio
238 | .ntvs_analysis.dat
239 | node_modules/
240 | 
241 | # Typescript v1 declaration files
242 | typings/
243 | 
244 | # Visual Studio 6 build log
245 | *.plg
246 | 
247 | # Visual Studio 6 workspace options file
248 | *.opt
249 | 
250 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
251 | *.vbw
252 | 
253 | # Visual Studio LightSwitch build output
254 | **/*.HTMLClient/GeneratedArtifacts
255 | **/*.DesktopClient/GeneratedArtifacts
256 | **/*.DesktopClient/ModelManifest.xml
257 | **/*.Server/GeneratedArtifacts
258 | **/*.Server/ModelManifest.xml
259 | _Pvt_Extensions
260 | 
261 | # Paket dependency manager
262 | .paket/paket.exe
263 | paket-files/
264 | 
265 | # FAKE - F# Make
266 | .fake/
267 | 
268 | # JetBrains Rider
269 | .idea/
270 | *.sln.iml
271 | 
272 | # CodeRush
273 | .cr/
274 | 
275 | # Python Tools for Visual Studio (PTVS)
276 | __pycache__/
277 | *.pyc
278 | 
279 | # Cake - Uncomment if you are using it
280 | # tools/**
281 | # !tools/packages.config
282 | 
283 | # Telerik's JustMock configuration file
284 | *.jmconfig
285 | 
286 | # BizTalk build output
287 | *.btp.cs
288 | *.btm.cs
289 | *.odx.cs
290 | *.xsd.cs
291 | 


--------------------------------------------------------------------------------
/Daemon/Daemon/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
 64 |     <xsd:element name="root" msdata:IsDataSet="true">
 65 |       <xsd:complexType>
 66 |         <xsd:choice maxOccurs="unbounded">
 67 |           <xsd:element name="metadata">
 68 |             <xsd:complexType>
 69 |               <xsd:sequence>
 70 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 71 |               </xsd:sequence>
 72 |               <xsd:attribute name="name" use="required" type="xsd:string" />
 73 |               <xsd:attribute name="type" type="xsd:string" />
 74 |               <xsd:attribute name="mimetype" type="xsd:string" />
 75 |               <xsd:attribute ref="xml:space" />
 76 |             </xsd:complexType>
 77 |           </xsd:element>
 78 |           <xsd:element name="assembly">
 79 |             <xsd:complexType>
 80 |               <xsd:attribute name="alias" type="xsd:string" />
 81 |               <xsd:attribute name="name" type="xsd:string" />
 82 |             </xsd:complexType>
 83 |           </xsd:element>
 84 |           <xsd:element name="data">
 85 |             <xsd:complexType>
 86 |               <xsd:sequence>
 87 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 88 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 89 |               </xsd:sequence>
 90 |               <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
 91 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 92 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 93 |               <xsd:attribute ref="xml:space" />
 94 |             </xsd:complexType>
 95 |           </xsd:element>
 96 |           <xsd:element name="resheader">
 97 |             <xsd:complexType>
 98 |               <xsd:sequence>
 99 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
100 |               </xsd:sequence>
101 |               <xsd:attribute name="name" type="xsd:string" use="required" />
102 |             </xsd:complexType>
103 |           </xsd:element>
104 |         </xsd:choice>
105 |       </xsd:complexType>
106 |     </xsd:element>
107 |   </xsd:schema>
108 |   <resheader name="resmimetype">
109 |     <value>text/microsoft-resx</value>
110 |   </resheader>
111 |   <resheader name="version">
112 |     <value>2.0</value>
113 |   </resheader>
114 |   <resheader name="reader">
115 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 |   <resheader name="writer">
118 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
119 |   </resheader>
120 |   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
121 |   <data name="icon" type="System.Resources.ResXFileRef, System.Windows.Forms">
122 |     <value>..\Resources\icon.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
123 |   </data>
124 | </root>


--------------------------------------------------------------------------------
/flac-player-sdl/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <SDL.h>
  2 | #include <math.h>
  3 | #include <FLAC/stream_decoder.h>
  4 | #include <pthread.h>
  5 | 
  6 | #undef main
  7 | #define SDL_main main
  8 | 
  9 | void feed_audio_stream(void *userdata, uint8_t *stream, int length);
 10 | 
 11 | void cleanup_event_queue() {
 12 |   static SDL_Event e;
 13 |   while (SDL_PollEvent(&e)) {
 14 |     ;
 15 |   }
 16 | }
 17 | 
 18 | struct pcm_buffer_node {
 19 |   size_t sample_count;
 20 |   int32_t **buffer;
 21 |   struct pcm_buffer_node *next;
 22 | };
 23 | 
 24 | struct audio_session {
 25 |   uint32_t sample_offset;
 26 |   uint32_t channels;
 27 |   struct pcm_buffer_node *head;
 28 |   struct pcm_buffer_node *current;
 29 | };
 30 | 
 31 | struct decode_session {
 32 |   uint32_t freq;
 33 |   uint32_t channels;
 34 |   struct pcm_buffer_node *head;
 35 |   struct pcm_buffer_node *tail;
 36 |   struct audio_session *playback_session;
 37 | };
 38 | 
 39 | void init_sdl_audio(int channels, int freq, struct audio_session **audio_session) {
 40 |   *audio_session = (struct audio_session *) malloc(sizeof(struct audio_session));
 41 |   (*audio_session)->sample_offset = 0;
 42 |   (*audio_session)->channels = channels;
 43 | 
 44 |   SDL_AudioSpec wanted_spec = {
 45 |     .freq = freq,
 46 |     .format = AUDIO_S16LSB,
 47 |     .channels = channels,
 48 |     .callback = feed_audio_stream,
 49 |     .userdata = *audio_session,
 50 |   };
 51 | 
 52 |   if (SDL_OpenAudio(&wanted_spec, NULL) < 0) {
 53 |     puts(SDL_GetError());
 54 |   }
 55 | }
 56 | 
 57 | void start_sdl_audio_playback(struct decode_session *decode_session) {
 58 |   printf("playback started!\n");
 59 |   SDL_PauseAudio(0);
 60 | }
 61 | 
 62 | void feed_audio_stream(void *userdata, uint8_t *stream, int length) {
 63 |   int i = 0, channel;
 64 |   struct audio_session *session = (struct audio_session *) userdata;
 65 | 
 66 |   int16_t *real_stream = (int16_t *)stream;
 67 |   int real_length = length * sizeof(uint8_t) / sizeof(int16_t) / session->channels;
 68 | 
 69 |   memset(stream, 0x00, length);
 70 | 
 71 |   for (i = 0; i != real_length; i++) {
 72 |     for (channel = 0; channel != session->channels; channel++) {
 73 |       if (session->sample_offset >= session->current->sample_count) {
 74 |         session->sample_offset = 0;
 75 |         if (session->current->next) {
 76 |           session->current = session->current->next;
 77 |         } else {
 78 |           return;
 79 |         }
 80 |       }
 81 |       real_stream[i * session->channels + channel] = session->current->buffer[channel][session->sample_offset] 
 82 | >> 8;
 83 |     }
 84 |     session->sample_offset ++;
 85 |   }
 86 | }
 87 | 
 88 | FLAC__StreamDecoderWriteStatus write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame,
 89 |                                               const FLAC__int32 * const buffer[], void *client_data) {
 90 |   struct decode_session *session = (struct decode_session *) client_data;
 91 |   struct pcm_buffer_node *node = (struct pcm_buffer_node *) malloc(sizeof(struct pcm_buffer_node));
 92 |   int i;
 93 | 
 94 |   printf("."); fflush(stdout);
 95 |   memset(node, 0, sizeof(struct pcm_buffer_node));
 96 |   node->buffer = (int32_t **) malloc(frame->header.channels * sizeof(int32_t *));
 97 |   node->sample_count = frame->header.blocksize;
 98 |   node->next = NULL;
 99 | 
100 |   // each channel require buffer for their pcm data.
101 |   for (i = 0; i != frame->header.channels; i++) {
102 |     node->buffer[i] = (int32_t *) malloc(frame->header.blocksize * sizeof(int32_t));
103 |     memcpy(node->buffer[i], buffer[i], frame->header.blocksize * sizeof(int32_t));
104 |   }
105 | 
106 |   if (session->head == NULL) {
107 |     // first frame, begin playback
108 |     session->head = node;
109 |     session->tail = node;
110 | 
111 |     session->playback_session->head = node;
112 |     session->playback_session->current = node;
113 |     start_sdl_audio_playback(session);
114 |   } else {
115 |     session->tail->next = node;
116 |     session->tail = node;
117 |   }
118 | 
119 |   return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
120 | }
121 | 
122 | void metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void 
123 | *client_data) {
124 |   struct decode_session *session = (struct decode_session *) client_data;
125 | 	/* print some stats */
126 | 	if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
127 | 		/* save for later */
128 | 		uint64_t total_samples = metadata->data.stream_info.total_samples;
129 | 		uint32_t sample_rate = metadata->data.stream_info.sample_rate;
130 | 		uint32_t channels = metadata->data.stream_info.channels;
131 | 		uint32_t bps = metadata->data.stream_info.bits_per_sample;
132 | 
133 |     session->channels = channels;
134 |     session->freq = sample_rate;
135 | 
136 |     init_sdl_audio(channels, sample_rate, &(session->playback_session));
137 | 
138 | 		fprintf(stderr, "sample rate    : %u Hz\n", sample_rate);
139 | 		fprintf(stderr, "channels       : %u\n", channels);
140 | 		fprintf(stderr, "bits per sample: %u\n", bps);
141 | 		fprintf(stderr, "total samples  : %" PRIu64 "\n", total_samples);
142 | 	}
143 | }
144 | 
145 | void error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void 
146 | *client_data) {
147 | 	fprintf(stderr, "Got error callback: %s\n", FLAC__StreamDecoderErrorStatusString[status]);
148 | }
149 | 
150 | struct decode_session *init_flac(const char *filename) {
151 |   FLAC__StreamDecoder *decoder = 0;
152 |   FLAC__StreamDecoderInitStatus init_status;
153 |   struct decode_session *decode_session = (struct decode_session *) malloc(sizeof(struct decode_session));
154 |   memset(decode_session, 0, sizeof(struct decode_session));
155 | 
156 |   decoder = FLAC__stream_decoder_new();
157 |   FLAC__stream_decoder_set_md5_checking(decoder, true);
158 | 	init_status = FLAC__stream_decoder_init_file(decoder, filename, write_callback, metadata_callback, 
159 | error_callback, decode_session);
160 | 
161 |   FLAC__stream_decoder_process_until_end_of_stream(decoder);
162 | 
163 |   return decode_session;
164 | }
165 | 
166 | void flac_decoder_thread_entry(void *userdata) {
167 |   struct decode_session **p_decode_session = (struct decode_session **)userdata;
168 | 
169 |   *p_decode_session = init_flac("/home/kasora/01. Der Zigeunerbaron Einzugsmarsch 2.flac");
170 | }
171 | 
172 | int SDL_main() {
173 |   SDL_Init(SDL_INIT_EVERYTHING);
174 | 
175 |   SDL_Surface *screen = SDL_SetVideoMode(500, 500, 32, SDL_SWSURFACE);
176 |   SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 128));
177 |   SDL_Flip(screen);
178 | 
179 |   struct decode_session *decode_session;
180 |   pthread_t decode_thread;
181 |   pthread_create(&decode_thread, NULL, flac_decoder_thread_entry, (void *) &decode_session);
182 | 
183 |   SDL_Event e;
184 |   for (;;) {
185 |     SDL_PollEvent(&e);
186 |     if (e.type == SDL_QUIT) {
187 |       break;
188 |     }
189 | 
190 |     cleanup_event_queue();
191 |     SDL_Delay(30);
192 |   }
193 | 
194 |   SDL_Quit();
195 |   return 0;
196 | }


--------------------------------------------------------------------------------
/music-read-trans/src/entry.js:
--------------------------------------------------------------------------------
  1 | import Vex from 'vexflow';
  2 | 
  3 | const VF = Vex.Flow;
  4 | 
  5 | const div = document.querySelector('div#app');
  6 | const renderer = new VF.Renderer(div, VF.Renderer.Backends.SVG);
  7 | const button = document.querySelector('button');
  8 | const result = document.querySelector('pre');
  9 | 
 10 | document.querySelector('input').value = '';
 11 | 
 12 | renderer.resize(500, 300);
 13 | 
 14 | const availableKeys = [
 15 |   'c/3',
 16 |   'd/3',
 17 |   'e/3',
 18 |   'f/3',
 19 |   'g/3',
 20 |   'a/3',
 21 |   'b/3',
 22 |   'c/4',
 23 |   'd/4',
 24 |   'e/4',
 25 |   'f/4',
 26 |   'g/4',
 27 |   'a/4',
 28 |   'b/4',
 29 |   'c/5',
 30 |   'd/5',
 31 |   'e/5',
 32 |   'f/5',
 33 |   'g/5',
 34 | ];
 35 | 
 36 | function getRandKey() {
 37 |   const ret = availableKeys[Math.floor(Math.random() * availableKeys.length)];
 38 |   return ret;
 39 | }
 40 | 
 41 | // And get a drawing context:
 42 | const context = renderer.getContext();
 43 | 
 44 | let notesTreble = [
 45 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 46 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 47 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 48 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 49 |   new Vex.Flow.BarNote(),
 50 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 51 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 52 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 53 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 54 |   new Vex.Flow.BarNote(),
 55 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 56 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 57 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 58 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 59 |   new Vex.Flow.BarNote(),
 60 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 61 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 62 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 63 |   new VF.StaveNote({ clef: "treble", keys: [getRandKey()], duration: "q" }),
 64 |   new Vex.Flow.BarNote(),
 65 | ];
 66 | 
 67 | let notesBass = [
 68 |   undefined,
 69 |   undefined,
 70 |   undefined,
 71 |   undefined,
 72 |   new Vex.Flow.BarNote(),
 73 |   undefined,
 74 |   undefined,
 75 |   undefined,
 76 |   undefined,
 77 |   new Vex.Flow.BarNote(),
 78 |   undefined,
 79 |   undefined,
 80 |   undefined,
 81 |   undefined,
 82 |   new Vex.Flow.BarNote(),
 83 |   undefined,
 84 |   undefined,
 85 |   undefined,
 86 |   undefined,
 87 |   new Vex.Flow.BarNote(),
 88 | ];
 89 | 
 90 | let answers = notesTreble.map(el => {
 91 |   if (!el.keys) {
 92 |     return null;
 93 |   }
 94 |   const map = {
 95 |     c: 'do',
 96 |     d: 're',
 97 |     e: 'mi',
 98 |     f: 'fa',
 99 |     g: 'so',
100 |     a: 'la',
101 |     b: 'xi',
102 |   }
103 |   return map[el.keys[0][0]];
104 | }).filter(el => el);
105 | 
106 | console.log(answers)
107 | 
108 | for (let i = 0; i < notesTreble.length; i++) {
109 |   if (i % 5 == 4) {
110 |     continue;
111 |   }
112 | 
113 |   const key = notesTreble[i].keys[0];
114 | 
115 |   if (key[2] == '3') {
116 |     notesBass[i] = new VF.StaveNote({ clef: "bass", keys: [key], duration: "q" }),
117 |     notesTreble[i] = undefined;
118 |   }
119 | }
120 | 
121 | for (let i = 0; i < 4; i++) {
122 |   for (let j = 0; j < 4;) {
123 |     if (notesTreble[i * 5 + j] === undefined) {
124 |       let length = 0;
125 | 
126 |       do {
127 |         length++;
128 |       } while (notesTreble[i * 5 + j + length] === undefined);
129 | 
130 |       switch (length) {
131 |         case 1: notesTreble[i * 5 + j] = new VF.StaveNote({ clef: "treble", keys: ['g/4'], duration: "qr" }); break;
132 |         case 2: notesTreble[i * 5 + j] = new VF.StaveNote({ clef: "treble", keys: ['g/4'], duration: "hr" }); break;
133 |         case 3: notesTreble[i * 5 + j] = new VF.StaveNote({ clef: "treble", keys: ['g/4'], duration: "hdr" }).addDot(0); break;
134 |         case 4: notesTreble[i * 5 + j] = new VF.StaveNote({ clef: "treble", keys: ['g/4'], duration: "1r" }); break;
135 |       }
136 | 
137 |       j += length;
138 |     } else {
139 |       j++;
140 |     }
141 |   }
142 | 
143 |   for (let j = 0; j < 4;) {
144 |     if (notesBass[i * 5 + j] === undefined) {
145 |       let length = 0;
146 | 
147 |       do {
148 |         length++;
149 |       } while (notesBass[i * 5 + j + length] === undefined);
150 | 
151 |       switch (length) {
152 |         case 1: notesBass[i * 5 + j] = new VF.StaveNote({ clef: "bass", keys: ['f/3'], duration: "qr" }); break;
153 |         case 2: notesBass[i * 5 + j] = new VF.StaveNote({ clef: "bass", keys: ['f/3'], duration: "hr" }); break;
154 |         case 3: notesBass[i * 5 + j] = new VF.StaveNote({ clef: "bass", keys: ['f/3'], duration: "hdr" }).addDot(0); break;
155 |         case 4: notesBass[i * 5 + j] = new VF.StaveNote({ clef: "bass", keys: ['f/3'], duration: "1r" }); break;
156 |       }
157 | 
158 |       j += length;
159 |     } else {
160 |       j++;
161 |     }
162 |   }
163 | }
164 | 
165 | notesTreble = notesTreble.filter(el => el);
166 | notesBass = notesBass.filter(el => el);
167 | 
168 | console.log({
169 |   notesUp: notesTreble,
170 |   notesDo: notesBass
171 | });
172 | 
173 | const staffTreble = new VF.Stave(30, 40, 600);
174 | staffTreble.addClef("treble").addTimeSignature("4/4");
175 | staffTreble.setContext(context).draw();
176 | 
177 | const voiceTreble = new VF.Voice({ num_beats: 16, beat_value: 4 });
178 | voiceTreble.addTickables(notesTreble);
179 | 
180 | const staffBass = new VF.Stave(30, 140, 600);
181 | staffBass.addClef("bass").addTimeSignature("4/4");
182 | staffBass.setContext(context).draw();
183 | 
184 | const voiceBass = new VF.Voice({ num_beats: 16, beat_value: 4 });
185 | voiceBass.addTickables(notesBass);
186 | 
187 | const startX = Math.max(staffTreble.getNoteStartX(), staffBass.getNoteStartX());
188 | staffTreble.setNoteStartX(startX);
189 | staffBass.setNoteStartX(startX);
190 | 
191 | const formatter = new Vex.Flow.Formatter();
192 | formatter.joinVoices([voiceTreble, voiceBass]);
193 | formatter.format([voiceTreble, voiceBass]);
194 | 
195 | new VF.StaveConnector(staffTreble, staffBass).setType(VF.StaveConnector.type.BRACE).setContext(context).draw();
196 | 
197 | new VF.StaveConnector(staffTreble, staffBass).setType(VF.StaveConnector.type.SINGLE_LEFT).setContext(context).draw();
198 | 
199 | new VF.StaveConnector(staffTreble, staffBass).setType(VF.StaveConnector.type.SINGLE_RIGHT).setContext(context).draw();
200 | 
201 | voiceTreble.draw(context, staffTreble);
202 | voiceBass.draw(context, staffBass);
203 | 
204 | button.addEventListener('click', () => {
205 |   result.innerHTML = `标准答案：${answers.join(' ')}\n你的答案：${document.querySelector('input').value}`;
206 | });


--------------------------------------------------------------------------------
/simple-sshd/server.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <string>
  3 | #include <cstdint>
  4 | #include <cstdlib>
  5 | #include <cstring>
  6 | #include <functional>
  7 | #include <unistd.h>
  8 | 
  9 | #include <libssh/libssh.h>
 10 | #include <libssh/server.h>
 11 | 
 12 | #define KEYS_FOLDER "/home/ntzyz/Document/playground/simple-sshd/ssh/"
 13 | 
 14 | using namespace std;
 15 | 
 16 | class Server {
 17 | private:
 18 |     ssh_session session;
 19 |     ssh_bind sshbind;
 20 |     ssh_message message;
 21 |     ssh_channel chan = 0;
 22 |     string port;
 23 |     string addr;
 24 |     void setup() {
 25 |         sshbind = ssh_bind_new();
 26 |         session = ssh_new();
 27 | 
 28 |         ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_DSAKEY, KEYS_FOLDER "ssh_host_dsa_key");
 29 |         ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_RSAKEY, KEYS_FOLDER "ssh_host_rsa_key");
 30 |         ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_BINDADDR, addr.c_str());
 31 |         ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_BINDPORT_STR, port.c_str());
 32 |     }
 33 | 
 34 | public: 
 35 |     function<bool (string, string&)> handler;
 36 |     string PS1 = "[NSH]$ ";
 37 | 
 38 |     Server(string _addr, string _port) {
 39 |         addr = _addr;
 40 |         port = _port;
 41 |         setup();
 42 |     };
 43 |     
 44 |     Server(const char *_addr, const char * _port) {
 45 |         addr = string(_addr);
 46 |         port = string(_port);
 47 |         setup();
 48 |     };
 49 | 
 50 |     bool listen() {
 51 |         if (ssh_bind_listen(sshbind) < 0) {
 52 |             cerr << "Bind error: " << ssh_get_error(sshbind) << endl;
 53 |             return false;
 54 |         }
 55 |         
 56 |         cout << "Server started on " << addr << ":" << port << endl;
 57 | 
 58 |         for (;;) {
 59 |             if (ssh_bind_accept(sshbind, session) == SSH_ERROR) {
 60 |                 cerr << "Accept error: " << ssh_get_error(sshbind) << endl;
 61 |                 continue;
 62 |             }
 63 | 
 64 |             pid_t pid = fork();
 65 |             if (pid == 0) {
 66 |                 cout << "Starting child process ..." << endl;
 67 |                 process();
 68 |                 cout << "Stoping child process ..." << endl;
 69 |                 exit(0);
 70 |             }
 71 |         }
 72 |     }
 73 | 
 74 |     bool login() {
 75 |         if (ssh_handle_key_exchange(session)) {
 76 |             cerr << "ssh_handle_key_exchange: " << ssh_get_error(session) << endl;
 77 |             return false;
 78 |         }
 79 | 
 80 |         for(int count = 0; count != 3; count++) {
 81 |             message = ssh_message_get(session);
 82 |             if (!message)
 83 |                 break;
 84 |             if (ssh_message_type(message) != SSH_REQUEST_AUTH) {
 85 |                 ssh_message_reply_default(message);
 86 |             }
 87 |             else if (ssh_message_subtype(message) == SSH_AUTH_METHOD_PASSWORD) {
 88 |                 cout << "User " << ssh_message_auth_user(message) << " wants to auth with pass " << ssh_message_auth_password(message) << endl;
 89 |                 // Just let it pass ...
 90 |                 ssh_message_auth_reply_success(message, 0);
 91 |                 return true;
 92 |             }
 93 |             else {
 94 |                 ssh_message_auth_set_methods(message, SSH_AUTH_METHOD_PASSWORD);
 95 |                 ssh_message_reply_default(message);
 96 |             }
 97 |             ssh_message_free(message);
 98 |         }
 99 |         return false;
100 |     }
101 | 
102 |     void process() {
103 |         int i;
104 |         const size_t buff_size = 16384;
105 |         char buf[buff_size];
106 |         memset(buf, 0, buff_size);
107 | 
108 |         if (!login()) {
109 |             cout << "Remote side login failed." << endl;
110 |             ssh_disconnect(session);
111 |             ssh_finalize();
112 |             goto quit;
113 |         }
114 |         if (!getChannel()) {
115 |             cout << "getChannel failed." << endl;
116 |             ssh_disconnect(session);
117 |             ssh_finalize();
118 |             goto quit;
119 |         }
120 |         if (!getShell()) {
121 |             cout << "getShell failed." << endl;
122 |             ssh_disconnect(session);
123 |             ssh_finalize();
124 |             goto quit;
125 |         }
126 | 
127 |         do {
128 |             ssh_channel_write(chan, PS1.c_str(), PS1.length());
129 | 
130 |             i = ssh_channel_read(chan, buf, 2048, 0);
131 |             buf[strlen(buf) - 1] = '\0';
132 |             string request = buf, response;
133 |             bool eof = handler(request, response);
134 | 
135 |             ssh_channel_write(chan, response.c_str(), response.length());
136 |             ssh_channel_write(chan, "\n", 1);
137 |             if (eof)
138 |                 break;
139 |         } while (i > 0);
140 | 
141 |     quit:
142 |         if (chan)
143 |             ssh_channel_close(chan);
144 |         if (session)
145 |             ssh_disconnect(session);
146 |         ssh_finalize();
147 |     }
148 | 
149 |     bool getShell() {
150 |         for (int count = 0; count != 3; count++) {
151 |             message = ssh_message_get(session);
152 |             if (message == NULL) {
153 |                 return false;
154 |             }
155 |             else if(ssh_message_type(message) == SSH_REQUEST_CHANNEL && ssh_message_subtype(message) == SSH_CHANNEL_REQUEST_SHELL) {
156 |                 ssh_message_channel_request_reply_success(message);
157 |                 ssh_message_free(message);
158 |                 return true;
159 |             }
160 |             else {
161 |                 ssh_message_reply_default(message);
162 |                 ssh_message_free(message);
163 |             }
164 |         }
165 |         return false;
166 |     }
167 | 
168 |     bool getChannel() {
169 |         for (int count = 0; count != 3; count++) {
170 |             message = ssh_message_get(session);
171 |             if(message) {
172 |                 if (ssh_message_type(message) == SSH_REQUEST_CHANNEL_OPEN && ssh_message_subtype(message) == SSH_CHANNEL_SESSION) {
173 |                     chan = ssh_message_channel_request_open_reply_accept(message);
174 |                     return true;
175 |                 }
176 |                 else {
177 |                     ssh_message_reply_default(message);
178 |                 }
179 |                 ssh_message_free(message);
180 |             }
181 |         }
182 |         return false;
183 |     }
184 | };
185 | 
186 | int main() {
187 |     Server server("0.0.0.0", "2022");
188 | 
189 |     server.handler = [](string request, string& response) {
190 |         if (request == string("ping")) {
191 |             response = string("Pong!");
192 |         }
193 |         else if (request == string("exit")) {
194 |             response = string("exiting...");
195 |             return true;
196 |         }
197 |         else {
198 |             response = "ECHO: ";
199 |             response += request;
200 |         }
201 |         return false;
202 |     };
203 | 
204 |     return server.listen();
205 | }
206 | 


--------------------------------------------------------------------------------
/wav-decode/main.js:
--------------------------------------------------------------------------------
  1 | (function() {
  2 |   'use strict';
  3 |   let start = document.querySelector('button[start]');
  4 |   let stop = document.querySelector('button[stop]');
  5 |   let frameSpan = document.querySelector('div[frame]');
  6 |   let status = document.querySelector('span[status]');
  7 |   let canvas = document.querySelector('canvas');
  8 |   let select = document.querySelector('select[song]');
  9 |   let glCtx = canvas.getContext('2d');
 10 | 
 11 |   function $get(url) {
 12 |     return new Promise((resolve, reject) => {
 13 |       let xhr = new XMLHttpRequest();
 14 |       xhr.open('GET', url);
 15 |       xhr.responseType = 'arraybuffer';
 16 |       xhr.addEventListener('progress', (e) => {
 17 |         status.innerText = `Loading media ${(100 * e.loaded / e.total).toFixed(3)}% ...`;
 18 |       });
 19 |       xhr.onreadystatechange = () => {
 20 |         switch(xhr.readyState) {
 21 |         case xhr.DONE:
 22 |           resolve(xhr.response)
 23 |           break;
 24 |         default:
 25 |           break;
 26 |         }
 27 |       };
 28 |       xhr.send();
 29 |     });
 30 |   }
 31 | 
 32 |   class Wav {
 33 |     constructor(file) {
 34 |       let rawFile = file;
 35 |       file = new Uint8Array(rawFile);
 36 | 
 37 |       // Reference for RIFF chunk and FMT chunk
 38 |       let RIFF = {
 39 |         RIFF:           { begin:    0, length:    4, type: 'CHAR'},
 40 |         ChunkSize:      { begin:    4, length:    4, type: 'INTEGER'},
 41 |         WAVE:           { begin:    8, length:    4, type: 'CHAR'},
 42 |       }
 43 |       let FMT = {
 44 |         fmt:            { begin:   12, length:    4, type: 'CHAR'},
 45 |         Subchunk1Size:  { begin:   16, length:    2, type: 'INTEGER'},
 46 |         AudioFormat:    { begin:   20, length:    2, type: 'INTEGER'},
 47 |         NumOfChan:      { begin:   22, length:    2, type: 'INTEGER'},
 48 |         SamplesPerSec:  { begin:   24, length:    4, type: 'INTEGER'},
 49 |         bytesPerSec:    { begin:   28, length:    4, type: 'INTEGER'},
 50 |         blockAlign:     { begin:   32, length:    2, type: 'INTEGER'},
 51 |         bitsPerSample:  { begin:   34, length:    2, type: 'INTEGER'},
 52 |       }
 53 |       
 54 |       file.subArray = (begin, length) => {
 55 |         return file.slice(begin, begin + length);
 56 |       };
 57 | 
 58 |       let readChar = (begin, length) => Array
 59 |         .from(file
 60 |           .subArray(begin, length))
 61 |         .map(ch => String.fromCharCode(ch))
 62 |         .join('');
 63 | 
 64 |       let readInt = (begin, length) => Array
 65 |         .from(file
 66 |           .subArray(begin, length))
 67 |         .reverse()
 68 |         .reduce((a, b) => a * 256 + b);
 69 | 
 70 |       let readChunk = (ref, save) => {
 71 |         for (let item in ref) {
 72 |           switch(ref[item].type) {
 73 |             case 'CHAR':
 74 |               save[item] = readChar(ref[item].begin, ref[item].length);
 75 |               break;
 76 |             case 'INTEGER':
 77 |               save[item] = readInt(ref[item].begin, ref[item].length);
 78 |               break;
 79 |           }
 80 |         }
 81 |       }
 82 | 
 83 |       // Read the RIFF chunk
 84 |       readChunk(RIFF, this);
 85 | 
 86 |       // Keep reading data until finding the 'data' chunk
 87 |       for (let offset = 12;;) {
 88 |         let chunkName = readChar(offset, 4); offset += 4;
 89 |         let chunkSize = readInt(offset, 4); offset += 4;
 90 |         this[chunkName] = {};
 91 |         this[chunkName].size = chunkSize;
 92 |         if (chunkName === 'fmt ') {
 93 |           // Read the RIFF chunk
 94 |           readChunk(FMT, this[chunkName]);
 95 |         }
 96 |         else {
 97 |           if (chunkName == 'data') {
 98 |             let type = `Int${this['fmt '].bitsPerSample}Array`;
 99 |             this[chunkName] = new window[type](rawFile.slice(offset, chunkSize))
100 |             break;
101 |           }
102 |           // Read as raw
103 |           this[chunkName]._rawData = file.subArray(offset, chunkSize);
104 |         }
105 |         offset += chunkSize;
106 |       }
107 |     }
108 | 
109 |     prepare() {
110 |       let ctx, framesCount;
111 | 
112 |       try {
113 |           ctx = this.ctx = new (window.AudioContext || window.webkitAudioContext)();
114 |           framesCount = this.framesCount = wav.ChunkSize / (wav['fmt '].bitsPerSample / 8);
115 |       } catch (ex) {
116 |           alert('browser do not support AudioContext API');
117 |           return
118 |       }
119 | 
120 |       let audioBuffer = this.audioBuffer = ctx.createBuffer(
121 |         wav['fmt '].NumOfChan, 
122 |         framesCount / 2, 
123 |         wav['fmt '].SamplesPerSec
124 |       );
125 | 
126 |       this.source = ctx.createBufferSource();
127 |       this.source.loop = false;
128 |       this.source.connect(ctx.destination);
129 |       this.source.buffer = this.audioBuffer;
130 | 
131 |       let last500frames = this.last500frames = new Array(500).fill(0);
132 |       this.sampleingInterval = 16;
133 |     }
134 | 
135 |     *step() {
136 |       let ctx = this.ctx;
137 |       let channelBuffering = [];
138 |       for (let i = 0; i < wav['fmt '].NumOfChan; ++i) {
139 |         channelBuffering[i] = this.audioBuffer.getChannelData(i);
140 |       }
141 | 
142 |       for (let currentFrame = 0; currentFrame < this.framesCount; ++currentFrame) {
143 |         channelBuffering[currentFrame % 2][Math.ceil(currentFrame / 2)]
144 |           = Number(wav.data[currentFrame]) / (1 << (wav['fmt '].bitsPerSample - 1));
145 | 
146 |         if (currentFrame % (this.sampleingInterval * 2) === 1) {
147 |           this.last500frames.shift();
148 |           this.last500frames.push((channelBuffering[1][Math.ceil(currentFrame / 2)] + channelBuffering[0][Math.ceil(currentFrame / 2)]) / 2);
149 |         }
150 | 
151 |         if (!this.started) {
152 |           setTimeout(() => {this.source.start()}, 10);
153 |           this.started = true;
154 |         }
155 | 
156 |         yield currentFrame;
157 |       }
158 |     }
159 |   }
160 | 
161 |   function main() {
162 |     $get(select.value).then((file) => {
163 |       status.innerText = 'Loading media ... ';
164 |       start.style.display = 'none';
165 |       window.wav = new Wav(file);
166 |       status.innerText = 'Playing ... ';
167 |       wav.prepare();
168 |       let begin = new Date();
169 |       let iterator = wav.step();
170 |       window.intervalId = setInterval(() => {
171 |         let diff = new Date().getTime() - begin.getTime();
172 |         let last;
173 |         for (;;) {
174 |           last = iterator.next().value;
175 |           if (typeof last === 'undefined') {
176 |             clearInterval(window.intervalId);
177 |             start.style.display = '';
178 |             status.innerText = 'Ready ... ';
179 |             console.info('end');
180 |             break;
181 |           }
182 |           diff = new Date().getTime() - begin.getTime() + 10;
183 |           if (last / wav['fmt '].SamplesPerSec / wav['fmt '].NumOfChan > diff / 1000) break;
184 |         }
185 |         frameSpan.innerText 
186 |           = `Current Frame Index: ${last}\n` 
187 |           + `Time Offset(Frame): ${last / wav['fmt '].SamplesPerSec / wav['fmt '].NumOfChan}\n`
188 |           + `Time Offset(Clock): ${diff / 1000}\n`
189 |           + `Buffered / Played: ${last / ((new Date().getTime() - begin.getTime()) / 1000 * wav['fmt '].SamplesPerSec * wav['fmt '].NumOfChan)}`;
190 |         // Draw the visualizer.
191 |         let width = canvas.width;
192 |         let height = canvas.height;
193 |         glCtx.clearRect(0, 0, width, height);
194 |         glCtx.beginPath();
195 |         glCtx.moveTo(0, canvas.height / 2);
196 |         for (let i = 0; i < 500; ++i) {
197 |           glCtx.lineTo(i * canvas.width / 500, canvas.height / 2 * (wav.last500frames[i] + 1) );
198 |         }
199 |         glCtx.stroke();
200 |       }, 10);
201 |     });
202 |   }
203 | 
204 |   start.onclick = main;
205 | })()
206 | 


--------------------------------------------------------------------------------
/Daemon/Daemon/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | using System.Threading.Tasks;
  6 | using System.Windows;
  7 | using System.Windows.Controls;
  8 | using System.Windows.Data;
  9 | using System.Windows.Documents;
 10 | using System.Windows.Input;
 11 | using System.Windows.Media;
 12 | using System.Windows.Media.Imaging;
 13 | using System.Windows.Navigation;
 14 | using System.Windows.Shapes;
 15 | using System.Diagnostics;
 16 | using System.Threading;
 17 | using System.Windows.Forms;
 18 | using System.IO;
 19 | 
 20 | namespace Daemon
 21 | {
 22 |     /// <summary>
 23 |     /// Interaction logic for MainWindow.xaml
 24 |     /// </summary>
 25 |     public partial class MainWindow : Window
 26 |     {
 27 |         private bool isJavaRunning = false;
 28 |         Process javaProcess = null;
 29 |         Thread javaProcessOutputHandler = null;
 30 |         private NotifyIcon icon;
 31 | 
 32 |         public MainWindow()
 33 |         {
 34 |             InitializeComponent();
 35 |             addIcon();
 36 | 
 37 |             try
 38 |             {
 39 |                 using (StreamReader sr = new StreamReader("config.txt"))
 40 |                 {
 41 |                     while (!sr.EndOfStream)
 42 |                     {
 43 |                         string line = sr.ReadLine();
 44 |                         int spliter = line.IndexOf('=');
 45 |                         if (spliter >= 0)
 46 |                         {
 47 |                             string key = line.Substring(0, spliter);
 48 |                             string value = line.Substring(spliter + 1);
 49 |                             switch (key)
 50 |                             {
 51 |                                 case "nginxCommand":
 52 |                                     nginxCommand.Text = value;
 53 |                                     break;
 54 |                                 case "nginxArguments":
 55 |                                     nginxArguments.Text = value;
 56 |                                     break;
 57 |                                 case "javaCommand":
 58 |                                     javaCommand.Text = value;
 59 |                                     break;
 60 |                                 case "javaArguments":
 61 |                                     javaArguments.Text = value;
 62 |                                     break;
 63 |                             }
 64 |                         }
 65 |                     }
 66 |                 }
 67 |             }
 68 |             catch (Exception e) { }
 69 |         }
 70 | 
 71 |         private void alert(string message)
 72 |         {
 73 |             icon.BalloonTipText = message;
 74 |             icon.BalloonTipIcon = ToolTipIcon.Info;
 75 |             icon.BalloonTipTitle = "Alert!";
 76 |             icon.ShowBalloonTip(500);
 77 |         }
 78 | 
 79 |         private void addIcon()
 80 |         {
 81 |             icon = new NotifyIcon();
 82 |             icon.Text = "守护进程（大雾）";
 83 |             icon.Icon = Properties.Resources.icon;
 84 |             icon.Visible = true;
 85 |             icon.ContextMenu = new System.Windows.Forms.ContextMenu();
 86 |             icon.ContextMenu.MenuItems.Add("重启 Nginx", (s, e) => {
 87 |                 runNginx();
 88 |             });
 89 |             icon.ContextMenu.MenuItems.Add("重启 Java", (s, e) => {
 90 |                 if (isJavaRunning)
 91 |                 {
 92 |                     abortJava();
 93 |                 }
 94 |                 runJava();
 95 |             });
 96 |             icon.MouseDoubleClick += new System.Windows.Forms.MouseEventHandler((s, e) => {
 97 |                 this.Show();
 98 |                 this.Focus();
 99 |                 this.WindowState = WindowState.Normal;
100 |             });
101 |         }
102 | 
103 |         private void runNginx()
104 |         {
105 |             var process = new Process();
106 |             process.StartInfo.FileName = nginxCommand.Text;
107 |             process.StartInfo.Arguments = nginxArguments.Text;
108 |             process.StartInfo.RedirectStandardOutput = true;
109 |             process.StartInfo.UseShellExecute = false;
110 |             process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
111 |             process.StartInfo.CreateNoWindow = true;
112 |             process.Start();
113 |             process.WaitForExit();
114 |             alert("Nginx 命令已执行");
115 |         }
116 | 
117 |         private void runJava()
118 |         {
119 |             // Start the process
120 |             javaProcess = new Process();
121 |             javaProcess.StartInfo.FileName = javaCommand.Text;
122 |             javaProcess.StartInfo.Arguments = javaArguments.Text;
123 |             javaProcess.StartInfo.RedirectStandardOutput = true;
124 |             javaProcess.StartInfo.UseShellExecute = false;
125 |             javaProcess.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
126 |             javaProcess.StartInfo.CreateNoWindow = true;
127 |             javaProcess.Start();
128 |             javaStdout.Text += "Process started.\r\n";
129 |             btnJava.Content = "重启";
130 |             btnJavaAbort.IsEnabled = true;
131 | 
132 |             // Change the running flag
133 |             isJavaRunning = true;
134 | 
135 |             javaProcessOutputHandler = new Thread(javaStdoutHandler);
136 |             javaProcessOutputHandler.Start();
137 |             alert("Java 已启动");
138 |         }
139 | 
140 |         private void abortJava()
141 |         {
142 |             // Already running, abort them.
143 |             javaProcessOutputHandler.Abort();
144 |             javaProcessOutputHandler = null;
145 |             if (!javaProcess.HasExited)
146 |                 javaProcess.Kill();
147 |             javaProcess = null;
148 | 
149 |             javaStdout.Text += "Process aborted.\r\n";
150 |             isJavaRunning = false;
151 |             btnJava.Content = "运行";
152 |             btnJavaAbort.IsEnabled = false;
153 |         }
154 | 
155 |         private void btnJava_Click(object sender, RoutedEventArgs e)
156 |         {
157 |             if (isJavaRunning)
158 |             {
159 |                 abortJava();
160 |             }
161 |             runJava();
162 |         }
163 | 
164 |         private void javaStdoutHandler()
165 |         {
166 |             while (!javaProcess.StandardOutput.EndOfStream)
167 |             {
168 |                 string line = javaProcess.StandardOutput.ReadLine();
169 |                 Dispatcher.Invoke(() => {
170 |                     javaStdout.Text += line + "\r\n";
171 |                     javaStdout.ScrollToEnd();
172 |                 });
173 |             }
174 |         }
175 | 
176 |         private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
177 |         {
178 |             if (isJavaRunning)
179 |             {
180 |                 abortJava();
181 |             }
182 |             icon.Dispose();
183 |             using (StreamWriter sw = new StreamWriter("config.txt"))
184 |             {
185 |                 sw.WriteLine("nginxCommand=" + nginxCommand.Text);
186 |                 sw.WriteLine("nginxArguments=" + nginxArguments.Text);
187 |                 sw.WriteLine("javaCommand=" + javaCommand.Text);
188 |                 sw.WriteLine("javaArguments=" + javaArguments.Text);
189 |             }
190 |         }
191 | 
192 |         private void btnJavaAbort_Click(object sender, RoutedEventArgs e)
193 |         {
194 |             if (isJavaRunning)
195 |             {
196 |                 abortJava();
197 |             }
198 |         }
199 | 
200 |         private void btnJavaLogClear_Click(object sender, RoutedEventArgs e)
201 |         {
202 |             javaStdout.Text = "";
203 |         }
204 | 
205 |         private void btnNginx_Click(object sender, RoutedEventArgs e)
206 |         {
207 |             runNginx();
208 |         }
209 | 
210 |         private void Window_StateChanged(object sender, EventArgs e)
211 |         {
212 |             if (this.WindowState == WindowState.Minimized)
213 |             {
214 |                 this.Hide();
215 |             }
216 |         }
217 |     }
218 | }
219 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <algorithm>
  2 | #include <cctype>
  3 | #include <cstdbool>
  4 | #include <cstdio>
  5 | #include <cstdlib>
  6 | #include <cstring>
  7 | #include <ctime>
  8 | 
  9 | #include <iostream>
 10 | #include <map>
 11 | #include <memory>
 12 | #include <sstream>
 13 | #include <string>
 14 | #include <vector>
 15 | #include <fstream>
 16 | #include <functional>
 17 | 
 18 | #include <arpa/inet.h>
 19 | #include <errno.h>
 20 | #include <sys/ioctl.h>
 21 | #include <sys/poll.h>
 22 | #include <sys/socket.h>
 23 | #include <sys/types.h>
 24 | #include <sys/stat.h>
 25 | #include <sys/utsname.h>
 26 | #include <unistd.h>
 27 | #include <getopt.h>
 28 | #include <signal.h>
 29 | 
 30 | #include "http.hpp"
 31 | #include "ws.hpp"
 32 | #include "frontend.hpp"
 33 | 
 34 | int create_server(uint16_t port, bool localhost = true) {
 35 |   int server_fd = 0;
 36 |   struct sockaddr_in server;
 37 | 
 38 |   if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 39 |     perror("socket");
 40 |     exit(1);
 41 |   }
 42 | 
 43 |   server.sin_family = AF_INET;
 44 |   server.sin_port = htons(port);
 45 |   server.sin_addr.s_addr = htonl(localhost ? INADDR_LOOPBACK : INADDR_ANY);
 46 | 
 47 |   int opt_val = 1;
 48 |   setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt_val, sizeof opt_val);
 49 |   if (bind(server_fd, reinterpret_cast<struct sockaddr *>(&server),
 50 |            sizeof(server)) < 0) {
 51 |     perror("bind");
 52 |     exit(1);
 53 |   }
 54 | 
 55 |   opt_val = 1;
 56 |   if (ioctl(server_fd, FIONBIO, (char *)&opt_val) < 0) {
 57 |     perror("ioctl");
 58 |     exit(1);
 59 |   }
 60 | 
 61 |   if (listen(server_fd, SOMAXCONN) < 0) {
 62 |     perror("listen");
 63 |     exit(1);
 64 |   }
 65 | 
 66 |   printf("[INFO] Server startted on %s:%d\n", localhost ? "127.0.0.1" : "0.0.0.0", port);
 67 |   return server_fd;
 68 | }
 69 | 
 70 | int main(int argc, char *argv[]) {
 71 |   const int POOL_TIMEOUT = 10;
 72 |   const int MAX_FDS = 512;
 73 |   int server_fd;
 74 |   int nfds;
 75 |   struct pollfd fds[MAX_FDS];
 76 |   std::map<int, std::shared_ptr<websocket_context_t>> sessions;
 77 |   std::map<int, std::shared_ptr<websocket_context_t>> pty_sessions;
 78 |   int bind_port = 2333;
 79 |   int opt;
 80 |   bool enable_builtin_webpages = false;
 81 |   bool allow_remote = false;
 82 | 
 83 |   while ((opt = getopt(argc, argv, "p:w::r::")) != -1) {
 84 |     switch (opt) {
 85 |     case 'p':
 86 |       bind_port = atoi(optarg);
 87 |       break;
 88 |     case 'w':
 89 |       enable_builtin_webpages = true;
 90 |       break;
 91 |     case 'r':
 92 |       allow_remote = true;
 93 |       break;
 94 |     default: /* '?' */
 95 |       fprintf(stderr, "Usage: %s [-p port] [-w] [-r]\n", argv[0]);
 96 |       exit(EXIT_FAILURE);
 97 |     }
 98 |   }
 99 | 
100 |   server_fd = create_server(bind_port, !allow_remote);
101 |   nfds = 1;
102 | 
103 |   memset(fds, 0, sizeof(fds));
104 |   fds[0].fd = server_fd;
105 |   fds[0].events = POLLIN;
106 | 
107 |   for (;;) {
108 |     int poll_result = poll(fds, nfds, POOL_TIMEOUT);
109 | 
110 |     if (poll_result < 0) {
111 |       perror("poll");
112 |       exit(1);
113 |     }
114 | 
115 |     if (poll_result == 0) {
116 |       continue;
117 |     }
118 | 
119 |     int current_fds_size = nfds;
120 |     bool shrink_fds_required = false;
121 | 
122 |     for (int i = 0; i != current_fds_size; i++) {
123 |       if (fds[i].revents == 0) {
124 |         continue;
125 |       }
126 | 
127 |       if (fds[i].revents != POLLIN && fds[i].revents != POLLHUP && errno != EWOULDBLOCK) {
128 |         perror("received poll event is unexpected.");
129 |         exit(1);
130 |       }
131 | 
132 |       if (fds[i].fd == server_fd) {
133 |         // New connection comming. accept it.
134 |         int client_fd = accept(server_fd, NULL, NULL);
135 | 
136 |         if (client_fd < 0 && errno != EWOULDBLOCK) {
137 |           perror("accept");
138 |         }
139 | 
140 |         int opt_val = 1;
141 |         if (ioctl(client_fd, FIONBIO, (char *)&opt_val) < 0) {
142 |           perror("ioctl");
143 |           exit(1);
144 |         }
145 | 
146 |         fds[nfds].fd = client_fd;
147 |         fds[nfds].events = POLLIN;
148 |         nfds++;
149 | 
150 |         // add it to sessions
151 |         auto session = std::make_shared<websocket_context_t>();
152 |         session->enable_builtin_webpages = enable_builtin_webpages;
153 |         session->client_fd = client_fd;
154 |         session->stage = websocket_connection_stage_t::handshaking;
155 | 
156 |         sessions[client_fd] = session;
157 |         session->regist_pty_session = [&fds, &nfds, &pty_sessions, session]() {
158 |           fds[nfds].fd = session->pty.master_fd;
159 |           fds[nfds].events = POLLIN;
160 |           nfds++;
161 |           pty_sessions[session->pty.master_fd] = session;
162 |         };
163 | 
164 |         printf("new connection accepted, current nfds = %d\n", nfds);
165 |       } else if (sessions.find(fds[i].fd) != sessions.end() && fds[i].revents == POLLIN) {
166 |         // some client send me some data, read and handle it.
167 |         ssize_t buffer_size = 1048576;
168 |         uint8_t buffer[buffer_size];
169 | 
170 |         for (;;) {
171 |           int client_fd = fds[i].fd;
172 |           int read_result = recv(client_fd, buffer, buffer_size, 0);
173 | 
174 |           if (read_result < 0) {
175 |             if (errno != EWOULDBLOCK) {
176 |               perror("recv");
177 |               fds[i].fd = -1;
178 |               shrink_fds_required = true;
179 |             }
180 | 
181 |             break;
182 |           }
183 | 
184 |           auto session = sessions[client_fd];
185 | 
186 |           session->append_buffer(buffer, read_result);
187 |           session->process();
188 | 
189 |           if (session->stage == terminated || session->stage == unknown) {
190 |             // erase it from websocket sessions
191 |             fds[i].fd = -1;
192 |             sessions.erase(sessions.find(client_fd));
193 | 
194 |             // also erase it from pty sessions
195 |             if (pty_sessions.find(session->pty.master_fd) != pty_sessions.end()) {
196 |               pty_sessions.erase(pty_sessions.find(session->pty.master_fd));
197 |             }
198 | 
199 |             for (ssize_t j = 0; j != nfds; j++) {
200 |               if (fds[j].fd == session->pty.master_fd) {
201 |                 fds[j].fd = -1;
202 |               }
203 |             }
204 | 
205 |             shrink_fds_required = true;
206 |             break;
207 |           }
208 |         }
209 |       } else if (pty_sessions.find(fds[i].fd) != pty_sessions.end()) {
210 |         auto session = pty_sessions[fds[i].fd];
211 |         ssize_t buffer_size = 1024;
212 |         uint8_t buffer[buffer_size];
213 | 
214 |         if (fds[i].revents == POLLHUP) {
215 |           // erase it from pty sessions
216 |           pty_sessions.erase(pty_sessions.find(fds[i].fd));
217 |           fds[i].fd = -1;
218 | 
219 |           // also erase it from ws sessions
220 |           sessions.erase(sessions.find(session->client_fd));
221 |           close(session->client_fd);
222 | 
223 |           for (ssize_t j = 0; j != nfds; j++) {
224 |             if (fds[j].fd == session->client_fd) {
225 |               fds[j].fd = -1;
226 |             }
227 |           }
228 | 
229 |           shrink_fds_required = true;
230 |           break;
231 |         } else for (;;) {
232 |           int pty_master_fd = fds[i].fd;
233 |           int read_result = read(pty_master_fd, buffer, buffer_size);
234 | 
235 |           if (read_result < 0) {
236 |             if (errno != EWOULDBLOCK) {
237 |               perror("read");
238 |               fds[i].fd = -1;
239 |               shrink_fds_required = true;
240 |             }
241 | 
242 |             break;
243 |           }
244 | 
245 |           websocket_frame_t response_frame;
246 |           response_frame.payload = std::vector<uint8_t>(buffer, buffer + read_result);
247 | 
248 |           size_t response_frame_size = 0;
249 |           auto response_data = response_frame.to_raw_frame(&response_frame_size);
250 | 
251 |           if (send(session->client_fd, response_data.get(), response_frame_size, MSG_NOSIGNAL) < 0) {
252 |             // erase it from websocket sessions
253 |             sessions.erase(sessions.find(session->client_fd));
254 | 
255 |             // also erase it from pty sessions
256 |             if (pty_sessions.find(session->pty.master_fd) != pty_sessions.end()) {
257 |               pty_sessions.erase(pty_sessions.find(session->pty.master_fd));
258 |             }
259 | 
260 |             for (ssize_t j = 0; j != nfds; j++) {
261 |               if (fds[j].fd == session->pty.master_fd || fds[j].fd == session->client_fd) {
262 |                 fds[j].fd = -1;
263 |               }
264 |             }
265 | 
266 |             shrink_fds_required = true;
267 |             break;
268 |           }
269 |         }
270 |       }
271 |     }
272 | 
273 |     if (shrink_fds_required) {
274 |       shrink_fds_required = false;
275 | 
276 |       for (int i = 0; i != nfds; i++) {
277 |         if (fds[i].fd == -1) {
278 |           for (int j = i; j < nfds - 1; j++) {
279 |             fds[j] = fds[j + 1];
280 |           }
281 | 
282 |           i--, nfds--;
283 |           printf("one fd closed, current nfds = %d\n", nfds);
284 |         }
285 |       }
286 |     }
287 |   }
288 | }
289 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/sha1.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |     sha1.cpp - source code of
  3 | 
  4 |     ============
  5 |     SHA-1 in C++
  6 |     ============
  7 | 
  8 |     100% Public Domain.
  9 | 
 10 |     Original C Code
 11 |         -- Steve Reid <steve@edmweb.com>
 12 |     Small changes to fit into bglibs
 13 |         -- Bruce Guenter <bruce@untroubled.org>
 14 |     Translation to simpler C++ Code
 15 |         -- Volker Diels-Grabsch <v@njh.eu>
 16 |     Safety fixes
 17 |         -- Eugene Hopkinson <slowriot at voxelstorm dot com>
 18 | */
 19 | 
 20 | #include "sha1.hpp"
 21 | #include <sstream>
 22 | #include <iomanip>
 23 | #include <fstream>
 24 | 
 25 | 
 26 | static const size_t BLOCK_INTS = 16;  /* number of 32bit integers per SHA1 block */
 27 | static const size_t BLOCK_BYTES = BLOCK_INTS * 4;
 28 | 
 29 | 
 30 | static void reset(uint32_t digest[], std::string &buffer, uint64_t &transforms)
 31 | {
 32 |     /* SHA1 initialization constants */
 33 |     digest[0] = 0x67452301;
 34 |     digest[1] = 0xefcdab89;
 35 |     digest[2] = 0x98badcfe;
 36 |     digest[3] = 0x10325476;
 37 |     digest[4] = 0xc3d2e1f0;
 38 | 
 39 |     /* Reset counters */
 40 |     buffer = "";
 41 |     transforms = 0;
 42 | }
 43 | 
 44 | 
 45 | static uint32_t rol(const uint32_t value, const size_t bits)
 46 | {
 47 |     return (value << bits) | (value >> (32 - bits));
 48 | }
 49 | 
 50 | 
 51 | static uint32_t blk(const uint32_t block[BLOCK_INTS], const size_t i)
 52 | {
 53 |     return rol(block[(i+13)&15] ^ block[(i+8)&15] ^ block[(i+2)&15] ^ block[i], 1);
 54 | }
 55 | 
 56 | 
 57 | /*
 58 |  * (R0+R1), R2, R3, R4 are the different operations used in SHA1
 59 |  */
 60 | 
 61 | static void R0(const uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i)
 62 | {
 63 |     z += ((w&(x^y))^y) + block[i] + 0x5a827999 + rol(v, 5);
 64 |     w = rol(w, 30);
 65 | }
 66 | 
 67 | 
 68 | static void R1(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i)
 69 | {
 70 |     block[i] = blk(block, i);
 71 |     z += ((w&(x^y))^y) + block[i] + 0x5a827999 + rol(v, 5);
 72 |     w = rol(w, 30);
 73 | }
 74 | 
 75 | 
 76 | static void R2(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i)
 77 | {
 78 |     block[i] = blk(block, i);
 79 |     z += (w^x^y) + block[i] + 0x6ed9eba1 + rol(v, 5);
 80 |     w = rol(w, 30);
 81 | }
 82 | 
 83 | 
 84 | static void R3(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i)
 85 | {
 86 |     block[i] = blk(block, i);
 87 |     z += (((w|x)&y)|(w&x)) + block[i] + 0x8f1bbcdc + rol(v, 5);
 88 |     w = rol(w, 30);
 89 | }
 90 | 
 91 | 
 92 | static void R4(uint32_t block[BLOCK_INTS], const uint32_t v, uint32_t &w, const uint32_t x, const uint32_t y, uint32_t &z, const size_t i)
 93 | {
 94 |     block[i] = blk(block, i);
 95 |     z += (w^x^y) + block[i] + 0xca62c1d6 + rol(v, 5);
 96 |     w = rol(w, 30);
 97 | }
 98 | 
 99 | 
100 | /*
101 |  * Hash a single 512-bit block. This is the core of the algorithm.
102 |  */
103 | 
104 | static void transform(uint32_t digest[], uint32_t block[BLOCK_INTS], uint64_t &transforms)
105 | {
106 |     /* Copy digest[] to working vars */
107 |     uint32_t a = digest[0];
108 |     uint32_t b = digest[1];
109 |     uint32_t c = digest[2];
110 |     uint32_t d = digest[3];
111 |     uint32_t e = digest[4];
112 | 
113 |     /* 4 rounds of 20 operations each. Loop unrolled. */
114 |     R0(block, a, b, c, d, e,  0);
115 |     R0(block, e, a, b, c, d,  1);
116 |     R0(block, d, e, a, b, c,  2);
117 |     R0(block, c, d, e, a, b,  3);
118 |     R0(block, b, c, d, e, a,  4);
119 |     R0(block, a, b, c, d, e,  5);
120 |     R0(block, e, a, b, c, d,  6);
121 |     R0(block, d, e, a, b, c,  7);
122 |     R0(block, c, d, e, a, b,  8);
123 |     R0(block, b, c, d, e, a,  9);
124 |     R0(block, a, b, c, d, e, 10);
125 |     R0(block, e, a, b, c, d, 11);
126 |     R0(block, d, e, a, b, c, 12);
127 |     R0(block, c, d, e, a, b, 13);
128 |     R0(block, b, c, d, e, a, 14);
129 |     R0(block, a, b, c, d, e, 15);
130 |     R1(block, e, a, b, c, d,  0);
131 |     R1(block, d, e, a, b, c,  1);
132 |     R1(block, c, d, e, a, b,  2);
133 |     R1(block, b, c, d, e, a,  3);
134 |     R2(block, a, b, c, d, e,  4);
135 |     R2(block, e, a, b, c, d,  5);
136 |     R2(block, d, e, a, b, c,  6);
137 |     R2(block, c, d, e, a, b,  7);
138 |     R2(block, b, c, d, e, a,  8);
139 |     R2(block, a, b, c, d, e,  9);
140 |     R2(block, e, a, b, c, d, 10);
141 |     R2(block, d, e, a, b, c, 11);
142 |     R2(block, c, d, e, a, b, 12);
143 |     R2(block, b, c, d, e, a, 13);
144 |     R2(block, a, b, c, d, e, 14);
145 |     R2(block, e, a, b, c, d, 15);
146 |     R2(block, d, e, a, b, c,  0);
147 |     R2(block, c, d, e, a, b,  1);
148 |     R2(block, b, c, d, e, a,  2);
149 |     R2(block, a, b, c, d, e,  3);
150 |     R2(block, e, a, b, c, d,  4);
151 |     R2(block, d, e, a, b, c,  5);
152 |     R2(block, c, d, e, a, b,  6);
153 |     R2(block, b, c, d, e, a,  7);
154 |     R3(block, a, b, c, d, e,  8);
155 |     R3(block, e, a, b, c, d,  9);
156 |     R3(block, d, e, a, b, c, 10);
157 |     R3(block, c, d, e, a, b, 11);
158 |     R3(block, b, c, d, e, a, 12);
159 |     R3(block, a, b, c, d, e, 13);
160 |     R3(block, e, a, b, c, d, 14);
161 |     R3(block, d, e, a, b, c, 15);
162 |     R3(block, c, d, e, a, b,  0);
163 |     R3(block, b, c, d, e, a,  1);
164 |     R3(block, a, b, c, d, e,  2);
165 |     R3(block, e, a, b, c, d,  3);
166 |     R3(block, d, e, a, b, c,  4);
167 |     R3(block, c, d, e, a, b,  5);
168 |     R3(block, b, c, d, e, a,  6);
169 |     R3(block, a, b, c, d, e,  7);
170 |     R3(block, e, a, b, c, d,  8);
171 |     R3(block, d, e, a, b, c,  9);
172 |     R3(block, c, d, e, a, b, 10);
173 |     R3(block, b, c, d, e, a, 11);
174 |     R4(block, a, b, c, d, e, 12);
175 |     R4(block, e, a, b, c, d, 13);
176 |     R4(block, d, e, a, b, c, 14);
177 |     R4(block, c, d, e, a, b, 15);
178 |     R4(block, b, c, d, e, a,  0);
179 |     R4(block, a, b, c, d, e,  1);
180 |     R4(block, e, a, b, c, d,  2);
181 |     R4(block, d, e, a, b, c,  3);
182 |     R4(block, c, d, e, a, b,  4);
183 |     R4(block, b, c, d, e, a,  5);
184 |     R4(block, a, b, c, d, e,  6);
185 |     R4(block, e, a, b, c, d,  7);
186 |     R4(block, d, e, a, b, c,  8);
187 |     R4(block, c, d, e, a, b,  9);
188 |     R4(block, b, c, d, e, a, 10);
189 |     R4(block, a, b, c, d, e, 11);
190 |     R4(block, e, a, b, c, d, 12);
191 |     R4(block, d, e, a, b, c, 13);
192 |     R4(block, c, d, e, a, b, 14);
193 |     R4(block, b, c, d, e, a, 15);
194 | 
195 |     /* Add the working vars back into digest[] */
196 |     digest[0] += a;
197 |     digest[1] += b;
198 |     digest[2] += c;
199 |     digest[3] += d;
200 |     digest[4] += e;
201 | 
202 |     /* Count the number of transformations */
203 |     transforms++;
204 | }
205 | 
206 | 
207 | static void buffer_to_block(const std::string &buffer, uint32_t block[BLOCK_INTS])
208 | {
209 |     /* Convert the std::string (byte buffer) to a uint32_t array (MSB) */
210 |     for (size_t i = 0; i < BLOCK_INTS; i++)
211 |     {
212 |         block[i] = (buffer[4*i+3] & 0xff)
213 |                    | (buffer[4*i+2] & 0xff)<<8
214 |                    | (buffer[4*i+1] & 0xff)<<16
215 |                    | (buffer[4*i+0] & 0xff)<<24;
216 |     }
217 | }
218 | 
219 | 
220 | SHA1::SHA1()
221 | {
222 |     reset(digest, buffer, transforms);
223 | }
224 | 
225 | 
226 | void SHA1::update(const std::string &s)
227 | {
228 |     std::istringstream is(s);
229 |     update(is);
230 | }
231 | 
232 | 
233 | void SHA1::update(std::istream &is)
234 | {
235 |     while (true)
236 |     {
237 |         char sbuf[BLOCK_BYTES];
238 |         is.read(sbuf, BLOCK_BYTES - buffer.size());
239 |         buffer.append(sbuf, (std::size_t)is.gcount());
240 |         if (buffer.size() != BLOCK_BYTES)
241 |         {
242 |             return;
243 |         }
244 |         uint32_t block[BLOCK_INTS];
245 |         buffer_to_block(buffer, block);
246 |         transform(digest, block, transforms);
247 |         buffer.clear();
248 |     }
249 | }
250 | 
251 | 
252 | /*
253 |  * Add padding and return the message digest.
254 |  */
255 | 
256 | std::string SHA1::final()
257 | {
258 |     /* Total number of hashed bits */
259 |     uint64_t total_bits = (transforms*BLOCK_BYTES + buffer.size()) * 8;
260 | 
261 |     /* Padding */
262 |     buffer += (char)0x80;
263 |     size_t orig_size = buffer.size();
264 |     while (buffer.size() < BLOCK_BYTES)
265 |     {
266 |         buffer += (char)0x00;
267 |     }
268 | 
269 |     uint32_t block[BLOCK_INTS];
270 |     buffer_to_block(buffer, block);
271 | 
272 |     if (orig_size > BLOCK_BYTES - 8)
273 |     {
274 |         transform(digest, block, transforms);
275 |         for (size_t i = 0; i < BLOCK_INTS - 2; i++)
276 |         {
277 |             block[i] = 0;
278 |         }
279 |     }
280 | 
281 |     /* Append total_bits, split this uint64_t into two uint32_t */
282 |     block[BLOCK_INTS - 1] = (uint32_t)total_bits;
283 |     block[BLOCK_INTS - 2] = (uint32_t)(total_bits >> 32);
284 |     transform(digest, block, transforms);
285 | 
286 |     /* Hex std::string */
287 |     std::ostringstream result;
288 |     for (size_t i = 0; i < sizeof(digest) / sizeof(digest[0]); i++)
289 |     {
290 |         result << std::hex << std::setfill('0') << std::setw(8);
291 |         result << digest[i];
292 |     }
293 | 
294 |     /* Reset for next run */
295 |     reset(digest, buffer, transforms);
296 | 
297 |     return result.str();
298 | }
299 | 
300 | 
301 | std::string SHA1::from_file(const std::string &filename)
302 | {
303 |     std::ifstream stream(filename.c_str(), std::ios::binary);
304 |     SHA1 checksum;
305 |     checksum.update(stream);
306 |     return checksum.final();
307 | }
308 | 


--------------------------------------------------------------------------------
/websocket-terminal-cpp-server/ws.cpp:
--------------------------------------------------------------------------------
  1 | #include "ws.hpp"
  2 | 
  3 | static inline uint32_t mask_gen() {
  4 |   static uint32_t mask = 0xdeadbeef;
  5 |   return mask ++;
  6 | }
  7 | 
  8 | websocket_frame_t::websocket_frame_t(std::unique_ptr<uint8_t[]> buffer, size_t buffer_size) {
  9 |   size_t offset = 0;
 10 | 
 11 |   fin = (buffer[offset] >> 7) & 0x01;
 12 |   opcode = static_cast<opcode_t>(buffer[offset] & 0x1F);
 13 | 
 14 |   offset ++;
 15 | 
 16 |   mask = buffer[offset] >> 7;
 17 |   uint64_t payload_len = static_cast<uint64_t>(buffer[offset] & 0x7f);
 18 | 
 19 |   if (payload_len == 126) {
 20 |     payload_len = static_cast<uint64_t>(buffer[offset + 1] << 8) |
 21 |                   static_cast<uint64_t>(buffer[offset + 2]);
 22 |     offset += 2;
 23 |   }
 24 | 
 25 |   if (payload_len == 127) {
 26 |     payload_len = (static_cast<uint64_t>(buffer[offset + 1]) << 56) |
 27 |                   (static_cast<uint64_t>(buffer[offset + 2]) << 48) |
 28 |                   (static_cast<uint64_t>(buffer[offset + 3]) << 40) |
 29 |                   (static_cast<uint64_t>(buffer[offset + 4]) << 32) |
 30 |                   (static_cast<uint64_t>(buffer[offset + 5]) << 24) |
 31 |                   (static_cast<uint64_t>(buffer[offset + 6]) << 16) |
 32 |                   (static_cast<uint64_t>(buffer[offset + 7]) << 8) |
 33 |                   static_cast<uint64_t>(buffer[offset + 8]);
 34 |     offset += 8;
 35 |   }
 36 | 
 37 |   offset ++;
 38 | 
 39 |   if (mask) {
 40 |     for (size_t i = 0; i != 4; i++) {
 41 |       mask_key[i] = buffer[offset + i];
 42 |     }
 43 | 
 44 |     offset += 4;
 45 |   }
 46 | 
 47 |   payload = std::vector<uint8_t>(buffer.get() + offset, buffer.get() + offset + payload_len);
 48 | 
 49 |   if (mask) {
 50 |     for (size_t i = 0; i != payload.size(); i++) {
 51 |       payload[i] ^= mask_key[i % 4];
 52 |     }
 53 |   }
 54 | 
 55 |   if (debug) {
 56 |     print_frame_info();
 57 |   }
 58 | }
 59 | 
 60 | websocket_frame_t::websocket_frame_t() {
 61 |   fin = true;
 62 |   opcode = opcode_t::TEXT_FRAME;
 63 |   mask = true;
 64 |   uint32_t raw_mask = mask_gen();
 65 | 
 66 |   mask_key[0] = raw_mask & 0xff000000;
 67 |   mask_key[1] = raw_mask & 0x00ff0000;
 68 |   mask_key[2] = raw_mask & 0x0000ff00;
 69 |   mask_key[3] = raw_mask & 0x000000ff;
 70 | }
 71 | 
 72 | void websocket_frame_t::print_frame_info() {
 73 |   printf("FIN:\t\t%s\n", fin ? "true" : "false");
 74 | 
 75 |   switch (opcode) {
 76 |   case CONTINUATION_FRAME:
 77 |     puts("OPCODE:\t\tCONTINUATION_FRAME");
 78 |     break;
 79 |   case TEXT_FRAME:
 80 |     puts("OPCODE:\t\tTEXT_FRAME");
 81 |     break;
 82 |   case BINARY_FRAME:
 83 |     puts("OPCODE:\t\tBINARY_FRAME");
 84 |     break;
 85 |   case CONNECTION_CLOSE_FRAME:
 86 |     puts("OPCODE:\t\tCONNECTION_CLOSE_FRAME");
 87 |     break;
 88 |   case PING_FRAME:
 89 |     puts("OPCODE:\t\tPING_FRAME");
 90 |     break;
 91 |   case PONG_FRAME:
 92 |     puts("OPCODE:\t\tPONG_FRAME");
 93 |     break;
 94 |   }
 95 | 
 96 |   printf("MASK:\t\t%s\n", mask ? "true" : "false");
 97 |   if (mask) {
 98 |     printf("  MASK_KEY:\t%02X%02X%02X%02X\n", mask_key[0], mask_key[1], mask_key[2], mask_key[3]);
 99 |   }
100 | 
101 |   printf("PAYLOAD_LEN:\t%ld\n", payload.size());
102 |   printf("PAYLOAD:\n");
103 | 
104 |   for (size_t i = 0; i != payload.size(); i++) {
105 |     printf("%02X ", payload[i]);
106 | 
107 |     if (i != 0 && i % 8 == 0) {
108 |       if (i % 16 == 0) {
109 |         putchar('\n');
110 |         continue;
111 |       }
112 |       putchar(' ');
113 |     }
114 |   }
115 | 
116 |   puts("\n");
117 | }
118 | 
119 | std::unique_ptr<uint8_t[]> websocket_frame_t::to_raw_frame(size_t *frame_size) {
120 |   ssize_t expected_frame_size = 0;
121 |   
122 |   // 假设现在 payload 的长度为 0，则在有 mask 的情况下，报文头部的长度应该是固定的，是：
123 |   // (FIN, RSV1 2 3, OPCODE)  => 1 byte
124 |   // (MASK, PAYLOAD)          => 1 byte
125 |   // (MASK KEY)               => 4 bytes
126 |   // (PAYLOAD)                => 0 byte
127 |   // 的和，也就是 5 byte
128 |   expected_frame_size = 6;
129 | 
130 |   if (126 <= payload.size() && payload.size() <= 65535) {
131 |     // 该情况下，(MASK, PAYLOAD) 后续跟了一个 uint16_t 表示真正的载荷大小，因此预期的头部长度多了 2byte
132 |     expected_frame_size += 2;
133 |   }
134 |   if (payload.size() > 65535) {
135 |     // 类似上面，但是是 uint64_t
136 |     expected_frame_size += 8;
137 |   }
138 | 
139 |   if (!mask) {
140 |     expected_frame_size -= 4;
141 |   }
142 | 
143 |   // 然后再算上载荷的大小，就是预期的帧大小了
144 |   expected_frame_size += payload.size();
145 |   
146 |   size_t offset = 0;
147 |   auto raw_frame = std::make_unique<uint8_t[]>(expected_frame_size);
148 |   std::fill(raw_frame.get(), raw_frame.get() + expected_frame_size, 0);
149 |   *frame_size = expected_frame_size;
150 | 
151 |   // FIN, RSV1, RSV2, RSV3, OPCODE
152 |   if (fin) {
153 |     raw_frame[offset] |= 0b10000000;
154 |   }
155 |   raw_frame[offset] |= opcode;
156 | 
157 |   offset ++;
158 | 
159 |   // MASK
160 |   if (mask) {
161 |     raw_frame[offset] |= 0b10000000;
162 |   }
163 | 
164 |   // PAYLOAD_LENGTH
165 |   if (payload.size() < 126) {
166 |     raw_frame[offset] |= payload.size();
167 |     offset += 1;
168 |   } if (126 <= payload.size() && payload.size() <= 65535) {
169 |     raw_frame[offset] |= 126;
170 |     raw_frame[offset + 1] = (payload.size() >> 8);
171 |     raw_frame[offset + 2] = payload.size() & 0xff;
172 |     offset += 3;
173 |   } if (payload.size() > 65535) {
174 |     raw_frame[offset] |= 127;
175 |     raw_frame[offset + 1] = (payload.size() >> 56) & 0xff;
176 |     raw_frame[offset + 2] = (payload.size() >> 48) & 0xff;
177 |     raw_frame[offset + 3] = (payload.size() >> 40) & 0xff;
178 |     raw_frame[offset + 4] = (payload.size() >> 32) & 0xff;
179 |     raw_frame[offset + 5] = (payload.size() >> 24) & 0xff;
180 |     raw_frame[offset + 6] = (payload.size() >> 16) & 0xff;
181 |     raw_frame[offset + 7] = (payload.size() >> 8) & 0xff;
182 |     raw_frame[offset + 8] = payload.size() & 0xff;
183 |     offset += 9;
184 |   }
185 | 
186 |   // MASKING KEY
187 |   if (mask) {
188 |     raw_frame[offset] = mask_key[0];
189 |     raw_frame[offset + 1] = mask_key[1];
190 |     raw_frame[offset + 2] = mask_key[2];
191 |     raw_frame[offset + 3] = mask_key[3];
192 |     offset += 4;
193 |   }
194 | 
195 |   // PAYLOAD
196 |   for (size_t i = 0; i != payload.size(); i++) {
197 |     raw_frame[offset + i] = payload[i];
198 |     
199 |     if (mask) {
200 |       raw_frame[offset + i] ^= mask_key[i % 4];
201 |     }
202 |   }
203 | 
204 |   return raw_frame;
205 | }
206 | 
207 | void websocket_context_t::append_buffer(uint8_t *buffer, ssize_t buffer_size) {
208 |   if (buffer_size <= 0) {
209 |     printf("session terminating\n");
210 |     stage = websocket_connection_stage_t::terminated;
211 |     return;
212 |   }
213 | 
214 |   if (received_buffer == nullptr) {
215 |     received_buffer_capacity = 1024;
216 |     received_buffer_used = 0;
217 |     received_buffer = new uint8_t[received_buffer_capacity];
218 |   }
219 | 
220 |   if (buffer_size + received_buffer_used > received_buffer_capacity) {
221 |     ssize_t new_buffer_capacity = received_buffer_capacity * 2;
222 |     uint8_t *new_buffer = new uint8_t[new_buffer_capacity];
223 | 
224 |     std::copy(received_buffer, received_buffer + received_buffer_used,
225 |               new_buffer);
226 | 
227 |     delete[] received_buffer;
228 |     received_buffer = new_buffer;
229 |     received_buffer_capacity = new_buffer_capacity;
230 |   }
231 | 
232 |   auto append_buffer_begin = received_buffer + received_buffer_used;
233 |   std::copy(buffer, buffer + buffer_size, append_buffer_begin);
234 | 
235 |   received_buffer_used += buffer_size;
236 | }
237 | 
238 | void websocket_context_t::process() {
239 |   if (this->stage == websocket_connection_stage_t::handshaking) {
240 |     this->process_handshake();
241 |     return;
242 |   }
243 | 
244 |   if (this->stage == websocket_connection_stage_t::terminated) {
245 |     return;
246 |   }
247 | 
248 |   this->process_data();
249 | }
250 | 
251 | void websocket_context_t::process_handshake() {
252 |   if (received_buffer[received_buffer_used - 4] == '\r' &&
253 |       received_buffer[received_buffer_used - 3] == '\n' &&
254 |       received_buffer[received_buffer_used - 2] == '\r' &&
255 |       received_buffer[received_buffer_used - 1] == '\n') {
256 |     http_request_t request(received_buffer, received_buffer_used);
257 | 
258 |     const auto ws_sec_key_header_it =
259 |         request.headers.find("sec-websocket-key");
260 |     const bool is_websocket = ws_sec_key_header_it != request.headers.end() &&
261 |                               (ws_sec_key_header_it->second).size() == 1;
262 | 
263 |     http_response_t response(is_websocket ? 101 : 200);
264 | 
265 |     if (is_websocket) {
266 |       if (regist_pty_session) {
267 |         pty.spawn();
268 |         regist_pty_session();
269 |         regist_pty_session = std::function<void(void)>{};
270 |       }
271 | 
272 |       const auto key = (ws_sec_key_header_it->second)[0];
273 | 
274 |       printf("Sec-WebSocket-Key sent from client is %s\n", key.c_str());
275 | 
276 |       SHA1 websocket_sec_hash;
277 | 
278 |       websocket_sec_hash.update(
279 |           (key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").c_str());
280 | 
281 |       const auto hash = websocket_sec_hash.final();
282 |       uint8_t hash_binary[20];
283 | 
284 |       for (size_t i = 0; i != hash.size(); i += 2) {
285 |         char temp[] = {
286 |             hash[i],
287 |             hash[i + 1],
288 |             '\0',
289 |         };
290 | 
291 |         sscanf(temp, "%02hhX", hash_binary + i / 2);
292 |       }
293 | 
294 |       std::string hash_base64 =
295 |           base64::encode(std::vector<uint8_t>(hash_binary, hash_binary + 20));
296 | 
297 |       response.headers["Sec-WebSocket-Accept"] =
298 |           std::vector<std::string>({hash_base64});
299 |     } else {
300 |       if (request.request_path == "/" && enable_builtin_webpages) {
301 |         std::string file_content(frontend_html, frontend_html + frontend_html_len);
302 | 
303 |         response.headers["content-type"] =
304 |             std::vector<std::string>({"text/html; charset=utf-8"});
305 |         response.headers["content-length"] = std::vector<std::string>({std::to_string(file_content.size())});
306 |         response.body = file_content;
307 |       } else {
308 |         response.headers["content-length"] = std::vector<std::string>({"0"});
309 |         response.headers["content-type"] =
310 |             std::vector<std::string>({"text/plain; charset=utf-8"});
311 |         response.status_code = 404;
312 |         response.status_text = "Not Found";
313 |       }
314 |     }
315 | 
316 |     const auto str = response.to_response();
317 |     send(client_fd, str.c_str(), str.size(), 0);
318 | 
319 |     if (is_websocket) {
320 |       stage = established;
321 |       received_buffer_used = 0;
322 |     } else {
323 |       stage = terminated;
324 |       close(client_fd);
325 |     }
326 |   }
327 | }
328 | 
329 | ssize_t websocket_context_t::next_valid_ws_frame_size() {
330 |   ssize_t expected_buffer_size = 2;
331 |   size_t cursor = 1;
332 | 
333 |   if (received_buffer_used < expected_buffer_size) {
334 |     return -1;
335 |   }
336 | 
337 |   uint8_t mask = received_buffer[cursor] >> 7;
338 |   uint64_t payload_len =
339 |       static_cast<uint64_t>(received_buffer[cursor] & 0x7f);
340 | 
341 |   if (payload_len == 126) {
342 |     // two bytes for extended payload length (uint16_t in big endian)
343 |     expected_buffer_size += 2;
344 | 
345 |     if (received_buffer_used < expected_buffer_size) {
346 |       return -1;
347 |     }
348 | 
349 |     payload_len = static_cast<uint64_t>(received_buffer[cursor + 1] << 8) |
350 |                   static_cast<uint64_t>(received_buffer[cursor + 2]);
351 |     cursor += 2;
352 |   }
353 | 
354 |   if (payload_len == 127) {
355 |     // eight bytes for extended payload length (uint64_t in big endian)
356 |     expected_buffer_size += 8;
357 | 
358 |     if (received_buffer_used < expected_buffer_size) {
359 |       return -1;
360 |     }
361 | 
362 |     payload_len = (static_cast<uint64_t>(received_buffer[cursor + 1]) << 56) |
363 |                   (static_cast<uint64_t>(received_buffer[cursor + 2]) << 48) |
364 |                   (static_cast<uint64_t>(received_buffer[cursor + 3]) << 40) |
365 |                   (static_cast<uint64_t>(received_buffer[cursor + 4]) << 32) |
366 |                   (static_cast<uint64_t>(received_buffer[cursor + 5]) << 24) |
367 |                   (static_cast<uint64_t>(received_buffer[cursor + 6]) << 16) |
368 |                   (static_cast<uint64_t>(received_buffer[cursor + 7]) << 8) |
369 |                   static_cast<uint64_t>(received_buffer[cursor + 8]);
370 |     cursor += 8;
371 |   }
372 | 
373 |   if (mask) {
374 |     // four bytes for optional mask key
375 |     expected_buffer_size += 4;
376 | 
377 |     if (received_buffer_used < expected_buffer_size) {
378 |       return -1;
379 |     }
380 | 
381 |     cursor += 4;
382 |   }
383 | 
384 |   expected_buffer_size += payload_len;
385 | 
386 |   if (received_buffer_used < expected_buffer_size) {
387 |     return -1;
388 |   }
389 | 
390 |   return expected_buffer_size;
391 | }
392 | 
393 | void websocket_context_t::process_data() {
394 |   auto frame_size = next_valid_ws_frame_size();
395 |   auto raw_frame = std::make_unique<uint8_t[]>(frame_size);
396 | 
397 |   std::copy(received_buffer, received_buffer + frame_size, raw_frame.get());
398 | 
399 |   for (ssize_t i = frame_size; i != received_buffer_used; i++) {
400 |     received_buffer[i - frame_size] = received_buffer[i];
401 |   }
402 |   
403 |   received_buffer_used -= frame_size;
404 | 
405 |   websocket_frame_t frame(std::move(raw_frame), frame_size);
406 | 
407 |   if (frame.opcode == websocket_frame_t::opcode_t::CONNECTION_CLOSE_FRAME) {
408 |     stage = terminated;
409 |     close(client_fd);
410 |     return;
411 |   }
412 | 
413 |   auto buffer = std::make_unique<uint8_t>(frame.payload.size());
414 |   std::copy(frame.payload.begin(), frame.payload.end(), buffer.get());
415 | 
416 |   write(pty.master_fd, buffer.get(), frame.payload.size());
417 | }
418 | 
419 | websocket_context_t::~websocket_context_t() {
420 |   if (received_buffer != nullptr) {
421 |     delete[] received_buffer;
422 |   }
423 | }


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