libcouchbase 0.0.1

data/ext/libcouchbase/tests/ioserver/socket.cc

@@ -0,0 +1,88 @@
+#include "ioserver.h"
+using namespace LCBTest;
+
+SockFD::SockFD(int sock)
+{
+    assert(sock >= 0);
+    fd = sock;
+    naddr = sizeof(sa_local);
+    int rv = getsockname(fd, (struct sockaddr *)&sa_local, &naddr);
+    assert(rv == 0);
+}
+
+void
+SockFD::loadRemoteAddr()
+{
+    socklen_t lentmp = sizeof(sa_remote);
+    getpeername(*this, (struct sockaddr *)&sa_remote, &lentmp);
+}
+
+void
+SockFD::close()
+{
+    if (fd != -1) {
+        shutdown(fd, SHUT_RDWR);
+        ::closesocket(fd);
+        fd = -1;
+    }
+}
+
+SockFD::~SockFD()
+{
+    close();
+}
+
+SockFD *
+SockFD::acceptClient()
+{
+    struct sockaddr_storage newaddr;
+    socklen_t newlen = sizeof(newaddr);
+    int newsock = accept(*this, (struct sockaddr *)&newaddr, &newlen);
+    return new SockFD(newsock);
+}
+
+SockFD *
+SockFD::newListener()
+{
+    struct sockaddr_in addr;
+    memset(&addr, 0, sizeof(addr));
+
+    int lsnfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+    addr.sin_port = 0;
+    bind(lsnfd, (struct sockaddr *)&addr, sizeof(addr));
+    listen(lsnfd, 5);
+    return new SockFD(lsnfd);
+}
+
+SockFD *
+SockFD::newClient(SockFD *server)
+{
+    int sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    assert(sockfd >= 0);
+    int rv = connect(sockfd, (struct sockaddr *)&server->localAddr4(),
+                     sizeof(struct sockaddr_in));
+    assert(rv == 0);
+    return new SockFD(sockfd);
+}
+
+#ifndef _WIN32
+std::string
+SockFD::getHostCommon(sockaddr_storage *ss)
+{
+    struct sockaddr_in *addr = (struct sockaddr_in *)ss;
+    char buf[4096];
+    inet_ntop(AF_INET, &addr->sin_addr, buf, sizeof(*addr));
+    return std::string(buf);
+
+}
+#else
+std::string
+SockFD::getHostCommon(sockaddr_storage *ss)
+{
+    struct sockaddr_in *inaddr = (struct sockaddr_in *)ss;
+    char *buf = inet_ntoa(inaddr->sin_addr);
+    return std::string(buf);
+}
+#endif

data/ext/libcouchbase/tests/ioserver/ssl_connection.cc

@@ -0,0 +1,145 @@
+#include "ioserver.h"
+
+#ifndef LCB_NO_SSL
+#include <openssl/ssl.h>
+
+using namespace LCBTest;
+using std::vector;
+
+class SslSocket : public SockFD {
+public:
+    SslSocket(SockFD *innner);
+
+    ~SslSocket();
+
+    // Receive data via SSL
+    size_t send(const void*,size_t,int);
+
+    // Send data via SSL
+    ssize_t recv(void*,size_t,int);
+
+    // Close the SSL context first
+    void close();
+
+    // Return the real FD
+    int getFD() const { return sfd->getFD(); }
+
+private:
+    SSL *ssl;
+    SSL_CTX *ctx;
+    SockFD *sfd;
+    bool ok;
+};
+
+SockFD *
+TestServer::sslSocketFactory(int fd)
+{
+    return new SslSocket(new SockFD(fd));
+}
+
+extern "C" {
+static void
+log_callback(const SSL *ssl, int where, int ret)
+{
+    const char *retstr = "";
+    int should_log = 0;
+
+    if (where & SSL_CB_ALERT) {
+        should_log = 1;
+    }
+    if (where == SSL_CB_HANDSHAKE_START || where == SSL_CB_HANDSHAKE_DONE) {
+        should_log = 1;
+    }
+    if ((where & SSL_CB_EXIT) && ret == 0) {
+        should_log = 1;
+    }
+
+    if (!should_log) {
+        return;
+    }
+
+    retstr = SSL_alert_type_string(ret);
+    fprintf(stderr, "SslSocket: ST(0x%x). %s. R(0x%x)%s\n", where, SSL_state_string_long(ssl), ret, retstr);
+
+    if (where == SSL_CB_HANDSHAKE_DONE) {
+        fprintf(stderr, "SslSocket: Using SSL version %s. Cipher=%s\n", SSL_get_version(ssl), SSL_get_cipher_name(ssl));
+    }
+}
+}
+
+// http://stackoverflow.com/questions/256405/programmatically-create-x509-certificate-using-openssl
+// http://www.opensource.apple.com/source/OpenSSL/OpenSSL-22/openssl/demos/x509/mkcert.c
+// Note we deviate from the examples by directly setting the certificate.
+
+static void genCertificate(SSL_CTX *ctx) {
+    EVP_PKEY * pkey = EVP_PKEY_new();
+    X509 * x509 = X509_new();
+    RSA * rsa = RSA_generate_key(2048, RSA_F4, NULL, NULL);
+
+    EVP_PKEY_assign_RSA(pkey, rsa);
+    ASN1_INTEGER_set(X509_get_serialNumber(x509), 1);
+    X509_gmtime_adj(X509_get_notBefore(x509), 0);
+    X509_gmtime_adj(X509_get_notAfter(x509), 31536000L);
+    X509_set_pubkey(x509, pkey);
+
+    X509_NAME * name = X509_get_subject_name(x509);
+    X509_NAME_add_entry_by_txt(name, "C",  MBSTRING_ASC, (unsigned char *)"CA", -1, -1, 0);
+    X509_NAME_add_entry_by_txt(name, "O",  MBSTRING_ASC, (unsigned char *)"MyCompany Inc.", -1, -1, 0);
+    X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, (unsigned char *)"localhost", -1, -1, 0);
+    X509_set_issuer_name(x509, name);
+    X509_sign(x509, pkey, EVP_sha1());
+
+    SSL_CTX_use_PrivateKey(ctx, pkey);
+    SSL_CTX_use_certificate(ctx, x509);
+    X509_free(x509);
+    EVP_PKEY_free(pkey);
+}
+
+SslSocket::SslSocket(SockFD *inner) : SockFD(inner->getFD())
+{
+    sfd = inner;
+    ctx = SSL_CTX_new(SSLv23_server_method());
+    assert(ctx != NULL);
+
+    SSL_CTX_set_info_callback(ctx, log_callback);
+    genCertificate(ctx);
+    SSL_CTX_set_mode(ctx, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
+    SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2|SSL_OP_NO_SSLv3);
+    SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
+    SSL_CTX_load_verify_locations(ctx, NULL, NULL);
+
+    ssl = SSL_new(ctx);
+    assert(ssl != NULL);
+    SSL_set_accept_state(ssl);
+    SSL_set_fd(ssl, sfd->getFD());
+}
+
+size_t
+SslSocket::send(const void *buf, size_t n, int)
+{
+    return SSL_write(ssl, buf, n);
+}
+
+ssize_t
+SslSocket::recv(void *buf, size_t n, int)
+{
+    return SSL_read(ssl, buf, n);
+}
+
+void
+SslSocket::close()
+{
+    SSL_shutdown(ssl);
+    sfd->close();
+}
+
+SslSocket::~SslSocket()
+{
+    SSL_free(ssl);
+    SSL_CTX_free(ctx);
+    delete sfd;
+}
+
+#else
+namespace { void dummySym() { } }
+#endif

data/ext/libcouchbase/tests/ioserver/threads-pthreads.cc

@@ -0,0 +1,119 @@
+#ifndef _WIN32
+#include "threads.h"
+#include <cstdlib>
+#include <unistd.h>
+#include <pthread.h>
+
+extern "C" {
+static void* startfunc(void *arg)
+{
+    Thread *thr = reinterpret_cast<Thread *>(arg);
+    thr->doRun();
+    return NULL;
+}
+}
+
+Thread::Thread(StartFunc startfn, void *arg)
+{
+    this->fn = startfn;
+    this->fnparam = arg;
+    initialized = true;
+    pthread_create(&thr, NULL, startfunc, this);
+}
+
+void
+Thread::close()
+{
+    if (!initialized) {
+        return;
+    }
+    join();
+    initialized = false;
+}
+
+Thread::~Thread()
+{
+    close();
+}
+
+void
+Thread::join()
+{
+    void *res;
+    pthread_join(thr, &res);
+}
+
+
+// Mutex:
+Mutex::Mutex()
+{
+    pthread_mutex_init(&mutex, NULL);
+    initialized = true;
+}
+
+void
+Mutex::lock()
+{
+    pthread_mutex_lock(&mutex);
+}
+
+bool
+Mutex::tryLock()
+{
+    return pthread_mutex_trylock(&mutex) == 0;
+}
+
+void
+Mutex::unlock()
+{
+    pthread_mutex_unlock(&mutex);
+}
+
+void
+Mutex::close()
+{
+    if (initialized) {
+        initialized = false;
+        pthread_mutex_destroy(&mutex);
+    }
+}
+
+Mutex::~Mutex()
+{
+    close();
+}
+
+
+// Condvar
+Condvar::Condvar()
+{
+    pthread_cond_init(&cond, NULL);
+    initialized = true;
+}
+
+void
+Condvar::wait(Mutex& mutex)
+{
+    pthread_cond_wait(&cond, &mutex.mutex);
+}
+
+void
+Condvar::signal()
+{
+    pthread_cond_signal(&cond);
+}
+
+void
+Condvar::close()
+{
+    if (initialized) {
+        pthread_cond_destroy(&cond);
+        initialized = false;
+    }
+}
+
+Condvar::~Condvar()
+{
+    close();
+}
+#endif

data/ext/libcouchbase/tests/ioserver/threads-win32.cc

@@ -0,0 +1,117 @@
+#ifdef _WIN32
+#include <cassert>
+#include <windows.h>
+#include <process.h>
+#include "threads.h"
+
+extern "C"
+{
+unsigned int __stdcall
+startfunc(void * param)
+{
+    Thread *thr = reinterpret_cast<Thread *>(param);
+    thr->doRun();
+    return 0;
+}
+}
+
+Thread::Thread(StartFunc thrfn, void *param)
+{
+    fn = thrfn;
+    fnparam = param;
+    uintptr_t rv;
+    rv = _beginthreadex(NULL, 0, startfunc, this, 0, NULL);
+    assert(rv);
+    hThread = (HANDLE)rv;
+    initialized = true;
+}
+
+void
+Thread::join()
+{
+    WaitForSingleObject(hThread, INFINITE);
+}
+
+void
+Thread::close()
+{
+    if (initialized) {
+        join();
+        CloseHandle(hThread);
+        initialized = false;
+    }
+}
+
+Thread::~Thread()
+{
+    close();
+}
+
+Mutex::Mutex()
+{
+    InitializeCriticalSection(&cs);
+    initialized = true;
+}
+
+Mutex::~Mutex()
+{
+    close();
+}
+
+void
+Mutex::close()
+{
+    if (initialized) {
+        DeleteCriticalSection(&cs);
+        initialized = false;
+    }
+}
+
+void
+Mutex::lock()
+{
+    EnterCriticalSection(&cs);
+}
+
+bool
+Mutex::tryLock()
+{
+    return TryEnterCriticalSection(&cs) == TRUE;
+}
+
+void
+Mutex::unlock()
+{
+    LeaveCriticalSection(&cs);
+}
+
+
+Condvar::Condvar()
+{
+    InitializeConditionVariable(&cv);
+    initialized = true;
+}
+
+void
+Condvar::close()
+{
+    initialized = false;
+}
+
+Condvar::~Condvar()
+{
+    close();
+}
+
+void
+Condvar::signal()
+{
+    WakeConditionVariable(&cv);
+}
+
+void
+Condvar::wait(Mutex& mutex)
+{
+    SleepConditionVariableCS(&cv, &mutex.cs, INFINITE);
+}
+#endif