Track correctly the number of secure command channel connections

src/trusted/service_runtime/nacl_secure_service.c

 /*
  * Copyright (c) 2012 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/service_runtime/nacl_secure_service.h"
 
 #include "native_client/src/shared/platform/nacl_exit.h"
 #include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/shared/platform/nacl_sync.h"
 #include "native_client/src/shared/platform/nacl_sync_checked.h"
 #include "native_client/src/shared/srpc/nacl_srpc.h"
 
 #include "native_client/src/trusted/fault_injection/fault_injection.h"
 #include "native_client/src/trusted/simple_service/nacl_simple_service.h"
 #include "native_client/src/trusted/service_runtime/sel_ldr.h"
 
 
-int NaClSecureThreadIfFactoryFn(
-    void                        *factory_data,
-    NaClThreadIfStartFunction   fn_ptr,
-    void                        *thread_data,
-    size_t                      thread_stack_size,
-    struct NaClThreadInterface  **out_new_thread);
-
 int NaClSecureServiceCtor(struct NaClSecureService          *self,
                           struct NaClSrpcHandlerDesc const  *srpc_handlers,
                           struct NaClApp                    *nap,
                           struct NaClDesc                   *service_port,
                           struct NaClDesc                   *sock_addr) {
   NaClLog(4,
           "Entered NaClSecureServiceCtor: self 0x%"NACL_PRIxPTR"\n",
           (uintptr_t) self);
   if (NACL_FI_ERROR_COND(
           "NaClSecureServiceCtor__NaClSimpleServiceWithSocketCtor",
           !NaClSimpleServiceWithSocketCtor(
               &self->base,
               srpc_handlers,
-              NaClSecureThreadIfFactoryFn,
+              NaClThreadInterfaceThreadFactory,
               (void *) self,
               service_port,
               sock_addr))) {
     goto done;
   }
   if (!NaClMutexCtor(&self->mu)) {
     NaClLog(4, "NaClMutexCtor failed\n");
     goto failure_mutex_ctor;
   }
   self->nap = nap;
-  self->thread_count = 0;
+  self->conn_count = 0;
   NACL_VTBL(NaClRefCount, self) =
       (struct NaClRefCountVtbl *) &kNaClSecureServiceVtbl;
   return 1;
 
  failure_mutex_ctor:
   (*NACL_VTBL(NaClRefCount, self)->Dtor)((struct NaClRefCount *) self);
  done:
   return 0;
 }
 
 void NaClSecureServiceDtor(struct NaClRefCount *vself) {
   struct NaClSecureService *self = (struct NaClSecureService *) vself;
 
-  if (0 != self->thread_count) {
+  if (0 != self->conn_count) {
     NaClLog(LOG_FATAL,
-            "SecureService dtor when thread count is nonzero\n");
+            "SecureService dtor when connection count is nonzero\n");
   }
   NaClMutexDtor(&self->mu);
 
   NACL_VTBL(NaClRefCount, self) = (struct NaClRefCountVtbl const *)
       &kNaClSimpleServiceVtbl;
   (*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
 }
 
 int NaClSecureServiceConnectionFactory(
     struct NaClSimpleService            *vself,
     struct NaClDesc                     *conn,
     struct NaClSimpleServiceConnection  **out) {
   struct NaClSecureService *self =
       (struct NaClSecureService *) vself;
 
   /* our instance_data is not connection specific */
   return NaClSimpleServiceConnectionFactoryWithInstanceData(
       vself, conn, (void *) self->nap, out);
 }
 
-static void NaClSecureServiceThreadCountIncr(
+static void NaClSecureServiceConnectionCountIncr(
     struct NaClSecureService *self) {
   NaClLog(5, "NaClSecureServiceThreadCountIncr\n");
   NaClXMutexLock(&self->mu);
-  if (0 == ++self->thread_count) {
+  if (0 == ++self->conn_count) {
     NaClLog(LOG_FATAL,
             "NaClSecureServiceThreadCountIncr: "
             "thread count overflow!\n");
   }
   NaClXMutexUnlock(&self->mu);
 }
 
-static void NaClSecureServiceThreadCountDecr(
+static void NaClSecureServiceConnectionCountDecr(
     struct NaClSecureService *self) {
   NaClLog(5, "NaClSecureServiceThreadCountDecr\n");
   NaClXMutexLock(&self->mu);
-  if (0 == self->thread_count) {
+  if (0 == self->conn_count) {
     NaClLog(LOG_FATAL,
             "NaClSecureServiceThreadCountDecr: "
             "decrementing thread count when count is zero\n");
   }
-  if (0 == --self->thread_count) {
-    NaClLog(4, "NaClSecureServiceThread: channel closed, exiting.\n");
+  if (0 == --self->conn_count) {
+    NaClLog(4, "NaClSecureServiceThread: all channels closed, exiting.\n");
     NaClExit(0);
   }
   NaClXMutexUnlock(&self->mu);
 }
 
-struct NaClSecureThreadInterface {
-  struct NaClThreadInterface  base NACL_IS_REFCOUNT_SUBCLASS;
-  struct NaClSecureService    *secure_service;
-};
+int NaClSecureServiceAcceptConnection(
+    struct NaClSimpleService            *vself,
+    struct NaClSimpleServiceConnection  **vconn) {
+  struct NaClSecureService *self =
+    (struct NaClSecureService *) vself;
+  int status;
 
-extern struct NaClThreadInterfaceVtbl
-  const kNaClSecureThreadInterfaceVtbl; /* fwd */
-
-int NaClReverseThreadIfCtor_protected(
-    struct NaClSecureThreadInterface   *self,
-    void                               *factory_data,
-    NaClThreadIfStartFunction          fn_ptr,
-    void                               *thread_data,
-    size_t                             thread_stack_size) {
-  struct NaClSecureService *service = (struct NaClSecureService *) factory_data;
-
-  NaClLog(3, "Entered NaClSecureThreadIfCtor_protected\n");
-  if (!NaClThreadInterfaceCtor_protected(
-          (struct NaClThreadInterface *) self,
-          NaClSecureThreadIfFactoryFn,
-          NaClRefCountRef((struct NaClRefCount *) service),
-          fn_ptr,
-          thread_data,
-          thread_stack_size)) {
-    NaClLog(4, "NaClThreadInterfaceCtor_protected failed\n");
-    NaClRefCountUnref((struct NaClRefCount *) service);
-    return 0;
+  NaClLog(4, "NaClSecureServiceAcceptConnection\n");
+  status = (*kNaClSimpleServiceVtbl.AcceptConnection)(vself, vconn);
+  if (0 == status) {
+    NaClSecureServiceConnectionCountIncr(self);
   }
-
-  self->secure_service = service;
-  NaClSecureServiceThreadCountIncr(service);
-
-  NACL_VTBL(NaClRefCount, self) =
-      (struct NaClRefCountVtbl *) &kNaClSecureThreadInterfaceVtbl;
-
-  NaClLog(3, "Leaving NaClSecureThreadIfCtor_protected\n");
-  return 1;
+  NaClLog(4, "Leaving NaClSecureServiceAcceptConnection, status %d.\n", status);
+  return status;
 }
 
-int NaClSecureThreadIfFactoryFn(
-    void                        *factory_data,
-    NaClThreadIfStartFunction   fn_ptr,
-    void                        *thread_data,
-    size_t                      thread_stack_size,
-    struct NaClThreadInterface  **out_new_thread) {
-  struct NaClSecureThreadInterface *new_thread;
-  int                              retval = 0; /* fail */
+void NaClSecureServiceRpcHandler(struct NaClSimpleService           *vself,
+                                 struct NaClSimpleServiceConnection *vconn) {
+  struct NaClSecureService *self =
+    (struct NaClSecureService *) vself;
 
-  NaClLog(3, "Entered NaClSecureThreadIfFactoryFn\n");
-  new_thread = (struct NaClSecureThreadInterface *)
-      malloc(sizeof *new_thread);
-  if (NULL == new_thread) {
-    goto cleanup;
-  }
-
-  if (!(retval =
-        NaClReverseThreadIfCtor_protected(new_thread,
-                                          factory_data,
-                                          fn_ptr,
-                                          thread_data,
-                                          thread_stack_size))) {
-    goto cleanup;
-  }
-
-  *out_new_thread = (struct NaClThreadInterface *) new_thread;
-  new_thread = NULL;
-
- cleanup:
-  free(new_thread);
-  NaClLog(3,
-          "Leaving NaClSecureThreadIfFactoryFn, rv %d\n",
-          retval);
-  return retval;
+  NaClLog(4, "NaClSecureChannelThread started\n");
+  (*kNaClSimpleServiceVtbl.RpcHandler)(vself, vconn);
+  NaClLog(4, "NaClSecureChannelThread closed.\n");
+  NaClSecureServiceConnectionCountDecr(self);
 }
 
-void NaClSecureThreadIfDtor(struct NaClRefCount *vself) {
-  struct NaClSecureThreadInterface *self =
-      (struct NaClSecureThreadInterface *) vself;
-
-  NaClRefCountUnref((struct NaClRefCount *) self->secure_service);
-  self->secure_service = NULL;
-  NACL_VTBL(NaClRefCount, self) = &kNaClRefCountVtbl;
-  (*NACL_VTBL(NaClRefCount, self)->Dtor)(vself);
-}
-
-void NaClSecureThreadIfLaunchCallback(struct NaClThreadInterface *self) {
-  NaClLog(4,
-          ("NaClSecureThreadIfLaunchCallback: thread 0x%"NACL_PRIxPTR
-           " is launching\n"),
-          (uintptr_t) self);
-}
-
-void NaClSecureThreadIfExit(struct NaClThreadInterface   *vself,
-                             void                         *exit_code) {
-  struct NaClSecureThreadInterface *self =
-      (struct NaClSecureThreadInterface *) vself;
-  NaClLog(4,
-          ("NaClSecureThreadIfExit: thread 0x%"NACL_PRIxPTR
-           " is exiting\n"),
-          (uintptr_t) vself);
-
-  NaClSecureServiceThreadCountDecr(self->secure_service);
-  NaClRefCountUnref((struct NaClRefCount *) self);
-  NaClThreadExit((int)(uintptr_t) exit_code);
-}
-
-struct NaClThreadInterfaceVtbl const kNaClSecureThreadInterfaceVtbl = {
-  {
-    NaClSecureThreadIfDtor,
-  },
-  NaClThreadInterfaceStartThread,
-  NaClSecureThreadIfLaunchCallback,
-  NaClSecureThreadIfExit,
-};
-
 struct NaClSimpleServiceVtbl const kNaClSecureServiceVtbl = {
   {
     NaClSecureServiceDtor,
   },
   NaClSecureServiceConnectionFactory,
-  NaClSimpleServiceAcceptConnection,
+  NaClSecureServiceAcceptConnection,
   NaClSimpleServiceAcceptAndSpawnHandler,
-  NaClSimpleServiceRpcHandler,
+  NaClSecureServiceRpcHandler,
 };
 
 struct NaClSecureRevClientConnHandler {
   struct NaClSecureRevClientConnHandler  *next;
 
   /* used by NaClSimpleRevServiceClient's ClientCallback fn */
   void                                   (*handler)(
       void                                          *state,
       struct NaClThreadInterface                    *tif,
       struct NaClDesc                               *conn);
@@ skipping 176 matching lines @@
 
 struct NaClSecureReverseClientVtbl const kNaClSecureReverseClientVtbl = {
   {
     {
       NaClSecureReverseClientDtor,
     },
   },
   NaClSecureReverseClientInsertHandler,
   NaClSecureReverseClientRemoveHandler,
 };