├── bin
├── message.js
├── 404.html
├── command.js
├── client.js
└── server.js
├── renovate.json
├── Dockerfile
├── tslint.json
├── package.json
├── .github
└── workflows
│ └── node.js.yml
├── src
├── message.ts
├── command.ts
├── client.ts
└── server.ts
├── .gitignore
├── README.md
├── .vscode
└── launch.json
├── tsconfig.json
└── LICENSE.md
/bin/message.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 |
--------------------------------------------------------------------------------
/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": [
3 | "config:base",
4 | ":automergeAll"
5 | ]
6 | }
7 |
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM alpine:latest
2 | RUN apk add --no-cache nodejs
3 | COPY . hyper-tunnel
4 | RUN npm install --production --global ./hyper-tunnel
--------------------------------------------------------------------------------
/tslint.json:
--------------------------------------------------------------------------------
1 | {
2 | "defaultSeverity": "error",
3 | "extends": [
4 | "tslint:recommended",
5 | "tslint-config-pretti"
6 | ],
7 | "jsRules": {},
8 | "rules": {},
9 | "rulesDirectory": []
10 | }
--------------------------------------------------------------------------------
/bin/404.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | 404 NotFound
8 |
19 |
20 |
21 |
22 |
23 | 404
24 | Not Found
25 |
26 | Sorry, that page doesn’t exist.
27 |
28 |
29 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "hyper-tunnel",
3 | "version": "1.4.4",
4 | "description": "noncloud is HTTPS tunnel over WSS",
5 | "main": "bin/command.js",
6 | "scripts": {
7 | "start": "node bin/command.js server -a $USERNAME:$PASSWORD -p $PORT",
8 | "test:server": "node bin/command.js server -a user:pass -p 4000",
9 | "test:client": "node bin/command.js client -a user:pass -l localhost:8000 -r localhost:4000 -p http:ws:http",
10 | "build": "tsc"
11 | },
12 | "bin": {
13 | "htunnel": "bin/command.js"
14 | },
15 | "author": "TANIGUCHI Masaya",
16 | "license": "GPL",
17 | "dependencies": {
18 | "circular-json": "^0.5.9",
19 | "commander": "^6.1.0",
20 | "ws": "^8.0.0"
21 | },
22 | "devDependencies": {
23 | "@types/circular-json": "0.4.0",
24 | "@types/commander": "2.12.2",
25 | "@types/ws": "8.5.12",
26 | "tslint": "6.1.3",
27 | "tslint-config-prettier": "1.18.0",
28 | "typescript": "5.0.4"
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/.github/workflows/node.js.yml:
--------------------------------------------------------------------------------
1 | # This workflow will do a clean install of node dependencies, cache/restore them, build the source code and run tests across different versions of node
2 | # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
3 |
4 | name: Node.js CI
5 |
6 | on:
7 | push:
8 | branches: [ master ]
9 | pull_request:
10 | branches: [ master ]
11 |
12 | jobs:
13 | build:
14 |
15 | runs-on: ubuntu-latest
16 |
17 | strategy:
18 | matrix:
19 | node-version: [12.x, 14.x, 16.x]
20 | # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
21 |
22 | steps:
23 | - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
24 | - name: Use Node.js ${{ matrix.node-version }}
25 | uses: actions/setup-node@v4
26 | with:
27 | node-version: ${{ matrix.node-version }}
28 | cache: 'npm'
29 | - run: npm ci
30 | - run: npm run build --if-present
31 |
--------------------------------------------------------------------------------
/src/message.ts:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is part of the noncloud.
3 | * Copyright (c) 2018 TANIGUCHI Masaya.
4 | *
5 | * This program is free software: you can redistribute it and/or modify
6 | * it under the terms of the GNU General Public License as published by
7 | * the Free Software Foundation, version 3.
8 | *
9 | * This program is distributed in the hope that it will be useful, but
10 | * WITHOUT ANY WARRANTY; without even the implied warranty of
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 | * General Public License for more details.
13 | *
14 | * You should have received a copy of the GNU General Public License
15 | * along with this program. If not, see .
16 | */
17 | export interface IHeaderMessage {
18 | identifier: string;
19 | type: "header";
20 | payload: T;
21 | }
22 | export interface IDataMessage {
23 | identifier: string;
24 | type: "data";
25 | payload: string;
26 | }
27 | export interface IEndMessage {
28 | identifier: string;
29 | type: "end";
30 | }
31 |
32 | export type Message = IHeaderMessage | IDataMessage | IEndMessage;
33 | export type RawMessage = string;
34 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 |
2 | # Created by https://www.gitignore.io/api/node
3 |
4 | ### Node ###
5 | # Logs
6 | logs
7 | *.log
8 | npm-debug.log*
9 | yarn-debug.log*
10 | yarn-error.log*
11 |
12 | # Runtime data
13 | pids
14 | *.pid
15 | *.seed
16 | *.pid.lock
17 |
18 | # Directory for instrumented libs generated by jscoverage/JSCover
19 | lib-cov
20 |
21 | # Coverage directory used by tools like istanbul
22 | coverage
23 |
24 | # nyc test coverage
25 | .nyc_output
26 |
27 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
28 | .grunt
29 |
30 | # Bower dependency directory (https://bower.io/)
31 | bower_components
32 |
33 | # node-waf configuration
34 | .lock-wscript
35 |
36 | # Compiled binary addons (http://nodejs.org/api/addons.html)
37 | build/Release
38 |
39 | # Dependency directories
40 | node_modules/
41 | jspm_packages/
42 |
43 | # Typescript v1 declaration files
44 | typings/
45 |
46 | # Optional npm cache directory
47 | .npm
48 |
49 | # Optional eslint cache
50 | .eslintcache
51 |
52 | # Optional REPL history
53 | .node_repl_history
54 |
55 | # Output of 'npm pack'
56 | *.tgz
57 |
58 | # Yarn Integrity file
59 | .yarn-integrity
60 |
61 | # dotenv environment variables file
62 | .env
63 |
64 |
65 |
66 | # End of https://www.gitignore.io/api/node
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # hyper-tunnel
2 |
3 | hyper-tunnel is HTTPS tunnel over WSS
4 |
5 | ## Introduction
6 |
7 | In the meetup and other situations, we have to expose our localhost to host demo-application avoid Firewall for other participants. Generally, this is worst way. Tunneling over HTTP have risks by MITM. For this reason, almost services provide tunnels over End-to-End SSL/TLS in paid plan. This project is a simple toolkit to make HTTP tunneling over End-to-End SSL/TLS by WSS (WebSocketSecure). hyper-tunnel works on the following route.
8 |
9 | ```
10 | web browser <--HTTPS--> hyper-tunnel server
11 | |
12 | ~~~~~~~~~~~~~~Firewall~~~~~~ WSS ~~~~~~~
13 | |
14 | localhost <-HTTP(S)-> hyper-tunnel client
15 | ```
16 |
17 | ## How to use
18 |
19 | ```sh
20 | $ npm install -g tani/hyper-tunnel
21 | $ htunnel server --authorization USERNAME:PASSWORD --port 4000
22 | $ htunnel client --authorization USERNAME:PASSWORD --localhost localhost:8000 --remotehost localhost:4000
23 | ```
24 |
25 | Now you can access localhost:4000 with browsers, and hyper-tunnel access localhost:4000. `
26 |
27 | ## Related Services
28 |
29 | - localtunnel
30 | - ngrok
31 | - pagekite
32 |
33 | ## Copyright & License
34 |
35 | Copryright (c) 2018 TANIGUCHI Masaya All Rights Reserved.
36 |
37 | hyper-tunnel licensed under the GPLv3 or later.
38 |
--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
1 | {
2 | // IntelliSense を使用して利用可能な属性を学べます。
3 | // 既存の属性の説明をホバーして表示します。
4 | // 詳細情報は次を確認してください: https://go.microsoft.com/fwlink/?linkid=830387
5 | "version": "0.2.0",
6 | "configurations": [
7 | {
8 | "type": "node",
9 | "request": "launch",
10 | "name": "Launch Server",
11 | "program": "${workspaceFolder}/bin/command.js",
12 | "outFiles": [
13 | "${workspaceFolder}/**/*.js"
14 | ],
15 | "args": [
16 | "server",
17 | "--port",
18 | "4000",
19 | "--authorization",
20 | "user:pass"
21 | ]
22 | },
23 | {
24 | "type": "node",
25 | "request": "launch",
26 | "name": "Launch Client",
27 | "program": "${workspaceFolder}/bin/command.js",
28 | "outFiles": [
29 | "${workspaceFolder}/**/*.js"
30 | ],
31 | "args": [
32 | "client",
33 | "--localhost",
34 | "localhost:8000",
35 | "--remotehost",
36 | "localhost:4000",
37 | "--protocol",
38 | "http:ws:http",
39 | "--authorization",
40 | "user:pass"
41 | ]
42 | }
43 | ]
44 | }
--------------------------------------------------------------------------------
/src/command.ts:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | /*
3 | * This file is part of the noncloud.
4 | * Copyright (c) 2018 TANIGUCHI Masaya.
5 | *
6 | * This program is free software: you can redistribute it and/or modify
7 | * it under the terms of the GNU General Public License as published by
8 | * the Free Software Foundation, version 3.
9 | *
10 | * This program is distributed in the hope that it will be useful, but
11 | * WITHOUT ANY WARRANTY; without even the implied warranty of
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 | * General Public License for more details.
14 | *
15 | * You should have received a copy of the GNU General Public License
16 | * along with this program. If not, see .
17 | */
18 | import Commander = require("commander");
19 | import { readFileSync } from "fs";
20 | import client from "./client";
21 | import server from "./server";
22 |
23 | const buffer = readFileSync(`${__dirname}/../package.json`);
24 | const version = JSON.parse(buffer.toString()).version;
25 |
26 | Commander.command("server")
27 | .option("-a, --authorization ", "set hyper-tunnel account")
28 | .option("-e, --encryption", "use encryption")
29 | .option("-p, --port ", "listen this port")
30 | .action(server);
31 |
32 | Commander.command("client")
33 | .option("-a, --authorization ", "login noncloud server")
34 | .option("-r, --remotehost ", "set noncloud server")
35 | .option("-l, --localhost ", "tunnel traffic to this host")
36 | .option(
37 | "-p, --protocol ",
38 | "use this protocols",
39 | "https:wss:http"
40 | )
41 | .action(client);
42 |
43 | Commander.version(version, "-v, --version").parse(process.argv);
44 |
--------------------------------------------------------------------------------
/bin/command.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | "use strict";
3 | var __importDefault = (this && this.__importDefault) || function (mod) {
4 | return (mod && mod.__esModule) ? mod : { "default": mod };
5 | };
6 | Object.defineProperty(exports, "__esModule", { value: true });
7 | /*
8 | * This file is part of the noncloud.
9 | * Copyright (c) 2018 TANIGUCHI Masaya.
10 | *
11 | * This program is free software: you can redistribute it and/or modify
12 | * it under the terms of the GNU General Public License as published by
13 | * the Free Software Foundation, version 3.
14 | *
15 | * This program is distributed in the hope that it will be useful, but
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 | * General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU General Public License
21 | * along with this program. If not, see .
22 | */
23 | const Commander = require("commander");
24 | const fs_1 = require("fs");
25 | const client_1 = __importDefault(require("./client"));
26 | const server_1 = __importDefault(require("./server"));
27 | const buffer = fs_1.readFileSync(`${__dirname}/../package.json`);
28 | const version = JSON.parse(buffer.toString()).version;
29 | Commander.command("server")
30 | .option("-a, --authorization ", "set hyper-tunnel account")
31 | .option("-e, --encryption", "use encryption")
32 | .option("-p, --port ", "listen this port")
33 | .action(server_1.default);
34 | Commander.command("client")
35 | .option("-a, --authorization ", "login noncloud server")
36 | .option("-r, --remotehost ", "set noncloud server")
37 | .option("-l, --localhost ", "tunnel traffic to this host")
38 | .option("-p, --protocol ", "use this protocols", "https:wss:http")
39 | .action(client_1.default);
40 | Commander.version(version, "-v, --version").parse(process.argv);
41 |
--------------------------------------------------------------------------------
/bin/client.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | Object.defineProperty(exports, "__esModule", { value: true });
3 | /*
4 | * This file is part of the noncloud.
5 | * Copyright (c) 2018 TANIGUCHI Masaya.
6 | *
7 | * This program is free software: you can redistribute it and/or modify
8 | * it under the terms of the GNU General Public License as published by
9 | * the Free Software Foundation, version 3.
10 | *
11 | * This program is distributed in the hope that it will be useful, but
12 | * WITHOUT ANY WARRANTY; without even the implied warranty of
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 | * General Public License for more details.
15 | *
16 | * You should have received a copy of the GNU General Public License
17 | * along with this program. If not, see .
18 | */
19 | const circular_json_1 = require("circular-json");
20 | const events_1 = require("events");
21 | const http_1 = require("http");
22 | const WebSocket = require("ws");
23 | exports.default = (options) => {
24 | const url = `${options.protocol.split(":")[1]}://${options.authorization}@${options.remotehost}`;
25 | const connection = new WebSocket(url, {
26 | perMessageDeflate: true
27 | });
28 | connection.on("open", () => {
29 | const emitter = new events_1.EventEmitter();
30 | connection.on("message", (rawMessage) => {
31 | const message = circular_json_1.parse(rawMessage);
32 | if (message.type === "header") {
33 | const requestOptions = {
34 | headers: message.payload.headers,
35 | host: options.localhost.split(":")[0],
36 | method: message.payload.method,
37 | path: message.payload.path,
38 | port: options.localhost.split(":")[1],
39 | protocol: `${options.protocol.split(":")[2]}:`
40 | };
41 | const clientRequest = http_1.request(requestOptions, (response) => {
42 | connection.send(circular_json_1.stringify({
43 | identifier: message.identifier,
44 | payload: response,
45 | type: "header"
46 | }));
47 | response.on("data", (data) => {
48 | const dataMessage = {
49 | identifier: message.identifier,
50 | payload: Buffer.from(data).toString("base64"),
51 | type: "data"
52 | };
53 | connection.send(circular_json_1.stringify(dataMessage));
54 | });
55 | response.on("end", () => {
56 | const endMessage = {
57 | identifier: message.identifier,
58 | type: "end"
59 | };
60 | connection.send(circular_json_1.stringify(endMessage));
61 | });
62 | });
63 | emitter.on(`data:${message.identifier}`, (dataMessage) => {
64 | clientRequest.write(Buffer.from(dataMessage.payload, "base64"));
65 | });
66 | emitter.on(`end:${message.identifier}`, (endMessage) => {
67 | clientRequest.end();
68 | emitter.removeAllListeners(`data:${message.identifier}`);
69 | emitter.removeAllListeners(`end:${message.identifier}`);
70 | });
71 | }
72 | if (message.type === "data" || message.type === "end") {
73 | emitter.emit(`${message.type}:${message.identifier}`, message);
74 | }
75 | });
76 | connection.on("close", () => {
77 | process.exit();
78 | });
79 | process.stdout.write(`${options.protocol.split(":")[0]}://${options.remotehost}`);
80 | process.stdout.write(" <-- ");
81 | process.stdout.write(`${options.protocol.split(":")[1]}://${options.remotehost}`);
82 | process.stdout.write(" --> ");
83 | process.stdout.write(`${options.protocol.split(":")[2]}://${options.localhost}\n`);
84 | });
85 | };
86 |
--------------------------------------------------------------------------------
/src/client.ts:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is part of the noncloud.
3 | * Copyright (c) 2018 TANIGUCHI Masaya.
4 | *
5 | * This program is free software: you can redistribute it and/or modify
6 | * it under the terms of the GNU General Public License as published by
7 | * the Free Software Foundation, version 3.
8 | *
9 | * This program is distributed in the hope that it will be useful, but
10 | * WITHOUT ANY WARRANTY; without even the implied warranty of
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 | * General Public License for more details.
13 | *
14 | * You should have received a copy of the GNU General Public License
15 | * along with this program. If not, see .
16 | */
17 | import { parse, stringify } from "circular-json";
18 | import { EventEmitter } from "events";
19 | import {
20 | IncomingMessage,
21 | request,
22 | RequestOptions
23 | } from "http";
24 | import WebSocket = require("ws");
25 | import {
26 | IDataMessage,
27 | IEndMessage,
28 | IHeaderMessage,
29 | Message,
30 | RawMessage
31 | } from "./message";
32 |
33 | export default (options: any) => {
34 | const url = `${options.protocol.split(":")[1]}://${options.authorization}@${
35 | options.remotehost
36 | }`;
37 | const connection = new WebSocket(url, {
38 | perMessageDeflate: true
39 | });
40 |
41 | connection.on("open", () => {
42 | const emitter = new EventEmitter();
43 | connection.on("message", (rawMessage: RawMessage) => {
44 | const message: Message = parse(rawMessage);
45 | if (message.type === "header") {
46 | const requestOptions: RequestOptions = {
47 | headers: message.payload.headers,
48 | host: options.localhost.split(":")[0],
49 | method: message.payload.method,
50 | path: message.payload.path,
51 | port: options.localhost.split(":")[1],
52 | protocol: `${options.protocol.split(":")[2]}:`
53 | };
54 | const clientRequest = request(
55 | requestOptions,
56 | (response: IncomingMessage) => {
57 | connection.send(
58 | stringify({
59 | identifier: message.identifier,
60 | payload: response,
61 | type: "header"
62 | } as IHeaderMessage)
63 | );
64 | response.on("data", (data: string | Buffer) => {
65 | const dataMessage: IDataMessage = {
66 | identifier: message.identifier,
67 | payload: Buffer.from(data as any).toString("base64"),
68 | type: "data"
69 | };
70 | connection.send(stringify(dataMessage));
71 | });
72 | response.on("end", () => {
73 | const endMessage: IEndMessage = {
74 | identifier: message.identifier,
75 | type: "end"
76 | };
77 | connection.send(stringify(endMessage));
78 | });
79 | }
80 | );
81 | emitter.on(
82 | `data:${message.identifier}`,
83 | (dataMessage: IDataMessage) => {
84 | clientRequest.write(Buffer.from(dataMessage.payload, "base64"));
85 | }
86 | );
87 | emitter.on(`end:${message.identifier}`, (endMessage: IEndMessage) => {
88 | clientRequest.end();
89 | emitter.removeAllListeners(`data:${message.identifier}`);
90 | emitter.removeAllListeners(`end:${message.identifier}`);
91 | });
92 | }
93 | if (message.type === "data" || message.type === "end") {
94 | emitter.emit(`${message.type}:${message.identifier}`, message);
95 | }
96 | });
97 | connection.on("close", () => {
98 | process.exit();
99 | });
100 | process.stdout.write(
101 | `${options.protocol.split(":")[0]}://${options.remotehost}`
102 | );
103 | process.stdout.write(" <-- ");
104 | process.stdout.write(
105 | `${options.protocol.split(":")[1]}://${options.remotehost}`
106 | );
107 | process.stdout.write(" --> ");
108 | process.stdout.write(
109 | `${options.protocol.split(":")[2]}://${options.localhost}\n`
110 | );
111 | });
112 | };
113 |
--------------------------------------------------------------------------------
/src/server.ts:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is part of the noncloud.
3 | * Copyright (c) 2018 TANIGUCHI Masaya.
4 | *
5 | * This program is free software: you can redistribute it and/or modify
6 | * it under the terms of the GNU General Public License as published by
7 | * the Free Software Foundation, version 3.
8 | *
9 | * This program is distributed in the hope that it will be useful, but
10 | * WITHOUT ANY WARRANTY; without even the implied warranty of
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 | * General Public License for more details.
13 | *
14 | * You should have received a copy of the GNU General Public License
15 | * along with this program. If not, see .
16 | */
17 | import { parse, stringify } from "circular-json";
18 | import { EventEmitter } from "events";
19 | import { readFileSync } from "fs";
20 | import {
21 | IncomingMessage,
22 | createServer,
23 | ServerResponse
24 | } from "http";
25 | import * as WebSocket from "ws";
26 | import {
27 | IDataMessage,
28 | IEndMessage,
29 | IHeaderMessage,
30 | Message,
31 | RawMessage
32 | } from "./message";
33 |
34 | export default (options: any) => {
35 | const emitter = new EventEmitter();
36 | let connection: WebSocket;
37 |
38 | const server = createServer(
39 | (request: IncomingMessage, response: ServerResponse) => {
40 | if (!connection || connection.readyState === connection.CLOSED) {
41 | response.writeHead(404);
42 | response.end(readFileSync(`${__dirname}/404.html`));
43 | } else {
44 | const identifier: string = Math.random()
45 | .toString(36)
46 | .slice(-8);
47 | connection.send(
48 | stringify({
49 | identifier,
50 | payload: request,
51 | type: "header"
52 | } as IHeaderMessage)
53 | );
54 | request.on("data", (data: string | Buffer) => {
55 | const dataMessage: IDataMessage = {
56 | identifier,
57 | payload: Buffer.from(data as any).toString("base64"),
58 | type: "data"
59 | };
60 | connection.send(stringify(dataMessage));
61 | });
62 | request.on("end", () => {
63 | const endMessage: IEndMessage = {
64 | identifier,
65 | type: "end"
66 | };
67 | connection.send(stringify(endMessage));
68 | });
69 | emitter.on(
70 | `header:${identifier}`,
71 | (headerMessage: IHeaderMessage) => {
72 | response.writeHead(
73 | headerMessage.payload.statusCode || 404,
74 | headerMessage.payload.headers
75 | );
76 | }
77 | );
78 | emitter.on(`data:${identifier}`, (dataMessage: IDataMessage) => {
79 | response.write(Buffer.from(dataMessage.payload, "base64"));
80 | });
81 | emitter.on(`end:${identifier}`, (endMessage: IEndMessage) => {
82 | response.end();
83 | emitter.removeAllListeners(`header:${identifier}`);
84 | emitter.removeAllListeners(`data:${identifier}`);
85 | emitter.removeAllListeners(`end:${identifier}`);
86 | });
87 | }
88 | }
89 | );
90 |
91 | server.listen(options.port);
92 |
93 | const webSocketServer = new WebSocket.Server({
94 | perMessageDeflate: true,
95 | server,
96 | verifyClient: ({ req, secure }: { req: any; secure: boolean }) => {
97 | if (secure || !options.encryption) {
98 | return (
99 | req.headers.authorization ===
100 | `Basic ${Buffer.from(options.authorization).toString("base64")}`
101 | );
102 | }
103 | }
104 | });
105 |
106 | webSocketServer.on("connection", (socket: WebSocket) => {
107 | if (connection) {
108 | connection.removeAllListeners("message");
109 | connection.removeAllListeners("ping");
110 | connection.close();
111 | }
112 | connection = socket;
113 | connection.on("message", (rawMessage: RawMessage) => {
114 | const message: Message = parse(rawMessage);
115 | if (
116 | message.type === "header" ||
117 | message.type === "data" ||
118 | message.type === "end"
119 | ) {
120 | emitter.emit(`${message.type}:${message.identifier}`, message);
121 | }
122 | });
123 | });
124 | };
125 |
--------------------------------------------------------------------------------
/bin/server.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 | var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
3 | if (k2 === undefined) k2 = k;
4 | Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
5 | }) : (function(o, m, k, k2) {
6 | if (k2 === undefined) k2 = k;
7 | o[k2] = m[k];
8 | }));
9 | var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
10 | Object.defineProperty(o, "default", { enumerable: true, value: v });
11 | }) : function(o, v) {
12 | o["default"] = v;
13 | });
14 | var __importStar = (this && this.__importStar) || function (mod) {
15 | if (mod && mod.__esModule) return mod;
16 | var result = {};
17 | if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
18 | __setModuleDefault(result, mod);
19 | return result;
20 | };
21 | Object.defineProperty(exports, "__esModule", { value: true });
22 | /*
23 | * This file is part of the noncloud.
24 | * Copyright (c) 2018 TANIGUCHI Masaya.
25 | *
26 | * This program is free software: you can redistribute it and/or modify
27 | * it under the terms of the GNU General Public License as published by
28 | * the Free Software Foundation, version 3.
29 | *
30 | * This program is distributed in the hope that it will be useful, but
31 | * WITHOUT ANY WARRANTY; without even the implied warranty of
32 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
33 | * General Public License for more details.
34 | *
35 | * You should have received a copy of the GNU General Public License
36 | * along with this program. If not, see .
37 | */
38 | const circular_json_1 = require("circular-json");
39 | const events_1 = require("events");
40 | const fs_1 = require("fs");
41 | const http_1 = require("http");
42 | const WebSocket = __importStar(require("ws"));
43 | exports.default = (options) => {
44 | const emitter = new events_1.EventEmitter();
45 | let connection;
46 | const server = http_1.createServer((request, response) => {
47 | if (!connection || connection.readyState === connection.CLOSED) {
48 | response.writeHead(404);
49 | response.end(fs_1.readFileSync(`${__dirname}/404.html`));
50 | }
51 | else {
52 | const identifier = Math.random()
53 | .toString(36)
54 | .slice(-8);
55 | connection.send(circular_json_1.stringify({
56 | identifier,
57 | payload: request,
58 | type: "header"
59 | }));
60 | request.on("data", (data) => {
61 | const dataMessage = {
62 | identifier,
63 | payload: Buffer.from(data).toString("base64"),
64 | type: "data"
65 | };
66 | connection.send(circular_json_1.stringify(dataMessage));
67 | });
68 | request.on("end", () => {
69 | const endMessage = {
70 | identifier,
71 | type: "end"
72 | };
73 | connection.send(circular_json_1.stringify(endMessage));
74 | });
75 | emitter.on(`header:${identifier}`, (headerMessage) => {
76 | response.writeHead(headerMessage.payload.statusCode || 404, headerMessage.payload.headers);
77 | });
78 | emitter.on(`data:${identifier}`, (dataMessage) => {
79 | response.write(Buffer.from(dataMessage.payload, "base64"));
80 | });
81 | emitter.on(`end:${identifier}`, (endMessage) => {
82 | response.end();
83 | emitter.removeAllListeners(`header:${identifier}`);
84 | emitter.removeAllListeners(`data:${identifier}`);
85 | emitter.removeAllListeners(`end:${identifier}`);
86 | });
87 | }
88 | });
89 | server.listen(options.port);
90 | const webSocketServer = new WebSocket.Server({
91 | perMessageDeflate: true,
92 | server,
93 | verifyClient: ({ req, secure }) => {
94 | if (secure || !options.encryption) {
95 | return (req.headers.authorization ===
96 | `Basic ${Buffer.from(options.authorization).toString("base64")}`);
97 | }
98 | }
99 | });
100 | webSocketServer.on("connection", (socket) => {
101 | if (connection) {
102 | connection.removeAllListeners("message");
103 | connection.removeAllListeners("ping");
104 | connection.close();
105 | }
106 | connection = socket;
107 | connection.on("message", (rawMessage) => {
108 | const message = circular_json_1.parse(rawMessage);
109 | if (message.type === "header" ||
110 | message.type === "data" ||
111 | message.type === "end") {
112 | emitter.emit(`${message.type}:${message.identifier}`, message);
113 | }
114 | });
115 | });
116 | };
117 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "include": ["src/*.ts"],
3 | "compilerOptions": {
4 | /* Basic Options */
5 | "target": "es6", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017','ES2018' or 'ESNEXT'. */
6 | "module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
7 | // "lib": [], /* Specify library files to be included in the compilation. */
8 | // "allowJs": true, /* Allow javascript files to be compiled. */
9 | // "checkJs": true, /* Report errors in .js files. */
10 | // "jsx": "preserve", /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
11 | // "declaration": true, /* Generates corresponding '.d.ts' file. */
12 | // "sourceMap": true, /* Generates corresponding '.map' file. */
13 | // "outFile": "./", /* Concatenate and emit output to single file. */
14 | "outDir": "./bin", /* Redirect output structure to the directory. */
15 | // "rootDir": "./", /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
16 | // "removeComments": true, /* Do not emit comments to output. */
17 | // "noEmit": true, /* Do not emit outputs. */
18 | // "importHelpers": true, /* Import emit helpers from 'tslib'. */
19 | // "downlevelIteration": true, /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
20 | // "isolatedModules": true, /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
21 |
22 | /* Strict Type-Checking Options */
23 | "strict": true, /* Enable all strict type-checking options. */
24 | // "noImplicitAny": true, /* Raise error on expressions and declarations with an implied 'any' type. */
25 | // "strictNullChecks": true, /* Enable strict null checks. */
26 | // "strictFunctionTypes": true, /* Enable strict checking of function types. */
27 | // "strictPropertyInitialization": true, /* Enable strict checking of property initialization in classes. */
28 | // "noImplicitThis": true, /* Raise error on 'this' expressions with an implied 'any' type. */
29 | // "alwaysStrict": true, /* Parse in strict mode and emit "use strict" for each source file. */
30 |
31 | /* Additional Checks */
32 | // "noUnusedLocals": true, /* Report errors on unused locals. */
33 | // "noUnusedParameters": true, /* Report errors on unused parameters. */
34 | // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
35 | // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
36 |
37 | /* Module Resolution Options */
38 | // "moduleResolution": "node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
39 | // "baseUrl": "./", /* Base directory to resolve non-absolute module names. */
40 | // "paths": {}, /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
41 | // "rootDirs": [], /* List of root folders whose combined content represents the structure of the project at runtime. */
42 | // "typeRoots": [], /* List of folders to include type definitions from. */
43 | // "types": [], /* Type declaration files to be included in compilation. */
44 | // "allowSyntheticDefaultImports": true, /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
45 | "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
46 | // "preserveSymlinks": true, /* Do not resolve the real path of symlinks. */
47 |
48 | /* Source Map Options */
49 | // "sourceRoot": "./", /* Specify the location where debugger should locate TypeScript files instead of source locations. */
50 | // "mapRoot": "./", /* Specify the location where debugger should locate map files instead of generated locations. */
51 | // "inlineSourceMap": true, /* Emit a single file with source maps instead of having a separate file. */
52 | // "inlineSources": true, /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
53 |
54 | /* Experimental Options */
55 | // "experimentalDecorators": true, /* Enables experimental support for ES7 decorators. */
56 | // "emitDecoratorMetadata": true, /* Enables experimental support for emitting type metadata for decorators. */
57 | }
58 | }
--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | ==========================
3 |
4 | Version 3, 29 June 2007
5 |
6 | Copyright © 2007 Free Software Foundation, Inc. <>
7 |
8 | Everyone is permitted to copy and distribute verbatim copies of this license
9 | document, but changing it is not allowed.
10 |
11 | ## Preamble
12 |
13 | The GNU General Public License is a free, copyleft license for software and other
14 | kinds of works.
15 |
16 | The licenses for most software and other practical works are designed to take away
17 | your freedom to share and change the works. By contrast, the GNU General Public
18 | License is intended to guarantee your freedom to share and change all versions of a
19 | program--to make sure it remains free software for all its users. We, the Free
20 | Software Foundation, use the GNU General Public License for most of our software; it
21 | applies also to any other work released this way by its authors. You can apply it to
22 | your programs, too.
23 |
24 | When we speak of free software, we are referring to freedom, not price. Our General
25 | Public Licenses are designed to make sure that you have the freedom to distribute
26 | copies of free software (and charge for them if you wish), that you receive source
27 | code or can get it if you want it, that you can change the software or use pieces of
28 | it in new free programs, and that you know you can do these things.
29 |
30 | To protect your rights, we need to prevent others from denying you these rights or
31 | asking you to surrender the rights. Therefore, you have certain responsibilities if
32 | you distribute copies of the software, or if you modify it: responsibilities to
33 | respect the freedom of others.
34 |
35 | For example, if you distribute copies of such a program, whether gratis or for a fee,
36 | you must pass on to the recipients the same freedoms that you received. You must make
37 | sure that they, too, receive or can get the source code. And you must show them these
38 | terms so they know their rights.
39 |
40 | Developers that use the GNU GPL protect your rights with two steps: (1) assert
41 | copyright on the software, and (2) offer you this License giving you legal permission
42 | to copy, distribute and/or modify it.
43 |
44 | For the developers' and authors' protection, the GPL clearly explains that there is
45 | no warranty for this free software. For both users' and authors' sake, the GPL
46 | requires that modified versions be marked as changed, so that their problems will not
47 | be attributed erroneously to authors of previous versions.
48 |
49 | Some devices are designed to deny users access to install or run modified versions of
50 | the software inside them, although the manufacturer can do so. This is fundamentally
51 | incompatible with the aim of protecting users' freedom to change the software. The
52 | systematic pattern of such abuse occurs in the area of products for individuals to
53 | use, which is precisely where it is most unacceptable. Therefore, we have designed
54 | this version of the GPL to prohibit the practice for those products. If such problems
55 | arise substantially in other domains, we stand ready to extend this provision to
56 | those domains in future versions of the GPL, as needed to protect the freedom of
57 | users.
58 |
59 | Finally, every program is threatened constantly by software patents. States should
60 | not allow patents to restrict development and use of software on general-purpose
61 | computers, but in those that do, we wish to avoid the special danger that patents
62 | applied to a free program could make it effectively proprietary. To prevent this, the
63 | GPL assures that patents cannot be used to render the program non-free.
64 |
65 | The precise terms and conditions for copying, distribution and modification follow.
66 |
67 | ## TERMS AND CONDITIONS
68 |
69 | ### 0. Definitions.
70 |
71 | “This License” refers to version 3 of the GNU General Public License.
72 |
73 | “Copyright” also means copyright-like laws that apply to other kinds of
74 | works, such as semiconductor masks.
75 |
76 | “The Program” refers to any copyrightable work licensed under this
77 | License. Each licensee is addressed as “you”. “Licensees” and
78 | “recipients” may be individuals or organizations.
79 |
80 | To “modify” a work means to copy from or adapt all or part of the work in
81 | a fashion requiring copyright permission, other than the making of an exact copy. The
82 | resulting work is called a “modified version” of the earlier work or a
83 | work “based on” the earlier work.
84 |
85 | A “covered work” means either the unmodified Program or a work based on
86 | the Program.
87 |
88 | To “propagate” a work means to do anything with it that, without
89 | permission, would make you directly or secondarily liable for infringement under
90 | applicable copyright law, except executing it on a computer or modifying a private
91 | copy. Propagation includes copying, distribution (with or without modification),
92 | making available to the public, and in some countries other activities as well.
93 |
94 | To “convey” a work means any kind of propagation that enables other
95 | parties to make or receive copies. Mere interaction with a user through a computer
96 | network, with no transfer of a copy, is not conveying.
97 |
98 | An interactive user interface displays “Appropriate Legal Notices” to the
99 | extent that it includes a convenient and prominently visible feature that (1)
100 | displays an appropriate copyright notice, and (2) tells the user that there is no
101 | warranty for the work (except to the extent that warranties are provided), that
102 | licensees may convey the work under this License, and how to view a copy of this
103 | License. If the interface presents a list of user commands or options, such as a
104 | menu, a prominent item in the list meets this criterion.
105 |
106 | ### 1. Source Code.
107 |
108 | The “source code” for a work means the preferred form of the work for
109 | making modifications to it. “Object code” means any non-source form of a
110 | work.
111 |
112 | A “Standard Interface” means an interface that either is an official
113 | standard defined by a recognized standards body, or, in the case of interfaces
114 | specified for a particular programming language, one that is widely used among
115 | developers working in that language.
116 |
117 | The “System Libraries” of an executable work include anything, other than
118 | the work as a whole, that (a) is included in the normal form of packaging a Major
119 | Component, but which is not part of that Major Component, and (b) serves only to
120 | enable use of the work with that Major Component, or to implement a Standard
121 | Interface for which an implementation is available to the public in source code form.
122 | A “Major Component”, in this context, means a major essential component
123 | (kernel, window system, and so on) of the specific operating system (if any) on which
124 | the executable work runs, or a compiler used to produce the work, or an object code
125 | interpreter used to run it.
126 |
127 | The “Corresponding Source” for a work in object code form means all the
128 | source code needed to generate, install, and (for an executable work) run the object
129 | code and to modify the work, including scripts to control those activities. However,
130 | it does not include the work's System Libraries, or general-purpose tools or
131 | generally available free programs which are used unmodified in performing those
132 | activities but which are not part of the work. For example, Corresponding Source
133 | includes interface definition files associated with source files for the work, and
134 | the source code for shared libraries and dynamically linked subprograms that the work
135 | is specifically designed to require, such as by intimate data communication or
136 | control flow between those subprograms and other parts of the work.
137 |
138 | The Corresponding Source need not include anything that users can regenerate
139 | automatically from other parts of the Corresponding Source.
140 |
141 | The Corresponding Source for a work in source code form is that same work.
142 |
143 | ### 2. Basic Permissions.
144 |
145 | All rights granted under this License are granted for the term of copyright on the
146 | Program, and are irrevocable provided the stated conditions are met. This License
147 | explicitly affirms your unlimited permission to run the unmodified Program. The
148 | output from running a covered work is covered by this License only if the output,
149 | given its content, constitutes a covered work. This License acknowledges your rights
150 | of fair use or other equivalent, as provided by copyright law.
151 |
152 | You may make, run and propagate covered works that you do not convey, without
153 | conditions so long as your license otherwise remains in force. You may convey covered
154 | works to others for the sole purpose of having them make modifications exclusively
155 | for you, or provide you with facilities for running those works, provided that you
156 | comply with the terms of this License in conveying all material for which you do not
157 | control copyright. Those thus making or running the covered works for you must do so
158 | exclusively on your behalf, under your direction and control, on terms that prohibit
159 | them from making any copies of your copyrighted material outside their relationship
160 | with you.
161 |
162 | Conveying under any other circumstances is permitted solely under the conditions
163 | stated below. Sublicensing is not allowed; section 10 makes it unnecessary.
164 |
165 | ### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
166 |
167 | No covered work shall be deemed part of an effective technological measure under any
168 | applicable law fulfilling obligations under article 11 of the WIPO copyright treaty
169 | adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention
170 | of such measures.
171 |
172 | When you convey a covered work, you waive any legal power to forbid circumvention of
173 | technological measures to the extent such circumvention is effected by exercising
174 | rights under this License with respect to the covered work, and you disclaim any
175 | intention to limit operation or modification of the work as a means of enforcing,
176 | against the work's users, your or third parties' legal rights to forbid circumvention
177 | of technological measures.
178 |
179 | ### 4. Conveying Verbatim Copies.
180 |
181 | You may convey verbatim copies of the Program's source code as you receive it, in any
182 | medium, provided that you conspicuously and appropriately publish on each copy an
183 | appropriate copyright notice; keep intact all notices stating that this License and
184 | any non-permissive terms added in accord with section 7 apply to the code; keep
185 | intact all notices of the absence of any warranty; and give all recipients a copy of
186 | this License along with the Program.
187 |
188 | You may charge any price or no price for each copy that you convey, and you may offer
189 | support or warranty protection for a fee.
190 |
191 | ### 5. Conveying Modified Source Versions.
192 |
193 | You may convey a work based on the Program, or the modifications to produce it from
194 | the Program, in the form of source code under the terms of section 4, provided that
195 | you also meet all of these conditions:
196 |
197 | * **a)** The work must carry prominent notices stating that you modified it, and giving a
198 | relevant date.
199 | * **b)** The work must carry prominent notices stating that it is released under this
200 | License and any conditions added under section 7. This requirement modifies the
201 | requirement in section 4 to “keep intact all notices”.
202 | * **c)** You must license the entire work, as a whole, under this License to anyone who
203 | comes into possession of a copy. This License will therefore apply, along with any
204 | applicable section 7 additional terms, to the whole of the work, and all its parts,
205 | regardless of how they are packaged. This License gives no permission to license the
206 | work in any other way, but it does not invalidate such permission if you have
207 | separately received it.
208 | * **d)** If the work has interactive user interfaces, each must display Appropriate Legal
209 | Notices; however, if the Program has interactive interfaces that do not display
210 | Appropriate Legal Notices, your work need not make them do so.
211 |
212 | A compilation of a covered work with other separate and independent works, which are
213 | not by their nature extensions of the covered work, and which are not combined with
214 | it such as to form a larger program, in or on a volume of a storage or distribution
215 | medium, is called an “aggregate” if the compilation and its resulting
216 | copyright are not used to limit the access or legal rights of the compilation's users
217 | beyond what the individual works permit. Inclusion of a covered work in an aggregate
218 | does not cause this License to apply to the other parts of the aggregate.
219 |
220 | ### 6. Conveying Non-Source Forms.
221 |
222 | You may convey a covered work in object code form under the terms of sections 4 and
223 | 5, provided that you also convey the machine-readable Corresponding Source under the
224 | terms of this License, in one of these ways:
225 |
226 | * **a)** Convey the object code in, or embodied in, a physical product (including a
227 | physical distribution medium), accompanied by the Corresponding Source fixed on a
228 | durable physical medium customarily used for software interchange.
229 | * **b)** Convey the object code in, or embodied in, a physical product (including a
230 | physical distribution medium), accompanied by a written offer, valid for at least
231 | three years and valid for as long as you offer spare parts or customer support for
232 | that product model, to give anyone who possesses the object code either (1) a copy of
233 | the Corresponding Source for all the software in the product that is covered by this
234 | License, on a durable physical medium customarily used for software interchange, for
235 | a price no more than your reasonable cost of physically performing this conveying of
236 | source, or (2) access to copy the Corresponding Source from a network server at no
237 | charge.
238 | * **c)** Convey individual copies of the object code with a copy of the written offer to
239 | provide the Corresponding Source. This alternative is allowed only occasionally and
240 | noncommercially, and only if you received the object code with such an offer, in
241 | accord with subsection 6b.
242 | * **d)** Convey the object code by offering access from a designated place (gratis or for
243 | a charge), and offer equivalent access to the Corresponding Source in the same way
244 | through the same place at no further charge. You need not require recipients to copy
245 | the Corresponding Source along with the object code. If the place to copy the object
246 | code is a network server, the Corresponding Source may be on a different server
247 | (operated by you or a third party) that supports equivalent copying facilities,
248 | provided you maintain clear directions next to the object code saying where to find
249 | the Corresponding Source. Regardless of what server hosts the Corresponding Source,
250 | you remain obligated to ensure that it is available for as long as needed to satisfy
251 | these requirements.
252 | * **e)** Convey the object code using peer-to-peer transmission, provided you inform
253 | other peers where the object code and Corresponding Source of the work are being
254 | offered to the general public at no charge under subsection 6d.
255 |
256 | A separable portion of the object code, whose source code is excluded from the
257 | Corresponding Source as a System Library, need not be included in conveying the
258 | object code work.
259 |
260 | A “User Product” is either (1) a “consumer product”, which
261 | means any tangible personal property which is normally used for personal, family, or
262 | household purposes, or (2) anything designed or sold for incorporation into a
263 | dwelling. In determining whether a product is a consumer product, doubtful cases
264 | shall be resolved in favor of coverage. For a particular product received by a
265 | particular user, “normally used” refers to a typical or common use of
266 | that class of product, regardless of the status of the particular user or of the way
267 | in which the particular user actually uses, or expects or is expected to use, the
268 | product. A product is a consumer product regardless of whether the product has
269 | substantial commercial, industrial or non-consumer uses, unless such uses represent
270 | the only significant mode of use of the product.
271 |
272 | “Installation Information” for a User Product means any methods,
273 | procedures, authorization keys, or other information required to install and execute
274 | modified versions of a covered work in that User Product from a modified version of
275 | its Corresponding Source. The information must suffice to ensure that the continued
276 | functioning of the modified object code is in no case prevented or interfered with
277 | solely because modification has been made.
278 |
279 | If you convey an object code work under this section in, or with, or specifically for
280 | use in, a User Product, and the conveying occurs as part of a transaction in which
281 | the right of possession and use of the User Product is transferred to the recipient
282 | in perpetuity or for a fixed term (regardless of how the transaction is
283 | characterized), the Corresponding Source conveyed under this section must be
284 | accompanied by the Installation Information. But this requirement does not apply if
285 | neither you nor any third party retains the ability to install modified object code
286 | on the User Product (for example, the work has been installed in ROM).
287 |
288 | The requirement to provide Installation Information does not include a requirement to
289 | continue to provide support service, warranty, or updates for a work that has been
290 | modified or installed by the recipient, or for the User Product in which it has been
291 | modified or installed. Access to a network may be denied when the modification itself
292 | materially and adversely affects the operation of the network or violates the rules
293 | and protocols for communication across the network.
294 |
295 | Corresponding Source conveyed, and Installation Information provided, in accord with
296 | this section must be in a format that is publicly documented (and with an
297 | implementation available to the public in source code form), and must require no
298 | special password or key for unpacking, reading or copying.
299 |
300 | ### 7. Additional Terms.
301 |
302 | “Additional permissions” are terms that supplement the terms of this
303 | License by making exceptions from one or more of its conditions. Additional
304 | permissions that are applicable to the entire Program shall be treated as though they
305 | were included in this License, to the extent that they are valid under applicable
306 | law. If additional permissions apply only to part of the Program, that part may be
307 | used separately under those permissions, but the entire Program remains governed by
308 | this License without regard to the additional permissions.
309 |
310 | When you convey a copy of a covered work, you may at your option remove any
311 | additional permissions from that copy, or from any part of it. (Additional
312 | permissions may be written to require their own removal in certain cases when you
313 | modify the work.) You may place additional permissions on material, added by you to a
314 | covered work, for which you have or can give appropriate copyright permission.
315 |
316 | Notwithstanding any other provision of this License, for material you add to a
317 | covered work, you may (if authorized by the copyright holders of that material)
318 | supplement the terms of this License with terms:
319 |
320 | * **a)** Disclaiming warranty or limiting liability differently from the terms of
321 | sections 15 and 16 of this License; or
322 | * **b)** Requiring preservation of specified reasonable legal notices or author
323 | attributions in that material or in the Appropriate Legal Notices displayed by works
324 | containing it; or
325 | * **c)** Prohibiting misrepresentation of the origin of that material, or requiring that
326 | modified versions of such material be marked in reasonable ways as different from the
327 | original version; or
328 | * **d)** Limiting the use for publicity purposes of names of licensors or authors of the
329 | material; or
330 | * **e)** Declining to grant rights under trademark law for use of some trade names,
331 | trademarks, or service marks; or
332 | * **f)** Requiring indemnification of licensors and authors of that material by anyone
333 | who conveys the material (or modified versions of it) with contractual assumptions of
334 | liability to the recipient, for any liability that these contractual assumptions
335 | directly impose on those licensors and authors.
336 |
337 | All other non-permissive additional terms are considered “further
338 | restrictions” within the meaning of section 10. If the Program as you received
339 | it, or any part of it, contains a notice stating that it is governed by this License
340 | along with a term that is a further restriction, you may remove that term. If a
341 | license document contains a further restriction but permits relicensing or conveying
342 | under this License, you may add to a covered work material governed by the terms of
343 | that license document, provided that the further restriction does not survive such
344 | relicensing or conveying.
345 |
346 | If you add terms to a covered work in accord with this section, you must place, in
347 | the relevant source files, a statement of the additional terms that apply to those
348 | files, or a notice indicating where to find the applicable terms.
349 |
350 | Additional terms, permissive or non-permissive, may be stated in the form of a
351 | separately written license, or stated as exceptions; the above requirements apply
352 | either way.
353 |
354 | ### 8. Termination.
355 |
356 | You may not propagate or modify a covered work except as expressly provided under
357 | this License. Any attempt otherwise to propagate or modify it is void, and will
358 | automatically terminate your rights under this License (including any patent licenses
359 | granted under the third paragraph of section 11).
360 |
361 | However, if you cease all violation of this License, then your license from a
362 | particular copyright holder is reinstated (a) provisionally, unless and until the
363 | copyright holder explicitly and finally terminates your license, and (b) permanently,
364 | if the copyright holder fails to notify you of the violation by some reasonable means
365 | prior to 60 days after the cessation.
366 |
367 | Moreover, your license from a particular copyright holder is reinstated permanently
368 | if the copyright holder notifies you of the violation by some reasonable means, this
369 | is the first time you have received notice of violation of this License (for any
370 | work) from that copyright holder, and you cure the violation prior to 30 days after
371 | your receipt of the notice.
372 |
373 | Termination of your rights under this section does not terminate the licenses of
374 | parties who have received copies or rights from you under this License. If your
375 | rights have been terminated and not permanently reinstated, you do not qualify to
376 | receive new licenses for the same material under section 10.
377 |
378 | ### 9. Acceptance Not Required for Having Copies.
379 |
380 | You are not required to accept this License in order to receive or run a copy of the
381 | Program. Ancillary propagation of a covered work occurring solely as a consequence of
382 | using peer-to-peer transmission to receive a copy likewise does not require
383 | acceptance. However, nothing other than this License grants you permission to
384 | propagate or modify any covered work. These actions infringe copyright if you do not
385 | accept this License. Therefore, by modifying or propagating a covered work, you
386 | indicate your acceptance of this License to do so.
387 |
388 | ### 10. Automatic Licensing of Downstream Recipients.
389 |
390 | Each time you convey a covered work, the recipient automatically receives a license
391 | from the original licensors, to run, modify and propagate that work, subject to this
392 | License. You are not responsible for enforcing compliance by third parties with this
393 | License.
394 |
395 | An “entity transaction” is a transaction transferring control of an
396 | organization, or substantially all assets of one, or subdividing an organization, or
397 | merging organizations. If propagation of a covered work results from an entity
398 | transaction, each party to that transaction who receives a copy of the work also
399 | receives whatever licenses to the work the party's predecessor in interest had or
400 | could give under the previous paragraph, plus a right to possession of the
401 | Corresponding Source of the work from the predecessor in interest, if the predecessor
402 | has it or can get it with reasonable efforts.
403 |
404 | You may not impose any further restrictions on the exercise of the rights granted or
405 | affirmed under this License. For example, you may not impose a license fee, royalty,
406 | or other charge for exercise of rights granted under this License, and you may not
407 | initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging
408 | that any patent claim is infringed by making, using, selling, offering for sale, or
409 | importing the Program or any portion of it.
410 |
411 | ### 11. Patents.
412 |
413 | A “contributor” is a copyright holder who authorizes use under this
414 | License of the Program or a work on which the Program is based. The work thus
415 | licensed is called the contributor's “contributor version”.
416 |
417 | A contributor's “essential patent claims” are all patent claims owned or
418 | controlled by the contributor, whether already acquired or hereafter acquired, that
419 | would be infringed by some manner, permitted by this License, of making, using, or
420 | selling its contributor version, but do not include claims that would be infringed
421 | only as a consequence of further modification of the contributor version. For
422 | purposes of this definition, “control” includes the right to grant patent
423 | sublicenses in a manner consistent with the requirements of this License.
424 |
425 | Each contributor grants you a non-exclusive, worldwide, royalty-free patent license
426 | under the contributor's essential patent claims, to make, use, sell, offer for sale,
427 | import and otherwise run, modify and propagate the contents of its contributor
428 | version.
429 |
430 | In the following three paragraphs, a “patent license” is any express
431 | agreement or commitment, however denominated, not to enforce a patent (such as an
432 | express permission to practice a patent or covenant not to sue for patent
433 | infringement). To “grant” such a patent license to a party means to make
434 | such an agreement or commitment not to enforce a patent against the party.
435 |
436 | If you convey a covered work, knowingly relying on a patent license, and the
437 | Corresponding Source of the work is not available for anyone to copy, free of charge
438 | and under the terms of this License, through a publicly available network server or
439 | other readily accessible means, then you must either (1) cause the Corresponding
440 | Source to be so available, or (2) arrange to deprive yourself of the benefit of the
441 | patent license for this particular work, or (3) arrange, in a manner consistent with
442 | the requirements of this License, to extend the patent license to downstream
443 | recipients. “Knowingly relying” means you have actual knowledge that, but
444 | for the patent license, your conveying the covered work in a country, or your
445 | recipient's use of the covered work in a country, would infringe one or more
446 | identifiable patents in that country that you have reason to believe are valid.
447 |
448 | If, pursuant to or in connection with a single transaction or arrangement, you
449 | convey, or propagate by procuring conveyance of, a covered work, and grant a patent
450 | license to some of the parties receiving the covered work authorizing them to use,
451 | propagate, modify or convey a specific copy of the covered work, then the patent
452 | license you grant is automatically extended to all recipients of the covered work and
453 | works based on it.
454 |
455 | A patent license is “discriminatory” if it does not include within the
456 | scope of its coverage, prohibits the exercise of, or is conditioned on the
457 | non-exercise of one or more of the rights that are specifically granted under this
458 | License. You may not convey a covered work if you are a party to an arrangement with
459 | a third party that is in the business of distributing software, under which you make
460 | payment to the third party based on the extent of your activity of conveying the
461 | work, and under which the third party grants, to any of the parties who would receive
462 | the covered work from you, a discriminatory patent license (a) in connection with
463 | copies of the covered work conveyed by you (or copies made from those copies), or (b)
464 | primarily for and in connection with specific products or compilations that contain
465 | the covered work, unless you entered into that arrangement, or that patent license
466 | was granted, prior to 28 March 2007.
467 |
468 | Nothing in this License shall be construed as excluding or limiting any implied
469 | license or other defenses to infringement that may otherwise be available to you
470 | under applicable patent law.
471 |
472 | ### 12. No Surrender of Others' Freedom.
473 |
474 | If conditions are imposed on you (whether by court order, agreement or otherwise)
475 | that contradict the conditions of this License, they do not excuse you from the
476 | conditions of this License. If you cannot convey a covered work so as to satisfy
477 | simultaneously your obligations under this License and any other pertinent
478 | obligations, then as a consequence you may not convey it at all. For example, if you
479 | agree to terms that obligate you to collect a royalty for further conveying from
480 | those to whom you convey the Program, the only way you could satisfy both those terms
481 | and this License would be to refrain entirely from conveying the Program.
482 |
483 | ### 13. Use with the GNU Affero General Public License.
484 |
485 | Notwithstanding any other provision of this License, you have permission to link or
486 | combine any covered work with a work licensed under version 3 of the GNU Affero
487 | General Public License into a single combined work, and to convey the resulting work.
488 | The terms of this License will continue to apply to the part which is the covered
489 | work, but the special requirements of the GNU Affero General Public License, section
490 | 13, concerning interaction through a network will apply to the combination as such.
491 |
492 | ### 14. Revised Versions of this License.
493 |
494 | The Free Software Foundation may publish revised and/or new versions of the GNU
495 | General Public License from time to time. Such new versions will be similar in spirit
496 | to the present version, but may differ in detail to address new problems or concerns.
497 |
498 | Each version is given a distinguishing version number. If the Program specifies that
499 | a certain numbered version of the GNU General Public License “or any later
500 | version” applies to it, you have the option of following the terms and
501 | conditions either of that numbered version or of any later version published by the
502 | Free Software Foundation. If the Program does not specify a version number of the GNU
503 | General Public License, you may choose any version ever published by the Free
504 | Software Foundation.
505 |
506 | If the Program specifies that a proxy can decide which future versions of the GNU
507 | General Public License can be used, that proxy's public statement of acceptance of a
508 | version permanently authorizes you to choose that version for the Program.
509 |
510 | Later license versions may give you additional or different permissions. However, no
511 | additional obligations are imposed on any author or copyright holder as a result of
512 | your choosing to follow a later version.
513 |
514 | ### 15. Disclaimer of Warranty.
515 |
516 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
517 | EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
518 | PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER
519 | EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
520 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE
521 | QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
522 | DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
523 |
524 | ### 16. Limitation of Liability.
525 |
526 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY
527 | COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS
528 | PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
529 | INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
530 | PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE
531 | OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
532 | WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
533 | POSSIBILITY OF SUCH DAMAGES.
534 |
535 | ### 17. Interpretation of Sections 15 and 16.
536 |
537 | If the disclaimer of warranty and limitation of liability provided above cannot be
538 | given local legal effect according to their terms, reviewing courts shall apply local
539 | law that most closely approximates an absolute waiver of all civil liability in
540 | connection with the Program, unless a warranty or assumption of liability accompanies
541 | a copy of the Program in return for a fee.
542 |
543 | END OF TERMS AND CONDITIONS
544 |
545 | ## How to Apply These Terms to Your New Programs
546 |
547 | If you develop a new program, and you want it to be of the greatest possible use to
548 | the public, the best way to achieve this is to make it free software which everyone
549 | can redistribute and change under these terms.
550 |
551 | To do so, attach the following notices to the program. It is safest to attach them
552 | to the start of each source file to most effectively state the exclusion of warranty;
553 | and each file should have at least the “copyright” line and a pointer to
554 | where the full notice is found.
555 |
556 |
557 | Copyright (C)
558 |
559 | This program is free software: you can redistribute it and/or modify
560 | it under the terms of the GNU General Public License as published by
561 | the Free Software Foundation, either version 3 of the License, or
562 | (at your option) any later version.
563 |
564 | This program is distributed in the hope that it will be useful,
565 | but WITHOUT ANY WARRANTY; without even the implied warranty of
566 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
567 | GNU General Public License for more details.
568 |
569 | You should have received a copy of the GNU General Public License
570 | along with this program. If not, see .
571 |
572 | Also add information on how to contact you by electronic and paper mail.
573 |
574 | If the program does terminal interaction, make it output a short notice like this
575 | when it starts in an interactive mode:
576 |
577 | Copyright (C)
578 | This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'.
579 | This is free software, and you are welcome to redistribute it
580 | under certain conditions; type 'show c' for details.
581 |
582 | The hypothetical commands 'show w' and 'show c' should show the appropriate parts of
583 | the General Public License. Of course, your program's commands might be different;
584 | for a GUI interface, you would use an “about box”.
585 |
586 | You should also get your employer (if you work as a programmer) or school, if any, to
587 | sign a “copyright disclaimer” for the program, if necessary. For more
588 | information on this, and how to apply and follow the GNU GPL, see
589 | <>.
590 |
591 | The GNU General Public License does not permit incorporating your program into
592 | proprietary programs. If your program is a subroutine library, you may consider it
593 | more useful to permit linking proprietary applications with the library. If this is
594 | what you want to do, use the GNU Lesser General Public License instead of this
595 | License. But first, please read
596 | <>.
--------------------------------------------------------------------------------