package/gluon-web/luasrc/usr/lib/lua/gluon/web/http.lua

+-- Copyright 2008 Steven Barth <steven@midlink.org>
+-- Copyright 2017 Matthias Schiffer <mschiffer@universe-factory.net>
+-- Licensed to the public under the Apache License 2.0.
+
+local protocol = require "gluon.web.http.protocol"
+local util  = require "gluon.web.util"
+
+
+local M = {}
+
+local Http = util.class()
+M.Http = Http
+
+function Http:__init__(env, input, output)
+	self.input = input
+	self.output = output
+
+	self.request = {
+		env = env,
+		headers = {},
+		params = protocol.urldecode_params(env.QUERY_STRING or ""),
+	}
+	self.headers = {}
+end
+
+local function push_headers(self)
+	if self.eoh then return end
+
+	for _, header in pairs(self.headers) do
+		self.output:write(string.format("%s: %s\r\n", header[1], header[2]))
+	end
+	self.output:write("\r\n")
+
+	self.eoh = true
+end
+
+function Http:parse_input(filehandler)
+	protocol.parse_message_body(
+		self.input,
+		self.request,
+		filehandler
+	)
+end
+
+function Http:formvalue(name)
+	return self:formvaluetable(name)[1]
+end
+
+function Http:formvaluetable(name)
+	return self.request.params[name] or {}
+end
+
+function Http:getcookie(name)
+	local c = string.gsub(";" .. (self:getenv("HTTP_COOKIE") or "") .. ";", "%s*;%s*", ";")
+	local p = ";" .. name .. "=(.-);"
+	local _, _, value = c:find(p)
+	return value and protocol.urldecode(value)
+end
+
+function Http:getenv(name)
+	return self.request.env[name]
+end
+
+function Http:close()
+	if not self.output then return end
+
+	push_headers(self)
+
+	self.output:flush()
+	self.output:close()
+	self.output = nil
+end
+
+function Http:header(key, value)
+	self.headers[key:lower()] = {key, value}
+end
+
+function Http:prepare_content(mime)
+	if self.headers["content-type"] then return end
+
+	self:header("Content-Type", mime)
+end
+
+function Http:status(code, request)
+	if not self.output or self.code then return end
+
+	code = code or 200
+	request = request or "OK"
+	self.code = code
+	self.output:write(string.format("Status: %i %s\r\n", code, request))
+end
+
+function Http:write(content)
+	if not self.output then return end
+
+	self:status()
+
+	self:prepare_content("text/html; charset=utf-8")
+
+	if not self.headers["cache-control"] then
+		self:header("Cache-Control", "no-cache")
+		self:header("Expires", "0")
+	end
+
+	push_headers(self)
+	self.output:write(content)
+end
+
+function Http:redirect(url)
+	self:status(302, "Found")
+	self:header("Location", url)
+	self:close()
+end
+
+return M

package/gluon-web/luasrc/usr/lib/lua/gluon/web/http/protocol.lua

+-- Copyright 2008 Freifunk Leipzig / Jo-Philipp Wich <jow@openwrt.org>
+-- Copyright 2017 Matthias Schiffer <mschiffer@universe-factory.net>
+-- Licensed to the public under the Apache License 2.0.
+
+-- This class contains several functions useful for http message- and content
+-- decoding and to retrieve form data from raw http messages.
+
+local M = {}
+
+local function pump(src, snk)
+	while true do
+		local chunk, src_err = src()
+		local ret, snk_err = snk(chunk, src_err)
+
+		if not (chunk and ret) then
+			local err = src_err or snk_err
+			if err then
+				return nil, err
+			else
+				return true
+			end
+		end
+	end
+end
+
+function M.urlencode(s)
+	return (string.gsub(s, '[^a-zA-Z0-9%-_%.~]',
+		function(c)
+			local ret = ''
+
+			for i = 1, string.len(c) do
+				ret = ret .. string.format('%%%02X', string.byte(c, i, i))
+			end
+
+			return ret
+		end
+	))
+end
+
+-- the "+" sign to " " - and return the decoded string.
+function M.urldecode(str, no_plus)
+
+	local function chrdec(hex)
+		return string.char(tonumber(hex, 16))
+	end
+
+	if type(str) == "string" then
+		if not no_plus then
+			str = str:gsub("+", " ")
+		end
+
+		str = str:gsub("%%(%x%x)", chrdec)
+	end
+
+	return str
+end
+
+local function initval(tbl, key)
+	if not tbl[key] then
+		tbl[key] = {}
+	end
+
+	table.insert(tbl[key], "")
+end
+
+local function appendval(tbl, key, chunk)
+	local t = tbl[key]
+	t[#t] = t[#t] .. chunk
+end
+
+-- from given url or string. Returns a table with urldecoded values.
+-- Simple parameters are stored as string values associated with the parameter
+-- name within the table. Parameters with multiple values are stored as array
+-- containing the corresponding values.
+function M.urldecode_params(url)
+	local params = {}
+
+	if url:find("?") then
+		url = url:gsub("^.+%?([^?]+)", "%1")
+	end
+
+	for pair in url:gmatch("[^&;]+") do
+
+		-- find key and value
+		local key = M.urldecode(pair:match("^([^=]+)"))
+		local val = M.urldecode(pair:match("^[^=]+=(.+)$"))
+
+		-- store
+		if key and key:len() > 0 then
+			initval(params, key)
+			if val then
+				appendval(params, key, val)
+			end
+		end
+	end
+
+	return params
+end
+
+-- Content-Type. Stores all extracted data associated with its parameter name
+-- in the params table within the given message object. Multiple parameter
+-- values are stored as tables, ordinary ones as strings.
+-- If an optional file callback function is given then it is fed with the
+-- file contents chunk by chunk and only the extracted file name is stored
+-- within the params table. The callback function will be called subsequently
+-- with three arguments:
+--  o Table containing decoded (name, file) and raw (headers) mime header data
+--  o String value containing a chunk of the file data
+--  o Boolean which indicates whether the current chunk is the last one (eof)
+local function mimedecode_message_body(src, msg, filecb)
+	local mime_boundary = (msg.env.CONTENT_TYPE or ''):match("^multipart/form%-data; boundary=(.+)$")
+	if not mime_boundary then
+		error("Invalid Content-Type found")
+	end
+
+	local tlen   = 0
+	local inhdr  = false
+	local field  = nil
+	local store  = nil
+	local lchunk = nil
+
+	local function parse_headers(chunk, pfield)
+		local stat
+		repeat
+			chunk, stat = chunk:gsub(
+				"^([A-Z][A-Za-z0-9%-_]+): +([^\r\n]+)\r\n",
+				function(k,v)
+					pfield.headers[k] = v
+					return ""
+				end
+			)
+		until stat == 0
+
+		chunk, stat = chunk:gsub("^\r\n","")
+
+		-- End of headers
+		if stat > 0 then
+			if pfield.headers["Content-Disposition"] then
+				if pfield.headers["Content-Disposition"]:match("^form%-data; ") then
+					pfield.name = pfield.headers["Content-Disposition"]:match('name="(.-)"')
+					pfield.file = pfield.headers["Content-Disposition"]:match('filename="(.+)"$')
+				end
+			end
+
+			if not pfield.headers["Content-Type"] then
+				pfield.headers["Content-Type"] = "text/plain"
+			end
+
+
+			if pfield.name then
+				initval(msg.params, pfield.name)
+				if pfield.file then
+					appendval(msg.params, pfield.name, pfield.file)
+					store = filecb
+				else
+					store = function(_, buf, _)
+						appendval(msg.params, pfield.name, buf)
+					end
+				end
+			else
+				store = nil
+			end
+
+			return chunk, true
+		end
+
+		return chunk, false
+	end
+
+	local function snk(chunk)
+
+		tlen = tlen + (chunk and #chunk or 0)
+
+		if msg.env.CONTENT_LENGTH and tlen > tonumber(msg.env.CONTENT_LENGTH) + 2 then
+			return nil, "Message body size exceeds Content-Length"
+		end
+
+		if chunk and not lchunk then
+			lchunk = "\r\n" .. chunk
+
+		elseif lchunk then
+			local data = lchunk .. (chunk or "")
+			local spos, epos, found
+
+			repeat
+				spos, epos = data:find("\r\n--" .. mime_boundary .. "\r\n", 1, true)
+
+				if not spos then
+					spos, epos = data:find("\r\n--" .. mime_boundary .. "--\r\n", 1, true)
+				end
+
+
+				if spos then
+					local predata = data:sub(1, spos - 1)
+					local eof
+
+					if inhdr then
+						predata, eof = parse_headers(predata, field)
+
+						if not eof then
+							return nil, "Invalid MIME section header"
+						elseif not field.name then
+							return nil, "Invalid Content-Disposition header"
+						end
+					end
+
+					if store then
+						store(field, predata, true)
+					end
+
+
+					field = { headers = { } }
+					found = true
+
+					data, eof = parse_headers(data:sub(epos + 1, #data), field)
+					inhdr = not eof
+				end
+			until not spos
+
+			if found then
+				-- We found at least some boundary. Save
+				-- the unparsed remaining data for the
+				-- next chunk.
+				lchunk = data
+			else
+				-- There was a complete chunk without a boundary. Parse it as headers or
+				-- append it as data, depending on our current state.
+				if inhdr then
+					local eof
+					lchunk, eof = parse_headers(data, field)
+					inhdr = not eof
+				else
+					-- We're inside data, so append the data. Note that we only append
+					-- lchunk, not all of data, since there is a chance that chunk
+					-- contains half a boundary. Assuming that each chunk is at least the
+					-- boundary in size, this should prevent problems
+					if store then
+						store(field, lchunk, false)
+					end
+					lchunk = chunk
+				end
+			end
+		end
+
+		return true
+	end
+
+	assert(pump(src, snk))
+end
+
+local function check_post_origin(msg)
+	local default_port = '80'
+	local request_scheme = 'http'
+	if msg.env.HTTPS then
+		default_port = '443'
+		request_scheme = 'https'
+	end
+
+	local request_host = msg.env.HTTP_HOST
+	if not request_host then
+		error('POST request without Host header')
+	end
+	if not request_host:match(':[0-9]+$') then
+		request_host = request_host .. ':' .. default_port
+	end
+
+	local origin = msg.env.HTTP_ORIGIN
+	if not origin then
+		error('POST request without Origin header')
+	end
+	local origin_scheme, origin_host = origin:match('^([^:]*)://(.*)$')
+	if not origin_host then
+		error('POST request with invalid Origin header')
+	end
+	if not origin_host:match(':[0-9]+$') then
+		local origin_port
+		if origin_scheme == 'http' then
+			origin_port = '80'
+		elseif origin_scheme == 'https' then
+			origin_port = '443'
+		else
+			error('POST request with invalid Origin header')
+		end
+		origin_host = origin_host .. ':' .. origin_port
+	end
+
+	if request_scheme ~= origin_scheme or request_host ~= origin_host then
+		error('Invalid cross-origin POST')
+	end
+end
+
+-- This function will examine the Content-Type within the given message object
+-- to select the appropriate content decoder.
+-- Currently only the multipart/form-data mime type is supported.
+function M.parse_message_body(src, msg, filecb)
+	if msg.env.REQUEST_METHOD ~= "POST" then
+		return
+	end
+
+	check_post_origin(msg)
+
+	mimedecode_message_body(src, msg, filecb)
+end
+
+return M

package/gluon-web/luasrc/usr/lib/lua/gluon/web/i18n.lua

+-- Copyright 2018 Matthias Schiffer <mschiffer@universe-factory.net>
+-- Licensed to the public under the Apache License 2.0.
+
+local tparser = require 'gluon.web.template.parser'
+local unistd = require 'posix.unistd'
+
+
+return function(config)
+	local i18ndir = config.base_path .. "/i18n"
+
+
+	local function i18n_file(lang, pkg)
+		return string.format('%s/%s.%s.lmo', i18ndir, pkg, lang)
+	end
+
+	local function no_translation()
+		return nil
+	end
+
+	local function load_catalog(lang, pkg)
+		if pkg then
+			local file = i18n_file(lang, pkg)
+			local cat = unistd.access(file) and tparser.load_catalog(file)
+
+			if cat then return cat end
+		end
+
+		return no_translation
+	end
+
+
+	local i18n = {}
+
+	function i18n.supported(lang)
+		return lang == 'en' or unistd.access(i18n_file(lang, 'gluon-web'))
+	end
+
+	function i18n.load(lang, pkg)
+		local _translate = load_catalog(lang, pkg)
+
+		local function translate(key)
+			return _translate(key) or key
+		end
+
+		local function translatef(key, ...)
+			return translate(key):format(...)
+		end
+
+		return {
+			_translate = _translate,
+			translate = translate,
+			translatef = translatef,
+		}
+	end
+
+	return i18n
+end

package/gluon-web/luasrc/usr/lib/lua/gluon/web/template.lua

+-- Copyright 2008 Steven Barth <steven@midlink.org>
+-- Copyright 2017-2018 Matthias Schiffer <mschiffer@universe-factory.net>
+-- Licensed to the public under the Apache License 2.0.
+
+local tparser = require 'gluon.web.template.parser'
+
+local tostring, ipairs, setmetatable, setfenv = tostring, ipairs, setmetatable, setfenv
+local pcall, assert = pcall, assert
+
+
+return function(config, env)
+	local i18n = require('gluon.web.i18n')(config)
+
+	local viewdir = config.base_path .. '/view/'
+
+	local ctx = {}
+
+	local language = 'en'
+	local catalogs = {}
+
+	function ctx.set_language(langs)
+		for _, lang in ipairs(langs) do
+			if i18n.supported(lang) then
+				language = lang
+				catalogs = {}
+				return
+			end
+		end
+	end
+
+	function ctx.i18n(pkg)
+		local cat = catalogs[pkg] or i18n.load(language, pkg)
+		if pkg then catalogs[pkg] = cat end
+		return cat
+	end
+
+	local function render_template(name, template, scope, pkg)
+		scope = scope or {}
+		local t = ctx.i18n(pkg)
+
+		local locals = {
+			renderer = ctx,
+			i18n = ctx.i18n,
+			translate = t.translate,
+			translatef = t.translatef,
+			_translate = t._translate,
+			include = function(include_name)
+				ctx.render(include_name, scope, pkg)
+			end,
+		}
+
+		setfenv(template, setmetatable({}, {
+			__index = function(_, key)
+				return scope[key] or locals[key] or env[key]
+			end
+		}))
+
+		-- Now finally render the thing
+		local stat, err = pcall(template)
+		assert(stat, "Failed to execute template '" .. name .. "'.\n" ..
+			"A runtime error occurred: " .. tostring(err or "(nil)"))
+	end
+
+	--- Render a certain template.
+	-- @param name		Template name
+	-- @param scope		Scope to assign to template (optional)
+	-- @param pkg		i18n namespace package (optional)
+	function ctx.render(name, scope, pkg)
+		local sourcefile = viewdir .. name .. ".html"
+		local template, _, err = tparser.parse(sourcefile)
+
+		assert(template, "Failed to load template '" .. name .. "'.\n" ..
+			"Error while parsing template '" .. sourcefile .. "':\n" ..
+			(err or "Unknown syntax error"))
+
+		render_template(name, template, scope, pkg)
+	end
+
+	--- Render a template from a string.
+	-- @param template	Template string
+	-- @param scope		Scope to assign to template (optional)
+	-- @param pkg		i18n namespace package (optional)
+	function ctx.render_string(str, scope, pkg)
+		local template, _, err = tparser.parse_string(str)
+
+		assert(template, "Error while parsing template:\n" ..
+			(err or "Unknown syntax error"))
+
+		render_template('(local)', template, scope, pkg)
+	end
+
+	--- Render a template, wrapped in the configured layout.
+	-- @param name		Template name
+	-- @param scope		Scope to assign to template (optional)
+	-- @param pkg		i18n namespace package (optional)
+	-- @param layout_scope  Additional variables to pass to the layout template
+	function ctx.render_layout(name, scope, pkg, layout_scope)
+		ctx.render(config.layout_template, setmetatable({
+			content = name,
+			scope = scope,
+			pkg = pkg,
+		}, {
+			__index = layout_scope
+		}), config.layout_package)
+	end
+
+	return ctx
+end

package/gluon-web/luasrc/usr/lib/lua/gluon/web/util.lua

+-- Copyright 2008 Steven Barth <steven@midlink.org>
+-- Copyright 2017 Matthias Schiffer <mschiffer@universe-factory.net>
+-- Licensed to the public under the Apache License 2.0.
+
+local tparser = require "gluon.web.template.parser"
+
+
+local M = {}
+
+--
+-- Class helper routines
+--
+
+-- Instantiates a class
+local function _instantiate(class, ...)
+	local inst = setmetatable({}, {__index = class})
+
+	if inst.__init__ then
+		inst:__init__(...)
+	end
+
+	return inst
+end
+
+-- The class object can be instantiated by calling itself.
+-- Any class functions or shared parameters can be attached to this object.
+-- Attaching a table to the class object makes this table shared between
+-- all instances of this class. For object parameters use the __init__ function.
+-- Classes can inherit member functions and values from a base class.
+-- Class can be instantiated by calling them. All parameters will be passed
+-- to the __init__ function of this class - if such a function exists.
+-- The __init__ function must be used to set any object parameters that are not shared
+-- with other objects of this class. Any return values will be ignored.
+function M.class(base)
+	return setmetatable({}, {
+		__call  = _instantiate,
+		__index = base
+	})
+end
+
+function M.instanceof(object, class)
+	while object do
+		if object == class then
+			return true
+		end
+		local mt = getmetatable(object)
+		object = mt and mt.__index
+	end
+	return false
+end
+
+
+--
+-- String and data manipulation routines
+--
+
+function M.pcdata(value)
+	return value and tparser.pcdata(tostring(value))
+end
+
+return M

package/gluon-web/src/Makefile

+all: compile
+
+%.o: %.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) -D_GNU_SOURCE -std=c99 -Wall -Wextra -fPIC -fvisibility=hidden -c -o $@ $<
+
+clean:
+	rm -f parser.so *.o
+
+parser.so: template_parser.o template_utils.o template_lmo.o template_lualib.o
+	$(CC) $(LDFLAGS) -shared -o $@ $^
+
+gluon-po2lmo: gluon-po2lmo.o template_lmo.o
+
+compile: parser.so
+
+install: compile
+	mkdir -p $(DESTDIR)/usr/lib/lua/gluon/web/template
+	cp parser.so $(DESTDIR)/usr/lib/lua/gluon/web/template/parser.so

package/gluon-web/src/gluon-po2lmo.c

+/*
+ * lmo - Lua Machine Objects - PO to LMO conversion tool
+ *
+ *   Copyright (C) 2009-2012 Jo-Philipp Wich <jow@openwrt.org>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "template_lmo.h"
+
+#include <arpa/inet.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+
+__attribute__((noreturn))
+static void die(const char *msg)
+{
+	fprintf(stderr, "Error: %s\n", msg);
+	exit(1);
+}
+
+__attribute__((noreturn))
+static void usage(const char *name)
+{
+	fprintf(stderr, "Usage: %s input.po output.lmo\n", name);
+	exit(1);
+}
+
+static void print(const void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+	if( fwrite(ptr, size, nmemb, stream) == 0 )
+		die("Failed to write stdout");
+}
+
+static ssize_t extract_string(const char *src, char *dest, size_t len)
+{
+	size_t pos = 0;
+	int esc = 0;
+	int off = -1;
+
+	for( pos = 0; (pos < strlen(src)) && (pos < len); pos++ )
+	{
+		if( (off == -1) && (src[pos] == '"') )
+		{
+			off = pos + 1;
+		}
+		else if( off >= 0 )
+		{
+			if( esc == 1 )
+			{
+				switch (src[pos])
+				{
+				case '"':
+				case '\\':
+					off++;
+					break;
+				}
+				dest[pos-off] = src[pos];
+				esc = 0;
+			}
+			else if( src[pos] == '\\' )
+			{
+				dest[pos-off] = src[pos];
+				esc = 1;
+			}
+			else if( src[pos] != '"' )
+			{
+				dest[pos-off] = src[pos];
+			}
+			else
+			{
+				dest[pos-off] = '\0';
+				break;
+			}
+		}
+	}
+
+	return (off > -1) ? (ssize_t) strlen(dest) : -1;
+}
+
+static int cmp_index(const void *a, const void *b)
+{
+	uint32_t x = ((const lmo_entry_t *)a)->key_id;
+	uint32_t y = ((const lmo_entry_t *)b)->key_id;
+
+	if (x < y)
+		return -1;
+	else if (x > y)
+		return 1;
+
+	return 0;
+}
+
+static void print_uint32(uint32_t x, FILE *out)
+{
+	uint32_t y = htonl(x);
+	print(&y, sizeof(uint32_t), 1, out);
+}
+
+static void print_index(void *array, int n, FILE *out)
+{
+	lmo_entry_t *e;
+
+	qsort(array, n, sizeof(*e), cmp_index);
+
+	for (e = array; n > 0; n--, e++)
+	{
+		print_uint32(e->key_id, out);
+		print_uint32(e->val_id, out);
+		print_uint32(e->offset, out);
+		print_uint32(e->length, out);
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	char line[4096];
+	char key[4096];
+	char val[4096];
+	char tmp[4096];
+	int state  = 0;
+	int offset = 0;
+	int length = 0;
+	int n_entries = 0;
+	void *array = NULL;
+	lmo_entry_t *entry = NULL;
+	uint32_t key_id, val_id;
+
+	FILE *in;
+	FILE *out;
+
+	if( (argc != 3) || ((in = fopen(argv[1], "r")) == NULL) || ((out = fopen(argv[2], "w")) == NULL) )
+		usage(argv[0]);
+
+	memset(line, 0, sizeof(key));
+	memset(key, 0, sizeof(val));
+	memset(val, 0, sizeof(val));
+
+	while( (NULL != fgets(line, sizeof(line), in)) || (state >= 2 && feof(in)) )
+	{
+		if( state == 0 && strstr(line, "msgid \"") == line )
+		{
+			switch(extract_string(line, key, sizeof(key)))
+			{
+				case -1:
+					die("Syntax error in msgid");
+				case 0:
+					state = 1;
+					break;
+				default:
+					state = 2;
+			}
+		}
+		else if( state == 1 || state == 2 )
+		{
+			if( strstr(line, "msgstr \"") == line || state == 2 )
+			{
+				switch(extract_string(line, val, sizeof(val)))
+				{
+					case -1:
+						state = 4;
+						break;
+					default:
+						state = 3;
+				}
+			}
+			else
+			{
+				switch(extract_string(line, tmp, sizeof(tmp)))
+				{
+					case -1:
+						state = 2;
+						break;
+					default:
+						strcat(key, tmp);
+				}
+			}
+		}
+		else if( state == 3 )
+		{
+			switch(extract_string(line, tmp, sizeof(tmp)))
+			{
+				case -1:
+					state = 4;
+					break;
+				default:
+					strcat(val, tmp);
+			}
+		}
+
+		if( state == 4 )
+		{
+			if( strlen(key) > 0 && strlen(val) > 0 )
+			{
+				key_id = sfh_hash(key, strlen(key));
+				val_id = sfh_hash(val, strlen(val));
+
+				if( key_id != val_id )
+				{
+					n_entries++;
+					array = realloc(array, n_entries * sizeof(lmo_entry_t));
+					entry = (lmo_entry_t *)array + n_entries - 1;
+
+					if (!array)
+						die("Out of memory");
+
+					entry->key_id = key_id;
+					entry->val_id = val_id;
+					entry->offset = offset;
+					entry->length = strlen(val);
+
+					length = strlen(val) + ((4 - (strlen(val) % 4)) % 4);
+
+					print(val, length, 1, out);
+					offset += length;
+				}
+			}
+
+			state = 0;
+			memset(key, 0, sizeof(key));
+			memset(val, 0, sizeof(val));
+		}
+
+		memset(line, 0, sizeof(line));
+	}
+
+	print_index(array, n_entries, out);
+
+	if( offset > 0 )
+	{
+		print_uint32(offset, out);
+		fsync(fileno(out));
+		fclose(out);
+	}
+	else
+	{
+		fclose(out);
+		unlink(argv[2]);
+	}
+
+	fclose(in);
+	return(0);
+}