147790 2007-07-11 18:37:44 +0000 RFE: ConsoleKit support in KDM (patch provided) 2008-11-18 14:52:32 +0000 1 1 10 Unmaintained kdm general unspecified Compiled Sources Linux RESOLVED FIXED NOR wishlist --- 1 kevin.kofler kdm-bugs-null fabo filip.brcic jtate+kde laurent.rineau olfway rdieter sitter than 60 oldest_to_newest 535879 0 kevin.kofler 2007-07-11 18:37:44 +0000 Version: KDE 3.91.0 (using KDE Devel) Installed from: Compiled sources Compiler: gcc-c++-4.1.2-12 Fedora 7 OS: Linux Recent GNU/Linux distributions, such as Fedora 7, are using a tool called ConsoleKit to keep track of logged-in users. When built with ConsoleKit support, HAL grants or rejects device access privileges based on the presence or absence of a valid ConsoleKit cookie for a local session. Therefore, KDM needs to register itself with ConsoleKit for things like USB automounting to work in current distributions. See also: https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=228111 Fedora currently ships a patch I did against KDE 3.5.6/3.5.7 which adds this support. (Thanks also go to S.Çağlar Onur who fixed a segfault in my original patch.) I now ported the patch to 3.91.0 (I'll rediff against the trunk if it doesn't apply cleanly) and am seeking for upstream inclusion into 4.0. What the patch contains: * functions to communicate with ConsoleKit using the low-level D-Bus interface lifted from GDM (under the GPL, by William Jon McCann) and ported to work with KDM, * added CMake logic to detect the low-level D-Bus interface (KDE currently only checks for QtDBus) - note that the patch only needs dbus-devel to build, not ConsoleKit-devel or hal-devel, * integration with KDM code, conditionalized under #ifdef WITH_CONSOLE_KIT. What is currently missing is a way to turn this feature on or off with a CMake option, currently the #define WITH_CONSOLE_KIT is hardcoded in dm.h. The KDE 3 version of the patch is being used successfully in production in Fedora 7. The KDE 4 version isn't much different and has been verified to compile, but some testing won't hurt. 535880 1 21120 kevin.kofler 2007-07-11 18:39:43 +0000 Created attachment 21120 The current patch (KDE 4 version) And here's the patch I mentioned. I'm attaching only the KDE 4 version because KDE 3 is now in bugfix-only mode as I understand it. 536246 2 kevin.kofler 2007-07-14 20:14:09 +0000 Could we have some feedback on: * whether the feature is considered desirable for KDE in the first place and * the current implementation? Should I send this to a mailing list for discussion? kde-devel? kde-core-devel? Somewhere else? 536256 3 ossi 2007-07-14 22:30:16 +0000 the integration into the existing structure sucks. ;) anyway, the first question that comes to mind is: why not a PAM module? if you need some information that is not available in the currently provided context, we can try to work this out. 536257 4 kevin.kofler 2007-07-14 22:34:28 +0000 The ConsoleKit folks say a PAM module is the wrong approach for a graphical login manager. See for example this thread: http://lists.freedesktop.org/archives/hal/2007-February/007363.html In particular the post from David Zeuthen: [snip] > Plus, you really want your login manager to have native ConsolKit > support (rather than a PAM module) so you can feed in more hints.. this > PAM module is more of a stop-gap solution because the RH util-linux > maintainer wanted it that way for /bin/login. Sure, this PAM module > might be useful too for wdm, kdm but I think the position of the > ConsoleKit team (or me at least; can't speak for Jon) is that you want > to call into ConsoleKit from your app... heck, you already have to patch > e.g. wdm to set/unset these environment variables. 536258 5 ossi 2007-07-14 22:49:29 +0000 i'm sort of with the util-linux guy. it's right that some env vars need to be set (well, actually, nothing except xauthority is missing, afaict - the vt can be queried from the x server), but that might have wider use anyway. oh, right - it is said in that thread, too. the "PAM sucks too much" argumentation doesn't make sense - get in touch with the novell guys who are the (only?) maintainers and fix it. so far for stop-gap solutions ... 536259 6 kevin.kofler 2007-07-14 23:17:03 +0000 But what do we have to gain by setting more environment variables and writing a PAM module or patching the existing one to handle the extra variables over just calling ConsoleKit directly using D-Bus? The code to do the latter is already written, it's how GDM does it, it's how KDM in Fedora 7 does it, and I don't see what the extra indirection through a PAM module would bring us. 536260 7 ossi 2007-07-14 23:40:47 +0000 you don't really grok the concepts of abstraction and modularity, huh? ;) and argumentum ad populum does not work for me. 536811 8 kevin.kofler 2007-07-18 13:26:11 +0000 William Jon McCann has explained the rationale for the ConsoleKit design at GUADEC, here are his slides: http://people.freedesktop.org/~hughsient/temp/guadec-multiuser.pdf 536819 9 rdieter 2007-07-18 13:51:22 +0000 Regardless, a solution is needed, and it looks like more discussion is warranted... so taking this to (something like) kde-core-devel is probably a good idea at this point. 536820 10 ossi 2007-07-18 14:06:14 +0000 in this context, deep integration makes a lot of sense, indeed. your patch isn't anything like that, though. it's just a poor hack that should be better done via PAM. ;) this wish depends on bug #89023, bug #59353, bug #103046 ... sort of all the same. 536921 11 kevin.kofler 2007-07-18 21:57:25 +0000 The goal of my patch wasn't to implement GDM-style fast user switching in KDM, but to make KDM with its existing behavior "play nice" with the ConsoleKit infrastructure. I did, however, port all of the ConsoleKit integration code from GDM, so the code needed to communicate with ConsoleKit for fast user switching if/when it gets implemented is already in consolekit.c (see unlock_ck_session), just not used. Note that fast user switching probably also needs support from KScreensaver, not just KDM. (gnome-screensaver communicates with ConsoleKit to support the session locking and unlocking for fast user switching.) 536992 12 ossi 2007-07-19 12:58:13 +0000 and this mere "playing nice" is better served via PAM. period. if you want this patch to be a basis for anything, you have to a) fix the license and b) fix the coding style. but don't expect integration any time soon anyway. 536993 13 kevin.kofler 2007-07-19 13:01:58 +0000 The GPL is compatible with the X11 license and the KDM frontend is already under the GPL, so what's the problem with GPL code in the backend? 536995 14 ossi 2007-07-19 13:09:55 +0000 the backend is supposed to stay x11 for free exchange with xdm (even though this hasn't happened for some years now). 538120 15 rdieter 2007-07-26 19:46:46 +0000 fyi, http://fedoraproject.org/wiki/Releases/FeatureRemovePAMConsole 538133 16 kevin.kofler 2007-07-26 21:28:11 +0000 It shall be noted that this is the next step (which is going to be taken for Fedora 8 if everything goes as planned), which probably isn't of direct relevance to KDM (it's just a move from a mix of the old pam_console setup and the new ConsoleKit+HAL setup to only the new one). What went into Fedora 7 already (and what we're patching KDM for) is this: http://fedoraproject.org/wiki/Releases/FeatureFastUserSwitching (As already discussed above, we don't have GDM-style fast user switching really working in KDM yet, but we did implement the parts needed to keep HAL working in KDM sessions.) 559013 17 22250 kevin.kofler 2007-11-29 19:42:54 +0000 Created attachment 22250 Updated consolekit-kdm patch This is an updated version of the patch: * applies against kdebase-workspace 3.96.1 * includes Mandriva's fixes for xdmcp not working, see: https://bugzilla.redhat.com/show_bug.cgi?id=243560 http://qa.mandriva.com/show_bug.cgi?id=35502 http://www.mandriva.com/security/advisories?name=MDKA-2007:110 559014 18 kevin.kofler 2007-11-29 19:45:22 +0000 Also http://qa.mandriva.com/show_bug.cgi?id=34786 (35502 is just the update tracker, not the actual bug report). 571286 19 23030 fabo 2008-01-14 16:36:21 +0000 Created attachment 23030 kdm consolekit support patch for 3.x series 571287 20 fabo 2008-01-14 16:37:24 +0000 Also http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=450603 -------- the pkg-utopia team is going to upload a hal version to experimental, which has compiled in support for ConsoleKit/PolicyKit and we plan to upload this version to unstable later if nothing goes awfully wrong. This means, that hal clients in the desktop session have to be active, in order to call hal methods ( at least for stuff like Suspend()/Hibernate()/Mount() ). For this to work, the login manager has to register the session on login with ConsoleKit. Then ConsoleKit allows to track, if the desktop session is active or not. This allows to fix many longstanding issues with regard to fast user switching. gdm already has support for ConsoleKit (upstream) and the attached patch also adds ConsoleKit support to kdm. It only adds a dependency on D-Bus. Running kdm without ConsoleKit being installed is still possible, so it's perfectly safe to include this patch now, even if the current hal version in unstable doesn't require it yet. This is a heads up, to give you enough time to upload an updated kdm version, before the CK/PK enabled hal version is uploaded to unstable. So please consider to add this patch to your next upload. -------- We have included the patch to our Debian packages. It could be nice to have it included upstream too. 571299 21 23031 kevin.kofler 2008-01-14 17:07:38 +0000 Created attachment 23031 kdm consolekit support patch for 3.5.8 (with Mandriva fixes) WARNING: The patch you uploaded is outdated, in particular you're missing the fix by Nicolas Lécureuil from Mandriva to make XDMCP work. I'm attaching the latest version I know about, which is the current version in Fedora CVS and includes the Mandriva fixes. 571313 22 23032 kevin.kofler 2008-01-14 17:17:52 +0000 Created attachment 23032 kdm consolekit support patch for 4.0.0 (with Mandriva fixes) And here's a version which applies against 4.0.0. 586368 23 fabo 2008-03-12 11:53:29 +0000 Another update related to http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=457487 --- a/kdm/backend/consolekit.c +++ b/kdm/backend/consolekit.c @@ -461,7 +461,7 @@ add_param_string (&iter_struct, "x11-display", d->name); add_param_boolean (&iter_struct, "is-local", ((d->displayType & d_location) == dLocal)); #ifdef XDMCP - if ((d->displayType & d_location) != dLocal) { + if ((d->displayType & d_location) != dLocal && d->remoteHost) { add_param_string (&iter_struct, "remote-host-name", d->remoteHost); } #endif 586369 24 kevin.kofler 2008-03-12 11:55:04 +0000 That change is redundant if the fixes from Mandriva have been applied. 586370 25 kevin.kofler 2008-03-12 11:56:40 +0000 To be more explicit, the fix from Mandriva is the proper fix, as it actually sets d->remoteHost as it's supposed to, see the xdmcp.c hunk: + d->remoteHost = networkAddressToHostname (pdpy->connectionType, + &pdpy->connectionAddress); 586374 26 modax.reg 2008-03-12 12:09:40 +0000 Please read Debian bug report. Debian was already using "kdm consolekit support patch for 3.5.8 (with Mandriva fixes)" and d->remoteHost could still be NULL under certain circumstances (see bug report). 586396 27 fabo 2008-03-12 13:45:17 +0000 we applied the patch with mandriva fixes, it seems not sufficient and resulted in the updated patch. from the bug report: [...] When logging in on a remote xterminal via XDMCP kdm segfaults, causing the session to die and the greeter to be redisplayed. A backtrace of the crash (below) shows that we crash trying to create a bogus DBUS entry. Further investigation indicates the d->remoteHost is NULL. It looks like there are two different types of nonlocal session: Localy manged X servers that connect to a remote XDMCP server, and remote X terminals logging into this host via XDMCP. remoteHost is only set in the former case. The patch below fixes the crash by only adding the dbus attribute if remoteHost is known. [...] 603461 28 rdieter 2008-05-22 21:26:23 +0000 srsly, about every major linux distro is including some variant of this patch, and that's just plain silly. Are we still blocking on just license and coding style (Re comment #12) ? 603465 29 jtate+kde 2008-05-22 22:00:04 +0000 I applied a version of this patch in foresight's not yet released KDE version. I updated it for 3.5.9. 611505 30 shawn.starr 2008-06-15 03:34:39 +0000 Please merge this into trunk. KDE Developers in Fedora will have serious problems because ConsoleKit is defacto now (it uses PAM) and thus No sound 611506 31 kevin.kofler 2008-06-15 03:37:15 +0000 s/it uses PAM/PulseAudio needs it to get access to sound devices and everything which outputs sound uses PulseAudio/ 611507 32 kevin.kofler 2008-06-15 03:41:20 +0000 (Display managers are still expected to talk to ConsoleKit directly, not through PAM. And PAM is completely irrelevant for the sound issue, maybe you mixed up PAM with PA (PulseAudio)?) 611510 33 kevin.kofler 2008-06-15 04:00:15 +0000 There's also a version of the patch by Patrice Dumas which uses libck-connector instead of the consolekit.c I adapted from GDM: https://bugzilla.redhat.com/show_bug.cgi?id=430388 This is probably cleaner, and easier to properly autodetect (use ConsoleKit if and only if libck-connector is there), the drawback is that the extra dependency is used instead of just D-Bus, but that's probably not a real issue. The real issue is that that version of the patch hasn't had much testing yet. 619520 34 kevin.kofler 2008-07-03 02:09:06 +0000 One advantage of using libck-connector is that there's no longer the GPLed consolekit.c, and libck-connector is licensed under the MIT X11 license, so Ossi's licensing concerns should be dealt with by that solution. 625046 35 26151 kevin.kofler 2008-07-15 18:08:09 +0000 Created attachment 26151 KDM ConsoleKit support patch using libck-connector (against 4.0.98) I have cleaned up the version of the patch using libck-connector, and Rex Dieter has tested it. I also applied the fix by the Debian folks (from comment #23). This patch: * automatically detects whether to enable ConsoleKit support: it is enabled if and only if libck-connector is detected (it can be overridden with -DWITH_CkConnector=off, as I'm using macro_optional_find_package). * uses macro_log_feature to report on the above. * contains no GPL code, it's all X11-licensed. * doesn't duplicate ConsoleKit interfacing code, reuses the (X11-licensed) ck-connector library instead. Therefore, I think this patch should be acceptable for upstream merging. Please take into account that most, if not all, major distributions are using some variant of this patch (or the older revision which used the low-level D-Bus interface only and had the ConsoleKit interfacing code copied from GDM) and that vanilla KDE no longer works properly on all those distributions, because ConsoleKit registration is required for several core mechanisms (e.g. HAL, PulseAudio, ...) to work. 625048 36 kevin.kofler 2008-07-15 18:12:33 +0000 (The patch is against 4.0.98, it should apply against both 4.1 branch and 4.2 trunk, probably 4.0 too. But by the freeze policies, I think only 4.2 can be considered for upstream merging.) 625064 37 kevin.kofler 2008-07-15 18:58:08 +0000 And I almost forgot: Thanks to Patrice Dumas for the original revision of the libck-connector-based version of the patch! 625206 38 ossi 2008-07-15 23:18:32 +0000 my very first sentence still applies. ;) look at the way pam is integrated; anything else is just wrong. the coding style does not match. i will fix that myself if you insist. 625513 39 26177 kevin.kofler 2008-07-16 16:24:15 +0000 Created attachment 26177 KDM ConsoleKit support patch using libck-connector (against 4.0.98, actually tested) Oops, we accidentally tested an old version. (Sorry, we really thought we had tested the new one successfully, but it turns out we didn't, oops.) This version is actually tested (I swear!), I fixed 2 more bugs (a segfault and an incorrect parameter name which caused ConsoleKit not to give out the device permissions), now it's working fine. > the coding style does not match. i will fix that myself if you insist That would be very helpful indeed, because I'm not sure I can find all the coding style mismatches. :-( And yes, I insist that the patch is needed. :-) 625528 40 ossi 2008-07-16 17:07:21 +0000 > And yes, I insist that the patch is needed. :-) > i don't doubt that. ;) you're not listening properly, though. the bottom line is, if you are touching session.c, you are doing something wrong. btw, the WIN32 test in FindCKConnector seems pretty pointless ... 661212 41 28377 kevin.kofler 2008-11-07 01:42:55 +0000 Created attachment 28377 KDM ConsoleKit support patch using libck-connector (against trunk or 4.1.2) So here's a version of the patch which does not touch session.c at all, but only client.c (and a one-line fix to xdmcp.c), as requested. I also made some minor adjustments to match the KDM backend's coding style. The behavior should be strictly equivalent to the previous version of the patch. The diff was made against 4.1.2, but I verified that it also applies cleanly (no rejects, no fuzz, even no offsets) against the current trunk. I have tested it in a Fedora kdebase-workspace-4.1.2 RPM (I replaced the previous ConsoleKit patch by this one), it works (builds and runs) fine (as confirmed by ConsoleKit's ck-list-sessions tool). 661214 42 28378 kevin.kofler 2008-11-07 02:06:59 +0000 Created attachment 28378 KDM ConsoleKit support patch using libck-connector (against trunk or 4.1.2) Same as above, but without the -Wwrite-strings warning (just a s/char \*remote_host_name/const char *remote_host_name/). ;-) The patch now introduces no warnings. 661434 43 ossi 2008-11-07 16:10:53 +0000 now we are getting somewhere ... ;) - the dbus check should use pkgconfig, too - extending the #ifdef in hunk 1207+ is wrong. it must be complementary to code in verify() - the if(p) in hunk 1216+ makes no sense. basically for the same reason as above. - !is_local && !td->remoteHost is most likely insatisfiable, too. pls check. - afaik, the generic error messages should not mention dbus-induced failures, as those are guaranteed to return a proper error code. btw, doesn't the connector provide some function to stringify its own error messages? can there be non-dbus errors at all? - camelCase is preferred to underscore_madness ;) there are some other minor stylistic issues which are harder to explain than to fix, so i'll do that myself prior to checkin. 661466 44 kevin.kofler 2008-11-07 17:22:15 +0000 > - the dbus check should use pkgconfig, too IIRC, I didn't use it because the 2 include dirs (DBUS_INCLUDE_DIR and DBUS_ARCH_INCLUDE_DIR) made the default cmake pkgconfig macros fail and so I followed the path of least resistance, but there must be a way to use pkgconfig anyway, I'm rechecking, I'll change it if I can. > - extending the #ifdef in hunk 1207+ is wrong. it must be complementary to code in verify() Uh, I don't understand, the pwent is needed by both the PAM and AIX code and the ConsoleKit code so why should I be computing the exact same pwent twice? I can easily change it, but I don't understand what's wrong with the way I implemented it. > - the if(p) in hunk 1216+ makes no sense. basically for the same reason as above. See above. > - !is_local && !td->remoteHost is most likely insatisfiable, too. pls check. That's what I thought too, but the Debian folks assured me otherwise, see comment #23 and comment #27. > - afaik, the generic error messages should not mention dbus-induced failures, > as those are guaranteed to return a proper error code. So should I just change it to a generic "Cannot close CK session\n"? > btw, doesn't the connector provide some function to stringify its own error > messages? Unfortunately no, it doesn't. > can there be non-dbus errors at all? I don't know, so I have to assume the worst. > - camelCase is preferred to underscore_madness ;) Uh, sorry, I tried to match the surrounding code, which uses underscores in a lot of places. :-) But I'm going to change my variable names to camelCase. 661469 45 kevin.kofler 2008-11-07 17:25:34 +0000 Oops, I understand now what you mean by those: > - extending the #ifdef in hunk 1207+ is wrong. it must be complementary to code > in verify() > - the if(p) in hunk 1216+ makes no sense. basically for the same reason as > above. (If not PAM nor AIX, p is already computed by verify, so I'm actually computing it twice, and if (p) is always satisfied, right?) /me needs more sleep, sorry. :-) I'll fix this. 661494 46 ossi 2008-11-07 18:26:02 +0000 > (If not PAM nor AIX, p is already computed by verify, so I'm actually computing > it twice, and if (p) is always satisfied, right?) > yup :) > the Debian folks assured me otherwise, see comment #23 and comment #27. > hmm. i wonder whether any of these cases is actually legitimate. "foreign" and "local feedback" (Xnest -query localhost) displays should be investigated, and the findings documented or the other code fixed. > So should I just change it to a generic "Cannot close CK session\n"? > sounds kind of reasonable. > I don't know, so I have to assume the worst. > i'd seek some definite clarification on that. > I tried to match the surrounding code, which uses underscores in a > lot of places. :-) > yeah, the naming is a mess. i'm trying to standardize incrementally. 661921 47 28418 kevin.kofler 2008-11-08 18:03:00 +0000 Created attachment 28418 KDM ConsoleKit support patch using libck-connector (against trunk/4.1.2, updated) Here's a version of the patch addressing your comments: * FindDBus.cmake now uses pkg-config, through the new FindPkgConfig. This also solves the problem with D-Bus's 2 include directories. * I also changed FindCkConnector.cmake to use FindPkgConfig instead of the old UsePkgConfig (also avoids having to hardcode the "/ConsoleKit/ck-connector" part of the includedir). * I removed the #ifdef extension (which was computing p a second time when verify() already did it) and the useless if (p) check. * I added a comment for the seemingly-redundant !is_local && td->remoteHost check pointing to the relevant Debian bug report. * The fallback error messages for when dbus_error_is_set is false for some reason are now less verbose. * I renamed all the variable names I added to camelCase. (Of course I can't change the names used by D-Bus and libck-connector nor pwent's pw_uid.) Tested, builds, runs, registers CK session successfully. 663303 48 kevin.kofler 2008-11-11 15:09:31 +0000 Ping? The 4.2 hard feature freeze is approaching, we need this merged before. (And yes, it's in the 4.2 feature plan, Rex Dieter added it.) 664483 49 28549 ossi 2008-11-13 21:05:08 +0000 Created attachment 28549 fixed partial patch i knew what i'm getting into, so i procrastinated. ;) i knew that the remoteHost stuff is fishy, just not how much. :} this patch compiles, but is otherwise untested. have fun with it. the case that would legitimately use remoteHost (the local chooser mode, "remote login" in the greeter) needs to be handled completely separately (yes, outside client.c this time ;). 664494 50 kevin.kofler 2008-11-13 21:17:36 +0000 So can we please commit it now (with your changes)? I really don't want to miss the freeze and get told it now has to wait until 4.3! And it would be helpful if you explained what exactly was wrong with the way remoteHost was handled. Because "fishy" is a bit vague. ;-) 664503 51 ossi 2008-11-13 21:34:39 +0000 stop panicking. this is clearly a bugfix, right? ;) everything is wrong with the remoteHost usage. grep for it, get a grip of what it is meant to do (you'll need that to implement the second part anyway). 664661 52 kevin.kofler 2008-11-14 03:18:09 +0000 But can we merge the current code now? The fact that this: > the case that would legitimately use remoteHost (the local chooser mode, > "remote login" in the greeter) needs to be handled completely separately (yes, > outside client.c this time ;). is missing isn't really a blocker bug, is it? 664665 53 kevin.kofler 2008-11-14 03:43:36 +0000 Oh, and for sessions where KDM is local and the session is remote (is this what remoteHost is used for? Looking at the code and your comment #49, I think it is, but I'm not 100% sure I understand), ConsoleKit probably doesn't really need to know about that session anyway. ConsoleKit is used to enumerate sessions on the local machine to give out permissions to those sessions (e.g. device permissions and PolicyKit-controlled application permissions), so as far as I know sessions which are actually on the remote machine aren't really interesting to ConsoleKit anyway. 665964 54 ossi 2008-11-17 00:45:25 +0000 > ConsoleKit probably doesn't really need to know about that session anyway. > maybe. it could be useful for fast user switching ... if there was a way to switch back to a local session. maybe some day. if you want me to commit, you have to say whether my patch works. ;) 666608 55 kevin.kofler 2008-11-18 06:00:45 +0000 Hmmm, to really test this, we'll need some XDMCP setup. I can have a try later today or tomorrow with my 2 machines (I have stuff for the university to do right now), hopefully that'll allow some testing. But I won't complain if somebody with more experience with XDMCP helps test this. ;-) (And I'm worried that the release team will kill us if we sneak this into 4.2 now, we're already late. ;-( ) 666762 56 ossi 2008-11-18 14:52:32 +0000 SVN commit 886022 by ossi: add rudimentary support for ConsoleKit. this is quite a crutch - it is so poorly integrated that one could just as well do it with PAM (if the respective module wasn't that braindead). BUG: 147790 A cmake/modules/FindCkConnector.cmake A cmake/modules/FindDBus.cmake M +11 -0 kdm/CMakeLists.txt M +4 -0 kdm/backend/CMakeLists.txt M +96 -0 kdm/backend/client.c M +3 -0 kdm/config-kdm.h.cmake WebSVN link: http://websvn.kde.org/?view=rev&revision=886022 21120 2007-07-11 18:39:43 +0000 2007-11-29 19:42:54 +0000 The current patch (KDE 4 version) kdebase-3.91.0-consolekit-kdm.patch text/plain 22371 kevin.kofler ZGlmZiAtTnVyIGtkZWJhc2UtMy45MS4wL3dvcmtzcGFjZS9jbWFrZS9tb2R1bGVzL0ZpbmREQnVz LmNtYWtlIGtkZWJhc2UtMy45MS4wLWNvbnNvbGVraXQvd29ya3NwYWNlL2NtYWtlL21vZHVsZXMv RmluZERCdXMuY21ha2UKLS0tIGtkZWJhc2UtMy45MS4wL3dvcmtzcGFjZS9jbWFrZS9tb2R1bGVz L0ZpbmREQnVzLmNtYWtlCTE5NzAtMDEtMDEgMDE6MDA6MDAuMDAwMDAwMDAwICswMTAwCisrKyBr ZGViYXNlLTMuOTEuMC1jb25zb2xla2l0L3dvcmtzcGFjZS9jbWFrZS9tb2R1bGVzL0ZpbmREQnVz LmNtYWtlCTIwMDctMDctMDQgMDk6MjM6MTIuMDAwMDAwMDAwICswMjAwCkBAIC0wLDAgKzEsMzkg QEAKKworaWYoREJVU19JTkNMVURFX0RJUiBBTkQgREJVU19MSUJSQVJZIEFORCBEQlVTX0FSQ0hf SU5DTFVERV9ESVIpCisJIyBBbHJlYWR5IGluIGNhY2hlLCBiZSBzaWxlbnQKKwlzZXQoREJVU19G SU5EX1FVSUVUTFkgVFJVRSkJCitlbmRpZihEQlVTX0lOQ0xVREVfRElSIEFORCBEQlVTX0xJQlJB UlkgQU5EIERCVVNfQVJDSF9JTkNMVURFX0RJUikKKworc2V0KERCVVNfTElCUkFSWSkKK3NldChE QlVTX0lOQ0xVREVfRElSKQorc2V0KERCVVNfQVJDSF9JTkNMVURFX0RJUikKKworRklORF9QQVRI KERCVVNfSU5DTFVERV9ESVIgZGJ1cy9kYnVzLmgKKwkvdXNyL2luY2x1ZGUKKwkvdXNyL2luY2x1 ZGUvZGJ1cy0xLjAKKwkvdXNyL2xvY2FsL2luY2x1ZGUKKykKKworRklORF9QQVRIKERCVVNfQVJD SF9JTkNMVURFX0RJUiBkYnVzL2RidXMtYXJjaC1kZXBzLmgKKwkvdXNyL2xpYiR7TElCX1NVRkZJ WH0vaW5jbHVkZQorCS91c3IvbGliJHtMSUJfU1VGRklYfS9kYnVzLTEuMC9pbmNsdWRlCisJL3Vz ci9saWI2NC9pbmNsdWRlCisJL3Vzci9saWI2NC9kYnVzLTEuMC9pbmNsdWRlCisJL3Vzci9saWIv aW5jbHVkZQorCS91c3IvbGliL2RidXMtMS4wL2luY2x1ZGUKKykKKworRklORF9MSUJSQVJZKERC VVNfTElCUkFSWSBOQU1FUyBkYnVzLTEgZGJ1cworCVBBVEhTCisJL3Vzci9saWIKKwkvdXNyL2xv Y2FsL2xpYgorKQorCitpZihEQlVTX0lOQ0xVREVfRElSIEFORCBEQlVTX0xJQlJBUlkgQU5EIERC VVNfQVJDSF9JTkNMVURFX0RJUikKKyAgIE1FU1NBR0UoIFNUQVRVUyAiZGJ1cyBmb3VuZDogaW5j bHVkZXMgaW4gJHtEQlVTX0lOQ0xVREVfRElSfSwgbGlicmFyeSBpbiAke0RCVVNfTElCUkFSWX0i KQorICAgc2V0KERCVVNfRk9VTkQgVFJVRSkKK2Vsc2UoREJVU19JTkNMVURFX0RJUiBBTkQgREJV U19MSUJSQVJZIEFORCBEQlVTX0FSQ0hfSU5DTFVERV9ESVIpCisgICBNRVNTQUdFKCBTVEFUVVMg ImRidXMgbm90IGZvdW5kIikKK2VuZGlmKERCVVNfSU5DTFVERV9ESVIgQU5EIERCVVNfTElCUkFS WSBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSKQorCitNQVJLX0FTX0FEVkFOQ0VEKERCVVNfSU5D TFVERV9ESVIgREJVU19MSUJSQVJZIERCVVNfQVJDSF9JTkNMVURFX0RJUikKZGlmZiAtTnVyIGtk ZWJhc2UtMy45MS4wL3dvcmtzcGFjZS9rZG0vYmFja2VuZC9jbGllbnQuYyBrZGViYXNlLTMuOTEu MC1jb25zb2xla2l0L3dvcmtzcGFjZS9rZG0vYmFja2VuZC9jbGllbnQuYwotLS0ga2RlYmFzZS0z LjkxLjAvd29ya3NwYWNlL2tkbS9iYWNrZW5kL2NsaWVudC5jCTIwMDctMDYtMjcgMTI6NDY6MDQu MDAwMDAwMDAwICswMjAwCisrKyBrZGViYXNlLTMuOTEuMC1jb25zb2xla2l0L3dvcmtzcGFjZS9r ZG0vYmFja2VuZC9jbGllbnQuYwkyMDA3LTA3LTA0IDA3OjMxOjAxLjAwMDAwMDAwMCArMDIwMApA QCAtODEsNiArODEsMTAgQEAKICMgaW5jbHVkZSA8dGltZS5oPgogI2VuZGlmIC8qIFVTRV9QQU0g fHwgX0FJWCAqLwogCisjaWZkZWYgV0lUSF9DT05TT0xFX0tJVAorI2luY2x1ZGUgImNvbnNvbGVr aXQuaCIKKyNlbmRpZgorCiAvKgogICogU2Vzc2lvbiBkYXRhLCBtb3N0bHkgd2hhdCBzdHJ1Y3Qg dmVyaWZ5X2luZm8gd2FzIGZvcgogICovCkBAIC0xMTAzLDggKzExMDcsMTMgQEAKIHN0YXRpYyBp bnQgcmVtb3ZlQ3JlZHM7CiAjZW5kaWYKIAorI2lmZGVmIFdJVEhfQ09OU09MRV9LSVQKK2ludAor c3RhcnRDbGllbnQoIHZvbGF0aWxlIGludCAqcGlkLCBjb25zdCBjaGFyICpja19zZXNzaW9uX2Nv b2tpZSApCisjZWxzZQogaW50CiBzdGFydENsaWVudCggdm9sYXRpbGUgaW50ICpwaWQgKQorI2Vu ZGlmCiB7CiAJY29uc3QgY2hhciAqaG9tZSwgKnNlc3NhcmdzLCAqZGVza3Nlc3M7CiAJY2hhciAq KmVudiwgKnhtYTsKQEAgLTExODQsNiArMTE5MywxMSBAQAogCWlmIChrcmJ0a2ZpbGVbMF0gIT0g J1wwJykKIAkJZW52ID0gc2V0RW52KCBlbnYsICJLUkJUS0ZJTEUiLCBrcmJ0a2ZpbGUgKTsKICNl bmRpZgorI2lmZGVmIFdJVEhfQ09OU09MRV9LSVQKKwlpZiAoY2tfc2Vzc2lvbl9jb29raWUgIT0g TlVMTCkgeworCQllbnYgPSBzZXRFbnYgKCBlbnYsICJYREdfU0VTU0lPTl9DT09LSUUiLCBja19z ZXNzaW9uX2Nvb2tpZSApOworCX0KKyNlbmRpZgogCXVzZXJFbnZpcm9uID0gaW5oZXJpdEVudigg ZW52LCBlbnZ2YXJzICk7CiAJZW52ID0gc3lzdGVtRW52KCBjdXJ1c2VyICk7CiAJc3lzdGVtRW52 aXJvbiA9IHNldEVudiggZW52LCAiSE9NRSIsIHAtPnB3X2RpciApOwpkaWZmIC1OdXIga2RlYmFz ZS0zLjkxLjAvd29ya3NwYWNlL2tkbS9iYWNrZW5kL0NNYWtlTGlzdHMudHh0IGtkZWJhc2UtMy45 MS4wLWNvbnNvbGVraXQvd29ya3NwYWNlL2tkbS9iYWNrZW5kL0NNYWtlTGlzdHMudHh0Ci0tLSBr ZGViYXNlLTMuOTEuMC93b3Jrc3BhY2Uva2RtL2JhY2tlbmQvQ01ha2VMaXN0cy50eHQJMjAwNy0w Ni0yNyAxMjo0NjowNC4wMDAwMDAwMDAgKzAyMDAKKysrIGtkZWJhc2UtMy45MS4wLWNvbnNvbGVr aXQvd29ya3NwYWNlL2tkbS9iYWNrZW5kL0NNYWtlTGlzdHMudHh0CTIwMDctMDctMTEgMTE6NDQ6 MzIuMDAwMDAwMDAwICswMjAwCkBAIC0xLDMgKzEsNCBAQAorZmluZF9wYWNrYWdlKERCdXMgUkVR VUlSRUQpCiBzZXQoa2RtX1NSQ1MKIAlncmVldC5oCiAJZG0uaApAQCAtOCw2ICs5LDcgQEAKIAli b290bWFuLmMKIAljbGllbnQuYwogCWN0cmwuYworCWNvbnNvbGVraXQuYwogCWRhZW1vbi5jCiAJ ZG0uYwogCWRweWxpc3QuYwpAQCAtNTQsNiArNTYsNyBAQAogbWFjcm9fYWRkX2ZpbGVfZGVwZW5k ZW5jaWVzKGVycm9yLmMgJHtDTUFLRV9DVVJSRU5UX1NPVVJDRV9ESVJ9L3ByaW50Zi5jKQoga2Rl NF9hZGRfZXhlY3V0YWJsZShrZG0gTk9HVUkgJHtrZG1fU1JDU30pCiBtYWNyb19hZGRfY29tcGls ZV9mbGFncyhrZG0gLVVfUkVFTlRSQU5UKQoraW5jbHVkZV9kaXJlY3Rvcmllcygke0RCVVNfSU5D TFVERV9ESVJ9ICR7REJVU19BUkNIX0lOQ0xVREVfRElSfSkKIHRhcmdldF9saW5rX2xpYnJhcmll cygga2RtCiAJJHtYMTFfTElCUkFSSUVTfQogCSR7VU5JWEFVVEhfTElCUkFSSUVTfQpAQCAtNjQs NiArNjcsNyBAQAogCSR7UkVTT0xWX0xJQlJBUklFU30KIAkke1VUSUxfTElCUkFSSUVTfQogCSR7 UE9TSVg0X0xJQlJBUklFU30KKwkke0RCVVNfTElCUkFSWX0KICkKIGlmKEtERTRfRU5BQkxFX0ZJ TkFMKQogICAgICAgICBtYWNyb19hZGRfZmlsZV9kZXBlbmRlbmNpZXMoJHtDTUFLRV9DVVJSRU5U X0JJTkFSWV9ESVJ9L2tkbV9maW5hbF9jcHAuY3BwICR7Y29uZmNpfSkKZGlmZiAtTnVyIGtkZWJh c2UtMy45MS4wL3dvcmtzcGFjZS9rZG0vYmFja2VuZC9jb25zb2xla2l0LmMga2RlYmFzZS0zLjkx LjAtY29uc29sZWtpdC93b3Jrc3BhY2Uva2RtL2JhY2tlbmQvY29uc29sZWtpdC5jCi0tLSBrZGVi YXNlLTMuOTEuMC93b3Jrc3BhY2Uva2RtL2JhY2tlbmQvY29uc29sZWtpdC5jCTE5NzAtMDEtMDEg MDE6MDA6MDAuMDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNlLTMuOTEuMC1jb25zb2xla2l0L3dv cmtzcGFjZS9rZG0vYmFja2VuZC9jb25zb2xla2l0LmMJMjAwNy0wNy0wNCAwNzo1MjozMi4wMDAw MDAwMDAgKzAyMDAKQEAgLTAsMCArMSw1MzkgQEAKKy8qIC0qLSBNb2RlOiBDOyB0YWItd2lkdGg6 IDg7IGluZGVudC10YWJzLW1vZGU6IHQ7IGMtYmFzaWMtb2Zmc2V0OiA4IC0qLQorICoKKyAqIENv cHlyaWdodCAoQykgMjAwNi0yMDA3IFdpbGxpYW0gSm9uIE1jQ2FubiA8bWNjYW5uQGpodS5lZHU+ CisgKiBDb3B5cmlnaHQgKEMpIDIwMDcgS2V2aW4gS29mbGVyIDxLZXZpbkB0aWdjYy50aWNhbGMu b3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29m dHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAq IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFt IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5v dCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRl bXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgor ICovCisKKyNpbmNsdWRlICJkbS5oIgorI2luY2x1ZGUgImRtX2F1dGguaCIKKyNpbmNsdWRlICJk bV9lcnJvci5oIgorCisjaW5jbHVkZSA8c3RkbGliLmg+CisjaW5jbHVkZSA8c3RyaW5nLmg+Cisj aW5jbHVkZSA8cHdkLmg+CisKKyNkZWZpbmUgREJVU19BUElfU1VCSkVDVF9UT19DSEFOR0UKKyNp bmNsdWRlIDxkYnVzL2RidXMuaD4KKworI2luY2x1ZGUgImNvbnNvbGVraXQuaCIKKworCisjZGVm aW5lIENLX05BTUUgICAgICAgICAgICAgICJvcmcuZnJlZWRlc2t0b3AuQ29uc29sZUtpdCIKKyNk ZWZpbmUgQ0tfUEFUSCAgICAgICAgICAgICAgIi9vcmcvZnJlZWRlc2t0b3AvQ29uc29sZUtpdCIK KyNkZWZpbmUgQ0tfSU5URVJGQUNFICAgICAgICAgIm9yZy5mcmVlZGVza3RvcC5Db25zb2xlS2l0 IgorI2RlZmluZSBDS19NQU5BR0VSX1BBVEggICAgICAiL29yZy9mcmVlZGVza3RvcC9Db25zb2xl S2l0L01hbmFnZXIiCisjZGVmaW5lIENLX01BTkFHRVJfSU5URVJGQUNFICJvcmcuZnJlZWRlc2t0 b3AuQ29uc29sZUtpdC5NYW5hZ2VyIgorI2RlZmluZSBDS19TRVNTSU9OX0lOVEVSRkFDRSAib3Jn LmZyZWVkZXNrdG9wLkNvbnNvbGVLaXQuU2Vzc2lvbiIKKworc3RhdGljIERCdXNDb25uZWN0aW9u ICpwcml2YXRlX2Nvbm5lY3Rpb24gPSBOVUxMOworCitzdGF0aWMgdm9pZAorYWRkX3BhcmFtX2lu dCAoREJ1c01lc3NhZ2VJdGVyICppdGVyX3N0cnVjdCwKKwkgICAgICAgY29uc3QgY2hhciAgICAg ICprZXksCisJICAgICAgIGludCAgICAgICAgICAgICAgdmFsdWUpCit7CisJREJ1c01lc3NhZ2VJ dGVyIGl0ZXJfc3RydWN0X2VudHJ5OworCURCdXNNZXNzYWdlSXRlciBpdGVyX3ZhcjsKKworCWRi dXNfbWVzc2FnZV9pdGVyX29wZW5fY29udGFpbmVyIChpdGVyX3N0cnVjdCwKKwkJCQkJICBEQlVT X1RZUEVfU1RSVUNULAorCQkJCQkgIE5VTEwsCisJCQkJCSAgJml0ZXJfc3RydWN0X2VudHJ5KTsK KworCWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXJfc3RydWN0X2VudHJ5LAor CQkJCQlEQlVTX1RZUEVfU1RSSU5HLAorCQkJCQkma2V5KTsKKworCWRidXNfbWVzc2FnZV9pdGVy X29wZW5fY29udGFpbmVyICgmaXRlcl9zdHJ1Y3RfZW50cnksCisJCQkJCSAgREJVU19UWVBFX1ZB UklBTlQsCisJCQkJCSAgREJVU19UWVBFX0lOVDMyX0FTX1NUUklORywKKwkJCQkJICAmaXRlcl92 YXIpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljICgmaXRlcl92YXIsCisJCQkJ CURCVVNfVFlQRV9JTlQzMiwKKwkJCQkJJnZhbHVlKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2Ns b3NlX2NvbnRhaW5lciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgICAmaXRlcl92YXIpOwor CisJZGJ1c19tZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFpbmVyIChpdGVyX3N0cnVjdCwgJml0ZXJf c3RydWN0X2VudHJ5KTsKK30KKworc3RhdGljIHZvaWQKK2FkZF9wYXJhbV9ib29sZWFuIChEQnVz TWVzc2FnZUl0ZXIgKml0ZXJfc3RydWN0LAorCQkgICBjb25zdCBjaGFyICAgICAgKmtleSwKKwkJ ICAgaW50ICAgICAgICAgICAgIHZhbHVlKQoreworCURCdXNNZXNzYWdlSXRlciBpdGVyX3N0cnVj dF9lbnRyeTsKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcl92YXI7CisKKwlkYnVzX21lc3NhZ2VfaXRl cl9vcGVuX2NvbnRhaW5lciAoaXRlcl9zdHJ1Y3QsCisJCQkJCSAgREJVU19UWVBFX1NUUlVDVCwK KwkJCQkJICBOVUxMLAorCQkJCQkgICZpdGVyX3N0cnVjdF9lbnRyeSk7CisKKwlkYnVzX21lc3Nh Z2VfaXRlcl9hcHBlbmRfYmFzaWMgKCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJREJVU19UWVBF X1NUUklORywKKwkJCQkJJmtleSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5l ciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgIERCVVNfVFlQRV9WQVJJQU5ULAorCQkJCQkg IERCVVNfVFlQRV9CT09MRUFOX0FTX1NUUklORywKKwkJCQkJICAmaXRlcl92YXIpOworCisJZGJ1 c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljICgmaXRlcl92YXIsCisJCQkJCURCVVNfVFlQRV9C T09MRUFOLAorCQkJCQkmdmFsdWUpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFp bmVyICgmaXRlcl9zdHJ1Y3RfZW50cnksCisJCQkJCSAgICZpdGVyX3Zhcik7CisKKwlkYnVzX21l c3NhZ2VfaXRlcl9jbG9zZV9jb250YWluZXIgKGl0ZXJfc3RydWN0LCAmaXRlcl9zdHJ1Y3RfZW50 cnkpOworfQorCitzdGF0aWMgdm9pZAorYWRkX3BhcmFtX3N0cmluZyAoREJ1c01lc3NhZ2VJdGVy ICppdGVyX3N0cnVjdCwKKwkJICBjb25zdCBjaGFyICAgICAgKmtleSwKKwkJICBjb25zdCBjaGFy ICAgICAgKnZhbHVlKQoreworCURCdXNNZXNzYWdlSXRlciBpdGVyX3N0cnVjdF9lbnRyeTsKKwlE QnVzTWVzc2FnZUl0ZXIgaXRlcl92YXI7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRh aW5lciAoaXRlcl9zdHJ1Y3QsCisJCQkJCSAgREJVU19UWVBFX1NUUlVDVCwKKwkJCQkJICBOVUxM LAorCQkJCQkgICZpdGVyX3N0cnVjdF9lbnRyeSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9hcHBl bmRfYmFzaWMgKCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJREJVU19UWVBFX1NUUklORywKKwkJ CQkJJmtleSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5lciAoJml0ZXJfc3Ry dWN0X2VudHJ5LAorCQkJCQkgIERCVVNfVFlQRV9WQVJJQU5ULAorCQkJCQkgIERCVVNfVFlQRV9T VFJJTkdfQVNfU1RSSU5HLAorCQkJCQkgICZpdGVyX3Zhcik7CisKKwlkYnVzX21lc3NhZ2VfaXRl cl9hcHBlbmRfYmFzaWMgKCZpdGVyX3ZhciwKKwkJCQkJREJVU19UWVBFX1NUUklORywKKwkJCQkJ JnZhbHVlKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lciAoJml0ZXJfc3Ry dWN0X2VudHJ5LAorCQkJCQkgICAmaXRlcl92YXIpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfY2xv c2VfY29udGFpbmVyIChpdGVyX3N0cnVjdCwgJml0ZXJfc3RydWN0X2VudHJ5KTsKK30KKworc3Rh dGljIGludAorc2Vzc2lvbl9nZXRfeDExX2Rpc3BsYXkgKERCdXNDb25uZWN0aW9uICpjb25uZWN0 aW9uLAorCQkJIGNvbnN0IGNoYXIgICAgICpzc2lkLAorCQkJIGNoYXIgICAgICAgICAgKipzdHIp Cit7CisJREJ1c0Vycm9yICAgICAgIGVycm9yOworCURCdXNNZXNzYWdlICAgICptZXNzYWdlOwor CURCdXNNZXNzYWdlICAgICpyZXBseTsKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcjsKKwljb25zdCBj aGFyICAgICAqdmFsdWU7CisKKwlpZiAoc3RyICE9IE5VTEwpIHsKKwkJKnN0ciA9IE5VTEw7CisJ fQorCisJbWVzc2FnZSA9IGRidXNfbWVzc2FnZV9uZXdfbWV0aG9kX2NhbGwgKENLX05BTUUsCisJ CQkJCQlzc2lkLAorCQkJCQkJQ0tfU0VTU0lPTl9JTlRFUkZBQ0UsCisJCQkJCQkiR2V0WDExRGlz cGxheSIpOworCWlmIChtZXNzYWdlID09IE5VTEwpIHsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiBD b3VsZG4ndCBhbGxvY2F0ZSB0aGUgRC1CdXMgbWVzc2FnZSIpOworCQlyZXR1cm4gRkFMU0U7CisJ fQorCisJZGJ1c19lcnJvcl9pbml0ICgmZXJyb3IpOworCXJlcGx5ID0gZGJ1c19jb25uZWN0aW9u X3NlbmRfd2l0aF9yZXBseV9hbmRfYmxvY2sgKGNvbm5lY3Rpb24sCisJCQkJCQkJICAgbWVzc2Fn ZSwKKwkJCQkJCQkgICAtMSwgJmVycm9yKTsKKwlpZiAoZGJ1c19lcnJvcl9pc19zZXQgKCZlcnJv cikpIHsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiAlcyByYWlzZWQ6XG4gJXNcblxuIiwgZXJyb3Iu bmFtZSwgZXJyb3IubWVzc2FnZSk7CisJCXJlcGx5ID0gTlVMTDsKKwl9CisKKwlkYnVzX2Nvbm5l Y3Rpb25fZmx1c2ggKGNvbm5lY3Rpb24pOworCWRidXNfbWVzc2FnZV91bnJlZiAobWVzc2FnZSk7 CisKKwlpZiAocmVwbHkgPT0gTlVMTCkgeworCQlyZXR1cm4gRkFMU0U7CisJfQorCisJZGJ1c19t ZXNzYWdlX2l0ZXJfaW5pdCAocmVwbHksICZpdGVyKTsKKwlkYnVzX21lc3NhZ2VfaXRlcl9nZXRf YmFzaWMgKCZpdGVyLCAmdmFsdWUpOworCWlmIChzdHIgIT0gTlVMTCkgeworCQkqc3RyID0gc3Ry ZHVwICh2YWx1ZSk7CisJfQorCWRidXNfbWVzc2FnZV91bnJlZiAocmVwbHkpOworCisJcmV0dXJu IFRSVUU7Cit9CisKK3N0YXRpYyBpbnQKK3Nlc3Npb25fdW5sb2NrIChEQnVzQ29ubmVjdGlvbiAq Y29ubmVjdGlvbiwKKwkJY29uc3QgY2hhciAgICAgKnNzaWQpCit7CisJREJ1c0Vycm9yICAgICAg IGVycm9yOworCURCdXNNZXNzYWdlICAgICptZXNzYWdlOworCURCdXNNZXNzYWdlICAgICpyZXBs eTsKKworCWRlYnVnICgiQ29uc29sZUtpdDogVW5sb2NraW5nIHNlc3Npb24gJXMiLCBzc2lkKTsK KwltZXNzYWdlID0gZGJ1c19tZXNzYWdlX25ld19tZXRob2RfY2FsbCAoQ0tfTkFNRSwKKwkJCQkJ CXNzaWQsCisJCQkJCQlDS19TRVNTSU9OX0lOVEVSRkFDRSwKKwkJCQkJCSJVbmxvY2siKTsKKwlp ZiAobWVzc2FnZSA9PSBOVUxMKSB7CisJCWRlYnVnICgiQ29uc29sZUtpdDogQ291bGRuJ3QgYWxs b2NhdGUgdGhlIEQtQnVzIG1lc3NhZ2UiKTsKKwkJcmV0dXJuIEZBTFNFOworCX0KKworCWRidXNf ZXJyb3JfaW5pdCAoJmVycm9yKTsKKwlyZXBseSA9IGRidXNfY29ubmVjdGlvbl9zZW5kX3dpdGhf cmVwbHlfYW5kX2Jsb2NrIChjb25uZWN0aW9uLAorCQkJCQkJCSAgIG1lc3NhZ2UsCisJCQkJCQkJ ICAgLTEsICZlcnJvcik7CisJZGJ1c19tZXNzYWdlX3VucmVmIChtZXNzYWdlKTsKKwlkYnVzX21l c3NhZ2VfdW5yZWYgKHJlcGx5KTsKKwlkYnVzX2Nvbm5lY3Rpb25fZmx1c2ggKGNvbm5lY3Rpb24p OworCisJaWYgKGRidXNfZXJyb3JfaXNfc2V0ICgmZXJyb3IpKSB7CisJCWRlYnVnICgiQ29uc29s ZUtpdDogJXMgcmFpc2VkOlxuICVzXG5cbiIsIGVycm9yLm5hbWUsIGVycm9yLm1lc3NhZ2UpOwor CQlyZXR1cm4gRkFMU0U7CisJfQorCisJcmV0dXJuIFRSVUU7Cit9CisKKy8qIGZyb20gbGliaGFs ICovCitzdGF0aWMgY2hhciAqKgorZ2V0X3BhdGhfYXJyYXlfZnJvbV9pdGVyIChEQnVzTWVzc2Fn ZUl0ZXIgKml0ZXIsCisJCQkgIGludCAgICAgICAgICAgICAqbnVtX2VsZW1lbnRzKQoreworCWlu dCBjb3VudDsKKwljaGFyICoqYnVmZmVyOworCisJY291bnQgPSAwOworCWJ1ZmZlciA9IChjaGFy ICoqKW1hbGxvYyAoc2l6ZW9mIChjaGFyICopICogOCk7CisKKwlpZiAoYnVmZmVyID09IE5VTEwp CisJCWdvdG8gb29tOworCisJYnVmZmVyWzBdID0gTlVMTDsKKwl3aGlsZSAoZGJ1c19tZXNzYWdl X2l0ZXJfZ2V0X2FyZ190eXBlIChpdGVyKSA9PSBEQlVTX1RZUEVfT0JKRUNUX1BBVEgpIHsKKwkJ Y29uc3QgY2hhciAqdmFsdWU7CisJCWNoYXIgKnN0cjsKKworCQlpZiAoKGNvdW50ICUgOCkgPT0g MCAmJiBjb3VudCAhPSAwKSB7CisJCQlidWZmZXIgPSByZWFsbG9jIChidWZmZXIsIHNpemVvZiAo Y2hhciAqKSAqIChjb3VudCArIDgpKTsKKwkJCWlmIChidWZmZXIgPT0gTlVMTCkKKwkJCQlnb3Rv IG9vbTsKKwkJfQorCisJCWRidXNfbWVzc2FnZV9pdGVyX2dldF9iYXNpYyAoaXRlciwgJnZhbHVl KTsKKwkJc3RyID0gc3RyZHVwICh2YWx1ZSk7CisJCWlmIChzdHIgPT0gTlVMTCkKKwkJCWdvdG8g b29tOworCisJCWJ1ZmZlcltjb3VudF0gPSBzdHI7CisKKwkJZGJ1c19tZXNzYWdlX2l0ZXJfbmV4 dCAoaXRlcik7CisJCWNvdW50Kys7CisJfQorCisJaWYgKChjb3VudCAlIDgpID09IDApIHsKKwkJ YnVmZmVyID0gcmVhbGxvYyAoYnVmZmVyLCBzaXplb2YgKGNoYXIgKikgKiAoY291bnQgKyAxKSk7 CisJCWlmIChidWZmZXIgPT0gTlVMTCkKKwkJCWdvdG8gb29tOworCX0KKworCWJ1ZmZlcltjb3Vu dF0gPSBOVUxMOworCWlmIChudW1fZWxlbWVudHMgIT0gTlVMTCkKKwkJKm51bV9lbGVtZW50cyA9 IGNvdW50OworCXJldHVybiBidWZmZXI7CisKK29vbToKKwlsb2dXYXJuICgiJXMgJWQgOiBlcnJv ciBhbGxvY2F0aW5nIG1lbW9yeVxuIiwgX19GSUxFX18sIF9fTElORV9fKTsKKwlyZXR1cm4gTlVM TDsKKworfQorCitzdGF0aWMgY2hhciAqKgorZ2V0X3Nlc3Npb25zX2Zvcl91c2VyIChEQnVzQ29u bmVjdGlvbiAqY29ubmVjdGlvbiwKKwkJICAgICAgIGNvbnN0IGNoYXIgICAgICp1c2VyLAorCQkg ICAgICAgY29uc3QgY2hhciAgICAgKngxMV9kaXNwbGF5KQoreworCURCdXNFcnJvciAgICAgICBl cnJvcjsKKwlEQnVzTWVzc2FnZSAgICAqbWVzc2FnZTsKKwlEQnVzTWVzc2FnZSAgICAqcmVwbHk7 CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXI7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXJfcmVwbHk7CisJ REJ1c01lc3NhZ2VJdGVyIGl0ZXJfYXJyYXk7CisJc3RydWN0IHBhc3N3ZAkqcHdlbnQ7CisJY2hh ciAgICAgICAgICAgKipzZXNzaW9uczsKKworCXNlc3Npb25zID0gTlVMTDsKKwltZXNzYWdlID0g TlVMTDsKKwlyZXBseSA9IE5VTEw7CisKKwlwd2VudCA9IGdldHB3bmFtICh1c2VyKTsKKworCWRi dXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwltZXNzYWdlID0gZGJ1c19tZXNzYWdlX25ld19tZXRo b2RfY2FsbCAoQ0tfTkFNRSwKKwkJCQkJCUNLX01BTkFHRVJfUEFUSCwKKwkJCQkJCUNLX01BTkFH RVJfSU5URVJGQUNFLAorCQkJCQkJIkdldFNlc3Npb25zRm9yVXNlciIpOworCWlmIChtZXNzYWdl ID09IE5VTEwpIHsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiBDb3VsZG4ndCBhbGxvY2F0ZSB0aGUg RC1CdXMgbWVzc2FnZSIpOworCQlnb3RvIG91dDsKKwl9CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9p bml0X2FwcGVuZCAobWVzc2FnZSwgJml0ZXIpOworCWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9i YXNpYyAoJml0ZXIsCisJCQkJCURCVVNfVFlQRV9VSU5UMzIsCisJCQkJCSZwd2VudC0+cHdfdWlk KTsKKworCWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwlyZXBseSA9IGRidXNfY29ubmVjdGlv bl9zZW5kX3dpdGhfcmVwbHlfYW5kX2Jsb2NrIChjb25uZWN0aW9uLAorCQkJCQkJCSAgIG1lc3Nh Z2UsCisJCQkJCQkJICAgLTEsICZlcnJvcik7CisJZGJ1c19jb25uZWN0aW9uX2ZsdXNoIChjb25u ZWN0aW9uKTsKKworCWlmIChkYnVzX2Vycm9yX2lzX3NldCAoJmVycm9yKSkgeworCQlkZWJ1ZyAo IkNvbnNvbGVLaXQ6ICVzIHJhaXNlZDpcbiAlc1xuXG4iLCBlcnJvci5uYW1lLCBlcnJvci5tZXNz YWdlKTsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKHJlcGx5ID09IE5VTEwpIHsKKwkJZGVidWcg KCJDb25zb2xlS2l0OiBObyByZXBseSBmb3IgR2V0U2Vzc2lvbnNGb3JVc2VyIik7CisJCWdvdG8g b3V0OworCX0KKworCWRidXNfbWVzc2FnZV9pdGVyX2luaXQgKHJlcGx5LCAmaXRlcl9yZXBseSk7 CisJaWYgKGRidXNfbWVzc2FnZV9pdGVyX2dldF9hcmdfdHlwZSAoJml0ZXJfcmVwbHkpICE9IERC VVNfVFlQRV9BUlJBWSkgeworCQlkZWJ1ZyAoIkNvbnNvbGVLaXQ6IFdyb25nIHJlcGx5IGZvciBH ZXRTZXNzaW9uc0ZvclVzZXIgLSBleHBlY3RpbmcgYW4gYXJyYXkuIik7CisJCWdvdG8gb3V0Owor CX0KKworCWRidXNfbWVzc2FnZV9pdGVyX3JlY3Vyc2UgKCZpdGVyX3JlcGx5LCAmaXRlcl9hcnJh eSk7CisJc2Vzc2lvbnMgPSBnZXRfcGF0aF9hcnJheV9mcm9tX2l0ZXIgKCZpdGVyX2FycmF5LCBO VUxMKTsKKworIG91dDoKKwlpZiAobWVzc2FnZSAhPSBOVUxMKSB7CisJCWRidXNfbWVzc2FnZV91 bnJlZiAobWVzc2FnZSk7CisJfQorCWlmIChyZXBseSAhPSBOVUxMKSB7CisJCWRidXNfbWVzc2Fn ZV91bnJlZiAocmVwbHkpOworCX0KKworCXJldHVybiBzZXNzaW9uczsKK30KKwordm9pZAordW5s b2NrX2NrX3Nlc3Npb24gKGNvbnN0IGNoYXIgKnVzZXIsCisJCSAgIGNvbnN0IGNoYXIgKngxMV9k aXNwbGF5KQoreworCURCdXNFcnJvciAgICAgICBlcnJvcjsKKwlEQnVzQ29ubmVjdGlvbiAqY29u bmVjdGlvbjsKKwljaGFyICAgICAgICAgICAqKnNlc3Npb25zOworCWludCAgICAgICAgICAgICAg aTsKKworCWRlYnVnICgiQ29uc29sZUtpdDogVW5sb2NraW5nIHNlc3Npb24gZm9yICVzIG9uICVz IiwgdXNlciwgeDExX2Rpc3BsYXkpOworCisJZGJ1c19lcnJvcl9pbml0ICgmZXJyb3IpOworCWNv bm5lY3Rpb24gPSBkYnVzX2J1c19nZXQgKERCVVNfQlVTX1NZU1RFTSwgJmVycm9yKTsKKwlpZiAo Y29ubmVjdGlvbiA9PSBOVUxMKSB7CisJCWRlYnVnICgiQ29uc29sZUtpdDogRmFpbGVkIHRvIGNv bm5lY3QgdG8gdGhlIEQtQnVzIGRhZW1vbjogJXMiLCBlcnJvci5tZXNzYWdlKTsKKwkJZGJ1c19l cnJvcl9mcmVlICgmZXJyb3IpOworCQlyZXR1cm47CisJfQorCisJc2Vzc2lvbnMgPSBnZXRfc2Vz c2lvbnNfZm9yX3VzZXIgKGNvbm5lY3Rpb24sIHVzZXIsIHgxMV9kaXNwbGF5KTsKKwlpZiAoc2Vz c2lvbnMgPT0gTlVMTCB8fCBzZXNzaW9uc1swXSA9PSBOVUxMKSB7CisJCWRlYnVnICgiQ29uc29s ZUtpdDogbm8gc2Vzc2lvbnMgZm91bmQiKTsKKwkJcmV0dXJuOworCX0KKworCWZvciAoaSA9IDA7 IHNlc3Npb25zW2ldICE9IE5VTEw7IGkrKykgeworCQljaGFyICpzc2lkOworCQljaGFyICp4ZGlz cGxheTsKKworCQlzc2lkID0gc2Vzc2lvbnNbaV07CisJCXNlc3Npb25fZ2V0X3gxMV9kaXNwbGF5 IChjb25uZWN0aW9uLCBzc2lkLCAmeGRpc3BsYXkpOworCQlkZWJ1ZyAoIkNvbnNvbGVLaXQ6IHNl c3Npb24gJXMgaGFzIERJU1BMQVkgJXMiLCBzc2lkLCB4ZGlzcGxheSk7CisKKwkJaWYgKHhkaXNw bGF5ICE9IE5VTEwKKwkJICAgICYmIHgxMV9kaXNwbGF5ICE9IE5VTEwKKwkJICAgICYmIHN0cmNt cCAoeGRpc3BsYXksIHgxMV9kaXNwbGF5KSA9PSAwKSB7CisJCQlpbnQgcmVzOworCisJCQlyZXMg PSBzZXNzaW9uX3VubG9jayAoY29ubmVjdGlvbiwgc3NpZCk7CisJCQlpZiAoISByZXMpIHsKKwkJ CQlsb2dFcnJvciAoIkNvbnNvbGVLaXQ6IFVuYWJsZSB0byB1bmxvY2sgJXMiLCBzc2lkKTsKKwkJ CX0KKwkJfQorCisJCWZyZWUgKHhkaXNwbGF5KTsKKwl9CisKKwlmcmVlU3RyQXJyIChzZXNzaW9u cyk7Cit9CisKK2NoYXIgKgorb3Blbl9ja19zZXNzaW9uIChzdHJ1Y3QgcGFzc3dkICpwd2VudCwK KwkJIHN0cnVjdCBkaXNwbGF5ICpkKQoreworCURCdXNDb25uZWN0aW9uICpjb25uZWN0aW9uOwor CURCdXNFcnJvciAgICAgICBlcnJvcjsKKwlEQnVzTWVzc2FnZSAgICAqbWVzc2FnZTsKKwlEQnVz TWVzc2FnZSAgICAqcmVwbHk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXI7CisJREJ1c01lc3NhZ2VJ dGVyIGl0ZXJfc3RydWN0OworCWNoYXIJICAgICAgICpjb29raWU7CisKKwljb29raWUgPSBOVUxM OworCisJZGVidWcgKCJDb25zb2xlS2l0OiBPcGVuaW5nIHNlc3Npb24gZm9yICVzIiwgcHdlbnQt PnB3X25hbWUpOworCisJZGJ1c19lcnJvcl9pbml0ICgmZXJyb3IpOworCWNvbm5lY3Rpb24gPSBk YnVzX2J1c19nZXRfcHJpdmF0ZSAoREJVU19CVVNfU1lTVEVNLCAmZXJyb3IpOworCXByaXZhdGVf Y29ubmVjdGlvbiA9IGNvbm5lY3Rpb247CisKKwlpZiAoY29ubmVjdGlvbiA9PSBOVUxMKSB7CisJ CWRlYnVnICgiQ29uc29sZUtpdDogRmFpbGVkIHRvIGNvbm5lY3QgdG8gdGhlIEQtQnVzIGRhZW1v bjogJXMiLCBlcnJvci5tZXNzYWdlKTsKKwkJZGJ1c19lcnJvcl9mcmVlICgmZXJyb3IpOworCQly ZXR1cm4gTlVMTDsKKwl9CisKKwlkYnVzX2Nvbm5lY3Rpb25fc2V0X2V4aXRfb25fZGlzY29ubmVj dCAoY29ubmVjdGlvbiwgRkFMU0UpOworCS8qIE5vIG1haW5sb29wIGludGVncmF0aW9uIG5lZWRl ZCBmb3IgRC1CdXMgYmVjYXVzZSBvbmx5IGJsb2NraW5nIGNhbGxzIGFyZSB1c2VkLiAqLworCisJ ZGJ1c19lcnJvcl9pbml0ICgmZXJyb3IpOworCW1lc3NhZ2UgPSBkYnVzX21lc3NhZ2VfbmV3X21l dGhvZF9jYWxsIChDS19OQU1FLAorCQkJCQkJQ0tfTUFOQUdFUl9QQVRILAorCQkJCQkJQ0tfTUFO QUdFUl9JTlRFUkZBQ0UsCisJCQkJCQkiT3BlblNlc3Npb25XaXRoUGFyYW1ldGVycyIpOworCWlm IChtZXNzYWdlID09IE5VTEwpIHsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiBDb3VsZG4ndCBhbGxv Y2F0ZSB0aGUgRC1CdXMgbWVzc2FnZSIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlkYnVzX21l c3NhZ2VfaXRlcl9pbml0X2FwcGVuZCAobWVzc2FnZSwgJml0ZXIpOworCWRidXNfbWVzc2FnZV9p dGVyX29wZW5fY29udGFpbmVyICgmaXRlciwKKwkJCQkJICBEQlVTX1RZUEVfQVJSQVksCisJCQkJ CSAgREJVU19TVFJVQ1RfQkVHSU5fQ0hBUl9BU19TVFJJTkcKKwkJCQkJICBEQlVTX1RZUEVfU1RS SU5HX0FTX1NUUklORworCQkJCQkgIERCVVNfVFlQRV9WQVJJQU5UX0FTX1NUUklORworCQkJCQkg IERCVVNfU1RSVUNUX0VORF9DSEFSX0FTX1NUUklORywKKwkJCQkJICAmaXRlcl9zdHJ1Y3QpOwor CisJYWRkX3BhcmFtX2ludCAoJml0ZXJfc3RydWN0LCAidXNlciIsIHB3ZW50LT5wd191aWQpOwor CWFkZF9wYXJhbV9zdHJpbmcgKCZpdGVyX3N0cnVjdCwgIngxMS1kaXNwbGF5IiwgZC0+bmFtZSk7 CisJYWRkX3BhcmFtX2Jvb2xlYW4gKCZpdGVyX3N0cnVjdCwgImlzLWxvY2FsIiwgKChkLT5kaXNw bGF5VHlwZSAmIGRfbG9jYXRpb24pID09IGRMb2NhbCkpOworI2lmZGVmIFhETUNQCisJaWYgKChk LT5kaXNwbGF5VHlwZSAmIGRfbG9jYXRpb24pICE9IGRMb2NhbCkgeworCQlhZGRfcGFyYW1fc3Ry aW5nICgmaXRlcl9zdHJ1Y3QsICJyZW1vdGUtaG9zdC1uYW1lIiwgZC0+cmVtb3RlSG9zdCk7CisJ fQorI2VuZGlmCisKKyNpZmRlZiBIQVZFX1ZUUworCWlmIChkLT5zZXJ2ZXJWVCA+IDApIHsKKwkJ Y2hhciBkZXZpY2VbMjBdOworCisJCS8qIEZJWE1FOiBob3cgZG9lcyB4b3JnIGNvbnN0cnVjdCB0 aGlzICovCisJCXNwcmludGYoZGV2aWNlLCAiL2Rldi90dHklZCIsIGQtPnNlcnZlclZUKTsKKwkJ YWRkX3BhcmFtX3N0cmluZyAoJml0ZXJfc3RydWN0LCAieDExLWRpc3BsYXktZGV2aWNlIiwgZGV2 aWNlKTsKKwl9CisjZW5kaWYKKworCWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lciAo Jml0ZXIsICZpdGVyX3N0cnVjdCk7CisKKwlyZXBseSA9IGRidXNfY29ubmVjdGlvbl9zZW5kX3dp dGhfcmVwbHlfYW5kX2Jsb2NrIChjb25uZWN0aW9uLAorCQkJCQkJCSAgIG1lc3NhZ2UsCisJCQkJ CQkJICAgLTEsICZlcnJvcik7CisJaWYgKGRidXNfZXJyb3JfaXNfc2V0ICgmZXJyb3IpKSB7CisJ CWRlYnVnICgiQ29uc29sZUtpdDogJXMgcmFpc2VkOlxuICVzXG5cbiIsIGVycm9yLm5hbWUsIGVy cm9yLm1lc3NhZ2UpOworCQlyZXBseSA9IE5VTEw7CisJfQorCisJZGJ1c19jb25uZWN0aW9uX2Zs dXNoIChjb25uZWN0aW9uKTsKKworCWRidXNfbWVzc2FnZV91bnJlZiAobWVzc2FnZSk7CisJZGJ1 c19lcnJvcl9mcmVlICgmZXJyb3IpOworCisJaWYgKHJlcGx5ICE9IE5VTEwpIHsKKwkJY29uc3Qg Y2hhciAqdmFsdWU7CisKKwkJZGJ1c19tZXNzYWdlX2l0ZXJfaW5pdCAocmVwbHksICZpdGVyKTsK KwkJZGJ1c19tZXNzYWdlX2l0ZXJfZ2V0X2Jhc2ljICgmaXRlciwgJnZhbHVlKTsKKwkJY29va2ll ID0gc3RyZHVwICh2YWx1ZSk7CisJCWRidXNfbWVzc2FnZV91bnJlZiAocmVwbHkpOworCX0KKwor CXJldHVybiBjb29raWU7Cit9CisKK3ZvaWQKK2Nsb3NlX2NrX3Nlc3Npb24gKGNvbnN0IGNoYXIg KmNvb2tpZSkKK3sKKwlEQnVzRXJyb3IgICAgICAgZXJyb3I7CisJREJ1c01lc3NhZ2UgICAgKm1l c3NhZ2U7CisJREJ1c01lc3NhZ2UgICAgKnJlcGx5OworCURCdXNNZXNzYWdlSXRlciBpdGVyOwor CisJaWYgKGNvb2tpZSA9PSBOVUxMKSB7CisJCXJldHVybjsKKwl9CisKKwlpZiAocHJpdmF0ZV9j b25uZWN0aW9uID09IE5VTEwpIHsKKwkJcmV0dXJuOworCX0KKworCWRidXNfZXJyb3JfaW5pdCAo JmVycm9yKTsKKwltZXNzYWdlID0gZGJ1c19tZXNzYWdlX25ld19tZXRob2RfY2FsbCAoQ0tfTkFN RSwKKwkJCQkJCUNLX01BTkFHRVJfUEFUSCwKKwkJCQkJCUNLX01BTkFHRVJfSU5URVJGQUNFLAor CQkJCQkJIkNsb3NlU2Vzc2lvbiIpOworCWlmIChtZXNzYWdlID09IE5VTEwpIHsKKwkJZGVidWcg KCJDb25zb2xlS2l0OiBDb3VsZG4ndCBhbGxvY2F0ZSB0aGUgRC1CdXMgbWVzc2FnZSIpOworCQly ZXR1cm47CisJfQorCisJZGJ1c19tZXNzYWdlX2l0ZXJfaW5pdF9hcHBlbmQgKG1lc3NhZ2UsICZp dGVyKTsKKwlkYnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMgKCZpdGVyLAorCQkJCQlEQlVT X1RZUEVfU1RSSU5HLAorCQkJCQkmY29va2llKTsKKworCXJlcGx5ID0gZGJ1c19jb25uZWN0aW9u X3NlbmRfd2l0aF9yZXBseV9hbmRfYmxvY2sgKHByaXZhdGVfY29ubmVjdGlvbiwKKwkJCQkJCQkg ICBtZXNzYWdlLAorCQkJCQkJCSAgIC0xLCAmZXJyb3IpOworCWlmIChkYnVzX2Vycm9yX2lzX3Nl dCAoJmVycm9yKSkgeworCQlkZWJ1ZyAoIkNvbnNvbGVLaXQ6ICVzIHJhaXNlZDpcbiAlc1xuXG4i LCBlcnJvci5uYW1lLCBlcnJvci5tZXNzYWdlKTsKKwkJcmVwbHkgPSBOVUxMOworCX0KKworCWRi dXNfY29ubmVjdGlvbl9mbHVzaCAocHJpdmF0ZV9jb25uZWN0aW9uKTsKKworCWRidXNfbWVzc2Fn ZV91bnJlZiAobWVzc2FnZSk7CisJZGJ1c19lcnJvcl9mcmVlICgmZXJyb3IpOworCisgICAgICAg IGRidXNfY29ubmVjdGlvbl9jbG9zZSAocHJpdmF0ZV9jb25uZWN0aW9uKTsKKwlwcml2YXRlX2Nv bm5lY3Rpb24gPSBOVUxMOworfQpkaWZmIC1OdXIga2RlYmFzZS0zLjkxLjAvd29ya3NwYWNlL2tk bS9iYWNrZW5kL2NvbnNvbGVraXQuaCBrZGViYXNlLTMuOTEuMC1jb25zb2xla2l0L3dvcmtzcGFj ZS9rZG0vYmFja2VuZC9jb25zb2xla2l0LmgKLS0tIGtkZWJhc2UtMy45MS4wL3dvcmtzcGFjZS9r ZG0vYmFja2VuZC9jb25zb2xla2l0LmgJMTk3MC0wMS0wMSAwMTowMDowMC4wMDAwMDAwMDAgKzAx MDAKKysrIGtkZWJhc2UtMy45MS4wLWNvbnNvbGVraXQvd29ya3NwYWNlL2tkbS9iYWNrZW5kL2Nv bnNvbGVraXQuaAkyMDA3LTA3LTA0IDA2OjI3OjI3LjAwMDAwMDAwMCArMDIwMApAQCAtMCwwICsx LDM2IEBACisvKiAtKi0gTW9kZTogQzsgdGFiLXdpZHRoOiA4OyBpbmRlbnQtdGFicy1tb2RlOiB0 OyBjLWJhc2ljLW9mZnNldDogOCAtKi0KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgV2lsbGlh bSBKb24gTWNDYW5uIDxtY2Nhbm5Aamh1LmVkdT4KKyAqIENvcHlyaWdodCAoQykgMjAwNyBLZXZp biBLb2ZsZXIgPEtldmluQHRpZ2NjLnRpY2FsYy5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAq IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVy c2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIg dmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUg dGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0 aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3Ig RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2 ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBh bG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2Fy ZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0 b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8KKworCisjaWZuZGVmIF9fQ09OU09MRV9L SVRfSAorI2RlZmluZSBfX0NPTlNPTEVfS0lUX0gKKworI2luY2x1ZGUgPHB3ZC5oPgorCitzdHJ1 Y3QgZGlzcGxheTsKKworY2hhciAqICAgICAgb3Blbl9ja19zZXNzaW9uICAgICAgIChzdHJ1Y3Qg cGFzc3dkICpwd2VudCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0 IGRpc3BsYXkgKmRpc3BsYXkpOwordm9pZCAgICAgICAgY2xvc2VfY2tfc2Vzc2lvbiAgICAgIChj b25zdCBjaGFyICAgICpjb29raWUpOwordm9pZCAgICAgICAgdW5sb2NrX2NrX3Nlc3Npb24gICAg IChjb25zdCBjaGFyICAgICp1c2VyLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBjb25zdCBjaGFyICAgICp4MTFfZGlzcGxheSk7CisKKyNlbmRpZiAvKiBfX0NPTlNPTEVfS0lU X0ggKi8KZGlmZiAtTnVyIGtkZWJhc2UtMy45MS4wL3dvcmtzcGFjZS9rZG0vYmFja2VuZC9kbS5o IGtkZWJhc2UtMy45MS4wLWNvbnNvbGVraXQvd29ya3NwYWNlL2tkbS9iYWNrZW5kL2RtLmgKLS0t IGtkZWJhc2UtMy45MS4wL3dvcmtzcGFjZS9rZG0vYmFja2VuZC9kbS5oCTIwMDctMDYtMjcgMTI6 NDY6MDQuMDAwMDAwMDAwICswMjAwCisrKyBrZGViYXNlLTMuOTEuMC1jb25zb2xla2l0L3dvcmtz cGFjZS9rZG0vYmFja2VuZC9kbS5oCTIwMDctMDctMDQgMDc6MzM6NDEuMDAwMDAwMDAwICswMjAw CkBAIC0zNyw2ICszNyw4IEBACiAjaWZuZGVmIF9ETV9IXwogI2RlZmluZSBfRE1fSF8gMQogCisj ZGVmaW5lIFdJVEhfQ09OU09MRV9LSVQKKwogI2luY2x1ZGUgImdyZWV0LmgiCiAjaW5jbHVkZSA8 Y29uZmlnLmNpPgogCkBAIC00NzMsNyArNDc1LDExIEBACiAjZGVmaW5lIEdDT05WX0JJTkFSWSAg NQogdHlwZWRlZiBjaGFyICooKkdDb252RnVuYykoIGludCB3aGF0LCBjb25zdCBjaGFyICpwcm9t cHQgKTsKIGludCB2ZXJpZnkoIEdDb252RnVuYyBnY29udiwgaW50IHJvb3RvayApOworI2lmZGVm IFdJVEhfQ09OU09MRV9LSVQKK2ludCBzdGFydENsaWVudCggdm9sYXRpbGUgaW50ICpwaWQsICBj b25zdCBjaGFyICpja19zZXNzaW9uX2Nvb2tpZSApOworI2Vsc2UKIGludCBzdGFydENsaWVudCgg dm9sYXRpbGUgaW50ICpwaWQgKTsKKyNlbmRpZgogdm9pZCBzZXNzaW9uRXhpdCggaW50IHN0YXR1 cyApIEFUVFJfTk9SRVRVUk47CiBpbnQgcmVhZERtcmMoIHZvaWQgKTsKIGV4dGVybiBjaGFyICoq dXNlckVudmlyb24sICoqc3lzdGVtRW52aXJvbjsKZGlmZiAtTnVyIGtkZWJhc2UtMy45MS4wL3dv cmtzcGFjZS9rZG0vYmFja2VuZC9JbWFrZWZpbGUga2RlYmFzZS0zLjkxLjAtY29uc29sZWtpdC93 b3Jrc3BhY2Uva2RtL2JhY2tlbmQvSW1ha2VmaWxlCi0tLSBrZGViYXNlLTMuOTEuMC93b3Jrc3Bh Y2Uva2RtL2JhY2tlbmQvSW1ha2VmaWxlCTIwMDYtMTAtMjYgMDQ6MTI6MzguMDAwMDAwMDAwICsw MjAwCisrKyBrZGViYXNlLTMuOTEuMC1jb25zb2xla2l0L3dvcmtzcGFjZS9rZG0vYmFja2VuZC9J bWFrZWZpbGUJMjAwNy0wNy0wNCAwNjoyNzoyNy4wMDAwMDAwMDAgKzAyMDAKQEAgLTE1NSwxMyAr MTU1LDEzIEBACiAJCSBuZXRhZGRyLmMgcmVzZXQuYyByZXNvdXJjZS5jIHByb3RvZHB5LmMgcG9s aWN5LmMgXAogCQkgc2Vzc2lvbi5jIHNvY2tldC5jIHN0cmVhbXMuYyB1dGlsLmMgeGRtY3AuYyBc CiAJCSBwcm9jZXNzLmMgbWl0YXV0aC5jIFwKLQkJIGdlbmF1dGguYyBhY2Nlc3MuYyBjaG9vc2Uu YyBcCisJCSBnZW5hdXRoLmMgYWNjZXNzLmMgY2hvb3NlLmMgY29uc29sZWtpdC5jIFwKIAkJICQo WERNQVVUSFNSQ1MpICQoUlBDU1JDUykgJChLUkI1U1JDUykKICAgICAgIENPTU1PQkpTID0gYXV0 aC5vIGRhZW1vbi5vIHNlcnZlci5vIGRweWxpc3QubyBkbS5vIGVycm9yLm8gXAogCQkgbmV0YWRk ci5vIHJlc2V0Lm8gcmVzb3VyY2UubyBwcm90b2RweS5vIHBvbGljeS5vIFwKIAkJIHNlc3Npb24u byBzb2NrZXQubyBzdHJlYW1zLm8gdXRpbC5vIHhkbWNwLm8gXAogCQkgcHJvY2Vzcy5vIG1pdGF1 dGgubyBcCi0JCSBnZW5hdXRoLm8gYWNjZXNzLm8gY2hvb3NlLm8gXAorCQkgZ2VuYXV0aC5vIGFj Y2Vzcy5vIGNob29zZS5vIGNvbnNvbGVraXQubyBcCiAJCSAkKFhETUFVVEhPQkpTKSAkKFJQQ09C SlMpICQoS1JCNU9CSlMpCiAKICAgICAgICAgIFNSQ1MxID0gJChDT01NU1JDUykgY2xpZW50LmMK ZGlmZiAtTnVyIGtkZWJhc2UtMy45MS4wL3dvcmtzcGFjZS9rZG0vYmFja2VuZC9zZXNzaW9uLmMg a2RlYmFzZS0zLjkxLjAtY29uc29sZWtpdC93b3Jrc3BhY2Uva2RtL2JhY2tlbmQvc2Vzc2lvbi5j Ci0tLSBrZGViYXNlLTMuOTEuMC93b3Jrc3BhY2Uva2RtL2JhY2tlbmQvc2Vzc2lvbi5jCTIwMDct MDYtMjcgMTI6NDY6MDQuMDAwMDAwMDAwICswMjAwCisrKyBrZGViYXNlLTMuOTEuMC1jb25zb2xl a2l0L3dvcmtzcGFjZS9rZG0vYmFja2VuZC9zZXNzaW9uLmMJMjAwNy0wNy0wNCAwNzozODowNy4w MDAwMDAwMDAgKzAyMDAKQEAgLTQ1LDYgKzQ1LDEwIEBACiAjaW5jbHVkZSA8Y3R5cGUuaD4KICNp bmNsdWRlIDxzaWduYWwuaD4KIAorI2lmZGVmIFdJVEhfQ09OU09MRV9LSVQKKyNpbmNsdWRlICJj b25zb2xla2l0LmgiCisjZW5kaWYKKwogc3RydWN0IGRpc3BsYXkgKnRkOwogY29uc3QgY2hhciAq dGRfc2V0dXAgPSAiYXV0byI7CiAKQEAgLTUyMiw2ICs1MjYsOSBAQAogCWludCBleCwgY21kOwog CXZvbGF0aWxlIGludCBjbGllbnRQaWQgPSAtMTsKIAl2b2xhdGlsZSB0aW1lX3QgdGRpZmY7Cisj aWZkZWYgV0lUSF9DT05TT0xFX0tJVAorCWNoYXIgKmNrX3Nlc3Npb25fY29va2llOworI2VuZGlm CiAKIAl0ZCA9IGQ7CiAJZGVidWcoICJtYW5hZ2VTZXNzaW9uICVzXG4iLCBkLT5uYW1lICk7CkBA IC02MTcsNyArNjI0LDEyIEBACiAJaWYgKHRkX3NldHVwKQogCQlzZXR1cERpc3BsYXkoIHRkX3Nl dHVwICk7CiAKKyNpZmRlZiBXSVRIX0NPTlNPTEVfS0lUCisJY2tfc2Vzc2lvbl9jb29raWUgPSBv cGVuX2NrX3Nlc3Npb24gKGdldHB3bmFtKGN1cnVzZXIpLCBkKTsKKwlpZiAoIXN0YXJ0Q2xpZW50 KCAmY2xpZW50UGlkLCBja19zZXNzaW9uX2Nvb2tpZSApKSB7CisjZWxzZQogCWlmICghc3RhcnRD bGllbnQoICZjbGllbnRQaWQgKSkgeworI2VuZGlmCiAJCWxvZ0Vycm9yKCAiQ2xpZW50IHN0YXJ0 IGZhaWxlZFxuIiApOwogCQlzZXNzaW9uRXhpdCggRVhfTk9STUFMICk7IC8qIFhYWCBtYXliZSBF WF9SRU1BTkFHRV9EUFk/IC0tIGVuYWJsZSBpbiBkbS5jISAqLwogCX0KQEAgLTYzOSw2ICs2NTEs MTQgQEAKIAkJCQljYXRjaFRlcm0oIFNJR1RFUk0gKTsKIAkJfQogCX0KKworI2lmZGVmIFdJVEhf Q09OU09MRV9LSVQKKwlpZiAoY2tfc2Vzc2lvbl9jb29raWUgIT0gTlVMTCkgeworCQljbG9zZV9j a19zZXNzaW9uIChja19zZXNzaW9uX2Nvb2tpZSk7CisJCWZyZWUgKGNrX3Nlc3Npb25fY29va2ll KTsKKwl9CisjZW5kaWYKKwogCS8qCiAJICogU29tZXRpbWVzIHRoZSBYc2Vzc2lvbiBzb21laG93 IG1hbmFnZXMgdG8gZXhpdCBiZWZvcmUKIAkgKiBhIHNlcnZlciBjcmFzaCBpcyBub3RpY2VkIC0g c28gd2Ugc2xlZXAgYSBiaXQgYW5kIHdhaXQK 22250 2007-11-29 19:42:54 +0000 2008-01-14 17:09:35 +0000 Updated consolekit-kdm patch kdebase-workspace-3.96.1-consolekit-kdm.patch text/plain 23096 kevin.kofler ZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTMuOTYuMS9jbWFrZS9tb2R1bGVzL0ZpbmREQnVz LmNtYWtlIGtkZWJhc2Utd29ya3NwYWNlLTMuOTYuMS1jb25zb2xla2l0LWtkbS9jbWFrZS9tb2R1 bGVzL0ZpbmREQnVzLmNtYWtlCi0tLSBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEvY21ha2UvbW9k dWxlcy9GaW5kREJ1cy5jbWFrZQkxOTcwLTAxLTAxIDAxOjAwOjAwLjAwMDAwMDAwMCArMDEwMAor Kysga2RlYmFzZS13b3Jrc3BhY2UtMy45Ni4xLWNvbnNvbGVraXQta2RtL2NtYWtlL21vZHVsZXMv RmluZERCdXMuY21ha2UJMjAwNy0xMS0yOSAxOToxOToxNC4wMDAwMDAwMDAgKzAxMDAKQEAgLTAs MCArMSwzOSBAQAorCitpZihEQlVTX0lOQ0xVREVfRElSIEFORCBEQlVTX0xJQlJBUlkgQU5EIERC VVNfQVJDSF9JTkNMVURFX0RJUikKKwkjIEFscmVhZHkgaW4gY2FjaGUsIGJlIHNpbGVudAorCXNl dChEQlVTX0ZJTkRfUVVJRVRMWSBUUlVFKQkKK2VuZGlmKERCVVNfSU5DTFVERV9ESVIgQU5EIERC VVNfTElCUkFSWSBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSKQorCitzZXQoREJVU19MSUJSQVJZ KQorc2V0KERCVVNfSU5DTFVERV9ESVIpCitzZXQoREJVU19BUkNIX0lOQ0xVREVfRElSKQorCitG SU5EX1BBVEgoREJVU19JTkNMVURFX0RJUiBkYnVzL2RidXMuaAorCS91c3IvaW5jbHVkZQorCS91 c3IvaW5jbHVkZS9kYnVzLTEuMAorCS91c3IvbG9jYWwvaW5jbHVkZQorKQorCitGSU5EX1BBVEgo REJVU19BUkNIX0lOQ0xVREVfRElSIGRidXMvZGJ1cy1hcmNoLWRlcHMuaAorCS91c3IvbGliJHtM SUJfU1VGRklYfS9pbmNsdWRlCisJL3Vzci9saWIke0xJQl9TVUZGSVh9L2RidXMtMS4wL2luY2x1 ZGUKKwkvdXNyL2xpYjY0L2luY2x1ZGUKKwkvdXNyL2xpYjY0L2RidXMtMS4wL2luY2x1ZGUKKwkv dXNyL2xpYi9pbmNsdWRlCisJL3Vzci9saWIvZGJ1cy0xLjAvaW5jbHVkZQorKQorCitGSU5EX0xJ QlJBUlkoREJVU19MSUJSQVJZIE5BTUVTIGRidXMtMSBkYnVzCisJUEFUSFMKKwkvdXNyL2xpYgor CS91c3IvbG9jYWwvbGliCispCisKK2lmKERCVVNfSU5DTFVERV9ESVIgQU5EIERCVVNfTElCUkFS WSBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSKQorICAgTUVTU0FHRSggU1RBVFVTICJkYnVzIGZv dW5kOiBpbmNsdWRlcyBpbiAke0RCVVNfSU5DTFVERV9ESVJ9LCBsaWJyYXJ5IGluICR7REJVU19M SUJSQVJZfSIpCisgICBzZXQoREJVU19GT1VORCBUUlVFKQorZWxzZShEQlVTX0lOQ0xVREVfRElS IEFORCBEQlVTX0xJQlJBUlkgQU5EIERCVVNfQVJDSF9JTkNMVURFX0RJUikKKyAgIE1FU1NBR0Uo IFNUQVRVUyAiZGJ1cyBub3QgZm91bmQiKQorZW5kaWYoREJVU19JTkNMVURFX0RJUiBBTkQgREJV U19MSUJSQVJZIEFORCBEQlVTX0FSQ0hfSU5DTFVERV9ESVIpCisKK01BUktfQVNfQURWQU5DRUQo REJVU19JTkNMVURFX0RJUiBEQlVTX0xJQlJBUlkgREJVU19BUkNIX0lOQ0xVREVfRElSKQpkaWZm IC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtMy45Ni4xL2tkbS9iYWNrZW5kL2NsaWVudC5jIGtkZWJh c2Utd29ya3NwYWNlLTMuOTYuMS1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9jbGllbnQuYwot LS0ga2RlYmFzZS13b3Jrc3BhY2UtMy45Ni4xL2tkbS9iYWNrZW5kL2NsaWVudC5jCTIwMDctMTEt MTQgMDA6NTU6MzIuMDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEt Y29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQvY2xpZW50LmMJMjAwNy0xMS0yOSAxOToxOToxNC4w MDAwMDAwMDAgKzAxMDAKQEAgLTgxLDYgKzgxLDEwIEBACiAjIGluY2x1ZGUgPHNoYWRvdy5oPgog I2VuZGlmCiAKKyNpZmRlZiBXSVRIX0NPTlNPTEVfS0lUCisjaW5jbHVkZSAiY29uc29sZWtpdC5o IgorI2VuZGlmCisKIC8qCiAgKiBTZXNzaW9uIGRhdGEsIG1vc3RseSB3aGF0IHN0cnVjdCB2ZXJp ZnlfaW5mbyB3YXMgZm9yCiAgKi8KQEAgLTExNDgsOCArMTE1MiwxMyBAQAogfQogKi8KIAorI2lm ZGVmIFdJVEhfQ09OU09MRV9LSVQKK2ludAorc3RhcnRDbGllbnQoIHZvbGF0aWxlIGludCAqcGlk LCBjb25zdCBjaGFyICpja19zZXNzaW9uX2Nvb2tpZSApCisjZWxzZQogaW50CiBzdGFydENsaWVu dCggdm9sYXRpbGUgaW50ICpwaWQgKQorI2VuZGlmCiB7CiAJY29uc3QgY2hhciAqaG9tZSwgKnNl c3NhcmdzLCAqZGVza3Nlc3M7CiAJY2hhciAqKmVudiwgKnhtYTsKQEAgLTEyMzksNiArMTI0OCwx MSBAQAogCWlmIChrcmJ0a2ZpbGVbMF0gIT0gJ1wwJykKIAkJZW52ID0gc2V0RW52KCBlbnYsICJL UkJUS0ZJTEUiLCBrcmJ0a2ZpbGUgKTsKICNlbmRpZgorI2lmZGVmIFdJVEhfQ09OU09MRV9LSVQK KwlpZiAoY2tfc2Vzc2lvbl9jb29raWUgIT0gTlVMTCkgeworCQllbnYgPSBzZXRFbnYgKCBlbnYs ICJYREdfU0VTU0lPTl9DT09LSUUiLCBja19zZXNzaW9uX2Nvb2tpZSApOworCX0KKyNlbmRpZgog CXVzZXJFbnZpcm9uID0gaW5oZXJpdEVudiggZW52LCBlbnZ2YXJzICk7CiAJZW52ID0gc3lzdGVt RW52KCBjdXJ1c2VyICk7CiAJc3lzdGVtRW52aXJvbiA9IHNldEVudiggZW52LCAiSE9NRSIsIHAt PnB3X2RpciApOwpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtMy45Ni4xL2tkbS9iYWNrZW5k L0NNYWtlTGlzdHMudHh0IGtkZWJhc2Utd29ya3NwYWNlLTMuOTYuMS1jb25zb2xla2l0LWtkbS9r ZG0vYmFja2VuZC9DTWFrZUxpc3RzLnR4dAotLS0ga2RlYmFzZS13b3Jrc3BhY2UtMy45Ni4xL2tk bS9iYWNrZW5kL0NNYWtlTGlzdHMudHh0CTIwMDctMTAtMDMgMTM6MTM6MTMuMDAwMDAwMDAwICsw MjAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEtY29uc29sZWtpdC1rZG0va2RtL2JhY2tl bmQvQ01ha2VMaXN0cy50eHQJMjAwNy0xMS0yOSAxOToyMjoyNS4wMDAwMDAwMDAgKzAxMDAKQEAg LTEsMyArMSw0IEBACitmaW5kX3BhY2thZ2UoREJ1cyBSRVFVSVJFRCkKIHNldChrZG1fU1JDUwog CWdyZWV0LmgKIAlkbS5oCkBAIC04LDYgKzksNyBAQAogCWJvb3RtYW4uYwogCWNsaWVudC5jCiAJ Y3RybC5jCisJY29uc29sZWtpdC5jCiAJZGFlbW9uLmMKIAlkbS5jCiAJZHB5bGlzdC5jCkBAIC01 NCw2ICs1Niw3IEBACiBtYWNyb19hZGRfZmlsZV9kZXBlbmRlbmNpZXMoZXJyb3IuYyAke0NNQUtF X0NVUlJFTlRfU09VUkNFX0RJUn0vcHJpbnRmLmMpCiBrZGU0X2FkZF9leGVjdXRhYmxlKGtkbSBO T0dVSSAke2tkbV9TUkNTfSkKIG1hY3JvX2FkZF9jb21waWxlX2ZsYWdzKGtkbSAtVV9SRUVOVFJB TlQpCitpbmNsdWRlX2RpcmVjdG9yaWVzKCR7REJVU19JTkNMVURFX0RJUn0gJHtEQlVTX0FSQ0hf SU5DTFVERV9ESVJ9KQogdGFyZ2V0X2xpbmtfbGlicmFyaWVzKCBrZG0KIAkke1gxMV9MSUJSQVJJ RVN9CiAJJHtVTklYQVVUSF9MSUJSQVJJRVN9CkBAIC02Myw2ICs2Niw3IEBACiAJJHtLUkI1X0xJ QlJBUklFU30KIAkke1NPQ0tFVF9MSUJSQVJJRVN9CiAJJHtSRVNPTFZfTElCUkFSSUVTfQorCSR7 REJVU19MSUJSQVJZfQogKQogaWYoVVRJTF9MSUJSQVJJRVMpCiAJdGFyZ2V0X2xpbmtfbGlicmFy aWVzKCBrZG0gJHtVVElMX0xJQlJBUklFU30gKQpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2Ut My45Ni4xL2tkbS9iYWNrZW5kL2NvbnNvbGVraXQuYyBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEt Y29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQvY29uc29sZWtpdC5jCi0tLSBrZGViYXNlLXdvcmtz cGFjZS0zLjk2LjEva2RtL2JhY2tlbmQvY29uc29sZWtpdC5jCTE5NzAtMDEtMDEgMDE6MDA6MDAu MDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEtY29uc29sZWtpdC1r ZG0va2RtL2JhY2tlbmQvY29uc29sZWtpdC5jCTIwMDctMTEtMjkgMTk6MzE6NTAuMDAwMDAwMDAw ICswMTAwCkBAIC0wLDAgKzEsNTQ0IEBACisvKiAtKi0gTW9kZTogQzsgdGFiLXdpZHRoOiA4OyBp bmRlbnQtdGFicy1tb2RlOiB0OyBjLWJhc2ljLW9mZnNldDogOCAtKi0KKyAqCisgKiBDb3B5cmln aHQgKEMpIDIwMDYtMjAwNyBXaWxsaWFtIEpvbiBNY0Nhbm4gPG1jY2FubkBqaHUuZWR1PgorICog Q29weXJpZ2h0IChDKSAyMDA3IEtldmluIEtvZmxlciA8S2V2aW5AdGlnY2MudGljYWxjLm9yZz4K KyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAqIHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCisgKiAoYXQg eW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBk aXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YK KyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g IFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVy YWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdy aXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUg UGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyAqLwor CisjaW5jbHVkZSAiZG0uaCIKKyNpbmNsdWRlICJkbV9hdXRoLmgiCisjaW5jbHVkZSAiZG1fZXJy b3IuaCIKKworI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2luY2x1ZGUgPHN0cmluZy5oPgorI2luY2x1 ZGUgPHB3ZC5oPgorCisjZGVmaW5lIERCVVNfQVBJX1NVQkpFQ1RfVE9fQ0hBTkdFCisjaW5jbHVk ZSA8ZGJ1cy9kYnVzLmg+CisKKyNpbmNsdWRlICJjb25zb2xla2l0LmgiCisKKworI2RlZmluZSBD S19OQU1FICAgICAgICAgICAgICAib3JnLmZyZWVkZXNrdG9wLkNvbnNvbGVLaXQiCisjZGVmaW5l IENLX1BBVEggICAgICAgICAgICAgICIvb3JnL2ZyZWVkZXNrdG9wL0NvbnNvbGVLaXQiCisjZGVm aW5lIENLX0lOVEVSRkFDRSAgICAgICAgICJvcmcuZnJlZWRlc2t0b3AuQ29uc29sZUtpdCIKKyNk ZWZpbmUgQ0tfTUFOQUdFUl9QQVRIICAgICAgIi9vcmcvZnJlZWRlc2t0b3AvQ29uc29sZUtpdC9N YW5hZ2VyIgorI2RlZmluZSBDS19NQU5BR0VSX0lOVEVSRkFDRSAib3JnLmZyZWVkZXNrdG9wLkNv bnNvbGVLaXQuTWFuYWdlciIKKyNkZWZpbmUgQ0tfU0VTU0lPTl9JTlRFUkZBQ0UgIm9yZy5mcmVl ZGVza3RvcC5Db25zb2xlS2l0LlNlc3Npb24iCisKK3N0YXRpYyBEQnVzQ29ubmVjdGlvbiAqcHJp dmF0ZV9jb25uZWN0aW9uID0gTlVMTDsKKworc3RhdGljIHZvaWQKK2FkZF9wYXJhbV9pbnQgKERC dXNNZXNzYWdlSXRlciAqaXRlcl9zdHJ1Y3QsCisJICAgICAgIGNvbnN0IGNoYXIgICAgICAqa2V5 LAorCSAgICAgICBpbnQgICAgICAgICAgICAgIHZhbHVlKQoreworCURCdXNNZXNzYWdlSXRlciBp dGVyX3N0cnVjdF9lbnRyeTsKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcl92YXI7CisKKwlkYnVzX21l c3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5lciAoaXRlcl9zdHJ1Y3QsCisJCQkJCSAgREJVU19UWVBF X1NUUlVDVCwKKwkJCQkJICBOVUxMLAorCQkJCQkgICZpdGVyX3N0cnVjdF9lbnRyeSk7CisKKwlk YnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMgKCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJ REJVU19UWVBFX1NUUklORywKKwkJCQkJJmtleSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9vcGVu X2NvbnRhaW5lciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgIERCVVNfVFlQRV9WQVJJQU5U LAorCQkJCQkgIERCVVNfVFlQRV9JTlQzMl9BU19TVFJJTkcsCisJCQkJCSAgJml0ZXJfdmFyKTsK KworCWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXJfdmFyLAorCQkJCQlEQlVT X1RZUEVfSU5UMzIsCisJCQkJCSZ2YWx1ZSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9jbG9zZV9j b250YWluZXIgKCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJICAgJml0ZXJfdmFyKTsKKworCWRi dXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lciAoaXRlcl9zdHJ1Y3QsICZpdGVyX3N0cnVj dF9lbnRyeSk7Cit9CisKK3N0YXRpYyB2b2lkCithZGRfcGFyYW1fYm9vbGVhbiAoREJ1c01lc3Nh Z2VJdGVyICppdGVyX3N0cnVjdCwKKwkJICAgY29uc3QgY2hhciAgICAgICprZXksCisJCSAgIGlu dCAgICAgICAgICAgICB2YWx1ZSkKK3sKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcl9zdHJ1Y3RfZW50 cnk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXJfdmFyOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfb3Bl bl9jb250YWluZXIgKGl0ZXJfc3RydWN0LAorCQkJCQkgIERCVVNfVFlQRV9TVFJVQ1QsCisJCQkJ CSAgTlVMTCwKKwkJCQkJICAmaXRlcl9zdHJ1Y3RfZW50cnkpOworCisJZGJ1c19tZXNzYWdlX2l0 ZXJfYXBwZW5kX2Jhc2ljICgmaXRlcl9zdHJ1Y3RfZW50cnksCisJCQkJCURCVVNfVFlQRV9TVFJJ TkcsCisJCQkJCSZrZXkpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfb3Blbl9jb250YWluZXIgKCZp dGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJICBEQlVTX1RZUEVfVkFSSUFOVCwKKwkJCQkJICBEQlVT X1RZUEVfQk9PTEVBTl9BU19TVFJJTkcsCisJCQkJCSAgJml0ZXJfdmFyKTsKKworCWRidXNfbWVz c2FnZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXJfdmFyLAorCQkJCQlEQlVTX1RZUEVfQk9PTEVB TiwKKwkJCQkJJnZhbHVlKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lciAo Jml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgICAmaXRlcl92YXIpOworCisJZGJ1c19tZXNzYWdl X2l0ZXJfY2xvc2VfY29udGFpbmVyIChpdGVyX3N0cnVjdCwgJml0ZXJfc3RydWN0X2VudHJ5KTsK K30KKworc3RhdGljIHZvaWQKK2FkZF9wYXJhbV9zdHJpbmcgKERCdXNNZXNzYWdlSXRlciAqaXRl cl9zdHJ1Y3QsCisJCSAgY29uc3QgY2hhciAgICAgICprZXksCisJCSAgY29uc3QgY2hhciAgICAg ICp2YWx1ZSkKK3sKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcl9zdHJ1Y3RfZW50cnk7CisJREJ1c01l c3NhZ2VJdGVyIGl0ZXJfdmFyOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfb3Blbl9jb250YWluZXIg KGl0ZXJfc3RydWN0LAorCQkJCQkgIERCVVNfVFlQRV9TVFJVQ1QsCisJCQkJCSAgTlVMTCwKKwkJ CQkJICAmaXRlcl9zdHJ1Y3RfZW50cnkpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jh c2ljICgmaXRlcl9zdHJ1Y3RfZW50cnksCisJCQkJCURCVVNfVFlQRV9TVFJJTkcsCisJCQkJCSZr ZXkpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfb3Blbl9jb250YWluZXIgKCZpdGVyX3N0cnVjdF9l bnRyeSwKKwkJCQkJICBEQlVTX1RZUEVfVkFSSUFOVCwKKwkJCQkJICBEQlVTX1RZUEVfU1RSSU5H X0FTX1NUUklORywKKwkJCQkJICAmaXRlcl92YXIpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfYXBw ZW5kX2Jhc2ljICgmaXRlcl92YXIsCisJCQkJCURCVVNfVFlQRV9TVFJJTkcsCisJCQkJCSZ2YWx1 ZSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9jbG9zZV9jb250YWluZXIgKCZpdGVyX3N0cnVjdF9l bnRyeSwKKwkJCQkJICAgJml0ZXJfdmFyKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2Nv bnRhaW5lciAoaXRlcl9zdHJ1Y3QsICZpdGVyX3N0cnVjdF9lbnRyeSk7Cit9CisKK3N0YXRpYyBp bnQKK3Nlc3Npb25fZ2V0X3gxMV9kaXNwbGF5IChEQnVzQ29ubmVjdGlvbiAqY29ubmVjdGlvbiwK KwkJCSBjb25zdCBjaGFyICAgICAqc3NpZCwKKwkJCSBjaGFyICAgICAgICAgICoqc3RyKQorewor CURCdXNFcnJvciAgICAgICBlcnJvcjsKKwlEQnVzTWVzc2FnZSAgICAqbWVzc2FnZTsKKwlEQnVz TWVzc2FnZSAgICAqcmVwbHk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXI7CisJY29uc3QgY2hhciAg ICAgKnZhbHVlOworCisJaWYgKHN0ciAhPSBOVUxMKSB7CisJCSpzdHIgPSBOVUxMOworCX0KKwor CW1lc3NhZ2UgPSBkYnVzX21lc3NhZ2VfbmV3X21ldGhvZF9jYWxsIChDS19OQU1FLAorCQkJCQkJ c3NpZCwKKwkJCQkJCUNLX1NFU1NJT05fSU5URVJGQUNFLAorCQkJCQkJIkdldFgxMURpc3BsYXki KTsKKwlpZiAobWVzc2FnZSA9PSBOVUxMKSB7CisJCWRlYnVnICgiQ29uc29sZUtpdDogQ291bGRu J3QgYWxsb2NhdGUgdGhlIEQtQnVzIG1lc3NhZ2UiKTsKKwkJcmV0dXJuIEZBTFNFOworCX0KKwor CWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwlyZXBseSA9IGRidXNfY29ubmVjdGlvbl9zZW5k X3dpdGhfcmVwbHlfYW5kX2Jsb2NrIChjb25uZWN0aW9uLAorCQkJCQkJCSAgIG1lc3NhZ2UsCisJ CQkJCQkJICAgLTEsICZlcnJvcik7CisJaWYgKGRidXNfZXJyb3JfaXNfc2V0ICgmZXJyb3IpKSB7 CisJCWRlYnVnICgiQ29uc29sZUtpdDogJXMgcmFpc2VkOlxuICVzXG5cbiIsIGVycm9yLm5hbWUs IGVycm9yLm1lc3NhZ2UpOworCQlyZXBseSA9IE5VTEw7CisJfQorCisJZGJ1c19jb25uZWN0aW9u X2ZsdXNoIChjb25uZWN0aW9uKTsKKwlkYnVzX21lc3NhZ2VfdW5yZWYgKG1lc3NhZ2UpOworCisJ aWYgKHJlcGx5ID09IE5VTEwpIHsKKwkJcmV0dXJuIEZBTFNFOworCX0KKworCWRidXNfbWVzc2Fn ZV9pdGVyX2luaXQgKHJlcGx5LCAmaXRlcik7CisJZGJ1c19tZXNzYWdlX2l0ZXJfZ2V0X2Jhc2lj ICgmaXRlciwgJnZhbHVlKTsKKwlpZiAoc3RyICE9IE5VTEwpIHsKKwkJKnN0ciA9IHN0cmR1cCAo dmFsdWUpOworCX0KKwlkYnVzX21lc3NhZ2VfdW5yZWYgKHJlcGx5KTsKKworCXJldHVybiBUUlVF OworfQorCitzdGF0aWMgaW50CitzZXNzaW9uX3VubG9jayAoREJ1c0Nvbm5lY3Rpb24gKmNvbm5l Y3Rpb24sCisJCWNvbnN0IGNoYXIgICAgICpzc2lkKQoreworCURCdXNFcnJvciAgICAgICBlcnJv cjsKKwlEQnVzTWVzc2FnZSAgICAqbWVzc2FnZTsKKwlEQnVzTWVzc2FnZSAgICAqcmVwbHk7CisK KwlkZWJ1ZyAoIkNvbnNvbGVLaXQ6IFVubG9ja2luZyBzZXNzaW9uICVzIiwgc3NpZCk7CisJbWVz c2FnZSA9IGRidXNfbWVzc2FnZV9uZXdfbWV0aG9kX2NhbGwgKENLX05BTUUsCisJCQkJCQlzc2lk LAorCQkJCQkJQ0tfU0VTU0lPTl9JTlRFUkZBQ0UsCisJCQkJCQkiVW5sb2NrIik7CisJaWYgKG1l c3NhZ2UgPT0gTlVMTCkgeworCQlkZWJ1ZyAoIkNvbnNvbGVLaXQ6IENvdWxkbid0IGFsbG9jYXRl IHRoZSBELUJ1cyBtZXNzYWdlIik7CisJCXJldHVybiBGQUxTRTsKKwl9CisKKwlkYnVzX2Vycm9y X2luaXQgKCZlcnJvcik7CisJcmVwbHkgPSBkYnVzX2Nvbm5lY3Rpb25fc2VuZF93aXRoX3JlcGx5 X2FuZF9ibG9jayAoY29ubmVjdGlvbiwKKwkJCQkJCQkgICBtZXNzYWdlLAorCQkJCQkJCSAgIC0x LCAmZXJyb3IpOworCWRidXNfbWVzc2FnZV91bnJlZiAobWVzc2FnZSk7CisJZGJ1c19tZXNzYWdl X3VucmVmIChyZXBseSk7CisJZGJ1c19jb25uZWN0aW9uX2ZsdXNoIChjb25uZWN0aW9uKTsKKwor CWlmIChkYnVzX2Vycm9yX2lzX3NldCAoJmVycm9yKSkgeworCQlkZWJ1ZyAoIkNvbnNvbGVLaXQ6 ICVzIHJhaXNlZDpcbiAlc1xuXG4iLCBlcnJvci5uYW1lLCBlcnJvci5tZXNzYWdlKTsKKwkJcmV0 dXJuIEZBTFNFOworCX0KKworCXJldHVybiBUUlVFOworfQorCisvKiBmcm9tIGxpYmhhbCAqLwor c3RhdGljIGNoYXIgKioKK2dldF9wYXRoX2FycmF5X2Zyb21faXRlciAoREJ1c01lc3NhZ2VJdGVy ICppdGVyLAorCQkJICBpbnQgICAgICAgICAgICAgKm51bV9lbGVtZW50cykKK3sKKwlpbnQgY291 bnQ7CisJY2hhciAqKmJ1ZmZlcjsKKworCWNvdW50ID0gMDsKKwlidWZmZXIgPSAoY2hhciAqKilt YWxsb2MgKHNpemVvZiAoY2hhciAqKSAqIDgpOworCisJaWYgKGJ1ZmZlciA9PSBOVUxMKQorCQln b3RvIG9vbTsKKworCWJ1ZmZlclswXSA9IE5VTEw7CisJd2hpbGUgKGRidXNfbWVzc2FnZV9pdGVy X2dldF9hcmdfdHlwZSAoaXRlcikgPT0gREJVU19UWVBFX09CSkVDVF9QQVRIKSB7CisJCWNvbnN0 IGNoYXIgKnZhbHVlOworCQljaGFyICpzdHI7CisKKwkJaWYgKChjb3VudCAlIDgpID09IDAgJiYg Y291bnQgIT0gMCkgeworCQkJYnVmZmVyID0gcmVhbGxvYyAoYnVmZmVyLCBzaXplb2YgKGNoYXIg KikgKiAoY291bnQgKyA4KSk7CisJCQlpZiAoYnVmZmVyID09IE5VTEwpCisJCQkJZ290byBvb207 CisJCX0KKworCQlkYnVzX21lc3NhZ2VfaXRlcl9nZXRfYmFzaWMgKGl0ZXIsICZ2YWx1ZSk7CisJ CXN0ciA9IHN0cmR1cCAodmFsdWUpOworCQlpZiAoc3RyID09IE5VTEwpCisJCQlnb3RvIG9vbTsK KworCQlidWZmZXJbY291bnRdID0gc3RyOworCisJCWRidXNfbWVzc2FnZV9pdGVyX25leHQgKGl0 ZXIpOworCQljb3VudCsrOworCX0KKworCWlmICgoY291bnQgJSA4KSA9PSAwKSB7CisJCWJ1ZmZl ciA9IHJlYWxsb2MgKGJ1ZmZlciwgc2l6ZW9mIChjaGFyICopICogKGNvdW50ICsgMSkpOworCQlp ZiAoYnVmZmVyID09IE5VTEwpCisJCQlnb3RvIG9vbTsKKwl9CisKKwlidWZmZXJbY291bnRdID0g TlVMTDsKKwlpZiAobnVtX2VsZW1lbnRzICE9IE5VTEwpCisJCSpudW1fZWxlbWVudHMgPSBjb3Vu dDsKKwlyZXR1cm4gYnVmZmVyOworCitvb206CisJbG9nV2FybiAoIiVzICVkIDogZXJyb3IgYWxs b2NhdGluZyBtZW1vcnlcbiIsIF9fRklMRV9fLCBfX0xJTkVfXyk7CisJcmV0dXJuIE5VTEw7CisK K30KKworc3RhdGljIGNoYXIgKioKK2dldF9zZXNzaW9uc19mb3JfdXNlciAoREJ1c0Nvbm5lY3Rp b24gKmNvbm5lY3Rpb24sCisJCSAgICAgICBjb25zdCBjaGFyICAgICAqdXNlciwKKwkJICAgICAg IGNvbnN0IGNoYXIgICAgICp4MTFfZGlzcGxheSkKK3sKKwlEQnVzRXJyb3IgICAgICAgZXJyb3I7 CisJREJ1c01lc3NhZ2UgICAgKm1lc3NhZ2U7CisJREJ1c01lc3NhZ2UgICAgKnJlcGx5OworCURC dXNNZXNzYWdlSXRlciBpdGVyOworCURCdXNNZXNzYWdlSXRlciBpdGVyX3JlcGx5OworCURCdXNN ZXNzYWdlSXRlciBpdGVyX2FycmF5OworCXN0cnVjdCBwYXNzd2QJKnB3ZW50OworCWNoYXIgICAg ICAgICAgICoqc2Vzc2lvbnM7CisKKwlzZXNzaW9ucyA9IE5VTEw7CisJbWVzc2FnZSA9IE5VTEw7 CisJcmVwbHkgPSBOVUxMOworCisJcHdlbnQgPSBnZXRwd25hbSAodXNlcik7CisKKwlkYnVzX2Vy cm9yX2luaXQgKCZlcnJvcik7CisJbWVzc2FnZSA9IGRidXNfbWVzc2FnZV9uZXdfbWV0aG9kX2Nh bGwgKENLX05BTUUsCisJCQkJCQlDS19NQU5BR0VSX1BBVEgsCisJCQkJCQlDS19NQU5BR0VSX0lO VEVSRkFDRSwKKwkJCQkJCSJHZXRTZXNzaW9uc0ZvclVzZXIiKTsKKwlpZiAobWVzc2FnZSA9PSBO VUxMKSB7CisJCWRlYnVnICgiQ29uc29sZUtpdDogQ291bGRuJ3QgYWxsb2NhdGUgdGhlIEQtQnVz IG1lc3NhZ2UiKTsKKwkJZ290byBvdXQ7CisJfQorCisJZGJ1c19tZXNzYWdlX2l0ZXJfaW5pdF9h cHBlbmQgKG1lc3NhZ2UsICZpdGVyKTsKKwlkYnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMg KCZpdGVyLAorCQkJCQlEQlVTX1RZUEVfVUlOVDMyLAorCQkJCQkmcHdlbnQtPnB3X3VpZCk7CisK KwlkYnVzX2Vycm9yX2luaXQgKCZlcnJvcik7CisJcmVwbHkgPSBkYnVzX2Nvbm5lY3Rpb25fc2Vu ZF93aXRoX3JlcGx5X2FuZF9ibG9jayAoY29ubmVjdGlvbiwKKwkJCQkJCQkgICBtZXNzYWdlLAor CQkJCQkJCSAgIC0xLCAmZXJyb3IpOworCWRidXNfY29ubmVjdGlvbl9mbHVzaCAoY29ubmVjdGlv bik7CisKKwlpZiAoZGJ1c19lcnJvcl9pc19zZXQgKCZlcnJvcikpIHsKKwkJZGVidWcgKCJDb25z b2xlS2l0OiAlcyByYWlzZWQ6XG4gJXNcblxuIiwgZXJyb3IubmFtZSwgZXJyb3IubWVzc2FnZSk7 CisJCWdvdG8gb3V0OworCX0KKworCWlmIChyZXBseSA9PSBOVUxMKSB7CisJCWRlYnVnICgiQ29u c29sZUtpdDogTm8gcmVwbHkgZm9yIEdldFNlc3Npb25zRm9yVXNlciIpOworCQlnb3RvIG91dDsK Kwl9CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9pbml0IChyZXBseSwgJml0ZXJfcmVwbHkpOworCWlm IChkYnVzX21lc3NhZ2VfaXRlcl9nZXRfYXJnX3R5cGUgKCZpdGVyX3JlcGx5KSAhPSBEQlVTX1RZ UEVfQVJSQVkpIHsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiBXcm9uZyByZXBseSBmb3IgR2V0U2Vz c2lvbnNGb3JVc2VyIC0gZXhwZWN0aW5nIGFuIGFycmF5LiIpOworCQlnb3RvIG91dDsKKwl9CisK KwlkYnVzX21lc3NhZ2VfaXRlcl9yZWN1cnNlICgmaXRlcl9yZXBseSwgJml0ZXJfYXJyYXkpOwor CXNlc3Npb25zID0gZ2V0X3BhdGhfYXJyYXlfZnJvbV9pdGVyICgmaXRlcl9hcnJheSwgTlVMTCk7 CisKKyBvdXQ6CisJaWYgKG1lc3NhZ2UgIT0gTlVMTCkgeworCQlkYnVzX21lc3NhZ2VfdW5yZWYg KG1lc3NhZ2UpOworCX0KKwlpZiAocmVwbHkgIT0gTlVMTCkgeworCQlkYnVzX21lc3NhZ2VfdW5y ZWYgKHJlcGx5KTsKKwl9CisKKwlyZXR1cm4gc2Vzc2lvbnM7Cit9CisKK3ZvaWQKK3VubG9ja19j a19zZXNzaW9uIChjb25zdCBjaGFyICp1c2VyLAorCQkgICBjb25zdCBjaGFyICp4MTFfZGlzcGxh eSkKK3sKKwlEQnVzRXJyb3IgICAgICAgZXJyb3I7CisJREJ1c0Nvbm5lY3Rpb24gKmNvbm5lY3Rp b247CisJY2hhciAgICAgICAgICAgKipzZXNzaW9uczsKKwlpbnQgICAgICAgICAgICAgIGk7CisK KwlkZWJ1ZyAoIkNvbnNvbGVLaXQ6IFVubG9ja2luZyBzZXNzaW9uIGZvciAlcyBvbiAlcyIsIHVz ZXIsIHgxMV9kaXNwbGF5KTsKKworCWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwljb25uZWN0 aW9uID0gZGJ1c19idXNfZ2V0IChEQlVTX0JVU19TWVNURU0sICZlcnJvcik7CisJaWYgKGNvbm5l Y3Rpb24gPT0gTlVMTCkgeworCQlkZWJ1ZyAoIkNvbnNvbGVLaXQ6IEZhaWxlZCB0byBjb25uZWN0 IHRvIHRoZSBELUJ1cyBkYWVtb246ICVzIiwgZXJyb3IubWVzc2FnZSk7CisJCWRidXNfZXJyb3Jf ZnJlZSAoJmVycm9yKTsKKwkJcmV0dXJuOworCX0KKworCXNlc3Npb25zID0gZ2V0X3Nlc3Npb25z X2Zvcl91c2VyIChjb25uZWN0aW9uLCB1c2VyLCB4MTFfZGlzcGxheSk7CisJaWYgKHNlc3Npb25z ID09IE5VTEwgfHwgc2Vzc2lvbnNbMF0gPT0gTlVMTCkgeworCQlkZWJ1ZyAoIkNvbnNvbGVLaXQ6 IG5vIHNlc3Npb25zIGZvdW5kIik7CisJCXJldHVybjsKKwl9CisKKwlmb3IgKGkgPSAwOyBzZXNz aW9uc1tpXSAhPSBOVUxMOyBpKyspIHsKKwkJY2hhciAqc3NpZDsKKwkJY2hhciAqeGRpc3BsYXk7 CisKKwkJc3NpZCA9IHNlc3Npb25zW2ldOworCQlzZXNzaW9uX2dldF94MTFfZGlzcGxheSAoY29u bmVjdGlvbiwgc3NpZCwgJnhkaXNwbGF5KTsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiBzZXNzaW9u ICVzIGhhcyBESVNQTEFZICVzIiwgc3NpZCwgeGRpc3BsYXkpOworCisJCWlmICh4ZGlzcGxheSAh PSBOVUxMCisJCSAgICAmJiB4MTFfZGlzcGxheSAhPSBOVUxMCisJCSAgICAmJiBzdHJjbXAgKHhk aXNwbGF5LCB4MTFfZGlzcGxheSkgPT0gMCkgeworCQkJaW50IHJlczsKKworCQkJcmVzID0gc2Vz c2lvbl91bmxvY2sgKGNvbm5lY3Rpb24sIHNzaWQpOworCQkJaWYgKCEgcmVzKSB7CisJCQkJbG9n RXJyb3IgKCJDb25zb2xlS2l0OiBVbmFibGUgdG8gdW5sb2NrICVzIiwgc3NpZCk7CisJCQl9CisJ CX0KKworCQlmcmVlICh4ZGlzcGxheSk7CisJfQorCisJZnJlZVN0ckFyciAoc2Vzc2lvbnMpOwor fQorCitjaGFyICoKK29wZW5fY2tfc2Vzc2lvbiAoc3RydWN0IHBhc3N3ZCAqcHdlbnQsCisJCSBz dHJ1Y3QgZGlzcGxheSAqZCkKK3sKKwlEQnVzQ29ubmVjdGlvbiAqY29ubmVjdGlvbjsKKwlEQnVz RXJyb3IgICAgICAgZXJyb3I7CisJREJ1c01lc3NhZ2UgICAgKm1lc3NhZ2U7CisJREJ1c01lc3Nh Z2UgICAgKnJlcGx5OworCURCdXNNZXNzYWdlSXRlciBpdGVyOworCURCdXNNZXNzYWdlSXRlciBp dGVyX3N0cnVjdDsKKwljaGFyCSAgICAgICAqY29va2llOworCisJY29va2llID0gTlVMTDsKKwor CWlmIChwd2VudCA9PSBOVUxMKSB7CisJCWRlYnVnICgiQ29uc29sZUtpdDogTlVMTCB1c2VyIHBh c3NlZCBhcyBwYXJhbWV0ZXIiKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJZGVidWcgKCJDb25z b2xlS2l0OiBPcGVuaW5nIHNlc3Npb24gZm9yICVzIiwgcHdlbnQtPnB3X25hbWUpOworCisJZGJ1 c19lcnJvcl9pbml0ICgmZXJyb3IpOworCWNvbm5lY3Rpb24gPSBkYnVzX2J1c19nZXRfcHJpdmF0 ZSAoREJVU19CVVNfU1lTVEVNLCAmZXJyb3IpOworCXByaXZhdGVfY29ubmVjdGlvbiA9IGNvbm5l Y3Rpb247CisKKwlpZiAoY29ubmVjdGlvbiA9PSBOVUxMKSB7CisJCWRlYnVnICgiQ29uc29sZUtp dDogRmFpbGVkIHRvIGNvbm5lY3QgdG8gdGhlIEQtQnVzIGRhZW1vbjogJXMiLCBlcnJvci5tZXNz YWdlKTsKKwkJZGJ1c19lcnJvcl9mcmVlICgmZXJyb3IpOworCQlyZXR1cm4gTlVMTDsKKwl9CisK KwlkYnVzX2Nvbm5lY3Rpb25fc2V0X2V4aXRfb25fZGlzY29ubmVjdCAoY29ubmVjdGlvbiwgRkFM U0UpOworCS8qIE5vIG1haW5sb29wIGludGVncmF0aW9uIG5lZWRlZCBmb3IgRC1CdXMgYmVjYXVz ZSBvbmx5IGJsb2NraW5nIGNhbGxzIGFyZSB1c2VkLiAqLworCisJZGJ1c19lcnJvcl9pbml0ICgm ZXJyb3IpOworCW1lc3NhZ2UgPSBkYnVzX21lc3NhZ2VfbmV3X21ldGhvZF9jYWxsIChDS19OQU1F LAorCQkJCQkJQ0tfTUFOQUdFUl9QQVRILAorCQkJCQkJQ0tfTUFOQUdFUl9JTlRFUkZBQ0UsCisJ CQkJCQkiT3BlblNlc3Npb25XaXRoUGFyYW1ldGVycyIpOworCWlmIChtZXNzYWdlID09IE5VTEwp IHsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiBDb3VsZG4ndCBhbGxvY2F0ZSB0aGUgRC1CdXMgbWVz c2FnZSIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9pbml0X2Fw cGVuZCAobWVzc2FnZSwgJml0ZXIpOworCWRidXNfbWVzc2FnZV9pdGVyX29wZW5fY29udGFpbmVy ICgmaXRlciwKKwkJCQkJICBEQlVTX1RZUEVfQVJSQVksCisJCQkJCSAgREJVU19TVFJVQ1RfQkVH SU5fQ0hBUl9BU19TVFJJTkcKKwkJCQkJICBEQlVTX1RZUEVfU1RSSU5HX0FTX1NUUklORworCQkJ CQkgIERCVVNfVFlQRV9WQVJJQU5UX0FTX1NUUklORworCQkJCQkgIERCVVNfU1RSVUNUX0VORF9D SEFSX0FTX1NUUklORywKKwkJCQkJICAmaXRlcl9zdHJ1Y3QpOworCisJYWRkX3BhcmFtX2ludCAo Jml0ZXJfc3RydWN0LCAidXNlciIsIHB3ZW50LT5wd191aWQpOworCWFkZF9wYXJhbV9zdHJpbmcg KCZpdGVyX3N0cnVjdCwgIngxMS1kaXNwbGF5IiwgZC0+bmFtZSk7CisJYWRkX3BhcmFtX2Jvb2xl YW4gKCZpdGVyX3N0cnVjdCwgImlzLWxvY2FsIiwgKChkLT5kaXNwbGF5VHlwZSAmIGRfbG9jYXRp b24pID09IGRMb2NhbCkpOworI2lmZGVmIFhETUNQCisJaWYgKChkLT5kaXNwbGF5VHlwZSAmIGRf bG9jYXRpb24pICE9IGRMb2NhbCkgeworCQlhZGRfcGFyYW1fc3RyaW5nICgmaXRlcl9zdHJ1Y3Qs ICJyZW1vdGUtaG9zdC1uYW1lIiwgZC0+cmVtb3RlSG9zdCk7CisJfQorI2VuZGlmCisKKyNpZmRl ZiBIQVZFX1ZUUworCWlmIChkLT5zZXJ2ZXJWVCA+IDApIHsKKwkJY2hhciBkZXZpY2VbMjBdOwor CisJCS8qIEZJWE1FOiBob3cgZG9lcyB4b3JnIGNvbnN0cnVjdCB0aGlzICovCisJCXNwcmludGYo ZGV2aWNlLCAiL2Rldi90dHklZCIsIGQtPnNlcnZlclZUKTsKKwkJYWRkX3BhcmFtX3N0cmluZyAo Jml0ZXJfc3RydWN0LCAieDExLWRpc3BsYXktZGV2aWNlIiwgZGV2aWNlKTsKKwl9CisjZW5kaWYK KworCWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lciAoJml0ZXIsICZpdGVyX3N0cnVj dCk7CisKKwlyZXBseSA9IGRidXNfY29ubmVjdGlvbl9zZW5kX3dpdGhfcmVwbHlfYW5kX2Jsb2Nr IChjb25uZWN0aW9uLAorCQkJCQkJCSAgIG1lc3NhZ2UsCisJCQkJCQkJICAgLTEsICZlcnJvcik7 CisJaWYgKGRidXNfZXJyb3JfaXNfc2V0ICgmZXJyb3IpKSB7CisJCWRlYnVnICgiQ29uc29sZUtp dDogJXMgcmFpc2VkOlxuICVzXG5cbiIsIGVycm9yLm5hbWUsIGVycm9yLm1lc3NhZ2UpOworCQly ZXBseSA9IE5VTEw7CisJfQorCisJZGJ1c19jb25uZWN0aW9uX2ZsdXNoIChjb25uZWN0aW9uKTsK KworCWRidXNfbWVzc2FnZV91bnJlZiAobWVzc2FnZSk7CisJZGJ1c19lcnJvcl9mcmVlICgmZXJy b3IpOworCisJaWYgKHJlcGx5ICE9IE5VTEwpIHsKKwkJY29uc3QgY2hhciAqdmFsdWU7CisKKwkJ ZGJ1c19tZXNzYWdlX2l0ZXJfaW5pdCAocmVwbHksICZpdGVyKTsKKwkJZGJ1c19tZXNzYWdlX2l0 ZXJfZ2V0X2Jhc2ljICgmaXRlciwgJnZhbHVlKTsKKwkJY29va2llID0gc3RyZHVwICh2YWx1ZSk7 CisJCWRidXNfbWVzc2FnZV91bnJlZiAocmVwbHkpOworCX0KKworCXJldHVybiBjb29raWU7Cit9 CisKK3ZvaWQKK2Nsb3NlX2NrX3Nlc3Npb24gKGNvbnN0IGNoYXIgKmNvb2tpZSkKK3sKKwlEQnVz RXJyb3IgICAgICAgZXJyb3I7CisJREJ1c01lc3NhZ2UgICAgKm1lc3NhZ2U7CisJREJ1c01lc3Nh Z2UgICAgKnJlcGx5OworCURCdXNNZXNzYWdlSXRlciBpdGVyOworCisJaWYgKGNvb2tpZSA9PSBO VUxMKSB7CisJCXJldHVybjsKKwl9CisKKwlpZiAocHJpdmF0ZV9jb25uZWN0aW9uID09IE5VTEwp IHsKKwkJcmV0dXJuOworCX0KKworCWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwltZXNzYWdl ID0gZGJ1c19tZXNzYWdlX25ld19tZXRob2RfY2FsbCAoQ0tfTkFNRSwKKwkJCQkJCUNLX01BTkFH RVJfUEFUSCwKKwkJCQkJCUNLX01BTkFHRVJfSU5URVJGQUNFLAorCQkJCQkJIkNsb3NlU2Vzc2lv biIpOworCWlmIChtZXNzYWdlID09IE5VTEwpIHsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiBDb3Vs ZG4ndCBhbGxvY2F0ZSB0aGUgRC1CdXMgbWVzc2FnZSIpOworCQlyZXR1cm47CisJfQorCisJZGJ1 c19tZXNzYWdlX2l0ZXJfaW5pdF9hcHBlbmQgKG1lc3NhZ2UsICZpdGVyKTsKKwlkYnVzX21lc3Nh Z2VfaXRlcl9hcHBlbmRfYmFzaWMgKCZpdGVyLAorCQkJCQlEQlVTX1RZUEVfU1RSSU5HLAorCQkJ CQkmY29va2llKTsKKworCXJlcGx5ID0gZGJ1c19jb25uZWN0aW9uX3NlbmRfd2l0aF9yZXBseV9h bmRfYmxvY2sgKHByaXZhdGVfY29ubmVjdGlvbiwKKwkJCQkJCQkgICBtZXNzYWdlLAorCQkJCQkJ CSAgIC0xLCAmZXJyb3IpOworCWlmIChkYnVzX2Vycm9yX2lzX3NldCAoJmVycm9yKSkgeworCQlk ZWJ1ZyAoIkNvbnNvbGVLaXQ6ICVzIHJhaXNlZDpcbiAlc1xuXG4iLCBlcnJvci5uYW1lLCBlcnJv ci5tZXNzYWdlKTsKKwkJcmVwbHkgPSBOVUxMOworCX0KKworCWRidXNfY29ubmVjdGlvbl9mbHVz aCAocHJpdmF0ZV9jb25uZWN0aW9uKTsKKworCWRidXNfbWVzc2FnZV91bnJlZiAobWVzc2FnZSk7 CisJZGJ1c19lcnJvcl9mcmVlICgmZXJyb3IpOworCisgICAgICAgIGRidXNfY29ubmVjdGlvbl9j bG9zZSAocHJpdmF0ZV9jb25uZWN0aW9uKTsKKwlwcml2YXRlX2Nvbm5lY3Rpb24gPSBOVUxMOwor fQpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtMy45Ni4xL2tkbS9iYWNrZW5kL2NvbnNvbGVr aXQuaCBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEtY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQv Y29uc29sZWtpdC5oCi0tLSBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEva2RtL2JhY2tlbmQvY29u c29sZWtpdC5oCTE5NzAtMDEtMDEgMDE6MDA6MDAuMDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNl LXdvcmtzcGFjZS0zLjk2LjEtY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQvY29uc29sZWtpdC5o CTIwMDctMTEtMjkgMTk6MTk6MTQuMDAwMDAwMDAwICswMTAwCkBAIC0wLDAgKzEsMzYgQEAKKy8q IC0qLSBNb2RlOiBDOyB0YWItd2lkdGg6IDg7IGluZGVudC10YWJzLW1vZGU6IHQ7IGMtYmFzaWMt b2Zmc2V0OiA4IC0qLQorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNiBXaWxsaWFtIEpvbiBNY0Nh bm4gPG1jY2FubkBqaHUuZWR1PgorICogQ29weXJpZ2h0IChDKSAyMDA3IEtldmluIEtvZmxlciA8 S2V2aW5AdGlnY2MudGljYWxjLm9yZz4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkKKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2Yg dGhlIExpY2Vuc2UsIG9yCisgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgor ICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdp bGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4g dGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVk IGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGgg dGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3Vu ZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIx MTEtMTMwNywgVVNBLgorICoKKyAqLworCisKKyNpZm5kZWYgX19DT05TT0xFX0tJVF9ICisjZGVm aW5lIF9fQ09OU09MRV9LSVRfSAorCisjaW5jbHVkZSA8cHdkLmg+CisKK3N0cnVjdCBkaXNwbGF5 OworCitjaGFyICogICAgICBvcGVuX2NrX3Nlc3Npb24gICAgICAgKHN0cnVjdCBwYXNzd2QgKnB3 ZW50LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgZGlzcGxheSAq ZGlzcGxheSk7Cit2b2lkICAgICAgICBjbG9zZV9ja19zZXNzaW9uICAgICAgKGNvbnN0IGNoYXIg ICAgKmNvb2tpZSk7Cit2b2lkICAgICAgICB1bmxvY2tfY2tfc2Vzc2lvbiAgICAgKGNvbnN0IGNo YXIgICAgKnVzZXIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNo YXIgICAgKngxMV9kaXNwbGF5KTsKKworI2VuZGlmIC8qIF9fQ09OU09MRV9LSVRfSCAqLwpkaWZm IC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtMy45Ni4xL2tkbS9iYWNrZW5kL2RtLmgga2RlYmFzZS13 b3Jrc3BhY2UtMy45Ni4xLWNvbnNvbGVraXQta2RtL2tkbS9iYWNrZW5kL2RtLmgKLS0tIGtkZWJh c2Utd29ya3NwYWNlLTMuOTYuMS9rZG0vYmFja2VuZC9kbS5oCTIwMDctMTEtMTQgMDA6NTU6MzIu MDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEtY29uc29sZWtpdC1r ZG0va2RtL2JhY2tlbmQvZG0uaAkyMDA3LTExLTI5IDE5OjIzOjQ2LjAwMDAwMDAwMCArMDEwMApA QCAtMzcsNiArMzcsOCBAQAogI2lmbmRlZiBfRE1fSF8KICNkZWZpbmUgX0RNX0hfIDEKIAorI2Rl ZmluZSBXSVRIX0NPTlNPTEVfS0lUCisKICNpbmNsdWRlICJncmVldC5oIgogI2luY2x1ZGUgPGNv bmZpZy5jaT4KIApAQCAtNTAwLDcgKzUwMiwxMSBAQAogI2RlZmluZSBHQ09OVl9CSU5BUlkgIDUK IHR5cGVkZWYgY2hhciAqKCpHQ29udkZ1bmMpKCBpbnQgd2hhdCwgY29uc3QgY2hhciAqcHJvbXB0 ICk7CiBpbnQgdmVyaWZ5KCBHQ29udkZ1bmMgZ2NvbnYsIGludCByb290b2sgKTsKKyNpZmRlZiBX SVRIX0NPTlNPTEVfS0lUCitpbnQgc3RhcnRDbGllbnQoIHZvbGF0aWxlIGludCAqcGlkLCAgY29u c3QgY2hhciAqY2tfc2Vzc2lvbl9jb29raWUgKTsKKyNlbHNlCiBpbnQgc3RhcnRDbGllbnQoIHZv bGF0aWxlIGludCAqcGlkICk7CisjZW5kaWYKIHZvaWQgY2xpZW50RXhpdGVkKCB2b2lkICk7CiB2 b2lkIHNlc3Npb25FeGl0KCBpbnQgc3RhdHVzICkgQVRUUl9OT1JFVFVSTjsKIGludCByZWFkRG1y Yyggdm9pZCApOwpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtMy45Ni4xL2tkbS9iYWNrZW5k L0ltYWtlZmlsZSBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEtY29uc29sZWtpdC1rZG0va2RtL2Jh Y2tlbmQvSW1ha2VmaWxlCi0tLSBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEva2RtL2JhY2tlbmQv SW1ha2VmaWxlCTIwMDYtMTAtMjYgMDQ6MTI6MzguMDAwMDAwMDAwICswMjAwCisrKyBrZGViYXNl LXdvcmtzcGFjZS0zLjk2LjEtY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQvSW1ha2VmaWxlCTIw MDctMTEtMjkgMTk6MTk6MTQuMDAwMDAwMDAwICswMTAwCkBAIC0xNTUsMTMgKzE1NSwxMyBAQAog CQkgbmV0YWRkci5jIHJlc2V0LmMgcmVzb3VyY2UuYyBwcm90b2RweS5jIHBvbGljeS5jIFwKIAkJ IHNlc3Npb24uYyBzb2NrZXQuYyBzdHJlYW1zLmMgdXRpbC5jIHhkbWNwLmMgXAogCQkgcHJvY2Vz cy5jIG1pdGF1dGguYyBcCi0JCSBnZW5hdXRoLmMgYWNjZXNzLmMgY2hvb3NlLmMgXAorCQkgZ2Vu YXV0aC5jIGFjY2Vzcy5jIGNob29zZS5jIGNvbnNvbGVraXQuYyBcCiAJCSAkKFhETUFVVEhTUkNT KSAkKFJQQ1NSQ1MpICQoS1JCNVNSQ1MpCiAgICAgICBDT01NT0JKUyA9IGF1dGgubyBkYWVtb24u byBzZXJ2ZXIubyBkcHlsaXN0Lm8gZG0ubyBlcnJvci5vIFwKIAkJIG5ldGFkZHIubyByZXNldC5v IHJlc291cmNlLm8gcHJvdG9kcHkubyBwb2xpY3kubyBcCiAJCSBzZXNzaW9uLm8gc29ja2V0Lm8g c3RyZWFtcy5vIHV0aWwubyB4ZG1jcC5vIFwKIAkJIHByb2Nlc3MubyBtaXRhdXRoLm8gXAotCQkg Z2VuYXV0aC5vIGFjY2Vzcy5vIGNob29zZS5vIFwKKwkJIGdlbmF1dGgubyBhY2Nlc3MubyBjaG9v c2UubyBjb25zb2xla2l0Lm8gXAogCQkgJChYRE1BVVRIT0JKUykgJChSUENPQkpTKSAkKEtSQjVP QkpTKQogCiAgICAgICAgICBTUkNTMSA9ICQoQ09NTVNSQ1MpIGNsaWVudC5jCmRpZmYgLU51ciBr ZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEva2RtL2JhY2tlbmQvc2Vzc2lvbi5jIGtkZWJhc2Utd29y a3NwYWNlLTMuOTYuMS1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9zZXNzaW9uLmMKLS0tIGtk ZWJhc2Utd29ya3NwYWNlLTMuOTYuMS9rZG0vYmFja2VuZC9zZXNzaW9uLmMJMjAwNy0xMS0xNCAw MDo1NTozMi4wMDAwMDAwMDAgKzAxMDAKKysrIGtkZWJhc2Utd29ya3NwYWNlLTMuOTYuMS1jb25z b2xla2l0LWtkbS9rZG0vYmFja2VuZC9zZXNzaW9uLmMJMjAwNy0xMS0yOSAxOToyNjo0OC4wMDAw MDAwMDAgKzAxMDAKQEAgLTQ1LDYgKzQ1LDEwIEBACiAjaW5jbHVkZSA8Y3R5cGUuaD4KICNpbmNs dWRlIDxzaWduYWwuaD4KIAorI2lmZGVmIFdJVEhfQ09OU09MRV9LSVQKKyNpbmNsdWRlICJjb25z b2xla2l0LmgiCisjZW5kaWYKKwogc3RydWN0IGRpc3BsYXkgKnRkOwogY29uc3QgY2hhciAqdGRf c2V0dXAgPSAiYXV0byI7CiAKQEAgLTU0Niw2ICs1NTAsOSBAQAogCWludCBleCwgY21kOwogCXZv bGF0aWxlIGludCBjbGllbnRQaWQgPSAtMTsKIAl2b2xhdGlsZSB0aW1lX3QgdGRpZmYgPSAwOwor I2lmZGVmIFdJVEhfQ09OU09MRV9LSVQKKwljaGFyICpja19zZXNzaW9uX2Nvb2tpZTsKKyNlbmRp ZgogCiAJdGQgPSBkOwogCWRlYnVnKCAibWFuYWdlU2Vzc2lvbiAlc1xuIiwgZC0+bmFtZSApOwpA QCAtNjIyLDcgKzYyOSwxMiBAQAogCWlmICh0ZF9zZXR1cCkKIAkJc2V0dXBEaXNwbGF5KCB0ZF9z ZXR1cCApOwogCisjaWZkZWYgV0lUSF9DT05TT0xFX0tJVAorCWNrX3Nlc3Npb25fY29va2llID0g b3Blbl9ja19zZXNzaW9uIChnZXRwd25hbShjdXJ1c2VyKSwgZCk7CisJaWYgKCFzdGFydENsaWVu dCggJmNsaWVudFBpZCwgY2tfc2Vzc2lvbl9jb29raWUgKSkgeworI2Vsc2UKIAlpZiAoIXN0YXJ0 Q2xpZW50KCAmY2xpZW50UGlkICkpIHsKKyNlbmRpZgogCQlsb2dFcnJvciggIkNsaWVudCBzdGFy dCBmYWlsZWRcbiIgKTsKIAkJc2Vzc2lvbkV4aXQoIEVYX05PUk1BTCApOyAvKiBYWFggbWF5YmUg RVhfUkVNQU5BR0VfRFBZPyAtLSBlbmFibGUgaW4gZG0uYyEgKi8KIAl9CkBAIC02NDQsNiArNjU2 LDE0IEBACiAJCQkJY2F0Y2hUZXJtKCBTSUdURVJNICk7CiAJCX0KIAl9CisKKyNpZmRlZiBXSVRI X0NPTlNPTEVfS0lUCisJaWYgKGNrX3Nlc3Npb25fY29va2llICE9IE5VTEwpIHsKKwkJY2xvc2Vf Y2tfc2Vzc2lvbiAoY2tfc2Vzc2lvbl9jb29raWUpOworCQlmcmVlIChja19zZXNzaW9uX2Nvb2tp ZSk7CisJfQorI2VuZGlmCisKIAkvKgogCSAqIFNvbWV0aW1lcyB0aGUgWHNlc3Npb24gc29tZWhv dyBtYW5hZ2VzIHRvIGV4aXQgYmVmb3JlCiAJICogYSBzZXJ2ZXIgY3Jhc2ggaXMgbm90aWNlZCAt IHNvIHdlIHNsZWVwIGEgYml0IGFuZCB3YWl0CmRpZmYgLU51ciBrZGViYXNlLXdvcmtzcGFjZS0z Ljk2LjEva2RtL2JhY2tlbmQveGRtY3AuYyBrZGViYXNlLXdvcmtzcGFjZS0zLjk2LjEtY29uc29s ZWtpdC1rZG0va2RtL2JhY2tlbmQveGRtY3AuYwotLS0ga2RlYmFzZS13b3Jrc3BhY2UtMy45Ni4x L2tkbS9iYWNrZW5kL3hkbWNwLmMJMjAwNy0xMC0zMSAyMzo1NzozNC4wMDAwMDAwMDAgKzAxMDAK KysrIGtkZWJhc2Utd29ya3NwYWNlLTMuOTYuMS1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC94 ZG1jcC5jCTIwMDctMTEtMjkgMTk6MzQ6MDAuMDAwMDAwMDAwICswMTAwCkBAIC05MjEsNiArOTIx LDkgQEAKIAkJCX0KIAkJCWQtPmNsaWVudEFkZHIgPSBjbGllbnRBZGRyZXNzOwogCQkJZC0+Y29u bmVjdGlvblR5cGUgPSBjb25uZWN0aW9uVHlwZTsKKwkJCWQtPnJlbW90ZUhvc3QgPSBuZXR3b3Jr QWRkcmVzc1RvSG9zdG5hbWUgKHBkcHktPmNvbm5lY3Rpb25UeXBlLAorCQkJICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAmcGRweS0+Y29ubmVjdGlvbkFkZHJlc3MpOworCiAJCQlYZG1jcERp c3Bvc2VBUlJBWTgoICZjbGllbnRQb3J0ICk7CiAJCQlpZiAocGRweS0+ZmlsZUF1dGhvcml6YXRp b24pIHsKIAkJCQlkLT5hdXRob3JpemF0aW9ucyA9IChYYXV0aCAqKilNYWxsb2MoIHNpemVvZihY YXV0aCAqKSApOwo= 23030 2008-01-14 16:36:21 +0000 2008-01-14 17:07:41 +0000 kdm consolekit support patch for 3.x series 70_kdm_consolekit.diff text/plain 23549 fabo ZGlmZiAtTnVyIGtkZWJhc2UtMy41LjguZGZzZy4xL2tkbS9iYWNrZW5kL2NsaWVudC5jIGtkZWJh c2UtMy41LjguZGZzZy4xLm5ldy9rZG0vYmFja2VuZC9jbGllbnQuYwotLS0ga2RlYmFzZS0zLjUu OC5kZnNnLjEva2RtL2JhY2tlbmQvY2xpZW50LmMJMjAwNy0xMi0yNiAxNDo0MTozNC4wMDAwMDAw MDAgKzAxMDAKKysrIGtkZWJhc2UtMy41LjguZGZzZy4xLm5ldy9rZG0vYmFja2VuZC9jbGllbnQu YwkyMDA3LTEyLTI2IDE0OjQxOjQ2LjAwMDAwMDAwMCArMDEwMApAQCAtODIsNiArODIsMTAgQEAK ICMgaW5jbHVkZSA8c2hhZG93Lmg+CiAjZW5kaWYKIAorI2lmZGVmIFdJVEhfQ09OU09MRV9LSVQK KyNpbmNsdWRlICJjb25zb2xla2l0LmgiCisjZW5kaWYKKwogLyoKICAqIFNlc3Npb24gZGF0YSwg bW9zdGx5IHdoYXQgc3RydWN0IHZlcmlmeV9pbmZvIHdhcyBmb3IKICAqLwpAQCAtMTEyMCw4ICsx MTI0LDEzIEBACiBzdGF0aWMgaW50IHJlbW92ZUNyZWRzOwogI2VuZGlmCiAKKyNpZmRlZiBXSVRI X0NPTlNPTEVfS0lUCitpbnQKK1N0YXJ0Q2xpZW50KCBjb25zdCBjaGFyICpja19zZXNzaW9uX2Nv b2tpZSApCisjZWxzZQogaW50CiBTdGFydENsaWVudCgpCisjZW5kaWYKIHsKIAljb25zdCBjaGFy ICpob21lLCAqc2Vzc2FyZ3MsICpkZXNrc2VzczsKIAljaGFyICoqZW52LCAqeG1hOwpAQCAtMTIx Nyw2ICsxMjI2LDExIEBACiAJaWYgKGtyYnRrZmlsZVswXSAhPSAnXDAnKQogCQllbnYgPSBzZXRF bnYoIGVudiwgIktSQlRLRklMRSIsIGtyYnRrZmlsZSApOwogI2VuZGlmCisjaWZkZWYgV0lUSF9D T05TT0xFX0tJVAorCWlmIChja19zZXNzaW9uX2Nvb2tpZSAhPSBOVUxMKSB7CisJCWVudiA9IHNl dEVudiAoIGVudiwgIlhER19TRVNTSU9OX0NPT0tJRSIsIGNrX3Nlc3Npb25fY29va2llICk7CisJ fQorI2VuZGlmCiAJdXNlckVudmlyb24gPSBpbmhlcml0RW52KCBlbnYsIGVudnZhcnMgKTsKIAll bnYgPSBzeXN0ZW1FbnYoIHAtPnB3X25hbWUgKTsKIAlzeXN0ZW1FbnZpcm9uID0gc2V0RW52KCBl bnYsICJIT01FIiwgcC0+cHdfZGlyICk7CmRpZmYgLU51ciBrZGViYXNlLTMuNS44LmRmc2cuMS9r ZG0vYmFja2VuZC9jb25zb2xla2l0LmMga2RlYmFzZS0zLjUuOC5kZnNnLjEubmV3L2tkbS9iYWNr ZW5kL2NvbnNvbGVraXQuYwotLS0ga2RlYmFzZS0zLjUuOC5kZnNnLjEva2RtL2JhY2tlbmQvY29u c29sZWtpdC5jCTE5NzAtMDEtMDEgMDE6MDA6MDAuMDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNl LTMuNS44LmRmc2cuMS5uZXcva2RtL2JhY2tlbmQvY29uc29sZWtpdC5jCTIwMDctMTItMjYgMTQ6 NDE6NDYuMDAwMDAwMDAwICswMTAwCkBAIC0wLDAgKzEsNTUyIEBACisvKiAtKi0gTW9kZTogQzsg dGFiLXdpZHRoOiA4OyBpbmRlbnQtdGFicy1tb2RlOiB0OyBjLWJhc2ljLW9mZnNldDogOCAtKi0K KyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYtMjAwNyBXaWxsaWFtIEpvbiBNY0Nhbm4gPG1jY2Fu bkBqaHUuZWR1PgorICogQ29weXJpZ2h0IChDKSAyMDA3IEtldmluIEtvZmxlciA8S2V2aW5AdGln Y2MudGljYWxjLm9yZz4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91 IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1z IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAqIHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vu c2UsIG9yCisgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRo aXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9n cmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJ bmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywg VVNBLgorICoKKyAqLworCisjaW5jbHVkZSAiZG0uaCIKKyNpbmNsdWRlICJkbV9hdXRoLmgiCisj aW5jbHVkZSAiZG1fZXJyb3IuaCIKKworI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2luY2x1ZGUgPHN0 cmluZy5oPgorI2luY2x1ZGUgPHB3ZC5oPgorCisjZGVmaW5lIERCVVNfQVBJX1NVQkpFQ1RfVE9f Q0hBTkdFCisjaW5jbHVkZSA8ZGJ1cy9kYnVzLmg+CisKKyNpbmNsdWRlICJjb25zb2xla2l0Lmgi CisKKworI2RlZmluZSBDS19OQU1FICAgICAgICAgICAgICAib3JnLmZyZWVkZXNrdG9wLkNvbnNv bGVLaXQiCisjZGVmaW5lIENLX1BBVEggICAgICAgICAgICAgICIvb3JnL2ZyZWVkZXNrdG9wL0Nv bnNvbGVLaXQiCisjZGVmaW5lIENLX0lOVEVSRkFDRSAgICAgICAgICJvcmcuZnJlZWRlc2t0b3Au Q29uc29sZUtpdCIKKyNkZWZpbmUgQ0tfTUFOQUdFUl9QQVRIICAgICAgIi9vcmcvZnJlZWRlc2t0 b3AvQ29uc29sZUtpdC9NYW5hZ2VyIgorI2RlZmluZSBDS19NQU5BR0VSX0lOVEVSRkFDRSAib3Jn LmZyZWVkZXNrdG9wLkNvbnNvbGVLaXQuTWFuYWdlciIKKyNkZWZpbmUgQ0tfU0VTU0lPTl9JTlRF UkZBQ0UgIm9yZy5mcmVlZGVza3RvcC5Db25zb2xlS2l0LlNlc3Npb24iCisKK3N0YXRpYyBEQnVz Q29ubmVjdGlvbiAqcHJpdmF0ZV9jb25uZWN0aW9uID0gTlVMTDsKKworc3RhdGljIHZvaWQKK2Fk ZF9wYXJhbV9pbnQgKERCdXNNZXNzYWdlSXRlciAqaXRlcl9zdHJ1Y3QsCisJICAgICAgIGNvbnN0 IGNoYXIgICAgICAqa2V5LAorCSAgICAgICBpbnQgICAgICAgICAgICAgIHZhbHVlKQoreworCURC dXNNZXNzYWdlSXRlciBpdGVyX3N0cnVjdF9lbnRyeTsKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcl92 YXI7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5lciAoaXRlcl9zdHJ1Y3QsCisJ CQkJCSAgREJVU19UWVBFX1NUUlVDVCwKKwkJCQkJICBOVUxMLAorCQkJCQkgICZpdGVyX3N0cnVj dF9lbnRyeSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMgKCZpdGVyX3N0cnVj dF9lbnRyeSwKKwkJCQkJREJVU19UWVBFX1NUUklORywKKwkJCQkJJmtleSk7CisKKwlkYnVzX21l c3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5lciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgIERC VVNfVFlQRV9WQVJJQU5ULAorCQkJCQkgIERCVVNfVFlQRV9JTlQzMl9BU19TVFJJTkcsCisJCQkJ CSAgJml0ZXJfdmFyKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXJf dmFyLAorCQkJCQlEQlVTX1RZUEVfSU5UMzIsCisJCQkJCSZ2YWx1ZSk7CisKKwlkYnVzX21lc3Nh Z2VfaXRlcl9jbG9zZV9jb250YWluZXIgKCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJICAgJml0 ZXJfdmFyKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lciAoaXRlcl9zdHJ1 Y3QsICZpdGVyX3N0cnVjdF9lbnRyeSk7Cit9CisKK3N0YXRpYyB2b2lkCithZGRfcGFyYW1fYm9v bGVhbiAoREJ1c01lc3NhZ2VJdGVyICppdGVyX3N0cnVjdCwKKwkJICAgY29uc3QgY2hhciAgICAg ICprZXksCisJCSAgIGludCAgICAgICAgICAgICB2YWx1ZSkKK3sKKwlEQnVzTWVzc2FnZUl0ZXIg aXRlcl9zdHJ1Y3RfZW50cnk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXJfdmFyOworCisJZGJ1c19t ZXNzYWdlX2l0ZXJfb3Blbl9jb250YWluZXIgKGl0ZXJfc3RydWN0LAorCQkJCQkgIERCVVNfVFlQ RV9TVFJVQ1QsCisJCQkJCSAgTlVMTCwKKwkJCQkJICAmaXRlcl9zdHJ1Y3RfZW50cnkpOworCisJ ZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljICgmaXRlcl9zdHJ1Y3RfZW50cnksCisJCQkJ CURCVVNfVFlQRV9TVFJJTkcsCisJCQkJCSZrZXkpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfb3Bl bl9jb250YWluZXIgKCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJICBEQlVTX1RZUEVfVkFSSUFO VCwKKwkJCQkJICBEQlVTX1RZUEVfQk9PTEVBTl9BU19TVFJJTkcsCisJCQkJCSAgJml0ZXJfdmFy KTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXJfdmFyLAorCQkJCQlE QlVTX1RZUEVfQk9PTEVBTiwKKwkJCQkJJnZhbHVlKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2Ns b3NlX2NvbnRhaW5lciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgICAmaXRlcl92YXIpOwor CisJZGJ1c19tZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFpbmVyIChpdGVyX3N0cnVjdCwgJml0ZXJf c3RydWN0X2VudHJ5KTsKK30KKworc3RhdGljIHZvaWQKK2FkZF9wYXJhbV9zdHJpbmcgKERCdXNN ZXNzYWdlSXRlciAqaXRlcl9zdHJ1Y3QsCisJCSAgY29uc3QgY2hhciAgICAgICprZXksCisJCSAg Y29uc3QgY2hhciAgICAgICp2YWx1ZSkKK3sKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcl9zdHJ1Y3Rf ZW50cnk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXJfdmFyOworCisJZGJ1c19tZXNzYWdlX2l0ZXJf b3Blbl9jb250YWluZXIgKGl0ZXJfc3RydWN0LAorCQkJCQkgIERCVVNfVFlQRV9TVFJVQ1QsCisJ CQkJCSAgTlVMTCwKKwkJCQkJICAmaXRlcl9zdHJ1Y3RfZW50cnkpOworCisJZGJ1c19tZXNzYWdl X2l0ZXJfYXBwZW5kX2Jhc2ljICgmaXRlcl9zdHJ1Y3RfZW50cnksCisJCQkJCURCVVNfVFlQRV9T VFJJTkcsCisJCQkJCSZrZXkpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfb3Blbl9jb250YWluZXIg KCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJICBEQlVTX1RZUEVfVkFSSUFOVCwKKwkJCQkJICBE QlVTX1RZUEVfU1RSSU5HX0FTX1NUUklORywKKwkJCQkJICAmaXRlcl92YXIpOworCisJZGJ1c19t ZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljICgmaXRlcl92YXIsCisJCQkJCURCVVNfVFlQRV9TVFJJ TkcsCisJCQkJCSZ2YWx1ZSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9jbG9zZV9jb250YWluZXIg KCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJICAgJml0ZXJfdmFyKTsKKworCWRidXNfbWVzc2Fn ZV9pdGVyX2Nsb3NlX2NvbnRhaW5lciAoaXRlcl9zdHJ1Y3QsICZpdGVyX3N0cnVjdF9lbnRyeSk7 Cit9CisKK3N0YXRpYyBpbnQKK3Nlc3Npb25fZ2V0X3gxMV9kaXNwbGF5IChEQnVzQ29ubmVjdGlv biAqY29ubmVjdGlvbiwKKwkJCSBjb25zdCBjaGFyICAgICAqc3NpZCwKKwkJCSBjaGFyICAgICAg ICAgICoqc3RyKQoreworCURCdXNFcnJvciAgICAgICBlcnJvcjsKKwlEQnVzTWVzc2FnZSAgICAq bWVzc2FnZTsKKwlEQnVzTWVzc2FnZSAgICAqcmVwbHk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXI7 CisJY29uc3QgY2hhciAgICAgKnZhbHVlOworCisJaWYgKHN0ciAhPSBOVUxMKSB7CisJCSpzdHIg PSBOVUxMOworCX0KKworCW1lc3NhZ2UgPSBkYnVzX21lc3NhZ2VfbmV3X21ldGhvZF9jYWxsIChD S19OQU1FLAorCQkJCQkJc3NpZCwKKwkJCQkJCUNLX1NFU1NJT05fSU5URVJGQUNFLAorCQkJCQkJ IkdldFgxMURpc3BsYXkiKTsKKwlpZiAobWVzc2FnZSA9PSBOVUxMKSB7CisJCURlYnVnICgiQ29u c29sZUtpdDogQ291bGRuJ3QgYWxsb2NhdGUgdGhlIEQtQnVzIG1lc3NhZ2UiKTsKKwkJcmV0dXJu IEZBTFNFOworCX0KKworCWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwlyZXBseSA9IGRidXNf Y29ubmVjdGlvbl9zZW5kX3dpdGhfcmVwbHlfYW5kX2Jsb2NrIChjb25uZWN0aW9uLAorCQkJCQkJ CSAgIG1lc3NhZ2UsCisJCQkJCQkJICAgLTEsICZlcnJvcik7CisJaWYgKGRidXNfZXJyb3JfaXNf c2V0ICgmZXJyb3IpKSB7CisJCURlYnVnICgiQ29uc29sZUtpdDogJXMgcmFpc2VkOlxuICVzXG5c biIsIGVycm9yLm5hbWUsIGVycm9yLm1lc3NhZ2UpOworCQlyZXBseSA9IE5VTEw7CisJfQorCisJ ZGJ1c19jb25uZWN0aW9uX2ZsdXNoIChjb25uZWN0aW9uKTsKKwlkYnVzX21lc3NhZ2VfdW5yZWYg KG1lc3NhZ2UpOworCisJaWYgKHJlcGx5ID09IE5VTEwpIHsKKwkJcmV0dXJuIEZBTFNFOworCX0K KworCWRidXNfbWVzc2FnZV9pdGVyX2luaXQgKHJlcGx5LCAmaXRlcik7CisJZGJ1c19tZXNzYWdl X2l0ZXJfZ2V0X2Jhc2ljICgmaXRlciwgJnZhbHVlKTsKKwlpZiAoc3RyICE9IE5VTEwpIHsKKwkJ KnN0ciA9IHN0cmR1cCAodmFsdWUpOworCX0KKwlkYnVzX21lc3NhZ2VfdW5yZWYgKHJlcGx5KTsK KworCXJldHVybiBUUlVFOworfQorCitzdGF0aWMgaW50CitzZXNzaW9uX3VubG9jayAoREJ1c0Nv bm5lY3Rpb24gKmNvbm5lY3Rpb24sCisJCWNvbnN0IGNoYXIgICAgICpzc2lkKQoreworCURCdXNF cnJvciAgICAgICBlcnJvcjsKKwlEQnVzTWVzc2FnZSAgICAqbWVzc2FnZTsKKwlEQnVzTWVzc2Fn ZSAgICAqcmVwbHk7CisKKwlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IFVubG9ja2luZyBzZXNzaW9uICVz Iiwgc3NpZCk7CisJbWVzc2FnZSA9IGRidXNfbWVzc2FnZV9uZXdfbWV0aG9kX2NhbGwgKENLX05B TUUsCisJCQkJCQlzc2lkLAorCQkJCQkJQ0tfU0VTU0lPTl9JTlRFUkZBQ0UsCisJCQkJCQkiVW5s b2NrIik7CisJaWYgKG1lc3NhZ2UgPT0gTlVMTCkgeworCQlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IENv dWxkbid0IGFsbG9jYXRlIHRoZSBELUJ1cyBtZXNzYWdlIik7CisJCXJldHVybiBGQUxTRTsKKwl9 CisKKwlkYnVzX2Vycm9yX2luaXQgKCZlcnJvcik7CisJcmVwbHkgPSBkYnVzX2Nvbm5lY3Rpb25f c2VuZF93aXRoX3JlcGx5X2FuZF9ibG9jayAoY29ubmVjdGlvbiwKKwkJCQkJCQkgICBtZXNzYWdl LAorCQkJCQkJCSAgIC0xLCAmZXJyb3IpOworCWRidXNfbWVzc2FnZV91bnJlZiAobWVzc2FnZSk7 CisJZGJ1c19tZXNzYWdlX3VucmVmIChyZXBseSk7CisJZGJ1c19jb25uZWN0aW9uX2ZsdXNoIChj b25uZWN0aW9uKTsKKworCWlmIChkYnVzX2Vycm9yX2lzX3NldCAoJmVycm9yKSkgeworCQlEZWJ1 ZyAoIkNvbnNvbGVLaXQ6ICVzIHJhaXNlZDpcbiAlc1xuXG4iLCBlcnJvci5uYW1lLCBlcnJvci5t ZXNzYWdlKTsKKwkJcmV0dXJuIEZBTFNFOworCX0KKworCXJldHVybiBUUlVFOworfQorCisvKiBm cm9tIGxpYmhhbCAqLworc3RhdGljIGNoYXIgKioKK2dldF9wYXRoX2FycmF5X2Zyb21faXRlciAo REJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJICBpbnQgICAgICAgICAgICAgKm51bV9lbGVtZW50 cykKK3sKKwlpbnQgY291bnQ7CisJY2hhciAqKmJ1ZmZlcjsKKworCWNvdW50ID0gMDsKKwlidWZm ZXIgPSAoY2hhciAqKiltYWxsb2MgKHNpemVvZiAoY2hhciAqKSAqIDgpOworCisJaWYgKGJ1ZmZl ciA9PSBOVUxMKQorCQlnb3RvIG9vbTsKKworCWJ1ZmZlclswXSA9IE5VTEw7CisJd2hpbGUgKGRi dXNfbWVzc2FnZV9pdGVyX2dldF9hcmdfdHlwZSAoaXRlcikgPT0gREJVU19UWVBFX09CSkVDVF9Q QVRIKSB7CisJCWNvbnN0IGNoYXIgKnZhbHVlOworCQljaGFyICpzdHI7CisKKwkJaWYgKChjb3Vu dCAlIDgpID09IDAgJiYgY291bnQgIT0gMCkgeworCQkJYnVmZmVyID0gcmVhbGxvYyAoYnVmZmVy LCBzaXplb2YgKGNoYXIgKikgKiAoY291bnQgKyA4KSk7CisJCQlpZiAoYnVmZmVyID09IE5VTEwp CisJCQkJZ290byBvb207CisJCX0KKworCQlkYnVzX21lc3NhZ2VfaXRlcl9nZXRfYmFzaWMgKGl0 ZXIsICZ2YWx1ZSk7CisJCXN0ciA9IHN0cmR1cCAodmFsdWUpOworCQlpZiAoc3RyID09IE5VTEwp CisJCQlnb3RvIG9vbTsKKworCQlidWZmZXJbY291bnRdID0gc3RyOworCisJCWRidXNfbWVzc2Fn ZV9pdGVyX25leHQgKGl0ZXIpOworCQljb3VudCsrOworCX0KKworCWlmICgoY291bnQgJSA4KSA9 PSAwKSB7CisJCWJ1ZmZlciA9IHJlYWxsb2MgKGJ1ZmZlciwgc2l6ZW9mIChjaGFyICopICogKGNv dW50ICsgMSkpOworCQlpZiAoYnVmZmVyID09IE5VTEwpCisJCQlnb3RvIG9vbTsKKwl9CisKKwli dWZmZXJbY291bnRdID0gTlVMTDsKKwlpZiAobnVtX2VsZW1lbnRzICE9IE5VTEwpCisJCSpudW1f ZWxlbWVudHMgPSBjb3VudDsKKwlyZXR1cm4gYnVmZmVyOworCitvb206CisJTG9nV2FybiAoIiVz ICVkIDogZXJyb3IgYWxsb2NhdGluZyBtZW1vcnlcbiIsIF9fRklMRV9fLCBfX0xJTkVfXyk7CisJ cmV0dXJuIE5VTEw7CisKK30KKworc3RhdGljIGNoYXIgKioKK2dldF9zZXNzaW9uc19mb3JfdXNl ciAoREJ1c0Nvbm5lY3Rpb24gKmNvbm5lY3Rpb24sCisJCSAgICAgICBjb25zdCBjaGFyICAgICAq dXNlciwKKwkJICAgICAgIGNvbnN0IGNoYXIgICAgICp4MTFfZGlzcGxheSkKK3sKKwlEQnVzRXJy b3IgICAgICAgZXJyb3I7CisJREJ1c01lc3NhZ2UgICAgKm1lc3NhZ2U7CisJREJ1c01lc3NhZ2Ug ICAgKnJlcGx5OworCURCdXNNZXNzYWdlSXRlciBpdGVyOworCURCdXNNZXNzYWdlSXRlciBpdGVy X3JlcGx5OworCURCdXNNZXNzYWdlSXRlciBpdGVyX2FycmF5OworCXN0cnVjdCBwYXNzd2QJKnB3 ZW50OworCWNoYXIgICAgICAgICAgICoqc2Vzc2lvbnM7CisKKwlzZXNzaW9ucyA9IE5VTEw7CisJ bWVzc2FnZSA9IE5VTEw7CisJcmVwbHkgPSBOVUxMOworCisJcHdlbnQgPSBnZXRwd25hbSAodXNl cik7CisKKwlkYnVzX2Vycm9yX2luaXQgKCZlcnJvcik7CisJbWVzc2FnZSA9IGRidXNfbWVzc2Fn ZV9uZXdfbWV0aG9kX2NhbGwgKENLX05BTUUsCisJCQkJCQlDS19NQU5BR0VSX1BBVEgsCisJCQkJ CQlDS19NQU5BR0VSX0lOVEVSRkFDRSwKKwkJCQkJCSJHZXRTZXNzaW9uc0ZvclVzZXIiKTsKKwlp ZiAobWVzc2FnZSA9PSBOVUxMKSB7CisJCURlYnVnICgiQ29uc29sZUtpdDogQ291bGRuJ3QgYWxs b2NhdGUgdGhlIEQtQnVzIG1lc3NhZ2UiKTsKKwkJZ290byBvdXQ7CisJfQorCisJZGJ1c19tZXNz YWdlX2l0ZXJfaW5pdF9hcHBlbmQgKG1lc3NhZ2UsICZpdGVyKTsKKwlkYnVzX21lc3NhZ2VfaXRl cl9hcHBlbmRfYmFzaWMgKCZpdGVyLAorCQkJCQlEQlVTX1RZUEVfVUlOVDMyLAorCQkJCQkmcHdl bnQtPnB3X3VpZCk7CisKKwlkYnVzX2Vycm9yX2luaXQgKCZlcnJvcik7CisJcmVwbHkgPSBkYnVz X2Nvbm5lY3Rpb25fc2VuZF93aXRoX3JlcGx5X2FuZF9ibG9jayAoY29ubmVjdGlvbiwKKwkJCQkJ CQkgICBtZXNzYWdlLAorCQkJCQkJCSAgIC0xLCAmZXJyb3IpOworCWRidXNfY29ubmVjdGlvbl9m bHVzaCAoY29ubmVjdGlvbik7CisKKwlpZiAoZGJ1c19lcnJvcl9pc19zZXQgKCZlcnJvcikpIHsK KwkJRGVidWcgKCJDb25zb2xlS2l0OiAlcyByYWlzZWQ6XG4gJXNcblxuIiwgZXJyb3IubmFtZSwg ZXJyb3IubWVzc2FnZSk7CisJCWdvdG8gb3V0OworCX0KKworCWlmIChyZXBseSA9PSBOVUxMKSB7 CisJCURlYnVnICgiQ29uc29sZUtpdDogTm8gcmVwbHkgZm9yIEdldFNlc3Npb25zRm9yVXNlciIp OworCQlnb3RvIG91dDsKKwl9CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9pbml0IChyZXBseSwgJml0 ZXJfcmVwbHkpOworCWlmIChkYnVzX21lc3NhZ2VfaXRlcl9nZXRfYXJnX3R5cGUgKCZpdGVyX3Jl cGx5KSAhPSBEQlVTX1RZUEVfQVJSQVkpIHsKKwkJRGVidWcgKCJDb25zb2xlS2l0OiBXcm9uZyBy ZXBseSBmb3IgR2V0U2Vzc2lvbnNGb3JVc2VyIC0gZXhwZWN0aW5nIGFuIGFycmF5LiIpOworCQln b3RvIG91dDsKKwl9CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9yZWN1cnNlICgmaXRlcl9yZXBseSwg Jml0ZXJfYXJyYXkpOworCXNlc3Npb25zID0gZ2V0X3BhdGhfYXJyYXlfZnJvbV9pdGVyICgmaXRl cl9hcnJheSwgTlVMTCk7CisKKyBvdXQ6CisJaWYgKG1lc3NhZ2UgIT0gTlVMTCkgeworCQlkYnVz X21lc3NhZ2VfdW5yZWYgKG1lc3NhZ2UpOworCX0KKwlpZiAocmVwbHkgIT0gTlVMTCkgeworCQlk YnVzX21lc3NhZ2VfdW5yZWYgKHJlcGx5KTsKKwl9CisKKwlyZXR1cm4gc2Vzc2lvbnM7Cit9CisK K3ZvaWQKK3VubG9ja19ja19zZXNzaW9uIChjb25zdCBjaGFyICp1c2VyLAorCQkgICBjb25zdCBj aGFyICp4MTFfZGlzcGxheSkKK3sKKwlEQnVzRXJyb3IgICAgICAgZXJyb3I7CisJREJ1c0Nvbm5l Y3Rpb24gKmNvbm5lY3Rpb247CisJY2hhciAgICAgICAgICAgKipzZXNzaW9uczsKKwlpbnQgICAg ICAgICAgICAgIGk7CisKKwlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IFVubG9ja2luZyBzZXNzaW9uIGZv ciAlcyBvbiAlcyIsIHVzZXIsIHgxMV9kaXNwbGF5KTsKKworCWRidXNfZXJyb3JfaW5pdCAoJmVy cm9yKTsKKwljb25uZWN0aW9uID0gZGJ1c19idXNfZ2V0IChEQlVTX0JVU19TWVNURU0sICZlcnJv cik7CisJaWYgKGNvbm5lY3Rpb24gPT0gTlVMTCkgeworCQlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IEZh aWxlZCB0byBjb25uZWN0IHRvIHRoZSBELUJ1cyBkYWVtb246ICVzIiwgZXJyb3IubWVzc2FnZSk7 CisJCWRidXNfZXJyb3JfZnJlZSAoJmVycm9yKTsKKwkJcmV0dXJuOworCX0KKworCXNlc3Npb25z ID0gZ2V0X3Nlc3Npb25zX2Zvcl91c2VyIChjb25uZWN0aW9uLCB1c2VyLCB4MTFfZGlzcGxheSk7 CisJaWYgKHNlc3Npb25zID09IE5VTEwgfHwgc2Vzc2lvbnNbMF0gPT0gTlVMTCkgeworCQlEZWJ1 ZyAoIkNvbnNvbGVLaXQ6IG5vIHNlc3Npb25zIGZvdW5kIik7CisJCXJldHVybjsKKwl9CisKKwlm b3IgKGkgPSAwOyBzZXNzaW9uc1tpXSAhPSBOVUxMOyBpKyspIHsKKwkJY2hhciAqc3NpZDsKKwkJ Y2hhciAqeGRpc3BsYXk7CisKKwkJc3NpZCA9IHNlc3Npb25zW2ldOworCQlzZXNzaW9uX2dldF94 MTFfZGlzcGxheSAoY29ubmVjdGlvbiwgc3NpZCwgJnhkaXNwbGF5KTsKKwkJRGVidWcgKCJDb25z b2xlS2l0OiBzZXNzaW9uICVzIGhhcyBESVNQTEFZICVzIiwgc3NpZCwgeGRpc3BsYXkpOworCisJ CWlmICh4ZGlzcGxheSAhPSBOVUxMCisJCSAgICAmJiB4MTFfZGlzcGxheSAhPSBOVUxMCisJCSAg ICAmJiBzdHJjbXAgKHhkaXNwbGF5LCB4MTFfZGlzcGxheSkgPT0gMCkgeworCQkJaW50IHJlczsK KworCQkJcmVzID0gc2Vzc2lvbl91bmxvY2sgKGNvbm5lY3Rpb24sIHNzaWQpOworCQkJaWYgKCEg cmVzKSB7CisJCQkJTG9nRXJyb3IgKCJDb25zb2xlS2l0OiBVbmFibGUgdG8gdW5sb2NrICVzIiwg c3NpZCk7CisJCQl9CisJCX0KKworCQlmcmVlICh4ZGlzcGxheSk7CisJfQorCisJZnJlZVN0ckFy ciAoc2Vzc2lvbnMpOworfQorCitjaGFyICoKK29wZW5fY2tfc2Vzc2lvbiAoc3RydWN0IHBhc3N3 ZCAqcHdlbnQsCisJCSBzdHJ1Y3QgZGlzcGxheSAqZCkKK3sKKwlEQnVzQ29ubmVjdGlvbiAqY29u bmVjdGlvbjsKKwlEQnVzRXJyb3IgICAgICAgZXJyb3I7CisJREJ1c01lc3NhZ2UgICAgKm1lc3Nh Z2U7CisJREJ1c01lc3NhZ2UgICAgKnJlcGx5OworCURCdXNNZXNzYWdlSXRlciBpdGVyOworCURC dXNNZXNzYWdlSXRlciBpdGVyX3N0cnVjdDsKKwljaGFyCSAgICAgICAqY29va2llOworCisJY29v a2llID0gTlVMTDsKKworCURlYnVnICgiQ29uc29sZUtpdDogT3BlbmluZyBzZXNzaW9uIGZvciAl cyIsIHB3ZW50LT5wd19uYW1lKTsKKworCWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwljb25u ZWN0aW9uID0gZGJ1c19idXNfZ2V0X3ByaXZhdGUgKERCVVNfQlVTX1NZU1RFTSwgJmVycm9yKTsK Kwlwcml2YXRlX2Nvbm5lY3Rpb24gPSBjb25uZWN0aW9uOworCisJaWYgKGNvbm5lY3Rpb24gPT0g TlVMTCkgeworCQlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IEZhaWxlZCB0byBjb25uZWN0IHRvIHRoZSBE LUJ1cyBkYWVtb246ICVzIiwgZXJyb3IubWVzc2FnZSk7CisJCWRidXNfZXJyb3JfZnJlZSAoJmVy cm9yKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJZGJ1c19jb25uZWN0aW9uX3NldF9leGl0X29u X2Rpc2Nvbm5lY3QgKGNvbm5lY3Rpb24sIEZBTFNFKTsKKwkvKiBGSVhNRTogV2hhdCB0byBkbyBh Ym91dCB0aGVzZT8KKwlkYnVzX2Nvbm5lY3Rpb25fc2V0X3dhdGNoX2Z1bmN0aW9ucyggY29ubmVj dGlvbiwKKwkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGJ1c0FkZFdhdGNo LAorCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkYnVzUmVtb3ZlV2F0Y2gs CisJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRidXNUb2dnbGVXYXRjaCwK KwkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGF0YSwgMCApOworCWRidXNf Y29ubmVjdGlvbl9zZXRfdGltZW91dF9mdW5jdGlvbnMoIGNvbm5lY3Rpb24sCisJICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGJ1c0FkZFRpbWVvdXQsCisJICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGJ1c1JlbW92ZVRpbWVvdXQsCisJICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGJ1c1RvZ2dsZVRpbWVvdXQsCisJICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGF0YSwgMCApOworCWRidXNfY29u bmVjdGlvbl9zZXRfd2FrZXVwX21haW5fZnVuY3Rpb24oIGNvbm5lY3Rpb24sCisJICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGJ1c1dha2V1cE1haW4sCisJICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGF0YSwgMCApOyAqLworCisJZGJ1 c19lcnJvcl9pbml0ICgmZXJyb3IpOworCW1lc3NhZ2UgPSBkYnVzX21lc3NhZ2VfbmV3X21ldGhv ZF9jYWxsIChDS19OQU1FLAorCQkJCQkJQ0tfTUFOQUdFUl9QQVRILAorCQkJCQkJQ0tfTUFOQUdF Ul9JTlRFUkZBQ0UsCisJCQkJCQkiT3BlblNlc3Npb25XaXRoUGFyYW1ldGVycyIpOworCWlmICht ZXNzYWdlID09IE5VTEwpIHsKKwkJRGVidWcgKCJDb25zb2xlS2l0OiBDb3VsZG4ndCBhbGxvY2F0 ZSB0aGUgRC1CdXMgbWVzc2FnZSIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlkYnVzX21lc3Nh Z2VfaXRlcl9pbml0X2FwcGVuZCAobWVzc2FnZSwgJml0ZXIpOworCWRidXNfbWVzc2FnZV9pdGVy X29wZW5fY29udGFpbmVyICgmaXRlciwKKwkJCQkJICBEQlVTX1RZUEVfQVJSQVksCisJCQkJCSAg REJVU19TVFJVQ1RfQkVHSU5fQ0hBUl9BU19TVFJJTkcKKwkJCQkJICBEQlVTX1RZUEVfU1RSSU5H X0FTX1NUUklORworCQkJCQkgIERCVVNfVFlQRV9WQVJJQU5UX0FTX1NUUklORworCQkJCQkgIERC VVNfU1RSVUNUX0VORF9DSEFSX0FTX1NUUklORywKKwkJCQkJICAmaXRlcl9zdHJ1Y3QpOworCisJ YWRkX3BhcmFtX2ludCAoJml0ZXJfc3RydWN0LCAidXNlciIsIHB3ZW50LT5wd191aWQpOworCWFk ZF9wYXJhbV9zdHJpbmcgKCZpdGVyX3N0cnVjdCwgIngxMS1kaXNwbGF5IiwgZC0+bmFtZSk7CisJ YWRkX3BhcmFtX2Jvb2xlYW4gKCZpdGVyX3N0cnVjdCwgImlzLWxvY2FsIiwgKChkLT5kaXNwbGF5 VHlwZSAmIGRfbG9jYXRpb24pID09IGRMb2NhbCkpOworI2lmZGVmIFhETUNQCisJaWYgKChkLT5k aXNwbGF5VHlwZSAmIGRfbG9jYXRpb24pICE9IGRMb2NhbCkgeworCQlhZGRfcGFyYW1fc3RyaW5n ICgmaXRlcl9zdHJ1Y3QsICJyZW1vdGUtaG9zdC1uYW1lIiwgZC0+cmVtb3RlSG9zdCk7CisJfQor I2VuZGlmCisKKyNpZmRlZiBIQVZFX1ZUUworCWlmIChkLT5zZXJ2ZXJWVCA+IDApIHsKKwkJY2hh ciBkZXZpY2VbMjBdOworCisJCS8qIEZJWE1FOiBob3cgZG9lcyB4b3JnIGNvbnN0cnVjdCB0aGlz ICovCisJCXNwcmludGYoZGV2aWNlLCAiL2Rldi90dHklZCIsIGQtPnNlcnZlclZUKTsKKwkJYWRk X3BhcmFtX3N0cmluZyAoJml0ZXJfc3RydWN0LCAieDExLWRpc3BsYXktZGV2aWNlIiwgZGV2aWNl KTsKKwl9CisjZW5kaWYKKworCWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lciAoJml0 ZXIsICZpdGVyX3N0cnVjdCk7CisKKwlyZXBseSA9IGRidXNfY29ubmVjdGlvbl9zZW5kX3dpdGhf cmVwbHlfYW5kX2Jsb2NrIChjb25uZWN0aW9uLAorCQkJCQkJCSAgIG1lc3NhZ2UsCisJCQkJCQkJ ICAgLTEsICZlcnJvcik7CisJaWYgKGRidXNfZXJyb3JfaXNfc2V0ICgmZXJyb3IpKSB7CisJCURl YnVnICgiQ29uc29sZUtpdDogJXMgcmFpc2VkOlxuICVzXG5cbiIsIGVycm9yLm5hbWUsIGVycm9y Lm1lc3NhZ2UpOworCQlyZXBseSA9IE5VTEw7CisJfQorCisJZGJ1c19jb25uZWN0aW9uX2ZsdXNo IChjb25uZWN0aW9uKTsKKworCWRidXNfbWVzc2FnZV91bnJlZiAobWVzc2FnZSk7CisJZGJ1c19l cnJvcl9mcmVlICgmZXJyb3IpOworCisJaWYgKHJlcGx5ICE9IE5VTEwpIHsKKwkJY29uc3QgY2hh ciAqdmFsdWU7CisKKwkJZGJ1c19tZXNzYWdlX2l0ZXJfaW5pdCAocmVwbHksICZpdGVyKTsKKwkJ ZGJ1c19tZXNzYWdlX2l0ZXJfZ2V0X2Jhc2ljICgmaXRlciwgJnZhbHVlKTsKKwkJY29va2llID0g c3RyZHVwICh2YWx1ZSk7CisJCWRidXNfbWVzc2FnZV91bnJlZiAocmVwbHkpOworCX0KKworCXJl dHVybiBjb29raWU7Cit9CisKK3ZvaWQKK2Nsb3NlX2NrX3Nlc3Npb24gKGNvbnN0IGNoYXIgKmNv b2tpZSkKK3sKKwlEQnVzRXJyb3IgICAgICAgZXJyb3I7CisJREJ1c01lc3NhZ2UgICAgKm1lc3Nh Z2U7CisJREJ1c01lc3NhZ2UgICAgKnJlcGx5OworCURCdXNNZXNzYWdlSXRlciBpdGVyOworCisJ aWYgKGNvb2tpZSA9PSBOVUxMKSB7CisJCXJldHVybjsKKwl9CisKKwlpZiAocHJpdmF0ZV9jb25u ZWN0aW9uID09IE5VTEwpIHsKKwkJcmV0dXJuOworCX0KKworCWRidXNfZXJyb3JfaW5pdCAoJmVy cm9yKTsKKwltZXNzYWdlID0gZGJ1c19tZXNzYWdlX25ld19tZXRob2RfY2FsbCAoQ0tfTkFNRSwK KwkJCQkJCUNLX01BTkFHRVJfUEFUSCwKKwkJCQkJCUNLX01BTkFHRVJfSU5URVJGQUNFLAorCQkJ CQkJIkNsb3NlU2Vzc2lvbiIpOworCWlmIChtZXNzYWdlID09IE5VTEwpIHsKKwkJRGVidWcgKCJD b25zb2xlS2l0OiBDb3VsZG4ndCBhbGxvY2F0ZSB0aGUgRC1CdXMgbWVzc2FnZSIpOworCQlyZXR1 cm47CisJfQorCisJZGJ1c19tZXNzYWdlX2l0ZXJfaW5pdF9hcHBlbmQgKG1lc3NhZ2UsICZpdGVy KTsKKwlkYnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMgKCZpdGVyLAorCQkJCQlEQlVTX1RZ UEVfU1RSSU5HLAorCQkJCQkmY29va2llKTsKKworCXJlcGx5ID0gZGJ1c19jb25uZWN0aW9uX3Nl bmRfd2l0aF9yZXBseV9hbmRfYmxvY2sgKHByaXZhdGVfY29ubmVjdGlvbiwKKwkJCQkJCQkgICBt ZXNzYWdlLAorCQkJCQkJCSAgIC0xLCAmZXJyb3IpOworCWlmIChkYnVzX2Vycm9yX2lzX3NldCAo JmVycm9yKSkgeworCQlEZWJ1ZyAoIkNvbnNvbGVLaXQ6ICVzIHJhaXNlZDpcbiAlc1xuXG4iLCBl cnJvci5uYW1lLCBlcnJvci5tZXNzYWdlKTsKKwkJcmVwbHkgPSBOVUxMOworCX0KKworCWRidXNf Y29ubmVjdGlvbl9mbHVzaCAocHJpdmF0ZV9jb25uZWN0aW9uKTsKKworCWRidXNfbWVzc2FnZV91 bnJlZiAobWVzc2FnZSk7CisJZGJ1c19lcnJvcl9mcmVlICgmZXJyb3IpOworCisgICAgICAgIGRi dXNfY29ubmVjdGlvbl9jbG9zZSAocHJpdmF0ZV9jb25uZWN0aW9uKTsKKwlwcml2YXRlX2Nvbm5l Y3Rpb24gPSBOVUxMOworfQpkaWZmIC1OdXIga2RlYmFzZS0zLjUuOC5kZnNnLjEva2RtL2JhY2tl bmQvY29uc29sZWtpdC5oIGtkZWJhc2UtMy41LjguZGZzZy4xLm5ldy9rZG0vYmFja2VuZC9jb25z b2xla2l0LmgKLS0tIGtkZWJhc2UtMy41LjguZGZzZy4xL2tkbS9iYWNrZW5kL2NvbnNvbGVraXQu aAkxOTcwLTAxLTAxIDAxOjAwOjAwLjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS0zLjUuOC5k ZnNnLjEubmV3L2tkbS9iYWNrZW5kL2NvbnNvbGVraXQuaAkyMDA3LTEyLTI2IDE0OjQxOjQ2LjAw MDAwMDAwMCArMDEwMApAQCAtMCwwICsxLDM2IEBACisvKiAtKi0gTW9kZTogQzsgdGFiLXdpZHRo OiA4OyBpbmRlbnQtdGFicy1tb2RlOiB0OyBjLWJhc2ljLW9mZnNldDogOCAtKi0KKyAqCisgKiBD b3B5cmlnaHQgKEMpIDIwMDYgV2lsbGlhbSBKb24gTWNDYW5uIDxtY2Nhbm5Aamh1LmVkdT4KKyAq IENvcHlyaWdodCAoQykgMjAwNyBLZXZpbiBLb2ZsZXIgPEtldmluQHRpZ2NjLnRpY2FsYy5vcmc+ CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0 IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMg ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m CisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3 cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxl IFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8K KworCisjaWZuZGVmIF9fQ09OU09MRV9LSVRfSAorI2RlZmluZSBfX0NPTlNPTEVfS0lUX0gKKwor I2luY2x1ZGUgPHB3ZC5oPgorCitzdHJ1Y3QgZGlzcGxheTsKKworY2hhciAqICAgICAgb3Blbl9j a19zZXNzaW9uICAgICAgIChzdHJ1Y3QgcGFzc3dkICpwd2VudCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgc3RydWN0IGRpc3BsYXkgKmRpc3BsYXkpOwordm9pZCAgICAgICAg Y2xvc2VfY2tfc2Vzc2lvbiAgICAgIChjb25zdCBjaGFyICAgICpjb29raWUpOwordm9pZCAgICAg ICAgdW5sb2NrX2NrX3Nlc3Npb24gICAgIChjb25zdCBjaGFyICAgICp1c2VyLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICAgICp4MTFfZGlzcGxheSk7CisK KyNlbmRpZiAvKiBfX0NPTlNPTEVfS0lUX0ggKi8KZGlmZiAtTnVyIGtkZWJhc2UtMy41LjguZGZz Zy4xL2tkbS9iYWNrZW5kL2RtLmgga2RlYmFzZS0zLjUuOC5kZnNnLjEubmV3L2tkbS9iYWNrZW5k L2RtLmgKLS0tIGtkZWJhc2UtMy41LjguZGZzZy4xL2tkbS9iYWNrZW5kL2RtLmgJMjAwNS0wOS0x MCAxMDoyNjoxMi4wMDAwMDAwMDAgKzAyMDAKKysrIGtkZWJhc2UtMy41LjguZGZzZy4xLm5ldy9r ZG0vYmFja2VuZC9kbS5oCTIwMDctMTItMjYgMTQ6NDE6NDYuMDAwMDAwMDAwICswMTAwCkBAIC0z Nyw2ICszNyw4IEBACiAjaWZuZGVmIF9ETV9IXwogI2RlZmluZSBfRE1fSF8gMQogCisjZGVmaW5l IFdJVEhfQ09OU09MRV9LSVQKKwogI2luY2x1ZGUgImdyZWV0LmgiCiAjaW5jbHVkZSA8Y29uZmln LmNpPgogCkBAIC00NzYsNyArNDc4LDExIEBACiAjZGVmaW5lIEdDT05WX0JJTkFSWSAgNQogdHlw ZWRlZiBjaGFyICooKkdDb252RnVuYykoIGludCB3aGF0LCBjb25zdCBjaGFyICpwcm9tcHQgKTsK IGludCBWZXJpZnkoIEdDb252RnVuYyBnY29udiwgaW50IHJvb3RvayApOworI2lmZGVmIFdJVEhf Q09OU09MRV9LSVQKK2ludCBTdGFydENsaWVudCggY29uc3QgY2hhciAqY2tfc2Vzc2lvbl9jb29r aWUgKTsKKyNlbHNlCiBpbnQgU3RhcnRDbGllbnQoIHZvaWQgKTsKKyNlbmRpZgogdm9pZCBTZXNz aW9uRXhpdCggaW50IHN0YXR1cyApIEFUVFJfTk9SRVRVUk47CiBpbnQgUmVhZERtcmMoIHZvaWQg KTsKIGV4dGVybiBjaGFyICoqdXNlckVudmlyb24sICoqc3lzdGVtRW52aXJvbjsKZGlmZiAtTnVy IGtkZWJhc2UtMy41LjguZGZzZy4xL2tkbS9iYWNrZW5kL0ltYWtlZmlsZSBrZGViYXNlLTMuNS44 LmRmc2cuMS5uZXcva2RtL2JhY2tlbmQvSW1ha2VmaWxlCi0tLSBrZGViYXNlLTMuNS44LmRmc2cu MS9rZG0vYmFja2VuZC9JbWFrZWZpbGUJMjAwNS0wOS0xMCAxMDoyNjoxMi4wMDAwMDAwMDAgKzAy MDAKKysrIGtkZWJhc2UtMy41LjguZGZzZy4xLm5ldy9rZG0vYmFja2VuZC9JbWFrZWZpbGUJMjAw Ny0xMi0yNiAxNDo0MTo0Ni4wMDAwMDAwMDAgKzAxMDAKQEAgLTE1NSwxMyArMTU1LDEzIEBACiAJ CSBuZXRhZGRyLmMgcmVzZXQuYyByZXNvdXJjZS5jIHByb3RvZHB5LmMgcG9saWN5LmMgXAogCQkg c2Vzc2lvbi5jIHNvY2tldC5jIHN0cmVhbXMuYyB1dGlsLmMgeGRtY3AuYyBcCiAJCSBwcm9jZXNz LmMgbWl0YXV0aC5jIFwKLQkJIGdlbmF1dGguYyBhY2Nlc3MuYyBjaG9vc2UuYyBcCisJCSBnZW5h dXRoLmMgYWNjZXNzLmMgY2hvb3NlLmMgY29uc29sZWtpdC5jIFwKIAkJICQoWERNQVVUSFNSQ1Mp ICQoUlBDU1JDUykgJChLUkI1U1JDUykKICAgICAgIENPTU1PQkpTID0gYXV0aC5vIGRhZW1vbi5v IHNlcnZlci5vIGRweWxpc3QubyBkbS5vIGVycm9yLm8gXAogCQkgbmV0YWRkci5vIHJlc2V0Lm8g cmVzb3VyY2UubyBwcm90b2RweS5vIHBvbGljeS5vIFwKIAkJIHNlc3Npb24ubyBzb2NrZXQubyBz dHJlYW1zLm8gdXRpbC5vIHhkbWNwLm8gXAogCQkgcHJvY2Vzcy5vIG1pdGF1dGgubyBcCi0JCSBn ZW5hdXRoLm8gYWNjZXNzLm8gY2hvb3NlLm8gXAorCQkgZ2VuYXV0aC5vIGFjY2Vzcy5vIGNob29z ZS5vIGNvbnNvbGVraXQubyBcCiAJCSAkKFhETUFVVEhPQkpTKSAkKFJQQ09CSlMpICQoS1JCNU9C SlMpCiAKICAgICAgICAgIFNSQ1MxID0gJChDT01NU1JDUykgY2xpZW50LmMKZGlmZiAtTnVyIGtk ZWJhc2UtMy41LjguZGZzZy4xL2tkbS9iYWNrZW5kL01ha2VmaWxlLmFtIGtkZWJhc2UtMy41Ljgu ZGZzZy4xLm5ldy9rZG0vYmFja2VuZC9NYWtlZmlsZS5hbQotLS0ga2RlYmFzZS0zLjUuOC5kZnNn LjEva2RtL2JhY2tlbmQvTWFrZWZpbGUuYW0JMjAwNy0xMC0wOCAxMTo1MTozMy4wMDAwMDAwMDAg KzAyMDAKKysrIGtkZWJhc2UtMy41LjguZGZzZy4xLm5ldy9rZG0vYmFja2VuZC9NYWtlZmlsZS5h bQkyMDA3LTEyLTI2IDE0OjQxOjQ2LjAwMDAwMDAwMCArMDEwMApAQCAtMSw5ICsxLDkgQEAKICMg Zm9yY2libHkgcmVtb3ZlIHRocmVhZC1yZWxhdGVkIGRlZmluZXMgJiBmbGFncwogQVVUT01BS0Vf T1BUSU9OUyA9IGZvcmVpZ24KLUNQUEZMQUdTID0gJChVU0VSX0lOQ0xVREVTKSAkKFhfSU5DTFVE RVMpICQoS1JCNF9JTkNTKSAkKEtSQjVfSU5DUykgLUkuLiAtSS4uLy4uCitDUFBGTEFHUyA9ICQo VVNFUl9JTkNMVURFUykgJChYX0lOQ0xVREVTKSAkKEtSQjRfSU5DUykgJChLUkI1X0lOQ1MpICQo REJVU19JTkNTKSAtSS4uIC1JLi4vLi4KIExERkxBR1MgPSAkKFVTRVJfTERGTEFHUykgJChYX0xE RkxBR1MpICQoWF9SUEFUSCkgJChLUkI0X1JQQVRIKSAkKEtSQjVfUlBBVEgpCiBMREFERCA9ICQo TElCX1gxMSkgLWxYYXUgJChMSUJYRE1DUCkgJChQQVNTV0RMSUJTKSAkKExJQlNIQURPVykgJChM SUJHRU4pIFwKLSAgICAkKExJQl9MSUJTKSAkKEtSQjRfTElCUykgJChLUkI1X0xJQlMpICQoTElC U09DS0VUKSAkKExJQlJFU09MVikgXAorICAgICQoTElCX0xJQlMpICQoS1JCNF9MSUJTKSAkKEtS QjVfTElCUykgJChEQlVTX0xJQlMpICQoTElCU09DS0VUKSAkKExJQlJFU09MVikgXAogICAgICQo TElCVUNCKSAkKExJQlVUSUwpICQoTElCUE9TSVg0KQogCiBiaW5fUFJPR1JBTVMgPSBrZG0KQEAg LTEzLDYgKzEzLDcgQEAKICAgICBib290bWFuLmMgXAogICAgIGNob29zZS5jIFwKICAgICBjbGll bnQuYyBcCisgICAgY29uc29sZWtpdC5jIFwKICAgICBjdHJsLmMgXAogICAgIGRhZW1vbi5jIFwK ICAgICBkbS5jIFwKZGlmZiAtTnVyIGtkZWJhc2UtMy41LjguZGZzZy4xL2tkbS9iYWNrZW5kL3Nl c3Npb24uYyBrZGViYXNlLTMuNS44LmRmc2cuMS5uZXcva2RtL2JhY2tlbmQvc2Vzc2lvbi5jCi0t LSBrZGViYXNlLTMuNS44LmRmc2cuMS9rZG0vYmFja2VuZC9zZXNzaW9uLmMJMjAwNy0xMi0yNiAx NDo0MTozNC4wMDAwMDAwMDAgKzAxMDAKKysrIGtkZWJhc2UtMy41LjguZGZzZy4xLm5ldy9rZG0v YmFja2VuZC9zZXNzaW9uLmMJMjAwNy0xMi0yNiAxNDo0MTo0Ni4wMDAwMDAwMDAgKzAxMDAKQEAg LTQ1LDYgKzQ1LDEwIEBACiAjaW5jbHVkZSA8Y3R5cGUuaD4KICNpbmNsdWRlIDxzaWduYWwuaD4K IAorI2lmZGVmIFdJVEhfQ09OU09MRV9LSVQKKyNpbmNsdWRlICJjb25zb2xla2l0LmgiCisjZW5k aWYKKwogc3RydWN0IGRpc3BsYXkgKnRkOwogY29uc3QgY2hhciAqdGRfc2V0dXAgPSAiYXV0byI7 CiAKQEAgLTUzMSw2ICs1MzUsMTAgQEAKIAl2b2xhdGlsZSBpbnQgY2xpZW50UGlkID0gMDsKIAl2 b2xhdGlsZSBUaW1lX3QgdGRpZmYgPSAwOwogCisjaWZkZWYgV0lUSF9DT05TT0xFX0tJVAorCWNo YXIgKmNrX3Nlc3Npb25fY29va2llOworI2VuZGlmCisKIAl0ZCA9IGQ7CiAJRGVidWcoICJNYW5h Z2VTZXNzaW9uICVzXG4iLCBkLT5uYW1lICk7CiAJaWYgKChleCA9IFNldGptcCggYWJvcnRTZXNz aW9uICkpKSB7CkBAIC02MjYsNyArNjM0LDEyIEBACiAJaWYgKHRkX3NldHVwKQogCQlTZXR1cERp c3BsYXkoIHRkX3NldHVwICk7CiAKKyNpZmRlZiBXSVRIX0NPTlNPTEVfS0lUCisJY2tfc2Vzc2lv bl9jb29raWUgPSBvcGVuX2NrX3Nlc3Npb24gKGdldHB3bmFtKGN1cnVzZXIpLCBkKTsKKwlpZiAo IShjbGllbnRQaWQgPSBTdGFydENsaWVudChja19zZXNzaW9uX2Nvb2tpZSkpKSB7CisjZWxzZQog CWlmICghKGNsaWVudFBpZCA9IFN0YXJ0Q2xpZW50KCkpKSB7CisjZW5kaWYKIAkJTG9nRXJyb3Io ICJDbGllbnQgc3RhcnQgZmFpbGVkXG4iICk7CiAJCVNlc3Npb25FeGl0KCBFWF9OT1JNQUwgKTsg LyogWFhYIG1heWJlIEVYX1JFTUFOQUdFX0RQWT8gLS0gZW5hYmxlIGluIGRtLmMhICovCiAJfQpA QCAtNjQ4LDYgKzY2MSwxNCBAQAogCQkJCWNhdGNoVGVybSggU0lHVEVSTSApOwogCQl9CiAJfQor CisjaWZkZWYgV0lUSF9DT05TT0xFX0tJVAorCWlmIChja19zZXNzaW9uX2Nvb2tpZSAhPSBOVUxM KSB7CisJCWNsb3NlX2NrX3Nlc3Npb24gKGNrX3Nlc3Npb25fY29va2llKTsKKwkJZnJlZSAoY2tf c2Vzc2lvbl9jb29raWUpOworCX0KKyNlbmRpZgorCiAJLyoKIAkgKiBTb21ldGltZXMgdGhlIFhz ZXNzaW9uIHNvbWVob3cgbWFuYWdlcyB0byBleGl0IGJlZm9yZQogCSAqIGEgc2VydmVyIGNyYXNo IGlzIG5vdGljZWQgLSBzbyB3ZSBzbGVlcCBhIGJpdCBhbmQgd2FpdApkaWZmIC1OdXIga2RlYmFz ZS0zLjUuOC5kZnNnLjEva2RtL2NvbmZpZ3VyZS5pbi5pbiBrZGViYXNlLTMuNS44LmRmc2cuMS5u ZXcva2RtL2NvbmZpZ3VyZS5pbi5pbgotLS0ga2RlYmFzZS0zLjUuOC5kZnNnLjEva2RtL2NvbmZp Z3VyZS5pbi5pbgkyMDA2LTAxLTE5IDE4OjAzOjE1LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFz ZS0zLjUuOC5kZnNnLjEubmV3L2tkbS9jb25maWd1cmUuaW4uaW4JMjAwNy0xMi0yNiAxNDo0MTo0 My4wMDAwMDAwMDAgKzAxMDAKQEAgLTI0MCw0ICsyNDAsNTEgQEAKICAgICBBQ19ERUZJTkUoV0lU SF9LRE1fWENPTlNPTEUsIDEsIFtCdWlsZCBrZG0gd2l0aCBidWlsdC1pbiB4Y29uc29sZV0pCiBm aQogCisjIyMjIyMjIyMjIyBDaGVjayBmb3IgREJ1cworCisgIEFDX01TR19DSEVDS0lORyhmb3Ig REJ1cykKKworICBkYnVzX2luYz1OT1RGT1VORAorICBkYnVzX2xpYj1OT1RGT1VORAorICBkYnVz PU5PVEZPVU5ECisKKyAgc2VhcmNoX2luY3M9IiRrZGVfaW5jbHVkZXMgJGtkZV9leHRyYV9pbmNs dWRlcyAvdXNyL2luY2x1ZGUgL3Vzci9pbmNsdWRlL2RidXMtMS4wIC91c3IvbG9jYWwvaW5jbHVk ZSAvdXNyL2xvY2FsL2luY2x1ZGUvZGJ1cy0xLjAiCisgIEFDX0ZJTkRfRklMRShkYnVzL2RidXMu aCwgJHNlYXJjaF9pbmNzLCBkYnVzX2luY2RpcikKKworICBzZWFyY2hfaW5jc19hcmNoX2RlcHM9 IiRrZGVfaW5jbHVkZXMgJGtkZV9leHRyYV9pbmNsdWRlcyAvdXNyL2xpYiRrZGVsaWJzdWZmL2Ri dXMtMS4wL2luY2x1ZGUgL3Vzci9sb2NhbC9saWIka2RlbGlic3VmZi9kYnVzLTEuMC9pbmNsdWRl IgorICBBQ19GSU5EX0ZJTEUoZGJ1cy9kYnVzLWFyY2gtZGVwcy5oLCAkc2VhcmNoX2luY3NfYXJj aF9kZXBzLCBkYnVzX2luY2Rpcl9hcmNoX2RlcHMpCisKKyAgaWYgdGVzdCAtciAkZGJ1c19pbmNk aXIvZGJ1cy9kYnVzLmggJiYgdGVzdCAtciAkZGJ1c19pbmNkaXJfYXJjaF9kZXBzL2RidXMvZGJ1 cy1hcmNoLWRlcHMuaCA7IHRoZW4KKyAgICBEQlVTX0lOQ1M9Ii1JJGRidXNfaW5jZGlyIC1JJGRi dXNfaW5jZGlyX2FyY2hfZGVwcyIKKyAgICBkYnVzX2luYz1GT1VORAorICBmaQorCisgIHNlYXJj aF9saWJzPSIka2RlX2xpYnJhcmllcyAka2RlX2V4dHJhX2xpYnMgL3Vzci9saWIka2RlbGlic3Vm ZiAvdXNyL2xvY2FsL2xpYiRrZGVsaWJzdWZmIgorICBBQ19GSU5EX0ZJTEUobGliZGJ1cy0xLnNv LCAkc2VhcmNoX2xpYnMsIGRidXNfbGliZGlyKQorCisgIGlmIHRlc3QgLXIgJGRidXNfbGliZGly L2xpYmRidXMtMS5zbyA7IHRoZW4KKyAgICBEQlVTX0xJQlM9Ii1MJGRidXNfbGliZGlyIC1sZGJ1 cy0xIgorICAgIGRidXNfbGliPUZPVU5ECisgIGZpCisKKyAgaWYgdGVzdCAkZGJ1c19pbmMgIT0g Rk9VTkQgfHwgdGVzdCAkZGJ1c19saWIgIT0gRk9VTkQgOyB0aGVuIAorICAgIEtERV9QS0dfQ0hF Q0tfTU9EVUxFUyggREJVUywgImRidXMtMSIsIFsgREJVU19JTkNTPSREQlVTX0NGTEFHUzsgZGJ1 c19pbmM9Rk9VTkQ7IGRidXNfbGliPUZPVU5EOyBdICwgQUNfTVNHX1JFU1VMVCggTm90aGluZyBm b3VuZCBvbiBQS0dfQ09ORklHX1BBVEggKSApCisgIGZpCisKKyAgZGJ1c19idXNfdmFyPWBwa2ct Y29uZmlnIC0tdmFyaWFibGU9c3lzdGVtX2J1c19kZWZhdWx0X2FkZHJlc3MgZGJ1cy0xIDI+L2Rl di9udWxsYAorICBpZiB0ZXN0IC16ICIkZGJ1c19idXNfdmFyIjsgdGhlbgorICAgICAgICBkYnVz X2J1c192YXI9InVuaXg6cGF0aD0vdmFyL3J1bi9kYnVzL3N5c3RlbV9idXNfc29ja2V0IgorICBm aQorICBBQ19ERUZJTkVfVU5RVU9URUQoREJVU19TWVNURU1fQlVTLCAiJGRidXNfYnVzX3ZhciIs IFtEZWZpbmUgdGhlIHVuaXggZG9tYWluIHBhdGggZm9yIGRidXMgc3lzdGVtIGJ1c10pCisKKyAg aWYgdGVzdCAkZGJ1c19pbmMgPSBGT1VORCAmJiB0ZXN0ICRkYnVzX2xpYiA9IEZPVU5EIDsgdGhl bgorICAgIEFDX01TR19SRVNVTFQoaGVhZGVycyAkREJVU19JTkNTIGxpYnJhcmllcyAkREJVU19M SUJTKQorICAgIGRidXM9Rk9VTkQKKyAgZWxzZQorICAgIEFDX01TR19SRVNVTFQoc2VhcmNoZWQg YnV0IG5vdCBmb3VuZCkKKyAgZmkKKworICBBQ19TVUJTVChEQlVTX0lOQ1MpCisgIEFDX1NVQlNU KERCVVNfTElCUykKKwogZG5sIEFDX09VVFBVVChrZG0va2Zyb250ZW5kL3Nlc3Npb25zL2tkZS5k ZXNrdG9wKQo= 23031 2008-01-14 17:07:38 +0000 2008-07-15 18:08:10 +0000 kdm consolekit support patch for 3.5.8 (with Mandriva fixes) kdebase-3.5.8-consolekit-kdm.patch text/plain 24363 kevin.kofler ZGlmZiAtdXAga2RlYmFzZS0zLjUuOC9rZG0vY29uZmlndXJlLmluLmluLmNvbnNvbGVraXQga2Rl YmFzZS0zLjUuOC9rZG0vY29uZmlndXJlLmluLmluCi0tLSBrZGViYXNlLTMuNS44L2tkbS9jb25m aWd1cmUuaW4uaW4uY29uc29sZWtpdAkyMDA2LTAxLTE5IDExOjAzOjE1LjAwMDAwMDAwMCAtMDYw MAorKysga2RlYmFzZS0zLjUuOC9rZG0vY29uZmlndXJlLmluLmluCTIwMDctMTEtMjggMTQ6MDg6 MjIuMDAwMDAwMDAwIC0wNjAwCkBAIC0yNDAsNCArMjQwLDUxIEBAIGlmIHRlc3QgIngkd2l0aF9r ZG1feGNvbnNvbGUiID0geHllczsgdGgKICAgICBBQ19ERUZJTkUoV0lUSF9LRE1fWENPTlNPTEUs IDEsIFtCdWlsZCBrZG0gd2l0aCBidWlsdC1pbiB4Y29uc29sZV0pCiBmaQogCisjIyMjIyMjIyMj IyBDaGVjayBmb3IgREJ1cworCisgIEFDX01TR19DSEVDS0lORyhmb3IgREJ1cykKKworICBkYnVz X2luYz1OT1RGT1VORAorICBkYnVzX2xpYj1OT1RGT1VORAorICBkYnVzPU5PVEZPVU5ECisKKyAg c2VhcmNoX2luY3M9IiRrZGVfaW5jbHVkZXMgJGtkZV9leHRyYV9pbmNsdWRlcyAvdXNyL2luY2x1 ZGUgL3Vzci9pbmNsdWRlL2RidXMtMS4wIC91c3IvbG9jYWwvaW5jbHVkZSAvdXNyL2xvY2FsL2lu Y2x1ZGUvZGJ1cy0xLjAiCisgIEFDX0ZJTkRfRklMRShkYnVzL2RidXMuaCwgJHNlYXJjaF9pbmNz LCBkYnVzX2luY2RpcikKKworICBzZWFyY2hfaW5jc19hcmNoX2RlcHM9IiRrZGVfaW5jbHVkZXMg JGtkZV9leHRyYV9pbmNsdWRlcyAvdXNyL2xpYiRrZGVsaWJzdWZmL2RidXMtMS4wL2luY2x1ZGUg L3Vzci9sb2NhbC9saWIka2RlbGlic3VmZi9kYnVzLTEuMC9pbmNsdWRlIgorICBBQ19GSU5EX0ZJ TEUoZGJ1cy9kYnVzLWFyY2gtZGVwcy5oLCAkc2VhcmNoX2luY3NfYXJjaF9kZXBzLCBkYnVzX2lu Y2Rpcl9hcmNoX2RlcHMpCisKKyAgaWYgdGVzdCAtciAkZGJ1c19pbmNkaXIvZGJ1cy9kYnVzLmgg JiYgdGVzdCAtciAkZGJ1c19pbmNkaXJfYXJjaF9kZXBzL2RidXMvZGJ1cy1hcmNoLWRlcHMuaCA7 IHRoZW4KKyAgICBEQlVTX0lOQ1M9Ii1JJGRidXNfaW5jZGlyIC1JJGRidXNfaW5jZGlyX2FyY2hf ZGVwcyIKKyAgICBkYnVzX2luYz1GT1VORAorICBmaQorCisgIHNlYXJjaF9saWJzPSIka2RlX2xp YnJhcmllcyAka2RlX2V4dHJhX2xpYnMgL3Vzci9saWIka2RlbGlic3VmZiAvdXNyL2xvY2FsL2xp YiRrZGVsaWJzdWZmIgorICBBQ19GSU5EX0ZJTEUobGliZGJ1cy0xLnNvLCAkc2VhcmNoX2xpYnMs IGRidXNfbGliZGlyKQorCisgIGlmIHRlc3QgLXIgJGRidXNfbGliZGlyL2xpYmRidXMtMS5zbyA7 IHRoZW4KKyAgICBEQlVTX0xJQlM9Ii1MJGRidXNfbGliZGlyIC1sZGJ1cy0xIgorICAgIGRidXNf bGliPUZPVU5ECisgIGZpCisKKyAgaWYgdGVzdCAkZGJ1c19pbmMgIT0gRk9VTkQgfHwgdGVzdCAk ZGJ1c19saWIgIT0gRk9VTkQgOyB0aGVuIAorICAgIEtERV9QS0dfQ0hFQ0tfTU9EVUxFUyggREJV UywgImRidXMtMSIsIFsgREJVU19JTkNTPSREQlVTX0NGTEFHUzsgZGJ1c19pbmM9Rk9VTkQ7IGRi dXNfbGliPUZPVU5EOyBdICwgQUNfTVNHX1JFU1VMVCggTm90aGluZyBmb3VuZCBvbiBQS0dfQ09O RklHX1BBVEggKSApCisgIGZpCisKKyAgZGJ1c19idXNfdmFyPWBwa2ctY29uZmlnIC0tdmFyaWFi bGU9c3lzdGVtX2J1c19kZWZhdWx0X2FkZHJlc3MgZGJ1cy0xIDI+L2Rldi9udWxsYAorICBpZiB0 ZXN0IC16ICIkZGJ1c19idXNfdmFyIjsgdGhlbgorICAgICAgICBkYnVzX2J1c192YXI9InVuaXg6 cGF0aD0vdmFyL3J1bi9kYnVzL3N5c3RlbV9idXNfc29ja2V0IgorICBmaQorICBBQ19ERUZJTkVf VU5RVU9URUQoREJVU19TWVNURU1fQlVTLCAiJGRidXNfYnVzX3ZhciIsIFtEZWZpbmUgdGhlIHVu aXggZG9tYWluIHBhdGggZm9yIGRidXMgc3lzdGVtIGJ1c10pCisKKyAgaWYgdGVzdCAkZGJ1c19p bmMgPSBGT1VORCAmJiB0ZXN0ICRkYnVzX2xpYiA9IEZPVU5EIDsgdGhlbgorICAgIEFDX01TR19S RVNVTFQoaGVhZGVycyAkREJVU19JTkNTIGxpYnJhcmllcyAkREJVU19MSUJTKQorICAgIGRidXM9 Rk9VTkQKKyAgZWxzZQorICAgIEFDX01TR19SRVNVTFQoc2VhcmNoZWQgYnV0IG5vdCBmb3VuZCkK KyAgZmkKKworICBBQ19TVUJTVChEQlVTX0lOQ1MpCisgIEFDX1NVQlNUKERCVVNfTElCUykKKwog ZG5sIEFDX09VVFBVVChrZG0va2Zyb250ZW5kL3Nlc3Npb25zL2tkZS5kZXNrdG9wKQpkaWZmIC11 cCAvZGV2L251bGwga2RlYmFzZS0zLjUuOC9rZG0vYmFja2VuZC9jb25zb2xla2l0LmgKLS0tIC9k ZXYvbnVsbAkyMDA3LTExLTEzIDA4OjQ3OjI1Ljg5MTA2MDQ5NyAtMDYwMAorKysga2RlYmFzZS0z LjUuOC9rZG0vYmFja2VuZC9jb25zb2xla2l0LmgJMjAwNy0xMS0yOCAxNDowODoyMi4wMDAwMDAw MDAgLTA2MDAKQEAgLTAsMCArMSwzNiBAQAorLyogLSotIE1vZGU6IEM7IHRhYi13aWR0aDogODsg aW5kZW50LXRhYnMtbW9kZTogdDsgYy1iYXNpYy1vZmZzZXQ6IDggLSotCisgKgorICogQ29weXJp Z2h0IChDKSAyMDA2IFdpbGxpYW0gSm9uIE1jQ2FubiA8bWNjYW5uQGpodS5lZHU+CisgKiBDb3B5 cmlnaHQgKEMpIDIwMDcgS2V2aW4gS29mbGVyIDxLZXZpbkB0aWdjYy50aWNhbGMub3JnPgorICoK KyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3Vy IG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3Ry aWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICog TUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAq CisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUg dG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFj ZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICovCisKKwor I2lmbmRlZiBfX0NPTlNPTEVfS0lUX0gKKyNkZWZpbmUgX19DT05TT0xFX0tJVF9ICisKKyNpbmNs dWRlIDxwd2QuaD4KKworc3RydWN0IGRpc3BsYXk7CisKK2NoYXIgKiAgICAgIG9wZW5fY2tfc2Vz c2lvbiAgICAgICAoc3RydWN0IHBhc3N3ZCAqcHdlbnQsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHN0cnVjdCBkaXNwbGF5ICpkaXNwbGF5KTsKK3ZvaWQgICAgICAgIGNsb3Nl X2NrX3Nlc3Npb24gICAgICAoY29uc3QgY2hhciAgICAqY29va2llKTsKK3ZvaWQgICAgICAgIHVu bG9ja19ja19zZXNzaW9uICAgICAoY29uc3QgY2hhciAgICAqdXNlciwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAgICAqeDExX2Rpc3BsYXkpOworCisjZW5k aWYgLyogX19DT05TT0xFX0tJVF9IICovCmRpZmYgLXVwIGtkZWJhc2UtMy41Ljgva2RtL2JhY2tl bmQvc2Vzc2lvbi5jLmNvbnNvbGVraXQga2RlYmFzZS0zLjUuOC9rZG0vYmFja2VuZC9zZXNzaW9u LmMKLS0tIGtkZWJhc2UtMy41Ljgva2RtL2JhY2tlbmQvc2Vzc2lvbi5jLmNvbnNvbGVraXQJMjAw Ny0xMC0wOCAwNDo1MTozMy4wMDAwMDAwMDAgLTA1MDAKKysrIGtkZWJhc2UtMy41Ljgva2RtL2Jh Y2tlbmQvc2Vzc2lvbi5jCTIwMDctMTEtMjggMTQ6MTM6MDUuMDAwMDAwMDAwIC0wNjAwCkBAIC00 NSw2ICs0NSwxMCBAQCBmcm9tIHRoZSBjb3B5cmlnaHQgaG9sZGVyLgogI2luY2x1ZGUgPGN0eXBl Lmg+CiAjaW5jbHVkZSA8c2lnbmFsLmg+CiAKKyNpZmRlZiBXSVRIX0NPTlNPTEVfS0lUCisjaW5j bHVkZSAiY29uc29sZWtpdC5oIgorI2VuZGlmCisKIHN0cnVjdCBkaXNwbGF5ICp0ZDsKIGNvbnN0 IGNoYXIgKnRkX3NldHVwID0gImF1dG8iOwogCkBAIC01MjYsNiArNTMwLDEwIEBAIE1hbmFnZVNl c3Npb24oIHN0cnVjdCBkaXNwbGF5ICpkICkKIAlpbnQgZXgsIGNtZDsKIAl2b2xhdGlsZSBpbnQg Y2xpZW50UGlkID0gMDsKIAl2b2xhdGlsZSBUaW1lX3QgdGRpZmYgPSAwOworI2lmZGVmIFdJVEhf Q09OU09MRV9LSVQKKwljaGFyICpja19zZXNzaW9uX2Nvb2tpZTsKKyNlbmRpZgorCiAKIAl0ZCA9 IGQ7CiAJRGVidWcoICJNYW5hZ2VTZXNzaW9uICVzXG4iLCBkLT5uYW1lICk7CkBAIC02MjIsNyAr NjMwLDEyIEBAIE1hbmFnZVNlc3Npb24oIHN0cnVjdCBkaXNwbGF5ICpkICkKIAlpZiAodGRfc2V0 dXApCiAJCVNldHVwRGlzcGxheSggdGRfc2V0dXAgKTsKIAorI2lmZGVmIFdJVEhfQ09OU09MRV9L SVQKKwlja19zZXNzaW9uX2Nvb2tpZSA9IG9wZW5fY2tfc2Vzc2lvbiAoZ2V0cHduYW0oY3VydXNl ciksIGQpOworCWlmICghKGNsaWVudFBpZCA9IFN0YXJ0Q2xpZW50KGNrX3Nlc3Npb25fY29va2ll KSkpIHsKKyNlbHNlCiAJaWYgKCEoY2xpZW50UGlkID0gU3RhcnRDbGllbnQoKSkpIHsKKyNlbmRp ZgogCQlMb2dFcnJvciggIkNsaWVudCBzdGFydCBmYWlsZWRcbiIgKTsKIAkJU2Vzc2lvbkV4aXQo IEVYX05PUk1BTCApOyAvKiBYWFggbWF5YmUgRVhfUkVNQU5BR0VfRFBZPyAtLSBlbmFibGUgaW4g ZG0uYyEgKi8KIAl9CkBAIC02NDQsNiArNjU3LDE0IEBAIE1hbmFnZVNlc3Npb24oIHN0cnVjdCBk aXNwbGF5ICpkICkKIAkJCQljYXRjaFRlcm0oIFNJR1RFUk0gKTsKIAkJfQogCX0KKworI2lmZGVm IFdJVEhfQ09OU09MRV9LSVQKKwlpZiAoY2tfc2Vzc2lvbl9jb29raWUgIT0gTlVMTCkgeworCQlj bG9zZV9ja19zZXNzaW9uIChja19zZXNzaW9uX2Nvb2tpZSk7CisJCWZyZWUgKGNrX3Nlc3Npb25f Y29va2llKTsKKwl9CisjZW5kaWYKKwogCS8qCiAJICogU29tZXRpbWVzIHRoZSBYc2Vzc2lvbiBz b21laG93IG1hbmFnZXMgdG8gZXhpdCBiZWZvcmUKIAkgKiBhIHNlcnZlciBjcmFzaCBpcyBub3Rp Y2VkIC0gc28gd2Ugc2xlZXAgYSBiaXQgYW5kIHdhaXQKZGlmZiAtdXAga2RlYmFzZS0zLjUuOC9r ZG0vYmFja2VuZC9kbS5oLmNvbnNvbGVraXQga2RlYmFzZS0zLjUuOC9rZG0vYmFja2VuZC9kbS5o Ci0tLSBrZGViYXNlLTMuNS44L2tkbS9iYWNrZW5kL2RtLmguY29uc29sZWtpdAkyMDA1LTA5LTEw IDAzOjI2OjEyLjAwMDAwMDAwMCAtMDUwMAorKysga2RlYmFzZS0zLjUuOC9rZG0vYmFja2VuZC9k bS5oCTIwMDctMTEtMjggMTQ6MDg6MjIuMDAwMDAwMDAwIC0wNjAwCkBAIC0zNyw2ICszNyw4IEBA IGZyb20gdGhlIGNvcHlyaWdodCBob2xkZXIuCiAjaWZuZGVmIF9ETV9IXwogI2RlZmluZSBfRE1f SF8gMQogCisjZGVmaW5lIFdJVEhfQ09OU09MRV9LSVQKKwogI2luY2x1ZGUgImdyZWV0LmgiCiAj aW5jbHVkZSA8Y29uZmlnLmNpPgogCkBAIC00NzYsNyArNDc4LDExIEBAIGNoYXIgKipHUmVjdkFy Z3YoIHZvaWQgKTsKICNkZWZpbmUgR0NPTlZfQklOQVJZICA1CiB0eXBlZGVmIGNoYXIgKigqR0Nv bnZGdW5jKSggaW50IHdoYXQsIGNvbnN0IGNoYXIgKnByb21wdCApOwogaW50IFZlcmlmeSggR0Nv bnZGdW5jIGdjb252LCBpbnQgcm9vdG9rICk7CisjaWZkZWYgV0lUSF9DT05TT0xFX0tJVAoraW50 IFN0YXJ0Q2xpZW50KCBjb25zdCBjaGFyICpja19zZXNzaW9uX2Nvb2tpZSApOworI2Vsc2UKIGlu dCBTdGFydENsaWVudCggdm9pZCApOworI2VuZGlmCiB2b2lkIFNlc3Npb25FeGl0KCBpbnQgc3Rh dHVzICkgQVRUUl9OT1JFVFVSTjsKIGludCBSZWFkRG1yYyggdm9pZCApOwogZXh0ZXJuIGNoYXIg Kip1c2VyRW52aXJvbiwgKipzeXN0ZW1FbnZpcm9uOwpkaWZmIC11cCBrZGViYXNlLTMuNS44L2tk bS9iYWNrZW5kL3hkbWNwLmMuY29uc29sZWtpdCBrZGViYXNlLTMuNS44L2tkbS9iYWNrZW5kL3hk bWNwLmMKLS0tIGtkZWJhc2UtMy41Ljgva2RtL2JhY2tlbmQveGRtY3AuYy5jb25zb2xla2l0CTIw MDYtMDctMjIgMDM6MTU6NTUuMDAwMDAwMDAwIC0wNTAwCisrKyBrZGViYXNlLTMuNS44L2tkbS9i YWNrZW5kL3hkbWNwLmMJMjAwNy0xMS0yOCAxNDowODoyMi4wMDAwMDAwMDAgLTA2MDAKQEAgLTky NCw2ICs5MjQsOSBAQCBtYW5hZ2UoIHN0cnVjdCBzb2NrYWRkciAqZnJvbSwgaW50IGZyb21sCiAJ CQl9CiAJCQlkLT5jbGllbnRBZGRyID0gY2xpZW50QWRkcmVzczsKIAkJCWQtPmNvbm5lY3Rpb25U eXBlID0gY29ubmVjdGlvblR5cGU7CisJCQlkLT5yZW1vdGVIb3N0ID0gTmV0d29ya0FkZHJlc3NU b0hvc3RuYW1lIChwZHB5LT5jb25uZWN0aW9uVHlwZSwKKwkJCSAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgJnBkcHktPmNvbm5lY3Rpb25BZGRyZXNzKTsKKwogCQkJWGRtY3BEaXNwb3NlQVJS QVk4KCAmY2xpZW50UG9ydCApOwogCQkJaWYgKHBkcHktPmZpbGVBdXRob3JpemF0aW9uKSB7CiAJ CQkJZC0+YXV0aG9yaXphdGlvbnMgPSAoWGF1dGggKiopTWFsbG9jKCBzaXplb2YoWGF1dGggKikg KTsKZGlmZiAtdXAgL2Rldi9udWxsIGtkZWJhc2UtMy41Ljgva2RtL2JhY2tlbmQvY29uc29sZWtp dC5jCi0tLSAvZGV2L251bGwJMjAwNy0xMS0xMyAwODo0NzoyNS44OTEwNjA0OTcgLTA2MDAKKysr IGtkZWJhc2UtMy41Ljgva2RtL2JhY2tlbmQvY29uc29sZWtpdC5jCTIwMDctMTEtMjggMTQ6MDg6 MjIuMDAwMDAwMDAwIC0wNjAwCkBAIC0wLDAgKzEsNTU3IEBACisvKiAtKi0gTW9kZTogQzsgdGFi LXdpZHRoOiA4OyBpbmRlbnQtdGFicy1tb2RlOiB0OyBjLWJhc2ljLW9mZnNldDogOCAtKi0KKyAq CisgKiBDb3B5cmlnaHQgKEMpIDIwMDYtMjAwNyBXaWxsaWFtIEpvbiBNY0Nhbm4gPG1jY2FubkBq aHUuZWR1PgorICogQ29weXJpZ2h0IChDKSAyMDA3IEtldmluIEtvZmxlciA8S2V2aW5AdGlnY2Mu dGljYWxjLm9yZz4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAqIHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yCisgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMg cHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFt OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMu LCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNB LgorICoKKyAqLworCisjaW5jbHVkZSAiZG0uaCIKKyNpbmNsdWRlICJkbV9hdXRoLmgiCisjaW5j bHVkZSAiZG1fZXJyb3IuaCIKKworI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2luY2x1ZGUgPHN0cmlu Zy5oPgorI2luY2x1ZGUgPHB3ZC5oPgorCisjZGVmaW5lIERCVVNfQVBJX1NVQkpFQ1RfVE9fQ0hB TkdFCisjaW5jbHVkZSA8ZGJ1cy9kYnVzLmg+CisKKyNpbmNsdWRlICJjb25zb2xla2l0LmgiCisK KworI2RlZmluZSBDS19OQU1FICAgICAgICAgICAgICAib3JnLmZyZWVkZXNrdG9wLkNvbnNvbGVL aXQiCisjZGVmaW5lIENLX1BBVEggICAgICAgICAgICAgICIvb3JnL2ZyZWVkZXNrdG9wL0NvbnNv bGVLaXQiCisjZGVmaW5lIENLX0lOVEVSRkFDRSAgICAgICAgICJvcmcuZnJlZWRlc2t0b3AuQ29u c29sZUtpdCIKKyNkZWZpbmUgQ0tfTUFOQUdFUl9QQVRIICAgICAgIi9vcmcvZnJlZWRlc2t0b3Av Q29uc29sZUtpdC9NYW5hZ2VyIgorI2RlZmluZSBDS19NQU5BR0VSX0lOVEVSRkFDRSAib3JnLmZy ZWVkZXNrdG9wLkNvbnNvbGVLaXQuTWFuYWdlciIKKyNkZWZpbmUgQ0tfU0VTU0lPTl9JTlRFUkZB Q0UgIm9yZy5mcmVlZGVza3RvcC5Db25zb2xlS2l0LlNlc3Npb24iCisKK3N0YXRpYyBEQnVzQ29u bmVjdGlvbiAqcHJpdmF0ZV9jb25uZWN0aW9uID0gTlVMTDsKKworc3RhdGljIHZvaWQKK2FkZF9w YXJhbV9pbnQgKERCdXNNZXNzYWdlSXRlciAqaXRlcl9zdHJ1Y3QsCisJICAgICAgIGNvbnN0IGNo YXIgICAgICAqa2V5LAorCSAgICAgICBpbnQgICAgICAgICAgICAgIHZhbHVlKQoreworCURCdXNN ZXNzYWdlSXRlciBpdGVyX3N0cnVjdF9lbnRyeTsKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcl92YXI7 CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5lciAoaXRlcl9zdHJ1Y3QsCisJCQkJ CSAgREJVU19UWVBFX1NUUlVDVCwKKwkJCQkJICBOVUxMLAorCQkJCQkgICZpdGVyX3N0cnVjdF9l bnRyeSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMgKCZpdGVyX3N0cnVjdF9l bnRyeSwKKwkJCQkJREJVU19UWVBFX1NUUklORywKKwkJCQkJJmtleSk7CisKKwlkYnVzX21lc3Nh Z2VfaXRlcl9vcGVuX2NvbnRhaW5lciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgIERCVVNf VFlQRV9WQVJJQU5ULAorCQkJCQkgIERCVVNfVFlQRV9JTlQzMl9BU19TVFJJTkcsCisJCQkJCSAg Jml0ZXJfdmFyKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXJfdmFy LAorCQkJCQlEQlVTX1RZUEVfSU5UMzIsCisJCQkJCSZ2YWx1ZSk7CisKKwlkYnVzX21lc3NhZ2Vf aXRlcl9jbG9zZV9jb250YWluZXIgKCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJICAgJml0ZXJf dmFyKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lciAoaXRlcl9zdHJ1Y3Qs ICZpdGVyX3N0cnVjdF9lbnRyeSk7Cit9CisKK3N0YXRpYyB2b2lkCithZGRfcGFyYW1fYm9vbGVh biAoREJ1c01lc3NhZ2VJdGVyICppdGVyX3N0cnVjdCwKKwkJICAgY29uc3QgY2hhciAgICAgICpr ZXksCisJCSAgIGludCAgICAgICAgICAgICB2YWx1ZSkKK3sKKwlEQnVzTWVzc2FnZUl0ZXIgaXRl cl9zdHJ1Y3RfZW50cnk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXJfdmFyOworCisJZGJ1c19tZXNz YWdlX2l0ZXJfb3Blbl9jb250YWluZXIgKGl0ZXJfc3RydWN0LAorCQkJCQkgIERCVVNfVFlQRV9T VFJVQ1QsCisJCQkJCSAgTlVMTCwKKwkJCQkJICAmaXRlcl9zdHJ1Y3RfZW50cnkpOworCisJZGJ1 c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljICgmaXRlcl9zdHJ1Y3RfZW50cnksCisJCQkJCURC VVNfVFlQRV9TVFJJTkcsCisJCQkJCSZrZXkpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfb3Blbl9j b250YWluZXIgKCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJICBEQlVTX1RZUEVfVkFSSUFOVCwK KwkJCQkJICBEQlVTX1RZUEVfQk9PTEVBTl9BU19TVFJJTkcsCisJCQkJCSAgJml0ZXJfdmFyKTsK KworCWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXJfdmFyLAorCQkJCQlEQlVT X1RZUEVfQk9PTEVBTiwKKwkJCQkJJnZhbHVlKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2Nsb3Nl X2NvbnRhaW5lciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgICAmaXRlcl92YXIpOworCisJ ZGJ1c19tZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFpbmVyIChpdGVyX3N0cnVjdCwgJml0ZXJfc3Ry dWN0X2VudHJ5KTsKK30KKworc3RhdGljIHZvaWQKK2FkZF9wYXJhbV9zdHJpbmcgKERCdXNNZXNz YWdlSXRlciAqaXRlcl9zdHJ1Y3QsCisJCSAgY29uc3QgY2hhciAgICAgICprZXksCisJCSAgY29u c3QgY2hhciAgICAgICp2YWx1ZSkKK3sKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcl9zdHJ1Y3RfZW50 cnk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXJfdmFyOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfb3Bl bl9jb250YWluZXIgKGl0ZXJfc3RydWN0LAorCQkJCQkgIERCVVNfVFlQRV9TVFJVQ1QsCisJCQkJ CSAgTlVMTCwKKwkJCQkJICAmaXRlcl9zdHJ1Y3RfZW50cnkpOworCisJZGJ1c19tZXNzYWdlX2l0 ZXJfYXBwZW5kX2Jhc2ljICgmaXRlcl9zdHJ1Y3RfZW50cnksCisJCQkJCURCVVNfVFlQRV9TVFJJ TkcsCisJCQkJCSZrZXkpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfb3Blbl9jb250YWluZXIgKCZp dGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJICBEQlVTX1RZUEVfVkFSSUFOVCwKKwkJCQkJICBEQlVT X1RZUEVfU1RSSU5HX0FTX1NUUklORywKKwkJCQkJICAmaXRlcl92YXIpOworCisJZGJ1c19tZXNz YWdlX2l0ZXJfYXBwZW5kX2Jhc2ljICgmaXRlcl92YXIsCisJCQkJCURCVVNfVFlQRV9TVFJJTkcs CisJCQkJCSZ2YWx1ZSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9jbG9zZV9jb250YWluZXIgKCZp dGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJICAgJml0ZXJfdmFyKTsKKworCWRidXNfbWVzc2FnZV9p dGVyX2Nsb3NlX2NvbnRhaW5lciAoaXRlcl9zdHJ1Y3QsICZpdGVyX3N0cnVjdF9lbnRyeSk7Cit9 CisKK3N0YXRpYyBpbnQKK3Nlc3Npb25fZ2V0X3gxMV9kaXNwbGF5IChEQnVzQ29ubmVjdGlvbiAq Y29ubmVjdGlvbiwKKwkJCSBjb25zdCBjaGFyICAgICAqc3NpZCwKKwkJCSBjaGFyICAgICAgICAg ICoqc3RyKQoreworCURCdXNFcnJvciAgICAgICBlcnJvcjsKKwlEQnVzTWVzc2FnZSAgICAqbWVz c2FnZTsKKwlEQnVzTWVzc2FnZSAgICAqcmVwbHk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXI7CisJ Y29uc3QgY2hhciAgICAgKnZhbHVlOworCisJaWYgKHN0ciAhPSBOVUxMKSB7CisJCSpzdHIgPSBO VUxMOworCX0KKworCW1lc3NhZ2UgPSBkYnVzX21lc3NhZ2VfbmV3X21ldGhvZF9jYWxsIChDS19O QU1FLAorCQkJCQkJc3NpZCwKKwkJCQkJCUNLX1NFU1NJT05fSU5URVJGQUNFLAorCQkJCQkJIkdl dFgxMURpc3BsYXkiKTsKKwlpZiAobWVzc2FnZSA9PSBOVUxMKSB7CisJCURlYnVnICgiQ29uc29s ZUtpdDogQ291bGRuJ3QgYWxsb2NhdGUgdGhlIEQtQnVzIG1lc3NhZ2UiKTsKKwkJcmV0dXJuIEZB TFNFOworCX0KKworCWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwlyZXBseSA9IGRidXNfY29u bmVjdGlvbl9zZW5kX3dpdGhfcmVwbHlfYW5kX2Jsb2NrIChjb25uZWN0aW9uLAorCQkJCQkJCSAg IG1lc3NhZ2UsCisJCQkJCQkJICAgLTEsICZlcnJvcik7CisJaWYgKGRidXNfZXJyb3JfaXNfc2V0 ICgmZXJyb3IpKSB7CisJCURlYnVnICgiQ29uc29sZUtpdDogJXMgcmFpc2VkOlxuICVzXG5cbiIs IGVycm9yLm5hbWUsIGVycm9yLm1lc3NhZ2UpOworCQlyZXBseSA9IE5VTEw7CisJfQorCisJZGJ1 c19jb25uZWN0aW9uX2ZsdXNoIChjb25uZWN0aW9uKTsKKwlkYnVzX21lc3NhZ2VfdW5yZWYgKG1l c3NhZ2UpOworCisJaWYgKHJlcGx5ID09IE5VTEwpIHsKKwkJcmV0dXJuIEZBTFNFOworCX0KKwor CWRidXNfbWVzc2FnZV9pdGVyX2luaXQgKHJlcGx5LCAmaXRlcik7CisJZGJ1c19tZXNzYWdlX2l0 ZXJfZ2V0X2Jhc2ljICgmaXRlciwgJnZhbHVlKTsKKwlpZiAoc3RyICE9IE5VTEwpIHsKKwkJKnN0 ciA9IHN0cmR1cCAodmFsdWUpOworCX0KKwlkYnVzX21lc3NhZ2VfdW5yZWYgKHJlcGx5KTsKKwor CXJldHVybiBUUlVFOworfQorCitzdGF0aWMgaW50CitzZXNzaW9uX3VubG9jayAoREJ1c0Nvbm5l Y3Rpb24gKmNvbm5lY3Rpb24sCisJCWNvbnN0IGNoYXIgICAgICpzc2lkKQoreworCURCdXNFcnJv ciAgICAgICBlcnJvcjsKKwlEQnVzTWVzc2FnZSAgICAqbWVzc2FnZTsKKwlEQnVzTWVzc2FnZSAg ICAqcmVwbHk7CisKKwlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IFVubG9ja2luZyBzZXNzaW9uICVzIiwg c3NpZCk7CisJbWVzc2FnZSA9IGRidXNfbWVzc2FnZV9uZXdfbWV0aG9kX2NhbGwgKENLX05BTUUs CisJCQkJCQlzc2lkLAorCQkJCQkJQ0tfU0VTU0lPTl9JTlRFUkZBQ0UsCisJCQkJCQkiVW5sb2Nr Iik7CisJaWYgKG1lc3NhZ2UgPT0gTlVMTCkgeworCQlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IENvdWxk bid0IGFsbG9jYXRlIHRoZSBELUJ1cyBtZXNzYWdlIik7CisJCXJldHVybiBGQUxTRTsKKwl9CisK KwlkYnVzX2Vycm9yX2luaXQgKCZlcnJvcik7CisJcmVwbHkgPSBkYnVzX2Nvbm5lY3Rpb25fc2Vu ZF93aXRoX3JlcGx5X2FuZF9ibG9jayAoY29ubmVjdGlvbiwKKwkJCQkJCQkgICBtZXNzYWdlLAor CQkJCQkJCSAgIC0xLCAmZXJyb3IpOworCWRidXNfbWVzc2FnZV91bnJlZiAobWVzc2FnZSk7CisJ ZGJ1c19tZXNzYWdlX3VucmVmIChyZXBseSk7CisJZGJ1c19jb25uZWN0aW9uX2ZsdXNoIChjb25u ZWN0aW9uKTsKKworCWlmIChkYnVzX2Vycm9yX2lzX3NldCAoJmVycm9yKSkgeworCQlEZWJ1ZyAo IkNvbnNvbGVLaXQ6ICVzIHJhaXNlZDpcbiAlc1xuXG4iLCBlcnJvci5uYW1lLCBlcnJvci5tZXNz YWdlKTsKKwkJcmV0dXJuIEZBTFNFOworCX0KKworCXJldHVybiBUUlVFOworfQorCisvKiBmcm9t IGxpYmhhbCAqLworc3RhdGljIGNoYXIgKioKK2dldF9wYXRoX2FycmF5X2Zyb21faXRlciAoREJ1 c01lc3NhZ2VJdGVyICppdGVyLAorCQkJICBpbnQgICAgICAgICAgICAgKm51bV9lbGVtZW50cykK K3sKKwlpbnQgY291bnQ7CisJY2hhciAqKmJ1ZmZlcjsKKworCWNvdW50ID0gMDsKKwlidWZmZXIg PSAoY2hhciAqKiltYWxsb2MgKHNpemVvZiAoY2hhciAqKSAqIDgpOworCisJaWYgKGJ1ZmZlciA9 PSBOVUxMKQorCQlnb3RvIG9vbTsKKworCWJ1ZmZlclswXSA9IE5VTEw7CisJd2hpbGUgKGRidXNf bWVzc2FnZV9pdGVyX2dldF9hcmdfdHlwZSAoaXRlcikgPT0gREJVU19UWVBFX09CSkVDVF9QQVRI KSB7CisJCWNvbnN0IGNoYXIgKnZhbHVlOworCQljaGFyICpzdHI7CisKKwkJaWYgKChjb3VudCAl IDgpID09IDAgJiYgY291bnQgIT0gMCkgeworCQkJYnVmZmVyID0gcmVhbGxvYyAoYnVmZmVyLCBz aXplb2YgKGNoYXIgKikgKiAoY291bnQgKyA4KSk7CisJCQlpZiAoYnVmZmVyID09IE5VTEwpCisJ CQkJZ290byBvb207CisJCX0KKworCQlkYnVzX21lc3NhZ2VfaXRlcl9nZXRfYmFzaWMgKGl0ZXIs ICZ2YWx1ZSk7CisJCXN0ciA9IHN0cmR1cCAodmFsdWUpOworCQlpZiAoc3RyID09IE5VTEwpCisJ CQlnb3RvIG9vbTsKKworCQlidWZmZXJbY291bnRdID0gc3RyOworCisJCWRidXNfbWVzc2FnZV9p dGVyX25leHQgKGl0ZXIpOworCQljb3VudCsrOworCX0KKworCWlmICgoY291bnQgJSA4KSA9PSAw KSB7CisJCWJ1ZmZlciA9IHJlYWxsb2MgKGJ1ZmZlciwgc2l6ZW9mIChjaGFyICopICogKGNvdW50 ICsgMSkpOworCQlpZiAoYnVmZmVyID09IE5VTEwpCisJCQlnb3RvIG9vbTsKKwl9CisKKwlidWZm ZXJbY291bnRdID0gTlVMTDsKKwlpZiAobnVtX2VsZW1lbnRzICE9IE5VTEwpCisJCSpudW1fZWxl bWVudHMgPSBjb3VudDsKKwlyZXR1cm4gYnVmZmVyOworCitvb206CisJTG9nV2FybiAoIiVzICVk IDogZXJyb3IgYWxsb2NhdGluZyBtZW1vcnlcbiIsIF9fRklMRV9fLCBfX0xJTkVfXyk7CisJcmV0 dXJuIE5VTEw7CisKK30KKworc3RhdGljIGNoYXIgKioKK2dldF9zZXNzaW9uc19mb3JfdXNlciAo REJ1c0Nvbm5lY3Rpb24gKmNvbm5lY3Rpb24sCisJCSAgICAgICBjb25zdCBjaGFyICAgICAqdXNl ciwKKwkJICAgICAgIGNvbnN0IGNoYXIgICAgICp4MTFfZGlzcGxheSkKK3sKKwlEQnVzRXJyb3Ig ICAgICAgZXJyb3I7CisJREJ1c01lc3NhZ2UgICAgKm1lc3NhZ2U7CisJREJ1c01lc3NhZ2UgICAg KnJlcGx5OworCURCdXNNZXNzYWdlSXRlciBpdGVyOworCURCdXNNZXNzYWdlSXRlciBpdGVyX3Jl cGx5OworCURCdXNNZXNzYWdlSXRlciBpdGVyX2FycmF5OworCXN0cnVjdCBwYXNzd2QJKnB3ZW50 OworCWNoYXIgICAgICAgICAgICoqc2Vzc2lvbnM7CisKKwlzZXNzaW9ucyA9IE5VTEw7CisJbWVz c2FnZSA9IE5VTEw7CisJcmVwbHkgPSBOVUxMOworCisJcHdlbnQgPSBnZXRwd25hbSAodXNlcik7 CisKKwlkYnVzX2Vycm9yX2luaXQgKCZlcnJvcik7CisJbWVzc2FnZSA9IGRidXNfbWVzc2FnZV9u ZXdfbWV0aG9kX2NhbGwgKENLX05BTUUsCisJCQkJCQlDS19NQU5BR0VSX1BBVEgsCisJCQkJCQlD S19NQU5BR0VSX0lOVEVSRkFDRSwKKwkJCQkJCSJHZXRTZXNzaW9uc0ZvclVzZXIiKTsKKwlpZiAo bWVzc2FnZSA9PSBOVUxMKSB7CisJCURlYnVnICgiQ29uc29sZUtpdDogQ291bGRuJ3QgYWxsb2Nh dGUgdGhlIEQtQnVzIG1lc3NhZ2UiKTsKKwkJZ290byBvdXQ7CisJfQorCisJZGJ1c19tZXNzYWdl X2l0ZXJfaW5pdF9hcHBlbmQgKG1lc3NhZ2UsICZpdGVyKTsKKwlkYnVzX21lc3NhZ2VfaXRlcl9h cHBlbmRfYmFzaWMgKCZpdGVyLAorCQkJCQlEQlVTX1RZUEVfVUlOVDMyLAorCQkJCQkmcHdlbnQt PnB3X3VpZCk7CisKKwlkYnVzX2Vycm9yX2luaXQgKCZlcnJvcik7CisJcmVwbHkgPSBkYnVzX2Nv bm5lY3Rpb25fc2VuZF93aXRoX3JlcGx5X2FuZF9ibG9jayAoY29ubmVjdGlvbiwKKwkJCQkJCQkg ICBtZXNzYWdlLAorCQkJCQkJCSAgIC0xLCAmZXJyb3IpOworCWRidXNfY29ubmVjdGlvbl9mbHVz aCAoY29ubmVjdGlvbik7CisKKwlpZiAoZGJ1c19lcnJvcl9pc19zZXQgKCZlcnJvcikpIHsKKwkJ RGVidWcgKCJDb25zb2xlS2l0OiAlcyByYWlzZWQ6XG4gJXNcblxuIiwgZXJyb3IubmFtZSwgZXJy b3IubWVzc2FnZSk7CisJCWdvdG8gb3V0OworCX0KKworCWlmIChyZXBseSA9PSBOVUxMKSB7CisJ CURlYnVnICgiQ29uc29sZUtpdDogTm8gcmVwbHkgZm9yIEdldFNlc3Npb25zRm9yVXNlciIpOwor CQlnb3RvIG91dDsKKwl9CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9pbml0IChyZXBseSwgJml0ZXJf cmVwbHkpOworCWlmIChkYnVzX21lc3NhZ2VfaXRlcl9nZXRfYXJnX3R5cGUgKCZpdGVyX3JlcGx5 KSAhPSBEQlVTX1RZUEVfQVJSQVkpIHsKKwkJRGVidWcgKCJDb25zb2xlS2l0OiBXcm9uZyByZXBs eSBmb3IgR2V0U2Vzc2lvbnNGb3JVc2VyIC0gZXhwZWN0aW5nIGFuIGFycmF5LiIpOworCQlnb3Rv IG91dDsKKwl9CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9yZWN1cnNlICgmaXRlcl9yZXBseSwgJml0 ZXJfYXJyYXkpOworCXNlc3Npb25zID0gZ2V0X3BhdGhfYXJyYXlfZnJvbV9pdGVyICgmaXRlcl9h cnJheSwgTlVMTCk7CisKKyBvdXQ6CisJaWYgKG1lc3NhZ2UgIT0gTlVMTCkgeworCQlkYnVzX21l c3NhZ2VfdW5yZWYgKG1lc3NhZ2UpOworCX0KKwlpZiAocmVwbHkgIT0gTlVMTCkgeworCQlkYnVz X21lc3NhZ2VfdW5yZWYgKHJlcGx5KTsKKwl9CisKKwlyZXR1cm4gc2Vzc2lvbnM7Cit9CisKK3Zv aWQKK3VubG9ja19ja19zZXNzaW9uIChjb25zdCBjaGFyICp1c2VyLAorCQkgICBjb25zdCBjaGFy ICp4MTFfZGlzcGxheSkKK3sKKwlEQnVzRXJyb3IgICAgICAgZXJyb3I7CisJREJ1c0Nvbm5lY3Rp b24gKmNvbm5lY3Rpb247CisJY2hhciAgICAgICAgICAgKipzZXNzaW9uczsKKwlpbnQgICAgICAg ICAgICAgIGk7CisKKwlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IFVubG9ja2luZyBzZXNzaW9uIGZvciAl cyBvbiAlcyIsIHVzZXIsIHgxMV9kaXNwbGF5KTsKKworCWRidXNfZXJyb3JfaW5pdCAoJmVycm9y KTsKKwljb25uZWN0aW9uID0gZGJ1c19idXNfZ2V0IChEQlVTX0JVU19TWVNURU0sICZlcnJvcik7 CisJaWYgKGNvbm5lY3Rpb24gPT0gTlVMTCkgeworCQlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IEZhaWxl ZCB0byBjb25uZWN0IHRvIHRoZSBELUJ1cyBkYWVtb246ICVzIiwgZXJyb3IubWVzc2FnZSk7CisJ CWRidXNfZXJyb3JfZnJlZSAoJmVycm9yKTsKKwkJcmV0dXJuOworCX0KKworCXNlc3Npb25zID0g Z2V0X3Nlc3Npb25zX2Zvcl91c2VyIChjb25uZWN0aW9uLCB1c2VyLCB4MTFfZGlzcGxheSk7CisJ aWYgKHNlc3Npb25zID09IE5VTEwgfHwgc2Vzc2lvbnNbMF0gPT0gTlVMTCkgeworCQlEZWJ1ZyAo IkNvbnNvbGVLaXQ6IG5vIHNlc3Npb25zIGZvdW5kIik7CisJCXJldHVybjsKKwl9CisKKwlmb3Ig KGkgPSAwOyBzZXNzaW9uc1tpXSAhPSBOVUxMOyBpKyspIHsKKwkJY2hhciAqc3NpZDsKKwkJY2hh ciAqeGRpc3BsYXk7CisKKwkJc3NpZCA9IHNlc3Npb25zW2ldOworCQlzZXNzaW9uX2dldF94MTFf ZGlzcGxheSAoY29ubmVjdGlvbiwgc3NpZCwgJnhkaXNwbGF5KTsKKwkJRGVidWcgKCJDb25zb2xl S2l0OiBzZXNzaW9uICVzIGhhcyBESVNQTEFZICVzIiwgc3NpZCwgeGRpc3BsYXkpOworCisJCWlm ICh4ZGlzcGxheSAhPSBOVUxMCisJCSAgICAmJiB4MTFfZGlzcGxheSAhPSBOVUxMCisJCSAgICAm JiBzdHJjbXAgKHhkaXNwbGF5LCB4MTFfZGlzcGxheSkgPT0gMCkgeworCQkJaW50IHJlczsKKwor CQkJcmVzID0gc2Vzc2lvbl91bmxvY2sgKGNvbm5lY3Rpb24sIHNzaWQpOworCQkJaWYgKCEgcmVz KSB7CisJCQkJTG9nRXJyb3IgKCJDb25zb2xlS2l0OiBVbmFibGUgdG8gdW5sb2NrICVzIiwgc3Np ZCk7CisJCQl9CisJCX0KKworCQlmcmVlICh4ZGlzcGxheSk7CisJfQorCisJZnJlZVN0ckFyciAo c2Vzc2lvbnMpOworfQorCitjaGFyICoKK29wZW5fY2tfc2Vzc2lvbiAoc3RydWN0IHBhc3N3ZCAq cHdlbnQsCisJCSBzdHJ1Y3QgZGlzcGxheSAqZCkKK3sKKwlEQnVzQ29ubmVjdGlvbiAqY29ubmVj dGlvbjsKKwlEQnVzRXJyb3IgICAgICAgZXJyb3I7CisJREJ1c01lc3NhZ2UgICAgKm1lc3NhZ2U7 CisJREJ1c01lc3NhZ2UgICAgKnJlcGx5OworCURCdXNNZXNzYWdlSXRlciBpdGVyOworCURCdXNN ZXNzYWdlSXRlciBpdGVyX3N0cnVjdDsKKwljaGFyCSAgICAgICAqY29va2llOworCisJY29va2ll ID0gTlVMTDsKKworCWlmIChwd2VudCA9PSBOVUxMKSB7CisJCURlYnVnICgiQ29uc29sZUtpdDog TlVMTCB1c2VyIHBhc3NlZCBhcyBwYXJhbWV0ZXIiKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJ RGVidWcgKCJDb25zb2xlS2l0OiBPcGVuaW5nIHNlc3Npb24gZm9yICVzIiwgcHdlbnQtPnB3X25h bWUpOworCisJZGJ1c19lcnJvcl9pbml0ICgmZXJyb3IpOworCWNvbm5lY3Rpb24gPSBkYnVzX2J1 c19nZXRfcHJpdmF0ZSAoREJVU19CVVNfU1lTVEVNLCAmZXJyb3IpOworCXByaXZhdGVfY29ubmVj dGlvbiA9IGNvbm5lY3Rpb247CisKKwlpZiAoY29ubmVjdGlvbiA9PSBOVUxMKSB7CisJCURlYnVn ICgiQ29uc29sZUtpdDogRmFpbGVkIHRvIGNvbm5lY3QgdG8gdGhlIEQtQnVzIGRhZW1vbjogJXMi LCBlcnJvci5tZXNzYWdlKTsKKwkJZGJ1c19lcnJvcl9mcmVlICgmZXJyb3IpOworCQlyZXR1cm4g TlVMTDsKKwl9CisKKwlkYnVzX2Nvbm5lY3Rpb25fc2V0X2V4aXRfb25fZGlzY29ubmVjdCAoY29u bmVjdGlvbiwgRkFMU0UpOworCS8qIEZJWE1FOiBXaGF0IHRvIGRvIGFib3V0IHRoZXNlPworCWRi dXNfY29ubmVjdGlvbl9zZXRfd2F0Y2hfZnVuY3Rpb25zKCBjb25uZWN0aW9uLAorCSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkYnVzQWRkV2F0Y2gsCisJICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGRidXNSZW1vdmVXYXRjaCwKKwkgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgZGJ1c1RvZ2dsZVdhdGNoLAorCSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBkYXRhLCAwICk7CisJZGJ1c19jb25uZWN0aW9uX3NldF90 aW1lb3V0X2Z1bmN0aW9ucyggY29ubmVjdGlvbiwKKwkgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBkYnVzQWRkVGltZW91dCwKKwkgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBkYnVzUmVtb3ZlVGltZW91dCwKKwkgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBkYnVzVG9nZ2xlVGltZW91dCwKKwkgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBkYXRhLCAwICk7CisJZGJ1c19jb25uZWN0aW9uX3NldF93YWtl dXBfbWFpbl9mdW5jdGlvbiggY29ubmVjdGlvbiwKKwkgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBkYnVzV2FrZXVwTWFpbiwKKwkgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBkYXRhLCAwICk7ICovCisKKwlkYnVzX2Vycm9yX2luaXQgKCZl cnJvcik7CisJbWVzc2FnZSA9IGRidXNfbWVzc2FnZV9uZXdfbWV0aG9kX2NhbGwgKENLX05BTUUs CisJCQkJCQlDS19NQU5BR0VSX1BBVEgsCisJCQkJCQlDS19NQU5BR0VSX0lOVEVSRkFDRSwKKwkJ CQkJCSJPcGVuU2Vzc2lvbldpdGhQYXJhbWV0ZXJzIik7CisJaWYgKG1lc3NhZ2UgPT0gTlVMTCkg eworCQlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IENvdWxkbid0IGFsbG9jYXRlIHRoZSBELUJ1cyBtZXNz YWdlIik7CisJCXJldHVybiBOVUxMOworCX0KKworCWRidXNfbWVzc2FnZV9pdGVyX2luaXRfYXBw ZW5kIChtZXNzYWdlLCAmaXRlcik7CisJZGJ1c19tZXNzYWdlX2l0ZXJfb3Blbl9jb250YWluZXIg KCZpdGVyLAorCQkJCQkgIERCVVNfVFlQRV9BUlJBWSwKKwkJCQkJICBEQlVTX1NUUlVDVF9CRUdJ Tl9DSEFSX0FTX1NUUklORworCQkJCQkgIERCVVNfVFlQRV9TVFJJTkdfQVNfU1RSSU5HCisJCQkJ CSAgREJVU19UWVBFX1ZBUklBTlRfQVNfU1RSSU5HCisJCQkJCSAgREJVU19TVFJVQ1RfRU5EX0NI QVJfQVNfU1RSSU5HLAorCQkJCQkgICZpdGVyX3N0cnVjdCk7CisKKwlhZGRfcGFyYW1faW50ICgm aXRlcl9zdHJ1Y3QsICJ1c2VyIiwgcHdlbnQtPnB3X3VpZCk7CisJYWRkX3BhcmFtX3N0cmluZyAo Jml0ZXJfc3RydWN0LCAieDExLWRpc3BsYXkiLCBkLT5uYW1lKTsKKwlhZGRfcGFyYW1fYm9vbGVh biAoJml0ZXJfc3RydWN0LCAiaXMtbG9jYWwiLCAoKGQtPmRpc3BsYXlUeXBlICYgZF9sb2NhdGlv bikgPT0gZExvY2FsKSk7CisjaWZkZWYgWERNQ1AKKwlpZiAoKGQtPmRpc3BsYXlUeXBlICYgZF9s b2NhdGlvbikgIT0gZExvY2FsKSB7CisJCWFkZF9wYXJhbV9zdHJpbmcgKCZpdGVyX3N0cnVjdCwg InJlbW90ZS1ob3N0LW5hbWUiLCBkLT5yZW1vdGVIb3N0KTsKKwl9CisjZW5kaWYKKworI2lmZGVm IEhBVkVfVlRTCisJaWYgKGQtPnNlcnZlclZUID4gMCkgeworCQljaGFyIGRldmljZVsyMF07CisK KwkJLyogRklYTUU6IGhvdyBkb2VzIHhvcmcgY29uc3RydWN0IHRoaXMgKi8KKwkJc3ByaW50Zihk ZXZpY2UsICIvZGV2L3R0eSVkIiwgZC0+c2VydmVyVlQpOworCQlhZGRfcGFyYW1fc3RyaW5nICgm aXRlcl9zdHJ1Y3QsICJ4MTEtZGlzcGxheS1kZXZpY2UiLCBkZXZpY2UpOworCX0KKyNlbmRpZgor CisJZGJ1c19tZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFpbmVyICgmaXRlciwgJml0ZXJfc3RydWN0 KTsKKworCXJlcGx5ID0gZGJ1c19jb25uZWN0aW9uX3NlbmRfd2l0aF9yZXBseV9hbmRfYmxvY2sg KGNvbm5lY3Rpb24sCisJCQkJCQkJICAgbWVzc2FnZSwKKwkJCQkJCQkgICAtMSwgJmVycm9yKTsK KwlpZiAoZGJ1c19lcnJvcl9pc19zZXQgKCZlcnJvcikpIHsKKwkJRGVidWcgKCJDb25zb2xlS2l0 OiAlcyByYWlzZWQ6XG4gJXNcblxuIiwgZXJyb3IubmFtZSwgZXJyb3IubWVzc2FnZSk7CisJCXJl cGx5ID0gTlVMTDsKKwl9CisKKwlkYnVzX2Nvbm5lY3Rpb25fZmx1c2ggKGNvbm5lY3Rpb24pOwor CisJZGJ1c19tZXNzYWdlX3VucmVmIChtZXNzYWdlKTsKKwlkYnVzX2Vycm9yX2ZyZWUgKCZlcnJv cik7CisKKwlpZiAocmVwbHkgIT0gTlVMTCkgeworCQljb25zdCBjaGFyICp2YWx1ZTsKKworCQlk YnVzX21lc3NhZ2VfaXRlcl9pbml0IChyZXBseSwgJml0ZXIpOworCQlkYnVzX21lc3NhZ2VfaXRl cl9nZXRfYmFzaWMgKCZpdGVyLCAmdmFsdWUpOworCQljb29raWUgPSBzdHJkdXAgKHZhbHVlKTsK KwkJZGJ1c19tZXNzYWdlX3VucmVmIChyZXBseSk7CisJfQorCisJcmV0dXJuIGNvb2tpZTsKK30K Kwordm9pZAorY2xvc2VfY2tfc2Vzc2lvbiAoY29uc3QgY2hhciAqY29va2llKQoreworCURCdXNF cnJvciAgICAgICBlcnJvcjsKKwlEQnVzTWVzc2FnZSAgICAqbWVzc2FnZTsKKwlEQnVzTWVzc2Fn ZSAgICAqcmVwbHk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXI7CisKKwlpZiAoY29va2llID09IE5V TEwpIHsKKwkJcmV0dXJuOworCX0KKworCWlmIChwcml2YXRlX2Nvbm5lY3Rpb24gPT0gTlVMTCkg eworCQlyZXR1cm47CisJfQorCisJZGJ1c19lcnJvcl9pbml0ICgmZXJyb3IpOworCW1lc3NhZ2Ug PSBkYnVzX21lc3NhZ2VfbmV3X21ldGhvZF9jYWxsIChDS19OQU1FLAorCQkJCQkJQ0tfTUFOQUdF Ul9QQVRILAorCQkJCQkJQ0tfTUFOQUdFUl9JTlRFUkZBQ0UsCisJCQkJCQkiQ2xvc2VTZXNzaW9u Iik7CisJaWYgKG1lc3NhZ2UgPT0gTlVMTCkgeworCQlEZWJ1ZyAoIkNvbnNvbGVLaXQ6IENvdWxk bid0IGFsbG9jYXRlIHRoZSBELUJ1cyBtZXNzYWdlIik7CisJCXJldHVybjsKKwl9CisKKwlkYnVz X21lc3NhZ2VfaXRlcl9pbml0X2FwcGVuZCAobWVzc2FnZSwgJml0ZXIpOworCWRidXNfbWVzc2Fn ZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXIsCisJCQkJCURCVVNfVFlQRV9TVFJJTkcsCisJCQkJ CSZjb29raWUpOworCisJcmVwbHkgPSBkYnVzX2Nvbm5lY3Rpb25fc2VuZF93aXRoX3JlcGx5X2Fu ZF9ibG9jayAocHJpdmF0ZV9jb25uZWN0aW9uLAorCQkJCQkJCSAgIG1lc3NhZ2UsCisJCQkJCQkJ ICAgLTEsICZlcnJvcik7CisJaWYgKGRidXNfZXJyb3JfaXNfc2V0ICgmZXJyb3IpKSB7CisJCURl YnVnICgiQ29uc29sZUtpdDogJXMgcmFpc2VkOlxuICVzXG5cbiIsIGVycm9yLm5hbWUsIGVycm9y Lm1lc3NhZ2UpOworCQlyZXBseSA9IE5VTEw7CisJfQorCisJZGJ1c19jb25uZWN0aW9uX2ZsdXNo IChwcml2YXRlX2Nvbm5lY3Rpb24pOworCisJZGJ1c19tZXNzYWdlX3VucmVmIChtZXNzYWdlKTsK KwlkYnVzX2Vycm9yX2ZyZWUgKCZlcnJvcik7CisKKyAgICAgICAgZGJ1c19jb25uZWN0aW9uX2Ns b3NlIChwcml2YXRlX2Nvbm5lY3Rpb24pOworCXByaXZhdGVfY29ubmVjdGlvbiA9IE5VTEw7Cit9 CmRpZmYgLXVwIGtkZWJhc2UtMy41Ljgva2RtL2JhY2tlbmQvSW1ha2VmaWxlLmNvbnNvbGVraXQg a2RlYmFzZS0zLjUuOC9rZG0vYmFja2VuZC9JbWFrZWZpbGUKLS0tIGtkZWJhc2UtMy41Ljgva2Rt L2JhY2tlbmQvSW1ha2VmaWxlLmNvbnNvbGVraXQJMjAwNS0wOS0xMCAwMzoyNjoxMi4wMDAwMDAw MDAgLTA1MDAKKysrIGtkZWJhc2UtMy41Ljgva2RtL2JhY2tlbmQvSW1ha2VmaWxlCTIwMDctMTEt MjggMTQ6MDg6MjIuMDAwMDAwMDAwIC0wNjAwCkBAIC0xNTUsMTMgKzE1NSwxMyBAQCBQUk9DVElU TEVfREVGSU5FUyA9IC1ESEFTX1NFVFBST0NUSVRMRQogCQkgbmV0YWRkci5jIHJlc2V0LmMgcmVz b3VyY2UuYyBwcm90b2RweS5jIHBvbGljeS5jIFwKIAkJIHNlc3Npb24uYyBzb2NrZXQuYyBzdHJl YW1zLmMgdXRpbC5jIHhkbWNwLmMgXAogCQkgcHJvY2Vzcy5jIG1pdGF1dGguYyBcCi0JCSBnZW5h dXRoLmMgYWNjZXNzLmMgY2hvb3NlLmMgXAorCQkgZ2VuYXV0aC5jIGFjY2Vzcy5jIGNob29zZS5j IGNvbnNvbGVraXQuYyBcCiAJCSAkKFhETUFVVEhTUkNTKSAkKFJQQ1NSQ1MpICQoS1JCNVNSQ1Mp CiAgICAgICBDT01NT0JKUyA9IGF1dGgubyBkYWVtb24ubyBzZXJ2ZXIubyBkcHlsaXN0Lm8gZG0u byBlcnJvci5vIFwKIAkJIG5ldGFkZHIubyByZXNldC5vIHJlc291cmNlLm8gcHJvdG9kcHkubyBw b2xpY3kubyBcCiAJCSBzZXNzaW9uLm8gc29ja2V0Lm8gc3RyZWFtcy5vIHV0aWwubyB4ZG1jcC5v IFwKIAkJIHByb2Nlc3MubyBtaXRhdXRoLm8gXAotCQkgZ2VuYXV0aC5vIGFjY2Vzcy5vIGNob29z ZS5vIFwKKwkJIGdlbmF1dGgubyBhY2Nlc3MubyBjaG9vc2UubyBjb25zb2xla2l0Lm8gXAogCQkg JChYRE1BVVRIT0JKUykgJChSUENPQkpTKSAkKEtSQjVPQkpTKQogCiAgICAgICAgICBTUkNTMSA9 ICQoQ09NTVNSQ1MpIGNsaWVudC5jCmRpZmYgLXVwIGtkZWJhc2UtMy41Ljgva2RtL2JhY2tlbmQv TWFrZWZpbGUuYW0uY29uc29sZWtpdCBrZGViYXNlLTMuNS44L2tkbS9iYWNrZW5kL01ha2VmaWxl LmFtCi0tLSBrZGViYXNlLTMuNS44L2tkbS9iYWNrZW5kL01ha2VmaWxlLmFtLmNvbnNvbGVraXQJ MjAwNy0xMC0wOCAwNDo1MTozMy4wMDAwMDAwMDAgLTA1MDAKKysrIGtkZWJhc2UtMy41Ljgva2Rt L2JhY2tlbmQvTWFrZWZpbGUuYW0JMjAwNy0xMS0yOCAxNDoxNDo0Mi4wMDAwMDAwMDAgLTA2MDAK QEAgLTEsOSArMSw5IEBACiAjIGZvcmNpYmx5IHJlbW92ZSB0aHJlYWQtcmVsYXRlZCBkZWZpbmVz ICYgZmxhZ3MKIEFVVE9NQUtFX09QVElPTlMgPSBmb3JlaWduCi1DUFBGTEFHUyA9ICQoVVNFUl9J TkNMVURFUykgJChYX0lOQ0xVREVTKSAkKEtSQjRfSU5DUykgJChLUkI1X0lOQ1MpIC1JLi4gLUku Li8uLgorQ1BQRkxBR1MgPSAkKFVTRVJfSU5DTFVERVMpICQoWF9JTkNMVURFUykgJChLUkI0X0lO Q1MpICQoS1JCNV9JTkNTKSAkKERCVVNfSU5DUykgLUkuLiAtSS4uLy4uCiBMREZMQUdTID0gJChV U0VSX0xERkxBR1MpICQoWF9MREZMQUdTKSAkKFhfUlBBVEgpICQoS1JCNF9SUEFUSCkgJChLUkI1 X1JQQVRIKQogTERBREQgPSAkKExJQl9YMTEpIC1sWGF1ICQoTElCWERNQ1ApICQoUEFTU1dETElC UykgJChMSUJTSEFET1cpICQoTElCR0VOKSBcCi0gICAgJChMSUJfTElCUykgJChLUkI0X0xJQlMp ICQoS1JCNV9MSUJTKSAkKExJQlNPQ0tFVCkgJChMSUJSRVNPTFYpIFwKKyAgICAkKExJQl9MSUJT KSAkKEtSQjRfTElCUykgJChLUkI1X0xJQlMpICQoREJVU19MSUJTKSAkKExJQlNPQ0tFVCkgJChM SUJSRVNPTFYpIFwKICAgICAkKExJQlVDQikgJChMSUJVVElMKSAkKExJQlBPU0lYNCkKIAogYmlu X1BST0dSQU1TID0ga2RtCkBAIC0xMyw2ICsxMyw3IEBAIGtkbV9TT1VSQ0VTID0gXAogICAgIGJv b3RtYW4uYyBcCiAgICAgY2hvb3NlLmMgXAogICAgIGNsaWVudC5jIFwKKyAgICBjb25zb2xla2l0 LmMgXAogICAgIGN0cmwuYyBcCiAgICAgZGFlbW9uLmMgXAogICAgIGRtLmMgXApkaWZmIC11cCBr ZGViYXNlLTMuNS44L2tkbS9iYWNrZW5kL2NsaWVudC5jLmNvbnNvbGVraXQga2RlYmFzZS0zLjUu OC9rZG0vYmFja2VuZC9jbGllbnQuYwotLS0ga2RlYmFzZS0zLjUuOC9rZG0vYmFja2VuZC9jbGll bnQuYy5jb25zb2xla2l0CTIwMDctMTAtMDggMDQ6NTE6MzMuMDAwMDAwMDAwIC0wNTAwCisrKyBr ZGViYXNlLTMuNS44L2tkbS9iYWNrZW5kL2NsaWVudC5jCTIwMDctMTEtMjggMTQ6MDg6MjIuMDAw MDAwMDAwIC0wNjAwCkBAIC04Miw2ICs4MiwxMCBAQCBleHRlcm4gaW50IGxvZ2luc3VjY2Vzcygg Y29uc3QgY2hhciAqVXNlCiAjIGluY2x1ZGUgPHNoYWRvdy5oPgogI2VuZGlmCiAKKyNpZmRlZiBX SVRIX0NPTlNPTEVfS0lUCisjaW5jbHVkZSAiY29uc29sZWtpdC5oIgorI2VuZGlmCisKIC8qCiAg KiBTZXNzaW9uIGRhdGEsIG1vc3RseSB3aGF0IHN0cnVjdCB2ZXJpZnlfaW5mbyB3YXMgZm9yCiAg Ki8KQEAgLTExMjAsOCArMTEyNCwxMyBAQCBzdGF0aWMgaW50IHJlbW92ZVNlc3Npb247CiBzdGF0 aWMgaW50IHJlbW92ZUNyZWRzOwogI2VuZGlmCiAKKyNpZmRlZiBXSVRIX0NPTlNPTEVfS0lUCitp bnQKK1N0YXJ0Q2xpZW50KCBjb25zdCBjaGFyICpja19zZXNzaW9uX2Nvb2tpZSApCisjZWxzZQog aW50CiBTdGFydENsaWVudCgpCisjZW5kaWYKIHsKIAljb25zdCBjaGFyICpob21lLCAqc2Vzc2Fy Z3MsICpkZXNrc2VzczsKIAljaGFyICoqZW52LCAqeG1hOwpAQCAtMTIxNyw2ICsxMjI2LDExIEBA IFN0YXJ0Q2xpZW50KCkKIAlpZiAoa3JidGtmaWxlWzBdICE9ICdcMCcpCiAJCWVudiA9IHNldEVu diggZW52LCAiS1JCVEtGSUxFIiwga3JidGtmaWxlICk7CiAjZW5kaWYKKyNpZmRlZiBXSVRIX0NP TlNPTEVfS0lUCisJaWYgKGNrX3Nlc3Npb25fY29va2llICE9IE5VTEwpIHsKKwkJZW52ID0gc2V0 RW52ICggZW52LCAiWERHX1NFU1NJT05fQ09PS0lFIiwgY2tfc2Vzc2lvbl9jb29raWUgKTsKKwl9 CisjZW5kaWYKIAl1c2VyRW52aXJvbiA9IGluaGVyaXRFbnYoIGVudiwgZW52dmFycyApOwogCWVu diA9IHN5c3RlbUVudiggcC0+cHdfbmFtZSApOwogCXN5c3RlbUVudmlyb24gPSBzZXRFbnYoIGVu diwgIkhPTUUiLCBwLT5wd19kaXIgKTsK 23032 2008-01-14 17:17:52 +0000 2008-07-15 18:08:10 +0000 kdm consolekit support patch for 4.0.0 (with Mandriva fixes) kdebase-workspace-4.0.0-consolekit-kdm.patch text/plain 23120 kevin.kofler ZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMC4wL2NtYWtlL21vZHVsZXMvRmluZERCdXMu Y21ha2Uga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAtY29uc29sZWtpdC1rZG0vY21ha2UvbW9kdWxl cy9GaW5kREJ1cy5jbWFrZQotLS0ga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAvY21ha2UvbW9kdWxl cy9GaW5kREJ1cy5jbWFrZQkxOTcwLTAxLTAxIDAxOjAwOjAwLjAwMDAwMDAwMCArMDEwMAorKysg a2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAtY29uc29sZWtpdC1rZG0vY21ha2UvbW9kdWxlcy9GaW5k REJ1cy5jbWFrZQkyMDA4LTAxLTA4IDAxOjExOjI1LjAwMDAwMDAwMCArMDEwMApAQCAtMCwwICsx LDM5IEBACisKK2lmKERCVVNfSU5DTFVERV9ESVIgQU5EIERCVVNfTElCUkFSWSBBTkQgREJVU19B UkNIX0lOQ0xVREVfRElSKQorCSMgQWxyZWFkeSBpbiBjYWNoZSwgYmUgc2lsZW50CisJc2V0KERC VVNfRklORF9RVUlFVExZIFRSVUUpCQorZW5kaWYoREJVU19JTkNMVURFX0RJUiBBTkQgREJVU19M SUJSQVJZIEFORCBEQlVTX0FSQ0hfSU5DTFVERV9ESVIpCisKK3NldChEQlVTX0xJQlJBUlkpCitz ZXQoREJVU19JTkNMVURFX0RJUikKK3NldChEQlVTX0FSQ0hfSU5DTFVERV9ESVIpCisKK0ZJTkRf UEFUSChEQlVTX0lOQ0xVREVfRElSIGRidXMvZGJ1cy5oCisJL3Vzci9pbmNsdWRlCisJL3Vzci9p bmNsdWRlL2RidXMtMS4wCisJL3Vzci9sb2NhbC9pbmNsdWRlCispCisKK0ZJTkRfUEFUSChEQlVT X0FSQ0hfSU5DTFVERV9ESVIgZGJ1cy9kYnVzLWFyY2gtZGVwcy5oCisJL3Vzci9saWIke0xJQl9T VUZGSVh9L2luY2x1ZGUKKwkvdXNyL2xpYiR7TElCX1NVRkZJWH0vZGJ1cy0xLjAvaW5jbHVkZQor CS91c3IvbGliNjQvaW5jbHVkZQorCS91c3IvbGliNjQvZGJ1cy0xLjAvaW5jbHVkZQorCS91c3Iv bGliL2luY2x1ZGUKKwkvdXNyL2xpYi9kYnVzLTEuMC9pbmNsdWRlCispCisKK0ZJTkRfTElCUkFS WShEQlVTX0xJQlJBUlkgTkFNRVMgZGJ1cy0xIGRidXMKKwlQQVRIUworCS91c3IvbGliCisJL3Vz ci9sb2NhbC9saWIKKykKKworaWYoREJVU19JTkNMVURFX0RJUiBBTkQgREJVU19MSUJSQVJZIEFO RCBEQlVTX0FSQ0hfSU5DTFVERV9ESVIpCisgICBNRVNTQUdFKCBTVEFUVVMgImRidXMgZm91bmQ6 IGluY2x1ZGVzIGluICR7REJVU19JTkNMVURFX0RJUn0sIGxpYnJhcnkgaW4gJHtEQlVTX0xJQlJB Ull9IikKKyAgIHNldChEQlVTX0ZPVU5EIFRSVUUpCitlbHNlKERCVVNfSU5DTFVERV9ESVIgQU5E IERCVVNfTElCUkFSWSBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSKQorICAgTUVTU0FHRSggU1RB VFVTICJkYnVzIG5vdCBmb3VuZCIpCitlbmRpZihEQlVTX0lOQ0xVREVfRElSIEFORCBEQlVTX0xJ QlJBUlkgQU5EIERCVVNfQVJDSF9JTkNMVURFX0RJUikKKworTUFSS19BU19BRFZBTkNFRChEQlVT X0lOQ0xVREVfRElSIERCVVNfTElCUkFSWSBEQlVTX0FSQ0hfSU5DTFVERV9ESVIpCmRpZmYgLU51 ciBrZGViYXNlLXdvcmtzcGFjZS00LjAuMC9rZG0vYmFja2VuZC9jbGllbnQuYyBrZGViYXNlLXdv cmtzcGFjZS00LjAuMC1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9jbGllbnQuYwotLS0ga2Rl YmFzZS13b3Jrc3BhY2UtNC4wLjAva2RtL2JhY2tlbmQvY2xpZW50LmMJMjAwOC0wMS0wNSAwMDo1 NTo0NC4wMDAwMDAwMDAgKzAxMDAKKysrIGtkZWJhc2Utd29ya3NwYWNlLTQuMC4wLWNvbnNvbGVr aXQta2RtL2tkbS9iYWNrZW5kL2NsaWVudC5jCTIwMDgtMDEtMDggMDE6MTE6MjUuMDAwMDAwMDAw ICswMTAwCkBAIC04Miw2ICs4MiwxMCBAQAogI2VuZGlmCiAjaW5jbHVkZSA8c2lnbmFsLmg+CiAK KyNpZmRlZiBXSVRIX0NPTlNPTEVfS0lUCisjaW5jbHVkZSAiY29uc29sZWtpdC5oIgorI2VuZGlm CisKIC8qCiAgKiBTZXNzaW9uIGRhdGEsIG1vc3RseSB3aGF0IHN0cnVjdCB2ZXJpZnlfaW5mbyB3 YXMgZm9yCiAgKi8KQEAgLTExNzgsOCArMTE4MiwxMyBAQAogfQogKi8KIAorI2lmZGVmIFdJVEhf Q09OU09MRV9LSVQKK2ludAorc3RhcnRDbGllbnQoIHZvbGF0aWxlIGludCAqcGlkLCBjb25zdCBj aGFyICpja19zZXNzaW9uX2Nvb2tpZSApCisjZWxzZQogaW50CiBzdGFydENsaWVudCggdm9sYXRp bGUgaW50ICpwaWQgKQorI2VuZGlmCiB7CiAJY29uc3QgY2hhciAqaG9tZSwgKnNlc3NhcmdzLCAq ZGVza3Nlc3M7CiAJY2hhciAqKmVudiwgKnhtYTsKQEAgLTEyNjgsNiArMTI3NywxMSBAQAogCWlm IChrcmJ0a2ZpbGVbMF0gIT0gJ1wwJykKIAkJZW52ID0gc2V0RW52KCBlbnYsICJLUkJUS0ZJTEUi LCBrcmJ0a2ZpbGUgKTsKICNlbmRpZgorI2lmZGVmIFdJVEhfQ09OU09MRV9LSVQKKwlpZiAoY2tf c2Vzc2lvbl9jb29raWUgIT0gTlVMTCkgeworCQllbnYgPSBzZXRFbnYgKCBlbnYsICJYREdfU0VT U0lPTl9DT09LSUUiLCBja19zZXNzaW9uX2Nvb2tpZSApOworCX0KKyNlbmRpZgogCXVzZXJFbnZp cm9uID0gaW5oZXJpdEVudiggZW52LCBlbnZ2YXJzICk7CiAJZW52ID0gc3lzdGVtRW52KCAwLCBj dXJ1c2VyICk7CiAJc3lzdGVtRW52aXJvbiA9IHNldEVudiggZW52LCAiSE9NRSIsIHAtPnB3X2Rp ciApOwpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAva2RtL2JhY2tlbmQvQ01ha2VM aXN0cy50eHQga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAtY29uc29sZWtpdC1rZG0va2RtL2JhY2tl bmQvQ01ha2VMaXN0cy50eHQKLS0tIGtkZWJhc2Utd29ya3NwYWNlLTQuMC4wL2tkbS9iYWNrZW5k L0NNYWtlTGlzdHMudHh0CTIwMDgtMDEtMDUgMDA6NTU6NDQuMDAwMDAwMDAwICswMTAwCisrKyBr ZGViYXNlLXdvcmtzcGFjZS00LjAuMC1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9DTWFrZUxp c3RzLnR4dAkyMDA4LTAxLTA4IDAxOjExOjI1LjAwMDAwMDAwMCArMDEwMApAQCAtMSw5ICsxLDEx IEBACitmaW5kX3BhY2thZ2UoREJ1cyBSRVFVSVJFRCkKIHNldChrZG1fU1JDUwogCWRtLmgKIAlh dXRoLmMKIAlib290bWFuLmMKIAljbGllbnQuYwogCWN0cmwuYworCWNvbnNvbGVraXQuYwogCWRh ZW1vbi5jCiAJZG0uYwogCWRweWxpc3QuYwpAQCAtNTAsNiArNTIsNyBAQAogbWFjcm9fYWRkX2Zp bGVfZGVwZW5kZW5jaWVzKGVycm9yLmMgJHtDTUFLRV9DVVJSRU5UX1NPVVJDRV9ESVJ9L3ByaW50 Zi5jKQoga2RlNF9hZGRfZXhlY3V0YWJsZShrZG0gTk9HVUkgJHtrZG1fU1JDU30pCiBtYWNyb19h ZGRfY29tcGlsZV9mbGFncyhrZG0gLVVfUkVFTlRSQU5UKQoraW5jbHVkZV9kaXJlY3Rvcmllcygk e0RCVVNfSU5DTFVERV9ESVJ9ICR7REJVU19BUkNIX0lOQ0xVREVfRElSfSkKIHRhcmdldF9saW5r X2xpYnJhcmllcygga2RtCiAJJHtYMTFfWDExX0xJQn0gJHtYMTFfWGF1X0xJQn0gJHtYMTFfWGRt Y3BfTElCfSAke1gxMV9YX0VYVFJBX0xJQlN9CiAJJHtVTklYQVVUSF9MSUJSQVJJRVN9CkBAIC01 OSw2ICs2Miw3IEBACiAJJHtLUkI1X0xJQlJBUklFU30KIAkke1NPQ0tFVF9MSUJSQVJJRVN9CiAJ JHtSRVNPTFZfTElCUkFSSUVTfQorCSR7REJVU19MSUJSQVJZfQogKQogaWYoVVRJTF9MSUJSQVJJ RVMpCiAJdGFyZ2V0X2xpbmtfbGlicmFyaWVzKCBrZG0gJHtVVElMX0xJQlJBUklFU30gKQpkaWZm IC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAva2RtL2JhY2tlbmQvY29uc29sZWtpdC5jIGtk ZWJhc2Utd29ya3NwYWNlLTQuMC4wLWNvbnNvbGVraXQta2RtL2tkbS9iYWNrZW5kL2NvbnNvbGVr aXQuYwotLS0ga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAva2RtL2JhY2tlbmQvY29uc29sZWtpdC5j CTE5NzAtMDEtMDEgMDE6MDA6MDAuMDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNlLXdvcmtzcGFj ZS00LjAuMC1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9jb25zb2xla2l0LmMJMjAwOC0wMS0w OCAwMToxMToyNS4wMDAwMDAwMDAgKzAxMDAKQEAgLTAsMCArMSw1NDQgQEAKKy8qIC0qLSBNb2Rl OiBDOyB0YWItd2lkdGg6IDg7IGluZGVudC10YWJzLW1vZGU6IHQ7IGMtYmFzaWMtb2Zmc2V0OiA4 IC0qLQorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNi0yMDA3IFdpbGxpYW0gSm9uIE1jQ2FubiA8 bWNjYW5uQGpodS5lZHU+CisgKiBDb3B5cmlnaHQgKEMpIDIwMDcgS2V2aW4gS29mbGVyIDxLZXZp bkB0aWdjYy50aWNhbGMub3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQor ICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUg TGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgor ICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBi ZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUg aW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlz IHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRp b24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0x MzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJkbS5oIgorI2luY2x1ZGUgImRtX2F1dGgu aCIKKyNpbmNsdWRlICJkbV9lcnJvci5oIgorCisjaW5jbHVkZSA8c3RkbGliLmg+CisjaW5jbHVk ZSA8c3RyaW5nLmg+CisjaW5jbHVkZSA8cHdkLmg+CisKKyNkZWZpbmUgREJVU19BUElfU1VCSkVD VF9UT19DSEFOR0UKKyNpbmNsdWRlIDxkYnVzL2RidXMuaD4KKworI2luY2x1ZGUgImNvbnNvbGVr aXQuaCIKKworCisjZGVmaW5lIENLX05BTUUgICAgICAgICAgICAgICJvcmcuZnJlZWRlc2t0b3Au Q29uc29sZUtpdCIKKyNkZWZpbmUgQ0tfUEFUSCAgICAgICAgICAgICAgIi9vcmcvZnJlZWRlc2t0 b3AvQ29uc29sZUtpdCIKKyNkZWZpbmUgQ0tfSU5URVJGQUNFICAgICAgICAgIm9yZy5mcmVlZGVz a3RvcC5Db25zb2xlS2l0IgorI2RlZmluZSBDS19NQU5BR0VSX1BBVEggICAgICAiL29yZy9mcmVl ZGVza3RvcC9Db25zb2xlS2l0L01hbmFnZXIiCisjZGVmaW5lIENLX01BTkFHRVJfSU5URVJGQUNF ICJvcmcuZnJlZWRlc2t0b3AuQ29uc29sZUtpdC5NYW5hZ2VyIgorI2RlZmluZSBDS19TRVNTSU9O X0lOVEVSRkFDRSAib3JnLmZyZWVkZXNrdG9wLkNvbnNvbGVLaXQuU2Vzc2lvbiIKKworc3RhdGlj IERCdXNDb25uZWN0aW9uICpwcml2YXRlX2Nvbm5lY3Rpb24gPSBOVUxMOworCitzdGF0aWMgdm9p ZAorYWRkX3BhcmFtX2ludCAoREJ1c01lc3NhZ2VJdGVyICppdGVyX3N0cnVjdCwKKwkgICAgICAg Y29uc3QgY2hhciAgICAgICprZXksCisJICAgICAgIGludCAgICAgICAgICAgICAgdmFsdWUpCit7 CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXJfc3RydWN0X2VudHJ5OworCURCdXNNZXNzYWdlSXRlciBp dGVyX3ZhcjsKKworCWRidXNfbWVzc2FnZV9pdGVyX29wZW5fY29udGFpbmVyIChpdGVyX3N0cnVj dCwKKwkJCQkJICBEQlVTX1RZUEVfU1RSVUNULAorCQkJCQkgIE5VTEwsCisJCQkJCSAgJml0ZXJf c3RydWN0X2VudHJ5KTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXJf c3RydWN0X2VudHJ5LAorCQkJCQlEQlVTX1RZUEVfU1RSSU5HLAorCQkJCQkma2V5KTsKKworCWRi dXNfbWVzc2FnZV9pdGVyX29wZW5fY29udGFpbmVyICgmaXRlcl9zdHJ1Y3RfZW50cnksCisJCQkJ CSAgREJVU19UWVBFX1ZBUklBTlQsCisJCQkJCSAgREJVU19UWVBFX0lOVDMyX0FTX1NUUklORywK KwkJCQkJICAmaXRlcl92YXIpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljICgm aXRlcl92YXIsCisJCQkJCURCVVNfVFlQRV9JTlQzMiwKKwkJCQkJJnZhbHVlKTsKKworCWRidXNf bWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkg ICAmaXRlcl92YXIpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFpbmVyIChpdGVy X3N0cnVjdCwgJml0ZXJfc3RydWN0X2VudHJ5KTsKK30KKworc3RhdGljIHZvaWQKK2FkZF9wYXJh bV9ib29sZWFuIChEQnVzTWVzc2FnZUl0ZXIgKml0ZXJfc3RydWN0LAorCQkgICBjb25zdCBjaGFy ICAgICAgKmtleSwKKwkJICAgaW50ICAgICAgICAgICAgIHZhbHVlKQoreworCURCdXNNZXNzYWdl SXRlciBpdGVyX3N0cnVjdF9lbnRyeTsKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcl92YXI7CisKKwlk YnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5lciAoaXRlcl9zdHJ1Y3QsCisJCQkJCSAgREJV U19UWVBFX1NUUlVDVCwKKwkJCQkJICBOVUxMLAorCQkJCQkgICZpdGVyX3N0cnVjdF9lbnRyeSk7 CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMgKCZpdGVyX3N0cnVjdF9lbnRyeSwK KwkJCQkJREJVU19UWVBFX1NUUklORywKKwkJCQkJJmtleSk7CisKKwlkYnVzX21lc3NhZ2VfaXRl cl9vcGVuX2NvbnRhaW5lciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgIERCVVNfVFlQRV9W QVJJQU5ULAorCQkJCQkgIERCVVNfVFlQRV9CT09MRUFOX0FTX1NUUklORywKKwkJCQkJICAmaXRl cl92YXIpOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfYXBwZW5kX2Jhc2ljICgmaXRlcl92YXIsCisJ CQkJCURCVVNfVFlQRV9CT09MRUFOLAorCQkJCQkmdmFsdWUpOworCisJZGJ1c19tZXNzYWdlX2l0 ZXJfY2xvc2VfY29udGFpbmVyICgmaXRlcl9zdHJ1Y3RfZW50cnksCisJCQkJCSAgICZpdGVyX3Zh cik7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9jbG9zZV9jb250YWluZXIgKGl0ZXJfc3RydWN0LCAm aXRlcl9zdHJ1Y3RfZW50cnkpOworfQorCitzdGF0aWMgdm9pZAorYWRkX3BhcmFtX3N0cmluZyAo REJ1c01lc3NhZ2VJdGVyICppdGVyX3N0cnVjdCwKKwkJICBjb25zdCBjaGFyICAgICAgKmtleSwK KwkJICBjb25zdCBjaGFyICAgICAgKnZhbHVlKQoreworCURCdXNNZXNzYWdlSXRlciBpdGVyX3N0 cnVjdF9lbnRyeTsKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcl92YXI7CisKKwlkYnVzX21lc3NhZ2Vf aXRlcl9vcGVuX2NvbnRhaW5lciAoaXRlcl9zdHJ1Y3QsCisJCQkJCSAgREJVU19UWVBFX1NUUlVD VCwKKwkJCQkJICBOVUxMLAorCQkJCQkgICZpdGVyX3N0cnVjdF9lbnRyeSk7CisKKwlkYnVzX21l c3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMgKCZpdGVyX3N0cnVjdF9lbnRyeSwKKwkJCQkJREJVU19U WVBFX1NUUklORywKKwkJCQkJJmtleSk7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRh aW5lciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgIERCVVNfVFlQRV9WQVJJQU5ULAorCQkJ CQkgIERCVVNfVFlQRV9TVFJJTkdfQVNfU1RSSU5HLAorCQkJCQkgICZpdGVyX3Zhcik7CisKKwlk YnVzX21lc3NhZ2VfaXRlcl9hcHBlbmRfYmFzaWMgKCZpdGVyX3ZhciwKKwkJCQkJREJVU19UWVBF X1NUUklORywKKwkJCQkJJnZhbHVlKTsKKworCWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRh aW5lciAoJml0ZXJfc3RydWN0X2VudHJ5LAorCQkJCQkgICAmaXRlcl92YXIpOworCisJZGJ1c19t ZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFpbmVyIChpdGVyX3N0cnVjdCwgJml0ZXJfc3RydWN0X2Vu dHJ5KTsKK30KKworc3RhdGljIGludAorc2Vzc2lvbl9nZXRfeDExX2Rpc3BsYXkgKERCdXNDb25u ZWN0aW9uICpjb25uZWN0aW9uLAorCQkJIGNvbnN0IGNoYXIgICAgICpzc2lkLAorCQkJIGNoYXIg ICAgICAgICAgKipzdHIpCit7CisJREJ1c0Vycm9yICAgICAgIGVycm9yOworCURCdXNNZXNzYWdl ICAgICptZXNzYWdlOworCURCdXNNZXNzYWdlICAgICpyZXBseTsKKwlEQnVzTWVzc2FnZUl0ZXIg aXRlcjsKKwljb25zdCBjaGFyICAgICAqdmFsdWU7CisKKwlpZiAoc3RyICE9IE5VTEwpIHsKKwkJ KnN0ciA9IE5VTEw7CisJfQorCisJbWVzc2FnZSA9IGRidXNfbWVzc2FnZV9uZXdfbWV0aG9kX2Nh bGwgKENLX05BTUUsCisJCQkJCQlzc2lkLAorCQkJCQkJQ0tfU0VTU0lPTl9JTlRFUkZBQ0UsCisJ CQkJCQkiR2V0WDExRGlzcGxheSIpOworCWlmIChtZXNzYWdlID09IE5VTEwpIHsKKwkJZGVidWcg KCJDb25zb2xlS2l0OiBDb3VsZG4ndCBhbGxvY2F0ZSB0aGUgRC1CdXMgbWVzc2FnZSIpOworCQly ZXR1cm4gRkFMU0U7CisJfQorCisJZGJ1c19lcnJvcl9pbml0ICgmZXJyb3IpOworCXJlcGx5ID0g ZGJ1c19jb25uZWN0aW9uX3NlbmRfd2l0aF9yZXBseV9hbmRfYmxvY2sgKGNvbm5lY3Rpb24sCisJ CQkJCQkJICAgbWVzc2FnZSwKKwkJCQkJCQkgICAtMSwgJmVycm9yKTsKKwlpZiAoZGJ1c19lcnJv cl9pc19zZXQgKCZlcnJvcikpIHsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiAlcyByYWlzZWQ6XG4g JXNcblxuIiwgZXJyb3IubmFtZSwgZXJyb3IubWVzc2FnZSk7CisJCXJlcGx5ID0gTlVMTDsKKwl9 CisKKwlkYnVzX2Nvbm5lY3Rpb25fZmx1c2ggKGNvbm5lY3Rpb24pOworCWRidXNfbWVzc2FnZV91 bnJlZiAobWVzc2FnZSk7CisKKwlpZiAocmVwbHkgPT0gTlVMTCkgeworCQlyZXR1cm4gRkFMU0U7 CisJfQorCisJZGJ1c19tZXNzYWdlX2l0ZXJfaW5pdCAocmVwbHksICZpdGVyKTsKKwlkYnVzX21l c3NhZ2VfaXRlcl9nZXRfYmFzaWMgKCZpdGVyLCAmdmFsdWUpOworCWlmIChzdHIgIT0gTlVMTCkg eworCQkqc3RyID0gc3RyZHVwICh2YWx1ZSk7CisJfQorCWRidXNfbWVzc2FnZV91bnJlZiAocmVw bHkpOworCisJcmV0dXJuIFRSVUU7Cit9CisKK3N0YXRpYyBpbnQKK3Nlc3Npb25fdW5sb2NrIChE QnVzQ29ubmVjdGlvbiAqY29ubmVjdGlvbiwKKwkJY29uc3QgY2hhciAgICAgKnNzaWQpCit7CisJ REJ1c0Vycm9yICAgICAgIGVycm9yOworCURCdXNNZXNzYWdlICAgICptZXNzYWdlOworCURCdXNN ZXNzYWdlICAgICpyZXBseTsKKworCWRlYnVnICgiQ29uc29sZUtpdDogVW5sb2NraW5nIHNlc3Np b24gJXMiLCBzc2lkKTsKKwltZXNzYWdlID0gZGJ1c19tZXNzYWdlX25ld19tZXRob2RfY2FsbCAo Q0tfTkFNRSwKKwkJCQkJCXNzaWQsCisJCQkJCQlDS19TRVNTSU9OX0lOVEVSRkFDRSwKKwkJCQkJ CSJVbmxvY2siKTsKKwlpZiAobWVzc2FnZSA9PSBOVUxMKSB7CisJCWRlYnVnICgiQ29uc29sZUtp dDogQ291bGRuJ3QgYWxsb2NhdGUgdGhlIEQtQnVzIG1lc3NhZ2UiKTsKKwkJcmV0dXJuIEZBTFNF OworCX0KKworCWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwlyZXBseSA9IGRidXNfY29ubmVj dGlvbl9zZW5kX3dpdGhfcmVwbHlfYW5kX2Jsb2NrIChjb25uZWN0aW9uLAorCQkJCQkJCSAgIG1l c3NhZ2UsCisJCQkJCQkJICAgLTEsICZlcnJvcik7CisJZGJ1c19tZXNzYWdlX3VucmVmIChtZXNz YWdlKTsKKwlkYnVzX21lc3NhZ2VfdW5yZWYgKHJlcGx5KTsKKwlkYnVzX2Nvbm5lY3Rpb25fZmx1 c2ggKGNvbm5lY3Rpb24pOworCisJaWYgKGRidXNfZXJyb3JfaXNfc2V0ICgmZXJyb3IpKSB7CisJ CWRlYnVnICgiQ29uc29sZUtpdDogJXMgcmFpc2VkOlxuICVzXG5cbiIsIGVycm9yLm5hbWUsIGVy cm9yLm1lc3NhZ2UpOworCQlyZXR1cm4gRkFMU0U7CisJfQorCisJcmV0dXJuIFRSVUU7Cit9CisK Ky8qIGZyb20gbGliaGFsICovCitzdGF0aWMgY2hhciAqKgorZ2V0X3BhdGhfYXJyYXlfZnJvbV9p dGVyIChEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkgIGludCAgICAgICAgICAgICAqbnVtX2Vs ZW1lbnRzKQoreworCWludCBjb3VudDsKKwljaGFyICoqYnVmZmVyOworCisJY291bnQgPSAwOwor CWJ1ZmZlciA9IChjaGFyICoqKW1hbGxvYyAoc2l6ZW9mIChjaGFyICopICogOCk7CisKKwlpZiAo YnVmZmVyID09IE5VTEwpCisJCWdvdG8gb29tOworCisJYnVmZmVyWzBdID0gTlVMTDsKKwl3aGls ZSAoZGJ1c19tZXNzYWdlX2l0ZXJfZ2V0X2FyZ190eXBlIChpdGVyKSA9PSBEQlVTX1RZUEVfT0JK RUNUX1BBVEgpIHsKKwkJY29uc3QgY2hhciAqdmFsdWU7CisJCWNoYXIgKnN0cjsKKworCQlpZiAo KGNvdW50ICUgOCkgPT0gMCAmJiBjb3VudCAhPSAwKSB7CisJCQlidWZmZXIgPSByZWFsbG9jIChi dWZmZXIsIHNpemVvZiAoY2hhciAqKSAqIChjb3VudCArIDgpKTsKKwkJCWlmIChidWZmZXIgPT0g TlVMTCkKKwkJCQlnb3RvIG9vbTsKKwkJfQorCisJCWRidXNfbWVzc2FnZV9pdGVyX2dldF9iYXNp YyAoaXRlciwgJnZhbHVlKTsKKwkJc3RyID0gc3RyZHVwICh2YWx1ZSk7CisJCWlmIChzdHIgPT0g TlVMTCkKKwkJCWdvdG8gb29tOworCisJCWJ1ZmZlcltjb3VudF0gPSBzdHI7CisKKwkJZGJ1c19t ZXNzYWdlX2l0ZXJfbmV4dCAoaXRlcik7CisJCWNvdW50Kys7CisJfQorCisJaWYgKChjb3VudCAl IDgpID09IDApIHsKKwkJYnVmZmVyID0gcmVhbGxvYyAoYnVmZmVyLCBzaXplb2YgKGNoYXIgKikg KiAoY291bnQgKyAxKSk7CisJCWlmIChidWZmZXIgPT0gTlVMTCkKKwkJCWdvdG8gb29tOworCX0K KworCWJ1ZmZlcltjb3VudF0gPSBOVUxMOworCWlmIChudW1fZWxlbWVudHMgIT0gTlVMTCkKKwkJ Km51bV9lbGVtZW50cyA9IGNvdW50OworCXJldHVybiBidWZmZXI7CisKK29vbToKKwlsb2dXYXJu ICgiJXMgJWQgOiBlcnJvciBhbGxvY2F0aW5nIG1lbW9yeVxuIiwgX19GSUxFX18sIF9fTElORV9f KTsKKwlyZXR1cm4gTlVMTDsKKworfQorCitzdGF0aWMgY2hhciAqKgorZ2V0X3Nlc3Npb25zX2Zv cl91c2VyIChEQnVzQ29ubmVjdGlvbiAqY29ubmVjdGlvbiwKKwkJICAgICAgIGNvbnN0IGNoYXIg ICAgICp1c2VyLAorCQkgICAgICAgY29uc3QgY2hhciAgICAgKngxMV9kaXNwbGF5KQoreworCURC dXNFcnJvciAgICAgICBlcnJvcjsKKwlEQnVzTWVzc2FnZSAgICAqbWVzc2FnZTsKKwlEQnVzTWVz c2FnZSAgICAqcmVwbHk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXI7CisJREJ1c01lc3NhZ2VJdGVy IGl0ZXJfcmVwbHk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXJfYXJyYXk7CisJc3RydWN0IHBhc3N3 ZAkqcHdlbnQ7CisJY2hhciAgICAgICAgICAgKipzZXNzaW9uczsKKworCXNlc3Npb25zID0gTlVM TDsKKwltZXNzYWdlID0gTlVMTDsKKwlyZXBseSA9IE5VTEw7CisKKwlwd2VudCA9IGdldHB3bmFt ICh1c2VyKTsKKworCWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwltZXNzYWdlID0gZGJ1c19t ZXNzYWdlX25ld19tZXRob2RfY2FsbCAoQ0tfTkFNRSwKKwkJCQkJCUNLX01BTkFHRVJfUEFUSCwK KwkJCQkJCUNLX01BTkFHRVJfSU5URVJGQUNFLAorCQkJCQkJIkdldFNlc3Npb25zRm9yVXNlciIp OworCWlmIChtZXNzYWdlID09IE5VTEwpIHsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiBDb3VsZG4n dCBhbGxvY2F0ZSB0aGUgRC1CdXMgbWVzc2FnZSIpOworCQlnb3RvIG91dDsKKwl9CisKKwlkYnVz X21lc3NhZ2VfaXRlcl9pbml0X2FwcGVuZCAobWVzc2FnZSwgJml0ZXIpOworCWRidXNfbWVzc2Fn ZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXIsCisJCQkJCURCVVNfVFlQRV9VSU5UMzIsCisJCQkJ CSZwd2VudC0+cHdfdWlkKTsKKworCWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwlyZXBseSA9 IGRidXNfY29ubmVjdGlvbl9zZW5kX3dpdGhfcmVwbHlfYW5kX2Jsb2NrIChjb25uZWN0aW9uLAor CQkJCQkJCSAgIG1lc3NhZ2UsCisJCQkJCQkJICAgLTEsICZlcnJvcik7CisJZGJ1c19jb25uZWN0 aW9uX2ZsdXNoIChjb25uZWN0aW9uKTsKKworCWlmIChkYnVzX2Vycm9yX2lzX3NldCAoJmVycm9y KSkgeworCQlkZWJ1ZyAoIkNvbnNvbGVLaXQ6ICVzIHJhaXNlZDpcbiAlc1xuXG4iLCBlcnJvci5u YW1lLCBlcnJvci5tZXNzYWdlKTsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKHJlcGx5ID09IE5V TEwpIHsKKwkJZGVidWcgKCJDb25zb2xlS2l0OiBObyByZXBseSBmb3IgR2V0U2Vzc2lvbnNGb3JV c2VyIik7CisJCWdvdG8gb3V0OworCX0KKworCWRidXNfbWVzc2FnZV9pdGVyX2luaXQgKHJlcGx5 LCAmaXRlcl9yZXBseSk7CisJaWYgKGRidXNfbWVzc2FnZV9pdGVyX2dldF9hcmdfdHlwZSAoJml0 ZXJfcmVwbHkpICE9IERCVVNfVFlQRV9BUlJBWSkgeworCQlkZWJ1ZyAoIkNvbnNvbGVLaXQ6IFdy b25nIHJlcGx5IGZvciBHZXRTZXNzaW9uc0ZvclVzZXIgLSBleHBlY3RpbmcgYW4gYXJyYXkuIik7 CisJCWdvdG8gb3V0OworCX0KKworCWRidXNfbWVzc2FnZV9pdGVyX3JlY3Vyc2UgKCZpdGVyX3Jl cGx5LCAmaXRlcl9hcnJheSk7CisJc2Vzc2lvbnMgPSBnZXRfcGF0aF9hcnJheV9mcm9tX2l0ZXIg KCZpdGVyX2FycmF5LCBOVUxMKTsKKworIG91dDoKKwlpZiAobWVzc2FnZSAhPSBOVUxMKSB7CisJ CWRidXNfbWVzc2FnZV91bnJlZiAobWVzc2FnZSk7CisJfQorCWlmIChyZXBseSAhPSBOVUxMKSB7 CisJCWRidXNfbWVzc2FnZV91bnJlZiAocmVwbHkpOworCX0KKworCXJldHVybiBzZXNzaW9uczsK K30KKwordm9pZAordW5sb2NrX2NrX3Nlc3Npb24gKGNvbnN0IGNoYXIgKnVzZXIsCisJCSAgIGNv bnN0IGNoYXIgKngxMV9kaXNwbGF5KQoreworCURCdXNFcnJvciAgICAgICBlcnJvcjsKKwlEQnVz Q29ubmVjdGlvbiAqY29ubmVjdGlvbjsKKwljaGFyICAgICAgICAgICAqKnNlc3Npb25zOworCWlu dCAgICAgICAgICAgICAgaTsKKworCWRlYnVnICgiQ29uc29sZUtpdDogVW5sb2NraW5nIHNlc3Np b24gZm9yICVzIG9uICVzIiwgdXNlciwgeDExX2Rpc3BsYXkpOworCisJZGJ1c19lcnJvcl9pbml0 ICgmZXJyb3IpOworCWNvbm5lY3Rpb24gPSBkYnVzX2J1c19nZXQgKERCVVNfQlVTX1NZU1RFTSwg JmVycm9yKTsKKwlpZiAoY29ubmVjdGlvbiA9PSBOVUxMKSB7CisJCWRlYnVnICgiQ29uc29sZUtp dDogRmFpbGVkIHRvIGNvbm5lY3QgdG8gdGhlIEQtQnVzIGRhZW1vbjogJXMiLCBlcnJvci5tZXNz YWdlKTsKKwkJZGJ1c19lcnJvcl9mcmVlICgmZXJyb3IpOworCQlyZXR1cm47CisJfQorCisJc2Vz c2lvbnMgPSBnZXRfc2Vzc2lvbnNfZm9yX3VzZXIgKGNvbm5lY3Rpb24sIHVzZXIsIHgxMV9kaXNw bGF5KTsKKwlpZiAoc2Vzc2lvbnMgPT0gTlVMTCB8fCBzZXNzaW9uc1swXSA9PSBOVUxMKSB7CisJ CWRlYnVnICgiQ29uc29sZUtpdDogbm8gc2Vzc2lvbnMgZm91bmQiKTsKKwkJcmV0dXJuOworCX0K KworCWZvciAoaSA9IDA7IHNlc3Npb25zW2ldICE9IE5VTEw7IGkrKykgeworCQljaGFyICpzc2lk OworCQljaGFyICp4ZGlzcGxheTsKKworCQlzc2lkID0gc2Vzc2lvbnNbaV07CisJCXNlc3Npb25f Z2V0X3gxMV9kaXNwbGF5IChjb25uZWN0aW9uLCBzc2lkLCAmeGRpc3BsYXkpOworCQlkZWJ1ZyAo IkNvbnNvbGVLaXQ6IHNlc3Npb24gJXMgaGFzIERJU1BMQVkgJXMiLCBzc2lkLCB4ZGlzcGxheSk7 CisKKwkJaWYgKHhkaXNwbGF5ICE9IE5VTEwKKwkJICAgICYmIHgxMV9kaXNwbGF5ICE9IE5VTEwK KwkJICAgICYmIHN0cmNtcCAoeGRpc3BsYXksIHgxMV9kaXNwbGF5KSA9PSAwKSB7CisJCQlpbnQg cmVzOworCisJCQlyZXMgPSBzZXNzaW9uX3VubG9jayAoY29ubmVjdGlvbiwgc3NpZCk7CisJCQlp ZiAoISByZXMpIHsKKwkJCQlsb2dFcnJvciAoIkNvbnNvbGVLaXQ6IFVuYWJsZSB0byB1bmxvY2sg JXMiLCBzc2lkKTsKKwkJCX0KKwkJfQorCisJCWZyZWUgKHhkaXNwbGF5KTsKKwl9CisKKwlmcmVl U3RyQXJyIChzZXNzaW9ucyk7Cit9CisKK2NoYXIgKgorb3Blbl9ja19zZXNzaW9uIChzdHJ1Y3Qg cGFzc3dkICpwd2VudCwKKwkJIHN0cnVjdCBkaXNwbGF5ICpkKQoreworCURCdXNDb25uZWN0aW9u ICpjb25uZWN0aW9uOworCURCdXNFcnJvciAgICAgICBlcnJvcjsKKwlEQnVzTWVzc2FnZSAgICAq bWVzc2FnZTsKKwlEQnVzTWVzc2FnZSAgICAqcmVwbHk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXI7 CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXJfc3RydWN0OworCWNoYXIJICAgICAgICpjb29raWU7CisK Kwljb29raWUgPSBOVUxMOworCisJaWYgKHB3ZW50ID09IE5VTEwpIHsKKwkJZGVidWcgKCJDb25z b2xlS2l0OiBOVUxMIHVzZXIgcGFzc2VkIGFzIHBhcmFtZXRlciIpOworCQlyZXR1cm4gTlVMTDsK Kwl9CisKKwlkZWJ1ZyAoIkNvbnNvbGVLaXQ6IE9wZW5pbmcgc2Vzc2lvbiBmb3IgJXMiLCBwd2Vu dC0+cHdfbmFtZSk7CisKKwlkYnVzX2Vycm9yX2luaXQgKCZlcnJvcik7CisJY29ubmVjdGlvbiA9 IGRidXNfYnVzX2dldF9wcml2YXRlIChEQlVTX0JVU19TWVNURU0sICZlcnJvcik7CisJcHJpdmF0 ZV9jb25uZWN0aW9uID0gY29ubmVjdGlvbjsKKworCWlmIChjb25uZWN0aW9uID09IE5VTEwpIHsK KwkJZGVidWcgKCJDb25zb2xlS2l0OiBGYWlsZWQgdG8gY29ubmVjdCB0byB0aGUgRC1CdXMgZGFl bW9uOiAlcyIsIGVycm9yLm1lc3NhZ2UpOworCQlkYnVzX2Vycm9yX2ZyZWUgKCZlcnJvcik7CisJ CXJldHVybiBOVUxMOworCX0KKworCWRidXNfY29ubmVjdGlvbl9zZXRfZXhpdF9vbl9kaXNjb25u ZWN0IChjb25uZWN0aW9uLCBGQUxTRSk7CisJLyogTm8gbWFpbmxvb3AgaW50ZWdyYXRpb24gbmVl ZGVkIGZvciBELUJ1cyBiZWNhdXNlIG9ubHkgYmxvY2tpbmcgY2FsbHMgYXJlIHVzZWQuICovCisK KwlkYnVzX2Vycm9yX2luaXQgKCZlcnJvcik7CisJbWVzc2FnZSA9IGRidXNfbWVzc2FnZV9uZXdf bWV0aG9kX2NhbGwgKENLX05BTUUsCisJCQkJCQlDS19NQU5BR0VSX1BBVEgsCisJCQkJCQlDS19N QU5BR0VSX0lOVEVSRkFDRSwKKwkJCQkJCSJPcGVuU2Vzc2lvbldpdGhQYXJhbWV0ZXJzIik7CisJ aWYgKG1lc3NhZ2UgPT0gTlVMTCkgeworCQlkZWJ1ZyAoIkNvbnNvbGVLaXQ6IENvdWxkbid0IGFs bG9jYXRlIHRoZSBELUJ1cyBtZXNzYWdlIik7CisJCXJldHVybiBOVUxMOworCX0KKworCWRidXNf bWVzc2FnZV9pdGVyX2luaXRfYXBwZW5kIChtZXNzYWdlLCAmaXRlcik7CisJZGJ1c19tZXNzYWdl X2l0ZXJfb3Blbl9jb250YWluZXIgKCZpdGVyLAorCQkJCQkgIERCVVNfVFlQRV9BUlJBWSwKKwkJ CQkJICBEQlVTX1NUUlVDVF9CRUdJTl9DSEFSX0FTX1NUUklORworCQkJCQkgIERCVVNfVFlQRV9T VFJJTkdfQVNfU1RSSU5HCisJCQkJCSAgREJVU19UWVBFX1ZBUklBTlRfQVNfU1RSSU5HCisJCQkJ CSAgREJVU19TVFJVQ1RfRU5EX0NIQVJfQVNfU1RSSU5HLAorCQkJCQkgICZpdGVyX3N0cnVjdCk7 CisKKwlhZGRfcGFyYW1faW50ICgmaXRlcl9zdHJ1Y3QsICJ1c2VyIiwgcHdlbnQtPnB3X3VpZCk7 CisJYWRkX3BhcmFtX3N0cmluZyAoJml0ZXJfc3RydWN0LCAieDExLWRpc3BsYXkiLCBkLT5uYW1l KTsKKwlhZGRfcGFyYW1fYm9vbGVhbiAoJml0ZXJfc3RydWN0LCAiaXMtbG9jYWwiLCAoKGQtPmRp c3BsYXlUeXBlICYgZF9sb2NhdGlvbikgPT0gZExvY2FsKSk7CisjaWZkZWYgWERNQ1AKKwlpZiAo KGQtPmRpc3BsYXlUeXBlICYgZF9sb2NhdGlvbikgIT0gZExvY2FsKSB7CisJCWFkZF9wYXJhbV9z dHJpbmcgKCZpdGVyX3N0cnVjdCwgInJlbW90ZS1ob3N0LW5hbWUiLCBkLT5yZW1vdGVIb3N0KTsK Kwl9CisjZW5kaWYKKworI2lmZGVmIEhBVkVfVlRTCisJaWYgKGQtPnNlcnZlclZUID4gMCkgewor CQljaGFyIGRldmljZVsyMF07CisKKwkJLyogRklYTUU6IGhvdyBkb2VzIHhvcmcgY29uc3RydWN0 IHRoaXMgKi8KKwkJc3ByaW50ZihkZXZpY2UsICIvZGV2L3R0eSVkIiwgZC0+c2VydmVyVlQpOwor CQlhZGRfcGFyYW1fc3RyaW5nICgmaXRlcl9zdHJ1Y3QsICJ4MTEtZGlzcGxheS1kZXZpY2UiLCBk ZXZpY2UpOworCX0KKyNlbmRpZgorCisJZGJ1c19tZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFpbmVy ICgmaXRlciwgJml0ZXJfc3RydWN0KTsKKworCXJlcGx5ID0gZGJ1c19jb25uZWN0aW9uX3NlbmRf d2l0aF9yZXBseV9hbmRfYmxvY2sgKGNvbm5lY3Rpb24sCisJCQkJCQkJICAgbWVzc2FnZSwKKwkJ CQkJCQkgICAtMSwgJmVycm9yKTsKKwlpZiAoZGJ1c19lcnJvcl9pc19zZXQgKCZlcnJvcikpIHsK KwkJZGVidWcgKCJDb25zb2xlS2l0OiAlcyByYWlzZWQ6XG4gJXNcblxuIiwgZXJyb3IubmFtZSwg ZXJyb3IubWVzc2FnZSk7CisJCXJlcGx5ID0gTlVMTDsKKwl9CisKKwlkYnVzX2Nvbm5lY3Rpb25f Zmx1c2ggKGNvbm5lY3Rpb24pOworCisJZGJ1c19tZXNzYWdlX3VucmVmIChtZXNzYWdlKTsKKwlk YnVzX2Vycm9yX2ZyZWUgKCZlcnJvcik7CisKKwlpZiAocmVwbHkgIT0gTlVMTCkgeworCQljb25z dCBjaGFyICp2YWx1ZTsKKworCQlkYnVzX21lc3NhZ2VfaXRlcl9pbml0IChyZXBseSwgJml0ZXIp OworCQlkYnVzX21lc3NhZ2VfaXRlcl9nZXRfYmFzaWMgKCZpdGVyLCAmdmFsdWUpOworCQljb29r aWUgPSBzdHJkdXAgKHZhbHVlKTsKKwkJZGJ1c19tZXNzYWdlX3VucmVmIChyZXBseSk7CisJfQor CisJcmV0dXJuIGNvb2tpZTsKK30KKwordm9pZAorY2xvc2VfY2tfc2Vzc2lvbiAoY29uc3QgY2hh ciAqY29va2llKQoreworCURCdXNFcnJvciAgICAgICBlcnJvcjsKKwlEQnVzTWVzc2FnZSAgICAq bWVzc2FnZTsKKwlEQnVzTWVzc2FnZSAgICAqcmVwbHk7CisJREJ1c01lc3NhZ2VJdGVyIGl0ZXI7 CisKKwlpZiAoY29va2llID09IE5VTEwpIHsKKwkJcmV0dXJuOworCX0KKworCWlmIChwcml2YXRl X2Nvbm5lY3Rpb24gPT0gTlVMTCkgeworCQlyZXR1cm47CisJfQorCisJZGJ1c19lcnJvcl9pbml0 ICgmZXJyb3IpOworCW1lc3NhZ2UgPSBkYnVzX21lc3NhZ2VfbmV3X21ldGhvZF9jYWxsIChDS19O QU1FLAorCQkJCQkJQ0tfTUFOQUdFUl9QQVRILAorCQkJCQkJQ0tfTUFOQUdFUl9JTlRFUkZBQ0Us CisJCQkJCQkiQ2xvc2VTZXNzaW9uIik7CisJaWYgKG1lc3NhZ2UgPT0gTlVMTCkgeworCQlkZWJ1 ZyAoIkNvbnNvbGVLaXQ6IENvdWxkbid0IGFsbG9jYXRlIHRoZSBELUJ1cyBtZXNzYWdlIik7CisJ CXJldHVybjsKKwl9CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9pbml0X2FwcGVuZCAobWVzc2FnZSwg Jml0ZXIpOworCWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYyAoJml0ZXIsCisJCQkJCURC VVNfVFlQRV9TVFJJTkcsCisJCQkJCSZjb29raWUpOworCisJcmVwbHkgPSBkYnVzX2Nvbm5lY3Rp b25fc2VuZF93aXRoX3JlcGx5X2FuZF9ibG9jayAocHJpdmF0ZV9jb25uZWN0aW9uLAorCQkJCQkJ CSAgIG1lc3NhZ2UsCisJCQkJCQkJICAgLTEsICZlcnJvcik7CisJaWYgKGRidXNfZXJyb3JfaXNf c2V0ICgmZXJyb3IpKSB7CisJCWRlYnVnICgiQ29uc29sZUtpdDogJXMgcmFpc2VkOlxuICVzXG5c biIsIGVycm9yLm5hbWUsIGVycm9yLm1lc3NhZ2UpOworCQlyZXBseSA9IE5VTEw7CisJfQorCisJ ZGJ1c19jb25uZWN0aW9uX2ZsdXNoIChwcml2YXRlX2Nvbm5lY3Rpb24pOworCisJZGJ1c19tZXNz YWdlX3VucmVmIChtZXNzYWdlKTsKKwlkYnVzX2Vycm9yX2ZyZWUgKCZlcnJvcik7CisKKyAgICAg ICAgZGJ1c19jb25uZWN0aW9uX2Nsb3NlIChwcml2YXRlX2Nvbm5lY3Rpb24pOworCXByaXZhdGVf Y29ubmVjdGlvbiA9IE5VTEw7Cit9CmRpZmYgLU51ciBrZGViYXNlLXdvcmtzcGFjZS00LjAuMC9r ZG0vYmFja2VuZC9jb25zb2xla2l0Lmgga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAtY29uc29sZWtp dC1rZG0va2RtL2JhY2tlbmQvY29uc29sZWtpdC5oCi0tLSBrZGViYXNlLXdvcmtzcGFjZS00LjAu MC9rZG0vYmFja2VuZC9jb25zb2xla2l0LmgJMTk3MC0wMS0wMSAwMTowMDowMC4wMDAwMDAwMDAg KzAxMDAKKysrIGtkZWJhc2Utd29ya3NwYWNlLTQuMC4wLWNvbnNvbGVraXQta2RtL2tkbS9iYWNr ZW5kL2NvbnNvbGVraXQuaAkyMDA4LTAxLTA4IDAxOjExOjI1LjAwMDAwMDAwMCArMDEwMApAQCAt MCwwICsxLDM2IEBACisvKiAtKi0gTW9kZTogQzsgdGFiLXdpZHRoOiA4OyBpbmRlbnQtdGFicy1t b2RlOiB0OyBjLWJhc2ljLW9mZnNldDogOCAtKi0KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYg V2lsbGlhbSBKb24gTWNDYW5uIDxtY2Nhbm5Aamh1LmVkdT4KKyAqIENvcHlyaWdodCAoQykgMjAw NyBLZXZpbiBLb2ZsZXIgPEtldmluQHRpZ2NjLnRpY2FsYy5vcmc+CisgKgorICogVGhpcyBwcm9n cmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2Rp ZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRo ZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkg bGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhl IGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5U WTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJ VFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91 bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl CisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBT b2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMw LCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8KKworCisjaWZuZGVmIF9fQ09O U09MRV9LSVRfSAorI2RlZmluZSBfX0NPTlNPTEVfS0lUX0gKKworI2luY2x1ZGUgPHB3ZC5oPgor CitzdHJ1Y3QgZGlzcGxheTsKKworY2hhciAqICAgICAgb3Blbl9ja19zZXNzaW9uICAgICAgIChz dHJ1Y3QgcGFzc3dkICpwd2VudCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg c3RydWN0IGRpc3BsYXkgKmRpc3BsYXkpOwordm9pZCAgICAgICAgY2xvc2VfY2tfc2Vzc2lvbiAg ICAgIChjb25zdCBjaGFyICAgICpjb29raWUpOwordm9pZCAgICAgICAgdW5sb2NrX2NrX3Nlc3Np b24gICAgIChjb25zdCBjaGFyICAgICp1c2VyLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBjb25zdCBjaGFyICAgICp4MTFfZGlzcGxheSk7CisKKyNlbmRpZiAvKiBfX0NPTlNP TEVfS0lUX0ggKi8KZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMC4wL2tkbS9iYWNrZW5k L2RtLmgga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAtY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQv ZG0uaAotLS0ga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAva2RtL2JhY2tlbmQvZG0uaAkyMDA4LTAx LTA1IDAwOjU1OjQ0LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAt Y29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQvZG0uaAkyMDA4LTAxLTA4IDAxOjExOjI1LjAwMDAw MDAwMCArMDEwMApAQCAtMzcsNiArMzcsOCBAQAogI2lmbmRlZiBfRE1fSF8KICNkZWZpbmUgX0RN X0hfIDEKIAorI2RlZmluZSBXSVRIX0NPTlNPTEVfS0lUCisKICNpbmNsdWRlICJncmVldC5oIgog CiAjZGVmaW5lIFdBTlRfQ09SRV9ERUNMUwpAQCAtNTA0LDcgKzUwNiwxMSBAQAogI2RlZmluZSBH Q09OVl9CSU5BUlkgIDUKIHR5cGVkZWYgY2hhciAqKCpHQ29udkZ1bmMpKCBpbnQgd2hhdCwgY29u c3QgY2hhciAqcHJvbXB0ICk7CiBpbnQgdmVyaWZ5KCBHQ29udkZ1bmMgZ2NvbnYsIGludCByb290 b2sgKTsKKyNpZmRlZiBXSVRIX0NPTlNPTEVfS0lUCitpbnQgc3RhcnRDbGllbnQoIHZvbGF0aWxl IGludCAqcGlkLCAgY29uc3QgY2hhciAqY2tfc2Vzc2lvbl9jb29raWUgKTsKKyNlbHNlCiBpbnQg c3RhcnRDbGllbnQoIHZvbGF0aWxlIGludCAqcGlkICk7CisjZW5kaWYKIHZvaWQgY2xpZW50RXhp dGVkKCB2b2lkICk7CiB2b2lkIHNlc3Npb25FeGl0KCBpbnQgc3RhdHVzICkgQVRUUl9OT1JFVFVS TjsKIGludCByZWFkRG1yYyggdm9pZCApOwpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4w LjAva2RtL2JhY2tlbmQvSW1ha2VmaWxlIGtkZWJhc2Utd29ya3NwYWNlLTQuMC4wLWNvbnNvbGVr aXQta2RtL2tkbS9iYWNrZW5kL0ltYWtlZmlsZQotLS0ga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjAv a2RtL2JhY2tlbmQvSW1ha2VmaWxlCTIwMDgtMDEtMDUgMDA6NTU6NDQuMDAwMDAwMDAwICswMTAw CisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjAuMC1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9J bWFrZWZpbGUJMjAwOC0wMS0wOCAwMToxMToyNS4wMDAwMDAwMDAgKzAxMDAKQEAgLTE1NSwxMyAr MTU1LDEzIEBACiAJCSBuZXRhZGRyLmMgcmVzZXQuYyByZXNvdXJjZS5jIHByb3RvZHB5LmMgcG9s aWN5LmMgXAogCQkgc2Vzc2lvbi5jIHNvY2tldC5jIHN0cmVhbXMuYyB1dGlsLmMgeGRtY3AuYyBc CiAJCSBwcm9jZXNzLmMgbWl0YXV0aC5jIFwKLQkJIGdlbmF1dGguYyBhY2Nlc3MuYyBjaG9vc2Uu YyBcCisJCSBnZW5hdXRoLmMgYWNjZXNzLmMgY2hvb3NlLmMgY29uc29sZWtpdC5jIFwKIAkJICQo WERNQVVUSFNSQ1MpICQoUlBDU1JDUykgJChLUkI1U1JDUykKICAgICAgIENPTU1PQkpTID0gYXV0 aC5vIGRhZW1vbi5vIHNlcnZlci5vIGRweWxpc3QubyBkbS5vIGVycm9yLm8gXAogCQkgbmV0YWRk ci5vIHJlc2V0Lm8gcmVzb3VyY2UubyBwcm90b2RweS5vIHBvbGljeS5vIFwKIAkJIHNlc3Npb24u byBzb2NrZXQubyBzdHJlYW1zLm8gdXRpbC5vIHhkbWNwLm8gXAogCQkgcHJvY2Vzcy5vIG1pdGF1 dGgubyBcCi0JCSBnZW5hdXRoLm8gYWNjZXNzLm8gY2hvb3NlLm8gXAorCQkgZ2VuYXV0aC5vIGFj Y2Vzcy5vIGNob29zZS5vIGNvbnNvbGVraXQubyBcCiAJCSAkKFhETUFVVEhPQkpTKSAkKFJQQ09C SlMpICQoS1JCNU9CSlMpCiAKICAgICAgICAgIFNSQ1MxID0gJChDT01NU1JDUykgY2xpZW50LmMK ZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMC4wL2tkbS9iYWNrZW5kL3Nlc3Npb24uYyBr ZGViYXNlLXdvcmtzcGFjZS00LjAuMC1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9zZXNzaW9u LmMKLS0tIGtkZWJhc2Utd29ya3NwYWNlLTQuMC4wL2tkbS9iYWNrZW5kL3Nlc3Npb24uYwkyMDA4 LTAxLTA1IDAwOjU1OjQ0LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4w LjAtY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQvc2Vzc2lvbi5jCTIwMDgtMDEtMDggMDE6MTE6 MjUuMDAwMDAwMDAwICswMTAwCkBAIC00NSw2ICs0NSwxMCBAQAogI2luY2x1ZGUgPGN0eXBlLmg+ CiAjaW5jbHVkZSA8c2lnbmFsLmg+CiAKKyNpZmRlZiBXSVRIX0NPTlNPTEVfS0lUCisjaW5jbHVk ZSAiY29uc29sZWtpdC5oIgorI2VuZGlmCisKIHN0cnVjdCBkaXNwbGF5ICp0ZDsKIGNvbnN0IGNo YXIgKnRkX3NldHVwID0gImF1dG8iOwogCkBAIC01NTIsNiArNTU2LDEwIEBACiAJdm9sYXRpbGUg aW50IGNsaWVudFBpZCA9IC0xOwogCXZvbGF0aWxlIHRpbWVfdCB0ZGlmZiA9IDA7CiAJc2lnc2V0 X3Qgc3M7CisjaWZkZWYgV0lUSF9DT05TT0xFX0tJVAorCWNoYXIgKmNrX3Nlc3Npb25fY29va2ll OworI2VuZGlmCisKIAogCXRkID0gZDsKIAlkZWJ1ZyggIm1hbmFnZVNlc3Npb24gJXNcbiIsIGQt Pm5hbWUgKTsKQEAgLTYyOCw3ICs2MzYsMTIgQEAKIAlpZiAodGRfc2V0dXApCiAJCXNldHVwRGlz cGxheSggdGRfc2V0dXAgKTsKIAorI2lmZGVmIFdJVEhfQ09OU09MRV9LSVQKKwlja19zZXNzaW9u X2Nvb2tpZSA9IG9wZW5fY2tfc2Vzc2lvbiAoZ2V0cHduYW0oY3VydXNlciksIGQpOworCWlmICgh c3RhcnRDbGllbnQoICZjbGllbnRQaWQsIGNrX3Nlc3Npb25fY29va2llICkpIHsKKyNlbHNlCiAJ aWYgKCFzdGFydENsaWVudCggJmNsaWVudFBpZCApKSB7CisjZW5kaWYKIAkJbG9nRXJyb3IoICJD bGllbnQgc3RhcnQgZmFpbGVkXG4iICk7CiAJCXNlc3Npb25FeGl0KCBFWF9OT1JNQUwgKTsgLyog WFhYIG1heWJlIEVYX1JFTUFOQUdFX0RQWT8gLS0gZW5hYmxlIGluIGRtLmMhICovCiAJfQpAQCAt NjUwLDYgKzY2MywxNCBAQAogCQkJCWNhdGNoVGVybSggU0lHVEVSTSApOwogCQl9CiAJfQorCisj aWZkZWYgV0lUSF9DT05TT0xFX0tJVAorCWlmIChja19zZXNzaW9uX2Nvb2tpZSAhPSBOVUxMKSB7 CisJCWNsb3NlX2NrX3Nlc3Npb24gKGNrX3Nlc3Npb25fY29va2llKTsKKwkJZnJlZSAoY2tfc2Vz c2lvbl9jb29raWUpOworCX0KKyNlbmRpZgorCiAJLyoKIAkgKiBTb21ldGltZXMgdGhlIFhzZXNz aW9uIHNvbWVob3cgbWFuYWdlcyB0byBleGl0IGJlZm9yZQogCSAqIGEgc2VydmVyIGNyYXNoIGlz IG5vdGljZWQgLSBzbyB3ZSBzbGVlcCBhIGJpdCBhbmQgd2FpdApkaWZmIC1OdXIga2RlYmFzZS13 b3Jrc3BhY2UtNC4wLjAva2RtL2JhY2tlbmQveGRtY3AuYyBrZGViYXNlLXdvcmtzcGFjZS00LjAu MC1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC94ZG1jcC5jCi0tLSBrZGViYXNlLXdvcmtzcGFj ZS00LjAuMC9rZG0vYmFja2VuZC94ZG1jcC5jCTIwMDgtMDEtMDUgMDA6NTU6NDQuMDAwMDAwMDAw ICswMTAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjAuMC1jb25zb2xla2l0LWtkbS9rZG0vYmFj a2VuZC94ZG1jcC5jCTIwMDgtMDEtMDggMDE6MTQ6MDMuMDAwMDAwMDAwICswMTAwCkBAIC0xMDE2 LDYgKzEwMTYsOCBAQAogCQkJZC0+Y2xpZW50QWRkciA9IGNsaWVudEFkZHJlc3M7CiAJCQlkLT5j bGllbnRQb3J0ID0gY2xpZW50UG9ydDsKIAkJCWQtPmNvbm5lY3Rpb25UeXBlID0gY29ubmVjdGlv blR5cGU7CisJCQlkLT5yZW1vdGVIb3N0ID0gbmV0d29ya0FkZHJlc3NUb0hvc3RuYW1lIChwZHB5 LT5jb25uZWN0aW9uVHlwZSwKKwkJCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnBkcHkt PmNvbm5lY3Rpb25BZGRyZXNzKTsKIAkJCWlmIChwZHB5LT5maWxlQXV0aG9yaXphdGlvbikgewog CQkJCWQtPmF1dGhvcml6YXRpb25zID0gKFhhdXRoICoqKU1hbGxvYyggc2l6ZW9mKFhhdXRoICop ICk7CiAJCQkJaWYgKCFkLT5hdXRob3JpemF0aW9ucykgewo= 26151 2008-07-15 18:08:09 +0000 2008-07-16 16:24:21 +0000 KDM ConsoleKit support patch using libck-connector (against 4.0.98) kdebase-workspace-4.0.98-consolekit-kdm.patch text/plain 11746 kevin.kofler ZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMC45OC9jbWFrZS9tb2R1bGVzL0ZpbmRDa0Nv bm5lY3Rvci5jbWFrZSBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgtY29uc29sZWtpdC1rZG0vY21h a2UvbW9kdWxlcy9GaW5kQ2tDb25uZWN0b3IuY21ha2UKLS0tIGtkZWJhc2Utd29ya3NwYWNlLTQu MC45OC9jbWFrZS9tb2R1bGVzL0ZpbmRDa0Nvbm5lY3Rvci5jbWFrZQkxOTcwLTAxLTAxIDAxOjAw OjAwLjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNvbnNvbGVr aXQta2RtL2NtYWtlL21vZHVsZXMvRmluZENrQ29ubmVjdG9yLmNtYWtlCTIwMDgtMDctMTUgMDM6 MzE6MDQuMDAwMDAwMDAwICswMjAwCkBAIC0wLDAgKzEsNTggQEAKKyMgLSBUcnkgdG8gZmluZCB0 aGUgQ29uc29sZUtpdCBjb25uZWN0b3IgbGlicmFyeSAobGliY2stY29ubmVjdG9yKQorIyBPbmNl IGRvbmUgdGhpcyB3aWxsIGRlZmluZQorIworIyAgQ0tDT05ORUNUT1JfRk9VTkQgLSBzeXN0ZW0g aGFzIHRoZSBDSyBDb25uZWN0b3IKKyMgIENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIC0gdGhlIENL IENvbm5lY3RvciBpbmNsdWRlIGRpcmVjdG9yeQorIyAgQ0tDT05ORUNUT1JfTElCUkFSSUVTIC0g VGhlIGxpYnJhcmllcyBuZWVkZWQgdG8gdXNlIENLIENvbm5lY3RvcgorCisjIENvcHlyaWdodCAo YykgMjAwOCwgS2V2aW4gS29mbGVyLCA8a2V2aW4ua29mbGVyQGNoZWxsby5hdD4KKyMgbW9kZWxl ZCBhZnRlciBGaW5kTGliQXJ0LmNtYWtlOgorIyBDb3B5cmlnaHQgKGMpIDIwMDYsIEFsZXhhbmRl ciBOZXVuZG9yZiwgPG5ldW5kb3JmQGtkZS5vcmc+CisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaXMgYWxsb3dlZCBhY2NvcmRpbmcgdG8gdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4K KyMgRm9yIGRldGFpbHMgc2VlIHRoZSBhY2NvbXBhbnlpbmcgQ09QWUlORy1DTUFLRS1TQ1JJUFRT IGZpbGUuCisKKworaWYgKENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIEFORCBDS0NPTk5FQ1RPUl9M SUJSQVJJRVMpCisKKyAgIyBpbiBjYWNoZSBhbHJlYWR5CisgIFNFVChDS0NPTk5FQ1RPUl9GT1VO RCBUUlVFKQorCitlbHNlIChDS0NPTk5FQ1RPUl9JTkNMVURFX0RJUiBBTkQgQ0tDT05ORUNUT1Jf TElCUkFSSUVTKQorCisgIElGIChOT1QgV0lOMzIpCisgICAgSU5DTFVERShVc2VQa2dDb25maWcp CisgICAgIyB1c2UgcGtnLWNvbmZpZyB0byBnZXQgdGhlIGRpcmVjdG9yaWVzIGFuZCB0aGVuIHVz ZSB0aGVzZSB2YWx1ZXMKKyAgICAjIGluIHRoZSBGSU5EX1BBVEgoKSBhbmQgRklORF9MSUJSQVJZ KCkgY2FsbHMKKyAgICBQS0dDT05GSUcoY2stY29ubmVjdG9yIF9ja0Nvbm5lY3RvckluY0RpciBf Y2tDb25uZWN0b3JMaW5rRGlyIF9ja0Nvbm5lY3RvckxpbmtGbGFncyBfY2tDb25uZWN0b3JDZmxh Z3MpCisgIEVORElGIChOT1QgV0lOMzIpCisKKyAgRklORF9QQVRIKENLQ09OTkVDVE9SX0lOQ0xV REVfRElSIGNrLWNvbm5lY3Rvci5oCisgICAgICR7X2NrQ29ubmVjdG9ySW5jRGlyfS9Db25zb2xl S2l0L2NrLWNvbm5lY3RvcgorICAgICAke19ja0Nvbm5lY3RvckluY0Rpcn0KKyAgKQorCisgIEZJ TkRfTElCUkFSWShDS0NPTk5FQ1RPUl9MSUJSQVJJRVMgTkFNRVMgY2stY29ubmVjdG9yCisgICAg IFBBVEhTCisgICAgICR7X2NrQ29ubmVjdG9yTGlua0Rpcn0KKyAgKQorCisKKyAgaWYgKENLQ09O TkVDVE9SX0lOQ0xVREVfRElSIEFORCBDS0NPTk5FQ1RPUl9MSUJSQVJJRVMpCisgICAgIHNldChD S0NPTk5FQ1RPUl9GT1VORCBUUlVFKQorICBlbmRpZiAoQ0tDT05ORUNUT1JfSU5DTFVERV9ESVIg QU5EIENLQ09OTkVDVE9SX0xJQlJBUklFUykKKworCisgIGlmIChDS0NPTk5FQ1RPUl9GT1VORCkK KyAgICAgaWYgKE5PVCBDa0Nvbm5lY3Rvcl9GSU5EX1FVSUVUTFkpCisgICAgICAgIG1lc3NhZ2Uo U1RBVFVTICJGb3VuZCBjay1jb25uZWN0b3I6ICR7Q0tDT05ORUNUT1JfTElCUkFSSUVTfSIpCisg ICAgIGVuZGlmIChOT1QgQ2tDb25uZWN0b3JfRklORF9RVUlFVExZKQorICBlbHNlIChDS0NPTk5F Q1RPUl9GT1VORCkKKyAgICAgaWYgKENrQ29ubmVjdG9yX0ZJTkRfUkVRVUlSRUQpCisgICAgICAg IG1lc3NhZ2UoRkFUQUxfRVJST1IgIkNvdWxkIE5PVCBmaW5kIGNrLWNvbm5lY3RvciIpCisgICAg IGVuZGlmIChDa0Nvbm5lY3Rvcl9GSU5EX1JFUVVJUkVEKQorICBlbmRpZiAoQ0tDT05ORUNUT1Jf Rk9VTkQpCisKKyAgTUFSS19BU19BRFZBTkNFRChDS0NPTk5FQ1RPUl9JTkNMVURFX0RJUiBDS0NP Tk5FQ1RPUl9MSUJSQVJJRVMpCisKK2VuZGlmIChDS0NPTk5FQ1RPUl9JTkNMVURFX0RJUiBBTkQg Q0tDT05ORUNUT1JfTElCUkFSSUVTKQpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4 L2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2Uga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNv bnNvbGVraXQta2RtL2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2UKLS0tIGtkZWJhc2Utd29y a3NwYWNlLTQuMC45OC9jbWFrZS9tb2R1bGVzL0ZpbmREQnVzLmNtYWtlCTE5NzAtMDEtMDEgMDE6 MDA6MDAuMDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgtY29uc29s ZWtpdC1rZG0vY21ha2UvbW9kdWxlcy9GaW5kREJ1cy5jbWFrZQkyMDA4LTA3LTE0IDIzOjU2OjM2 LjAwMDAwMDAwMCArMDIwMApAQCAtMCwwICsxLDM5IEBACisKK2lmKERCVVNfSU5DTFVERV9ESVIg QU5EIERCVVNfTElCUkFSWSBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSKQorCSMgQWxyZWFkeSBp biBjYWNoZSwgYmUgc2lsZW50CisJc2V0KERCVVNfRklORF9RVUlFVExZIFRSVUUpCQorZW5kaWYo REJVU19JTkNMVURFX0RJUiBBTkQgREJVU19MSUJSQVJZIEFORCBEQlVTX0FSQ0hfSU5DTFVERV9E SVIpCisKK3NldChEQlVTX0xJQlJBUlkpCitzZXQoREJVU19JTkNMVURFX0RJUikKK3NldChEQlVT X0FSQ0hfSU5DTFVERV9ESVIpCisKK0ZJTkRfUEFUSChEQlVTX0lOQ0xVREVfRElSIGRidXMvZGJ1 cy5oCisJL3Vzci9pbmNsdWRlCisJL3Vzci9pbmNsdWRlL2RidXMtMS4wCisJL3Vzci9sb2NhbC9p bmNsdWRlCispCisKK0ZJTkRfUEFUSChEQlVTX0FSQ0hfSU5DTFVERV9ESVIgZGJ1cy9kYnVzLWFy Y2gtZGVwcy5oCisJL3Vzci9saWIke0xJQl9TVUZGSVh9L2luY2x1ZGUKKwkvdXNyL2xpYiR7TElC X1NVRkZJWH0vZGJ1cy0xLjAvaW5jbHVkZQorCS91c3IvbGliNjQvaW5jbHVkZQorCS91c3IvbGli NjQvZGJ1cy0xLjAvaW5jbHVkZQorCS91c3IvbGliL2luY2x1ZGUKKwkvdXNyL2xpYi9kYnVzLTEu MC9pbmNsdWRlCispCisKK0ZJTkRfTElCUkFSWShEQlVTX0xJQlJBUlkgTkFNRVMgZGJ1cy0xIGRi dXMKKwlQQVRIUworCS91c3IvbGliCisJL3Vzci9sb2NhbC9saWIKKykKKworaWYoREJVU19JTkNM VURFX0RJUiBBTkQgREJVU19MSUJSQVJZIEFORCBEQlVTX0FSQ0hfSU5DTFVERV9ESVIpCisgICBN RVNTQUdFKCBTVEFUVVMgImRidXMgZm91bmQ6IGluY2x1ZGVzIGluICR7REJVU19JTkNMVURFX0RJ Un0sIGxpYnJhcnkgaW4gJHtEQlVTX0xJQlJBUll9IikKKyAgIHNldChEQlVTX0ZPVU5EIFRSVUUp CitlbHNlKERCVVNfSU5DTFVERV9ESVIgQU5EIERCVVNfTElCUkFSWSBBTkQgREJVU19BUkNIX0lO Q0xVREVfRElSKQorICAgTUVTU0FHRSggU1RBVFVTICJkYnVzIG5vdCBmb3VuZCIpCitlbmRpZihE QlVTX0lOQ0xVREVfRElSIEFORCBEQlVTX0xJQlJBUlkgQU5EIERCVVNfQVJDSF9JTkNMVURFX0RJ UikKKworTUFSS19BU19BRFZBTkNFRChEQlVTX0lOQ0xVREVfRElSIERCVVNfTElCUkFSWSBEQlVT X0FSQ0hfSU5DTFVERV9ESVIpCmRpZmYgLU51ciBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgva2Rt L2JhY2tlbmQvY2xpZW50LmMga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNvbnNvbGVraXQta2Rt L2tkbS9iYWNrZW5kL2NsaWVudC5jCi0tLSBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgva2RtL2Jh Y2tlbmQvY2xpZW50LmMJMjAwOC0wNS0wNyAxMTowNToyNi4wMDAwMDAwMDAgKzAyMDAKKysrIGtk ZWJhc2Utd29ya3NwYWNlLTQuMC45OC1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9jbGllbnQu YwkyMDA4LTA3LTE0IDIzOjQ4OjM1LjAwMDAwMDAwMCArMDIwMApAQCAtMTE4MCw3ICsxMTgwLDEx IEBACiAqLwogCiBpbnQKKyNpZmRlZiBIQVZFX0NLQ09OTkVDVE9SCitzdGFydENsaWVudCggdm9s YXRpbGUgaW50ICpwaWQsIGNvbnN0IGNoYXIgKmNrX3Nlc3Npb25fY29va2llICkKKyNlbHNlCiBz dGFydENsaWVudCggdm9sYXRpbGUgaW50ICpwaWQgKQorI2VuZGlmCiB7CiAJY29uc3QgY2hhciAq aG9tZSwgKnNlc3NhcmdzLCAqZGVza3Nlc3M7CiAJY2hhciAqKmVudiwgKnhtYTsKQEAgLTEyNjks NiArMTI3MywxMSBAQAogCWlmIChrcmJ0a2ZpbGVbMF0gIT0gJ1wwJykKIAkJZW52ID0gc2V0RW52 KCBlbnYsICJLUkJUS0ZJTEUiLCBrcmJ0a2ZpbGUgKTsKICNlbmRpZgorI2lmZGVmIEhBVkVfQ0tD T05ORUNUT1IKKwlpZiAoY2tfc2Vzc2lvbl9jb29raWUgIT0gTlVMTCkgeworCQllbnYgPSBzZXRF bnYgKCBlbnYsICJYREdfU0VTU0lPTl9DT09LSUUiLCBja19zZXNzaW9uX2Nvb2tpZSApOworCX0K KyNlbmRpZgogCXVzZXJFbnZpcm9uID0gaW5oZXJpdEVudiggZW52LCBlbnZ2YXJzICk7CiAJZW52 ID0gc3lzdGVtRW52KCAwLCBjdXJ1c2VyICk7CiAJc3lzdGVtRW52aXJvbiA9IHNldEVudiggZW52 LCAiSE9NRSIsIHAtPnB3X2RpciApOwpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4 L2tkbS9iYWNrZW5kL0NNYWtlTGlzdHMudHh0IGtkZWJhc2Utd29ya3NwYWNlLTQuMC45OC1jb25z b2xla2l0LWtkbS9rZG0vYmFja2VuZC9DTWFrZUxpc3RzLnR4dAotLS0ga2RlYmFzZS13b3Jrc3Bh Y2UtNC4wLjk4L2tkbS9iYWNrZW5kL0NNYWtlTGlzdHMudHh0CTIwMDgtMDUtMjkgMTM6MTk6MDEu MDAwMDAwMDAwICswMjAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgtY29uc29sZWtpdC1r ZG0va2RtL2JhY2tlbmQvQ01ha2VMaXN0cy50eHQJMjAwOC0wNy0xNSAwMDozMjoyOS4wMDAwMDAw MDAgKzAyMDAKQEAgLTYwLDYgKzYwLDEwIEBACiAJJHtTT0NLRVRfTElCUkFSSUVTfQogCSR7UkVT T0xWX0xJQlJBUklFU30KICkKK2lmIChDS0NPTk5FQ1RPUl9GT1VORCkKKwlpbmNsdWRlX2RpcmVj dG9yaWVzKCR7Q0tDT05ORUNUT1JfSU5DTFVERV9ESVJ9ICR7REJVU19JTkNMVURFX0RJUn0gJHtE QlVTX0FSQ0hfSU5DTFVERV9ESVJ9KQorCXRhcmdldF9saW5rX2xpYnJhcmllcygga2RtICR7Q0tD T05ORUNUT1JfTElCUkFSSUVTfSAke0RCVVNfTElCUkFSWX0gKQorZW5kaWYgKENLQ09OTkVDVE9S X0ZPVU5EKQogaWYoVVRJTF9MSUJSQVJJRVMpCiAJdGFyZ2V0X2xpbmtfbGlicmFyaWVzKCBrZG0g JHtVVElMX0xJQlJBUklFU30gKQogZW5kaWYoVVRJTF9MSUJSQVJJRVMpCmRpZmYgLU51ciBrZGVi YXNlLXdvcmtzcGFjZS00LjAuOTgva2RtL2JhY2tlbmQvZG0uaCBrZGViYXNlLXdvcmtzcGFjZS00 LjAuOTgtY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQvZG0uaAotLS0ga2RlYmFzZS13b3Jrc3Bh Y2UtNC4wLjk4L2tkbS9iYWNrZW5kL2RtLmgJMjAwOC0wMS0wNSAwMDo1NTo0NC4wMDAwMDAwMDAg KzAxMDAKKysrIGtkZWJhc2Utd29ya3NwYWNlLTQuMC45OC1jb25zb2xla2l0LWtkbS9rZG0vYmFj a2VuZC9kbS5oCTIwMDgtMDctMTQgMjM6NDg6MzUuMDAwMDAwMDAwICswMjAwCkBAIC01MDQsNyAr NTA0LDExIEBACiAjZGVmaW5lIEdDT05WX0JJTkFSWSAgNQogdHlwZWRlZiBjaGFyICooKkdDb252 RnVuYykoIGludCB3aGF0LCBjb25zdCBjaGFyICpwcm9tcHQgKTsKIGludCB2ZXJpZnkoIEdDb252 RnVuYyBnY29udiwgaW50IHJvb3RvayApOworI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKK2ludCBz dGFydENsaWVudCggdm9sYXRpbGUgaW50ICpwaWQsIGNvbnN0IGNoYXIgKmNrX3Nlc3Npb25fY29v a2llICk7CisjZWxzZQogaW50IHN0YXJ0Q2xpZW50KCB2b2xhdGlsZSBpbnQgKnBpZCApOworI2Vu ZGlmCiB2b2lkIGNsaWVudEV4aXRlZCggdm9pZCApOwogdm9pZCBzZXNzaW9uRXhpdCggaW50IHN0 YXR1cyApIEFUVFJfTk9SRVRVUk47CiBpbnQgcmVhZERtcmMoIHZvaWQgKTsKZGlmZiAtTnVyIGtk ZWJhc2Utd29ya3NwYWNlLTQuMC45OC9rZG0vYmFja2VuZC9zZXNzaW9uLmMga2RlYmFzZS13b3Jr c3BhY2UtNC4wLjk4LWNvbnNvbGVraXQta2RtL2tkbS9iYWNrZW5kL3Nlc3Npb24uYwotLS0ga2Rl YmFzZS13b3Jrc3BhY2UtNC4wLjk4L2tkbS9iYWNrZW5kL3Nlc3Npb24uYwkyMDA4LTAxLTA1IDAw OjU1OjQ0LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNvbnNv bGVraXQta2RtL2tkbS9iYWNrZW5kL3Nlc3Npb24uYwkyMDA4LTA3LTE1IDA0OjI5OjEzLjAwMDAw MDAwMCArMDIwMApAQCAtNDUsNiArNDUsMTQgQEAKICNpbmNsdWRlIDxjdHlwZS5oPgogI2luY2x1 ZGUgPHNpZ25hbC5oPgogCisjaWZkZWYgSEFWRV9DS0NPTk5FQ1RPUgorI2luY2x1ZGUgPGNrLWNv bm5lY3Rvci5oPgorI2luY2x1ZGUgPGRidXMvZGJ1cy5oPgorLyogZm9yIGdldHB3bmFtICovCisj aW5jbHVkZSA8c3lzL3R5cGVzLmg+CisjaW5jbHVkZSA8cHdkLmg+CisjZW5kaWYKKwogc3RydWN0 IGRpc3BsYXkgKnRkOwogY29uc3QgY2hhciAqdGRfc2V0dXAgPSAiYXV0byI7CiAKQEAgLTU1Myw2 ICs1NjEsMTggQEAKIAl2b2xhdGlsZSB0aW1lX3QgdGRpZmYgPSAwOwogCXNpZ3NldF90IHNzOwog CisjaWZkZWYgSEFWRV9DS0NPTk5FQ1RPUgorCURCdXNFcnJvciBlcnJvcjsKKwlDa0Nvbm5lY3Rv ciAqY29ubmVjdG9yOworCWNoYXIgKmNrX3Nlc3Npb25fY29va2llOworCXN0cnVjdCBwYXNzd2Qg KnB3ZW50OworCWNoYXIgZGV2aWNlWzIwXSA9ICIiOworCWRidXNfYm9vbF90IGlzX2xvY2FsOwor I2lmZGVmIFhETUNQCisJY2hhciAqcmVtb3RlX2hvc3RfbmFtZSA9ICIiOworI2VuZGlmCisjZW5k aWYKKwogCXRkID0gZDsKIAlkZWJ1ZyggIm1hbmFnZVNlc3Npb24gJXNcbiIsIGQtPm5hbWUgKTsK IAlpZiAoKGV4ID0gU2V0am1wKCBhYm9ydFNlc3Npb24gKSkpIHsKQEAgLTYyOCw3ICs2NDgsNTcg QEAKIAlpZiAodGRfc2V0dXApCiAJCXNldHVwRGlzcGxheSggdGRfc2V0dXAgKTsKIAorI2lmZGVm IEhBVkVfQ0tDT05ORUNUT1IKKyNpZmRlZiBIQVZFX1ZUUworCWlmIChkLT5zZXJ2ZXJWVCA+IDAp IHsKKwkJLyogRklYTUU6IGhvdyBkb2VzIHhvcmcgY29uc3RydWN0IHRoaXMgKi8KKwkJc3ByaW50 ZihkZXZpY2UsICIvZGV2L3R0eSVkIiwgZC0+c2VydmVyVlQpOworCX0JCisjZW5kaWYKKworCXB3 ZW50ID0gZ2V0cHduYW0oY3VydXNlcik7CisJaWYgKHB3ZW50ID09IE5VTEwpIHsKKwkJZGVidWcg KCJOVUxMIHVzZXJcbiIpOworCQlja19zZXNzaW9uX2Nvb2tpZSA9IE5VTEw7CisJfSBlbHNlIHsK KwkJY29ubmVjdG9yID0gY2tfY29ubmVjdG9yX25ldyAoKTsKKwkJaWYgKGNvbm5lY3RvciAhPSBO VUxMKSB7CisJCQlpc19sb2NhbCA9ICgoZC0+ZGlzcGxheVR5cGUgJiBkX2xvY2F0aW9uKSA9PSBk TG9jYWwpOworI2lmZGVmIFhETUNQCisJCQlpZiAoIWlzX2xvY2FsICYmIGQtPnJlbW90ZUhvc3Qp CisJCQkJcmVtb3RlX2hvc3RfbmFtZSA9IGQtPnJlbW90ZUhvc3Q7CisjZW5kaWYKKworCQkJZGJ1 c19lcnJvcl9pbml0ICgmZXJyb3IpOworCQkJaWYgKCAhKGNrX2Nvbm5lY3Rvcl9vcGVuX3Nlc3Np b25fd2l0aF9wYXJhbWV0ZXJzIChjb25uZWN0b3IsCisJCQkJJmVycm9yLCAidW5peC11c2VyIiwg Jihwd2VudC0+cHdfdWlkKSwKKwkJCQkiZGlzcGxheS1kZXZpY2UiLCAmZGV2aWNlLAorCQkJCSJ4 MTEtZGlzcGxheSIsICYoZC0+bmFtZSksCisJCQkJImlzLWxvY2FsIiwgJmlzX2xvY2FsLAorI2lm ZGVmIFhETUNQCisJCQkJInJlbW90ZS1ob3N0LW5hbWUiLCAmcmVtb3RlX2hvc3RfbmFtZSwKKyNl bmRpZgorCQkJCU5VTEwpKSkgeworCQkJCWlmIChkYnVzX2Vycm9yX2lzX3NldCAoJmVycm9yKSkg eworCQkJCQlsb2dFcnJvciggIkNvbnNvbGVLaXQgb3BlbjogJXNcbiIsIGVycm9yLm1lc3NhZ2Up OworCQkJCQlkYnVzX2Vycm9yX2ZyZWUgKCZlcnJvcik7CisJCQkJfSBlbHNlIHsKKwkJCQkJbG9n RXJyb3IoImNhbm5vdCBvcGVuIENLIHNlc3Npb246IE9PTSwgRC1CdXMgc3lzdGVtIGJ1cyBub3Qg YXZhaWxhYmxlLFxuIgorCQkJCQkJIkNvbnNvbGVLaXQgbm90IGF2YWlsYWJsZSBvciBpbnN1ZmZp Y2llbnQgcHJpdmlsZWdlcy5cbiIpOworCQkJCX0KKwkJCQlja19jb25uZWN0b3JfdW5yZWYgKGNv bm5lY3Rvcik7CisJCQkJc2Vzc2lvbkV4aXQoIEVYX05PUk1BTCApOworCQkJfQorCQl9IGVsc2Ug eworCQkJZGVidWcgKCJPT00gY3JlYXRpbmcgQ2tDb25uZWN0b3JcbiIpOworCQkJc2Vzc2lvbkV4 aXQoIEVYX05PUk1BTCApOworCQl9CisJCWNrX3Nlc3Npb25fY29va2llID0gY2tfY29ubmVjdG9y X2dldF9jb29raWUgKGNvbm5lY3Rvcik7CisJfQorCWlmICghc3RhcnRDbGllbnQoICZjbGllbnRQ aWQsIGNrX3Nlc3Npb25fY29va2llICkpIHsKKyNlbHNlCiAJaWYgKCFzdGFydENsaWVudCggJmNs aWVudFBpZCApKSB7CisjZW5kaWYKIAkJbG9nRXJyb3IoICJDbGllbnQgc3RhcnQgZmFpbGVkXG4i ICk7CiAJCXNlc3Npb25FeGl0KCBFWF9OT1JNQUwgKTsgLyogWFhYIG1heWJlIEVYX1JFTUFOQUdF X0RQWT8gLS0gZW5hYmxlIGluIGRtLmMhICovCiAJfQpAQCAtNjUwLDYgKzcyMCwyMyBAQAogCQkJ CWNhdGNoVGVybSggU0lHVEVSTSApOwogCQl9CiAJfQorCisvKiBjbG9zZSBjb25zb2xla2l0IHNl c3Npb24gKi8KKyNpZmRlZiBIQVZFX0NLQ09OTkVDVE9SCisJaWYgKGNrX3Nlc3Npb25fY29va2ll ICE9IE5VTEwpIHsKKwkJZGJ1c19lcnJvcl9pbml0ICgmZXJyb3IpOworCQlpZiAoISBja19jb25u ZWN0b3JfY2xvc2Vfc2Vzc2lvbiAoY29ubmVjdG9yLCAmZXJyb3IpKSB7CisJCQlpZiAoZGJ1c19l cnJvcl9pc19zZXQgKCZlcnJvcikpIHsKKwkJCQlsb2dFcnJvciAoIkNvbnNvbGVLaXQgY2xvc2U6 ICVzXG4iLCBlcnJvci5tZXNzYWdlKTsKKwkJCQkgZGJ1c19lcnJvcl9mcmVlICgmZXJyb3IpOwor CQkJfSBlbHNlIHsKKwkJCQlsb2dFcnJvciAoIkNhbm5vdCBjbG9zZSBDSyBzZXNzaW9uOiBPT00s IEQtQnVzIHN5c3RlbSBidXMgbm90IGF2YWlsYWJsZSxcbiIKKwkJCQkiQ29uc29sZUtpdCBub3Qg YXZhaWxhYmxlIG9yIGluc3VmZmljaWVudCBwcml2aWxlZ2VzLlxuIik7CisJCQl9CisJCX0KKwkJ Y2tfY29ubmVjdG9yX3VucmVmIChjb25uZWN0b3IpOworCX0KKyNlbmRpZgogCS8qCiAJICogU29t ZXRpbWVzIHRoZSBYc2Vzc2lvbiBzb21laG93IG1hbmFnZXMgdG8gZXhpdCBiZWZvcmUKIAkgKiBh IHNlcnZlciBjcmFzaCBpcyBub3RpY2VkIC0gc28gd2Ugc2xlZXAgYSBiaXQgYW5kIHdhaXQKZGlm ZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMC45OC9rZG0vYmFja2VuZC94ZG1jcC5jIGtkZWJh c2Utd29ya3NwYWNlLTQuMC45OC1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC94ZG1jcC5jCi0t LSBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgva2RtL2JhY2tlbmQveGRtY3AuYwkyMDA4LTAxLTA1 IDAwOjU1OjQ0LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNv bnNvbGVraXQta2RtL2tkbS9iYWNrZW5kL3hkbWNwLmMJMjAwOC0wNy0xNCAyMzo0ODozNS4wMDAw MDAwMDAgKzAyMDAKQEAgLTEwMTYsNiArMTAxNiw4IEBACiAJCQlkLT5jbGllbnRBZGRyID0gY2xp ZW50QWRkcmVzczsKIAkJCWQtPmNsaWVudFBvcnQgPSBjbGllbnRQb3J0OwogCQkJZC0+Y29ubmVj dGlvblR5cGUgPSBjb25uZWN0aW9uVHlwZTsKKwkJCWQtPnJlbW90ZUhvc3QgPSBuZXR3b3JrQWRk cmVzc1RvSG9zdG5hbWUgKHBkcHktPmNvbm5lY3Rpb25UeXBlLAorCQkJCSZwZHB5LT5jb25uZWN0 aW9uQWRkcmVzcyk7CiAJCQlpZiAocGRweS0+ZmlsZUF1dGhvcml6YXRpb24pIHsKIAkJCQlkLT5h dXRob3JpemF0aW9ucyA9IChYYXV0aCAqKilNYWxsb2MoIHNpemVvZihYYXV0aCAqKSApOwogCQkJ CWlmICghZC0+YXV0aG9yaXphdGlvbnMpIHsKZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQu MC45OC9rZG0vQ01ha2VMaXN0cy50eHQga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNvbnNvbGVr aXQta2RtL2tkbS9DTWFrZUxpc3RzLnR4dAotLS0ga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4L2tk bS9DTWFrZUxpc3RzLnR4dAkyMDA4LTAyLTA3IDE0OjE5OjUxLjAwMDAwMDAwMCArMDEwMAorKysg a2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNvbnNvbGVraXQta2RtL2tkbS9DTWFrZUxpc3RzLnR4 dAkyMDA4LTA3LTE1IDAwOjI4OjE2LjAwMDAwMDAwMCArMDIwMApAQCAtNCw2ICs0LDE3IEBACiBp bnN0YWxsX3BhbV9zZXJ2aWNlKEtETSkKIAogaW5jbHVkZShDb25maWd1cmVDaGVja3MuY21ha2Up CisKK21hY3JvX29wdGlvbmFsX2ZpbmRfcGFja2FnZShDa0Nvbm5lY3RvcikKK2lmKENLQ09OTkVD VE9SX0ZPVU5EKQorICAjIHdoZW4gYnVpbGRpbmcgd2l0aCBsaWJjay1jb25uZWN0b3IsIHdlIGFs c28gbmVlZCB0aGUgbG93LWxldmVsIEQtQnVzIEFQSQorICBmaW5kX3BhY2thZ2UoREJ1cyBSRVFV SVJFRCkKK2VuZGlmKENLQ09OTkVDVE9SX0ZPVU5EKQorCittYWNyb19sb2dfZmVhdHVyZShDS0NP Tk5FQ1RPUl9GT1VORCAiY2stY29ubmVjdG9yIiAiVGhlIENvbnNvbGVLaXQgY29ubmVjdG9yIGxp YnJhcnkiICJodHRwOi8vZnJlZWRlc2t0b3Aub3JnL3dpa2kvU29mdHdhcmUvQ29uc29sZUtpdCIg RkFMU0UgIiIgIlByb3ZpZGVzIENvbnNvbGVLaXQgaW50ZWdyYXRpb24gaW4gS0RNIikKKworbWFj cm9fYm9vbF90b18wMShDS0NPTk5FQ1RPUl9GT1VORCBIQVZFX0NLQ09OTkVDVE9SKQorCiBjb25m aWd1cmVfZmlsZShjb25maWcta2RtLmguY21ha2UgJHtDTUFLRV9DVVJSRU5UX0JJTkFSWV9ESVJ9 L2NvbmZpZy1rZG0uaCkKIAogaW5zdGFsbCggRklMRVMgUkVBRE1FIERFU1RJTkFUSU9OICR7REFU QV9JTlNUQUxMX0RJUn0vZG9jL2tkbSApCmRpZmYgLU51ciBrZGViYXNlLXdvcmtzcGFjZS00LjAu OTgva2RtL2NvbmZpZy1rZG0uaC5jbWFrZSBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgtY29uc29s ZWtpdC1rZG0va2RtL2NvbmZpZy1rZG0uaC5jbWFrZQotLS0ga2RlYmFzZS13b3Jrc3BhY2UtNC4w Ljk4L2tkbS9jb25maWcta2RtLmguY21ha2UJMjAwOC0wMS0wNSAwMDo1NTo0NS4wMDAwMDAwMDAg KzAxMDAKKysrIGtkZWJhc2Utd29ya3NwYWNlLTQuMC45OC1jb25zb2xla2l0LWtkbS9rZG0vY29u ZmlnLWtkbS5oLmNtYWtlCTIwMDgtMDctMTQgMjM6NDg6MzUuMDAwMDAwMDAwICswMjAwCkBAIC0x MjMsNiArMTIzLDkgQEAKIC8qIERlZmluZSB0byAxIGlmIHlvdSBoYXZlIHRoZSA8dGVybWlvcy5o PiBoZWFkZXIgZmlsZS4gKi8KICNjbWFrZWRlZmluZSBIQVZFX1RFUk1JT1NfSCAxCiAKKy8qIERl ZmluZSB0byAxIGlmIHRoZSBjay1jb25uZWN0b3IgbGlicmFyeSBpcyBmb3VuZCAqLworI2NtYWtl ZGVmaW5lIEhBVkVfQ0tDT05ORUNUT1IgMQorCiAvKiAkUEFUSCBkZWZhdWx0cyBzZXQgYnkgS0RN ICovCiAjY21ha2VkZWZpbmUgS0RNX0RFRl9VU0VSX1BBVEggIiR7S0RNX0RFRl9VU0VSX1BBVEh9 IgogI2NtYWtlZGVmaW5lIEtETV9ERUZfU1lTVEVNX1BBVEggIiR7S0RNX0RFRl9TWVNURU1fUEFU SH0iCg== 26177 2008-07-16 16:24:15 +0000 2008-11-07 01:42:55 +0000 KDM ConsoleKit support patch using libck-connector (against 4.0.98, actually tested) kdebase-workspace-4.0.98-consolekit-kdm.patch text/plain 11781 kevin.kofler ZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMC45OC9jbWFrZS9tb2R1bGVzL0ZpbmRDa0Nv bm5lY3Rvci5jbWFrZSBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgtY29uc29sZWtpdC1rZG0vY21h a2UvbW9kdWxlcy9GaW5kQ2tDb25uZWN0b3IuY21ha2UKLS0tIGtkZWJhc2Utd29ya3NwYWNlLTQu MC45OC9jbWFrZS9tb2R1bGVzL0ZpbmRDa0Nvbm5lY3Rvci5jbWFrZQkxOTcwLTAxLTAxIDAxOjAw OjAwLjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNvbnNvbGVr aXQta2RtL2NtYWtlL21vZHVsZXMvRmluZENrQ29ubmVjdG9yLmNtYWtlCTIwMDgtMDctMTUgMDM6 MzE6MDQuMDAwMDAwMDAwICswMjAwCkBAIC0wLDAgKzEsNTggQEAKKyMgLSBUcnkgdG8gZmluZCB0 aGUgQ29uc29sZUtpdCBjb25uZWN0b3IgbGlicmFyeSAobGliY2stY29ubmVjdG9yKQorIyBPbmNl IGRvbmUgdGhpcyB3aWxsIGRlZmluZQorIworIyAgQ0tDT05ORUNUT1JfRk9VTkQgLSBzeXN0ZW0g aGFzIHRoZSBDSyBDb25uZWN0b3IKKyMgIENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIC0gdGhlIENL IENvbm5lY3RvciBpbmNsdWRlIGRpcmVjdG9yeQorIyAgQ0tDT05ORUNUT1JfTElCUkFSSUVTIC0g VGhlIGxpYnJhcmllcyBuZWVkZWQgdG8gdXNlIENLIENvbm5lY3RvcgorCisjIENvcHlyaWdodCAo YykgMjAwOCwgS2V2aW4gS29mbGVyLCA8a2V2aW4ua29mbGVyQGNoZWxsby5hdD4KKyMgbW9kZWxl ZCBhZnRlciBGaW5kTGliQXJ0LmNtYWtlOgorIyBDb3B5cmlnaHQgKGMpIDIwMDYsIEFsZXhhbmRl ciBOZXVuZG9yZiwgPG5ldW5kb3JmQGtkZS5vcmc+CisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaXMgYWxsb3dlZCBhY2NvcmRpbmcgdG8gdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4K KyMgRm9yIGRldGFpbHMgc2VlIHRoZSBhY2NvbXBhbnlpbmcgQ09QWUlORy1DTUFLRS1TQ1JJUFRT IGZpbGUuCisKKworaWYgKENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIEFORCBDS0NPTk5FQ1RPUl9M SUJSQVJJRVMpCisKKyAgIyBpbiBjYWNoZSBhbHJlYWR5CisgIFNFVChDS0NPTk5FQ1RPUl9GT1VO RCBUUlVFKQorCitlbHNlIChDS0NPTk5FQ1RPUl9JTkNMVURFX0RJUiBBTkQgQ0tDT05ORUNUT1Jf TElCUkFSSUVTKQorCisgIElGIChOT1QgV0lOMzIpCisgICAgSU5DTFVERShVc2VQa2dDb25maWcp CisgICAgIyB1c2UgcGtnLWNvbmZpZyB0byBnZXQgdGhlIGRpcmVjdG9yaWVzIGFuZCB0aGVuIHVz ZSB0aGVzZSB2YWx1ZXMKKyAgICAjIGluIHRoZSBGSU5EX1BBVEgoKSBhbmQgRklORF9MSUJSQVJZ KCkgY2FsbHMKKyAgICBQS0dDT05GSUcoY2stY29ubmVjdG9yIF9ja0Nvbm5lY3RvckluY0RpciBf Y2tDb25uZWN0b3JMaW5rRGlyIF9ja0Nvbm5lY3RvckxpbmtGbGFncyBfY2tDb25uZWN0b3JDZmxh Z3MpCisgIEVORElGIChOT1QgV0lOMzIpCisKKyAgRklORF9QQVRIKENLQ09OTkVDVE9SX0lOQ0xV REVfRElSIGNrLWNvbm5lY3Rvci5oCisgICAgICR7X2NrQ29ubmVjdG9ySW5jRGlyfS9Db25zb2xl S2l0L2NrLWNvbm5lY3RvcgorICAgICAke19ja0Nvbm5lY3RvckluY0Rpcn0KKyAgKQorCisgIEZJ TkRfTElCUkFSWShDS0NPTk5FQ1RPUl9MSUJSQVJJRVMgTkFNRVMgY2stY29ubmVjdG9yCisgICAg IFBBVEhTCisgICAgICR7X2NrQ29ubmVjdG9yTGlua0Rpcn0KKyAgKQorCisKKyAgaWYgKENLQ09O TkVDVE9SX0lOQ0xVREVfRElSIEFORCBDS0NPTk5FQ1RPUl9MSUJSQVJJRVMpCisgICAgIHNldChD S0NPTk5FQ1RPUl9GT1VORCBUUlVFKQorICBlbmRpZiAoQ0tDT05ORUNUT1JfSU5DTFVERV9ESVIg QU5EIENLQ09OTkVDVE9SX0xJQlJBUklFUykKKworCisgIGlmIChDS0NPTk5FQ1RPUl9GT1VORCkK KyAgICAgaWYgKE5PVCBDa0Nvbm5lY3Rvcl9GSU5EX1FVSUVUTFkpCisgICAgICAgIG1lc3NhZ2Uo U1RBVFVTICJGb3VuZCBjay1jb25uZWN0b3I6ICR7Q0tDT05ORUNUT1JfTElCUkFSSUVTfSIpCisg ICAgIGVuZGlmIChOT1QgQ2tDb25uZWN0b3JfRklORF9RVUlFVExZKQorICBlbHNlIChDS0NPTk5F Q1RPUl9GT1VORCkKKyAgICAgaWYgKENrQ29ubmVjdG9yX0ZJTkRfUkVRVUlSRUQpCisgICAgICAg IG1lc3NhZ2UoRkFUQUxfRVJST1IgIkNvdWxkIE5PVCBmaW5kIGNrLWNvbm5lY3RvciIpCisgICAg IGVuZGlmIChDa0Nvbm5lY3Rvcl9GSU5EX1JFUVVJUkVEKQorICBlbmRpZiAoQ0tDT05ORUNUT1Jf Rk9VTkQpCisKKyAgTUFSS19BU19BRFZBTkNFRChDS0NPTk5FQ1RPUl9JTkNMVURFX0RJUiBDS0NP Tk5FQ1RPUl9MSUJSQVJJRVMpCisKK2VuZGlmIChDS0NPTk5FQ1RPUl9JTkNMVURFX0RJUiBBTkQg Q0tDT05ORUNUT1JfTElCUkFSSUVTKQpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4 L2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2Uga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNv bnNvbGVraXQta2RtL2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2UKLS0tIGtkZWJhc2Utd29y a3NwYWNlLTQuMC45OC9jbWFrZS9tb2R1bGVzL0ZpbmREQnVzLmNtYWtlCTE5NzAtMDEtMDEgMDE6 MDA6MDAuMDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgtY29uc29s ZWtpdC1rZG0vY21ha2UvbW9kdWxlcy9GaW5kREJ1cy5jbWFrZQkyMDA4LTA3LTE0IDIzOjU2OjM2 LjAwMDAwMDAwMCArMDIwMApAQCAtMCwwICsxLDM5IEBACisKK2lmKERCVVNfSU5DTFVERV9ESVIg QU5EIERCVVNfTElCUkFSWSBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSKQorCSMgQWxyZWFkeSBp biBjYWNoZSwgYmUgc2lsZW50CisJc2V0KERCVVNfRklORF9RVUlFVExZIFRSVUUpCQorZW5kaWYo REJVU19JTkNMVURFX0RJUiBBTkQgREJVU19MSUJSQVJZIEFORCBEQlVTX0FSQ0hfSU5DTFVERV9E SVIpCisKK3NldChEQlVTX0xJQlJBUlkpCitzZXQoREJVU19JTkNMVURFX0RJUikKK3NldChEQlVT X0FSQ0hfSU5DTFVERV9ESVIpCisKK0ZJTkRfUEFUSChEQlVTX0lOQ0xVREVfRElSIGRidXMvZGJ1 cy5oCisJL3Vzci9pbmNsdWRlCisJL3Vzci9pbmNsdWRlL2RidXMtMS4wCisJL3Vzci9sb2NhbC9p bmNsdWRlCispCisKK0ZJTkRfUEFUSChEQlVTX0FSQ0hfSU5DTFVERV9ESVIgZGJ1cy9kYnVzLWFy Y2gtZGVwcy5oCisJL3Vzci9saWIke0xJQl9TVUZGSVh9L2luY2x1ZGUKKwkvdXNyL2xpYiR7TElC X1NVRkZJWH0vZGJ1cy0xLjAvaW5jbHVkZQorCS91c3IvbGliNjQvaW5jbHVkZQorCS91c3IvbGli NjQvZGJ1cy0xLjAvaW5jbHVkZQorCS91c3IvbGliL2luY2x1ZGUKKwkvdXNyL2xpYi9kYnVzLTEu MC9pbmNsdWRlCispCisKK0ZJTkRfTElCUkFSWShEQlVTX0xJQlJBUlkgTkFNRVMgZGJ1cy0xIGRi dXMKKwlQQVRIUworCS91c3IvbGliCisJL3Vzci9sb2NhbC9saWIKKykKKworaWYoREJVU19JTkNM VURFX0RJUiBBTkQgREJVU19MSUJSQVJZIEFORCBEQlVTX0FSQ0hfSU5DTFVERV9ESVIpCisgICBN RVNTQUdFKCBTVEFUVVMgImRidXMgZm91bmQ6IGluY2x1ZGVzIGluICR7REJVU19JTkNMVURFX0RJ Un0sIGxpYnJhcnkgaW4gJHtEQlVTX0xJQlJBUll9IikKKyAgIHNldChEQlVTX0ZPVU5EIFRSVUUp CitlbHNlKERCVVNfSU5DTFVERV9ESVIgQU5EIERCVVNfTElCUkFSWSBBTkQgREJVU19BUkNIX0lO Q0xVREVfRElSKQorICAgTUVTU0FHRSggU1RBVFVTICJkYnVzIG5vdCBmb3VuZCIpCitlbmRpZihE QlVTX0lOQ0xVREVfRElSIEFORCBEQlVTX0xJQlJBUlkgQU5EIERCVVNfQVJDSF9JTkNMVURFX0RJ UikKKworTUFSS19BU19BRFZBTkNFRChEQlVTX0lOQ0xVREVfRElSIERCVVNfTElCUkFSWSBEQlVT X0FSQ0hfSU5DTFVERV9ESVIpCmRpZmYgLU51ciBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgva2Rt L2JhY2tlbmQvY2xpZW50LmMga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNvbnNvbGVraXQta2Rt L2tkbS9iYWNrZW5kL2NsaWVudC5jCi0tLSBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgva2RtL2Jh Y2tlbmQvY2xpZW50LmMJMjAwOC0wNS0wNyAxMTowNToyNi4wMDAwMDAwMDAgKzAyMDAKKysrIGtk ZWJhc2Utd29ya3NwYWNlLTQuMC45OC1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9jbGllbnQu YwkyMDA4LTA3LTE0IDIzOjQ4OjM1LjAwMDAwMDAwMCArMDIwMApAQCAtMTE4MCw3ICsxMTgwLDEx IEBACiAqLwogCiBpbnQKKyNpZmRlZiBIQVZFX0NLQ09OTkVDVE9SCitzdGFydENsaWVudCggdm9s YXRpbGUgaW50ICpwaWQsIGNvbnN0IGNoYXIgKmNrX3Nlc3Npb25fY29va2llICkKKyNlbHNlCiBz dGFydENsaWVudCggdm9sYXRpbGUgaW50ICpwaWQgKQorI2VuZGlmCiB7CiAJY29uc3QgY2hhciAq aG9tZSwgKnNlc3NhcmdzLCAqZGVza3Nlc3M7CiAJY2hhciAqKmVudiwgKnhtYTsKQEAgLTEyNjks NiArMTI3MywxMSBAQAogCWlmIChrcmJ0a2ZpbGVbMF0gIT0gJ1wwJykKIAkJZW52ID0gc2V0RW52 KCBlbnYsICJLUkJUS0ZJTEUiLCBrcmJ0a2ZpbGUgKTsKICNlbmRpZgorI2lmZGVmIEhBVkVfQ0tD T05ORUNUT1IKKwlpZiAoY2tfc2Vzc2lvbl9jb29raWUgIT0gTlVMTCkgeworCQllbnYgPSBzZXRF bnYgKCBlbnYsICJYREdfU0VTU0lPTl9DT09LSUUiLCBja19zZXNzaW9uX2Nvb2tpZSApOworCX0K KyNlbmRpZgogCXVzZXJFbnZpcm9uID0gaW5oZXJpdEVudiggZW52LCBlbnZ2YXJzICk7CiAJZW52 ID0gc3lzdGVtRW52KCAwLCBjdXJ1c2VyICk7CiAJc3lzdGVtRW52aXJvbiA9IHNldEVudiggZW52 LCAiSE9NRSIsIHAtPnB3X2RpciApOwpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4 L2tkbS9iYWNrZW5kL0NNYWtlTGlzdHMudHh0IGtkZWJhc2Utd29ya3NwYWNlLTQuMC45OC1jb25z b2xla2l0LWtkbS9rZG0vYmFja2VuZC9DTWFrZUxpc3RzLnR4dAotLS0ga2RlYmFzZS13b3Jrc3Bh Y2UtNC4wLjk4L2tkbS9iYWNrZW5kL0NNYWtlTGlzdHMudHh0CTIwMDgtMDUtMjkgMTM6MTk6MDEu MDAwMDAwMDAwICswMjAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgtY29uc29sZWtpdC1r ZG0va2RtL2JhY2tlbmQvQ01ha2VMaXN0cy50eHQJMjAwOC0wNy0xNSAwMDozMjoyOS4wMDAwMDAw MDAgKzAyMDAKQEAgLTYwLDYgKzYwLDEwIEBACiAJJHtTT0NLRVRfTElCUkFSSUVTfQogCSR7UkVT T0xWX0xJQlJBUklFU30KICkKK2lmIChDS0NPTk5FQ1RPUl9GT1VORCkKKwlpbmNsdWRlX2RpcmVj dG9yaWVzKCR7Q0tDT05ORUNUT1JfSU5DTFVERV9ESVJ9ICR7REJVU19JTkNMVURFX0RJUn0gJHtE QlVTX0FSQ0hfSU5DTFVERV9ESVJ9KQorCXRhcmdldF9saW5rX2xpYnJhcmllcygga2RtICR7Q0tD T05ORUNUT1JfTElCUkFSSUVTfSAke0RCVVNfTElCUkFSWX0gKQorZW5kaWYgKENLQ09OTkVDVE9S X0ZPVU5EKQogaWYoVVRJTF9MSUJSQVJJRVMpCiAJdGFyZ2V0X2xpbmtfbGlicmFyaWVzKCBrZG0g JHtVVElMX0xJQlJBUklFU30gKQogZW5kaWYoVVRJTF9MSUJSQVJJRVMpCmRpZmYgLU51ciBrZGVi YXNlLXdvcmtzcGFjZS00LjAuOTgva2RtL2JhY2tlbmQvZG0uaCBrZGViYXNlLXdvcmtzcGFjZS00 LjAuOTgtY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQvZG0uaAotLS0ga2RlYmFzZS13b3Jrc3Bh Y2UtNC4wLjk4L2tkbS9iYWNrZW5kL2RtLmgJMjAwOC0wMS0wNSAwMDo1NTo0NC4wMDAwMDAwMDAg KzAxMDAKKysrIGtkZWJhc2Utd29ya3NwYWNlLTQuMC45OC1jb25zb2xla2l0LWtkbS9rZG0vYmFj a2VuZC9kbS5oCTIwMDgtMDctMTQgMjM6NDg6MzUuMDAwMDAwMDAwICswMjAwCkBAIC01MDQsNyAr NTA0LDExIEBACiAjZGVmaW5lIEdDT05WX0JJTkFSWSAgNQogdHlwZWRlZiBjaGFyICooKkdDb252 RnVuYykoIGludCB3aGF0LCBjb25zdCBjaGFyICpwcm9tcHQgKTsKIGludCB2ZXJpZnkoIEdDb252 RnVuYyBnY29udiwgaW50IHJvb3RvayApOworI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKK2ludCBz dGFydENsaWVudCggdm9sYXRpbGUgaW50ICpwaWQsIGNvbnN0IGNoYXIgKmNrX3Nlc3Npb25fY29v a2llICk7CisjZWxzZQogaW50IHN0YXJ0Q2xpZW50KCB2b2xhdGlsZSBpbnQgKnBpZCApOworI2Vu ZGlmCiB2b2lkIGNsaWVudEV4aXRlZCggdm9pZCApOwogdm9pZCBzZXNzaW9uRXhpdCggaW50IHN0 YXR1cyApIEFUVFJfTk9SRVRVUk47CiBpbnQgcmVhZERtcmMoIHZvaWQgKTsKZGlmZiAtTnVyIGtk ZWJhc2Utd29ya3NwYWNlLTQuMC45OC9rZG0vYmFja2VuZC9zZXNzaW9uLmMga2RlYmFzZS13b3Jr c3BhY2UtNC4wLjk4LWNvbnNvbGVraXQta2RtL2tkbS9iYWNrZW5kL3Nlc3Npb24uYwotLS0ga2Rl YmFzZS13b3Jrc3BhY2UtNC4wLjk4L2tkbS9iYWNrZW5kL3Nlc3Npb24uYwkyMDA4LTAxLTA1IDAw OjU1OjQ0LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNvbnNv bGVraXQta2RtL2tkbS9iYWNrZW5kL3Nlc3Npb24uYwkyMDA4LTA3LTE2IDE1OjI2OjQwLjAwMDAw MDAwMCArMDIwMApAQCAtNDUsNiArNDUsMTQgQEAKICNpbmNsdWRlIDxjdHlwZS5oPgogI2luY2x1 ZGUgPHNpZ25hbC5oPgogCisjaWZkZWYgSEFWRV9DS0NPTk5FQ1RPUgorI2luY2x1ZGUgPGNrLWNv bm5lY3Rvci5oPgorI2luY2x1ZGUgPGRidXMvZGJ1cy5oPgorLyogZm9yIGdldHB3bmFtICovCisj aW5jbHVkZSA8c3lzL3R5cGVzLmg+CisjaW5jbHVkZSA8cHdkLmg+CisjZW5kaWYKKwogc3RydWN0 IGRpc3BsYXkgKnRkOwogY29uc3QgY2hhciAqdGRfc2V0dXAgPSAiYXV0byI7CiAKQEAgLTU1Myw2 ICs1NjEsMTkgQEAKIAl2b2xhdGlsZSB0aW1lX3QgdGRpZmYgPSAwOwogCXNpZ3NldF90IHNzOwog CisjaWZkZWYgSEFWRV9DS0NPTk5FQ1RPUgorCURCdXNFcnJvciBlcnJvcjsKKwlDa0Nvbm5lY3Rv ciAqY29ubmVjdG9yOworCWNoYXIgKmNrX3Nlc3Npb25fY29va2llOworCXN0cnVjdCBwYXNzd2Qg KnB3ZW50OworCWNoYXIgZGV2aWNlYnVmWzIwXSA9ICIiOworCWNoYXIgKmRldmljZSA9IGRldmlj ZWJ1ZjsKKwlkYnVzX2Jvb2xfdCBpc19sb2NhbDsKKyNpZmRlZiBYRE1DUAorCWNoYXIgKnJlbW90 ZV9ob3N0X25hbWUgPSAiIjsKKyNlbmRpZgorI2VuZGlmCisKIAl0ZCA9IGQ7CiAJZGVidWcoICJt YW5hZ2VTZXNzaW9uICVzXG4iLCBkLT5uYW1lICk7CiAJaWYgKChleCA9IFNldGptcCggYWJvcnRT ZXNzaW9uICkpKSB7CkBAIC02MjgsNyArNjQ5LDU3IEBACiAJaWYgKHRkX3NldHVwKQogCQlzZXR1 cERpc3BsYXkoIHRkX3NldHVwICk7CiAKKyNpZmRlZiBIQVZFX0NLQ09OTkVDVE9SCisjaWZkZWYg SEFWRV9WVFMKKwlpZiAoZC0+c2VydmVyVlQgPiAwKSB7CisJCS8qIEZJWE1FOiBob3cgZG9lcyB4 b3JnIGNvbnN0cnVjdCB0aGlzICovCisJCXNwcmludGYoZGV2aWNlLCAiL2Rldi90dHklZCIsIGQt PnNlcnZlclZUKTsKKwl9CQorI2VuZGlmCisKKwlwd2VudCA9IGdldHB3bmFtKGN1cnVzZXIpOwor CWlmIChwd2VudCA9PSBOVUxMKSB7CisJCWRlYnVnICgiTlVMTCB1c2VyXG4iKTsKKwkJY2tfc2Vz c2lvbl9jb29raWUgPSBOVUxMOworCX0gZWxzZSB7CisJCWNvbm5lY3RvciA9IGNrX2Nvbm5lY3Rv cl9uZXcgKCk7CisJCWlmIChjb25uZWN0b3IgIT0gTlVMTCkgeworCQkJaXNfbG9jYWwgPSAoKGQt PmRpc3BsYXlUeXBlICYgZF9sb2NhdGlvbikgPT0gZExvY2FsKTsKKyNpZmRlZiBYRE1DUAorCQkJ aWYgKCFpc19sb2NhbCAmJiBkLT5yZW1vdGVIb3N0KQorCQkJCXJlbW90ZV9ob3N0X25hbWUgPSBk LT5yZW1vdGVIb3N0OworI2VuZGlmCisKKwkJCWRidXNfZXJyb3JfaW5pdCAoJmVycm9yKTsKKwkJ CWlmICggIShja19jb25uZWN0b3Jfb3Blbl9zZXNzaW9uX3dpdGhfcGFyYW1ldGVycyAoY29ubmVj dG9yLAorCQkJCSZlcnJvciwgInVuaXgtdXNlciIsICYocHdlbnQtPnB3X3VpZCksCisJCQkJIngx MS1kaXNwbGF5LWRldmljZSIsICZkZXZpY2UsCisJCQkJIngxMS1kaXNwbGF5IiwgJihkLT5uYW1l KSwKKwkJCQkiaXMtbG9jYWwiLCAmaXNfbG9jYWwsCisjaWZkZWYgWERNQ1AKKwkJCQkicmVtb3Rl LWhvc3QtbmFtZSIsICZyZW1vdGVfaG9zdF9uYW1lLAorI2VuZGlmCisJCQkJTlVMTCkpKSB7CisJ CQkJaWYgKGRidXNfZXJyb3JfaXNfc2V0ICgmZXJyb3IpKSB7CisJCQkJCWxvZ0Vycm9yKCAiQ29u c29sZUtpdCBvcGVuOiAlc1xuIiwgZXJyb3IubWVzc2FnZSk7CisJCQkJCWRidXNfZXJyb3JfZnJl ZSAoJmVycm9yKTsKKwkJCQl9IGVsc2UgeworCQkJCQlsb2dFcnJvcigiY2Fubm90IG9wZW4gQ0sg c2Vzc2lvbjogT09NLCBELUJ1cyBzeXN0ZW0gYnVzIG5vdCBhdmFpbGFibGUsXG4iCisJCQkJCQki Q29uc29sZUtpdCBub3QgYXZhaWxhYmxlIG9yIGluc3VmZmljaWVudCBwcml2aWxlZ2VzLlxuIik7 CisJCQkJfQorCQkJCWNrX2Nvbm5lY3Rvcl91bnJlZiAoY29ubmVjdG9yKTsKKwkJCQlzZXNzaW9u RXhpdCggRVhfTk9STUFMICk7CisJCQl9CisJCX0gZWxzZSB7CisJCQlkZWJ1ZyAoIk9PTSBjcmVh dGluZyBDa0Nvbm5lY3RvclxuIik7CisJCQlzZXNzaW9uRXhpdCggRVhfTk9STUFMICk7CisJCX0K KwkJY2tfc2Vzc2lvbl9jb29raWUgPSBja19jb25uZWN0b3JfZ2V0X2Nvb2tpZSAoY29ubmVjdG9y KTsKKwl9CisJaWYgKCFzdGFydENsaWVudCggJmNsaWVudFBpZCwgY2tfc2Vzc2lvbl9jb29raWUg KSkgeworI2Vsc2UKIAlpZiAoIXN0YXJ0Q2xpZW50KCAmY2xpZW50UGlkICkpIHsKKyNlbmRpZgog CQlsb2dFcnJvciggIkNsaWVudCBzdGFydCBmYWlsZWRcbiIgKTsKIAkJc2Vzc2lvbkV4aXQoIEVY X05PUk1BTCApOyAvKiBYWFggbWF5YmUgRVhfUkVNQU5BR0VfRFBZPyAtLSBlbmFibGUgaW4gZG0u YyEgKi8KIAl9CkBAIC02NTAsNiArNzIxLDIzIEBACiAJCQkJY2F0Y2hUZXJtKCBTSUdURVJNICk7 CiAJCX0KIAl9CisKKy8qIGNsb3NlIGNvbnNvbGVraXQgc2Vzc2lvbiAqLworI2lmZGVmIEhBVkVf Q0tDT05ORUNUT1IKKwlpZiAoY2tfc2Vzc2lvbl9jb29raWUgIT0gTlVMTCkgeworCQlkYnVzX2Vy cm9yX2luaXQgKCZlcnJvcik7CisJCWlmICghIGNrX2Nvbm5lY3Rvcl9jbG9zZV9zZXNzaW9uIChj b25uZWN0b3IsICZlcnJvcikpIHsKKwkJCWlmIChkYnVzX2Vycm9yX2lzX3NldCAoJmVycm9yKSkg eworCQkJCWxvZ0Vycm9yICgiQ29uc29sZUtpdCBjbG9zZTogJXNcbiIsIGVycm9yLm1lc3NhZ2Up OworCQkJCSBkYnVzX2Vycm9yX2ZyZWUgKCZlcnJvcik7CisJCQl9IGVsc2UgeworCQkJCWxvZ0Vy cm9yICgiQ2Fubm90IGNsb3NlIENLIHNlc3Npb246IE9PTSwgRC1CdXMgc3lzdGVtIGJ1cyBub3Qg YXZhaWxhYmxlLFxuIgorCQkJCSJDb25zb2xlS2l0IG5vdCBhdmFpbGFibGUgb3IgaW5zdWZmaWNp ZW50IHByaXZpbGVnZXMuXG4iKTsKKwkJCX0KKwkJfQorCQlja19jb25uZWN0b3JfdW5yZWYgKGNv bm5lY3Rvcik7CisJfQorI2VuZGlmCiAJLyoKIAkgKiBTb21ldGltZXMgdGhlIFhzZXNzaW9uIHNv bWVob3cgbWFuYWdlcyB0byBleGl0IGJlZm9yZQogCSAqIGEgc2VydmVyIGNyYXNoIGlzIG5vdGlj ZWQgLSBzbyB3ZSBzbGVlcCBhIGJpdCBhbmQgd2FpdApkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3Bh Y2UtNC4wLjk4L2tkbS9iYWNrZW5kL3hkbWNwLmMga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4LWNv bnNvbGVraXQta2RtL2tkbS9iYWNrZW5kL3hkbWNwLmMKLS0tIGtkZWJhc2Utd29ya3NwYWNlLTQu MC45OC9rZG0vYmFja2VuZC94ZG1jcC5jCTIwMDgtMDEtMDUgMDA6NTU6NDQuMDAwMDAwMDAwICsw MTAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgtY29uc29sZWtpdC1rZG0va2RtL2JhY2tl bmQveGRtY3AuYwkyMDA4LTA3LTE0IDIzOjQ4OjM1LjAwMDAwMDAwMCArMDIwMApAQCAtMTAxNiw2 ICsxMDE2LDggQEAKIAkJCWQtPmNsaWVudEFkZHIgPSBjbGllbnRBZGRyZXNzOwogCQkJZC0+Y2xp ZW50UG9ydCA9IGNsaWVudFBvcnQ7CiAJCQlkLT5jb25uZWN0aW9uVHlwZSA9IGNvbm5lY3Rpb25U eXBlOworCQkJZC0+cmVtb3RlSG9zdCA9IG5ldHdvcmtBZGRyZXNzVG9Ib3N0bmFtZSAocGRweS0+ Y29ubmVjdGlvblR5cGUsCisJCQkJJnBkcHktPmNvbm5lY3Rpb25BZGRyZXNzKTsKIAkJCWlmIChw ZHB5LT5maWxlQXV0aG9yaXphdGlvbikgewogCQkJCWQtPmF1dGhvcml6YXRpb25zID0gKFhhdXRo ICoqKU1hbGxvYyggc2l6ZW9mKFhhdXRoICopICk7CiAJCQkJaWYgKCFkLT5hdXRob3JpemF0aW9u cykgewpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4wLjk4L2tkbS9DTWFrZUxpc3RzLnR4 dCBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgtY29uc29sZWtpdC1rZG0va2RtL0NNYWtlTGlzdHMu dHh0Ci0tLSBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgva2RtL0NNYWtlTGlzdHMudHh0CTIwMDgt MDItMDcgMTQ6MTk6NTEuMDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjAu OTgtY29uc29sZWtpdC1rZG0va2RtL0NNYWtlTGlzdHMudHh0CTIwMDgtMDctMTUgMDA6Mjg6MTYu MDAwMDAwMDAwICswMjAwCkBAIC00LDYgKzQsMTcgQEAKIGluc3RhbGxfcGFtX3NlcnZpY2UoS0RN KQogCiBpbmNsdWRlKENvbmZpZ3VyZUNoZWNrcy5jbWFrZSkKKworbWFjcm9fb3B0aW9uYWxfZmlu ZF9wYWNrYWdlKENrQ29ubmVjdG9yKQoraWYoQ0tDT05ORUNUT1JfRk9VTkQpCisgICMgd2hlbiBi dWlsZGluZyB3aXRoIGxpYmNrLWNvbm5lY3Rvciwgd2UgYWxzbyBuZWVkIHRoZSBsb3ctbGV2ZWwg RC1CdXMgQVBJCisgIGZpbmRfcGFja2FnZShEQnVzIFJFUVVJUkVEKQorZW5kaWYoQ0tDT05ORUNU T1JfRk9VTkQpCisKK21hY3JvX2xvZ19mZWF0dXJlKENLQ09OTkVDVE9SX0ZPVU5EICJjay1jb25u ZWN0b3IiICJUaGUgQ29uc29sZUtpdCBjb25uZWN0b3IgbGlicmFyeSIgImh0dHA6Ly9mcmVlZGVz a3RvcC5vcmcvd2lraS9Tb2Z0d2FyZS9Db25zb2xlS2l0IiBGQUxTRSAiIiAiUHJvdmlkZXMgQ29u c29sZUtpdCBpbnRlZ3JhdGlvbiBpbiBLRE0iKQorCittYWNyb19ib29sX3RvXzAxKENLQ09OTkVD VE9SX0ZPVU5EIEhBVkVfQ0tDT05ORUNUT1IpCisKIGNvbmZpZ3VyZV9maWxlKGNvbmZpZy1rZG0u aC5jbWFrZSAke0NNQUtFX0NVUlJFTlRfQklOQVJZX0RJUn0vY29uZmlnLWtkbS5oKQogCiBpbnN0 YWxsKCBGSUxFUyBSRUFETUUgREVTVElOQVRJT04gJHtEQVRBX0lOU1RBTExfRElSfS9kb2Mva2Rt ICkKZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMC45OC9rZG0vY29uZmlnLWtkbS5oLmNt YWtlIGtkZWJhc2Utd29ya3NwYWNlLTQuMC45OC1jb25zb2xla2l0LWtkbS9rZG0vY29uZmlnLWtk bS5oLmNtYWtlCi0tLSBrZGViYXNlLXdvcmtzcGFjZS00LjAuOTgva2RtL2NvbmZpZy1rZG0uaC5j bWFrZQkyMDA4LTAxLTA1IDAwOjU1OjQ1LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jr c3BhY2UtNC4wLjk4LWNvbnNvbGVraXQta2RtL2tkbS9jb25maWcta2RtLmguY21ha2UJMjAwOC0w Ny0xNCAyMzo0ODozNS4wMDAwMDAwMDAgKzAyMDAKQEAgLTEyMyw2ICsxMjMsOSBAQAogLyogRGVm aW5lIHRvIDEgaWYgeW91IGhhdmUgdGhlIDx0ZXJtaW9zLmg+IGhlYWRlciBmaWxlLiAqLwogI2Nt YWtlZGVmaW5lIEhBVkVfVEVSTUlPU19IIDEKIAorLyogRGVmaW5lIHRvIDEgaWYgdGhlIGNrLWNv bm5lY3RvciBsaWJyYXJ5IGlzIGZvdW5kICovCisjY21ha2VkZWZpbmUgSEFWRV9DS0NPTk5FQ1RP UiAxCisKIC8qICRQQVRIIGRlZmF1bHRzIHNldCBieSBLRE0gKi8KICNjbWFrZWRlZmluZSBLRE1f REVGX1VTRVJfUEFUSCAiJHtLRE1fREVGX1VTRVJfUEFUSH0iCiAjY21ha2VkZWZpbmUgS0RNX0RF Rl9TWVNURU1fUEFUSCAiJHtLRE1fREVGX1NZU1RFTV9QQVRIfSIK 28377 2008-11-07 01:42:55 +0000 2008-11-07 02:06:59 +0000 KDM ConsoleKit support patch using libck-connector (against trunk or 4.1.2) kdebase-workspace-4.1.2-consolekit-kdm.patch text/plain 10739 kevin.kofler ZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2NtYWtlL21vZHVsZXMvRmluZENrQ29u bmVjdG9yLmNtYWtlIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yLWNvbnNvbGVraXQta2RtL2NtYWtl L21vZHVsZXMvRmluZENrQ29ubmVjdG9yLmNtYWtlCi0tLSBrZGViYXNlLXdvcmtzcGFjZS00LjEu Mi9jbWFrZS9tb2R1bGVzL0ZpbmRDa0Nvbm5lY3Rvci5jbWFrZQkxOTcwLTAxLTAxIDAxOjAwOjAw LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1r ZG0vY21ha2UvbW9kdWxlcy9GaW5kQ2tDb25uZWN0b3IuY21ha2UJMjAwOC0xMS0wNyAwMDoxNToz MS4wMDAwMDAwMDAgKzAxMDAKQEAgLTAsMCArMSw1OCBAQAorIyAtIFRyeSB0byBmaW5kIHRoZSBD b25zb2xlS2l0IGNvbm5lY3RvciBsaWJyYXJ5IChsaWJjay1jb25uZWN0b3IpCisjIE9uY2UgZG9u ZSB0aGlzIHdpbGwgZGVmaW5lCisjCisjICBDS0NPTk5FQ1RPUl9GT1VORCAtIHN5c3RlbSBoYXMg dGhlIENLIENvbm5lY3RvcgorIyAgQ0tDT05ORUNUT1JfSU5DTFVERV9ESVIgLSB0aGUgQ0sgQ29u bmVjdG9yIGluY2x1ZGUgZGlyZWN0b3J5CisjICBDS0NPTk5FQ1RPUl9MSUJSQVJJRVMgLSBUaGUg bGlicmFyaWVzIG5lZWRlZCB0byB1c2UgQ0sgQ29ubmVjdG9yCisKKyMgQ29weXJpZ2h0IChjKSAy MDA4LCBLZXZpbiBLb2ZsZXIsIDxrZXZpbi5rb2ZsZXJAY2hlbGxvLmF0PgorIyBtb2RlbGVkIGFm dGVyIEZpbmRMaWJBcnQuY21ha2U6CisjIENvcHlyaWdodCAoYykgMjAwNiwgQWxleGFuZGVyIE5l dW5kb3JmLCA8bmV1bmRvcmZAa2RlLm9yZz4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp cyBhbGxvd2VkIGFjY29yZGluZyB0byB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorIyBG b3IgZGV0YWlscyBzZWUgdGhlIGFjY29tcGFueWluZyBDT1BZSU5HLUNNQUtFLVNDUklQVFMgZmls ZS4KKworCitpZiAoQ0tDT05ORUNUT1JfSU5DTFVERV9ESVIgQU5EIENLQ09OTkVDVE9SX0xJQlJB UklFUykKKworICAjIGluIGNhY2hlIGFscmVhZHkKKyAgU0VUKENLQ09OTkVDVE9SX0ZPVU5EIFRS VUUpCisKK2Vsc2UgKENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIEFORCBDS0NPTk5FQ1RPUl9MSUJS QVJJRVMpCisKKyAgSUYgKE5PVCBXSU4zMikKKyAgICBJTkNMVURFKFVzZVBrZ0NvbmZpZykKKyAg ICAjIHVzZSBwa2ctY29uZmlnIHRvIGdldCB0aGUgZGlyZWN0b3JpZXMgYW5kIHRoZW4gdXNlIHRo ZXNlIHZhbHVlcworICAgICMgaW4gdGhlIEZJTkRfUEFUSCgpIGFuZCBGSU5EX0xJQlJBUlkoKSBj YWxscworICAgIFBLR0NPTkZJRyhjay1jb25uZWN0b3IgX2NrQ29ubmVjdG9ySW5jRGlyIF9ja0Nv bm5lY3RvckxpbmtEaXIgX2NrQ29ubmVjdG9yTGlua0ZsYWdzIF9ja0Nvbm5lY3RvckNmbGFncykK KyAgRU5ESUYgKE5PVCBXSU4zMikKKworICBGSU5EX1BBVEgoQ0tDT05ORUNUT1JfSU5DTFVERV9E SVIgY2stY29ubmVjdG9yLmgKKyAgICAgJHtfY2tDb25uZWN0b3JJbmNEaXJ9L0NvbnNvbGVLaXQv Y2stY29ubmVjdG9yCisgICAgICR7X2NrQ29ubmVjdG9ySW5jRGlyfQorICApCisKKyAgRklORF9M SUJSQVJZKENLQ09OTkVDVE9SX0xJQlJBUklFUyBOQU1FUyBjay1jb25uZWN0b3IKKyAgICAgUEFU SFMKKyAgICAgJHtfY2tDb25uZWN0b3JMaW5rRGlyfQorICApCisKKworICBpZiAoQ0tDT05ORUNU T1JfSU5DTFVERV9ESVIgQU5EIENLQ09OTkVDVE9SX0xJQlJBUklFUykKKyAgICAgc2V0KENLQ09O TkVDVE9SX0ZPVU5EIFRSVUUpCisgIGVuZGlmIChDS0NPTk5FQ1RPUl9JTkNMVURFX0RJUiBBTkQg Q0tDT05ORUNUT1JfTElCUkFSSUVTKQorCisKKyAgaWYgKENLQ09OTkVDVE9SX0ZPVU5EKQorICAg ICBpZiAoTk9UIENrQ29ubmVjdG9yX0ZJTkRfUVVJRVRMWSkKKyAgICAgICAgbWVzc2FnZShTVEFU VVMgIkZvdW5kIGNrLWNvbm5lY3RvcjogJHtDS0NPTk5FQ1RPUl9MSUJSQVJJRVN9IikKKyAgICAg ZW5kaWYgKE5PVCBDa0Nvbm5lY3Rvcl9GSU5EX1FVSUVUTFkpCisgIGVsc2UgKENLQ09OTkVDVE9S X0ZPVU5EKQorICAgICBpZiAoQ2tDb25uZWN0b3JfRklORF9SRVFVSVJFRCkKKyAgICAgICAgbWVz c2FnZShGQVRBTF9FUlJPUiAiQ291bGQgTk9UIGZpbmQgY2stY29ubmVjdG9yIikKKyAgICAgZW5k aWYgKENrQ29ubmVjdG9yX0ZJTkRfUkVRVUlSRUQpCisgIGVuZGlmIChDS0NPTk5FQ1RPUl9GT1VO RCkKKworICBNQVJLX0FTX0FEVkFOQ0VEKENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIENLQ09OTkVD VE9SX0xJQlJBUklFUykKKworZW5kaWYgKENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIEFORCBDS0NP Tk5FQ1RPUl9MSUJSQVJJRVMpCmRpZmYgLU51ciBrZGViYXNlLXdvcmtzcGFjZS00LjEuMi9jbWFr ZS9tb2R1bGVzL0ZpbmREQnVzLmNtYWtlIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yLWNvbnNvbGVr aXQta2RtL2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2UKLS0tIGtkZWJhc2Utd29ya3NwYWNl LTQuMS4yL2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2UJMTk3MC0wMS0wMSAwMTowMDowMC4w MDAwMDAwMDAgKzAxMDAKKysrIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yLWNvbnNvbGVraXQta2Rt L2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2UJMjAwOC0xMS0wNyAwMDoxNTozMS4wMDAwMDAw MDAgKzAxMDAKQEAgLTAsMCArMSwzOSBAQAorCitpZihEQlVTX0lOQ0xVREVfRElSIEFORCBEQlVT X0xJQlJBUlkgQU5EIERCVVNfQVJDSF9JTkNMVURFX0RJUikKKwkjIEFscmVhZHkgaW4gY2FjaGUs IGJlIHNpbGVudAorCXNldChEQlVTX0ZJTkRfUVVJRVRMWSBUUlVFKQkKK2VuZGlmKERCVVNfSU5D TFVERV9ESVIgQU5EIERCVVNfTElCUkFSWSBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSKQorCitz ZXQoREJVU19MSUJSQVJZKQorc2V0KERCVVNfSU5DTFVERV9ESVIpCitzZXQoREJVU19BUkNIX0lO Q0xVREVfRElSKQorCitGSU5EX1BBVEgoREJVU19JTkNMVURFX0RJUiBkYnVzL2RidXMuaAorCS91 c3IvaW5jbHVkZQorCS91c3IvaW5jbHVkZS9kYnVzLTEuMAorCS91c3IvbG9jYWwvaW5jbHVkZQor KQorCitGSU5EX1BBVEgoREJVU19BUkNIX0lOQ0xVREVfRElSIGRidXMvZGJ1cy1hcmNoLWRlcHMu aAorCS91c3IvbGliJHtMSUJfU1VGRklYfS9pbmNsdWRlCisJL3Vzci9saWIke0xJQl9TVUZGSVh9 L2RidXMtMS4wL2luY2x1ZGUKKwkvdXNyL2xpYjY0L2luY2x1ZGUKKwkvdXNyL2xpYjY0L2RidXMt MS4wL2luY2x1ZGUKKwkvdXNyL2xpYi9pbmNsdWRlCisJL3Vzci9saWIvZGJ1cy0xLjAvaW5jbHVk ZQorKQorCitGSU5EX0xJQlJBUlkoREJVU19MSUJSQVJZIE5BTUVTIGRidXMtMSBkYnVzCisJUEFU SFMKKwkvdXNyL2xpYgorCS91c3IvbG9jYWwvbGliCispCisKK2lmKERCVVNfSU5DTFVERV9ESVIg QU5EIERCVVNfTElCUkFSWSBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSKQorICAgTUVTU0FHRSgg U1RBVFVTICJkYnVzIGZvdW5kOiBpbmNsdWRlcyBpbiAke0RCVVNfSU5DTFVERV9ESVJ9LCBsaWJy YXJ5IGluICR7REJVU19MSUJSQVJZfSIpCisgICBzZXQoREJVU19GT1VORCBUUlVFKQorZWxzZShE QlVTX0lOQ0xVREVfRElSIEFORCBEQlVTX0xJQlJBUlkgQU5EIERCVVNfQVJDSF9JTkNMVURFX0RJ UikKKyAgIE1FU1NBR0UoIFNUQVRVUyAiZGJ1cyBub3QgZm91bmQiKQorZW5kaWYoREJVU19JTkNM VURFX0RJUiBBTkQgREJVU19MSUJSQVJZIEFORCBEQlVTX0FSQ0hfSU5DTFVERV9ESVIpCisKK01B UktfQVNfQURWQU5DRUQoREJVU19JTkNMVURFX0RJUiBEQlVTX0xJQlJBUlkgREJVU19BUkNIX0lO Q0xVREVfRElSKQpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIva2RtL2JhY2tlbmQv Y2xpZW50LmMga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1rZG0va2RtL2JhY2tl bmQvY2xpZW50LmMKLS0tIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2tkbS9iYWNrZW5kL2NsaWVu dC5jCTIwMDgtMDUtMDcgMTE6MDU6MjYuMDAwMDAwMDAwICswMjAwCisrKyBrZGViYXNlLXdvcmtz cGFjZS00LjEuMi1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9jbGllbnQuYwkyMDA4LTExLTA3 IDAwOjU3OjU1LjAwMDAwMDAwMCArMDEwMApAQCAtNzcsNiArNzcsMTAgQEAKIC8qIGZvciBleHBp cmF0aW9uICovCiAjIGluY2x1ZGUgPHRpbWUuaD4KICNlbmRpZiAvKiBVU0VfUEFNIHx8IF9BSVgg Ki8KKyNpZmRlZiBIQVZFX0NLQ09OTkVDVE9SCisjIGluY2x1ZGUgPGNrLWNvbm5lY3Rvci5oPgor IyBpbmNsdWRlIDxkYnVzL2RidXMuaD4KKyNlbmRpZgogI2lmZGVmIEhBVkVfR0VUU1BOQU0KICMg aW5jbHVkZSA8c2hhZG93Lmg+CiAjZW5kaWYKQEAgLTExNDksNiArMTE1MywxMCBAQAogc3RhdGlj IGludCByZW1vdmVTZXNzaW9uOwogc3RhdGljIGludCByZW1vdmVDcmVkczsKICNlbmRpZgorI2lm ZGVmIEhBVkVfQ0tDT05ORUNUT1IKK3N0YXRpYyBjb25zdCBjaGFyICpja19zZXNzaW9uX2Nvb2tp ZTsKK3N0YXRpYyBDa0Nvbm5lY3RvciAqY29ubmVjdG9yOworI2VuZGlmCiAKIHN0YXRpYyBHUGlw ZSBjdGxwaXBlOwogc3RhdGljIEdUYWxrIGN0bHRhbGs7CkBAIC0xMTk4LDYgKzEyMDYsMTUgQEAK IAlleHRlcm4gY2hhciAqKm5ld2VudjsgLyogZnJvbSBsaWJzLmEsIHRoaXMgaXMgc2V0IHVwIGJ5 IHNldHBlbnYgKi8KICMgZW5kaWYKICNlbmRpZgorI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKwlE QnVzRXJyb3IgZXJyb3I7CisJY2hhciBkZXZpY2VidWZbMjBdID0gIiI7CisJY2hhciAqZGV2aWNl ID0gZGV2aWNlYnVmOworCWRidXNfYm9vbF90IGlzX2xvY2FsOworI2lmZGVmIFhETUNQCisJY2hh ciAqcmVtb3RlX2hvc3RfbmFtZSA9ICIiOworI2VuZGlmCisjZW5kaWYKIAljaGFyICpmYWlsc2Fm ZUFyZ3ZbMl07CiAJY2hhciAqYnVmLCAqYnVmMjsKIAlpbnQgaTsKQEAgLTEyMDcsNyArMTIyNCw3 IEBACiAJCWlmIChkbXJjdXNlcikgeyBmcmVlKCBkbXJjdXNlciApOyBkbXJjdXNlciA9IDA7IH0K IAl9CiAKLSNpZiBkZWZpbmVkKFVTRV9QQU0pIHx8IGRlZmluZWQoX0FJWCkKKyNpZiBkZWZpbmVk KFVTRV9QQU0pIHx8IGRlZmluZWQoX0FJWCkgfHwgZGVmaW5lZChIQVZFX0NLQ09OTkVDVE9SKQog CWlmICghKHAgPSBnZXRwd25hbSggY3VydXNlciApKSkgewogCQlsb2dFcnJvciggImdldHB3bmFt KCVzKSBmYWlsZWQuXG4iLCBjdXJ1c2VyICk7CiAJICBwRXJyb3I6CkBAIC0xMjE2LDYgKzEyMzMs NTIgQEAKIAl9CiAjZW5kaWYKIAorI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKyNpZmRlZiBIQVZF X1ZUUworCWlmICh0ZC0+c2VydmVyVlQgPiAwKSB7CisJCS8qIEZJWE1FOiBob3cgZG9lcyB4b3Jn IGNvbnN0cnVjdCB0aGlzICovCisJCXNwcmludGYoIGRldmljZSwgIi9kZXYvdHR5JWQiLCB0ZC0+ c2VydmVyVlQgKTsKKwl9CQorI2VuZGlmCisKKwlpZiAocCkgeworCQljb25uZWN0b3IgPSBja19j b25uZWN0b3JfbmV3KCk7CisJCWlmIChjb25uZWN0b3IpIHsKKwkJCWlzX2xvY2FsID0gKCh0ZC0+ ZGlzcGxheVR5cGUgJiBkX2xvY2F0aW9uKSA9PSBkTG9jYWwpOworI2lmZGVmIFhETUNQCisJCQlp ZiAoIWlzX2xvY2FsICYmIHRkLT5yZW1vdGVIb3N0KQorCQkJCXJlbW90ZV9ob3N0X25hbWUgPSB0 ZC0+cmVtb3RlSG9zdDsKKyNlbmRpZgorCisJCQlkYnVzX2Vycm9yX2luaXQoICZlcnJvciApOwor CQkJaWYgKCFja19jb25uZWN0b3Jfb3Blbl9zZXNzaW9uX3dpdGhfcGFyYW1ldGVycyggY29ubmVj dG9yLAorCQkJCSZlcnJvciwgInVuaXgtdXNlciIsICYocC0+cHdfdWlkKSwKKwkJCQkieDExLWRp c3BsYXktZGV2aWNlIiwgJmRldmljZSwKKwkJCQkieDExLWRpc3BsYXkiLCAmKHRkLT5uYW1lKSwK KwkJCQkiaXMtbG9jYWwiLCAmaXNfbG9jYWwsCisjaWZkZWYgWERNQ1AKKwkJCQkicmVtb3RlLWhv c3QtbmFtZSIsICZyZW1vdGVfaG9zdF9uYW1lLAorI2VuZGlmCisJCQkJTlVMTCApKSB7CisJCQkJ aWYgKGRidXNfZXJyb3JfaXNfc2V0KCAmZXJyb3IgKSkgeworCQkJCQlsb2dFcnJvciggIkNvbnNv bGVLaXQgb3BlbjogJXNcbiIsIGVycm9yLm1lc3NhZ2UgKTsKKwkJCQkJZGJ1c19lcnJvcl9mcmVl KCAmZXJyb3IgKTsKKwkJCQl9IGVsc2UgeworCQkJCQlsb2dFcnJvciggImNhbm5vdCBvcGVuIENL IHNlc3Npb246IE9PTSwgRC1CdXMgc3lzdGVtIGJ1cyBub3QgYXZhaWxhYmxlLFxuIgorCQkJCQkJ IkNvbnNvbGVLaXQgbm90IGF2YWlsYWJsZSBvciBpbnN1ZmZpY2llbnQgcHJpdmlsZWdlcy5cbiIg KTsKKwkJCQl9CisJCQkJY2tfY29ubmVjdG9yX3VucmVmKCBjb25uZWN0b3IgKTsKKwkJCQlWX1JF VDsKKwkJCX0KKwkJfSBlbHNlIHsKKwkJCWRlYnVnKCAiT09NIGNyZWF0aW5nIENrQ29ubmVjdG9y XG4iICk7CisJCQlWX1JFVDsKKwkJfQorCQlja19zZXNzaW9uX2Nvb2tpZSA9IGNrX2Nvbm5lY3Rv cl9nZXRfY29va2llKCBjb25uZWN0b3IgKTsKKwl9IGVsc2UKKwkJY2tfc2Vzc2lvbl9jb29raWUg PSBOVUxMOworI2VuZGlmCisKIAlzdHJjcHkoIGN1cnVzZXIsIHAtPnB3X25hbWUgKTsgLyogVXNl IG5vcm1hbGl6ZWQgbG9naW4gbmFtZS4gKi8KIAogI2lmbmRlZiBVU0VfUEFNCkBAIC0xMjY5LDYg KzEzMzIsMTAgQEAKIAlpZiAoa3JidGtmaWxlWzBdICE9ICdcMCcpCiAJCWVudiA9IHNldEVudigg ZW52LCAiS1JCVEtGSUxFIiwga3JidGtmaWxlICk7CiAjZW5kaWYKKyNpZmRlZiBIQVZFX0NLQ09O TkVDVE9SCisJaWYgKGNrX3Nlc3Npb25fY29va2llKQorCQllbnYgPSBzZXRFbnYoIGVudiwgIlhE R19TRVNTSU9OX0NPT0tJRSIsIGNrX3Nlc3Npb25fY29va2llICk7CisjZW5kaWYKIAl1c2VyRW52 aXJvbiA9IGluaGVyaXRFbnYoIGVudiwgZW52dmFycyApOwogCWVudiA9IHN5c3RlbUVudiggMCwg Y3VydXNlciApOwogCXN5c3RlbUVudmlyb24gPSBzZXRFbnYoIGVudiwgIkhPTUUiLCBwLT5wd19k aXIgKTsKQEAgLTE2ODUsNiArMTc1Miw5IEBACiAjaWZkZWYgVVNFX1BBTQogCWludCBwcmV0YzsK ICNlbmRpZgorI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKwlEQnVzRXJyb3IgZXJyb3I7CisjZW5k aWYKIAogCWlmIChyZW1vdmVBdXRoKSB7CiAJCXN3aXRjaCAoc291cmNlKCBzeXN0ZW1FbnZpcm9u LCB0ZC0+cmVzZXQsIHRkX3NldHVwICkpIHsKQEAgLTE3NTksNiArMTgyOSwyNCBAQAogCQlwYW1o ID0gMDsKIAl9CiAjZW5kaWYKKworI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKwkvKiBjbG9zZSBD b25zb2xlS2l0IHNlc3Npb24gKi8KKwlpZiAoY2tfc2Vzc2lvbl9jb29raWUpIHsKKwkJZGJ1c19l cnJvcl9pbml0KCAmZXJyb3IgKTsKKwkJaWYgKCFja19jb25uZWN0b3JfY2xvc2Vfc2Vzc2lvbigg Y29ubmVjdG9yLCAmZXJyb3IgKSkgeworCQkJaWYgKGRidXNfZXJyb3JfaXNfc2V0KCAmZXJyb3Ig KSkgeworCQkJCWxvZ0Vycm9yKCAiQ29uc29sZUtpdCBjbG9zZTogJXNcbiIsIGVycm9yLm1lc3Nh Z2UgKTsKKwkJCQlkYnVzX2Vycm9yX2ZyZWUoICZlcnJvciApOworCQkJfSBlbHNlIHsKKwkJCQls b2dFcnJvciggIkNhbm5vdCBjbG9zZSBDSyBzZXNzaW9uOiBPT00sIEQtQnVzIHN5c3RlbSBidXMg bm90IGF2YWlsYWJsZSxcbiIKKwkJCQkiQ29uc29sZUtpdCBub3QgYXZhaWxhYmxlIG9yIGluc3Vm ZmljaWVudCBwcml2aWxlZ2VzLlxuIiApOworCQkJfQorCQl9CisJCWNrX2Nvbm5lY3Rvcl91bnJl ZiggY29ubmVjdG9yICk7CisJCWNrX3Nlc3Npb25fY29va2llID0gTlVMTDsKKwl9CisjZW5kaWYK IH0KIAogdm9pZApkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIva2RtL2JhY2tlbmQv Q01ha2VMaXN0cy50eHQga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1rZG0va2Rt L2JhY2tlbmQvQ01ha2VMaXN0cy50eHQKLS0tIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2tkbS9i YWNrZW5kL0NNYWtlTGlzdHMudHh0CTIwMDgtMDUtMjkgMTM6MTk6MDEuMDAwMDAwMDAwICswMjAw CisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjEuMi1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9D TWFrZUxpc3RzLnR4dAkyMDA4LTExLTA3IDAwOjE1OjMxLjAwMDAwMDAwMCArMDEwMApAQCAtNjAs NiArNjAsMTAgQEAKIAkke1NPQ0tFVF9MSUJSQVJJRVN9CiAJJHtSRVNPTFZfTElCUkFSSUVTfQog KQoraWYgKENLQ09OTkVDVE9SX0ZPVU5EKQorCWluY2x1ZGVfZGlyZWN0b3JpZXMoJHtDS0NPTk5F Q1RPUl9JTkNMVURFX0RJUn0gJHtEQlVTX0lOQ0xVREVfRElSfSAke0RCVVNfQVJDSF9JTkNMVURF X0RJUn0pCisJdGFyZ2V0X2xpbmtfbGlicmFyaWVzKCBrZG0gJHtDS0NPTk5FQ1RPUl9MSUJSQVJJ RVN9ICR7REJVU19MSUJSQVJZfSApCitlbmRpZiAoQ0tDT05ORUNUT1JfRk9VTkQpCiBpZihVVElM X0xJQlJBUklFUykKIAl0YXJnZXRfbGlua19saWJyYXJpZXMoIGtkbSAke1VUSUxfTElCUkFSSUVT fSApCiBlbmRpZihVVElMX0xJQlJBUklFUykKZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQu MS4yL2tkbS9iYWNrZW5kL3hkbWNwLmMga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtp dC1rZG0va2RtL2JhY2tlbmQveGRtY3AuYwotLS0ga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIva2Rt L2JhY2tlbmQveGRtY3AuYwkyMDA4LTAxLTA1IDAwOjU1OjQ0LjAwMDAwMDAwMCArMDEwMAorKysg a2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQveGRtY3Au YwkyMDA4LTExLTA3IDAwOjU0OjIzLjAwMDAwMDAwMCArMDEwMApAQCAtMTAxNiw2ICsxMDE2LDgg QEAKIAkJCWQtPmNsaWVudEFkZHIgPSBjbGllbnRBZGRyZXNzOwogCQkJZC0+Y2xpZW50UG9ydCA9 IGNsaWVudFBvcnQ7CiAJCQlkLT5jb25uZWN0aW9uVHlwZSA9IGNvbm5lY3Rpb25UeXBlOworCQkJ ZC0+cmVtb3RlSG9zdCA9IG5ldHdvcmtBZGRyZXNzVG9Ib3N0bmFtZSggcGRweS0+Y29ubmVjdGlv blR5cGUsCisJCQkJJnBkcHktPmNvbm5lY3Rpb25BZGRyZXNzICk7CiAJCQlpZiAocGRweS0+Zmls ZUF1dGhvcml6YXRpb24pIHsKIAkJCQlkLT5hdXRob3JpemF0aW9ucyA9IChYYXV0aCAqKilNYWxs b2MoIHNpemVvZihYYXV0aCAqKSApOwogCQkJCWlmICghZC0+YXV0aG9yaXphdGlvbnMpIHsKZGlm ZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2tkbS9DTWFrZUxpc3RzLnR4dCBrZGViYXNl LXdvcmtzcGFjZS00LjEuMi1jb25zb2xla2l0LWtkbS9rZG0vQ01ha2VMaXN0cy50eHQKLS0tIGtk ZWJhc2Utd29ya3NwYWNlLTQuMS4yL2tkbS9DTWFrZUxpc3RzLnR4dAkyMDA4LTAyLTA3IDE0OjE5 OjUxLjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtp dC1rZG0va2RtL0NNYWtlTGlzdHMudHh0CTIwMDgtMTEtMDcgMDA6MTU6MzEuMDAwMDAwMDAwICsw MTAwCkBAIC00LDYgKzQsMTcgQEAKIGluc3RhbGxfcGFtX3NlcnZpY2UoS0RNKQogCiBpbmNsdWRl KENvbmZpZ3VyZUNoZWNrcy5jbWFrZSkKKworbWFjcm9fb3B0aW9uYWxfZmluZF9wYWNrYWdlKENr Q29ubmVjdG9yKQoraWYoQ0tDT05ORUNUT1JfRk9VTkQpCisgICMgd2hlbiBidWlsZGluZyB3aXRo IGxpYmNrLWNvbm5lY3Rvciwgd2UgYWxzbyBuZWVkIHRoZSBsb3ctbGV2ZWwgRC1CdXMgQVBJCisg IGZpbmRfcGFja2FnZShEQnVzIFJFUVVJUkVEKQorZW5kaWYoQ0tDT05ORUNUT1JfRk9VTkQpCisK K21hY3JvX2xvZ19mZWF0dXJlKENLQ09OTkVDVE9SX0ZPVU5EICJjay1jb25uZWN0b3IiICJUaGUg Q29uc29sZUtpdCBjb25uZWN0b3IgbGlicmFyeSIgImh0dHA6Ly9mcmVlZGVza3RvcC5vcmcvd2lr aS9Tb2Z0d2FyZS9Db25zb2xlS2l0IiBGQUxTRSAiIiAiUHJvdmlkZXMgQ29uc29sZUtpdCBpbnRl Z3JhdGlvbiBpbiBLRE0iKQorCittYWNyb19ib29sX3RvXzAxKENLQ09OTkVDVE9SX0ZPVU5EIEhB VkVfQ0tDT05ORUNUT1IpCisKIGNvbmZpZ3VyZV9maWxlKGNvbmZpZy1rZG0uaC5jbWFrZSAke0NN QUtFX0NVUlJFTlRfQklOQVJZX0RJUn0vY29uZmlnLWtkbS5oKQogCiBpbnN0YWxsKCBGSUxFUyBS RUFETUUgREVTVElOQVRJT04gJHtEQVRBX0lOU1RBTExfRElSfS9kb2Mva2RtICkKZGlmZiAtTnVy IGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2tkbS9jb25maWcta2RtLmguY21ha2Uga2RlYmFzZS13 b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1rZG0va2RtL2NvbmZpZy1rZG0uaC5jbWFrZQotLS0g a2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIva2RtL2NvbmZpZy1rZG0uaC5jbWFrZQkyMDA4LTAxLTA1 IDAwOjU1OjQ1LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29u c29sZWtpdC1rZG0va2RtL2NvbmZpZy1rZG0uaC5jbWFrZQkyMDA4LTExLTA3IDAwOjE1OjMxLjAw MDAwMDAwMCArMDEwMApAQCAtMTIzLDYgKzEyMyw5IEBACiAvKiBEZWZpbmUgdG8gMSBpZiB5b3Ug aGF2ZSB0aGUgPHRlcm1pb3MuaD4gaGVhZGVyIGZpbGUuICovCiAjY21ha2VkZWZpbmUgSEFWRV9U RVJNSU9TX0ggMQogCisvKiBEZWZpbmUgdG8gMSBpZiB0aGUgY2stY29ubmVjdG9yIGxpYnJhcnkg aXMgZm91bmQgKi8KKyNjbWFrZWRlZmluZSBIQVZFX0NLQ09OTkVDVE9SIDEKKwogLyogJFBBVEgg ZGVmYXVsdHMgc2V0IGJ5IEtETSAqLwogI2NtYWtlZGVmaW5lIEtETV9ERUZfVVNFUl9QQVRIICIk e0tETV9ERUZfVVNFUl9QQVRIfSIKICNjbWFrZWRlZmluZSBLRE1fREVGX1NZU1RFTV9QQVRIICIk e0tETV9ERUZfU1lTVEVNX1BBVEh9Igo= 28378 2008-11-07 02:06:59 +0000 2008-11-08 18:03:00 +0000 KDM ConsoleKit support patch using libck-connector (against trunk or 4.1.2) kdebase-workspace-4.1.2-consolekit-kdm.patch text/plain 10745 kevin.kofler ZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2NtYWtlL21vZHVsZXMvRmluZENrQ29u bmVjdG9yLmNtYWtlIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yLWNvbnNvbGVraXQta2RtL2NtYWtl L21vZHVsZXMvRmluZENrQ29ubmVjdG9yLmNtYWtlCi0tLSBrZGViYXNlLXdvcmtzcGFjZS00LjEu Mi9jbWFrZS9tb2R1bGVzL0ZpbmRDa0Nvbm5lY3Rvci5jbWFrZQkxOTcwLTAxLTAxIDAxOjAwOjAw LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1r ZG0vY21ha2UvbW9kdWxlcy9GaW5kQ2tDb25uZWN0b3IuY21ha2UJMjAwOC0xMS0wNyAwMDoxNToz MS4wMDAwMDAwMDAgKzAxMDAKQEAgLTAsMCArMSw1OCBAQAorIyAtIFRyeSB0byBmaW5kIHRoZSBD b25zb2xlS2l0IGNvbm5lY3RvciBsaWJyYXJ5IChsaWJjay1jb25uZWN0b3IpCisjIE9uY2UgZG9u ZSB0aGlzIHdpbGwgZGVmaW5lCisjCisjICBDS0NPTk5FQ1RPUl9GT1VORCAtIHN5c3RlbSBoYXMg dGhlIENLIENvbm5lY3RvcgorIyAgQ0tDT05ORUNUT1JfSU5DTFVERV9ESVIgLSB0aGUgQ0sgQ29u bmVjdG9yIGluY2x1ZGUgZGlyZWN0b3J5CisjICBDS0NPTk5FQ1RPUl9MSUJSQVJJRVMgLSBUaGUg bGlicmFyaWVzIG5lZWRlZCB0byB1c2UgQ0sgQ29ubmVjdG9yCisKKyMgQ29weXJpZ2h0IChjKSAy MDA4LCBLZXZpbiBLb2ZsZXIsIDxrZXZpbi5rb2ZsZXJAY2hlbGxvLmF0PgorIyBtb2RlbGVkIGFm dGVyIEZpbmRMaWJBcnQuY21ha2U6CisjIENvcHlyaWdodCAoYykgMjAwNiwgQWxleGFuZGVyIE5l dW5kb3JmLCA8bmV1bmRvcmZAa2RlLm9yZz4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp cyBhbGxvd2VkIGFjY29yZGluZyB0byB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorIyBG b3IgZGV0YWlscyBzZWUgdGhlIGFjY29tcGFueWluZyBDT1BZSU5HLUNNQUtFLVNDUklQVFMgZmls ZS4KKworCitpZiAoQ0tDT05ORUNUT1JfSU5DTFVERV9ESVIgQU5EIENLQ09OTkVDVE9SX0xJQlJB UklFUykKKworICAjIGluIGNhY2hlIGFscmVhZHkKKyAgU0VUKENLQ09OTkVDVE9SX0ZPVU5EIFRS VUUpCisKK2Vsc2UgKENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIEFORCBDS0NPTk5FQ1RPUl9MSUJS QVJJRVMpCisKKyAgSUYgKE5PVCBXSU4zMikKKyAgICBJTkNMVURFKFVzZVBrZ0NvbmZpZykKKyAg ICAjIHVzZSBwa2ctY29uZmlnIHRvIGdldCB0aGUgZGlyZWN0b3JpZXMgYW5kIHRoZW4gdXNlIHRo ZXNlIHZhbHVlcworICAgICMgaW4gdGhlIEZJTkRfUEFUSCgpIGFuZCBGSU5EX0xJQlJBUlkoKSBj YWxscworICAgIFBLR0NPTkZJRyhjay1jb25uZWN0b3IgX2NrQ29ubmVjdG9ySW5jRGlyIF9ja0Nv bm5lY3RvckxpbmtEaXIgX2NrQ29ubmVjdG9yTGlua0ZsYWdzIF9ja0Nvbm5lY3RvckNmbGFncykK KyAgRU5ESUYgKE5PVCBXSU4zMikKKworICBGSU5EX1BBVEgoQ0tDT05ORUNUT1JfSU5DTFVERV9E SVIgY2stY29ubmVjdG9yLmgKKyAgICAgJHtfY2tDb25uZWN0b3JJbmNEaXJ9L0NvbnNvbGVLaXQv Y2stY29ubmVjdG9yCisgICAgICR7X2NrQ29ubmVjdG9ySW5jRGlyfQorICApCisKKyAgRklORF9M SUJSQVJZKENLQ09OTkVDVE9SX0xJQlJBUklFUyBOQU1FUyBjay1jb25uZWN0b3IKKyAgICAgUEFU SFMKKyAgICAgJHtfY2tDb25uZWN0b3JMaW5rRGlyfQorICApCisKKworICBpZiAoQ0tDT05ORUNU T1JfSU5DTFVERV9ESVIgQU5EIENLQ09OTkVDVE9SX0xJQlJBUklFUykKKyAgICAgc2V0KENLQ09O TkVDVE9SX0ZPVU5EIFRSVUUpCisgIGVuZGlmIChDS0NPTk5FQ1RPUl9JTkNMVURFX0RJUiBBTkQg Q0tDT05ORUNUT1JfTElCUkFSSUVTKQorCisKKyAgaWYgKENLQ09OTkVDVE9SX0ZPVU5EKQorICAg ICBpZiAoTk9UIENrQ29ubmVjdG9yX0ZJTkRfUVVJRVRMWSkKKyAgICAgICAgbWVzc2FnZShTVEFU VVMgIkZvdW5kIGNrLWNvbm5lY3RvcjogJHtDS0NPTk5FQ1RPUl9MSUJSQVJJRVN9IikKKyAgICAg ZW5kaWYgKE5PVCBDa0Nvbm5lY3Rvcl9GSU5EX1FVSUVUTFkpCisgIGVsc2UgKENLQ09OTkVDVE9S X0ZPVU5EKQorICAgICBpZiAoQ2tDb25uZWN0b3JfRklORF9SRVFVSVJFRCkKKyAgICAgICAgbWVz c2FnZShGQVRBTF9FUlJPUiAiQ291bGQgTk9UIGZpbmQgY2stY29ubmVjdG9yIikKKyAgICAgZW5k aWYgKENrQ29ubmVjdG9yX0ZJTkRfUkVRVUlSRUQpCisgIGVuZGlmIChDS0NPTk5FQ1RPUl9GT1VO RCkKKworICBNQVJLX0FTX0FEVkFOQ0VEKENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIENLQ09OTkVD VE9SX0xJQlJBUklFUykKKworZW5kaWYgKENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIEFORCBDS0NP Tk5FQ1RPUl9MSUJSQVJJRVMpCmRpZmYgLU51ciBrZGViYXNlLXdvcmtzcGFjZS00LjEuMi9jbWFr ZS9tb2R1bGVzL0ZpbmREQnVzLmNtYWtlIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yLWNvbnNvbGVr aXQta2RtL2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2UKLS0tIGtkZWJhc2Utd29ya3NwYWNl LTQuMS4yL2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2UJMTk3MC0wMS0wMSAwMTowMDowMC4w MDAwMDAwMDAgKzAxMDAKKysrIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yLWNvbnNvbGVraXQta2Rt L2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2UJMjAwOC0xMS0wNyAwMDoxNTozMS4wMDAwMDAw MDAgKzAxMDAKQEAgLTAsMCArMSwzOSBAQAorCitpZihEQlVTX0lOQ0xVREVfRElSIEFORCBEQlVT X0xJQlJBUlkgQU5EIERCVVNfQVJDSF9JTkNMVURFX0RJUikKKwkjIEFscmVhZHkgaW4gY2FjaGUs IGJlIHNpbGVudAorCXNldChEQlVTX0ZJTkRfUVVJRVRMWSBUUlVFKQkKK2VuZGlmKERCVVNfSU5D TFVERV9ESVIgQU5EIERCVVNfTElCUkFSWSBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSKQorCitz ZXQoREJVU19MSUJSQVJZKQorc2V0KERCVVNfSU5DTFVERV9ESVIpCitzZXQoREJVU19BUkNIX0lO Q0xVREVfRElSKQorCitGSU5EX1BBVEgoREJVU19JTkNMVURFX0RJUiBkYnVzL2RidXMuaAorCS91 c3IvaW5jbHVkZQorCS91c3IvaW5jbHVkZS9kYnVzLTEuMAorCS91c3IvbG9jYWwvaW5jbHVkZQor KQorCitGSU5EX1BBVEgoREJVU19BUkNIX0lOQ0xVREVfRElSIGRidXMvZGJ1cy1hcmNoLWRlcHMu aAorCS91c3IvbGliJHtMSUJfU1VGRklYfS9pbmNsdWRlCisJL3Vzci9saWIke0xJQl9TVUZGSVh9 L2RidXMtMS4wL2luY2x1ZGUKKwkvdXNyL2xpYjY0L2luY2x1ZGUKKwkvdXNyL2xpYjY0L2RidXMt MS4wL2luY2x1ZGUKKwkvdXNyL2xpYi9pbmNsdWRlCisJL3Vzci9saWIvZGJ1cy0xLjAvaW5jbHVk ZQorKQorCitGSU5EX0xJQlJBUlkoREJVU19MSUJSQVJZIE5BTUVTIGRidXMtMSBkYnVzCisJUEFU SFMKKwkvdXNyL2xpYgorCS91c3IvbG9jYWwvbGliCispCisKK2lmKERCVVNfSU5DTFVERV9ESVIg QU5EIERCVVNfTElCUkFSWSBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSKQorICAgTUVTU0FHRSgg U1RBVFVTICJkYnVzIGZvdW5kOiBpbmNsdWRlcyBpbiAke0RCVVNfSU5DTFVERV9ESVJ9LCBsaWJy YXJ5IGluICR7REJVU19MSUJSQVJZfSIpCisgICBzZXQoREJVU19GT1VORCBUUlVFKQorZWxzZShE QlVTX0lOQ0xVREVfRElSIEFORCBEQlVTX0xJQlJBUlkgQU5EIERCVVNfQVJDSF9JTkNMVURFX0RJ UikKKyAgIE1FU1NBR0UoIFNUQVRVUyAiZGJ1cyBub3QgZm91bmQiKQorZW5kaWYoREJVU19JTkNM VURFX0RJUiBBTkQgREJVU19MSUJSQVJZIEFORCBEQlVTX0FSQ0hfSU5DTFVERV9ESVIpCisKK01B UktfQVNfQURWQU5DRUQoREJVU19JTkNMVURFX0RJUiBEQlVTX0xJQlJBUlkgREJVU19BUkNIX0lO Q0xVREVfRElSKQpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIva2RtL2JhY2tlbmQv Y2xpZW50LmMga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1rZG0va2RtL2JhY2tl bmQvY2xpZW50LmMKLS0tIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2tkbS9iYWNrZW5kL2NsaWVu dC5jCTIwMDgtMDUtMDcgMTE6MDU6MjYuMDAwMDAwMDAwICswMjAwCisrKyBrZGViYXNlLXdvcmtz cGFjZS00LjEuMi1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC9jbGllbnQuYwkyMDA4LTExLTA3 IDAxOjQ3OjEzLjAwMDAwMDAwMCArMDEwMApAQCAtNzcsNiArNzcsMTAgQEAKIC8qIGZvciBleHBp cmF0aW9uICovCiAjIGluY2x1ZGUgPHRpbWUuaD4KICNlbmRpZiAvKiBVU0VfUEFNIHx8IF9BSVgg Ki8KKyNpZmRlZiBIQVZFX0NLQ09OTkVDVE9SCisjIGluY2x1ZGUgPGNrLWNvbm5lY3Rvci5oPgor IyBpbmNsdWRlIDxkYnVzL2RidXMuaD4KKyNlbmRpZgogI2lmZGVmIEhBVkVfR0VUU1BOQU0KICMg aW5jbHVkZSA8c2hhZG93Lmg+CiAjZW5kaWYKQEAgLTExNDksNiArMTE1MywxMCBAQAogc3RhdGlj IGludCByZW1vdmVTZXNzaW9uOwogc3RhdGljIGludCByZW1vdmVDcmVkczsKICNlbmRpZgorI2lm ZGVmIEhBVkVfQ0tDT05ORUNUT1IKK3N0YXRpYyBjb25zdCBjaGFyICpja19zZXNzaW9uX2Nvb2tp ZTsKK3N0YXRpYyBDa0Nvbm5lY3RvciAqY29ubmVjdG9yOworI2VuZGlmCiAKIHN0YXRpYyBHUGlw ZSBjdGxwaXBlOwogc3RhdGljIEdUYWxrIGN0bHRhbGs7CkBAIC0xMTk4LDYgKzEyMDYsMTUgQEAK IAlleHRlcm4gY2hhciAqKm5ld2VudjsgLyogZnJvbSBsaWJzLmEsIHRoaXMgaXMgc2V0IHVwIGJ5 IHNldHBlbnYgKi8KICMgZW5kaWYKICNlbmRpZgorI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKwlE QnVzRXJyb3IgZXJyb3I7CisJY2hhciBkZXZpY2VidWZbMjBdID0gIiI7CisJY2hhciAqZGV2aWNl ID0gZGV2aWNlYnVmOworCWRidXNfYm9vbF90IGlzX2xvY2FsOworI2lmZGVmIFhETUNQCisJY29u c3QgY2hhciAqcmVtb3RlX2hvc3RfbmFtZSA9ICIiOworI2VuZGlmCisjZW5kaWYKIAljaGFyICpm YWlsc2FmZUFyZ3ZbMl07CiAJY2hhciAqYnVmLCAqYnVmMjsKIAlpbnQgaTsKQEAgLTEyMDcsNyAr MTIyNCw3IEBACiAJCWlmIChkbXJjdXNlcikgeyBmcmVlKCBkbXJjdXNlciApOyBkbXJjdXNlciA9 IDA7IH0KIAl9CiAKLSNpZiBkZWZpbmVkKFVTRV9QQU0pIHx8IGRlZmluZWQoX0FJWCkKKyNpZiBk ZWZpbmVkKFVTRV9QQU0pIHx8IGRlZmluZWQoX0FJWCkgfHwgZGVmaW5lZChIQVZFX0NLQ09OTkVD VE9SKQogCWlmICghKHAgPSBnZXRwd25hbSggY3VydXNlciApKSkgewogCQlsb2dFcnJvciggImdl dHB3bmFtKCVzKSBmYWlsZWQuXG4iLCBjdXJ1c2VyICk7CiAJICBwRXJyb3I6CkBAIC0xMjE2LDYg KzEyMzMsNTIgQEAKIAl9CiAjZW5kaWYKIAorI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKyNpZmRl ZiBIQVZFX1ZUUworCWlmICh0ZC0+c2VydmVyVlQgPiAwKSB7CisJCS8qIEZJWE1FOiBob3cgZG9l cyB4b3JnIGNvbnN0cnVjdCB0aGlzICovCisJCXNwcmludGYoIGRldmljZSwgIi9kZXYvdHR5JWQi LCB0ZC0+c2VydmVyVlQgKTsKKwl9CQorI2VuZGlmCisKKwlpZiAocCkgeworCQljb25uZWN0b3Ig PSBja19jb25uZWN0b3JfbmV3KCk7CisJCWlmIChjb25uZWN0b3IpIHsKKwkJCWlzX2xvY2FsID0g KCh0ZC0+ZGlzcGxheVR5cGUgJiBkX2xvY2F0aW9uKSA9PSBkTG9jYWwpOworI2lmZGVmIFhETUNQ CisJCQlpZiAoIWlzX2xvY2FsICYmIHRkLT5yZW1vdGVIb3N0KQorCQkJCXJlbW90ZV9ob3N0X25h bWUgPSB0ZC0+cmVtb3RlSG9zdDsKKyNlbmRpZgorCisJCQlkYnVzX2Vycm9yX2luaXQoICZlcnJv ciApOworCQkJaWYgKCFja19jb25uZWN0b3Jfb3Blbl9zZXNzaW9uX3dpdGhfcGFyYW1ldGVycygg Y29ubmVjdG9yLAorCQkJCSZlcnJvciwgInVuaXgtdXNlciIsICYocC0+cHdfdWlkKSwKKwkJCQki eDExLWRpc3BsYXktZGV2aWNlIiwgJmRldmljZSwKKwkJCQkieDExLWRpc3BsYXkiLCAmKHRkLT5u YW1lKSwKKwkJCQkiaXMtbG9jYWwiLCAmaXNfbG9jYWwsCisjaWZkZWYgWERNQ1AKKwkJCQkicmVt b3RlLWhvc3QtbmFtZSIsICZyZW1vdGVfaG9zdF9uYW1lLAorI2VuZGlmCisJCQkJTlVMTCApKSB7 CisJCQkJaWYgKGRidXNfZXJyb3JfaXNfc2V0KCAmZXJyb3IgKSkgeworCQkJCQlsb2dFcnJvcigg IkNvbnNvbGVLaXQgb3BlbjogJXNcbiIsIGVycm9yLm1lc3NhZ2UgKTsKKwkJCQkJZGJ1c19lcnJv cl9mcmVlKCAmZXJyb3IgKTsKKwkJCQl9IGVsc2UgeworCQkJCQlsb2dFcnJvciggImNhbm5vdCBv cGVuIENLIHNlc3Npb246IE9PTSwgRC1CdXMgc3lzdGVtIGJ1cyBub3QgYXZhaWxhYmxlLFxuIgor CQkJCQkJIkNvbnNvbGVLaXQgbm90IGF2YWlsYWJsZSBvciBpbnN1ZmZpY2llbnQgcHJpdmlsZWdl cy5cbiIgKTsKKwkJCQl9CisJCQkJY2tfY29ubmVjdG9yX3VucmVmKCBjb25uZWN0b3IgKTsKKwkJ CQlWX1JFVDsKKwkJCX0KKwkJfSBlbHNlIHsKKwkJCWRlYnVnKCAiT09NIGNyZWF0aW5nIENrQ29u bmVjdG9yXG4iICk7CisJCQlWX1JFVDsKKwkJfQorCQlja19zZXNzaW9uX2Nvb2tpZSA9IGNrX2Nv bm5lY3Rvcl9nZXRfY29va2llKCBjb25uZWN0b3IgKTsKKwl9IGVsc2UKKwkJY2tfc2Vzc2lvbl9j b29raWUgPSBOVUxMOworI2VuZGlmCisKIAlzdHJjcHkoIGN1cnVzZXIsIHAtPnB3X25hbWUgKTsg LyogVXNlIG5vcm1hbGl6ZWQgbG9naW4gbmFtZS4gKi8KIAogI2lmbmRlZiBVU0VfUEFNCkBAIC0x MjY5LDYgKzEzMzIsMTAgQEAKIAlpZiAoa3JidGtmaWxlWzBdICE9ICdcMCcpCiAJCWVudiA9IHNl dEVudiggZW52LCAiS1JCVEtGSUxFIiwga3JidGtmaWxlICk7CiAjZW5kaWYKKyNpZmRlZiBIQVZF X0NLQ09OTkVDVE9SCisJaWYgKGNrX3Nlc3Npb25fY29va2llKQorCQllbnYgPSBzZXRFbnYoIGVu diwgIlhER19TRVNTSU9OX0NPT0tJRSIsIGNrX3Nlc3Npb25fY29va2llICk7CisjZW5kaWYKIAl1 c2VyRW52aXJvbiA9IGluaGVyaXRFbnYoIGVudiwgZW52dmFycyApOwogCWVudiA9IHN5c3RlbUVu diggMCwgY3VydXNlciApOwogCXN5c3RlbUVudmlyb24gPSBzZXRFbnYoIGVudiwgIkhPTUUiLCBw LT5wd19kaXIgKTsKQEAgLTE2ODUsNiArMTc1Miw5IEBACiAjaWZkZWYgVVNFX1BBTQogCWludCBw cmV0YzsKICNlbmRpZgorI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKwlEQnVzRXJyb3IgZXJyb3I7 CisjZW5kaWYKIAogCWlmIChyZW1vdmVBdXRoKSB7CiAJCXN3aXRjaCAoc291cmNlKCBzeXN0ZW1F bnZpcm9uLCB0ZC0+cmVzZXQsIHRkX3NldHVwICkpIHsKQEAgLTE3NTksNiArMTgyOSwyNCBAQAog CQlwYW1oID0gMDsKIAl9CiAjZW5kaWYKKworI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKwkvKiBj bG9zZSBDb25zb2xlS2l0IHNlc3Npb24gKi8KKwlpZiAoY2tfc2Vzc2lvbl9jb29raWUpIHsKKwkJ ZGJ1c19lcnJvcl9pbml0KCAmZXJyb3IgKTsKKwkJaWYgKCFja19jb25uZWN0b3JfY2xvc2Vfc2Vz c2lvbiggY29ubmVjdG9yLCAmZXJyb3IgKSkgeworCQkJaWYgKGRidXNfZXJyb3JfaXNfc2V0KCAm ZXJyb3IgKSkgeworCQkJCWxvZ0Vycm9yKCAiQ29uc29sZUtpdCBjbG9zZTogJXNcbiIsIGVycm9y Lm1lc3NhZ2UgKTsKKwkJCQlkYnVzX2Vycm9yX2ZyZWUoICZlcnJvciApOworCQkJfSBlbHNlIHsK KwkJCQlsb2dFcnJvciggIkNhbm5vdCBjbG9zZSBDSyBzZXNzaW9uOiBPT00sIEQtQnVzIHN5c3Rl bSBidXMgbm90IGF2YWlsYWJsZSxcbiIKKwkJCQkiQ29uc29sZUtpdCBub3QgYXZhaWxhYmxlIG9y IGluc3VmZmljaWVudCBwcml2aWxlZ2VzLlxuIiApOworCQkJfQorCQl9CisJCWNrX2Nvbm5lY3Rv cl91bnJlZiggY29ubmVjdG9yICk7CisJCWNrX3Nlc3Npb25fY29va2llID0gTlVMTDsKKwl9Cisj ZW5kaWYKIH0KIAogdm9pZApkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIva2RtL2Jh Y2tlbmQvQ01ha2VMaXN0cy50eHQga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1r ZG0va2RtL2JhY2tlbmQvQ01ha2VMaXN0cy50eHQKLS0tIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4y L2tkbS9iYWNrZW5kL0NNYWtlTGlzdHMudHh0CTIwMDgtMDUtMjkgMTM6MTk6MDEuMDAwMDAwMDAw ICswMjAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjEuMi1jb25zb2xla2l0LWtkbS9rZG0vYmFj a2VuZC9DTWFrZUxpc3RzLnR4dAkyMDA4LTExLTA3IDAwOjE1OjMxLjAwMDAwMDAwMCArMDEwMApA QCAtNjAsNiArNjAsMTAgQEAKIAkke1NPQ0tFVF9MSUJSQVJJRVN9CiAJJHtSRVNPTFZfTElCUkFS SUVTfQogKQoraWYgKENLQ09OTkVDVE9SX0ZPVU5EKQorCWluY2x1ZGVfZGlyZWN0b3JpZXMoJHtD S0NPTk5FQ1RPUl9JTkNMVURFX0RJUn0gJHtEQlVTX0lOQ0xVREVfRElSfSAke0RCVVNfQVJDSF9J TkNMVURFX0RJUn0pCisJdGFyZ2V0X2xpbmtfbGlicmFyaWVzKCBrZG0gJHtDS0NPTk5FQ1RPUl9M SUJSQVJJRVN9ICR7REJVU19MSUJSQVJZfSApCitlbmRpZiAoQ0tDT05ORUNUT1JfRk9VTkQpCiBp ZihVVElMX0xJQlJBUklFUykKIAl0YXJnZXRfbGlua19saWJyYXJpZXMoIGtkbSAke1VUSUxfTElC UkFSSUVTfSApCiBlbmRpZihVVElMX0xJQlJBUklFUykKZGlmZiAtTnVyIGtkZWJhc2Utd29ya3Nw YWNlLTQuMS4yL2tkbS9iYWNrZW5kL3hkbWNwLmMga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29u c29sZWtpdC1rZG0va2RtL2JhY2tlbmQveGRtY3AuYwotLS0ga2RlYmFzZS13b3Jrc3BhY2UtNC4x LjIva2RtL2JhY2tlbmQveGRtY3AuYwkyMDA4LTAxLTA1IDAwOjU1OjQ0LjAwMDAwMDAwMCArMDEw MAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQv eGRtY3AuYwkyMDA4LTExLTA3IDAwOjU0OjIzLjAwMDAwMDAwMCArMDEwMApAQCAtMTAxNiw2ICsx MDE2LDggQEAKIAkJCWQtPmNsaWVudEFkZHIgPSBjbGllbnRBZGRyZXNzOwogCQkJZC0+Y2xpZW50 UG9ydCA9IGNsaWVudFBvcnQ7CiAJCQlkLT5jb25uZWN0aW9uVHlwZSA9IGNvbm5lY3Rpb25UeXBl OworCQkJZC0+cmVtb3RlSG9zdCA9IG5ldHdvcmtBZGRyZXNzVG9Ib3N0bmFtZSggcGRweS0+Y29u bmVjdGlvblR5cGUsCisJCQkJJnBkcHktPmNvbm5lY3Rpb25BZGRyZXNzICk7CiAJCQlpZiAocGRw eS0+ZmlsZUF1dGhvcml6YXRpb24pIHsKIAkJCQlkLT5hdXRob3JpemF0aW9ucyA9IChYYXV0aCAq KilNYWxsb2MoIHNpemVvZihYYXV0aCAqKSApOwogCQkJCWlmICghZC0+YXV0aG9yaXphdGlvbnMp IHsKZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2tkbS9DTWFrZUxpc3RzLnR4dCBr ZGViYXNlLXdvcmtzcGFjZS00LjEuMi1jb25zb2xla2l0LWtkbS9rZG0vQ01ha2VMaXN0cy50eHQK LS0tIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2tkbS9DTWFrZUxpc3RzLnR4dAkyMDA4LTAyLTA3 IDE0OjE5OjUxLjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29u c29sZWtpdC1rZG0va2RtL0NNYWtlTGlzdHMudHh0CTIwMDgtMTEtMDcgMDA6MTU6MzEuMDAwMDAw MDAwICswMTAwCkBAIC00LDYgKzQsMTcgQEAKIGluc3RhbGxfcGFtX3NlcnZpY2UoS0RNKQogCiBp bmNsdWRlKENvbmZpZ3VyZUNoZWNrcy5jbWFrZSkKKworbWFjcm9fb3B0aW9uYWxfZmluZF9wYWNr YWdlKENrQ29ubmVjdG9yKQoraWYoQ0tDT05ORUNUT1JfRk9VTkQpCisgICMgd2hlbiBidWlsZGlu ZyB3aXRoIGxpYmNrLWNvbm5lY3Rvciwgd2UgYWxzbyBuZWVkIHRoZSBsb3ctbGV2ZWwgRC1CdXMg QVBJCisgIGZpbmRfcGFja2FnZShEQnVzIFJFUVVJUkVEKQorZW5kaWYoQ0tDT05ORUNUT1JfRk9V TkQpCisKK21hY3JvX2xvZ19mZWF0dXJlKENLQ09OTkVDVE9SX0ZPVU5EICJjay1jb25uZWN0b3Ii ICJUaGUgQ29uc29sZUtpdCBjb25uZWN0b3IgbGlicmFyeSIgImh0dHA6Ly9mcmVlZGVza3RvcC5v cmcvd2lraS9Tb2Z0d2FyZS9Db25zb2xlS2l0IiBGQUxTRSAiIiAiUHJvdmlkZXMgQ29uc29sZUtp dCBpbnRlZ3JhdGlvbiBpbiBLRE0iKQorCittYWNyb19ib29sX3RvXzAxKENLQ09OTkVDVE9SX0ZP VU5EIEhBVkVfQ0tDT05ORUNUT1IpCisKIGNvbmZpZ3VyZV9maWxlKGNvbmZpZy1rZG0uaC5jbWFr ZSAke0NNQUtFX0NVUlJFTlRfQklOQVJZX0RJUn0vY29uZmlnLWtkbS5oKQogCiBpbnN0YWxsKCBG SUxFUyBSRUFETUUgREVTVElOQVRJT04gJHtEQVRBX0lOU1RBTExfRElSfS9kb2Mva2RtICkKZGlm ZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2tkbS9jb25maWcta2RtLmguY21ha2Uga2Rl YmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1rZG0va2RtL2NvbmZpZy1rZG0uaC5jbWFr ZQotLS0ga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIva2RtL2NvbmZpZy1rZG0uaC5jbWFrZQkyMDA4 LTAxLTA1IDAwOjU1OjQ1LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4x LjItY29uc29sZWtpdC1rZG0va2RtL2NvbmZpZy1rZG0uaC5jbWFrZQkyMDA4LTExLTA3IDAwOjE1 OjMxLjAwMDAwMDAwMCArMDEwMApAQCAtMTIzLDYgKzEyMyw5IEBACiAvKiBEZWZpbmUgdG8gMSBp ZiB5b3UgaGF2ZSB0aGUgPHRlcm1pb3MuaD4gaGVhZGVyIGZpbGUuICovCiAjY21ha2VkZWZpbmUg SEFWRV9URVJNSU9TX0ggMQogCisvKiBEZWZpbmUgdG8gMSBpZiB0aGUgY2stY29ubmVjdG9yIGxp YnJhcnkgaXMgZm91bmQgKi8KKyNjbWFrZWRlZmluZSBIQVZFX0NLQ09OTkVDVE9SIDEKKwogLyog JFBBVEggZGVmYXVsdHMgc2V0IGJ5IEtETSAqLwogI2NtYWtlZGVmaW5lIEtETV9ERUZfVVNFUl9Q QVRIICIke0tETV9ERUZfVVNFUl9QQVRIfSIKICNjbWFrZWRlZmluZSBLRE1fREVGX1NZU1RFTV9Q QVRIICIke0tETV9ERUZfU1lTVEVNX1BBVEh9Igo= 28418 2008-11-08 18:03:00 +0000 2008-11-08 18:03:00 +0000 KDM ConsoleKit support patch using libck-connector (against trunk/4.1.2, updated) kdebase-workspace-4.1.2-consolekit-kdm.patch text/plain 11392 kevin.kofler ZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2NtYWtlL21vZHVsZXMvRmluZENrQ29u bmVjdG9yLmNtYWtlIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yLWNvbnNvbGVraXQta2RtL2NtYWtl L21vZHVsZXMvRmluZENrQ29ubmVjdG9yLmNtYWtlCi0tLSBrZGViYXNlLXdvcmtzcGFjZS00LjEu Mi9jbWFrZS9tb2R1bGVzL0ZpbmRDa0Nvbm5lY3Rvci5jbWFrZQkxOTcwLTAxLTAxIDAxOjAwOjAw LjAwMDAwMDAwMCArMDEwMAorKysga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1r ZG0vY21ha2UvbW9kdWxlcy9GaW5kQ2tDb25uZWN0b3IuY21ha2UJMjAwOC0xMS0wOCAxNzowOTo0 MS4wMDAwMDAwMDAgKzAxMDAKQEAgLTAsMCArMSw1OSBAQAorIyAtIFRyeSB0byBmaW5kIHRoZSBD b25zb2xlS2l0IGNvbm5lY3RvciBsaWJyYXJ5IChsaWJjay1jb25uZWN0b3IpCisjIE9uY2UgZG9u ZSB0aGlzIHdpbGwgZGVmaW5lCisjCisjICBDS0NPTk5FQ1RPUl9GT1VORCAtIHN5c3RlbSBoYXMg dGhlIENLIENvbm5lY3RvcgorIyAgQ0tDT05ORUNUT1JfSU5DTFVERV9ESVIgLSB0aGUgQ0sgQ29u bmVjdG9yIGluY2x1ZGUgZGlyZWN0b3J5CisjICBDS0NPTk5FQ1RPUl9MSUJSQVJJRVMgLSB0aGUg bGlicmFyaWVzIG5lZWRlZCB0byB1c2UgQ0sgQ29ubmVjdG9yCisKKyMgQ29weXJpZ2h0IChjKSAy MDA4LCBLZXZpbiBLb2ZsZXIsIDxrZXZpbi5rb2ZsZXJAY2hlbGxvLmF0PgorIyBtb2RlbGVkIGFm dGVyIEZpbmRMaWJBcnQuY21ha2U6CisjIENvcHlyaWdodCAoYykgMjAwNiwgQWxleGFuZGVyIE5l dW5kb3JmLCA8bmV1bmRvcmZAa2RlLm9yZz4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp cyBhbGxvd2VkIGFjY29yZGluZyB0byB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorIyBG b3IgZGV0YWlscyBzZWUgdGhlIGFjY29tcGFueWluZyBDT1BZSU5HLUNNQUtFLVNDUklQVFMgZmls ZS4KKworCitpZiAoQ0tDT05ORUNUT1JfSU5DTFVERV9ESVIgQU5EIENLQ09OTkVDVE9SX0xJQlJB UklFUykKKworICAjIGluIGNhY2hlIGFscmVhZHkKKyAgU0VUKENLQ09OTkVDVE9SX0ZPVU5EIFRS VUUpCisKK2Vsc2UgKENLQ09OTkVDVE9SX0lOQ0xVREVfRElSIEFORCBDS0NPTk5FQ1RPUl9MSUJS QVJJRVMpCisKKyAgSUYgKE5PVCBXSU4zMikKKyAgICBGSU5EX1BBQ0tBR0UoUGtnQ29uZmlnKQor ICAgIElGIChQS0dfQ09ORklHX0ZPVU5EKQorICAgICAgIyB1c2UgcGtnLWNvbmZpZyB0byBnZXQg dGhlIGRpcmVjdG9yaWVzIGFuZCB0aGVuIHVzZSB0aGVzZSB2YWx1ZXMKKyAgICAgICMgaW4gdGhl IEZJTkRfUEFUSCgpIGFuZCBGSU5EX0xJQlJBUlkoKSBjYWxscworICAgICAgcGtnX2NoZWNrX21v ZHVsZXMoX0NLQ09OTkVDVE9SX1BDIGNrLWNvbm5lY3RvcikKKyAgICBFTkRJRiAoUEtHX0NPTkZJ R19GT1VORCkKKyAgRU5ESUYgKE5PVCBXSU4zMikKKworICBGSU5EX1BBVEgoQ0tDT05ORUNUT1Jf SU5DTFVERV9ESVIgY2stY29ubmVjdG9yLmgKKyAgICAgJHtfQ0tDT05ORUNUT1JfUENfSU5DTFVE RV9ESVJTfQorICApCisKKyAgRklORF9MSUJSQVJZKENLQ09OTkVDVE9SX0xJQlJBUklFUyBOQU1F UyBjay1jb25uZWN0b3IKKyAgICAgUEFUSFMKKyAgICAgJHtfQ0tDT05ORUNUT1JfUENfTElCRElS fQorICApCisKKworICBpZiAoQ0tDT05ORUNUT1JfSU5DTFVERV9ESVIgQU5EIENLQ09OTkVDVE9S X0xJQlJBUklFUykKKyAgICAgc2V0KENLQ09OTkVDVE9SX0ZPVU5EIFRSVUUpCisgIGVuZGlmIChD S0NPTk5FQ1RPUl9JTkNMVURFX0RJUiBBTkQgQ0tDT05ORUNUT1JfTElCUkFSSUVTKQorCisKKyAg aWYgKENLQ09OTkVDVE9SX0ZPVU5EKQorICAgICBpZiAoTk9UIENrQ29ubmVjdG9yX0ZJTkRfUVVJ RVRMWSkKKyAgICAgICAgbWVzc2FnZShTVEFUVVMgIkZvdW5kIGNrLWNvbm5lY3RvcjogJHtDS0NP Tk5FQ1RPUl9MSUJSQVJJRVN9IikKKyAgICAgZW5kaWYgKE5PVCBDa0Nvbm5lY3Rvcl9GSU5EX1FV SUVUTFkpCisgIGVsc2UgKENLQ09OTkVDVE9SX0ZPVU5EKQorICAgICBpZiAoQ2tDb25uZWN0b3Jf RklORF9SRVFVSVJFRCkKKyAgICAgICAgbWVzc2FnZShGQVRBTF9FUlJPUiAiQ291bGQgTk9UIGZp bmQgY2stY29ubmVjdG9yIikKKyAgICAgZW5kaWYgKENrQ29ubmVjdG9yX0ZJTkRfUkVRVUlSRUQp CisgIGVuZGlmIChDS0NPTk5FQ1RPUl9GT1VORCkKKworICBNQVJLX0FTX0FEVkFOQ0VEKENLQ09O TkVDVE9SX0lOQ0xVREVfRElSIENLQ09OTkVDVE9SX0xJQlJBUklFUykKKworZW5kaWYgKENLQ09O TkVDVE9SX0lOQ0xVREVfRElSIEFORCBDS0NPTk5FQ1RPUl9MSUJSQVJJRVMpCmRpZmYgLU51ciBr ZGViYXNlLXdvcmtzcGFjZS00LjEuMi9jbWFrZS9tb2R1bGVzL0ZpbmREQnVzLmNtYWtlIGtkZWJh c2Utd29ya3NwYWNlLTQuMS4yLWNvbnNvbGVraXQta2RtL2NtYWtlL21vZHVsZXMvRmluZERCdXMu Y21ha2UKLS0tIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2NtYWtlL21vZHVsZXMvRmluZERCdXMu Y21ha2UJMTk3MC0wMS0wMSAwMTowMDowMC4wMDAwMDAwMDAgKzAxMDAKKysrIGtkZWJhc2Utd29y a3NwYWNlLTQuMS4yLWNvbnNvbGVraXQta2RtL2NtYWtlL21vZHVsZXMvRmluZERCdXMuY21ha2UJ MjAwOC0xMS0wOCAxNzoxMDoxNS4wMDAwMDAwMDAgKzAxMDAKQEAgLTAsMCArMSw3MiBAQAorIyAt IFRyeSB0byBmaW5kIHRoZSBsb3ctbGV2ZWwgRC1CdXMgbGlicmFyeQorIyBPbmNlIGRvbmUgdGhp cyB3aWxsIGRlZmluZQorIworIyAgREJVU19GT1VORCAtIHN5c3RlbSBoYXMgRC1CdXMKKyMgIERC VVNfSU5DTFVERV9ESVIgLSB0aGUgRC1CdXMgaW5jbHVkZSBkaXJlY3RvcnkKKyMgIERCVVNfQVJD SF9JTkNMVURFX0RJUiAtIHRoZSBELUJ1cyBhcmNoaXRlY3R1cmUtc3BlY2lmaWMgaW5jbHVkZSBk aXJlY3RvcnkKKyMgIERCVVNfTElCUkFSSUVTIC0gdGhlIGxpYnJhcmllcyBuZWVkZWQgdG8gdXNl IEQtQnVzCisKKyMgQ29weXJpZ2h0IChjKSAyMDA4LCBLZXZpbiBLb2ZsZXIsIDxrZXZpbi5rb2Zs ZXJAY2hlbGxvLmF0PgorIyBtb2RlbGVkIGFmdGVyIEZpbmRMaWJBcnQuY21ha2U6CisjIENvcHly aWdodCAoYykgMjAwNiwgQWxleGFuZGVyIE5ldW5kb3JmLCA8bmV1bmRvcmZAa2RlLm9yZz4KKyMK KyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpcyBhbGxvd2VkIGFjY29yZGluZyB0byB0aGUgdGVy bXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorIyBGb3IgZGV0YWlscyBzZWUgdGhlIGFjY29tcGFueWlu ZyBDT1BZSU5HLUNNQUtFLVNDUklQVFMgZmlsZS4KKworaWYgKERCVVNfSU5DTFVERV9ESVIgQU5E IERCVVNfQVJDSF9JTkNMVURFX0RJUiBBTkQgREJVU19MSUJSQVJJRVMpCisKKyAgIyBpbiBjYWNo ZSBhbHJlYWR5CisgIFNFVChEQlVTX0ZPVU5EIFRSVUUpCisKK2Vsc2UgKERCVVNfSU5DTFVERV9E SVIgQU5EIERCVVNfQVJDSF9JTkNMVURFX0RJUiBBTkQgREJVU19MSUJSQVJJRVMpCisKKyAgSUYg KE5PVCBXSU4zMikKKyAgICBGSU5EX1BBQ0tBR0UoUGtnQ29uZmlnKQorICAgIElGIChQS0dfQ09O RklHX0ZPVU5EKQorICAgICAgIyB1c2UgcGtnLWNvbmZpZyB0byBnZXQgdGhlIGRpcmVjdG9yaWVz IGFuZCB0aGVuIHVzZSB0aGVzZSB2YWx1ZXMKKyAgICAgICMgaW4gdGhlIEZJTkRfUEFUSCgpIGFu ZCBGSU5EX0xJQlJBUlkoKSBjYWxscworICAgICAgcGtnX2NoZWNrX21vZHVsZXMoX0RCVVNfUEMg ZGJ1cy0xKQorICAgIEVORElGIChQS0dfQ09ORklHX0ZPVU5EKQorICBFTkRJRiAoTk9UIFdJTjMy KQorCisgIEZJTkRfUEFUSChEQlVTX0lOQ0xVREVfRElSIGRidXMvZGJ1cy5oCisgICAgJHtfREJV U19QQ19JTkNMVURFX0RJUlN9CisgICAgL3Vzci9pbmNsdWRlCisgICAgL3Vzci9pbmNsdWRlL2Ri dXMtMS4wCisgICAgL3Vzci9sb2NhbC9pbmNsdWRlCisgICkKKworICBGSU5EX1BBVEgoREJVU19B UkNIX0lOQ0xVREVfRElSIGRidXMvZGJ1cy1hcmNoLWRlcHMuaAorICAgICR7X0RCVVNfUENfSU5D TFVERV9ESVJTfQorICAgIC91c3IvbGliJHtMSUJfU1VGRklYfS9pbmNsdWRlCisgICAgL3Vzci9s aWIke0xJQl9TVUZGSVh9L2RidXMtMS4wL2luY2x1ZGUKKyAgICAvdXNyL2xpYjY0L2luY2x1ZGUK KyAgICAvdXNyL2xpYjY0L2RidXMtMS4wL2luY2x1ZGUKKyAgICAvdXNyL2xpYi9pbmNsdWRlCisg ICAgL3Vzci9saWIvZGJ1cy0xLjAvaW5jbHVkZQorICApCisKKyAgRklORF9MSUJSQVJZKERCVVNf TElCUkFSSUVTIE5BTUVTIGRidXMtMSBkYnVzCisgICAgUEFUSFMKKyAgICAgJHtfREJVU19QQ19M SUJESVJ9CisgICkKKworCisgIGlmIChEQlVTX0lOQ0xVREVfRElSIEFORCBEQlVTX0FSQ0hfSU5D TFVERV9ESVIgQU5EIERCVVNfTElCUkFSSUVTKQorICAgICBzZXQoREJVU19GT1VORCBUUlVFKQor ICBlbmRpZiAoREJVU19JTkNMVURFX0RJUiBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSIEFORCBE QlVTX0xJQlJBUklFUykKKworCisgIGlmIChEQlVTX0ZPVU5EKQorICAgICBpZiAoTk9UIERCdXNf RklORF9RVUlFVExZKQorICAgICAgICBtZXNzYWdlKFNUQVRVUyAiRm91bmQgRC1CdXM6ICR7REJV U19MSUJSQVJJRVN9IikKKyAgICAgZW5kaWYgKE5PVCBEQnVzX0ZJTkRfUVVJRVRMWSkKKyAgZWxz ZSAoREJVU19GT1VORCkKKyAgICAgaWYgKERCdXNfRklORF9SRVFVSVJFRCkKKyAgICAgICAgbWVz c2FnZShGQVRBTF9FUlJPUiAiQ291bGQgTk9UIGZpbmQgRC1CdXMiKQorICAgICBlbmRpZiAoREJ1 c19GSU5EX1JFUVVJUkVEKQorICBlbmRpZiAoREJVU19GT1VORCkKKworICBNQVJLX0FTX0FEVkFO Q0VEKERCVVNfSU5DTFVERV9ESVIgREJVU19BUkNIX0lOQ0xVREVfRElSIERCVVNfTElCUkFSSUVT KQorCitlbmRpZiAoREJVU19JTkNMVURFX0RJUiBBTkQgREJVU19BUkNIX0lOQ0xVREVfRElSIEFO RCBEQlVTX0xJQlJBUklFUykKZGlmZiAtTnVyIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yL2tkbS9i YWNrZW5kL2NsaWVudC5jIGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yLWNvbnNvbGVraXQta2RtL2tk bS9iYWNrZW5kL2NsaWVudC5jCi0tLSBrZGViYXNlLXdvcmtzcGFjZS00LjEuMi9rZG0vYmFja2Vu ZC9jbGllbnQuYwkyMDA4LTA1LTA3IDExOjA1OjI2LjAwMDAwMDAwMCArMDIwMAorKysga2RlYmFz ZS13b3Jrc3BhY2UtNC4xLjItY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQvY2xpZW50LmMJMjAw OC0xMS0wOCAxNzoyNzo1NC4wMDAwMDAwMDAgKzAxMDAKQEAgLTc3LDYgKzc3LDEwIEBACiAvKiBm b3IgZXhwaXJhdGlvbiAqLwogIyBpbmNsdWRlIDx0aW1lLmg+CiAjZW5kaWYgLyogVVNFX1BBTSB8 fCBfQUlYICovCisjaWZkZWYgSEFWRV9DS0NPTk5FQ1RPUgorIyBpbmNsdWRlIDxjay1jb25uZWN0 b3IuaD4KKyMgaW5jbHVkZSA8ZGJ1cy9kYnVzLmg+CisjZW5kaWYKICNpZmRlZiBIQVZFX0dFVFNQ TkFNCiAjIGluY2x1ZGUgPHNoYWRvdy5oPgogI2VuZGlmCkBAIC0xMTQ5LDYgKzExNTMsMTAgQEAK IHN0YXRpYyBpbnQgcmVtb3ZlU2Vzc2lvbjsKIHN0YXRpYyBpbnQgcmVtb3ZlQ3JlZHM7CiAjZW5k aWYKKyNpZmRlZiBIQVZFX0NLQ09OTkVDVE9SCitzdGF0aWMgY29uc3QgY2hhciAqY2tTZXNzaW9u Q29va2llOworc3RhdGljIENrQ29ubmVjdG9yICpjb25uZWN0b3I7CisjZW5kaWYKIAogc3RhdGlj IEdQaXBlIGN0bHBpcGU7CiBzdGF0aWMgR1RhbGsgY3RsdGFsazsKQEAgLTExOTgsNiArMTIwNiwx NSBAQAogCWV4dGVybiBjaGFyICoqbmV3ZW52OyAvKiBmcm9tIGxpYnMuYSwgdGhpcyBpcyBzZXQg dXAgYnkgc2V0cGVudiAqLwogIyBlbmRpZgogI2VuZGlmCisjaWZkZWYgSEFWRV9DS0NPTk5FQ1RP UgorCURCdXNFcnJvciBlcnJvcjsKKwljaGFyIGRldmljZUJ1ZlsyMF0gPSAiIjsKKwljaGFyICpk ZXZpY2UgPSBkZXZpY2VCdWY7CisJZGJ1c19ib29sX3QgaXNMb2NhbDsKKyNpZmRlZiBYRE1DUAor CWNvbnN0IGNoYXIgKnJlbW90ZUhvc3ROYW1lID0gIiI7CisjZW5kaWYKKyNlbmRpZgogCWNoYXIg KmZhaWxzYWZlQXJndlsyXTsKIAljaGFyICpidWYsICpidWYyOwogCWludCBpOwpAQCAtMTIxNiw2 ICsxMjMzLDUwIEBACiAJfQogI2VuZGlmCiAKKyNpZmRlZiBIQVZFX0NLQ09OTkVDVE9SCisjaWZk ZWYgSEFWRV9WVFMKKwlpZiAodGQtPnNlcnZlclZUID4gMCkgeworCQkvKiBGSVhNRTogaG93IGRv ZXMgeG9yZyBjb25zdHJ1Y3QgdGhpcyAqLworCQlzcHJpbnRmKCBkZXZpY2UsICIvZGV2L3R0eSVk IiwgdGQtPnNlcnZlclZUICk7CisJfQkKKyNlbmRpZgorCisJY29ubmVjdG9yID0gY2tfY29ubmVj dG9yX25ldygpOworCWlmIChjb25uZWN0b3IpIHsKKwkJaXNMb2NhbCA9ICgodGQtPmRpc3BsYXlU eXBlICYgZF9sb2NhdGlvbikgPT0gZExvY2FsKTsKKyNpZmRlZiBYRE1DUAorCQkvKiA/Pz8gdGQt PnJlbW90ZUhvc3QgY2FuIGJlIE5VTEwgZXZlbiBpZiBub3QgbG9jYWwuIFNlZQorCQkgICBodHRw Oi8vYnVncy5kZWJpYW4ub3JnL2NnaS1iaW4vYnVncmVwb3J0LmNnaT9idWc9NDU3NDg3ICovCisJ CWlmICghaXNMb2NhbCAmJiB0ZC0+cmVtb3RlSG9zdCkKKwkJCXJlbW90ZUhvc3ROYW1lID0gdGQt PnJlbW90ZUhvc3Q7CisjZW5kaWYKKworCQlkYnVzX2Vycm9yX2luaXQoICZlcnJvciApOworCQlp ZiAoIWNrX2Nvbm5lY3Rvcl9vcGVuX3Nlc3Npb25fd2l0aF9wYXJhbWV0ZXJzKCBjb25uZWN0b3Is CisJCQkmZXJyb3IsICJ1bml4LXVzZXIiLCAmKHAtPnB3X3VpZCksCisJCQkieDExLWRpc3BsYXkt ZGV2aWNlIiwgJmRldmljZSwKKwkJCSJ4MTEtZGlzcGxheSIsICYodGQtPm5hbWUpLAorCQkJImlz LWxvY2FsIiwgJmlzTG9jYWwsCisjaWZkZWYgWERNQ1AKKwkJCSJyZW1vdGUtaG9zdC1uYW1lIiwg JnJlbW90ZUhvc3ROYW1lLAorI2VuZGlmCisJCQlOVUxMICkpIHsKKwkJCWlmIChkYnVzX2Vycm9y X2lzX3NldCggJmVycm9yICkpIHsKKwkJCQlsb2dFcnJvciggIkNvbnNvbGVLaXQgb3BlbjogJXNc biIsIGVycm9yLm1lc3NhZ2UgKTsKKwkJCQlkYnVzX2Vycm9yX2ZyZWUoICZlcnJvciApOworCQkJ fSBlbHNlIHsKKwkJCQlsb2dFcnJvciggImNhbm5vdCBvcGVuIENvbnNvbGVLaXQgc2Vzc2lvblxu IiApOworCQkJfQorCQkJY2tfY29ubmVjdG9yX3VucmVmKCBjb25uZWN0b3IgKTsKKwkJCVZfUkVU OworCQl9CisJfSBlbHNlIHsKKwkJZGVidWcoICJPT00gY3JlYXRpbmcgQ2tDb25uZWN0b3JcbiIg KTsKKwkJVl9SRVQ7CisJfQorCWNrU2Vzc2lvbkNvb2tpZSA9IGNrX2Nvbm5lY3Rvcl9nZXRfY29v a2llKCBjb25uZWN0b3IgKTsKKyNlbmRpZgorCiAJc3RyY3B5KCBjdXJ1c2VyLCBwLT5wd19uYW1l ICk7IC8qIFVzZSBub3JtYWxpemVkIGxvZ2luIG5hbWUuICovCiAKICNpZm5kZWYgVVNFX1BBTQpA QCAtMTI2OSw2ICsxMzMwLDEwIEBACiAJaWYgKGtyYnRrZmlsZVswXSAhPSAnXDAnKQogCQllbnYg PSBzZXRFbnYoIGVudiwgIktSQlRLRklMRSIsIGtyYnRrZmlsZSApOwogI2VuZGlmCisjaWZkZWYg SEFWRV9DS0NPTk5FQ1RPUgorCWlmIChja1Nlc3Npb25Db29raWUpCisJCWVudiA9IHNldEVudigg ZW52LCAiWERHX1NFU1NJT05fQ09PS0lFIiwgY2tTZXNzaW9uQ29va2llICk7CisjZW5kaWYKIAl1 c2VyRW52aXJvbiA9IGluaGVyaXRFbnYoIGVudiwgZW52dmFycyApOwogCWVudiA9IHN5c3RlbUVu diggMCwgY3VydXNlciApOwogCXN5c3RlbUVudmlyb24gPSBzZXRFbnYoIGVudiwgIkhPTUUiLCBw LT5wd19kaXIgKTsKQEAgLTE2ODUsNiArMTc1MCw5IEBACiAjaWZkZWYgVVNFX1BBTQogCWludCBw cmV0YzsKICNlbmRpZgorI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKwlEQnVzRXJyb3IgZXJyb3I7 CisjZW5kaWYKIAogCWlmIChyZW1vdmVBdXRoKSB7CiAJCXN3aXRjaCAoc291cmNlKCBzeXN0ZW1F bnZpcm9uLCB0ZC0+cmVzZXQsIHRkX3NldHVwICkpIHsKQEAgLTE3NTksNiArMTgyNywyMyBAQAog CQlwYW1oID0gMDsKIAl9CiAjZW5kaWYKKworI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKwkvKiBj bG9zZSBDb25zb2xlS2l0IHNlc3Npb24gKi8KKwlpZiAoY2tTZXNzaW9uQ29va2llKSB7CisJCWRi dXNfZXJyb3JfaW5pdCggJmVycm9yICk7CisJCWlmICghY2tfY29ubmVjdG9yX2Nsb3NlX3Nlc3Np b24oIGNvbm5lY3RvciwgJmVycm9yICkpIHsKKwkJCWlmIChkYnVzX2Vycm9yX2lzX3NldCggJmVy cm9yICkpIHsKKwkJCQlsb2dFcnJvciggIkNvbnNvbGVLaXQgY2xvc2U6ICVzXG4iLCBlcnJvci5t ZXNzYWdlICk7CisJCQkJZGJ1c19lcnJvcl9mcmVlKCAmZXJyb3IgKTsKKwkJCX0gZWxzZSB7CisJ CQkJbG9nRXJyb3IoICJjYW5ub3QgY2xvc2UgQ29uc29sZUtpdCBzZXNzaW9uXG4iICk7CisJCQl9 CisJCX0KKwkJY2tfY29ubmVjdG9yX3VucmVmKCBjb25uZWN0b3IgKTsKKwkJY2tTZXNzaW9uQ29v a2llID0gTlVMTDsKKwl9CisjZW5kaWYKIH0KIAogdm9pZApkaWZmIC1OdXIga2RlYmFzZS13b3Jr c3BhY2UtNC4xLjIva2RtL2JhY2tlbmQvQ01ha2VMaXN0cy50eHQga2RlYmFzZS13b3Jrc3BhY2Ut NC4xLjItY29uc29sZWtpdC1rZG0va2RtL2JhY2tlbmQvQ01ha2VMaXN0cy50eHQKLS0tIGtkZWJh c2Utd29ya3NwYWNlLTQuMS4yL2tkbS9iYWNrZW5kL0NNYWtlTGlzdHMudHh0CTIwMDgtMDUtMjkg MTM6MTk6MDEuMDAwMDAwMDAwICswMjAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjEuMi1jb25z b2xla2l0LWtkbS9rZG0vYmFja2VuZC9DTWFrZUxpc3RzLnR4dAkyMDA4LTExLTA4IDE3OjAzOjM3 LjAwMDAwMDAwMCArMDEwMApAQCAtNjAsNiArNjAsMTAgQEAKIAkke1NPQ0tFVF9MSUJSQVJJRVN9 CiAJJHtSRVNPTFZfTElCUkFSSUVTfQogKQoraWYgKENLQ09OTkVDVE9SX0ZPVU5EKQorCWluY2x1 ZGVfZGlyZWN0b3JpZXMoJHtDS0NPTk5FQ1RPUl9JTkNMVURFX0RJUn0gJHtEQlVTX0lOQ0xVREVf RElSfSAke0RCVVNfQVJDSF9JTkNMVURFX0RJUn0pCisJdGFyZ2V0X2xpbmtfbGlicmFyaWVzKCBr ZG0gJHtDS0NPTk5FQ1RPUl9MSUJSQVJJRVN9ICR7REJVU19MSUJSQVJJRVN9ICkKK2VuZGlmIChD S0NPTk5FQ1RPUl9GT1VORCkKIGlmKFVUSUxfTElCUkFSSUVTKQogCXRhcmdldF9saW5rX2xpYnJh cmllcygga2RtICR7VVRJTF9MSUJSQVJJRVN9ICkKIGVuZGlmKFVUSUxfTElCUkFSSUVTKQpkaWZm IC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIva2RtL2JhY2tlbmQveGRtY3AuYyBrZGViYXNl LXdvcmtzcGFjZS00LjEuMi1jb25zb2xla2l0LWtkbS9rZG0vYmFja2VuZC94ZG1jcC5jCi0tLSBr ZGViYXNlLXdvcmtzcGFjZS00LjEuMi9rZG0vYmFja2VuZC94ZG1jcC5jCTIwMDgtMDEtMDUgMDA6 NTU6NDQuMDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNlLXdvcmtzcGFjZS00LjEuMi1jb25zb2xl a2l0LWtkbS9rZG0vYmFja2VuZC94ZG1jcC5jCTIwMDgtMTEtMDcgMDA6NTQ6MjMuMDAwMDAwMDAw ICswMTAwCkBAIC0xMDE2LDYgKzEwMTYsOCBAQAogCQkJZC0+Y2xpZW50QWRkciA9IGNsaWVudEFk ZHJlc3M7CiAJCQlkLT5jbGllbnRQb3J0ID0gY2xpZW50UG9ydDsKIAkJCWQtPmNvbm5lY3Rpb25U eXBlID0gY29ubmVjdGlvblR5cGU7CisJCQlkLT5yZW1vdGVIb3N0ID0gbmV0d29ya0FkZHJlc3NU b0hvc3RuYW1lKCBwZHB5LT5jb25uZWN0aW9uVHlwZSwKKwkJCQkmcGRweS0+Y29ubmVjdGlvbkFk ZHJlc3MgKTsKIAkJCWlmIChwZHB5LT5maWxlQXV0aG9yaXphdGlvbikgewogCQkJCWQtPmF1dGhv cml6YXRpb25zID0gKFhhdXRoICoqKU1hbGxvYyggc2l6ZW9mKFhhdXRoICopICk7CiAJCQkJaWYg KCFkLT5hdXRob3JpemF0aW9ucykgewpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIv a2RtL0NNYWtlTGlzdHMudHh0IGtkZWJhc2Utd29ya3NwYWNlLTQuMS4yLWNvbnNvbGVraXQta2Rt L2tkbS9DTWFrZUxpc3RzLnR4dAotLS0ga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIva2RtL0NNYWtl TGlzdHMudHh0CTIwMDgtMDItMDcgMTQ6MTk6NTEuMDAwMDAwMDAwICswMTAwCisrKyBrZGViYXNl LXdvcmtzcGFjZS00LjEuMi1jb25zb2xla2l0LWtkbS9rZG0vQ01ha2VMaXN0cy50eHQJMjAwOC0x MS0wNyAwMDoxNTozMS4wMDAwMDAwMDAgKzAxMDAKQEAgLTQsNiArNCwxNyBAQAogaW5zdGFsbF9w YW1fc2VydmljZShLRE0pCiAKIGluY2x1ZGUoQ29uZmlndXJlQ2hlY2tzLmNtYWtlKQorCittYWNy b19vcHRpb25hbF9maW5kX3BhY2thZ2UoQ2tDb25uZWN0b3IpCitpZihDS0NPTk5FQ1RPUl9GT1VO RCkKKyAgIyB3aGVuIGJ1aWxkaW5nIHdpdGggbGliY2stY29ubmVjdG9yLCB3ZSBhbHNvIG5lZWQg dGhlIGxvdy1sZXZlbCBELUJ1cyBBUEkKKyAgZmluZF9wYWNrYWdlKERCdXMgUkVRVUlSRUQpCitl bmRpZihDS0NPTk5FQ1RPUl9GT1VORCkKKworbWFjcm9fbG9nX2ZlYXR1cmUoQ0tDT05ORUNUT1Jf Rk9VTkQgImNrLWNvbm5lY3RvciIgIlRoZSBDb25zb2xlS2l0IGNvbm5lY3RvciBsaWJyYXJ5IiAi aHR0cDovL2ZyZWVkZXNrdG9wLm9yZy93aWtpL1NvZnR3YXJlL0NvbnNvbGVLaXQiIEZBTFNFICIi ICJQcm92aWRlcyBDb25zb2xlS2l0IGludGVncmF0aW9uIGluIEtETSIpCisKK21hY3JvX2Jvb2xf dG9fMDEoQ0tDT05ORUNUT1JfRk9VTkQgSEFWRV9DS0NPTk5FQ1RPUikKKwogY29uZmlndXJlX2Zp bGUoY29uZmlnLWtkbS5oLmNtYWtlICR7Q01BS0VfQ1VSUkVOVF9CSU5BUllfRElSfS9jb25maWct a2RtLmgpCiAKIGluc3RhbGwoIEZJTEVTIFJFQURNRSBERVNUSU5BVElPTiAke0RBVEFfSU5TVEFM TF9ESVJ9L2RvYy9rZG0gKQpkaWZmIC1OdXIga2RlYmFzZS13b3Jrc3BhY2UtNC4xLjIva2RtL2Nv bmZpZy1rZG0uaC5jbWFrZSBrZGViYXNlLXdvcmtzcGFjZS00LjEuMi1jb25zb2xla2l0LWtkbS9r ZG0vY29uZmlnLWtkbS5oLmNtYWtlCi0tLSBrZGViYXNlLXdvcmtzcGFjZS00LjEuMi9rZG0vY29u ZmlnLWtkbS5oLmNtYWtlCTIwMDgtMDEtMDUgMDA6NTU6NDUuMDAwMDAwMDAwICswMTAwCisrKyBr ZGViYXNlLXdvcmtzcGFjZS00LjEuMi1jb25zb2xla2l0LWtkbS9rZG0vY29uZmlnLWtkbS5oLmNt YWtlCTIwMDgtMTEtMDcgMDA6MTU6MzEuMDAwMDAwMDAwICswMTAwCkBAIC0xMjMsNiArMTIzLDkg QEAKIC8qIERlZmluZSB0byAxIGlmIHlvdSBoYXZlIHRoZSA8dGVybWlvcy5oPiBoZWFkZXIgZmls ZS4gKi8KICNjbWFrZWRlZmluZSBIQVZFX1RFUk1JT1NfSCAxCiAKKy8qIERlZmluZSB0byAxIGlm IHRoZSBjay1jb25uZWN0b3IgbGlicmFyeSBpcyBmb3VuZCAqLworI2NtYWtlZGVmaW5lIEhBVkVf Q0tDT05ORUNUT1IgMQorCiAvKiAkUEFUSCBkZWZhdWx0cyBzZXQgYnkgS0RNICovCiAjY21ha2Vk ZWZpbmUgS0RNX0RFRl9VU0VSX1BBVEggIiR7S0RNX0RFRl9VU0VSX1BBVEh9IgogI2NtYWtlZGVm aW5lIEtETV9ERUZfU1lTVEVNX1BBVEggIiR7S0RNX0RFRl9TWVNURU1fUEFUSH0iCg== 28549 2008-11-13 21:05:08 +0000 2008-11-13 21:05:08 +0000 fixed partial patch _kdm_ck_part.diff text/plain 3793 ossi SW5kZXg6IGNsaWVudC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNsaWVudC5jCShyZXZpc2lvbiA4ODM4MTIp CisrKyBjbGllbnQuYwkod29ya2luZyBjb3B5KQpAQCAtNzcsNiArNzcsMTAgQEAgZXh0ZXJuIGlu dCBsb2dpbnN1Y2Nlc3MoIGNvbnN0IGNoYXIgKlVzZQogLyogZm9yIGV4cGlyYXRpb24gKi8KICMg aW5jbHVkZSA8dGltZS5oPgogI2VuZGlmIC8qIFVTRV9QQU0gfHwgX0FJWCAqLworI2lmZGVmIEhB VkVfQ0tDT05ORUNUT1IKKyMgaW5jbHVkZSA8Y2stY29ubmVjdG9yLmg+CisjIGluY2x1ZGUgPGRi dXMvZGJ1cy5oPgorI2VuZGlmCiAjaWZkZWYgSEFWRV9HRVRTUE5BTQogIyBpbmNsdWRlIDxzaGFk b3cuaD4KICNlbmRpZgpAQCAtMTE0OSw2ICsxMTUzLDkgQEAgc3RhdGljIGludCByZW1vdmVBdXRo Owogc3RhdGljIGludCByZW1vdmVTZXNzaW9uOwogc3RhdGljIGludCByZW1vdmVDcmVkczsKICNl bmRpZgorI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKK3N0YXRpYyBDa0Nvbm5lY3RvciAqY2tDb25u ZWN0b3I7CisjZW5kaWYKIAogc3RhdGljIEdQaXBlIGN0bHBpcGU7CiBzdGF0aWMgR1RhbGsgY3Rs dGFsazsKQEAgLTExOTgsNiArMTIwNSwxNyBAQCBzdGFydENsaWVudCggdm9sYXRpbGUgaW50ICpw aWQgKQogCWV4dGVybiBjaGFyICoqbmV3ZW52OyAvKiBmcm9tIGxpYnMuYSwgdGhpcyBpcyBzZXQg dXAgYnkgc2V0cGVudiAqLwogIyBlbmRpZgogI2VuZGlmCisjaWZkZWYgSEFWRV9DS0NPTk5FQ1RP UgorCURCdXNFcnJvciBlcnJvcjsKKwlpbnQgY2tTdGF0dXM7CisjIGlmZGVmIFhETUNQCisJY2hh ciAqcmVtb3RlSG9zdE5hbWUgPSAwOworCWNvbnN0IGNoYXIgKnNwYWNlU3RyID0gIiI7CisjIGVu ZGlmCisJY2hhciBja0RldmljZUJ1ZlsyMF0gPSAiIjsKKwljb25zdCBjaGFyICpja0RldmljZSA9 IGNrRGV2aWNlQnVmOworCWRidXNfYm9vbF90IGlzTG9jYWw7CisjZW5kaWYKIAljaGFyICpmYWls c2FmZUFyZ3ZbMl07CiAJY2hhciAqYnVmLCAqYnVmMjsKIAlpbnQgaTsKQEAgLTEyMTgsNiArMTIz Niw1OSBAQCBzdGFydENsaWVudCggdm9sYXRpbGUgaW50ICpwaWQgKQogCiAJc3RyY3B5KCBjdXJ1 c2VyLCBwLT5wd19uYW1lICk7IC8qIFVzZSBub3JtYWxpemVkIGxvZ2luIG5hbWUuICovCiAKKyNp ZmRlZiBIQVZFX0NLQ09OTkVDVE9SCisJaWYgKCEoY2tDb25uZWN0b3IgPSBja19jb25uZWN0b3Jf bmV3KCkpKSB7CisJCWxvZ09PTSgpOworCQlWX1JFVDsKKwl9CisJCisjIGlmZGVmIEhBVkVfVlRT CisJaWYgKHRkLT5zZXJ2ZXJWVCA+IDApCisJCXNwcmludGYoIGNrRGV2aWNlQnVmLCAiL2Rldi90 dHklZCIsIHRkLT5zZXJ2ZXJWVCApOworIyBlbmRpZgorCWlzTG9jYWwgPSAoKHRkLT5kaXNwbGF5 VHlwZSAmIGRfbG9jYXRpb24pID09IGRMb2NhbCk7CisjIGlmZGVmIFhETUNQCisJaWYgKCFpc0xv Y2FsKSB7CisJCWludCBsZW5ndGgsIGZhbWlseTsKKwkJQ0FSRDggKmRhdGE7CisJCUFSUkFZOCBh ZGRyOworCisJCWZhbWlseSA9IGNvbnZlcnRBZGRyKCAoWGRtY3BOZXRhZGRyKXRzLT5wZWVyLCAm bGVuZ3RoLCAmZGF0YSApOworCQlhZGRyLmRhdGEgPSAodW5zaWduZWQgY2hhciAqKWRhdGE7CisJ CWFkZHIubGVuZ3RoID0gbGVuZ3RoOworCisJCS8qIFdlIGFyZSBub3Qgc2ltcGx5IHVzaW5nIHRo ZSBhZGRyIHBhcnQgb2YgdGQtPm5hbWUgYXMgaXQgbWlnaHQgYmUKKwkJICAgbnVtZXJpYyBkdWUg dG8gdGhlIFNvdXJjZUFkZHJlc3Mgc2V0dGluZ3MgKi8KKwkJcmVtb3RlSG9zdE5hbWUgPSBuZXR3 b3JrQWRkcmVzc1RvSG9zdG5hbWUoZmFtaWx5LCAmYWRkcik7CisJfQorIyBlbmRpZgorCisJZGJ1 c19lcnJvcl9pbml0KCAmZXJyb3IgKTsKKwlja1N0YXR1cyA9IGNrX2Nvbm5lY3Rvcl9vcGVuX3Nl c3Npb25fd2l0aF9wYXJhbWV0ZXJzKCBja0Nvbm5lY3RvciwgJmVycm9yLAorCQkJInVuaXgtdXNl ciIsICZwLT5wd191aWQsCisJCQkieDExLWRpc3BsYXktZGV2aWNlIiwgJmNrRGV2aWNlLAorCQkJ IngxMS1kaXNwbGF5IiwgJnRkLT5uYW1lLAorCQkJImlzLWxvY2FsIiwgJmlzTG9jYWwsIC8qIG1l YW5pbmcgbm90IGVudGlyZWx5IGNsZWFyIHBlciBkb2MgKi8KKyMgaWZkZWYgWERNQ1AKKwkJCSJy ZW1vdGUtaG9zdC1uYW1lIiwgcmVtb3RlSG9zdE5hbWUgPyAmcmVtb3RlSG9zdE5hbWUgOiAmc3Bh Y2VTdHIsCisjIGVuZGlmCisJCQlOVUxMICk7CisjIGlmZGVmIFhETUNQCisJaWYgKHJlbW90ZUhv c3ROYW1lKQorCQlmcmVlKCByZW1vdGVIb3N0TmFtZSApOworIyBlbmRpZgorCWlmICghY2tTdGF0 dXMpIHsKKwkJaWYgKGRidXNfZXJyb3JfaXNfc2V0KCAmZXJyb3IgKSkgeworCQkJbG9nRXJyb3Io ICJDYW5ub3Qgb3BlbiBDb25zb2xlS2l0IHNlc3Npb246ICVzXG4iLCBlcnJvci5tZXNzYWdlICk7 CisJCQlkYnVzX2Vycm9yX2ZyZWUoICZlcnJvciApOworCQl9IGVsc2UgeworCQkJbG9nRXJyb3Io ICJDYW5ub3Qgb3BlbiBDb25zb2xlS2l0IHNlc3Npb24sIGxpa2VseSBPT01cbiIgKTsKKwkJfQor CQlja19jb25uZWN0b3JfdW5yZWYoIGNrQ29ubmVjdG9yICk7CisJCVZfUkVUOworCX0KKyNlbmRp ZgorCiAjaWZuZGVmIFVTRV9QQU0KICMgaWZkZWYgX0FJWAogCW1zZyA9IE5VTEw7CkBAIC0xMjY5 LDYgKzEzNDAsOSBAQCBzdGFydENsaWVudCggdm9sYXRpbGUgaW50ICpwaWQgKQogCWlmIChrcmJ0 a2ZpbGVbMF0gIT0gJ1wwJykKIAkJZW52ID0gc2V0RW52KCBlbnYsICJLUkJUS0ZJTEUiLCBrcmJ0 a2ZpbGUgKTsKICNlbmRpZgorI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKwllbnYgPSBzZXRFbnYo IGVudiwgIlhER19TRVNTSU9OX0NPT0tJRSIsIGNrX2Nvbm5lY3Rvcl9nZXRfY29va2llKCBja0Nv bm5lY3RvciApICk7CisjZW5kaWYKIAl1c2VyRW52aXJvbiA9IGluaGVyaXRFbnYoIGVudiwgZW52 dmFycyApOwogCWVudiA9IHN5c3RlbUVudiggMCwgY3VydXNlciApOwogCXN5c3RlbUVudmlyb24g PSBzZXRFbnYoIGVudiwgIkhPTUUiLCBwLT5wd19kaXIgKTsKQEAgLTE2ODUsNiArMTc1OSw5IEBA IGNsaWVudEV4aXRlZCggdm9pZCApCiAjaWZkZWYgVVNFX1BBTQogCWludCBwcmV0YzsKICNlbmRp ZgorI2lmZGVmIEhBVkVfQ0tDT05ORUNUT1IKKwlEQnVzRXJyb3IgZXJyb3I7CisjZW5kaWYKIAog CWlmIChyZW1vdmVBdXRoKSB7CiAJCXN3aXRjaCAoc291cmNlKCBzeXN0ZW1FbnZpcm9uLCB0ZC0+ cmVzZXQsIHRkX3NldHVwICkpIHsKQEAgLTE3NTksNiArMTgzNiwyMiBAQCBjbGllbnRFeGl0ZWQo IHZvaWQgKQogCQlwYW1oID0gMDsKIAl9CiAjZW5kaWYKKworI2lmZGVmIEhBVkVfQ0tDT05ORUNU T1IKKwlpZiAoY2tDb25uZWN0b3IpIHsKKwkJZGJ1c19lcnJvcl9pbml0KCAmZXJyb3IgKTsKKwkJ aWYgKCFja19jb25uZWN0b3JfY2xvc2Vfc2Vzc2lvbiggY2tDb25uZWN0b3IsICZlcnJvciApKSB7 CisJCQlpZiAoZGJ1c19lcnJvcl9pc19zZXQoICZlcnJvciApKSB7CisJCQkJbG9nRXJyb3IoICJD YW5ub3QgY2xvc2UgQ29uc29sZUtpdCBzZXNzaW9uOiAlc1xuIiwgZXJyb3IubWVzc2FnZSApOwor CQkJCWRidXNfZXJyb3JfZnJlZSggJmVycm9yICk7CisJCQl9IGVsc2UgeworCQkJCWxvZ0Vycm9y KCAiQ2Fubm90IGNsb3NlIENvbnNvbGVLaXQgc2Vzc2lvbiwgbGlrZWx5IE9PTVxuIiApOworCQkJ fQorCQl9CisJCWNrX2Nvbm5lY3Rvcl91bnJlZiggY2tDb25uZWN0b3IgKTsKKwkJY2tDb25uZWN0 b3IgPSAwOworCX0KKyNlbmRpZgogfQogCiB2b2lkCg==