OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright (c) 2011 The Chromium 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 <stdarg.h> | |
8 #include <stdlib.h> | |
9 #include <string.h> | |
10 | |
11 #include "native_client/src/include/portability_io.h" | |
12 #include "native_client/src/include/portability_process.h" | |
13 #include "native_client/src/shared/platform/nacl_check.h" | |
14 #include "ppapi/cpp/module.h" | |
15 #include "ppapi/native_client/src/trusted/plugin/utility.h" | |
16 | |
17 namespace plugin { | |
18 | |
19 int gNaClPluginDebugPrintEnabled = -1; | |
20 | |
21 /* | |
22 * Prints formatted message to the log. | |
23 */ | |
24 int NaClPluginPrintLog(const char *format, ...) { | |
25 va_list arg; | |
26 int out_size; | |
27 | |
28 static const int kStackBufferSize = 512; | |
29 char stack_buffer[kStackBufferSize]; | |
30 | |
31 // Just log locally to stderr if we can't use the nacl interface. | |
32 if (!GetNaClInterface()) { | |
33 va_start(arg, format); | |
34 int rc = vfprintf(stderr, format, arg); | |
35 va_end(arg); | |
36 return rc; | |
37 } | |
38 | |
39 va_start(arg, format); | |
40 out_size = vsnprintf(stack_buffer, kStackBufferSize, format, arg); | |
41 va_end(arg); | |
42 if (out_size < kStackBufferSize) { | |
43 GetNaClInterface()->Vlog(stack_buffer); | |
44 } else { | |
45 // Message too large for our stack buffer; we have to allocate memory | |
46 // instead. | |
47 char *buffer = static_cast<char*>(malloc(out_size + 1)); | |
48 va_start(arg, format); | |
49 vsnprintf(buffer, out_size + 1, format, arg); | |
50 va_end(arg); | |
51 GetNaClInterface()->Vlog(buffer); | |
52 free(buffer); | |
53 } | |
54 return out_size; | |
55 } | |
56 | |
57 /* | |
58 * Currently looks for presence of NACL_PLUGIN_DEBUG and returns | |
59 * 0 if absent and 1 if present. In the future we may include notions | |
60 * of verbosity level. | |
61 */ | |
62 int NaClPluginDebugPrintCheckEnv() { | |
63 char* env = getenv("NACL_PLUGIN_DEBUG"); | |
64 return (NULL != env); | |
65 } | |
66 | |
67 bool IsValidIdentifierString(const char* strval, uint32_t* length) { | |
68 // This function is supposed to recognize valid ECMAScript identifiers, | |
69 // as described in | |
70 // http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf | |
71 // It is currently restricted to only the ASCII subset. | |
72 // TODO(sehr): Recognize the full Unicode formulation of identifiers. | |
73 // TODO(sehr): Make this table-driven if efficiency becomes a problem. | |
74 if (NULL != length) { | |
75 *length = 0; | |
76 } | |
77 if (NULL == strval) { | |
78 return false; | |
79 } | |
80 static const char* kValidFirstChars = | |
81 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz$_"; | |
82 static const char* kValidOtherChars = | |
83 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz$_" | |
84 "0123456789"; | |
85 if (NULL == strchr(kValidFirstChars, strval[0])) { | |
86 return false; | |
87 } | |
88 uint32_t pos; | |
89 for (pos = 1; ; ++pos) { | |
90 if (0 == pos) { | |
91 // Unsigned overflow. | |
92 return false; | |
93 } | |
94 int c = strval[pos]; | |
95 if (0 == c) { | |
96 break; | |
97 } | |
98 if (NULL == strchr(kValidOtherChars, c)) { | |
99 return false; | |
100 } | |
101 } | |
102 if (NULL != length) { | |
103 *length = pos; | |
104 } | |
105 return true; | |
106 } | |
107 | |
108 // We cache the NaCl interface pointer and ensure that its set early on, on the | |
109 // main thread. This allows GetNaClInterface() to be used from non-main threads. | |
110 static const PPB_NaCl_Private* g_nacl_interface = NULL; | |
111 | |
112 const PPB_NaCl_Private* GetNaClInterface() { | |
113 return g_nacl_interface; | |
114 } | |
115 | |
116 void SetNaClInterface(const PPB_NaCl_Private* nacl_interface) { | |
117 g_nacl_interface = nacl_interface; | |
118 } | |
119 | |
120 void CloseFileHandle(PP_FileHandle file_handle) { | |
121 #if NACL_WINDOWS | |
122 CloseHandle(file_handle); | |
123 #else | |
124 close(file_handle); | |
125 #endif | |
126 } | |
127 | |
128 // Converts a PP_FileHandle to a POSIX file descriptor. | |
129 int32_t ConvertFileDescriptor(PP_FileHandle handle, bool read_only) { | |
130 PLUGIN_PRINTF(("ConvertFileDescriptor, handle=%d\n", handle)); | |
131 #if NACL_WINDOWS | |
132 int32_t file_desc = NACL_NO_FILE_DESC; | |
133 // On Windows, valid handles are 32 bit unsigned integers so this is safe. | |
134 file_desc = reinterpret_cast<intptr_t>(handle); | |
135 // Convert the Windows HANDLE from Pepper to a POSIX file descriptor. | |
136 int flags = _O_BINARY; | |
137 flags |= read_only ? _O_RDONLY : _O_RDWR; | |
138 int32_t posix_desc = _open_osfhandle(file_desc, flags); | |
139 if (posix_desc == -1) { | |
140 // Close the Windows HANDLE if it can't be converted. | |
141 CloseHandle(reinterpret_cast<HANDLE>(file_desc)); | |
142 return -1; | |
143 } | |
144 return posix_desc; | |
145 #else | |
146 return handle; | |
147 #endif | |
148 } | |
149 | |
150 } // namespace plugin | |
OLD | NEW |