Merge XFA to PDFium master at 4dc95e7 on 10/28/2014
[pdfium.git] / core / src / fxcrt / fx_extension.cpp
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "../../include/fxcrt/fx_ext.h"
8 #include "extension.h"
9 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
10 #include <wincrypt.h>
11 #else
12 #include <ctime>
13 #endif
14 FX_HFILE FX_File_Open(FX_BSTR fileName, FX_DWORD dwMode)
15 {
16     IFXCRT_FileAccess* pFA = FXCRT_FileAccess_Create();
17     if (pFA && !pFA->Open(fileName, dwMode)) {
18         pFA->Release();
19         return NULL;
20     }
21     return (FX_HFILE)pFA;
22 }
23 FX_HFILE FX_File_Open(FX_WSTR fileName, FX_DWORD dwMode)
24 {
25     IFXCRT_FileAccess* pFA = FXCRT_FileAccess_Create();
26     if (pFA && !pFA->Open(fileName, dwMode)) {
27         pFA->Release();
28         return NULL;
29     }
30     return (FX_HFILE)pFA;
31 }
32 void FX_File_Close(FX_HFILE hFile)
33 {
34     FXSYS_assert(hFile != NULL);
35     ((IFXCRT_FileAccess*)hFile)->Close();
36     ((IFXCRT_FileAccess*)hFile)->Release();
37 }
38 FX_FILESIZE FX_File_GetSize(FX_HFILE hFile)
39 {
40     FXSYS_assert(hFile != NULL);
41     return ((IFXCRT_FileAccess*)hFile)->GetSize();
42 }
43 FX_FILESIZE FX_File_GetPosition(FX_HFILE hFile)
44 {
45     FXSYS_assert(hFile != NULL);
46     return ((IFXCRT_FileAccess*)hFile)->GetPosition();
47 }
48 FX_FILESIZE FX_File_SetPosition(FX_HFILE hFile, FX_FILESIZE pos)
49 {
50     FXSYS_assert(hFile != NULL);
51     return ((IFXCRT_FileAccess*)hFile)->SetPosition(pos);
52 }
53 size_t FX_File_Read(FX_HFILE hFile, void* pBuffer, size_t szBuffer)
54 {
55     FXSYS_assert(hFile != NULL);
56     return ((IFXCRT_FileAccess*)hFile)->Read(pBuffer, szBuffer);
57 }
58 size_t FX_File_ReadPos(FX_HFILE hFile, void* pBuffer, size_t szBuffer, FX_FILESIZE pos)
59 {
60     FXSYS_assert(hFile != NULL);
61     return ((IFXCRT_FileAccess*)hFile)->ReadPos(pBuffer, szBuffer, pos);
62 }
63 size_t FX_File_Write(FX_HFILE hFile, const void* pBuffer, size_t szBuffer)
64 {
65     FXSYS_assert(hFile != NULL);
66     return ((IFXCRT_FileAccess*)hFile)->Write(pBuffer, szBuffer);
67 }
68 size_t FX_File_WritePos(FX_HFILE hFile, const void* pBuffer, size_t szBuffer, FX_FILESIZE pos)
69 {
70     FXSYS_assert(hFile != NULL);
71     return ((IFXCRT_FileAccess*)hFile)->WritePos(pBuffer, szBuffer, pos);
72 }
73 FX_BOOL FX_File_Flush(FX_HFILE hFile)
74 {
75     FXSYS_assert(hFile != NULL);
76     return ((IFXCRT_FileAccess*)hFile)->Flush();
77 }
78 FX_BOOL FX_File_Truncate(FX_HFILE hFile, FX_FILESIZE szFile)
79 {
80     FXSYS_assert(hFile != NULL);
81     return ((IFXCRT_FileAccess*)hFile)->Truncate(szFile);
82 }
83 IFX_FileAccess* FX_CreateDefaultFileAccess(FX_WSTR wsPath)\r
84 {\r
85         if (wsPath.GetLength() == 0)\r
86                 return NULL;\r
87 \r
88         CFX_CRTFileAccess* pFA = NULL;\r
89         pFA = FX_NEW CFX_CRTFileAccess;\r
90         if (NULL == pFA) return NULL;\r
91 \r
92         pFA->Init(wsPath);\r
93         return pFA;\r
94 }\r
95 IFX_FileStream* FX_CreateFileStream(FX_LPCSTR filename, FX_DWORD dwModes)
96 {
97     IFXCRT_FileAccess* pFA = FXCRT_FileAccess_Create();
98     if (!pFA) {
99         return NULL;
100     }
101     if (!pFA->Open(filename, dwModes)) {
102         pFA->Release();
103         return NULL;
104     }
105     return FX_NEW CFX_CRTFileStream(pFA);
106 }
107 IFX_FileStream* FX_CreateFileStream(FX_LPCWSTR filename, FX_DWORD dwModes)
108 {
109     IFXCRT_FileAccess* pFA = FXCRT_FileAccess_Create();
110     if (!pFA) {
111         return NULL;
112     }
113     if (!pFA->Open(filename, dwModes)) {
114         pFA->Release();
115         return NULL;
116     }
117     return FX_NEW CFX_CRTFileStream(pFA);
118 }
119 IFX_FileWrite* FX_CreateFileWrite(FX_LPCSTR filename)
120 {
121     return FX_CreateFileStream(filename, FX_FILEMODE_Truncate);
122 }
123 IFX_FileWrite* FX_CreateFileWrite(FX_LPCWSTR filename)
124 {
125     return FX_CreateFileStream(filename, FX_FILEMODE_Truncate);
126 }
127 IFX_FileRead* FX_CreateFileRead(FX_LPCSTR filename)
128 {
129     return FX_CreateFileStream(filename, FX_FILEMODE_ReadOnly);
130 }
131 IFX_FileRead* FX_CreateFileRead(FX_LPCWSTR filename)
132 {
133     return FX_CreateFileStream(filename, FX_FILEMODE_ReadOnly);
134 }
135 IFX_MemoryStream* FX_CreateMemoryStream(FX_LPBYTE pBuffer, size_t dwSize, FX_BOOL bTakeOver)
136 {
137     return FX_NEW CFX_MemoryStream(pBuffer, dwSize, bTakeOver);
138 }
139 IFX_MemoryStream* FX_CreateMemoryStream(FX_BOOL bConsecutive)
140 {
141     return FX_NEW CFX_MemoryStream(bConsecutive);
142 }
143 #ifdef __cplusplus
144 extern "C" {
145 #endif
146 FX_FLOAT FXSYS_tan(FX_FLOAT a)
147 {
148     return (FX_FLOAT)tan(a);
149 }
150 FX_FLOAT FXSYS_logb(FX_FLOAT b, FX_FLOAT x)
151 {
152     return FXSYS_log(x) / FXSYS_log(b);
153 }
154 FX_FLOAT FXSYS_strtof(FX_LPCSTR pcsStr, FX_INT32 iLength, FX_INT32 *pUsedLen)
155 {
156     FXSYS_assert(pcsStr != NULL);
157     if (iLength < 0) {
158         iLength = (FX_INT32)FXSYS_strlen(pcsStr);
159     }
160     CFX_WideString ws = CFX_WideString::FromLocal(pcsStr, iLength);
161     return FXSYS_wcstof((FX_LPCWSTR)ws, iLength, pUsedLen);
162 }
163 FX_FLOAT FXSYS_wcstof(FX_LPCWSTR pwsStr, FX_INT32 iLength, FX_INT32 *pUsedLen)
164 {
165     FXSYS_assert(pwsStr != NULL);
166     if (iLength < 0) {
167         iLength = (FX_INT32)FXSYS_wcslen(pwsStr);
168     }
169     if (iLength == 0) {
170         return 0.0f;
171     }
172     FX_INT32 iUsedLen = 0;
173     FX_BOOL bNegtive = FALSE;
174     switch (pwsStr[iUsedLen]) {
175         case '-':
176             bNegtive = TRUE;
177         case '+':
178             iUsedLen++;
179             break;
180     }
181     FX_FLOAT fValue = 0.0f;
182     while (iUsedLen < iLength) {
183         FX_WCHAR wch = pwsStr[iUsedLen];
184         if (wch >= L'0' && wch <= L'9') {
185             fValue = fValue * 10.0f + (wch - L'0');
186         } else {
187             break;
188         }
189         iUsedLen++;
190     }
191     if (iUsedLen < iLength && pwsStr[iUsedLen] == L'.') {
192         FX_FLOAT fPrecise = 0.1f;
193         while (++iUsedLen < iLength) {
194             FX_WCHAR wch = pwsStr[iUsedLen];
195             if (wch >= L'0' && wch <= L'9') {
196                 fValue += (wch - L'0') * fPrecise;
197                 fPrecise *= 0.1f;
198             } else {
199                 break;
200             }
201         }
202     }
203     if (pUsedLen) {
204         *pUsedLen = iUsedLen;
205     }
206     return bNegtive ? -fValue : fValue;
207 }
208 FX_LPWSTR FXSYS_wcsncpy(FX_LPWSTR dstStr, FX_LPCWSTR srcStr, size_t count)
209 {
210     FXSYS_assert(dstStr != NULL && srcStr != NULL && count > 0);
211     for (size_t i = 0; i < count; ++i)
212         if ((dstStr[i] = srcStr[i]) == L'\0') {
213             break;
214         }
215     return dstStr;
216 }
217 FX_INT32 FXSYS_wcsnicmp(FX_LPCWSTR s1, FX_LPCWSTR s2, size_t count)
218 {
219     FXSYS_assert(s1 != NULL && s2 != NULL && count > 0);
220     FX_WCHAR wch1 = 0, wch2 = 0;
221     while (count-- > 0) {
222         wch1 = (FX_WCHAR)FXSYS_tolower(*s1++);
223         wch2 = (FX_WCHAR)FXSYS_tolower(*s2++);
224         if (wch1 != wch2) {
225             break;
226         }
227     }
228     return wch1 - wch2;
229 }
230 FX_INT32 FXSYS_strnicmp(FX_LPCSTR s1, FX_LPCSTR s2, size_t count)
231 {
232     FXSYS_assert(s1 != NULL && s2 != NULL && count > 0);
233     FX_CHAR ch1 = 0, ch2 = 0;
234     while (count-- > 0) {
235         ch1 = (FX_CHAR)FXSYS_tolower(*s1++);
236         ch2 = (FX_CHAR)FXSYS_tolower(*s2++);
237         if (ch1 != ch2) {
238             break;
239         }
240     }
241     return ch1 - ch2;
242 }
243 FX_DWORD FX_HashCode_String_GetA(FX_LPCSTR pStr, FX_INT32 iLength, FX_BOOL bIgnoreCase)
244 {
245     FXSYS_assert(pStr != NULL);
246     if (iLength < 0) {
247         iLength = (FX_INT32)FXSYS_strlen(pStr);
248     }
249     FX_LPCSTR pStrEnd = pStr + iLength;
250     FX_DWORD dwHashCode = 0;
251     if (bIgnoreCase) {
252         while (pStr < pStrEnd) {
253             dwHashCode = 31 * dwHashCode + FXSYS_tolower(*pStr++);
254         }
255     } else {
256         while (pStr < pStrEnd) {
257             dwHashCode = 31 * dwHashCode + *pStr ++;
258         }
259     }
260     return dwHashCode;
261 }
262 FX_DWORD FX_HashCode_String_GetW(FX_LPCWSTR pStr, FX_INT32 iLength, FX_BOOL bIgnoreCase)
263 {
264     FXSYS_assert(pStr != NULL);
265     if (iLength < 0) {
266         iLength = (FX_INT32)FXSYS_wcslen(pStr);
267     }
268     FX_LPCWSTR pStrEnd = pStr + iLength;
269     FX_DWORD dwHashCode = 0;
270     if (bIgnoreCase) {
271         while (pStr < pStrEnd) {
272             dwHashCode = 1313 * dwHashCode + FXSYS_tolower(*pStr++);
273         }
274     } else {
275         while (pStr < pStrEnd) {
276             dwHashCode = 1313 * dwHashCode + *pStr ++;
277         }
278     }
279     return dwHashCode;
280 }
281 #ifdef __cplusplus
282 }
283 #endif
284 #ifdef __cplusplus
285 extern "C" {
286 #endif
287 FX_LPVOID FX_Random_MT_Start(FX_DWORD dwSeed)
288 {
289     FX_LPMTRANDOMCONTEXT pContext = FX_Alloc(FX_MTRANDOMCONTEXT, 1);
290     if (!pContext) {
291         return NULL;
292     }
293     pContext->mt[0] = dwSeed;
294     FX_DWORD &i = pContext->mti;
295     FX_LPDWORD pBuf = pContext->mt;
296     for (i = 1; i < MT_N; i ++) {
297         pBuf[i] = (1812433253UL * (pBuf[i - 1] ^ (pBuf[i - 1] >> 30)) + i);
298     }
299     pContext->bHaveSeed = TRUE;
300     return pContext;
301 }
302 FX_DWORD FX_Random_MT_Generate(FX_LPVOID pContext)
303 {
304     FXSYS_assert(pContext != NULL);
305     FX_LPMTRANDOMCONTEXT pMTC = (FX_LPMTRANDOMCONTEXT)pContext;
306     FX_DWORD v;
307     static FX_DWORD mag[2] = {0, MT_Matrix_A};
308     FX_DWORD &mti = pMTC->mti;
309     FX_LPDWORD pBuf = pMTC->mt;
310     if ((int)mti < 0 || mti >= MT_N) {
311         if (mti > MT_N && !pMTC->bHaveSeed) {
312             return 0;
313         }
314         FX_DWORD kk;
315         for (kk = 0; kk < MT_N - MT_M; kk ++) {
316             v = (pBuf[kk] & MT_Upper_Mask) | (pBuf[kk + 1] & MT_Lower_Mask);
317             pBuf[kk] = pBuf[kk + MT_M] ^ (v >> 1) ^ mag[v & 1];
318         }
319         for (; kk < MT_N - 1; kk ++) {
320             v = (pBuf[kk] & MT_Upper_Mask) | (pBuf[kk + 1] & MT_Lower_Mask);
321             pBuf[kk] = pBuf[kk + (MT_M - MT_N)] ^ (v >> 1) ^ mag[v & 1];
322         }
323         v = (pBuf[MT_N - 1] & MT_Upper_Mask) | (pBuf[0] & MT_Lower_Mask);
324         pBuf[MT_N - 1] = pBuf[MT_M - 1] ^ (v >> 1) ^ mag[v & 1];
325         mti = 0;
326     }
327     v = pBuf[mti ++];
328     v ^= (v >> 11);
329     v ^= (v << 7) & 0x9d2c5680UL;
330     v ^= (v << 15) & 0xefc60000UL;
331     v ^= (v >> 18);
332     return v;
333 }
334 void FX_Random_MT_Close(FX_LPVOID pContext)
335 {
336     FXSYS_assert(pContext != NULL);
337     FX_Free(pContext);
338 }
339 void FX_Random_GenerateMT(FX_LPDWORD pBuffer, FX_INT32 iCount)
340 {
341     FX_DWORD dwSeed;
342 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
343     if (!FX_GenerateCryptoRandom(&dwSeed, 1)) {
344         FX_Random_GenerateBase(&dwSeed, 1);
345     }
346 #else
347     FX_Random_GenerateBase(&dwSeed, 1);
348 #endif
349     FX_LPVOID pContext = FX_Random_MT_Start(dwSeed);
350     while (iCount -- > 0) {
351         *pBuffer ++ = FX_Random_MT_Generate(pContext);
352     }
353     FX_Random_MT_Close(pContext);
354 }
355 void FX_Random_GenerateBase(FX_LPDWORD pBuffer, FX_INT32 iCount)
356 {
357 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
358     SYSTEMTIME st1, st2;
359     ::GetSystemTime(&st1);
360     do {
361         ::GetSystemTime(&st2);
362     } while (FXSYS_memcmp32(&st1, &st2, sizeof(SYSTEMTIME)) == 0);
363     FX_DWORD dwHash1 = FX_HashCode_String_GetA((FX_LPCSTR)&st1, sizeof(st1), TRUE);
364     FX_DWORD dwHash2 = FX_HashCode_String_GetA((FX_LPCSTR)&st2, sizeof(st2), TRUE);
365     ::srand((dwHash1 << 16) | (FX_DWORD)dwHash2);
366 #else
367     time_t tmLast = time(NULL), tmCur;
368     while ((tmCur = time(NULL)) == tmLast);
369     ::srand((tmCur << 16) | (tmLast & 0xFFFF));
370 #endif
371     while (iCount -- > 0) {
372         *pBuffer ++ = (FX_DWORD)((::rand() << 16) | (::rand() & 0xFFFF));
373     }
374 }
375 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
376 FX_BOOL FX_GenerateCryptoRandom(FX_LPDWORD pBuffer, FX_INT32 iCount)
377 {
378     HCRYPTPROV hCP = NULL;
379     if (!::CryptAcquireContext(&hCP, NULL, NULL, PROV_RSA_FULL, 0) || hCP == NULL) {
380         return FALSE;
381     }
382     ::CryptGenRandom(hCP, iCount * sizeof(FX_DWORD), (FX_LPBYTE)pBuffer);
383     ::CryptReleaseContext(hCP, 0);
384     return TRUE;
385 }
386 #endif
387 void FX_Random_GenerateCrypto(FX_LPDWORD pBuffer, FX_INT32 iCount)
388 {
389 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
390     FX_GenerateCryptoRandom(pBuffer, iCount);
391 #else
392     FX_Random_GenerateBase(pBuffer, iCount);
393 #endif
394 }
395 #ifdef __cplusplus
396 }
397 #endif
398 #ifdef __cplusplus\r
399 extern "C" {\r
400 #endif\r
401 void FX_GUID_CreateV4(FX_LPGUID pGUID)\r
402 {\r
403 #if (_FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN32_MOBILE_ || _FX_OS_ == _FX_WIN64_)\r
404 #ifdef _FX_WINAPI_PARTITION_DESKTOP_\r
405     if (!FX_GenerateCryptoRandom((FX_LPDWORD)pGUID, 4)) {\r
406         FX_Random_GenerateMT((FX_LPDWORD)pGUID, 4);\r
407     }\r
408 #else\r
409     FX_Random_GenerateMT((FX_LPDWORD)pGUID, 4);\r
410 #endif\r
411 #else\r
412     FX_Random_GenerateMT((FX_LPDWORD)pGUID, 4);\r
413 #endif\r
414     FX_BYTE &b = ((FX_LPBYTE)pGUID)[6];\r
415     b = (b & 0x0F) | 0x40;\r
416 }\r
417 FX_LPCSTR gs_FX_pHexChars = "0123456789ABCDEF";\r
418 void FX_GUID_ToString(FX_LPCGUID pGUID, CFX_ByteString &bsStr, FX_BOOL bSeparator)\r
419 {\r
420     FX_LPSTR pBuf = bsStr.GetBuffer(40);\r
421     FX_BYTE b;\r
422     for (FX_INT32 i = 0; i < 16; i ++) {\r
423         b = ((FX_LPCBYTE)pGUID)[i];\r
424         *pBuf ++ = gs_FX_pHexChars[b >> 4];\r
425         *pBuf ++ = gs_FX_pHexChars[b & 0x0F];\r
426         if (bSeparator && (i == 3 || i == 5 || i == 7 || i == 9)) {\r
427             *pBuf ++ = L'-';\r
428         }\r
429     }\r
430     bsStr.ReleaseBuffer(bSeparator ? 36 : 32);\r
431 }\r
432 #ifdef __cplusplus\r
433 }\r
434 #endif\r