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 <string.h>
       8                 : 
       9                 : #include "native_client/src/trusted/service_runtime/nacl_copy.h"
      10                 : 
      11                 : #include "native_client/src/shared/platform/nacl_check.h"
      12                 : #include "native_client/src/shared/platform/nacl_sync_checked.h"
      13                 : #include "native_client/src/trusted/service_runtime/sel_ldr.h"
      14                 : 
      15           91331 : int NaClCopyInFromUser(struct NaClApp *nap,
      16           91331 :                        void           *dst_sys_ptr,
      17           91331 :                        uintptr_t      src_usr_addr,
      18           91331 :                        size_t         num_bytes) {
      19           91331 :   uintptr_t src_sys_addr;
      20                 : 
      21           91331 :   src_sys_addr = NaClUserToSysAddrRange(nap, src_usr_addr, num_bytes);
      22           91331 :   if (kNaClBadAddress == src_sys_addr) {
      23               3 :     return 0;
      24                 :   }
      25           91328 :   NaClCopyTakeLock(nap);
      26          273984 :   memcpy((void *) dst_sys_ptr, (void *) src_sys_addr, num_bytes);
      27           91328 :   NaClCopyDropLock(nap);
      28                 : 
      29           91328 :   return 1;
      30           91331 : }
      31                 : 
      32         1963723 : int NaClCopyInFromUserAndDropLock(struct NaClApp *nap,
      33         1963723 :                                   void           *dst_sys_ptr,
      34         1963723 :                                   uintptr_t      src_usr_addr,
      35         1963723 :                                   size_t         num_bytes) {
      36         1963723 :   uintptr_t src_sys_addr;
      37                 : 
      38         1963723 :   src_sys_addr = NaClUserToSysAddrRange(nap, src_usr_addr, num_bytes);
      39         1963723 :   if (kNaClBadAddress == src_sys_addr) {
      40               0 :     return 0;
      41                 :   }
      42                 : 
      43         5891169 :   memcpy((void *) dst_sys_ptr, (void *) src_sys_addr, num_bytes);
      44         1963723 :   NaClCopyDropLock(nap);
      45                 : 
      46         1963723 :   return 1;
      47         1963723 : }
      48                 : 
      49             238 : int NaClCopyInFromUserZStr(struct NaClApp *nap,
      50             238 :                            char           *dst_buffer,
      51             238 :                            size_t         dst_buffer_bytes,
      52             238 :                            uintptr_t      src_usr_addr) {
      53             238 :   uintptr_t src_sys_addr;
      54                 : 
      55             714 :   CHECK(dst_buffer_bytes > 0);
      56             238 :   src_sys_addr = NaClUserToSysAddr(nap, src_usr_addr);
      57             238 :   if (kNaClBadAddress == src_sys_addr) {
      58               1 :     dst_buffer[0] = '\0';
      59               1 :     return 0;
      60                 :   }
      61             237 :   NaClCopyTakeLock(nap);
      62             711 :   strncpy(dst_buffer, (char *) src_sys_addr, dst_buffer_bytes);
      63             237 :   NaClCopyDropLock(nap);
      64                 : 
      65                 :   /* POSIX strncpy pads with NUL characters */
      66             237 :   if (dst_buffer[dst_buffer_bytes - 1] != '\0') {
      67               0 :     dst_buffer[dst_buffer_bytes - 1] = '\0';
      68               0 :     return 0;
      69                 :   }
      70             237 :   return 1;
      71             238 : }
      72                 : 
      73                 : 
      74          737986 : int NaClCopyOutToUser(struct NaClApp  *nap,
      75          737986 :                       uintptr_t       dst_usr_addr,
      76          737986 :                       void            *src_sys_ptr,
      77          737986 :                       size_t          num_bytes) {
      78          737986 :   uintptr_t dst_sys_addr;
      79                 : 
      80          737986 :   dst_sys_addr = NaClUserToSysAddrRange(nap, dst_usr_addr, num_bytes);
      81          737986 :   if (kNaClBadAddress == dst_sys_addr) {
      82               1 :     return 0;
      83                 :   }
      84          737985 :   NaClCopyTakeLock(nap);
      85         2213955 :   memcpy((void *) dst_sys_addr, src_sys_ptr, num_bytes);
      86          737985 :   NaClCopyDropLock(nap);
      87                 : 
      88          737985 :   return 1;
      89          737986 : }