this patch adds the manifest proxy server to sel_ldr and the manifest

src/trusted/simple_service/nacl_simple_service.c

 /*
  * Copyright (c) 2011 The Native Client 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 "native_client/src/trusted/simple_service/nacl_simple_service.h"
 
 #include "native_client/src/include/nacl_compiler_annotations.h"
 
@@ skipping 13 matching lines @@
 #include "native_client/src/trusted/service_runtime/include/sys/errno.h"
 
 #include "native_client/src/trusted/threading/nacl_thread_interface.h"
 
 int NaClSimpleServiceConnectionCtor(
     struct NaClSimpleServiceConnection  *self,
     struct NaClSimpleService            *server,
     struct NaClDesc                     *conn,
     void                                *instance_data) {
   NaClLog(4,
-          "NaClSimpleServiceConnectionCtor: this 0x%"NACL_PRIxPTR"\n",
+          "NaClSimpleServiceConnectionCtor: self 0x%"NACL_PRIxPTR"\n",
           (uintptr_t) self);
   if (!NaClRefCountCtor((struct NaClRefCount *) self)) {
     return 0;
   }
   self->server = (struct NaClSimpleService *) NaClRefCountRef(
       (struct NaClRefCount *) server);
   self->connected_socket = (struct NaClDesc *) NaClRefCountRef(
       (struct NaClRefCount *) conn);
   self->instance_data = instance_data;
 
@@ skipping 69 matching lines @@
   NaClRefCountUnref((struct NaClRefCount *) conn);
   return (void *) NULL;
 }
 
 static int NaClSimpleServiceCtorIntern(
     struct NaClSimpleService          *self,
     struct NaClSrpcHandlerDesc const  *srpc_handlers,
     NaClThreadIfFactoryFunction       thread_factory_fn,
     void                              *thread_factory_data) {
   NaClLog(4,
-          "NaClSimpleServiceCtorIntern, this 0x%"NACL_PRIxPTR"\n",
+          "NaClSimpleServiceCtorIntern, self 0x%"NACL_PRIxPTR"\n",
           (uintptr_t) self);
   if (!NaClRefCountCtor((struct NaClRefCount *) self)) {
     NaClLog(4, "NaClSimpleServiceCtorIntern: NaClRefCountCtor failed\n");
     return 0;
   }
   self->handlers = srpc_handlers;
   self->thread_factory_fn = thread_factory_fn;
   self->thread_factory_data = thread_factory_data;
   self->acceptor = (struct NaClThreadInterface *) NULL;
 
   self->base.vtbl = (struct NaClRefCountVtbl const *) &kNaClSimpleServiceVtbl;
   NaClLog(4, "Leaving NaClSimpleServiceCtorIntern\n");
   return 1;
 }
 
 int NaClSimpleServiceCtor(
     struct NaClSimpleService          *self,
     struct NaClSrpcHandlerDesc const  *srpc_handlers,
     NaClThreadIfFactoryFunction       thread_factory_fn,
     void                              *thread_factory_data) {
   NaClLog(4,
-          "NaClSimpleServiceCtor: this 0x%"NACL_PRIxPTR"\n",
+          "Entered NaClSimpleServiceCtor: self 0x%"NACL_PRIxPTR"\n",
           (uintptr_t) self);
 
   if (0 != NaClCommonDescMakeBoundSock(self->bound_and_cap)) {
     return 0;
   }
   if (!NaClSimpleServiceCtorIntern(self, srpc_handlers,
                                    thread_factory_fn, thread_factory_data)) {
     NaClDescUnref(self->bound_and_cap[0]);
     NaClDescUnref(self->bound_and_cap[1]);
     return 0;
   }
   return 1;
 }
 
 int NaClSimpleServiceWithSocketCtor(
     struct NaClSimpleService          *self,
     struct NaClSrpcHandlerDesc const  *srpc_handlers,
     NaClThreadIfFactoryFunction       thread_factory_fn,
     void                              *thread_factory_data,
     struct NaClDesc                   *service_port,
     struct NaClDesc                   *sock_addr) {
   NaClLog(4,
-          "NaClSimpleServiceWithSocketCtor: this 0x%"NACL_PRIxPTR"\n",
+          "NaClSimpleServiceWithSocketCtor: self 0x%"NACL_PRIxPTR"\n",
           (uintptr_t) self);
   if (!NaClSimpleServiceCtorIntern(self, srpc_handlers,
                                    thread_factory_fn, thread_factory_data)) {
     return 0;
   }
   self->bound_and_cap[0] = NaClDescRef(service_port);
   self->bound_and_cap[1] = NaClDescRef(sock_addr);
 
   return 1;
 }
@@ skipping 89 matching lines @@
 
   status = (*NACL_VTBL(NaClSimpleService, self)->ConnectionFactory)(
       self,
       connected_desc,
       &conn);
   if (0 != status) {
     NaClLog(4, "ConnectionFactory failed\n");
     goto cleanup;
   }
   /* all okay! */
-  NaClLog(4, "conn is 0x%"NACL_PRIxPTR"\n", (uintptr_t) conn);
-  NaClLog(4, "out  is 0x%"NACL_PRIxPTR"\n", (uintptr_t) out);
+
+  NaClLog(4,
+          "NaClSimpleServiceAcceptConnection: conn is 0x%"NACL_PRIxPTR"\n",
+          (uintptr_t) conn);
+  NaClLog(4,
+          "NaClSimpleServiceAcceptConnection: out  is 0x%"NACL_PRIxPTR"\n",
+          (uintptr_t) out);
   *out = conn;
   status = 0;
 cleanup:
   NaClRefCountSafeUnref((struct NaClRefCount *) connected_desc);
   NaClLog(4, "Leaving NaClSimpleServiceAcceptConnection, status %d\n", status);
   return status;
 }
 
 int NaClSimpleServiceAcceptAndSpawnHandler(
     struct NaClSimpleService *self) {
   struct NaClSimpleServiceConnection  *conn = NULL;
   int                                 status;
 
   NaClLog(4, "Entered NaClSimpleServiceAcceptAndSpawnHandler\n");
   NaClLog(4,
           ("NaClSimpleServiceAcceptAndSpawnHandler:"
            " &conn is 0x%"NACL_PRIxPTR"\n"),
           (uintptr_t) &conn);
   status = (*NACL_VTBL(NaClSimpleService, self)->AcceptConnection)(
       self,
       &conn);
   NaClLog(4, "AcceptConnection vfn returned %d\n", status);
   if (0 != status) {
     goto abort;
   }
-  NaClLog(4, "conn is 0x%"NACL_PRIxPTR"\n", (uintptr_t) conn);
+  NaClLog(4,
+          "NaClSimpleServiceAcceptAndSpawnHandler: conn is 0x%"NACL_PRIxPTR"\n",
+          (uintptr_t) conn);
   NaClLog(4, "NaClSimpleServiceAcceptAndSpawnHandler: spawning thread\n");
 
   CHECK(NULL == conn->thread);
 
   /* ownership of |conn| reference is passed to the thread */
   if (!NaClThreadInterfaceConstructAndStartThread(
           self->thread_factory_fn,
           self->thread_factory_data,
           RpcHandlerBase,
           conn,
@@ skipping 51 matching lines @@
           NACL_KERN_STACK_SIZE,
           &server->acceptor)) {
     NaClLog(4, "NaClSimpleServiceStartServiceThread: no thread\n");
     NaClRefCountUnref(&server->base);  /* undo ref in Ctor call arglist */
     server->acceptor = NULL;
     return 0;
   }
   NaClLog(4, "NaClSimpleServiceStartServiceThread: success\n");
   return 1;
 }