ooxml_crypt 0.1.0

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

@@ -0,0 +1,203 @@
+#pragma once
+/**
+	@file
+	@brief tiny wrapper of openssl class
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+#include <cybozu/socket.hpp>
+#include <cybozu/exception.hpp>
+#include <openssl/engine.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#include <openssl/rand.h>
+//#include <openssl/crypto.h>
+//#include <openssl/conf.h>
+#ifdef _MSC_VER
+	#include <cybozu/link_libeay32.hpp>
+	#include <cybozu/link_ssleay32.hpp>
+#endif
+
+namespace cybozu {
+
+namespace ssl {
+
+struct Engine {
+	Engine()
+	{
+		SSL_load_error_strings();
+		SSL_library_init();
+	}
+	~Engine()
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L && OPENSSL_VERSION_NUMBER < 0x10100000L
+		ERR_remove_thread_state(0);
+#elif OPENSSL_VERSION_NUMBER < 0x10000000L
+		ERR_remove_state(0);
+#endif
+		EVP_cleanup();
+		CRYPTO_cleanup_all_ex_data();
+		ENGINE_cleanup();
+		ERR_free_strings();
+//		CONF_modules_unload(1); // openssl/conf.h
+		/* this decreases one leak, but is this correct? */
+		OPENSSL_free(SSL_COMP_get_compression_methods());
+	}
+	static Engine& getInstance()
+	{
+		static Engine engine;
+		return engine;
+	}
+	void putError()
+	{
+		ERR_print_errors_fp(stderr);
+	}
+};
+
+class Ctx {
+	Engine& engine_;
+	SSL_CTX *ctx_;
+	Ctx(const Ctx&);
+	void operator=(const Ctx&);
+public:
+	explicit Ctx()
+		: engine_(Engine::getInstance())
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		, ctx_(SSL_CTX_new(TLS_client_method()))
+#else
+		, ctx_(SSL_CTX_new(TLSv1_client_method()))
+#endif
+	{
+		if (ctx_ == 0) {
+			engine_.putError();
+			fprintf(stderr, "SSL_CTX_new:err");
+			exit(1);
+		}
+#if 0
+		if (SSL_CTX_set_cipher_list(ctx_, "ALL:eNULL") == 0) {
+			engine_.putError();
+			fprintf(stderr, "SSL_CTX_set_cipher_list:err");
+			exit(1);
+		}
+#endif
+	}
+	~Ctx()
+	{
+		if (ctx_) SSL_CTX_free(ctx_);
+	}
+	SSL_CTX* get() const { return ctx_; }
+};
+
+namespace impl {
+template<int dummy = 0>
+struct InstanceIsHere { static Ctx ctx_; };
+
+template<int dummy>
+Ctx InstanceIsHere<dummy>::ctx_;
+
+struct DummyCall {
+	DummyCall() { InstanceIsHere<>::ctx_.get(); }
+};
+
+} // impl
+
+class ClientSocket {
+	cybozu::Socket soc_;
+	SSL *ssl_;
+
+	ClientSocket(const ClientSocket&);
+	void operator=(const ClientSocket&);
+public:
+	ClientSocket()
+		: ssl_(SSL_new(impl::InstanceIsHere<>::ctx_.get()))
+	{
+		if (ssl_ == 0) {
+			throw cybozu::Exception("ssl:ClientSocket");
+		}
+	}
+	void connect(const std::string& address, uint16_t port)
+	{
+		SocketAddr addr;
+		addr.set(address, port);
+		connect(addr);
+	}
+	void connect(const cybozu::SocketAddr& addr)
+	{
+		soc_.connect(addr);
+		bool isOK;
+#ifdef _WIN32
+		if (soc_.sd_ > INT_MAX) {
+			throw cybozu::Exception("ssl:ClientSocket:connect:large socket handle") << soc_.sd_;
+		}
+#endif
+		isOK = SSL_set_fd(ssl_, static_cast<int>(soc_.sd_)) != 0;
+		if (!isOK) goto ERR_EXIT;
+		isOK = SSL_connect(ssl_) == 1;
+		if (!isOK) goto ERR_EXIT;
+		return;
+	ERR_EXIT:
+		Engine::getInstance().putError();
+		throw cybozu::Exception("ssl:ClientSocket:connect");
+	}
+	size_t readSome(void *buf, size_t bufSize)
+	{
+		int size = (int)std::min((size_t)0x7fffffff, bufSize);
+	RETRY:
+		int ret = SSL_read(ssl_, buf, size);
+		if (ret > 0) return ret;
+		ret = SSL_get_error(ssl_, ret);
+		if (ret == SSL_ERROR_ZERO_RETURN) return 0;
+		if (ret == SSL_ERROR_WANT_READ || ret == SSL_ERROR_WANT_WRITE) goto RETRY;
+		Engine::getInstance().putError();
+		throw cybozu::Exception("ssl:ClientSocket:readSome") << ret;
+	}
+	void read(void *buf, size_t bufSize)
+	{
+		char *p = (char *)buf;
+		while (bufSize > 0) {
+			size_t readSize = readSome(p, bufSize);
+			p += readSize;
+			bufSize -= readSize;
+		}
+	}
+	void write(const char *buf, size_t bufSize)
+	{
+		const char *p = (const char *)buf;
+		while (bufSize > 0) {
+			int size = (int)std::min((size_t)0x7fffffff, bufSize);
+			int ret = SSL_write(ssl_, p, size);
+			if (ret <= 0) {
+				ret = SSL_get_error(ssl_, ret);
+				if (ret == SSL_ERROR_WANT_READ || ret == SSL_ERROR_WANT_WRITE) continue;
+				Engine::getInstance().putError();
+				throw cybozu::Exception("ssl:ClientSocket:write") << ret;
+			}
+			p += ret;
+			bufSize -= ret;
+		}
+	}
+	void close(bool dontThrow = false)
+	{
+		bool isOK = true;
+		if (soc_.isValid()) {
+			isOK = SSL_shutdown(ssl_) == 1;
+			if (!isOK) {
+				Engine::getInstance().putError();
+			}
+			soc_.close(dontThrow);
+		}
+		if (!dontThrow && !isOK) throw cybozu::Exception("ssl:ClientSocket:close");
+	}
+	~ClientSocket()
+	{
+		if (ssl_) {
+			close(cybozu::DontThrow);
+			SSL_free(ssl_);
+			ssl_ = 0;
+		}
+	}
+};
+
+} // cybozu::ssl
+
+} // cybozu

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

@@ -0,0 +1,291 @@
+#pragma once
+/**
+	@file
+	@brief stacktrace class
+	@author MITSUNARI Shigeo(@herumi)
+*/
+#include <string>
+#include <vector>
+#include <cybozu/itoa.hpp>
+#include <stdlib.h>
+#include <iosfwd>
+
+#ifdef _WIN32
+	#ifndef WIN32_LEAN_AND_MEAN
+		#define WIN32_LEAN_AND_MEAN
+	#endif
+	#include <windows.h>
+	#include <imagehlp.h>
+	#include <stdio.h>
+	#pragma comment(lib, "imagehlp.lib")
+#else
+	#include <execinfo.h>
+	#include <string.h>
+	#include <cxxabi.h>
+	#include <stdint.h>
+	#ifdef CYBOZU_STACKTRACE_WITH_BFD_GPL
+		#include <cybozu/bfd.hpp>
+	#endif
+#endif
+
+#ifndef NDEBUG
+	#define CYBOZU_STACKTRACE_RESOLVE_SYMBOL
+#endif
+
+namespace cybozu {
+
+namespace stacktrace_local {
+
+#ifdef _WIN32
+
+struct InitSymbol {
+	HANDLE hdl_;
+	InitSymbol()
+		: hdl_(GetCurrentProcess())
+	{
+#ifdef CYBOZU_STACKTRACE_RESOLVE_SYMBOL
+		SymInitialize(hdl_, NULL, TRUE);
+#endif
+	}
+	~InitSymbol()
+	{
+#ifdef CYBOZU_STACKTRACE_RESOLVE_SYMBOL
+		SymCleanup(hdl_);
+#endif
+	}
+	HANDLE getHandle() const { return hdl_; }
+};
+
+template<int dummy = 0>
+struct InstanceIsHere { static InitSymbol is_; };
+
+template<int dummy>
+InitSymbol InstanceIsHere<dummy>::is_;
+
+struct DummyCall {
+	DummyCall() { InstanceIsHere<>::is_.getHandle(); }
+};
+
+#endif
+
+class AutoFree {
+	void *p_;
+public:
+	AutoFree(void *p)
+		: p_(p)
+	{
+	}
+	~AutoFree()
+	{
+		free(p_);
+	}
+};
+
+#if defined(CYBOZU_STACKTRACE_WITH_BFD_GPL) || defined(CYBOZU_STACKTRACE_RESOLVE_SYMBOL)
+	const char delim = '\n';
+#else
+	#define CYBOZU_STACKTRACE_ONELINE
+	const char delim = ' ';
+#endif
+
+inline std::string addrToHex(const void *addr)
+{
+	char buf[32];
+#ifdef CYBOZU_STACKTRACE_ONELINE
+	CYBOZU_SNPRINTF(buf, sizeof(buf), "0x%llx", (long long)addr);
+#else
+	CYBOZU_SNPRINTF(buf, sizeof(buf), "[0x%llx]", (long long)addr);
+#endif
+	return buf;
+}
+
+} // stacktrace_local
+
+#ifdef __GNUC__
+inline bool Demangle(std::string& out, const std::string& func)
+{
+	int status;
+	char *demangled = abi::__cxa_demangle(func.c_str(), 0, 0, &status);
+	stacktrace_local::AutoFree afDemangle(demangled);
+	if (status == 0) {
+		out = demangled;
+		return true;
+	} else {
+		out = func;
+		return false;
+	}
+}
+#endif
+
+class StackTrace {
+	std::vector<void*> data_;
+#ifdef CYBOZU_STACKTRACE_WITH_BFD_GPL
+	static inline cybozu::Bfd& getBfd()
+	{
+		static cybozu::Bfd bfd;
+		return bfd;
+	}
+#endif
+public:
+	/**
+		set current stack trace
+	*/
+	StackTrace()
+	{
+		data_.clear();
+
+		const int maxTraceNum = 32;
+
+#ifdef _WIN32
+
+		CONTEXT ctx;
+		memset(&ctx, 0, sizeof(ctx));
+		ctx.ContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;
+		RtlCaptureContext(&ctx);
+
+		STACKFRAME64 sf;
+		memset(&sf, 0, sizeof(sf));
+
+#ifdef _WIN64
+		sf.AddrPC.Offset = ctx.Rip;
+		sf.AddrFrame.Offset = ctx.Rbp;
+		sf.AddrStack.Offset = ctx.Rsp;
+		DWORD machineType = IMAGE_FILE_MACHINE_AMD64;
+#else
+		sf.AddrPC.Offset = ctx.Eip;
+		sf.AddrFrame.Offset = ctx.Ebp;
+		sf.AddrStack.Offset = ctx.Esp;
+		DWORD machineType = IMAGE_FILE_MACHINE_I386;
+#endif
+		sf.AddrPC.Mode = AddrModeFlat;
+		sf.AddrFrame.Mode = AddrModeFlat;
+		sf.AddrStack.Mode = AddrModeFlat;
+
+		HANDLE threadHdl = GetCurrentThread();
+
+		HANDLE processHdl = stacktrace_local::InstanceIsHere<>::is_.getHandle();
+		for(;;) {
+			BOOL ret;
+			ret = StackWalk64(machineType, processHdl, threadHdl, &sf, &ctx, NULL,
+					SymFunctionTableAccess64, SymGetModuleBase64, NULL);
+			if (!ret || sf.AddrFrame.Offset == 0) return;
+
+			data_.push_back((void*)sf.AddrPC.Offset);
+			if (data_.size() == maxTraceNum) return;
+		}
+#else
+		data_.resize(maxTraceNum);
+		int traceNum = backtrace(&data_[0], maxTraceNum);
+		data_.resize(traceNum);
+#endif
+	}
+	/**
+		get stack trace
+	*/
+	std::string toString() const
+	{
+		size_t traceNum = data_.size();
+		if (traceNum == 0) return "";
+
+		std::string out;
+
+#ifdef _WIN32
+#ifdef CYBOZU_STACKTRACE_RESOLVE_SYMBOL
+		HANDLE processHdl = stacktrace_local::InstanceIsHere<>::is_.getHandle();
+#endif
+		if (traceNum > 1) traceNum--; // last information is unnecessary
+		for (size_t i = 0; i < traceNum; i++) {
+			uintptr_t ptr = (uintptr_t)data_[i];
+
+#ifdef CYBOZU_STACKTRACE_RESOLVE_SYMBOL
+			DWORD disp;
+			IMAGEHLP_LINE64 line;
+			memset(&line, 0, sizeof(line));
+			line.SizeOfStruct = sizeof(line);
+			if (SymGetLineFromAddr64(processHdl, ptr, &disp, &line)) {
+				out += line.FileName;
+				out += ':';
+				out += cybozu::itoa((int)line.LineNumber);
+				out += ' ';
+			}
+#endif
+			out += stacktrace_local::addrToHex((const void*)ptr);
+			if (i < traceNum - 1) out += stacktrace_local::delim;
+		}
+#else
+
+#ifdef CYBOZU_STACKTRACE_RESOLVE_SYMBOL
+		char **symbol = backtrace_symbols(&data_[0], traceNum);
+		stacktrace_local::AutoFree freeSymbol(symbol);
+#endif
+		for (size_t i = 0; i < traceNum; i++) {
+			std::string funcName;
+#ifdef CYBOZU_STACKTRACE_WITH_BFD_GPL
+			{
+				std::string fileName;
+				int line;
+				if (getBfd().getInfo(&fileName, &funcName, &line, data_[i])) {
+					Demangle(funcName, funcName);
+					out += fileName;
+					out += ':';
+					out += cybozu::itoa(line);
+					out += ' ';
+				}
+			}
+#endif
+#ifdef CYBOZU_STACKTRACE_RESOLVE_SYMBOL
+			if (symbol) {
+				std::string str(symbol[i]);
+				str += '\0';
+				size_t p = str.find('(');
+				const char *obj = 0, *addr = 0;
+				if (p != std::string::npos) {
+					size_t q = str.find('+', p + 1);
+					if (q != std::string::npos) {
+						obj = &str[0]; str[p] = '\0';
+						const char *const func = &str[p + 1]; str[q] = '\0';
+						addr = &str[q + 1];
+						if (funcName.empty()) {
+							Demangle(funcName, func);
+						}
+					}
+				}
+				bool doPrint = false;
+				if (obj && addr) {
+					out += obj;
+					out += '(';
+					out += funcName;
+					out += '+';
+					out += addr;
+					out += ' ';
+					doPrint = true;
+				} else if (!funcName.empty()) {
+					out += funcName;
+					out += ' ';
+				}
+				if (!doPrint) {
+					out += symbol[i];
+					out += ' ';
+				}
+			} else
+#endif
+			{
+				out += stacktrace_local::addrToHex(data_[i]);
+			}
+			if (i < traceNum - 1) out += stacktrace_local::delim;
+		}
+#endif
+		return out;
+	}
+	bool empty() const CYBOZU_NOEXCEPT { return data_.empty(); }
+	void clear() CYBOZU_NOEXCEPT { data_.clear(); }
+};
+
+inline std::ostream& operator<<(std::ostream& os, const StackTrace& self)
+{
+	return os << self.toString();
+}
+
+} // cybozu
+
+#undef CYBOZU_STACKTRACE_RESOLVE_SYMBOL