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          102321 : int NaClCopyInFromUser(struct NaClApp *nap,
      16                 :                        void           *dst_sys_ptr,
      17                 :                        uintptr_t      src_usr_addr,
      18                 :                        size_t         num_bytes) {
      19                 :   uintptr_t src_sys_addr;
      20                 : 
      21          102321 :   src_sys_addr = NaClUserToSysAddrRange(nap, src_usr_addr, num_bytes);
      22          102319 :   if (kNaClBadAddress == src_sys_addr) {
      23               3 :     return 0;
      24                 :   }
      25          102316 :   NaClCopyTakeLock(nap);
      26          102324 :   memcpy((void *) dst_sys_ptr, (void *) src_sys_addr, num_bytes);
      27          102324 :   NaClCopyDropLock(nap);
      28                 : 
      29          102319 :   return 1;
      30                 : }
      31                 : 
      32         1491181 : int NaClCopyInFromUserAndDropLock(struct NaClApp *nap,
      33                 :                                   void           *dst_sys_ptr,
      34                 :                                   uintptr_t      src_usr_addr,
      35                 :                                   size_t         num_bytes) {
      36                 :   uintptr_t src_sys_addr;
      37                 : 
      38         1491181 :   src_sys_addr = NaClUserToSysAddrRange(nap, src_usr_addr, num_bytes);
      39         1491181 :   if (kNaClBadAddress == src_sys_addr) {
      40               0 :     return 0;
      41                 :   }
      42                 : 
      43         1491181 :   memcpy((void *) dst_sys_ptr, (void *) src_sys_addr, num_bytes);
      44         1491181 :   NaClCopyDropLock(nap);
      45                 : 
      46         1491181 :   return 1;
      47                 : }
      48                 : 
      49             237 : int NaClCopyInFromUserZStr(struct NaClApp *nap,
      50                 :                            char           *dst_buffer,
      51                 :                            size_t         dst_buffer_bytes,
      52                 :                            uintptr_t      src_usr_addr) {
      53                 :   uintptr_t src_sys_addr;
      54                 : 
      55             237 :   CHECK(dst_buffer_bytes > 0);
      56             237 :   src_sys_addr = NaClUserToSysAddr(nap, src_usr_addr);
      57             237 :   if (kNaClBadAddress == src_sys_addr) {
      58               0 :     dst_buffer[0] = '\0';
      59               0 :     return 0;
      60                 :   }
      61             237 :   NaClCopyTakeLock(nap);
      62             237 :   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                 : }
      72                 : 
      73                 : 
      74          444159 : int NaClCopyOutToUser(struct NaClApp  *nap,
      75                 :                       uintptr_t       dst_usr_addr,
      76                 :                       void            *src_sys_ptr,
      77                 :                       size_t          num_bytes) {
      78                 :   uintptr_t dst_sys_addr;
      79                 : 
      80          444159 :   dst_sys_addr = NaClUserToSysAddrRange(nap, dst_usr_addr, num_bytes);
      81          444165 :   if (kNaClBadAddress == dst_sys_addr) {
      82               1 :     return 0;
      83                 :   }
      84          444164 :   NaClCopyTakeLock(nap);
      85          444164 :   memcpy((void *) dst_sys_addr, src_sys_ptr, num_bytes);
      86          444164 :   NaClCopyDropLock(nap);
      87                 : 
      88          444164 :   return 1;
      89                 : }