ooxml_crypt 0.1.0

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

@@ -0,0 +1,149 @@
+#pragma once
+/**
+	@file
+	@brief line stream class
+*/
+#include <string>
+#include <memory.h>
+#include <iosfwd>
+#include <cybozu/file.hpp>
+
+namespace cybozu {
+
+namespace line_stream {
+
+#define CYBOZU_STREAM_CRLF "\x0d\x0a"
+
+const char CR = '\x0d';
+const char LF = '\x0a';
+const char CRLF[] = CYBOZU_STREAM_CRLF;
+
+} // line_stream
+
+/**
+	construct lines from reader
+	accept 0x0d 0xa and 0x0a and remove them
+	next() returns one line without CRLF
+	throw exception if line.size() > maxLineSize (line.size() does not include CRLF)
+
+	Remark:next() may return the last data without CRLF
+
+	Reader must have size_t readSome(char *buf, size_t size); method
+
+	How to use this
+
+	LinstStreamT<Reader> lineStream(reader);
+	for (;;) {
+		std::string line;
+		if (!lineStream.next(line)) break;
+	}
+*/
+template<class Reader>
+class LineStreamT {
+	Reader& reader_;
+	size_t maxLineSize_;
+	std::string buf_;
+	size_t bufSize_;
+	const char *next_;
+	bool eof_;
+	LineStreamT(const LineStreamT&);
+	void operator=(const LineStreamT&);
+	void verifySize(const char *begin, const char *end) const
+	{
+		if (static_cast<uintptr_t>(end - begin) > maxLineSize_) {
+			throw cybozu::Exception("LineStreamT:next:line is too long") << cybozu::exception::makeString(begin, 10);
+		}
+	}
+public:
+	explicit LineStreamT(Reader& reader, size_t maxLineSize = 1024 * 2)
+		: reader_(reader)
+		, maxLineSize_(maxLineSize)
+		, buf_(maxLineSize * 2, 0)
+		, bufSize_(0)
+		, next_(buf_.data())
+		, eof_(false)
+	{
+	}
+	/**
+		get line without CRLF
+		@param begin [out] begin of line
+		@param end [out] end of line
+		@retval true if sucess
+		@retval false if not data
+	*/
+	bool next(const char **begin, const char **end)
+	{
+		if (eof_) return false;
+		for (;;) {
+			const size_t remainSize = &buf_[bufSize_] - next_;
+			if (remainSize > 0) {
+				const char *endl = static_cast<const char *>(memchr(next_, cybozu::line_stream::LF, remainSize));
+				if (endl) {
+					if (endl > next_ && endl[-1] == cybozu::line_stream::CR) {
+						*end = endl - 1;
+					} else {
+						*end = endl;
+					}
+					*begin = next_;
+					verifySize(*begin, *end);
+					next_ = endl + 1;
+					return true;
+				}
+				// move next_ to top of buf_
+				for (size_t i = 0; i < remainSize; i++) {
+					buf_[i] = next_[i];
+				}
+				bufSize_ = remainSize;
+			} else {
+				bufSize_ = 0;
+			}
+			next_ = buf_.data();
+			size_t readSize = reader_.readSome(&buf_[bufSize_], buf_.size() - bufSize_);
+			if (readSize == 0) {
+				eof_ = true;
+				if (bufSize_ == 0) return false;
+				if (bufSize_ > maxLineSize_) {
+					throw cybozu::Exception("LineStreamT:next:no CRLF");
+				}
+				// take all remain buffer
+				*begin= buf_.data();
+				*end = &buf_[bufSize_];
+				verifySize(*begin, *end);
+				return true;
+			}
+			bufSize_ += readSize;
+		}
+	}
+	/**
+		get line
+	*/
+	bool next(std::string& line)
+	{
+		const char *begin;
+		const char *end;
+		if (next(&begin, &end)) {
+			line.assign(begin, end);
+			return true;
+		}
+		return false;
+	}
+	/*
+		get remaining raw data
+	*/
+	void getRemain(std::string& remain) const
+	{
+		if (eof_) {
+			remain.clear();
+		} else {
+			remain.assign(next_, &buf_[bufSize_]);
+		}
+	}
+	std::string getRemain() const
+	{
+		std::string remain;
+		getRemain(remain);
+		return remain;
+	}
+};
+
+} // cybozu

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

@@ -0,0 +1,21 @@
+#pragma once
+/**
+	@file
+	@brief link libeay32.lib of openssl
+	@author MITSUNARI Shigeo(@herumi)
+*/
+#if defined(_WIN32) && defined(_MT)
+	#if _MSC_VER >= 1900 // VC2015
+		#ifdef _WIN64
+			#pragma comment(lib, "mt/14/libeay32.lib")
+		#else
+			#pragma comment(lib, "mt/14/32/libeay32.lib")
+		#endif
+//	#elif _MSC_VER == 1800 // VC2013
+	#else
+		#pragma comment(lib, "mt/12/libeay32.lib")
+	#endif
+	#pragma comment(lib, "advapi32.lib")
+	#pragma comment(lib, "gdi32.lib")
+	#pragma comment(lib, "user32.lib")
+#endif

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

@@ -0,0 +1,18 @@
+#pragma once
+/**
+	@file
+	@brief link mpir/mpirxx of mpir
+	@author MITSUNARI Shigeo(@herumi)
+*/
+#if defined(_WIN32) && defined(_MT)
+	#if _MSC_VER >= 1900 // VC2015, VC2017(1910)
+		#pragma comment(lib, "mt/14/mpir.lib")
+		#pragma comment(lib, "mt/14/mpirxx.lib")
+	#elif _MSC_VER == 1800 // VC2013
+		#pragma comment(lib, "mt/12/mpir.lib")
+		#pragma comment(lib, "mt/12/mpirxx.lib")
+	#elif _MSC_VER == 1700 // VC2012
+		#pragma comment(lib, "mt/11/mpir.lib")
+		#pragma comment(lib, "mt/11/mpirxx.lib")
+	#endif
+#endif

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

@@ -0,0 +1,19 @@
+#pragma once
+/**
+	@file
+	@brief link ssleay32.lib of openssl
+	@author MITSUNARI Shigeo(@herumi)
+*/
+#if defined(_WIN32) && defined(_MT)
+	#if _MSC_VER >= 1900 // VC2015
+		#ifdef _WIN64
+			#pragma comment(lib, "mt/14/ssleay32.lib")
+		#else
+			#pragma comment(lib, "mt/14/32/ssleay32.lib")
+		#endif
+//	#elif _MSC_VER == 1800 // VC2013
+	#else
+		#pragma comment(lib, "mt/12/ssleay32.lib")
+	#endif
+	#pragma comment(lib, "user32.lib")
+#endif

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

@@ -0,0 +1,237 @@
+#pragma once
+/**
+	@file
+	@brief logger
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+#include <cybozu/format.hpp>
+#include <cybozu/time.hpp>
+#ifdef _WIN32
+#else
+	#include <syslog.h>
+#endif
+
+namespace cybozu {
+
+enum LogPriority {
+	LogDebug = 0,
+	LogInfo = 1,
+	LogWarning = 2,
+	LogError = 3
+};
+
+namespace log_local {
+
+class Logger {
+	int priority_;
+	FILE *fp_;
+	bool doClose_;
+	bool useSyslog_;
+	bool useMsec_;
+public:
+	Logger()
+		: priority_(cybozu::LogInfo)
+		, fp_(stderr)
+		, doClose_(false)
+		, useSyslog_(true)
+		, useMsec_(false)
+	{
+	}
+	~Logger() CYBOZU_NOEXCEPT
+	{
+		closeFile();
+	}
+	void put(LogPriority priority, const std::string& str)
+	{
+		if (priority < priority_) return;
+		if (fp_) {
+			cybozu::Time cur(true);
+			if (fprintf(fp_, "%s %s\n", cur.toString(useMsec_).c_str(), str.c_str()) < 0) {
+				fprintf(stderr, "ERR:cybozu:Logger:put:fprintf:%s\n", str.c_str());
+			}
+			if (fflush(fp_) < 0) {
+				fprintf(stderr, "ERR:cybozu:Logger:put:fflush:%s\n", str.c_str());
+			}
+		}
+		if (useSyslog_) {
+#ifdef __linux__
+			int pri = LOG_CRIT;
+			if (priority == LogDebug) {
+				pri = LOG_DEBUG;
+			} else if (priority == LogInfo) {
+				pri = LOG_INFO;
+			} else if (priority == LogWarning) {
+				pri = LOG_WARNING;
+			}
+			::syslog(pri, "%s\n", str.c_str());
+#endif
+		}
+	}
+	void put(LogPriority priority, const char *format, va_list args)
+	{
+		if (priority < priority_) return;
+		std::string str;
+		cybozu::vformat(str, format, args);
+		put(priority, str);
+	}
+
+	static Logger& getInstance()
+	{
+		static Logger logger;
+		return logger;
+	}
+	/*
+		@note : not thread safe
+		@param path [in] open path for log
+	*/
+	void openFile(const std::string& path)
+	{
+		FILE *fp = 0;
+#ifdef _MSC_VER
+		if (fopen_s(&fp, path.c_str(), "a+b")) fp = 0;
+#else
+		fp = fopen(path.c_str(), "a+b");
+#endif
+		if (fp == 0) throw cybozu::Exception("cybozu:Logger:openFile") << path;
+		if (!closeFile()) throw cybozu::Exception("cybozu:Logger:openFile:fail to closeFile");
+		fp_ = fp;
+		doClose_ = true;
+		useSyslog_ = false;
+	}
+	/*
+		set FILE pointer
+		@param fp [in] write log to fp if fp != NULL
+		@note Logger does not close the pointer
+	*/
+	void set(FILE *fp)
+	{
+		if (!closeFile()) throw cybozu::Exception("cybozu:Logger:set:fail to closeFile");
+		fp_ = fp;
+		doClose_ = false;
+		useSyslog_ = false;
+	}
+	/*
+		use syslog if useSyslog is true
+	*/
+	void useSyslog(bool useSyslog)
+	{
+		useSyslog_ = useSyslog;
+	}
+	bool closeFile() CYBOZU_NOEXCEPT
+	{
+		if (!doClose_ || fp_ == 0) return true;
+		if (fp_ == stdout || fp_ == stderr) {
+			fp_ = NULL;
+			return true;
+		}
+		bool isOK = fclose(fp_) == 0;
+		fp_ = NULL;
+		return isOK;
+	}
+	void setPriority(LogPriority priority)
+	{
+		priority_ = priority;
+	}
+	void setUseMsec(bool useMsec)
+	{
+		useMsec_ = useMsec;
+	}
+};
+
+} // cybozu::log_local
+
+/*
+	write log to path(default is stderr, syslog)
+	@param path [in] open path for log
+	@note this function is not thread safe
+*/
+inline void OpenLogFile(const std::string& path)
+{
+	return log_local::Logger::getInstance().openFile(path);
+}
+
+/*
+	set FILE pointer
+	@param fp [in] write log to fp if fp != NULL
+	@note Logger does not close the pointer
+	@note this function is not thread safe
+*/
+inline void SetLogFILE(FILE *fp)
+{
+	return log_local::Logger::getInstance().set(fp);
+}
+
+/*
+	use syslog if useSyslog is true
+*/
+inline void useSyslog(bool useSyslog)
+{
+	log_local::Logger::getInstance().useSyslog(useSyslog);
+}
+/*
+	set priority(default cybozu::LogInfo)
+	does not show the message of which is less or equal to the priority
+*/
+inline void SetLogPriority(LogPriority priority)
+{
+	log_local::Logger::getInstance().setPriority(priority);
+}
+/*
+	set useMsec
+*/
+inline void SetLogUseMsec(bool useMsec = true)
+{
+	log_local::Logger::getInstance().setUseMsec(useMsec);
+}
+/*
+	write log like printf
+	Linux : default is syslog
+	Windows : default is file(use openFile)
+*/
+#ifdef __GNUC__
+inline void PutLog(LogPriority priority, const char *format, ...) CYBOZU_NOEXCEPT __attribute__((format(printf, 2, 3)));
+#endif
+inline void PutLog(LogPriority priority, const char *format, ...) CYBOZU_NOEXCEPT
+	try
+{
+	va_list args;
+	va_start(args, format);
+	log_local::Logger::getInstance().put(priority, format, args);
+	va_end(args);
+} catch (std::exception& e) {
+	fprintf(stderr, "faital error in cybozu::PutLog %s\n", e.what());
+} catch (...) {
+	fprintf(stderr, "faital error in cybozu::PutLog\n");
+}
+
+} // cybozu
+
+namespace cybozu {
+/*
+	write log like std::cout
+	Linux : default is syslog
+	Windows : default is file(use openFile)
+*/
+class Log {
+	LogPriority pri_;
+	std::ostringstream os_;
+	Log(const Log&);
+	void operator=(const Log&);
+public:
+	explicit Log(LogPriority priority = cybozu::LogInfo) : pri_(priority) { }
+	~Log() CYBOZU_NOEXCEPT
+	{
+		try {
+			log_local::Logger::getInstance().put(pri_, os_.str());
+		} catch (std::exception& e) {
+			fprintf(stderr, "faital error in cybozu::Log %s\n", e.what());
+		} catch (...) {
+			fprintf(stderr, "faital error in cybozu::Log\n");
+		}
+	}
+	template<class T>
+	Log& operator<<(const T& t) { os_ << t; return *this; }
+};
+
+} // cybozu