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

src/trusted/service_runtime/name_service/name_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 <string.h>
 
 #include "native_client/src/include/portability.h"
 #include "native_client/src/include/portability_string.h"
@@ skipping 110 matching lines @@
 int NaClNameServiceCreateDescEntry(
     struct NaClNameService  *nnsp,
     char const              *name,
     int                     mode,
     struct NaClDesc         *new_desc) {
   int                         retval = NACL_NAME_SERVICE_INSUFFICIENT_RESOURCES;
   struct NaClNameServiceEntry *name_entry = NULL;
   struct NaClNameServiceEntry *found = NULL;
   char                        *dup_name = STRDUP(name);
 
+  NaClLog(3,
+          "NaClNameServiceCreateDescEntry: entering %s, %d (0x%x)\n",
+          name,
+          mode, mode);
   /*
    * common case is insertion success, so we pre-allocate memory
    * (strdup, malloc) to avoid doing memory allocations while holding
    * the name service lock.
    */
   if (NULL == dup_name) {
     goto dup_failed;
   }
   name_entry = (struct NaClNameServiceEntry *) malloc(sizeof *name_entry);
   if (NULL == name_entry) {
     goto entry_alloc_failed;
   }
 
   NaClXMutexLock(&nnsp->mu);
   found = *NameServiceSearch(&nnsp->head, name);
   if (NULL != found) {
     retval = NACL_NAME_SERVICE_DUPLICATE_NAME;
     goto unlock_and_cleanup;
   }
   name_entry->next = nnsp->head;
   name_entry->name = dup_name;
   dup_name = (char *) NULL;
   name_entry->mode = mode;
-  name_entry->entry = NaClDescRef(new_desc);
+  name_entry->entry = new_desc;
   name_entry->factory = (NaClNameServiceFactoryFn_t) NULL;
   name_entry->state = (void *) NULL;
   nnsp->head = name_entry;
   name_entry = NULL;
   retval = NACL_NAME_SERVICE_SUCCESS;
 
  unlock_and_cleanup:
   NaClXMutexUnlock(&nnsp->mu);
   free(name_entry);
  entry_alloc_failed:
   free(dup_name);
  dup_failed:
   return retval;
 }
 
 int NaClNameServiceCreateFactoryEntry(
     struct NaClNameService      *nnsp,
     char const                  *name,
     NaClNameServiceFactoryFn_t  factory_fn,
     void                        *factory_state) {
   int                         retval = NACL_NAME_SERVICE_INSUFFICIENT_RESOURCES;
   struct NaClNameServiceEntry *name_entry = NULL;
   struct NaClNameServiceEntry *found = NULL;
   char                        *dup_name = STRDUP(name);
 
+  NaClLog(3,
+          ("NaClNameServiceCreateFactoryEntry: entering %s,"
+           " 0x%"NACL_PRIxPTR", 0x%"NACL_PRIxPTR"\n"),
+          name,
+          (uintptr_t) factory_fn,
+          (uintptr_t) factory_state);
   /*
    * common case is insertion success, so we pre-allocate memory
    * (strdup, malloc) to avoid doing memory allocation while holding
    * the name service lock.
    */
   if (NULL == dup_name) {
     goto dup_failed;
   }
   name_entry = (struct NaClNameServiceEntry *) malloc(sizeof *name_entry);
   if (NULL == name_entry) {
@@ skipping 25 matching lines @@
   return retval;
 }
 
 int NaClNameServiceResolveName(struct NaClNameService  *nnsp,
                                char const              *name,
                                int                     flags,
                                struct NaClDesc         **out) {
   struct NaClNameServiceEntry *nnsep;
   int                         status = NACL_NAME_SERVICE_NAME_NOT_FOUND;
 
-  if (0 != (flags & NACL_ABI_O_ACCMODE)) {
+  NaClLog(3,
+          "NaClNameServiceResolveName: looking up %s, flags %d (0x%x)\n",
+          name,
+          flags, flags);
+  if (0 != (flags & ~NACL_ABI_O_ACCMODE)) {
+    NaClLog(2, "NaClNameServiceResolveName:  bad flags!\n");
     status = NACL_NAME_SERVICE_PERMISSION_DENIED;
     goto quit;
   }
 
   NaClXMutexLock(&nnsp->mu);
   nnsep = *NameServiceSearch(&nnsp->head, name);
   if (NULL != nnsep) {
     if (NULL != nnsep->entry) {
+      NaClLog(3,
+              "NaClNameServiceResolveName: found %s, mode %d (0x%x)\n",
+              name,
+              nnsep->mode, nnsep->mode);
       /* check flags against nnsep->mode */
+      NaClLog(4,
+              ("NaClNameServiceResolveName: checking mode/flags"
+               " compatibility\n"));
       switch (flags) {
         case NACL_ABI_O_RDONLY:
           if (NACL_ABI_O_WRONLY == nnsep->mode) {
             status = NACL_NAME_SERVICE_PERMISSION_DENIED;
+            NaClLog(4,
+                    "NaClNameServiceResolveName: incompatible,"
+                    " not readable\n");
             goto unlock_and_quit;
           }
           break;
         case NACL_ABI_O_WRONLY:
           if (NACL_ABI_O_RDONLY == nnsep->mode) {
             status = NACL_NAME_SERVICE_PERMISSION_DENIED;
+            NaClLog(4,
+                    "NaClNameServiceResolveName: incompatible,"
+                    " not writeable\n");
             goto unlock_and_quit;
           }
           break;
         case NACL_ABI_O_RDWR:
           if (NACL_ABI_O_RDWR != nnsep->mode) {
             status = NACL_NAME_SERVICE_PERMISSION_DENIED;
+            NaClLog(4, "NaClNameServiceResolveName: incompatible,"
+                    " not for both read and write\n");
             goto unlock_and_quit;
           }
           break;
         default:
           status = NACL_NAME_SERVICE_INVALID_ARGUMENT;
+          NaClLog(4, "NaClNameServiceResolveName: invalid flag\n");
           goto unlock_and_quit;
       }
+      NaClLog(4, "NaClNameServiceResolveName: mode and flags are compatible\n");
       *out = NaClDescRef(nnsep->entry);
       status = NACL_NAME_SERVICE_SUCCESS;
     } else {
       status = (*nnsep->factory)(nnsep->state, name, flags, out);
     }
   }
  unlock_and_quit:
   nnsep = NULL;

[noelallen_use_chromium, 2011/06/14 02:25:45]

We are clearing this pointer to prevent it's use after the unlock?  Not part of
this CL, but I've seen in a few cases and I'm trying to understand why we do it.

[bsy, 2011/06/14 20:30:03]

defensive programming.  compilers will get rid of it.  new code added later
won't accidentally use it.

   NaClXMutexUnlock(&nnsp->mu);
  quit:
   return status;
 }
 
 int NaClNameServiceDeleteName(struct NaClNameService *nnsp,
                               char const             *name) {
   struct NaClNameServiceEntry **nnsepp;
   struct NaClNameServiceEntry *to_free = NULL;
   int                         status = NACL_NAME_SERVICE_NAME_NOT_FOUND;
@@ skipping 51 matching lines @@
     struct NaClSrpcRpc      *rpc,
     struct NaClSrpcArg      **in_args,
     struct NaClSrpcArg      **out_args,
     struct NaClSrpcClosure  *done_cls) {
   struct NaClNameService  *nnsp =
       (struct NaClNameService *) rpc->channel->server_instance_data;
   char                    *name = in_args[0]->arrays.str;
   int                     mode  = in_args[1]->u.ival;
   struct NaClDesc         *desc = in_args[2]->u.hval;
 
+  NaClLog(3,
+          "NaClNameServiceNameInsertRpc: inserting %s, %d (0x%x)\n",
+          name,
+          mode, mode);
   out_args[0]->u.ival = (*NACL_VTBL(NaClNameService, nnsp)->CreateDescEntry)(
       nnsp, name, mode, desc);
   rpc->result = NACL_SRPC_RESULT_OK;
   (*done_cls->Run)(done_cls);
 }
 
 static void NaClNameServiceNameLookupOldRpc(
     struct NaClSrpcRpc      *rpc,
     struct NaClSrpcArg      **in_args,
     struct NaClSrpcArg      **out_args,
     struct NaClSrpcClosure  *done_cls) {
   struct NaClNameService  *nnsp =
       (struct NaClNameService *) rpc->channel->server_instance_data;
   char                    *name = in_args[0]->arrays.str;
   int                     status;
   struct NaClDesc         *desc;
 
   NaClLog(LOG_WARNING,
           "NaClNameServiceNameLookupOldRpc: DEPRECATED interface used.\n");
+  NaClLog(3, "NaClNameServiceNameLookupOldRpc: looking up %s\n", name);
   status = (*NACL_VTBL(NaClNameService, nnsp)->ResolveName)(
       nnsp, name, NACL_ABI_O_RDONLY, &desc);
   out_args[0]->u.ival = status;
   out_args[1]->u.hval = (NACL_NAME_SERVICE_SUCCESS == status)
       ? desc
       : (struct NaClDesc *) NaClDescInvalidMake();
   rpc->result = NACL_SRPC_RESULT_OK;
   (*done_cls->Run)(done_cls);
 }
 
 static void NaClNameServiceNameLookupRpc(
     struct NaClSrpcRpc      *rpc,
     struct NaClSrpcArg      **in_args,
     struct NaClSrpcArg      **out_args,
     struct NaClSrpcClosure  *done_cls) {
   struct NaClNameService  *nnsp =
       (struct NaClNameService *) rpc->channel->server_instance_data;
   char                    *name = in_args[0]->arrays.str;
   int                     flags = in_args[1]->u.ival;
   int                     status;
   struct NaClDesc         *desc;
 
+  NaClLog(3, "NaClNameServiceNameLookupRpc: looking up %s\n", name);
+  NaClLog(3, "NaClNameServiceNameLookupRpc: flags %d (0x%x)\n", flags, flags);
   status = (*NACL_VTBL(NaClNameService, nnsp)->ResolveName)(
       nnsp, name, flags, &desc);
   out_args[0]->u.ival = status;
   out_args[1]->u.hval = (NACL_NAME_SERVICE_SUCCESS == status)
       ? desc
       : (struct NaClDesc *) NaClDescInvalidMake();
+  NaClLog(3, "NaClNameServiceNameLookupRpc: status %d\n", status);
+  NaClLog(3, "NaClNameServiceNameLookupRpc: desc 0x%"NACL_PRIxPTR"\n",
+          (uintptr_t) desc);
   rpc->result = NACL_SRPC_RESULT_OK;
   (*done_cls->Run)(done_cls);
 }
 
 static void NaClNameServiceNameDeleteRpc(
     struct NaClSrpcRpc      *rpc,
     struct NaClSrpcArg      **in_args,
     struct NaClSrpcArg      **out_args,
     struct NaClSrpcClosure  *done_cls) {
   struct NaClNameService  *nnsp =
@@ skipping 56 matching lines @@
     NaClSimpleLtdServiceAcceptConnection,
     NaClSimpleServiceAcceptAndSpawnHandler,
     NaClSimpleLtdServiceRpcHandler,
   },
   NaClNameServiceCreateDescEntry,
   NaClNameServiceCreateFactoryEntry,
   NaClNameServiceResolveName,
   NaClNameServiceDeleteName,
   NaClNameServiceEnumerate,
 };