34180 2010-01-26 13:01:14 -0800 [Qt] Enable websockets support in QtWebKit 2010-02-01 11:44:46 -0800 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED Qt P2 Normal --- 1 yael yael commit-queue hausmann laszlo.gombos markus oldest_to_newest 184690 0 yael 2010-01-26 13:01:14 -0800 A patch is coming soon 184733 1 yael 2010-01-26 14:21:48 -0800 (In reply to comment #0) > A patch is coming soon Unfortunately, I am getting a couple of sparious crashes when running websockets tests in DRT. Need more time to investigate the crashes. 184860 2 47474 yael 2010-01-26 17:35:55 -0800 Created attachment 47474 Patch v1 About 2 out of the 27 websockets tests in DRT are crashing randomly with this patch, but I wanted to start the review process while I am working on the crashes. With this patch - both secure and non-secure websockets work - SSL errors are ignored - proxy authentication is not supported. 184869 3 47476 yael 2010-01-26 17:50:20 -0800 Created attachment 47476 Patch v2 Got rid of all the tabs in the code. Maybe eclipse is not the best editor after all :-) 184964 4 47476 ukai 2010-01-26 23:36:49 -0800 Comment on attachment 47476 Patch v2 > Index: WebCore/WebCore.pro > =================================================================== > --- WebCore/WebCore.pro (revision 53851) > +++ WebCore/WebCore.pro (working copy) > @@ -1530,6 +1530,7 @@ > platform/network/NetworkStateNotifier.h \ > platform/network/ProtectionSpace.h \ > platform/network/qt/QNetworkReplyHandler.h \ > + platform/network/qt/SocketStreamHandlePrivate.h \ > platform/network/ResourceErrorBase.h \ > platform/network/ResourceHandle.h \ > platform/network/ResourceRequestBase.h \ > Index: WebCore/ChangeLog > =================================================================== > --- WebCore/ChangeLog (revision 53876) > +++ WebCore/ChangeLog (working copy) > @@ -1,3 +1,34 @@ > +2010-01-26 Yael Aharon <yael.aharon@nokia.com> > + > + Reviewed by NOBODY (OOPS!). > + > + [Qt] Enable websockets support in QtWebKit > + https://bugs.webkit.org/show_bug.cgi?id=34180 > + > + Connected between SocketStreamHandle and QTcpSocket/QSslSocket > + to enable support for websockets. > + > + * WebCore.pro: > + * platform/network/qt/SocketStreamHandle.h: > + * platform/network/qt/SocketStreamHandlePrivate.h: Added. > + * platform/network/qt/SocketStreamHandleQt.cpp: > + (WebCore::SocketStreamHandlePrivate::SocketStreamHandlePrivate): > + (WebCore::SocketStreamHandlePrivate::~SocketStreamHandlePrivate): > + (WebCore::SocketStreamHandlePrivate::socketConnected): > + (WebCore::SocketStreamHandlePrivate::socketReadyRead): > + (WebCore::SocketStreamHandlePrivate::send): > + (WebCore::SocketStreamHandlePrivate::close): > + (WebCore::SocketStreamHandlePrivate::socketSentdata): > + (WebCore::SocketStreamHandlePrivate::socketClosed): > + (WebCore::SocketStreamHandlePrivate::socketError): > + (WebCore::SocketStreamHandlePrivate::socketClosedCallback): > + (WebCore::SocketStreamHandlePrivate::socketErrorCallback): > + (WebCore::SocketStreamHandlePrivate::socketSslErrors): > + (WebCore::SocketStreamHandle::SocketStreamHandle): > + (WebCore::SocketStreamHandle::~SocketStreamHandle): > + (WebCore::SocketStreamHandle::platformSend): > + (WebCore::SocketStreamHandle::platformClose): > + > 2010-01-26 Dmitry Titov <dimich@chromium.org> > > Reviewed by Steve Falkenburg. > Index: WebCore/platform/network/qt/SocketStreamHandlePrivate.h > =================================================================== > --- WebCore/platform/network/qt/SocketStreamHandlePrivate.h (revision 0) > +++ WebCore/platform/network/qt/SocketStreamHandlePrivate.h (revision 0) > @@ -0,0 +1,74 @@ > +/* > + * Copyright (C) 2009 Apple Inc. All rights reserved. > + * Copyright (C) 2009 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions are > + * met: > + * > + * * Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * * Redistributions in binary form must reproduce the above > + * copyright notice, this list of conditions and the following disclaimer > + * in the documentation and/or other materials provided with the > + * distribution. > + * * Neither the name of Google Inc. nor the names of its > + * contributors may be used to endorse or promote products derived from > + * this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR > + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT > + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, > + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT > + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, > + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY > + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE > + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +#ifndef SocketStreamHandlePrivate_h > +#define SocketStreamHandlePrivate_h > + > +#include "SocketStreamHandleBase.h" > + > +#include <QSslSocket> > +#include <QTcpSocket> > + > +class QSslSocket; > + > +namespace WebCore { > + > +class AuthenticationChallenge; > +class Credential; > +class SocketStreamHandleClient; > +class SocketStreamHandlePrivate; > + > +class SocketStreamHandlePrivate : public QObject { > +Q_OBJECT > +public: > + SocketStreamHandlePrivate(SocketStreamHandle* streamHandle, const KURL& url); > + ~SocketStreamHandlePrivate(); > + > +public slots: > + void socketConnected(); > + void socketReadyRead(); > + int send(const char* data, int len); > + void close(); > + void socketSentdata(); > + void socketClosed(); > + void socketError(QAbstractSocket::SocketError); > + void socketClosedCallback(); > + void socketErrorCallback(int); > + void socketSslErrors(const QList<QSslError>&); > +public: > + QTcpSocket* m_socket; > + SocketStreamHandle* m_streamHandle; > + quint64 m_lastSentSize; Do you need this? > +}; > + > +} > + > +#endif > Index: WebCore/platform/network/qt/SocketStreamHandle.h > =================================================================== > --- WebCore/platform/network/qt/SocketStreamHandle.h (revision 53851) > +++ WebCore/platform/network/qt/SocketStreamHandle.h (working copy) > @@ -42,6 +42,7 @@ > class AuthenticationChallenge; > class Credential; > class SocketStreamHandleClient; > + class SocketStreamHandlePrivate; > > class SocketStreamHandle : public RefCounted<SocketStreamHandle>, public SocketStreamHandleBase { > public: > @@ -61,6 +62,8 @@ > void receivedCredential(const AuthenticationChallenge&, const Credential&); > void receivedRequestToContinueWithoutCredential(const AuthenticationChallenge&); > void receivedCancellation(const AuthenticationChallenge&); > + SocketStreamHandlePrivate* m_p; > + friend class SocketStreamHandlePrivate; > }; > > } // namespace WebCore > Index: WebCore/platform/network/qt/SocketStreamHandleQt.cpp > =================================================================== > --- WebCore/platform/network/qt/SocketStreamHandleQt.cpp (revision 53851) > +++ WebCore/platform/network/qt/SocketStreamHandleQt.cpp (working copy) > @@ -35,34 +35,128 @@ > #include "Logging.h" > #include "NotImplemented.h" > #include "SocketStreamHandleClient.h" > +#include "SocketStreamHandlePrivate.h" > > namespace WebCore { > > +SocketStreamHandlePrivate::SocketStreamHandlePrivate(SocketStreamHandle* streamHandle, const KURL& url) : QObject() > +{ > + m_streamHandle = streamHandle; > + m_socket = 0; > + bool isSecure = url.protocol().contains("wss"); url.protocolIs("wss") ? > + if (isSecure) > + m_socket = new QSslSocket(this); > + else > + m_socket = new QTcpSocket(this); > + connect(m_socket, SIGNAL(connected()), this, SLOT(socketConnected())); > + connect(m_socket, SIGNAL(readyRead()), this, SLOT(socketReadyRead())); > + connect(m_socket, SIGNAL(disconnected()), this, SLOT(socketClosed())); > + connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError))); > + if (isSecure) > + connect(m_socket, SIGNAL(sslErrors(const QList<QSslError>&)), this, SLOT(socketSslErrors(const QList<QSslError>&))); > + unsigned int port = url.hasPort() ? url.port() : isSecure ? 443 : 80; > + QString host = url.host(); > + if (isSecure) > + qobject_cast<QSslSocket*>(m_socket)->connectToHostEncrypted(host, port); > + else > + m_socket->connectToHost(host, port); > +} > + > +SocketStreamHandlePrivate::~SocketStreamHandlePrivate() > +{ > + Q_ASSERT(!(m_socket && m_socket->state() == QAbstractSocket::ConnectedState)); m_socket is leaked? > +} > + > +void SocketStreamHandlePrivate::socketConnected() > +{ > + if (m_streamHandle && m_streamHandle->client()) { > + m_streamHandle->m_state = SocketStreamHandleBase::Open; > + m_streamHandle->client()->didOpen(m_streamHandle); > + } > +} > + > +void SocketStreamHandlePrivate::socketReadyRead() > +{ > + if (m_streamHandle && m_streamHandle->client()) { > + QByteArray data = m_socket->readAll(); > + m_streamHandle->client()->didReceiveData(m_streamHandle, data.constData(), data.size()); > + } > +} > + > +int SocketStreamHandlePrivate::send(const char* data, int len) > +{ > + m_lastSentSize = m_socket->write(data, len); > + QMetaObject::invokeMethod(this, "socketSentData", Qt::QueuedConnection); > + return m_lastSentSize; > +} > + > +void SocketStreamHandlePrivate::close() > +{ > + if (m_socket && m_socket->state() == QAbstractSocket::ConnectedState) > + m_socket->close(); > +} > + > +void SocketStreamHandlePrivate::socketSentdata() > +{ > + if (m_streamHandle) > + m_streamHandle->sendPendingData(); > +} > + > +void SocketStreamHandlePrivate::socketClosed() > +{ > + QMetaObject::invokeMethod(this, "socketClosedCallback", Qt::QueuedConnection); > +} > + > +void SocketStreamHandlePrivate::socketError(QAbstractSocket::SocketError error) > +{ > + QMetaObject::invokeMethod(this, "socketError", Qt::QueuedConnection, Q_ARG(int, error)); > +} > + > +void SocketStreamHandlePrivate::socketClosedCallback() > +{ > + if (m_streamHandle && m_streamHandle->client()) { > + m_streamHandle->client()->didClose(m_streamHandle); > + m_streamHandle = 0; > + } > +} > + > +void SocketStreamHandlePrivate::socketErrorCallback(int error) > +{ > + // FIXME - in the future, we might not want to treat all errors as fatal. > + if (m_streamHandle && m_streamHandle->client()) { > + m_streamHandle->client()->didClose(m_streamHandle); > + m_streamHandle = 0; > + } > +} > + > +void SocketStreamHandlePrivate::socketSslErrors(const QList<QSslError>&) > +{ > + qobject_cast<QSslSocket*>(m_socket)->ignoreSslErrors(); > +} > SocketStreamHandle::SocketStreamHandle(const KURL& url, SocketStreamHandleClient* client) > : SocketStreamHandleBase(url, client) > { > LOG(Network, "SocketStreamHandle %p new client %p", this, m_client); > - notImplemented(); > + m_p = new SocketStreamHandlePrivate(this, url); > } > > SocketStreamHandle::~SocketStreamHandle() > { > LOG(Network, "SocketStreamHandle %p delete", this); > setClient(0); > - notImplemented(); > + delete m_p; > } > > -int SocketStreamHandle::platformSend(const char*, int) > +int SocketStreamHandle::platformSend(const char* data, int len) > { > LOG(Network, "SocketStreamHandle %p platformSend", this); > - notImplemented(); > - return 0; > + return m_p->send(data, len); > } > > void SocketStreamHandle::platformClose() > { > LOG(Network, "SocketStreamHandle %p platformClose", this); > - notImplemented(); > + m_p->close(); > } > > void SocketStreamHandle::didReceiveAuthenticationChallenge(const AuthenticationChallenge&) > @@ -86,3 +180,5 @@ > } > > } // namespace WebCore > + > +#include "moc_SocketStreamHandlePrivate.cpp" > Index: LayoutTests/platform/qt/Skipped > =================================================================== > --- LayoutTests/platform/qt/Skipped (revision 53851) > +++ LayoutTests/platform/qt/Skipped (working copy) > @@ -4965,7 +4965,6 @@ > http/tests/xmlhttprequest/workers/shared-worker-methods-async.html > > # Missing SocketStreamHandle implementation > -websocket/tests > > # Need rebaseline: https://bugs.webkit.org/show_bug.cgi?id=26830 > fast/multicol/single-line.html > Index: LayoutTests/ChangeLog > =================================================================== > --- LayoutTests/ChangeLog (revision 53876) > +++ LayoutTests/ChangeLog (working copy) > @@ -1,3 +1,14 @@ > +2010-01-26 Yael Aharon <yael.aharon@nokia.com> > + > + Reviewed by NOBODY (OOPS!). > + > + [Qt] Enable websockets support in QtWebKit > + https://bugs.webkit.org/show_bug.cgi?id=34180 > + > + Remove websockets tests from skiplist. > + > + * platform/qt/Skipped: > + > 2010-01-26 Fumitoshi Ukai <ukai@chromium.org> > > Reviewed by Alexey Proskuryakov. 184992 5 47476 hausmann 2010-01-27 01:04:10 -0800 Comment on attachment 47476 Patch v2 Great that you're starting with this, Yael! > +#include <QSslSocket> > +#include <QTcpSocket> > + > +class QSslSocket; Why include QSslSocket and also forward declare it? :) > +class SocketStreamHandlePrivate : public QObject { > +Q_OBJECT The Q_OBJECT macro us usually indented. > +public: > + SocketStreamHandlePrivate(SocketStreamHandle* streamHandle, const KURL& url); WebKit style suggests to remove the names of the arguments here, as they're redundant (The type is the same as the variable name). > + connect(m_socket, SIGNAL(connected()), this, SLOT(socketConnected())); > + connect(m_socket, SIGNAL(readyRead()), this, SLOT(socketReadyRead())); > + connect(m_socket, SIGNAL(disconnected()), this, SLOT(socketClosed())); > + connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError))); > + if (isSecure) > + connect(m_socket, SIGNAL(sslErrors(const QList<QSslError>&)), this, SLOT(socketSslErrors(const QList<QSslError>&))); > + unsigned int port = url.hasPort() ? url.port() : isSecure ? 443 : 80; This looks rather convoluted :). Do you mind splitting this up a little bit or adding parentheses? > + QString host = url.host(); > + if (isSecure) > + qobject_cast<QSslSocket*>(m_socket)->connectToHostEncrypted(host, port); I suggest to do a static_cast here, it's faster and if something is wrong it'll crash either way ;-) > +void SocketStreamHandlePrivate::socketReadyRead() > +{ > + if (m_streamHandle && m_streamHandle->client()) { > + QByteArray data = m_socket->readAll(); > + m_streamHandle->client()->didReceiveData(m_streamHandle, data.constData(), data.size()); > + } > +} Is it intentional to read _all_ data here and block until all is available? I wonder if it should be done like in QNetworkReplyHandler instead: QByteArray data = m_socket->read(m_socket->bytesAvailable()); Performance wise it's sad that we have to copy the data here, but I don't see any obvious solution here (as well as in QNetworkReplyHandler). > +int SocketStreamHandlePrivate::send(const char* data, int len) > +{ > + m_lastSentSize = m_socket->write(data, len); Looks like one whitespace too much here :) > + QMetaObject::invokeMethod(this, "socketSentData", Qt::QueuedConnection); What's the reason for this queued connection? Is the goal to call sendPendingData() only once the previous data has been written? (That itself may not be guaranteed with a queued connection that just goes through the event loop once) > +void SocketStreamHandlePrivate::socketClosed() > +{ > + QMetaObject::invokeMethod(this, "socketClosedCallback", Qt::QueuedConnection); > +} > + > +void SocketStreamHandlePrivate::socketError(QAbstractSocket::SocketError error) > +{ > + QMetaObject::invokeMethod(this, "socketError", Qt::QueuedConnection, Q_ARG(int, error)); > +} Out of curiousity again, why the queued connections? > +void SocketStreamHandlePrivate::socketErrorCallback(int error) > +{ > + // FIXME - in the future, we might not want to treat all errors as fatal. > + if (m_streamHandle && m_streamHandle->client()) { > + m_streamHandle->client()->didClose(m_streamHandle); Since this is called in case of socket errors, shouldn't we call didFail() on the stream handle client instead of just didClose()? > +void SocketStreamHandlePrivate::socketSslErrors(const QList<QSslError>&) > +{ > + qobject_cast<QSslSocket*>(m_socket)->ignoreSslErrors(); > +} Hmmm, doesn't that effectively remove any security from encrypted connections? If someone spoofs a certificate we ignore it and still happily connect, allowing a man-in-the-middle to read all the traffic. > Index: LayoutTests/platform/qt/Skipped > =================================================================== > --- LayoutTests/platform/qt/Skipped (revision 53851) > +++ LayoutTests/platform/qt/Skipped (working copy) > @@ -4965,7 +4965,6 @@ > http/tests/xmlhttprequest/workers/shared-worker-methods-async.html > > # Missing SocketStreamHandle implementation > -websocket/tests I like this part! Yay for layout testing :) But you should also remove the comment then that says the implementation is missing ;-) 185064 6 yael 2010-01-27 06:13:01 -0800 Thank you Ukai & Simon for reviewing this patch! (In reply to comment #4) >Do you need this? I thought I would need it, but it turns out that I don't. Wiill take it out >url.protocolIs("wss") ? will do >m_socket is leaked? The QObject system will delete it when its parent is deleted (SocketStreamHandlePrivate) (In reply to comment #5) >Why include QSslSocket and also forward declare it? :) I should take it out! >The Q_OBJECT macro us usually indented. will do >WebKit style suggests to remove the names of the arguments here, as they're >redundant (The type is the same as the variable name). will do >This looks rather convoluted :). Do you mind splitting this up a little bit or >adding parentheses? will do >> + QString host = url.host(); >> + if (isSecure) >> + qobject_cast<QSslSocket*>(m_socket)->connectToHostEncrypted(host, port); >I suggest to do a static_cast here, it's faster and if something is wrong it'll >crash either way ;-) will do >Is it intentional to read _all_ data here and block until all is available? > >I wonder if it should be done like in QNetworkReplyHandler instead: > > QByteArray data = m_socket->read(m_socket->bytesAvailable()); > >Performance wise it's sad that we have to copy the data here, but I don't see >any obvious solution here (as well as in QNetworkReplyHandler). I thought that the result of readAll() and bytesAvailable(0 would be the same, but I will change that. >> + m_lastSentSize = m_socket->write(data, len); > >Looks like one whitespace too much here :) Should be added to chek-webkit-style :-) >> + QMetaObject::invokeMethod(this, "socketSentData", Qt::QueuedConnection); > >What's the reason for this queued connection? Is the goal to call >sendPendingData() only once the previous data has been written? (That itself >may not be guaranteed with a queued connection that just goes through the event >loop once) I wanted to match chromium port that calls this asynchronously. QTcpSocket does not provide a callback when it is really done sending. >> +void SocketStreamHandlePrivate::socketClosed() >> +{ > + QMetaObject::invokeMethod(this, "socketClosedCallback", Qt::QueuedConnection); >> +} >> + >> +void SocketStreamHandlePrivate::socketError(QAbstractSocket::SocketError error) >> +{ >> + QMetaObject::invokeMethod(this, "socketError", Qt::QueuedConnection, Q_ARG(int, error)); >> +} > >Out of curiousity again, why the queued connections? These calls would result in cleanup, and I thought it was safer to call them asynchronously. Do you think this will cause performance issues? >> +void SocketStreamHandlePrivate::socketErrorCallback(int error) >> +{ >> + // FIXME - in the future, we might not want to treat all errors as fatal. >> + if (m_streamHandle && m_streamHandle->client()) { >> + m_streamHandle->client()->didClose(m_streamHandle); > >Since this is called in case of socket errors, shouldn't we call didFail() on >the stream handle client instead of just didClose()? Chromium port is calling didClose(), so I followed it, but I will look into this again >> +void SocketStreamHandlePrivate::socketSslErrors(const QList<QSslError>&) >> +{ >> + qobject_cast<QSslSocket*>(m_socket)->ignoreSslErrors(); >> +} > >Hmmm, doesn't that effectively remove any security from encrypted connections? >If someone spoofs a certificate we ignore it and still happily connect, >allowing a man-in-the-middle to read all the traffic. Yes, I acknowledged this in comment #2, as a missing feature. >> # Missing SocketStreamHandle implementation >> -websocket/tests> > >I like this part! Yay for layout testing :) > >But you should also remove the comment then that says the implementation is >missing ;-) oops! 185076 7 yael 2010-01-27 06:47:42 -0800 Changing didClose() to didFail() caused 7 layout tests to fail. Since the error code is not used for anything, I would like to keep the didClose() call. 185141 8 47547 yael 2010-01-27 10:32:37 -0800 Created attachment 47547 Patch v3 Thanks to valgrind I found and fixed the random crashes. With this patch proxy authentication still does not work, and for the purpose of testing, I allow wss connections with bad certificates. This should be disabled later on. 185153 9 laszlo.gombos 2010-01-27 11:04:15 -0800 v3 looks good to me - with the minor comment to include the status of the implementation in the ChangeLog as well. 185154 10 47551 yael 2010-01-27 11:06:01 -0800 Created attachment 47551 Patch v4 Added more comments at Laszlo's request. 185155 11 47551 laszlo.gombos 2010-01-27 11:08:11 -0800 Comment on attachment 47551 Patch v4 Looks good to me; all the previous review comments have been addressed. 185180 12 47551 commit-queue 2010-01-27 12:16:59 -0800 Comment on attachment 47551 Patch v4 Clearing flags on attachment: 47551 Committed r53947: <http://trac.webkit.org/changeset/53947> 185181 13 commit-queue 2010-01-27 12:17:06 -0800 All reviewed patches have been landed. Closing bug. 186330 14 markus 2010-02-01 01:32:26 -0800 Small note: Theoretically, the SSL channel can only be seen as open after encrypted() has been emitted. The connected() signal is for the underlying TCP connection. I don't know if it is worth to fix this or not. 186331 15 markus 2010-02-01 01:39:07 -0800 The check "m_socket->state() == QAbstractSocket::ConnectedState" should maybe be removed since we also want to close a socket that is e.g. still in HostLookupState. 186503 16 yael 2010-02-01 11:44:46 -0800 Created https://bugs.webkit.org/show_bug.cgi?id=34425 to address comments #14 and #15. 47474 2010-01-26 17:35:55 -0800 2010-01-26 17:50:20 -0800 Patch v1 34180.patch text/plain 12014 yael SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnBybwkocmV2aXNpb24gNTM4NTEpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5nIGNv cHkpCkBAIC0xNTMwLDYgKzE1MzAsNyBAQAogICAgIHBsYXRmb3JtL25ldHdvcmsvTmV0d29ya1N0 YXRlTm90aWZpZXIuaCBcCiAgICAgcGxhdGZvcm0vbmV0d29yay9Qcm90ZWN0aW9uU3BhY2UuaCBc CiAgICAgcGxhdGZvcm0vbmV0d29yay9xdC9RTmV0d29ya1JlcGx5SGFuZGxlci5oIFwKKyAgICBw bGF0Zm9ybS9uZXR3b3JrL3F0L1NvY2tldFN0cmVhbUhhbmRsZVByaXZhdGUuaCBcCiAgICAgcGxh dGZvcm0vbmV0d29yay9SZXNvdXJjZUVycm9yQmFzZS5oIFwKICAgICBwbGF0Zm9ybS9uZXR3b3Jr L1Jlc291cmNlSGFuZGxlLmggXAogICAgIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VSZXF1ZXN0 QmFzZS5oIFwKSW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv Q2hhbmdlTG9nCShyZXZpc2lvbiA1Mzg3NikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTAtMDEtMjYgIFlhZWwgQWhhcm9uICA8eWFlbC5h aGFyb25Abm9raWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFtRdF0gRW5hYmxlIHdlYnNvY2tldHMgc3VwcG9ydCBpbiBRdFdlYktpdAorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQxODAKKworICAg ICAgICBDb25uZWN0ZWQgYmV0d2VlbiBTb2NrZXRTdHJlYW1IYW5kbGUgYW5kIFFUY3BTb2NrZXQv UVNzbFNvY2tldAorICAgICAgICB0byBlbmFibGUgc3VwcG9ydCBmb3Igd2Vic29ja2V0cy4KKwor ICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvcXQvU29j a2V0U3RyZWFtSGFuZGxlLmg6CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRT dHJlYW1IYW5kbGVQcml2YXRlLmg6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsv cXQvU29ja2V0U3RyZWFtSGFuZGxlUXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3Ry ZWFtSGFuZGxlUHJpdmF0ZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZSk6CisgICAgICAgIChX ZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjp+U29ja2V0U3RyZWFtSGFuZGxlUHJp dmF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjpzb2Nr ZXRDb25uZWN0ZWQpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0 ZTo6c29ja2V0UmVhZHlSZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRs ZVByaXZhdGU6OnNlbmQpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJp dmF0ZTo6Y2xvc2UpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0 ZTo6c29ja2V0U2VudGRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxl UHJpdmF0ZTo6c29ja2V0Q2xvc2VkKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhh bmRsZVByaXZhdGU6OnNvY2tldEVycm9yKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVh bUhhbmRsZVByaXZhdGU6OnNvY2tldENsb3NlZENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6 OlNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldEVycm9yQ2FsbGJhY2spOgorICAgICAg ICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6c29ja2V0U3NsRXJyb3JzKToK KyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRsZTo6U29ja2V0U3RyZWFtSGFuZGxl KToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRsZTo6flNvY2tldFN0cmVhbUhh bmRsZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGU6OnBsYXRmb3JtU2Vu ZCk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGU6OnBsYXRmb3JtQ2xvc2Up OgorCiAyMDEwLTAxLTI2ICBEbWl0cnkgVGl0b3YgIDxkaW1pY2hAY2hyb21pdW0ub3JnPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IFN0ZXZlIEZhbGtlbmJ1cmcuCkluZGV4OiBXZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlLmgJ KHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFt SGFuZGxlUHJpdmF0ZS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDc3IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDA5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHly aWdodCAoQykgMjAwOSBHb29nbGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0 aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5h bWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVj aWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAor ICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFNvY2tl dFN0cmVhbUhhbmRsZVByaXZhdGVfaAorI2RlZmluZSBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRl X2gKKworI2luY2x1ZGUgIlNvY2tldFN0cmVhbUhhbmRsZUJhc2UuaCIKKworI2luY2x1ZGUgPHd0 Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KKworI2luY2x1ZGUg PFFUY3BTb2NrZXQ+CisjaW5jbHVkZSA8UVNzbFNvY2tldD4KKworY2xhc3MgUVNzbFNvY2tldDsK KworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZTsK K2NsYXNzIENyZWRlbnRpYWw7CitjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVDbGllbnQ7CitjbGFz cyBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOworCitjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVQ cml2YXRlIDogcHVibGljIFFPYmplY3QgeworUV9PQkpFQ1QKK3B1YmxpYzoKKyAgICBTb2NrZXRT dHJlYW1IYW5kbGVQcml2YXRlKFNvY2tldFN0cmVhbUhhbmRsZSogc3RyZWFtSGFuZGxlLCBjb25z dCBLVVJMJiB1cmwpOworICAgIH5Tb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlKCk7CisKK3B1Ymxp YyBzbG90czoKKyAgICB2b2lkIHNvY2tldENvbm5lY3RlZCgpOworICAgIHZvaWQgc29ja2V0UmVh ZHlSZWFkKCk7CisgICAgaW50IHNlbmQoY29uc3QgY2hhciogZGF0YSwgaW50IGxlbik7CisgICAg dm9pZCBjbG9zZSgpOworICAgIHZvaWQgc29ja2V0U2VudGRhdGEoKTsKKyAgICB2b2lkIHNvY2tl dENsb3NlZCgpOworICAgIHZvaWQgc29ja2V0RXJyb3IoUUFic3RyYWN0U29ja2V0OjpTb2NrZXRF cnJvcik7CisgICAgdm9pZCBzb2NrZXRDbG9zZWRDYWxsYmFjaygpOworICAgIHZvaWQgc29ja2V0 RXJyb3JDYWxsYmFjayhpbnQpOworICAgIHZvaWQgc29ja2V0U3NsRXJyb3JzKGNvbnN0IFFMaXN0 PFFTc2xFcnJvcj4mKTsKK3B1YmxpYzoKKyAgICBRVGNwU29ja2V0KiBtX3NvY2tldDsKKyAgICBT b2NrZXRTdHJlYW1IYW5kbGUqIG1fc3RyZWFtSGFuZGxlOworICAgIHF1aW50NjQgbV9sYXN0U2Vu dFNpemU7Cit9OworCit9ICAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgIC8vIFNvY2tl dFN0cmVhbUhhbmRsZVByaXZhdGVfaApJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3F0 L1NvY2tldFN0cmVhbUhhbmRsZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGUuaAkocmV2aXNpb24gNTM4NTEpCisrKyBXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlLmgJKHdvcmtpbmcgY29weSkK QEAgLTQyLDYgKzQyLDcgQEAKICAgICBjbGFzcyBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZTsKICAg ICBjbGFzcyBDcmVkZW50aWFsOwogICAgIGNsYXNzIFNvY2tldFN0cmVhbUhhbmRsZUNsaWVudDsK KyAgICBjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOwogCiAgICAgY2xhc3MgU29ja2V0 U3RyZWFtSGFuZGxlIDogcHVibGljIFJlZkNvdW50ZWQ8U29ja2V0U3RyZWFtSGFuZGxlPiwgcHVi bGljIFNvY2tldFN0cmVhbUhhbmRsZUJhc2UgewogICAgIHB1YmxpYzoKQEAgLTYxLDYgKzYyLDgg QEAKICAgICAgICAgdm9pZCByZWNlaXZlZENyZWRlbnRpYWwoY29uc3QgQXV0aGVudGljYXRpb25D aGFsbGVuZ2UmLCBjb25zdCBDcmVkZW50aWFsJik7CiAgICAgICAgIHZvaWQgcmVjZWl2ZWRSZXF1 ZXN0VG9Db250aW51ZVdpdGhvdXRDcmVkZW50aWFsKGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxl bmdlJik7CiAgICAgICAgIHZvaWQgcmVjZWl2ZWRDYW5jZWxsYXRpb24oY29uc3QgQXV0aGVudGlj YXRpb25DaGFsbGVuZ2UmKTsKKyAgICAgICAgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZSogbV9w OworICAgICAgICBmcmllbmQgY2xhc3MgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTsKICAgICB9 OwogCiB9ICAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3F0L1NvY2tldFN0cmVhbUhhbmRsZVF0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlUXQuY3BwCShyZXZpc2lvbiA1Mzg1 MSkKKysrIFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGVRdC5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTM1LDM0ICszNSwxMjggQEAKICNpbmNsdWRlICJMb2dnaW5n LmgiCiAjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKICNpbmNsdWRlICJTb2NrZXRTdHJlYW1I YW5kbGVDbGllbnQuaCIKKyNpbmNsdWRlICJTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlLmgiCiAK IG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6U29ja2V0 U3RyZWFtSGFuZGxlUHJpdmF0ZShTb2NrZXRTdHJlYW1IYW5kbGUqIHN0cmVhbUhhbmRsZSwgY29u c3QgS1VSTCYgdXJsKSA6IFFPYmplY3QoKQoreworICAgIG1fc3RyZWFtSGFuZGxlID0gc3RyZWFt SGFuZGxlOworICAgIG1fc29ja2V0ID0gTlVMTDsKKyAgICBib29sIGlzU2VjdXJlID0gdXJsLnBy b3RvY29sKCkuY29udGFpbnMoIndzcyIpOworICAgIGlmIChpc1NlY3VyZSkKKyAgICAJbV9zb2Nr ZXQgPSBuZXcgUVNzbFNvY2tldCh0aGlzKTsKKyAgICBlbHNlCisgICAgCW1fc29ja2V0ID0gbmV3 IFFUY3BTb2NrZXQodGhpcyk7CisgICAgY29ubmVjdChtX3NvY2tldCwgU0lHTkFMKGNvbm5lY3Rl ZCgpKSwgdGhpcywgU0xPVChzb2NrZXRDb25uZWN0ZWQoKSkpOworICAgIGNvbm5lY3QobV9zb2Nr ZXQsIFNJR05BTChyZWFkeVJlYWQoKSksIHRoaXMsIFNMT1Qoc29ja2V0UmVhZHlSZWFkKCkpKTsK KyAgICBjb25uZWN0KG1fc29ja2V0LCBTSUdOQUwoZGlzY29ubmVjdGVkKCkpLCB0aGlzLCBTTE9U KHNvY2tldENsb3NlZCgpKSk7CisgICAgY29ubmVjdChtX3NvY2tldCwgU0lHTkFMKGVycm9yKFFB YnN0cmFjdFNvY2tldDo6U29ja2V0RXJyb3IpKSwgdGhpcywgU0xPVChzb2NrZXRFcnJvcihRQWJz dHJhY3RTb2NrZXQ6OlNvY2tldEVycm9yKSkpOworICAgIGlmIChpc1NlY3VyZSkKKyAgICAgICAg Y29ubmVjdChtX3NvY2tldCwgU0lHTkFMKHNzbEVycm9ycyhjb25zdCBRTGlzdDxRU3NsRXJyb3I+ JikpLCB0aGlzLCBTTE9UKHNvY2tldFNzbEVycm9ycyhjb25zdCBRTGlzdDxRU3NsRXJyb3I+Jikp KTsKKyAgICB1bnNpZ25lZCBpbnQgcG9ydCA9IHVybC5oYXNQb3J0KCkgPyB1cmwucG9ydCgpIDog aXNTZWN1cmUgPyA0NDMgOiA4MDsKKyAgICBRU3RyaW5nIGhvc3QgPSB1cmwuaG9zdCgpOworICAg IGlmIChpc1NlY3VyZSkKKyAgICAJcW9iamVjdF9jYXN0PFFTc2xTb2NrZXQqPihtX3NvY2tldCkt PmNvbm5lY3RUb0hvc3RFbmNyeXB0ZWQoaG9zdCwgcG9ydCk7CisgICAgZWxzZQorICAgIAltX3Nv Y2tldC0+Y29ubmVjdFRvSG9zdChob3N0LCBwb3J0KTsKK30KKworU29ja2V0U3RyZWFtSGFuZGxl UHJpdmF0ZTo6flNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGUoKQoreworCVFfQVNTRVJUKCEobV9z b2NrZXQgJiYgbV9zb2NrZXQtPnN0YXRlKCkgPT0gUUFic3RyYWN0U29ja2V0OjpDb25uZWN0ZWRT dGF0ZSkpOworfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldENvbm5l Y3RlZCgpCit7CisJaWYgKG1fc3RyZWFtSGFuZGxlICYmIG1fc3RyZWFtSGFuZGxlLT5jbGllbnQo KSkgeworCQltX3N0cmVhbUhhbmRsZS0+bV9zdGF0ZSA9IFNvY2tldFN0cmVhbUhhbmRsZUJhc2U6 Ok9wZW47CisJCW1fc3RyZWFtSGFuZGxlLT5jbGllbnQoKS0+ZGlkT3BlbihtX3N0cmVhbUhhbmRs ZSk7CisJfQorfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldFJlYWR5 UmVhZCgpCit7CisJaWYgKG1fc3RyZWFtSGFuZGxlICYmIG1fc3RyZWFtSGFuZGxlLT5jbGllbnQo KSkgeworCQlRQnl0ZUFycmF5IGRhdGEgPSBtX3NvY2tldC0+cmVhZEFsbCgpOworCQltX3N0cmVh bUhhbmRsZS0+Y2xpZW50KCktPmRpZFJlY2VpdmVEYXRhKG1fc3RyZWFtSGFuZGxlLCBkYXRhLmNv bnN0RGF0YSgpLCBkYXRhLnNpemUoKSk7CisJfQorfQorCitpbnQgU29ja2V0U3RyZWFtSGFuZGxl UHJpdmF0ZTo6c2VuZChjb25zdCBjaGFyKiBkYXRhLCBpbnQgbGVuKQoreworICAgIG1fbGFzdFNl bnRTaXplID0gIG1fc29ja2V0LT53cml0ZShkYXRhLCBsZW4pOworICAgIFFNZXRhT2JqZWN0Ojpp bnZva2VNZXRob2QodGhpcywgInNvY2tldFNlbnREYXRhIiwgUXQ6OlF1ZXVlZENvbm5lY3Rpb24p OworICAgIHJldHVybiBtX2xhc3RTZW50U2l6ZTsKK30KKwordm9pZCBTb2NrZXRTdHJlYW1IYW5k bGVQcml2YXRlOjpjbG9zZSgpCit7CisJaWYgKG1fc29ja2V0ICYmIG1fc29ja2V0LT5zdGF0ZSgp ID09IFFBYnN0cmFjdFNvY2tldDo6Q29ubmVjdGVkU3RhdGUpCisJCW1fc29ja2V0LT5jbG9zZSgp OworfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldFNlbnRkYXRhKCkK K3sKKwlpZiAobV9zdHJlYW1IYW5kbGUpCisJCW1fc3RyZWFtSGFuZGxlLT5zZW5kUGVuZGluZ0Rh dGEoKTsKK30KKwordm9pZCBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjpzb2NrZXRDbG9zZWQo KQoreworICAgIFFNZXRhT2JqZWN0OjppbnZva2VNZXRob2QodGhpcywgInNvY2tldENsb3NlZENh bGxiYWNrIiwgUXQ6OlF1ZXVlZENvbm5lY3Rpb24pOworfQorCit2b2lkIFNvY2tldFN0cmVhbUhh bmRsZVByaXZhdGU6OnNvY2tldEVycm9yKFFBYnN0cmFjdFNvY2tldDo6U29ja2V0RXJyb3IgZXJy b3IpCit7CisgICAgUU1ldGFPYmplY3Q6Omludm9rZU1ldGhvZCh0aGlzLCAic29ja2V0RXJyb3Ii LCBRdDo6UXVldWVkQ29ubmVjdGlvbiwgUV9BUkcoaW50LCBlcnJvcikpOworfQorCit2b2lkIFNv Y2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldENsb3NlZENhbGxiYWNrKCkKK3sKKwlpZiAo bV9zdHJlYW1IYW5kbGUgJiYgbV9zdHJlYW1IYW5kbGUtPmNsaWVudCgpKSB7CisJCW1fc3RyZWFt SGFuZGxlLT5jbGllbnQoKS0+ZGlkQ2xvc2UobV9zdHJlYW1IYW5kbGUpOworCQltX3N0cmVhbUhh bmRsZSA9IE5VTEw7CisJfQorfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNv Y2tldEVycm9yQ2FsbGJhY2soaW50IGVycm9yKQoreworCS8vIEZJWE1FIC0gaW4gdGhlIGZ1dHVy ZSwgd2UgbWlnaHQgbm90IHdhbnQgdG8gdHJlYXQgYWxsIGVycm9ycyBhcyBmYXRhbC4KKwlpZiAo bV9zdHJlYW1IYW5kbGUgJiYgbV9zdHJlYW1IYW5kbGUtPmNsaWVudCgpKSB7CisJCW1fc3RyZWFt SGFuZGxlLT5jbGllbnQoKS0+ZGlkQ2xvc2UobV9zdHJlYW1IYW5kbGUpOworCQltX3N0cmVhbUhh bmRsZSA9IE5VTEw7CisJfQorfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNv Y2tldFNzbEVycm9ycyhjb25zdCBRTGlzdDxRU3NsRXJyb3I+JikKK3sKKwlxb2JqZWN0X2Nhc3Q8 UVNzbFNvY2tldCo+KG1fc29ja2V0KS0+aWdub3JlU3NsRXJyb3JzKCk7Cit9CiBTb2NrZXRTdHJl YW1IYW5kbGU6OlNvY2tldFN0cmVhbUhhbmRsZShjb25zdCBLVVJMJiB1cmwsIFNvY2tldFN0cmVh bUhhbmRsZUNsaWVudCogY2xpZW50KQogICAgIDogU29ja2V0U3RyZWFtSGFuZGxlQmFzZSh1cmws IGNsaWVudCkKIHsKICAgICBMT0coTmV0d29yaywgIlNvY2tldFN0cmVhbUhhbmRsZSAlcCBuZXcg Y2xpZW50ICVwIiwgdGhpcywgbV9jbGllbnQpOwotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAg bV9wID0gbmV3IFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGUodGhpcywgdXJsKTsKIH0KIAogU29j a2V0U3RyZWFtSGFuZGxlOjp+U29ja2V0U3RyZWFtSGFuZGxlKCkKIHsKICAgICBMT0coTmV0d29y aywgIlNvY2tldFN0cmVhbUhhbmRsZSAlcCBkZWxldGUiLCB0aGlzKTsKICAgICBzZXRDbGllbnQo MCk7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBkZWxldGUgbV9wOwogfQogCi1pbnQgU29j a2V0U3RyZWFtSGFuZGxlOjpwbGF0Zm9ybVNlbmQoY29uc3QgY2hhciosIGludCkKK2ludCBTb2Nr ZXRTdHJlYW1IYW5kbGU6OnBsYXRmb3JtU2VuZChjb25zdCBjaGFyKiBkYXRhLCBpbnQgbGVuKQog ewogICAgIExPRyhOZXR3b3JrLCAiU29ja2V0U3RyZWFtSGFuZGxlICVwIHBsYXRmb3JtU2VuZCIs IHRoaXMpOwotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0gICAgcmV0dXJuIDA7CisgICAgcmV0dXJu IG1fcC0+c2VuZChkYXRhLCBsZW4pOwogfQogCiB2b2lkIFNvY2tldFN0cmVhbUhhbmRsZTo6cGxh dGZvcm1DbG9zZSgpCiB7CiAgICAgTE9HKE5ldHdvcmssICJTb2NrZXRTdHJlYW1IYW5kbGUgJXAg cGxhdGZvcm1DbG9zZSIsIHRoaXMpOwotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgbV9wLT5j bG9zZSgpOwogfQogCiB2b2lkIFNvY2tldFN0cmVhbUhhbmRsZTo6ZGlkUmVjZWl2ZUF1dGhlbnRp Y2F0aW9uQ2hhbGxlbmdlKGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJikKQEAgLTg2LDMg KzE4MCw1IEBACiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2luY2x1ZGUgIm1vY19T b2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlLmNwcCIKSW5kZXg6IExheW91dFRlc3RzL3BsYXRmb3Jt L3F0L1NraXBwZWQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQvU2tpcHBl ZAkocmV2aXNpb24gNTM4NTEpCisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9Ta2lwcGVkCSh3 b3JraW5nIGNvcHkpCkBAIC00OTY1LDcgKzQ5NjUsNiBAQAogaHR0cC90ZXN0cy94bWxodHRwcmVx dWVzdC93b3JrZXJzL3NoYXJlZC13b3JrZXItbWV0aG9kcy1hc3luYy5odG1sCiAKICMgTWlzc2lu ZyBTb2NrZXRTdHJlYW1IYW5kbGUgaW1wbGVtZW50YXRpb24KLXdlYnNvY2tldC90ZXN0cwogCiAj IE5lZWQgcmViYXNlbGluZTogaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI2ODMwCiBmYXN0L211bHRpY29sL3NpbmdsZS1saW5lLmh0bWwKSW5kZXg6IExheW91dFRlc3Rz L0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9u IDUzODc2KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMg KzEsMTQgQEAKKzIwMTAtMDEtMjYgIFlhZWwgQWhhcm9uICA8eWFlbC5haGFyb25Abm9raWEuY29t PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtRdF0g RW5hYmxlIHdlYnNvY2tldHMgc3VwcG9ydCBpbiBRdFdlYktpdAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQxODAKKworICAgICAgICBSZW1vdmUgd2Vi c29ja2V0cyB0ZXN0cyBmcm9tIHNraXBsaXN0LgorCisgICAgICAgICogcGxhdGZvcm0vcXQvU2tp cHBlZDoKKwogMjAxMC0wMS0yNiAgRnVtaXRvc2hpIFVrYWkgIDx1a2FpQGNocm9taXVtLm9yZz4K IAogICAgICAgICBSZXZpZXdlZCBieSBBbGV4ZXkgUHJvc2t1cnlha292Lgo= 47476 2010-01-26 17:50:20 -0800 2010-01-27 10:32:37 -0800 Patch v2 34180.patch text/plain 12002 yael SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnBybwkocmV2aXNpb24gNTM4NTEpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5nIGNv cHkpCkBAIC0xNTMwLDYgKzE1MzAsNyBAQAogICAgIHBsYXRmb3JtL25ldHdvcmsvTmV0d29ya1N0 YXRlTm90aWZpZXIuaCBcCiAgICAgcGxhdGZvcm0vbmV0d29yay9Qcm90ZWN0aW9uU3BhY2UuaCBc CiAgICAgcGxhdGZvcm0vbmV0d29yay9xdC9RTmV0d29ya1JlcGx5SGFuZGxlci5oIFwKKyAgICBw bGF0Zm9ybS9uZXR3b3JrL3F0L1NvY2tldFN0cmVhbUhhbmRsZVByaXZhdGUuaCBcCiAgICAgcGxh dGZvcm0vbmV0d29yay9SZXNvdXJjZUVycm9yQmFzZS5oIFwKICAgICBwbGF0Zm9ybS9uZXR3b3Jr L1Jlc291cmNlSGFuZGxlLmggXAogICAgIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VSZXF1ZXN0 QmFzZS5oIFwKSW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv Q2hhbmdlTG9nCShyZXZpc2lvbiA1Mzg3NikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTAtMDEtMjYgIFlhZWwgQWhhcm9uICA8eWFlbC5h aGFyb25Abm9raWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFtRdF0gRW5hYmxlIHdlYnNvY2tldHMgc3VwcG9ydCBpbiBRdFdlYktpdAorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQxODAKKworICAg ICAgICBDb25uZWN0ZWQgYmV0d2VlbiBTb2NrZXRTdHJlYW1IYW5kbGUgYW5kIFFUY3BTb2NrZXQv UVNzbFNvY2tldAorICAgICAgICB0byBlbmFibGUgc3VwcG9ydCBmb3Igd2Vic29ja2V0cy4KKwor ICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvcXQvU29j a2V0U3RyZWFtSGFuZGxlLmg6CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRT dHJlYW1IYW5kbGVQcml2YXRlLmg6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsv cXQvU29ja2V0U3RyZWFtSGFuZGxlUXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3Ry ZWFtSGFuZGxlUHJpdmF0ZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZSk6CisgICAgICAgIChX ZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjp+U29ja2V0U3RyZWFtSGFuZGxlUHJp dmF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjpzb2Nr ZXRDb25uZWN0ZWQpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0 ZTo6c29ja2V0UmVhZHlSZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRs ZVByaXZhdGU6OnNlbmQpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJp dmF0ZTo6Y2xvc2UpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0 ZTo6c29ja2V0U2VudGRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxl UHJpdmF0ZTo6c29ja2V0Q2xvc2VkKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhh bmRsZVByaXZhdGU6OnNvY2tldEVycm9yKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVh bUhhbmRsZVByaXZhdGU6OnNvY2tldENsb3NlZENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6 OlNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldEVycm9yQ2FsbGJhY2spOgorICAgICAg ICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6c29ja2V0U3NsRXJyb3JzKToK KyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRsZTo6U29ja2V0U3RyZWFtSGFuZGxl KToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRsZTo6flNvY2tldFN0cmVhbUhh bmRsZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGU6OnBsYXRmb3JtU2Vu ZCk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGU6OnBsYXRmb3JtQ2xvc2Up OgorCiAyMDEwLTAxLTI2ICBEbWl0cnkgVGl0b3YgIDxkaW1pY2hAY2hyb21pdW0ub3JnPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IFN0ZXZlIEZhbGtlbmJ1cmcuCkluZGV4OiBXZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlLmgJ KHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFt SGFuZGxlUHJpdmF0ZS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDc0IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDA5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHly aWdodCAoQykgMjAwOSBHb29nbGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0 aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5h bWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVj aWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAor ICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFNvY2tl dFN0cmVhbUhhbmRsZVByaXZhdGVfaAorI2RlZmluZSBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRl X2gKKworI2luY2x1ZGUgIlNvY2tldFN0cmVhbUhhbmRsZUJhc2UuaCIKKworI2luY2x1ZGUgPFFT c2xTb2NrZXQ+CisjaW5jbHVkZSA8UVRjcFNvY2tldD4KKworY2xhc3MgUVNzbFNvY2tldDsKKwor bmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZTsKK2Ns YXNzIENyZWRlbnRpYWw7CitjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVDbGllbnQ7CitjbGFzcyBT b2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOworCitjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVQcml2 YXRlIDogcHVibGljIFFPYmplY3QgeworUV9PQkpFQ1QKK3B1YmxpYzoKKyAgICBTb2NrZXRTdHJl YW1IYW5kbGVQcml2YXRlKFNvY2tldFN0cmVhbUhhbmRsZSogc3RyZWFtSGFuZGxlLCBjb25zdCBL VVJMJiB1cmwpOworICAgIH5Tb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlKCk7CisKK3B1YmxpYyBz bG90czoKKyAgICB2b2lkIHNvY2tldENvbm5lY3RlZCgpOworICAgIHZvaWQgc29ja2V0UmVhZHlS ZWFkKCk7CisgICAgaW50IHNlbmQoY29uc3QgY2hhciogZGF0YSwgaW50IGxlbik7CisgICAgdm9p ZCBjbG9zZSgpOworICAgIHZvaWQgc29ja2V0U2VudGRhdGEoKTsKKyAgICB2b2lkIHNvY2tldENs b3NlZCgpOworICAgIHZvaWQgc29ja2V0RXJyb3IoUUFic3RyYWN0U29ja2V0OjpTb2NrZXRFcnJv cik7CisgICAgdm9pZCBzb2NrZXRDbG9zZWRDYWxsYmFjaygpOworICAgIHZvaWQgc29ja2V0RXJy b3JDYWxsYmFjayhpbnQpOworICAgIHZvaWQgc29ja2V0U3NsRXJyb3JzKGNvbnN0IFFMaXN0PFFT c2xFcnJvcj4mKTsKK3B1YmxpYzoKKyAgICBRVGNwU29ja2V0KiBtX3NvY2tldDsKKyAgICBTb2Nr ZXRTdHJlYW1IYW5kbGUqIG1fc3RyZWFtSGFuZGxlOworICAgIHF1aW50NjQgbV9sYXN0U2VudFNp emU7Cit9OworCit9CisKKyNlbmRpZgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3F0 L1NvY2tldFN0cmVhbUhhbmRsZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGUuaAkocmV2aXNpb24gNTM4NTEpCisrKyBXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlLmgJKHdvcmtpbmcgY29weSkK QEAgLTQyLDYgKzQyLDcgQEAKICAgICBjbGFzcyBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZTsKICAg ICBjbGFzcyBDcmVkZW50aWFsOwogICAgIGNsYXNzIFNvY2tldFN0cmVhbUhhbmRsZUNsaWVudDsK KyAgICBjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOwogCiAgICAgY2xhc3MgU29ja2V0 U3RyZWFtSGFuZGxlIDogcHVibGljIFJlZkNvdW50ZWQ8U29ja2V0U3RyZWFtSGFuZGxlPiwgcHVi bGljIFNvY2tldFN0cmVhbUhhbmRsZUJhc2UgewogICAgIHB1YmxpYzoKQEAgLTYxLDYgKzYyLDgg QEAKICAgICAgICAgdm9pZCByZWNlaXZlZENyZWRlbnRpYWwoY29uc3QgQXV0aGVudGljYXRpb25D aGFsbGVuZ2UmLCBjb25zdCBDcmVkZW50aWFsJik7CiAgICAgICAgIHZvaWQgcmVjZWl2ZWRSZXF1 ZXN0VG9Db250aW51ZVdpdGhvdXRDcmVkZW50aWFsKGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxl bmdlJik7CiAgICAgICAgIHZvaWQgcmVjZWl2ZWRDYW5jZWxsYXRpb24oY29uc3QgQXV0aGVudGlj YXRpb25DaGFsbGVuZ2UmKTsKKyAgICAgICAgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZSogbV9w OworICAgICAgICBmcmllbmQgY2xhc3MgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTsKICAgICB9 OwogCiB9ICAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3F0L1NvY2tldFN0cmVhbUhhbmRsZVF0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlUXQuY3BwCShyZXZpc2lvbiA1Mzg1 MSkKKysrIFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGVRdC5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTM1LDM0ICszNSwxMjggQEAKICNpbmNsdWRlICJMb2dnaW5n LmgiCiAjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKICNpbmNsdWRlICJTb2NrZXRTdHJlYW1I YW5kbGVDbGllbnQuaCIKKyNpbmNsdWRlICJTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlLmgiCiAK IG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6U29ja2V0 U3RyZWFtSGFuZGxlUHJpdmF0ZShTb2NrZXRTdHJlYW1IYW5kbGUqIHN0cmVhbUhhbmRsZSwgY29u c3QgS1VSTCYgdXJsKSA6IFFPYmplY3QoKQoreworICAgIG1fc3RyZWFtSGFuZGxlID0gc3RyZWFt SGFuZGxlOworICAgIG1fc29ja2V0ID0gMDsKKyAgICBib29sIGlzU2VjdXJlID0gdXJsLnByb3Rv Y29sKCkuY29udGFpbnMoIndzcyIpOworICAgIGlmIChpc1NlY3VyZSkKKyAgICAgICAgbV9zb2Nr ZXQgPSBuZXcgUVNzbFNvY2tldCh0aGlzKTsKKyAgICBlbHNlCisgICAgICAgIG1fc29ja2V0ID0g bmV3IFFUY3BTb2NrZXQodGhpcyk7CisgICAgY29ubmVjdChtX3NvY2tldCwgU0lHTkFMKGNvbm5l Y3RlZCgpKSwgdGhpcywgU0xPVChzb2NrZXRDb25uZWN0ZWQoKSkpOworICAgIGNvbm5lY3QobV9z b2NrZXQsIFNJR05BTChyZWFkeVJlYWQoKSksIHRoaXMsIFNMT1Qoc29ja2V0UmVhZHlSZWFkKCkp KTsKKyAgICBjb25uZWN0KG1fc29ja2V0LCBTSUdOQUwoZGlzY29ubmVjdGVkKCkpLCB0aGlzLCBT TE9UKHNvY2tldENsb3NlZCgpKSk7CisgICAgY29ubmVjdChtX3NvY2tldCwgU0lHTkFMKGVycm9y KFFBYnN0cmFjdFNvY2tldDo6U29ja2V0RXJyb3IpKSwgdGhpcywgU0xPVChzb2NrZXRFcnJvcihR QWJzdHJhY3RTb2NrZXQ6OlNvY2tldEVycm9yKSkpOworICAgIGlmIChpc1NlY3VyZSkKKyAgICAg ICAgY29ubmVjdChtX3NvY2tldCwgU0lHTkFMKHNzbEVycm9ycyhjb25zdCBRTGlzdDxRU3NsRXJy b3I+JikpLCB0aGlzLCBTTE9UKHNvY2tldFNzbEVycm9ycyhjb25zdCBRTGlzdDxRU3NsRXJyb3I+ JikpKTsKKyAgICB1bnNpZ25lZCBpbnQgcG9ydCA9IHVybC5oYXNQb3J0KCkgPyB1cmwucG9ydCgp IDogaXNTZWN1cmUgPyA0NDMgOiA4MDsKKyAgICBRU3RyaW5nIGhvc3QgPSB1cmwuaG9zdCgpOwor ICAgIGlmIChpc1NlY3VyZSkKKyAgICAgICAgcW9iamVjdF9jYXN0PFFTc2xTb2NrZXQqPihtX3Nv Y2tldCktPmNvbm5lY3RUb0hvc3RFbmNyeXB0ZWQoaG9zdCwgcG9ydCk7CisgICAgZWxzZQorICAg ICAgICBtX3NvY2tldC0+Y29ubmVjdFRvSG9zdChob3N0LCBwb3J0KTsKK30KKworU29ja2V0U3Ry ZWFtSGFuZGxlUHJpdmF0ZTo6flNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGUoKQoreworICAgIFFf QVNTRVJUKCEobV9zb2NrZXQgJiYgbV9zb2NrZXQtPnN0YXRlKCkgPT0gUUFic3RyYWN0U29ja2V0 OjpDb25uZWN0ZWRTdGF0ZSkpOworfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6 OnNvY2tldENvbm5lY3RlZCgpCit7CisgICAgaWYgKG1fc3RyZWFtSGFuZGxlICYmIG1fc3RyZWFt SGFuZGxlLT5jbGllbnQoKSkgeworICAgICAgICBtX3N0cmVhbUhhbmRsZS0+bV9zdGF0ZSA9IFNv Y2tldFN0cmVhbUhhbmRsZUJhc2U6Ok9wZW47CisgICAgICAgIG1fc3RyZWFtSGFuZGxlLT5jbGll bnQoKS0+ZGlkT3BlbihtX3N0cmVhbUhhbmRsZSk7CisgICAgfQorfQorCit2b2lkIFNvY2tldFN0 cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldFJlYWR5UmVhZCgpCit7CisgICAgaWYgKG1fc3RyZWFt SGFuZGxlICYmIG1fc3RyZWFtSGFuZGxlLT5jbGllbnQoKSkgeworICAgICAgICBRQnl0ZUFycmF5 IGRhdGEgPSBtX3NvY2tldC0+cmVhZEFsbCgpOworICAgICAgICBtX3N0cmVhbUhhbmRsZS0+Y2xp ZW50KCktPmRpZFJlY2VpdmVEYXRhKG1fc3RyZWFtSGFuZGxlLCBkYXRhLmNvbnN0RGF0YSgpLCBk YXRhLnNpemUoKSk7CisgICAgfQorfQorCitpbnQgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6 c2VuZChjb25zdCBjaGFyKiBkYXRhLCBpbnQgbGVuKQoreworICAgIG1fbGFzdFNlbnRTaXplID0g IG1fc29ja2V0LT53cml0ZShkYXRhLCBsZW4pOworICAgIFFNZXRhT2JqZWN0OjppbnZva2VNZXRo b2QodGhpcywgInNvY2tldFNlbnREYXRhIiwgUXQ6OlF1ZXVlZENvbm5lY3Rpb24pOworICAgIHJl dHVybiBtX2xhc3RTZW50U2l6ZTsKK30KKwordm9pZCBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRl OjpjbG9zZSgpCit7CisgICAgaWYgKG1fc29ja2V0ICYmIG1fc29ja2V0LT5zdGF0ZSgpID09IFFB YnN0cmFjdFNvY2tldDo6Q29ubmVjdGVkU3RhdGUpCisgICAgICAgIG1fc29ja2V0LT5jbG9zZSgp OworfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldFNlbnRkYXRhKCkK K3sKKyAgICBpZiAobV9zdHJlYW1IYW5kbGUpCisgICAgICAgIG1fc3RyZWFtSGFuZGxlLT5zZW5k UGVuZGluZ0RhdGEoKTsKK30KKwordm9pZCBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjpzb2Nr ZXRDbG9zZWQoKQoreworICAgIFFNZXRhT2JqZWN0OjppbnZva2VNZXRob2QodGhpcywgInNvY2tl dENsb3NlZENhbGxiYWNrIiwgUXQ6OlF1ZXVlZENvbm5lY3Rpb24pOworfQorCit2b2lkIFNvY2tl dFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldEVycm9yKFFBYnN0cmFjdFNvY2tldDo6U29ja2V0 RXJyb3IgZXJyb3IpCit7CisgICAgUU1ldGFPYmplY3Q6Omludm9rZU1ldGhvZCh0aGlzLCAic29j a2V0RXJyb3IiLCBRdDo6UXVldWVkQ29ubmVjdGlvbiwgUV9BUkcoaW50LCBlcnJvcikpOworfQor Cit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldENsb3NlZENhbGxiYWNrKCkK K3sKKyAgICBpZiAobV9zdHJlYW1IYW5kbGUgJiYgbV9zdHJlYW1IYW5kbGUtPmNsaWVudCgpKSB7 CisgICAgICAgIG1fc3RyZWFtSGFuZGxlLT5jbGllbnQoKS0+ZGlkQ2xvc2UobV9zdHJlYW1IYW5k bGUpOworICAgICAgICBtX3N0cmVhbUhhbmRsZSA9IDA7CisgICAgfQorfQorCit2b2lkIFNvY2tl dFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldEVycm9yQ2FsbGJhY2soaW50IGVycm9yKQorewor ICAgIC8vIEZJWE1FIC0gaW4gdGhlIGZ1dHVyZSwgd2UgbWlnaHQgbm90IHdhbnQgdG8gdHJlYXQg YWxsIGVycm9ycyBhcyBmYXRhbC4KKyAgICBpZiAobV9zdHJlYW1IYW5kbGUgJiYgbV9zdHJlYW1I YW5kbGUtPmNsaWVudCgpKSB7CisgICAgICAgIG1fc3RyZWFtSGFuZGxlLT5jbGllbnQoKS0+ZGlk Q2xvc2UobV9zdHJlYW1IYW5kbGUpOworICAgICAgICBtX3N0cmVhbUhhbmRsZSA9IDA7CisgICAg fQorfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldFNzbEVycm9ycyhj b25zdCBRTGlzdDxRU3NsRXJyb3I+JikKK3sKKyAgICBxb2JqZWN0X2Nhc3Q8UVNzbFNvY2tldCo+ KG1fc29ja2V0KS0+aWdub3JlU3NsRXJyb3JzKCk7Cit9CiBTb2NrZXRTdHJlYW1IYW5kbGU6OlNv Y2tldFN0cmVhbUhhbmRsZShjb25zdCBLVVJMJiB1cmwsIFNvY2tldFN0cmVhbUhhbmRsZUNsaWVu dCogY2xpZW50KQogICAgIDogU29ja2V0U3RyZWFtSGFuZGxlQmFzZSh1cmwsIGNsaWVudCkKIHsK ICAgICBMT0coTmV0d29yaywgIlNvY2tldFN0cmVhbUhhbmRsZSAlcCBuZXcgY2xpZW50ICVwIiwg dGhpcywgbV9jbGllbnQpOwotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgbV9wID0gbmV3IFNv Y2tldFN0cmVhbUhhbmRsZVByaXZhdGUodGhpcywgdXJsKTsKIH0KIAogU29ja2V0U3RyZWFtSGFu ZGxlOjp+U29ja2V0U3RyZWFtSGFuZGxlKCkKIHsKICAgICBMT0coTmV0d29yaywgIlNvY2tldFN0 cmVhbUhhbmRsZSAlcCBkZWxldGUiLCB0aGlzKTsKICAgICBzZXRDbGllbnQoMCk7Ci0gICAgbm90 SW1wbGVtZW50ZWQoKTsKKyAgICBkZWxldGUgbV9wOwogfQogCi1pbnQgU29ja2V0U3RyZWFtSGFu ZGxlOjpwbGF0Zm9ybVNlbmQoY29uc3QgY2hhciosIGludCkKK2ludCBTb2NrZXRTdHJlYW1IYW5k bGU6OnBsYXRmb3JtU2VuZChjb25zdCBjaGFyKiBkYXRhLCBpbnQgbGVuKQogewogICAgIExPRyhO ZXR3b3JrLCAiU29ja2V0U3RyZWFtSGFuZGxlICVwIHBsYXRmb3JtU2VuZCIsIHRoaXMpOwotICAg IG5vdEltcGxlbWVudGVkKCk7Ci0gICAgcmV0dXJuIDA7CisgICAgcmV0dXJuIG1fcC0+c2VuZChk YXRhLCBsZW4pOwogfQogCiB2b2lkIFNvY2tldFN0cmVhbUhhbmRsZTo6cGxhdGZvcm1DbG9zZSgp CiB7CiAgICAgTE9HKE5ldHdvcmssICJTb2NrZXRTdHJlYW1IYW5kbGUgJXAgcGxhdGZvcm1DbG9z ZSIsIHRoaXMpOwotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgbV9wLT5jbG9zZSgpOwogfQog CiB2b2lkIFNvY2tldFN0cmVhbUhhbmRsZTo6ZGlkUmVjZWl2ZUF1dGhlbnRpY2F0aW9uQ2hhbGxl bmdlKGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJikKQEAgLTg2LDMgKzE4MCw1IEBACiB9 CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2luY2x1ZGUgIm1vY19Tb2NrZXRTdHJlYW1I YW5kbGVQcml2YXRlLmNwcCIKSW5kZXg6IExheW91dFRlc3RzL3BsYXRmb3JtL3F0L1NraXBwZWQK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQvU2tpcHBlZAkocmV2aXNpb24g NTM4NTEpCisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9Ta2lwcGVkCSh3b3JraW5nIGNvcHkp CkBAIC00OTY1LDcgKzQ5NjUsNiBAQAogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC93b3JrZXJz L3NoYXJlZC13b3JrZXItbWV0aG9kcy1hc3luYy5odG1sCiAKICMgTWlzc2luZyBTb2NrZXRTdHJl YW1IYW5kbGUgaW1wbGVtZW50YXRpb24KLXdlYnNvY2tldC90ZXN0cwogCiAjIE5lZWQgcmViYXNl bGluZTogaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI2ODMwCiBmYXN0 L211bHRpY29sL3NpbmdsZS1saW5lLmh0bWwKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDUzODc2KQorKysg TGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQgQEAKKzIw MTAtMDEtMjYgIFlhZWwgQWhhcm9uICA8eWFlbC5haGFyb25Abm9raWEuY29tPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtRdF0gRW5hYmxlIHdlYnNv Y2tldHMgc3VwcG9ydCBpbiBRdFdlYktpdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MzQxODAKKworICAgICAgICBSZW1vdmUgd2Vic29ja2V0cyB0ZXN0 cyBmcm9tIHNraXBsaXN0LgorCisgICAgICAgICogcGxhdGZvcm0vcXQvU2tpcHBlZDoKKwogMjAx MC0wMS0yNiAgRnVtaXRvc2hpIFVrYWkgIDx1a2FpQGNocm9taXVtLm9yZz4KIAogICAgICAgICBS ZXZpZXdlZCBieSBBbGV4ZXkgUHJvc2t1cnlha292Lgo= 47547 2010-01-27 10:32:37 -0800 2010-01-27 11:06:01 -0800 Patch v3 34180.patch text/plain 12616 yael SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnBybwkocmV2aXNpb24gNTM4NTEpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5nIGNv cHkpCkBAIC0xNTMwLDYgKzE1MzAsNyBAQAogICAgIHBsYXRmb3JtL25ldHdvcmsvTmV0d29ya1N0 YXRlTm90aWZpZXIuaCBcCiAgICAgcGxhdGZvcm0vbmV0d29yay9Qcm90ZWN0aW9uU3BhY2UuaCBc CiAgICAgcGxhdGZvcm0vbmV0d29yay9xdC9RTmV0d29ya1JlcGx5SGFuZGxlci5oIFwKKyAgICBw bGF0Zm9ybS9uZXR3b3JrL3F0L1NvY2tldFN0cmVhbUhhbmRsZVByaXZhdGUuaCBcCiAgICAgcGxh dGZvcm0vbmV0d29yay9SZXNvdXJjZUVycm9yQmFzZS5oIFwKICAgICBwbGF0Zm9ybS9uZXR3b3Jr L1Jlc291cmNlSGFuZGxlLmggXAogICAgIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VSZXF1ZXN0 QmFzZS5oIFwKSW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv Q2hhbmdlTG9nCShyZXZpc2lvbiA1Mzg3NikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTAtMDEtMjYgIFlhZWwgQWhhcm9uICA8eWFlbC5h aGFyb25Abm9raWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFtRdF0gRW5hYmxlIHdlYnNvY2tldHMgc3VwcG9ydCBpbiBRdFdlYktpdAorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQxODAKKworICAg ICAgICBDb25uZWN0ZWQgYmV0d2VlbiBTb2NrZXRTdHJlYW1IYW5kbGUgYW5kIFFUY3BTb2NrZXQv UVNzbFNvY2tldAorICAgICAgICB0byBlbmFibGUgc3VwcG9ydCBmb3Igd2Vic29ja2V0cy4KKwor ICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvcXQvU29j a2V0U3RyZWFtSGFuZGxlLmg6CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRT dHJlYW1IYW5kbGVQcml2YXRlLmg6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsv cXQvU29ja2V0U3RyZWFtSGFuZGxlUXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3Ry ZWFtSGFuZGxlUHJpdmF0ZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZSk6CisgICAgICAgIChX ZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjp+U29ja2V0U3RyZWFtSGFuZGxlUHJp dmF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjpzb2Nr ZXRDb25uZWN0ZWQpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0 ZTo6c29ja2V0UmVhZHlSZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRs ZVByaXZhdGU6OnNlbmQpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJp dmF0ZTo6Y2xvc2UpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0 ZTo6c29ja2V0U2VudGRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxl UHJpdmF0ZTo6c29ja2V0Q2xvc2VkKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhh bmRsZVByaXZhdGU6OnNvY2tldEVycm9yKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVh bUhhbmRsZVByaXZhdGU6OnNvY2tldENsb3NlZENhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6 OlNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldEVycm9yQ2FsbGJhY2spOgorICAgICAg ICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6c29ja2V0U3NsRXJyb3JzKToK KyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRsZTo6U29ja2V0U3RyZWFtSGFuZGxl KToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRsZTo6flNvY2tldFN0cmVhbUhh bmRsZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGU6OnBsYXRmb3JtU2Vu ZCk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGU6OnBsYXRmb3JtQ2xvc2Up OgorCiAyMDEwLTAxLTI2ICBEbWl0cnkgVGl0b3YgIDxkaW1pY2hAY2hyb21pdW0ub3JnPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IFN0ZXZlIEZhbGtlbmJ1cmcuCkluZGV4OiBXZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlLmgJ KHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFt SGFuZGxlUHJpdmF0ZS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDcwIEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIE5va2lhIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0 aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5h bWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVj aWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAor ICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFNvY2tl dFN0cmVhbUhhbmRsZVByaXZhdGVfaAorI2RlZmluZSBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRl X2gKKworI2luY2x1ZGUgIlNvY2tldFN0cmVhbUhhbmRsZUJhc2UuaCIKKworI2luY2x1ZGUgPFFT c2xTb2NrZXQ+CisjaW5jbHVkZSA8UVRjcFNvY2tldD4KKworbmFtZXNwYWNlIFdlYkNvcmUgewor CitjbGFzcyBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZTsKK2NsYXNzIENyZWRlbnRpYWw7CitjbGFz cyBTb2NrZXRTdHJlYW1IYW5kbGVDbGllbnQ7CitjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVQcml2 YXRlOworCitjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlIDogcHVibGljIFFPYmplY3Qg eworICAgIFFfT0JKRUNUCitwdWJsaWM6CisgICAgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZShT b2NrZXRTdHJlYW1IYW5kbGUqLCBjb25zdCBLVVJMJik7CisgICAgflNvY2tldFN0cmVhbUhhbmRs ZVByaXZhdGUoKTsKKworcHVibGljIHNsb3RzOgorICAgIHZvaWQgc29ja2V0Q29ubmVjdGVkKCk7 CisgICAgdm9pZCBzb2NrZXRSZWFkeVJlYWQoKTsKKyAgICBpbnQgc2VuZChjb25zdCBjaGFyKiBk YXRhLCBpbnQgbGVuKTsKKyAgICB2b2lkIGNsb3NlKCk7CisgICAgdm9pZCBzb2NrZXRTZW50ZGF0 YSgpOworICAgIHZvaWQgc29ja2V0Q2xvc2VkKCk7CisgICAgdm9pZCBzb2NrZXRFcnJvcihRQWJz dHJhY3RTb2NrZXQ6OlNvY2tldEVycm9yKTsKKyAgICB2b2lkIHNvY2tldENsb3NlZENhbGxiYWNr KCk7CisgICAgdm9pZCBzb2NrZXRFcnJvckNhbGxiYWNrKGludCk7CisgICAgdm9pZCBzb2NrZXRT c2xFcnJvcnMoY29uc3QgUUxpc3Q8UVNzbEVycm9yPiYpOworcHVibGljOgorICAgIFFUY3BTb2Nr ZXQqIG1fc29ja2V0OworICAgIFNvY2tldFN0cmVhbUhhbmRsZSogbV9zdHJlYW1IYW5kbGU7Cit9 OworCit9CisKKyNlbmRpZgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3F0L1NvY2tl dFN0cmVhbUhhbmRsZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9x dC9Tb2NrZXRTdHJlYW1IYW5kbGUuaAkocmV2aXNpb24gNTM4NTEpCisrKyBXZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlLmgJKHdvcmtpbmcgY29weSkKQEAgLTQy LDYgKzQyLDcgQEAKICAgICBjbGFzcyBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZTsKICAgICBjbGFz cyBDcmVkZW50aWFsOwogICAgIGNsYXNzIFNvY2tldFN0cmVhbUhhbmRsZUNsaWVudDsKKyAgICBj bGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOwogCiAgICAgY2xhc3MgU29ja2V0U3RyZWFt SGFuZGxlIDogcHVibGljIFJlZkNvdW50ZWQ8U29ja2V0U3RyZWFtSGFuZGxlPiwgcHVibGljIFNv Y2tldFN0cmVhbUhhbmRsZUJhc2UgewogICAgIHB1YmxpYzoKQEAgLTYxLDYgKzYyLDggQEAKICAg ICAgICAgdm9pZCByZWNlaXZlZENyZWRlbnRpYWwoY29uc3QgQXV0aGVudGljYXRpb25DaGFsbGVu Z2UmLCBjb25zdCBDcmVkZW50aWFsJik7CiAgICAgICAgIHZvaWQgcmVjZWl2ZWRSZXF1ZXN0VG9D b250aW51ZVdpdGhvdXRDcmVkZW50aWFsKGNvbnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJik7 CiAgICAgICAgIHZvaWQgcmVjZWl2ZWRDYW5jZWxsYXRpb24oY29uc3QgQXV0aGVudGljYXRpb25D aGFsbGVuZ2UmKTsKKyAgICAgICAgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZSogbV9wOworICAg ICAgICBmcmllbmQgY2xhc3MgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTsKICAgICB9OwogCiB9 ICAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3F0 L1NvY2tldFN0cmVhbUhhbmRsZVF0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlUXQuY3BwCShyZXZpc2lvbiA1Mzg1MSkKKysr IFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGVRdC5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTEsNCArMSw1IEBACiAvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIE5v a2lhIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqIENvcHlyaWdodCAoQykgMjAwOSBHb29n bGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTM0LDM1 ICszNSwxMzkgQEAKICNpbmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgogI2lu Y2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCisjaW5jbHVkZSAiU29ja2V0U3RyZWFtRXJyb3IuaCIK ICNpbmNsdWRlICJTb2NrZXRTdHJlYW1IYW5kbGVDbGllbnQuaCIKKyNpbmNsdWRlICJTb2NrZXRT dHJlYW1IYW5kbGVQcml2YXRlLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorU29ja2V0U3Ry ZWFtSGFuZGxlUHJpdmF0ZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZShTb2NrZXRTdHJlYW1I YW5kbGUqIHN0cmVhbUhhbmRsZSwgY29uc3QgS1VSTCYgdXJsKSA6IFFPYmplY3QoKQoreworICAg IG1fc3RyZWFtSGFuZGxlID0gc3RyZWFtSGFuZGxlOworICAgIG1fc29ja2V0ID0gMDsKKyAgICBi b29sIGlzU2VjdXJlID0gdXJsLnByb3RvY29sSXMoIndzcyIpOworICAgIGlmIChpc1NlY3VyZSkK KyAgICAgICAgbV9zb2NrZXQgPSBuZXcgUVNzbFNvY2tldCh0aGlzKTsKKyAgICBlbHNlCisgICAg ICAgIG1fc29ja2V0ID0gbmV3IFFUY3BTb2NrZXQodGhpcyk7CisgICAgY29ubmVjdChtX3NvY2tl dCwgU0lHTkFMKGNvbm5lY3RlZCgpKSwgdGhpcywgU0xPVChzb2NrZXRDb25uZWN0ZWQoKSkpOwor ICAgIGNvbm5lY3QobV9zb2NrZXQsIFNJR05BTChyZWFkeVJlYWQoKSksIHRoaXMsIFNMT1Qoc29j a2V0UmVhZHlSZWFkKCkpKTsKKyAgICBjb25uZWN0KG1fc29ja2V0LCBTSUdOQUwoZGlzY29ubmVj dGVkKCkpLCB0aGlzLCBTTE9UKHNvY2tldENsb3NlZCgpKSk7CisgICAgY29ubmVjdChtX3NvY2tl dCwgU0lHTkFMKGVycm9yKFFBYnN0cmFjdFNvY2tldDo6U29ja2V0RXJyb3IpKSwgdGhpcywgU0xP VChzb2NrZXRFcnJvcihRQWJzdHJhY3RTb2NrZXQ6OlNvY2tldEVycm9yKSkpOworICAgIGlmIChp c1NlY3VyZSkKKyAgICAgICAgY29ubmVjdChtX3NvY2tldCwgU0lHTkFMKHNzbEVycm9ycyhjb25z dCBRTGlzdDxRU3NsRXJyb3I+JikpLCB0aGlzLCBTTE9UKHNvY2tldFNzbEVycm9ycyhjb25zdCBR TGlzdDxRU3NsRXJyb3I+JikpKTsKKworICAgIHVuc2lnbmVkIGludCBwb3J0ID0gdXJsLmhhc1Bv cnQoKSA/IHVybC5wb3J0KCkgOiAoaXNTZWN1cmUgPyA0NDMgOiA4MCk7CisKKyAgICBRU3RyaW5n IGhvc3QgPSB1cmwuaG9zdCgpOworICAgIGlmIChpc1NlY3VyZSkKKyAgICAgICAgc3RhdGljX2Nh c3Q8UVNzbFNvY2tldCo+KG1fc29ja2V0KS0+Y29ubmVjdFRvSG9zdEVuY3J5cHRlZChob3N0LCBw b3J0KTsKKyAgICBlbHNlCisgICAgICAgIG1fc29ja2V0LT5jb25uZWN0VG9Ib3N0KGhvc3QsIHBv cnQpOworfQorCitTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjp+U29ja2V0U3RyZWFtSGFuZGxl UHJpdmF0ZSgpCit7CisgICAgUV9BU1NFUlQoIShtX3NvY2tldCAmJiBtX3NvY2tldC0+c3RhdGUo KSA9PSBRQWJzdHJhY3RTb2NrZXQ6OkNvbm5lY3RlZFN0YXRlKSk7Cit9CisKK3ZvaWQgU29ja2V0 U3RyZWFtSGFuZGxlUHJpdmF0ZTo6c29ja2V0Q29ubmVjdGVkKCkKK3sKKyAgICBpZiAobV9zdHJl YW1IYW5kbGUgJiYgbV9zdHJlYW1IYW5kbGUtPmNsaWVudCgpKSB7CisgICAgICAgIG1fc3RyZWFt SGFuZGxlLT5tX3N0YXRlID0gU29ja2V0U3RyZWFtSGFuZGxlQmFzZTo6T3BlbjsKKyAgICAgICAg bV9zdHJlYW1IYW5kbGUtPmNsaWVudCgpLT5kaWRPcGVuKG1fc3RyZWFtSGFuZGxlKTsKKyAgICB9 Cit9CisKK3ZvaWQgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6c29ja2V0UmVhZHlSZWFkKCkK K3sKKyAgICBpZiAobV9zdHJlYW1IYW5kbGUgJiYgbV9zdHJlYW1IYW5kbGUtPmNsaWVudCgpKSB7 CisgICAgICAgIFFCeXRlQXJyYXkgZGF0YSA9IG1fc29ja2V0LT5yZWFkKG1fc29ja2V0LT5ieXRl c0F2YWlsYWJsZSgpKTsKKyAgICAgICAgbV9zdHJlYW1IYW5kbGUtPmNsaWVudCgpLT5kaWRSZWNl aXZlRGF0YShtX3N0cmVhbUhhbmRsZSwgZGF0YS5jb25zdERhdGEoKSwgZGF0YS5zaXplKCkpOwor ICAgIH0KK30KKworaW50IFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNlbmQoY29uc3QgY2hh ciogZGF0YSwgaW50IGxlbikKK3sKKyAgICBpZiAobV9zb2NrZXQtPnN0YXRlKCkgIT0gUUFic3Ry YWN0U29ja2V0OjpDb25uZWN0ZWRTdGF0ZSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgcXVpbnQ2 NCBzZW50U2l6ZSA9IG1fc29ja2V0LT53cml0ZShkYXRhLCBsZW4pOworICAgIFFNZXRhT2JqZWN0 OjppbnZva2VNZXRob2QodGhpcywgInNvY2tldFNlbnREYXRhIiwgUXQ6OlF1ZXVlZENvbm5lY3Rp b24pOworICAgIHJldHVybiBzZW50U2l6ZTsKK30KKwordm9pZCBTb2NrZXRTdHJlYW1IYW5kbGVQ cml2YXRlOjpjbG9zZSgpCit7CisgICAgaWYgKG1fc29ja2V0ICYmIG1fc29ja2V0LT5zdGF0ZSgp ID09IFFBYnN0cmFjdFNvY2tldDo6Q29ubmVjdGVkU3RhdGUpCisgICAgICAgIG1fc29ja2V0LT5j bG9zZSgpOworfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldFNlbnRk YXRhKCkKK3sKKyAgICBpZiAobV9zdHJlYW1IYW5kbGUpCisgICAgICAgIG1fc3RyZWFtSGFuZGxl LT5zZW5kUGVuZGluZ0RhdGEoKTsKK30KKwordm9pZCBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRl Ojpzb2NrZXRDbG9zZWQoKQoreworICAgIFFNZXRhT2JqZWN0OjppbnZva2VNZXRob2QodGhpcywg InNvY2tldENsb3NlZENhbGxiYWNrIiwgUXQ6OlF1ZXVlZENvbm5lY3Rpb24pOworfQorCit2b2lk IFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldEVycm9yKFFBYnN0cmFjdFNvY2tldDo6 U29ja2V0RXJyb3IgZXJyb3IpCit7CisgICAgUU1ldGFPYmplY3Q6Omludm9rZU1ldGhvZCh0aGlz LCAic29ja2V0RXJyb3JDYWxsYmFjayIsIFF0OjpRdWV1ZWRDb25uZWN0aW9uLCBRX0FSRyhpbnQs IGVycm9yKSk7Cit9CisKK3ZvaWQgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6c29ja2V0Q2xv c2VkQ2FsbGJhY2soKQoreworICAgIGlmIChtX3N0cmVhbUhhbmRsZSAmJiBtX3N0cmVhbUhhbmRs ZS0+Y2xpZW50KCkpIHsKKyAgICAgICAgU29ja2V0U3RyZWFtSGFuZGxlKiBzdHJlYW1IYW5kbGUg PSBtX3N0cmVhbUhhbmRsZTsKKyAgICAgICAgICAgIG1fc3RyZWFtSGFuZGxlID0gMDsKKyAgICAg ICAgICAgIHN0cmVhbUhhbmRsZS0+Y2xpZW50KCktPmRpZENsb3NlKHN0cmVhbUhhbmRsZSk7Cisg ICAgfQorfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldEVycm9yQ2Fs bGJhY2soaW50IGVycm9yKQoreworICAgIC8vIEZJWE1FIC0gaW4gdGhlIGZ1dHVyZSwgd2UgbWln aHQgbm90IHdhbnQgdG8gdHJlYXQgYWxsIGVycm9ycyBhcyBmYXRhbC4KKyAgICBpZiAobV9zdHJl YW1IYW5kbGUgJiYgbV9zdHJlYW1IYW5kbGUtPmNsaWVudCgpKSB7CisgICAgICAgIFNvY2tldFN0 cmVhbUhhbmRsZSogc3RyZWFtSGFuZGxlID0gbV9zdHJlYW1IYW5kbGU7CisgICAgICAgIG1fc3Ry ZWFtSGFuZGxlID0gMDsKKyAgICAgICAgc3RyZWFtSGFuZGxlLT5jbGllbnQoKS0+ZGlkQ2xvc2Uo c3RyZWFtSGFuZGxlKTsKKyAgICB9Cit9CisKK3ZvaWQgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0 ZTo6c29ja2V0U3NsRXJyb3JzKGNvbnN0IFFMaXN0PFFTc2xFcnJvcj4mKQoreworICAgIC8vIEZJ WE1FOiBiYXNlZCBvbiBodHRwOi8vdG9vbHMuaWV0Zi5vcmcvaHRtbC9kcmFmdC1oaXhpZS10aGV3 ZWJzb2NrZXRwcm90b2NvbC02OCNwYWdlLTE1CisgICAgLy8gd2Ugc2hvdWxkIGFib3J0IG9uIGNl cnRpZmljYXRlIGVycm9ycy4KKyAgICAvLyBXZSBkb24ndCBhYm9ydCB3aGlsZSB0aGlzIGlzIHN0 aWxsIHdvcmsgaW4gcHJvZ3Jlc3MuCisgICAgc3RhdGljX2Nhc3Q8UVNzbFNvY2tldCo+KG1fc29j a2V0KS0+aWdub3JlU3NsRXJyb3JzKCk7Cit9CiBTb2NrZXRTdHJlYW1IYW5kbGU6OlNvY2tldFN0 cmVhbUhhbmRsZShjb25zdCBLVVJMJiB1cmwsIFNvY2tldFN0cmVhbUhhbmRsZUNsaWVudCogY2xp ZW50KQogICAgIDogU29ja2V0U3RyZWFtSGFuZGxlQmFzZSh1cmwsIGNsaWVudCkKIHsKICAgICBM T0coTmV0d29yaywgIlNvY2tldFN0cmVhbUhhbmRsZSAlcCBuZXcgY2xpZW50ICVwIiwgdGhpcywg bV9jbGllbnQpOwotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgbV9wID0gbmV3IFNvY2tldFN0 cmVhbUhhbmRsZVByaXZhdGUodGhpcywgdXJsKTsKIH0KIAogU29ja2V0U3RyZWFtSGFuZGxlOjp+ U29ja2V0U3RyZWFtSGFuZGxlKCkKIHsKICAgICBMT0coTmV0d29yaywgIlNvY2tldFN0cmVhbUhh bmRsZSAlcCBkZWxldGUiLCB0aGlzKTsKICAgICBzZXRDbGllbnQoMCk7Ci0gICAgbm90SW1wbGVt ZW50ZWQoKTsKKyAgICBkZWxldGUgbV9wOwogfQogCi1pbnQgU29ja2V0U3RyZWFtSGFuZGxlOjpw bGF0Zm9ybVNlbmQoY29uc3QgY2hhciosIGludCkKK2ludCBTb2NrZXRTdHJlYW1IYW5kbGU6OnBs YXRmb3JtU2VuZChjb25zdCBjaGFyKiBkYXRhLCBpbnQgbGVuKQogewogICAgIExPRyhOZXR3b3Jr LCAiU29ja2V0U3RyZWFtSGFuZGxlICVwIHBsYXRmb3JtU2VuZCIsIHRoaXMpOwotICAgIG5vdElt cGxlbWVudGVkKCk7Ci0gICAgcmV0dXJuIDA7CisgICAgcmV0dXJuIG1fcC0+c2VuZChkYXRhLCBs ZW4pOwogfQogCiB2b2lkIFNvY2tldFN0cmVhbUhhbmRsZTo6cGxhdGZvcm1DbG9zZSgpCiB7CiAg ICAgTE9HKE5ldHdvcmssICJTb2NrZXRTdHJlYW1IYW5kbGUgJXAgcGxhdGZvcm1DbG9zZSIsIHRo aXMpOwotICAgIG5vdEltcGxlbWVudGVkKCk7CisgICAgbV9wLT5jbG9zZSgpOwogfQogCiB2b2lk IFNvY2tldFN0cmVhbUhhbmRsZTo6ZGlkUmVjZWl2ZUF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlKGNv bnN0IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlJikKQEAgLTg2LDMgKzE5MSw1IEBACiB9CiAKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2luY2x1ZGUgIm1vY19Tb2NrZXRTdHJlYW1IYW5kbGVQ cml2YXRlLmNwcCIKSW5kZXg6IExheW91dFRlc3RzL3BsYXRmb3JtL3F0L1NraXBwZWQKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQvU2tpcHBlZAkocmV2aXNpb24gNTM4NTEp CisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9Ta2lwcGVkCSh3b3JraW5nIGNvcHkpCkBAIC00 OTY0LDkgKzQ5NjQsNiBAQAogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC93b3JrZXJzL21ldGhv ZHMuaHRtbAogaHR0cC90ZXN0cy94bWxodHRwcmVxdWVzdC93b3JrZXJzL3NoYXJlZC13b3JrZXIt bWV0aG9kcy1hc3luYy5odG1sCiAKLSMgTWlzc2luZyBTb2NrZXRTdHJlYW1IYW5kbGUgaW1wbGVt ZW50YXRpb24KLXdlYnNvY2tldC90ZXN0cwotCiAjIE5lZWQgcmViYXNlbGluZTogaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI2ODMwCiBmYXN0L211bHRpY29sL3Npbmds ZS1saW5lLmh0bWwKIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNTM4NzYpCisrKyBMYXlvdXRUZXN0cy9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNCBAQAorMjAxMC0wMS0yNiAgWWFl bCBBaGFyb24gIDx5YWVsLmFoYXJvbkBub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW1F0XSBFbmFibGUgd2Vic29ja2V0cyBzdXBwb3J0 IGluIFF0V2ViS2l0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0zNDE4MAorCisgICAgICAgIFJlbW92ZSB3ZWJzb2NrZXRzIHRlc3RzIGZyb20gc2tpcGxp c3QuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9xdC9Ta2lwcGVkOgorCiAyMDEwLTAxLTI2ICBGdW1p dG9zaGkgVWthaSAgPHVrYWlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFs ZXhleSBQcm9za3VyeWFrb3YuCg== 47551 2010-01-27 11:06:01 -0800 2010-01-27 12:16:59 -0800 Patch v4 34180.patch text/plain 13029 yael SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5wcm8KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3Jl LnBybwkocmV2aXNpb24gNTM4NTEpCisrKyBXZWJDb3JlL1dlYkNvcmUucHJvCSh3b3JraW5nIGNv cHkpCkBAIC0xNTMwLDYgKzE1MzAsNyBAQAogICAgIHBsYXRmb3JtL25ldHdvcmsvTmV0d29ya1N0 YXRlTm90aWZpZXIuaCBcCiAgICAgcGxhdGZvcm0vbmV0d29yay9Qcm90ZWN0aW9uU3BhY2UuaCBc CiAgICAgcGxhdGZvcm0vbmV0d29yay9xdC9RTmV0d29ya1JlcGx5SGFuZGxlci5oIFwKKyAgICBw bGF0Zm9ybS9uZXR3b3JrL3F0L1NvY2tldFN0cmVhbUhhbmRsZVByaXZhdGUuaCBcCiAgICAgcGxh dGZvcm0vbmV0d29yay9SZXNvdXJjZUVycm9yQmFzZS5oIFwKICAgICBwbGF0Zm9ybS9uZXR3b3Jr L1Jlc291cmNlSGFuZGxlLmggXAogICAgIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VSZXF1ZXN0 QmFzZS5oIFwKSW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv Q2hhbmdlTG9nCShyZXZpc2lvbiA1Mzg3NikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMzYgQEAKKzIwMTAtMDEtMjYgIFlhZWwgQWhhcm9uICA8eWFlbC5h aGFyb25Abm9raWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFtRdF0gRW5hYmxlIHdlYnNvY2tldHMgc3VwcG9ydCBpbiBRdFdlYktpdAorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzQxODAKKworICAg ICAgICBDb25uZWN0ZWQgYmV0d2VlbiBTb2NrZXRTdHJlYW1IYW5kbGUgYW5kIFFUY3BTb2NrZXQv UVNzbFNvY2tldAorICAgICAgICB0byBlbmFibGUgc3VwcG9ydCBmb3Igd2Vic29ja2V0cy4KKyAg ICAgICAgUHJveHkgYXV0aGVudGljYXRpb24gaXMgbm90IHlldCBzdXBwb3J0ZWQuCisgICAgICAg IFNTTCBjZXJ0aWZpY2F0ZSBlcnJvcnMgYXJlIGlnbm9yZWQgd2hpbGUgdGhpcyBpcyB1bmRlciBk ZXZlbG9wbWVudC4KKworICAgICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIHBsYXRmb3Jt L25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlLmg6CisgICAgICAgICogcGxhdGZvcm0vbmV0 d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlLmg6IEFkZGVkLgorICAgICAgICAqIHBs YXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlUXQuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0 ZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjp+U29ja2V0 U3RyZWFtSGFuZGxlUHJpdmF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5k bGVQcml2YXRlOjpzb2NrZXRDb25uZWN0ZWQpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3Ry ZWFtSGFuZGxlUHJpdmF0ZTo6c29ja2V0UmVhZHlSZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OlNv Y2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNlbmQpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0 U3RyZWFtSGFuZGxlUHJpdmF0ZTo6Y2xvc2UpOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3Ry ZWFtSGFuZGxlUHJpdmF0ZTo6c29ja2V0U2VudGRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6U29j a2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6c29ja2V0Q2xvc2VkKToKKyAgICAgICAgKFdlYkNvcmU6 OlNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldEVycm9yKToKKyAgICAgICAgKFdlYkNv cmU6OlNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldENsb3NlZENhbGxiYWNrKToKKyAg ICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldEVycm9yQ2Fs bGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6c29j a2V0U3NsRXJyb3JzKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRsZTo6U29j a2V0U3RyZWFtSGFuZGxlKToKKyAgICAgICAgKFdlYkNvcmU6OlNvY2tldFN0cmVhbUhhbmRsZTo6 flNvY2tldFN0cmVhbUhhbmRsZSk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5k bGU6OnBsYXRmb3JtU2VuZCk6CisgICAgICAgIChXZWJDb3JlOjpTb2NrZXRTdHJlYW1IYW5kbGU6 OnBsYXRmb3JtQ2xvc2UpOgorCiAyMDEwLTAxLTI2ICBEbWl0cnkgVGl0b3YgIDxkaW1pY2hAY2hy b21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFN0ZXZlIEZhbGtlbmJ1cmcuCkluZGV4 OiBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZS5o Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRTdHJlYW1I YW5kbGVQcml2YXRlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv cXQvU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDcw IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisg KiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4g dGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUg SW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRv IGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdh cmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRS SUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBV UlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAq IE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaWZuZGVmIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGVfaAorI2RlZmluZSBTb2NrZXRTdHJl YW1IYW5kbGVQcml2YXRlX2gKKworI2luY2x1ZGUgIlNvY2tldFN0cmVhbUhhbmRsZUJhc2UuaCIK KworI2luY2x1ZGUgPFFTc2xTb2NrZXQ+CisjaW5jbHVkZSA8UVRjcFNvY2tldD4KKworbmFtZXNw YWNlIFdlYkNvcmUgeworCitjbGFzcyBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZTsKK2NsYXNzIENy ZWRlbnRpYWw7CitjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVDbGllbnQ7CitjbGFzcyBTb2NrZXRT dHJlYW1IYW5kbGVQcml2YXRlOworCitjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlIDog cHVibGljIFFPYmplY3QgeworICAgIFFfT0JKRUNUCitwdWJsaWM6CisgICAgU29ja2V0U3RyZWFt SGFuZGxlUHJpdmF0ZShTb2NrZXRTdHJlYW1IYW5kbGUqLCBjb25zdCBLVVJMJik7CisgICAgflNv Y2tldFN0cmVhbUhhbmRsZVByaXZhdGUoKTsKKworcHVibGljIHNsb3RzOgorICAgIHZvaWQgc29j a2V0Q29ubmVjdGVkKCk7CisgICAgdm9pZCBzb2NrZXRSZWFkeVJlYWQoKTsKKyAgICBpbnQgc2Vu ZChjb25zdCBjaGFyKiBkYXRhLCBpbnQgbGVuKTsKKyAgICB2b2lkIGNsb3NlKCk7CisgICAgdm9p ZCBzb2NrZXRTZW50ZGF0YSgpOworICAgIHZvaWQgc29ja2V0Q2xvc2VkKCk7CisgICAgdm9pZCBz b2NrZXRFcnJvcihRQWJzdHJhY3RTb2NrZXQ6OlNvY2tldEVycm9yKTsKKyAgICB2b2lkIHNvY2tl dENsb3NlZENhbGxiYWNrKCk7CisgICAgdm9pZCBzb2NrZXRFcnJvckNhbGxiYWNrKGludCk7Cisg ICAgdm9pZCBzb2NrZXRTc2xFcnJvcnMoY29uc3QgUUxpc3Q8UVNzbEVycm9yPiYpOworcHVibGlj OgorICAgIFFUY3BTb2NrZXQqIG1fc29ja2V0OworICAgIFNvY2tldFN0cmVhbUhhbmRsZSogbV9z dHJlYW1IYW5kbGU7Cit9OworCit9CisKKyNlbmRpZgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3F0L1NvY2tldFN0cmVhbUhhbmRsZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGUuaAkocmV2aXNpb24gNTM4NTEpCisr KyBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlLmgJKHdvcmtp bmcgY29weSkKQEAgLTEsNCArMSw1IEBACiAvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIE5va2lh IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqIENvcHlyaWdodCAoQykgMjAwOSBBcHBsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDkgR29vZ2xlIElu Yy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgpAQCAtNDIsNiArNDMsNyBAQAogICAgIGNsYXNz IEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlOwogICAgIGNsYXNzIENyZWRlbnRpYWw7CiAgICAgY2xh c3MgU29ja2V0U3RyZWFtSGFuZGxlQ2xpZW50OworICAgIGNsYXNzIFNvY2tldFN0cmVhbUhhbmRs ZVByaXZhdGU7CiAKICAgICBjbGFzcyBTb2NrZXRTdHJlYW1IYW5kbGUgOiBwdWJsaWMgUmVmQ291 bnRlZDxTb2NrZXRTdHJlYW1IYW5kbGU+LCBwdWJsaWMgU29ja2V0U3RyZWFtSGFuZGxlQmFzZSB7 CiAgICAgcHVibGljOgpAQCAtNjEsNiArNjMsOCBAQAogICAgICAgICB2b2lkIHJlY2VpdmVkQ3Jl ZGVudGlhbChjb25zdCBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZSYsIGNvbnN0IENyZWRlbnRpYWwm KTsKICAgICAgICAgdm9pZCByZWNlaXZlZFJlcXVlc3RUb0NvbnRpbnVlV2l0aG91dENyZWRlbnRp YWwoY29uc3QgQXV0aGVudGljYXRpb25DaGFsbGVuZ2UmKTsKICAgICAgICAgdm9pZCByZWNlaXZl ZENhbmNlbGxhdGlvbihjb25zdCBBdXRoZW50aWNhdGlvbkNoYWxsZW5nZSYpOworICAgICAgICBT b2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlKiBtX3A7CisgICAgICAgIGZyaWVuZCBjbGFzcyBTb2Nr ZXRTdHJlYW1IYW5kbGVQcml2YXRlOwogICAgIH07CiAKIH0gIC8vIG5hbWVzcGFjZSBXZWJDb3Jl CkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlUXQu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRTdHJl YW1IYW5kbGVRdC5jcHAJKHJldmlzaW9uIDUzODUxKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3F0L1NvY2tldFN0cmVhbUhhbmRsZVF0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMSw0ICsx LDUgQEAKIC8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgTm9raWEgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgogICogQ29weXJpZ2h0IChDKSAyMDA5IEdvb2dsZSBJbmMuICBBbGwgcmlnaHRzIHJl c2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtMzUsMzQgKzM2LDEzOSBAQAogI2luY2x1ZGUg IkxvZ2dpbmcuaCIKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgogI2luY2x1ZGUgIlNvY2tl dFN0cmVhbUhhbmRsZUNsaWVudC5oIgorI2luY2x1ZGUgIlNvY2tldFN0cmVhbUhhbmRsZVByaXZh dGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRl OjpTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlKFNvY2tldFN0cmVhbUhhbmRsZSogc3RyZWFtSGFu ZGxlLCBjb25zdCBLVVJMJiB1cmwpIDogUU9iamVjdCgpCit7CisgICAgbV9zdHJlYW1IYW5kbGUg PSBzdHJlYW1IYW5kbGU7CisgICAgbV9zb2NrZXQgPSAwOworICAgIGJvb2wgaXNTZWN1cmUgPSB1 cmwucHJvdG9jb2xJcygid3NzIik7CisgICAgaWYgKGlzU2VjdXJlKQorICAgICAgICBtX3NvY2tl dCA9IG5ldyBRU3NsU29ja2V0KHRoaXMpOworICAgIGVsc2UKKyAgICAgICAgbV9zb2NrZXQgPSBu ZXcgUVRjcFNvY2tldCh0aGlzKTsKKyAgICBjb25uZWN0KG1fc29ja2V0LCBTSUdOQUwoY29ubmVj dGVkKCkpLCB0aGlzLCBTTE9UKHNvY2tldENvbm5lY3RlZCgpKSk7CisgICAgY29ubmVjdChtX3Nv Y2tldCwgU0lHTkFMKHJlYWR5UmVhZCgpKSwgdGhpcywgU0xPVChzb2NrZXRSZWFkeVJlYWQoKSkp OworICAgIGNvbm5lY3QobV9zb2NrZXQsIFNJR05BTChkaXNjb25uZWN0ZWQoKSksIHRoaXMsIFNM T1Qoc29ja2V0Q2xvc2VkKCkpKTsKKyAgICBjb25uZWN0KG1fc29ja2V0LCBTSUdOQUwoZXJyb3Io UUFic3RyYWN0U29ja2V0OjpTb2NrZXRFcnJvcikpLCB0aGlzLCBTTE9UKHNvY2tldEVycm9yKFFB YnN0cmFjdFNvY2tldDo6U29ja2V0RXJyb3IpKSk7CisgICAgaWYgKGlzU2VjdXJlKQorICAgICAg ICBjb25uZWN0KG1fc29ja2V0LCBTSUdOQUwoc3NsRXJyb3JzKGNvbnN0IFFMaXN0PFFTc2xFcnJv cj4mKSksIHRoaXMsIFNMT1Qoc29ja2V0U3NsRXJyb3JzKGNvbnN0IFFMaXN0PFFTc2xFcnJvcj4m KSkpOworCisgICAgdW5zaWduZWQgaW50IHBvcnQgPSB1cmwuaGFzUG9ydCgpID8gdXJsLnBvcnQo KSA6IChpc1NlY3VyZSA/IDQ0MyA6IDgwKTsKKworICAgIFFTdHJpbmcgaG9zdCA9IHVybC5ob3N0 KCk7CisgICAgaWYgKGlzU2VjdXJlKQorICAgICAgICBzdGF0aWNfY2FzdDxRU3NsU29ja2V0Kj4o bV9zb2NrZXQpLT5jb25uZWN0VG9Ib3N0RW5jcnlwdGVkKGhvc3QsIHBvcnQpOworICAgIGVsc2UK KyAgICAgICAgbV9zb2NrZXQtPmNvbm5lY3RUb0hvc3QoaG9zdCwgcG9ydCk7Cit9CisKK1NvY2tl dFN0cmVhbUhhbmRsZVByaXZhdGU6On5Tb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlKCkKK3sKKyAg ICBRX0FTU0VSVCghKG1fc29ja2V0ICYmIG1fc29ja2V0LT5zdGF0ZSgpID09IFFBYnN0cmFjdFNv Y2tldDo6Q29ubmVjdGVkU3RhdGUpKTsKK30KKwordm9pZCBTb2NrZXRTdHJlYW1IYW5kbGVQcml2 YXRlOjpzb2NrZXRDb25uZWN0ZWQoKQoreworICAgIGlmIChtX3N0cmVhbUhhbmRsZSAmJiBtX3N0 cmVhbUhhbmRsZS0+Y2xpZW50KCkpIHsKKyAgICAgICAgbV9zdHJlYW1IYW5kbGUtPm1fc3RhdGUg PSBTb2NrZXRTdHJlYW1IYW5kbGVCYXNlOjpPcGVuOworICAgICAgICBtX3N0cmVhbUhhbmRsZS0+ Y2xpZW50KCktPmRpZE9wZW4obV9zdHJlYW1IYW5kbGUpOworICAgIH0KK30KKwordm9pZCBTb2Nr ZXRTdHJlYW1IYW5kbGVQcml2YXRlOjpzb2NrZXRSZWFkeVJlYWQoKQoreworICAgIGlmIChtX3N0 cmVhbUhhbmRsZSAmJiBtX3N0cmVhbUhhbmRsZS0+Y2xpZW50KCkpIHsKKyAgICAgICAgUUJ5dGVB cnJheSBkYXRhID0gbV9zb2NrZXQtPnJlYWQobV9zb2NrZXQtPmJ5dGVzQXZhaWxhYmxlKCkpOwor ICAgICAgICBtX3N0cmVhbUhhbmRsZS0+Y2xpZW50KCktPmRpZFJlY2VpdmVEYXRhKG1fc3RyZWFt SGFuZGxlLCBkYXRhLmNvbnN0RGF0YSgpLCBkYXRhLnNpemUoKSk7CisgICAgfQorfQorCitpbnQg U29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6c2VuZChjb25zdCBjaGFyKiBkYXRhLCBpbnQgbGVu KQoreworICAgIGlmIChtX3NvY2tldC0+c3RhdGUoKSAhPSBRQWJzdHJhY3RTb2NrZXQ6OkNvbm5l Y3RlZFN0YXRlKQorICAgICAgICByZXR1cm4gMDsKKyAgICBxdWludDY0IHNlbnRTaXplID0gbV9z b2NrZXQtPndyaXRlKGRhdGEsIGxlbik7CisgICAgUU1ldGFPYmplY3Q6Omludm9rZU1ldGhvZCh0 aGlzLCAic29ja2V0U2VudERhdGEiLCBRdDo6UXVldWVkQ29ubmVjdGlvbik7CisgICAgcmV0dXJu IHNlbnRTaXplOworfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OmNsb3NlKCkK K3sKKyAgICBpZiAobV9zb2NrZXQgJiYgbV9zb2NrZXQtPnN0YXRlKCkgPT0gUUFic3RyYWN0U29j a2V0OjpDb25uZWN0ZWRTdGF0ZSkKKyAgICAgICAgbV9zb2NrZXQtPmNsb3NlKCk7Cit9CisKK3Zv aWQgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZTo6c29ja2V0U2VudGRhdGEoKQoreworICAgIGlm IChtX3N0cmVhbUhhbmRsZSkKKyAgICAgICAgbV9zdHJlYW1IYW5kbGUtPnNlbmRQZW5kaW5nRGF0 YSgpOworfQorCit2b2lkIFNvY2tldFN0cmVhbUhhbmRsZVByaXZhdGU6OnNvY2tldENsb3NlZCgp Cit7CisgICAgUU1ldGFPYmplY3Q6Omludm9rZU1ldGhvZCh0aGlzLCAic29ja2V0Q2xvc2VkQ2Fs bGJhY2siLCBRdDo6UXVldWVkQ29ubmVjdGlvbik7Cit9CisKK3ZvaWQgU29ja2V0U3RyZWFtSGFu ZGxlUHJpdmF0ZTo6c29ja2V0RXJyb3IoUUFic3RyYWN0U29ja2V0OjpTb2NrZXRFcnJvciBlcnJv cikKK3sKKyAgICBRTWV0YU9iamVjdDo6aW52b2tlTWV0aG9kKHRoaXMsICJzb2NrZXRFcnJvckNh bGxiYWNrIiwgUXQ6OlF1ZXVlZENvbm5lY3Rpb24sIFFfQVJHKGludCwgZXJyb3IpKTsKK30KKwor dm9pZCBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjpzb2NrZXRDbG9zZWRDYWxsYmFjaygpCit7 CisgICAgaWYgKG1fc3RyZWFtSGFuZGxlICYmIG1fc3RyZWFtSGFuZGxlLT5jbGllbnQoKSkgewor ICAgICAgICBTb2NrZXRTdHJlYW1IYW5kbGUqIHN0cmVhbUhhbmRsZSA9IG1fc3RyZWFtSGFuZGxl OworICAgICAgICBtX3N0cmVhbUhhbmRsZSA9IDA7CisgICAgICAgIC8vIFRoaXMgZm9sbG93aW5n IGNhbGwgZGVsZXRlcyBfdGhpc18uIE5vdGhpbmcgc2hvdWxkIGJlIGFmdGVyIGl0LgorICAgICAg ICBzdHJlYW1IYW5kbGUtPmNsaWVudCgpLT5kaWRDbG9zZShzdHJlYW1IYW5kbGUpOworICAgIH0K K30KKwordm9pZCBTb2NrZXRTdHJlYW1IYW5kbGVQcml2YXRlOjpzb2NrZXRFcnJvckNhbGxiYWNr KGludCBlcnJvcikKK3sKKyAgICAvLyBGSVhNRSAtIGluIHRoZSBmdXR1cmUsIHdlIG1pZ2h0IG5v dCB3YW50IHRvIHRyZWF0IGFsbCBlcnJvcnMgYXMgZmF0YWwuCisgICAgaWYgKG1fc3RyZWFtSGFu ZGxlICYmIG1fc3RyZWFtSGFuZGxlLT5jbGllbnQoKSkgeworICAgICAgICBTb2NrZXRTdHJlYW1I YW5kbGUqIHN0cmVhbUhhbmRsZSA9IG1fc3RyZWFtSGFuZGxlOworICAgICAgICBtX3N0cmVhbUhh bmRsZSA9IDA7CisgICAgICAgIC8vIFRoaXMgZm9sbG93aW5nIGNhbGwgZGVsZXRlcyBfdGhpc18u IE5vdGhpbmcgc2hvdWxkIGJlIGFmdGVyIGl0LgorICAgICAgICBzdHJlYW1IYW5kbGUtPmNsaWVu dCgpLT5kaWRDbG9zZShzdHJlYW1IYW5kbGUpOworICAgIH0KK30KKwordm9pZCBTb2NrZXRTdHJl YW1IYW5kbGVQcml2YXRlOjpzb2NrZXRTc2xFcnJvcnMoY29uc3QgUUxpc3Q8UVNzbEVycm9yPiYp Cit7CisgICAgLy8gRklYTUU6IGJhc2VkIG9uIGh0dHA6Ly90b29scy5pZXRmLm9yZy9odG1sL2Ry YWZ0LWhpeGllLXRoZXdlYnNvY2tldHByb3RvY29sLTY4I3BhZ2UtMTUKKyAgICAvLyB3ZSBzaG91 bGQgYWJvcnQgb24gY2VydGlmaWNhdGUgZXJyb3JzLgorICAgIC8vIFdlIGRvbid0IGFib3J0IHdo aWxlIHRoaXMgaXMgc3RpbGwgd29yayBpbiBwcm9ncmVzcy4KKyAgICBzdGF0aWNfY2FzdDxRU3Ns U29ja2V0Kj4obV9zb2NrZXQpLT5pZ25vcmVTc2xFcnJvcnMoKTsKK30KIFNvY2tldFN0cmVhbUhh bmRsZTo6U29ja2V0U3RyZWFtSGFuZGxlKGNvbnN0IEtVUkwmIHVybCwgU29ja2V0U3RyZWFtSGFu ZGxlQ2xpZW50KiBjbGllbnQpCiAgICAgOiBTb2NrZXRTdHJlYW1IYW5kbGVCYXNlKHVybCwgY2xp ZW50KQogewogICAgIExPRyhOZXR3b3JrLCAiU29ja2V0U3RyZWFtSGFuZGxlICVwIG5ldyBjbGll bnQgJXAiLCB0aGlzLCBtX2NsaWVudCk7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBtX3Ag PSBuZXcgU29ja2V0U3RyZWFtSGFuZGxlUHJpdmF0ZSh0aGlzLCB1cmwpOwogfQogCiBTb2NrZXRT dHJlYW1IYW5kbGU6On5Tb2NrZXRTdHJlYW1IYW5kbGUoKQogewogICAgIExPRyhOZXR3b3JrLCAi U29ja2V0U3RyZWFtSGFuZGxlICVwIGRlbGV0ZSIsIHRoaXMpOwogICAgIHNldENsaWVudCgwKTsK LSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIGRlbGV0ZSBtX3A7CiB9CiAKLWludCBTb2NrZXRT dHJlYW1IYW5kbGU6OnBsYXRmb3JtU2VuZChjb25zdCBjaGFyKiwgaW50KQoraW50IFNvY2tldFN0 cmVhbUhhbmRsZTo6cGxhdGZvcm1TZW5kKGNvbnN0IGNoYXIqIGRhdGEsIGludCBsZW4pCiB7CiAg ICAgTE9HKE5ldHdvcmssICJTb2NrZXRTdHJlYW1IYW5kbGUgJXAgcGxhdGZvcm1TZW5kIiwgdGhp cyk7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLSAgICByZXR1cm4gMDsKKyAgICByZXR1cm4gbV9w LT5zZW5kKGRhdGEsIGxlbik7CiB9CiAKIHZvaWQgU29ja2V0U3RyZWFtSGFuZGxlOjpwbGF0Zm9y bUNsb3NlKCkKIHsKICAgICBMT0coTmV0d29yaywgIlNvY2tldFN0cmVhbUhhbmRsZSAlcCBwbGF0 Zm9ybUNsb3NlIiwgdGhpcyk7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBtX3AtPmNsb3Nl KCk7CiB9CiAKIHZvaWQgU29ja2V0U3RyZWFtSGFuZGxlOjpkaWRSZWNlaXZlQXV0aGVudGljYXRp b25DaGFsbGVuZ2UoY29uc3QgQXV0aGVudGljYXRpb25DaGFsbGVuZ2UmKQpAQCAtODYsMyArMTky LDUgQEAKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjaW5jbHVkZSAibW9jX1NvY2tl dFN0cmVhbUhhbmRsZVByaXZhdGUuY3BwIgpJbmRleDogTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQv U2tpcHBlZAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9Ta2lwcGVkCShy ZXZpc2lvbiA1Mzg1MSkKKysrIExheW91dFRlc3RzL3BsYXRmb3JtL3F0L1NraXBwZWQJKHdvcmtp bmcgY29weSkKQEAgLTQ5NjQsOSArNDk2NCw2IEBACiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0 L3dvcmtlcnMvbWV0aG9kcy5odG1sCiBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L3dvcmtlcnMv c2hhcmVkLXdvcmtlci1tZXRob2RzLWFzeW5jLmh0bWwKIAotIyBNaXNzaW5nIFNvY2tldFN0cmVh bUhhbmRsZSBpbXBsZW1lbnRhdGlvbgotd2Vic29ja2V0L3Rlc3RzCi0KICMgTmVlZCByZWJhc2Vs aW5lOiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjY4MzAKIGZhc3Qv bXVsdGljb2wvc2luZ2xlLWxpbmUuaHRtbAogCkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA1Mzg3NikKKysr IExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE0IEBACisy MDEwLTAxLTI2ICBZYWVsIEFoYXJvbiAgPHlhZWwuYWhhcm9uQG5va2lhLmNvbT4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbUXRdIEVuYWJsZSB3ZWJz b2NrZXRzIHN1cHBvcnQgaW4gUXRXZWJLaXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTM0MTgwCisKKyAgICAgICAgUmVtb3ZlIHdlYnNvY2tldHMgdGVz dHMgZnJvbSBza2lwbGlzdC4KKworICAgICAgICAqIHBsYXRmb3JtL3F0L1NraXBwZWQ6CisKIDIw MTAtMDEtMjYgIEZ1bWl0b3NoaSBVa2FpICA8dWthaUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgQWxleGV5IFByb3NrdXJ5YWtvdi4K