ooxml_crypt 0.1.0

data/vendor/cybozulib/include/cybozu/parallel.hpp

@@ -0,0 +1,88 @@
+#pragma once
+/**
+	@file
+	@brief parallel for
+	@author MITSUNARI Shigeo(@herumi)
+	@license modified new BSD license
+	http://opensource.org/licenses/BSD-3-Clause
+*/
+#include <cybozu/exception.hpp>
+#include <cybozu/thread.hpp>
+#include <cybozu/array.hpp>
+
+namespace cybozu {
+
+namespace parallel_util {
+
+template<class T, class N>
+struct Thread : public cybozu::ThreadBase {
+	T *t_;
+	N begin_;
+	N end_;
+	N threadIdx_;
+	std::string err_;
+	Thread()
+		: t_(0)
+		, begin_(0)
+		, end_(0)
+		, threadIdx_(0)
+	{
+	}
+	void init(T& t, N begin, N end, N threadIdx)
+	{
+		t_ = &t;
+		begin_ = begin;
+		end_ = end;
+		threadIdx_ = threadIdx;
+		err_.clear();
+	}
+	void threadEntry()
+	{
+		for (N i = begin_; i < end_; i++) {
+			try {
+				if (!(*t_)(i, threadIdx_)) break;
+			} catch (std::exception& e) {
+				err_ = e.what();
+				break;
+			}
+		}
+	}
+	const std::string& getErr() const { return err_; }
+};
+
+} // parallel_util
+/*
+	void T::f(N i, size_t threadIdx);
+*/
+template<class T, class N>
+void parallel_for(T& target, N n, N threadNum)
+{
+	if (n == 0) return;
+	if (threadNum == 0) throw cybozu::Exception("cybozu:parallel_for:threadNum is zero");
+	if ((N)threadNum > n) threadNum = (size_t)n;
+	typedef parallel_util::Thread<T, N> Thread;
+	{
+		cybozu::ScopedArray<Thread> thread(threadNum);
+		const N q = N(n / threadNum);
+		const N r = N(n % threadNum);
+		N begin = 0;
+		for (N i = 0; i < threadNum; i++) {
+			N end = begin + q;
+			if (i < r) end++;
+			thread[i].init(target, begin, end, i);
+			begin = end;
+		}
+		for (N i = 0; i < threadNum; i++) {
+			if (!thread[i].beginThread()) throw cybozu::Exception("cybozu:parallel_for:can't beginThread") << i;
+		}
+		for (N i = 0; i < threadNum; i++) {
+			if (!thread[i].joinThread()) throw cybozu::Exception("cybozu:parallel_for:can't joinThread") << i;
+		}
+		for (N i = 0; i < threadNum; i++) {
+			const std::string& err = thread[i].getErr();
+			if (!err.empty()) throw cybozu::Exception("cybozu:paralell_for") << i << err;
+		}
+	}
+}
+
+} // cybozu

data/vendor/cybozulib/include/cybozu/pcg.hpp

@@ -0,0 +1,72 @@
+#pragma once
+/**
+	@file
+	@brief PCG
+	@see http://www.pcg-random.org/
+
+	@author MITSUNARI Shigeo(@herumi)
+	@author MITSUNARI Shigeo
+*/
+#include <cybozu/inttype.hpp>
+#include <stdlib.h> // for _rotr
+
+namespace cybozu {
+
+class Pcg32 {
+public:
+	uint64_t state;
+	uint32_t rotr(uint32_t x, uint32_t r) const
+	{
+#if defined(__GNUC__) && (CYBOZU_HOST == CYBOZU_HOST_INTEL)
+		__asm__ volatile("rorl %%cl, %0" : "=r"(x) : "0"(x), "c"(r));
+		return x;
+#elif defined(_MSC_VER)
+		return _rotr(x, r);
+#else
+		return (x >> r) | (x << ((-r) & 31));
+#endif
+	}
+public:
+	explicit Pcg32(uint64_t state = uint64_t(0x185706b82c2e03f8ULL))
+		: state(state)
+	{
+	}
+	uint32_t get32()
+	{
+		uint64_t old = state;
+		state = old * 6364136223846793005ULL + 0x6d;
+		uint32_t x = uint32_t(((old >> 18u) ^ old) >> 27u);
+		uint32_t r = uint32_t(old >> 59u);
+		return rotr(x, r);
+	}
+	uint32_t operator()() { return get32(); }
+	uint64_t get64()
+	{
+		uint32_t a = get32();
+		uint32_t b = get32();
+		return (uint64_t(a) << 32) | b;
+	}
+	template<class T>
+	void read(T *x, size_t n)
+	{
+		const size_t size = sizeof(T) * n;
+		uint8_t *p8 = static_cast<uint8_t*>(x);
+		for (size_t i = 0; i < size; i++) {
+			p8[i] = static_cast<uint8_t>(get32());
+		}
+	}
+	void read(uint32_t *x, size_t n)
+	{
+		for (size_t i = 0; i < n; i++) {
+			x[i] = get32();
+		}
+	}
+	void read(uint64_t *x, size_t n)
+	{
+		for (size_t i = 0; i < n; i++) {
+			x[i] = get64();
+		}
+	}
+};
+
+} // cybozu

data/vendor/cybozulib/include/cybozu/process.hpp

@@ -0,0 +1,324 @@
+#pragma once
+
+/**
+    @file
+    @brief process class
+
+    @author MITSUNARI Shigeo(@herumi)
+    @author MITSUNARI Shigeo
+*/
+#include <vector>
+#include <string>
+#include <assert.h>
+#include <cybozu/exception.hpp>
+
+#ifdef _WIN32
+	#ifndef WIN32_LEAN_AND_MEAN
+		#define WIN32_LEAN_AND_MEAN
+	#endif
+	#include <windows.h>
+#else
+	#include <unistd.h>
+	#include <fcntl.h>
+	#include <sys/types.h>
+	#include <sys/wait.h>
+	#include <stdlib.h>
+#endif
+
+namespace cybozu {
+
+namespace process {
+
+#ifdef _WIN32
+typedef HANDLE Handle;
+const Handle InvalidHandle = (Handle)0;
+#else
+typedef pid_t Handle;
+const Handle InvalidHandle = (Handle)-1;
+#endif
+
+#ifndef _WIN32
+class Pipe {
+	int fd_[2];
+public:
+	enum Mode {
+		Read = 0,
+		Write = 1
+	};
+	Pipe()
+	{
+		fd_[0] = fd_[1] = -1;
+	}
+	bool init()
+	{
+		if (::pipe (fd_) < 0) {
+			return false;
+		}
+		if (::fcntl (fd_[Write], F_SETFD, FD_CLOEXEC) < 0) {
+			return false;
+		}
+		return true;
+	}
+	void close(Mode mode)
+	{
+		if (fd_[mode] != -1) {
+			::close(fd_[mode]);
+			fd_[mode] = -1;
+		}
+	}
+	int write(const char* buf, size_t size)
+	{
+		return ::write(fd_[Write], buf, size);
+	}
+	int read(char* buf, size_t size)
+	{
+		return ::read(fd_[Read], buf, size);
+	}
+	~Pipe()
+	{
+		close(Read);
+		close(Write);
+	}
+};
+
+bool toDevNull(int fd, int flags)
+{
+	int newFd = open("/dev/null", flags);
+
+	if (newFd < 0) return false;
+
+	int ret = dup2(newFd, fd);
+	close(newFd);
+	return ret >= 0;
+}
+
+#endif
+
+inline std::string escape(const std::string& in)
+{
+	std::string out;
+	for (size_t i = 0, n = in.size(); i < n; i++) {
+		char c = in[i];
+		if (c == '"') {
+			out += "\\\"";
+		} else {
+			out += c;
+		}
+	}
+	return out;
+}
+
+/**
+	start process and return the handle of it
+	argv[0] = exe
+*/
+static inline bool Start(Handle* hdl, const std::string& exe, const std::vector<std::string>& arg, bool closeStdio = true)
+{
+#ifdef _WIN32
+	cybozu::disable_warning_unused_variable(closeStdio);
+	PROCESS_INFORMATION pi;
+	STARTUPINFO si;
+	memset(&si, 0, sizeof(si));
+	si.cb = sizeof(si);
+	std::string cmdLine = "\"" + exe + '"';
+
+	for (size_t i = 0, n = arg.size(); i < n; i++) {
+		cmdLine += " \"" + escape(arg[i]) + '"';
+	}
+
+	cmdLine += '\0';
+
+	if (!CreateProcess(exe.c_str(), &cmdLine[0], NULL, NULL, FALSE
+		/* Advanced Windows p.123 */
+		, CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP | CREATE_DEFAULT_ERROR_MODE, NULL, 0, &si, &pi)) {
+		return false;
+	}
+
+	if (pi.hThread) CloseHandle(pi.hThread);
+
+//  if (pi.hProcess) CloseHandle(pi.hProcess);
+	*hdl = pi.hProcess;
+	return true;
+#else
+	Pipe pipe;
+
+	if (!pipe.init()) {
+		return false;
+	}
+
+	pid_t pid = fork();
+
+	if (pid < 0) {
+		return false;
+
+	} else if (pid == 0) {
+		pipe.close(Pipe::Read);
+		std::vector<char*> argv;
+		argv.push_back(const_cast<char*>(exe.c_str()));
+
+		for (size_t i = 0, n = arg.size(); i < n; i++) {
+			argv.push_back(const_cast<char*>(arg[i].c_str()));
+		}
+
+		argv.push_back(0);
+
+		if (closeStdio) {
+			if (!toDevNull(0, O_RDONLY)) goto ERR_EXIT;
+			if (!toDevNull(1, O_RDWR)) goto ERR_EXIT;
+			if (!toDevNull(2, O_RDWR)) goto ERR_EXIT;
+		}
+		{
+			const int ret = static_cast<int>(sysconf(_SC_OPEN_MAX));
+			const int maxFd = ret < 0 ? 1024 : maxFd;
+			for (int i = 3; i < maxFd; i++) {
+				close(i);
+			}
+		}
+
+		execv(exe.c_str(), &argv[0]);
+ERR_EXIT:
+		/*
+			write pipe if execv fails
+		*/
+		pipe.write("x", 1);
+		pipe.close(Pipe::Write);
+		::exit(1);
+	}
+
+	pipe.close(Pipe::Write);
+	char buf[1];
+
+	/*
+		if execv succeeds then Pipe::Read is closed and returns error
+		otherwise gets 'x' from child
+	*/
+	if (pipe.read(buf, 1) == 1) {
+		waitpid(pid, 0, WNOHANG);
+		return false;
+	}
+
+	*hdl = pid;
+	return true;
+#endif
+}
+
+#ifdef _WIN32
+inline bool Close(Handle hdl)
+{
+	return CloseHandle(hdl) != 0;
+}
+#else
+inline bool Close(Handle)
+{
+	return true;
+}
+#endif
+
+/**
+	whether process is alive or not
+	@param hdl [in] handle of process
+	@param exitCode [out] return exitCode if !IsAlive()
+*/
+inline bool IsAlive(Handle hdl, int* exitCode = 0)
+{
+#ifdef _WIN32
+//	int ret = WaitForSingleObject(hdl, 0);
+//	return ret == WAIT_TIMEOUT;
+	DWORD code;
+	if (GetExitCodeProcess(hdl, &code)) {
+		if (code == STILL_ACTIVE) {
+			return true;
+		}
+		if (exitCode) {
+			*exitCode = (int)code;
+		}
+	}
+	return false;
+#else
+	int status;
+	pid_t p = waitpid(hdl, &status, WNOHANG);
+	if (p == 0) return true;
+	if (p == hdl) {
+		if (exitCode) {
+			if (WIFEXITED(status)) {
+				*exitCode = WEXITSTATUS(status);
+			} else {
+				*exitCode = -1;
+			}
+		}
+	}
+	return false;
+#endif
+}
+
+} // process
+
+class Process {
+	mutable process::Handle hdl_;
+	void move(const Process& rhs) const
+	{
+		assert(!isValid());
+		hdl_ = rhs.hdl_;
+		rhs.hdl_ = process::InvalidHandle;
+	}
+	void close()
+	{
+		if (!isValid()) return;
+
+		process::Close(hdl_);
+		hdl_ = process::InvalidHandle;
+	}
+public:
+	Process()
+		: hdl_(process::InvalidHandle)
+	{
+	}
+	~Process()
+	{
+		close();
+	}
+	Process(const Process& rhs)
+		: hdl_(process::InvalidHandle)
+	{
+		move(rhs);
+	}
+	Process& operator=(const Process& rhs)
+	{
+		if (this != &rhs) {
+			move (rhs);
+		}
+
+		return *this;
+	}
+	bool run(const std::string& exe, const std::vector<std::string>& arg = std::vector<std::string>(), bool closeStdio = true)
+	{
+		close();
+		return process::Start(&hdl_, exe, arg, closeStdio);
+	}
+	bool run(const std::string& exe, const std::string& p1 = "", const std::string& p2 = "", const std::string& p3 = "", const std::string& p4 = "", const std::string& p5 = "", const std::string& p6 = "", const std::string& p7 = "", const std::string& p8 = "", const std::string& p9 = "")
+	{
+		std::vector<std::string> arg;
+		if (!p1.empty()) arg.push_back(p1);
+		if (!p2.empty()) arg.push_back(p2);
+		if (!p3.empty()) arg.push_back(p3);
+		if (!p4.empty()) arg.push_back(p4);
+		if (!p5.empty()) arg.push_back(p5);
+		if (!p6.empty()) arg.push_back(p6);
+		if (!p7.empty()) arg.push_back(p7);
+		if (!p8.empty()) arg.push_back(p8);
+		if (!p9.empty()) arg.push_back(p9);
+		return run(exe, arg, false);
+	}
+	bool isValid() const
+	{
+		return hdl_ != process::InvalidHandle;
+	}
+	bool isAlive(int* exitCode = 0) const
+	{
+		if (exitCode) *exitCode = 0;
+		return isValid() && process::IsAlive(hdl_, exitCode);
+	}
+};
+
+} // cybozu
+

data/vendor/cybozulib/include/cybozu/quit_signal_handler.hpp

@@ -0,0 +1,66 @@
+#pragma once
+/**
+	@file
+	@brief quit signal handler
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+	#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#else
+#include <signal.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+
+namespace cybozu {
+
+/*
+	class App must have quit() method
+*/
+template<class App>
+class QuitSignalHandler {
+	static App *app_;
+#ifdef _WIN32
+	static inline BOOL WINAPI ctrlHandler(DWORD) CYBOZU_NOEXCEPT
+	{
+		if (app_) app_->quit();
+		return TRUE;
+	}
+#else
+	static void ctrlHandler(int) CYBOZU_NOEXCEPT
+	{
+		app_->quit();
+//		signal(SIGINT, SIG_IGN);
+	}
+#endif
+public:
+	explicit QuitSignalHandler(App& app)
+	{
+		app_ = &app;
+#ifdef _WIN32
+		bool isOK = SetConsoleCtrlHandler(ctrlHandler, TRUE) != 0;
+#else
+		struct sigaction sa;
+		sa.sa_handler = ctrlHandler;
+		sigfillset(&sa.sa_mask);
+		sa.sa_flags = 0;
+		bool isOK = (sigaction(SIGINT, &sa, NULL) == 0)
+		         && (sigaction(SIGQUIT, &sa, NULL) == 0)
+		         && (sigaction(SIGABRT, &sa, NULL) == 0)
+		         && (sigaction(SIGTERM, &sa, NULL) == 0);
+#endif
+		if (!isOK) {
+			fprintf(stderr, "can't setup ctrl handler\n");
+			exit(1);
+		}
+	}
+};
+
+template<class App>
+App *QuitSignalHandler<App>::app_;
+
+} // cybozu

data/vendor/cybozulib/include/cybozu/random_generator.hpp

@@ -0,0 +1,144 @@
+#pragma once
+/**
+	@file
+	@brief pseudrandom generator
+	@author MITSUNARI Shigeo(@herumi)
+	@license modified new BSD license
+	http://opensource.org/licenses/BSD-3-Clause
+*/
+
+#ifndef CYBOZU_DONT_USE_EXCEPTION
+#include <cybozu/exception.hpp>
+#endif
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+	#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <wincrypt.h>
+#ifdef _MSC_VER
+#pragma comment (lib, "advapi32.lib")
+#endif
+#else
+#include <sys/types.h>
+#include <fcntl.h>
+#endif
+
+namespace cybozu {
+
+class RandomGenerator {
+	RandomGenerator(const RandomGenerator&);
+	void operator=(const RandomGenerator&);
+public:
+#ifdef _WIN32
+	RandomGenerator()
+		: prov_(0)
+	{
+		DWORD flagTbl[] = { CRYPT_VERIFYCONTEXT | CRYPT_SILENT, 0, CRYPT_MACHINE_KEYSET };
+		for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(flagTbl); i++) {
+			if (CryptAcquireContext(&prov_, NULL, NULL, PROV_RSA_FULL, flagTbl[i]) != 0) return;
+		}
+#ifdef CYBOZU_DONT_USE_EXCEPTION
+		prov_ = 0;
+#else
+		throw cybozu::Exception("randomgenerator");
+#endif
+	}
+	bool read_inner(void *buf, size_t byteSize)
+	{
+		if (prov_ == 0) return false;
+		return CryptGenRandom(prov_, static_cast<DWORD>(byteSize), static_cast<BYTE*>(buf)) != 0;
+	}
+	~RandomGenerator()
+	{
+		if (prov_) {
+			CryptReleaseContext(prov_, 0);
+		}
+	}
+	/*
+		fill buf[0..bufNum-1] with random data
+		@note bufNum is not byte size
+	*/
+	template<class T>
+	void read(bool *pb, T *buf, size_t bufNum)
+	{
+		const size_t byteSize = sizeof(T) * bufNum;
+		*pb = read_inner(buf, byteSize);
+	}
+private:
+	HCRYPTPROV prov_;
+#else
+	RandomGenerator()
+		: fp_(::fopen("/dev/urandom", "rb"))
+	{
+#ifndef CYBOZU_DONT_USE_EXCEPTION
+		if (!fp_) throw cybozu::Exception("randomgenerator");
+#endif
+	}
+	~RandomGenerator()
+	{
+		if (fp_) ::fclose(fp_);
+	}
+	/*
+		fill buf[0..bufNum-1] with random data
+		@note bufNum is not byte size
+	*/
+	template<class T>
+	void read(bool *pb, T *buf, size_t bufNum)
+	{
+		if (fp_ == 0) {
+			*pb = false;
+			return;
+		}
+		const size_t byteSize = sizeof(T) * bufNum;
+		*pb = ::fread(buf, 1, (int)byteSize, fp_) == byteSize;
+	}
+private:
+	FILE *fp_;
+#endif
+#ifndef CYBOZU_DONT_USE_EXCEPTION
+public:
+	template<class T>
+	void read(T *buf, size_t bufNum)
+	{
+		bool b;
+		read(&b, buf, bufNum);
+		if (!b) throw cybozu::Exception("RandomGenerator:read") << bufNum;
+	}
+	uint32_t get32()
+	{
+		uint32_t ret;
+		read(&ret, 1);
+		return ret;
+	}
+	uint64_t get64()
+	{
+		uint64_t ret;
+		read(&ret, 1);
+		return ret;
+	}
+	uint32_t operator()()
+	{
+		return get32();
+	}
+#endif
+};
+
+template<class T, class RG>
+void shuffle(T* v, size_t n, RG& rg)
+{
+	if (n <= 1) return;
+	for (size_t i = 0; i < n - 1; i++) {
+		size_t r = i + size_t(rg.get64() % (n - i));
+		using namespace std;
+		swap(v[i], v[r]);
+	}
+}
+
+template<class V, class RG>
+void shuffle(V& v, RG& rg)
+{
+	shuffle(v.data(), v.size(), rg);
+}
+
+} // cybozu