279 lines
6.0 KiB
Plaintext
279 lines
6.0 KiB
Plaintext
#!/usr/bin/ucode
|
|
'use strict';
|
|
|
|
import * as fs from 'fs';
|
|
|
|
const default_dir = ARGV[0] || '/tmp';
|
|
const content_type = getenv('CONTENT_TYPE') || '';
|
|
let input_available = +getenv('CONTENT_LENGTH') || 0;
|
|
let input = fs.fdopen(0, 'r');
|
|
let output = fs.fdopen(1, 'w');
|
|
let error = fs.fdopen(2, 'w');
|
|
let pending = '';
|
|
let target_tmp = null;
|
|
|
|
function cleanup() {
|
|
if (target_tmp)
|
|
fs.unlink(target_tmp);
|
|
}
|
|
|
|
function fail(message) {
|
|
cleanup();
|
|
error.write('ОШИБКА: ' + message + '\n');
|
|
exit(1);
|
|
}
|
|
|
|
function ok(message) {
|
|
output.write(message + '\n');
|
|
}
|
|
|
|
function valid_path(path) {
|
|
return type(path) == 'string' && match(path, /^\/[A-Za-z0-9._\/-]+$/);
|
|
}
|
|
|
|
function safe_filename(name) {
|
|
name = name != null ? '' + name : '';
|
|
name = replace(name, /\\/g, '/');
|
|
name = fs.basename(name);
|
|
return replace(name, /[^A-Za-z0-9._-]/g, '_');
|
|
}
|
|
|
|
function trim_crlf(line) {
|
|
line = line != null ? '' + line : '';
|
|
line = replace(line, /\r\n$/, '');
|
|
return replace(line, /\n$/, '');
|
|
}
|
|
|
|
function append_array(array, value) {
|
|
array[length(array)] = value;
|
|
}
|
|
|
|
function concat_array(array, separator) {
|
|
let result = '';
|
|
|
|
for (let i = 0; i < length(array); i++) {
|
|
if (i > 0)
|
|
result += separator;
|
|
|
|
result += array[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function read_from_stdin(size) {
|
|
if (input_available <= 0)
|
|
return null;
|
|
|
|
size = size != null ? size : 8192;
|
|
let chunk = input.read(min(input_available, size, 8192));
|
|
|
|
if (chunk == null) {
|
|
input_available = 0;
|
|
return null;
|
|
}
|
|
|
|
input_available -= length(chunk);
|
|
return chunk;
|
|
}
|
|
|
|
function read_line() {
|
|
while (true) {
|
|
let pos = index(pending, '\n');
|
|
|
|
if (pos != null && pos >= 0) {
|
|
let line = substr(pending, 0, pos + 1);
|
|
pending = substr(pending, pos + 1);
|
|
return line;
|
|
}
|
|
|
|
let chunk = read_from_stdin(1024);
|
|
|
|
if (chunk == null) {
|
|
if (length(pending) > 0) {
|
|
let line = pending;
|
|
pending = '';
|
|
return line;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
pending += chunk;
|
|
}
|
|
}
|
|
|
|
let boundary_match = match(content_type, /boundary="?([^";]+)"?/);
|
|
let boundary = boundary_match ? boundary_match[1] : null;
|
|
|
|
if (!boundary)
|
|
fail('multipart boundary не найден');
|
|
|
|
if (input_available <= 0)
|
|
fail('пустой upload');
|
|
|
|
const marker = '--' + boundary;
|
|
const delimiter = '\r\n' + marker;
|
|
|
|
let first_line = trim_crlf(read_line());
|
|
if (first_line != marker)
|
|
fail('multipart boundary не найден в теле запроса');
|
|
|
|
function read_headers() {
|
|
let headers = [];
|
|
|
|
while (true) {
|
|
let line = read_line();
|
|
|
|
if (line == null)
|
|
fail('не удалось прочитать заголовки upload');
|
|
|
|
line = trim_crlf(line);
|
|
|
|
if (line == '')
|
|
break;
|
|
|
|
append_array(headers, line);
|
|
}
|
|
|
|
return concat_array(headers, '\n');
|
|
}
|
|
|
|
function read_part(out, max_text) {
|
|
let keep = length(delimiter) + 4;
|
|
let buffer = '';
|
|
let text = [];
|
|
let text_size = 0;
|
|
let part_size = 0;
|
|
|
|
function consume(data) {
|
|
if (data == null || length(data) == 0)
|
|
return;
|
|
|
|
part_size += length(data);
|
|
|
|
if (out) {
|
|
out.write(data);
|
|
return;
|
|
}
|
|
|
|
text_size += length(data);
|
|
|
|
max_text = max_text != null ? max_text : 4096;
|
|
|
|
if (text_size > max_text)
|
|
fail('поле формы слишком большое');
|
|
|
|
append_array(text, data);
|
|
}
|
|
|
|
while (true) {
|
|
let chunk;
|
|
|
|
if (length(pending) > 0) {
|
|
chunk = pending;
|
|
pending = '';
|
|
}
|
|
else {
|
|
chunk = read_from_stdin(8192);
|
|
}
|
|
|
|
if (chunk == null)
|
|
fail('не найден конец multipart upload');
|
|
|
|
buffer += chunk;
|
|
|
|
let start_pos = index(buffer, delimiter);
|
|
|
|
if (start_pos != null && start_pos >= 0) {
|
|
consume(substr(buffer, 0, start_pos));
|
|
|
|
let after = start_pos + length(delimiter);
|
|
let final = false;
|
|
|
|
if (substr(buffer, after, 2) == '--') {
|
|
final = true;
|
|
after += 2;
|
|
}
|
|
|
|
if (substr(buffer, after, 2) == '\r\n')
|
|
after += 2;
|
|
|
|
pending = substr(buffer, after);
|
|
return [ final, concat_array(text, ''), part_size ];
|
|
}
|
|
|
|
if (length(buffer) > keep) {
|
|
consume(substr(buffer, 0, length(buffer) - keep));
|
|
buffer = substr(buffer, length(buffer) - keep);
|
|
}
|
|
}
|
|
}
|
|
|
|
let upload_dir = default_dir;
|
|
let saved_path = null;
|
|
let saved_size = 0;
|
|
let final = false;
|
|
|
|
while (!final) {
|
|
let headers = read_headers();
|
|
let disposition_match = match(headers, /[Cc]ontent-[Dd]isposition:\s*([^\n]+)/);
|
|
let disposition = disposition_match ? disposition_match[1] : null;
|
|
let name_match = disposition ? match(disposition, /name="([^"]+)"/) : null;
|
|
let filename_match = disposition ? match(disposition, /filename="([^"]*)"/) : null;
|
|
let name = name_match ? name_match[1] : null;
|
|
let filename = filename_match ? filename_match[1] : null;
|
|
|
|
if (name == 'upload_dir' && filename == null) {
|
|
let part = read_part(null, 4096);
|
|
final = part[0];
|
|
upload_dir = part[1] != null ? '' + part[1] : '';
|
|
upload_dir = replace(upload_dir, /[\r\n]/g, '');
|
|
}
|
|
else if (name == 'archive' && filename != null && filename != '') {
|
|
if (!valid_path(upload_dir))
|
|
fail('неверная папка для загрузки: ' + upload_dir);
|
|
|
|
let file_name = safe_filename(filename);
|
|
|
|
if (!file_name)
|
|
fail('файл архива не выбран');
|
|
|
|
if (!match(file_name, /\.tar\.gz$/))
|
|
fail('можно загружать только архивы .tar.gz');
|
|
|
|
fs.mkdir(upload_dir, 0755);
|
|
|
|
let target = replace(upload_dir, /\/+$/, '') + '/' + file_name;
|
|
target_tmp = target + '.uploading.' + time() + '.' + input_available;
|
|
|
|
let out = fs.open(target_tmp, 'w', 384);
|
|
if (!out)
|
|
fail('не удалось открыть файл для записи: ' + target);
|
|
|
|
let part = read_part(out, 0);
|
|
final = part[0];
|
|
saved_size = part[2];
|
|
out.close();
|
|
|
|
if (saved_size <= 0)
|
|
fail('файл пустой');
|
|
|
|
if (!fs.rename(target_tmp, target))
|
|
fail('не удалось сохранить файл: ' + target);
|
|
|
|
target_tmp = null;
|
|
saved_path = target;
|
|
}
|
|
else {
|
|
let part = read_part(null, 1024);
|
|
final = part[0];
|
|
}
|
|
}
|
|
|
|
if (!saved_path)
|
|
fail('файл архива не выбран');
|
|
|
|
ok('Архив загружен: ' + saved_path);
|
|
ok('Размер: ' + saved_size + ' байт');
|