From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 24146 invoked by alias); 13 Dec 2011 15:29:31 -0000 Received: (qmail 24127 invoked by uid 22791); 13 Dec 2011 15:29:26 -0000 X-SWARE-Spam-Status: No, hits=-2.1 required=5.0 tests=AWL,BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,RCVD_IN_DNSWL_LOW,TW_BJ X-Spam-Check-By: sourceware.org Received: from mail-vx0-f169.google.com (HELO mail-vx0-f169.google.com) (209.85.220.169) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 13 Dec 2011 15:29:09 +0000 Received: by vcbfk26 with SMTP id fk26so5710076vcb.0 for ; Tue, 13 Dec 2011 07:29:08 -0800 (PST) Received: by 10.220.149.200 with SMTP id u8mr1841176vcv.35.1323790148269; Tue, 13 Dec 2011 07:29:08 -0800 (PST) MIME-Version: 1.0 Received: by 10.220.4.210 with HTTP; Tue, 13 Dec 2011 07:28:47 -0800 (PST) In-Reply-To: References: From: Kevin Pouget Date: Tue, 13 Dec 2011 15:55:00 -0000 Message-ID: Subject: Re: [PATCH] Add bp_location to Python interface To: pmuldoon@redhat.com Cc: gdb-patches@sourceware.org Content-Type: multipart/mixed; boundary=f46d043c821c8b77d904b3fae9b5 X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2011-12/txt/msg00405.txt.bz2 --f46d043c821c8b77d904b3fae9b5 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-length: 15895 On Fri, Dec 9, 2011 at 3:10 PM, Phil Muldoon wrote: > Kevin Pouget writes: > >> On Thu, Dec 8, 2011 at 3:28 PM, Phil Muldoon wrote: >> > >>>> +A breakpoint location is represented with a @code{gdb.BpLocation} obj= ect, >>>> +which offers the following attributes (all read only) and methods. >>>> +Please note that breakpoint locations are very transient entities in >>>> +@value{GDBN}, so one should avoid keeping references to them. >> >>> >>> While it is good to note that, I'm not sure =A0what we are explaining h= ere >>> other than when the breakpoint is deleted, all location objects that are >>> associated with that object are invalid too. =A0Or, are you noting we >>> should allow the user to interact after the fact? If that is the case, >>> what is "is_valid" for? =A0Why note the transient nature of the object? >> >>> I'm not sure what we are explaining here other than when the breakpoint= is deleted >> >> that's what I wanted to emphasize here, bp_locations are cleaned/reset >> more often than 'high-level' breakpoints are removed. My knowledge >> about that is quite limited, but for instance this (cleaned up) stack: >> >> #0 =A0gdbpy_bplocation_free py-bploc.c:60 >> #1 =A0free_bp_location (loc=3D) breakpoint.c:5685 >> #2 =A0decref_bp_location (blp=3D) breakpoint.c:5707 >> #3 =A0update_global_location_list (should_insert=3D1) =A0breakpoint.c:10= 575 >> #4 =A0update_breakpoint_locations (b=3D, sals=3D..., =A0 =A0 sals_end=3D= ...) >> breakpoint.c:11787 >> #5 =A0breakpoint_re_set_default (b=3D) breakpoint.c:11937 >> #6 =A0breakpoint_re_set_one (bint=3D) breakpoint.c:11968 >> #8 =A0breakpoint_re_set () breakpoint.c:11992 >> #9 =A0solib_add (pattern=3D0x0, from_tty=3D0, target=3D, =A0readsyms=3D1= ) solib.c:926 >> #10 bpstat_what (bs_head=3D) breakpoint.c:4487 >> #11 handle_inferior_event (ecs=3D) infrun.c:4394 >> #12 wait_for_inferior () >> >> shows that bplocations might be removed when a shared library is loaded > > Good point, I did not think of this scenario. =A0Looking at several > sections of GDB code, update_global_location_list can just be called > whenever. > >>> If the breakpoint is deleted and the user still has reference to a >>> location object, I think we should just run a validation routine and >>> refuse to do anything but raise an exception at that point (like >>> is_valid, but triggered for all function/attribute calls). >> >> hum, I think that's what I already do in the code :) >> >> I've updated the gdb.BpLocation.is_valid documentation, maybe it's clear= er? > > Yeah, I saw it later. =A0Forgot to delete that comment! > >>> @defun BpLocation.is_valid () >>> Returns @code{True} if the @code{gdb.BpLocation} object is valid, >>> @code{False} if not. =A0A @code{gdb.BpLocation} object may be invalidat= ed by >>> GDB at any moment for internal reasons. All other @code{gdb.BpLocation}= methods >>> and attributes will throw an exception if the object is invalid. >>> @end defun >> >>>> + >>>> +@defvar BpLocation.owner >>>> +This attribute holds a reference to the @code{gdb.Breakpoint} object = which >>>> +owns this location. >>>> +@end defvar >> >>> Note which attributes are read only/writable. =A0This and others. >> I specify a few lines above that all the attributes are read only, but >> I've noted it on each attribute as well. > > Right, but there is no guarantee that the user will read the entirety > of that section's documentation. =A0So we always put attribute access rig= hts > in the attribute section. ok, I thought that as soon as it was clearly mentioned somewhere, that was enough. But it doesn't cost anything to me to write it for each attribute, so no problem! >>> Also many different breakpoints can be at one location. =A0I'm not sure= if it >>> is worth pointing out here that "this breakpoint" only owns the >>> location insofar as the scope of that breakpoint (there could be other >>> breakpoints set to that location). >> >> from an implementation point of view, the is a BP =A0<1--------n> >> BpLocation relation, even if two locations have the same address. >> >> Also, I think that the end-users won't have problems to understand >> these BpLocations, as they're already exposed with "info breakpoints": > > I was purely talking from a scripting point of view, but ok. =A0My view > is, if the user has to run experiments to collect data on the actual > behavior, then our documentation needs to be a little better. yes, no doubt about that! > You could just put in that "from an implementation point of view" paragra= ph in > the documentation somewhere? I've added it to 'BpLocation.owner' description: @defvar BpLocation.owner This attribute holds a reference to the @code{gdb.Breakpoint} object which owns this location. This attribute is not writable. From an implementation point of view, there is a @code{1 ... n} relation between a breakpoint and its locations, even if two breakpoints are set on at same address. >>>> +struct bploc_object >>>> +{ >>>> + =A0PyObject_HEAD >>>> + >>>> + =A0/* The location corresponding to this py object. =A0NULL is the l= ocation >>>> + =A0 =A0 has been deleted. =A0*/ >>>> + =A0struct bp_location *loc; >>> >>> Typo in the comment "NULL is the location has been deleted.". =A0Also n= it >>> pick shouldn't it be "The location corresponding to a gdb.Breakpoint >>> object"? >> >> typo fixed, but not the nit: it's the same idea as breakpoint, >> if the 'backend' breakpoint is deleted, 'struct breakpoint_object . bp' = is NULL, >> if the 'backend' location is deleted, 'struct bploc_object . loc' is >> NULL > > My objection was to "py object", I would just find it clearer to name > the object. =A0Also, the explanation above would go a long way for future > hackers to understand the relationship. =A0Maybe add that to the code too? You're right, it looks obvious to me, but it would take time to figure out by itself. Here are a few more bits of comments: /* The location corresponding to this gdb.BpLocation object. It's the same idea as gdb.Breakpoint, if the 'backend' location is deleted, LOC is set to NULL. No reference to the location is owned here (in terms of ref. counting) in order not to change the internal behavior. */ struct bp_location *loc; >> >>>> + >>>> + =A0/* 1 if the owner BP has been deleted, 0 otherwise. =A0*/ >>>> + =A0int invalid_owner; >>>> + >>>> + =A0/* Cache for the gdb.Value object corresponding to loc->address. = =A0*/ >>>> + =A0PyObject *py_address; >>>> +}; >>> >>> I'm not sure if breakpoint locations can change. =A0I do not think so, = but >>> why do we need to cache loc->address? >> >> I assumed that it can't change, but didn't actually investigate all >> the implementation. >> My feeling is "caching is easy, creating a Py object has a cost, so >> let's cache!", but I've got no idea about the actual cost, so I'll >> change it if someone insists [and convinces me] :) > > I don't know enough about breakpoint locations to be able to advise you, > but what does update_global_location_list do? =A0Just shuffle add/delete > locations to the list? =A0I am not against caching. =A0Just not sure why = we > need it. =A0I tend towards the conservative with things like these, if > only purely because we keep missing reference counts in the existing > code. I somehow managed to convinced myself to remove this address caching, 1/I'm not sure about the actual py object creation, certainly quite low, 2/BpLocation objects have a short lifespan, so the cached addresses would be discarded quite frequently so all in all, I can't see anymore any relevant reason to cache it :) >>>> + >>>> +/* Require that LOCATION be a valid bp_location; throw a Python >>>> + =A0 exception if it is invalid. =A0*/ >>>> +#define BPLOCPY_REQUIRE_VALID(Location) =A0 =A0 =A0 =A0 =A0 =A0 =A0 = =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 \ >>>> + =A0 =A0do { =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 = =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0\ >>>> + =A0 =A0 =A0if ((Location)->loc =3D=3D NULL) =A0 =A0 =A0 =A0 =A0 =A0 = =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0\ >>>> + =A0 =A0 =A0 =A0return PyErr_Format (PyExc_RuntimeError, =A0 =A0 =A0 = =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0\ >>>> + =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 _("BpLocatio= n invalid.")); =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 \ >>>> + =A0 =A0} while (0) >>> >>> I prefer error messages a little more descriptive. =A0That is just a >>> personal thing of mine, but "BpLocation invalid" would seem cryptic when >>> thrown in the context of a script. >> >> I'm not sure how I could improve it, at this point (checking validity >> at the beginning of all the attributes), we just know that the backend >> location has been freed, but we don't know why. > > "BpLocation object, breakpoint location is NULL". Or something like that. I'm still not sure, I think that when I read "BpLocation invalid", I'd take a look at the 'is_valid' method description, and understand that "A @code{gdb.BpLocation} object may be invalidated by GDB at any moment for internal reasons." 'breakpoint location is NULL' sounds like an internal error to me ... Maybe "BpLocation invalid: internal location object freed up/removed by GDB= ." ? >>>> +PyObject * >>>> +bplocation_to_bplocation_object (struct bp_location *loc) >>>> +{ >>>> + =A0bploc_object *bploc_obj; >>>> + >>>> + =A0gdb_assert (loc !=3D NULL); >>> >>> Is this a fatal error that we need to shutdown GDB for? =A0gdb_assert >>> seems pretty strong from an API point of view. >> >> hum, I'm not sure here, >> I wrote this line to actually shutdown GDB instead of segfaulting on >> the next line, >> for instance 'py-pspace.c::pspace_to_pspace_object' and >> 'py-objfile.c::objfile_to_objfile_object" will just segfault if >> there're called with a NULL parameter. >> >> throwing an Python/GDB exception wouldn't make much sense to me >> either, as there end-user won't be able to deal with it > > Neither would killing GDB. =A0I almost never use gdb_assert because of the > possible negative user implications. =A0Can you discern that GDB has > entered an unstable state because a function has received a NULL > argument for a bp_location? =A0If you cannot answer "yes" with a high > degree of certainty, it is my opinion we should raise an exception and > return NULL. =A0We can make sure in the Python API that, if this is the > case, we will return the exception to the script boundary for the script > to deal with. =A0From an API point-of-view I think we should defer to > script authors the opportunity to deal with and decide what to do in > this scenario. =A0If GDB is truly unstable, then I agree, assert is > correct. =A0I think the other two cases are bugs. I get your point and quite agree with you, the only thing is that we're talking about 'gdb_assert' and not 'assert' itself. > Neither would killing GDB. and here's my point, 'gdb_assert' does't kill GDB, but raises a warning message asking the user if he wants to quit or continue. My feeling about *assert is that it's a development/beta-test features, which might/should be turned into noop for production. > From an API point-of-view I think we should defer to script authors the o= pportunity to deal with I don't think so, because (from my developer point of view) I see it as very improbable that this situation would occur, or even impossible if I were a good programmer! I don't think that API should cover internal 'buggy' situations, otherwise they would be endless! > The Maintainers may differ on this, wait for their opinion. yes, I'm curious about different point of views >>>> +bplocpy_get_address (PyObject *self, void *closure) >>>> +{ >>>> + =A0bploc_object *self_bploc =3D (bploc_object *) self; >>>> + >>>> + =A0BPLOCPY_REQUIRE_VALID (self_bploc); >>>> + >>>> + =A0if (!self_bploc->py_address) >>>> + =A0 =A0{ >>>> + =A0 =A0 =A0/* Get the address Value object as a void *. =A0*/ >>>> + =A0 =A0 =A0volatile struct gdb_exception except; >>>> + =A0 =A0 =A0struct type *void_ptr_type; >>>> + =A0 =A0 =A0struct value *val =3D NULL ; /* Initialize to appease gcc= warning. =A0*/ >>>> + >>>> + =A0 =A0 =A0TRY_CATCH (except, RETURN_MASK_ALL) >>>> + =A0 =A0 =A0 =A0{ >>>> + =A0 =A0 =A0 =A0 =A0void_ptr_type =3D lookup_pointer_type ( >>>> + =A0 =A0 =A0 =A0 =A0 =A0 =A0builtin_type (python_gdbarch)->builtin_vo= id); >>>> + =A0 =A0 =A0 =A0 =A0val =3D value_from_pointer (void_ptr_type, self_b= ploc->loc->address); >>>> + =A0 =A0 =A0 =A0} >>>> + =A0 =A0 =A0GDB_PY_HANDLE_EXCEPTION (except); >>>> + >>>> + =A0 =A0 =A0self_bploc->py_address =3D value_to_value_object (val); >>>> + =A0 =A0 =A0Py_XINCREF (self_bploc->py_address); >>>> + =A0 =A0} >>>> + =A0Py_XINCREF (self_bploc->py_address); >>> >>> I don't really mind it, but I prefer explicit return NULL when dealing >>> with cases of exceptions. =A0I find the other logic hard to read. =A0Th= is is >>> not a request for a change. Is there a case where py_address will be >>> NULL? =A0Yes, there is, value_to_value_object can return NULL. =A0If it >>> returns NULL, then there is an exception set. =A0I much prefer to exit >>> then and there, other the conditional XINCREF step, and returning at the >>> function exit. =A0Still, this is just a stylistic thing, and probably >>> personal thing. =A0The second XINCREF can just be a plain old INCREF as= we >>> already tested for NULL. >> >> makes sense to me, my "single return point" idea doesn't stand against >> error handling > > Note this is purely a personal style issue, there was nothing wrong with > the correctness of your code. sure, I try to make it clear when I don't agree with the suggestion; this one was perfectly fine, I think that's actually the way I wrote it at the first time :) >>> This brings me to the address cache argument. =A0Is it worthwhile manag= ing >>> the cache increment counts instead of just returning the address each >>> time? =A0I ask as I am not sure if you have done any metrics that indic= ate >>> this is a slow operation. >> >> no, I didn't run any measurement so far; I'll wait for a maintainer >> point of view about that > > Ok. > >>> We need to make sure that the this is not a watchpoint. >> >> why not? >> I don't know much about watchpoints, but as per my quick >> investigations, they share the same high-level structure (struct >> breakpoint), and they seem to use bp_location the same way ? > > I'm not sure as watchpoints are based on expressions. =A0Maybe it is ok, > but note that watchpoints are removed and reinserted on scope of the > expression. =A0It might be fine. =A0A few tests would prove the issue. I'll try to build some test to ensure that it's fine thanks for your comments and reviews, Kevin -- 2011-12-13 Kevin Pouget Add bp_location to Python interface * Makefile.in (SUBDIR_PYTHON_OBS): Add py-bploc.o (SUBDIR_PYTHON_SRCS): Add python/py-bploc.c Add build rule for this file. * breakpoint.h (struct bploc_object): Forward declaration. (struct bp_location): Add py_bploc_obj. * breakpoint.c (free_bp_location): Call gdbpy_bplocation_free. * python/py-bploc.c: New file. * python/py-breakpoint.c (bppy_locations): New function. (breakpoint_object_methods): New method binding: locations(). * python/python-internal.h (bploc_object): New typedef. (bplocation_to_bplocation_object): New prototype. (gdbpy_initialize_bplocation): Likewise. * python/python.c (gdbpy_bplocation_free): New empty stub. (_initialize_python): Call gdbpy_initialize_bplocation. * python/python.h (gdbpy_bplocation_free): New prototype. =09 doc/ Add bp_location to Python interface * gdb.texinfo (Breakpoints In Python): Document gdb.Breakpoint.locations and gdb.BpLocation. testsuite/ Add bp_location to Python interface * gdb.python/py-breakpoint.exp: Test gdb.BpLocation. --f46d043c821c8b77d904b3fae9b5 Content-Type: text/x-patch; charset=US-ASCII; name="0001-Add-bp_location-to-Python-interface.patch" Content-Disposition: attachment; filename="0001-Add-bp_location-to-Python-interface.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_gw52fcs40 Content-length: 30561 RnJvbSBlNGYzZTdhZjQ2ODZiMTk2Y2UyZDRjYmU2ZDhjN2VmMDA5MTVkMzUy IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBLZXZpbiBQb3VnZXQg PGtldmluLnBvdWdldEBzdC5jb20+CkRhdGU6IFdlZCwgMTggTWF5IDIwMTEg MTA6MDI6MjMgLTA0MDAKU3ViamVjdDogW1BBVENIXSBBZGQgYnBfbG9jYXRp b24gdG8gUHl0aG9uIGludGVyZmFjZQoKLS0tCiBnZGIvTWFrZWZpbGUuaW4g ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICA2ICsKIGdkYi9ORVdT ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDggKwog Z2RiL2JyZWFrcG9pbnQuYyAgICAgICAgICAgICAgICAgICAgICAgICAgIHwg ICAgMyArCiBnZGIvYnJlYWtwb2ludC5oICAgICAgICAgICAgICAgICAgICAg ICAgICAgfCAgICA2ICsKIGdkYi9kb2MvZ2RiLnRleGluZm8gICAgICAgICAg ICAgICAgICAgICAgICB8ICAgNDQgKysrKwogZ2RiL3B5dGhvbi9weS1icGxv Yy5jICAgICAgICAgICAgICAgICAgICAgIHwgIDMwMiArKysrKysrKysrKysr KysrKysrKysrKysrKysrCiBnZGIvcHl0aG9uL3B5LWJyZWFrcG9pbnQuYyAg ICAgICAgICAgICAgICAgfCAgIDM5ICsrKysKIGdkYi9weXRob24vcHl0aG9u LWludGVybmFsLmggICAgICAgICAgICAgICB8ICAgIDYgKwogZ2RiL3B5dGhv bi9weXRob24uYyAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgNyArCiBn ZGIvcHl0aG9uL3B5dGhvbi5oICAgICAgICAgICAgICAgICAgICAgICAgfCAg ICAyICsKIGdkYi90ZXN0c3VpdGUvZ2RiLnB5dGhvbi9weS1icmVha3BvaW50 LmV4cCB8ICAgNTIgKysrKysKIDExIGZpbGVzIGNoYW5nZWQsIDQ3NSBpbnNl cnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0 IGdkYi9weXRob24vcHktYnBsb2MuYwoKZGlmZiAtLWdpdCBhL2dkYi9NYWtl ZmlsZS5pbiBiL2dkYi9NYWtlZmlsZS5pbgppbmRleCBiNzFkYjMzLi41OGI0 OTEwIDEwMDY0NAotLS0gYS9nZGIvTWFrZWZpbGUuaW4KKysrIGIvZ2RiL01h a2VmaWxlLmluCkBAIC0yODAsNiArMjgwLDcgQEAgU1VCRElSX1BZVEhPTl9P QlMgPSBcCiAJcHktYXV0by1sb2FkLm8gXAogCXB5LWJsb2NrLm8gXAogCXB5 LWJwZXZlbnQubyBcCisJcHktYnBsb2MubyBcCiAJcHktYnJlYWtwb2ludC5v IFwKIAlweS1jbWQubyBcCiAJcHktY29udGludWVldmVudC5vIFwKQEAgLTMx MSw2ICszMTIsNyBAQCBTVUJESVJfUFlUSE9OX1NSQ1MgPSBcCiAJcHl0aG9u L3B5LWF1dG8tbG9hZC5jIFwKIAlweXRob24vcHktYmxvY2suYyBcCiAJcHl0 aG9uL3B5LWJwZXZlbnQuYyBcCisJcHl0aG9uL3B5LWJwbG9jLmMgXAogCXB5 dGhvbi9weS1icmVha3BvaW50LmMgXAogCXB5dGhvbi9weS1jbWQuYyBcCiAJ cHl0aG9uL3B5LWNvbnRpbnVlZXZlbnQuYyBcCkBAIC0yMDgxLDYgKzIwODMs MTAgQEAgcHktYnBldmVudC5vOiAkKHNyY2RpcikvcHl0aG9uL3B5LWJwZXZl bnQuYwogCSQoQ09NUElMRSkgJChQWVRIT05fQ0ZMQUdTKSAkKHNyY2Rpcikv cHl0aG9uL3B5LWJwZXZlbnQuYwogCSQoUE9TVENPTVBJTEUpCiAKK3B5LWJw bG9jLm86ICQoc3JjZGlyKS9weXRob24vcHktYnBsb2MuYworCSQoQ09NUElM RSkgJChQWVRIT05fQ0ZMQUdTKSAkKHNyY2RpcikvcHl0aG9uL3B5LWJwbG9j LmMKKwkkKFBPU1RDT01QSUxFKQorCiBweS1icmVha3BvaW50Lm86ICQoc3Jj ZGlyKS9weXRob24vcHktYnJlYWtwb2ludC5jCiAJJChDT01QSUxFKSAkKFBZ VEhPTl9DRkxBR1MpICQoc3JjZGlyKS9weXRob24vcHktYnJlYWtwb2ludC5j CiAJJChQT1NUQ09NUElMRSkKZGlmZiAtLWdpdCBhL2dkYi9ORVdTIGIvZ2Ri L05FV1MKaW5kZXggNDI3ODJjZS4uNDM0NGZjOSAxMDA2NDQKLS0tIGEvZ2Ri L05FV1MKKysrIGIvZ2RiL05FV1MKQEAgLTEsNiArMSwxNCBAQAogCQlXaGF0 IGhhcyBjaGFuZ2VkIGluIEdEQj8KIAkgICAgIChPcmdhbml6ZWQgcmVsZWFz ZSBieSByZWxlYXNlKQogCisqKiogQ2hhbmdlcyBzaW5jZSBHREIgNy40CisK KyogUHl0aG9uIHNjcmlwdGluZworCisgICoqIEEgbmV3IG1ldGhvZCAiZ2Ri LkJyZWFrcG9pbnQubG9jYXRpb25zIiBoYXMgYmVlbiBhZGRlZCwgYXMgd2Vs bCBhcworICAgICB0aGUgY2xhc3MgZ2RiLkJwTG9jYXRpb24gdG8gcHJvdmlk ZSBmdXJ0aGVyIGRldGFpbHMgYWJvdXQgYnJlYWtwb2ludAorICAgICBsb2Nh dGlvbnMuCisKICoqKiBDaGFuZ2VzIHNpbmNlIEdEQiA3LjMuMQogCiAqIEdE QiBub3cgaGFuZGxlcyBhbWJpZ3VvdXMgbGluZXNwZWNzIG1vcmUgY29uc2lz dGVudGx5OyB0aGUgZXhpc3RpbmcKZGlmZiAtLWdpdCBhL2dkYi9icmVha3Bv aW50LmMgYi9nZGIvYnJlYWtwb2ludC5jCmluZGV4IDA2ODY1ODcuLjJmMTM1 N2EgMTAwNjQ0Ci0tLSBhL2dkYi9icmVha3BvaW50LmMKKysrIGIvZ2RiL2Jy ZWFrcG9pbnQuYwpAQCAtNTY4MSw2ICs1NjgxLDkgQEAgc3RhdGljIHZvaWQK IGZyZWVfYnBfbG9jYXRpb24gKHN0cnVjdCBicF9sb2NhdGlvbiAqbG9jKQog ewogICBsb2MtPm9wcy0+ZHRvciAobG9jKTsKKworICBnZGJweV9icGxvY2F0 aW9uX2ZyZWUgKGxvYyk7CisKICAgeGZyZWUgKGxvYyk7CiB9CiAKZGlmZiAt LWdpdCBhL2dkYi9icmVha3BvaW50LmggYi9nZGIvYnJlYWtwb2ludC5oCmlu ZGV4IGRkZjE4ODEuLjVhOGExYWYgMTAwNjQ0Ci0tLSBhL2dkYi9icmVha3Bv aW50LmgKKysrIGIvZ2RiL2JyZWFrcG9pbnQuaApAQCAtMjgsNiArMjgsNyBA QAogc3RydWN0IHZhbHVlOwogc3RydWN0IGJsb2NrOwogc3RydWN0IGJyZWFr cG9pbnRfb2JqZWN0Oworc3RydWN0IGJwbG9jX29iamVjdDsKIHN0cnVjdCBn ZXRfbnVtYmVyX29yX3JhbmdlX3N0YXRlOwogc3RydWN0IHRocmVhZF9pbmZv Owogc3RydWN0IGJwc3RhdHM7CkBAIC00MDUsNiArNDA2LDExIEBAIHN0cnVj dCBicF9sb2NhdGlvbgogICAvKiBTb3VyY2UgZmlsZSBuYW1lIG9mIHRoaXMg YWRkcmVzcy4gICovCiAKICAgY2hhciAqc291cmNlX2ZpbGU7CisKKyAgLyog UHl0aG9uIG9iamVjdCBhc3NvY2lhdGVkIHdpdGggdGhpcyBsb2NhdGlvbi4g IE1heSBiZSBOVUxMIGlmIHRoZSBsb2NhdGlvbgorICAgICBpcyBub3QgeWV0 IGV4cG9ydGVkIHRvIFB5dGhvbi4gICovCisKKyAgc3RydWN0IGJwbG9jX29i amVjdCAqcHlfYnBsb2Nfb2JqOwogfTsKIAogLyogVGhpcyBzdHJ1Y3R1cmUg aXMgYSBjb2xsZWN0aW9uIG9mIGZ1bmN0aW9uIHBvaW50ZXJzIHRoYXQsIGlm IGF2YWlsYWJsZSwKZGlmZiAtLWdpdCBhL2dkYi9kb2MvZ2RiLnRleGluZm8g Yi9nZGIvZG9jL2dkYi50ZXhpbmZvCmluZGV4IDUwYzI5OWUuLjQ2NjU3NzIg MTAwNjQ0Ci0tLSBhL2dkYi9kb2MvZ2RiLnRleGluZm8KKysrIGIvZ2RiL2Rv Yy9nZGIudGV4aW5mbwpAQCAtMjQzMzUsNiArMjQzMzUsNTAgQEAgY29tbWFu ZHMsIHNlcGFyYXRlZCBieSBuZXdsaW5lcy4gIElmIHRoZXJlIGFyZSBubyBj b21tYW5kcywgdGhpcwogYXR0cmlidXRlIGlzIEBjb2Rle05vbmV9LiAgVGhp cyBhdHRyaWJ1dGUgaXMgbm90IHdyaXRhYmxlLgogQGVuZCBkZWZ2YXIKIAor QGZpbmRleCBnZGIubG9jYXRpb25zCitAZGVmdW4gZ2RiLmxvY2F0aW9ucyAo KQorUmV0dXJuIGEgdHVwbGUgY29udGFpbmluZyBhIHNlcXVlbmNlIG9mIEBj b2Rle2dkYi5CcExvY2F0aW9ufSBvYmplY3RzIAorKHNlZSBiZWxvdykgYXNz b2NpYXRlZCB3aXRoIHRoaXMgYnJlYWtwb2ludC4gIEEgYnJlYWtwb2ludCB3 aXRoIG5vIGxvY2F0aW9uCitpcyBhIHBlbmRpbmcgYnJlYWtwb2ludCAoQHhy ZWZ7U2V0IEJyZWFrcywgLCBwZW5kaW5nIGJyZWFrcG9pbnRzfSkuCitAZW5k IGRlZnVuCisKK0EgYnJlYWtwb2ludCBsb2NhdGlvbiBpcyByZXByZXNlbnRl ZCB3aXRoIGEgQGNvZGV7Z2RiLkJwTG9jYXRpb259IG9iamVjdCwKK3doaWNo IG9mZmVycyB0aGUgZm9sbG93aW5nIGF0dHJpYnV0ZXMgKGFsbCByZWFkIG9u bHkpIGFuZCBtZXRob2RzLgorUGxlYXNlIG5vdGUgdGhhdCBicmVha3BvaW50 IGxvY2F0aW9ucyBhcmUgdmVyeSB0cmFuc2llbnQgZW50aXRpZXMgaW4KK0B2 YWx1ZXtHREJOfSwgc28gb25lIHNob3VsZCBhdm9pZCBrZWVwaW5nIHJlZmVy ZW5jZXMgdG8gdGhlbS4KKworQGRlZnZhciBCcExvY2F0aW9uLm93bmVyCitU aGlzIGF0dHJpYnV0ZSBob2xkcyBhIHJlZmVyZW5jZSB0byB0aGUgQGNvZGV7 Z2RiLkJyZWFrcG9pbnR9IG9iamVjdCB3aGljaAorb3ducyB0aGlzIGxvY2F0 aW9uLiAgVGhpcyBhdHRyaWJ1dGUgaXMgbm90IHdyaXRhYmxlLiAgRnJvbSBh biBpbXBsZW1lbnRhdGlvbiAKK3BvaW50IG9mIHZpZXcsIHRoZXJlIGlzIGEg QGNvZGV7MSAuLi4gbn0gcmVsYXRpb24gYmV0d2VlbiBhIGJyZWFrcG9pbnQg YW5kCitpdHMgbG9jYXRpb25zLCBldmVuIGlmIHR3byBicmVha3BvaW50cyBh cmUgc2V0IG9uIGF0IHNhbWUgYWRkcmVzcy4KKyAKK0BlbmQgZGVmdmFyCisK K0BkZWZ2YXIgQnBMb2NhdGlvbi5lbmFibGVkCitUaGlzIGF0dHJpYnV0ZSBp bmRpY2F0ZXMgd2hldGhlciB0aGlzIGxvY2F0aW9uIGlzIGN1cnJlbnRseSBl bmFibGVkIG9yIG5vdC4KK1RoaXMgYXR0cmlidXRlIGlzIG5vdCB3cml0YWJs ZS4KK0BlbmQgZGVmdmFyCisKK0BkZWZ2YXIgQnBMb2NhdGlvbi5pbmZlcmlv cgorVGhpcyBhdHRyaWJ1dGUgaG9sZHMgYSByZWZlcmVuY2UgdG8gdGhlIEBj b2Rle2dkYi5JbmZlcmlvcn0gaW5mZXJpb3Igb2JqZWN0CitpbiB3aGljaCB0 aGlzIGJyZWFrcG9pbnQgbG9jYXRpb24gaGFzIGJlZW4gaW5zZXJ0ZWQuICBU aGUgdmFsdWUgd2lsbCBiZSAKK0Bjb2Rle05vbmV9IGlmIHRoZXJlIGlzIG5v IGluZmVyaW9yIGFzc29jaWF0ZWQgd2l0aCB0aGlzIGxvY2F0aW9uLiAgIFRo aXMgCithdHRyaWJ1dGUgaXMgbm90IHdyaXRhYmxlLgorQGVuZCBkZWZ2YXIK KworQGRlZnZhciBCcExvY2F0aW9uLmFkZHJlc3MKK1RoaXMgYXR0cmlidXRl IGhvbGRzIGEgQGNvZGV7Z2RiLlZhbHVlfSBvYmplY3QgY29ycmVzcG9uZGlu ZyB0byB0aGUgYWRkcmVzcyAKK2F0IHdoaWNoIHRoZSBicmVha3BvaW50IGhh cyBiZWVuIGluc2VydGVkLiAgIFRoaXMgYXR0cmlidXRlIGlzIG5vdCB3cml0 YWJsZS4KK0BlbmQgZGVmdmFyCisKK0BkZWZ1biBCcExvY2F0aW9uLmlzX3Zh bGlkICgpCitSZXR1cm5zIEBjb2Rle1RydWV9IGlmIHRoZSBAY29kZXtnZGIu QnBMb2NhdGlvbn0gb2JqZWN0IGlzIHZhbGlkLAorQGNvZGV7RmFsc2V9IGlm IG5vdC4gIEEgQGNvZGV7Z2RiLkJwTG9jYXRpb259IG9iamVjdCBtYXkgYmUg aW52YWxpZGF0ZWQgYnkKK0dEQiBhdCBhbnkgbW9tZW50IGZvciBpbnRlcm5h bCByZWFzb25zLiAgQWxsIG90aGVyIEBjb2Rle2dkYi5CcExvY2F0aW9ufQor bWV0aG9kcyBhbmQgYXR0cmlidXRlcyB3aWxsIHRocm93IGFuIGV4Y2VwdGlv biBpZiB0aGUgb2JqZWN0IGlzIGludmFsaWQuCitAZW5kIGRlZnVuCisKIEBu b2RlIExhenkgU3RyaW5ncyBJbiBQeXRob24KIEBzdWJzdWJzZWN0aW9uIFB5 dGhvbiByZXByZXNlbnRhdGlvbiBvZiBsYXp5IHN0cmluZ3MuCiAKZGlmZiAt LWdpdCBhL2dkYi9weXRob24vcHktYnBsb2MuYyBiL2dkYi9weXRob24vcHkt YnBsb2MuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41 YmEzOTQ4Ci0tLSAvZGV2L251bGwKKysrIGIvZ2RiL3B5dGhvbi9weS1icGxv Yy5jCkBAIC0wLDAgKzEsMzAyIEBACisvKiBQeXRob24gaW50ZXJmYWNlIHRv IGJyZWFrcG9pbnQgbG9jYXRpb25zLgorCisgICBDb3B5cmlnaHQgKEMpIDIw MTEgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisKKyAgIFRoaXMg ZmlsZSBpcyBwYXJ0IG9mIEdEQi4KKworICAgVGhpcyBwcm9ncmFtIGlzIGZy ZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBt b2RpZnkKKyAgIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgICB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAzIG9mIHRo ZSBMaWNlbnNlLCBvcgorICAgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIg dmVyc2lvbi4KKworICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgICBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZgorICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICAgR05VIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKworICAgWW91 IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVy YWwgUHVibGljIExpY2Vuc2UKKyAgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFt LiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+ LiAgKi8KKworCisjaW5jbHVkZSAiZGVmcy5oIgorI2luY2x1ZGUgImluZmVy aW9yLmgiCisjaW5jbHVkZSAicHl0aG9uLWludGVybmFsLmgiCisjaW5jbHVk ZSAib2JzZXJ2ZXIuaCIKKyNpbmNsdWRlICJnZGJhcmNoLmgiCisKK3N0cnVj dCBicGxvY19vYmplY3QKK3sKKyAgUHlPYmplY3RfSEVBRAorCisgIC8qIFRo ZSBsb2NhdGlvbiBjb3JyZXNwb25kaW5nIHRvIHRoaXMgZ2RiLkJwTG9jYXRp b24gb2JqZWN0LiAgSXQncyB0aGUgc2FtZQorICAgICBpZGVhIGFzIGdkYi5C cmVha3BvaW50LCBpZiB0aGUgJ2JhY2tlbmQnIGxvY2F0aW9uIGlzIGRlbGV0 ZWQsIExPQyBpcworICAgICBzZXQgdG8gTlVMTC4gIE5vIHJlZmVyZW5jZSB0 byB0aGUgbG9jYXRpb24gaXMgb3duZWQgaGVyZSAoaW4gdGVybXMgb2YKKyAg ICAgcmVmLiBjb3VudGluZykgaW4gb3JkZXIgbm90IHRvIGNoYW5nZSB0aGUg aW50ZXJuYWwgYmVoYXZpb3IuICAqLworICBzdHJ1Y3QgYnBfbG9jYXRpb24g KmxvYzsKKworICAvKiAxIGlmIHRoZSBvd25lciBCUCBoYXMgYmVlbiBkZWxl dGVkLCAwIG90aGVyd2lzZS4gICovCisgIGludCBpbnZhbGlkX293bmVyOwor fTsKKworLyogUmVxdWlyZSB0aGF0IExPQ0FUSU9OIGJlIGEgdmFsaWQgYnBf bG9jYXRpb247IHRocm93IGEgUHl0aG9uCisgICBleGNlcHRpb24gaWYgaXQg aXMgaW52YWxpZC4gICovCisjZGVmaW5lIEJQTE9DUFlfUkVRVUlSRV9WQUxJ RChMb2NhdGlvbikgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBc CisgICAgZG8geyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICBpZiAoKExv Y2F0aW9uKS0+bG9jID09IE5VTEwpICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBcCisgICAgICAgIHJldHVybiBQeUVycl9Gb3JtYXQg KFB5RXhjX1J1bnRpbWVFcnJvciwgICAgICAgICAgICAgICAgICAgICAgICBc CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIF8oIkJwTG9jYXRpb24g aW52YWxpZC4iKSk7ICAgICAgICAgICAgICAgICBcCisgICAgfSB3aGlsZSAo MCkKKworc3RhdGljIFB5VHlwZU9iamVjdCBicGxvY19vYmplY3RfdHlwZTsK KworLyogQ2FsbCBieSBmcmVlX2JwX2xvY2F0aW9uIHdoZW4gbG9jIGlzIGFi b3V0IHRvIGJlIGZyZWVkLiAgKi8KKwordm9pZAorZ2RicHlfYnBsb2NhdGlv bl9mcmVlIChzdHJ1Y3QgYnBfbG9jYXRpb24gKmxvYykKK3sKKyAgaWYgKGxv Yy0+cHlfYnBsb2Nfb2JqKQorICAgIHsKKyAgICAgIGxvYy0+cHlfYnBsb2Nf b2JqLT5sb2MgPSBOVUxMOworICAgICAgUHlfREVDUkVGIChsb2MtPnB5X2Jw bG9jX29iaik7CisgICAgfQorfQorCisvKiBEaXNzb2NpYXRlIHRoZSBicF9s b2NhdGlvbiBmcm9tIHRoZSBQeXRob24gb2JqZWN0LiAgKi8KKworc3RhdGlj IHZvaWQKK2JwbG9jcHlfZGVhbGxvYyAoUHlPYmplY3QgKnNlbGYpCit7Cisg IGJwbG9jX29iamVjdCAqc2VsZl9icGxvYyA9IChicGxvY19vYmplY3QgKikg c2VsZjsKKworICBpZiAoc2VsZl9icGxvYy0+bG9jICE9IE5VTEwpCisgICAg c2VsZl9icGxvYy0+bG9jLT5weV9icGxvY19vYmogPSBOVUxMOworCisgIHNl bGYtPm9iX3R5cGUtPnRwX2ZyZWUgKHNlbGYpOworfQorCisvKiBDcmVhdGUg b3IgYWNxdWlyZSBhIHJlZiB0byB0aGUgYnBfbG9jYXRpb24gb2JqZWN0IChn ZGIuQnBMb2NhdGlvbikKKyAgIHRoYXQgZW5jYXBzdWxhdGVzIHRoZSBzdHJ1 Y3QgYnBfbG9jYXRpb24gZnJvbSBHREIuICAqLworCitQeU9iamVjdCAqCiti cGxvY2F0aW9uX3RvX2JwbG9jYXRpb25fb2JqZWN0IChzdHJ1Y3QgYnBfbG9j YXRpb24gKmxvYykKK3sKKyAgYnBsb2Nfb2JqZWN0ICpicGxvY19vYmo7CisK KyAgZ2RiX2Fzc2VydCAobG9jICE9IE5VTEwpOworICBpZiAobG9jLT5weV9i cGxvY19vYmopCisgICAgeworICAgICAgUHlfSU5DUkVGIChsb2MtPnB5X2Jw bG9jX29iaik7CisgICAgICByZXR1cm4gKFB5T2JqZWN0ICopIGxvYy0+cHlf YnBsb2Nfb2JqOworICAgIH0KKworICBicGxvY19vYmogPSBQeU9iamVjdF9O ZXcgKGJwbG9jX29iamVjdCwgJmJwbG9jX29iamVjdF90eXBlKTsKKyAgaWYg KCFicGxvY19vYmopCisgICAgcmV0dXJuIE5VTEw7CisKKyAgYnBsb2Nfb2Jq LT5sb2MgPSBsb2M7CisgIGJwbG9jX29iai0+aW52YWxpZF9vd25lciA9IDA7 CisgIFB5X0lOQ1JFRiAoYnBsb2Nfb2JqKTsKKyAgbG9jLT5weV9icGxvY19v YmogPSBicGxvY19vYmo7CisKKyAgcmV0dXJuIChQeU9iamVjdCAqKSBicGxv Y19vYmo7Cit9CisKKy8qIFB5dGhvbiBmdW5jdGlvbiB0byBnZXQgdGhlIEJQ IG93bmluZyB0aGlzIGxvY2F0aW9uLCBpZiBhbnkuICAqLworCitzdGF0aWMg UHlPYmplY3QgKgorYnBsb2NweV9nZXRfb3duZXIgKFB5T2JqZWN0ICpzZWxm LCB2b2lkICpjbG9zdXJlKQoreworICBicGxvY19vYmplY3QgKnNlbGZfYnBs b2MgPSAoYnBsb2Nfb2JqZWN0ICopIHNlbGY7CisKKyAgQlBMT0NQWV9SRVFV SVJFX1ZBTElEIChzZWxmX2JwbG9jKTsKKworICBpZiAoc2VsZl9icGxvYy0+ aW52YWxpZF9vd25lcikKKyAgICBQeV9SRVRVUk5fTk9ORTsKKworICBpZiAo c2VsZl9icGxvYy0+bG9jLT5vd25lcgorICAgICAgJiYgc2VsZl9icGxvYy0+ bG9jLT5vd25lci0+cHlfYnBfb2JqZWN0KQorICAgIHsKKyAgICAgIFB5X0lO Q1JFRiAoc2VsZl9icGxvYy0+bG9jLT5vd25lci0+cHlfYnBfb2JqZWN0KTsK KyAgICAgIHJldHVybiAoUHlPYmplY3QgKikgc2VsZl9icGxvYy0+bG9jLT5v d25lci0+cHlfYnBfb2JqZWN0OworICAgIH0KKworICBQeV9SRVRVUk5fTk9O RTsKK30KKworLyogUHl0aG9uIGZ1bmN0aW9uIHRvIHRlc3Qgd2hldGhlciBv ciBub3QgdGhpcyBicmVha3BvaW50IGxvY2F0aW9uIGlzCisgICBlbmFibGVk LiAgKi8KKworc3RhdGljIFB5T2JqZWN0ICoKK2JwbG9jcHlfZ2V0X2VuYWJs ZWQgKFB5T2JqZWN0ICpzZWxmLCB2b2lkICpjbG9zdXJlKQoreworICBicGxv Y19vYmplY3QgKnNlbGZfYnBsb2MgPSAoYnBsb2Nfb2JqZWN0ICopIHNlbGY7 CisKKyAgQlBMT0NQWV9SRVFVSVJFX1ZBTElEIChzZWxmX2JwbG9jKTsKKwor ICBpZiAoc2VsZl9icGxvYy0+bG9jLT5lbmFibGVkKQorICAgIFB5X1JFVFVS Tl9UUlVFOworCisgIFB5X1JFVFVSTl9GQUxTRTsKK30KKworLyogUHl0aG9u IGZ1bmN0aW9uIHRvIGdldCB0aGUgYWRkcmVzcyBvZiB0aGlzIGJyZWFrcG9p bnQgbG9jYXRpb24uICBUaGUKKyAgIGdkYi5WYWx1ZSBvYmplY3Qgd2lsbCBi ZSBjYWNoZWQgaWYgdGhpcyBpcyB0aGUgZmlyc3QgYWNjZXNzLiAgUmV0dXJu cworICAgTlVMTCBpbiBjYXNlIG9mIGZhaWx1cmUsIHdpdGggYSBQeXRob24g ZXhjZXB0aW9uIHNldC4gICovCisKK3N0YXRpYyBQeU9iamVjdCAqCiticGxv Y3B5X2dldF9hZGRyZXNzIChQeU9iamVjdCAqc2VsZiwgdm9pZCAqY2xvc3Vy ZSkKK3sKKyAgYnBsb2Nfb2JqZWN0ICpzZWxmX2JwbG9jID0gKGJwbG9jX29i amVjdCAqKSBzZWxmOworICB2b2xhdGlsZSBzdHJ1Y3QgZ2RiX2V4Y2VwdGlv biBleGNlcHQ7CisgIHN0cnVjdCB0eXBlICp2b2lkX3B0cl90eXBlOworICBz dHJ1Y3QgdmFsdWUgKnZhbCA9IE5VTEw7IC8qIEluaXRpYWxpemUgdG8gYXBw ZWFzZSBnY2Mgd2FybmluZy4gICovCisgIFB5T2JqZWN0ICpweV9hZGRyZXNz OworCisgIEJQTE9DUFlfUkVRVUlSRV9WQUxJRCAoc2VsZl9icGxvYyk7CisK KyAgLyogR2V0IHRoZSBhZGRyZXNzIFZhbHVlIG9iamVjdCBhcyBhIHZvaWQg KiB2YWx1ZS4gICovCisgIFRSWV9DQVRDSCAoZXhjZXB0LCBSRVRVUk5fTUFT S19BTEwpCisgICAgeworICAgICAgdm9pZF9wdHJfdHlwZSA9IGxvb2t1cF9w b2ludGVyX3R5cGUgKAorICAgICAgICAgIGJ1aWx0aW5fdHlwZSAocHl0aG9u X2dkYmFyY2gpLT5idWlsdGluX3ZvaWQpOworICAgICAgdmFsID0gdmFsdWVf ZnJvbV9wb2ludGVyICh2b2lkX3B0cl90eXBlLCBzZWxmX2JwbG9jLT5sb2Mt PmFkZHJlc3MpOworICAgIH0KKyAgR0RCX1BZX0hBTkRMRV9FWENFUFRJT04g KGV4Y2VwdCk7CisKKyAgcHlfYWRkcmVzcyA9IHZhbHVlX3RvX3ZhbHVlX29i amVjdCAodmFsKTsKKyAgaWYgKCFweV9hZGRyZXNzKQorICAgIHJldHVybiBO VUxMOworCisgIHJldHVybiBweV9hZGRyZXNzOworfQorCisvKiBQeXRob24g ZnVuY3Rpb24gdG8gZ2V0IHRoZSBpbmZlcmlvciBob3N0aW5nIHRoaXMgYnJl YWtwb2ludCBsb2NhdGlvbi4KKyAgIFJldHVybiBQeV9Ob25lIGlmIHRoZXJl IGlzIG5vIGluZmVyaW9yIGFzc29jaWF0ZWQgd2l0aCB0aGUgcHJvZ3JhbSBz cGFjZSBvZgorICAgdGhpcyBsb2NhdGlvbiwgb3IgTlVMTCBpbiBjYXNlIG9m IGZhaWx1cmUsIHdpdGggYSBweXRob24gZXhjZXB0aW9uIHNldC4gICovCisK K3N0YXRpYyBQeU9iamVjdCAqCiticGxvY3B5X2dldF9pbmZlcmlvciAoUHlP YmplY3QgKnNlbGYsIHZvaWQgKmNsb3N1cmUpCit7CisgIGJwbG9jX29iamVj dCAqc2VsZl9icGxvYyA9IChicGxvY19vYmplY3QgKikgc2VsZjsKKyAgc3Ry dWN0IGluZmVyaW9yICppbmY7CisgIFB5T2JqZWN0ICppbmZvYmo7CisKKyAg QlBMT0NQWV9SRVFVSVJFX1ZBTElEIChzZWxmX2JwbG9jKTsKKworICBpbmYg PSBmaW5kX2luZmVyaW9yX2Zvcl9wcm9ncmFtX3NwYWNlIChzZWxmX2JwbG9j LT5sb2MtPnBzcGFjZSk7CisgIGlmICghaW5mKQorICAgIFB5X1JFVFVSTl9O T05FOworCisgIGluZm9iaiA9IGluZmVyaW9yX3RvX2luZmVyaW9yX29iamVj dCAoaW5mKTsKKyAgUHlfWElOQ1JFRiAoaW5mb2JqKTsKKworICByZXR1cm4g aW5mb2JqOworfQorCisvKiBQeXRob24gZnVuY3Rpb24gd2hpY2ggY2hlY2tz IHRoZSB2YWxpZGl0eSBvZiBhIGJwIGxvY2F0aW9uIG9iamVjdC4gICovCisK K3N0YXRpYyBQeU9iamVjdCAqCiticGxvY3B5X2lzX3ZhbGlkIChQeU9iamVj dCAqc2VsZiwgUHlPYmplY3QgKmFyZ3MpCit7CisgIGJwbG9jX29iamVjdCAq c2VsZl9icGxvYyA9IChicGxvY19vYmplY3QgKikgc2VsZjsKKworICBpZiAo c2VsZl9icGxvYy0+bG9jKQorICAgIFB5X1JFVFVSTl9UUlVFOworICBQeV9S RVRVUk5fRkFMU0U7Cit9CisKKy8qIENhbGxiYWNrIHRyaWdnZXJlZCB3aGVu IGEgYnJlYWtwb2ludCBpcyBkZWxldGVkLiAgVGhpcyB3aWxsIGludmFsaWRh dGUKKyAgIHRoZSBjb3JyZXNwb25kaW5nIGJwX2xvY2F0aW9uIFB5dGhvbiBv YmplY3Qgb3duZXJzLiAgKi8KKworc3RhdGljIHZvaWQKK2JwbG9jcHlfYnJl YWtwb2ludF9kZWxldGVkIChzdHJ1Y3QgYnJlYWtwb2ludCAqYikgeworICBz dHJ1Y3QgYnBfbG9jYXRpb24gKmxvYzsKKworICBmb3IgKGxvYyA9IGItPmxv YzsgbG9jOyBsb2MgPSBsb2MtPm5leHQpCisgICAgeworICAgICAgaWYgKGxv Yy0+cHlfYnBsb2Nfb2JqKQorICAgICAgICBsb2MtPnB5X2JwbG9jX29iai0+ aW52YWxpZF9vd25lciA9IDE7CisgICAgfQorfQorCisvKiBJbml0aWFsaXpl IHRoZSBQeXRob24gYnBfbG9jYXRpb24gY29kZS4gICovCisKK3ZvaWQKK2dk YnB5X2luaXRpYWxpemVfYnBsb2NhdGlvbiAodm9pZCkKK3sKKyAgaWYgKFB5 VHlwZV9SZWFkeSAoJmJwbG9jX29iamVjdF90eXBlKSA8IDApCisgICAgcmV0 dXJuOworCisgIFB5X0lOQ1JFRiAoJmJwbG9jX29iamVjdF90eXBlKTsKKyAg aWYgKFB5TW9kdWxlX0FkZE9iamVjdCAoZ2RiX21vZHVsZSwgIkJwTG9jYXRp b24iLAorICAgICAgICAgICAgICAgICAgICAgICAgICAoUHlPYmplY3QgKikg JmJwbG9jX29iamVjdF90eXBlKSA8IDApCisgICAgcmV0dXJuOworCisgIG9i c2VydmVyX2F0dGFjaF9icmVha3BvaW50X2RlbGV0ZWQgKGJwbG9jcHlfYnJl YWtwb2ludF9kZWxldGVkKTsKK30KKworc3RhdGljIFB5R2V0U2V0RGVmIGJw bG9jX29iamVjdF9nZXRzZXRbXSA9Cit7CisgIHsgIm93bmVyIiwgYnBsb2Nw eV9nZXRfb3duZXIsIE5VTEwsCisgICAgIkVhY2ggYnJlYWtwb2ludCBsb2Nh dGlvbiBtdXN0IGJlbG9uZyB0byBleGFjdGx5IG9uZSBoaWdoZXItbGV2ZWwg XAorYnJlYWtwb2ludC4gIFRoaXMgcG9pbnRlciBpcyBOVUxMIGlmZiB0aGlz IGJwX2xvY2F0aW9uIGlzIG5vIFwKK2xvbmdlciBhdHRhY2hlZCB0byBhIGJy ZWFrcG9pbnQgKHJlYWQtb25seSkuIiwKKyAgICBOVUxMIH0sCisgIHsgImVu YWJsZWQiLCBicGxvY3B5X2dldF9lbmFibGVkLCBOVUxMLAorICAgICJJcyB0 aGlzIHBhcnRpY3VsYXIgbG9jYXRpb24gZW5hYmxlZC4iLCBOVUxMIH0sCisg IHsgImFkZHJlc3MiLCBicGxvY3B5X2dldF9hZGRyZXNzLCBOVUxMLAorICAg ICJUaGUgYWRkcmVzcyBhdCB3aGljaCB0aGUgYnJlYWtwb2ludCBoYXMgYmVl biBzZXQuIiwgTlVMTCB9LAorICB7ICJpbmZlcmlvciIsIGJwbG9jcHlfZ2V0 X2luZmVyaW9yLCBOVUxMLAorICAgICJUaGUgaW5mZXJpb3IgaW4gd2hpY2gg dGhpcyBicmVha3BvaW50IGxvY2F0aW9uIGhhcyBiZWVuIHNldC4iLCBOVUxM IH0sCisgIHsgTlVMTCB9ICAvKiBTZW50aW5lbC4gICovCit9OworCisKK3N0 YXRpYyBQeU1ldGhvZERlZiBicGxvY19vYmplY3RfbWV0aG9kc1tdID0KK3sK KyAgeyAiaXNfdmFsaWQiLCBicGxvY3B5X2lzX3ZhbGlkLCBNRVRIX05PQVJH UywKKyAgICAiUmV0dXJuIHRydWUgaWYgdGhpcyBicmVha3BvaW50IGxvY2F0 aW9uIGlzIHZhbGlkLCBmYWxzZSBpZiBub3QuIiB9LAorICB7IE5VTEwgfSAv KiBTZW50aW5lbC4gICovCit9OworCitzdGF0aWMgUHlUeXBlT2JqZWN0IGJw bG9jX29iamVjdF90eXBlID0KK3sKKyAgUHlPYmplY3RfSEVBRF9JTklUIChO VUxMKQorICAwLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIC8qIG9iX3NpemUgKi8KKyAgImdkYi5CcExvY2F0aW9uIiwgICAg ICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9uYW1lICovCisgIHNpemVv ZiAoYnBsb2Nfb2JqZWN0KSwgICAgICAgICAgICAgICAgICAgICAgLyogdHBf YmFzaWNzaXplICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgLyogdHBfaXRlbXNpemUgKi8KKyAgYnBsb2NweV9k ZWFsbG9jLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9kZWFs bG9jICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgLyogdHBfcHJpbnQgKi8KKyAgMCwgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9nZXRhdHRyICovCisg IDAsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg LyogdHBfc2V0YXR0ciAqLworICAwLCAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIC8qIHRwX2NvbXBhcmUgKi8KKyAgMCwgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9y ZXByICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgLyogdHBfYXNfbnVtYmVyICovCisgIDAsICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBfYXNfc2VxdWVu Y2UgKi8KKyAgMCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAvKiB0cF9hc19tYXBwaW5nICovCisgIDAsICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBfaGFzaCAgKi8K KyAgMCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAvKiB0cF9jYWxsICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgLyogdHBfc3RyICovCisgIDAsICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBfZ2V0YXR0 cm8gKi8KKyAgMCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAvKiB0cF9zZXRhdHRybyAqLworICAwLCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIHRwX2FzX2J1ZmZlciAq LworICBQeV9UUEZMQUdTX0RFRkFVTFQgfCBQeV9UUEZMQUdTX0JBU0VUWVBF LCAgIC8qIHRwX2ZsYWdzICovCisgICJHREIgYnJlYWtwb2ludCBsb2NhdGlv biBvYmplY3QiLCAgICAgICAgICAgLyogdHBfZG9jICovCisgIDAsICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBfdHJh dmVyc2UgKi8KKyAgMCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAvKiB0cF9jbGVhciAqLworICAwLCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIHRwX3JpY2hjb21wYXJl ICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgLyogdHBfd2Vha2xpc3RvZmZzZXQgKi8KKyAgMCwgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9pdGVyICov CisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgLyogdHBfaXRlcm5leHQgKi8KKyAgYnBsb2Nfb2JqZWN0X21ldGhvZHMs ICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9tZXRob2RzICovCisgIDAs ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyog dHBfbWVtYmVycyAqLworICBicGxvY19vYmplY3RfZ2V0c2V0LCAgICAgICAg ICAgICAgICAgICAgICAgIC8qIHRwX2dldHNldCAqLworICAwLCAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIHRwX2Jhc2Ug Ki8KKyAgMCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAvKiB0cF9kaWN0ICovCisgIDAsICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgLyogdHBfZGVzY3JfZ2V0ICovCisgIDAs ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyog dHBfZGVzY3Jfc2V0ICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgLyogdHBfZGljdG9mZnNldCAqLworICAwLCAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIHRw X2luaXQgKi8KKyAgMCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAvKiB0cF9hbGxvYyAqLworfTsKZGlmZiAtLWdpdCBhL2dk Yi9weXRob24vcHktYnJlYWtwb2ludC5jIGIvZ2RiL3B5dGhvbi9weS1icmVh a3BvaW50LmMKaW5kZXggMTFkNjBmZS4uY2NjYmYwZSAxMDA2NDQKLS0tIGEv Z2RiL3B5dGhvbi9weS1icmVha3BvaW50LmMKKysrIGIvZ2RiL3B5dGhvbi9w eS1icmVha3BvaW50LmMKQEAgLTYyMCw2ICs2MjAsNDMgQEAgYnBweV9nZXRf aWdub3JlX2NvdW50IChQeU9iamVjdCAqc2VsZiwgdm9pZCAqY2xvc3VyZSkK ICAgcmV0dXJuIFB5SW50X0Zyb21Mb25nIChzZWxmX2JwLT5icC0+aWdub3Jl X2NvdW50KTsKIH0KIAorCisvKiBQeXRob24gZnVuY3Rpb24gd2hpY2ggcmV0 dXJucyB0aGUgQnBMb2NhdGlvbiBvYmplY3RzIGFzc29jaWF0ZWQKKyAgIHdp dGggdGhpcyBicmVha3BvaW50LiAgKi8KKworc3RhdGljIFB5T2JqZWN0ICoK K2JwcHlfbG9jYXRpb25zIChQeU9iamVjdCAqc2VsZiwgUHlPYmplY3QgKmFy Z3MpCit7CisgIGJyZWFrcG9pbnRfb2JqZWN0ICpzZWxmX2JwID0gKGJyZWFr cG9pbnRfb2JqZWN0ICopIHNlbGY7CisgIFB5T2JqZWN0ICpsaXN0LCAqdHVw bGU7CisgIHN0cnVjdCBicF9sb2NhdGlvbiAqbG9jOworICBpbnQgZXJyOwor CisgIEJQUFlfUkVRVUlSRV9WQUxJRCAoc2VsZl9icCk7CisKKyAgbGlzdCA9 IFB5TGlzdF9OZXcgKDApOworICBpZiAoIWxpc3QpCisgICAgcmV0dXJuIE5V TEw7CisKKyAgZXJyID0gMDsKKyAgZm9yIChsb2MgPSBzZWxmX2JwLT5icC0+ bG9jOyBsb2M7IGxvYyA9IGxvYy0+bmV4dCkKKyAgICB7CisgICAgICBQeU9i amVjdCAqbG9jX29iaiA9ICBicGxvY2F0aW9uX3RvX2JwbG9jYXRpb25fb2Jq ZWN0IChsb2MpOworICAgICAgZXJyID0gUHlMaXN0X0FwcGVuZCAobGlzdCwg bG9jX29iaik7CisgICAgICBpZiAoZXJyID09IC0xKQorICAgICAgICB7Cisg ICAgICAgICAgUHlfREVDUkVGIChsaXN0KTsKKyAgICAgICAgICByZXR1cm4g TlVMTDsKKyAgICAgICAgfQorICAgICAgUHlfREVDUkVGIChsb2Nfb2JqKTsK KyAgICB9CisKKyAgdHVwbGUgPSBQeUxpc3RfQXNUdXBsZSAobGlzdCk7Cisg IFB5X0RFQ1JFRiAobGlzdCk7CisKKyAgcmV0dXJuIHR1cGxlOworfQorCiAv KiBQeXRob24gZnVuY3Rpb24gdG8gY3JlYXRlIGEgbmV3IGJyZWFrcG9pbnQu ICAqLwogc3RhdGljIGludAogYnBweV9pbml0IChQeU9iamVjdCAqc2VsZiwg UHlPYmplY3QgKmFyZ3MsIFB5T2JqZWN0ICprd2FyZ3MpCkBAIC0xMDAzLDYg KzEwNDAsOCBAQCBzdGF0aWMgUHlNZXRob2REZWYgYnJlYWtwb2ludF9vYmpl Y3RfbWV0aG9kc1tdID0KICAgICAiUmV0dXJuIHRydWUgaWYgdGhpcyBicmVh a3BvaW50IGlzIHZhbGlkLCBmYWxzZSBpZiBub3QuIiB9LAogICB7ICJkZWxl dGUiLCBicHB5X2RlbGV0ZV9icmVha3BvaW50LCBNRVRIX05PQVJHUywKICAg ICAiRGVsZXRlIHRoZSB1bmRlcmx5aW5nIEdEQiBicmVha3BvaW50LiIgfSwK KyAgeyAibG9jYXRpb25zIiwgYnBweV9sb2NhdGlvbnMsIE1FVEhfTk9BUkdT LAorICAgICJHZXQgYSBsaXN0IG9mIGdkYi5CcExvY2F0aW9uIG9iamVjdHMg YXNzb2NpYXRlZCB3aXRoIHRoaXMgYnJlYWtwb2ludC4iIH0sCiAgIHsgTlVM TCB9IC8qIFNlbnRpbmVsLiAgKi8KIH07CiAKZGlmZiAtLWdpdCBhL2dkYi9w eXRob24vcHl0aG9uLWludGVybmFsLmggYi9nZGIvcHl0aG9uL3B5dGhvbi1p bnRlcm5hbC5oCmluZGV4IGVmMzlkNWQuLjQ5YmIzMmUgMTAwNjQ0Ci0tLSBh L2dkYi9weXRob24vcHl0aG9uLWludGVybmFsLmgKKysrIGIvZ2RiL3B5dGhv bi9weXRob24taW50ZXJuYWwuaApAQCAtMTI0LDYgKzEyNCw5IEBAIGV4dGVy biBQeVR5cGVPYmplY3Qgc3RvcF9ldmVudF9vYmplY3RfdHlwZTsKIC8qIERl ZmluZWQgaW4gcHktYnJlYWtwb2ludC5jICovCiB0eXBlZGVmIHN0cnVjdCBi cmVha3BvaW50X29iamVjdCBicmVha3BvaW50X29iamVjdDsKIAorLyogRGVm aW5lZCBpbiBweS1icGxvYy5jICovCit0eXBlZGVmIHN0cnVjdCBicGxvY19v YmplY3QgYnBsb2Nfb2JqZWN0OworCiB0eXBlZGVmIHN0cnVjdAogewogICBQ eU9iamVjdF9IRUFECkBAIC0xNzYsNiArMTc5LDggQEAgUHlPYmplY3QgKnBz cHlfZ2V0X3ByaW50ZXJzIChQeU9iamVjdCAqLCB2b2lkICopOwogUHlPYmpl Y3QgKm9iamZpbGVfdG9fb2JqZmlsZV9vYmplY3QgKHN0cnVjdCBvYmpmaWxl ICopOwogUHlPYmplY3QgKm9iamZweV9nZXRfcHJpbnRlcnMgKFB5T2JqZWN0 ICosIHZvaWQgKik7CiAKK1B5T2JqZWN0ICpicGxvY2F0aW9uX3RvX2JwbG9j YXRpb25fb2JqZWN0IChzdHJ1Y3QgYnBfbG9jYXRpb24gKmxvYyk7CisKIHRo cmVhZF9vYmplY3QgKmNyZWF0ZV90aHJlYWRfb2JqZWN0IChzdHJ1Y3QgdGhy ZWFkX2luZm8gKnRwKTsKIHRocmVhZF9vYmplY3QgKmZpbmRfdGhyZWFkX29i amVjdCAocHRpZF90IHB0aWQpOwogUHlPYmplY3QgKmZpbmRfaW5mZXJpb3Jf b2JqZWN0IChpbnQgcGlkKTsKQEAgLTIwMiw2ICsyMDcsNyBAQCB2b2lkIGdk YnB5X2luaXRpYWxpemVfZnVuY3Rpb25zICh2b2lkKTsKIHZvaWQgZ2RicHlf aW5pdGlhbGl6ZV9wc3BhY2UgKHZvaWQpOwogdm9pZCBnZGJweV9pbml0aWFs aXplX29iamZpbGUgKHZvaWQpOwogdm9pZCBnZGJweV9pbml0aWFsaXplX2Jy ZWFrcG9pbnRzICh2b2lkKTsKK3ZvaWQgZ2RicHlfaW5pdGlhbGl6ZV9icGxv Y2F0aW9uICh2b2lkKTsKIHZvaWQgZ2RicHlfaW5pdGlhbGl6ZV9sYXp5X3N0 cmluZyAodm9pZCk7CiB2b2lkIGdkYnB5X2luaXRpYWxpemVfcGFyYW1ldGVy cyAodm9pZCk7CiB2b2lkIGdkYnB5X2luaXRpYWxpemVfdGhyZWFkICh2b2lk KTsKZGlmZiAtLWdpdCBhL2dkYi9weXRob24vcHl0aG9uLmMgYi9nZGIvcHl0 aG9uL3B5dGhvbi5jCmluZGV4IGIwYjlhOWMuLmRlNmI1MWYgMTAwNjQ0Ci0t LSBhL2dkYi9weXRob24vcHl0aG9uLmMKKysrIGIvZ2RiL3B5dGhvbi9weXRo b24uYwpAQCAtMTA1OCw2ICsxMDU4LDEyIEBAIGdkYnB5X2JyZWFrcG9pbnRf aGFzX3B5X2NvbmQgKHN0cnVjdCBicmVha3BvaW50X29iamVjdCAqYnBfb2Jq KQogCQkgICAgInNjcmlwdGluZyBpcyBub3Qgc3VwcG9ydGVkLiIpKTsKIH0K IAordm9pZAorZ2RicHlfYnBsb2NhdGlvbl9mcmVlIChzdHJ1Y3QgYnJlYWtw b2ludF9vYmplY3QgKmJwX29iaikKK3sKKyAgcmV0dXJuOworfQorCiAjZW5k aWYgLyogSEFWRV9QWVRIT04gKi8KIAogDApAQCAtMTI0Nyw2ICsxMjUzLDcg QEAgRW5hYmxlcyBvciBkaXNhYmxlcyBwcmludGluZyBvZiBQeXRob24gc3Rh Y2sgdHJhY2VzLiIpLAogICBnZGJweV9pbml0aWFsaXplX3BzcGFjZSAoKTsK ICAgZ2RicHlfaW5pdGlhbGl6ZV9vYmpmaWxlICgpOwogICBnZGJweV9pbml0 aWFsaXplX2JyZWFrcG9pbnRzICgpOworICBnZGJweV9pbml0aWFsaXplX2Jw bG9jYXRpb24gKCk7CiAgIGdkYnB5X2luaXRpYWxpemVfbGF6eV9zdHJpbmcg KCk7CiAgIGdkYnB5X2luaXRpYWxpemVfdGhyZWFkICgpOwogICBnZGJweV9p bml0aWFsaXplX2luZmVyaW9yICgpOwpkaWZmIC0tZ2l0IGEvZ2RiL3B5dGhv bi9weXRob24uaCBiL2dkYi9weXRob24vcHl0aG9uLmgKaW5kZXggYWU1NWNj Mi4uY2VlOGE2YiAxMDA2NDQKLS0tIGEvZ2RiL3B5dGhvbi9weXRob24uaAor KysgYi9nZGIvcHl0aG9uL3B5dGhvbi5oCkBAIC00Nyw0ICs0Nyw2IEBAIGlu dCBnZGJweV9zaG91bGRfc3RvcCAoc3RydWN0IGJyZWFrcG9pbnRfb2JqZWN0 ICpicF9vYmopOwogCiBpbnQgZ2RicHlfYnJlYWtwb2ludF9oYXNfcHlfY29u ZCAoc3RydWN0IGJyZWFrcG9pbnRfb2JqZWN0ICpicF9vYmopOwogCit2b2lk IGdkYnB5X2JwbG9jYXRpb25fZnJlZSAoc3RydWN0IGJwX2xvY2F0aW9uICps b2MpOworCiAjZW5kaWYgLyogR0RCX1BZVEhPTl9IICovCmRpZmYgLS1naXQg YS9nZGIvdGVzdHN1aXRlL2dkYi5weXRob24vcHktYnJlYWtwb2ludC5leHAg Yi9nZGIvdGVzdHN1aXRlL2dkYi5weXRob24vcHktYnJlYWtwb2ludC5leHAK aW5kZXggZTBkZDA4Ny4uZDk0NmQ3YiAxMDA2NDQKLS0tIGEvZ2RiL3Rlc3Rz dWl0ZS9nZGIucHl0aG9uL3B5LWJyZWFrcG9pbnQuZXhwCisrKyBiL2dkYi90 ZXN0c3VpdGUvZ2RiLnB5dGhvbi9weS1icmVha3BvaW50LmV4cApAQCAtMzAx LDMgKzMwMSw1NSBAQCBnZGJfcHlfdGVzdF9zaWxlbnRfY21kICAicHl0aG9u IHdwMSA9IHdwX2V2YWwgKFwicmVzdWx0XCIsIHR5cGU9Z2RiLkJQX1dBVENI UE9JTgogZ2RiX3Rlc3QgImNvbnRpbnVlIiAiLipcW1d3XF1hdGNocG9pbnQu KnJlc3VsdC4qT2xkIHZhbHVlID0uKk5ldyB2YWx1ZSA9IDc4OC4qIiAiVGVz dCB3YXRjaHBvaW50IHdyaXRlIgogZ2RiX3Rlc3QgInB5dGhvbiBwcmludCBu ZXZlcl9ldmFsX2JwMS5jb3VudCIgIjAiIFwKICAgICAiQ2hlY2sgdGhhdCB0 aGlzIHVucmVsYXRlZCBicmVha3BvaW50cyBldmFsIGZ1bmN0aW9uIHdhcyBu ZXZlciBjYWxsZWQuIgorCisjIGdkYi5CcExvY2F0aW9uCisKKyMgU3RhcnQg d2l0aCBhIGZyZXNoIGdkYi4KK2NsZWFuX3Jlc3RhcnQgJHt0ZXN0ZmlsZX0K KworaWYgIVtydW50b19tYWluXSB0aGVuIHsKKyAgICBmYWlsICJDYW5ub3Qg cnVuIHRvIG1haW4uIgorICAgIHJldHVybiAwCit9CitkZWxldGVfYnJlYWtw b2ludHMKK2dkYl90ZXN0X25vX291dHB1dCAic2V0IGRldGFjaC1vbi1mb3Jr IG9mZiIgImRvbid0IGRldGFjaCBvbiBmb3JrIgorZ2RiX3Rlc3QgImNhbGwg Zm9yaygpIiAiTmV3IHByb2Nlc3MgLioiICJjcmVhdGUgYSBzZWNvbmQgaW5m ZXJpb3IiCisKK2dkYl9icmVha3BvaW50ICJtYWluIgorZ2RiX3Rlc3QgInB5 IHByaW50IGxlbihnZGIuYnJlYWtwb2ludHMoKSkiICIxIiAiZW5zdXJlIHRo YXQgdGhyZXJlIGlzIG9ubHkgb25lIEJQIgorZ2RiX3Rlc3Rfbm9fb3V0cHV0 IHtweSBicDAgPSBnZGIuYnJlYWtwb2ludHMoKVswXX0gInNhdmUgYnJlYWtw b2ludCAwIgorZ2RiX3Rlc3QgInB5IHByaW50IGxlbihicDAubG9jYXRpb25z KCkpIiAiMiIgImVuc3VyZSB0aGF0IHRocmVyZSBhcmUgMiBsb2NhdGlvbnMi CisKK2dkYl90ZXN0X25vX291dHB1dCB7cHkgbG9jMCA9IGJwMC5sb2NhdGlv bnMoKVswXX0gInNhdmUgbG9jYXRpb24gMCIKK2dkYl90ZXN0X25vX291dHB1 dCB7cHkgbG9jMSA9IGJwMC5sb2NhdGlvbnMoKVsxXX0gInNhdmUgbG9jYXRp b24gMSIKKworZ2RiX3Rlc3QgInB5IHByaW50IGxvYzAub3duZXIgPT0gbG9j MS5vd25lciA9PSBicDAiICJUcnVlIiAidmVyaWZ5IG93bmVyc2hpcCIKK2dk Yl90ZXN0ICJweSBwcmludCBsb2MwLmFkZHJlc3MgPT0gbG9jMS5hZGRyZXNz ICIgIlRydWUiICJ2ZXJpZnkgYWRkcmVzc2VzIGFyZSBpZGVudGljYWwiCisj IGhvdyB0byBjaGVjayBhZGRyZXNzIGxvY2F0aW9uID8gIT0gYWRkcmVzcyht YWluKQorCitnZGJfdGVzdCB7cHkgcHJpbnQgbG9jMC5pbmZlcmlvciA9PSBn ZGIuaW5mZXJpb3JzKClbMF19ICJUcnVlIiAidmVyaWZ5IGluZmVyaW9yIGZv ciBsb2MgMCIgI2luZiAyCitnZGJfdGVzdCB7cHkgcHJpbnQgbG9jMS5pbmZl cmlvciA9PSBnZGIuaW5mZXJpb3JzKClbMV19ICJUcnVlIiAidmVyaWZ5IGlu ZmVyaW9yIGZvciBsb2MgMSIgI2luZiAxCisKK2dkYl90ZXN0ICJweSBwcmlu dCBsb2MwLmVuYWJsZWQgPT0gbG9jMS5lbmFibGVkID09IFRydWUiICJUcnVl IiAidmVyaWZ5IHRoYXQgbG9jYXRpb25zIGFyZSBlbmFibGVkIgorCitnZGJf dGVzdCAicHkgcHJpbnQgbG9jMC5pbmZlcmlvci5udW0iICIyIiAiZW5zdXJl IHRoYXQgbG9jMCBpcyBvbiBpbmZlcmlvciAyIgorCitnZGJfdGVzdCAiZGV0 YWNoIGluZmVyaW9yIDIiICJEZXRhY2hpbmcgZnJvbSBwcm9ncmFtOi4qIiAi ZGV0YWNoIGluZmVyaW9yIDIiCitnZGJfdGVzdCAiaW5mZXJpb3IgMSIgIlN3 aXRjaGluZyB0byBpbmZlcmlvciAuKiIgInN3aXRjaCB0byBpbmZlcmlvciAx IgorZ2RiX3Rlc3Rfbm9fb3V0cHV0ICJyZW1vdmUtaW5mZXJpb3JzIDIiICJy ZW1vdmUgaW5mZXJpb3IgMiIKK2dkYl90ZXN0ICJweSBwcmludCBsb2MwLmlu ZmVyaW9yIiAiTm9uZSIgInJlbW92ZWQgaW5mZXJpb3Igc2V0IHRvIE5vbmUi CisKK2RlbGV0ZV9icmVha3BvaW50cworZ2RiX3Rlc3QgInB5IHByaW50IGJw MC5pc192YWxpZCgpIiAiRmFsc2UiICJ2ZXJpZnkgdGhhdCBCUCBoYXMgYmVl biBpbnZhbGlkYXRlZCIKK2dkYl90ZXN0ICJweSBicDAubG9jYXRpb25zKCki ICIuKlJ1bnRpbWVFcnJvcjogQnJlYWtwb2ludCAuKiBpcyBpbnZhbGlkLioi XAorICAgICAgICAgInZlcmlmeSB0aGF0IGxvY2F0aW9ucyBjYW4ndCBhY2Nl c3NlZCBvbiBhbiBpbnZhbGlkIGJyZWFrcG9pbnQiCisgICAgICAgICAKK2dk Yl90ZXN0ICJweSBwcmludCBsb2MwLmlzX3ZhbGlkKCkiICJGYWxzZSIgInZl cmlmeSB0aGF0IGxvY2F0aW9uIGlzIGludmFsaWQiCitnZGJfdGVzdCAicHkg cHJpbnQgbG9jMC5vd25lciIgIi4qUnVudGltZUVycm9yOiBCcExvY2F0aW9u IGludmFsaWQuKiJcCisgICAgICAgICAidmVyaWZ5IHRoYXQgb3duZXIgY2Fu J3QgYmUgYWNjZXNzZWQiCitnZGJfdGVzdCAicHkgcHJpbnQgbG9jMC5lbmFi bGVkIiAiLipSdW50aW1lRXJyb3I6IEJwTG9jYXRpb24gaW52YWxpZC4qIlwK KyAgICAgICAgICJ2ZXJpZnkgdGhhdCBsb2NhdGlvbiBjYW4ndCBiZSBhY2Nl c3NlZCIKK2dkYl90ZXN0ICJweSBwcmludCBsb2MwLmFkZHJlc3MiICIuKlJ1 bnRpbWVFcnJvcjogQnBMb2NhdGlvbiBpbnZhbGlkLioiXAorICAgICAgICAg InZlcmlmeSB0aGF0IGxvY2F0aW9uIGNhbid0IGJlIGFjY2Vzc2VkIgorZ2Ri X3Rlc3QgInB5IHByaW50IGxvYzAuaW5mZXJpb3IiICIuKlJ1bnRpbWVFcnJv cjogQnBMb2NhdGlvbiBpbnZhbGlkLioiXAorICAgICAgICAgInZlcmlmeSB0 aGF0IGluZmVyaW9yIGNhbid0IGJlIGFjY2Vzc2VkIgotLSAKMS43LjYuNAoK --f46d043c821c8b77d904b3fae9b5--