| //===------- syscalls.cpp - CStdLib runtime wrappers for system calls -----===// |
| // |
| // The SAFECode Compiler |
| // |
| // This file was developed by the LLVM research group and is distributed under |
| // the University of Illinois Open Source License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file provides CStdLib runtime wrapper versions of system calls. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "CStdLib.h" |
| |
| #include <climits> |
| |
| #include <unistd.h> |
| #include <sys/types.h> |
| #include <sys/socket.h> |
| |
| // |
| // Function: pool_read() |
| // |
| // Description: |
| // This is a memory safe replacement for the read() function. |
| // |
| // Inputs: |
| // Pool - The pool handle for the input buffer |
| // Buf - The input buffer |
| // FD - The file descriptor |
| // Count - The maximum number of bytes to read |
| // Complete - The Completeness bit vector |
| // TAG - The Tag information for debugging purposes |
| // SRC_INFO - Source file and line number information for debugging purposes |
| // |
| ssize_t |
| pool_read_debug (DebugPoolTy * Pool, |
| void * Buf, |
| int FD, |
| size_t Count, |
| const uint8_t Complete, |
| TAG, |
| SRC_INFO) { |
| minSizeCheck (Pool, Buf, ARG1_COMPLETE(Complete), Count, SRC_INFO_ARGS); |
| return read (FD, Buf, Count); |
| } |
| |
| ssize_t |
| pool_read (DebugPoolTy * Pool, |
| void * Buf, |
| int FD, |
| size_t Count, |
| const uint8_t Complete) { |
| return pool_read_debug (Pool, Buf, FD, Count, Complete, DEFAULTS); |
| } |
| |
| // |
| // Function: pool_recv() |
| // |
| // Description: |
| // This is a memory safe replacement for the recv() function. |
| // |
| // Inputs: |
| // Pool - The pool handle for the input buffer |
| // Buf - The input buffer |
| // FD - The file descriptor |
| // Len - The maximum number of bytes to read |
| // Flags - Additional options |
| // Complete - The Completeness bit vector |
| // TAG - The Tag information for debugging purposes |
| // SRC_INFO - Source file and line number information for debugging purposes |
| // |
| ssize_t |
| pool_recv_debug (DebugPoolTy * Pool, |
| void * Buf, |
| int SockFD, |
| size_t Len, |
| int Flags, |
| const uint8_t Complete, |
| TAG, |
| SRC_INFO) { |
| minSizeCheck (Pool, Buf, ARG1_COMPLETE(Complete), Len, SRC_INFO_ARGS); |
| return recv (SockFD, Buf, Len, Flags); |
| } |
| |
| ssize_t |
| pool_recv (DebugPoolTy * Pool, |
| void * Buf, |
| int SockFD, |
| size_t Len, |
| int Flags, |
| const uint8_t Complete) { |
| return pool_recv_debug (Pool, Buf, SockFD, Len, Flags, Complete, DEFAULTS); |
| } |
| |
| // |
| // Function: pool_recvfrom() |
| // |
| // Description: |
| // This is a memory safe replacement for the recvfrom() function. |
| // |
| // Inputs: |
| // Pool - The pool handle for the input buffer |
| // Buf - The input buffer |
| // FD - The file descriptor |
| // Len - The maximum number of bytes to read |
| // Flags - Additional options |
| // SrcAddr - Behavior depends on protocol |
| // AddrLen - Behavior depends on protocol |
| // Complete - The Completeness bit vector |
| // TAG - The Tag information for debugging purposes |
| // SRC_INFO - Source file and line number information for debugging purposes |
| // |
| ssize_t |
| pool_recvfrom_debug (DebugPoolTy * Pool, |
| void * Buf, |
| int SockFD, |
| size_t Len, |
| int Flags, |
| struct sockaddr *SrcAddr, |
| socklen_t *AddrLen, |
| const uint8_t Complete, |
| TAG, |
| SRC_INFO) { |
| minSizeCheck (Pool, Buf, ARG1_COMPLETE(Complete), Len, SRC_INFO_ARGS); |
| return recvfrom (SockFD, Buf, Len, Flags, SrcAddr, AddrLen); |
| } |
| |
| ssize_t |
| pool_recvfrom (DebugPoolTy * Pool, |
| void * Buf, |
| int SockFD, |
| size_t Len, |
| int Flags, |
| struct sockaddr *SrcAddr, |
| socklen_t *AddrLen, |
| const uint8_t Complete) { |
| return pool_recvfrom_debug( |
| Pool, Buf, SockFD, Len, Flags, SrcAddr, AddrLen, Complete, DEFAULTS |
| ); |
| } |
| |
| // |
| // Function: pool_write() |
| // |
| // Description: |
| // This is a memory safe replacement for the write() function. |
| // |
| // Inputs: |
| // Pool - The pool handle for the output buffer |
| // Buf - The output buffer |
| // FD - The file descriptor |
| // Count - The maximum number of bytes to write |
| // Complete - The Completeness bit vector |
| // TAG - The Tag information for debugging purposes |
| // SRC_INFO - Source file and line number information for debugging purposes |
| // |
| ssize_t |
| pool_write_debug (DebugPoolTy * Pool, |
| void * Buf, |
| int FD, |
| size_t Count, |
| const uint8_t Complete, |
| TAG, |
| SRC_INFO) { |
| minSizeCheck (Pool, Buf, ARG1_COMPLETE(Complete), Count, SRC_INFO_ARGS); |
| return write (FD, Buf, Count); |
| } |
| |
| ssize_t |
| pool_write (DebugPoolTy * Pool, |
| void * Buf, |
| int FD, |
| size_t Count, |
| const uint8_t Complete) { |
| return pool_write_debug (Pool, Buf, FD, Count, Complete, DEFAULTS); |
| } |
| |
| // |
| // Function: pool_send() |
| // |
| // Description: |
| // This is a memory safe replacement for the send() function. |
| // |
| // Inputs: |
| // Pool - The pool handle for the output buffer |
| // Buf - The output buffer |
| // FD - The file descriptor |
| // Len - The maximum number of bytes to write |
| // Flags - Additional options |
| // Complete - The Completeness bit vector |
| // TAG - The Tag information for debugging purposes |
| // SRC_INFO - Source file and line number information for debugging purposes |
| // |
| ssize_t |
| pool_send_debug (DebugPoolTy * Pool, |
| void * Buf, |
| int SockFD, |
| size_t Len, |
| int Flags, |
| const uint8_t Complete, |
| TAG, |
| SRC_INFO) { |
| minSizeCheck (Pool, Buf, ARG1_COMPLETE(Complete), Len, SRC_INFO_ARGS); |
| return send (SockFD, Buf, Len, Flags); |
| } |
| |
| ssize_t |
| pool_send (DebugPoolTy * Pool, |
| void * Buf, |
| int SockFD, |
| size_t Len, |
| int Flags, |
| const uint8_t Complete) { |
| return pool_send_debug (Pool, Buf, SockFD, Len, Flags, Complete, DEFAULTS); |
| } |
| |
| // |
| // Function: pool_sendto() |
| // |
| // Description: |
| // This is a memory safe replacement for the sendto() function. |
| // |
| // Inputs: |
| // Pool - The pool handle for the output buffer |
| // Buf - The output buffer |
| // FD - The file descriptor |
| // Len - The maximum number of bytes to write |
| // Flags - Additional options |
| // DestAddr - Behavior depends on protocol |
| // DestLen - Behavior depends on protocol |
| // Complete - The Completeness bit vector |
| // TAG - The Tag information for debugging purposes |
| // SRC_INFO - Source file and line number information for debugging purposes |
| // |
| ssize_t |
| pool_sendto_debug (DebugPoolTy * Pool, |
| void * Buf, |
| int SockFD, |
| size_t Len, |
| int Flags, |
| const struct sockaddr *DestAddr, |
| socklen_t DestLen, |
| const uint8_t Complete, |
| TAG, |
| SRC_INFO) { |
| minSizeCheck (Pool, Buf, ARG1_COMPLETE(Complete), Len, SRC_INFO_ARGS); |
| return sendto (SockFD, Buf, Len, Flags, DestAddr, DestLen); |
| } |
| |
| ssize_t |
| pool_sendto (DebugPoolTy * Pool, |
| void * Buf, |
| int SockFD, |
| size_t Len, |
| int Flags, |
| const struct sockaddr *DestAddr, |
| socklen_t DestLen, |
| const uint8_t Complete) { |
| return pool_sendto_debug( |
| Pool, Buf, SockFD, Len, Flags, DestAddr, DestLen, Complete, DEFAULTS |
| ); |
| } |
| |
| // |
| // Function: pool_readlink() |
| // |
| // Description: |
| // Implement a memory safe replacement for readlink(). |
| // |
| ssize_t |
| pool_readlink_debug (DebugPoolTy * PathPool, |
| DebugPoolTy * BufPool, |
| const char *path, |
| char *buf, |
| size_t len, |
| const uint8_t Complete, |
| TAG, |
| SRC_INFO) { |
| // |
| // First ensure that the buffer containing the pathname is properly |
| // terminated. Note that a NULL path pointer is okay. |
| // |
| if (path != NULL) { |
| validStringCheck (path, PathPool, ARG1_COMPLETE(Complete), "Generic", SRC_INFO_ARGS); |
| } |
| |
| // |
| // Next, if the caller provided a buffer for the result, make sure that the |
| // size is okay. |
| // |
| if (buf) { |
| minSizeCheck (BufPool, buf, ARG2_COMPLETE(Complete), len, SRC_INFO_ARGS); |
| } |
| |
| return readlink (path, buf, len); |
| } |
| |
| ssize_t |
| pool_readlink (DebugPoolTy * PathPool, |
| DebugPoolTy * BufPool, |
| const char *path, |
| char *buf, |
| size_t len, |
| const uint8_t Complete) { |
| return pool_readlink_debug (PathPool, |
| BufPool, |
| path, |
| buf, |
| len, |
| Complete, |
| DEFAULTS); |
| } |
| |
| // |
| // Function: pool_realpath() |
| // |
| // Description: |
| // Implement a memory safe replacement for realpath(). |
| // |
| char * |
| pool_realpath_debug (DebugPoolTy * PathPool, |
| DebugPoolTy * BufPool, |
| const char *path, |
| char *buf, |
| const uint8_t Complete, |
| TAG, |
| SRC_INFO) { |
| // |
| // First ensure that the buffer containing the pathname is properly |
| // terminated. Note that a NULL path pointer is okay. |
| // |
| if (path != NULL) { |
| validStringCheck (path, PathPool, ARG1_COMPLETE(Complete), "Generic", SRC_INFO_ARGS); |
| } |
| |
| // |
| // Next, get the path, but permit realpath to allocate the buffer. This |
| // should ensure that the buffer is sufficiently large. |
| // |
| char *result; |
| result = realpath (path, NULL); |
| |
| if (buf && result) { |
| // |
| // If buf is non-NULL and realpath() succeeded, copy the data into the |
| // caller's buffer and return the buffer. |
| // |
| size_t realLength = strlen (result); |
| minSizeCheck (BufPool, |
| buf, |
| ARG2_COMPLETE(Complete), |
| realLength + 1, |
| SRC_INFO_ARGS); |
| strcpy (buf, result); |
| free (result); |
| return buf; |
| } else if (buf == NULL && result) { |
| // |
| // If buf is NULL, return the allocated result. |
| // |
| return result; |
| } else { |
| // |
| // Otherwise, result must be NULL and so an error occurred. |
| // |
| return NULL; |
| } |
| } |
| |
| char * |
| pool_realpath (DebugPoolTy * PathPool, |
| DebugPoolTy * BufPool, |
| const char *path, |
| char *buf, |
| const uint8_t Complete) { |
| return pool_realpath_debug (PathPool, |
| BufPool, |
| path, |
| buf, |
| Complete, |
| DEFAULTS); |
| } |