Add thunks for MojoDuplicateHandle[WithReducedRights]().

mojo/nacl/sfi/nacl_bindings/mojo_syscall.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // WARNING this file was generated by generate_nacl_bindings.py
 // Do not edit by hand.
 
 #include "mojo/nacl/sfi/nacl_bindings/mojo_syscall.h"
 
 #include <stdio.h>
@@ skipping 146 matching lines @@
 
       {
         ScopedCopyLock copy_lock(nap);
         *rights_ptr = rights_value;
         *result_ptr = result_value;
       }
 
       return 0;
     }
     case 4: {
+      if (num_params != 5) {
+        return -1;
+      }
+      MojoHandle handle_value;
+      MojoHandleRights rights_to_remove_value;
+      MojoHandle volatile* new_handle_ptr;
+      MojoHandle new_handle_value;
+      MojoResult volatile* result_ptr;
+      MojoResult result_value;
+      {
+        ScopedCopyLock copy_lock(nap);
+        if (!ConvertScalarInput(nap, params[1], &handle_value)) {
+          return -1;
+        }
+        if (!ConvertScalarInput(nap, params[2], &rights_to_remove_value)) {
+          return -1;
+        }
+        if (!ConvertScalarInOut(nap, params[3], false, &new_handle_value,
+                                &new_handle_ptr)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) {
+          return -1;
+        }
+      }
+
+      result_value = MojoSystemImplDuplicateHandleWithReducedRights(
+          g_mojo_system, handle_value, rights_to_remove_value,
+          &new_handle_value);
+
+      {
+        ScopedCopyLock copy_lock(nap);
+        *new_handle_ptr = new_handle_value;
+        *result_ptr = result_value;
+      }
+
+      return 0;
+    }
+    case 5: {
+      if (num_params != 4) {
+        return -1;
+      }
+      MojoHandle handle_value;
+      MojoHandle volatile* new_handle_ptr;
+      MojoHandle new_handle_value;
+      MojoResult volatile* result_ptr;
+      MojoResult result_value;
+      {
+        ScopedCopyLock copy_lock(nap);
+        if (!ConvertScalarInput(nap, params[1], &handle_value)) {
+          return -1;
+        }
+        if (!ConvertScalarInOut(nap, params[2], false, &new_handle_value,
+                                &new_handle_ptr)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) {
+          return -1;
+        }
+      }
+
+      result_value = MojoSystemImplDuplicateHandle(g_mojo_system, handle_value,
+                                                   &new_handle_value);
+
+      {
+        ScopedCopyLock copy_lock(nap);
+        *new_handle_ptr = new_handle_value;
+        *result_ptr = result_value;
+      }
+
+      return 0;
+    }
+    case 6: {
       if (num_params != 6) {
         return -1;
       }
       MojoHandle handle_value;
       MojoHandleSignals signals_value;
       MojoDeadline deadline_value;
       MojoHandleSignalsState volatile* signals_state_ptr;
       MojoHandleSignalsState signals_state_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
@@ skipping 24 matching lines @@
         ScopedCopyLock copy_lock(nap);
         if (signals_state_ptr) {
           memcpy_volatile_out(signals_state_ptr, &signals_state_value,
                               sizeof(MojoHandleSignalsState));
         }
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 5: {
+    case 7: {
       if (num_params != 8) {
         return -1;
       }
       const MojoHandle* handles;
       const MojoHandleSignals* signals;
       uint32_t num_handles_value;
       MojoDeadline deadline_value;
       uint32_t volatile* result_index_ptr;
       uint32_t result_index_value;
       struct MojoHandleSignalsState* signals_states;
@@ skipping 35 matching lines @@
       {
         ScopedCopyLock copy_lock(nap);
         if (result_index_ptr) {
           *result_index_ptr = result_index_value;
         }
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 6: {
+    case 8: {
       if (num_params != 5) {
         return -1;
       }
       const struct MojoCreateMessagePipeOptions* options;
       MojoHandle volatile* message_pipe_handle0_ptr;
       MojoHandle message_pipe_handle0_value;
       MojoHandle volatile* message_pipe_handle1_ptr;
       MojoHandle message_pipe_handle1_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
@@ skipping 23 matching lines @@
 
       {
         ScopedCopyLock copy_lock(nap);
         *message_pipe_handle0_ptr = message_pipe_handle0_value;
         *message_pipe_handle1_ptr = message_pipe_handle1_value;
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 7: {
+    case 9: {
       if (num_params != 8) {
         return -1;
       }
       MojoHandle message_pipe_handle_value;
       const void* bytes;
       uint32_t num_bytes_value;
       const MojoHandle* handles;
       uint32_t num_handles_value;
       MojoWriteMessageFlags flags_value;
       MojoResult volatile* result_ptr;
@@ skipping 28 matching lines @@
           g_mojo_system, message_pipe_handle_value, bytes, num_bytes_value,
           handles, num_handles_value, flags_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 8: {
+    case 10: {
       if (num_params != 8) {
         return -1;
       }
       MojoHandle message_pipe_handle_value;
       void* bytes;
       uint32_t volatile* num_bytes_ptr;
       uint32_t num_bytes_value;
       MojoHandle* handles;
       uint32_t volatile* num_handles_ptr;
       uint32_t num_handles_value;
@@ skipping 39 matching lines @@
           *num_bytes_ptr = num_bytes_value;
         }
         if (num_handles_ptr) {
           *num_handles_ptr = num_handles_value;
         }
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 9: {
+    case 11: {
       if (num_params != 5) {
         return -1;
       }
       const struct MojoCreateDataPipeOptions* options;
       MojoHandle volatile* data_pipe_producer_handle_ptr;
       MojoHandle data_pipe_producer_handle_value;
       MojoHandle volatile* data_pipe_consumer_handle_ptr;
       MojoHandle data_pipe_consumer_handle_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
@@ skipping 23 matching lines @@
 
       {
         ScopedCopyLock copy_lock(nap);
         *data_pipe_producer_handle_ptr = data_pipe_producer_handle_value;
         *data_pipe_consumer_handle_ptr = data_pipe_consumer_handle_value;
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 10: {
+    case 12: {
       if (num_params != 4) {
         return -1;
       }
       MojoHandle data_pipe_producer_handle_value;
       const struct MojoDataPipeProducerOptions* options;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
       {
         ScopedCopyLock copy_lock(nap);
         if (!ConvertScalarInput(nap, params[1],
@@ skipping 11 matching lines @@
       result_value = MojoSystemImplSetDataPipeProducerOptions(
           g_mojo_system, data_pipe_producer_handle_value, options);
 
       {
         ScopedCopyLock copy_lock(nap);
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 11: {
+    case 13: {
       if (num_params != 5) {
         return -1;
       }
       MojoHandle data_pipe_producer_handle_value;
       struct MojoDataPipeProducerOptions* options;
       uint32_t options_num_bytes_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
       {
         ScopedCopyLock copy_lock(nap);
@@ skipping 17 matching lines @@
           g_mojo_system, data_pipe_producer_handle_value, options,
           options_num_bytes_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 12: {
+    case 14: {
       if (num_params != 6) {
         return -1;
       }
       MojoHandle data_pipe_producer_handle_value;
       const void* elements;
       uint32_t volatile* num_bytes_ptr;
       uint32_t num_bytes_value;
       MojoWriteDataFlags flags_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
@@ skipping 24 matching lines @@
           &num_bytes_value, flags_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *num_bytes_ptr = num_bytes_value;
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 13:
+    case 15:
       fprintf(stderr, "MojoBeginWriteData not implemented\n");
       return -1;
-    case 14: {
+    case 16: {
       if (num_params != 4) {
         return -1;
       }
       MojoHandle data_pipe_producer_handle_value;
       uint32_t num_bytes_written_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
       {
         ScopedCopyLock copy_lock(nap);
         if (!ConvertScalarInput(nap, params[1],
@@ skipping 12 matching lines @@
                                                 data_pipe_producer_handle_value,
                                                 num_bytes_written_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 15: {
+    case 17: {
       if (num_params != 4) {
         return -1;
       }
       MojoHandle data_pipe_consumer_handle_value;
       const struct MojoDataPipeConsumerOptions* options;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
       {
         ScopedCopyLock copy_lock(nap);
         if (!ConvertScalarInput(nap, params[1],
@@ skipping 11 matching lines @@
       result_value = MojoSystemImplSetDataPipeConsumerOptions(
           g_mojo_system, data_pipe_consumer_handle_value, options);
 
       {
         ScopedCopyLock copy_lock(nap);
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 16: {
+    case 18: {
       if (num_params != 5) {
         return -1;
       }
       MojoHandle data_pipe_consumer_handle_value;
       struct MojoDataPipeConsumerOptions* options;
       uint32_t options_num_bytes_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
       {
         ScopedCopyLock copy_lock(nap);
@@ skipping 17 matching lines @@
           g_mojo_system, data_pipe_consumer_handle_value, options,
           options_num_bytes_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 17: {
+    case 19: {
       if (num_params != 6) {
         return -1;
       }
       MojoHandle data_pipe_consumer_handle_value;
       void* elements;
       uint32_t volatile* num_bytes_ptr;
       uint32_t num_bytes_value;
       MojoReadDataFlags flags_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
@@ skipping 24 matching lines @@
                                  elements, &num_bytes_value, flags_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *num_bytes_ptr = num_bytes_value;
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 18:
+    case 20:
       fprintf(stderr, "MojoBeginReadData not implemented\n");
       return -1;
-    case 19: {
+    case 21: {
       if (num_params != 4) {
         return -1;
       }
       MojoHandle data_pipe_consumer_handle_value;
       uint32_t num_bytes_read_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
       {
         ScopedCopyLock copy_lock(nap);
         if (!ConvertScalarInput(nap, params[1],
@@ skipping 11 matching lines @@
       result_value = MojoSystemImplEndReadData(
           g_mojo_system, data_pipe_consumer_handle_value, num_bytes_read_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 20: {
+    case 22: {
       if (num_params != 5) {
         return -1;
       }
       const struct MojoCreateSharedBufferOptions* options;
       uint64_t num_bytes_value;
       MojoHandle volatile* shared_buffer_handle_ptr;
       MojoHandle shared_buffer_handle_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
       {
@@ skipping 18 matching lines @@
           g_mojo_system, options, num_bytes_value, &shared_buffer_handle_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *shared_buffer_handle_ptr = shared_buffer_handle_value;
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 21: {
+    case 23: {
       if (num_params != 5) {
         return -1;
       }
       MojoHandle buffer_handle_value;
       const struct MojoDuplicateBufferHandleOptions* options;
       MojoHandle volatile* new_buffer_handle_ptr;
       MojoHandle new_buffer_handle_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
       {
@@ skipping 18 matching lines @@
           &new_buffer_handle_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *new_buffer_handle_ptr = new_buffer_handle_value;
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 22: {
+    case 24: {
       if (num_params != 5) {
         return -1;
       }
       MojoHandle buffer_handle_value;
       struct MojoBufferInformation* info;
       uint32_t info_num_bytes_value;
       MojoResult volatile* result_ptr;
       MojoResult result_value;
       {
         ScopedCopyLock copy_lock(nap);
@@ skipping 15 matching lines @@
       result_value = MojoSystemImplGetBufferInformation(
           g_mojo_system, buffer_handle_value, info, info_num_bytes_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *result_ptr = result_value;
       }
 
       return 0;
     }
-    case 23:
+    case 25:
       fprintf(stderr, "MojoMapBuffer not implemented\n");
       return -1;
-    case 24:
+    case 26:
       fprintf(stderr, "MojoUnmapBuffer not implemented\n");
       return -1;
   }
 
   return -1;
 }
 
 ssize_t MojoDescRecvMsg(void* handle,
                         struct NaClImcTypedMsgHdr* msg,
                         int flags) {
@@ skipping 43 matching lines @@
 MojoResult InjectMojo(struct NaClApp* nap, MojoHandle handle) {
   NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeMojoDesc(nap));
   g_mojo_system = MojoSystemImplCreateImpl();
   return MojoSystemImplTransferHandle(MojoSystemImplGetDefaultImpl(), handle,
                                       g_mojo_system, &g_mojo_handle);
 }
 
 void InjectDisabledMojo(struct NaClApp* nap) {
   NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeDisabledMojoDesc(nap));
 }