diff --git a/libweave/examples/ubuntu/avahi_client.cc b/libweave/examples/ubuntu/avahi_client.cc
new file mode 100644
index 0000000..b14d45c
--- /dev/null
+++ b/libweave/examples/ubuntu/avahi_client.cc
@@ -0,0 +1,103 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "libweave/examples/ubuntu/avahi_client.h"
+
+#include <cstdlib>
+#include <vector>
+
+#include <avahi-common/error.h>
+
+namespace weave {
+namespace examples {
+
+namespace {
+
+void GroupCallback(AvahiEntryGroup* g,
+                   AvahiEntryGroupState state,
+                   AVAHI_GCC_UNUSED void* userdata) {
+  CHECK_NE(state, AVAHI_ENTRY_GROUP_COLLISION);
+  CHECK_NE(state, AVAHI_ENTRY_GROUP_FAILURE);
+}
+
+}  // namespace
+
+MdnsImpl::MdnsImpl() {
+  CHECK_EQ(0, std::system("service avahi-daemon status | grep process || "
+                          "service avahi-daemon start"));
+  thread_pool_.reset(avahi_threaded_poll_new());
+  CHECK(thread_pool_);
+
+  int ret = 0;
+  client_.reset(avahi_client_new(avahi_threaded_poll_get(thread_pool_.get()),
+                                 {}, nullptr, this, &ret));
+  CHECK(client_) << avahi_strerror(ret);
+
+  avahi_threaded_poll_start(thread_pool_.get());
+
+  group_.reset(avahi_entry_group_new(client_.get(), GroupCallback, nullptr));
+
+  CHECK(group_);
+}
+
+MdnsImpl::~MdnsImpl() {
+  if (thread_pool_)
+    avahi_threaded_poll_stop(thread_pool_.get());
+}
+
+void MdnsImpl::PublishService(const std::string& service_name,
+                              uint16_t port,
+                              const std::map<std::string, std::string>& txt) {
+  LOG(INFO) << "Publishing service";
+  CHECK(group_);
+
+  // Create txt record.
+  std::unique_ptr<AvahiStringList, decltype(&avahi_string_list_free)> txt_list{
+      nullptr, &avahi_string_list_free};
+  if (!txt.empty()) {
+    std::vector<std::string> txt_vector;
+    for (const auto& i : txt)
+      txt_vector.push_back(i.first + "=" + i.second);
+    std::vector<const char*> txt_vector_ptr;
+    for (const auto& i : txt_vector)
+      txt_vector_ptr.push_back(i.c_str());
+    txt_list.reset(avahi_string_list_new_from_array(txt_vector_ptr.data(),
+                                                    txt_vector_ptr.size()));
+    CHECK(txt_list);
+  }
+
+  int ret = 0;
+  if (prev_port_ == port && prev_type_ == service_name) {
+    ret = avahi_entry_group_update_service_txt_strlst(
+        group_.get(), AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, {}, GetId().c_str(),
+        ("_" + service_name + "._tcp").c_str(), nullptr, txt_list.get());
+    CHECK_GE(ret, 0) << avahi_strerror(ret);
+  } else {
+    prev_port_ = port;
+    prev_type_ = service_name;
+
+    avahi_entry_group_reset(group_.get());
+    CHECK(avahi_entry_group_is_empty(group_.get()));
+
+    ret = avahi_entry_group_add_service_strlst(
+        group_.get(), AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, {}, GetId().c_str(),
+        ("_" + service_name + "._tcp").c_str(), nullptr, nullptr, port,
+        txt_list.get());
+    CHECK_GE(ret, 0) << avahi_strerror(ret);
+    ret = avahi_entry_group_commit(group_.get());
+    CHECK_GE(ret, 0) << avahi_strerror(ret);
+  }
+}
+
+void MdnsImpl::StopPublishing(const std::string& service_name) {
+  CHECK(group_);
+  avahi_entry_group_reset(group_.get());
+}
+
+std::string MdnsImpl::GetId() const {
+  return "Weave example " + std::to_string(gethostid());
+}
+
+}  // namespace examples
+}  // namespace weave
diff --git a/libweave/examples/ubuntu/avahi_client.h b/libweave/examples/ubuntu/avahi_client.h
new file mode 100644
index 0000000..6b5d1b0
--- /dev/null
+++ b/libweave/examples/ubuntu/avahi_client.h
@@ -0,0 +1,48 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_EXAMPLES_UBUNTU_AVAHI_CLIENT_H_
+#define LIBWEAVE_EXAMPLES_UBUNTU_AVAHI_CLIENT_H_
+
+#include <map>
+#include <string>
+
+#include <avahi-client/client.h>
+#include <avahi-client/publish.h>
+#include <avahi-common/thread-watch.h>
+
+#include <weave/mdns.h>
+
+namespace weave {
+namespace examples {
+
+// Example of weave::Mdns implemented with avahi.
+class MdnsImpl : public Mdns {
+ public:
+  MdnsImpl();
+
+  ~MdnsImpl() override;
+  void PublishService(const std::string& service_name,
+                      uint16_t port,
+                      const std::map<std::string, std::string>& txt) override;
+  void StopPublishing(const std::string& service_name) override;
+  std::string GetId() const override;
+
+  uint16_t prev_port_{0};
+  std::string prev_type_;
+
+  std::unique_ptr<AvahiThreadedPoll, decltype(&avahi_threaded_poll_free)>
+      thread_pool_{nullptr, &avahi_threaded_poll_free};
+
+  std::unique_ptr<AvahiClient, decltype(&avahi_client_free)> client_{
+      nullptr, &avahi_client_free};
+
+  std::unique_ptr<AvahiEntryGroup, decltype(&avahi_entry_group_free)> group_{
+      nullptr, &avahi_entry_group_free};
+};
+
+}  // namespace examples
+}  // namespace weave
+
+#endif  // LIBWEAVE_EXAMPLES_UBUNTU_AVAHI_CLIENT_H_
diff --git a/libweave/examples/ubuntu/curl_http_client.cc b/libweave/examples/ubuntu/curl_http_client.cc
new file mode 100644
index 0000000..3ab3497
--- /dev/null
+++ b/libweave/examples/ubuntu/curl_http_client.cc
@@ -0,0 +1,146 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "libweave/examples/ubuntu/curl_http_client.h"
+
+#include <base/bind.h>
+#include <curl/curl.h>
+#include <weave/task_runner.h>
+
+namespace weave {
+namespace examples {
+
+namespace {
+
+struct ResponseImpl : public HttpClient::Response {
+  int GetStatusCode() const { return status; }
+  std::string GetContentType() const { return content_type; }
+  const std::string& GetData() const { return data; }
+
+  int status;
+  std::string content_type;
+  std::string data;
+};
+
+size_t WriteFunction(void* contents, size_t size, size_t nmemb, void* userp) {
+  static_cast<std::string*>(userp)
+      ->append(static_cast<const char*>(contents), size * nmemb);
+  return size * nmemb;
+}
+
+}  // namespace
+
+CurlHttpClient::CurlHttpClient(TaskRunner* task_runner)
+    : task_runner_{task_runner} {}
+
+std::unique_ptr<HttpClient::Response> CurlHttpClient::SendRequestAndBlock(
+    const std::string& method,
+    const std::string& url,
+    const Headers& headers,
+    const std::string& data,
+    ErrorPtr* error) {
+  std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> curl{curl_easy_init(),
+                                                           &curl_easy_cleanup};
+  CHECK(curl);
+
+  if (method == "GET") {
+    CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_HTTPGET, 1L));
+  } else if (method == "POST") {
+    CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_HTTPPOST, 1L));
+  } else {
+    CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_CUSTOMREQUEST,
+                                        method.c_str()));
+  }
+
+  CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str()));
+
+  curl_slist* chunk = nullptr;
+  for (const auto& h : headers)
+    chunk = curl_slist_append(chunk, (h.first + ": " + h.second).c_str());
+
+  CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, chunk));
+
+  if (!data.empty() || method == "POST") {
+    CHECK_EQ(CURLE_OK,
+             curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDS, data.c_str()));
+  }
+
+  std::unique_ptr<ResponseImpl> response{new ResponseImpl};
+  CHECK_EQ(CURLE_OK,
+           curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, &WriteFunction));
+  CHECK_EQ(CURLE_OK,
+           curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &response->data));
+  CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_HEADERFUNCTION,
+                                      &WriteFunction));
+  CHECK_EQ(CURLE_OK, curl_easy_setopt(curl.get(), CURLOPT_HEADERDATA,
+                                      &response->content_type));
+
+  CURLcode res = curl_easy_perform(curl.get());
+  if (chunk)
+    curl_slist_free_all(chunk);
+
+  if (res != CURLE_OK) {
+    Error::AddTo(error, FROM_HERE, "curl", "curl_easy_perform_error",
+                 curl_easy_strerror(res));
+    return nullptr;
+  }
+
+  const std::string kContentType = "\r\nContent-Type:";
+  auto pos = response->content_type.find(kContentType);
+  if (pos == std::string::npos) {
+    Error::AddTo(error, FROM_HERE, "curl", "no_content_header",
+                 "Content-Type header is missing");
+    return nullptr;
+  }
+  pos += kContentType.size();
+  auto pos_end = response->content_type.find("\r\n", pos);
+  if (pos_end == std::string::npos) {
+    pos_end = response->content_type.size();
+  }
+
+  response->content_type = response->content_type.substr(pos, pos_end);
+
+  CHECK_EQ(CURLE_OK, curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE,
+                                       &response->status));
+  return std::move(response);
+}
+
+int CurlHttpClient::SendRequest(const std::string& method,
+                                const std::string& url,
+                                const Headers& headers,
+                                const std::string& data,
+                                const SuccessCallback& success_callback,
+                                const ErrorCallback& error_callback) {
+  ++request_id_;
+  ErrorPtr error;
+  auto response = SendRequestAndBlock(method, url, headers, data, &error);
+  if (response) {
+    task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&CurlHttpClient::RunSuccessCallback,
+                              weak_ptr_factory_.GetWeakPtr(), success_callback,
+                              request_id_, base::Passed(&response)),
+        {});
+    return request_id_;
+  }
+  task_runner_->PostDelayedTask(
+      FROM_HERE, base::Bind(&CurlHttpClient::RunErrorCallback,
+                            weak_ptr_factory_.GetWeakPtr(), error_callback,
+                            request_id_, base::Passed(&error)),
+      {});
+}
+
+void CurlHttpClient::RunSuccessCallback(const SuccessCallback& success_callback,
+                                        int id,
+                                        std::unique_ptr<Response> response) {
+  success_callback.Run(id, *response);
+}
+
+void CurlHttpClient::RunErrorCallback(const ErrorCallback& error_callback,
+                                      int id,
+                                      ErrorPtr error) {
+  error_callback.Run(id, error.get());
+}
+
+}  // namespace examples
+}  // namespace weave
diff --git a/libweave/examples/ubuntu/curl_http_client.h b/libweave/examples/ubuntu/curl_http_client.h
new file mode 100644
index 0000000..45e13dc
--- /dev/null
+++ b/libweave/examples/ubuntu/curl_http_client.h
@@ -0,0 +1,54 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_EXAMPLES_UBUNTU_CURL_HTTP_CLIENT_H_
+#define LIBWEAVE_EXAMPLES_UBUNTU_CURL_HTTP_CLIENT_H_
+
+#include <string>
+
+#include <base/memory/weak_ptr.h>
+#include <weave/http_client.h>
+
+namespace weave {
+
+class TaskRunner;
+
+namespace examples {
+
+// Basic implementation of weave::HttpClient using libcurl. Should be used in
+// production code as it's blocking and does not validate server certificates.
+class CurlHttpClient : public HttpClient {
+ public:
+  explicit CurlHttpClient(TaskRunner* task_runner);
+
+  std::unique_ptr<Response> SendRequestAndBlock(const std::string& method,
+                                                const std::string& url,
+                                                const Headers& headers,
+                                                const std::string& data,
+                                                ErrorPtr* error) override;
+  int SendRequest(const std::string& method,
+                  const std::string& url,
+                  const Headers& headers,
+                  const std::string& data,
+                  const SuccessCallback& success_callback,
+                  const ErrorCallback& error_callback) override;
+
+ private:
+  void RunSuccessCallback(const SuccessCallback& success_callback,
+                          int id,
+                          std::unique_ptr<Response> response);
+  void RunErrorCallback(const ErrorCallback& error_callback,
+                        int id,
+                        ErrorPtr error);
+
+  TaskRunner* task_runner_{nullptr};
+  int request_id_ = 0;
+
+  base::WeakPtrFactory<CurlHttpClient> weak_ptr_factory_{this};
+};
+
+}  // namespace examples
+}  // namespace weave
+
+#endif  // LIBWEAVE_EXAMPLES_UBUNTU_CURL_HTTP_CLIENT_H_
diff --git a/libweave/examples/ubuntu/event_http_server.cc b/libweave/examples/ubuntu/event_http_server.cc
new file mode 100644
index 0000000..a8e2139
--- /dev/null
+++ b/libweave/examples/ubuntu/event_http_server.cc
@@ -0,0 +1,185 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "libweave/examples/ubuntu/event_http_server.h"
+
+#include <vector>
+
+#include <base/bind.h>
+#include <base/time/time.h>
+#include <event2/bufferevent_ssl.h>
+#include <openssl/err.h>
+
+namespace weave {
+namespace examples {
+
+namespace {
+
+std::string GetSslError() {
+  char error[1000] = {};
+  ERR_error_string_n(ERR_get_error(), error, sizeof(error));
+  return error;
+}
+
+bufferevent* BuffetEventCallback(event_base* base, void* arg) {
+  SSL_CTX* ctx = static_cast<SSL_CTX*>(arg);
+  return bufferevent_openssl_socket_new(
+      base, -1, SSL_new(ctx), BUFFEREVENT_SSL_ACCEPTING, BEV_OPT_CLOSE_ON_FREE);
+}
+
+}  // namespace
+
+class HttpServerImpl::RequestImpl : public Request {
+ public:
+  explicit RequestImpl(evhttp_request* req) : path_{evhttp_request_uri(req)} {
+    path_ = path_.substr(0, path_.find("?"));
+    path_ = path_.substr(0, path_.find("#"));
+    req_.reset(req);
+
+    data_.resize(evbuffer_get_length(req_->input_buffer));
+    evbuffer_remove(req_->input_buffer, data_.data(), data_.size());
+  }
+
+  ~RequestImpl() {}
+
+  const std::string& GetPath() const override { return path_; }
+  std::string GetFirstHeader(const std::string& name) const override {
+    const char* header = evhttp_find_header(req_->input_headers, name.c_str());
+    if (!header)
+      return {};
+    return header;
+  }
+  const std::vector<uint8_t>& GetData() const override { return data_; }
+
+  evhttp_request* ReleaseHandler() { return req_.release(); }
+
+ private:
+  std::vector<uint8_t> data_;
+  std::unique_ptr<evhttp_request, decltype(&evhttp_cancel_request)> req_{
+      nullptr, &evhttp_cancel_request};
+  std::string path_;
+};
+
+HttpServerImpl::HttpServerImpl(event_base* base) : base_{base} {
+  SSL_load_error_strings();
+  SSL_library_init();
+
+  ctx_.reset(SSL_CTX_new(TLSv1_2_server_method()));
+  SSL_CTX_set_options(ctx_.get(), SSL_OP_SINGLE_DH_USE |
+                                      SSL_OP_SINGLE_ECDH_USE | SSL_OP_NO_SSLv2);
+
+  ec_key_.reset(EC_KEY_new_by_curve_name(NID_X9_62_prime256v1));
+  CHECK(ec_key_) << GetSslError();
+  CHECK_EQ(1, SSL_CTX_set_tmp_ecdh(ctx_.get(), ec_key_.get())) << GetSslError();
+
+  GenerateX509();
+  CHECK_EQ(1, SSL_CTX_use_PrivateKey(ctx_.get(), pkey_.get())) << GetSslError();
+  CHECK_EQ(1, SSL_CTX_use_certificate(ctx_.get(), x509_.get()))
+      << GetSslError();
+
+  CHECK_EQ(1, SSL_CTX_check_private_key(ctx_.get())) << GetSslError();
+
+  httpd_.reset(evhttp_new(base_));
+  CHECK(httpd_);
+  httpsd_.reset(evhttp_new(base_));
+  CHECK(httpsd_);
+
+  evhttp_set_bevcb(httpsd_.get(), BuffetEventCallback, ctx_.get());
+  evhttp_set_gencb(httpd_.get(), ProcessRequestCallback, this);
+  evhttp_set_gencb(httpsd_.get(), ProcessRequestCallback, this);
+
+  CHECK_EQ(0, evhttp_bind_socket(httpd_.get(), "0.0.0.0", GetHttpPort()));
+  CHECK_EQ(0, evhttp_bind_socket(httpsd_.get(), "0.0.0.0", GetHttpsPort()));
+}
+
+void HttpServerImpl::GenerateX509() {
+  x509_.reset(X509_new());
+  CHECK(x509_) << GetSslError();
+
+  X509_set_version(x509_.get(), 2);
+
+  X509_gmtime_adj(X509_get_notBefore(x509_.get()), 0);
+  X509_gmtime_adj(X509_get_notAfter(x509_.get()),
+                  base::TimeDelta::FromDays(365).InSeconds());
+
+  pkey_.reset(EVP_PKEY_new());
+  CHECK(pkey_) << GetSslError();
+  std::unique_ptr<BIGNUM, decltype(&BN_free)> big_num(BN_new(), &BN_free);
+  CHECK(BN_set_word(big_num.get(), 65537)) << GetSslError();
+  auto rsa = RSA_new();
+  RSA_generate_key_ex(rsa, 2048, big_num.get(), nullptr);
+  CHECK(EVP_PKEY_assign_RSA(pkey_.get(), rsa)) << GetSslError();
+
+  X509_set_pubkey(x509_.get(), pkey_.get());
+
+  CHECK(X509_sign(x509_.get(), pkey_.get(), EVP_sha256())) << GetSslError();
+
+  cert_fingerprint_.resize(EVP_MD_size(EVP_sha256()));
+  uint32_t len = 0;
+  CHECK(X509_digest(x509_.get(), EVP_sha256(), cert_fingerprint_.data(), &len));
+  CHECK_EQ(len, cert_fingerprint_.size());
+}
+
+void HttpServerImpl::ProcessRequestCallback(evhttp_request* req, void* arg) {
+  static_cast<HttpServerImpl*>(arg)->ProcessRequest(req);
+}
+
+void HttpServerImpl::NotFound(evhttp_request* req) {
+  std::unique_ptr<evbuffer, decltype(&evbuffer_free)> buf{evbuffer_new(),
+                                                          &evbuffer_free};
+  evbuffer_add_printf(buf.get(), "404 Not Found: %s\n",
+                      evhttp_request_uri(req));
+  evhttp_send_reply(req, 404, "Not Found", buf.get());
+}
+
+void HttpServerImpl::ProcessRequest(evhttp_request* req) {
+  std::string path = evhttp_request_uri(req);
+  for (auto i = handlers_.rbegin(); i != handlers_.rend(); ++i) {
+    if (path.compare(0, i->first.size(), i->first) == 0) {
+      auto request = std::make_shared<RequestImpl>(req);
+      i->second.Run(*request,
+                    base::Bind(&HttpServerImpl::ProcessReply,
+                               weak_ptr_factory_.GetWeakPtr(), request));
+      return;
+    }
+  }
+  NotFound(req);
+}
+void HttpServerImpl::ProcessReply(std::shared_ptr<RequestImpl> request,
+                                  int status_code,
+                                  const std::string& data,
+                                  const std::string& mime_type) {
+  std::unique_ptr<evbuffer, decltype(&evbuffer_free)> buf{evbuffer_new(),
+                                                          &evbuffer_free};
+  evbuffer_add(buf.get(), data.data(), data.size());
+  evhttp_request* req = request->ReleaseHandler();
+  evhttp_add_header(req->output_headers, "Content-Type", mime_type.c_str());
+  evhttp_send_reply(req, status_code, "None", buf.get());
+}
+
+void HttpServerImpl::AddOnStateChangedCallback(
+    const OnStateChangedCallback& callback) {
+  callback.Run(*this);
+}
+
+void HttpServerImpl::AddRequestHandler(const std::string& path_prefix,
+                                       const OnRequestCallback& callback) {
+  handlers_.emplace(path_prefix, callback);
+}
+
+uint16_t HttpServerImpl::GetHttpPort() const {
+  return 7780;
+}
+
+uint16_t HttpServerImpl::GetHttpsPort() const {
+  return 7781;
+}
+
+const std::vector<uint8_t>& HttpServerImpl::GetHttpsCertificateFingerprint()
+    const {
+  return cert_fingerprint_;
+}
+
+}  // namespace examples
+}  // namespace weave
diff --git a/libweave/examples/ubuntu/event_http_server.h b/libweave/examples/ubuntu/event_http_server.h
new file mode 100644
index 0000000..32d567e
--- /dev/null
+++ b/libweave/examples/ubuntu/event_http_server.h
@@ -0,0 +1,70 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_EXAMPLES_UBUNTU_EVENT_HTTP_SERVER_H_
+#define LIBWEAVE_EXAMPLES_UBUNTU_EVENT_HTTP_SERVER_H_
+
+#include <event2/http.h>
+#include <evhttp.h>
+#include <openssl/ssl.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include <base/memory/weak_ptr.h>
+#include <weave/http_server.h>
+
+namespace weave {
+namespace examples {
+
+// HTTP/HTTPS server implemented with libevent.
+class HttpServerImpl : public HttpServer {
+ public:
+  class RequestImpl;
+
+  explicit HttpServerImpl(event_base* base);
+
+  void AddOnStateChangedCallback(
+      const OnStateChangedCallback& callback) override;
+  void AddRequestHandler(const std::string& path_prefix,
+                         const OnRequestCallback& callback) override;
+  uint16_t GetHttpPort() const override;
+  uint16_t GetHttpsPort() const override;
+  const std::vector<uint8_t>& GetHttpsCertificateFingerprint() const override;
+
+ private:
+  void GenerateX509();
+  static void ProcessRequestCallback(evhttp_request* req, void* arg);
+  void ProcessRequest(evhttp_request* req);
+  void ProcessReply(std::shared_ptr<RequestImpl> request,
+                    int status_code,
+                    const std::string& data,
+                    const std::string& mime_type);
+  void NotFound(evhttp_request* req);
+
+  std::map<std::string, OnRequestCallback> handlers_;
+
+  std::unique_ptr<EC_KEY, decltype(&EC_KEY_free)> ec_key_{nullptr,
+                                                          &EC_KEY_free};
+
+  std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)> pkey_{nullptr,
+                                                            &EVP_PKEY_free};
+
+  std::unique_ptr<X509, decltype(&X509_free)> x509_{nullptr, &X509_free};
+
+  std::unique_ptr<SSL_CTX, decltype(&SSL_CTX_free)> ctx_{nullptr,
+                                                         &SSL_CTX_free};
+  std::vector<uint8_t> cert_fingerprint_;
+  event_base* base_{nullptr};
+  std::unique_ptr<evhttp, decltype(&evhttp_free)> httpd_{nullptr, &evhttp_free};
+  std::unique_ptr<evhttp, decltype(&evhttp_free)> httpsd_{nullptr,
+                                                          &evhttp_free};
+  base::WeakPtrFactory<HttpServerImpl> weak_ptr_factory_{this};
+};
+
+}  // namespace examples
+}  // namespace weave
+
+#endif  // LIBWEAVE_EXAMPLES_UBUNTU_EVENT_HTTP_SERVER_H_
diff --git a/libweave/examples/ubuntu/event_task_runner.cc b/libweave/examples/ubuntu/event_task_runner.cc
new file mode 100644
index 0000000..e80d7a5
--- /dev/null
+++ b/libweave/examples/ubuntu/event_task_runner.cc
@@ -0,0 +1,70 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "libweave/examples/ubuntu/event_task_runner.h"
+
+#include <signal.h>
+
+namespace weave {
+namespace examples {
+
+namespace {
+event_base* g_event_base = nullptr;
+}
+
+void EventTaskRunner::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  base::Time new_time = base::Time::Now() + delay;
+  if (queue_.empty() || new_time < queue_.top().first.first) {
+    ReScheduleEvent(delay);
+  }
+  queue_.emplace(std::make_pair(new_time, ++counter_), task);
+}
+
+void EventTaskRunner::Run() {
+  g_event_base = base_.get();
+
+  struct sigaction sa = {};
+  sa.sa_handler = [](int signal) {
+    event_base_loopexit(g_event_base, nullptr);
+  };
+  sigfillset(&sa.sa_mask);
+  sigaction(SIGINT, &sa, nullptr);
+
+  event_base_loop(g_event_base, EVLOOP_NO_EXIT_ON_EMPTY);
+  g_event_base = nullptr;
+}
+
+void EventTaskRunner::ReScheduleEvent(base::TimeDelta delay) {
+  timespec ts = delay.ToTimeSpec();
+  timeval tv = {ts.tv_sec, ts.tv_nsec / 1000};
+  event_add(task_event_.get(), &tv);
+}
+
+void EventTaskRunner::EventHandler(int, int16_t, void* runner) {
+  static_cast<EventTaskRunner*>(runner)->Process();
+}
+
+void EventTaskRunner::FreeEvent(event* evnt) {
+  event_del(evnt);
+  event_free(evnt);
+}
+
+void EventTaskRunner::Process() {
+  while (!queue_.empty() && queue_.top().first.first <= base::Time::Now()) {
+    auto cb = queue_.top().second;
+    queue_.pop();
+    cb.Run();
+  }
+  if (!queue_.empty()) {
+    base::TimeDelta delta = std::max(
+        base::TimeDelta(), queue_.top().first.first - base::Time::Now());
+    ReScheduleEvent(delta);
+  }
+}
+
+}  // namespace examples
+}  // namespace weave
diff --git a/libweave/examples/ubuntu/event_task_runner.h b/libweave/examples/ubuntu/event_task_runner.h
new file mode 100644
index 0000000..726a621
--- /dev/null
+++ b/libweave/examples/ubuntu/event_task_runner.h
@@ -0,0 +1,59 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_EXAMPLES_UBUNTU_EVENT_TASK_RUNNER_H_
+#define LIBWEAVE_EXAMPLES_UBUNTU_EVENT_TASK_RUNNER_H_
+
+#include <queue>
+#include <utility>
+#include <vector>
+
+#include <event2/event.h>
+
+#include <weave/task_runner.h>
+
+namespace weave {
+namespace examples {
+
+// Simple task runner implemented with libevent message loop.
+class EventTaskRunner : public TaskRunner {
+ public:
+  void PostDelayedTask(const tracked_objects::Location& from_here,
+                       const base::Closure& task,
+                       base::TimeDelta delay) override;
+
+  event_base* GetEventBase() const { return base_.get(); }
+
+  void Run();
+
+ private:
+  void ReScheduleEvent(base::TimeDelta delay);
+  static void EventHandler(int, int16_t, void* runner);
+  static void FreeEvent(event* evnt);
+  void Process();
+
+  using QueueItem = std::pair<std::pair<base::Time, size_t>, base::Closure>;
+
+  struct Greater {
+    bool operator()(const QueueItem& a, const QueueItem& b) const {
+      return a.first > b.first;
+    }
+  };
+
+  size_t counter_{0};  // Keeps order of tasks with the same time.
+
+  std::priority_queue<QueueItem,
+                      std::vector<QueueItem>,
+                      EventTaskRunner::Greater> queue_;
+
+  std::unique_ptr<event_base, decltype(&event_base_free)> base_{
+      event_base_new(), &event_base_free};
+  std::unique_ptr<event, decltype(&FreeEvent)> task_event_{
+      event_new(base_.get(), -1, EV_TIMEOUT, &EventHandler, this), &FreeEvent};
+};
+
+}  // namespace examples
+}  // namespace weave
+
+#endif  // LIBWEAVE_EXAMPLES_UBUNTU_EVENT_TASK_RUNNER_H_
diff --git a/libweave/examples/ubuntu/file_config_store.cc b/libweave/examples/ubuntu/file_config_store.cc
new file mode 100644
index 0000000..b2bfd0a
--- /dev/null
+++ b/libweave/examples/ubuntu/file_config_store.cc
@@ -0,0 +1,134 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "libweave/examples/ubuntu/file_config_store.h"
+
+#include <sys/stat.h>
+#include <sys/utsname.h>
+
+#include <fstream>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace weave {
+namespace examples {
+
+const char kSettingsDir[] = "/var/lib/weave/";
+const char kSettingsPath[] = "/var/lib/weave/weave_settings.json";
+
+bool FileConfigStore::LoadDefaults(Settings* settings) {
+  char host_name[HOST_NAME_MAX] = {};
+  gethostname(host_name, HOST_NAME_MAX);
+
+  settings->name = host_name;
+  settings->description = "";
+
+  utsname uname_data;
+  uname(&uname_data);
+
+  settings->firmware_version = uname_data.sysname;
+  settings->oem_name = "Unknown";
+  settings->model_name = "Unknown";
+  settings->model_id = "AAAAA";
+  settings->pairing_modes = {PairingType::kEmbeddedCode};
+  settings->embedded_code = "0000";
+  return true;
+}
+
+std::string FileConfigStore::LoadSettings() {
+  LOG(INFO) << "Loading settings from " << kSettingsPath;
+  std::ifstream str(kSettingsPath);
+  return std::string(std::istreambuf_iterator<char>(str),
+                     std::istreambuf_iterator<char>());
+}
+
+void FileConfigStore::SaveSettings(const std::string& settings) {
+  CHECK(mkdir(kSettingsDir, S_IRWXU) == 0 || errno == EEXIST);
+  LOG(INFO) << "Saving settings to " << kSettingsPath;
+  std::ofstream str(kSettingsPath);
+  str << settings;
+}
+
+void FileConfigStore::OnSettingsChanged(const Settings& settings) {
+  LOG(INFO) << "OnSettingsChanged";
+}
+
+std::string FileConfigStore::LoadBaseCommandDefs() {
+  return R"({
+    "base": {
+      "updateBaseConfiguration": {
+        "minimalRole": "manager",
+        "parameters": {
+          "localDiscoveryEnabled": "boolean",
+          "localAnonymousAccessMaxRole": [ "none", "viewer", "user" ],
+          "localPairingEnabled": "boolean"
+        },
+        "results": {}
+      },
+      "identify": {
+        "minimalRole": "user",
+        "parameters": {},
+        "results": {}
+      },
+      "updateDeviceInfo": {
+        "minimalRole": "manager",
+        "parameters": {
+          "description": "string",
+          "name": "string",
+          "location": "string"
+        },
+        "results": {}
+      }
+    }
+  })";
+}
+
+std::map<std::string, std::string> FileConfigStore::LoadCommandDefs() {
+  return {{"example", R"({
+    "base": {
+      "updateBaseConfiguration": {},
+      "identify": {},
+      "updateDeviceInfo": {}
+    }
+  })"}};
+}
+
+std::string FileConfigStore::LoadBaseStateDefs() {
+  return R"({
+    "base": {
+      "firmwareVersion": "string",
+      "localDiscoveryEnabled": "boolean",
+      "localAnonymousAccessMaxRole": [ "none", "viewer", "user" ],
+      "localPairingEnabled": "boolean",
+      "network": {
+        "properties": {
+          "name": "string"
+        }
+      }
+    }
+  })";
+}
+
+std::string FileConfigStore::LoadBaseStateDefaults() {
+  return R"({
+    "base": {
+      "firmwareVersion": "unknown",
+      "localDiscoveryEnabled": false,
+      "localAnonymousAccessMaxRole": "none",
+      "localPairingEnabled": false
+    }
+  })";
+}
+
+std::map<std::string, std::string> FileConfigStore::LoadStateDefs() {
+  return {};
+}
+
+std::vector<std::string> FileConfigStore::LoadStateDefaults() {
+  return {};
+}
+
+}  // namespace examples
+}  // namespace weave
diff --git a/libweave/examples/ubuntu/file_config_store.h b/libweave/examples/ubuntu/file_config_store.h
new file mode 100644
index 0000000..f6e9b5f
--- /dev/null
+++ b/libweave/examples/ubuntu/file_config_store.h
@@ -0,0 +1,34 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_EXAMPLES_UBUNTU_FILE_CONFIG_STORE_H_
+#define LIBWEAVE_EXAMPLES_UBUNTU_FILE_CONFIG_STORE_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include <weave/config_store.h>
+
+namespace weave {
+namespace examples {
+
+class FileConfigStore : public ConfigStore {
+ public:
+  bool LoadDefaults(Settings* settings) override;
+  std::string LoadSettings() override;
+  void SaveSettings(const std::string& settings) override;
+  void OnSettingsChanged(const Settings& settings) override;
+  std::string LoadBaseCommandDefs() override;
+  std::map<std::string, std::string> LoadCommandDefs() override;
+  std::string LoadBaseStateDefs() override;
+  std::string LoadBaseStateDefaults() override;
+  std::map<std::string, std::string> LoadStateDefs() override;
+  std::vector<std::string> LoadStateDefaults() override;
+};
+
+}  // namespace examples
+}  // namespace weave
+
+#endif  // LIBWEAVE_EXAMPLES_UBUNTU_FILE_CONFIG_STORE_H_
diff --git a/libweave/examples/ubuntu/main.cc b/libweave/examples/ubuntu/main.cc
new file mode 100644
index 0000000..b42ab66
--- /dev/null
+++ b/libweave/examples/ubuntu/main.cc
@@ -0,0 +1,35 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <weave/device.h>
+
+#include "libweave/examples/ubuntu/avahi_client.h"
+#include "libweave/examples/ubuntu/curl_http_client.h"
+#include "libweave/examples/ubuntu/event_http_server.h"
+#include "libweave/examples/ubuntu/event_task_runner.h"
+#include "libweave/examples/ubuntu/file_config_store.h"
+#include "libweave/examples/ubuntu/network_manager.h"
+
+int main() {
+  weave::examples::FileConfigStore config_store;
+  weave::examples::EventTaskRunner task_runner;
+  weave::examples::CurlHttpClient http_client{&task_runner};
+  weave::examples::NetworkImpl network{&task_runner};
+  weave::examples::MdnsImpl mdns;
+  weave::examples::HttpServerImpl http_server{task_runner.GetEventBase()};
+
+  auto device = weave::Device::Create();
+  weave::Device::Options opts;
+  opts.xmpp_enabled = true;
+  opts.disable_privet = false;
+  opts.disable_security = false;
+  opts.enable_ping = true;
+  device->Start(opts, &config_store, &task_runner, &http_client, &network,
+                &mdns, &http_server);
+
+  task_runner.Run();
+
+  LOG(INFO) << "exit";
+  return 0;
+}
diff --git a/libweave/examples/ubuntu/network_manager.cc b/libweave/examples/ubuntu/network_manager.cc
new file mode 100644
index 0000000..48c817c
--- /dev/null
+++ b/libweave/examples/ubuntu/network_manager.cc
@@ -0,0 +1,534 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "libweave/examples/ubuntu/network_manager.h"
+
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <linux/wireless.h>
+#include <netdb.h>
+#include <openssl/ssl.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+
+#include <cstdlib>
+#include <fstream>
+
+#include <base/bind.h>
+#include <weave/task_runner.h>
+
+namespace weave {
+namespace examples {
+
+namespace {
+
+int ForkCmd(const std::string& path, const std::vector<std::string>& args) {
+  int pid = fork();
+  if (pid != 0)
+    return pid;
+
+  std::vector<const char*> args_vector;
+  args_vector.push_back(path.c_str());
+  for (auto& i : args)
+    args_vector.push_back(i.c_str());
+  args_vector.push_back(nullptr);
+
+  execvp(path.c_str(), const_cast<char**>(args_vector.data()));
+  NOTREACHED();
+}
+
+class SocketStream : public Stream {
+ public:
+  explicit SocketStream(TaskRunner* task_runner) : task_runner_{task_runner} {}
+
+  ~SocketStream() { CloseBlocking(nullptr); }
+
+  void RunDelayedTask(const base::Closure& success_callback) {
+    success_callback.Run();
+  }
+
+  bool ReadAsync(void* buffer,
+                 size_t size_to_read,
+                 const base::Callback<void(size_t)>& success_callback,
+                 const base::Callback<void(const Error*)>& error_callback,
+                 ErrorPtr* error) {
+    if (socket_fd_ < 0) {
+      Error::AddTo(error, FROM_HERE, "socket", "invalid_socket",
+                   strerror(errno));
+      return false;
+    }
+    int size_read = recv(socket_fd_, buffer, size_to_read, MSG_DONTWAIT);
+    if (size_read > 0) {
+      task_runner_->PostDelayedTask(
+          FROM_HERE, base::Bind(&SocketStream::RunDelayedTask,
+                                weak_ptr_factory_.GetWeakPtr(),
+                                base::Bind(success_callback, size_read)),
+          {});
+      return true;
+    }
+    if (errno == EAGAIN || errno == EWOULDBLOCK) {
+      task_runner_->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(base::IgnoreResult(&SocketStream::ReadAsync),
+                     weak_ptr_factory_.GetWeakPtr(), buffer, size_to_read,
+                     success_callback, error_callback, nullptr),
+          base::TimeDelta::FromMilliseconds(200));
+      return true;
+    }
+
+    ErrorPtr recv_error;
+    Error::AddTo(&recv_error, FROM_HERE, "socket", "socket_recv_failed",
+                 strerror(errno));
+    task_runner_->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(error_callback, base::Owned(recv_error.release())), {});
+    return true;
+  }
+
+  bool WriteAllAsync(const void* buffer,
+                     size_t size_to_write,
+                     const base::Closure& success_callback,
+                     const base::Callback<void(const Error*)>& error_callback,
+                     ErrorPtr* error) {
+    if (socket_fd_ < 0) {
+      Error::AddTo(error, FROM_HERE, "socket", "invalid_socket",
+                   strerror(errno));
+      return false;
+    }
+    const char* buffer_ptr = static_cast<const char*>(buffer);
+    do {
+      int size_sent = send(socket_fd_, buffer_ptr, size_to_write, 0);
+      if (size_sent <= 0) {
+        ErrorPtr send_error;
+        Error::AddTo(&send_error, FROM_HERE, "socket", "socket_send_failed",
+                     strerror(errno));
+        task_runner_->PostDelayedTask(
+            FROM_HERE,
+            base::Bind(error_callback, base::Owned(send_error.release())), {});
+        // Still true as we return error with callback.
+        return true;
+      }
+      size_to_write -= size_sent;
+      buffer_ptr += size_sent;
+    } while (size_to_write > 0);
+
+    task_runner_->PostDelayedTask(FROM_HERE, success_callback, {});
+    return true;
+  }
+  bool FlushBlocking(ErrorPtr* error) { return true; }
+
+  bool CloseBlocking(ErrorPtr* error) {
+    weak_ptr_factory_.InvalidateWeakPtrs();
+    if (socket_fd_ >= 0) {
+      close(socket_fd_);
+      socket_fd_ = -1;
+    }
+  }
+
+  void CancelPendingAsyncOperations() {
+    weak_ptr_factory_.InvalidateWeakPtrs();
+  }
+
+  bool Connect(const std::string& host, uint16_t port) {
+    std::string service = std::to_string(port);
+    addrinfo hints = {0, AF_UNSPEC, SOCK_STREAM};
+    addrinfo* result = nullptr;
+    if (getaddrinfo(host.c_str(), service.c_str(), &hints, &result)) {
+      LOG(ERROR) << "Failed to resolve host name: " << host;
+      return false;
+    }
+    std::unique_ptr<addrinfo, decltype(&freeaddrinfo)> result_deleter{
+        result, &freeaddrinfo};
+
+    for (const addrinfo* info = result; info != nullptr; info = info->ai_next) {
+      socket_fd_ =
+          socket(info->ai_family, info->ai_socktype, info->ai_protocol);
+      if (socket_fd_ < 0)
+        continue;
+
+      int flags = fcntl(socket_fd_, F_GETFL, 0);
+      if (flags == -1)
+        flags = 0;
+      fcntl(socket_fd_, F_SETFL, flags | O_NONBLOCK);
+
+      LOG(INFO) << "Connecting...";
+      if (connect(socket_fd_, info->ai_addr, info->ai_addrlen) == 0)
+        break;  // Success.
+
+      if (errno == EINPROGRESS) {
+        fd_set write_fds;
+        FD_ZERO(&write_fds);
+        FD_SET(socket_fd_, &write_fds);
+
+        struct timeval tv;
+        tv.tv_sec = 5;
+        tv.tv_usec = 0;
+
+        int select_ret = select(socket_fd_ + 1, NULL, &write_fds, NULL, &tv);
+        if (select_ret != -1 && select_ret != 0) {
+          break;
+        }
+      }
+
+      LOG(ERROR) << "Failed to connect";
+      CloseBlocking(nullptr);
+    }
+
+    return socket_fd_ >= 0;
+  }
+
+  int GetFd() const { return socket_fd_; }
+
+ private:
+  TaskRunner* task_runner_{nullptr};
+  int socket_fd_{-1};
+
+  base::WeakPtrFactory<SocketStream> weak_ptr_factory_{this};
+};
+
+class SSLStream : public Stream {
+ public:
+  explicit SSLStream(TaskRunner* task_runner) : task_runner_{task_runner} {}
+
+  ~SSLStream() { weak_ptr_factory_.InvalidateWeakPtrs(); }
+
+  void RunDelayedTask(const base::Closure& success_callback) {
+    success_callback.Run();
+  }
+
+  bool ReadAsync(void* buffer,
+                 size_t size_to_read,
+                 const base::Callback<void(size_t)>& success_callback,
+                 const base::Callback<void(const Error*)>& error_callback,
+                 ErrorPtr* error) {
+    int res = SSL_read(ssl_.get(), buffer, size_to_read);
+    if (res > 0) {
+      task_runner_->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&SSLStream::RunDelayedTask, weak_ptr_factory_.GetWeakPtr(),
+                     base::Bind(success_callback, res)),
+          {});
+      return true;
+    }
+
+    int err = SSL_get_error(ssl_.get(), res);
+
+    if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
+      task_runner_->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(base::IgnoreResult(&SSLStream::ReadAsync),
+                     weak_ptr_factory_.GetWeakPtr(), buffer, size_to_read,
+                     success_callback, error_callback, nullptr),
+          base::TimeDelta::FromSeconds(1));
+      return true;
+    }
+
+    ErrorPtr weave_error;
+    Error::AddTo(&weave_error, FROM_HERE, "ssl", "socket_read_failed",
+                 "SSL error");
+    task_runner_->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(
+            &SSLStream::RunDelayedTask, weak_ptr_factory_.GetWeakPtr(),
+            base::Bind(error_callback, base::Owned(weave_error.release()))),
+        {});
+    return true;
+  }
+
+  bool WriteAllAsync(const void* buffer,
+                     size_t size_to_write,
+                     const base::Closure& success_callback,
+                     const base::Callback<void(const Error*)>& error_callback,
+                     ErrorPtr* error) {
+    int res = SSL_write(ssl_.get(), buffer, size_to_write);
+    if (res > 0) {
+      buffer = static_cast<const char*>(buffer) + res;
+      size_to_write -= res;
+      if (size_to_write == 0) {
+        task_runner_->PostDelayedTask(
+            FROM_HERE,
+            base::Bind(&SSLStream::RunDelayedTask,
+                       weak_ptr_factory_.GetWeakPtr(), success_callback),
+            {});
+        return true;
+      }
+
+      task_runner_->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(base::IgnoreResult(&SSLStream::WriteAllAsync),
+                     weak_ptr_factory_.GetWeakPtr(), buffer, size_to_write,
+                     success_callback, error_callback, nullptr),
+          base::TimeDelta::FromSeconds(1));
+
+      return true;
+    }
+
+    int err = SSL_get_error(ssl_.get(), res);
+
+    if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
+      task_runner_->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(base::IgnoreResult(&SSLStream::WriteAllAsync),
+                     weak_ptr_factory_.GetWeakPtr(), buffer, size_to_write,
+                     success_callback, error_callback, nullptr),
+          base::TimeDelta::FromSeconds(1));
+      return true;
+    }
+
+    ErrorPtr weave_error;
+    Error::AddTo(&weave_error, FROM_HERE, "ssl", "socket_write_failed",
+                 "SSL error");
+    task_runner_->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(
+            &SSLStream::RunDelayedTask, weak_ptr_factory_.GetWeakPtr(),
+            base::Bind(error_callback, base::Owned(weave_error.release()))),
+        {});
+    return true;
+  }
+
+  bool FlushBlocking(ErrorPtr* error) { return true; }
+
+  bool CloseBlocking(ErrorPtr* error) {
+    weak_ptr_factory_.InvalidateWeakPtrs();
+    return true;
+  }
+
+  void CancelPendingAsyncOperations() {
+    weak_ptr_factory_.InvalidateWeakPtrs();
+  }
+
+  bool Init() {
+    ctx_.reset(SSL_CTX_new(TLSv1_2_client_method()));
+    CHECK(ctx_);
+    ssl_.reset(SSL_new(ctx_.get()));
+
+    char endpoint[] = "talk.google.com:5223";
+    stream_bio_ = BIO_new_connect(endpoint);
+    CHECK(stream_bio_);
+    BIO_set_nbio(stream_bio_, 1);
+
+    while (BIO_do_connect(stream_bio_) != 1) {
+      CHECK(BIO_should_retry(stream_bio_));
+      sleep(1);
+    }
+
+    SSL_set_bio(ssl_.get(), stream_bio_, stream_bio_);
+    SSL_set_connect_state(ssl_.get());
+
+    for (;;) {
+      int res = SSL_do_handshake(ssl_.get());
+      if (res) {
+        return true;
+      }
+
+      res = SSL_get_error(ssl_.get(), res);
+
+      if (res != SSL_ERROR_WANT_READ || res != SSL_ERROR_WANT_WRITE) {
+        return false;
+      }
+
+      sleep(1);
+    }
+    return false;
+  }
+
+ private:
+  TaskRunner* task_runner_{nullptr};
+  std::unique_ptr<SSL_CTX, decltype(&SSL_CTX_free)> ctx_{nullptr, SSL_CTX_free};
+  std::unique_ptr<SSL, decltype(&SSL_free)> ssl_{nullptr, SSL_free};
+  BIO* stream_bio_{nullptr};
+
+  base::WeakPtrFactory<SSLStream> weak_ptr_factory_{this};
+};
+
+}  // namespace
+
+NetworkImpl::NetworkImpl(TaskRunner* task_runner) : task_runner_{task_runner} {
+  SSL_load_error_strings();
+  SSL_library_init();
+
+  DisableAccessPoint();
+}
+NetworkImpl::~NetworkImpl() {
+  DisableAccessPoint();
+}
+
+void NetworkImpl::AddOnConnectionChangedCallback(
+    const OnConnectionChangedCallback& listener) {
+  callbacks_.push_back(listener);
+}
+
+void NetworkImpl::TryToConnect(const std::string& ssid,
+                               const std::string& passphrase,
+                               int pid,
+                               base::Time until,
+                               const base::Closure& on_success) {
+  if (pid) {
+    int status = 0;
+    if (pid == waitpid(pid, &status, WNOWAIT)) {
+      int sockf_d = socket(AF_INET, SOCK_DGRAM, 0);
+      CHECK_GE(sockf_d, 0) << strerror(errno);
+
+      iwreq wreq = {};
+      snprintf(wreq.ifr_name, sizeof(wreq.ifr_name), "wlan0");
+      std::string essid(' ', IW_ESSID_MAX_SIZE + 1);
+      wreq.u.essid.pointer = &essid[0];
+      wreq.u.essid.length = essid.size();
+      CHECK_GE(ioctl(sockf_d, SIOCGIWESSID, &wreq), 0) << strerror(errno);
+      essid.resize(wreq.u.essid.length);
+      close(sockf_d);
+
+      if (ssid == essid) {
+        task_runner_->PostDelayedTask(
+            FROM_HERE, base::Bind(&NetworkImpl::NotifyNetworkChanged,
+                                  weak_ptr_factory_.GetWeakPtr()),
+            {});
+        return task_runner_->PostDelayedTask(FROM_HERE, on_success, {});
+      }
+      pid = 0;  // Try again.
+    }
+  }
+
+  if (pid == 0) {
+    pid = ForkCmd("nmcli",
+                  {"dev", "wifi", "connect", ssid, "password", passphrase});
+  }
+
+  if (base::Time::Now() >= until) {
+    task_runner_->PostDelayedTask(FROM_HERE,
+                                  base::Bind(&NetworkImpl::NotifyNetworkChanged,
+                                             weak_ptr_factory_.GetWeakPtr()),
+                                  {});
+    return;
+  }
+
+  task_runner_->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&NetworkImpl::TryToConnect, weak_ptr_factory_.GetWeakPtr(),
+                 ssid, passphrase, pid, until, on_success),
+      base::TimeDelta::FromSeconds(1));
+}
+
+bool NetworkImpl::ConnectToService(const std::string& ssid,
+                                   const std::string& passphrase,
+                                   const base::Closure& on_success,
+                                   ErrorPtr* error) {
+  CHECK(!hostapd_started_);
+  if (hostapd_started_) {
+    Error::AddTo(error, FROM_HERE, "wifi", "busy", "Running Access Point.");
+    return false;
+  }
+
+  TryToConnect(ssid, passphrase, 0,
+               base::Time::Now() + base::TimeDelta::FromMinutes(1), on_success);
+}
+
+NetworkState NetworkImpl::GetConnectionState() const {
+  // Forced soft AP.
+  return NetworkState::kOffline;
+
+  if (std::system("ping talk.google.com -c 1") == 0)
+    return NetworkState::kConnected;
+
+  if (std::system("nmcli dev"))
+    return NetworkState::kFailure;
+
+  if (std::system("nmcli dev | grep connecting") == 0)
+    return NetworkState::kConnecting;
+
+  return NetworkState::kOffline;
+}
+
+void NetworkImpl::EnableAccessPoint(const std::string& ssid) {
+  if (hostapd_started_)
+    return;
+
+  // Release wlan0 interface.
+  CHECK_EQ(0, std::system("nmcli nm wifi off"));
+  CHECK_EQ(0, std::system("rfkill unblock wlan"));
+  sleep(1);
+
+  std::string hostapd_conf = "/tmp/weave_hostapd.conf";
+  {
+    std::ofstream ofs(hostapd_conf);
+    ofs << "interface=wlan0" << std::endl;
+    ofs << "channel=1" << std::endl;
+    ofs << "ssid=" << ssid << std::endl;
+  }
+
+  CHECK_EQ(0, std::system(("hostapd -B -K " + hostapd_conf).c_str()));
+  hostapd_started_ = true;
+
+  for (size_t i = 0; i < 10; ++i) {
+    if (0 == std::system("ifconfig wlan0 192.168.76.1/24"))
+      break;
+    sleep(1);
+  }
+
+  std::string dnsmasq_conf = "/tmp/weave_dnsmasq.conf";
+  {
+    std::ofstream ofs(dnsmasq_conf.c_str());
+    ofs << "port=0" << std::endl;
+    ofs << "bind-interfaces" << std::endl;
+    ofs << "log-dhcp" << std::endl;
+    ofs << "dhcp-range=192.168.76.10,192.168.76.100" << std::endl;
+    ofs << "interface=wlan0" << std::endl;
+    ofs << "dhcp-leasefile=" << dnsmasq_conf << ".leases" << std::endl;
+  }
+
+  CHECK_EQ(0, std::system(("dnsmasq --conf-file=" + dnsmasq_conf).c_str()));
+  task_runner_->PostDelayedTask(FROM_HERE,
+                                base::Bind(&NetworkImpl::NotifyNetworkChanged,
+                                           weak_ptr_factory_.GetWeakPtr()),
+                                {});
+}
+
+void NetworkImpl::DisableAccessPoint() {
+  int res = std::system("pkill -f dnsmasq.*/tmp/weave");
+  res = std::system("pkill -f hostapd.*/tmp/weave");
+  CHECK_EQ(0, std::system("nmcli nm wifi on"));
+  hostapd_started_ = false;
+
+  task_runner_->PostDelayedTask(FROM_HERE,
+                                base::Bind(&NetworkImpl::NotifyNetworkChanged,
+                                           weak_ptr_factory_.GetWeakPtr()),
+                                {});
+}
+
+void NetworkImpl::NotifyNetworkChanged() {
+  bool online = GetConnectionState() == NetworkState::kConnected;
+  for (const auto& i : callbacks_)
+    i.Run(online);
+}
+
+std::unique_ptr<Stream> NetworkImpl::OpenSocketBlocking(const std::string& host,
+                                                        uint16_t port) {
+  std::unique_ptr<SocketStream> stream{new SocketStream{task_runner_}};
+  if (!stream->Connect(host, port))
+    return nullptr;
+  return std::move(stream);
+}
+
+void NetworkImpl::CreateTlsStream(
+    std::unique_ptr<Stream> stream,
+    const std::string& host,
+    const base::Callback<void(std::unique_ptr<Stream>)>& success_callback,
+    const base::Callback<void(const Error*)>& error_callback) {
+  // Connect to SSL port instead of upgrading to TLS.
+  std::unique_ptr<SSLStream> tls_stream{new SSLStream{task_runner_}};
+
+  if (tls_stream->Init()) {
+    task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(success_callback, base::Passed(&tls_stream)), {});
+  } else {
+    ErrorPtr error;
+    Error::AddTo(&error, FROM_HERE, "tls", "tls_init_failed",
+                 "Failed to initialize TLS stream.");
+  }
+}
+
+}  // namespace examples
+}  // namespace weave
diff --git a/libweave/examples/ubuntu/network_manager.h b/libweave/examples/ubuntu/network_manager.h
new file mode 100644
index 0000000..c58d220
--- /dev/null
+++ b/libweave/examples/ubuntu/network_manager.h
@@ -0,0 +1,63 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_EXAMPLES_UBUNTU_NETWORK_MANAGER_H_
+#define LIBWEAVE_EXAMPLES_UBUNTU_NETWORK_MANAGER_H_
+
+#include <string>
+#include <vector>
+
+#include <base/memory/weak_ptr.h>
+#include <base/time/time.h>
+#include <weave/network.h>
+
+namespace weave {
+
+class TaskRunner;
+
+namespace examples {
+
+// Basic weave::Network implementation.
+// Production version of SSL socket needs secure server certificate check.
+class NetworkImpl : public Network {
+ public:
+  explicit NetworkImpl(TaskRunner* task_runner);
+  ~NetworkImpl();
+
+  void AddOnConnectionChangedCallback(
+      const OnConnectionChangedCallback& listener) override;
+  bool ConnectToService(const std::string& ssid,
+                        const std::string& passphrase,
+                        const base::Closure& on_success,
+                        ErrorPtr* error) override;
+  NetworkState GetConnectionState() const override;
+  void EnableAccessPoint(const std::string& ssid) override;
+  void DisableAccessPoint() override;
+  std::unique_ptr<Stream> OpenSocketBlocking(const std::string& host,
+                                             uint16_t port) override;
+  void CreateTlsStream(
+      std::unique_ptr<Stream> stream,
+      const std::string& host,
+      const base::Callback<void(std::unique_ptr<Stream>)>& success_callback,
+      const base::Callback<void(const Error*)>& error_callback) override;
+
+ private:
+  void TryToConnect(const std::string& ssid,
+                    const std::string& passphrase,
+                    int pid,
+                    base::Time until,
+                    const base::Closure& on_success);
+  void NotifyNetworkChanged();
+
+  bool hostapd_started_{false};
+  TaskRunner* task_runner_{nullptr};
+  std::vector<OnConnectionChangedCallback> callbacks_;
+
+  base::WeakPtrFactory<NetworkImpl> weak_ptr_factory_{this};
+};
+
+}  // namespace examples
+}  // namespace weave
+
+#endif  // LIBWEAVE_EXAMPLES_UBUNTU_NETWORK_MANAGER_H_