OLD | NEW |
1 // Copyright 2014 PDFium Authors. All rights reserved. | 1 // Copyright 2014 PDFium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
6 | 6 |
7 #include "../../../core/include/fdrm/fx_crypt.h" | 7 #include "../../../core/include/fdrm/fx_crypt.h" |
8 #include "../../include/javascript/JavaScript.h" | 8 #include "../../include/javascript/JavaScript.h" |
9 #include "../../include/javascript/IJavaScript.h" | 9 #include "../../include/javascript/IJavaScript.h" |
10 #include "../../include/javascript/JS_GlobalData.h" | 10 #include "../../include/javascript/JS_GlobalData.h" |
11 | 11 |
12 #define JS_MAXGLOBALDATA (1024 * 4 - 8) | 12 #define JS_MAXGLOBALDATA (1024 * 4 - 8) |
13 | 13 |
14 /* --------------------- CJS_GlobalVariableArray --------------------- */ | 14 /* --------------------- CJS_GlobalVariableArray --------------------- */ |
15 | 15 |
16 CJS_GlobalVariableArray::CJS_GlobalVariableArray() | 16 CJS_GlobalVariableArray::CJS_GlobalVariableArray() {} |
17 { | 17 |
18 } | 18 CJS_GlobalVariableArray::~CJS_GlobalVariableArray() { |
19 | 19 Empty(); |
20 CJS_GlobalVariableArray::~CJS_GlobalVariableArray() | 20 } |
21 { | 21 |
22 Empty(); | 22 void CJS_GlobalVariableArray::Copy(const CJS_GlobalVariableArray& array) { |
23 } | 23 Empty(); |
24 | 24 for (int i = 0, sz = array.Count(); i < sz; i++) { |
25 void CJS_GlobalVariableArray::Copy(const CJS_GlobalVariableArray& array) | 25 CJS_KeyValue* pOldObjData = array.GetAt(i); |
26 { | 26 ASSERT(pOldObjData != NULL); |
27 Empty(); | 27 |
28 for (int i=0,sz=array.Count(); i<sz; i++) | 28 switch (pOldObjData->nType) { |
29 { | 29 case JS_GLOBALDATA_TYPE_NUMBER: { |
30 CJS_KeyValue* pOldObjData = array.GetAt(i); | 30 CJS_KeyValue* pNewObjData = new CJS_KeyValue; |
31 ASSERT(pOldObjData != NULL); | 31 pNewObjData->sKey = pOldObjData->sKey; |
32 | 32 pNewObjData->nType = pOldObjData->nType; |
33 switch (pOldObjData->nType) | 33 pNewObjData->dData = pOldObjData->dData; |
34 { | 34 Add(pNewObjData); |
35 case JS_GLOBALDATA_TYPE_NUMBER: | 35 } break; |
36 { | 36 case JS_GLOBALDATA_TYPE_BOOLEAN: { |
37 CJS_KeyValue* pNewObjData = new CJS_KeyValue; | 37 CJS_KeyValue* pNewObjData = new CJS_KeyValue; |
38 pNewObjData->sKey = pOldObjData->sKey; | 38 pNewObjData->sKey = pOldObjData->sKey; |
39 pNewObjData->nType = pOldObjData->nType; | 39 pNewObjData->nType = pOldObjData->nType; |
40 pNewObjData->dData = pOldObjData->dData; | 40 pNewObjData->bData = pOldObjData->bData; |
41 Add(pNewObjData); | 41 Add(pNewObjData); |
| 42 } break; |
| 43 case JS_GLOBALDATA_TYPE_STRING: { |
| 44 CJS_KeyValue* pNewObjData = new CJS_KeyValue; |
| 45 pNewObjData->sKey = pOldObjData->sKey; |
| 46 pNewObjData->nType = pOldObjData->nType; |
| 47 pNewObjData->sData = pOldObjData->sData; |
| 48 Add(pNewObjData); |
| 49 } break; |
| 50 case JS_GLOBALDATA_TYPE_OBJECT: { |
| 51 CJS_KeyValue* pNewObjData = new CJS_KeyValue; |
| 52 pNewObjData->sKey = pOldObjData->sKey; |
| 53 pNewObjData->nType = pOldObjData->nType; |
| 54 pNewObjData->objData.Copy(pOldObjData->objData); |
| 55 Add(pNewObjData); |
| 56 } |
| 57 case JS_GLOBALDATA_TYPE_NULL: { |
| 58 CJS_KeyValue* pNewObjData = new CJS_KeyValue; |
| 59 pNewObjData->sKey = pOldObjData->sKey; |
| 60 pNewObjData->nType = pOldObjData->nType; |
| 61 Add(pNewObjData); |
| 62 } |
| 63 } |
| 64 } |
| 65 } |
| 66 |
| 67 void CJS_GlobalVariableArray::Add(CJS_KeyValue* p) { |
| 68 array.Add(p); |
| 69 } |
| 70 |
| 71 int CJS_GlobalVariableArray::Count() const { |
| 72 return array.GetSize(); |
| 73 } |
| 74 |
| 75 CJS_KeyValue* CJS_GlobalVariableArray::GetAt(int index) const { |
| 76 return array.GetAt(index); |
| 77 } |
| 78 |
| 79 void CJS_GlobalVariableArray::Empty() { |
| 80 for (int i = 0, sz = array.GetSize(); i < sz; i++) |
| 81 delete array.GetAt(i); |
| 82 array.RemoveAll(); |
| 83 } |
| 84 |
| 85 /* -------------------------- CJS_GlobalData -------------------------- */ |
| 86 |
| 87 #define READER_JS_GLOBALDATA_FILENAME L"Reader_JsGlobal.Data" |
| 88 #define PHANTOM_JS_GLOBALDATA_FILENAME L"Phantom_JsGlobal.Data" |
| 89 #define SDK_JS_GLOBALDATA_FILENAME L"SDK_JsGlobal.Data" |
| 90 |
| 91 static const uint8_t JS_RC4KEY[] = { |
| 92 0x19, 0xa8, 0xe8, 0x01, 0xf6, 0xa8, 0xb6, 0x4d, 0x82, 0x04, 0x45, 0x6d, |
| 93 0xb4, 0xcf, 0xd7, 0x77, 0x67, 0xf9, 0x75, 0x9f, 0xf0, 0xe0, 0x1e, 0x51, |
| 94 0xee, 0x46, 0xfd, 0x0b, 0xc9, 0x93, 0x25, 0x55, 0x4a, 0xee, 0xe0, 0x16, |
| 95 0xd0, 0xdf, 0x8c, 0xfa, 0x2a, 0xa9, 0x49, 0xfd, 0x97, 0x1c, 0x0e, 0x22, |
| 96 0x13, 0x28, 0x7c, 0xaf, 0xc4, 0xfc, 0x9c, 0x12, 0x65, 0x8c, 0x4e, 0x5b, |
| 97 0x04, 0x75, 0x89, 0xc9, 0xb1, 0xed, 0x50, 0xca, 0x96, 0x6f, 0x1a, 0x7a, |
| 98 0xfe, 0x58, 0x5d, 0xec, 0x19, 0x4a, 0xf6, 0x35, 0x6a, 0x97, 0x14, 0x00, |
| 99 0x0e, 0xd0, 0x6b, 0xbb, 0xd5, 0x75, 0x55, 0x8b, 0x6e, 0x6b, 0x19, 0xa0, |
| 100 0xf8, 0x77, 0xd5, 0xa3}; |
| 101 |
| 102 CJS_GlobalData::CJS_GlobalData(CPDFDoc_Environment* pApp) { |
| 103 // IBaseAnnot* pBaseAnnot = IBaseAnnot::GetBaseAnnot(m_pApp); |
| 104 // ASSERT(pBaseAnnot != NULL); |
| 105 // |
| 106 // m_sFilePath = pBaseAnnot->GetUserPath(); |
| 107 m_sFilePath += SDK_JS_GLOBALDATA_FILENAME; |
| 108 |
| 109 LoadGlobalPersistentVariables(); |
| 110 } |
| 111 |
| 112 CJS_GlobalData::~CJS_GlobalData() { |
| 113 SaveGlobalPersisitentVariables(); |
| 114 |
| 115 for (int i = 0, sz = m_arrayGlobalData.GetSize(); i < sz; i++) |
| 116 delete m_arrayGlobalData.GetAt(i); |
| 117 |
| 118 m_arrayGlobalData.RemoveAll(); |
| 119 } |
| 120 |
| 121 int CJS_GlobalData::FindGlobalVariable(const FX_CHAR* propname) { |
| 122 ASSERT(propname != NULL); |
| 123 |
| 124 int nRet = -1; |
| 125 |
| 126 for (int i = 0, sz = m_arrayGlobalData.GetSize(); i < sz; i++) { |
| 127 CJS_GlobalData_Element* pTemp = m_arrayGlobalData.GetAt(i); |
| 128 if (pTemp->data.sKey[0] == *propname && pTemp->data.sKey == propname) { |
| 129 nRet = i; |
| 130 break; |
| 131 } |
| 132 } |
| 133 |
| 134 return nRet; |
| 135 } |
| 136 |
| 137 CJS_GlobalData_Element* CJS_GlobalData::GetGlobalVariable( |
| 138 const FX_CHAR* propname) { |
| 139 ASSERT(propname != NULL); |
| 140 |
| 141 int nFind = FindGlobalVariable(propname); |
| 142 if (nFind >= 0) |
| 143 return m_arrayGlobalData.GetAt(nFind); |
| 144 |
| 145 return NULL; |
| 146 } |
| 147 |
| 148 void CJS_GlobalData::SetGlobalVariableNumber(const FX_CHAR* propname, |
| 149 double dData) { |
| 150 ASSERT(propname != NULL); |
| 151 |
| 152 CFX_ByteString sPropName = propname; |
| 153 sPropName.TrimLeft(); |
| 154 sPropName.TrimRight(); |
| 155 if (sPropName.GetLength() == 0) |
| 156 return; |
| 157 |
| 158 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) { |
| 159 pData->data.nType = JS_GLOBALDATA_TYPE_NUMBER; |
| 160 pData->data.dData = dData; |
| 161 } else { |
| 162 CJS_GlobalData_Element* pNewData = new CJS_GlobalData_Element; |
| 163 pNewData->data.sKey = sPropName; |
| 164 pNewData->data.nType = JS_GLOBALDATA_TYPE_NUMBER; |
| 165 pNewData->data.dData = dData; |
| 166 m_arrayGlobalData.Add(pNewData); |
| 167 } |
| 168 } |
| 169 |
| 170 void CJS_GlobalData::SetGlobalVariableBoolean(const FX_CHAR* propname, |
| 171 bool bData) { |
| 172 ASSERT(propname != NULL); |
| 173 CFX_ByteString sPropName = propname; |
| 174 |
| 175 sPropName.TrimLeft(); |
| 176 sPropName.TrimRight(); |
| 177 |
| 178 if (sPropName.GetLength() == 0) |
| 179 return; |
| 180 |
| 181 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) { |
| 182 pData->data.nType = JS_GLOBALDATA_TYPE_BOOLEAN; |
| 183 pData->data.bData = bData; |
| 184 } else { |
| 185 CJS_GlobalData_Element* pNewData = new CJS_GlobalData_Element; |
| 186 pNewData->data.sKey = sPropName; |
| 187 pNewData->data.nType = JS_GLOBALDATA_TYPE_BOOLEAN; |
| 188 pNewData->data.bData = bData; |
| 189 |
| 190 m_arrayGlobalData.Add(pNewData); |
| 191 } |
| 192 } |
| 193 |
| 194 void CJS_GlobalData::SetGlobalVariableString(const FX_CHAR* propname, |
| 195 const CFX_ByteString& sData) { |
| 196 ASSERT(propname != NULL); |
| 197 CFX_ByteString sPropName = propname; |
| 198 |
| 199 sPropName.TrimLeft(); |
| 200 sPropName.TrimRight(); |
| 201 |
| 202 if (sPropName.GetLength() == 0) |
| 203 return; |
| 204 |
| 205 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) { |
| 206 pData->data.nType = JS_GLOBALDATA_TYPE_STRING; |
| 207 pData->data.sData = sData; |
| 208 } else { |
| 209 CJS_GlobalData_Element* pNewData = new CJS_GlobalData_Element; |
| 210 pNewData->data.sKey = sPropName; |
| 211 pNewData->data.nType = JS_GLOBALDATA_TYPE_STRING; |
| 212 pNewData->data.sData = sData; |
| 213 |
| 214 m_arrayGlobalData.Add(pNewData); |
| 215 } |
| 216 } |
| 217 |
| 218 void CJS_GlobalData::SetGlobalVariableObject( |
| 219 const FX_CHAR* propname, |
| 220 const CJS_GlobalVariableArray& array) { |
| 221 ASSERT(propname != NULL); |
| 222 CFX_ByteString sPropName = propname; |
| 223 |
| 224 sPropName.TrimLeft(); |
| 225 sPropName.TrimRight(); |
| 226 |
| 227 if (sPropName.GetLength() == 0) |
| 228 return; |
| 229 |
| 230 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) { |
| 231 pData->data.nType = JS_GLOBALDATA_TYPE_OBJECT; |
| 232 pData->data.objData.Copy(array); |
| 233 } else { |
| 234 CJS_GlobalData_Element* pNewData = new CJS_GlobalData_Element; |
| 235 pNewData->data.sKey = sPropName; |
| 236 pNewData->data.nType = JS_GLOBALDATA_TYPE_OBJECT; |
| 237 pNewData->data.objData.Copy(array); |
| 238 |
| 239 m_arrayGlobalData.Add(pNewData); |
| 240 } |
| 241 } |
| 242 |
| 243 void CJS_GlobalData::SetGlobalVariableNull(const FX_CHAR* propname) { |
| 244 ASSERT(propname != NULL); |
| 245 CFX_ByteString sPropName = propname; |
| 246 |
| 247 sPropName.TrimLeft(); |
| 248 sPropName.TrimRight(); |
| 249 |
| 250 if (sPropName.GetLength() == 0) |
| 251 return; |
| 252 |
| 253 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) { |
| 254 pData->data.nType = JS_GLOBALDATA_TYPE_NULL; |
| 255 } else { |
| 256 CJS_GlobalData_Element* pNewData = new CJS_GlobalData_Element; |
| 257 pNewData->data.sKey = sPropName; |
| 258 pNewData->data.nType = JS_GLOBALDATA_TYPE_NULL; |
| 259 |
| 260 m_arrayGlobalData.Add(pNewData); |
| 261 } |
| 262 } |
| 263 |
| 264 FX_BOOL CJS_GlobalData::SetGlobalVariablePersistent(const FX_CHAR* propname, |
| 265 FX_BOOL bPersistent) { |
| 266 ASSERT(propname != NULL); |
| 267 CFX_ByteString sPropName = propname; |
| 268 |
| 269 sPropName.TrimLeft(); |
| 270 sPropName.TrimRight(); |
| 271 |
| 272 if (sPropName.GetLength() == 0) |
| 273 return FALSE; |
| 274 |
| 275 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) { |
| 276 pData->bPersistent = bPersistent; |
| 277 return TRUE; |
| 278 } |
| 279 |
| 280 return FALSE; |
| 281 } |
| 282 |
| 283 FX_BOOL CJS_GlobalData::DeleteGlobalVariable(const FX_CHAR* propname) { |
| 284 ASSERT(propname != NULL); |
| 285 CFX_ByteString sPropName = propname; |
| 286 |
| 287 sPropName.TrimLeft(); |
| 288 sPropName.TrimRight(); |
| 289 |
| 290 if (sPropName.GetLength() == 0) |
| 291 return FALSE; |
| 292 |
| 293 int nFind = FindGlobalVariable(sPropName); |
| 294 |
| 295 if (nFind >= 0) { |
| 296 delete m_arrayGlobalData.GetAt(nFind); |
| 297 m_arrayGlobalData.RemoveAt(nFind); |
| 298 return TRUE; |
| 299 } |
| 300 |
| 301 return FALSE; |
| 302 } |
| 303 |
| 304 int32_t CJS_GlobalData::GetSize() const { |
| 305 return m_arrayGlobalData.GetSize(); |
| 306 } |
| 307 |
| 308 CJS_GlobalData_Element* CJS_GlobalData::GetAt(int index) const { |
| 309 return m_arrayGlobalData.GetAt(index); |
| 310 } |
| 311 |
| 312 void CJS_GlobalData::LoadGlobalPersistentVariables() { |
| 313 uint8_t* pBuffer = NULL; |
| 314 int32_t nLength = 0; |
| 315 |
| 316 LoadFileBuffer(m_sFilePath.c_str(), pBuffer, nLength); |
| 317 CRYPT_ArcFourCryptBlock(pBuffer, nLength, JS_RC4KEY, sizeof(JS_RC4KEY)); |
| 318 |
| 319 if (pBuffer) { |
| 320 uint8_t* p = pBuffer; |
| 321 FX_WORD wType = *((FX_WORD*)p); |
| 322 p += sizeof(FX_WORD); |
| 323 |
| 324 // FX_WORD wTemp = (FX_WORD)(('X' << 8) | 'F'); |
| 325 |
| 326 if (wType == (FX_WORD)(('X' << 8) | 'F')) { |
| 327 FX_WORD wVersion = *((FX_WORD*)p); |
| 328 p += sizeof(FX_WORD); |
| 329 |
| 330 ASSERT(wVersion <= 2); |
| 331 |
| 332 FX_DWORD dwCount = *((FX_DWORD*)p); |
| 333 p += sizeof(FX_DWORD); |
| 334 |
| 335 FX_DWORD dwSize = *((FX_DWORD*)p); |
| 336 p += sizeof(FX_DWORD); |
| 337 |
| 338 if (dwSize == nLength - sizeof(FX_WORD) * 2 - sizeof(FX_DWORD) * 2) { |
| 339 for (int32_t i = 0, sz = dwCount; i < sz; i++) { |
| 340 if (p > pBuffer + nLength) |
| 341 break; |
| 342 |
| 343 FX_DWORD dwNameLen = *((FX_DWORD*)p); |
| 344 p += sizeof(FX_DWORD); |
| 345 |
| 346 if (p + dwNameLen > pBuffer + nLength) |
| 347 break; |
| 348 |
| 349 CFX_ByteString sEntry = CFX_ByteString(p, dwNameLen); |
| 350 p += sizeof(char) * dwNameLen; |
| 351 |
| 352 FX_WORD wDataType = *((FX_WORD*)p); |
| 353 p += sizeof(FX_WORD); |
| 354 |
| 355 switch (wDataType) { |
| 356 case JS_GLOBALDATA_TYPE_NUMBER: { |
| 357 double dData = 0; |
| 358 switch (wVersion) { |
| 359 case 1: { |
| 360 FX_DWORD dwData = *((FX_DWORD*)p); |
| 361 p += sizeof(FX_DWORD); |
| 362 dData = dwData; |
| 363 } break; |
| 364 case 2: { |
| 365 dData = *((double*)p); |
| 366 p += sizeof(double); |
| 367 } break; |
| 368 } |
| 369 SetGlobalVariableNumber(sEntry, dData); |
| 370 SetGlobalVariablePersistent(sEntry, TRUE); |
| 371 } break; |
| 372 case JS_GLOBALDATA_TYPE_BOOLEAN: { |
| 373 FX_WORD wData = *((FX_WORD*)p); |
| 374 p += sizeof(FX_WORD); |
| 375 SetGlobalVariableBoolean(sEntry, (bool)(wData == 1)); |
| 376 SetGlobalVariablePersistent(sEntry, TRUE); |
| 377 } break; |
| 378 case JS_GLOBALDATA_TYPE_STRING: { |
| 379 FX_DWORD dwLength = *((FX_DWORD*)p); |
| 380 p += sizeof(FX_DWORD); |
| 381 |
| 382 if (p + dwLength > pBuffer + nLength) |
| 383 break; |
| 384 |
| 385 SetGlobalVariableString(sEntry, CFX_ByteString(p, dwLength)); |
| 386 SetGlobalVariablePersistent(sEntry, TRUE); |
| 387 p += sizeof(char) * dwLength; |
| 388 } break; |
| 389 case JS_GLOBALDATA_TYPE_NULL: { |
| 390 SetGlobalVariableNull(sEntry); |
| 391 SetGlobalVariablePersistent(sEntry, TRUE); |
42 } | 392 } |
43 break; | 393 } |
44 case JS_GLOBALDATA_TYPE_BOOLEAN: | |
45 { | |
46 CJS_KeyValue* pNewObjData = new CJS_KeyValue; | |
47 pNewObjData->sKey = pOldObjData->sKey; | |
48 pNewObjData->nType = pOldObjData->nType; | |
49 pNewObjData->bData = pOldObjData->bData; | |
50 Add(pNewObjData); | |
51 } | |
52 break; | |
53 case JS_GLOBALDATA_TYPE_STRING: | |
54 { | |
55 CJS_KeyValue* pNewObjData = new CJS_KeyValue; | |
56 pNewObjData->sKey = pOldObjData->sKey; | |
57 pNewObjData->nType = pOldObjData->nType; | |
58 pNewObjData->sData = pOldObjData->sData; | |
59 Add(pNewObjData); | |
60 } | |
61 break; | |
62 case JS_GLOBALDATA_TYPE_OBJECT: | |
63 { | |
64 CJS_KeyValue* pNewObjData = new CJS_KeyValue; | |
65 pNewObjData->sKey = pOldObjData->sKey; | |
66 pNewObjData->nType = pOldObjData->nType; | |
67 pNewObjData->objData.Copy(pOldObjData->objData); | |
68 Add(pNewObjData); | |
69 } | |
70 case JS_GLOBALDATA_TYPE_NULL: | |
71 { | |
72 CJS_KeyValue* pNewObjData = new CJS_KeyValue; | |
73 pNewObjData->sKey = pOldObjData->sKey; | |
74 pNewObjData->nType = pOldObjData->nType; | |
75 Add(pNewObjData); | |
76 } | |
77 } | 394 } |
| 395 } |
78 } | 396 } |
79 } | 397 FX_Free(pBuffer); |
80 | 398 } |
81 void CJS_GlobalVariableArray::Add(CJS_KeyValue* p) | |
82 { | |
83 array.Add(p); | |
84 } | |
85 | |
86 int CJS_GlobalVariableArray::Count() const | |
87 { | |
88 return array.GetSize(); | |
89 } | |
90 | |
91 CJS_KeyValue* CJS_GlobalVariableArray::GetAt(int index) const | |
92 { | |
93 return array.GetAt(index); | |
94 } | |
95 | |
96 void CJS_GlobalVariableArray::Empty() | |
97 { | |
98 for (int i=0,sz=array.GetSize(); i<sz; i++) | |
99 delete array.GetAt(i); | |
100 array.RemoveAll(); | |
101 } | |
102 | |
103 /* -------------------------- CJS_GlobalData -------------------------- */ | |
104 | |
105 #define READER_JS_GLOBALDATA_FILENAME L"Reader_JsGlobal.Data" | |
106 #define PHANTOM_JS_GLOBALDATA_FILENAME L"Phantom_JsGlobal.Data" | |
107 #define SDK_JS_GLOBALDATA_FILENAME L"SDK_JsGlobal.Data" | |
108 | |
109 static const uint8_t JS_RC4KEY[] = {0x19,0xa8,0xe8,0x01,0xf6,0xa8,0xb6,0x4d,0x82
,0x04, | |
110 0x45,0x6d,0xb4,0xcf,0xd7,0x77,0x67,0xf9,0x75,0x9f, | |
111 0xf0,0xe0,0x1e,0x51,0xee,0x46,0xfd,0x0b,0xc9,0x93, | |
112 0x25,0x55,0x4a,0xee,0xe0,0x16,0xd0,0xdf,0x8c,0xfa, | |
113 0x2a,0xa9,0x49,0xfd,0x97,0x1c,0x0e,0x22,0x13,0x28, | |
114 0x7c,0xaf,0xc4,0xfc,0x9c,0x12,0x65,0x8c,0x4e,0x5b, | |
115 0x04,0x75,0x89,0xc9,0xb1,0xed,0x50,0xca,0x96,0x6f, | |
116 0x1a,0x7a,0xfe,0x58,0x5d,0xec,0x19,0x4a,0xf6,0x35, | |
117 0x6a,0x97,0x14,0x00,0x0e,0xd0,0x6b,0xbb,0xd5,0x75, | |
118 0x55,0x8b,0x6e,0x6b,0x19,0xa0,0xf8,0x77,0xd5,0xa3 | |
119 }; | |
120 | |
121 CJS_GlobalData::CJS_GlobalData(CPDFDoc_Environment* pApp) | |
122 { | |
123 // IBaseAnnot* pBaseAnnot = IBaseAnnot::GetBaseAnnot(m_pApp); | |
124 // ASSERT(pBaseAnnot != NULL); | |
125 // | |
126 // m_sFilePath = pBaseAnnot->GetUserPath(); | |
127 m_sFilePath += SDK_JS_GLOBALDATA_FILENAME; | |
128 | |
129 LoadGlobalPersistentVariables(); | |
130 } | |
131 | |
132 CJS_GlobalData::~CJS_GlobalData() | |
133 { | |
134 SaveGlobalPersisitentVariables(); | |
135 | |
136 for (int i=0,sz=m_arrayGlobalData.GetSize(); i<sz; i++) | |
137 delete m_arrayGlobalData.GetAt(i); | |
138 | |
139 m_arrayGlobalData.RemoveAll(); | |
140 } | |
141 | |
142 int CJS_GlobalData::FindGlobalVariable(const FX_CHAR* propname) | |
143 { | |
144 ASSERT(propname != NULL); | |
145 | |
146 int nRet = -1; | |
147 | |
148 for (int i=0,sz=m_arrayGlobalData.GetSize(); i<sz; i++) | |
149 { | |
150 CJS_GlobalData_Element* pTemp = m_arrayGlobalData.GetAt(i); | |
151 if (pTemp->data.sKey[0] == *propname && pTemp->data.sKey == propname) | |
152 { | |
153 nRet = i; | |
154 break; | |
155 } | |
156 } | |
157 | |
158 return nRet; | |
159 } | |
160 | |
161 CJS_GlobalData_Element* CJS_GlobalData::GetGlobalVariable(const FX_CHAR* propnam
e) | |
162 { | |
163 ASSERT(propname != NULL); | |
164 | |
165 int nFind = FindGlobalVariable(propname); | |
166 if (nFind >= 0) | |
167 return m_arrayGlobalData.GetAt(nFind); | |
168 | |
169 return NULL; | |
170 } | |
171 | |
172 void CJS_GlobalData::SetGlobalVariableNumber(const FX_CHAR* propname, double dDa
ta) | |
173 { | |
174 ASSERT(propname != NULL); | |
175 | |
176 CFX_ByteString sPropName = propname; | |
177 sPropName.TrimLeft(); | |
178 sPropName.TrimRight(); | |
179 if (sPropName.GetLength() == 0) | |
180 return; | |
181 | |
182 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) | |
183 { | |
184 pData->data.nType = JS_GLOBALDATA_TYPE_NUMBER; | |
185 pData->data.dData = dData; | |
186 } | |
187 else | |
188 { | |
189 CJS_GlobalData_Element* pNewData = new CJS_GlobalData_Element; | |
190 pNewData->data.sKey = sPropName; | |
191 pNewData->data.nType = JS_GLOBALDATA_TYPE_NUMBER; | |
192 pNewData->data.dData = dData; | |
193 m_arrayGlobalData.Add(pNewData); | |
194 } | |
195 } | |
196 | |
197 void CJS_GlobalData::SetGlobalVariableBoolean(const FX_CHAR* propname, bool bDat
a) | |
198 { | |
199 ASSERT(propname != NULL); | |
200 CFX_ByteString sPropName = propname; | |
201 | |
202 sPropName.TrimLeft(); | |
203 sPropName.TrimRight(); | |
204 | |
205 if (sPropName.GetLength() == 0) return; | |
206 | |
207 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) | |
208 { | |
209 pData->data.nType = JS_GLOBALDATA_TYPE_BOOLEAN; | |
210 pData->data.bData = bData; | |
211 } | |
212 else | |
213 { | |
214 CJS_GlobalData_Element* pNewData = new CJS_GlobalData_Element; | |
215 pNewData->data.sKey = sPropName; | |
216 pNewData->data.nType = JS_GLOBALDATA_TYPE_BOOLEAN; | |
217 pNewData->data.bData = bData; | |
218 | |
219 m_arrayGlobalData.Add(pNewData); | |
220 } | |
221 } | |
222 | |
223 void CJS_GlobalData::SetGlobalVariableString(const FX_CHAR* propname, const CFX_
ByteString& sData) | |
224 { | |
225 ASSERT(propname != NULL); | |
226 CFX_ByteString sPropName = propname; | |
227 | |
228 sPropName.TrimLeft(); | |
229 sPropName.TrimRight(); | |
230 | |
231 if (sPropName.GetLength() == 0) return; | |
232 | |
233 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) | |
234 { | |
235 pData->data.nType = JS_GLOBALDATA_TYPE_STRING; | |
236 pData->data.sData = sData; | |
237 } | |
238 else | |
239 { | |
240 CJS_GlobalData_Element* pNewData = new CJS_GlobalData_Element; | |
241 pNewData->data.sKey = sPropName; | |
242 pNewData->data.nType = JS_GLOBALDATA_TYPE_STRING; | |
243 pNewData->data.sData = sData; | |
244 | |
245 m_arrayGlobalData.Add(pNewData); | |
246 } | |
247 } | |
248 | |
249 void CJS_GlobalData::SetGlobalVariableObject(const FX_CHAR* propname, const CJS_
GlobalVariableArray& array) | |
250 { | |
251 ASSERT(propname != NULL); | |
252 CFX_ByteString sPropName = propname; | |
253 | |
254 sPropName.TrimLeft(); | |
255 sPropName.TrimRight(); | |
256 | |
257 if (sPropName.GetLength() == 0) return; | |
258 | |
259 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) | |
260 { | |
261 pData->data.nType = JS_GLOBALDATA_TYPE_OBJECT; | |
262 pData->data.objData.Copy(array); | |
263 } | |
264 else | |
265 { | |
266 CJS_GlobalData_Element* pNewData = new CJS_GlobalData_Element; | |
267 pNewData->data.sKey = sPropName; | |
268 pNewData->data.nType = JS_GLOBALDATA_TYPE_OBJECT; | |
269 pNewData->data.objData.Copy(array); | |
270 | |
271 m_arrayGlobalData.Add(pNewData); | |
272 } | |
273 } | |
274 | |
275 void CJS_GlobalData::SetGlobalVariableNull(const FX_CHAR* propname) | |
276 { | |
277 ASSERT(propname != NULL); | |
278 CFX_ByteString sPropName = propname; | |
279 | |
280 sPropName.TrimLeft(); | |
281 sPropName.TrimRight(); | |
282 | |
283 if (sPropName.GetLength() == 0) return; | |
284 | |
285 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) | |
286 { | |
287 pData->data.nType = JS_GLOBALDATA_TYPE_NULL; | |
288 } | |
289 else | |
290 { | |
291 CJS_GlobalData_Element* pNewData = new CJS_GlobalData_Element; | |
292 pNewData->data.sKey = sPropName; | |
293 pNewData->data.nType = JS_GLOBALDATA_TYPE_NULL; | |
294 | |
295 m_arrayGlobalData.Add(pNewData); | |
296 } | |
297 } | |
298 | |
299 FX_BOOL CJS_GlobalData::SetGlobalVariablePersistent(const FX_CHAR* propname, FX_
BOOL bPersistent) | |
300 { | |
301 ASSERT(propname != NULL); | |
302 CFX_ByteString sPropName = propname; | |
303 | |
304 sPropName.TrimLeft(); | |
305 sPropName.TrimRight(); | |
306 | |
307 if (sPropName.GetLength() == 0) return FALSE; | |
308 | |
309 if (CJS_GlobalData_Element* pData = GetGlobalVariable(sPropName)) | |
310 { | |
311 pData->bPersistent = bPersistent; | |
312 return TRUE; | |
313 } | |
314 | |
315 return FALSE; | |
316 } | |
317 | |
318 FX_BOOL CJS_GlobalData::DeleteGlobalVariable(const FX_CHAR* propname) | |
319 { | |
320 ASSERT(propname != NULL); | |
321 CFX_ByteString sPropName = propname; | |
322 | |
323 sPropName.TrimLeft(); | |
324 sPropName.TrimRight(); | |
325 | |
326 if (sPropName.GetLength() == 0) return FALSE; | |
327 | |
328 int nFind = FindGlobalVariable(sPropName); | |
329 | |
330 if (nFind >= 0) | |
331 { | |
332 delete m_arrayGlobalData.GetAt(nFind); | |
333 m_arrayGlobalData.RemoveAt(nFind); | |
334 return TRUE; | |
335 } | |
336 | |
337 return FALSE; | |
338 } | |
339 | |
340 int32_t CJS_GlobalData::GetSize() const | |
341 { | |
342 return m_arrayGlobalData.GetSize(); | |
343 } | |
344 | |
345 CJS_GlobalData_Element* CJS_GlobalData::GetAt(int index) const | |
346 { | |
347 return m_arrayGlobalData.GetAt(index); | |
348 } | |
349 | |
350 void CJS_GlobalData::LoadGlobalPersistentVariables() | |
351 { | |
352 uint8_t* pBuffer = NULL; | |
353 int32_t nLength = 0; | |
354 | |
355 LoadFileBuffer(m_sFilePath.c_str(), pBuffer, nLength); | |
356 CRYPT_ArcFourCryptBlock(pBuffer, nLength, JS_RC4KEY, sizeof(JS_RC4KEY)); | |
357 | |
358 if (pBuffer) | |
359 { | |
360 uint8_t* p = pBuffer; | |
361 FX_WORD wType = *((FX_WORD*)p); | |
362 p += sizeof(FX_WORD); | |
363 | |
364 //FX_WORD wTemp = (FX_WORD)(('X' << 8) | 'F'); | |
365 | |
366 if (wType == (FX_WORD)(('X' << 8) | 'F')) | |
367 { | |
368 FX_WORD wVersion = *((FX_WORD*)p); | |
369 p += sizeof(FX_WORD); | |
370 | |
371 ASSERT(wVersion <= 2); | |
372 | |
373 FX_DWORD dwCount = *((FX_DWORD*)p); | |
374 p += sizeof(FX_DWORD); | |
375 | |
376 FX_DWORD dwSize = *((FX_DWORD*)p); | |
377 p += sizeof(FX_DWORD); | |
378 | |
379 if (dwSize == nLength - sizeof(FX_WORD) * 2 - sizeof(FX_DWORD)* 2) | |
380 { | |
381 for (int32_t i=0,sz=dwCount; i<sz; i++) | |
382 { | |
383 if (p > pBuffer + nLength) | |
384 break; | |
385 | |
386 FX_DWORD dwNameLen = *((FX_DWORD*)p); | |
387 p += sizeof(FX_DWORD); | |
388 | |
389 if (p + dwNameLen > pBuffer + nLength) | |
390 break; | |
391 | |
392 CFX_ByteString sEntry = CFX_ByteString(p, dwNameLen); | |
393 p += sizeof(char) * dwNameLen; | |
394 | |
395 FX_WORD wDataType = *((FX_WORD*)p); | |
396 p += sizeof(FX_WORD); | |
397 | |
398 switch (wDataType) | |
399 { | |
400 case JS_GLOBALDATA_TYPE_NUMBER: | |
401 { | |
402 double dData = 0; | |
403 switch (wVersion) | |
404 { | |
405 case 1: | |
406 { | |
407 FX_DWORD dwData = *((FX_DWORD*)p); | |
408 p += sizeof(FX_DWORD); | |
409 dData = dwData; | |
410 } | |
411 break; | |
412 case 2: | |
413 { | |
414 dData = *((double*)p); | |
415 p += sizeof(double); | |
416 } | |
417 break; | |
418 } | |
419 SetGlobalVariableNumber(sEntry, dData); | |
420 SetGlobalVariablePersistent(sEntry, TRUE); | |
421 } | |
422 break; | |
423 case JS_GLOBALDATA_TYPE_BOOLEAN: | |
424 { | |
425 FX_WORD wData = *((FX_WORD*)p); | |
426 p += sizeof(FX_WORD); | |
427 SetGlobalVariableBoolean(sEntry, (bool)(wData == 1))
; | |
428 SetGlobalVariablePersistent(sEntry, TRUE); | |
429 } | |
430 break; | |
431 case JS_GLOBALDATA_TYPE_STRING: | |
432 { | |
433 FX_DWORD dwLength = *((FX_DWORD*)p); | |
434 p += sizeof(FX_DWORD); | |
435 | |
436 if (p + dwLength > pBuffer + nLength) | |
437 break; | |
438 | |
439 SetGlobalVariableString(sEntry, CFX_ByteString(p, dw
Length)); | |
440 SetGlobalVariablePersistent(sEntry, TRUE); | |
441 p += sizeof(char) * dwLength; | |
442 } | |
443 break; | |
444 case JS_GLOBALDATA_TYPE_NULL: | |
445 { | |
446 SetGlobalVariableNull(sEntry); | |
447 SetGlobalVariablePersistent(sEntry, TRUE); | |
448 } | |
449 } | |
450 } | |
451 } | |
452 } | |
453 FX_Free(pBuffer); | |
454 } | |
455 } | 399 } |
456 | 400 |
457 /* | 401 /* |
458 struct js_global_datafile_header | 402 struct js_global_datafile_header |
459 { | 403 { |
460 FX_WORD type; //FX ('X' << 8) | 'F' | 404 FX_WORD type; //FX ('X' << 8) | 'F' |
461 FX_WORD version; //1.0 | 405 FX_WORD version; //1.0 |
462 FX_DWORD datacount; | 406 FX_DWORD datacount; |
463 }; | 407 }; |
464 struct js_global_datafile_data | 408 struct js_global_datafile_data |
465 { | 409 { |
466 FX_WORD type; | 410 FX_WORD type; |
467 FX_DWORD nData; | 411 FX_DWORD nData; |
468 FX_WORD bData; | 412 FX_WORD bData; |
469 FX_DWORD nStrLen; | 413 FX_DWORD nStrLen; |
470 char* pStr; | 414 char* pStr; |
471 }; | 415 }; |
472 */ | 416 */ |
473 | 417 |
474 void CJS_GlobalData::SaveGlobalPersisitentVariables() | 418 void CJS_GlobalData::SaveGlobalPersisitentVariables() { |
475 { | 419 FX_DWORD nCount = 0; |
476 FX_DWORD nCount = 0; | 420 CFX_BinaryBuf sData; |
477 CFX_BinaryBuf sData; | |
478 | 421 |
479 for (int i=0,sz=m_arrayGlobalData.GetSize(); i<sz; i++) | 422 for (int i = 0, sz = m_arrayGlobalData.GetSize(); i < sz; i++) { |
480 { | 423 CJS_GlobalData_Element* pElement = m_arrayGlobalData.GetAt(i); |
481 CJS_GlobalData_Element* pElement = m_arrayGlobalData.GetAt(i); | 424 ASSERT(pElement != NULL); |
482 ASSERT(pElement != NULL); | |
483 | 425 |
484 if (pElement->bPersistent) | 426 if (pElement->bPersistent) { |
485 { | 427 CFX_BinaryBuf sElement; |
486 CFX_BinaryBuf sElement; | 428 MakeByteString(pElement->data.sKey, &pElement->data, sElement); |
487 MakeByteString(pElement->data.sKey, &pElement->data, sElement); | |
488 | 429 |
489 if (sData.GetSize() + sElement.GetSize() > JS_MAXGLOBALDATA) | 430 if (sData.GetSize() + sElement.GetSize() > JS_MAXGLOBALDATA) |
490 break; | 431 break; |
491 | 432 |
492 sData.AppendBlock(sElement.GetBuffer(), sElement.GetSize()); | 433 sData.AppendBlock(sElement.GetBuffer(), sElement.GetSize()); |
493 nCount++; | 434 nCount++; |
494 } | |
495 } | 435 } |
| 436 } |
496 | 437 |
497 CFX_BinaryBuf sFile; | 438 CFX_BinaryBuf sFile; |
498 | 439 |
499 FX_WORD wType = (FX_WORD)(('X' << 8) | 'F'); | 440 FX_WORD wType = (FX_WORD)(('X' << 8) | 'F'); |
500 sFile.AppendBlock(&wType, sizeof(FX_WORD)); | 441 sFile.AppendBlock(&wType, sizeof(FX_WORD)); |
501 FX_WORD wVersion = 2; | 442 FX_WORD wVersion = 2; |
502 sFile.AppendBlock(&wVersion, sizeof(FX_WORD)); | 443 sFile.AppendBlock(&wVersion, sizeof(FX_WORD)); |
503 sFile.AppendBlock(&nCount, sizeof(FX_DWORD)); | 444 sFile.AppendBlock(&nCount, sizeof(FX_DWORD)); |
504 FX_DWORD dwSize = sData.GetSize(); | 445 FX_DWORD dwSize = sData.GetSize(); |
505 sFile.AppendBlock(&dwSize, sizeof(FX_DWORD)); | 446 sFile.AppendBlock(&dwSize, sizeof(FX_DWORD)); |
506 | 447 |
507 sFile.AppendBlock(sData.GetBuffer(), sData.GetSize()); | 448 sFile.AppendBlock(sData.GetBuffer(), sData.GetSize()); |
508 | 449 |
509 CRYPT_ArcFourCryptBlock(sFile.GetBuffer(), sFile.GetSize(), JS_RC4KEY, sizeo
f(JS_RC4KEY)); | 450 CRYPT_ArcFourCryptBlock(sFile.GetBuffer(), sFile.GetSize(), JS_RC4KEY, |
510 WriteFileBuffer(m_sFilePath.c_str(), (const FX_CHAR*)sFile.GetBuffer(), sFil
e.GetSize()); | 451 sizeof(JS_RC4KEY)); |
| 452 WriteFileBuffer(m_sFilePath.c_str(), (const FX_CHAR*)sFile.GetBuffer(), |
| 453 sFile.GetSize()); |
511 } | 454 } |
512 | 455 |
513 void CJS_GlobalData::LoadFileBuffer(const FX_WCHAR* sFilePath, uint8_t*& pBuffer
, int32_t& nLength) | 456 void CJS_GlobalData::LoadFileBuffer(const FX_WCHAR* sFilePath, |
514 { | 457 uint8_t*& pBuffer, |
515 //UnSupport. | 458 int32_t& nLength) { |
| 459 // UnSupport. |
516 } | 460 } |
517 | 461 |
518 void CJS_GlobalData::WriteFileBuffer(const FX_WCHAR* sFilePath, const FX_CHAR* p
Buffer, int32_t nLength) | 462 void CJS_GlobalData::WriteFileBuffer(const FX_WCHAR* sFilePath, |
519 { | 463 const FX_CHAR* pBuffer, |
520 //UnSupport. | 464 int32_t nLength) { |
| 465 // UnSupport. |
521 } | 466 } |
522 | 467 |
523 void CJS_GlobalData::MakeByteString(const CFX_ByteString& name, CJS_KeyValue* pD
ata, CFX_BinaryBuf& sData) | 468 void CJS_GlobalData::MakeByteString(const CFX_ByteString& name, |
524 { | 469 CJS_KeyValue* pData, |
525 FX_WORD wType = (FX_WORD)pData->nType; | 470 CFX_BinaryBuf& sData) { |
526 switch (wType) | 471 FX_WORD wType = (FX_WORD)pData->nType; |
527 { | 472 switch (wType) { |
528 case JS_GLOBALDATA_TYPE_NUMBER: | 473 case JS_GLOBALDATA_TYPE_NUMBER: { |
529 { | 474 FX_DWORD dwNameLen = (FX_DWORD)name.GetLength(); |
530 FX_DWORD dwNameLen = (FX_DWORD)name.GetLength(); | 475 sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD)); |
531 sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD)); | 476 sData.AppendString(name); |
532 sData.AppendString(name); | 477 sData.AppendBlock(&wType, sizeof(FX_WORD)); |
533 sData.AppendBlock(&wType, sizeof(FX_WORD)); | |
534 | 478 |
535 double dData = pData->dData; | 479 double dData = pData->dData; |
536 sData.AppendBlock(&dData, sizeof(double)); | 480 sData.AppendBlock(&dData, sizeof(double)); |
537 } | 481 } break; |
538 break; | 482 case JS_GLOBALDATA_TYPE_BOOLEAN: { |
539 case JS_GLOBALDATA_TYPE_BOOLEAN: | 483 FX_DWORD dwNameLen = (FX_DWORD)name.GetLength(); |
540 { | 484 sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD)); |
541 FX_DWORD dwNameLen = (FX_DWORD)name.GetLength(); | 485 sData.AppendString(name); |
542 sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD)); | 486 sData.AppendBlock(&wType, sizeof(FX_WORD)); |
543 sData.AppendString(name); | |
544 sData.AppendBlock(&wType, sizeof(FX_WORD)); | |
545 | 487 |
546 FX_WORD wData = (FX_WORD)pData->bData; | 488 FX_WORD wData = (FX_WORD)pData->bData; |
547 sData.AppendBlock(&wData, sizeof(FX_WORD)); | 489 sData.AppendBlock(&wData, sizeof(FX_WORD)); |
548 } | 490 } break; |
549 break; | 491 case JS_GLOBALDATA_TYPE_STRING: { |
550 case JS_GLOBALDATA_TYPE_STRING: | 492 FX_DWORD dwNameLen = (FX_DWORD)name.GetLength(); |
551 { | 493 sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD)); |
552 FX_DWORD dwNameLen = (FX_DWORD)name.GetLength(); | 494 sData.AppendString(name); |
553 sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD)); | 495 sData.AppendBlock(&wType, sizeof(FX_WORD)); |
554 sData.AppendString(name); | |
555 sData.AppendBlock(&wType, sizeof(FX_WORD)); | |
556 | 496 |
557 FX_DWORD dwDataLen = (FX_DWORD)pData->sData.GetLength(); | 497 FX_DWORD dwDataLen = (FX_DWORD)pData->sData.GetLength(); |
558 sData.AppendBlock(&dwDataLen, sizeof(FX_DWORD)); | 498 sData.AppendBlock(&dwDataLen, sizeof(FX_DWORD)); |
559 sData.AppendString(pData->sData); | 499 sData.AppendString(pData->sData); |
560 } | 500 } break; |
561 break; | 501 case JS_GLOBALDATA_TYPE_NULL: { |
562 case JS_GLOBALDATA_TYPE_NULL: | 502 FX_DWORD dwNameLen = (FX_DWORD)name.GetLength(); |
563 { | 503 sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD)); |
564 FX_DWORD dwNameLen = (FX_DWORD)name.GetLength(); | 504 sData.AppendString(name); |
565 sData.AppendBlock(&dwNameLen, sizeof(FX_DWORD)); | 505 sData.AppendBlock(&wType, sizeof(FX_DWORD)); |
566 sData.AppendString(name); | 506 } break; |
567 sData.AppendBlock(&wType, sizeof(FX_DWORD)); | |
568 } | |
569 break; | |
570 default: | 507 default: |
571 break; | 508 break; |
572 } | 509 } |
573 } | 510 } |
574 | |
OLD | NEW |