166029 2016-12-19 11:47:27 -0800 [SOUP] SoupCookieJar is never released (resulting in sqlite temp files lying around) 2017-07-10 06:21:46 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugzilla.gnome.org/show_bug.cgi?id=776287 https://bugzilla.gnome.org/show_bug.cgi?id=774011 https://bugs.webkit.org/show_bug.cgi?id=168126 P2 Normal --- 1 desrt mcatanzaro berto bugs-noreply buildbot cgarcia danw gustavo jidanni mcatanzaro olivier.blin oldest_to_newest 1261172 0 desrt 2016-12-19 11:47:27 -0800 When running epiphany, the SoupCookieJar opens the cookies.sqlite file, creating two temporary files for journalling. Normally, on sqlite cleanup, these files are committed to the main file and deleted. libsoup does this properly when the SoupCookieJar is freed. Unfortunately, that never happens because of the global singleton WebKitWebContext (or in the case of ephy, its own EphyShell). See https://bugzilla.gnome.org/show_bug.cgi?id=776287 for the original report. 1266243 1 mcatanzaro 2017-01-12 12:27:50 -0800 (In reply to comment #0) > When running epiphany, the SoupCookieJar opens the cookies.sqlite file, > creating two temporary files for journalling. Normally, on sqlite cleanup, > these files are committed to the main file and deleted. > > libsoup does this properly when the SoupCookieJar is freed. > > Unfortunately, that never happens because of the global singleton > WebKitWebContext (or in the case of ephy, its own EphyShell). Something else must be wrong, because Ephy does not use the default global web context, it uses its own, and I was wrong: Ephy DOES delete its own web context. 1266961 2 mcatanzaro 2017-01-15 05:39:29 -0800 I just found: https://bugzilla.gnome.org/show_bug.cgi?id=774011 which I reported not so long ago, but forgot about. There I discovered that we have the following code in WebKit in SoupCookieJar.cpp: void deleteAllCookies(const NetworkStorageSession& session) { SoupCookieJar* cookieJar = cookieJarForSession(session); GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar)); for (GSList* item = cookies.get(); item; item = g_slist_next(item)) { SoupCookie* cookie = static_cast<SoupCookie*>(item->data); soup_cookie_jar_delete_cookie(cookieJar, cookie); soup_cookie_free(cookie); } } Note that we need to free the cookie jar there too, else the delete all cookies feature will not remove the .sqlite-wal and .sqlite-shm files. 1266993 3 mcatanzaro 2017-01-15 11:16:30 -0800 The problem (after the recent cookie storage refactor in trunk) is that NetworkStorageSession::defaultSession is never destroyed: static std::unique_ptr<NetworkStorageSession>& defaultSession() { ASSERT(isMainThread()); static NeverDestroyed<std::unique_ptr<NetworkStorageSession>> session; return session; } NetworkStorageSession& NetworkStorageSession::defaultStorageSession() { if (!defaultSession()) defaultSession() = std::make_unique<NetworkStorageSession>(SessionID::defaultSessionID(), nullptr); return *defaultSession(); } This is a problem we have again, and again, and again (e.g. bug #163504 and bug #164303) and just don't know how to solve. It's a best-practices clash between C++ exit time destructors, C++ smart pointers, and GObject. In C++ it is an antipattern to ever destroy a static object, since exit-time destructors are a perennial source of crashes, so we use NeverDestroyed to ensure we leak these objects and to indicate that it is intentional. But, repeatedly, we find that the correctness of our code depends on destroying some GObject that we store in a GRefPtr inside a NeverDestroyed object, ensuring that the GObject never gets unreffed when we really need it to. It's not even really a problem specific to GObject. If a big object is declared with NeverDestroyed, that means the destructors of all its member variables, and the members' members, and so on, never run. Nobody is likely to check a big tree of data members to make sure the destructors are not doing anything that really needs to happen at exit time. The only clear options are to (a) get rid of the use of NeverDestroyed and hope for the best, or (b) set up an exit handler to manually unref the GObject. In general, both are poor choices. In general, GObjects assume that they will always be freed and may rightfully do important stuff in dispose and finalize, so we really shouldn't be leaking them. 1275784 4 mcatanzaro 2017-02-11 06:32:26 -0800 Although bug #168126 is related and could certainly exacerbate this issue, note that fixing it will do nothing to solve this. We need to actually destroy the default NetworkStorageSession somewhere. 1324143 5 jidanni 2017-06-29 16:42:55 -0700 I had the dream that I could import a lot of cookies into epiphany. I would examine the cookies.sqlite structures, and figure out what sqlite commands I needed to add them in. However, no matter how I close epiphany, the cookies are always have newer shm and wal files. 1324148 6 jidanni 2017-06-29 16:48:33 -0700 cookies.sqlite always has newer shm and wal files. OK today I will research: Find out if there is some tool I can use, that after closing epiphany, I can then give it the three cookies.* files, and it will delete the other two, and just leave an updated cookies.sqlite. 1324192 7 jidanni 2017-06-29 17:41:23 -0700 OK, I found that $ sqlite3 cookies.sqlite .dump apparently treats all three files as a whole, GOOD. Also I found that sometimes ~/.config/epiphany/cookies.sqlite is the only file of the three there, the shm and wal are gone. But apparently this state is not achieved by any special way of closing epiphany, but probably epiphany reaching some checkpointing level... All I know is after every few {open browser, browse some stuff, close browser} sessions, a single cookies.sqlite file remained. Usually not, but sometimes I was lucky. 1324267 8 mcatanzaro 2017-06-29 20:43:43 -0700 Dan, this bug is to delete those temp files on exit. It's not an appropriate place to discuss anything else. 1324272 9 mcatanzaro 2017-06-29 20:46:47 -0700 By the way, Carlos, I have no clue what to do here. We need to really rethink how we handle static objects. See comment #3. 1324429 10 jidanni 2017-06-30 08:57:31 -0700 (In reply to Michael Catanzaro from comment #8) Yes. I'm saying that this bug Blocks: [many (other peoples') projects] that one might have never imagined. 1324865 11 jidanni 2017-07-01 19:14:43 -0700 A workaround I discovered is 1. Close your browser. 2. $ sqlite3 cookies.db .dump > /dev/null http://sqlite.1065341.n5.nabble.com/Doc-bug-wal-html-should-mention-proper-way-to-remove-wal-and-shm-files-td96459.html This will clean up the shm and wal (until the next time you open your browser.) 1324877 12 mcatanzaro 2017-07-01 21:15:23 -0700 This implementation of NetworkStorageSession::defaultStorageSession fixes the bug: NetworkStorageSession& NetworkStorageSession::defaultStorageSession() { if (!defaultSession()) { defaultSession() = std::make_unique<NetworkStorageSession>(SessionID::defaultSessionID(), nullptr); std::atexit([] { // Ensure cookie storage is closed cleanly even though the default session is NeverDestroyed. g_object_unref(defaultSession()->m_cookieStorage.get()); g_object_unref(defaultSession()->m_cookieStorage.get()); g_object_unref(defaultSession()->m_cookieStorage.leakRef()); }); } return *defaultSession(); } It requires one unref for the SoupCookieJar owned by the default NeverDestroyed NetworkStorageSession, another unref because it's also owned by the SoupSession owned by the default NeverDestroyed SoupNetworkSession, and a third unref because it's also owned by... I dunno, something else, haven't figured that out. The first thing I would do to simplify this is have the NetworkStorageSession access its SoupCookieJar via the SoupNetworkSession instead of keeping its own reference. Unfortunately we know we for sure cannot destroy the default SoupSession, because that has caused nasty exit handler crashes in the past. So if we want to destroy the SoupCookieJar, then we have no choice but to unref it from somewhere it is not owned, to balance the ref owned by the default SoupSession that we know will never be destroyed. Alternatively, we could try to sqlite3_close() the database manually. This would require exposing the private SQLiteDatabase object owned by WebKitSoupCookieJarSqlite (not desirable) or else adding some way to tell WebKitSoupCookieJarSqlite to close its database even though it's not being destroyed. This seems like the best approach. 1324929 13 314418 mcatanzaro 2017-07-02 08:55:52 -0700 Created attachment 314418 Patch 1326969 14 cgarcia 2017-07-10 05:26:10 -0700 (In reply to Michael Catanzaro from comment #12) > This implementation of NetworkStorageSession::defaultStorageSession fixes > the bug: > > NetworkStorageSession& NetworkStorageSession::defaultStorageSession() > { > if (!defaultSession()) { > defaultSession() = > std::make_unique<NetworkStorageSession>(SessionID::defaultSessionID(), > nullptr); > std::atexit([] { > // Ensure cookie storage is closed cleanly even though the > default session is NeverDestroyed. > g_object_unref(defaultSession()->m_cookieStorage.get()); > g_object_unref(defaultSession()->m_cookieStorage.get()); > g_object_unref(defaultSession()->m_cookieStorage.leakRef()); > }); > } > return *defaultSession(); > } > > It requires one unref for the SoupCookieJar owned by the default > NeverDestroyed NetworkStorageSession, another unref because it's also owned > by the SoupSession owned by the default NeverDestroyed SoupNetworkSession, > and a third unref because it's also owned by... I dunno, something else, > haven't figured that out. SoupSession actually takes two references, one in the list of features and another one in the default implementation of SoupSessionFeature::attach. Both are removed in soup_session_remove_feature, called in dispose. So, I think we could try again to actually clear the soup session, that will properly lcear the cookie jar too. > The first thing I would do to simplify this is have the > NetworkStorageSession access its SoupCookieJar via the SoupNetworkSession > instead of keeping its own reference. > > Unfortunately we know we for sure cannot destroy the default SoupSession, > because that has caused nasty exit handler crashes in the past. So if we > want to destroy the SoupCookieJar, then we have no choice but to unref it > from somewhere it is not owned, to balance the ref owned by the default > SoupSession that we know will never be destroyed. Well, the crashes happened when the soup session was destroyed in exit handlers. We never figured out why, but it might have to do with the fact that we don't really know in which order global static variables are removed. Also note that the crash was not in WebKit, not in libsoup, but in gbnutls, so maybe newer versions of gnutls don't have that problem. In any case, I think we can try to clear the session from ChildProcessMainBase::platformFinalize(), which is called right after the run loop quits, before any exit handler, so I think it should be safe. The only problem is in case the network process finishes with an exit() call instead of quiting the main loop. If we see that's happening (it doesn't seem to happen here right now) we can then try a hack like what you propose below. > Alternatively, we could try to sqlite3_close() the database manually. This > would require exposing the private SQLiteDatabase object owned by > WebKitSoupCookieJarSqlite (not desirable) or else adding some way to tell > WebKitSoupCookieJarSqlite to close its database even though it's not being > destroyed. This seems like the best approach. I prefer to avoid this, unless there's no other cleaner option. 1326971 15 314418 cgarcia 2017-07-10 05:27:41 -0700 Comment on attachment 314418 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=314418&action=review > Source/WebKit2/ChangeLog:37 > + Also note that we might be able to get rid of WebKitSoupCookieJarSqlite, since it seems to > + use exactly the same database format as the upstream SoupCookieJarDb class. I suspect > + WebKitSoupCookieJarSqlite exists only because SoupCookieJarDb is relatively new, and the > + older SoupCookieJarSqlite class existed only in libsoup-gnome rather than libsoup proper. > + The advantage of continuing to use our WebKitSoupCookieJarSqlite class, besides that we > + already know it works, is that it utilizes the same SQLiteDatabase class that is used > + elsewhere in WebKit. SoupCookieJarDb is part of libsoup-gnome and we depend on libsoup, not libsoup-gnome. That's why we added WebKitSoupCookieJarSqlite long time ago. 1326973 16 314975 cgarcia 2017-07-10 05:36:16 -0700 Created attachment 314975 Alternative patch Could you try this alternative patch? 1326976 17 314975 mcatanzaro 2017-07-10 06:07:31 -0700 Comment on attachment 314975 Alternative patch OK, but please don't backport this since it's not unlikely it will introduce crashes. 1326980 18 mcatanzaro 2017-07-10 06:09:21 -0700 (In reply to Carlos Garcia Campos from comment #15) > SoupCookieJarDb is part of libsoup-gnome and we depend on libsoup, not > libsoup-gnome. That's why we added WebKitSoupCookieJarSqlite long time ago. SoupCookieJarSqlite is part of libsoup-gnome. SoupCookieJarDb is in libsoup, new in 2.42, which is now our min required version. The implementation was copied from SoupCookieJarSqlite to SoupCookieJarDb. Maybe we can start using SoupCookieJarDb. 1326981 19 cgarcia 2017-07-10 06:17:30 -0700 (In reply to Michael Catanzaro from comment #18) > (In reply to Carlos Garcia Campos from comment #15) > > SoupCookieJarDb is part of libsoup-gnome and we depend on libsoup, not > > libsoup-gnome. That's why we added WebKitSoupCookieJarSqlite long time ago. > > SoupCookieJarSqlite is part of libsoup-gnome. SoupCookieJarDb is in libsoup, > new in 2.42, which is now our min required version. The implementation was > copied from SoupCookieJarSqlite to SoupCookieJarDb. Maybe we can start using > SoupCookieJarDb. Ah, I didn't know that, then there's no a reason to use our own copy anymore. 1326983 20 cgarcia 2017-07-10 06:21:46 -0700 Committed r219290: <http://trac.webkit.org/changeset/219290> 314418 2017-07-02 08:55:52 -0700 2017-07-10 06:07:37 -0700 Patch bug-166029-20170702105551.patch text/plain 6455 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjE5MDA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggYmQ5ZTZiNTFjZjM1Yjk4 MjBlNWVhNWQ1N2M1MTBmNTVhNmFkYzFkOS4uYmViMGJlNDM4YTA5NTJjNzc0MGE4MGU0YWRkMmNh OThmM2Y0ODI3NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ3IEBACisyMDE3LTA3LTAyICBNaWNo YWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AaWdhbGlhLmNvbT4KKworICAgICAgICBbU09VUF0g U291cENvb2tpZUphciBpcyBuZXZlciByZWxlYXNlZCAocmVzdWx0aW5nIGluIHNxbGl0ZSB0ZW1w IGZpbGVzIGx5aW5nIGFyb3VuZCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTE2NjAyOQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIFdlIGFyZSBjdXJyZW50bHkgbGVha2luZyBTUUxpdGUgcnVudGltZSBqb3Vy bmFsaW5nIGZpbGVzIGNvb2tpZXMuc3FsaXRlLXNobSBhbmQKKyAgICAgICAgY29va2llcy5zcWxp dGUtd2FsIGFmdGVyIHByb2Nlc3MgdGVybWluYXRpb24uIFRoZXNlIGZpbGVzIGFyZSBzdXBwb3Nl ZCB0byBiZSBkZWxldGVkIHdoZW4KKyAgICAgICAgdGhlIGRhdGFiYXNlIGlzIGNsb3NlZCwgYnV0 IHRoZSBkYXRhYmFzZSBpcyBuZXZlciBjbG9zZWQgYmVjYXVzZSBvdXIgU291cENvb2tpZUphciBp cyBuZXZlcgorICAgICAgICBmcmVlZC4gT3VyIGN1c3RvbSBTb3VwQ29va2llSmFyIGltcGxlbWVu dGF0aW9uIFdlYktpdFNvdXBDb29raWVKYXJTcWxpdGUgd2lsbCBkZXN0cm95IGl0cworICAgICAg ICBTUUxpdGVEYXRhYmFzZSBvYmplY3Qgd2hlbiBpdCBpcyBmaW5hbGl6ZWQsIGFuZCB0aGUgZGVz dHJ1Y3RvciBvZiBTUUxpdGVEYXRhYmFzZSBpcyB3aGF0IGlzCisgICAgICAgIHN1cHBvc2VkIHRv IGhhbmRsZSBjbG9zaW5nIHRoZSBkYXRhYmFzZS4gVGhhdCBjYW4ndCBoYXBwZW4gaWYgdGhlIFdl YktpdFNvdXBDb29raWVKYXJTcWxpdGUKKyAgICAgICAgaXMgbmV2ZXIgZmluYWxpemVkLgorCisg ICAgICAgIFR1cm5zIG91dCB0aGUgU291cENvb2tpZUphciBpcyBvd25lZCBpbiB0aHJlZSBwbGFj ZXM6ICgxKSB0aGUgZGVmYXVsdCBOZXZlckRlc3Ryb3llZAorICAgICAgICBOZXR3b3JrU3RvcmFn ZVNlc3Npb24sICgyKSB0aGUgU291cFNlc3Npb24gb3duZWQgYnkgdGhlIGRlZmF1bHQgTmV2ZXJE ZXN0cm95ZWQKKyAgICAgICAgU291cE5ldHdvcmtTZXNzaW9uLCBhbmQgKDMpIHNvbWV3aGVyZSBl bHNlLiAoSSBkb24ndCBrbm93IHdoZXJlIHNvbWV3aGVyZSBlbHNlIGlzLCBiZWNhdXNlCisgICAg ICAgIGl0IHR1cm5zIG91dCBkZWJ1Z2dpbmcgR09iamVjdCBvd25lcnNoaXAgcHJvYmxlbXMgaXMg aGFyZC4pIEkgZG9uJ3Qga25vdyBpZiBpdCB3b3VsZCBiZQorICAgICAgICBwb3NzaWJsZSB0byBz dG9wIHVzaW5nIE5ldmVyRGVzdHJveWVkIGZvciB0aGUgZGVmYXVsdCBOZXR3b3JrU3RvcmFnZVNl c3Npb24sIGJ1dCBpdCBzZWVtcworICAgICAgICByaXNreS4gSXQgaXMgZGVmaW5pdGVseSBub3Qg cG9zc2libGUgdG8gc3RvcCB1c2luZyBOZXZlckRlc3Ryb3llZCBmb3IgdGhlIGRlZmF1bHQKKyAg ICAgICAgU291cE5ldHdvcmtTZXNzaW9uLCBiZWNhdXNlIHdlIGtub3cgdGhhdCBjYXVzZXMgZXhp dCBoYW5kbGVyIGNyYXNoZXMgaW4gcHJhY3RpY2UuIFNvIHdlIGFyZQorICAgICAgICBqdXN0IG5v dCBnb2luZyB0byBiZSBhYmxlIHRvIHJlbHkgb24gZGVzdHJveWluZyB0aGUgamFyIHRvIGNsb3Nl IHRoZSBkYXRhYmFzZSwgYmVjYXVzZSB0aGUKKyAgICAgICAgamFyIHdpbGwgbmV2ZXIgYmUgZGVz dHJveWVkLgorCisgICAgICAgIEFkZCBhIG5ldyBtZXRob2QgdG8gY2xvc2UgdGhlIGRhdGFiYXNl LCBhbmQgY2FsbCBpdCBtYW51YWxseSBmcm9tIGFuIGV4aXQgaGFuZGxlci4KKworICAgICAgICBO b3RlIHRoYXQgaXQgd291bGQgYmUgcG9zc2libGUgdG8gdXNlIHN0ZDo6Y2FsbF9vbmNlIGhlcmUs IGJ1dCB0aGlzIHVzYWdlIGRvZXMgbm90IHNlZW0gdG8KKyAgICAgICAgcmVxdWlyZSB0aHJlYWQg c2FmZXR5LCBzbyBJIG9wdGVkIG5vdCB0by4KKworICAgICAgICBBbHNvIG5vdGUgdGhhdCB3ZSBt aWdodCBiZSBhYmxlIHRvIGdldCByaWQgb2YgV2ViS2l0U291cENvb2tpZUphclNxbGl0ZSwgc2lu Y2UgaXQgc2VlbXMgdG8KKyAgICAgICAgdXNlIGV4YWN0bHkgdGhlIHNhbWUgZGF0YWJhc2UgZm9y bWF0IGFzIHRoZSB1cHN0cmVhbSBTb3VwQ29va2llSmFyRGIgY2xhc3MuIEkgc3VzcGVjdAorICAg ICAgICBXZWJLaXRTb3VwQ29va2llSmFyU3FsaXRlIGV4aXN0cyBvbmx5IGJlY2F1c2UgU291cENv b2tpZUphckRiIGlzIHJlbGF0aXZlbHkgbmV3LCBhbmQgdGhlCisgICAgICAgIG9sZGVyIFNvdXBD b29raWVKYXJTcWxpdGUgY2xhc3MgZXhpc3RlZCBvbmx5IGluIGxpYnNvdXAtZ25vbWUgcmF0aGVy IHRoYW4gbGlic291cCBwcm9wZXIuCisgICAgICAgIFRoZSBhZHZhbnRhZ2Ugb2YgY29udGludWlu ZyB0byB1c2Ugb3VyIFdlYktpdFNvdXBDb29raWVKYXJTcWxpdGUgY2xhc3MsIGJlc2lkZXMgdGhh dCB3ZQorICAgICAgICBhbHJlYWR5IGtub3cgaXQgd29ya3MsIGlzIHRoYXQgaXQgdXRpbGl6ZXMg dGhlIHNhbWUgU1FMaXRlRGF0YWJhc2UgY2xhc3MgdGhhdCBpcyB1c2VkCisgICAgICAgIGVsc2V3 aGVyZSBpbiBXZWJLaXQuCisKKyAgICAgICAgKiBXZWJQcm9jZXNzL0Nvb2tpZXMvc291cC9XZWJD b29raWVNYW5hZ2VyU291cC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYkNvb2tpZU1hbmFnZXI6 OnNldENvb2tpZVBlcnNpc3RlbnRTdG9yYWdlKToKKyAgICAgICAgKiBXZWJQcm9jZXNzL0Nvb2tp ZXMvc291cC9XZWJLaXRTb3VwQ29va2llSmFyU3FsaXRlLmNwcDoKKyAgICAgICAgKHdlYmtpdFNv dXBDb29raWVKYXJTcWxpdGVDbG9zZSk6CisgICAgICAgICogV2ViUHJvY2Vzcy9Db29raWVzL3Nv dXAvV2ViS2l0U291cENvb2tpZUphclNxbGl0ZS5oOgorCiAyMDE3LTA2LTMwICBDaHJpcyBEdW1l eiAgPGNkdW1lekBhcHBsZS5jb20+CiAKICAgICAgICAgUmVzb3VyY2VMb2FkT2JzZXJ2ZXIgZG9l cyBub3QgbmVlZCBhIFJlc291cmNlTG9hZFN0YXRpc3RpY3NTdG9yZQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9Db29raWVzL3NvdXAvV2ViQ29va2llTWFuYWdlclNvdXAu Y3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9Db29raWVzL3NvdXAvV2ViQ29va2llTWFu YWdlclNvdXAuY3BwCmluZGV4IDdkMDBkMjllYjVhZjU5YjVmNWE1NTdhMGE5ZDBlODRiNWVjNjA5 MTguLmQ5NzAwMzliNjllY2M0NGI5ODYyYzI0YTIyNDVhZTRhNWI5NDhmZWIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvQ29va2llcy9zb3VwL1dlYkNvb2tpZU1hbmFnZXJT b3VwLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0Nvb2tpZXMvc291cC9XZWJD b29raWVNYW5hZ2VyU291cC5jcHAKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlICJXZWJLaXRT b3VwQ29va2llSmFyU3FsaXRlLmgiCiAjaW5jbHVkZSA8V2ViQ29yZS9OZXR3b3JrU3RvcmFnZVNl c3Npb24uaD4KICNpbmNsdWRlIDxXZWJDb3JlL1NvdXBOZXR3b3JrU2Vzc2lvbi5oPgorI2luY2x1 ZGUgPGNzdGRsaWI+CiAjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CiAjaW5jbHVkZSA8d3RmL2ds aWIvR1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KQEAgLTgyLDYgKzgz LDIwIEBAIHZvaWQgV2ViQ29va2llTWFuYWdlcjo6c2V0Q29va2llUGVyc2lzdGVudFN0b3JhZ2Uo Y29uc3QgU3RyaW5nJiBzdG9yYWdlUGF0aCwgdWluCiAgICAgICAgIGJyZWFrOwogICAgIGNhc2Ug U291cENvb2tpZVBlcnNpc3RlbnRTdG9yYWdlU1FMaXRlOgogICAgICAgICBqYXIgPSBhZG9wdEdS ZWYod2Via2l0U291cENvb2tpZUphclNxbGl0ZU5ldyhzdG9yYWdlUGF0aCkpOworICAgICAgICBz dGF0aWMgYm9vbCBvbmNlID0gdHJ1ZTsKKyAgICAgICAgaWYgKG9uY2UpIHsKKyAgICAgICAgICAg IHN0ZDo6YXRleGl0KFtdIHsKKyAgICAgICAgICAgICAgICAvLyBFbnN1cmUgY29va2llIHN0b3Jh Z2UgaXMgY2xvc2VkIGNsZWFubHkgYXQgZXhpdC4gVGhpcyBpcyBkaWZmaWN1bHQgYmVjYXVzZSB0 aGUKKyAgICAgICAgICAgICAgICAvLyBTb3VwQ29va2llSmFyIGlzIG93bmVkIGJ5IGJvdGggdGhl IGRlZmF1bHQgTmV0d29ya1N0b3JhZ2VTZXNzaW9uLCB3aGljaCBpcworICAgICAgICAgICAgICAg IC8vIE5ldmVyRGVzdHJveWVkLCBhbmQgYnkgdGhlIFNvdXBTZXNzaW9uIG93bmVkIGJ5IHRoZSBk ZWZhdWx0IFNvdXBOZXR3b3JrU2Vzc2lvbiwKKyAgICAgICAgICAgICAgICAvLyB3aGljaCBpcyBh bHNvIE5ldmVyRGVzdHJveWVkIChkZXN0cm95aW5nIGEgU291cFNlc3Npb24gaW4gYW4gZXhpdCBo YW5kbGVyIGNhdXNlcworICAgICAgICAgICAgICAgIC8vIGNyYXNoZXMpLiBJdCBhbHNvIHNlZW1z IHRvIGJlIG93bmVkIHNvbWV3aGVyZSBlbHNlLiBTbyBjbG9zZSBpdCBtYW51YWxseS4KKyAgICAg ICAgICAgICAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBOZXR3b3JrU3RvcmFnZVNlc3Npb246OmRl ZmF1bHRTdG9yYWdlU2Vzc2lvbigpLmNvb2tpZVN0b3JhZ2UoKTsKKyAgICAgICAgICAgICAgICBp ZiAoV0VCS0lUX0lTX1NPVVBfQ09PS0lFX0pBUl9TUUxJVEUoamFyKSkKKyAgICAgICAgICAgICAg ICAgICAgd2Via2l0U291cENvb2tpZUphclNxbGl0ZUNsb3NlKFdFQktJVF9TT1VQX0NPT0tJRV9K QVJfU1FMSVRFKGphcikpOworICAgICAgICAgICAgfSk7CisgICAgICAgICAgICBvbmNlID0gZmFs c2U7CisgICAgICAgIH0KICAgICAgICAgYnJlYWs7CiAgICAgZGVmYXVsdDoKICAgICAgICAgQVNT RVJUX05PVF9SRUFDSEVEKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNz L0Nvb2tpZXMvc291cC9XZWJLaXRTb3VwQ29va2llSmFyU3FsaXRlLmNwcCBiL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvQ29va2llcy9zb3VwL1dlYktpdFNvdXBDb29raWVKYXJTcWxpdGUuY3Bw CmluZGV4IDM2OWZhYmZhZmE3NDJiNzYwYjc5NzExM2EyZTE3MWY4MzE2YjFiMGYuLjJiNTIwYjNk OTg5ODUzMzQ0NzdiZTlhMzY2ZjM5ZDk0MzFkMGJiMmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvQ29va2llcy9zb3VwL1dlYktpdFNvdXBDb29raWVKYXJTcWxpdGUuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvQ29va2llcy9zb3VwL1dlYktpdFNvdXBD b29raWVKYXJTcWxpdGUuY3BwCkBAIC0yMjIsMyArMjIyLDkgQEAgU291cENvb2tpZUphciogd2Vi a2l0U291cENvb2tpZUphclNxbGl0ZU5ldyhjb25zdCBTdHJpbmcmIGRhdGFiYXNlUGF0aCkKICAg ICB3ZWJraXRTb3VwQ29va2llSmFyU3FsaXRlTG9hZChzcWxpdGVKYXIpOwogICAgIHJldHVybiBT T1VQX0NPT0tJRV9KQVIoc3FsaXRlSmFyKTsKIH0KKwordm9pZCB3ZWJraXRTb3VwQ29va2llSmFy U3FsaXRlQ2xvc2UoV2ViS2l0U291cENvb2tpZUphclNxbGl0ZSogc3FsaXRlSmFyKQoreworICAg IEFTU0VSVChXRUJLSVRfSVNfU09VUF9DT09LSUVfSkFSX1NRTElURShzcWxpdGVKYXIpKTsKKyAg ICBzcWxpdGVKYXItPnByaXYtPmRhdGFiYXNlLmNsb3NlKCk7Cit9CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0Nvb2tpZXMvc291cC9XZWJLaXRTb3VwQ29va2llSmFyU3Fs aXRlLmggYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL0Nvb2tpZXMvc291cC9XZWJLaXRTb3Vw Q29va2llSmFyU3FsaXRlLmgKaW5kZXggMTRlZGVjOTk4YzM4YzcwYjY3ZTdmY2RmNjJjOGU3MDc3 OTc4NjY3OS4uNjJkNWFkOWI2YjZlNGYyNDNkMWY5ZjI2MzUyMjQzYmMyMGQ4NzQzYSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9Db29raWVzL3NvdXAvV2ViS2l0U291cENv b2tpZUphclNxbGl0ZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvQ29va2llcy9z b3VwL1dlYktpdFNvdXBDb29raWVKYXJTcWxpdGUuaApAQCAtNDgsNiArNDgsNyBAQCBzdHJ1Y3Qg X1dlYktpdFNvdXBDb29raWVKYXJTcWxpdGVDbGFzcyB7CiAKIEdUeXBlIHdlYmtpdF9zb3VwX2Nv b2tpZV9qYXJfc3FsaXRlX2dldF90eXBlKCk7CiBTb3VwQ29va2llSmFyKiB3ZWJraXRTb3VwQ29v a2llSmFyU3FsaXRlTmV3KGNvbnN0IFN0cmluZyYgZGF0YWJhc2VQYXRoKTsKK3ZvaWQgd2Via2l0 U291cENvb2tpZUphclNxbGl0ZUNsb3NlKFdlYktpdFNvdXBDb29raWVKYXJTcWxpdGUqKTsKIAog R19FTkRfREVDTFMKIAo= 314975 2017-07-10 05:36:16 -0700 2017-07-10 06:07:31 -0700 Alternative patch wk2-clear-cookies-db.diff text/plain 4182 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAwZjllZjM4NGQ3ZS4uZjNkYzkyMTc2NmMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs NSArMSwxOSBAQAogMjAxNy0wNy0xMCAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGln YWxpYS5jb20+CiAKKyAgICAgICAgW1NPVVBdIFNvdXBDb29raWVKYXIgaXMgbmV2ZXIgcmVsZWFz ZWQgKHJlc3VsdGluZyBpbiBzcWxpdGUgdGVtcCBmaWxlcyBseWluZyBhcm91bmQpCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjYwMjkKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgY2xlYXJTb3VwTmV0 d29ya1Nlc3Npb25BbmRDb29raWVTdG9yYWdlKCkgdG8gY2xlYXIgdGhlIFNvdXBOZXR3b3JrU2Vz c2lvbiBhbmQgY29va2llIHN0b3JhZ2Ugb2YgdGhlIG1haW4KKyAgICAgICAgbmV0d29yayBzZXNz aW9uLCBlbnN1cmluZyB0aGUgY29va2llcyBkYXRhYmFzZSBpcyBwcm9wZXJseSBjbG9zZWQuCisK KyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL05ldHdvcmtTdG9yYWdlU2Vzc2lvbi5oOgorICAg ICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9OZXR3b3JrU3RvcmFnZVNlc3Npb25Tb3VwLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6Ok5ldHdvcmtTdG9yYWdlU2Vzc2lvbjo6Y2xlYXJTb3VwTmV0 d29ya1Nlc3Npb25BbmRDb29raWVTdG9yYWdlKToKKworMjAxNy0wNy0xMCAgQ2FybG9zIEdhcmNp YSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKICAgICAgICAgTW92ZSBtYWtlLWpzLWZp bGUtYXJyYXlzLnB5IGZyb20gV2ViQ29yZSB0byBKYXZhU2NyaXB0Q29yZQogICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTc0MDI0CiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvTmV0d29ya1N0b3JhZ2VTZXNzaW9uLmgg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL05ldHdvcmtTdG9yYWdlU2Vzc2lvbi5o CmluZGV4IDI4NTVjYjc5ZDIxLi41OGIxNjZlMWE1MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9OZXR3b3JrU3RvcmFnZVNlc3Npb24uaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL05ldHdvcmtTdG9yYWdlU2Vzc2lvbi5oCkBAIC05Miw2 ICs5Miw3IEBAIHB1YmxpYzoKIAogICAgIFNvdXBOZXR3b3JrU2Vzc2lvbiogc291cE5ldHdvcmtT ZXNzaW9uKCkgY29uc3QgeyByZXR1cm4gbV9zZXNzaW9uLmdldCgpOyB9OwogICAgIFNvdXBOZXR3 b3JrU2Vzc2lvbiYgZ2V0T3JDcmVhdGVTb3VwTmV0d29ya1Nlc3Npb24oKSBjb25zdDsKKyAgICB2 b2lkIGNsZWFyU291cE5ldHdvcmtTZXNzaW9uQW5kQ29va2llU3RvcmFnZSgpOwogICAgIFNvdXBD b29raWVKYXIqIGNvb2tpZVN0b3JhZ2UoKSBjb25zdDsKICAgICB2b2lkIHNldENvb2tpZVN0b3Jh Z2UoU291cENvb2tpZUphciopOwogICAgIHZvaWQgc2V0Q29va2llT2JzZXJ2ZXJIYW5kbGVyKEZ1 bmN0aW9uPHZvaWQgKCk+JiYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9zb3VwL05ldHdvcmtTdG9yYWdlU2Vzc2lvblNvdXAuY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL05ldHdvcmtTdG9yYWdlU2Vzc2lvblNvdXAuY3BwCmlu ZGV4IDg4MDE4NGFjZmQ2Li4xNmEzZmM2YTEyOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL05ldHdvcmtTdG9yYWdlU2Vzc2lvblNvdXAuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9OZXR3b3JrU3RvcmFnZVNlc3Np b25Tb3VwLmNwcApAQCAtMTAzLDYgKzEwMywxNCBAQCBTb3VwTmV0d29ya1Nlc3Npb24mIE5ldHdv cmtTdG9yYWdlU2Vzc2lvbjo6Z2V0T3JDcmVhdGVTb3VwTmV0d29ya1Nlc3Npb24oKSBjb25zdAog ICAgIHJldHVybiAqbV9zZXNzaW9uOwogfQogCit2b2lkIE5ldHdvcmtTdG9yYWdlU2Vzc2lvbjo6 Y2xlYXJTb3VwTmV0d29ya1Nlc3Npb25BbmRDb29raWVTdG9yYWdlKCkKK3sKKyAgICBBU1NFUlQo ZGVmYXVsdFNlc3Npb24oKS5nZXQoKSA9PSB0aGlzKTsKKyAgICBtX3Nlc3Npb24gPSBudWxscHRy OworICAgIG1fY29va2llT2JzZXJ2ZXJIYW5kbGVyID0gbnVsbHB0cjsKKyAgICBtX2Nvb2tpZVN0 b3JhZ2UgPSBudWxscHRyOworfQorCiB2b2lkIE5ldHdvcmtTdG9yYWdlU2Vzc2lvbjo6Y29va2ll c0RpZENoYW5nZShOZXR3b3JrU3RvcmFnZVNlc3Npb24qIHNlc3Npb24pCiB7CiAgICAgaWYgKHNl c3Npb24tPm1fY29va2llT2JzZXJ2ZXJIYW5kbGVyKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IGE4ZjVhMWFjMzgw Li42OWQyMjdiNDNjYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDE3LTA3LTEwICBD YXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KKworICAgICAgICBbU09V UF0gU291cENvb2tpZUphciBpcyBuZXZlciByZWxlYXNlZCAocmVzdWx0aW5nIGluIHNxbGl0ZSB0 ZW1wIGZpbGVzIGx5aW5nIGFyb3VuZCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE2NjAyOQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIENsZWFyIHRoZSBTb3VwTmV0d29ya1Nlc3Npb24gYW5kIGNvb2tpZSBz dG9yYWdlIGFmdGVyIHRoZSBtYWluIGxvb3AgcXVpdHMuCisKKyAgICAgICAgKiBOZXR3b3JrUHJv Y2Vzcy9zb3VwL05ldHdvcmtQcm9jZXNzTWFpblNvdXAuY3BwOgorICAgICAgICAoV2ViS2l0OjpO ZXR3b3JrUHJvY2Vzc01haW5Vbml4KToKKwogMjAxNy0wNy0xMCAgV2Vuc29uIEhzaWVoICA8d2Vu c29uX2hzaWVoQGFwcGxlLmNvbT4KIAogICAgICAgICBbV0syXSBBY3Rpb24gc2hlZXRzIGZvciBs aW5rcyBmYWlsIHRvIHByZXNlbnQgaW4gV2ViS2l0MiBQREYgdmlldwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3Mvc291cC9OZXR3b3JrUHJvY2Vzc01haW5Tb3VwLmNw cCBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL3NvdXAvTmV0d29ya1Byb2Nlc3NNYWlu U291cC5jcHAKaW5kZXggZDUwODFhY2QzOTIuLmI1NTk4YjQ0MmE2IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9zb3VwL05ldHdvcmtQcm9jZXNzTWFpblNvdXAuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL3NvdXAvTmV0d29ya1Byb2Nlc3NN YWluU291cC5jcHAKQEAgLTI5LDEyICsyOSwyMSBAQAogCiAjaW5jbHVkZSAiQ2hpbGRQcm9jZXNz TWFpbi5oIgogI2luY2x1ZGUgIk5ldHdvcmtQcm9jZXNzTWFpblVuaXguaCIKKyNpbmNsdWRlIDxX ZWJDb3JlL05ldHdvcmtTdG9yYWdlU2Vzc2lvbi5oPgogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAor Y2xhc3MgTmV0d29ya1Byb2Nlc3NNYWluIGZpbmFsOiBwdWJsaWMgQ2hpbGRQcm9jZXNzTWFpbkJh c2UgeworcHVibGljOgorICAgIHZvaWQgcGxhdGZvcm1GaW5hbGl6ZSgpIG92ZXJyaWRlCisgICAg eworICAgICAgICBXZWJDb3JlOjpOZXR3b3JrU3RvcmFnZVNlc3Npb246OmRlZmF1bHRTdG9yYWdl U2Vzc2lvbigpLmNsZWFyU291cE5ldHdvcmtTZXNzaW9uQW5kQ29va2llU3RvcmFnZSgpOworICAg IH0KK307CisKIGludCBOZXR3b3JrUHJvY2Vzc01haW5Vbml4KGludCBhcmdjLCBjaGFyKiogYXJn dikKIHsKLSAgICByZXR1cm4gQ2hpbGRQcm9jZXNzTWFpbjxOZXR3b3JrUHJvY2VzcywgQ2hpbGRQ cm9jZXNzTWFpbkJhc2U+KGFyZ2MsIGFyZ3YpOworICAgIHJldHVybiBDaGlsZFByb2Nlc3NNYWlu PE5ldHdvcmtQcm9jZXNzLCBOZXR3b3JrUHJvY2Vzc01haW4+KGFyZ2MsIGFyZ3YpOwogfQogCiB9 IC8vIG5hbWVzcGFjZSBXZWJLaXQK