1                 : /*
       2                 :  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
       3                 :  * Use of this source code is governed by a BSD-style license that can be
       4                 :  * found in the LICENSE file.
       5                 :  */
       6                 : 
       7                 : #include "native_client/src/shared/imc/nacl_imc_c.h"
       8                 : #include "native_client/src/shared/srpc/nacl_srpc.h"
       9                 : #include "native_client/src/shared/platform/nacl_threads.h"
      10                 : 
      11                 : #if !defined(__native_client__)
      12                 : #include "native_client/src/trusted/desc/nacl_desc_imc.h"
      13                 : #include "native_client/src/trusted/desc/nrd_all_modules.h"
      14                 : #endif
      15                 : 
      16                 : 
      17                 : #define TEST_NUM 42
      18                 : 
      19                 : /* Writes the last error message to the standard error. */
      20               0 : static void failWithErrno(const char* message) {
      21               0 :   char buffer[256];
      22                 : 
      23               0 :   if (0 == NaClGetLastErrorString(buffer, sizeof(buffer))) {
      24               0 :     fprintf(stderr, "%s: %s", message, buffer);
      25               0 :   }
      26               0 :   exit(EXIT_FAILURE);
      27               0 : }
      28                 : 
      29               1 : static void handleGetNum(NaClSrpcRpc* rpc,
      30               1 :                          NaClSrpcArg** ins,
      31               1 :                          NaClSrpcArg** outs,
      32               1 :                          NaClSrpcClosure* done) {
      33               2 :   UNREFERENCED_PARAMETER(ins);
      34               1 :   outs[0]->u.ival = TEST_NUM;
      35               1 :   rpc->result = NACL_SRPC_RESULT_OK;
      36               1 :   done->Run(done);
      37               1 : }
      38                 : 
      39                 : struct ServiceThreadArgs {
      40                 :   NaClSrpcImcDescType desc;
      41                 : };
      42                 : 
      43               1 : void WINAPI serviceThread(void* arg) {
      44               1 :   struct ServiceThreadArgs* typedArg;
      45               1 :   NaClSrpcImcDescType desc;
      46               1 :   NaClSrpcHandlerDesc handlers[] = {
      47                 :     { "getNum::i", handleGetNum },
      48                 :     { NULL, NULL }
      49                 :   };
      50               1 :   typedArg = (struct ServiceThreadArgs*) arg;
      51               1 :   desc = typedArg->desc;
      52               1 :   free(typedArg);
      53                 : 
      54               1 :   if (!NaClSrpcServerLoop(desc, handlers, 0)) {
      55               0 :     failWithErrno("NaClSrpcServerLoop");
      56               0 :     exit(EXIT_FAILURE);
      57                 :   }
      58                 : #ifdef __native_client__
      59                 :   close(desc);
      60                 : #else
      61               1 :   NaClDescUnref(desc);
      62                 : #endif
      63               1 :   NaClThreadExit();
      64               1 : }
      65                 : 
      66               1 : int main(int argc, char* argv[]) {
      67               1 :   int result;
      68               1 :   NaClHandle pair[2];
      69                 : #ifdef __native_client__
      70                 :   int imc_desc[2];
      71                 : #else
      72               1 :   struct NaClDescImcDesc* imc_desc[2];
      73                 : #endif
      74               1 :   struct NaClThread thr;
      75               1 :   NaClSrpcChannel channel;
      76               1 :   NaClSrpcError error;
      77               1 :   struct ServiceThreadArgs* threadArg;
      78                 : 
      79               2 :   UNREFERENCED_PARAMETER(argc);
      80               2 :   UNREFERENCED_PARAMETER(argv);
      81                 : 
      82               1 :   NaClSrpcModuleInit();
      83                 : 
      84               1 :   if (0 != NaClSocketPair(pair)) {
      85               0 :     failWithErrno("SocketPair");
      86               0 :   }
      87                 : 
      88                 : #ifdef __native_client__
      89                 :   imc_desc[0] = pair[0];
      90                 :   imc_desc[1] = pair[1];
      91                 : #else
      92               1 :   NaClNrdAllModulesInit();
      93                 : 
      94               1 :   imc_desc[0] = (struct NaClDescImcDesc*) calloc(1, sizeof(*imc_desc[0]));
      95               1 :   if (0 == imc_desc[0]) {
      96               0 :     failWithErrno("calloc");
      97               0 :   }
      98               1 :   imc_desc[1] = (struct NaClDescImcDesc*) calloc(1, sizeof(*imc_desc[1]));
      99               1 :   if (0 == imc_desc[1]) {
     100               0 :     failWithErrno("calloc");
     101               0 :   }
     102                 : 
     103               1 :   if (!NaClDescImcDescCtor(imc_desc[0], pair[0])) {
     104               0 :     failWithErrno("NaClDescImcDescCtor");
     105               0 :   }
     106                 : 
     107               1 :   if (!NaClDescImcDescCtor(imc_desc[1], pair[1])) {
     108               0 :     failWithErrno("NaClDescImcDescCtor");
     109               0 :   }
     110                 : #endif
     111                 : 
     112               1 :   threadArg = (struct ServiceThreadArgs*) calloc(1, sizeof(*threadArg));
     113               1 :   if (NULL == threadArg) {
     114               0 :     failWithErrno("calloc for threadArg");
     115               0 :   }
     116               1 :   threadArg->desc = (NaClSrpcImcDescType)imc_desc[0];
     117                 : 
     118               1 :   if (!NaClThreadCreateJoinable(&thr, serviceThread, threadArg, 128*1024)) {
     119               0 :     failWithErrno("NaClThreadCtor");
     120               0 :   }
     121                 : 
     122               1 :   if (!NaClSrpcClientCtor(&channel, (NaClSrpcImcDescType) imc_desc[1])) {
     123               0 :     failWithErrno("NaClSrpcClientCtor");
     124               0 :   }
     125                 : 
     126               1 :   error = NaClSrpcInvokeBySignature(&channel, "getNum::i", &result);
     127               1 :   if (NACL_SRPC_RESULT_OK != error) {
     128               0 :     fprintf(stderr,
     129                 :             "SRPC call to getNum::i failed: %s\n",
     130               0 :             NaClSrpcErrorString(error));
     131               0 :     exit(EXIT_FAILURE);
     132                 :   }
     133                 : 
     134               1 :   if (TEST_NUM != result) {
     135               0 :     fprintf(stderr, "expected: %d, got: %d\n", TEST_NUM, result);
     136               0 :     exit(EXIT_FAILURE);
     137                 :   }
     138                 : 
     139               1 :   NaClSrpcDtor(&channel);
     140                 : #ifdef __native_client__
     141                 :   close(imc_desc[1]);
     142                 : #else
     143               1 :   NaClDescUnref((NaClSrpcImcDescType)imc_desc[1]);
     144                 : #endif
     145                 : 
     146               1 :   NaClThreadJoin(&thr);
     147                 : 
     148               1 :   NaClSrpcModuleFini();
     149               1 :   return 0;
     150                 : }