Browse Source

Opera 12.15 rendering engine.

tags/12.15.1
Presto! 25 years ago
parent
commit
8c5977d18f
100 changed files with 35740 additions and 1 deletions
  1. 55
    0
      .gitignore
  2. 5
    1
      README.md
  3. 530
    0
      adjunct/autoupdate/additionchecker.cpp
  4. 374
    0
      adjunct/autoupdate/additionchecker.h
  5. 49
    0
      adjunct/autoupdate/additioncheckerlistener.h
  6. 4
    0
      adjunct/autoupdate/autoupdate_checker/.gitignore
  7. 70
    0
      adjunct/autoupdate/autoupdate_checker/adaptation_layer/global_storage.h
  8. 133
    0
      adjunct/autoupdate/autoupdate_checker/adaptation_layer/ipc.h
  9. 109
    0
      adjunct/autoupdate/autoupdate_checker/adaptation_layer/network.h
  10. 142
    0
      adjunct/autoupdate/autoupdate_checker/adaptation_layer/protocol.h
  11. 34
    0
      adjunct/autoupdate/autoupdate_checker/adaptation_layer/system_info.h
  12. 32
    0
      adjunct/autoupdate/autoupdate_checker/adaptation_layer/system_utils.h
  13. 50
    0
      adjunct/autoupdate/autoupdate_checker/autoupdate_checker_vc2010.sln
  14. 447
    0
      adjunct/autoupdate/autoupdate_checker/autoupdate_checker_vc2010.vcxproj
  15. 1016
    0
      adjunct/autoupdate/autoupdate_checker/autoupdatechecker.cpp
  16. 153
    0
      adjunct/autoupdate/autoupdate_checker/autoupdatechecker.h
  17. 24
    0
      adjunct/autoupdate/autoupdate_checker/certificate/cert.pem
  18. 39
    0
      adjunct/autoupdate/autoupdate_checker/common/common.h
  19. 162
    0
      adjunct/autoupdate/autoupdate_checker/licenses/LICENSES
  20. 26
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/Makefile.m32
  21. 26
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/Makefile.m64
  22. 19
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/build_libs_32bit
  23. 19
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/build_libs_64bit
  24. 15
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/impl/Makefile.m32
  25. 15
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/impl/Makefile.m64
  26. 27
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/impl/globalstorageimpl.cpp
  27. 133
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/impl/globalstorageimpl.mm
  28. 305
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/impl/ipcimpl.cpp
  29. 31
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/impl/systeminfoimpl.cpp
  30. 40
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/impl/systeminfoimpl.mm
  31. 31
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/impl/systemutilsimpl.cpp
  32. 33
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/includes/globalstorageimpl.h
  33. 28
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/includes/ipcconfig.h
  34. 49
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/includes/ipcimpl.h
  35. 74
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/includes/platform.h
  36. BIN
      adjunct/autoupdate/autoupdate_checker/platforms/mac/libs/i386/libcrypto.a
  37. BIN
      adjunct/autoupdate/autoupdate_checker/platforms/mac/libs/i386/libcurl.a
  38. BIN
      adjunct/autoupdate/autoupdate_checker/platforms/mac/libs/i386/libssl.a
  39. BIN
      adjunct/autoupdate/autoupdate_checker/platforms/mac/libs/x86_64/libcrypto.a
  40. BIN
      adjunct/autoupdate/autoupdate_checker/platforms/mac/libs/x86_64/libcurl.a
  41. BIN
      adjunct/autoupdate/autoupdate_checker/platforms/mac/libs/x86_64/libssl.a
  42. 59
    0
      adjunct/autoupdate/autoupdate_checker/platforms/mac/main.cpp
  43. 16
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/all_includes.h
  44. 7
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/.gitignore
  45. 25
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/ACKNOWLEDGMENTS
  46. 9992
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/CHANGES
  47. 968
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/CHANGES.SSLeay
  48. 2174
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/Configure
  49. 1041
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/FAQ
  50. 360
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/INSTALL
  51. 47
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/INSTALL.DJGPP
  52. 72
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/INSTALL.MacOS
  53. 454
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/INSTALL.NW
  54. 31
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/INSTALL.OS2
  55. 293
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/INSTALL.VMS
  56. 325
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/INSTALL.W32
  57. 66
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/INSTALL.W64
  58. 95
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/INSTALL.WCE
  59. 127
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/LICENSE
  60. 62
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/GUSI_Init.cpp
  61. 2753
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/GetHTTPS.src/CPStringUtils.cpp
  62. 104
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/GetHTTPS.src/CPStringUtils.hpp
  63. 170
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/GetHTTPS.src/ErrorHandling.cpp
  64. 147
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/GetHTTPS.src/ErrorHandling.hpp
  65. 209
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/GetHTTPS.src/GetHTTPS.cpp
  66. 1607
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/GetHTTPS.src/MacSocket.cpp
  67. 103
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/GetHTTPS.src/MacSocket.h
  68. 4940
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/OpenSSL.mcp.hqx
  69. 476
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/Randomizer.cpp
  70. 43
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/Randomizer.h
  71. 18
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/TODO
  72. 9
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/_MWERKS_GUSI_prefix.h
  73. 9
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/_MWERKS_prefix.h
  74. 5
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/buildinf.h
  75. 820
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/mklinks.as.hqx
  76. 116
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/MacOS/opensslconf.h
  77. 644
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/NEWS
  78. 235
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/Netware/build.bat
  79. 113
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/Netware/cpy_tests.bat
  80. 624
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/Netware/do_tests.pl
  81. 254
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/Netware/globals.txt
  82. 19
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/Netware/readme.txt
  83. 112
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/Netware/set_env.bat
  84. 199
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/PROBLEMS
  85. 218
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/README
  86. 187
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/README.ASN1
  87. 289
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/README.ENGINE
  88. 18
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/TODO
  89. 34
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/VMSify-conf.pl
  90. 4
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/WISHLIST.TXT
  91. 67
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/install-vms.com
  92. 476
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/mkshared.com
  93. 1
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/multinet_shr.opt
  94. 108
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/openssl_startup.com
  95. 20
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/openssl_undo.com
  96. 46
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/openssl_utils.com
  97. 1
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/socketshr_shr.opt
  98. 1
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/tcpip_shr_decc.opt
  99. 28
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/test-includes.com
  100. 0
    0
      adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/openssl/VMS/ucx_shr_decc.opt

+ 55
- 0
.gitignore View File

@@ -0,0 +1,55 @@
# Files generated by Core
module.generated
module.sources_protobuf
**/**/src/generated/g_message_*_messages.cpp
**/**/src/generated/g_message_*_messages.h
**/**/src/generated/g_proto_descriptor_*_messages.cpp
**/**/src/generated/g_proto_descriptor_*_messages.h
**/**/src/generated/g_proto_*_messages.h
**/**/src/generated/g_proto_*_messages.cpp
*_jumbo.cpp
data/i18ndata/tables/encoding.bin
data/i18ndata/tables/encodingbin.cpp
local-tweaks.h
*.tmp
/core/

# Windows-specific
/debug_unicode/
/Debug/
/Instrumented/
/PGO/
/release_unicode/
/Release/
/vTune/
*VTune/
*Debug Unicode DLL/
*Release Unicode DLL/
*.vcproj.*.user
/VS_Output/
7z.log
Opera autoupdate.exe
Opera installer.exe
Opera.7z
desktop.ini

# Mac-specific
/build/
/output/

# UNIX-specific
/build/
/run/
/packages/
/build.log
/build.log.*
*~
.#*

# Other
/adjunct/autoupdate/autoupdate_checker/platforms/universal_adaptation_layer/network/curl
/*.conf.py
*.py[oc]
*Tagging/
/#*#
.DS_Store

+ 5
- 1
README.md View File

@@ -1 +1,5 @@
# browser
# Presto Web rendering engine: Opera 12.15

This repository contains the Presto rendering engine, used up to Opera 12.

.-Peace out

+ 530
- 0
adjunct/autoupdate/additionchecker.cpp View File

@@ -0,0 +1,530 @@
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2012 Opera Software ASA. All rights reserved.
*
* This file is part of the Opera web browser. It may not be distributed
* under any circumstances.
*
* @author Michal Zajaczkowski
*/

#include "core/pch.h"

#ifdef AUTO_UPDATE_SUPPORT
#include "adjunct/autoupdate/additionchecker.h"
#include "adjunct/autoupdate/additioncheckerlistener.h"
#include "adjunct/autoupdate/autoupdateserverurl.h"
#include "adjunct/quick/managers/AutoUpdateManager.h"

/**
* The list of updatable resource types that can be resolved by the addition checker.
* No other type of resource will be possible to resolve this way.
*/
UpdatableResource::UpdatableResourceType AdditionChecker::KNOWN_TYPES[] =
{
UpdatableResource::RTPlugin,
UpdatableResource::RTDictionary
};

/**
* The number of seconds that will pass between resolving a new addition has been requested and the actual HTTP request.
* The lower this is, the faster the resolve will happen, the higher it is, the less requests will be made since more
* items will have the chance to get scheduled for a single request.
* The plugin install manager might request a couple of mimetypes for a single Web page during the page load, and we'd
* rather send them out with a single HTTP request to the autoupdate server.
*/
const unsigned int AdditionChecker::RESOLVE_TIMER_KICK_NOW_PERIOD_SEC = 2;

/**
* The number of seconds that will pass between a failed request to the autoupdate server and a retry attempt. Note that
* requesting any new addition check during the retry time will cause the retry to happen sooner, with the new addition
* resolve attempt.
*/
const unsigned int AdditionChecker::RESOLVE_TIMER_KICK_DELAYED_PERDIOD_SEC = 10;

/**
* The maximum number of resolve attempts per item. If the item could not be resolved with this many requests to the autoupdate
* server, it is broadcasted as failing to resolve.
*/
const unsigned int AdditionChecker::RESOLVE_MAX_RETRY_COUNT_PER_ITEM = 5;

AdditionChecker::AdditionChecker():
m_resolve_timer(NULL),
m_autoupdate_server_url(NULL),
m_autoupdate_xml(NULL)
{
}

AdditionChecker::~AdditionChecker()
{
OP_DELETE(m_autoupdate_server_url);
OP_DELETE(m_autoupdate_xml);

if (m_resolve_timer)
m_resolve_timer->SetTimerListener(NULL);

OP_DELETE(m_resolve_timer);

// Delete all items that are still not resolved
m_items.DeleteAll();

// Stop and *delete* all downloaders that might happen to be still alive
for (UINT32 i=0; i<m_xml_downloaders.GetCount(); i++)
{
StatusXMLDownloader* downloader = m_xml_downloaders.Get(i);
OP_ASSERT(downloader);
OpStatus::Ignore(downloader->StopRequest());
}
m_xml_downloaders.DeleteAll();
}

OP_STATUS AdditionChecker::Init()
{
OpAutoPtr<OpTimer> resolve_timer_guard;
OpAutoPtr<AutoUpdateXML> autoupdate_xml_guard;
OpAutoPtr<AutoUpdateServerURL> autoupdate_server_url_guard;

m_resolve_timer = OP_NEW(OpTimer, ());
RETURN_OOM_IF_NULL(m_resolve_timer);
resolve_timer_guard = m_resolve_timer;
m_resolve_timer->SetTimerListener(this);

m_autoupdate_xml = OP_NEW(AutoUpdateXML, ());
RETURN_OOM_IF_NULL(m_autoupdate_xml);
autoupdate_xml_guard = m_autoupdate_xml;
RETURN_IF_ERROR(m_autoupdate_xml->Init());

m_autoupdate_server_url = OP_NEW(AutoUpdateServerURL, ());
RETURN_OOM_IF_NULL(m_autoupdate_server_url);
autoupdate_server_url_guard = m_autoupdate_server_url;
RETURN_IF_ERROR(m_autoupdate_server_url->Init());

resolve_timer_guard.release();
autoupdate_xml_guard.release();
autoupdate_server_url_guard.release();

return OpStatus::OK;
}

OP_STATUS AdditionChecker::AddListener(AdditionCheckerListener* listener)
{
return m_listeners.Add(listener);
}

OP_STATUS AdditionChecker::RemoveListener(AdditionCheckerListener* listener)
{
return m_listeners.Remove(listener);
}

OP_STATUS AdditionChecker::CheckForAddition(UpdatableResource::UpdatableResourceType type, const OpStringC& key)
{
// Did you call Init()?
OP_ASSERT(m_resolve_timer);

// Only allow the known types. See AdditionChecker::KNOWN_TYPES[]
if (!IsKnownType(type))
{
OP_ASSERT(!"Uknown resource type passed to addition checker!");
return OpStatus::ERR;
}

// Only allow new items, don't cache same items twice.
if (NULL == GetItem(type, key))
{
// Haven't seen this item before, save it among m_items as pending a resolve attempt.
OpAutoPtr<AdditionCheckerItem> item(OP_NEW(AdditionCheckerItem, ()));
RETURN_OOM_IF_NULL(item.get());
RETURN_IF_ERROR(item->SetKey(key));
item->SetType(type);
RETURN_IF_ERROR(m_items.Add(item.get()));
item.release();
}

/* No matter if the item was known before or not, reset the resolve timer in order to
* shorten the retry time in case we're in the retry period at the moment and still
* allow to cache more items before a request is made if this is a new item.
*/
KickResolveTimer(KickNow);

return OpStatus::OK;
}

AdditionCheckerItem* AdditionChecker::GetItem(UpdatableResource::UpdatableResourceType type, const OpStringC& key)
{
OP_ASSERT(key.HasContent());
// Find an item with the given type and key, there should be only one, but we don't verify that here
AdditionCheckerItem* item = NULL;
for (UINT32 i=0; i<m_items.GetCount(); i++)
{
item = m_items.Get(i);
OP_ASSERT(item);
if (item->IsType(type) && item->IsKey(key))
return item;
}
return NULL;
}

OP_STATUS AdditionChecker::GetItemsForDownloader(OpVector<AdditionCheckerItem>& items, StatusXMLDownloader* downloader)
{
// Gather all items that are supposed to be resolved by the given StatusXMLDownloader.
for (UINT32 i=0; i<m_items.GetCount(); i++)
{
AdditionCheckerItem* item = m_items.Get(i);
OP_ASSERT(item);
if (item->IsXMLDownloader(downloader))
RETURN_IF_ERROR(items.Add(item));
}
return OpStatus::OK;
}

OP_STATUS AdditionChecker::GetItemsForDownloaderAndType(OpVector<AdditionCheckerItem>& items, StatusXMLDownloader* downloader, UpdatableResource::UpdatableResourceType type)
{
// Gather all items that are supposed to be resolved by the given StatusXMLDownloader.
for (UINT32 i=0; i<m_items.GetCount(); i++)
{
AdditionCheckerItem* item = m_items.Get(i);
OP_ASSERT(item);
if (item->IsXMLDownloader(downloader) && item->IsType(type))
RETURN_IF_ERROR(items.Add(item));
}
return OpStatus::OK;

}

void AdditionChecker::OnTimeOut(OpTimer* timer)
{
OP_ASSERT(m_resolve_timer);
if (timer == m_resolve_timer)
{
if (OpStatus::IsError(OnResolveTimeOut()))
{
// Something went terribly wrong. Perhaps things will get better next time an addition check is requested,
// however this should not happen.
OP_ASSERT(!"Shouldn't happen");
}
}
else
OP_ASSERT(!"Unknown timer");
}

OP_STATUS AdditionChecker::OnResolveTimeOut()
{
OP_ASSERT(m_resolve_timer);
OP_ASSERT(m_autoupdate_xml);
OP_ASSERT(m_autoupdate_server_url);
// The resolve timer fired. We want to send a request to the autoupdate server asking about all additions that are still not resolved
// at this moment.
// Since the autoupdate server requires a different autoupdate check level for every different addition type and since we really don't
// want to change that, we cannot mix different addition types with one request to the server.

// Go through all the known types
for (UINT32 i=0; i<GetKnownTypesCount(); i++)
{
// The type that we're currently processing
UpdatableResource::UpdatableResourceType current_type = KNOWN_TYPES[i];
OP_ASSERT(current_type);

// Gather a list of all addition items of the current type that are still not resolved in this vector
OpVector<AdditionCheckerItem> items;
// Get a list of all items of the current type that have a NULL downloader, meaning that they are not
// waiting for a callback from a downloader.
RETURN_IF_ERROR(GetItemsForDownloaderAndType(items, NULL, current_type));

if (items.GetCount() > 0)
{
// There is only one AutoUpdateXML, so we need to prepare it for a new request
m_autoupdate_xml->ClearRequestItems();

for (UINT32 i=0; i<items.GetCount(); i++)
{
AdditionCheckerItem* item = items.Get(i);
OP_ASSERT(item);
// Add the item to the AutoUpdateXML, this is needed to generate the proper request XML with all the items
// we want to resolve.
RETURN_IF_ERROR(m_autoupdate_xml->AddRequestItem(item));
}

// Get the current autoupdate server address. It is possible to have multiple addresses in the Autoupdate Server
// preference, these will be cycled through in case of error while getting the response XML.
OpString autoupdate_server_url_string;
RETURN_IF_ERROR(m_autoupdate_server_url->GetCurrentURL(autoupdate_server_url_string));

// Create a new StatusXMLDownloader that will be responsible for resolving this particular list of items
OpAutoPtr<StatusXMLDownloader> current_downloader(OP_NEW(StatusXMLDownloader, ()));
RETURN_OOM_IF_NULL(current_downloader.get());
// The StatusXMLDownloader class saves the response XML to the filesystem in order to parse it. This is needed to
// be able to reparse the XML in case the browser has crashed during autoupdate check, since we want to try hard
// to limit the request count made to the autoupdate server.
// The check type for the downloader determines if the response XML is saved in the autoupdate_response.xml file
// or a temporary file with a temporary name that will be lost right after the check is done.
RETURN_IF_ERROR(current_downloader->Init(StatusXMLDownloader::CheckTypeOther, this));

// Get the autoupdate XML request string basing on the items that we want to resolve
OpString8 xml_string;
RETURN_IF_ERROR(m_autoupdate_xml->GetRequestXML(xml_string));

// Save the StatusXMLDownloader to be able to recoginze it later
RETURN_IF_ERROR(m_xml_downloaders.Add(current_downloader.get()));

// Start the XML request, we'll get a callback via the StatusXMLDownloaderListener interface once the request
// is complete
RETURN_IF_ERROR(current_downloader->StartXMLRequest(autoupdate_server_url_string, xml_string));

// Since everything went fine, we want to set the StatusXMLDownloader pointer for all items that were requested
// with the above call.
for (UINT32 i=0; i<items.GetCount(); i++)
{
AdditionCheckerItem* item = items.Get(i);
OP_ASSERT(item);
item->SetXMLDownloader(current_downloader.get());
}

// Forget about the downloader now, we hold it in the m_xml_downloaders vector
current_downloader.release();
}
else
{
// No items of this type found currently, we'll pick up the remaining items with the next pass.
}
}
return OpStatus::OK;
}

void AdditionChecker::StatusXMLDownloaded(StatusXMLDownloader* downloader)
{
OP_ASSERT(downloader);
// Check if we have spawned the downloader that is calling us back
OP_ASSERT(m_xml_downloaders.Find(downloader) != -1);

// Get all the items that are currently waiting to be resolved by the downloader that is calling us back
OpVector<AdditionCheckerItem> items;
// We can't return an error from this method. The only reason for GetItemsForDownloader() to fail
// seems to be an OOM. Let's try to resume operation with whatever items there are, we need to get
// to deleting the downloader at the end of this method anyway.
OpStatus::Ignore(GetItemsForDownloader(items, downloader));

// The StatusXMLDownloader gives us a list of resources that it got in response to the HTTP request that was sent out.
// First, we check all the items that match both among the items waiting to be resolved and those sent by the downloader.
for (UINT32 i=0; i<items.GetCount(); i++)
{
AdditionCheckerItem* item = items.Get(i);
OP_ASSERT(item);

UpdatableResource* resource = downloader->GetFirstResource();

// Go through all the resources that are currently left in the downloader
while (resource)
{
UpdatableResource::UpdatableResourceType resource_type = resource->GetType();
URAttr resource_key = resource->GetResourceKey();

// You haven't implemented UpdatableResource::GetResourceKey() for your resource type if this assert triggers.
OP_ASSERT(URA_LAST != resource_key);

OpString key_value;

// If this resource is our addition...
if (OpStatus::IsSuccess(resource->GetAttrValue(resource_key, key_value)) && item->IsType(resource_type) && item->IsKey(key_value))
{
// Notify that it is resolved and forget about it
NotifyAdditionResolved(resource_type, key_value, resource);
RETURN_VOID_IF_ERROR(downloader->RemoveResource(resource));
// Note that we have invalid items in the items vector now, but we don't go back over it anyway
RETURN_VOID_IF_ERROR(m_items.Delete(item));
break;
}
resource = downloader->GetNextResource();
}
}

// Go through all the items that we should have gotten with this StatusXMLDownloader but we didn't
items.Clear();
// We can't return an error from this method. The only reason for GetItemsForDownloader() to fail
// seems to be an OOM. Let's try to resume operation with whatever items there are, we need to get
// to deleting the downloader at the end of this method anyway.
OpStatus::Ignore(GetItemsForDownloader(items, downloader));

// This shouldn't really happen since we should always get a response about an item if we ask about it
// but the autoupdate server has its ways.
for (UINT32 i=0; i<items.GetCount(); i++)
{
AdditionCheckerItem* item = items.Get(i);
OP_ASSERT(item);
OpString key;
if (OpStatus::IsSuccess(item->GetKey(key)))
{
// We can only notify if we can know the key.
NotifyAdditionResolveFailed(item->GetType(), key);
}

OpStatus::Ignore(m_items.Delete(item));
}

// Iterate over all the resources that the downloader sent us but that we have never asked for.
UpdatableResource* resource = downloader->GetFirstResource();
while (resource)
{
// If this is a setting then we'll handle it
if (resource->GetType() == UpdatableResource::RTSetting)
{
UpdatableSetting* setting = static_cast<UpdatableSetting*>(resource);
if (!(setting->CheckResource() && OpStatus::IsSuccess(setting->UpdateResource())))
OP_ASSERT(!"Could not update setting resource!");
}
else
{
// But if it's anything else then we're really confused
OP_ASSERT(!"Unexpected resource got from the autoupdate server!");
}
OpStatus::Ignore(downloader->RemoveResource(resource));
resource = downloader->GetNextResource();
}

// Delete the downloader finally.
OpStatus::Ignore(m_xml_downloaders.Delete(downloader));
}

void AdditionChecker::StatusXMLDownloadFailed(StatusXMLDownloader* downloader, StatusXMLDownloader::DownloadStatus status)
{
OP_ASSERT(downloader);
// Check if we know the downloader
OP_ASSERT(m_xml_downloaders.Find(downloader) != -1);

// Try to increment the server URL, i.e. use a different one next time. This will most likely fail since we use one server anyway.
OpStatus::Ignore(m_autoupdate_server_url->IncrementURLNo(AutoUpdateServerURL::Wrap));

// Get the list of all the items that should be resolved by this downloader
OpVector<AdditionCheckerItem> items;
// We can't return an error from this method. The only reason for GetItemsForDownloader() to fail
// seems to be an OOM. Let's try to resume operation with whatever items there are, we need to get
// to deleting the downloader at the end of this method anyway.
OpStatus::Ignore(GetItemsForDownloader(items, downloader));

for (UINT32 i=0; i<items.GetCount(); i++)
{
AdditionCheckerItem* item = items.Get(i);
OP_ASSERT(item);
// Increment the retry timer
item->IncRetryCounter();
// Set the downloader to NULL in order to pick this item up with the next resolve attempt.
item->SetXMLDownloader(NULL);

// However in case the item has reached the maximum retry count, notify it has failed to be resolved and drop it without a further retry
if (item->GetRetryCounterValue() >= RESOLVE_MAX_RETRY_COUNT_PER_ITEM)
{
OpString item_key;
UpdatableResource::UpdatableResourceType item_type = item->GetType();
if (OpStatus::IsSuccess(item->GetKey(item_key)))
NotifyAdditionResolveFailed(item_type, item_key);

OpStatus::Ignore(m_items.Delete(item));
}
}

// If there still are some items that should be retried, schedule a retry attempt
if (items.GetCount() > 0)
KickResolveTimer(KickDelayed);

OpStatus::Ignore(m_xml_downloaders.Delete(downloader));
}

void AdditionChecker::NotifyAdditionResolved(UpdatableResource::UpdatableResourceType type, const OpStringC& key, UpdatableResource* resource)
{
for (OpListenersIterator iterator(m_listeners); m_listeners.HasNext(iterator);)
m_listeners.GetNext(iterator)->OnAdditionResolved(type, key, resource);
}

void AdditionChecker::NotifyAdditionResolveFailed(UpdatableResource::UpdatableResourceType type, const OpStringC& key)
{
for (OpListenersIterator iterator(m_listeners); m_listeners.HasNext(iterator);)
m_listeners.GetNext(iterator)->OnAdditionResolveFailed(type, key);
}

UINT32 AdditionChecker::GetKnownTypesCount()
{
size_t item_size = sizeof(UpdatableResource::UpdatableResourceType);
size_t full_size = sizeof(KNOWN_TYPES);
return full_size / item_size;
}

bool AdditionChecker::IsKnownType(UpdatableResource::UpdatableResourceType type)
{
UINT32 count = GetKnownTypesCount();
for (UINT32 i=0; i<count; i++)
{
if (KNOWN_TYPES[i] == type)
return true;
}
return false;
}

void AdditionChecker::KickResolveTimer(KickType type)
{
OP_ASSERT(m_resolve_timer);
if (KickNow == type)
m_resolve_timer->Start(RESOLVE_TIMER_KICK_NOW_PERIOD_SEC * 1000);
else
m_resolve_timer->Start(RESOLVE_TIMER_KICK_DELAYED_PERDIOD_SEC * 1000);
}

/***********************
* AdditionCheckerItem *
***********************/

AdditionCheckerItem::AdditionCheckerItem():
m_status_xml_downloader(NULL),
m_type(UpdatableResource::RTEmpty),
m_retry_counter(0)
{
}

AdditionCheckerItem::~AdditionCheckerItem()
{
}

OP_STATUS AdditionCheckerItem::SetKey(const OpStringC& key)
{
return m_key.Set(key);
}

void AdditionCheckerItem::SetType(UpdatableResource::UpdatableResourceType type)
{
m_type = type;
}

OP_STATUS AdditionCheckerItem::GetKey(OpString& key)
{
return key.Set(m_key);
}

UpdatableResource::UpdatableResourceType AdditionCheckerItem::GetType()
{
return m_type;
}

bool AdditionCheckerItem::IsType(UpdatableResource::UpdatableResourceType type)
{
return m_type == type;
}

bool AdditionCheckerItem::IsKey(const OpStringC& key)
{
return m_key.CompareI(key) == 0;
}

bool AdditionCheckerItem::IsXMLDownloader(const StatusXMLDownloader* downloader)
{
return m_status_xml_downloader == downloader;
}

void AdditionCheckerItem::SetXMLDownloader(const StatusXMLDownloader* downloader)
{
m_status_xml_downloader = downloader;
}

const StatusXMLDownloader* AdditionCheckerItem::GetXMLDownloader()
{
return m_status_xml_downloader;
}

#endif // AUTO_UPDATE_SUPPORT

+ 374
- 0
adjunct/autoupdate/additionchecker.h View File

@@ -0,0 +1,374 @@
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2011 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser. It may not be distributed
* under any circumstances.
*
* @author Michal Zajaczkowski
*/

#ifdef AUTO_UPDATE_SUPPORT

#ifndef AUTOUPDATE_ADDITION_CHECKER_H
#define AUTOUPDATE_ADDITION_CHECKER_H

#include "modules/util/adt/oplisteners.h"
#include "modules/hardcore/timer/optimer.h"
#include "adjunct/autoupdate/autoupdatexml.h"
#include "adjunct/autoupdate/autoupdateserverurl.h"
#include "adjunct/autoupdate/statusxmldownloader.h"

class AutoUpdateXML;
class AutoUpdateManager;
class AutoUpdateServerURL;
class AdditionCheckerListener;

/**
* AdditionCheckerItem represents a single addition item that is being resolved by the addition checker.
* Each item has a type (i.e. UpdatableResource::ResourceTypePlugin), a key (i.e. the mimetype of the plugin) and a
* StatusXMLDownloader* value.
* If the item is not waiting to be resolved by any StatusXMLDownloader, then it has the downloader value set to NULL.
* Otherwise the downloader value points to the StatusXMLDownloader object that should send back information about this
* particular item.
*/
class AdditionCheckerItem
{
public:
AdditionCheckerItem();
~AdditionCheckerItem();

/**
* Sets the value of the key of the addition item (i.e. the plugin mime-type)
*
* @param key - the new value of the key
*
* @returns - OpStatus:OK if setting the key value succeeds, ERR otherwise
*/
OP_STATUS SetKey(const OpStringC& key);

/**
* Sets the type of the addition item (i.e. UpdatableResource::ResourceTypePlugin)
*
* @param type - the new type to set
*
* @returns nothing
*/
void SetType(UpdatableResource::UpdatableResourceType type);

/**
* Assings a StatusXMLDownloader to the addition item, designating that item is pending an autoupdate response from the
* particular downloader. If this value is NULL, then the item is pending to be resolved.
*
* @param downloader - the new StatusXMLDownloader* value
*/
void SetXMLDownloader(const StatusXMLDownloader* downloader);

/**
* Get the key of the item (i.e. the mime-type of a plugin)
*
* @param key - a reference to an OpString that will get the key value in case of success
*
* @returns - OpStatus::OK in case the value was set OK, ERR otherwise
*/
OP_STATUS GetKey(OpString& key);

/**
* Get the type of the item, i.e. UpdatableResource::ResourceTypePlugin
*
* @returns - the type of the item
*/
UpdatableResource::UpdatableResourceType GetType();

/**
* Get the StatusXMLDownloader* value assinged to the item, see SetXMLDownloader()
*
* @returns - the StatusXMLDownloader* value
*/
const StatusXMLDownloader* GetXMLDownloader();

/**
* Check if this item is of the given type
*
* @param type - the type that we want to verify against the type of this item
*
* @returns - TRUE in case the type of this item matches the given type, FALSE otherwise
*/
bool IsType(UpdatableResource::UpdatableResourceType type);

/**
* Check if this item has the given key value
*
* @param key - the key value that we want to check against the key of this item
*
* @returns TRUE in case the keys match, FALSE otherwise
*/
bool IsKey(const OpStringC& key);

/**
* Check if the value of the StatusXMLDownloader pointer assigned to this item matches the given value
*
* @param downloader - the StatusXMLDownloader pointer value that is to be checked against the value stored with this item
*
* @returns - TRUE in case the pointers match, FALSE otherwise
*/
bool IsXMLDownloader(const StatusXMLDownloader* downloader);

/**
* Increment the resolve retry counter for this item. This method does not check if the pointer exceeded the maximum retry count.
*/
void IncRetryCounter() { m_retry_counter++; }

/**
* Get the retry counter value to compare against the maximum retry count in the calling code.
*
* @returns - the current retry count for the given item
*/
unsigned int GetRetryCounterValue() { return m_retry_counter; }

private:
/**
* The value of the key for this item. The key is an unique identifier among all items of the same type, i.e. a mime-type for a plugin.
*/
OpString m_key;

/**
* The value of the StatusXMLDownloader pointer assigned to this item. This is NULL in case this item is pending resolving and it points
* to a downloader that should resolve this item in case the item has been requested to resolve.
*/
const StatusXMLDownloader* m_status_xml_downloader;

/**
* Type of the addition represented by this item, i.e. UpdatableResource::ResourceTypePlugin.
*/
UpdatableResource::UpdatableResourceType m_type;

/**
* The resolve retry counter that counts how many times a request about the given item has been sent to the autoupdate server.
* Used to have a resolve retry mechanism that will give up after RESOLVE_MAX_RETRY_COUNT_PER_ITEM attempts.
*/
unsigned int m_retry_counter;
};

/**
* The autoupdate server currently serves two quite different purposes:
* 1. Keeping the browser up-to-date with periodic automatic checks and manual checks;
* 2. Making it possible to discover and download "additions" via the autoupdate server.
*
* An addition is any additional installable resource that might be needed during the browser run, currently
* the only supported addition types are plugins and dictionaries, both installable on user demand. If the user
* visits a page that requires a given plugin, the plugin availablity is checked against the autoupdate server with
* the additions mechanisms.
*
* If you want to add a new type of resource that you want to resolve via the autoupdate server, you need to:
* 1. Add a new resource type (see updatableresource.h, updatablefile.h);
* 2. Add the new resource to the KNOWN_TYPES[] array;
* 3. Agree with the core services team that the autoupdate server will support the new resource, agree a new update level for the new resource type! See
* AutoUpdateXML::AutoUpdateLevel.
* 4. Make sure the UpdatableResourceFactory is able to recognize all the XML elements used to describe the new resource
* type;
* 5. Choose a key for the new resource. This is the value that is supposed to be unique across all resources of the same type,
* i.e. the mimetype for a plugin or the language for a dictionary, make sure you implement the key by implementing the
* UpdatableResource::GetResourceKey() method.
* 6. Make sure AutoUpdateXML can recognize the new resource type, choose a new update check level and generate a proper XML for the new item type.
* 7. You should get asserts if you forget about any of the above;
*
* In order to resolve a resource:
* 1. Make your class inherit from the AdditionCheckerListener class, implement its methods;
* 2. Register yourself as a listener with something like g_autoupdate_manager->AddListener(this);
* 3. Call g_autoupdate_manager->CheckForAddition() to check the availability of the addition and wait for a callback via the
* AdditionCheckerListener interface;
* 4. Carry on.
*
* The addition checker will try to repeat failed requests to the autoupdate server on its own, so you can consider that when it
* fails to resolve the addition, it fails for good.
* The addition checker may make a couple of HTTP requests to the autoupdate server in parallel in order to speed up things.
* The addition checker will send a cummulative requst about all additions of a given type that are not resolved at the moment
* of seding the request.
*
* The AdditionChecker class is meant to be used by the AutoUpdateManager only. The AutoUpdateManager has all the interfaces
* required to use the addition resolving functionality.
*
*/
class AdditionChecker:
public OpTimerListener,
public StatusXMLDownloaderListener
{
friend class AutoUpdateManager;
public:
AdditionChecker();
virtual ~AdditionChecker();

protected:
/**
* The list of types that the AdditionChecker is be able to resolve.
*/
static UpdatableResource::UpdatableResourceType KNOWN_TYPES[];
/**
* The resolve timer timeout period for the KickNow kick type.
*/
static const unsigned int RESOLVE_TIMER_KICK_NOW_PERIOD_SEC;
/**
* The resolve timer timeout period for the KickDelayed kick type.
*/
static const unsigned int RESOLVE_TIMER_KICK_DELAYED_PERDIOD_SEC;
/**
* The maximum retry count per a queued addition item, if the addition is not resolved after this many tries, it's
* broadcasted as failed.
*/
static const unsigned int RESOLVE_MAX_RETRY_COUNT_PER_ITEM;

enum KickType
{
/**
* Start the resolve timer using the RESOLVE_TIMER_KICK_DELAYED_PERDIOD_SEC period
*/
KickDelayed,
/**
* Start the resolve timer using the RESOLVE_TIMER_KICK_NOW_PERIOD_SEC period
*/
KickNow
};

/**
* Initializes the object, needs to be called once before any operations are made on the AdditionChecker.
*
* @returns - OpStatus::OK if initialization went OK, ERR otherwise. The object can't be used until Init() returns OpStatus::OK.
*/
OP_STATUS Init();

/**
* OpTimerListener implementation.
*/
virtual void OnTimeOut(OpTimer* timer);

/**
* Handler for resolve timer. Will send out autoupdate XML requests for items awaiting resolving.
*
* @returns - OpStatus::OK on success, ERR otherwise.
*/
OP_STATUS OnResolveTimeOut();

/**
* Implementation of the StatusXMLDownloaderListener interface.
*/
virtual void StatusXMLDownloaded(StatusXMLDownloader* downloader);
virtual void StatusXMLDownloadFailed(StatusXMLDownloader* downloader, StatusXMLDownloader::DownloadStatus status);

/**
* Register a listener with the addition resolver. You don't want to do that with your classes, use g_autoupdate_manager->AddListener().
*
* @param listener - a pointer to a class inheriting from the AdditionCheckerListener interface.
*
* @returns - OpStatus::OK if adding the listener succeeded, OpStatus::ERR otherwise.
*/
OP_STATUS AddListener(AdditionCheckerListener* listener);

/**
* Unregister a listener with the addition resolver. You don't want to do that with your classes, use g_autoupdate_manager->RemoveListener().
*
* @param listener - a pointer to a class inheriting from the AdditionCheckerListener interface.
*
* @returns - OpStatus::OK if removing the listener succeeded, OpStatus::ERR otherwise.
*/
OP_STATUS RemoveListener(AdditionCheckerListener* listener);

/**
* Try to resolve an addition of the given type and the given key against the autoupdate server. You don't want to use this, use
* g_autoupdate_manager->CheckForAddition() instead.
* Before you call this method, be sure to register as a listener to AdditionChecker.
* After a call to this method, wait for a callback via the AdditionCheckerListener interface.
* Note that the actual XML request will be made later on, after the resolve timer fires.
*
* @param type - the type of the addition to be resolved.
* @param key - the key of the addition to be resolved.
*
* @returns - OpStatus::OK if queing the addition check was OK, ERR otherwise.
*/
OP_STATUS CheckForAddition(UpdatableResource::UpdatableResourceType type, const OpStringC& key);

/**
* Starts the resolve timer with the timeout period determined by the parameter given.
*
* @param type - determines the timeout period, see KickType definition.
*/
void KickResolveTimer(KickType type);

/**
* Notifies all the registered listeners about an addition being resolved or failed to resolve.
*/
void NotifyAdditionResolved(UpdatableResource::UpdatableResourceType type, const OpStringC& key, UpdatableResource* resource);
void NotifyAdditionResolveFailed(UpdatableResource::UpdatableResourceType type, const OpStringC& key);

/**
* Checks if a resource with the given type can be resolved as an addition.
*/
bool IsKnownType(UpdatableResource::UpdatableResourceType type);

/**
* Get the total number of the types recognized as additions. Returns the number of items in the KNOWN_TYPES[] array.
*/
UINT32 GetKnownTypesCount();

/**
* Searches the m_items vector for an item with the given type and key.
* The m_items vector should never contain more than one item with the same type AND key, i.e. we should never have queued
* more than one plugin with the same mime-type.
* This method doesn't check that condition, it relies on CheckForAddition() making the proper checks.
*
* @param type - addition type
* @param key - addition key
*
* @returns - a pointer to the addition item found, if one, NULL otherwise.
*/
AdditionCheckerItem* GetItem(UpdatableResource::UpdatableResourceType type, const OpStringC& key);

/**
* Searches the m_items vector for all items that have the given StatusXMLDownloader assigned to them.
*
* @param items - a reference to a vector that will contain the items found.
* @param downloader - a pointer to the StatusXMLDownloader that we're looking for, may be NULL.
*
* @returns - OpStatus::OK if everything went fine, ERR otherwise.
*/
OP_STATUS GetItemsForDownloader(OpVector<AdditionCheckerItem>& items, StatusXMLDownloader* downloader);

/**
* Searches the m_items vector for all items that have the given StatusXMLDownloader assigned to them AND that are of the given type.
*
* @param items - a reference to a vector that will contain the items found.
* @param downloader - a pointer to the StatusXMLDownloader that we're looking for, may be NULL.
* @param type - the type of the items that we care about.
*
* @returns - OpStatus::OK if everything went fine, ERR otherwise.
*/
OP_STATUS GetItemsForDownloaderAndType(OpVector<AdditionCheckerItem>& items, StatusXMLDownloader* downloader, UpdatableResource::UpdatableResourceType type);

/**
* Hold a list of StatusXMLDownloader objects that were created when making the XML requests.
* A downloader is destroyed and removed after a callback is returned from it via the StatusXMLDownloaderListener interface.
* Additionally, if any downloaders still exist while the AdditionChecker is destroyed, they are stopped and destroyed as well.
*/
OpVector<StatusXMLDownloader> m_xml_downloaders;

/**
* The resolve timer.
*/
OpTimer* m_resolve_timer;

/**
* The list of registered listeners.
*/
OpListeners<AdditionCheckerListener> m_listeners;

/**
* The list of addition checker items that are awaiting resolving.
*/
OpVector<AdditionCheckerItem> m_items;

AutoUpdateServerURL* m_autoupdate_server_url;
AutoUpdateXML* m_autoupdate_xml;
};

#endif // AUTOUPDATE_ADDITION_CHECKER_H
#endif // AUTO_UPDATE_SUPPORT

+ 49
- 0
adjunct/autoupdate/additioncheckerlistener.h View File

@@ -0,0 +1,49 @@
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2011 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser. It may not be distributed
* under any circumstances.
*
* @author Michal Zajaczkowski
*/

#ifdef AUTO_UPDATE_SUPPORT

#ifndef AUTOUPDATE_ADDITION_CHECKER_LISTENER_H
#define AUTOUPDATE_ADDITION_CHECKER_LISTENER_H

/**
* The listener interface for the AdditionChecker. Implement this to get notifications about an addition resolve result.
* In order to receive the notifications, register with the g_autoupdate_manager->AddListener().
*/
class AdditionCheckerListener
{
public:
virtual ~AdditionCheckerListener() {};

/**
* Called if an addition was able to resolve succesfully. You need to check if this call is for you, since notifications for ALL queued items
* are broadcasted to ALL registered listeners.
* You need to know what you have requested and ignore calls that are not meant for you.
*
* @param type - the type of the addition that was just resolved.
* @param key - the key of the addition that was just resolved.
* @param resource - a pointer to an UpdatableResource object representing the addition that was resolved. You receive the ownership of this
* resource with this call, so be very careful to filter out the calls that are meant for you.
*/
virtual void OnAdditionResolved(UpdatableResource::UpdatableResourceType type, const OpStringC& key, UpdatableResource* resource) = 0;

/**
* Called when an addition finally failed to resolve after a few retries (RESOLVE_MAX_RETRY_COUNT_PER_ITEM). Since this might still be
* a network or the autoupdate server issue it might have sense to ask about this addition later on.
* The autoupdate server should be configured in such a way that is sends a meaningful resources for calls that request an addition that
* can't be served by it, i.e. a request for a plugin that we don't offer for automatic installation still returns an XML with a plugin
* description that has a <has-installer> XML element with a zero value.
* This call is meant to inform that there was a problem with receiving any answer about this addition from the server.
*/
virtual void OnAdditionResolveFailed(UpdatableResource::UpdatableResourceType type, const OpStringC& key) = 0;
};

#endif // AUTOUPDATE_ADDITION_CHECKER_LISTENER_H
#endif // AUTO_UPDATE_SUPPORT

+ 4
- 0
adjunct/autoupdate/autoupdate_checker/.gitignore View File

@@ -0,0 +1,4 @@
/Output/
*.*sdf
*.suo
*.user

+ 70
- 0
adjunct/autoupdate/autoupdate_checker/adaptation_layer/global_storage.h View File

@@ -0,0 +1,70 @@
/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
**
** Copyright (C) 2012 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
**
*/

#ifndef OAUC_GLOBAL_STORAGE_H
#define OAUC_GLOBAL_STORAGE_H

#include "adjunct/autoupdate/autoupdate_checker/common/common.h"

namespace opera_update_checker
{
namespace global_storage
{
static const char* UUID_KEY = "UUID";
static const char* LUT_KEY = "LUT";

/** The class representing a system global storage e.g. the system registry on Windows. */
class GlobalStorage
{
private:
GlobalStorage(GlobalStorage&) {}
protected:
GlobalStorage() {}
virtual ~GlobalStorage() {}
public:
/** The factory method. */
static GlobalStorage* Create();
/** The terminator */
static void Destroy(GlobalStorage* storage);
/** Sets Opera product name. Function is used only on OsX for meet
* Apple sandbox policy.
*
* @param[in] product_type - Opera product name.
*/
virtual void SetOperaProductType(const char* product_type) {};
/** Stores the data identified by the key in the storage.
*
* If the data, key pair entry already exists its data is updated.
* Otherwise a new entry with the data, key pair is created and stored.
*
* @param[in] key - the key to identify the data by. Shouldn't be NULL.
* @param[in] data - the data to be set. May be NULL in which case the given key,data pair entry should be deleted.
* @param[in] data_len - the length of the data.
*
* @return StatusCode
* @see StatusCode
*/
virtual status::Status SetData(const char *key, const char* data, unsigned long data_len) = 0;
/** Gets the data associated with the given key (NULL if there's no such data).
* The caller is responsible for deleting the returned buffer.
*
* @param[in] key - the key to identify the data by. Shouldn't be NULL.
* @param[in] data - a pointer to the buffer the data is put in.
* @param[out] data_len - the length of the data.
*
* @return StatusCode
* @see StatusCode
*/
virtual status::Status GetData(const char *key, const char*& data, unsigned long& data_len) = 0;
};
}
}

#endif // OAUC_GLOBAL_STORAGE_H

+ 133
- 0
adjunct/autoupdate/autoupdate_checker/adaptation_layer/ipc.h View File

@@ -0,0 +1,133 @@
/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
**
** Copyright (C) 2012 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
*/

#ifndef OAUC_IPC_H
# define OAUC_IPC_H

#include "adjunct/autoupdate/autoupdate_checker/common/common.h"

namespace opera_update_checker
{
namespace ipc
{
enum MessageType
{
AUTOUPDATE_STATUS
};

/** The struct describing a message passed between processes. */
struct Message
{
Message() : data(NULLPTR), data_len(0), owns_data(false) {}
~Message()
{
if (owns_data)
OAUC_DELETEA(data);
}
MessageType type;
char* data;
unsigned long data_len;
bool owns_data;
};

class Channel;
class Channel
{
private:
Channel(Channel&) {}
protected:
Channel() {}
virtual ~Channel() {}
public:
/** The mode of this channel. */
enum ChannelMode
{
CHANNEL_MODE_READ = 0x1, /**< The channel may only be read from. */
CHANNEL_MODE_WRITE = 0x2, /**< The channel may only be written to. */
CHANNEL_MODE_READ_WRITE = CHANNEL_MODE_READ | CHANNEL_MODE_WRITE /**< The channel may be both read and written. */
};

/** The flow direction of this channel. */
enum ChannelFlowDirection
{
FROM_SERVER_TO_CLIENT,
FROM_CLIENT_TO_SERVER,
BIDIRECTIONAL
};

/** The factory method.
*
* @param[in] is_server - If true it's the server part which creates this channel (the client otherwise).
* @param[in] name - The unique id of the pipe to be used for creating pipe's name.
* Its to ensure communicating processes have the same unique pipe name.
* @param[in] mode - The mode of this channel.
* @param[in] flow_direction - The flow direction of this channel.
*
* @see ChannelMode
* @see ChannelType
* @see ChannelFlowDirection
*/
static Channel* Create(bool is_server, PidType id, ChannelMode mode, ChannelFlowDirection flow_direction);

/** The terminator */
static void Destroy(Channel* channel);

/** Connects to the channel synchronously with a timeout.
*
* @param[in] timeout - The wait timeout. If it's RETURN_IMMEDIATELY there is no timeout.
* If it's WAIT_INFINITELY this function blocks.
*
* @return StatusCode.
* @see StatusCode.
* @see OAUCTime.
*/
virtual status::Status Connect(const OAUCTime& timeout) = 0;

/** Returns true if the channel is connected. Otherwise false. */
virtual bool IsConnected() = 0;

/** Disconnects from the channel. */
virtual void Disconnect() = 0;

/** Sends a message synchronously with a timeout.
*
* @param[in] message - The message to be sent.
* @param[in] timeout - The wait timeout. If it's RETURN_IMMEDIATELY there is no timeout.
* If it's WAIT_INFINITELY this function blocks.
*
* @return StatusCode.
* @see StatusCode.
* @see Message.
* @see OAUCTime.
*/
virtual status::Status SendMessage(const Message& message, const OAUCTime& timeout) = 0;

/** Gets a message synchronously with a timeout.
*
* @param[in] timeout - The wait timeout. If it's RETURN_IMMEDIATELY there is no timeout.
* If it's WAIT_INFINITELY this function blocks.
*
* @return A pointer to a message or NULL on error. The caller must release the message when no longer needed.
*
* @see Message.
* @see OAUCTime.
*/
virtual const Message* GetMessage(const OAUCTime& timeout) = 0;
}; // class Channel

/** Returns the process Id of the current process, used for finding out
* a unique name for a channel.
* PidType is defined in platform-specific platform.h header and is an
* integer type (ex. pid_t on POSIX, DWORD on Windows).
*/
PidType GetCurrentProcessId();
} // namespace ipc
}

#endif // OAUC_IPC_H

+ 109
- 0
adjunct/autoupdate/autoupdate_checker/adaptation_layer/network.h View File

@@ -0,0 +1,109 @@
/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
**
** Copyright (C) 2012 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
*/

#ifndef OAUC_NETWORK_H
# define OAUC_NETWORK_H

# include "../common/common.h"

namespace opera_update_checker
{
namespace network
{
/** The class hiding the details of the network layer using the HTTP protocol. */
class Network
{
private:
Network(Network&) {}
protected:
Network() {}
virtual ~Network() {}
public:
/** Method which should be used when issuing the request. */
enum Method
{
GET, /**< Use HTTP GET method. */
POST /**< Use HTTP POST method. */
};

/** The struct encapsulating the request data. */
struct RequestData
{
RequestData() : data(NULLPTR), data_mime_type(NULLPTR)
{
}
/** The data. */
const char* data;
/** The length of the data. */
unsigned data_length;
/** The mime type of the data. May be NULL. It's ignored when the method is POST as application/x-www-form-urlencoded is assumed then. */
const char* data_mime_type;
};

/** The location of the certificate to be used to verify https host. */
enum CertificateLocation
{
/** The certificate is in a file. */
CERTIFICATE_FILE,
/** The certificate could be found in a directory. */
CERTIFICATE_DIR,
/** The certificate is in the memory. */
CERTIFICATE_MEMORY
}; // enum CertificateLocation

/** Info about the certificate to be used. */
struct CertificateInfo
{
/**
* If location is CERTIFICATE_DIR or CERTIFICATE_FILE it's the path to
* the certificate store/file. Otherwise it's certificate's data.
* Must not be NULLPTR.
*/
const char* certificate;
/** Format of the certificate e.g. "PEM". Must not be NULLPTR. */
const char* certificate_format;
/** Specifies if the certificate is in the memory or in the filesystem. */
CertificateLocation location;
}; // struct CertificateInfo

/** The response observer interface. Must be overridden by interested in getting the response. */
class ResponseObserver
{
public:
/** Called when some header is got. */
virtual void OnHeaderReceived(const char* header, unsigned long data_len) = 0;
/** Called when some data (other then an header) is got. */
virtual void OnDataReceived(const char* data, unsigned long data_len) = 0;
};

/** The factory method. */
static Network* Create();
/** The terminator. */
static void Destroy(Network* network);

/** Sends the given request to a server given by the url using the specified method.
* Blocks until the comunnication is done.
*
* @param url[in] - the server url to send the request to.
* @param is_secure[in] - true if HTTPs protocol should be used.
* @param cert[in] - relevant only if is_secure is true. Contains the certificate to be used for host verification. @see CertificateInfo.
* @param method[in] - the method to be used. @see Method.
* @param data[in] - the data to be sent. Some parts of it may be ignored depending on the method used. @see RequestData.
* @param observer[in] - the observer to be notified about the response.
*
* @return StatusCode. @see StatusCode.
*/
virtual status::Status SendHTTPRequest(const char* url, bool is_secure, const CertificateInfo* cert, Method method, const RequestData& data, ResponseObserver* observer) = 0;

/** Gets the HTTP response code. The return value will be zero if no server response code has been received. */
virtual unsigned GetResponseCode() = 0;
};
}
}
#endif // OAUC_NETWORK_H

+ 142
- 0
adjunct/autoupdate/autoupdate_checker/adaptation_layer/protocol.h View File

@@ -0,0 +1,142 @@
/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
**
** Copyright (C) 2012 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
**
*/

#ifndef OAUC_XML_H
# define OAUC_XML_H

# include "../common/common.h"

namespace opera_update_checker
{
namespace protocol
{
/** The class hiding the details of the request to the autoupdate server. */
class Request
{
private:
Request(Request&) {}
protected:
Request() {}
virtual ~Request() {}
public:
/** The factory method returning an instance of this class. */
static Request* Create();
/** The terminator. */
static void Destroy(Request* p);

/** Provides the data needed to compose the main request part. The data is owned by the provider. */
class UpdateDataProvider
{
public:
virtual ~UpdateDataProvider() {}
virtual const char* GetProductName() const = 0;
virtual status::Status GetUUID(const char*&) const = 0;
virtual status::Status GetLUT(const char*&) const = 0;
virtual const char* GetOsName() const = 0;
virtual const char* GetOsVersion() const = 0;
virtual const char* GetArch() const = 0;
virtual const char* GetPackage() const = 0;
virtual const char* GetFirstRunVersion() const = 0;
virtual const char* GetFirstRunTimestamp() const = 0;
virtual const char* GetUserLocation() const = 0;
virtual const char* GetDetectedLocation() const = 0;
virtual const char* GetActiveLocation() const = 0;
virtual const char* GetRegion() const = 0;
virtual const char* GetProductLanguage() const = 0;
virtual const char* GetProductVersion() const = 0;
};

/** Causes the main update check part (metrics, Opera binary) to be composed and added the the data.
*
* @param[in] provider - The update data provider.
* @param[in] with_metrics - If true the metrics data will be included.
*
* @return StatusCode
* @see StatusCode
* @see UpdateDataProvider
*/
virtual status::Status ComposeMainUpdatePart(const UpdateDataProvider& data_provider, bool with_metrics) = 0;
/** Stores data about needed resources got from a product.
*
* @param[in] raw_data - the data to be added.
*
* @return StatusCode
* @see StatusCode
*/
virtual status::Status SetProductResourcesUpdatePart(const char* raw_data) = 0;
/** Adds whole product data to the product specific data section.
*
* @param[in] provider - The update data provider.
*
* @return StatusCode
* @see StatusCode
* @see UpdateDataProvider
*/
virtual status::Status AddProductUpdatePart(const UpdateDataProvider& provider) = 0;
/** Gets the whole request data (might be NULL if no data has been composed/added).
* The type and format of the data depends on the underlying implementation.
*/
virtual const char* GetAllData() = 0;
/** Clears the current content of the request. */
virtual void Clear() = 0;
};

/** The class hiding the details of the request to the autoupdate server. */
class Response
{
private:
Response(Response&) {}
protected:
Response() {}
virtual ~Response() {}
public:
/** The factory method returning an instance of this class. */
static Response* Create();
/** The terminator. */
static void Destroy(Response* p);

/** Adds the response data to be parsed when Parse() is called.
*
* @param[in] data - the response data.
* @param[in] data_len - the length of the data.
*
* @return StatusCode
* @see StatusCode
*/
virtual status::Status AddData(const char* data, unsigned data_len) = 0;

/** Parses the response data.
*
* @return StatusCode
* @see StatusCode
*/
virtual status::Status Parse() = 0;

/** Gets UUID from the response. */
virtual const char* GetUUID() = 0;

/** Gets LUT (last update timestamp) from the response. */
virtual const char* GetLUT() = 0;

/** Gets the retry time. The retry time > 0 means the response is incomplete and the request
* should be sent again after the given retry time. */
virtual unsigned GetRetryTime() = 0;

/** Gets the whole response data (might be NULL if no data has been composed/added).
* The type and format of the data depends on the underlying implementation.
*/
virtual const char* GetAllRawData() = 0;
/** Clears the current content of the response. */
virtual void Clear() = 0;
};
}
}

#endif // OAUC_XML_H

+ 34
- 0
adjunct/autoupdate/autoupdate_checker/adaptation_layer/system_info.h View File

@@ -0,0 +1,34 @@
/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
**
** Copyright (C) 2012 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
**
*/

#ifndef OAUC_SYSTEM_INFO_H
# define OAUC_SYSTEM_INFO_H

namespace opera_update_checker
{
namespace system_info
{
/** The class providing information about the system. */
class SystemInfo
{
public:
/** Returns operating system's name e.g. "Windows". Never NULL. */
static const char* GetOsName();
/** Returns operating system's version e.g. "7" for Windows 7. Never NULL. */
static const char* GetOsVersion();
/** Returns computer's architecture e.g. "x86". Never NULL. */
static const char* GetArch();
/** Returns expected package type e.g. "EXE". Never NULL. */
static const char* GetPackageType();
};
}
}

#endif // OAUC_SYSTEM_INFO_H

+ 32
- 0
adjunct/autoupdate/autoupdate_checker/adaptation_layer/system_utils.h View File

@@ -0,0 +1,32 @@
/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: s; c-basic-offset: 2 -*-
**
** Copyright (C) 2012 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
**
*/

#ifndef OAUC_SYSTEM_UTILS_H
# define OAUC_SYSTEM_UTILS_H

#include "adjunct/autoupdate/autoupdate_checker/common/common.h"

namespace opera_update_checker
{
namespace system_utils
{
/** The class providing the functionality using the underlying system's infrastructure. */
class SystemUtils
{
public:
/** Should sleep the calling process for the given amount of time in miliseconds. */
static void Sleep(OAUCTime time);
/** Case insensitive strncmp(). */
static int strnicmp(const char* str1, const char* str2, size_t num_chars);
};
}
}

#endif // OAUC_SYSTEM_UTILS_H

+ 50
- 0
adjunct/autoupdate/autoupdate_checker/autoupdate_checker_vc2010.sln View File

@@ -0,0 +1,50 @@

Microsoft Visual Studio Solution File, Format Version 11.00
# Visual C++ Express 2010
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "autoupdate_checker", "autoupdate_checker_vc2010.vcxproj", "{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}"
ProjectSection(ProjectDependencies) = postProject
{87EE9DA4-DE1E-4448-8324-183C98DCA588} = {87EE9DA4-DE1E-4448-8324-183C98DCA588}
{C406DAEC-0886-4771-8DEA-9D7329B46CC1} = {C406DAEC-0886-4771-8DEA-9D7329B46CC1}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tinyxml", "platforms\universal_adaptation_layer\tinyxml\tinyxml_lib.vcxproj", "{C406DAEC-0886-4771-8DEA-9D7329B46CC1}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libcurl", "platforms\universal_adaptation_layer\network\curl\lib\libcurl.vcxproj", "{87EE9DA4-DE1E-4448-8324-183C98DCA588}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Debug|x64 = Debug|x64
Release|Win32 = Release|Win32
Release|x64 = Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Debug|Win32.ActiveCfg = Debug|Win32
{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Debug|Win32.Build.0 = Debug|Win32
{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Debug|x64.ActiveCfg = Debug|x64
{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Debug|x64.Build.0 = Debug|x64
{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Release|Win32.ActiveCfg = Release|Win32
{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Release|Win32.Build.0 = Release|Win32
{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Release|x64.ActiveCfg = Release|x64
{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}.Release|x64.Build.0 = Release|x64
{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Debug|Win32.ActiveCfg = Debug|Win32
{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Debug|Win32.Build.0 = Debug|Win32
{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Debug|x64.ActiveCfg = Debug|x64
{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Debug|x64.Build.0 = Debug|x64
{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Release|Win32.ActiveCfg = Release|Win32
{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Release|Win32.Build.0 = Release|Win32
{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Release|x64.ActiveCfg = Release|x64
{C406DAEC-0886-4771-8DEA-9D7329B46CC1}.Release|x64.Build.0 = Release|x64
{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Debug|Win32.ActiveCfg = Debug|Win32
{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Debug|Win32.Build.0 = Debug|Win32
{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Debug|x64.ActiveCfg = Debug|x64
{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Debug|x64.Build.0 = Debug|x64
{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Release|Win32.ActiveCfg = Release|Win32
{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Release|Win32.Build.0 = Release|Win32
{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Release|x64.ActiveCfg = Release|x64
{87EE9DA4-DE1E-4448-8324-183C98DCA588}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

+ 447
- 0
adjunct/autoupdate/autoupdate_checker/autoupdate_checker_vc2010.vcxproj View File

@@ -0,0 +1,447 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Instrumented|Win32">
<Configuration>Instrumented</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Instrumented|x64">
<Configuration>Instrumented</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="PGO|Win32">
<Configuration>PGO</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="PGO|x64">
<Configuration>PGO</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="vTune|Win32">
<Configuration>vTune</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="vTune|x64">
<Configuration>vTune</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClCompile Include="autoupdatechecker.cpp" />
<ClCompile Include="platforms\universal_adaptation_layer\networkimpl.cpp" />
<ClCompile Include="platforms\universal_adaptation_layer\protocolimpl.cpp" />
<ClCompile Include="platforms\windows\globalstorageimpl.cpp" />
<ClCompile Include="platforms\windows\ipcimpl.cpp" />
<ClCompile Include="platforms\windows\main_win.cpp" />
<ClCompile Include="platforms\windows\systeminfoimpl.cpp" />
<ClCompile Include="platforms\windows\systemutilsimpl.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="adaptation_layer\global_storage.h" />
<ClInclude Include="adaptation_layer\ipc.h" />
<ClInclude Include="adaptation_layer\ipcconfig.h" />
<ClInclude Include="adaptation_layer\message_types.h" />
<ClInclude Include="adaptation_layer\network.h" />
<ClInclude Include="adaptation_layer\protocol.h" />
<ClInclude Include="adaptation_layer\system_info.h" />
<ClInclude Include="adaptation_layer\system_utils.h" />
<ClInclude Include="autoupdatechecker.h" />
<ClInclude Include="common\common.h" />
<ClInclude Include="platforms\universal_adaptation_layer\all_includes.h" />
<ClInclude Include="platforms\universal_adaptation_layer\networkimpl.h" />
<ClInclude Include="platforms\universal_adaptation_layer\protocolimpl.h" />
<ClInclude Include="platforms\windows\includes\globalstorageimpl.h" />
<ClInclude Include="platforms\windows\includes\ipcconfig.h" />
<ClInclude Include="platforms\windows\includes\ipcimpl.h" />
<ClInclude Include="platforms\windows\includes\platform.h" />
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{7DB78C53-BA4D-4D95-BB5C-F3AA75C18C63}</ProjectGuid>
<RootNamespace>autoupdate_checker_vc2010</RootNamespace>
<ProjectName>autoupdate_checker</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='vTune|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='vTune|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='PGO|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='PGO|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
<IntDir>Output\$(ProjectName)\</IntDir>
<TargetName>opera_autoupdate</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
<IntDir>Output\$(ProjectName)\</IntDir>
<TargetName>opera_autoupdate</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|Win32'">
<OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|x64'">
<OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|Win32'">
<OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|x64'">
<OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|Win32'">
<OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|x64'">
<OutDir>$(SolutionDir)..\..\VS_Output\$(Configuration)\</OutDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<IntDir>Output\$(ProjectName)\</IntDir>
<TargetName>opera_autoupdate</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<IntDir>Output\$(ProjectName)\</IntDir>
<TargetName>opera_autoupdate</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|Win32'">
<IntDir>Output\$(ProjectName)\</IntDir>
<TargetName>opera_autoupdate</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='vTune|x64'">
<IntDir>Output\$(ProjectName)\</IntDir>
<TargetName>opera_autoupdate</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|Win32'">
<IntDir>Output\$(ProjectName)\</IntDir>
<TargetName>opera_autoupdate</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='PGO|x64'">
<IntDir>Output\$(ProjectName)\</IntDir>
<TargetName>opera_autoupdate</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|Win32'">
<IntDir>Output\$(ProjectName)\</IntDir>
<TargetName>opera_autoupdate</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|x64'">
<IntDir>Output\$(ProjectName)\</IntDir>
<TargetName>opera_autoupdate</TargetName>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
<AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libeay32.lib;ssleay32.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<ShowProgress>NotSet</ShowProgress>
<SubSystem>Windows</SubSystem>
</Link>
<PreBuildEvent>
<Command>
</Command>
</PreBuildEvent>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
<AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libeay32_x64.lib;ssleay32_x64.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<ShowProgress>NotSet</ShowProgress>
<SubSystem>Windows</SubSystem>
</Link>
<PreBuildEvent>
<Command>
</Command>
</PreBuildEvent>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
<AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<AdditionalDependencies>libeay32.lib;ssleay32.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;nothrownew.obj;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<SubSystem>Windows</SubSystem>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
<AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<AdditionalDependencies>libeay32_x64.lib;ssleay32_x64.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;nothrownew.obj;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<SubSystem>Windows</SubSystem>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='vTune|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
<AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<AdditionalDependencies>libeay32.lib;ssleay32.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<SubSystem>Windows</SubSystem>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='vTune|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
<AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<AdditionalDependencies>libeay32_x64.lib;ssleay32_x64.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<SubSystem>Windows</SubSystem>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='PGO|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
<AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<AdditionalDependencies>libeay32.lib;ssleay32.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<SubSystem>Windows</SubSystem>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='PGO|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>OAUC_PLATFORM_INCLUDES="platforms/windows/includes/platform.h";NDEBUG;CURL_STATICLIB;CURL_DISABLE_GOPHER;CURL_DISABLE_SMTP;CURL_DISABLE_IMAP;CURL_DISABLE_POP3;CURL_DISABLE_TFTP;CURL_DISABLE_TELNET;CURL_DISABLE_DICT;CURL_DISABLE_PROXY;CURL_DISABLE_LDAPS;CURL_DISABLE_LDAP;CURL_DISABLE_FILE;CURL_DISABLE_FTP;CURL_DISABLE_RTSP;USE_OPENSSL;USE_SSLEAY;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions);</PreprocessorDefinitions>
<AdditionalIncludeDirectories>.;platforms/universal_adaptation_layer/network/openssl/include/;../../..</AdditionalIncludeDirectories>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<ExceptionHandling>Sync</ExceptionHandling>
</ClCompile>
<Link>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<AdditionalDependencies>libeay32_x64.lib;ssleay32_x64.lib;tinyxml.lib;ws2_32.lib;libcurl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>Output;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<SubSystem>Windows</SubSystem>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Instrumented|Win32'">
<ClCompile>