Blog

// proxies.cpp — 같은 인터페이스 뒤에서 접근을 통제하는 세 가지 프록시
#include <iostream>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>

struct Document {                                     // Subject
	virtual ~Document() = default;
	virtual std::string read(int page) = 0;
};

struct PdfDocument : Document {                       // RealSubject: 열기가 비싸다
	explicit PdfDocument(std::string p) : path(std::move(p)) { std::cout << "  [open " << path << ": 비싼 작업]\n"; ++opens; }
	std::string read(int page) override { ++reads; return path + "#p" + std::to_string(page); }
	std::string path;
	static inline int opens = 0, reads = 0;
};

class LazyDocument : public Document {                // 가상 프록시: 처음 필요할 때 생성
public:
	explicit LazyDocument(std::string p) : path_(std::move(p)) {}
	std::string read(int page) override
	{
		if (!real_)
			real_ = std::make_unique<PdfDocument>(path_);
		return real_->read(page);
	}
private:
	std::string path_;
	std::unique_ptr<PdfDocument> real_;
};

class GuardedDocument : public Document {             // 보호 프록시: 권한 검사
public:
	GuardedDocument(Document &d, std::string role) : d_(d), role_(std::move(role)) {}
	std::string read(int page) override
	{
		if (page > 10 && role_ != "admin")
			throw std::runtime_error("page " + std::to_string(page) + " requires admin");
		return d_.read(page);
	}
private:
	Document &d_;
	std::string role_;
};

class CachedDocument : public Document {              // 캐싱 프록시: 결과 재사용
public:
	explicit CachedDocument(Document &d) : d_(d) {}
	std::string read(int page) override
	{
		auto [it, miss] = cache_.try_emplace(page);
		if (miss)
			it->second = d_.read(page);
		return it->second;
	}
private:
	Document &d_;
	std::map<int, std::string> cache_;
};

int main()
{
	LazyDocument lazy("manual.pdf");
	std::cout << "proxy created, opens=" << PdfDocument::opens << '\n';
	std::cout << lazy.read(1) << ", opens=" << PdfDocument::opens << '\n';

	GuardedDocument guest(lazy, "guest");
	try {
		std::cout << guest.read(3) << '\n';
		std::cout << guest.read(42) << '\n';
	} catch (const std::exception &e) {
		std::cout << "denied: " << e.what() << '\n';
	}

	CachedDocument cached(lazy);
	PdfDocument::reads = 0;
	for (int i = 0; i < 5; ++i)
		cached.read(7);
	std::cout << "5 cached reads -> real reads=" << PdfDocument::reads << '\n';
}

// locked.cpp — 호출마다 락을 거는 동기화 프록시: operator->가 임시 잠금 객체를 돌려준다
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

template <class T>
class Synchronized {
	class Locked {                                    // 이 임시 객체가 살아 있는 동안 잠김
	public:
		Locked(T &obj, std::mutex &m) : obj_(obj), lock_(m) {}
		T *operator->() { return &obj_; }
	private:
		T &obj_;
		std::unique_lock<std::mutex> lock_;
	};
public:
	Locked operator->() { return Locked(obj_, m_); }  // operator-> 연쇄 적용
	T &unsafe() { return obj_; }
private:
	T obj_;
	std::mutex m_;
};

int main()
{
	Synchronized<std::vector<int>> safe;

	auto run = [](auto push) {
		std::vector<std::thread> ts;
		for (int t = 0; t < 4; ++t)
			ts.emplace_back([&] { for (int i = 0; i < 50000; ++i) push(i); });
		for (auto &t : ts)
			t.join();
	};

	run([&](int i) { safe->push_back(i); });               // 매 호출이 잠금 하에 실행
	std::cout << "synchronized size=" << safe.unsafe().size() << " (expected 200000)\n";
}

// vecbool.cpp — 표준 라이브러리 속 프록시: vector<bool>::reference
#include <iostream>
#include <type_traits>
#include <vector>

int main()
{
	std::vector<bool> flags = {false, false};
	auto f = flags[0];                         // bool이 아니라 프록시 객체
	f = true;                                  // 원본 비트를 바꾼다
	std::cout << std::boolalpha << "flags[0]=" << flags[0]
		  << ", decltype is bool? " << std::is_same_v<decltype(f), bool> << '\n';

	bool copy = flags[1];                      // 명시적으로 bool로 받으면 값 복사
	copy = true;
	std::cout << "copy=" << copy << ", flags[1]=" << flags[1] << " (unchanged)\n";
	std::cout << "sizeof(vector<bool>::reference)=" << sizeof(flags[0]) << '\n';
}

// dangling_read.cpp — 임시 vector<bool>의 프록시를 붙잡아 읽으면
#include <iostream>
#include <vector>
std::vector<bool> make_flags() { return {true, false, true}; }
int main()
{
	auto f = make_flags()[0];
	std::cout << "read: " << bool(f) << '\n';
}

/* openlog.c — LD_PRELOAD 프록시: 프로그램을 고치지 않고 open() 호출을 가로채 기록·검사한 뒤 진짜 함수로 넘긴다 */
#define _GNU_SOURCE
#include <dlfcn.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

typedef int (*open_fn)(const char *, int, ...);

static int allowed(const char *path)
{
	if (strstr(path, "data/")) {                        /* 관심 있는 경로만 기록 */
		fprintf(stderr, "[proxy] open(%s)\n", path);
		if (strstr(path, "secret")) {                   /* 보호 프록시 역할 */
			errno = EACCES;
			return 0;
		}
	}
	return 1;
}

int open(const char *path, int flags, ...)
{
	static open_fn real;
	mode_t mode = 0;

	if (!real)
		real = (open_fn)dlsym(RTLD_NEXT, "open");     /* 다음 라이브러리(libc)의 진짜 open */
	if (flags & (O_CREAT | O_TMPFILE)) {
		va_list ap;
		va_start(ap, flags);
		mode = va_arg(ap, mode_t);
		va_end(ap);
	}
	if (!allowed(path))
		return -1;
	return real(path, flags, mode);
}