Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vkrn3-003AN3-2u for pgsql-hackers@arkaria.postgresql.org; Tue, 27 Jan 2026 22:44:06 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vkrn3-00GJaw-0E for pgsql-hackers@arkaria.postgresql.org; Tue, 27 Jan 2026 22:44:05 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vkrn2-00GJao-22 for pgsql-hackers@lists.postgresql.org; Tue, 27 Jan 2026 22:44:05 +0000 Received: from mail-qt1-x836.google.com ([2607:f8b0:4864:20::836]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1vkrn0-00000000mQK-2YMg for pgsql-hackers@lists.postgresql.org; Tue, 27 Jan 2026 22:44:04 +0000 Received: by mail-qt1-x836.google.com with SMTP id d75a77b69052e-50299648ae9so56611cf.1 for ; Tue, 27 Jan 2026 14:44:02 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1769553841; cv=none; d=google.com; s=arc-20240605; b=gvHIRZZun+bFLY+EqX7feMIY+USn+a3IMZuc9twecM9INoL4FYhhLOEkawc/fzNDIp WCYH4MZX86WHGBLePtkplLjHjr7/5GGvzfC8uHYiptUTuLRguYZJpWbd/FF7EvJXCKp2 9QaTKNnWtt/KcaLQtPksI0wFPXbVtfM+Q2W2hFgje+1CHFpronKZtNa9P1KC6igtehvn 6yU3QKAR3+jsUqLQFuCmIKevOPVLGYLlAh1Jsk7mgRzt+mQ4ltKdmor9qGlbmpE/MUrd IZyi7GoO8YBCePxOFOxL5Z6YFYqPD9YRMgV3gzmdGKkSNFisGOKYaflugTAHfF/eaVEw 6biw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:dkim-signature; bh=e1fRonf7ZmsgRfuHs2N9GaNtbeR6EBPzRG2TY3AIKgA=; fh=Lqnx0mMzpTbGx2V0kf9STfb2eloL1x79BHL7hcMm9YU=; b=IUUPFG1OT5Y9VBqoqTylUxwxScqBl51bwUw0CODnoFJwqPXYcSkMEuR0bVfmB31SQp 0AekTbN3fJny0itlC96RTdV/v0pjVhmhS9IQzL550bTUn3H9b2vnzfA5PNh1P+pylgnp 5Wh10mV4Xr1G2eNA+LagWPKxr3idoMeE3pTD5ux968Z0JQSLROX5TEPEDnmrMeQmMOMg u6YEartX7KROyPXZtrNsL8uwvVotqxvBgB6h2/Y0+xbPgU04zf42flfsOjmTFmVC5rc/ TE/ny6L3G+KXAzq7gH4KpyXuIATFk/eg7BLVFMxyeRPSj5ByHw+uLU6REQas8MQPdRhf WsdQ==; darn=lists.postgresql.org ARC-Authentication-Results: i=1; mx.google.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1769553841; x=1770158641; darn=lists.postgresql.org; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=e1fRonf7ZmsgRfuHs2N9GaNtbeR6EBPzRG2TY3AIKgA=; b=MtDKD/hw7LvTIUmQyqFBcgmVpPdg7iNm8SfUbI3UaYd/+CrEZCLVTPkG4/fv1RN3m8 R+IfmkKn9fn55fZsRcgISmDRDFvYqhZfRTURIYypotsE0LfRdgDLnHNtYnbYNHbR1vuj f412r6M1bDXRmLj9hq0Vc+vHYE44QAy05x7S8upvIGycDSOFyafNpxLOXqlRc4FXARLD 3yM7en38+4rE2GPkF2W0rduXgE1xQ44zjS50uEhYDSPklRi9xw2Ic1u3D/RBbmN00sEp IyBRblb9XiO3MojzjKJe7wP+sEoITeSrT0EwXRLu4yrysvREeK0L+WuN+GVIY8uCKPBt DbkA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1769553841; x=1770158641; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=e1fRonf7ZmsgRfuHs2N9GaNtbeR6EBPzRG2TY3AIKgA=; b=CwZyTgj0tpO8S7hiEgJ6nstt+UpK5708XvEv/r9JFEncNRsqLtjs8K1sAFIoubjLpG q1sU9wAdL+fPjfrzBb6gGLrr5JpK4kM1zR5C7DVmsbnvrJV8GYiHDVvsUZdCU4rJI0qq rxWLYCAY/iMPwUQoCkAjD1zC4iJXu31LfLwMv3DAvNGlgbKMylLsgxrPTl6kcYwfIUq0 LXAuM1cFTNiEcnwHQtBp2OWNAwk3nUuNP3fY22mdTpGOcR84wubXflBgGVWh3KT/bwIc 0FN6c++mNZ7XOrcvIDTxN1FZQwn3eZCIca8V183Z75//R36QZUyKS2lnk3EiPMSA7ONv mCHA== X-Forwarded-Encrypted: i=1; AJvYcCVU3oQyX5S4HHVelbwEIAp0vHKuRaTM2P9Am1R3Hq8SPLcwAS1LxFbwO00YwicAul2SO+nQv3oe1oNgGWUs@lists.postgresql.org X-Gm-Message-State: AOJu0Yyp/B3mDi5qAEfCMouL0fm3PWB/bZp8inMZSNn9Aiw64/g8kUqi Sz/oe4yC3yyYpn2VFj7ZiJm8DpwaSqBw/QxSzpAxr1McwgM+GjR0dDX8SyzmwQOMshaoybfr2yF fUXs9GE1XKfN4gMSoECzhWQLasQ4lrZXNexXQ4uUQ X-Gm-Gg: AZuq6aKSPgewq7AEezkiJu2wTcnCoTlW+b/teku/kPMSLvpI3sYxBbfOukHMffKeXHc FcrMy5Myv5a7j069I2Oe271CGovHtgf6QuUkKNXQM0GuETgN/XnezwG7TSdX3eBEeCHGPS49Fwj /+1gJ4g7wYeWN//ZYHqmfqJSUi0fCi6HKCb9Csw76xkqBp0Byg76LGQFhNME4K9tCcYJQiwh6aX B7Uavi+MvhUNCewubekCeZQ0c9+w2yzeafGqxU5j0R1Yg7pzo6MnpJZ7Zx4NOxuQbQ+iA== X-Received: by 2002:ac8:5702:0:b0:4ed:70d6:6618 with SMTP id d75a77b69052e-503340e2460mr9436781cf.10.1769553840337; Tue, 27 Jan 2026 14:44:00 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Hannu Krosing Date: Tue, 27 Jan 2026 23:43:44 +0100 X-Gm-Features: AZwV_QjDaDP_7jgSo9dO7eTh3yWShHimCzG3nruPrXx_dyuIcY_EXOT_QqnSU7E Message-ID: Subject: Re: Patch: dumping tables data in multiple chunks in pg_dump To: David Rowley Cc: Zsolt Parragi , Ashutosh Bapat , PostgreSQL Hackers , Nathan Bossart Content-Type: multipart/mixed; boundary="00000000000012819a0649665c42" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000012819a0649665c42 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi David Thanks for reviewing. Please hold back reviewing this v12 patch until I have verified that it passes CfBot and until I have finished my testing with 17TB table. I would appreciate pointers or help on adding the data correctness tests to the tap tests as real tests. For now I put them as DO$$ ... $$ blocks in the parallel test .pl and I check manually that the table data checksums match If we add them we should add them to other places in pg_dump tests as well. Currently we just test that dump and restore do not fail, not that the restored data is correct. On Fri, Jan 23, 2026 at 3:15=E2=80=AFAM David Rowley = wrote: > > On Fri, 23 Jan 2026 at 06:05, Hannu Krosing wrote: > > > > Fixing all the warnings > > I think overall this needs significantly more care and precision than > what you've given it so far. For example, you have: > > + if(dopt->max_table_segment_pages !=3D InvalidBlockNumber) > + appendPQExpBufferStr(query, > "pg_relation_size(c.oid)/current_setting('block_size')::int AS > relpages, "); > + else > + appendPQExpBufferStr(query, "c.relpages, "); > > Note that pg_class.relpages is "int". Later the code in master does: > > tblinfo[i].relpages =3D atoi(PQgetvalue(res, i, i_relpages)); I have now fixed the base issue by changing the data type of TableInfo.relpages to BlockNumber, and also changed the way we get it by 1. converting it to unsigned int ( c.relpages::oid ) in the query 2. reading it from the result using strtoul() (technically it should have been enough to just use strtoul() as it already wraps signed ints to unsigned ones, but having it converted in the query seems cleaner) This allowed removing casts to (BlockNumber) everywhere where .relpages was used. Functionally value was ever only used for ordering and even this loosley, which explains why patch v10 did not break anything. I also changed the data type of TocEntry.dataLength from pgoff_t to uint64. The current clearly had an overflow in case when off_t was 32 bit and sum of relpages from heap and toast was larger than allowed for it. > If you look in vacuum.c, you'll see "pgcform->relpages =3D (int32) > num_pages;" that the value stored in relpages will be negative when > the table is >=3D 16TB (assuming 8k pages). Your pg_relation_size > expression is not going to produce an INT. It'll produce a BIGINT, per > "select pg_typeof(pg_relation_size('pg_class') / > current_setting('block_size')::int);". So the atoi() can receive a > string of digits representing an integer larger than INT_MAX in this > case. Looking at [1], I see: As said above this should be fixed now by using correct type in struch and strtoul(). To be sure I have now created a 17TB table and running some tests on this as well. Will let you know here when done. > "7.22.1 Numeric conversion functions 1 The functions atof, atoi, atol, > and atoll need not affect the value of the integer expression errno on > an error. If the value of the result cannot be represented, *the > behavior is undefined.*" > > And testing locally, I see that my Microsoft compiler will just return > INT_MAX on overflow, whereas I see gcc does nothing to prevent > overflows and just continues to multiply by 10 regardless of what > overflows occur, which I think would just make the code work by > accident. As .relpages was only ever used for ordering parallel copies it does work just not optimally. The old code has similar overflow/wraparound for case when off_t is 32 bit int and the sum of relpages from heap and toast table is above INT_MAX I have removed the whole part where this was partially fixed for the case when one of them was > 0x7fffffff (i.e. negative) by pinning the dataLength to INT_MAX in that case > Aside from that, nothing in the documentation mentions that this is > for "heap" tables only. That should be mentioned as it'll just result > in people posting questions about why it's not working for some other > table access method. There's also not much care for white space. > You've introduced a bunch of whitespace changes unrelated to code > changes you've made, plus there's not much regard for following > project standard. For example, you commonly do "if(" and don't > consistently follow the bracing rules, e.g: > > + for(chkptr =3D optarg; *chkptr !=3D '\0'; chkptr++) > + if(*chkptr =3D=3D '-') I assumed that it is the classical "single statemet -- no braces. Do we have a writeup of our coding standards somewhere ? Now this specific case is rewritten using while() so shoud be ok. > Things like the following help convey the level of care that's gone into = this: > > +/* > + * option_parse_int > + * > + * Parse integer value for an option. If the parsing is successful, ret= urns > + * true and stores the result in *result if that's given; if parsing fai= ls, > + * returns false. > + */ > +bool > +option_parse_uint32(const char *optarg, const char *optname, > > i.e zero effort gone in to modify the comments after pasting them from > option_parse_int(). > > Another example: > > + pg_log_error("%s musst be in range %lu..%lu", > > Also, I have no comprehension of why you'd use uint64 for the valid > range when the function is for processing uint32 types in: The uint64 there I picked up from the referenced long unsigned usage in pg_resetval after I managed to get pg_log_warning to print out -1 for format %u and did not want to go to debug why that happens. I have now made all the arguments uint32 > +bool > +option_parse_uint32(const char *optarg, const char *optname, > + uint64 min_range, uint64 max_range, > + uint32 *result) > > In its current state, it's quite hard to take this patch seriously. > Please spend longer self-reviewing it before posting. You could > temporarily hard-code something for testing which makes at least 1 > table appear to be larger than 16TB and ensure your code works. What > you have is visually broken and depends on whatever the atoi > implementation opts to do in the overflow case. These are all things > diligent commiters will be testing and it's sad to see how little > effort you're putting into this. How do you expect this community to > scale with this quality level of patch submissions? You've been around > long enough and should know and do better. Are you just expecting the > committer to fix these things for you? That work does not get done via > magic wand. Being on v10 already, I'd have expected the patch to be > far beyond proof of concept grade. If you're withholding investing > time on this until you see more community buy-in, then I'd suggest you > write that and withhold further revisions until you're happy with the > level of buy-in. > I'm also still not liking your de-normalised TableInfo representation > for "is_segment". > IMO, InvalidBlockNumber should be used to represent > open bounded ranges, and if there's no chunking, then startPage and > endPage will both be InvalidBlockNumber. That's what I ended up doing I switched to using startPage =3D InvalidBlockNumber to indicate that no chunking is in effect. This is safe because when chunking is in use I always try to set both chunk end pages, and lower bound I can always set the lower bound. Only for the last page is the endPage left to InvalidBlockNumber. > IMO, what you have now > needlessly allows invalid states where is_segment =3D=3D true and > startPage, endPage are not set correctly. If you want to keep the code > simple, hide the complexity in a macro or an inline function. There's > just no performance reason to materialise the more complex condition > into a dedicated boolean flag. --00000000000012819a0649665c42 Content-Type: text/x-patch; charset="US-ASCII"; name="v12-0001-changed-flag-name-to-max-table-segment-pages.patch" Content-Disposition: attachment; filename="v12-0001-changed-flag-name-to-max-table-segment-pages.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkx557nq0 RnJvbSAyYjc2YzgyNDJmZTliMWIyOTRiNWFkNDQzNjEyZmU1ODNlNTE3OTJhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBIYW5udSBLcm9zaW5nIDxoYW5udWtAZ29vZ2xlLmNvbT4KRGF0 ZTogVHVlLCAyNyBKYW4gMjAyNiAyMjo1MTowMyArMDEwMApTdWJqZWN0OiBbUEFUQ0ggdjEyXSAq IGNoYW5nZWQgZmxhZyBuYW1lIHRvIG1heC10YWJsZS1zZWdtZW50LXBhZ2VzICogYWRkZWQKIGNo ZWNrIGZvciBhbW5hbWUgPSAiaGVhcCIgKiBhZGRlZCBzaW1wbGUgY2h1bmtlZCBkdW1wIGFuZCBy ZXN0b3JlIHRlc3QgKgogY2hhbmdlZCB0aGUgZGF0YSB0eXBlIG9mIFRhYmxlSW5mby5yZWxwYWdl cyB0byBCbG9ja051bWJlciwgICAqIHNlbGVjdCBpdAogdXNpbmcgcmVscGFnZXM6b2lkIHRvIGdl dCB1bnNpZ25lZCBpbnQgb3V0ICAgKiByZWFkIGl0IGluIGZyb20gcXVlcnkgcmVzdWx0CiB1c2lu ZyBzdHJ0b3VsKCkgICAqIHJlbW92ZWQgYSBidW5jaCBvZiBjYXN0cyBmcm9tIC5yZWxwYWdlcyB0 byAoQmxvY051bWJlcikgKgogY2hhbmdlZCB0aGUgZGF0YSB0eXBlIG9mIFRvY0VudHJ5LmRhdGFM ZW5ndGggdG8gdWludDY0ICAgY3VycmVudCBwZ29mZl90CiBjZXJ0YWlubHkgaGFkIGFuIG92ZXJm bG93IGluIDMyYml0IGNhc2Ugd2hlbiBoZWFwIHJlbHBhZ2VzICsgdG9hc3QgcmVscGFnZXMgPgog SU5UX01BWCAqIHN3aXRjaGVkIHRvIHVzaW5nIG9mCiBwZ19yZWxhdGlvbl9zaXplKGMub2lkKS9j dXJyZW50X3NldHRpbmcoJ2Jsb2NrX3NpemUnKTo6aW50IHdoZW4KIC0tbWF4LXRhYmxlLXNlZ21l bnQtcGFnZXMgaXMgc2V0ICogYWRkZWQgZG9jdW1lbnRhdGlvbiAqIGFkZGVkCiBvcHRpb25fcGFy c2VfdWludDMyKC4uLikgdG8gYmUgdXNlZCBmb3IgZnVsbCByYW5nZSBvZiBwYWdlcyBudW1iZXJz CgoqIFRFU1RTOiBhZGRlZCBhIFdBUk5JTkcgd2l0aCBjb3VudCBhbmQgdGFibGUgZGF0YSBoYXNo IHRvIHNvdXJjZSBhbmQgY2h1bmtlZCByZXN0b3JlIGRhdGFiYXNlCi0tLQogZG9jL3NyYy9zZ21s L3JlZi9wZ19kdW1wLnNnbWwgICAgICAgICAgICAgfCAgMjQgKysrCiBzcmMvYmluL3BnX2R1bXAv cGdfYmFja3VwLmggICAgICAgICAgICAgICB8ICAgMiArCiBzcmMvYmluL3BnX2R1bXAvcGdfYmFj a3VwX2FyY2hpdmVyLmMgICAgICB8ICAgMiArCiBzcmMvYmluL3BnX2R1bXAvcGdfYmFja3VwX2Fy Y2hpdmVyLmggICAgICB8ICAgMiArLQogc3JjL2Jpbi9wZ19kdW1wL3BnX2R1bXAuYyAgICAgICAg ICAgICAgICAgfCAxNjkgKysrKysrKysrKysrKysrKystLS0tLQogc3JjL2Jpbi9wZ19kdW1wL3Bn X2R1bXAuaCAgICAgICAgICAgICAgICAgfCAgMjIgKystCiBzcmMvYmluL3BnX2R1bXAvdC8wMDRf cGdfZHVtcF9wYXJhbGxlbC5wbCB8ICA1MiArKysrKysrCiBzcmMvZmVfdXRpbHMvb3B0aW9uX3V0 aWxzLmMgICAgICAgICAgICAgICB8ICA1NSArKysrKysrCiBzcmMvaW5jbHVkZS9mZV91dGlscy9v cHRpb25fdXRpbHMuaCAgICAgICB8ICAgMyArCiA5IGZpbGVzIGNoYW5nZWQsIDI4OSBpbnNlcnRp b25zKCspLCA0MiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kb2Mvc3JjL3NnbWwvcmVmL3Bn X2R1bXAuc2dtbCBiL2RvYy9zcmMvc2dtbC9yZWYvcGdfZHVtcC5zZ21sCmluZGV4IDY4OGUyM2Mw ZTkwLi4xODExYzY3ZDE0MSAxMDA2NDQKLS0tIGEvZG9jL3NyYy9zZ21sL3JlZi9wZ19kdW1wLnNn bWwKKysrIGIvZG9jL3NyYy9zZ21sL3JlZi9wZ19kdW1wLnNnbWwKQEAgLTEwODgsNiArMTA4OCwz MCBAQCBQb3N0Z3JlU1FMIGRvY3VtZW50YXRpb24KICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgIDwv dmFybGlzdGVudHJ5PgogCisgICAgIDx2YXJsaXN0ZW50cnk+CisgICAgICA8dGVybT48b3B0aW9u Pi0tbWF4LXRhYmxlLXNlZ21lbnQtcGFnZXM9PHJlcGxhY2VhYmxlIGNsYXNzPSJwYXJhbWV0ZXIi Pm5wYWdlczwvcmVwbGFjZWFibGU+PC9vcHRpb24+PC90ZXJtPgorICAgICAgPGxpc3RpdGVtPgor ICAgICAgIDxwYXJhPgorICAgICAgICBEdW1wIGRhdGEgaW4gc2VnbWVudHMgYmFzZWQgb24gbnVt YmVyIG9mIHBhZ2VzIGluIHRoZSBtYWluIHJlbGF0aW9uLgorICAgICAgICBJZiB0aGUgbnVtYmVy IG9mIGRhdGEgcGFnZXMgaW4gdGhlIHJlbGF0aW9uIGlzIG1vcmUgdGhhbiA8cmVwbGFjZWFibGUg Y2xhc3M9InBhcmFtZXRlciI+bnBhZ2VzPC9yZXBsYWNlYWJsZT4gCisgICAgICAgIHRoZSBkYXRh IGlzIHNwbGl0IGludG8gc2VnbWVudHMgYmFzZWQgb24gdGhhdCBudW1iZXIgb2YgcGFnZXMuCisg ICAgICAgIEluZGl2aWR1YWwgc2VnbWVudHMgY2FuIGJlIGR1bXBlZCBpbiBwYXJhbGxlbC4KKyAg ICAgICA8L3BhcmE+CisKKyAgICAgICA8bm90ZT4KKyAgICAgICAgPHBhcmE+CisgICAgICAgICBU aGUgb3B0aW9uIDxvcHRpb24+LS1tYXgtdGFibGUtc2VnbWVudC1wYWdlczwvb3B0aW9uPiBpcyBh cHBsaWVkIHRvIG9ubHkgcGFnZXMKKyAgICAgICAgIGluIHRoZSBtYWluIGhlYXAgYW5kIGlmIHRo ZSB0YWJsZSBoYXMgYSBsYXJnZSBUT0FTVGVkIHBhcnQgdGhpcyBoYXMgdG8gYmUKKyAgICAgICAg IHRha2VuIGludG8gYWNjb3VudCB3aGVuIGRlY2lkaW5nIG9uIHRoZSBudW1iZXIgb2YgcGFnZXMg dG8gdXNlLgorICAgICAgICAgSW4gdGhlIGV4dHJlbWUgY2FzZSBhIHNpbmdsZSA4a0IgaGVhcCBw YWdlIGNhbiBoYXZlIH4yMDAgdG9hc3QgcG9pbnRlcnMgZWFjaCAKKyAgICAgICAgIGNvcnJlc3Bv bmRpbmcgdG8gMUdCIG9mIGRhdGEuIElmIHRoaXMgZGF0YSBpcyBhbHNvIG5vbi1jb21wcmVzc2li bGUgdGhlbiBhIAorICAgICAgICAgc2luZ2xlLXBhZ2Ugc2VnbWVudCBjYW4gZHVtcCBhcyAyMDBH QiBmaWxlLgorICAgICAgICA8L3BhcmE+CisgICAgICAgPC9ub3RlPgorCisgICAgICA8L2xpc3Rp dGVtPgorICAgICA8L3Zhcmxpc3RlbnRyeT4KKwogICAgICA8dmFybGlzdGVudHJ5PgogICAgICAg PHRlcm0+PG9wdGlvbj4tLW5vLWNvbW1lbnRzPC9vcHRpb24+PC90ZXJtPgogICAgICAgPGxpc3Rp dGVtPgpkaWZmIC0tZ2l0IGEvc3JjL2Jpbi9wZ19kdW1wL3BnX2JhY2t1cC5oIGIvc3JjL2Jpbi9w Z19kdW1wL3BnX2JhY2t1cC5oCmluZGV4IGQ5MDQxZGFkNzIwLi5iNjNhZTA1ZDg5NSAxMDA2NDQK LS0tIGEvc3JjL2Jpbi9wZ19kdW1wL3BnX2JhY2t1cC5oCisrKyBiL3NyYy9iaW4vcGdfZHVtcC9w Z19iYWNrdXAuaApAQCAtMjcsNiArMjcsNyBAQAogI2luY2x1ZGUgImNvbW1vbi9maWxlX3V0aWxz LmgiCiAjaW5jbHVkZSAiZmVfdXRpbHMvc2ltcGxlX2xpc3QuaCIKICNpbmNsdWRlICJsaWJwcS1m ZS5oIgorI2luY2x1ZGUgInN0b3JhZ2UvYmxvY2suaCIKIAogCiB0eXBlZGVmIGVudW0gdHJpdmFs dWUKQEAgLTE3OCw2ICsxNzksNyBAQCB0eXBlZGVmIHN0cnVjdCBfZHVtcE9wdGlvbnMKIAlib29s CQlhY2xzU2tpcDsKIAljb25zdCBjaGFyICpsb2NrV2FpdFRpbWVvdXQ7CiAJaW50CQkJZHVtcF9p bnNlcnRzOwkvKiAwID0gQ09QWSwgb3RoZXJ3aXNlIHJvd3MgcGVyIElOU0VSVCAqLworCUJsb2Nr TnVtYmVyCW1heF90YWJsZV9zZWdtZW50X3BhZ2VzOyAvKiBjaHVuayB3aGVuIHJlbHBhZ2VzIGlz IGFib3ZlIHRoaXMgKi8KIAogCS8qIGZsYWdzIGZvciB2YXJpb3VzIGNvbW1hbmQtbGluZSBsb25n IG9wdGlvbnMgKi8KIAlpbnQJCQlkaXNhYmxlX2RvbGxhcl9xdW90aW5nOwpkaWZmIC0tZ2l0IGEv c3JjL2Jpbi9wZ19kdW1wL3BnX2JhY2t1cF9hcmNoaXZlci5jIGIvc3JjL2Jpbi9wZ19kdW1wL3Bn X2JhY2t1cF9hcmNoaXZlci5jCmluZGV4IDRhNjNmNzM5MmFlLi5lZDE5MTNkNjZiYyAxMDA2NDQK LS0tIGEvc3JjL2Jpbi9wZ19kdW1wL3BnX2JhY2t1cF9hcmNoaXZlci5jCisrKyBiL3NyYy9iaW4v cGdfZHVtcC9wZ19iYWNrdXBfYXJjaGl2ZXIuYwpAQCAtNDQsNiArNDQsNyBAQAogI2luY2x1ZGUg InBnX2JhY2t1cF9hcmNoaXZlci5oIgogI2luY2x1ZGUgInBnX2JhY2t1cF9kYi5oIgogI2luY2x1 ZGUgInBnX2JhY2t1cF91dGlscy5oIgorI2luY2x1ZGUgInN0b3JhZ2UvYmxvY2suaCIKIAogI2Rl ZmluZSBURVhUX0RVTVBfSEVBREVSICItLVxuLS0gUG9zdGdyZVNRTCBkYXRhYmFzZSBkdW1wXG4t LVxuXG4iCiAjZGVmaW5lIFRFWFRfRFVNUEFMTF9IRUFERVIgIi0tXG4tLSBQb3N0Z3JlU1FMIGRh dGFiYXNlIGNsdXN0ZXIgZHVtcFxuLS1cblxuIgpAQCAtMTU0LDYgKzE1NSw3IEBAIEluaXREdW1w T3B0aW9ucyhEdW1wT3B0aW9ucyAqb3B0cykKIAlvcHRzLT5kdW1wU2NoZW1hID0gdHJ1ZTsKIAlv cHRzLT5kdW1wRGF0YSA9IHRydWU7CiAJb3B0cy0+ZHVtcFN0YXRpc3RpY3MgPSBmYWxzZTsKKwlv cHRzLT5tYXhfdGFibGVfc2VnbWVudF9wYWdlcyA9IEludmFsaWRCbG9ja051bWJlcjsKIH0KIAog LyoKZGlmZiAtLWdpdCBhL3NyYy9iaW4vcGdfZHVtcC9wZ19iYWNrdXBfYXJjaGl2ZXIuaCBiL3Ny Yy9iaW4vcGdfZHVtcC9wZ19iYWNrdXBfYXJjaGl2ZXIuaAppbmRleCAzMjViNTNmYzliZC4uYjZh OWYxNmExMjIgMTAwNjQ0Ci0tLSBhL3NyYy9iaW4vcGdfZHVtcC9wZ19iYWNrdXBfYXJjaGl2ZXIu aAorKysgYi9zcmMvYmluL3BnX2R1bXAvcGdfYmFja3VwX2FyY2hpdmVyLmgKQEAgLTM3Nyw3ICsz NzcsNyBAQCBzdHJ1Y3QgX3RvY0VudHJ5CiAJc2l6ZV90CQlkZWZuTGVuOwkJLyogbGVuZ3RoIG9m IGR1bXBlZCBkZWZpbml0aW9uICovCiAKIAkvKiB3b3JraW5nIHN0YXRlIHdoaWxlIGR1bXBpbmcv cmVzdG9yaW5nICovCi0JcGdvZmZfdAkJZGF0YUxlbmd0aDsJCS8qIGl0ZW0ncyBkYXRhIHNpemU7 IDAgaWYgbm9uZSBvciB1bmtub3duICovCisJdWludDY0CQlkYXRhTGVuZ3RoOwkJLyogaXRlbSdz IGRhdGEgc2l6ZTsgMCBpZiBub25lIG9yIHVua25vd24gKi8KIAlpbnQJCQlyZXFzOwkJCS8qIGRv IHdlIG5lZWQgc2NoZW1hIGFuZC9vciBkYXRhIG9mIG9iamVjdAogCQkJCQkJCQkgKiAoUkVRXyog Yml0IG1hc2spICovCiAJYm9vbAkJY3JlYXRlZDsJCS8qIHNldCBmb3IgREFUQSBtZW1iZXIgaWYg VEFCTEUgd2FzIGNyZWF0ZWQgKi8KZGlmZiAtLWdpdCBhL3NyYy9iaW4vcGdfZHVtcC9wZ19kdW1w LmMgYi9zcmMvYmluL3BnX2R1bXAvcGdfZHVtcC5jCmluZGV4IDY4N2RjOThlNDZkLi4wYmFkYjI0 NWI1NSAxMDA2NDQKLS0tIGEvc3JjL2Jpbi9wZ19kdW1wL3BnX2R1bXAuYworKysgYi9zcmMvYmlu L3BnX2R1bXAvcGdfZHVtcC5jCkBAIC01MzksNiArNTM5LDcgQEAgbWFpbihpbnQgYXJnYywgY2hh ciAqKmFyZ3YpCiAJCXsiZXhjbHVkZS1leHRlbnNpb24iLCByZXF1aXJlZF9hcmd1bWVudCwgTlVM TCwgMTd9LAogCQl7InNlcXVlbmNlLWRhdGEiLCBub19hcmd1bWVudCwgJmRvcHQuc2VxdWVuY2Vf ZGF0YSwgMX0sCiAJCXsicmVzdHJpY3Qta2V5IiwgcmVxdWlyZWRfYXJndW1lbnQsIE5VTEwsIDI1 fSwKKwkJeyJtYXgtdGFibGUtc2VnbWVudC1wYWdlcyIsIHJlcXVpcmVkX2FyZ3VtZW50LCBOVUxM LCAyNn0sCiAKIAkJe05VTEwsIDAsIE5VTEwsIDB9CiAJfTsKQEAgLTgwMyw2ICs4MDQsMTMgQEAg bWFpbihpbnQgYXJnYywgY2hhciAqKmFyZ3YpCiAJCQkJZG9wdC5yZXN0cmljdF9rZXkgPSBwZ19z dHJkdXAob3B0YXJnKTsKIAkJCQlicmVhazsKIAorCQkJY2FzZSAyNjoKKwkJCQlpZiAoIW9wdGlv bl9wYXJzZV91aW50MzIob3B0YXJnLCAiLS1tYXgtdGFibGUtc2VnbWVudC1wYWdlcyIsIDEsIE1h eEJsb2NrTnVtYmVyLAorCQkJCQkJCQkJICAmZG9wdC5tYXhfdGFibGVfc2VnbWVudF9wYWdlcykp CisJCQkJCWV4aXRfbmljZWx5KDEpOworCQkJCXBnX2xvZ193YXJuaW5nKCJDSFVOS0lORzogc2V0 IGRvcHQubWF4X3RhYmxlX3NlZ21lbnRfcGFnZXMgdG8gWyV1XSIsIGRvcHQubWF4X3RhYmxlX3Nl Z21lbnRfcGFnZXMpOworCQkJCWJyZWFrOworCiAJCQlkZWZhdWx0OgogCQkJCS8qIGdldG9wdF9s b25nIGFscmVhZHkgZW1pdHRlZCBhIGNvbXBsYWludCAqLwogCQkJCXBnX2xvZ19lcnJvcl9oaW50 KCJUcnkgXCIlcyAtLWhlbHBcIiBmb3IgbW9yZSBpbmZvcm1hdGlvbi4iLCBwcm9nbmFtZSk7CkBA IC0xMzcyLDYgKzEzODAsOSBAQCBoZWxwKGNvbnN0IGNoYXIgKnByb2duYW1lKQogCXByaW50Zihf KCIgIC0tZXh0cmEtZmxvYXQtZGlnaXRzPU5VTSAgICAgb3ZlcnJpZGUgZGVmYXVsdCBzZXR0aW5n IGZvciBleHRyYV9mbG9hdF9kaWdpdHNcbiIpKTsKIAlwcmludGYoXygiICAtLWZpbHRlcj1GSUxF TkFNRSAgICAgICAgICAgIGluY2x1ZGUgb3IgZXhjbHVkZSBvYmplY3RzIGFuZCBkYXRhIGZyb20g ZHVtcFxuIgogCQkJICIgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYmFzZWQgb24gZXhw cmVzc2lvbnMgaW4gRklMRU5BTUVcbiIpKTsKKwlwcmludGYoXygiICAtLW1heC10YWJsZS1zZWdt ZW50LXBhZ2VzPU5VTVBBR0VTXG4iCisJCSAgICAgIiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBOdW1iZXIgb2YgbWFpbiB0YWJsZSBwYWdlcyBhYm92ZSB3aGljaCBkYXRhIGlzIFxuIgor CQkJICIgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29waWVkIG91dCBpbiBjaHVua3Ms IGFsc28gZGV0ZXJtaW5lcyB0aGUgY2h1bmsgc2l6ZVxuIikpOwogCXByaW50ZihfKCIgIC0taWYt ZXhpc3RzICAgICAgICAgICAgICAgICAgdXNlIElGIEVYSVNUUyB3aGVuIGRyb3BwaW5nIG9iamVj dHNcbiIpKTsKIAlwcmludGYoXygiICAtLWluY2x1ZGUtZm9yZWlnbi1kYXRhPVBBVFRFUk5cbiIK IAkJCSAiICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluY2x1ZGUgZGF0YSBvZiBmb3Jl aWduIHRhYmxlcyBvbiBmb3JlaWduXG4iCkBAIC0yNDEyLDcgKzI0MjMsNyBAQCBkdW1wVGFibGVE YXRhX2NvcHkoQXJjaGl2ZSAqZm91dCwgY29uc3Qgdm9pZCAqZGNvbnRleHQpCiAJICogYSBmaWx0 ZXIgY29uZGl0aW9uIHdhcyBzcGVjaWZpZWQuICBGb3Igb3RoZXIgY2FzZXMgYSBzaW1wbGUgQ09Q WQogCSAqIHN1ZmZpY2VzLgogCSAqLwotCWlmICh0ZGluZm8tPmZpbHRlcmNvbmQgfHwgdGJpbmZv LT5yZWxraW5kID09IFJFTEtJTkRfRk9SRUlHTl9UQUJMRSkKKwlpZiAodGRpbmZvLT5maWx0ZXJj b25kIHx8IGlzX3NlZ21lbnQodGRpbmZvKSB8fCB0YmluZm8tPnJlbGtpbmQgPT0gUkVMS0lORF9G T1JFSUdOX1RBQkxFKQogCXsKIAkJLyogVGVtcG9yYXJ5IGFsbG93cyB0byBhY2Nlc3MgdG8gZm9y ZWlnbiB0YWJsZXMgdG8gZHVtcCBkYXRhICovCiAJCWlmICh0YmluZm8tPnJlbGtpbmQgPT0gUkVM S0lORF9GT1JFSUdOX1RBQkxFKQpAQCAtMjQyOCw5ICsyNDM5LDIzIEBAIGR1bXBUYWJsZURhdGFf Y29weShBcmNoaXZlICpmb3V0LCBjb25zdCB2b2lkICpkY29udGV4dCkKIAkJZWxzZQogCQkJYXBw ZW5kUFFFeHBCdWZmZXJTdHIocSwgIiogIik7CiAKLQkJYXBwZW5kUFFFeHBCdWZmZXIocSwgIkZS T00gJXMgJXMpIFRPIHN0ZG91dDsiLAorCQlhcHBlbmRQUUV4cEJ1ZmZlcihxLCAiRlJPTSAlcyAl cyIsCiAJCQkJCQkgIGZtdFF1YWxpZmllZER1bXBhYmxlKHRiaW5mbyksCiAJCQkJCQkgIHRkaW5m by0+ZmlsdGVyY29uZCA/IHRkaW5mby0+ZmlsdGVyY29uZCA6ICIiKTsKKwkJaWYgKGlzX3NlZ21l bnQodGRpbmZvKSkKKwkJeworCQkJYXBwZW5kUFFFeHBCdWZmZXJTdHIocSwgdGRpbmZvLT5maWx0 ZXJjb25kPyIgQU5EICI6IiBXSEVSRSAiKTsKKwkJCWlmKHRkaW5mby0+c3RhcnRQYWdlID09IDAp CisJCQkJYXBwZW5kUFFFeHBCdWZmZXIocSwgImN0aWQgPD0gJygldSwzMjAwMCknIiwgdGRpbmZv LT5lbmRQYWdlKTsJCQkKKwkJCWVsc2UgaWYodGRpbmZvLT5lbmRQYWdlICE9IEludmFsaWRCbG9j a051bWJlcikKKwkJCQlhcHBlbmRQUUV4cEJ1ZmZlcihxLCAiY3RpZCBCRVRXRUVOICcoJXUsMSkn IEFORCAnKCV1LDMyMDAwKSciLAorCQkJCQkJCQkgdGRpbmZvLT5zdGFydFBhZ2UsIHRkaW5mby0+ ZW5kUGFnZSk7CisJCQllbHNlCisJCQkJYXBwZW5kUFFFeHBCdWZmZXIocSwgImN0aWQgPj0gJygl dSwxKSciLCB0ZGluZm8tPnN0YXJ0UGFnZSk7CisJCQlwZ19sb2dfd2FybmluZygiQ0hVTktJTkc6 IHBhZ2VzIFsldToldV0iLHRkaW5mby0+c3RhcnRQYWdlLCB0ZGluZm8tPmVuZFBhZ2UpOworCQl9 CisKKwkJYXBwZW5kUFFFeHBCdWZmZXIocSwgIikgVE8gc3Rkb3V0OyIpOwogCX0KIAllbHNlCiAJ ewpAQCAtMjQzOCw2ICsyNDYzLDkgQEAgZHVtcFRhYmxlRGF0YV9jb3B5KEFyY2hpdmUgKmZvdXQs IGNvbnN0IHZvaWQgKmRjb250ZXh0KQogCQkJCQkJICBmbXRRdWFsaWZpZWREdW1wYWJsZSh0Ymlu Zm8pLAogCQkJCQkJICBjb2x1bW5fbGlzdCk7CiAJfQorCisJcGdfbG9nX3dhcm5pbmcoIkNIVU5L SU5HOiBkYXRhIHF1ZXJ5OiAlcyIsIHEtPmRhdGEpOworCQogCXJlcyA9IEV4ZWN1dGVTcWxRdWVy eShmb3V0LCBxLT5kYXRhLCBQR1JFU19DT1BZX09VVCk7CiAJUFFjbGVhcihyZXMpOwogCWRlc3Ry b3lQUUV4cEJ1ZmZlcihjbGlzdEJ1Zik7CkBAIC0yOTMzLDQyICsyOTYxLDk1IEBAIGR1bXBUYWJs ZURhdGEoQXJjaGl2ZSAqZm91dCwgY29uc3QgVGFibGVEYXRhSW5mbyAqdGRpbmZvKQogCXsKIAkJ VG9jRW50cnkgICAqdGU7CiAKLQkJdGUgPSBBcmNoaXZlRW50cnkoZm91dCwgdGRpbmZvLT5kb2Jq LmNhdElkLCB0ZGluZm8tPmRvYmouZHVtcElkLAotCQkJCQkJICBBUkNISVZFX09QVFMoLnRhZyA9 IHRiaW5mby0+ZG9iai5uYW1lLAotCQkJCQkJCQkJICAgLm5hbWVzcGFjZSA9IHRiaW5mby0+ZG9i ai5uYW1lc3BhY2UtPmRvYmoubmFtZSwKLQkJCQkJCQkJCSAgIC5vd25lciA9IHRiaW5mby0+cm9s bmFtZSwKLQkJCQkJCQkJCSAgIC5kZXNjcmlwdGlvbiA9ICJUQUJMRSBEQVRBIiwKLQkJCQkJCQkJ CSAgIC5zZWN0aW9uID0gU0VDVElPTl9EQVRBLAotCQkJCQkJCQkJICAgLmNyZWF0ZVN0bXQgPSB0 ZERlZm4sCi0JCQkJCQkJCQkgICAuY29weVN0bXQgPSBjb3B5U3RtdCwKLQkJCQkJCQkJCSAgIC5k ZXBzID0gJih0YmluZm8tPmRvYmouZHVtcElkKSwKLQkJCQkJCQkJCSAgIC5uRGVwcyA9IDEsCi0J CQkJCQkJCQkgICAuZHVtcEZuID0gZHVtcEZuLAotCQkJCQkJCQkJICAgLmR1bXBBcmcgPSB0ZGlu Zm8pKTsKLQotCQkvKgotCQkgKiBTZXQgdGhlIFRvY0VudHJ5J3MgZGF0YUxlbmd0aCBpbiBjYXNl IHdlIGFyZSBkb2luZyBhIHBhcmFsbGVsIGR1bXAKLQkJICogYW5kIHdhbnQgdG8gb3JkZXIgZHVt cCBqb2JzIGJ5IHRhYmxlIHNpemUuICBXZSBjaG9vc2UgdG8gbWVhc3VyZQotCQkgKiBkYXRhTGVu Z3RoIGluIHRhYmxlIHBhZ2VzIChpbmNsdWRpbmcgVE9BU1QgcGFnZXMpIGR1cmluZyBkdW1wLCBz bwotCQkgKiBubyBzY2FsaW5nIGlzIG5lZWRlZC4KLQkJICoKLQkJICogSG93ZXZlciwgcmVscGFn ZXMgaXMgZGVjbGFyZWQgYXMgImludGVnZXIiIGluIHBnX2NsYXNzLCBhbmQgaGVuY2UKLQkJICog YWxzbyBpbiBUYWJsZUluZm8sIGJ1dCBpdCdzIHJlYWxseSBCbG9ja051bWJlciBhL2svYSB1bnNp Z25lZCBpbnQuCi0JCSAqIENhc3Qgc28gdGhhdCB3ZSBnZXQgdGhlIHJpZ2h0IGludGVycHJldGF0 aW9uIG9mIHRhYmxlIHNpemVzCi0JCSAqIGV4Y2VlZGluZyBJTlRfTUFYIHBhZ2VzLgorCQkvKiBk YXRhIGNodW5raW5nIHdvcmtzIG9mZiByZWxwYWdlcywgd2hpY2ggYXJlIGNvbXB1dGVkIGV4YWN0 bHkgdXNpbmcKKwkJICogcGdfcmVsYXRpb25fc2l6ZSgpIHdoZW4gLS1tYXgtdGFibGUtc2VnbWVu dC1wYWdlcyB3YXMgc2V0CisJCSAqIAorCQkgKiBXZSBhbHNvIGRvbid0IGNodW5rIGlmIHRhYmxl IGFjY2VzcyBtZXRob2QgaXMgbm90ICJoZWFwIgorCQkgKiBUT0RPOiB3ZSBtYXkgYWRkIGNodW5r aW5nIGZvciBvdGhlciBhY2Nlc3MgbWV0aG9kcyBsYXRlciwgbWF5YmUgCisJCSAqIGJhc2VkIG9u IHByaW1hcnkga2V5IHRyYW5nZXMKIAkJICovCi0JCXRlLT5kYXRhTGVuZ3RoID0gKEJsb2NrTnVt YmVyKSB0YmluZm8tPnJlbHBhZ2VzOwotCQl0ZS0+ZGF0YUxlbmd0aCArPSAoQmxvY2tOdW1iZXIp IHRiaW5mby0+dG9hc3RwYWdlczsKKwkJaWYgKHRiaW5mby0+cmVscGFnZXMgPD0gZG9wdC0+bWF4 X3RhYmxlX3NlZ21lbnRfcGFnZXMgfHwgCisJCQlzdHJjbXAodGJpbmZvLT5hbW5hbWUsICJoZWFw IikgIT0gMCkKKwkJeworCQkJdGUgPSBBcmNoaXZlRW50cnkoZm91dCwgdGRpbmZvLT5kb2JqLmNh dElkLCB0ZGluZm8tPmRvYmouZHVtcElkLAorCQkJCQkJCUFSQ0hJVkVfT1BUUygudGFnID0gdGJp bmZvLT5kb2JqLm5hbWUsCisJCQkJCQkJCQkJLm5hbWVzcGFjZSA9IHRiaW5mby0+ZG9iai5uYW1l c3BhY2UtPmRvYmoubmFtZSwKKwkJCQkJCQkJCQkub3duZXIgPSB0YmluZm8tPnJvbG5hbWUsCisJ CQkJCQkJCQkJLmRlc2NyaXB0aW9uID0gIlRBQkxFIERBVEEiLAorCQkJCQkJCQkJCS5zZWN0aW9u ID0gU0VDVElPTl9EQVRBLAorCQkJCQkJCQkJCS5jcmVhdGVTdG10ID0gdGREZWZuLAorCQkJCQkJ CQkJCS5jb3B5U3RtdCA9IGNvcHlTdG10LAorCQkJCQkJCQkJCS5kZXBzID0gJih0YmluZm8tPmRv YmouZHVtcElkKSwKKwkJCQkJCQkJCQkubkRlcHMgPSAxLAorCQkJCQkJCQkJCS5kdW1wRm4gPSBk dW1wRm4sCisJCQkJCQkJCQkJLmR1bXBBcmcgPSB0ZGluZm8pKTsKIAotCQkvKgotCQkgKiBJZiBw Z29mZl90IGlzIG9ubHkgMzIgYml0cyB3aWRlLCB0aGUgYWJvdmUgcmVmaW5lbWVudCBpcyB1c2Vs ZXNzLAotCQkgKiBhbmQgaW5zdGVhZCB3ZSdkIGJldHRlciB3b3JyeSBhYm91dCBpbnRlZ2VyIG92 ZXJmbG93LiAgQ2xhbXAgdG8KLQkJICogSU5UX01BWCBpZiB0aGUgY29ycmVjdCByZXN1bHQgZXhj ZWVkcyB0aGF0LgotCQkgKi8KLQkJaWYgKHNpemVvZih0ZS0+ZGF0YUxlbmd0aCkgPT0gNCAmJgot CQkJKHRiaW5mby0+cmVscGFnZXMgPCAwIHx8IHRiaW5mby0+dG9hc3RwYWdlcyA8IDAgfHwKLQkJ CSB0ZS0+ZGF0YUxlbmd0aCA8IDApKQotCQkJdGUtPmRhdGFMZW5ndGggPSBJTlRfTUFYOworCQkJ LyoKKwkJCSAqIFNldCB0aGUgVG9jRW50cnkncyBkYXRhTGVuZ3RoIGluIGNhc2Ugd2UgYXJlIGRv aW5nIGEgcGFyYWxsZWwgZHVtcAorCQkJICogYW5kIHdhbnQgdG8gb3JkZXIgZHVtcCBqb2JzIGJ5 IHRhYmxlIHNpemUuICBXZSBjaG9vc2UgdG8gbWVhc3VyZQorCQkJICogZGF0YUxlbmd0aCBpbiB0 YWJsZSBwYWdlcyAoaW5jbHVkaW5nIFRPQVNUIHBhZ2VzKSBkdXJpbmcgZHVtcCwgc28KKwkJCSAq IG5vIHNjYWxpbmcgaXMgbmVlZGVkLgorCQkJICoKKwkJCSAqIFdoaWxlIHBnX2NsYXNzLnJlbHBh Z2VzIHdoaWNoIHN0b3JlcyBCbG9ja051bWJlciwgYS9rL2EgdW5zaWduZWQgaW50LAorCQkJICog aXMgZGVjbGFyZWQgYXMgImludGVnZXIiIHdlIGNvbnZlcnQgaXQgYmFjayBhbmQgc3RvcmUgaXQg YXMgCisJCQkgKiBCbG9ja051bWJlciBpbiBUYWJsZUluZm8uCisJCQkgKiBBbmQgZGF0YUxlbmdo dCBpcyBwZ29mZl90IChsb25nIGludCkgc28gZG9lcyBub3cgb3ZlcmZsb3cgZm9yCisJCQkgKiAy IHggVUlOVDMyX01BWCAKKwkJCSAqLworCQkJdGUtPmRhdGFMZW5ndGggPSB0YmluZm8tPnJlbHBh Z2VzOworCQkJdGUtPmRhdGFMZW5ndGggKz0gdGJpbmZvLT50b2FzdHBhZ2VzOworCQl9CisJCWVs c2UKKwkJeworCQkJdWludDY0IGN1cnJlbnRfY2h1bmtfc3RhcnQgPSAwOworCQkJUFFFeHBCdWZm ZXIgY2h1bmtfZGVzYyA9IGNyZWF0ZVBRRXhwQnVmZmVyKCk7CisJCQkKKwkJCXBnX2xvZ193YXJu aW5nKCJDSFVOS0lORzogdG9jIGZvciBjaHVua2VkIHJlbHBhZ2VzIFsldV0iLCB0YmluZm8tPnJl bHBhZ2VzKTsKKworCQkJLyogVE9ETyAtIHVzZSB1aW50IDY0IGZvciBjdXJyZW50X2NodW5rX3N0 YXJ0IHRvIGF2b2lkIHdyYXBhcm91bmQgKi8KKwkJCXdoaWxlIChjdXJyZW50X2NodW5rX3N0YXJ0 IDwgdGJpbmZvLT5yZWxwYWdlcykKKwkJCXsKKwkJCQlUYWJsZURhdGFJbmZvICpjaHVua190ZGlu Zm8gPSAoVGFibGVEYXRhSW5mbyAqKSBwZ19tYWxsb2Moc2l6ZW9mKFRhYmxlRGF0YUluZm8pKTsK KworCQkJCW1lbWNweShjaHVua190ZGluZm8sIHRkaW5mbywgc2l6ZW9mKFRhYmxlRGF0YUluZm8p KTsKKwkJCQlBc3NpZ25EdW1wSWQoJmNodW5rX3RkaW5mby0+ZG9iaik7CisJCQkJLy9hZGRPYmpl Y3REZXBlbmRlbmN5KCZjaHVua190ZGluZm8tPmRvYmosIHRiaW5mby0+ZG9iai5kdW1wSWQpOyAv KiBkbyB3ZSBuZWVkIHRoaXMgaGVyZSAqLworLy8JCQkJY2h1bmtfdGRpbmZvLT5pc19zZWdtZW50 ID0gdHJ1ZTsKKwkJCQljaHVua190ZGluZm8tPnN0YXJ0UGFnZSA9IChCbG9ja051bWJlcikgY3Vy cmVudF9jaHVua19zdGFydDsKKwkJCQljaHVua190ZGluZm8tPmVuZFBhZ2UgPSBjaHVua190ZGlu Zm8tPnN0YXJ0UGFnZSArIGRvcHQtPm1heF90YWJsZV9zZWdtZW50X3BhZ2VzIC0gMTsKKworCQkJ CXBnX2xvZ193YXJuaW5nKCJDSFVOS0lORzogdG9jIGZvciBwYWdlcyBbJXU6JXVdIixjaHVua190 ZGluZm8tPnN0YXJ0UGFnZSwgY2h1bmtfdGRpbmZvLT5lbmRQYWdlKTsKKwkJCQkKKwkJCQljdXJy ZW50X2NodW5rX3N0YXJ0ICs9IGRvcHQtPm1heF90YWJsZV9zZWdtZW50X3BhZ2VzOworCQkJCWlm IChjdXJyZW50X2NodW5rX3N0YXJ0ID49IHRiaW5mby0+cmVscGFnZXMpCisJCQkJCWNodW5rX3Rk aW5mby0+ZW5kUGFnZSA9IEludmFsaWRCbG9ja051bWJlcjsgLyogbGFzdCBjaHVuayBpcyBmb3Ig ImFsbCB0aGUgcmVzdCIgKi8KKworCQkJCXByaW50ZlBRRXhwQnVmZmVyKGNodW5rX2Rlc2MsICJU QUJMRSBEQVRBIChwYWdlcyAldToldSkiLCBjaHVua190ZGluZm8tPnN0YXJ0UGFnZSwgY2h1bmtf dGRpbmZvLT5lbmRQYWdlKTsKKworCQkJCXRlID0gQXJjaGl2ZUVudHJ5KGZvdXQsIGNodW5rX3Rk aW5mby0+ZG9iai5jYXRJZCwgY2h1bmtfdGRpbmZvLT5kb2JqLmR1bXBJZCwKKwkJCQkJCQlBUkNI SVZFX09QVFMoLnRhZyA9IHRiaW5mby0+ZG9iai5uYW1lLAorCQkJCQkJCQkJCS5uYW1lc3BhY2Ug PSB0YmluZm8tPmRvYmoubmFtZXNwYWNlLT5kb2JqLm5hbWUsCisJCQkJCQkJCQkJLm93bmVyID0g dGJpbmZvLT5yb2xuYW1lLAorCQkJCQkJCQkJCS5kZXNjcmlwdGlvbiA9IGNodW5rX2Rlc2MtPmRh dGEsCisJCQkJCQkJCQkJLnNlY3Rpb24gPSBTRUNUSU9OX0RBVEEsCisJCQkJCQkJCQkJLmNyZWF0 ZVN0bXQgPSB0ZERlZm4sCisJCQkJCQkJCQkJLmNvcHlTdG10ID0gY29weVN0bXQsCisJCQkJCQkJ CQkJLmRlcHMgPSAmKHRiaW5mby0+ZG9iai5kdW1wSWQpLAorCQkJCQkJCQkJCS5uRGVwcyA9IDEs CisJCQkJCQkJCQkJLmR1bXBGbiA9IGR1bXBGbiwKKwkJCQkJCQkJCQkuZHVtcEFyZyA9IGNodW5r X3RkaW5mbykpOworCisJCQkJaWYoY2h1bmtfdGRpbmZvLT5lbmRQYWdlID09IEludmFsaWRCbG9j a051bWJlcikKKwkJCQkJdGUtPmRhdGFMZW5ndGggPSB0YmluZm8tPnJlbHBhZ2VzIC0gY2h1bmtf dGRpbmZvLT5zdGFydFBhZ2U7CisJCQkJZWxzZQorCQkJCQl0ZS0+ZGF0YUxlbmd0aCA9IGRvcHQt Pm1heF90YWJsZV9zZWdtZW50X3BhZ2VzOworCQkJCS8qIGxldCdzIGFzc3VtZSB0b2FzdCBwYWdl cyBkaXN0cmlidXRlIGV2ZW5seSBhbW9uZyBjaHVua3MgKi8KKwkJCQlpZih0YmluZm8tPnJlbHBh Z2VzKQorCQkJCQl0ZS0+ZGF0YUxlbmd0aCArPSB0ZS0+ZGF0YUxlbmd0aCAqIHRiaW5mby0+dG9h c3RwYWdlcyAvIHRiaW5mby0+cmVscGFnZXM7CisJCQl9CisKKwkJCWRlc3Ryb3lQUUV4cEJ1ZmZl cihjaHVua19kZXNjKTsKKwkJfQogCX0KIAogCWRlc3Ryb3lQUUV4cEJ1ZmZlcihjb3B5QnVmKTsK QEAgLTMwOTIsNiArMzE3Myw4IEBAIG1ha2VUYWJsZURhdGFJbmZvKER1bXBPcHRpb25zICpkb3B0 LCBUYWJsZUluZm8gKnRiaW5mbykKIAl0ZGluZm8tPmRvYmoubmFtZXNwYWNlID0gdGJpbmZvLT5k b2JqLm5hbWVzcGFjZTsKIAl0ZGluZm8tPnRkdGFibGUgPSB0YmluZm87CiAJdGRpbmZvLT5maWx0 ZXJjb25kID0gTlVMTDsJLyogbWlnaHQgZ2V0IHNldCBsYXRlciAqLworCXRkaW5mby0+c3RhcnRQ YWdlID0gSW52YWxpZEJsb2NrTnVtYmVyOyAvKiB3ZSB1c2UgdGhpcyBhcyBpbmRpY2F0aW9uIHRo YXQgbm8gY2h1bmtpbmcgaXMgbmVlZGVkICovCisJdGRpbmZvLT5lbmRQYWdlID0gSW52YWxpZEJs b2NrTnVtYmVyOwogCWFkZE9iamVjdERlcGVuZGVuY3koJnRkaW5mby0+ZG9iaiwgdGJpbmZvLT5k b2JqLmR1bXBJZCk7CiAKIAkvKiBBIFRhYmxlRGF0YUluZm8gY29udGFpbnMgZGF0YSwgb2YgY291 cnNlICovCkBAIC03MjU0LDggKzczMzcsMTYgQEAgZ2V0VGFibGVzKEFyY2hpdmUgKmZvdXQsIGlu dCAqbnVtVGFibGVzKQogCQkJCQkJICJjLnJlbG5hbWVzcGFjZSwgYy5yZWxraW5kLCBjLnJlbHR5 cGUsICIKIAkJCQkJCSAiYy5yZWxvd25lciwgIgogCQkJCQkJICJjLnJlbGNoZWNrcywgIgotCQkJ CQkJICJjLnJlbGhhc2luZGV4LCBjLnJlbGhhc3J1bGVzLCBjLnJlbHBhZ2VzLCAiCi0JCQkJCQkg ImMucmVsdHVwbGVzLCBjLnJlbGFsbHZpc2libGUsICIpOworCQkJCQkJICJjLnJlbGhhc2luZGV4 LCBjLnJlbGhhc3J1bGVzLCAiKTsKKworCS8qIGZldGNoIGN1cnJlbnQgcmVsYXRpb24gc2l6ZSBp ZiBjaHVua2luZyBpcyByZXF1ZXN0ZWQgKi8KKwlpZihkb3B0LT5tYXhfdGFibGVfc2VnbWVudF9w YWdlcyAhPSBJbnZhbGlkQmxvY2tOdW1iZXIpCisJCWFwcGVuZFBRRXhwQnVmZmVyU3RyKHF1ZXJ5 LCAicGdfcmVsYXRpb25fc2l6ZShjLm9pZCkvY3VycmVudF9zZXR0aW5nKCdibG9ja19zaXplJyk6 OmludCBBUyByZWxwYWdlcywgIik7CisJZWxzZQorCQkvKiBwZ19jbGFzcy5yZWxwYWdlcyBzdG9y ZXMgQmxvY2tOdW1iZXIgKHVpbnQzMikgaW4gYW4gaW50IGZpZWxkLCBjb252ZXJ0IHRvIG9pZCB0 byBnZXQgdW5zaWduZWQgaW50IG91dCAqLworCQlhcHBlbmRQUUV4cEJ1ZmZlclN0cihxdWVyeSwg ImMucmVscGFnZXM6Om9pZCwgIik7CisKKwlhcHBlbmRQUUV4cEJ1ZmZlclN0cihxdWVyeSwgImMu cmVsdHVwbGVzLCBjLnJlbGFsbHZpc2libGUsICIpOwogCiAJaWYgKGZvdXQtPnJlbW90ZVZlcnNp b24gPj0gMTgwMDAwKQogCQlhcHBlbmRQUUV4cEJ1ZmZlclN0cihxdWVyeSwgImMucmVsYWxsZnJv emVuLCAiKTsKQEAgLTc0OTUsNyArNzU4Niw3IEBAIGdldFRhYmxlcyhBcmNoaXZlICpmb3V0LCBp bnQgKm51bVRhYmxlcykKIAkJdGJsaW5mb1tpXS5uY2hlY2sgPSBhdG9pKFBRZ2V0dmFsdWUocmVz LCBpLCBpX3JlbGNoZWNrcykpOwogCQl0YmxpbmZvW2ldLmhhc2luZGV4ID0gKHN0cmNtcChQUWdl dHZhbHVlKHJlcywgaSwgaV9yZWxoYXNpbmRleCksICJ0IikgPT0gMCk7CiAJCXRibGluZm9baV0u aGFzcnVsZXMgPSAoc3RyY21wKFBRZ2V0dmFsdWUocmVzLCBpLCBpX3JlbGhhc3J1bGVzKSwgInQi KSA9PSAwKTsKLQkJdGJsaW5mb1tpXS5yZWxwYWdlcyA9IGF0b2koUFFnZXR2YWx1ZShyZXMsIGks IGlfcmVscGFnZXMpKTsKKwkJdGJsaW5mb1tpXS5yZWxwYWdlcyA9IHN0cnRvdWwoUFFnZXR2YWx1 ZShyZXMsIGksIGlfcmVscGFnZXMpLCBOVUxMLCAxMCk7CiAJCWlmIChQUWdldGlzbnVsbChyZXMs IGksIGlfdG9hc3RwYWdlcykpCiAJCQl0YmxpbmZvW2ldLnRvYXN0cGFnZXMgPSAwOwogCQllbHNl CmRpZmYgLS1naXQgYS9zcmMvYmluL3BnX2R1bXAvcGdfZHVtcC5oIGIvc3JjL2Jpbi9wZ19kdW1w L3BnX2R1bXAuaAppbmRleCA0YzRiMTRlNWZjNy4uYmU3MTY2MWFjNDEgMTAwNjQ0Ci0tLSBhL3Ny Yy9iaW4vcGdfZHVtcC9wZ19kdW1wLmgKKysrIGIvc3JjL2Jpbi9wZ19kdW1wL3BnX2R1bXAuaApA QCAtMTYsNiArMTYsNyBAQAogCiAjaW5jbHVkZSAicGdfYmFja3VwLmgiCiAjaW5jbHVkZSAiY2F0 YWxvZy9wZ19wdWJsaWNhdGlvbl9kLmgiCisjaW5jbHVkZSAic3RvcmFnZS9ibG9jay5oIgogCiAK ICNkZWZpbmUgb2lkY21wKHgseSkgKCAoKHgpIDwgKHkpID8gLTEgOiAoKHgpID4gKHkpKSA/ICAx IDogMCkgKQpAQCAtMzM1LDcgKzMzNiwxMSBAQCB0eXBlZGVmIHN0cnVjdCBfdGFibGVJbmZvCiAJ T2lkCQkJb3duaW5nX3RhYjsJCS8qIE9JRCBvZiB0YWJsZSBvd25pbmcgc2VxdWVuY2UgKi8KIAlp bnQJCQlvd25pbmdfY29sOwkJLyogYXR0ciAjIG9mIGNvbHVtbiBvd25pbmcgc2VxdWVuY2UgKi8K IAlib29sCQlpc19pZGVudGl0eV9zZXF1ZW5jZTsKLQlpbnQzMgkJcmVscGFnZXM7CQkvKiB0YWJs ZSdzIHNpemUgaW4gcGFnZXMgKGZyb20gcGdfY2xhc3MpICovCisJQmxvY2tOdW1iZXIJcmVscGFn ZXM7CQkvKiB0YWJsZSdzIHNpemUgaW4gcGFnZXMgKGZyb20gcGdfY2xhc3MpIAorCSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgKiBjb252ZXJ0ZWQgdG8gdW5zaWduZWQgaW50ZWdlcgorCQkJ CQkJCQkgKiB3aGVuIC0tbWF4LXRhYmxlLXNlZ21lbnQtcGFnZXMgaXMgc2V0CisJCQkJCQkJCSAq IHRoZSBjb21wdXRlZCBmcm9tIHBvZ19yZWxhdGlvbl9zaXplKCkKKwkgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICovCiAJaW50CQkJdG9hc3RwYWdlczsJCS8qIHRvYXN0IHRhYmxlJ3Mgc2l6 ZSBpbiBwYWdlcywgaWYgYW55ICovCiAKIAlib29sCQlpbnRlcmVzdGluZzsJLyogdHJ1ZSBpZiBu ZWVkIHRvIGNvbGxlY3QgbW9yZSBkYXRhICovCkBAIC00MTMsOCArNDE4LDIxIEBAIHR5cGVkZWYg c3RydWN0IF90YWJsZURhdGFJbmZvCiAJRHVtcGFibGVPYmplY3QgZG9iajsKIAlUYWJsZUluZm8g ICp0ZHRhYmxlOwkJLyogbGluayB0byB0YWJsZSB0byBkdW1wICovCiAJY2hhcgkgICAqZmlsdGVy Y29uZDsJCS8qIFdIRVJFIGNvbmRpdGlvbiB0byBsaW1pdCByb3dzIGR1bXBlZCAqLworCS8qIHN0 YXJ0UGFnZSBhbmQgZW5kUGFnZSB0byBzdXBwb3J0IHNlZ21lbnRlZCBkdW1wICovCisJQmxvY2tO dW1iZXIJc3RhcnRQYWdlOwkJLyogQXMgd2UgYWx3YXlzIGtub3cgdGhlIGxvd2VzdCBzZWdtZW50 IHBhZ2UKKwkJCQkJCQkJICogbnVtYmVyIHdlIGNhbiB1c2UgSW52YWxpZEJsb2NrTnVtYmVyIGhl cmUKKwkJCQkJCQkJICogdG8gcmVjb2duaXplIG5vIHNlZ21lbnRpbmcgY2FzZS4KKwkJCQkJCQkJ ICogV2hlbiAwIGZvciB0aGUgZmlyc3QgcGFnZSBvZiBmaXJzdAorCQkJCQkJCQkgKiBzZWdtZW50 IHdlIGNhbiBvbWl0IGluIHJhbmdlIHF1ZXJ5ICovCisJQmxvY2tOdW1iZXIJZW5kUGFnZTsJCS8q IGxhc3QgcGFnZSBpbiBzZWdtZW50IGZvciBwYWdlLXJhbmdlIGR1bXAsCisJICAgICAgICAgICAg ICAgICAgICAJCSAqIHN0YXJ0UGFnZSttYXhfdGFibGVfc2VnbWVudF9wYWdlcy0xIGZvciAKKwkJ CQkJCQkJICogbW9zdCBzZWdtZW50cywgYnV0IEludmFsaWRCbG9ja051bWJlciBmb3IKKwkJCQkJ CQkJICogdGhlIGxhc3Qgb25lIHRvIGluZGljYXRlIG9wZW4gcmFuZ2UKKwkJCQkJCQkJICovCiB9 IFRhYmxlRGF0YUluZm87CiAKKyNkZWZpbmUgaXNfc2VnbWVudCh0ZGlwdHIpICh0ZGlwdHItPnN0 YXJ0UGFnZSAhPSBJbnZhbGlkQmxvY2tOdW1iZXIpCisKIHR5cGVkZWYgc3RydWN0IF9pbmR4SW5m bwogewogCUR1bXBhYmxlT2JqZWN0IGRvYmo7CkBAIC00NDgsNyArNDY2LDcgQEAgdHlwZWRlZiBz dHJ1Y3QgX2luZGV4QXR0YWNoSW5mbwogdHlwZWRlZiBzdHJ1Y3QgX3JlbFN0YXRzSW5mbwogewog CUR1bXBhYmxlT2JqZWN0IGRvYmo7Ci0JaW50MzIJCXJlbHBhZ2VzOworCUJsb2NrTnVtYmVyCXJl bHBhZ2VzOwogCWNoYXIJICAgKnJlbHR1cGxlczsKIAlpbnQzMgkJcmVsYWxsdmlzaWJsZTsKIAlp bnQzMgkJcmVsYWxsZnJvemVuOwpkaWZmIC0tZ2l0IGEvc3JjL2Jpbi9wZ19kdW1wL3QvMDA0X3Bn X2R1bXBfcGFyYWxsZWwucGwgYi9zcmMvYmluL3BnX2R1bXAvdC8wMDRfcGdfZHVtcF9wYXJhbGxl bC5wbAppbmRleCA3MzhmMzRiMWMxYi4uODhhZjI1ZDI4ODkgMTAwNjQ0Ci0tLSBhL3NyYy9iaW4v cGdfZHVtcC90LzAwNF9wZ19kdW1wX3BhcmFsbGVsLnBsCisrKyBiL3NyYy9iaW4vcGdfZHVtcC90 LzAwNF9wZ19kdW1wX3BhcmFsbGVsLnBsCkBAIC0xMSw2ICsxMSw3IEBAIHVzZSBUZXN0OjpNb3Jl OwogbXkgJGRibmFtZTEgPSAncmVncmVzc2lvbl9zcmMnOwogbXkgJGRibmFtZTIgPSAncmVncmVz c2lvbl9kZXN0MSc7CiBteSAkZGJuYW1lMyA9ICdyZWdyZXNzaW9uX2Rlc3QyJzsKK215ICRkYm5h bWU0ID0gJ3JlZ3Jlc3Npb25fZGVzdDMnOwogCiBteSAkbm9kZSA9IFBvc3RncmVTUUw6OlRlc3Q6 OkNsdXN0ZXItPm5ldygnbWFpbicpOwogJG5vZGUtPmluaXQ7CkBAIC0yMSw2ICsyMiw3IEBAIG15 ICRiYWNrdXBkaXIgPSAkbm9kZS0+YmFja3VwX2RpcjsKICRub2RlLT5ydW5fbG9nKFsgJ2NyZWF0 ZWRiJywgJGRibmFtZTEgXSk7CiAkbm9kZS0+cnVuX2xvZyhbICdjcmVhdGVkYicsICRkYm5hbWUy IF0pOwogJG5vZGUtPnJ1bl9sb2coWyAnY3JlYXRlZGInLCAkZGJuYW1lMyBdKTsKKyRub2RlLT5y dW5fbG9nKFsgJ2NyZWF0ZWRiJywgJGRibmFtZTQgXSk7CiAKICRub2RlLT5zYWZlX3BzcWwoCiAJ JGRibmFtZTEsCkBAIC00NCw2ICs0NiwxOCBAQCBjcmVhdGUgdGFibGUgdGh0X3AxIHBhcnRpdGlv biBvZiB0aHQgZm9yIHZhbHVlcyB3aXRoIChtb2R1bHVzIDMsIHJlbWFpbmRlciAwKTsKIGNyZWF0 ZSB0YWJsZSB0aHRfcDIgcGFydGl0aW9uIG9mIHRodCBmb3IgdmFsdWVzIHdpdGggKG1vZHVsdXMg MywgcmVtYWluZGVyIDEpOwogY3JlYXRlIHRhYmxlIHRodF9wMyBwYXJ0aXRpb24gb2YgdGh0IGZv ciB2YWx1ZXMgd2l0aCAobW9kdWx1cyAzLCByZW1haW5kZXIgMik7CiBpbnNlcnQgaW50byB0aHQg c2VsZWN0ICh4JTEwKTo6dGV4dDo6ZGlnaXQsIHggZnJvbSBnZW5lcmF0ZV9zZXJpZXMoMSwxMDAw KSB4OworCistLSByYWlzZSB3YXJuaW5nIHNvIEkgY2FuIGNoZWNrIGluIC5sb2cgaWYgZGF0YSB3 YXMgY29ycmVjdAorRE8gXCRcJAorREVDTEFSRQorICAgIHRoYXNoX3JlYyBSRUNPUkQ7CitCRUdJ TgorICAgIFNFTEVDVCAndHBsYWluJywgY291bnQoKiksIHN1bShoYXNodGV4dCh0Ojp0ZXh0KSkg YXMgdGFibGVoYXNoIAorCSAgSU5UTyB0aGFzaF9yZWMKKwkgIEZST00gdHBsYWluIEFTIHQ7Cisg ICAgUkFJU0UgV0FSTklORyAndGhhc2g6ICUnLCB0aGFzaF9yZWM7CitFTkQ7CitcJFwkOwogCX0p OwogCiAkbm9kZS0+Y29tbWFuZF9vaygKQEAgLTg3LDQgKzEwMSw0MiBAQCAkbm9kZS0+Y29tbWFu ZF9vaygKIAldLAogCSdwYXJhbGxlbCByZXN0b3JlIGFzIGluc2VydHMnKTsKIAorJG5vZGUtPmNv bW1hbmRfb2soCisJWworCQkncGdfZHVtcCcsCisJCSctLWZvcm1hdCcgPT4gJ2RpcmVjdG9yeScs CisJCSctLW1heC10YWJsZS1zZWdtZW50LXBhZ2VzJyA9PiAyLAorCQknLS1uby1zeW5jJywKKwkJ Jy0tam9icycgPT4gMiwKKwkJJy0tZmlsZScgPT4gIiRiYWNrdXBkaXIvZHVtcDMiLAorCQkkbm9k ZS0+Y29ubnN0cigkZGJuYW1lMSksCisJXSwKKwkncGFyYWxsZWwgZHVtcCB3aXRoIGNodW5rcyBv ZiB0d28gaGVhcCBwYWdlcycpOworCiskbm9kZS0+Y29tbWFuZF9vaygKKwlbCisJCSdwZ19yZXN0 b3JlJywgJy0tdmVyYm9zZScsCisJCSctLWRibmFtZScgPT4gJG5vZGUtPmNvbm5zdHIoJGRibmFt ZTQpLAorCQknLS1qb2JzJyA9PiAzLAorCQkiJGJhY2t1cGRpci9kdW1wMyIsCisJXSwKKwkncGFy YWxsZWwgcmVzdG9yZSB3aXRoIGNodW5rcyBvZiB0d28gaGVhcCBwYWdlcycpOworCiskbm9kZS0+ c2FmZV9wc3FsKAorCSRkYm5hbWU0LAorCXFxeworCistLSByYWlzZSB3YXJuaW5nIHNvIEkgY2Fu IGNoZWNrIGluIC5sb2cgaWYgZGF0YSB3YXMgY29ycmVjdAorRE8gXCRcJAorREVDTEFSRQorICAg IHRoYXNoX3JlYyBSRUNPUkQ7CitCRUdJTgorICAgIFNFTEVDVCAndHBsYWluJywgY291bnQoKiks IHN1bShoYXNodGV4dCh0Ojp0ZXh0KSkgYXMgdGFibGVoYXNoIAorCSAgSU5UTyB0aGFzaF9yZWMK KwkgIEZST00gdHBsYWluIEFTIHQ7CisgICAgUkFJU0UgV0FSTklORyAndGhhc2ggYWZ0ZXIgcGFy YWxsZWwgY2h1bmtlZCByZXN0b3JlOiAlJywgdGhhc2hfcmVjOworRU5EOworXCRcJDsKKwl9KTsK KwogZG9uZV90ZXN0aW5nKCk7CmRpZmYgLS1naXQgYS9zcmMvZmVfdXRpbHMvb3B0aW9uX3V0aWxz LmMgYi9zcmMvZmVfdXRpbHMvb3B0aW9uX3V0aWxzLmMKaW5kZXggY2M0ODNhZTE3NmMuLmFmZjFm YmQzMWEzIDEwMDY0NAotLS0gYS9zcmMvZmVfdXRpbHMvb3B0aW9uX3V0aWxzLmMKKysrIGIvc3Jj L2ZlX3V0aWxzL29wdGlvbl91dGlscy5jCkBAIC04Myw2ICs4Myw2MSBAQCBvcHRpb25fcGFyc2Vf aW50KGNvbnN0IGNoYXIgKm9wdGFyZywgY29uc3QgY2hhciAqb3B0bmFtZSwKIAlyZXR1cm4gdHJ1 ZTsKIH0KIAorLyoKKyAqIG9wdGlvbl9wYXJzZV91aW50MzIKKyAqCisgKiBQYXJzZSB1bnNpZ25l ZCBpbnRlZ2VyIHZhbHVlIGZvciBhbiBvcHRpb24uICBJZiB0aGUgcGFyc2luZyBpcyBzdWNjZXNz ZnVsLAorICogcmV0dXJucyB0cnVlIGFuZCBzdG9yZXMgdGhlIHJlc3VsdCBpbiAqcmVzdWx0IGlm IHRoYXQncyBnaXZlbjsKKyAqIGlmIHBhcnNpbmcgZmFpbHMsIHJldHVybnMgZmFsc2UuCisgKi8K K2Jvb2wKK29wdGlvbl9wYXJzZV91aW50MzIoY29uc3QgY2hhciAqb3B0YXJnLCBjb25zdCBjaGFy ICpvcHRuYW1lLAorCQkJCSB1aW50MzIgbWluX3JhbmdlLCB1aW50MzIgbWF4X3JhbmdlLAorCQkJ CSB1aW50MzIgKnJlc3VsdCkKK3sKKwljaGFyCSAgIAkJKmVuZHB0cjsKKwl1bnNpZ25lZCBsb25n CXZhbDsKKworCS8qIEZhaWwgaWYgdGhlcmUgaXMgYSBtaW51cyBzaWduIGF0IHRoZSBzdGFydCBv ZiB2YWx1ZSAqLworCXdoaWxlKGlzc3BhY2UoKHVuc2lnbmVkIGNoYXIpICpvcHRhcmcpKQorCQlv cHRhcmcrKzsKKwlpZigqb3B0YXJnID09ICctJykKKwl7CisJCXBnX2xvZ19lcnJvcigidmFsdWUg XCIlc1wiIGZvciBvcHRpb24gJXMgY2FuIG5vdCBiZSBuZWdhdGl2ZSIsCisJCQkJCW9wdGFyZywg b3B0bmFtZSk7CisJCXJldHVybiBmYWxzZTsKKwl9CisKKwllcnJubyA9IDA7CisJdmFsID0gc3Ry dG91bChvcHRhcmcsICZlbmRwdHIsIDEwKTsKKworCS8qCisJICogU2tpcCBhbnkgdHJhaWxpbmcg d2hpdGVzcGFjZTsgaWYgYW55dGhpbmcgYnV0IHdoaXRlc3BhY2UgcmVtYWlucyBiZWZvcmUKKwkg KiB0aGUgdGVybWluYXRpbmcgY2hhcmFjdGVyLCBmYWlsLgorCSAqLworCXdoaWxlICgqZW5kcHRy ICE9ICdcMCcgJiYgaXNzcGFjZSgodW5zaWduZWQgY2hhcikgKmVuZHB0cikpCisJCWVuZHB0cisr OworCisJaWYgKCplbmRwdHIgIT0gJ1wwJykKKwl7CisJCXBnX2xvZ19lcnJvcigiaW52YWxpZCB2 YWx1ZSBcIiVzXCIgZm9yIG9wdGlvbiAlcyIsCisJCQkJCSBvcHRhcmcsIG9wdG5hbWUpOworCQly ZXR1cm4gZmFsc2U7CisJfQorCisJLyogYXMgbWluX3JhbmdlIGFuZCBtYXhfcmFuZ2UgYXJlIHVp bnQzMiB0aGVuIHRoZSByYW5nZSBjaGVjayB3aWxsCisJICogY2F0Y2ggdGhlIGNhc2Ugd2hlcmUg dW5zaWduZWQgbG9uZyB2YWwgaXMgb3V0c2lkZSAzMiBiaXQgcmFuZ2UgKi8KKwlpZiAoZXJybm8g PT0gRVJBTkdFIHx8IHZhbCA8IG1pbl9yYW5nZSB8fCB2YWwgPiBtYXhfcmFuZ2UpCisJeworCQlw Z19sb2dfZXJyb3IoIiVzIG5vdCBpbiByYW5nZSAldS4uJXUiLCBvcHRuYW1lLCBtaW5fcmFuZ2Us IG1heF9yYW5nZSk7CisJCXJldHVybiBmYWxzZTsKKwl9CisKKwlpZiAocmVzdWx0KQorCQkqcmVz dWx0ID0gKHVpbnQzMikgdmFsOworCXJldHVybiB0cnVlOworfQorCiAvKgogICogUHJvdmlkZSBz dHJpY3RseSBoYXJtb25pemVkIGhhbmRsaW5nIG9mIHRoZSAtLXN5bmMtbWV0aG9kIG9wdGlvbi4K ICAqLwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvZmVfdXRpbHMvb3B0aW9uX3V0aWxzLmggYi9z cmMvaW5jbHVkZS9mZV91dGlscy9vcHRpb25fdXRpbHMuaAppbmRleCAwZGI2ZTNiNmU5MS4uYzc0 Y2QxZmI1OTUgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2ZlX3V0aWxzL29wdGlvbl91dGlscy5o CisrKyBiL3NyYy9pbmNsdWRlL2ZlX3V0aWxzL29wdGlvbl91dGlscy5oCkBAIC0yMiw2ICsyMiw5 IEBAIGV4dGVybiB2b2lkIGhhbmRsZV9oZWxwX3ZlcnNpb25fb3B0cyhpbnQgYXJnYywgY2hhciAq YXJndltdLAogZXh0ZXJuIGJvb2wgb3B0aW9uX3BhcnNlX2ludChjb25zdCBjaGFyICpvcHRhcmcs IGNvbnN0IGNoYXIgKm9wdG5hbWUsCiAJCQkJCQkJIGludCBtaW5fcmFuZ2UsIGludCBtYXhfcmFu Z2UsCiAJCQkJCQkJIGludCAqcmVzdWx0KTsKK2V4dGVybiBib29sIG9wdGlvbl9wYXJzZV91aW50 MzIoY29uc3QgY2hhciAqb3B0YXJnLCBjb25zdCBjaGFyICpvcHRuYW1lLAorCQkJCQkJCSB1aW50 MzIgbWluX3JhbmdlLCB1aW50MzIgbWF4X3JhbmdlLAorCQkJCQkJCSB1aW50MzIgKnJlc3VsdCk7 CiBleHRlcm4gYm9vbCBwYXJzZV9zeW5jX21ldGhvZChjb25zdCBjaGFyICpvcHRhcmcsCiAJCQkJ CQkJICBEYXRhRGlyU3luY01ldGhvZCAqc3luY19tZXRob2QpOwogCi0tIAoyLjQzLjAKCg== --00000000000012819a0649665c42--