1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ 2 /* ***** BEGIN LICENSE BLOCK ***** 3 * Version: MPL 1.1/GPL 2.0/LGPL 2.1 4 * 5 * The contents of this file are subject to the Mozilla Public License Version 6 * 1.1 (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * http://www.mozilla.org/MPL/ 9 * 10 * Software distributed under the License is distributed on an "AS IS" basis, 11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 12 * for the specific language governing rights and limitations under the 13 * License. 14 * 15 * The Original Code is mozilla.org code. 16 * 17 * The Initial Developer of the Original Code is 18 * Netscape Communications Corporation. 19 * Portions created by the Initial Developer are Copyright (C) 1998 20 * the Initial Developer. All Rights Reserved. 21 * 22 * Contributor(s): 23 * 24 * Alternatively, the contents of this file may be used under the terms of 25 * either the GNU General Public License Version 2 or later (the "GPL"), or 26 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), 27 * in which case the provisions of the GPL or the LGPL are applicable instead 28 * of those above. If you wish to allow use of your version of this file only 29 * under the terms of either the GPL or the LGPL, and not to allow others to 30 * use your version of this file under the terms of the MPL, indicate your 31 * decision by deleting the provisions above and replace them with the notice 32 * and other provisions required by the GPL or the LGPL. If you do not delete 33 * the provisions above, a recipient may use your version of this file under 34 * the terms of any one of the MPL, the GPL or the LGPL. 35 * 36 * ***** END LICENSE BLOCK ***** */ 37 38 #include <string> 39 #include <vector> 40 #include <errno.h> 41 42 43 #include "xp.h" 44 45 #include "format.h" 46 #include "logger.h" 47 48 extern Logger * logger; 49 50 //////////////////////////////////////////////////////////////////////////////// 51 // From Google Chrome's string_util.cc 52 53 // It's possible for functions that use a va_list, such as StringPrintf, to 54 // invalidate the data in it upon use. The fix is to make a copy of the 55 // structure before using it and use that copy instead. va_copy is provided 56 // for this purpose. MSVC does not provide va_copy, so define an 57 // implementation here. It is not guaranteed that assignment is a copy, so the 58 // StringUtil.__GNUC__ unit test tests this capability. 59 #if defined(COMPILER_GCC) 60 #define GG_VA_COPY(a, b) (va_copy(a, b)) 61 #elif defined(_MSC_VER) 62 #define GG_VA_COPY(a, b) (a = b) 63 #endif 64 65 66 // The arraysize(arr) macro returns the # of elements in an array arr. 67 // The expression is a compile-time constant, and therefore can be 68 // used in defining new arrays, for example. If you use arraysize on 69 // a pointer by mistake, you will get a compile-time error. 70 // 71 // One caveat is that arraysize() doesn't accept any array of an 72 // anonymous type or a type defined inside a function. In these rare 73 // cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below. This is 74 // due to a limitation in C++'s template system. The limitation might 75 // eventually be removed, but it hasn't happened yet. 76 77 // This template function declaration is used in defining arraysize. 78 // Note that the function doesn't need an implementation, as we only 79 // use its type. 80 template <typename T, size_t N> 81 char (&ArraySizeHelper(T (&array)[N]))[N]; 82 83 // That gcc wants both of these prototypes seems mysterious. VC, for 84 // its part, can't decide which to use (another mystery). Matching of 85 // template overloads: the final frontier. 86 #ifndef _MSC_VER 87 template <typename T, size_t N> 88 char (&ArraySizeHelper(const T (&array)[N]))[N]; 89 #endif 90 91 #define arraysize(array) (sizeof(ArraySizeHelper(array))) 92 93 #if defined(_WIN32) 94 inline int vsnprintf(char* buffer, size_t size, 95 const char* format, va_list arguments) { 96 int length = vsnprintf_s(buffer, size, size - 1, format, arguments); 97 if (length < 0) 98 return _vscprintf(format, arguments); 99 return length; 100 } 101 #else 102 inline int vsnprintf(char* buffer, size_t size, 103 const char* format, va_list arguments) { 104 return ::vsnprintf(buffer, size, format, arguments); 105 } 106 #endif 107 108 109 // Templatized backend for StringPrintF/StringAppendF. This does not finalize 110 // the va_list, the caller is expected to do that. 111 template <class StringType> 112 static void StringAppendVT(StringType* dst, 113 const typename StringType::value_type* format, 114 va_list ap) { 115 // First try with a small fixed size buffer. 116 // This buffer size should be kept in sync with StringUtilTest.GrowBoundary 117 // and StringUtilTest.StringPrintfBounds. 118 typename StringType::value_type stack_buf[1024]; 119 120 va_list ap_copy; 121 GG_VA_COPY(ap_copy, ap); 122 123 #if !defined(_WIN32) 124 errno = 0; 125 #endif 126 int result = vsnprintf(stack_buf, arraysize(stack_buf), format, ap_copy); 127 va_end(ap_copy); 128 129 if (result >= 0 && result < static_cast<int>(arraysize(stack_buf))) { 130 // It fit. 131 dst->append(stack_buf, result); 132 return; 133 } 134 135 // Repeatedly increase buffer size until it fits. 136 int mem_length = arraysize(stack_buf); 137 while (true) { 138 if (result < 0) { 139 #if !defined(_WIN32) 140 // On Windows, vsnprintf always returns the number of characters in a 141 // fully-formatted string, so if we reach this point, something else is 142 // wrong and no amount of buffer-doubling is going to fix it. 143 if (errno != 0 && errno != EOVERFLOW) 144 #endif 145 { 146 // If an error other than overflow occurred, it's never going to work. 147 return; 148 } 149 // Try doubling the buffer size. 150 mem_length *= 2; 151 } else { 152 // We need exactly "result + 1" characters. 153 mem_length = result + 1; 154 } 155 156 if (mem_length > 32 * 1024 * 1024) { 157 // That should be plenty, don't try anything larger. This protects 158 // against huge allocations when using vsnprintf implementations that 159 // return -1 for reasons other than overflow without setting errno. 160 return; 161 } 162 163 std::vector<typename StringType::value_type> mem_buf(mem_length); 164 165 // NOTE: You can only use a va_list once. Since we're in a while loop, we 166 // need to make a new copy each time so we don't use up the original. 167 GG_VA_COPY(ap_copy, ap); 168 result = vsnprintf(&mem_buf[0], mem_length, format, ap_copy); 169 va_end(ap_copy); 170 171 if ((result >= 0) && (result < mem_length)) { 172 // It fit. 173 dst->append(&mem_buf[0], result); 174 return; 175 } 176 } 177 } 178 179 std::string StringPrintf(const char* format, ...) { 180 va_list ap; 181 va_start(ap, format); 182 std::string result; 183 StringAppendVT(&result, format, ap); 184 va_end(ap); 185 return result; 186 } 187 188 //////////////////////////////////////////////////////////////////////////////// 189 190 191 char * FormatNPAPIError(int iError) 192 { 193 static char szError[64]; 194 switch (iError) 195 { 196 case NPERR_NO_ERROR: 197 sprintf(szError, "NPERR_NO_ERROR"); 198 break; 199 case NPERR_GENERIC_ERROR: 200 sprintf(szError, "NPERR_GENERIC_ERROR"); 201 break; 202 case NPERR_INVALID_INSTANCE_ERROR: 203 sprintf(szError, "NPERR_INVALID_INSTANCE_ERROR"); 204 break; 205 case NPERR_INVALID_FUNCTABLE_ERROR: 206 sprintf(szError, "NPERR_INVALID_FUNCTABLE_ERROR"); 207 break; 208 case NPERR_MODULE_LOAD_FAILED_ERROR: 209 sprintf(szError, "NPERR_MODULE_LOAD_FAILED_ERROR"); 210 break; 211 case NPERR_OUT_OF_MEMORY_ERROR: 212 sprintf(szError, "NPERR_OUT_OF_MEMORY_ERROR"); 213 break; 214 case NPERR_INVALID_PLUGIN_ERROR: 215 sprintf(szError, "NPERR_INVALID_PLUGIN_ERROR"); 216 break; 217 case NPERR_INVALID_PLUGIN_DIR_ERROR: 218 sprintf(szError, "NPERR_INVALID_PLUGIN_DIR_ERROR"); 219 break; 220 case NPERR_INCOMPATIBLE_VERSION_ERROR: 221 sprintf(szError, "NPERR_INCOMPATIBLE_VERSION_ERROR"); 222 break; 223 case NPERR_INVALID_PARAM: 224 sprintf(szError, "NPERR_INVALID_PARAM"); 225 break; 226 case NPERR_INVALID_URL: 227 sprintf(szError, "NPERR_INVALID_URL"); 228 break; 229 case NPERR_FILE_NOT_FOUND: 230 sprintf(szError, "NPERR_FILE_NOT_FOUND"); 231 break; 232 case NPERR_NO_DATA: 233 sprintf(szError, "NPERR_NO_DATA"); 234 break; 235 case NPERR_STREAM_NOT_SEEKABLE: 236 sprintf(szError, "NPERR_STREAM_NOT_SEEKABLE"); 237 break; 238 default: 239 sprintf(szError, "Unlisted error"); 240 break; 241 } 242 return &szError[0]; 243 } 244 245 char * FormatNPAPIReason(int iReason) 246 { 247 static char szReason[64]; 248 switch (iReason) 249 { 250 case NPRES_DONE: 251 sprintf(szReason, "NPRES_DONE"); 252 break; 253 case NPRES_NETWORK_ERR: 254 sprintf(szReason, "NPRES_NETWORK_ERR"); 255 break; 256 case NPRES_USER_BREAK: 257 sprintf(szReason, "NPRES_USER_BREAK"); 258 break; 259 default: 260 sprintf(szReason, "Unlisted reason"); 261 break; 262 } 263 return &szReason[0]; 264 } 265 266 char * FormatNPNVariable(NPNVariable var) 267 { 268 static char szVar[80]; 269 switch (var) 270 { 271 case NPNVxDisplay: 272 sprintf(szVar, "%i -- NPNVxDisplay", var); 273 break; 274 case NPNVxtAppContext: 275 sprintf(szVar, "%i -- NPNVxtAppContext", var); 276 break; 277 case NPNVnetscapeWindow: 278 sprintf(szVar, "%i -- NPNVnetscapeWindow", var); 279 break; 280 case NPNVjavascriptEnabledBool: 281 sprintf(szVar, "%i -- NPNVjavascriptEnabledBool", var); 282 break; 283 case NPNVasdEnabledBool: 284 sprintf(szVar, "%i -- NPNVasdEnabledBool", var); 285 break; 286 case NPNVisOfflineBool: 287 sprintf(szVar, "%i -- NPNVisOfflineBool", var); 288 break; 289 default: 290 sprintf(szVar, "%i -- Unlisted variable", var); 291 break; 292 } 293 return &szVar[0]; 294 } 295 296 char * FormatNPPVariable(NPPVariable var) 297 { 298 static char szVar[80]; 299 switch (var) 300 { 301 case NPPVpluginNameString: 302 sprintf(szVar, "%i -- NPPVpluginNameString", var); 303 break; 304 case NPPVpluginDescriptionString: 305 sprintf(szVar, "%i -- NPPVpluginDescriptionString?", var); 306 break; 307 case NPPVpluginWindowBool: 308 sprintf(szVar, "%i -- NPPVpluginWindowBool?", var); 309 break; 310 case NPPVpluginTransparentBool: 311 sprintf(szVar, "%i -- NPPVpluginTransparentBool?", var); 312 break; 313 case NPPVjavaClass: 314 sprintf(szVar, "%i -- NPPVjavaClass?", var); 315 break; 316 case NPPVpluginWindowSize: 317 sprintf(szVar, "%i -- NPPVpluginWindowSize?", var); 318 break; 319 case NPPVpluginTimerInterval: 320 sprintf(szVar, "%i -- NPPVpluginTimerInterval?", var); 321 break; 322 case NPPVpluginScriptableInstance: 323 sprintf(szVar, "%i -- NPPVpluginScriptableInstance?", var); 324 break; 325 case NPPVpluginScriptableIID: 326 sprintf(szVar, "%i -- NPPVpluginScriptableIID?", var); 327 break; 328 default: 329 sprintf(szVar, "%i -- Unlisted variable?", var); 330 break; 331 } 332 return &szVar[0]; 333 } 334 335 BOOL FormatPCHARArgument(char * szBuf, int iLength, LogArgumentStruct * parg) 336 { 337 if(iLength <= parg->iLength) 338 return FALSE; 339 340 if(parg->pData == NULL) 341 sprintf(szBuf, "%#08lx", parg->dwArg); 342 else 343 sprintf(szBuf, "%#08lx(\"%s\")", parg->dwArg, (char *)parg->pData); 344 return TRUE; 345 } 346 347 BOOL FormatBOOLArgument(char * szBuf, int iLength, LogArgumentStruct * parg) 348 { 349 if(iLength <= 8) 350 return FALSE; 351 352 sprintf(szBuf, "%s", ((NPBool)parg->dwArg == TRUE) ? "TRUE" : "FALSE"); 353 return TRUE; 354 } 355 356 BOOL FormatPBOOLArgument(char * szBuf, int iLength, LogArgumentStruct * parg) 357 { 358 if(iLength <= 8) 359 return FALSE; 360 361 sprintf(szBuf, "%#08lx(%s)", parg->dwArg, (*((NPBool *)parg->pData) == TRUE) ? "TRUE" : "FALSE"); 362 return TRUE; 363 } 364 365 static void makeAbbreviatedString(char * szBuf, int iSize, DWORD dwArg, int iLength, int iWrap) 366 { 367 if(dwArg == 0L) 368 { 369 szBuf[0] = '\0'; 370 return; 371 } 372 373 if(iLength > iWrap) 374 { 375 int iRealWrap = (iSize > iWrap) ? iWrap : (iSize - 4); 376 memcpy((LPVOID)&szBuf[0], (LPVOID)dwArg, iRealWrap); 377 szBuf[iRealWrap] = '.'; 378 szBuf[iRealWrap + 1] = '.'; 379 szBuf[iRealWrap + 2] = '.'; 380 szBuf[iRealWrap + 3] = '\0'; 381 } 382 else 383 { 384 if(iLength >= iSize) 385 { 386 memcpy((LPVOID)&szBuf[0], (LPVOID)dwArg, iSize - 4); 387 szBuf[iSize] = '.'; 388 szBuf[iSize + 1] = '.'; 389 szBuf[iSize + 2] = '.'; 390 szBuf[iSize + 3] = '\0'; 391 } 392 else 393 { 394 memcpy((LPVOID)&szBuf[0], (LPVOID)dwArg, iLength); 395 szBuf[iLength] = '\0'; 396 } 397 } 398 } 399 400 LogItemStruct * makeLogItemStruct(NPAPI_Action action, 401 DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, 402 DWORD dw5, DWORD dw6, DWORD dw7, BOOL bShort) 403 { 404 int iWrap = 64; 405 406 LogItemStruct * plis = new LogItemStruct; 407 if(plis == NULL) 408 return NULL; 409 410 plis->action = action; 411 plis->arg1.dwArg = dw1; 412 plis->arg2.dwArg = dw2; 413 plis->arg3.dwArg = dw3; 414 plis->arg4.dwArg = dw4; 415 plis->arg5.dwArg = dw5; 416 plis->arg6.dwArg = dw6; 417 plis->arg7.dwArg = dw7; 418 419 char szTarget[1024] = {'\0'}; 420 char szBuf[1024] = {'\0'}; 421 422 if(bShort) 423 return plis; 424 425 switch (action) 426 { 427 case action_invalid: 428 break; 429 430 // NPN action 431 case action_npn_version: 432 plis->arg1.pData = new int[1]; 433 *(int*)(plis->arg1.pData) = *((int*)dw1); 434 plis->arg1.iLength = sizeof(int); 435 436 plis->arg2.pData = new int[1]; 437 *(int*)(plis->arg2.pData) = *((int*)dw2); 438 plis->arg2.iLength = sizeof(int); 439 440 plis->arg3.pData = new int[1]; 441 *(int*)(plis->arg3.pData) = *((int*)dw3); 442 plis->arg3.iLength = sizeof(int); 443 444 plis->arg4.pData = new int[1]; 445 *(int*)(plis->arg4.pData) = *((int*)dw4); 446 plis->arg4.iLength = sizeof(int); 447 448 break; 449 case action_npn_get_url_notify: 450 if(dw2 != 0L) 451 { 452 plis->arg2.iLength = strlen((char *)dw2) + 1; 453 plis->arg2.pData = new char[plis->arg2.iLength]; 454 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 455 } 456 457 if(dw3 != 0L) 458 { 459 makeAbbreviatedString(szTarget, sizeof(szTarget), dw3, strlen((char *)dw3), iWrap); 460 plis->arg3.iLength = strlen(szTarget) + 1; 461 plis->arg3.pData = new char[plis->arg3.iLength]; 462 memcpy(plis->arg3.pData, (LPVOID)&szTarget[0], plis->arg3.iLength); 463 } 464 break; 465 case action_npn_get_url: 466 { 467 if(dw2 != 0L) 468 { 469 plis->arg2.iLength = strlen((char *)dw2) + 1; 470 plis->arg2.pData = new char[plis->arg2.iLength]; 471 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 472 } 473 474 if(dw3 != 0L) 475 { 476 makeAbbreviatedString(szTarget, sizeof(szTarget), dw3, strlen((char *)dw3), iWrap); 477 plis->arg3.iLength = strlen(szTarget) + 1; 478 plis->arg3.pData = new char[plis->arg3.iLength]; 479 memcpy(plis->arg3.pData, (LPVOID)&szTarget[0], plis->arg3.iLength); 480 } 481 break; 482 } 483 case action_npn_post_url_notify: 484 { 485 if(dw2 != 0L) 486 { 487 plis->arg2.iLength = strlen((char *)dw2) + 1; 488 plis->arg2.pData = new char[plis->arg2.iLength]; 489 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 490 } 491 492 if(dw3 != 0L) 493 { 494 makeAbbreviatedString(szTarget, sizeof(szTarget), dw3, strlen((char *)dw3), iWrap); 495 plis->arg3.iLength = strlen(szTarget) + 1; 496 plis->arg3.pData = new char[plis->arg3.iLength]; 497 memcpy(plis->arg3.pData, (LPVOID)&szTarget[0], plis->arg3.iLength); 498 } 499 500 makeAbbreviatedString(szBuf, sizeof(szBuf), dw5, strlen((char *)dw5), iWrap); 501 plis->arg5.iLength = (int)dw4 + 1; 502 plis->arg5.pData = new char[plis->arg5.iLength]; 503 memcpy(plis->arg5.pData, (LPVOID)&szBuf[0], plis->arg5.iLength); 504 505 break; 506 } 507 case action_npn_post_url: 508 { 509 if(dw2 != 0L) 510 { 511 plis->arg2.iLength = strlen((char *)dw2) + 1; 512 plis->arg2.pData = new char[plis->arg2.iLength]; 513 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 514 } 515 516 if(dw3 != 0L) 517 { 518 makeAbbreviatedString(szTarget, sizeof(szTarget), dw3, strlen((char *)dw3), iWrap); 519 plis->arg3.iLength = strlen(szTarget) + 1; 520 plis->arg3.pData = new char[plis->arg3.iLength]; 521 memcpy(plis->arg3.pData, (LPVOID)&szTarget[0], plis->arg3.iLength); 522 } 523 524 makeAbbreviatedString(szBuf, sizeof(szBuf), dw5, strlen((char *)dw5), iWrap); 525 plis->arg5.iLength = (int)dw4 + 1; 526 plis->arg5.pData = new char[plis->arg5.iLength]; 527 memcpy(plis->arg5.pData, (LPVOID)&szBuf[0], plis->arg5.iLength); 528 529 break; 530 } 531 case action_npn_new_stream: 532 { 533 if(dw2 != 0L) 534 { 535 plis->arg2.iLength = strlen((char *)dw2) + 1; 536 plis->arg2.pData = new char[plis->arg2.iLength]; 537 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 538 } 539 540 makeAbbreviatedString(szTarget, sizeof(szTarget), dw3, strlen((char *)dw3), iWrap); 541 plis->arg3.iLength = strlen(szTarget) + 1; 542 plis->arg3.pData = new char[plis->arg3.iLength]; 543 memcpy(plis->arg3.pData, (LPVOID)&szTarget[0], plis->arg3.iLength); 544 545 plis->arg4.pData = new char[sizeof(DWORD)]; 546 plis->arg4.iLength = sizeof(DWORD); 547 memcpy(plis->arg4.pData, (LPVOID)dw4, plis->arg4.iLength); 548 549 break; 550 } 551 case action_npn_destroy_stream: 552 break; 553 case action_npn_request_read: 554 break; 555 case action_npn_write: 556 { 557 makeAbbreviatedString(szBuf, sizeof(szBuf), dw4, strlen((char *)dw4), iWrap); 558 plis->arg4.iLength = strlen(szBuf) + 1; 559 plis->arg4.pData = new char[plis->arg4.iLength]; 560 memcpy(plis->arg4.pData, (LPVOID)&szBuf[0], plis->arg4.iLength); 561 break; 562 } 563 case action_npn_status: 564 if(dw2 != 0L) 565 { 566 plis->arg2.iLength = strlen((char *)dw2) + 1; 567 plis->arg2.pData = new char[plis->arg2.iLength]; 568 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 569 } 570 break; 571 case action_npn_user_agent: 572 break; 573 case action_npn_mem_alloc: 574 break; 575 case action_npn_mem_free: 576 break; 577 case action_npn_mem_flush: 578 break; 579 case action_npn_reload_plugins: 580 break; 581 case action_npn_get_java_env: 582 break; 583 case action_npn_get_java_peer: 584 break; 585 case action_npn_get_value: 586 plis->arg3.iLength = sizeof(DWORD); 587 plis->arg3.pData = new char[plis->arg3.iLength]; 588 memcpy(plis->arg3.pData, (LPVOID)dw3, plis->arg3.iLength); 589 break; 590 case action_npn_set_value: 591 if(((NPPVariable)dw2 == NPPVpluginNameString) || ((NPPVariable)dw2 == NPPVpluginDescriptionString)) 592 { 593 makeAbbreviatedString(szBuf, sizeof(szBuf), dw3, strlen((char *)dw3), iWrap); 594 plis->arg3.iLength = strlen(szBuf) + 1; 595 plis->arg3.pData = new char[plis->arg3.iLength]; 596 memcpy(plis->arg3.pData, (LPVOID)&szBuf[0], plis->arg3.iLength); 597 } 598 else if(((NPPVariable)dw2 == NPPVpluginWindowBool) || ((NPPVariable)dw2 == NPPVpluginTransparentBool)) 599 { 600 plis->arg3.iLength = sizeof(NPBool); 601 plis->arg3.pData = new char[plis->arg3.iLength]; 602 memcpy(plis->arg3.pData, (LPVOID)&dw3, plis->arg3.iLength); 603 } 604 else if((NPPVariable)dw2 == NPPVpluginWindowSize) 605 { 606 plis->arg3.iLength = sizeof(NPSize); 607 plis->arg3.pData = new char[plis->arg3.iLength]; 608 memcpy(plis->arg3.pData, (LPVOID)dw3, plis->arg3.iLength); 609 } 610 break; 611 case action_npn_invalidate_rect: 612 { 613 plis->arg2.iLength = sizeof(NPRect); 614 plis->arg2.pData = new char[plis->arg2.iLength]; 615 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 616 break; 617 } 618 case action_npn_invalidate_region: 619 break; 620 case action_npn_force_redraw: 621 break; 622 623 // NPP action 624 case action_npp_new: 625 plis->arg1.iLength = strlen((char *)dw1) + 1; 626 plis->arg1.pData = new char[plis->arg1.iLength]; 627 memcpy(plis->arg1.pData, (LPVOID)dw1, plis->arg1.iLength); 628 break; 629 case action_npp_destroy: 630 plis->arg2.iLength = sizeof(DWORD); 631 plis->arg2.pData = new char[plis->arg2.iLength]; 632 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 633 break; 634 case action_npp_set_window: 635 plis->arg2.iLength = sizeof(NPWindow); 636 plis->arg2.pData = new char[plis->arg2.iLength]; 637 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 638 break; 639 case action_npp_new_stream: 640 plis->arg2.iLength = strlen((char *)dw2) + 1; 641 plis->arg2.pData = new char[plis->arg2.iLength]; 642 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 643 644 plis->arg5.iLength = sizeof(uint16); 645 plis->arg5.pData = new char[plis->arg5.iLength]; 646 memcpy(plis->arg5.pData, (LPVOID)dw5, plis->arg5.iLength); 647 break; 648 case action_npp_destroy_stream: 649 break; 650 case action_npp_stream_as_file: 651 plis->arg3.iLength = strlen((char *)dw3) + 1; 652 plis->arg3.pData = new char[plis->arg3.iLength]; 653 memcpy(plis->arg3.pData, (LPVOID)dw3, plis->arg3.iLength); 654 break; 655 case action_npp_write_ready: 656 break; 657 case action_npp_write: 658 { 659 if(dw5 != 0L) 660 { 661 makeAbbreviatedString(szBuf, sizeof(szBuf), dw5, strlen((char *)dw5), iWrap); 662 plis->arg5.iLength = strlen(szBuf) + 1; 663 plis->arg5.pData = new char[plis->arg5.iLength]; 664 memcpy(plis->arg5.pData, (LPVOID)&szBuf[0], plis->arg5.iLength); 665 } 666 break; 667 } 668 case action_npp_print: 669 break; 670 case action_npp_handle_event: 671 break; 672 case action_npp_url_notify: 673 plis->arg2.iLength = strlen((char *)dw2) + 1; 674 plis->arg2.pData = new char[plis->arg2.iLength]; 675 memcpy(plis->arg2.pData, (LPVOID)dw2, plis->arg2.iLength); 676 break; 677 case action_npp_get_java_class: 678 break; 679 case action_npp_get_value: 680 break; 681 case action_npp_set_value: 682 break; 683 684 default: 685 break; 686 } 687 688 return plis; 689 } 690 691 void freeLogItemStruct(LogItemStruct * lis) 692 { 693 if(lis) 694 delete lis; 695 } 696 697 void formatLogItem(LogItemStruct * plis, std::string* output, BOOL bDOSStyle) 698 { 699 static char szEOL[8]; 700 static char szEOI[256]; 701 static char szEndOfItem[] = ""; 702 703 if(bDOSStyle) 704 { 705 strcpy(szEOL, "\r\n"); 706 //strcpy(szEOI, szEndOfItem); 707 //strcat(szEOI, "\r\n"); 708 } 709 else 710 { 711 strcpy(szEOL, "\n"); 712 //strcpy(szEOI, szEndOfItem); 713 //strcat(szEOI, "\n"); 714 } 715 716 DWORD dw1 = plis->arg1.dwArg; 717 DWORD dw2 = plis->arg2.dwArg; 718 DWORD dw3 = plis->arg3.dwArg; 719 DWORD dw4 = plis->arg4.dwArg; 720 DWORD dw5 = plis->arg5.dwArg; 721 DWORD dw6 = plis->arg6.dwArg; 722 DWORD dw7 = plis->arg7.dwArg; 723 724 char sz1[1024] = {'\0'}; 725 char sz2[1024] = {'\0'}; 726 char sz3[1024] = {'\0'}; 727 char sz4[1024] = {'\0'}; 728 char sz5[1024] = {'\0'}; 729 char sz6[1024] = {'\0'}; 730 731 switch (plis->action) 732 { 733 case action_invalid: 734 break; 735 736 // NPN action 737 case action_npn_version: 738 if((plis->arg1.pData != NULL)&&(plis->arg2.pData != NULL)&&(plis->arg3.pData != NULL)&&(plis->arg4.pData != NULL)) 739 *output = StringPrintf("NPN_Version(%#08lx, %#08lx, %#08lx, %#08lx)", dw1,dw2,dw3,dw4); 740 else 741 *output = StringPrintf("NPN_Version(%#08lx, %#08lx, %#08lx, %#08lx)", dw1,dw2,dw3,dw4); 742 break; 743 case action_npn_get_url_notify: 744 { 745 FormatPCHARArgument(sz2, sizeof(sz2), &plis->arg2); 746 FormatPCHARArgument(sz3, sizeof(sz3), &plis->arg3); 747 *output = StringPrintf("NPN_GetURLNotify(%#08lx, %s, %s, %#08lx)", dw1,sz2,sz3,dw4); 748 break; 749 } 750 case action_npn_get_url: 751 { 752 FormatPCHARArgument(sz2, sizeof(sz2), &plis->arg2); 753 FormatPCHARArgument(sz3, sizeof(sz3), &plis->arg3); 754 *output = StringPrintf("NPN_GetURL(%#08lx, %s, %s)", dw1,sz2,sz3); 755 break; 756 } 757 case action_npn_post_url_notify: 758 { 759 FormatPCHARArgument(sz2, sizeof(sz2), &plis->arg2); 760 FormatPCHARArgument(sz3, sizeof(sz3), &plis->arg3); 761 FormatPCHARArgument(sz5, sizeof(sz5), &plis->arg5); 762 FormatBOOLArgument(sz6, sizeof(sz6), &plis->arg6); 763 764 *output = StringPrintf("NPN_PostURLNotify(%#08lx, %s, %s, %li, %s, %s, %#08lx)", 765 dw1,sz2,sz3,(uint32)dw4,sz5,sz6,dw7); 766 break; 767 } 768 case action_npn_post_url: 769 { 770 FormatPCHARArgument(sz2, sizeof(sz2), &plis->arg2); 771 FormatPCHARArgument(sz3, sizeof(sz3), &plis->arg3); 772 FormatPCHARArgument(sz5, sizeof(sz5), &plis->arg5); 773 FormatBOOLArgument(sz6, sizeof(sz6), &plis->arg6); 774 775 *output = StringPrintf("NPN_PostURL(%#08lx, %s, %s, %li, %s, %s)", 776 dw1,sz2,sz3,(uint32)dw4,sz5,sz6); 777 break; 778 } 779 case action_npn_new_stream: 780 { 781 FormatPCHARArgument(sz2, sizeof(sz2), &plis->arg2); 782 FormatPCHARArgument(sz3, sizeof(sz3), &plis->arg3); 783 if(plis->arg4.pData != NULL) 784 *output = StringPrintf("NPN_NewStream(%#08lx, %s, %s, %#08lx(%#08lx))", 785 dw1, sz2,sz3,dw4,*(DWORD *)plis->arg4.pData); 786 else 787 *output = StringPrintf("NPN_NewStream(%#08lx, \"%s\", \"%s\", %#08lx)", dw1, sz2,sz3,dw4); 788 break; 789 } 790 case action_npn_destroy_stream: 791 *output = StringPrintf("NPN_DestroyStream(%#08lx, %#08lx, %s)", dw1,dw2,FormatNPAPIReason((int)dw3)); 792 break; 793 case action_npn_request_read: 794 *output = StringPrintf("NPN_RequestRead(%#08lx, %#08lx)", dw1, dw2); 795 break; 796 case action_npn_write: 797 { 798 FormatPCHARArgument(sz4, sizeof(sz4), &plis->arg4); 799 *output = StringPrintf("NPN_Write(%#08lx, %#08lx, %li, %s)", dw1, dw2, (int32)dw3, sz4); 800 break; 801 } 802 case action_npn_status: 803 { 804 FormatPCHARArgument(sz2, sizeof(sz2), &plis->arg2); 805 *output = StringPrintf("NPN_Status(%#08lx, %s)", dw1, sz2); 806 break; 807 } 808 case action_npn_user_agent: 809 *output = StringPrintf("NPN_UserAgent(%#08lx)", dw1); 810 break; 811 case action_npn_mem_alloc: 812 *output = StringPrintf("NPN_MemAlloc(%li)", dw1); 813 break; 814 case action_npn_mem_free: 815 *output = StringPrintf("NPN_MemFree(%#08lx)", dw1); 816 break; 817 case action_npn_mem_flush: 818 *output = StringPrintf("NPN_MemFlush(%li)", dw1); 819 break; 820 case action_npn_reload_plugins: 821 { 822 FormatBOOLArgument(sz1, sizeof(sz1), &plis->arg1); 823 *output = StringPrintf("NPN_ReloadPlugins(%s)", sz1); 824 break; 825 } 826 case action_npn_get_java_env: 827 *output = StringPrintf("NPN_GetJavaEnv()"); 828 break; 829 case action_npn_get_java_peer: 830 *output = StringPrintf("NPN_GetJavaPeer(%#08lx)", dw1); 831 break; 832 case action_npn_get_value: 833 { 834 switch(dw2) 835 { 836 case NPNVxDisplay: 837 case NPNVxtAppContext: 838 case NPNVnetscapeWindow: 839 if(dw3 != 0L) 840 *output = StringPrintf("NPN_GetValue(%#08lx, %s, %#08lx(%#08lx))",dw1,FormatNPNVariable((NPNVariable)dw2),dw3,*(DWORD *)dw3); 841 else 842 *output = StringPrintf("NPN_GetValue(%#08lx, %s, %#08lx)",dw1,FormatNPNVariable((NPNVariable)dw2),dw3); 843 break; 844 case NPNVjavascriptEnabledBool: 845 case NPNVasdEnabledBool: 846 case NPNVisOfflineBool: 847 if(dw3 != 0L) 848 *output = StringPrintf("NPN_GetValue(%#08lx, %s, %#08lx(%s))", 849 dw1,FormatNPNVariable((NPNVariable)dw2),dw3, 850 (((NPBool)*(DWORD *)dw3) == TRUE) ? "TRUE" : "FALSE"); 851 else 852 *output = StringPrintf("NPN_GetValue(%#08lx, %s, %#08lx)",dw1,FormatNPNVariable((NPNVariable)dw2),dw3); 853 break; 854 default: 855 break; 856 } 857 break; 858 } 859 case action_npn_set_value: 860 861 if(((NPPVariable)dw2 == NPPVpluginNameString) || ((NPPVariable)dw2 == NPPVpluginDescriptionString)) 862 { 863 FormatPCHARArgument(sz3, sizeof(sz3), &plis->arg3); 864 *output = StringPrintf("NPN_SetValue(%#08lx, %s, %s)", dw1,FormatNPPVariable((NPPVariable)dw2),sz3); 865 } 866 else if(((NPPVariable)dw2 == NPPVpluginWindowBool) || ((NPPVariable)dw2 == NPPVpluginTransparentBool)) 867 { 868 FormatPBOOLArgument(sz3, sizeof(sz3), &plis->arg3); 869 *output = StringPrintf("NPN_SetValue(%#08lx, %s, %s)", 870 dw1,FormatNPPVariable((NPPVariable)dw2),sz3); 871 } 872 else if((NPPVariable)dw2 == NPPVpluginWindowSize) 873 { 874 if(plis->arg3.pData != NULL) 875 { 876 int32 iWidth = ((NPSize *)plis->arg3.pData)->width; 877 int32 iHeight = ((NPSize *)plis->arg3.pData)->height; 878 *output = StringPrintf("NPN_SetValue(%#08lx, %s, %#08lx(%li,%li))", 879 dw1,FormatNPPVariable((NPPVariable)dw2),dw3,iWidth,iHeight); 880 } 881 else 882 *output = StringPrintf("NPN_SetValue(%#08lx, %s, %#08lx(?,?))", 883 dw1,FormatNPPVariable((NPPVariable)dw2),dw3); 884 } 885 else 886 *output = StringPrintf("NPN_SetValue(%#08lx, %s, %#08lx(What is it?))", dw1,FormatNPPVariable((NPPVariable)dw2),dw3); 887 break; 888 case action_npn_invalidate_rect: 889 { 890 if(plis->arg2.pData != NULL) 891 { 892 uint16 top = ((NPRect *)plis->arg2.pData)->top; 893 uint16 left = ((NPRect *)plis->arg2.pData)->left; 894 uint16 bottom = ((NPRect *)plis->arg2.pData)->bottom; 895 uint16 right = ((NPRect *)plis->arg2.pData)->right; 896 *output = StringPrintf("NPN_InvalidateRect(%#08lx, %#08lx(%u,%u;%u,%u)", dw1,dw2,top,left,bottom,right); 897 } 898 else 899 *output = StringPrintf("NPN_InvalidateRect(%#08lx, %#08lx(?,?,?,?)", dw1,dw2); 900 break; 901 } 902 case action_npn_invalidate_region: 903 *output = StringPrintf("NPN_InvalidateRegion(%#08lx, %#08lx)", dw1,dw2); 904 break; 905 case action_npn_force_redraw: 906 *output = StringPrintf("NPN_ForceRedraw(%#08lx)", dw1); 907 break; 908 case action_npn_enumerate: 909 *output = StringPrintf("NPN_Enumerate()"); 910 break; 911 case action_npn_pop_popups_enabled_state: 912 *output = StringPrintf("NPN_PopPopupsEnabledState()"); 913 break; 914 case action_npn_push_popups_enabled_state: 915 *output = StringPrintf("NPN_PushPopupsEnabledState()"); 916 break; 917 case action_npn_set_exception: 918 *output = StringPrintf("NPN_SetException(%s)", dw1); 919 break; 920 case action_npn_has_method: 921 *output = StringPrintf("NPN_HasMethod(%d)", dw1); 922 break; 923 case action_npn_has_property: 924 *output = StringPrintf("NPN_HasProperty(%d)", dw1); 925 break; 926 case action_npn_remove_property: 927 *output = StringPrintf("NPN_RemoveProperty(%d)", dw1); 928 break; 929 case action_npn_set_property: 930 *output = StringPrintf("NPN_SetProperty(%d)", dw1); 931 break; 932 case action_npn_get_property: 933 *output = StringPrintf("NPN_GetProperty(%d)", dw1); 934 break; 935 case action_npn_evaluate: 936 *output = StringPrintf("NPN_Evaluate(%s)", dw1); 937 break; 938 case action_npn_invoke_default: 939 *output = StringPrintf("NPN_InvokeDefault(%#08lx)", dw1); 940 break; 941 case action_npn_invoke: 942 *output = StringPrintf("NPN_Invoke(%#08lx)", dw1); 943 break; 944 case action_npn_release_object: 945 *output = StringPrintf("NPN_ReleaseObject(%d)", dw1); 946 break; 947 case action_npn_retain_object: 948 *output = StringPrintf("NPN_RetainObject(%d)", dw1); 949 break; 950 case action_npn_create_object: 951 *output = StringPrintf("NPN_CreateObject(%#08lx)", dw1); 952 break; 953 case action_npn_int_from_identifier: 954 *output = StringPrintf("NPN_IntFromIdentifier(%d)", dw1); 955 break; 956 case action_npn_utf8_from_identifier: 957 *output = StringPrintf("NPN_UTF8FromIdentifier(%d)", dw1); 958 break; 959 case action_npn_identifier_is_string: 960 *output = StringPrintf("NPN_IdentifierIsString(%d)", dw1); 961 break; 962 case action_npn_get_int_identifer: 963 *output = StringPrintf("NPN_GetIntIdentifier(%d)", dw1); 964 break; 965 case action_npn_get_string_identifiers: 966 *output = StringPrintf("NPN_GetStringIdentifier()"); 967 break; 968 969 // NPP action 970 case action_npp_new: 971 { 972 char szMode[16]; 973 switch (dw3) 974 { 975 case NP_EMBED: 976 strcpy(szMode, "NP_EMBED"); 977 break; 978 case NP_FULL: 979 strcpy(szMode, "NP_FULL"); 980 break; 981 default: 982 strcpy(szMode, "[Invalid mode]"); 983 break; 984 } 985 *output = StringPrintf("NPP_New(\"%s\", %#08lx, %s, %i, %#08lx, %#08lx, %#08lx)", 986 (char *)dw1,dw2,szMode,(int)dw4,dw5,dw6,dw7); 987 break; 988 } 989 case action_npp_destroy: 990 *output = StringPrintf("NPP_Destroy(%#08lx, %#08lx(%#08lx))", dw1, dw2, *(DWORD *)plis->arg2.pData); 991 break; 992 case action_npp_set_window: 993 { 994 char szWindow[512]; 995 996 if(plis->arg2.pData != NULL) 997 { 998 char szType[80]; 999 switch (((NPWindow*)plis->arg2.pData)->type) 1000 { 1001 case NPWindowTypeWindow: 1002 sprintf(szType, "NPWindowTypeWindow"); 1003 break; 1004 case NPWindowTypeDrawable: 1005 sprintf(szType, "NPWindowTypeDrawable"); 1006 break; 1007 default: 1008 sprintf(szType, "[Unlisted type]"); 1009 break; 1010 } 1011 sprintf(szWindow, "NPWindow: %#08lx, (%li,%li), (%li,%li), (%i,%i,%i,%i), %s", 1012 ((NPWindow*)plis->arg2.pData)->window, 1013 ((NPWindow*)plis->arg2.pData)->x, 1014 ((NPWindow*)plis->arg2.pData)->y, 1015 ((NPWindow*)plis->arg2.pData)->width, 1016 ((NPWindow*)plis->arg2.pData)->height, 1017 ((NPWindow*)plis->arg2.pData)->clipRect.top, 1018 ((NPWindow*)plis->arg2.pData)->clipRect.left, 1019 ((NPWindow*)plis->arg2.pData)->clipRect.bottom, 1020 ((NPWindow*)plis->arg2.pData)->clipRect.right, szType); 1021 *output = StringPrintf("NPP_SetWindow(%#08lx, %#08lx) %s", dw1,dw2,szWindow); 1022 } 1023 else 1024 *output = StringPrintf("NPP_SetWindow(%#08lx, %#08lx)", dw1,dw2); 1025 1026 break; 1027 } 1028 case action_npp_new_stream: 1029 { 1030 switch (*(int16 *)plis->arg5.pData) 1031 { 1032 case NP_NORMAL: 1033 sprintf(sz5, "NP_NORMAL"); 1034 break; 1035 case NP_ASFILEONLY: 1036 sprintf(sz5, "NP_ASFILEONLY"); 1037 break; 1038 case NP_ASFILE: 1039 sprintf(sz5, "NP_ASFILE"); 1040 break; 1041 default: 1042 sprintf(sz5, "[Unlisted type]"); 1043 break; 1044 } 1045 FormatPCHARArgument(sz2, sizeof(sz2), &plis->arg2); 1046 *output = StringPrintf("NPP_NewStream(%#08lx, %s, %#08lx (%s), %s, %s)", dw1, sz2, dw3, 1047 ((NPStream*)dw3)->url, ((NPBool)dw4 == TRUE) ? "TRUE" : "FALSE", sz5); 1048 break; 1049 } 1050 case action_npp_destroy_stream: 1051 *output = StringPrintf("NPP_DestroyStream(%#08lx, %#08lx, %s)", dw1,dw2,FormatNPAPIReason((int)dw3)); 1052 break; 1053 case action_npp_stream_as_file: 1054 FormatPCHARArgument(sz3, sizeof(sz3), &plis->arg3); 1055 *output = StringPrintf("NPP_StreamAsFile(%#08lx, %#08lx, %s)", dw1,dw2,sz3); 1056 break; 1057 case action_npp_write_ready: 1058 *output = StringPrintf("NPP_WriteReady(%#08lx, %#08lx)", dw1,dw2); 1059 break; 1060 case action_npp_write: 1061 { 1062 FormatPCHARArgument(sz5, sizeof(sz5), &plis->arg5); 1063 *output = StringPrintf("NPP_Write(%#08lx, %#08lx, %li, %li, %s))",dw1,dw2,dw3,dw4,sz5); 1064 break; 1065 } 1066 case action_npp_print: 1067 *output = StringPrintf("NPP_Print(%#08lx, %#08lx)", dw1, dw2); 1068 break; 1069 case action_npp_handle_event: 1070 { 1071 NPEvent *event = (NPEvent*)dw2; 1072 *output = StringPrintf("NPP_HandleEvent(%#08lx, %#08lx {event=%d, wParam=%#08lx lParam=%#08lx)", dw1,dw2,event->event, event->wParam, event->lParam); 1073 break; 1074 } 1075 case action_npp_url_notify: 1076 { 1077 FormatPCHARArgument(sz2, sizeof(sz2), &plis->arg2); 1078 *output = StringPrintf("NPP_URLNotify(%#08lx, %s, %s, %#08lx)", dw1,sz2,FormatNPAPIReason((int)dw3),dw4); 1079 break; 1080 } 1081 case action_npp_get_java_class: 1082 *output = StringPrintf("NPP_GetJavaClass()"); 1083 break; 1084 case action_npp_get_value: 1085 *output = StringPrintf("NPP_GetValue(%#08lx, %s, %#08lx)", dw1,FormatNPPVariable((NPPVariable)dw2),dw3); 1086 break; 1087 case action_npp_set_value: 1088 *output = StringPrintf("NPP_SetValue(%#08lx, %s, %#08lx)", dw1,FormatNPNVariable((NPNVariable)dw2),dw3); 1089 break; 1090 1091 default: 1092 *output = StringPrintf("Unknown action"); 1093 break; 1094 } 1095 *output += szEOL; 1096 *output += szEOI; 1097 } 1098
