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