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 1vVREp-003PEp-14 for pgsql-hackers@arkaria.postgresql.org; Tue, 16 Dec 2025 09:21:00 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vVREo-005TIG-0S for pgsql-hackers@arkaria.postgresql.org; Tue, 16 Dec 2025 09:20:58 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vVREn-005TI7-10 for pgsql-hackers@lists.postgresql.org; Tue, 16 Dec 2025 09:20:58 +0000 Received: from mail-oi1-x22e.google.com ([2607:f8b0:4864:20::22e]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.96) (envelope-from ) id 1vVREl-000wNG-2O for pgsql-hackers@lists.postgresql.org; Tue, 16 Dec 2025 09:20:57 +0000 Received: by mail-oi1-x22e.google.com with SMTP id 5614622812f47-44ffed84cccso840504b6e.0 for ; Tue, 16 Dec 2025 01:20:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1765876854; x=1766481654; 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=rKELHvUcwRkucjfOaiKKKHPAd08qE6Efjzo2i2cnMdc=; b=OLAZnOe4hio9BI2boB1a4g05/9WuhKF7mGtEROyH/Lo/PgOMUkzKWaEeUJFO65OjJ7 5eF4+8L4eXPlJZoevahaoxpB+crT1qbIBOU+HkjpSoJL1C4p+oIWHcrBuwRQv1lgUhZP sRwADiNQjCbPce8+1fgTgFGkn8RhFp0/931F5q1FKu8L0lHWfgN4j3cpFNKS2xvqrFOn HG29rnA+zVFM6rI+j7y4AkzXgKoWcb2K7hgJHJrZoOB/KZIANoD4qYxqJ9xQKEkEF62q Eh5FZk0Hm59WQYKT9fDSlwHaoJdaWYUA1XJgymtUYU8hPyVyKnyqbwE6bFVq3cwdepl5 2Pcw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1765876854; x=1766481654; 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=rKELHvUcwRkucjfOaiKKKHPAd08qE6Efjzo2i2cnMdc=; b=ih6LnORikhdJYcIzhQuC6jKeguuWOx3y4G9KsG3F1w+kJ+e/fAvhmyzWXuwhsnkI36 Dk2SMq0mzCprqCgoGA866E2lypDOazpjw7dlzv0ffsO9mgBqHQtJesBpVBRWlh9+WYyM b3GHJRsQV/FqUswuaaKhsshdzcMBmYDvSNWjlUNdHU2SCX8nT+wi967Hbo82OhF44Men EDBU8XOzlyY7zGvweHDhF08pZMJ/TYFLN/MalpkzC+9sTem+B/iWtsKOBhDBrQdEzYfQ +DKQsL6lcWPUAKTcNEwS+bBYuCP3vXYVwGSeIR2jcvKL4qSR8PSopeJQiHn92gmOUgzV T5Gg== X-Forwarded-Encrypted: i=1; AJvYcCX5fGTuIVULcdR/pRhXtfPl9qM+MJiM4QHu9bTDq7ulZl70O/xCv8ioUgVF85RaiSFpbkYZRTyJH6kZKTP/@lists.postgresql.org X-Gm-Message-State: AOJu0YxsYQQkcXjmvobFqGPpPfPuB0Qqfg6+IvG6P+Ynox3GkfAf2gY4 wyD6sI01Enqiuqt4QI6mD+v4UYQFegTstO/j2GfW0BZ5KFNGlcUqQbDScS4E+fFHc260e3Az92P T7D4OkqTPPN0Kt1K6FXV4CmY7tEdZQQg= X-Gm-Gg: AY/fxX6AD0AAAfQWvj21N9z91+8Bx/4TB38LUoy4fcgVX5wS9Ful1UiJLiR4DIo2HD5 GoxsE+zVYCEjYfYad111tntqD8wHkfENRqpoaev/DNUk/eIl8WfJQ5TP8JkFfEwp6BxAeV/VfGX AllTnWmWrzU7jFQ6IQP3DpUnm2ncUjW4ISBHM0zkrG6H1bwbhrBcGVPqYCnQPzOSC6pY2Neu+SM UNB1ozROJgQffAUGJl3PiCXu+//VinatV1UuUsqihH7czEThJ5jaez1eVUrOTf7+4GH/WtN2dIj dg0iL3CI X-Google-Smtp-Source: AGHT+IGL1wQTM7T4g0wgpnSBunmPgTtfoxRviUbT/GA4rKexGOIVvzsOnOaGZp4yJtb+iwjXV6EnGjIDEUZaqNVxJvU= X-Received: by 2002:a05:6808:1597:b0:450:b798:da4d with SMTP id 5614622812f47-455ac822e2cmr5590697b6e.13.1765876853953; Tue, 16 Dec 2025 01:20:53 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Shlok Kyal Date: Tue, 16 Dec 2025 14:50:41 +0530 X-Gm-Features: AQt7F2oiekuHDRQ8wumpNI79IfWJKm-VXx-Lfp8khorhXSIBhOzAuvPW1lODy3g Message-ID: Subject: Re: Skipping schema changes in publication To: Peter Smith Cc: shveta malik , Amit Kapila , vignesh C , "Zhijie Hou (Fujitsu)" , YeXiu <1518981153@qq.com>, Ian Lawrence Barwick , Bharath Rupireddy , PostgreSQL Hackers Content-Type: multipart/mixed; boundary="00000000000098f5a806460e3ee4" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000098f5a806460e3ee4 Content-Type: text/plain; charset="UTF-8" On Thu, 11 Dec 2025 at 04:10, Peter Smith wrote: > > Hi Shlok - > > Here are some review comments for v31-0001 (EXCEPT (tablelist)) > > ====== > Commit message > > 1. > The new syntax allows specifying excluded relations when creating or altering > a publication. For example: > CREATE PUBLICATION pub1 FOR ALL TABLES EXCEPT TABLE (t1,t2); > > ~ > > In v30, you removed all the ALTER PUBLICATION changes, so the "or > altering" in the message above also needs to be removed. > > ====== > doc/src/sgml/logical-replication.sgml > > 2. > > - To add tables to a publication, the user must have ownership rights on the > - table. To add all tables in schema to a publication, the user must be a > - superuser. To create a publication that publishes all tables, all tables in > - schema, or all sequences automatically, the user must be a superuser. > + To create a publication using FOR ALL TABLES, > + FOR ALL SEQUENCES or > + FOR TABLES IN SCHEMA, the user must be a > superuser. To add > + ALL TABLES or TABLES IN SCHEMA to a > + publication, the user must be a superuser. To add tables to a publication, > + the user must have ownership rights on the table. > > > This is a good improvement, but I was not sure why it is in this > patch. Should it be a separate thread for a docs improvement? > > ====== > src/backend/catalog/pg_publication.c > > GetTopMostAncestorInPublication: > > 3. > { > Oid ancestor = lfirst_oid(lc); > - List *apubids = GetRelationPublications(ancestor); > - List *aschemaPubids = NIL; > + List *apubids = NIL; > + List *aexceptpubids = NIL; > + List *aschemapubids = NIL; > + bool set_top = false; > + > + GetRelationPublications(ancestor, &apubids, &aexceptpubids); > > level++; > > - if (list_member_oid(apubids, puboid)) > + /* check if member of table publications */ > + set_top = list_member_oid(apubids, puboid); > + if (!set_top) > { > - topmost_relid = ancestor; > + aschemapubids = GetSchemaPublications(get_rel_namespace(ancestor)); > > - if (ancestor_level) > - *ancestor_level = level; > + /* check if member of schema publications */ > + set_top = list_member_oid(aschemapubids, puboid); > + > + /* > + * If the publication is all tables publication and the table is > + * not part of exception tables. > + */ > + if (!set_top && puballtables) > + set_top = !list_member_oid(aexceptpubids, puboid); > } > - else > + > + if (set_top) > { > - aschemaPubids = GetSchemaPublications(get_rel_namespace(ancestor)); > - if (list_member_oid(aschemaPubids, puboid)) > - { > - topmost_relid = ancestor; > + topmost_relid = ancestor; > > - if (ancestor_level) > - *ancestor_level = level; > - } > + if (ancestor_level) > + *ancestor_level = level; > } > > list_free(apubids); > - list_free(aschemaPubids); > + list_free(aschemapubids); > + list_free(aexceptpubids); > } > > That 'aschemapubids' can be declared and freed within the if block. > > ~~~ > > publication_add_relation: > > 4. > + /* > + * Check when a partition is excluded via EXCEPT TABLE while the > + * publication has publish_via_partition_root = true. > + */ > + if (pub->alltables && pub->pubviaroot && pri->except && > + targetrel->rd_rel->relispartition) > + ereport(WARNING, > > > This comment doesn't sound quite right: > > SUGGESTION > Handle the case where a partition is excluded by EXCEPT TABLE while > publish_via_partition_root = true. > > ~~~ > > 5. > + /* > + * Check when a partitioned table is excluded via EXCEPT TABLE while the > + * publication has publish_via_partition_root = false. > + */ > + if (pub->alltables && !pub->pubviaroot && pri->except && > + targetrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE) > + ereport(WARNING, > > Ditto. Reword like suggested in the previous review comment. > > ~~~ > > 6. > +/* > + * Get the list of publication oids associated with a specified relation. > + * pubids is filled with the list of publication oids the relation is part of. > + * except_pubids is filled with the list of publication oids the relation is > + * excluded from. > + * > + * This function returns true if the relation is part of any publication. > + */ > > Maybe putting 'pubids' and 'except_pubids' in single quotes will help > readability of this comment? > > Also, these are already Lists, so they are not filled with lists. > > SUGGESTION > Parameter 'pubids' returns the OIDs of the publications the relation is part of. > Parameter 'except_pubids' returns the OIDs of publications the > relation is excluded from. > > ~~~ > > GetPublicationRelations: > > 7. > /* > - * Gets list of relation oids for a publication. > + * Return the list of relation OIDs for a publication. > + * > + * For a FOR ALL TABLES publication, this returns the list of tables that were > + * explicitly excluded via an EXCEPT TABLE clause. > + * > + * For a FOR TABLE publication, this returns the list of tables explicitly > + * included in the publication. > * > - * This should only be used FOR TABLE publications, the FOR ALL > TABLES/SEQUENCES > - * should use GetAllPublicationRelations(). > + * Publications declared with FOR ALL TABLES or FOR ALL SEQUENCES should use > + * GetAllPublicationRelations() to obtain the complete set of tables covered by > + * the publication. > */ > List * > GetPublicationRelations(Oid pubid, PublicationPartOpt pub_partopt) > > 7a. > The function is called 'GetPublicationRelations', so it seems > unintuitive that it sometimes returns the list of all the tables that > are *excluded* from the publication. If you are going to have one > single function that does everything, then IMO it might be better to > hide that behind some wrapper functions like: > GetPublicationMemberRelations > GetPublicationExcludedRelations > > Consider also that all these assumptions might be OK today but they > won't be OK in the future. e.g. One day, when named FOR SEQUENCE > sq1,sq2 are supported then you will be alble to write a command like > FOR ALL TABLES EXCEPT (t1), FOR SEQUENCE sq1,sq2. That's going to be a > muddle of some included and some excluded relations. So, it is better > to cater for that scenario now, rather than have to rewrite all of > this function again in the future. e.g. Maybe instead of this function > returning one list it is better to return included/excluded Lists or > relations as output parameters? > > ~ > > 7b. > Also, comments like "Publications declared with FOR ALL TABLES or FOR > ALL SEQUENCES should use..." seems like too many assumptions are being > made. It would be better to enforce the calling requirements using > parameter checking and Asserts instead instead of hoping that callers > are going to abide by the comments. > > ~~~ > > GetAllPublicationRelations: > > 8. > + exceptlist = GetPublicationRelations(pubid, pubviaroot ? > + PUBLICATION_PART_ALL : > + PUBLICATION_PART_ROOT); > > This is similar to the above review comment. I'm not sure how you can > just assume that this must be the "except list" -- AFAICT this assumes > that 'GetAllPublicationRelations' can only be called by FOR ALL TABLES > (???). Seems like a lot of assumptions, that would be much better to > be enforced by Asserts in the code. > I agree with comments 7 and 8. I have added two functions 'GetPublicationIncludedRelations' and 'GetPublicationExcludedRelations'. To get Relations which are included or excluded in a publication. Both functions will call 'GetPublicationRelationsInternal' function. I have also reintroduced the 'except_flag' variable > ====== > src/backend/commands/publicationcmds.c > > pub_rf_contains_invalid_column: > > 9. > bool > pub_rf_contains_invalid_column(Oid pubid, Relation relation, List *ancestors, > - bool pubviaroot) > + bool pubviaroot, bool puballtables) > > I felt that 'puballtables' is more "important" than 'pubviaroot' so > maybe it should come earlier in the parameter list. (e.g. make it more > similar to 'pub_contains_invalid_column') > > ====== > src/backend/parser/gram.y > > 10. > + pub_except_obj_list opt_except_clause > > I felt that 'opt_except_clause' should better be called > 'opt_pub_except_clause' or 'pub_opt_except_clause' because without > 'pub' it is a bit vague. > I agree. I prefer 'opt_pub_except_clause'. By looking at other variables it better make sense to start the variable name with 'opt_' as it indicates that it is optional. Made changes for the same. > ~~~ > > 11. > +/* > + * ALL TABLES EXCEPT ( table_name [, ...] ) specification > + */ > > 11a > This comment should be up where all the other CREATE PUBLICATION > syntax is commented. > > ~ > > 11b. > Also, there is a missing optional "[TABLE]" part. > > ~~~ > > 12. > +pub_except_obj_list: PublicationExceptObjSpec > + { $$ = list_make1($1); } > + | pub_except_obj_list ',' PublicationExceptObjSpec > + { $$ = lappend($1, $3); } > + ; > + > +opt_except_clause: > + EXCEPT opt_table '(' pub_except_obj_list ')' { $$ = $4; } > + | /*EMPTY*/ { $$ = NIL; } > + ; > > I felt the clause should be defined before the obj list because that > seems the natural order to read these. > > ====== > src/bin/pg_dump/pg_dump.c > > 13. > +static SimplePtrList exceptinfo = {NULL, NULL}; > > Having this as global seems a bit hacky. It has nothing in common with > all the other nearby lists, which are commented as being based on > "patterns given by command-line switches" > I agree, I have added it in the PublicationInfo struct and made the corresponding code changes. > ~~~ > > dumpPublication: > > 14. > + /* Include exception tables if the publication has EXCEPT TABLEs */ > + for (SimplePtrListCell *cell = exceptinfo.head; cell; cell = cell->next) > + { > + PublicationRelInfo *pubrinfo = (PublicationRelInfo *) cell->ptr; > + TableInfo *tbinfo; > + > + if (pubinfo == pubrinfo->publication) > + { > + tbinfo = pubrinfo->pubtable; > > That 'tbinfo' can be declared within the "if". > > ~~~ > > 15. > + appendPQExpBuffer(query, "ONLY %s", fmtQualifiedDumpable(tbinfo)); > > ONLY is not the default. How did you decide that "ONLY" is the correct > thing to do here? > For pg_dump for publication we use "ONLY" by default while specifying the table For Alter publication we use similar thing: ``` appendPQExpBuffer(query, "ALTER PUBLICATION %s ADD TABLE ONLY", fmtId(pubinfo->dobj.name)); ``` Also if we specify a parent table in a publication(without ONLY) all its child tables are also added to the pg_publication_rel table. So when we dump such a publication we get something like: .... EXCEPT TABLE(ONLY parent_table, ONLY child_table)... > ~~~ > > getPublicationTables: > > 16. > - pubrinfo[j].dobj.objType = DO_PUBLICATION_REL; > + if (prexcept) > + pubrinfo[j].dobj.objType = DO_PUBLICATION_EXCEPT_REL; > + else > + pubrinfo[j].dobj.objType = DO_PUBLICATION_REL; > + > > Would a single assignment (ternary) make this code simpler and easier to read? > > SUGGESTION > pubrinfo[j].dobj.objType = prexcept ? > DO_PUBLICATION_EXCEPT_REL : > DO_PUBLICATION_REL; > > ====== > src/bin/pg_dump/t/002_pg_dump.pl > > 17. > + 'CREATE PUBLICATION pub10' => { > + create_order => 50, > + create_sql => > + 'CREATE PUBLICATION pub10 FOR ALL TABLES EXCEPT TABLE > (dump_test.test_table_generated);', > + regexp => qr/^ > + \QCREATE PUBLICATION pub10 FOR ALL TABLES EXCEPT TABLE (ONLY > dump_test.test_table_generated, ONLY > dump_test.test_table_generated_child2, ONLY > dump_test.test_table_generated_child1) WITH (publish = 'insert, > update, delete, truncate');\E > + /xm, > + like => { %full_runs, section_post_data => 1, }, > + }, > + > > These "generated" names seem unusual. I saw there are some other > tables like 'dump_test.test_inheritance_child' and > 'dump_test.test_inheritance_parent'. Can you use those more normal > table names instead? > > Also curious - does the order of the tests matter? I saw that the > CREATE TABLE tests seem to be coming after the CREATE PUBLICATION > tests that are using them. > I looked into it and came to the conclusion that this is controlled using 'create_order' while specifying the tests. Tests with a lower create_order value are executed earlier. So to ensure 'CREATE PUBLICATION' runs correctly we have to make sure the 'create_order' of these statements is higher than that of the respective 'CREATE TABLE' statement. > ~~~ > 18. > - if (!defined($tests{$test}->{all_runs}) > + if ( !defined($tests{$test}->{all_runs}) > > Why add this whitespace? > pg_perltidy makes this change. I have reverted it. > ====== > src/include/nodes/parsenodes.h > > 19. > AP_SetObjects, /* set list of objects */ > + AP_Reset, /* reset the publication */ > } AlterPublicationAction; > > AFAIK, you removed all ALTER command changes from v30-0001. So this > should not be here. > > ~~~ > > 20. > + bool for_all_tables; /* Special publication for all tables in db */ > AlterPublicationAction action; /* What action to perform with the given > * objects */ > } AlterPublicationStmt; > > AFAIK, you removed all ALTER command changes from v30-0001. So this > should not be here. > > ====== > src/test/regress/sql/publication.sql > > 21. > +SET client_min_messages = 'ERROR'; > +CREATE PUBLICATION testpub_foralltables_excepttable FOR ALL TABLES > EXCEPT TABLE (testpub_tbl1, testpub_tbl2); > +-- specify EXCEPT without TABLE > +CREATE PUBLICATION testpub_foralltables_excepttable1 FOR ALL TABLES > EXCEPT (testpub_tbl1); > > Should be 2 comments here for the 2x CREATE: > > # Exclude tables using FOR ALL TABLES EXCEPT TABLE (tablelist) > > # Exclude tables using FOR ALL TABLES EXCEPT (tablelist) > > ~~~ > > 22. > CREATE TABLE testpub_tbl3 (a int); > CREATE TABLE testpub_tbl3a (b text) INHERITS (testpub_tbl3); > > If you rename these tables like 'testpub_tbl_parent' and > 'testpub_tbl_child', it will be much easier to see what is going on. > > ~~~ > > 23. > +CREATE PUBLICATION testpub5 FOR ALL TABLES EXCEPT TABLE (testpub_tbl3); > > Missing comment -- something like: > # Exclude parent table, omitting both of 'ONLY' and '*' > > ~~~ > > 24. > +-- EXCEPT with wildcard: exclude table and all descendants > +CREATE PUBLICATION testpub6 FOR ALL TABLES EXCEPT TABLE (testpub_tbl3*); > > 24a. > TBH, I don't think this is a "wildcard" -- it is not doing any pattern > matching. IMO just call it an "asterisk" or a "star". > > ~ > > 24b. > And put a space before the '*' here. > > ====== > .../t/037_rep_changes_except_table.pl > > 25. > +# ============================================ > +# EXCEPT TABLE test cases for partition tables > +# ============================================ > +# Check behavior of EXCEPT TABLE together with publish_via_partition_root > +# when applied to a partitioned table and its partitions. > > > Really, that "Check behavior" sentence is generic for all of the > following tests, so it should also be (within the "=======" of the > previous comment) > > ~~~ > > 26. > +$node_publisher->safe_psql( > + 'postgres', qq( > + CREATE TABLE sch1.t1(a int) PARTITION BY RANGE(a); > + CREATE TABLE sch1.part1 PARTITION OF sch1.t1 FOR VALUES FROM (0) TO (5); > + CREATE TABLE sch1.part2 PARTITION OF sch1.t1 FOR VALUES FROM (6) TO (10); > + INSERT INTO sch1.t1 VALUES (1), (6); > +)); > + > +$node_subscriber->safe_psql( > + 'postgres', qq( > + CREATE TABLE sch1.t1(a int); > + CREATE TABLE sch1.part1(a int); > + CREATE TABLE sch1.part2(a int); > +)); > > 26a. > There should be a comment for this part that just says something like > "Setup partition table and partitions on the publisher that map to > normal tables on the subscriber" > > ~ > > 26b. > The INSERT should be done later, after the CREATE PUBLICATION but > before the CREATE SUBSCRIPTION. The pattern will be the same for all > the test cases. > > ~~~ > > 27. > +$node_publisher->safe_psql('postgres', > + "CREATE PUBLICATION tap_pub_part FOR ALL TABLES EXCEPT TABLE (sch1.part1)" > +); > > Even though the publish_via_partition_root is 'false' by default, I > think you should spell it out explicitly here for clarity. > > ~~~ > > 28. > +# EXCEPT TABLE (sch1.t1) with publish_via_partition_root = false > +# Excluding the partitioned table while publish_via_partition_root = false > +# still allows rows inserted into its partitions to be replicated. > > I felt you should word this differently. I don't think you should say > "inserted into its partitions" because actually, you inserted into the > partition table, and the data just ends up in the partitions. > > ~~~ > > 29. > +$node_publisher->safe_psql( > + 'postgres', qq( > + CREATE PUBLICATION tap_pub_part FOR ALL TABLES EXCEPT TABLE (sch1.t1); > + INSERT INTO sch1.t1 VALUES (1), (6); > +)); > > Ditto earlier comment. Better to explicitly say > "publish_via_partition_root=false". > I have also addressed the remaining comments and attached the latest patch. Thanks, Shlok Kyal --00000000000098f5a806460e3ee4 Content-Type: application/octet-stream; name="v32-0001-Skip-publishing-the-tables-specified-in-EXCEPT-T.patch" Content-Disposition: attachment; filename="v32-0001-Skip-publishing-the-tables-specified-in-EXCEPT-T.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mj8dek5n0 RnJvbSBlNWViMmZiYWE3ZDc0NzM1YzNiNzUzNmM0ODc3YzY4YmQ5MjhmMmU2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBTaGxvayBLeWFsIDxzaGxvay5reWFsLm9zc0BnbWFpbC5jb20+ CkRhdGU6IFR1ZSwgOSBEZWMgMjAyNSAyMjo0MToyMyArMDUzMApTdWJqZWN0OiBbUEFUQ0ggdjMy XSBTa2lwIHB1Ymxpc2hpbmcgdGhlIHRhYmxlcyBzcGVjaWZpZWQgaW4gRVhDRVBUIFRBQkxFLgoK QSBuZXcgIkVYQ0VQVCBUQUJMRSIgY2xhdXNlIGZvciBDUkVBVEUvQUxURVIgUFVCTElDQVRJT04g YWxsb3dzIG9uZSBvcgptb3JlIHRhYmxlcyB0byBiZSBleGNsdWRlZC4gVGhlIHB1Ymxpc2hlciB3 aWxsIG5vdCBzZW5kIHRoZSBkYXRhIG9mCmV4Y2x1ZGVkIHRhYmxlcyB0byB0aGUgc3Vic2NyaWJl ci4KClRoZSBuZXcgc3ludGF4IGFsbG93cyBzcGVjaWZ5aW5nIGV4Y2x1ZGVkIHJlbGF0aW9ucyB3 aGVuIGNyZWF0aW5nIGEKcHVibGljYXRpb24uIEZvciBleGFtcGxlOgpDUkVBVEUgUFVCTElDQVRJ T04gcHViMSBGT1IgQUxMIFRBQkxFUyBFWENFUFQgVEFCTEUgKHQxLHQyKTsKCkEgbmV3IGNvbHVt biAicHJleGNlcHQiIGlzIGFkZGVkIHRvIHRhYmxlICJwZ19wdWJsaWNhdGlvbl9yZWwiLCB0byBm bGFnCnRoZSByZWxhdGlvbnMgdGhhdCB0aGUgdXNlciB3YW50cyB0byBleGNsdWRlIGZyb20gdGhl IHB1YmxpY2F0aW9ucy4KCnBnX2R1bXAgaXMgdXBkYXRlZCB0byBpZGVudGlmeSBhbmQgZHVtcCB0 aGUgZXhjbHVkZWQgdGFibGVzIG9mIHRoZSBwdWJsaWNhdGlvbnMuCgpUaGUgcHNxbCBcZCBmYW1p bHkgb2YgY29tbWFuZHMgY2FuIG5vdyBkaXNwbGF5IGV4Y2x1ZGVkIHRhYmxlcy4gZS5nLiBwc3Fs ClxkUnArIHZhcmlhbnQgd2lsbCBub3cgZGlzcGxheSBhc3NvY2lhdGVkICJleGNlcHQgdGFibGVz IiBpZiBhbnkuCgpCdW1wIGNhdGFsb2cgdmVyc2lvbi4KLS0tCiBkb2Mvc3JjL3NnbWwvY2F0YWxv Z3Muc2dtbCAgICAgICAgICAgICAgICAgICAgfCAgMTAgKwogZG9jL3NyYy9zZ21sL2xvZ2ljYWwt cmVwbGljYXRpb24uc2dtbCAgICAgICAgIHwgICA2ICstCiBkb2Mvc3JjL3NnbWwvcmVmL2NyZWF0 ZV9wdWJsaWNhdGlvbi5zZ21sICAgICAgfCAgNTIgKysrKy0KIGRvYy9zcmMvc2dtbC9yZWYvcHNx bC1yZWYuc2dtbCAgICAgICAgICAgICAgICB8ICAgNSArLQogc3JjL2JhY2tlbmQvY2F0YWxvZy9w Z19wdWJsaWNhdGlvbi5jICAgICAgICAgIHwgMTc3ICsrKysrKysrKystLS0tCiBzcmMvYmFja2Vu ZC9jb21tYW5kcy9wdWJsaWNhdGlvbmNtZHMuYyAgICAgICAgfCAxMjQgKysrKysrLS0tLQogc3Jj L2JhY2tlbmQvY29tbWFuZHMvdGFibGVjbWRzLmMgICAgICAgICAgICAgIHwgICA0ICstCiBzcmMv YmFja2VuZC9wYXJzZXIvZ3JhbS55ICAgICAgICAgICAgICAgICAgICAgfCAgMzMgKystCiBzcmMv YmFja2VuZC9yZXBsaWNhdGlvbi9wZ291dHB1dC9wZ291dHB1dC5jICAgfCAgMjcgKy0tCiBzcmMv YmFja2VuZC91dGlscy9jYWNoZS9yZWxjYWNoZS5jICAgICAgICAgICAgfCAgMjMgKy0KIHNyYy9i aW4vcGdfZHVtcC9wZ19kdW1wLmMgICAgICAgICAgICAgICAgICAgICB8ICA3MCArKysrKy0KIHNy Yy9iaW4vcGdfZHVtcC9wZ19kdW1wLmggICAgICAgICAgICAgICAgICAgICB8ICAgMiArCiBzcmMv YmluL3BnX2R1bXAvcGdfZHVtcF9zb3J0LmMgICAgICAgICAgICAgICAgfCAgMTAgKy0KIHNyYy9i aW4vcGdfZHVtcC90LzAwMl9wZ19kdW1wLnBsICAgICAgICAgICAgICB8ICAzMCArKysKIHNyYy9i aW4vcHNxbC9kZXNjcmliZS5jICAgICAgICAgICAgICAgICAgICAgICB8ICA4NyArKysrKystCiBz cmMvYmluL3BzcWwvdGFiLWNvbXBsZXRlLmluLmMgICAgICAgICAgICAgICAgfCAgMTIgKy0KIHNy Yy9pbmNsdWRlL2NhdGFsb2cvcGdfcHVibGljYXRpb24uaCAgICAgICAgICB8ICAxNSArLQogc3Jj L2luY2x1ZGUvY2F0YWxvZy9wZ19wdWJsaWNhdGlvbl9yZWwuaCAgICAgIHwgICAxICsKIHNyYy9p bmNsdWRlL2NvbW1hbmRzL3B1YmxpY2F0aW9uY21kcy5oICAgICAgICB8ICAgNyArLQogc3JjL2lu Y2x1ZGUvbm9kZXMvcGFyc2Vub2Rlcy5oICAgICAgICAgICAgICAgIHwgICAzICsKIHNyYy90ZXN0 L3JlZ3Jlc3MvZXhwZWN0ZWQvcHVibGljYXRpb24ub3V0ICAgICB8ICA3NSArKysrKy0KIHNyYy90 ZXN0L3JlZ3Jlc3Mvc3FsL3B1YmxpY2F0aW9uLnNxbCAgICAgICAgICB8ICAzMyArKy0KIHNyYy90 ZXN0L3N1YnNjcmlwdGlvbi9tZXNvbi5idWlsZCAgICAgICAgICAgICB8ICAgMSArCiAuLi4vdC8w MzdfcmVwX2NoYW5nZXNfZXhjZXB0X3RhYmxlLnBsICAgICAgICAgfCAyMTggKysrKysrKysrKysr KysrKysrCiAyNCBmaWxlcyBjaGFuZ2VkLCA4NzUgaW5zZXJ0aW9ucygrKSwgMTUwIGRlbGV0aW9u cygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L3N1YnNjcmlwdGlvbi90LzAzN19yZXBf Y2hhbmdlc19leGNlcHRfdGFibGUucGwKCmRpZmYgLS1naXQgYS9kb2Mvc3JjL3NnbWwvY2F0YWxv Z3Muc2dtbCBiL2RvYy9zcmMvc2dtbC9jYXRhbG9ncy5zZ21sCmluZGV4IDJmYzYzNDQyOTgwLi45 ZTg0NzE1MmI0NCAxMDA2NDQKLS0tIGEvZG9jL3NyYy9zZ21sL2NhdGFsb2dzLnNnbWwKKysrIGIv ZG9jL3NyYy9zZ21sL2NhdGFsb2dzLnNnbWwKQEAgLTY1ODEsNiArNjU4MSwxNiBAQCBTQ1JBTS1T SEEtMjU2JDxyZXBsYWNlYWJsZT4mbHQ7aXRlcmF0aW9uIGNvdW50Jmd0OzwvcmVwbGFjZWFibGU+ OjxyZXBsYWNlYWJsZT4mbAogICAgICAgaWYgdGhlcmUgaXMgbm8gcHVibGljYXRpb24gcXVhbGlm eWluZyBjb25kaXRpb24uPC9wYXJhPjwvZW50cnk+CiAgICAgIDwvcm93PgogCisgICAgIDxyb3c+ CisgICAgICA8ZW50cnkgcm9sZT0iY2F0YWxvZ190YWJsZV9lbnRyeSI+PHBhcmEgcm9sZT0iY29s dW1uX2RlZmluaXRpb24iPgorICAgICAgPHN0cnVjdGZpZWxkPnByZXhjZXB0PC9zdHJ1Y3RmaWVs ZD4gPHR5cGU+Ym9vbDwvdHlwZT4KKyAgICAgIDwvcGFyYT4KKyAgICAgIDxwYXJhPgorICAgICAg IFRydWUgaWYgdGhlIHJlbGF0aW9uIGlzIGV4Y2x1ZGVkIGZyb20gdGhlIHB1YmxpY2F0aW9uLiBT ZWUKKyAgICAgICA8bGluayBsaW5rZW5kPSJzcWwtY3JlYXRlcHVibGljYXRpb24tcGFyYW1zLWZv ci1leGNlcHQtdGFibGUiPjxsaXRlcmFsPkVYQ0VQVCBUQUJMRTwvbGl0ZXJhbD48L2xpbms+Lgor ICAgICAgPC9wYXJhPjwvZW50cnk+CisgICAgIDwvcm93PgorCiAgICAgIDxyb3c+CiAgICAgICA8 ZW50cnkgcm9sZT0iY2F0YWxvZ190YWJsZV9lbnRyeSI+PHBhcmEgcm9sZT0iY29sdW1uX2RlZmlu aXRpb24iPgogICAgICAgIDxzdHJ1Y3RmaWVsZD5wcmF0dHJzPC9zdHJ1Y3RmaWVsZD4gPHR5cGU+ aW50MnZlY3RvcjwvdHlwZT4KZGlmZiAtLWdpdCBhL2RvYy9zcmMvc2dtbC9sb2dpY2FsLXJlcGxp Y2F0aW9uLnNnbWwgYi9kb2Mvc3JjL3NnbWwvbG9naWNhbC1yZXBsaWNhdGlvbi5zZ21sCmluZGV4 IGFhMDEzZjM0OGQ0Li44MDUxMmY4N2ZkYSAxMDA2NDQKLS0tIGEvZG9jL3NyYy9zZ21sL2xvZ2lj YWwtcmVwbGljYXRpb24uc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvbG9naWNhbC1yZXBsaWNhdGlv bi5zZ21sCkBAIC0xMTYsNyArMTE2LDExIEBACiAgICA8bGl0ZXJhbD5GT1IgVEFCTEVTIElOIFND SEVNQTwvbGl0ZXJhbD4sIDxsaXRlcmFsPkZPUiBBTEwgVEFCTEVTPC9saXRlcmFsPiwKICAgIG9y IDxsaXRlcmFsPkZPUiBBTEwgU0VRVUVOQ0VTPC9saXRlcmFsPi4gVW5saWtlIHRhYmxlcywgc2Vx dWVuY2VzIGNhbiBiZQogICAgc3luY2hyb25pemVkIGF0IGFueSB0aW1lLiBGb3IgbW9yZSBpbmZv cm1hdGlvbiwgc2VlCi0gICA8eHJlZiBsaW5rZW5kPSJsb2dpY2FsLXJlcGxpY2F0aW9uLXNlcXVl bmNlcyIvPi4KKyAgIDx4cmVmIGxpbmtlbmQ9ImxvZ2ljYWwtcmVwbGljYXRpb24tc2VxdWVuY2Vz Ii8+LiBXaGVuIGEgcHVibGljYXRpb24gaXMKKyAgIGNyZWF0ZWQgd2l0aCA8bGl0ZXJhbD5GT1Ig QUxMIFRBQkxFUzwvbGl0ZXJhbD4sIHRhYmxlcyBjYW4gYmUgZXhwbGljaXRseQorICAgZXhjbHVk ZWQgZnJvbSBwdWJsaWNhdGlvbiB1c2luZyB0aGUgPGxpdGVyYWw+RVhDRVBUIFRBQkxFPC9saXRl cmFsPiBjbGF1c2UuCisgICBTZWUgPGxpbmsgbGlua2VuZD0ic3FsLWNyZWF0ZXB1YmxpY2F0aW9u LXBhcmFtcy1mb3ItZXhjZXB0LXRhYmxlIj48bGl0ZXJhbD5FWENFUFQgVEFCTEU8L2xpdGVyYWw+ PC9saW5rPgorICAgZm9yIG1vcmUgaW5mb3JtYXRpb24uCiAgIDwvcGFyYT4KIAogICA8cGFyYT4K ZGlmZiAtLWdpdCBhL2RvYy9zcmMvc2dtbC9yZWYvY3JlYXRlX3B1YmxpY2F0aW9uLnNnbWwgYi9k b2Mvc3JjL3NnbWwvcmVmL2NyZWF0ZV9wdWJsaWNhdGlvbi5zZ21sCmluZGV4IDc1YTUwOGJlYmZh Li42YjFjN2YzODNlNSAxMDA2NDQKLS0tIGEvZG9jL3NyYy9zZ21sL3JlZi9jcmVhdGVfcHVibGlj YXRpb24uc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvcmVmL2NyZWF0ZV9wdWJsaWNhdGlvbi5zZ21s CkBAIC0zMiwxMiArMzIsMTYgQEAgQ1JFQVRFIFBVQkxJQ0FUSU9OIDxyZXBsYWNlYWJsZSBjbGFz cz0icGFyYW1ldGVyIj5uYW1lPC9yZXBsYWNlYWJsZT4KIAogPHBocmFzZT5hbmQgPHJlcGxhY2Vh YmxlIGNsYXNzPSJwYXJhbWV0ZXIiPnB1YmxpY2F0aW9uX2FsbF9vYmplY3Q8L3JlcGxhY2VhYmxl PiBpcyBvbmUgb2Y6PC9waHJhc2U+CiAKLSAgICBBTEwgVEFCTEVTCisgICAgQUxMIFRBQkxFUyBb IEVYQ0VQVCBbIFRBQkxFIF0gKCA8cmVwbGFjZWFibGUgY2xhc3M9InBhcmFtZXRlciI+ZXhjZXB0 X3RhYmxlX29iamVjdDwvcmVwbGFjZWFibGU+IFssIC4uLiBdICkgXQogICAgIEFMTCBTRVFVRU5D RVMKIAogPHBocmFzZT5hbmQgPHJlcGxhY2VhYmxlIGNsYXNzPSJwYXJhbWV0ZXIiPnRhYmxlX2Fu ZF9jb2x1bW5zPC9yZXBsYWNlYWJsZT4gaXM6PC9waHJhc2U+CiAKICAgICBbIE9OTFkgXSA8cmVw bGFjZWFibGUgY2xhc3M9InBhcmFtZXRlciI+dGFibGVfbmFtZTwvcmVwbGFjZWFibGU+IFsgKiBd IFsgKCA8cmVwbGFjZWFibGUgY2xhc3M9InBhcmFtZXRlciI+Y29sdW1uX25hbWU8L3JlcGxhY2Vh YmxlPiBbLCAuLi4gXSApIF0gWyBXSEVSRSAoIDxyZXBsYWNlYWJsZSBjbGFzcz0icGFyYW1ldGVy Ij5leHByZXNzaW9uPC9yZXBsYWNlYWJsZT4gKSBdCisKKzxwaHJhc2U+d2hlcmUgPHJlcGxhY2Vh YmxlIGNsYXNzPSJwYXJhbWV0ZXIiPmV4Y2VwdF90YWJsZV9vYmplY3Q8L3JlcGxhY2VhYmxlPiBp czo8L3BocmFzZT4KKworICAgIFsgT05MWSBdIDxyZXBsYWNlYWJsZSBjbGFzcz0icGFyYW1ldGVy Ij50YWJsZV9uYW1lPC9yZXBsYWNlYWJsZT4gWyAqIF0KIDwvc3lub3BzaXM+CiAgPC9yZWZzeW5v cHNpc2Rpdj4KIApAQCAtMTY0LDcgKzE2OCw4IEBAIENSRUFURSBQVUJMSUNBVElPTiA8cmVwbGFj ZWFibGUgY2xhc3M9InBhcmFtZXRlciI+bmFtZTwvcmVwbGFjZWFibGU+CiAgICAgPGxpc3RpdGVt PgogICAgICA8cGFyYT4KICAgICAgIE1hcmtzIHRoZSBwdWJsaWNhdGlvbiBhcyBvbmUgdGhhdCBy ZXBsaWNhdGVzIGNoYW5nZXMgZm9yIGFsbCB0YWJsZXMgaW4KLSAgICAgIHRoZSBkYXRhYmFzZSwg aW5jbHVkaW5nIHRhYmxlcyBjcmVhdGVkIGluIHRoZSBmdXR1cmUuCisgICAgICB0aGUgZGF0YWJh c2UsIGluY2x1ZGluZyB0YWJsZXMgY3JlYXRlZCBpbiB0aGUgZnV0dXJlLiBUYWJsZXMgbGlzdGVk IGluCisgICAgICBFWENFUFQgVEFCTEUgYXJlIGV4Y2x1ZGVkIGZyb20gdGhlIHB1YmxpY2F0aW9u LgogICAgICA8L3BhcmE+CiAgICAgPC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgpAQCAt MTg0LDYgKzE4OSwzMiBAQCBDUkVBVEUgUFVCTElDQVRJT04gPHJlcGxhY2VhYmxlIGNsYXNzPSJw YXJhbWV0ZXIiPm5hbWU8L3JlcGxhY2VhYmxlPgogICAgIDwvbGlzdGl0ZW0+CiAgICA8L3Zhcmxp c3RlbnRyeT4KIAorICAgPHZhcmxpc3RlbnRyeSBpZD0ic3FsLWNyZWF0ZXB1YmxpY2F0aW9uLXBh cmFtcy1mb3ItZXhjZXB0LXRhYmxlIj4KKyAgICA8dGVybT48bGl0ZXJhbD5FWENFUFQgVEFCTEU8 L2xpdGVyYWw+PC90ZXJtPgorICAgIDxsaXN0aXRlbT4KKyAgICAgPHBhcmE+CisgICAgICBUaGlz IGNsYXVzZSBzcGVjaWZpZXMgYSBsaXN0IG9mIHRhYmxlcyB0byBiZSBleGNsdWRlZCBmcm9tIHRo ZQorICAgICAgcHVibGljYXRpb24uIElmIDxsaXRlcmFsPk9OTFk8L2xpdGVyYWw+IGlzIHNwZWNp ZmllZCBiZWZvcmUgdGhlIHRhYmxlCisgICAgICBuYW1lLCBvbmx5IHRoYXQgdGFibGUgaXMgZXhj bHVkZWQgZnJvbSB0aGUgcHVibGljYXRpb24uIElmCisgICAgICA8bGl0ZXJhbD5PTkxZPC9saXRl cmFsPiBpcyBub3Qgc3BlY2lmaWVkLCB0aGUgdGFibGUgYW5kIGFsbCBpdHMgZGVzY2VuZGFudAor ICAgICAgdGFibGVzIChpZiBhbnkpIGFyZSBleGNsdWRlZC4gT3B0aW9uYWxseSwgPGxpdGVyYWw+ KjwvbGl0ZXJhbD4gY2FuIGJlCisgICAgICBzcGVjaWZpZWQgYWZ0ZXIgdGhlIHRhYmxlIG5hbWUg dG8gZXhwbGljaXRseSBpbmRpY2F0ZSB0aGF0IGRlc2NlbmRhbnQKKyAgICAgIHRhYmxlcyBhcmUg ZXhjbHVkZWQuIFRoaXMgZG9lcyBub3QgYXBwbHkgdG8gYSBwYXJ0aXRpb25lZCB0YWJsZSwgaG93 ZXZlci4KKyAgICAgPC9wYXJhPgorICAgICA8cGFyYT4KKyAgICAgIFdoZW4gPGxpdGVyYWw+cHVi bGlzaF92aWFfcGFydGl0aW9uX3Jvb3Q8L2xpdGVyYWw+IGlzIHNldCB0bworICAgICAgPGxpdGVy YWw+dHJ1ZTwvbGl0ZXJhbD4sIHNwZWNpZnlpbmcgYSByb290IHBhcnRpdGlvbmVkIHRhYmxlIGlu CisgICAgICA8bGl0ZXJhbD5FWENFUFQgVEFCTEU8L2xpdGVyYWw+IGV4Y2x1ZGVzIGl0IGFuZCBh bGwgaXRzIHBhcnRpdGlvbnMgZnJvbQorICAgICAgcmVwbGljYXRpb24uIFNwZWNpZnlpbmcgYSBs ZWFmIHBhcnRpdGlvbiBoYXMgbm8gZWZmZWN0LCBhcyBpdHMgY2hhbmdlcyBhcmUKKyAgICAgIHN0 aWxsIHJlcGxpY2F0ZWQgdmlhIHRoZSByb290IHBhcnRpdGlvbmVkIHRhYmxlLiBXaGVuCisgICAg ICA8bGl0ZXJhbD5wdWJsaXNoX3ZpYV9wYXJ0aXRpb25fcm9vdDwvbGl0ZXJhbD4gaXMgc2V0IHRv CisgICAgICA8bGl0ZXJhbD5mYWxzZTwvbGl0ZXJhbD4sIHNwZWNpZnlpbmcgYSByb290IHBhcnRp dGlvbmVkIHRhYmxlIGhhcyBubworICAgICAgZWZmZWN0LCBhcyBjaGFuZ2VzIGFyZSByZXBsaWNh dGVkIHZpYSB0aGUgbGVhZiBwYXJ0aXRpb25zLiBTcGVjaWZ5aW5nIGEKKyAgICAgIGxlYWYgcGFy dGl0aW9uIGV4Y2x1ZGVzIG9ubHkgdGhhdCBwYXJ0aXRpb24gZnJvbSByZXBsaWNhdGlvbi4KKyAg ICAgPC9wYXJhPgorICAgIDwvbGlzdGl0ZW0+CisgICA8L3Zhcmxpc3RlbnRyeT4KKwogICAgPHZh cmxpc3RlbnRyeSBpZD0ic3FsLWNyZWF0ZXB1YmxpY2F0aW9uLXBhcmFtcy13aXRoIj4KICAgICA8 dGVybT48bGl0ZXJhbD5XSVRIICggPHJlcGxhY2VhYmxlIGNsYXNzPSJwYXJhbWV0ZXIiPnB1Ymxp Y2F0aW9uX3BhcmFtZXRlcjwvcmVwbGFjZWFibGU+IFs9IDxyZXBsYWNlYWJsZSBjbGFzcz0icGFy YW1ldGVyIj52YWx1ZTwvcmVwbGFjZWFibGU+XSBbLCAuLi4gXSApPC9saXRlcmFsPjwvdGVybT4K ICAgICA8bGlzdGl0ZW0+CkBAIC00ODcsNiArNTE4LDIzIEBAIENSRUFURSBQVUJMSUNBVElPTiBh bGxfc2VxdWVuY2VzIEZPUiBBTEwgU0VRVUVOQ0VTOwogICAgYWxsIHNlcXVlbmNlcyBmb3Igc3lu Y2hyb25pemF0aW9uOgogPHByb2dyYW1saXN0aW5nPgogQ1JFQVRFIFBVQkxJQ0FUSU9OIGFsbF90 YWJsZXNfc2VxdWVuY2VzIEZPUiBBTEwgVEFCTEVTLCBBTEwgU0VRVUVOQ0VTOworPC9wcm9ncmFt bGlzdGluZz4KKyAgPC9wYXJhPgorCisgIDxwYXJhPgorICAgQ3JlYXRlIGEgcHVibGljYXRpb24g dGhhdCBwdWJsaXNoZXMgYWxsIGNoYW5nZXMgaW4gYWxsIHRhYmxlcyBleGNlcHQKKyAgIDxzdHJ1 Y3RuYW1lPnVzZXJzPC9zdHJ1Y3RuYW1lPiBhbmQgPHN0cnVjdG5hbWU+ZGVwYXJ0bWVudHM8L3N0 cnVjdG5hbWU+OgorPHByb2dyYW1saXN0aW5nPgorQ1JFQVRFIFBVQkxJQ0FUSU9OIGFsbF90YWJs ZXNfZXhjZXB0IEZPUiBBTEwgVEFCTEVTIEVYQ0VQVCAodXNlcnMsIGRlcGFydG1lbnRzKTsKKzwv cHJvZ3JhbWxpc3Rpbmc+CisgIDwvcGFyYT4KKworICA8cGFyYT4KKyAgIENyZWF0ZSBhIHB1Ymxp Y2F0aW9uIHRoYXQgcHVibGlzaGVzIGFsbCBjaGFuZ2VzIGluIGFsbCBzZXF1ZW5jZXMgYW5kIGFs bAorICAgdGFibGVzIGV4Y2VwdCB0YWJsZXMgPHN0cnVjdG5hbWU+dXNlcnM8L3N0cnVjdG5hbWU+ IGFuZAorICAgPHN0cnVjdG5hbWU+ZGVwYXJ0bWVudHM8L3N0cnVjdG5hbWU+OgorPHByb2dyYW1s aXN0aW5nPgorQ1JFQVRFIFBVQkxJQ0FUSU9OIGFsbF9zZXF1ZW5jZXNfdGFibGVzX2V4Y2VwdCBG T1IgQUxMIFNFUVVFTkNFUywgQUxMIFRBQkxFUyBFWENFUFQgKHVzZXJzLCBkZXBhcnRtZW50cyk7 CiA8L3Byb2dyYW1saXN0aW5nPgogICA8L3BhcmE+CiAgPC9yZWZzZWN0MT4KZGlmZiAtLWdpdCBh L2RvYy9zcmMvc2dtbC9yZWYvcHNxbC1yZWYuc2dtbCBiL2RvYy9zcmMvc2dtbC9yZWYvcHNxbC1y ZWYuc2dtbAppbmRleCBmNTZjNzAyNjNlMC4uZjFiM2NlMzgwYjYgMTAwNjQ0Ci0tLSBhL2RvYy9z cmMvc2dtbC9yZWYvcHNxbC1yZWYuc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvcmVmL3BzcWwtcmVm LnNnbWwKQEAgLTIxMDMsOCArMjEwMyw5IEBAIFNFTEVDVCAkMSBccGFyc2Ugc3RtdDEKICAgICAg ICAgbGlzdGVkLgogICAgICAgICBJZiA8bGl0ZXJhbD54PC9saXRlcmFsPiBpcyBhcHBlbmRlZCB0 byB0aGUgY29tbWFuZCBuYW1lLCB0aGUgcmVzdWx0cwogICAgICAgICBhcmUgZGlzcGxheWVkIGlu IGV4cGFuZGVkIG1vZGUuCi0gICAgICAgIElmIDxsaXRlcmFsPis8L2xpdGVyYWw+IGlzIGFwcGVu ZGVkIHRvIHRoZSBjb21tYW5kIG5hbWUsIHRoZSB0YWJsZXMgYW5kCi0gICAgICAgIHNjaGVtYXMg YXNzb2NpYXRlZCB3aXRoIGVhY2ggcHVibGljYXRpb24gYXJlIHNob3duIGFzIHdlbGwuCisgICAg ICAgIElmIDxsaXRlcmFsPis8L2xpdGVyYWw+IGlzIGFwcGVuZGVkIHRvIHRoZSBjb21tYW5kIG5h bWUsIHRoZSB0YWJsZXMsCisgICAgICAgIGV4Y2x1ZGVkIHRhYmxlcywgYW5kIHNjaGVtYXMgYXNz b2NpYXRlZCB3aXRoIGVhY2ggcHVibGljYXRpb24gYXJlIHNob3duCisgICAgICAgIGFzIHdlbGwu CiAgICAgICAgIDwvcGFyYT4KICAgICAgICAgPC9saXN0aXRlbT4KICAgICAgIDwvdmFybGlzdGVu dHJ5PgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY2F0YWxvZy9wZ19wdWJsaWNhdGlvbi5jIGIv c3JjL2JhY2tlbmQvY2F0YWxvZy9wZ19wdWJsaWNhdGlvbi5jCmluZGV4IDdhYTNmMTc5OTI0Li44 NmQ5YmYxMmE0NSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY2F0YWxvZy9wZ19wdWJsaWNhdGlv bi5jCisrKyBiL3NyYy9iYWNrZW5kL2NhdGFsb2cvcGdfcHVibGljYXRpb24uYwpAQCAtMzU0LDcg KzM1NCw4IEBAIEdldFB1YlBhcnRpdGlvbk9wdGlvblJlbGF0aW9ucyhMaXN0ICpyZXN1bHQsIFB1 YmxpY2F0aW9uUGFydE9wdCBwdWJfcGFydG9wdCwKICAqIGFuY2VzdG9yIGlzIGF0IHRoZSBlbmQg b2YgdGhlIGxpc3QuCiAgKi8KIE9pZAotR2V0VG9wTW9zdEFuY2VzdG9ySW5QdWJsaWNhdGlvbihP aWQgcHVib2lkLCBMaXN0ICphbmNlc3RvcnMsIGludCAqYW5jZXN0b3JfbGV2ZWwpCitHZXRUb3BN b3N0QW5jZXN0b3JJblB1YmxpY2F0aW9uKE9pZCBwdWJvaWQsIExpc3QgKmFuY2VzdG9ycywKKwkJ CQkJCQkJaW50ICphbmNlc3Rvcl9sZXZlbCwgYm9vbCBwdWJhbGx0YWJsZXMpCiB7CiAJTGlzdENl bGwgICAqbGM7CiAJT2lkCQkJdG9wbW9zdF9yZWxpZCA9IEludmFsaWRPaWQ7CkBAIC0zNjYsMzIg KzM2Nyw0MiBAQCBHZXRUb3BNb3N0QW5jZXN0b3JJblB1YmxpY2F0aW9uKE9pZCBwdWJvaWQsIExp c3QgKmFuY2VzdG9ycywgaW50ICphbmNlc3Rvcl9sZXZlbAogCWZvcmVhY2gobGMsIGFuY2VzdG9y cykKIAl7CiAJCU9pZAkJCWFuY2VzdG9yID0gbGZpcnN0X29pZChsYyk7Ci0JCUxpc3QJICAgKmFw dWJpZHMgPSBHZXRSZWxhdGlvblB1YmxpY2F0aW9ucyhhbmNlc3Rvcik7Ci0JCUxpc3QJICAgKmFz Y2hlbWFQdWJpZHMgPSBOSUw7CisJCUxpc3QJICAgKmFwdWJpZHMgPSBOSUw7CisJCUxpc3QJICAg KmFleGNlcHRwdWJpZHMgPSBOSUw7CisJCWJvb2wJCXNldF90b3AgPSBmYWxzZTsKKworCQlHZXRS ZWxhdGlvblB1YmxpY2F0aW9ucyhhbmNlc3RvciwgJmFwdWJpZHMsICZhZXhjZXB0cHViaWRzKTsK IAogCQlsZXZlbCsrOwogCi0JCWlmIChsaXN0X21lbWJlcl9vaWQoYXB1YmlkcywgcHVib2lkKSkK KwkJLyogY2hlY2sgaWYgbWVtYmVyIG9mIHRhYmxlIHB1YmxpY2F0aW9ucyAqLworCQlzZXRfdG9w ID0gbGlzdF9tZW1iZXJfb2lkKGFwdWJpZHMsIHB1Ym9pZCk7CisJCWlmICghc2V0X3RvcCkKIAkJ ewotCQkJdG9wbW9zdF9yZWxpZCA9IGFuY2VzdG9yOworCQkJTGlzdAkgICAqYXNjaGVtYXB1Ymlk cyA9IEdldFNjaGVtYVB1YmxpY2F0aW9ucyhnZXRfcmVsX25hbWVzcGFjZShhbmNlc3RvcikpOwog Ci0JCQlpZiAoYW5jZXN0b3JfbGV2ZWwpCi0JCQkJKmFuY2VzdG9yX2xldmVsID0gbGV2ZWw7CisJ CQkvKiBjaGVjayBpZiBtZW1iZXIgb2Ygc2NoZW1hIHB1YmxpY2F0aW9ucyAqLworCQkJc2V0X3Rv cCA9IGxpc3RfbWVtYmVyX29pZChhc2NoZW1hcHViaWRzLCBwdWJvaWQpOworCQkJbGlzdF9mcmVl KGFzY2hlbWFwdWJpZHMpOworCisJCQkvKgorCQkJICogSWYgdGhlIHB1YmxpY2F0aW9uIGlzIGFs bCB0YWJsZXMgcHVibGljYXRpb24gYW5kIHRoZSB0YWJsZSBpcworCQkJICogbm90IHBhcnQgb2Yg ZXhjZXB0aW9uIHRhYmxlcy4KKwkJCSAqLworCQkJaWYgKCFzZXRfdG9wICYmIHB1YmFsbHRhYmxl cykKKwkJCQlzZXRfdG9wID0gIWxpc3RfbWVtYmVyX29pZChhZXhjZXB0cHViaWRzLCBwdWJvaWQp OwogCQl9Ci0JCWVsc2UKKworCQlpZiAoc2V0X3RvcCkKIAkJewotCQkJYXNjaGVtYVB1YmlkcyA9 IEdldFNjaGVtYVB1YmxpY2F0aW9ucyhnZXRfcmVsX25hbWVzcGFjZShhbmNlc3RvcikpOwotCQkJ aWYgKGxpc3RfbWVtYmVyX29pZChhc2NoZW1hUHViaWRzLCBwdWJvaWQpKQotCQkJewotCQkJCXRv cG1vc3RfcmVsaWQgPSBhbmNlc3RvcjsKKwkJCXRvcG1vc3RfcmVsaWQgPSBhbmNlc3RvcjsKIAot CQkJCWlmIChhbmNlc3Rvcl9sZXZlbCkKLQkJCQkJKmFuY2VzdG9yX2xldmVsID0gbGV2ZWw7Ci0J CQl9CisJCQlpZiAoYW5jZXN0b3JfbGV2ZWwpCisJCQkJKmFuY2VzdG9yX2xldmVsID0gbGV2ZWw7 CiAJCX0KIAogCQlsaXN0X2ZyZWUoYXB1Ymlkcyk7Ci0JCWxpc3RfZnJlZShhc2NoZW1hUHViaWRz KTsKKwkJbGlzdF9mcmVlKGFleGNlcHRwdWJpZHMpOwogCX0KIAogCXJldHVybiB0b3Btb3N0X3Jl bGlkOwpAQCAtNDY2LDYgKzQ3NywyNiBAQCBwdWJsaWNhdGlvbl9hZGRfcmVsYXRpb24oT2lkIHB1 YmlkLCBQdWJsaWNhdGlvblJlbEluZm8gKnByaSwKIAkJCQkJCVJlbGF0aW9uR2V0UmVsYXRpb25O YW1lKHRhcmdldHJlbCksIHB1Yi0+bmFtZSkpKTsKIAl9CiAKKwkvKgorCSAqIEhhbmRsZSB0aGUg Y2FzZSB3aGVyZSBhIHBhcnRpdGlvbiBpcyBleGNsdWRlZCBieSBFWENFUFQgVEFCTEUgd2hpbGUK KwkgKiBwdWJsaXNoX3ZpYV9wYXJ0aXRpb25fcm9vdCA9IHRydWUuCisJICovCisJaWYgKHB1Yi0+ YWxsdGFibGVzICYmIHB1Yi0+cHVidmlhcm9vdCAmJiBwcmktPmV4Y2VwdCAmJgorCQl0YXJnZXRy ZWwtPnJkX3JlbC0+cmVsaXNwYXJ0aXRpb24pCisJCWVyZXBvcnQoV0FSTklORywKKwkJCQkoZXJy bXNnKCJwYXJ0aXRpb24gXCIlc1wiIG1pZ2h0IGJlIHJlcGxpY2F0ZWQgYXMgcHVibGlzaF92aWFf cGFydGl0aW9uX3Jvb3QgaXMgXCIlc1wiIiwKKwkJCQkJCVJlbGF0aW9uR2V0UmVsYXRpb25OYW1l KHRhcmdldHJlbCksICJ0cnVlIikpKTsKKworCS8qCisJICogSGFuZGxlIHRoZSBjYXNlIHdoZXJl IGEgcGFydGl0aW9uZWQgdGFibGUgaXMgZXhjbHVkZWQgYnkgRVhDRVBUIFRBQkxFCisJICogd2hp bGUgcHVibGlzaF92aWFfcGFydGl0aW9uX3Jvb3QgPSBmYWxzZS4KKwkgKi8KKwlpZiAocHViLT5h bGx0YWJsZXMgJiYgIXB1Yi0+cHVidmlhcm9vdCAmJiBwcmktPmV4Y2VwdCAmJgorCQl0YXJnZXRy ZWwtPnJkX3JlbC0+cmVsa2luZCA9PSBSRUxLSU5EX1BBUlRJVElPTkVEX1RBQkxFKQorCQllcmVw b3J0KFdBUk5JTkcsCisJCQkJKGVycm1zZygicGFydGl0aW9uZWQgdGFibGUgXCIlc1wiIG1pZ2h0 IGJlIHJlcGxpY2F0ZWQgYXMgcHVibGlzaF92aWFfcGFydGl0aW9uX3Jvb3QgaXMgXCIlc1wiIiwK KwkJCQkJCVJlbGF0aW9uR2V0UmVsYXRpb25OYW1lKHRhcmdldHJlbCksICJmYWxzZSIpKSk7CisK IAljaGVja19wdWJsaWNhdGlvbl9hZGRfcmVsYXRpb24odGFyZ2V0cmVsKTsKIAogCS8qIFZhbGlk YXRlIGFuZCB0cmFuc2xhdGUgY29sdW1uIG5hbWVzIGludG8gYSBCaXRtYXBzZXQgb2YgYXR0bnVt cy4gKi8KQEAgLTQ4Miw2ICs1MTMsOCBAQCBwdWJsaWNhdGlvbl9hZGRfcmVsYXRpb24oT2lkIHB1 YmlkLCBQdWJsaWNhdGlvblJlbEluZm8gKnByaSwKIAkJT2JqZWN0SWRHZXREYXR1bShwdWJpZCk7 CiAJdmFsdWVzW0FudW1fcGdfcHVibGljYXRpb25fcmVsX3BycmVsaWQgLSAxXSA9CiAJCU9iamVj dElkR2V0RGF0dW0ocmVsaWQpOworCXZhbHVlc1tBbnVtX3BnX3B1YmxpY2F0aW9uX3JlbF9wcmV4 Y2VwdCAtIDFdID0KKwkJQm9vbEdldERhdHVtKHByaS0+ZXhjZXB0KTsKIAogCS8qIEFkZCBxdWFs aWZpY2F0aW9ucywgaWYgYXZhaWxhYmxlICovCiAJaWYgKHByaS0+d2hlcmVDbGF1c2UgIT0gTlVM TCkKQEAgLTc0OSwzOCArNzgyLDU4IEBAIHB1YmxpY2F0aW9uX2FkZF9zY2hlbWEoT2lkIHB1Ymlk LCBPaWQgc2NoZW1haWQsIGJvb2wgaWZfbm90X2V4aXN0cykKIAlyZXR1cm4gbXlzZWxmOwogfQog Ci0vKiBHZXRzIGxpc3Qgb2YgcHVibGljYXRpb24gb2lkcyBmb3IgYSByZWxhdGlvbiAqLwotTGlz dCAqCi1HZXRSZWxhdGlvblB1YmxpY2F0aW9ucyhPaWQgcmVsaWQpCisvKgorICogR2V0IHRoZSBs aXN0IG9mIHB1YmxpY2F0aW9uIG9pZHMgYXNzb2NpYXRlZCB3aXRoIGEgc3BlY2lmaWVkIHJlbGF0 aW9uLgorICoKKyAqIFBhcmFtZXRlciAncHViaWRzJyByZXR1cm5zIHRoZSBPSURzIG9mIHRoZSBw dWJsaWNhdGlvbnMgdGhlIHJlbGF0aW9uIGlzIHBhcnQKKyAqIG9mLiBQYXJhbWV0ZXIgJ2V4Y2Vw dF9wdWJpZHMnIHJldHVybnMgdGhlIE9JRHMgb2YgcHVibGljYXRpb25zIHRoZSByZWxhdGlvbgor ICogaXMgZXhjbHVkZWQgZnJvbS4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIHJldHVybnMgdHJ1ZSBp ZiB0aGUgcmVsYXRpb24gaXMgcGFydCBvZiBhbnkgcHVibGljYXRpb24uCisgKi8KK2Jvb2wKK0dl dFJlbGF0aW9uUHVibGljYXRpb25zKE9pZCByZWxpZCwgTGlzdCAqKnB1YmlkcywgTGlzdCAqKmV4 Y2VwdF9wdWJpZHMpCiB7Ci0JTGlzdAkgICAqcmVzdWx0ID0gTklMOwogCUNhdENMaXN0ICAgKnB1 YnJlbGxpc3Q7Ci0JaW50CQkJaTsKKwlib29sCQlmb3VuZCA9IGZhbHNlOwogCiAJLyogRmluZCBh bGwgcHVibGljYXRpb25zIGFzc29jaWF0ZWQgd2l0aCB0aGUgcmVsYXRpb24uICovCiAJcHVicmVs bGlzdCA9IFNlYXJjaFN5c0NhY2hlTGlzdDEoUFVCTElDQVRJT05SRUxNQVAsCiAJCQkJCQkJCQkg T2JqZWN0SWRHZXREYXR1bShyZWxpZCkpOwotCWZvciAoaSA9IDA7IGkgPCBwdWJyZWxsaXN0LT5u X21lbWJlcnM7IGkrKykKKwlmb3IgKGludCBpID0gMDsgaSA8IHB1YnJlbGxpc3QtPm5fbWVtYmVy czsgaSsrKQogCXsKIAkJSGVhcFR1cGxlCXR1cCA9ICZwdWJyZWxsaXN0LT5tZW1iZXJzW2ldLT50 dXBsZTsKLQkJT2lkCQkJcHViaWQgPSAoKEZvcm1fcGdfcHVibGljYXRpb25fcmVsKSBHRVRTVFJV Q1QodHVwKSktPnBycHViaWQ7CisJCUZvcm1fcGdfcHVibGljYXRpb25fcmVsIHB1YnJlbCA9IChG b3JtX3BnX3B1YmxpY2F0aW9uX3JlbCkgR0VUU1RSVUNUKHR1cCk7CisJCU9pZAkJCXB1YmlkID0g cHVicmVsLT5wcnB1YmlkOwogCi0JCXJlc3VsdCA9IGxhcHBlbmRfb2lkKHJlc3VsdCwgcHViaWQp OworCQlpZiAocHVicmVsLT5wcmV4Y2VwdCkKKwkJeworCQkJaWYgKGV4Y2VwdF9wdWJpZHMpCisJ CQkJKmV4Y2VwdF9wdWJpZHMgPSBsYXBwZW5kX29pZCgqZXhjZXB0X3B1YmlkcywgcHViaWQpOwor CQl9CisJCWVsc2UKKwkJeworCQkJaWYgKHB1YmlkcykKKwkJCQkqcHViaWRzID0gbGFwcGVuZF9v aWQoKnB1YmlkcywgcHViaWQpOworCQkJZm91bmQgPSB0cnVlOworCQl9CiAJfQogCiAJUmVsZWFz ZVN5c0NhY2hlTGlzdChwdWJyZWxsaXN0KTsKIAotCXJldHVybiByZXN1bHQ7CisJcmV0dXJuIGZv dW5kOwogfQogCiAvKgotICogR2V0cyBsaXN0IG9mIHJlbGF0aW9uIG9pZHMgZm9yIGEgcHVibGlj YXRpb24uCisgKiBJbnRlcm5hbCBmdW5jdGlvbiB0byBnZXQgdGhlIGxpc3Qgb2YgcmVsYXRpb24g T0lEcyBmb3IgYSBwdWJsaWNhdGlvbi4KICAqCi0gKiBUaGlzIHNob3VsZCBvbmx5IGJlIHVzZWQg Rk9SIFRBQkxFIHB1YmxpY2F0aW9ucywgdGhlIEZPUiBBTEwgVEFCTEVTL1NFUVVFTkNFUwotICog c2hvdWxkIHVzZSBHZXRBbGxQdWJsaWNhdGlvblJlbGF0aW9ucygpLgorICogSWYgZXhjZXB0X2Zs YWcgaXMgdHJ1ZSwgcmV0dXJucyB0aGUgbGlzdCBvZiByZWxhdGlvbnMgZXhjbHVkZWQgZnJvbSB0 aGUKKyAqIHB1YmxpY2F0aW9uOyBvdGhlcndpc2UsIHJldHVybnMgdGhlIGxpc3Qgb2YgcmVsYXRp b25zIGluY2x1ZGVkIGluIHRoZQorICogcHVibGljYXRpb24uCiAgKi8KLUxpc3QgKgotR2V0UHVi bGljYXRpb25SZWxhdGlvbnMoT2lkIHB1YmlkLCBQdWJsaWNhdGlvblBhcnRPcHQgcHViX3BhcnRv cHQpCitzdGF0aWMgTGlzdCAqCitHZXRQdWJsaWNhdGlvblJlbGF0aW9uc0ludGVybmFsKE9pZCBw dWJpZCwgUHVibGljYXRpb25QYXJ0T3B0IHB1Yl9wYXJ0b3B0LAorCQkJCQkJCQlib29sIGV4Y2Vw dF9mbGFnKQogewogCUxpc3QJICAgKnJlc3VsdDsKIAlSZWxhdGlvbglwdWJyZWxzcmVsOwpAQCAt ODA1LDggKzg1OCwxMCBAQCBHZXRQdWJsaWNhdGlvblJlbGF0aW9ucyhPaWQgcHViaWQsIFB1Ymxp Y2F0aW9uUGFydE9wdCBwdWJfcGFydG9wdCkKIAkJRm9ybV9wZ19wdWJsaWNhdGlvbl9yZWwgcHVi cmVsOwogCiAJCXB1YnJlbCA9IChGb3JtX3BnX3B1YmxpY2F0aW9uX3JlbCkgR0VUU1RSVUNUKHR1 cCk7Ci0JCXJlc3VsdCA9IEdldFB1YlBhcnRpdGlvbk9wdGlvblJlbGF0aW9ucyhyZXN1bHQsIHB1 Yl9wYXJ0b3B0LAotCQkJCQkJCQkJCQkJcHVicmVsLT5wcnJlbGlkKTsKKworCQlpZiAoZXhjZXB0 X2ZsYWcgPT0gcHVicmVsLT5wcmV4Y2VwdCkKKwkJCXJlc3VsdCA9IEdldFB1YlBhcnRpdGlvbk9w dGlvblJlbGF0aW9ucyhyZXN1bHQsIHB1Yl9wYXJ0b3B0LAorCQkJCQkJCQkJCQkJCXB1YnJlbC0+ cHJyZWxpZCk7CiAJfQogCiAJc3lzdGFibGVfZW5kc2NhbihzY2FuKTsKQEAgLTgxOSw2ICs4NzQs MzQgQEAgR2V0UHVibGljYXRpb25SZWxhdGlvbnMoT2lkIHB1YmlkLCBQdWJsaWNhdGlvblBhcnRP cHQgcHViX3BhcnRvcHQpCiAJcmV0dXJuIHJlc3VsdDsKIH0KIAorLyoKKyAqIFJldHVybiB0aGUg bGlzdCBvZiByZWxhdGlvbiBPSURzIGZvciBhIHB1YmxpY2F0aW9uLgorICoKKyAqIEZvciBhIEZP UiBUQUJMRSBwdWJsaWNhdGlvbiwgdGhpcyByZXR1cm5zIHRoZSBsaXN0IG9mIHJlbGF0aW9ucyBl eHBsaWNpdGx5CisgKiBpbmNsdWRlZCBpbiB0aGUgcHVibGljYXRpb24uCisgKgorICogUHVibGlj YXRpb25zIGRlY2xhcmVkIHdpdGggRk9SIEFMTCBUQUJMRVMgb3IgRk9SIEFMTCBTRVFVRU5DRVMg c2hvdWxkIHVzZQorICogR2V0QWxsUHVibGljYXRpb25SZWxhdGlvbnMoKSB0byBvYnRhaW4gdGhl IGNvbXBsZXRlIHNldCBvZiB0YWJsZXMgY292ZXJlZCBieQorICogdGhlIHB1YmxpY2F0aW9uLgor ICovCitMaXN0ICoKK0dldFB1YmxpY2F0aW9uSW5jbHVkZWRSZWxhdGlvbnMoT2lkIHB1YmlkLCBQ dWJsaWNhdGlvblBhcnRPcHQgcHViX3BhcnRvcHQpCit7CisJcmV0dXJuIEdldFB1YmxpY2F0aW9u UmVsYXRpb25zSW50ZXJuYWwocHViaWQsIHB1Yl9wYXJ0b3B0LCBmYWxzZSk7Cit9CisKKy8qCisg KiBSZXR1cm4gdGhlIGxpc3Qgb2YgcmVsYXRpb24gT0lEcyBleGNsdWRlZCBmcm9tIGEgcHVibGlj YXRpb24uCisgKiBUaGlzIGlzIG9ubHkgYXBwbGljYWJsZSBmb3IgRk9SIEFMTCBUQUJMRVMgcHVi bGljYXRpb25zLgorICovCitMaXN0ICoKK0dldFB1YmxpY2F0aW9uRXhjbHVkZWRSZWxhdGlvbnMo T2lkIHB1YmlkLCBQdWJsaWNhdGlvblBhcnRPcHQgcHViX3BhcnRvcHQpCit7CisJQXNzZXJ0KEdl dFB1YmxpY2F0aW9uKHB1YmlkKS0+YWxsdGFibGVzKTsKKworCXJldHVybiBHZXRQdWJsaWNhdGlv blJlbGF0aW9uc0ludGVybmFsKHB1YmlkLCBwdWJfcGFydG9wdCwgdHJ1ZSk7Cit9CisKIC8qCiAg KiBHZXRzIGxpc3Qgb2YgcHVibGljYXRpb24gb2lkcyBmb3IgcHVibGljYXRpb25zIG1hcmtlZCBh cyBGT1IgQUxMIFRBQkxFUy4KICAqLwpAQCAtODY0LDE1ICs5NDcsMjQgQEAgR2V0QWxsVGFibGVz UHVibGljYXRpb25zKHZvaWQpCiAgKiBwYXJ0aXRpb25lZCB0YWJsZXMsIHdlIG11c3QgZXhjbHVk ZSBwYXJ0aXRpb25zIGluIGZhdm9yIG9mIGluY2x1ZGluZyB0aGUKICAqIHJvb3QgcGFydGl0aW9u ZWQgdGFibGVzLiBUaGlzIGlzIG5vdCBhcHBsaWNhYmxlIHRvIEZPUiBBTEwgU0VRVUVOQ0VTCiAg KiBwdWJsaWNhdGlvbi4KKyAqCisgKiBUaGUgbGlzdCBkb2VzIG5vdCBpbmNsdWRlIHJlbGF0aW9u cyB0aGF0IGFyZSBleHBsaWNpdGx5IGV4Y2x1ZGVkIHZpYSB0aGUKKyAqIEVYQ0VQVCBUQUJMRSBj bGF1c2Ugb2YgdGhlIHB1YmxpY2F0aW9uIHNwZWNpZmllZCBieSBwdWJpZC4KICAqLwogTGlzdCAq Ci1HZXRBbGxQdWJsaWNhdGlvblJlbGF0aW9ucyhjaGFyIHJlbGtpbmQsIGJvb2wgcHVidmlhcm9v dCkKK0dldEFsbFB1YmxpY2F0aW9uUmVsYXRpb25zKE9pZCBwdWJpZCwgY2hhciByZWxraW5kLCBi b29sIHB1YnZpYXJvb3QpCiB7CiAJUmVsYXRpb24JY2xhc3NSZWw7CiAJU2NhbktleURhdGEga2V5 WzFdOwogCVRhYmxlU2NhbkRlc2Mgc2NhbjsKIAlIZWFwVHVwbGUJdHVwbGU7CiAJTGlzdAkgICAq cmVzdWx0ID0gTklMOworCUxpc3QJICAgKmV4Y2VwdGxpc3QgPSBOSUw7CisKKwlpZiAocmVsa2lu ZCA9PSBSRUxLSU5EX1JFTEFUSU9OKQorCQlleGNlcHRsaXN0ID0gR2V0UHVibGljYXRpb25FeGNs dWRlZFJlbGF0aW9ucyhwdWJpZCwgcHVidmlhcm9vdCA/CisJCQkJCQkJCQkJCQkJIFBVQkxJQ0FU SU9OX1BBUlRfQUxMIDoKKwkJCQkJCQkJCQkJCQkgUFVCTElDQVRJT05fUEFSVF9ST09UKTsKIAog CUFzc2VydCghKHJlbGtpbmQgPT0gUkVMS0lORF9TRVFVRU5DRSAmJiBwdWJ2aWFyb290KSk7CiAK QEAgLTg5MSw3ICs5ODMsOCBAQCBHZXRBbGxQdWJsaWNhdGlvblJlbGF0aW9ucyhjaGFyIHJlbGtp bmQsIGJvb2wgcHVidmlhcm9vdCkKIAkJT2lkCQkJcmVsaWQgPSByZWxGb3JtLT5vaWQ7CiAKIAkJ aWYgKGlzX3B1Ymxpc2hhYmxlX2NsYXNzKHJlbGlkLCByZWxGb3JtKSAmJgotCQkJIShyZWxGb3Jt LT5yZWxpc3BhcnRpdGlvbiAmJiBwdWJ2aWFyb290KSkKKwkJCSEocmVsRm9ybS0+cmVsaXNwYXJ0 aXRpb24gJiYgcHVidmlhcm9vdCkgJiYKKwkJCSFsaXN0X21lbWJlcl9vaWQoZXhjZXB0bGlzdCwg cmVsaWQpKQogCQkJcmVzdWx0ID0gbGFwcGVuZF9vaWQocmVzdWx0LCByZWxpZCk7CiAJfQogCkBA IC05MTIsNyArMTAwNSw4IEBAIEdldEFsbFB1YmxpY2F0aW9uUmVsYXRpb25zKGNoYXIgcmVsa2lu ZCwgYm9vbCBwdWJ2aWFyb290KQogCQkJT2lkCQkJcmVsaWQgPSByZWxGb3JtLT5vaWQ7CiAKIAkJ CWlmIChpc19wdWJsaXNoYWJsZV9jbGFzcyhyZWxpZCwgcmVsRm9ybSkgJiYKLQkJCQkhcmVsRm9y bS0+cmVsaXNwYXJ0aXRpb24pCisJCQkJIXJlbEZvcm0tPnJlbGlzcGFydGl0aW9uICYmCisJCQkJ IWxpc3RfbWVtYmVyX29pZChleGNlcHRsaXN0LCByZWxpZCkpCiAJCQkJcmVzdWx0ID0gbGFwcGVu ZF9vaWQocmVzdWx0LCByZWxpZCk7CiAJCX0KIApAQCAtMTE2OCwxNyArMTI2MiwxOCBAQCBwZ19n ZXRfcHVibGljYXRpb25fdGFibGVzKFBHX0ZVTkNUSU9OX0FSR1MpCiAJCQkgKiB0aG9zZS4gT3Ro ZXJ3aXNlLCBnZXQgdGhlIHBhcnRpdGlvbmVkIHRhYmxlIGl0c2VsZi4KIAkJCSAqLwogCQkJaWYg KHB1Yl9lbGVtLT5hbGx0YWJsZXMpCi0JCQkJcHViX2VsZW1fdGFibGVzID0gR2V0QWxsUHVibGlj YXRpb25SZWxhdGlvbnMoUkVMS0lORF9SRUxBVElPTiwKKwkJCQlwdWJfZWxlbV90YWJsZXMgPSBH ZXRBbGxQdWJsaWNhdGlvblJlbGF0aW9ucyhwdWJfZWxlbS0+b2lkLAorCQkJCQkJCQkJCQkJCQkJ IFJFTEtJTkRfUkVMQVRJT04sCiAJCQkJCQkJCQkJCQkJCQkgcHViX2VsZW0tPnB1YnZpYXJvb3Qp OwogCQkJZWxzZQogCQkJewogCQkJCUxpc3QJICAgKnJlbGlkcywKIAkJCQkJCSAgICpzY2hlbWFy ZWxpZHM7CiAKLQkJCQlyZWxpZHMgPSBHZXRQdWJsaWNhdGlvblJlbGF0aW9ucyhwdWJfZWxlbS0+ b2lkLAotCQkJCQkJCQkJCQkJIHB1Yl9lbGVtLT5wdWJ2aWFyb290ID8KLQkJCQkJCQkJCQkJCSBQ VUJMSUNBVElPTl9QQVJUX1JPT1QgOgotCQkJCQkJCQkJCQkJIFBVQkxJQ0FUSU9OX1BBUlRfTEVB Rik7CisJCQkJcmVsaWRzID0gR2V0UHVibGljYXRpb25JbmNsdWRlZFJlbGF0aW9ucyhwdWJfZWxl bS0+b2lkLAorCQkJCQkJCQkJCQkJCQkgcHViX2VsZW0tPnB1YnZpYXJvb3QgPworCQkJCQkJCQkJ CQkJCQkgUFVCTElDQVRJT05fUEFSVF9ST09UIDoKKwkJCQkJCQkJCQkJCQkJIFBVQkxJQ0FUSU9O X1BBUlRfTEVBRik7CiAJCQkJc2NoZW1hcmVsaWRzID0gR2V0QWxsU2NoZW1hUHVibGljYXRpb25S ZWxhdGlvbnMocHViX2VsZW0tPm9pZCwKIAkJCQkJCQkJCQkJCQkJCQlwdWJfZWxlbS0+cHVidmlh cm9vdCA/CiAJCQkJCQkJCQkJCQkJCQkJUFVCTElDQVRJT05fUEFSVF9ST09UIDoKQEAgLTEzNjcs NyArMTQ2Miw3IEBAIHBnX2dldF9wdWJsaWNhdGlvbl9zZXF1ZW5jZXMoUEdfRlVOQ1RJT05fQVJH UykKIAkJcHVibGljYXRpb24gPSBHZXRQdWJsaWNhdGlvbkJ5TmFtZShwdWJuYW1lLCBmYWxzZSk7 CiAKIAkJaWYgKHB1YmxpY2F0aW9uLT5hbGxzZXF1ZW5jZXMpCi0JCQlzZXF1ZW5jZXMgPSBHZXRB bGxQdWJsaWNhdGlvblJlbGF0aW9ucyhSRUxLSU5EX1NFUVVFTkNFLCBmYWxzZSk7CisJCQlzZXF1 ZW5jZXMgPSBHZXRBbGxQdWJsaWNhdGlvblJlbGF0aW9ucyhwdWJsaWNhdGlvbi0+b2lkLCBSRUxL SU5EX1NFUVVFTkNFLCBmYWxzZSk7CiAKIAkJZnVuY2N0eC0+dXNlcl9mY3R4ID0gc2VxdWVuY2Vz OwogCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy9wdWJsaWNhdGlvbmNtZHMuYyBi L3NyYy9iYWNrZW5kL2NvbW1hbmRzL3B1YmxpY2F0aW9uY21kcy5jCmluZGV4IGExOTgzNTA4OTUw Li5iMmZiNzI0ZjA0OCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvcHVibGljYXRp b25jbWRzLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvcHVibGljYXRpb25jbWRzLmMKQEAg LTE3MCw2ICsxNzAsMzggQEAgcGFyc2VfcHVibGljYXRpb25fb3B0aW9ucyhQYXJzZVN0YXRlICpw c3RhdGUsCiAJfQogfQogCisvKgorICogQ29udmVydCB0aGUgUHVibGljYXRpb25PYmpTcGVjIGxp c3Qgd2hpY2ggaXMgcGFydCBvZgorICogUHVibGljYXRpb25BbGxPYmpTcGVjVHlwZSBsaXN0IGlu dG8gUHVibGljYXRpb25UYWJsZSBsaXN0LgorICovCitzdGF0aWMgdm9pZAorT2JqZWN0c0luQWxs UHVibGljYXRpb25Ub09pZHMoTGlzdCAqcHViYWxsb2Jqc3BlY19saXN0LAorCQkJCQkJCSAgUGFy c2VTdGF0ZSAqcHN0YXRlLCBMaXN0ICoqcmVscykKK3sKKwlpZiAoIXB1YmFsbG9ianNwZWNfbGlz dCkKKwkJcmV0dXJuOworCisJZm9yZWFjaF9wdHIoUHVibGljYXRpb25BbGxPYmpTcGVjLCBwdWJh bGxvYmosIHB1YmFsbG9ianNwZWNfbGlzdCkKKwl7CisJCXN3aXRjaCAocHViYWxsb2JqLT5wdWJv Ymp0eXBlKQorCQl7CisJCQljYXNlIFBVQkxJQ0FUSU9OX0FMTF9TRVFVRU5DRVM6CisJCQkJYnJl YWs7CisJCQljYXNlIFBVQkxJQ0FUSU9OX0FMTF9UQUJMRVM6CisJCQkJZm9yZWFjaF9wdHIoUHVi bGljYXRpb25PYmpTcGVjLCBwdWJvYmosIHB1YmFsbG9iai0+ZXhjZXB0X29iamVjdHMpCisJCQkJ eworCQkJCQlwdWJvYmotPnB1YnRhYmxlLT5leGNlcHQgPSB0cnVlOworCQkJCQkqcmVscyA9IGxh cHBlbmQoKnJlbHMsIHB1Ym9iai0+cHVidGFibGUpOworCQkJCX0KKwkJCQlicmVhazsKKwkJCWRl ZmF1bHQ6CisJCQkJZWxvZyhFUlJPUiwgImludmFsaWQgcHVibGljYXRpb24gb2JqZWN0IHR5cGUg JWQiLAorCQkJCQkgcHViYWxsb2JqLT5wdWJvYmp0eXBlKTsKKwkJCQlicmVhazsKKwkJfQorCX0K K30KKwogLyoKICAqIENvbnZlcnQgdGhlIFB1YmxpY2F0aW9uT2JqU3BlY1R5cGUgbGlzdCBpbnRv IHNjaGVtYSBvaWQgbGlzdCBhbmQKICAqIFB1YmxpY2F0aW9uVGFibGUgbGlzdC4KQEAgLTE5NCw2 ICsyMjYsOCBAQCBPYmplY3RzSW5QdWJsaWNhdGlvblRvT2lkcyhMaXN0ICpwdWJvYmpzcGVjX2xp c3QsIFBhcnNlU3RhdGUgKnBzdGF0ZSwKIAkJc3dpdGNoIChwdWJvYmotPnB1Ym9ianR5cGUpCiAJ CXsKIAkJCWNhc2UgUFVCTElDQVRJT05PQkpfVEFCTEU6CisJCQljYXNlIFBVQkxJQ0FUSU9OT0JK X0VYQ0VQVF9UQUJMRToKKwkJCQlwdWJvYmotPnB1YnRhYmxlLT5leGNlcHQgPSAocHVib2JqLT5w dWJvYmp0eXBlID09IFBVQkxJQ0FUSU9OT0JKX0VYQ0VQVF9UQUJMRSk7CiAJCQkJKnJlbHMgPSBs YXBwZW5kKCpyZWxzLCBwdWJvYmotPnB1YnRhYmxlKTsKIAkJCQlicmVhazsKIAkJCWNhc2UgUFVC TElDQVRJT05PQkpfVEFCTEVTX0lOX1NDSEVNQToKQEAgLTI2OCw3ICszMDIsNyBAQCBjb250YWlu X2ludmFsaWRfcmZjb2x1bW5fd2Fsa2VyKE5vZGUgKm5vZGUsIHJmX2NvbnRleHQgKmNvbnRleHQp CiAgKi8KIGJvb2wKIHB1Yl9yZl9jb250YWluc19pbnZhbGlkX2NvbHVtbihPaWQgcHViaWQsIFJl bGF0aW9uIHJlbGF0aW9uLCBMaXN0ICphbmNlc3RvcnMsCi0JCQkJCQkJICAgYm9vbCBwdWJ2aWFy b290KQorCQkJCQkJCSAgIGJvb2wgcHViYWxsdGFibGVzLCBib29sIHB1YnZpYXJvb3QpCiB7CiAJ SGVhcFR1cGxlCXJmdHVwbGU7CiAJT2lkCQkJcmVsaWQgPSBSZWxhdGlvbkdldFJlbGlkKHJlbGF0 aW9uKTsKQEAgLTI5NSw3ICszMjksOCBAQCBwdWJfcmZfY29udGFpbnNfaW52YWxpZF9jb2x1bW4o T2lkIHB1YmlkLCBSZWxhdGlvbiByZWxhdGlvbiwgTGlzdCAqYW5jZXN0b3JzLAogCWlmIChwdWJ2 aWFyb290ICYmIHJlbGF0aW9uLT5yZF9yZWwtPnJlbGlzcGFydGl0aW9uKQogCXsKIAkJcHVibGlz aF9hc19yZWxpZAotCQkJPSBHZXRUb3BNb3N0QW5jZXN0b3JJblB1YmxpY2F0aW9uKHB1YmlkLCBh bmNlc3RvcnMsIE5VTEwpOworCQkJPSBHZXRUb3BNb3N0QW5jZXN0b3JJblB1YmxpY2F0aW9uKHB1 YmlkLCBhbmNlc3RvcnMsIE5VTEwsCisJCQkJCQkJCQkJCSAgcHViYWxsdGFibGVzKTsKIAogCQlp ZiAoIU9pZElzVmFsaWQocHVibGlzaF9hc19yZWxpZCkpCiAJCQlwdWJsaXNoX2FzX3JlbGlkID0g cmVsaWQ7CkBAIC0zNTQsOCArMzg5LDggQEAgcHViX3JmX2NvbnRhaW5zX2ludmFsaWRfY29sdW1u KE9pZCBwdWJpZCwgUmVsYXRpb24gcmVsYXRpb24sIExpc3QgKmFuY2VzdG9ycywKICAqLwogYm9v bAogcHViX2NvbnRhaW5zX2ludmFsaWRfY29sdW1uKE9pZCBwdWJpZCwgUmVsYXRpb24gcmVsYXRp b24sIExpc3QgKmFuY2VzdG9ycywKLQkJCQkJCQlib29sIHB1YnZpYXJvb3QsIGNoYXIgcHViZ2Vu Y29sc190eXBlLAotCQkJCQkJCWJvb2wgKmludmFsaWRfY29sdW1uX2xpc3QsCisJCQkJCQkJYm9v bCBwdWJhbGx0YWJsZXMsIGJvb2wgcHVidmlhcm9vdCwKKwkJCQkJCQljaGFyIHB1YmdlbmNvbHNf dHlwZSwgYm9vbCAqaW52YWxpZF9jb2x1bW5fbGlzdCwKIAkJCQkJCQlib29sICppbnZhbGlkX2dl bl9jb2wpCiB7CiAJT2lkCQkJcmVsaWQgPSBSZWxhdGlvbkdldFJlbGlkKHJlbGF0aW9uKTsKQEAg LTM3OSw3ICs0MTQsOCBAQCBwdWJfY29udGFpbnNfaW52YWxpZF9jb2x1bW4oT2lkIHB1YmlkLCBS ZWxhdGlvbiByZWxhdGlvbiwgTGlzdCAqYW5jZXN0b3JzLAogCSAqLwogCWlmIChwdWJ2aWFyb290 ICYmIHJlbGF0aW9uLT5yZF9yZWwtPnJlbGlzcGFydGl0aW9uKQogCXsKLQkJcHVibGlzaF9hc19y ZWxpZCA9IEdldFRvcE1vc3RBbmNlc3RvckluUHVibGljYXRpb24ocHViaWQsIGFuY2VzdG9ycywg TlVMTCk7CisJCXB1Ymxpc2hfYXNfcmVsaWQgPSBHZXRUb3BNb3N0QW5jZXN0b3JJblB1YmxpY2F0 aW9uKHB1YmlkLCBhbmNlc3RvcnMsCisJCQkJCQkJCQkJCQkJCSAgIE5VTEwsIHB1YmFsbHRhYmxl cyk7CiAKIAkJaWYgKCFPaWRJc1ZhbGlkKHB1Ymxpc2hfYXNfcmVsaWQpKQogCQkJcHVibGlzaF9h c19yZWxpZCA9IHJlbGlkOwpAQCAtNTE0LDggKzU1MCw4IEBAIEludmFsaWRhdGVQdWJSZWxTeW5j Q2FjaGUoT2lkIHB1YmlkLCBib29sIHB1YmFsbHRhYmxlcykKIAkJICogYSB0YXJnZXQuIEhvd2V2 ZXIsIFdBTCByZWNvcmRzIGZvciBUUlVOQ0FURSBzcGVjaWZ5IGJvdGggYSByb290IGFuZAogCQkg KiBpdHMgbGVhdmVzLgogCQkgKi8KLQkJcmVsaWRzID0gR2V0UHVibGljYXRpb25SZWxhdGlvbnMo cHViaWQsCi0JCQkJCQkJCQkJIFBVQkxJQ0FUSU9OX1BBUlRfQUxMKTsKKwkJcmVsaWRzID0gR2V0 UHVibGljYXRpb25JbmNsdWRlZFJlbGF0aW9ucyhwdWJpZCwKKwkJCQkJCQkJCQkJCSBQVUJMSUNB VElPTl9QQVJUX0FMTCk7CiAJCXNjaGVtYXJlbGlkcyA9IEdldEFsbFNjaGVtYVB1YmxpY2F0aW9u UmVsYXRpb25zKHB1YmlkLAogCQkJCQkJCQkJCQkJCQlQVUJMSUNBVElPTl9QQVJUX0FMTCk7CiAK QEAgLTkyMywxNiArOTU5LDkgQEAgQ3JlYXRlUHVibGljYXRpb24oUGFyc2VTdGF0ZSAqcHN0YXRl LCBDcmVhdGVQdWJsaWNhdGlvblN0bXQgKnN0bXQpCiAJLyogTWFrZSB0aGUgY2hhbmdlcyB2aXNp YmxlLiAqLwogCUNvbW1hbmRDb3VudGVySW5jcmVtZW50KCk7CiAKLQkvKiBBc3NvY2lhdGUgb2Jq ZWN0cyB3aXRoIHRoZSBwdWJsaWNhdGlvbi4gKi8KIAlpZiAoc3RtdC0+Zm9yX2FsbF90YWJsZXMp Ci0JewotCQkvKgotCQkgKiBJbnZhbGlkYXRlIHJlbGNhY2hlIHNvIHRoYXQgcHVibGljYXRpb24g aW5mbyBpcyByZWJ1aWx0LiBTZXF1ZW5jZXMKLQkJICogcHVibGljYXRpb24gZG9lc24ndCByZXF1 aXJlIGludmFsaWRhdGlvbiwgYXMgcmVwbGljYSBpZGVudGl0eQotCQkgKiBjaGVja3MgZG9uJ3Qg YXBwbHkgdG8gdGhlbS4KLQkJICovCi0JCUNhY2hlSW52YWxpZGF0ZVJlbGNhY2hlQWxsKCk7Ci0J fQorCQlPYmplY3RzSW5BbGxQdWJsaWNhdGlvblRvT2lkcyhzdG10LT5wdWJvYmplY3RzLCBwc3Rh dGUsICZyZWxhdGlvbnMpOworCiAJZWxzZSBpZiAoIXN0bXQtPmZvcl9hbGxfc2VxdWVuY2VzKQog CXsKIAkJT2JqZWN0c0luUHVibGljYXRpb25Ub09pZHMoc3RtdC0+cHVib2JqZWN0cywgcHN0YXRl LCAmcmVsYXRpb25zLApAQCAtOTQ0LDIyICs5NzMsNiBAQCBDcmVhdGVQdWJsaWNhdGlvbihQYXJz ZVN0YXRlICpwc3RhdGUsIENyZWF0ZVB1YmxpY2F0aW9uU3RtdCAqc3RtdCkKIAkJCQkJZXJyY29k ZShFUlJDT0RFX0lOU1VGRklDSUVOVF9QUklWSUxFR0UpLAogCQkJCQllcnJtc2coIm11c3QgYmUg c3VwZXJ1c2VyIHRvIGNyZWF0ZSBGT1IgVEFCTEVTIElOIFNDSEVNQSBwdWJsaWNhdGlvbiIpKTsK IAotCQlpZiAocmVsYXRpb25zICE9IE5JTCkKLQkJewotCQkJTGlzdAkgICAqcmVsczsKLQotCQkJ cmVscyA9IE9wZW5UYWJsZUxpc3QocmVsYXRpb25zKTsKLQkJCVRyYW5zZm9ybVB1YldoZXJlQ2xh dXNlcyhyZWxzLCBwc3RhdGUtPnBfc291cmNldGV4dCwKLQkJCQkJCQkJCSBwdWJsaXNoX3ZpYV9w YXJ0aXRpb25fcm9vdCk7Ci0KLQkJCUNoZWNrUHViUmVsYXRpb25Db2x1bW5MaXN0KHN0bXQtPnB1 Ym5hbWUsIHJlbHMsCi0JCQkJCQkJCQkgICBzY2hlbWFpZGxpc3QgIT0gTklMLAotCQkJCQkJCQkJ ICAgcHVibGlzaF92aWFfcGFydGl0aW9uX3Jvb3QpOwotCi0JCQlQdWJsaWNhdGlvbkFkZFRhYmxl cyhwdWJvaWQsIHJlbHMsIHRydWUsIE5VTEwpOwotCQkJQ2xvc2VUYWJsZUxpc3QocmVscyk7Ci0J CX0KLQogCQlpZiAoc2NoZW1haWRsaXN0ICE9IE5JTCkKIAkJewogCQkJLyoKQEAgLTk3MSw4ICs5 ODQsMzcgQEAgQ3JlYXRlUHVibGljYXRpb24oUGFyc2VTdGF0ZSAqcHN0YXRlLCBDcmVhdGVQdWJs aWNhdGlvblN0bXQgKnN0bXQpCiAJCX0KIAl9CiAKKwkvKgorCSAqIElmIHB1YmxpY2F0aW9uIGlz IGZvciBBTEwgVEFCTEVTIGFuZCByZWxhdGlvbnMgaXMgbm90IGVtcHR5LCBpdCBtZWFucworCSAq IHRoYXQgdGhlcmUgYXJlIHNvbWUgcmVsYXRpb25zIHRvIGJlIGV4Y2x1ZGVkIGZyb20gdGhlIHB1 YmxpY2F0aW9uLgorCSAqIEVsc2UsIHJlbGF0aW9ucyBpcyB0aGUgbGlzdCBvZiByZWxhdGlvbnMg dG8gYmUgYWRkZWQgdG8gdGhlCisJICogcHVibGljYXRpb24uCisJICovCisJaWYgKHJlbGF0aW9u cyAhPSBOSUwpCisJeworCQlMaXN0CSAgICpyZWxzOworCisJCXJlbHMgPSBPcGVuVGFibGVMaXN0 KHJlbGF0aW9ucyk7CisJCVRyYW5zZm9ybVB1YldoZXJlQ2xhdXNlcyhyZWxzLCBwc3RhdGUtPnBf c291cmNldGV4dCwKKwkJCQkJCQkJIHB1Ymxpc2hfdmlhX3BhcnRpdGlvbl9yb290KTsKKworCQlD aGVja1B1YlJlbGF0aW9uQ29sdW1uTGlzdChzdG10LT5wdWJuYW1lLCByZWxzLAorCQkJCQkJCQkg ICBzY2hlbWFpZGxpc3QgIT0gTklMLAorCQkJCQkJCQkgICBwdWJsaXNoX3ZpYV9wYXJ0aXRpb25f cm9vdCk7CisKKwkJUHVibGljYXRpb25BZGRUYWJsZXMocHVib2lkLCByZWxzLCB0cnVlLCBOVUxM KTsKKwkJQ2xvc2VUYWJsZUxpc3QocmVscyk7CisJfQorCiAJdGFibGVfY2xvc2UocmVsLCBSb3dF eGNsdXNpdmVMb2NrKTsKIAorCS8qIEFzc29jaWF0ZSBvYmplY3RzIHdpdGggdGhlIHB1YmxpY2F0 aW9uLiAqLworCWlmIChzdG10LT5mb3JfYWxsX3RhYmxlcykKKwl7CisJCS8qIEludmFsaWRhdGUg cmVsY2FjaGUgc28gdGhhdCBwdWJsaWNhdGlvbiBpbmZvIGlzIHJlYnVpbHQuICovCisJCUNhY2hl SW52YWxpZGF0ZVJlbGNhY2hlQWxsKCk7CisJfQorCiAJSW52b2tlT2JqZWN0UG9zdENyZWF0ZUhv b2soUHVibGljYXRpb25SZWxhdGlvbklkLCBwdWJvaWQsIDApOwogCiAJaWYgKHdhbF9sZXZlbCAh PSBXQUxfTEVWRUxfTE9HSUNBTCkKQEAgLTEwNDAsOCArMTA4Miw4IEBAIEFsdGVyUHVibGljYXRp b25PcHRpb25zKFBhcnNlU3RhdGUgKnBzdGF0ZSwgQWx0ZXJQdWJsaWNhdGlvblN0bXQgKnN0bXQs CiAJCUxvY2tEYXRhYmFzZU9iamVjdChQdWJsaWNhdGlvblJlbGF0aW9uSWQsIHB1YmZvcm0tPm9p ZCwgMCwKIAkJCQkJCSAgIEFjY2Vzc1NoYXJlTG9jayk7CiAKLQkJcm9vdF9yZWxpZHMgPSBHZXRQ dWJsaWNhdGlvblJlbGF0aW9ucyhwdWJmb3JtLT5vaWQsCi0JCQkJCQkJCQkJCSAgUFVCTElDQVRJ T05fUEFSVF9ST09UKTsKKwkJcm9vdF9yZWxpZHMgPSBHZXRQdWJsaWNhdGlvbkluY2x1ZGVkUmVs YXRpb25zKHB1YmZvcm0tPm9pZCwKKwkJCQkJCQkJCQkJCQkgIFBVQkxJQ0FUSU9OX1BBUlRfUk9P VCk7CiAKIAkJZm9yZWFjaChsYywgcm9vdF9yZWxpZHMpCiAJCXsKQEAgLTExNjAsOCArMTIwMiw4 IEBAIEFsdGVyUHVibGljYXRpb25PcHRpb25zKFBhcnNlU3RhdGUgKnBzdGF0ZSwgQWx0ZXJQdWJs aWNhdGlvblN0bXQgKnN0bXQsCiAJCSAqIHRyZWVzLCBub3QganVzdCB0aG9zZSBleHBsaWNpdGx5 IG1lbnRpb25lZCBpbiB0aGUgcHVibGljYXRpb24uCiAJCSAqLwogCQlpZiAocm9vdF9yZWxpZHMg PT0gTklMKQotCQkJcmVsaWRzID0gR2V0UHVibGljYXRpb25SZWxhdGlvbnMocHViZm9ybS0+b2lk LAotCQkJCQkJCQkJCQkgUFVCTElDQVRJT05fUEFSVF9BTEwpOworCQkJcmVsaWRzID0gR2V0UHVi bGljYXRpb25JbmNsdWRlZFJlbGF0aW9ucyhwdWJmb3JtLT5vaWQsCisJCQkJCQkJCQkJCQkJIFBV QkxJQ0FUSU9OX1BBUlRfQUxMKTsKIAkJZWxzZQogCQl7CiAJCQkvKgpAQCAtMTI0Niw4ICsxMjg4 LDggQEAgQWx0ZXJQdWJsaWNhdGlvblRhYmxlcyhBbHRlclB1YmxpY2F0aW9uU3RtdCAqc3RtdCwg SGVhcFR1cGxlIHR1cCwKIAkJUHVibGljYXRpb25Ecm9wVGFibGVzKHB1YmlkLCByZWxzLCBmYWxz ZSk7CiAJZWxzZQkJCQkJCS8qIEFQX1NldE9iamVjdHMgKi8KIAl7Ci0JCUxpc3QJICAgKm9sZHJl bGlkcyA9IEdldFB1YmxpY2F0aW9uUmVsYXRpb25zKHB1YmlkLAotCQkJCQkJCQkJCQkJCQlQVUJM SUNBVElPTl9QQVJUX1JPT1QpOworCQlMaXN0CSAgICpvbGRyZWxpZHMgPSBHZXRQdWJsaWNhdGlv bkluY2x1ZGVkUmVsYXRpb25zKHB1YmlkLAorCQkJCQkJCQkJCQkJCQkJCVBVQkxJQ0FUSU9OX1BB UlRfUk9PVCk7CiAJCUxpc3QJICAgKmRlbHJlbHMgPSBOSUw7CiAJCUxpc3RDZWxsICAgKm9sZGxj OwogCkBAIC0xMzQ4LDYgKzEzOTAsNyBAQCBBbHRlclB1YmxpY2F0aW9uVGFibGVzKEFsdGVyUHVi bGljYXRpb25TdG10ICpzdG10LCBIZWFwVHVwbGUgdHVwLAogCQkJCW9sZHJlbCA9IHBhbGxvY19v YmplY3QoUHVibGljYXRpb25SZWxJbmZvKTsKIAkJCQlvbGRyZWwtPndoZXJlQ2xhdXNlID0gTlVM TDsKIAkJCQlvbGRyZWwtPmNvbHVtbnMgPSBOSUw7CisJCQkJb2xkcmVsLT5leGNlcHQgPSBmYWxz ZTsKIAkJCQlvbGRyZWwtPnJlbGF0aW9uID0gdGFibGVfb3BlbihvbGRyZWxpZCwKIAkJCQkJCQkJ CQkJICBTaGFyZVVwZGF0ZUV4Y2x1c2l2ZUxvY2spOwogCQkJCWRlbHJlbHMgPSBsYXBwZW5kKGRl bHJlbHMsIG9sZHJlbCk7CkBAIC0xMzk4LDcgKzE0NDEsOCBAQCBBbHRlclB1YmxpY2F0aW9uU2No ZW1hcyhBbHRlclB1YmxpY2F0aW9uU3RtdCAqc3RtdCwKIAkJTGlzdENlbGwgICAqbGM7CiAJCUxp c3QJICAgKnJlbG9pZHM7CiAKLQkJcmVsb2lkcyA9IEdldFB1YmxpY2F0aW9uUmVsYXRpb25zKHB1 YmZvcm0tPm9pZCwgUFVCTElDQVRJT05fUEFSVF9ST09UKTsKKwkJcmVsb2lkcyA9IEdldFB1Ymxp Y2F0aW9uSW5jbHVkZWRSZWxhdGlvbnMocHViZm9ybS0+b2lkLAorCQkJCQkJCQkJCQkJICBQVUJM SUNBVElPTl9QQVJUX1JPT1QpOwogCiAJCWZvcmVhY2gobGMsIHJlbG9pZHMpCiAJCXsKQEAgLTE3 NjEsNiArMTgwNSw3IEBAIE9wZW5UYWJsZUxpc3QoTGlzdCAqdGFibGVzKQogCQlwdWJfcmVsLT5y ZWxhdGlvbiA9IHJlbDsKIAkJcHViX3JlbC0+d2hlcmVDbGF1c2UgPSB0LT53aGVyZUNsYXVzZTsK IAkJcHViX3JlbC0+Y29sdW1ucyA9IHQtPmNvbHVtbnM7CisJCXB1Yl9yZWwtPmV4Y2VwdCA9IHQt PmV4Y2VwdDsKIAkJcmVscyA9IGxhcHBlbmQocmVscywgcHViX3JlbCk7CiAJCXJlbGlkcyA9IGxh cHBlbmRfb2lkKHJlbGlkcywgbXlyZWxpZCk7CiAKQEAgLTE4MzMsNiArMTg3OCw3IEBAIE9wZW5U YWJsZUxpc3QoTGlzdCAqdGFibGVzKQogCiAJCQkJLyogY2hpbGQgaW5oZXJpdHMgY29sdW1uIGxp c3QgZnJvbSBwYXJlbnQgKi8KIAkJCQlwdWJfcmVsLT5jb2x1bW5zID0gdC0+Y29sdW1uczsKKwkJ CQlwdWJfcmVsLT5leGNlcHQgPSB0LT5leGNlcHQ7CiAJCQkJcmVscyA9IGxhcHBlbmQocmVscywg cHViX3JlbCk7CiAJCQkJcmVsaWRzID0gbGFwcGVuZF9vaWQocmVsaWRzLCBjaGlsZHJlbGlkKTsK IApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdGFibGVjbWRzLmMgYi9zcmMvYmFj a2VuZC9jb21tYW5kcy90YWJsZWNtZHMuYwppbmRleCA2YjFhMDBlZDQ3Ny4uM2VhOTVhZTFhMjYg MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3RhYmxlY21kcy5jCisrKyBiL3NyYy9i YWNrZW5kL2NvbW1hbmRzL3RhYmxlY21kcy5jCkBAIC04Njg3LDcgKzg2ODcsNyBAQCBBVEV4ZWNT ZXRFeHByZXNzaW9uKEFsdGVyZWRUYWJsZUluZm8gKnRhYiwgUmVsYXRpb24gcmVsLCBjb25zdCBj aGFyICpjb2xOYW1lLAogCSAqIGV4cHJlc3Npb25zLgogCSAqLwogCWlmIChhdHRnZW5lcmF0ZWQg PT0gQVRUUklCVVRFX0dFTkVSQVRFRF9WSVJUVUFMICYmCi0JCUdldFJlbGF0aW9uUHVibGljYXRp b25zKFJlbGF0aW9uR2V0UmVsaWQocmVsKSkgIT0gTklMKQorCQlHZXRSZWxhdGlvblB1YmxpY2F0 aW9ucyhSZWxhdGlvbkdldFJlbGlkKHJlbCksIE5VTEwsIE5VTEwpKQogCQllcmVwb3J0KEVSUk9S LAogCQkJCShlcnJjb2RlKEVSUkNPREVfRkVBVFVSRV9OT1RfU1VQUE9SVEVEKSwKIAkJCQkgZXJy bXNnKCJBTFRFUiBUQUJMRSAvIFNFVCBFWFBSRVNTSU9OIGlzIG5vdCBzdXBwb3J0ZWQgZm9yIHZp cnR1YWwgZ2VuZXJhdGVkIGNvbHVtbnMgaW4gdGFibGVzIHRoYXQgYXJlIHBhcnQgb2YgYSBwdWJs aWNhdGlvbiIpLApAQCAtMTg4ODIsNyArMTg4ODIsNyBAQCBBVFByZXBDaGFuZ2VQZXJzaXN0ZW5j ZShBbHRlcmVkVGFibGVJbmZvICp0YWIsIFJlbGF0aW9uIHJlbCwgYm9vbCB0b0xvZ2dlZCkKIAkg KiBVTkxPR0dFRCwgYXMgVU5MT0dHRUQgdGFibGVzIGNhbid0IGJlIHB1Ymxpc2hlZC4KIAkgKi8K IAlpZiAoIXRvTG9nZ2VkICYmCi0JCUdldFJlbGF0aW9uUHVibGljYXRpb25zKFJlbGF0aW9uR2V0 UmVsaWQocmVsKSkgIT0gTklMKQorCQlHZXRSZWxhdGlvblB1YmxpY2F0aW9ucyhSZWxhdGlvbkdl dFJlbGlkKHJlbCksIE5VTEwsIE5VTEwpKQogCQllcmVwb3J0KEVSUk9SLAogCQkJCShlcnJjb2Rl KEVSUkNPREVfT0JKRUNUX05PVF9JTl9QUkVSRVFVSVNJVEVfU1RBVEUpLAogCQkJCSBlcnJtc2co ImNhbm5vdCBjaGFuZ2UgdGFibGUgXCIlc1wiIHRvIHVubG9nZ2VkIGJlY2F1c2UgaXQgaXMgcGFy dCBvZiBhIHB1YmxpY2F0aW9uIiwKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3BhcnNlci9ncmFt LnkgYi9zcmMvYmFja2VuZC9wYXJzZXIvZ3JhbS55CmluZGV4IDI4ZjRlMTFlMzBmLi5mMTIyMGU1 NTA5MyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcGFyc2VyL2dyYW0ueQorKysgYi9zcmMvYmFj a2VuZC9wYXJzZXIvZ3JhbS55CkBAIC00NTUsNiArNDU1LDcgQEAgc3RhdGljIE5vZGUgKm1ha2VS ZWN1cnNpdmVWaWV3U2VsZWN0KGNoYXIgKnJlbG5hbWUsIExpc3QgKmFsaWFzZXMsIE5vZGUgKnF1 ZXJ5KTsKIAkJCQlUcmlnZ2VyVHJhbnNpdGlvbnMgVHJpZ2dlclJlZmVyZW5jaW5nCiAJCQkJdmFj dXVtX3JlbGF0aW9uX2xpc3Qgb3B0X3ZhY3V1bV9yZWxhdGlvbl9saXN0CiAJCQkJZHJvcF9vcHRp b25fbGlzdCBwdWJfb2JqX2xpc3QgcHViX2FsbF9vYmpfdHlwZV9saXN0CisJCQkJcHViX2V4Y2Vw dF9vYmpfbGlzdCBvcHRfcHViX2V4Y2VwdF9jbGF1c2UKIAogJXR5cGUgPHJldGNsYXVzZT4gcmV0 dXJuaW5nX2NsYXVzZQogJXR5cGUgPG5vZGU+CXJldHVybmluZ19vcHRpb24KQEAgLTU5Miw2ICs1 OTMsNyBAQCBzdGF0aWMgTm9kZSAqbWFrZVJlY3Vyc2l2ZVZpZXdTZWxlY3QoY2hhciAqcmVsbmFt ZSwgTGlzdCAqYWxpYXNlcywgTm9kZSAqcXVlcnkpOwogJXR5cGUgPG5vZGU+CXZhcl92YWx1ZSB6 b25lX3ZhbHVlCiAldHlwZSA8cm9sZXNwZWM+IGF1dGhfaWRlbnQgUm9sZVNwZWMgb3B0X2dyYW50 ZWRfYnkKICV0eXBlIDxwdWJsaWNhdGlvbm9iamVjdHNwZWM+IFB1YmxpY2F0aW9uT2JqU3BlYwor JXR5cGUgPHB1YmxpY2F0aW9ub2JqZWN0c3BlYz4gUHVibGljYXRpb25FeGNlcHRPYmpTcGVjCiAl dHlwZSA8cHVibGljYXRpb25hbGxvYmplY3RzcGVjPiBQdWJsaWNhdGlvbkFsbE9ialNwZWMKIAog JXR5cGUgPGtleXdvcmQ+IHVucmVzZXJ2ZWRfa2V5d29yZCB0eXBlX2Z1bmNfbmFtZV9rZXl3b3Jk CkBAIC0xMDc4Nyw3ICsxMDc4OSw3IEBAIEFsdGVyT3duZXJTdG10OiBBTFRFUiBBR0dSRUdBVEUg YWdncmVnYXRlX3dpdGhfYXJndHlwZXMgT1dORVIgVE8gUm9sZVNwZWMKICAqCiAgKiBwdWJfYWxs X29ial90eXBlIGlzIG9uZSBvZjoKICAqCi0gKgkJVEFCTEVTCisgKgkJVEFCTEVTIFtFWENFUFQg W1RBQkxFXSAoIHRhYmxlIFssIC4uLl0gKV0KICAqCQlTRVFVRU5DRVMKICAqCiAgKiBDUkVBVEUg UFVCTElDQVRJT04gRk9SIHB1Yl9vYmogWywgLi4uXSBbV0lUSCBvcHRpb25zXQpAQCAtMTA4MTMs NiArMTA4MTUsNyBAQCBDcmVhdGVQdWJsaWNhdGlvblN0bXQ6CiAJCQkJCUNyZWF0ZVB1YmxpY2F0 aW9uU3RtdCAqbiA9IG1ha2VOb2RlKENyZWF0ZVB1YmxpY2F0aW9uU3RtdCk7CiAKIAkJCQkJbi0+ cHVibmFtZSA9ICQzOworCQkJCQluLT5wdWJvYmplY3RzID0gJDU7CiAJCQkJCXByZXByb2Nlc3Nf cHViX2FsbF9vYmp0eXBlX2xpc3QoJDUsICZuLT5mb3JfYWxsX3RhYmxlcywKIAkJCQkJCQkJCQkJ CQkmbi0+Zm9yX2FsbF9zZXF1ZW5jZXMsCiAJCQkJCQkJCQkJCQkJeXlzY2FubmVyKTsKQEAgLTEw ODUzLDYgKzEwODU2LDcgQEAgUHVibGljYXRpb25PYmpTcGVjOgogCQkJCQkkJC0+cHVidGFibGUt PnJlbGF0aW9uID0gJDI7CiAJCQkJCSQkLT5wdWJ0YWJsZS0+Y29sdW1ucyA9ICQzOwogCQkJCQkk JC0+cHVidGFibGUtPndoZXJlQ2xhdXNlID0gJDQ7CisJCQkJCSQkLT5sb2NhdGlvbiA9IEAxOwog CQkJCX0KIAkJCXwgVEFCTEVTIElOX1AgU0NIRU1BIENvbElkCiAJCQkJewpAQCAtMTA5MjgsMTEg KzEwOTMyLDE5IEBAIHB1Yl9vYmpfbGlzdDoJUHVibGljYXRpb25PYmpTcGVjCiAJCQkJCXsgJCQg PSBsYXBwZW5kKCQxLCAkMyk7IH0KIAk7CiAKK29wdF9wdWJfZXhjZXB0X2NsYXVzZToKKwkJCUVY Q0VQVCBvcHRfdGFibGUgJygnIHB1Yl9leGNlcHRfb2JqX2xpc3QgJyknCXsgJCQgPSAkNDsgfQor CQkJfCAvKkVNUFRZKi8JCQkJCQkJCQkJeyAkJCA9IE5JTDsgfQorCQk7CisKIFB1YmxpY2F0aW9u QWxsT2JqU3BlYzoKLQkJCQlBTEwgVEFCTEVTCisJCQkJQUxMIFRBQkxFUyBvcHRfcHViX2V4Y2Vw dF9jbGF1c2UKIAkJCQkJewogCQkJCQkJJCQgPSBtYWtlTm9kZShQdWJsaWNhdGlvbkFsbE9ialNw ZWMpOwogCQkJCQkJJCQtPnB1Ym9ianR5cGUgPSBQVUJMSUNBVElPTl9BTExfVEFCTEVTOworCQkJ CQkJJCQtPmV4Y2VwdF9vYmplY3RzID0gJDM7CisJCQkJCQlpZigkJC0+ZXhjZXB0X29iamVjdHMg IT0gTlVMTCkKKwkJCQkJCQlwcmVwcm9jZXNzX3B1Ym9ial9saXN0KCQkLT5leGNlcHRfb2JqZWN0 cywgeXlzY2FubmVyKTsKIAkJCQkJCSQkLT5sb2NhdGlvbiA9IEAxOwogCQkJCQl9CiAJCQkJfCBB TEwgU0VRVUVOQ0VTCkBAIC0xMDk0OSw2ICsxMDk2MSwyMyBAQCBwdWJfYWxsX29ial90eXBlX2xp c3Q6CVB1YmxpY2F0aW9uQWxsT2JqU3BlYwogCQkJCQl7ICQkID0gbGFwcGVuZCgkMSwgJDMpOyB9 CiAJOwogCitQdWJsaWNhdGlvbkV4Y2VwdE9ialNwZWM6CisJCQkgcmVsYXRpb25fZXhwcgorCQkJ CXsKKwkJCQkJJCQgPSBtYWtlTm9kZShQdWJsaWNhdGlvbk9ialNwZWMpOworCQkJCQkkJC0+cHVi b2JqdHlwZSA9IFBVQkxJQ0FUSU9OT0JKX0VYQ0VQVF9UQUJMRTsKKwkJCQkJJCQtPnB1YnRhYmxl ID0gbWFrZU5vZGUoUHVibGljYXRpb25UYWJsZSk7CisJCQkJCSQkLT5wdWJ0YWJsZS0+ZXhjZXB0 ID0gdHJ1ZTsKKwkJCQkJJCQtPnB1YnRhYmxlLT5yZWxhdGlvbiA9ICQxOworCQkJCQkkJC0+bG9j YXRpb24gPSBAMTsKKwkJCQl9CisJOworCitwdWJfZXhjZXB0X29ial9saXN0OiBQdWJsaWNhdGlv bkV4Y2VwdE9ialNwZWMKKwkJCQkJeyAkJCA9IGxpc3RfbWFrZTEoJDEpOyB9CisJCQl8IHB1Yl9l eGNlcHRfb2JqX2xpc3QgJywnIFB1YmxpY2F0aW9uRXhjZXB0T2JqU3BlYworCQkJCQl7ICQkID0g bGFwcGVuZCgkMSwgJDMpOyB9CisJOwogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqCmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9wZ291dHB1dC9wZ291dHB1dC5jIGIvc3Jj L2JhY2tlbmQvcmVwbGljYXRpb24vcGdvdXRwdXQvcGdvdXRwdXQuYwppbmRleCA3ODc5OThhYmI4 YS4uZDA0MmRhN2IzNDcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL3Bnb3V0 cHV0L3Bnb3V0cHV0LmMKKysrIGIvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vcGdvdXRwdXQvcGdv dXRwdXQuYwpAQCAtMjA4NCw3ICsyMDg0LDggQEAgZ2V0X3JlbF9zeW5jX2VudHJ5KFBHT3V0cHV0 RGF0YSAqZGF0YSwgUmVsYXRpb24gcmVsYXRpb24pCiAJaWYgKCFlbnRyeS0+cmVwbGljYXRlX3Zh bGlkKQogCXsKIAkJT2lkCQkJc2NoZW1hSWQgPSBnZXRfcmVsX25hbWVzcGFjZShyZWxpZCk7Ci0J CUxpc3QJICAgKnB1YmlkcyA9IEdldFJlbGF0aW9uUHVibGljYXRpb25zKHJlbGlkKTsKKwkJTGlz dAkgICAqcHViaWRzID0gTklMOworCQlMaXN0CSAgICpleGNlcHRUYWJsZVB1YmlkcyA9IE5JTDsK IAogCQkvKgogCQkgKiBXZSBkb24ndCBhY3F1aXJlIGEgbG9jayBvbiB0aGUgbmFtZXNwYWNlIHN5 c3RlbSB0YWJsZSBhcyB3ZSBidWlsZApAQCAtMjA5OSw2ICsyMTAwLDggQEAgZ2V0X3JlbF9zeW5j X2VudHJ5KFBHT3V0cHV0RGF0YSAqZGF0YSwgUmVsYXRpb24gcmVsYXRpb24pCiAJCWNoYXIJCXJl bGtpbmQgPSBnZXRfcmVsX3JlbGtpbmQocmVsaWQpOwogCQlMaXN0CSAgICpyZWxfcHVibGljYXRp b25zID0gTklMOwogCisJCUdldFJlbGF0aW9uUHVibGljYXRpb25zKHJlbGlkLCAmcHViaWRzLCAm ZXhjZXB0VGFibGVQdWJpZHMpOworCiAJCS8qIFJlbG9hZCBwdWJsaWNhdGlvbnMgaWYgbmVlZGVk IGJlZm9yZSB1c2UuICovCiAJCWlmICghcHVibGljYXRpb25zX3ZhbGlkKQogCQl7CkBAIC0yMTk1 LDIyICsyMTk4LDYgQEAgZ2V0X3JlbF9zeW5jX2VudHJ5KFBHT3V0cHV0RGF0YSAqZGF0YSwgUmVs YXRpb24gcmVsYXRpb24pCiAJCQlPaWQJCQlwdWJfcmVsaWQgPSByZWxpZDsKIAkJCWludAkJCWFu Y2VzdG9yX2xldmVsID0gMDsKIAotCQkJLyoKLQkJCSAqIElmIHRoaXMgaXMgYSBGT1IgQUxMIFRB QkxFUyBwdWJsaWNhdGlvbiwgcGljayB0aGUgcGFydGl0aW9uCi0JCQkgKiByb290IGFuZCBzZXQg dGhlIGFuY2VzdG9yIGxldmVsIGFjY29yZGluZ2x5LgotCQkJICovCi0JCQlpZiAocHViLT5hbGx0 YWJsZXMpCi0JCQl7Ci0JCQkJcHVibGlzaCA9IHRydWU7Ci0JCQkJaWYgKHB1Yi0+cHVidmlhcm9v dCAmJiBhbV9wYXJ0aXRpb24pCi0JCQkJewotCQkJCQlMaXN0CSAgICphbmNlc3RvcnMgPSBnZXRf cGFydGl0aW9uX2FuY2VzdG9ycyhyZWxpZCk7Ci0KLQkJCQkJcHViX3JlbGlkID0gbGxhc3Rfb2lk KGFuY2VzdG9ycyk7Ci0JCQkJCWFuY2VzdG9yX2xldmVsID0gbGlzdF9sZW5ndGgoYW5jZXN0b3Jz KTsKLQkJCQl9Ci0JCQl9Ci0KIAkJCWlmICghcHVibGlzaCkKIAkJCXsKIAkJCQlib29sCQlhbmNl c3Rvcl9wdWJsaXNoZWQgPSBmYWxzZTsKQEAgLTIyMjksNyArMjIxNiw4IEBAIGdldF9yZWxfc3lu Y19lbnRyeShQR091dHB1dERhdGEgKmRhdGEsIFJlbGF0aW9uIHJlbGF0aW9uKQogCiAJCQkJCWFu Y2VzdG9yID0gR2V0VG9wTW9zdEFuY2VzdG9ySW5QdWJsaWNhdGlvbihwdWItPm9pZCwKIAkJCQkJ CQkJCQkJCQkJCSAgIGFuY2VzdG9ycywKLQkJCQkJCQkJCQkJCQkJCSAgICZsZXZlbCk7CisJCQkJ CQkJCQkJCQkJCQkgICAmbGV2ZWwsCisJCQkJCQkJCQkJCQkJCQkgICBwdWItPmFsbHRhYmxlcyk7 CiAKIAkJCQkJaWYgKGFuY2VzdG9yICE9IEludmFsaWRPaWQpCiAJCQkJCXsKQEAgLTIyNDQsNiAr MjIzMiw4IEBAIGdldF9yZWxfc3luY19lbnRyeShQR091dHB1dERhdGEgKmRhdGEsIFJlbGF0aW9u IHJlbGF0aW9uKQogCiAJCQkJaWYgKGxpc3RfbWVtYmVyX29pZChwdWJpZHMsIHB1Yi0+b2lkKSB8 fAogCQkJCQlsaXN0X21lbWJlcl9vaWQoc2NoZW1hUHViaWRzLCBwdWItPm9pZCkgfHwKKwkJCQkJ KHB1Yi0+YWxsdGFibGVzICYmCisJCQkJCSAhbGlzdF9tZW1iZXJfb2lkKGV4Y2VwdFRhYmxlUHVi aWRzLCBwdWItPm9pZCkpIHx8CiAJCQkJCWFuY2VzdG9yX3B1Ymxpc2hlZCkKIAkJCQkJcHVibGlz aCA9IHRydWU7CiAJCQl9CkBAIC0yMzIyLDYgKzIzMTIsNyBAQCBnZXRfcmVsX3N5bmNfZW50cnko UEdPdXRwdXREYXRhICpkYXRhLCBSZWxhdGlvbiByZWxhdGlvbikKIAogCQlsaXN0X2ZyZWUocHVi aWRzKTsKIAkJbGlzdF9mcmVlKHNjaGVtYVB1Ymlkcyk7CisJCWxpc3RfZnJlZShleGNlcHRUYWJs ZVB1Ymlkcyk7CiAJCWxpc3RfZnJlZShyZWxfcHVibGljYXRpb25zKTsKIAogCQllbnRyeS0+cmVw bGljYXRlX3ZhbGlkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL2NhY2hl L3JlbGNhY2hlLmMgYi9zcmMvYmFja2VuZC91dGlscy9jYWNoZS9yZWxjYWNoZS5jCmluZGV4IDJk MGNiN2JjZmQ0Li5mNTIxZmQ5NDlkZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvY2Fj aGUvcmVsY2FjaGUuYworKysgYi9zcmMvYmFja2VuZC91dGlscy9jYWNoZS9yZWxjYWNoZS5jCkBA IC01NzkzLDcgKzU3OTMsOSBAQCBSZWxhdGlvbkdldEV4Y2x1c2lvbkluZm8oUmVsYXRpb24gaW5k ZXhSZWxhdGlvbiwKIHZvaWQKIFJlbGF0aW9uQnVpbGRQdWJsaWNhdGlvbkRlc2MoUmVsYXRpb24g cmVsYXRpb24sIFB1YmxpY2F0aW9uRGVzYyAqcHViZGVzYykKIHsKLQlMaXN0CSAgICpwdWJvaWRz OworCUxpc3QJICAgKnB1Ym9pZHMgPSBOSUw7CisJTGlzdAkgICAqZXhjZXB0cHVib2lkcyA9IE5J TDsKKwlMaXN0CSAgICphbGx0YWJsZXNwdWJvaWRzOwogCUxpc3RDZWxsICAgKmxjOwogCU1lbW9y eUNvbnRleHQgb2xkY3h0OwogCU9pZAkJCXNjaGVtYWlkOwpAQCAtNTgzMSw3ICs1ODMzLDcgQEAg UmVsYXRpb25CdWlsZFB1YmxpY2F0aW9uRGVzYyhSZWxhdGlvbiByZWxhdGlvbiwgUHVibGljYXRp b25EZXNjICpwdWJkZXNjKQogCXB1YmRlc2MtPmdlbmNvbHNfdmFsaWRfZm9yX2RlbGV0ZSA9IHRy dWU7CiAKIAkvKiBGZXRjaCB0aGUgcHVibGljYXRpb24gbWVtYmVyc2hpcCBpbmZvLiAqLwotCXB1 Ym9pZHMgPSBHZXRSZWxhdGlvblB1YmxpY2F0aW9ucyhyZWxpZCk7CisJR2V0UmVsYXRpb25QdWJs aWNhdGlvbnMocmVsaWQsICZwdWJvaWRzLCAmZXhjZXB0cHVib2lkcyk7CiAJc2NoZW1haWQgPSBS ZWxhdGlvbkdldE5hbWVzcGFjZShyZWxhdGlvbik7CiAJcHVib2lkcyA9IGxpc3RfY29uY2F0X3Vu aXF1ZV9vaWQocHVib2lkcywgR2V0U2NoZW1hUHVibGljYXRpb25zKHNjaGVtYWlkKSk7CiAKQEAg LTU4NDMsMTYgKzU4NDUsMjUgQEAgUmVsYXRpb25CdWlsZFB1YmxpY2F0aW9uRGVzYyhSZWxhdGlv biByZWxhdGlvbiwgUHVibGljYXRpb25EZXNjICpwdWJkZXNjKQogCQlmb3JlYWNoKGxjLCBhbmNl c3RvcnMpCiAJCXsKIAkJCU9pZAkJCWFuY2VzdG9yID0gbGZpcnN0X29pZChsYyk7CisJCQlMaXN0 CSAgICphbmNlc3Rvcl9wdWJvaWRzID0gTklMOworCQkJTGlzdAkgICAqYW5jZXN0b3JfZXhjZXB0 cHVib2lkcyA9IE5JTDsKIAotCQkJcHVib2lkcyA9IGxpc3RfY29uY2F0X3VuaXF1ZV9vaWQocHVi b2lkcywKLQkJCQkJCQkJCQkJIEdldFJlbGF0aW9uUHVibGljYXRpb25zKGFuY2VzdG9yKSk7CisJ CQlHZXRSZWxhdGlvblB1YmxpY2F0aW9ucyhhbmNlc3RvciwgJmFuY2VzdG9yX3B1Ym9pZHMsCisJ CQkJCQkJCQkmYW5jZXN0b3JfZXhjZXB0cHVib2lkcyk7CisKKwkJCXB1Ym9pZHMgPSBsaXN0X2Nv bmNhdF91bmlxdWVfb2lkKHB1Ym9pZHMsIGFuY2VzdG9yX3B1Ym9pZHMpOwogCQkJc2NoZW1haWQg PSBnZXRfcmVsX25hbWVzcGFjZShhbmNlc3Rvcik7CiAJCQlwdWJvaWRzID0gbGlzdF9jb25jYXRf dW5pcXVlX29pZChwdWJvaWRzLAogCQkJCQkJCQkJCQkgR2V0U2NoZW1hUHVibGljYXRpb25zKHNj aGVtYWlkKSk7CisJCQlleGNlcHRwdWJvaWRzID0gbGlzdF9jb25jYXRfdW5pcXVlX29pZChleGNl cHRwdWJvaWRzLAorCQkJCQkJCQkJCQkJICAgYW5jZXN0b3JfZXhjZXB0cHVib2lkcyk7CiAJCX0K IAl9Ci0JcHVib2lkcyA9IGxpc3RfY29uY2F0X3VuaXF1ZV9vaWQocHVib2lkcywgR2V0QWxsVGFi bGVzUHVibGljYXRpb25zKCkpOwogCisJYWxsdGFibGVzcHVib2lkcyA9IEdldEFsbFRhYmxlc1B1 YmxpY2F0aW9ucygpOworCXB1Ym9pZHMgPSBsaXN0X2NvbmNhdF91bmlxdWVfb2lkKHB1Ym9pZHMs CisJCQkJCQkJCQkgbGlzdF9kaWZmZXJlbmNlX29pZChhbGx0YWJsZXNwdWJvaWRzLAorCQkJCQkJ CQkJCQkJCQkgZXhjZXB0cHVib2lkcykpOwogCWZvcmVhY2gobGMsIHB1Ym9pZHMpCiAJewogCQlP aWQJCQlwdWJpZCA9IGxmaXJzdF9vaWQobGMpOwpAQCAtNTg4Myw2ICs1ODk0LDcgQEAgUmVsYXRp b25CdWlsZFB1YmxpY2F0aW9uRGVzYyhSZWxhdGlvbiByZWxhdGlvbiwgUHVibGljYXRpb25EZXNj ICpwdWJkZXNjKQogCQlpZiAoIXB1YmZvcm0tPnB1YmFsbHRhYmxlcyAmJgogCQkJKHB1YmZvcm0t PnB1YnVwZGF0ZSB8fCBwdWJmb3JtLT5wdWJkZWxldGUpICYmCiAJCQlwdWJfcmZfY29udGFpbnNf aW52YWxpZF9jb2x1bW4ocHViaWQsIHJlbGF0aW9uLCBhbmNlc3RvcnMsCisJCQkJCQkJCQkJICAg cHViZm9ybS0+cHViYWxsdGFibGVzLAogCQkJCQkJCQkJCSAgIHB1YmZvcm0tPnB1YnZpYXJvb3Qp KQogCQl7CiAJCQlpZiAocHViZm9ybS0+cHVidXBkYXRlKQpAQCAtNTg5OSw2ICs1OTExLDcgQEAg UmVsYXRpb25CdWlsZFB1YmxpY2F0aW9uRGVzYyhSZWxhdGlvbiByZWxhdGlvbiwgUHVibGljYXRp b25EZXNjICpwdWJkZXNjKQogCQkgKi8KIAkJaWYgKChwdWJmb3JtLT5wdWJ1cGRhdGUgfHwgcHVi Zm9ybS0+cHViZGVsZXRlKSAmJgogCQkJcHViX2NvbnRhaW5zX2ludmFsaWRfY29sdW1uKHB1Ymlk LCByZWxhdGlvbiwgYW5jZXN0b3JzLAorCQkJCQkJCQkJCXB1YmZvcm0tPnB1YmFsbHRhYmxlcywK IAkJCQkJCQkJCQlwdWJmb3JtLT5wdWJ2aWFyb290LAogCQkJCQkJCQkJCXB1YmZvcm0tPnB1Ymdl bmNvbHMsCiAJCQkJCQkJCQkJJmludmFsaWRfY29sdW1uX2xpc3QsCmRpZmYgLS1naXQgYS9zcmMv YmluL3BnX2R1bXAvcGdfZHVtcC5jIGIvc3JjL2Jpbi9wZ19kdW1wL3BnX2R1bXAuYwppbmRleCAy NGFkMjAxYWYyZi4uZDI5Yzc4M2FjNWMgMTAwNjQ0Ci0tLSBhL3NyYy9iaW4vcGdfZHVtcC9wZ19k dW1wLmMKKysrIGIvc3JjL2Jpbi9wZ19kdW1wL3BnX2R1bXAuYwpAQCAtNDYzNCw5ICs0NjM0LDQ4 IEBAIGdldFB1YmxpY2F0aW9ucyhBcmNoaXZlICpmb3V0KQogCQkJKHN0cmNtcChQUWdldHZhbHVl KHJlcywgaSwgaV9wdWJ2aWFyb290KSwgInQiKSA9PSAwKTsKIAkJcHViaW5mb1tpXS5wdWJnZW5j b2xzX3R5cGUgPQogCQkJKihQUWdldHZhbHVlKHJlcywgaSwgaV9wdWJnZW5jb2xzKSk7CisJCXB1 YmluZm9baV0uZXhjZXB0dGJscyA9IChTaW1wbGVQdHJMaXN0KQorCQl7CisJCQlOVUxMLCBOVUxM CisJCX07CiAKIAkJLyogRGVjaWRlIHdoZXRoZXIgd2Ugd2FudCB0byBkdW1wIGl0ICovCiAJCXNl bGVjdER1bXBhYmxlT2JqZWN0KCYocHViaW5mb1tpXS5kb2JqKSwgZm91dCk7CisKKwkJaWYgKGZv dXQtPnJlbW90ZVZlcnNpb24gPj0gMTkwMDAwKQorCQl7CisJCQlpbnQJCQludGJsczsKKwkJCVBH cmVzdWx0ICAgKnJlc190YmxzOworCisJCQlyZXNldFBRRXhwQnVmZmVyKHF1ZXJ5KTsKKwkJCWFw cGVuZFBRRXhwQnVmZmVyKHF1ZXJ5LAorCQkJCQkJCSAgIlNFTEVDVCBwcnJlbGlkXG4iCisJCQkJ CQkJICAiRlJPTSBwZ19jYXRhbG9nLnBnX3B1YmxpY2F0aW9uX3JlbFxuIgorCQkJCQkJCSAgIldI RVJFIHBycHViaWQgPSAlZCBhbmQgcHJleGNlcHQgPSB0cnVlIiwKKwkJCQkJCQkgIHB1YmluZm9b aV0uZG9iai5jYXRJZC5vaWQpOworCisJCQlyZXNfdGJscyA9IEV4ZWN1dGVTcWxRdWVyeShmb3V0 LCBxdWVyeS0+ZGF0YSwgUEdSRVNfVFVQTEVTX09LKTsKKworCQkJbnRibHMgPSBQUW50dXBsZXMo cmVzX3RibHMpOworCQkJaWYgKG50YmxzID09IDApCisJCQkJY29udGludWU7CisKKwkJCWZvciAo aW50IGogPSAwOyBqIDwgbnRibHM7IGorKykKKwkJCXsKKwkJCQlPaWQJCQlwcnJlbGlkOworCQkJ CVRhYmxlSW5mbyAgKnRiaW5mbzsKKworCQkJCXBycmVsaWQgPSBhdG9vaWQoUFFnZXR2YWx1ZShy ZXNfdGJscywgaiwgMCkpOworCisJCQkJdGJpbmZvID0gZmluZFRhYmxlQnlPaWQocHJyZWxpZCk7 CisJCQkJaWYgKHRiaW5mbyA9PSBOVUxMKQorCQkJCQljb250aW51ZTsKKworCQkJCXNpbXBsZV9w dHJfbGlzdF9hcHBlbmQoJnB1YmluZm9baV0uZXhjZXB0dGJscywgdGJpbmZvKTsKKwkJCX0KKwor CQkJUFFjbGVhcihyZXNfdGJscyk7CisJCX0KIAl9CiAKIGNsZWFudXA6CkBAIC00Njc2LDcgKzQ3 MTUsMjggQEAgZHVtcFB1YmxpY2F0aW9uKEFyY2hpdmUgKmZvdXQsIGNvbnN0IFB1YmxpY2F0aW9u SW5mbyAqcHViaW5mbykKIAlpZiAocHViaW5mby0+cHViYWxsdGFibGVzICYmIHB1YmluZm8tPnB1 YmFsbHNlcXVlbmNlcykKIAkJYXBwZW5kUFFFeHBCdWZmZXJTdHIocXVlcnksICIgRk9SIEFMTCBU QUJMRVMsIEFMTCBTRVFVRU5DRVMiKTsKIAllbHNlIGlmIChwdWJpbmZvLT5wdWJhbGx0YWJsZXMp CisJeworCQlib29sCQlmaXJzdF90YmwgPSB0cnVlOworCiAJCWFwcGVuZFBRRXhwQnVmZmVyU3Ry KHF1ZXJ5LCAiIEZPUiBBTEwgVEFCTEVTIik7CisKKwkJLyogSW5jbHVkZSBleGNlcHRpb24gdGFi bGVzIGlmIHRoZSBwdWJsaWNhdGlvbiBoYXMgRVhDRVBUIFRBQkxFcyAqLworCQlmb3IgKFNpbXBs ZVB0ckxpc3RDZWxsICpjZWxsID0gcHViaW5mby0+ZXhjZXB0dGJscy5oZWFkOyBjZWxsOyBjZWxs ID0gY2VsbC0+bmV4dCkKKwkJeworCQkJVGFibGVJbmZvICAqdGJpbmZvID0gKFRhYmxlSW5mbyAq KSBjZWxsLT5wdHI7CisKKwkJCWlmIChmaXJzdF90YmwpCisJCQl7CisJCQkJYXBwZW5kUFFFeHBC dWZmZXJTdHIocXVlcnksICIgRVhDRVBUIFRBQkxFICgiKTsKKwkJCQlmaXJzdF90YmwgPSBmYWxz ZTsKKwkJCX0KKwkJCWVsc2UKKwkJCQlhcHBlbmRQUUV4cEJ1ZmZlclN0cihxdWVyeSwgIiwgIik7 CisJCQlhcHBlbmRQUUV4cEJ1ZmZlcihxdWVyeSwgIk9OTFkgJXMiLCBmbXRRdWFsaWZpZWREdW1w YWJsZSh0YmluZm8pKTsKKwkJfQorCQlpZiAoIWZpcnN0X3RibCkKKwkJCWFwcGVuZFBRRXhwQnVm ZmVyU3RyKHF1ZXJ5LCAiKSIpOworCX0KIAllbHNlIGlmIChwdWJpbmZvLT5wdWJhbGxzZXF1ZW5j ZXMpCiAJCWFwcGVuZFBRRXhwQnVmZmVyU3RyKHF1ZXJ5LCAiIEZPUiBBTEwgU0VRVUVOQ0VTIik7 CiAKQEAgLTQ4NTYsOCArNDkxNiw5IEBAIGdldFB1YmxpY2F0aW9uVGFibGVzKEFyY2hpdmUgKmZv dXQsIFRhYmxlSW5mbyB0YmxpbmZvW10sIGludCBudW1UYWJsZXMpCiAKIAkvKiBDb2xsZWN0IGFs bCBwdWJsaWNhdGlvbiBtZW1iZXJzaGlwIGluZm8uICovCiAJaWYgKGZvdXQtPnJlbW90ZVZlcnNp b24gPj0gMTUwMDAwKQorCXsKIAkJYXBwZW5kUFFFeHBCdWZmZXJTdHIocXVlcnksCi0JCQkJCQkJ ICJTRUxFQ1QgdGFibGVvaWQsIG9pZCwgcHJwdWJpZCwgcHJyZWxpZCwgIgorCQkJCQkJCSAiU0VM RUNUIHRhYmxlb2lkLCBvaWQsIHBycHViaWQsIHBycmVsaWQsXG4iCiAJCQkJCQkJICJwZ19jYXRh bG9nLnBnX2dldF9leHByKHBycXVhbCwgcHJyZWxpZCkgQVMgcHJyZWxxdWFsLCAiCiAJCQkJCQkJ ICIoQ0FTRVxuIgogCQkJCQkJCSAiICBXSEVOIHByLnByYXR0cnMgSVMgTk9UIE5VTEwgVEhFTlxu IgpAQCAtNDg2OCw2ICs0OTI5LDkgQEAgZ2V0UHVibGljYXRpb25UYWJsZXMoQXJjaGl2ZSAqZm91 dCwgVGFibGVJbmZvIHRibGluZm9bXSwgaW50IG51bVRhYmxlcykKIAkJCQkJCQkgIiAgICAgIFdI RVJFIGF0dHJlbGlkID0gcHIucHJyZWxpZCBBTkQgYXR0bnVtID0gcHJhdHRyc1tzXSlcbiIKIAkJ CQkJCQkgIiAgRUxTRSBOVUxMIEVORCkgcHJhdHRycyAiCiAJCQkJCQkJICJGUk9NIHBnX2NhdGFs b2cucGdfcHVibGljYXRpb25fcmVsIHByIik7CisJCWlmIChmb3V0LT5yZW1vdGVWZXJzaW9uID49 IDE5MDAwMCkKKwkJCWFwcGVuZFBRRXhwQnVmZmVyU3RyKHF1ZXJ5LCAiIFdIRVJFIHByZXhjZXB0 ID0gZmFsc2UiKTsKKwl9CiAJZWxzZQogCQlhcHBlbmRQUUV4cEJ1ZmZlclN0cihxdWVyeSwKIAkJ CQkJCQkgIlNFTEVDVCB0YWJsZW9pZCwgb2lkLCBwcnB1YmlkLCBwcnJlbGlkLCAiCkBAIC0xMTgy Niw2ICsxMTg5MCw5IEBAIGR1bXBEdW1wYWJsZU9iamVjdChBcmNoaXZlICpmb3V0LCBEdW1wYWJs ZU9iamVjdCAqZG9iaikKIAkJY2FzZSBET19QVUJMSUNBVElPTjoKIAkJCWR1bXBQdWJsaWNhdGlv bihmb3V0LCAoY29uc3QgUHVibGljYXRpb25JbmZvICopIGRvYmopOwogCQkJYnJlYWs7CisJCWNh c2UgRE9fUFVCTElDQVRJT05fRVhDRVBUX1JFTDoKKwkJCS8qIHdpbGwgYmUgZHVtcGVkIGluIGR1 bXBQdWJsaWNhdGlvbiAqLworCQkJYnJlYWs7CiAJCWNhc2UgRE9fUFVCTElDQVRJT05fUkVMOgog CQkJZHVtcFB1YmxpY2F0aW9uVGFibGUoZm91dCwgKGNvbnN0IFB1YmxpY2F0aW9uUmVsSW5mbyAq KSBkb2JqKTsKIAkJCWJyZWFrOwpAQCAtMjAxOTYsNiArMjAyNjMsNyBAQCBhZGRCb3VuZGFyeURl cGVuZGVuY2llcyhEdW1wYWJsZU9iamVjdCAqKmRvYmpzLCBpbnQgbnVtT2JqcywKIAkJCWNhc2Ug RE9fREVGQVVMVF9BQ0w6CiAJCQljYXNlIERPX1BPTElDWToKIAkJCWNhc2UgRE9fUFVCTElDQVRJ T046CisJCQljYXNlIERPX1BVQkxJQ0FUSU9OX0VYQ0VQVF9SRUw6CiAJCQljYXNlIERPX1BVQkxJ Q0FUSU9OX1JFTDoKIAkJCWNhc2UgRE9fUFVCTElDQVRJT05fVEFCTEVfSU5fU0NIRU1BOgogCQkJ Y2FzZSBET19TVUJTQ1JJUFRJT046CmRpZmYgLS1naXQgYS9zcmMvYmluL3BnX2R1bXAvcGdfZHVt cC5oIGIvc3JjL2Jpbi9wZ19kdW1wL3BnX2R1bXAuaAppbmRleCA3MmEwMGUxYmMyMC4uYjg1ZTI1 MGMyMDMgMTAwNjQ0Ci0tLSBhL3NyYy9iaW4vcGdfZHVtcC9wZ19kdW1wLmgKKysrIGIvc3JjL2Jp bi9wZ19kdW1wL3BnX2R1bXAuaApAQCAtODEsNiArODEsNyBAQCB0eXBlZGVmIGVudW0KIAlET19S RUZSRVNIX01BVFZJRVcsCiAJRE9fUE9MSUNZLAogCURPX1BVQkxJQ0FUSU9OLAorCURPX1BVQkxJ Q0FUSU9OX0VYQ0VQVF9SRUwsCiAJRE9fUFVCTElDQVRJT05fUkVMLAogCURPX1BVQkxJQ0FUSU9O X1RBQkxFX0lOX1NDSEVNQSwKIAlET19SRUxfU1RBVFMsCkBAIC02NzYsNiArNjc3LDcgQEAgdHlw ZWRlZiBzdHJ1Y3QgX1B1YmxpY2F0aW9uSW5mbwogCWJvb2wJCXB1YnRydW5jYXRlOwogCWJvb2wJ CXB1YnZpYXJvb3Q7CiAJUHVibGlzaEdlbmNvbHNUeXBlIHB1YmdlbmNvbHNfdHlwZTsKKwlTaW1w bGVQdHJMaXN0IGV4Y2VwdHRibHM7CiB9IFB1YmxpY2F0aW9uSW5mbzsKIAogLyoKZGlmZiAtLWdp dCBhL3NyYy9iaW4vcGdfZHVtcC9wZ19kdW1wX3NvcnQuYyBiL3NyYy9iaW4vcGdfZHVtcC9wZ19k dW1wX3NvcnQuYwppbmRleCAxNjRjNzZlMDg2NC4uNmViZWI5Yzk2YTEgMTAwNjQ0Ci0tLSBhL3Ny Yy9iaW4vcGdfZHVtcC9wZ19kdW1wX3NvcnQuYworKysgYi9zcmMvYmluL3BnX2R1bXAvcGdfZHVt cF9zb3J0LmMKQEAgLTkyLDYgKzkyLDcgQEAgZW51bSBkYk9iamVjdFR5cGVQcmlvcml0aWVzCiAJ UFJJT19GS19DT05TVFJBSU5ULAogCVBSSU9fUE9MSUNZLAogCVBSSU9fUFVCTElDQVRJT04sCisJ UFJJT19QVUJMSUNBVElPTl9FWENFUFRfUkVMLAogCVBSSU9fUFVCTElDQVRJT05fUkVMLAogCVBS SU9fUFVCTElDQVRJT05fVEFCTEVfSU5fU0NIRU1BLAogCVBSSU9fU1VCU0NSSVBUSU9OLApAQCAt MTQ3LDYgKzE0OCw3IEBAIHN0YXRpYyBjb25zdCBpbnQgZGJPYmplY3RUeXBlUHJpb3JpdHlbXSA9 CiAJW0RPX1JFRlJFU0hfTUFUVklFV10gPSBQUklPX1JFRlJFU0hfTUFUVklFVywKIAlbRE9fUE9M SUNZXSA9IFBSSU9fUE9MSUNZLAogCVtET19QVUJMSUNBVElPTl0gPSBQUklPX1BVQkxJQ0FUSU9O LAorCVtET19QVUJMSUNBVElPTl9FWENFUFRfUkVMXSA9IFBSSU9fUFVCTElDQVRJT05fRVhDRVBU X1JFTCwKIAlbRE9fUFVCTElDQVRJT05fUkVMXSA9IFBSSU9fUFVCTElDQVRJT05fUkVMLAogCVtE T19QVUJMSUNBVElPTl9UQUJMRV9JTl9TQ0hFTUFdID0gUFJJT19QVUJMSUNBVElPTl9UQUJMRV9J Tl9TQ0hFTUEsCiAJW0RPX1JFTF9TVEFUU10gPSBQUklPX1NUQVRJU1RJQ1NfREFUQV9EQVRBLApA QCAtNDMyLDcgKzQzNCw4IEBAIERPVHlwZU5hbWVDb21wYXJlKGNvbnN0IHZvaWQgKnAxLCBjb25z dCB2b2lkICpwMikKIAkJaWYgKGNtcHZhbCAhPSAwKQogCQkJcmV0dXJuIGNtcHZhbDsKIAl9Ci0J ZWxzZSBpZiAob2JqMS0+b2JqVHlwZSA9PSBET19QVUJMSUNBVElPTl9SRUwpCisJZWxzZSBpZiAo b2JqMS0+b2JqVHlwZSA9PSBET19QVUJMSUNBVElPTl9SRUwgfHwKKwkJCSBvYmoxLT5vYmpUeXBl ID09IERPX1BVQkxJQ0FUSU9OX0VYQ0VQVF9SRUwpCiAJewogCQlQdWJsaWNhdGlvblJlbEluZm8g KnByb2JqMSA9ICooUHVibGljYXRpb25SZWxJbmZvICpjb25zdCAqKSBwMTsKIAkJUHVibGljYXRp b25SZWxJbmZvICpwcm9iajIgPSAqKFB1YmxpY2F0aW9uUmVsSW5mbyAqY29uc3QgKikgcDI7CkBA IC0xNzE1LDYgKzE3MTgsMTEgQEAgZGVzY3JpYmVEdW1wYWJsZU9iamVjdChEdW1wYWJsZU9iamVj dCAqb2JqLCBjaGFyICpidWYsIGludCBidWZzaXplKQogCQkJCQkgIlBVQkxJQ0FUSU9OIChJRCAl ZCBPSUQgJXUpIiwKIAkJCQkJIG9iai0+ZHVtcElkLCBvYmotPmNhdElkLm9pZCk7CiAJCQlyZXR1 cm47CisJCWNhc2UgRE9fUFVCTElDQVRJT05fRVhDRVBUX1JFTDoKKwkJCXNucHJpbnRmKGJ1Ziwg YnVmc2l6ZSwKKwkJCQkJICJQVUJMSUNBVElPTiBFWENFUFQgVEFCTEUgKElEICVkIE9JRCAldSki LAorCQkJCQkgb2JqLT5kdW1wSWQsIG9iai0+Y2F0SWQub2lkKTsKKwkJCXJldHVybjsKIAkJY2Fz ZSBET19QVUJMSUNBVElPTl9SRUw6CiAJCQlzbnByaW50ZihidWYsIGJ1ZnNpemUsCiAJCQkJCSAi UFVCTElDQVRJT04gVEFCTEUgKElEICVkIE9JRCAldSkiLApkaWZmIC0tZ2l0IGEvc3JjL2Jpbi9w Z19kdW1wL3QvMDAyX3BnX2R1bXAucGwgYi9zcmMvYmluL3BnX2R1bXAvdC8wMDJfcGdfZHVtcC5w bAppbmRleCBlMzNhYTk1ZjZmZi4uYTNmY2YzYzJiMGEgMTAwNjQ0Ci0tLSBhL3NyYy9iaW4vcGdf ZHVtcC90LzAwMl9wZ19kdW1wLnBsCisrKyBiL3NyYy9iaW4vcGdfZHVtcC90LzAwMl9wZ19kdW1w LnBsCkBAIC0zMTcwLDYgKzMxNzAsMzYgQEAgbXkgJXRlc3RzID0gKAogCQlsaWtlID0+IHsgJWZ1 bGxfcnVucywgc2VjdGlvbl9wb3N0X2RhdGEgPT4gMSwgfSwKIAl9LAogCisJJ0NSRUFURSBQVUJM SUNBVElPTiBwdWI4JyA9PiB7CisJCWNyZWF0ZV9vcmRlciA9PiA1MCwKKwkJY3JlYXRlX3NxbCA9 PgorCQkgICdDUkVBVEUgUFVCTElDQVRJT04gcHViOCBGT1IgQUxMIFRBQkxFUyBFWENFUFQgKGR1 bXBfdGVzdC50ZXN0X3RhYmxlKTsnLAorCQlyZWdleHAgPT4gcXIvXgorCQkJXFFDUkVBVEUgUFVC TElDQVRJT04gcHViOCBGT1IgQUxMIFRBQkxFUyBFWENFUFQgVEFCTEUgKE9OTFkgZHVtcF90ZXN0 LnRlc3RfdGFibGUpIFdJVEggKHB1Ymxpc2ggPSAnaW5zZXJ0LCB1cGRhdGUsIGRlbGV0ZSwgdHJ1 bmNhdGUnKTtcRQorCQkJL3htLAorCQlsaWtlID0+IHsgJWZ1bGxfcnVucywgc2VjdGlvbl9wb3N0 X2RhdGEgPT4gMSwgfSwKKwl9LAorCisJJ0NSRUFURSBQVUJMSUNBVElPTiBwdWI5JyA9PiB7CisJ CWNyZWF0ZV9vcmRlciA9PiA1MCwKKwkJY3JlYXRlX3NxbCA9PgorCQkgICdDUkVBVEUgUFVCTElD QVRJT04gcHViOSBGT1IgQUxMIFRBQkxFUyBFWENFUFQgVEFCTEUgKGR1bXBfdGVzdC50ZXN0X3Rh YmxlLCBkdW1wX3Rlc3QudGVzdF9zZWNvbmRfdGFibGUpOycsCisJCXJlZ2V4cCA9PiBxci9eCisJ CQlcUUNSRUFURSBQVUJMSUNBVElPTiBwdWI5IEZPUiBBTEwgVEFCTEVTIEVYQ0VQVCBUQUJMRSAo T05MWSBkdW1wX3Rlc3QudGVzdF90YWJsZSwgT05MWSBkdW1wX3Rlc3QudGVzdF9zZWNvbmRfdGFi bGUpIFdJVEggKHB1Ymxpc2ggPSAnaW5zZXJ0LCB1cGRhdGUsIGRlbGV0ZSwgdHJ1bmNhdGUnKTtc RQorCQkJL3htLAorCQlsaWtlID0+IHsgJWZ1bGxfcnVucywgc2VjdGlvbl9wb3N0X2RhdGEgPT4g MSwgfSwKKwl9LAorCisJJ0NSRUFURSBQVUJMSUNBVElPTiBwdWIxMCcgPT4geworCQljcmVhdGVf b3JkZXIgPT4gOTIsCisJCWNyZWF0ZV9zcWwgPT4KKwkJICAnQ1JFQVRFIFBVQkxJQ0FUSU9OIHB1 YjEwIEZPUiBBTEwgVEFCTEVTIEVYQ0VQVCBUQUJMRSAoZHVtcF90ZXN0LnRlc3RfaW5oZXJpdGFu Y2VfcGFyZW50KTsnLAorCQlyZWdleHAgPT4gcXIvXgorCQkJXFFDUkVBVEUgUFVCTElDQVRJT04g cHViMTAgRk9SIEFMTCBUQUJMRVMgRVhDRVBUIFRBQkxFIChPTkxZIGR1bXBfdGVzdC50ZXN0X2lu aGVyaXRhbmNlX3BhcmVudCwgT05MWSBkdW1wX3Rlc3QudGVzdF9pbmhlcml0YW5jZV9jaGlsZCkg V0lUSCAocHVibGlzaCA9ICdpbnNlcnQsIHVwZGF0ZSwgZGVsZXRlLCB0cnVuY2F0ZScpO1xFCisJ CQkveG0sCisJCWxpa2UgPT4geyAlZnVsbF9ydW5zLCBzZWN0aW9uX3Bvc3RfZGF0YSA9PiAxLCB9 LAorCX0sCisKIAknQ1JFQVRFIFNVQlNDUklQVElPTiBzdWIxJyA9PiB7CiAJCWNyZWF0ZV9vcmRl ciA9PiA1MCwKIAkJY3JlYXRlX3NxbCA9PiAnQ1JFQVRFIFNVQlNDUklQVElPTiBzdWIxCmRpZmYg LS1naXQgYS9zcmMvYmluL3BzcWwvZGVzY3JpYmUuYyBiL3NyYy9iaW4vcHNxbC9kZXNjcmliZS5j CmluZGV4IDM2ZjI0NTAyODQyLi44Y2Q3M2IzYWQ1MyAxMDA2NDQKLS0tIGEvc3JjL2Jpbi9wc3Fs L2Rlc2NyaWJlLmMKKysrIGIvc3JjL2Jpbi9wc3FsL2Rlc2NyaWJlLmMKQEAgLTMwNzMsMTcgKzMw NzMsMzQgQEAgZGVzY3JpYmVPbmVUYWJsZURldGFpbHMoY29uc3QgY2hhciAqc2NoZW1hbmFtZSwK IAkJCQkJCQkJICAiICAgICAgICAgIFdIRVJFIGF0dHJlbGlkID0gcHIucHJyZWxpZCBBTkQgYXR0 bnVtID0gcHJhdHRyc1tzXSlcbiIKIAkJCQkJCQkJICAiICAgICAgICBFTFNFIE5VTEwgRU5EKSAi CiAJCQkJCQkJCSAgIkZST00gcGdfY2F0YWxvZy5wZ19wdWJsaWNhdGlvbiBwXG4iCi0JCQkJCQkJ CSAgIiAgICAgSk9JTiBwZ19jYXRhbG9nLnBnX3B1YmxpY2F0aW9uX3JlbCBwciBPTiBwLm9pZCA9 IHByLnBycHViaWRcbiIKLQkJCQkJCQkJICAiICAgICBKT0lOIHBnX2NhdGFsb2cucGdfY2xhc3Mg YyBPTiBjLm9pZCA9IHByLnBycmVsaWRcbiIKLQkJCQkJCQkJICAiV0hFUkUgcHIucHJyZWxpZCA9 ICclcydcbiIKKwkJCQkJCQkJICAiCQlKT0lOIHBnX2NhdGFsb2cucGdfcHVibGljYXRpb25fcmVs IHByIE9OIHAub2lkID0gcHIucHJwdWJpZFxuIgorCQkJCQkJCQkgICIJCUpPSU4gcGdfY2F0YWxv Zy5wZ19jbGFzcyBjIE9OIGMub2lkID0gcHIucHJyZWxpZFxuIgorCQkJCQkJCQkgICJXSEVSRSBw ci5wcnJlbGlkID0gJyVzJ1xuIiwKKwkJCQkJCQkJICBvaWQsIG9pZCwgb2lkKTsKKworCQkJCWlm IChwc2V0LnN2ZXJzaW9uID49IDE5MDAwMCkKKwkJCQkJYXBwZW5kUFFFeHBCdWZmZXJTdHIoJmJ1 ZiwgIiBBTkQgTk9UIHByLnByZXhjZXB0XG4iKTsKKworCQkJCWFwcGVuZFBRRXhwQnVmZmVyKCZi dWYsCiAJCQkJCQkJCSAgIlVOSU9OXG4iCiAJCQkJCQkJCSAgIlNFTEVDVCBwdWJuYW1lXG4iCi0J CQkJCQkJCSAgIiAgICAgLCBOVUxMXG4iCi0JCQkJCQkJCSAgIiAgICAgLCBOVUxMXG4iCisJCQkJ CQkJCSAgIgkJLCBOVUxMXG4iCisJCQkJCQkJCSAgIgkJLCBOVUxMXG4iCiAJCQkJCQkJCSAgIkZS T00gcGdfY2F0YWxvZy5wZ19wdWJsaWNhdGlvbiBwXG4iCi0JCQkJCQkJCSAgIldIRVJFIHAucHVi YWxsdGFibGVzIEFORCBwZ19jYXRhbG9nLnBnX3JlbGF0aW9uX2lzX3B1Ymxpc2hhYmxlKCclcycp XG4iCi0JCQkJCQkJCSAgIk9SREVSIEJZIDE7IiwKLQkJCQkJCQkJICBvaWQsIG9pZCwgb2lkLCBv aWQpOworCQkJCQkJCQkgICJXSEVSRSBwLnB1YmFsbHRhYmxlcyBBTkQgcGdfY2F0YWxvZy5wZ19y ZWxhdGlvbl9pc19wdWJsaXNoYWJsZSgnJXMnKVxuIiwKKwkJCQkJCQkJICBvaWQpOworCisJCQkJ aWYgKHBzZXQuc3ZlcnNpb24gPj0gMTkwMDAwKQorCQkJCQlhcHBlbmRQUUV4cEJ1ZmZlcigmYnVm LAorCQkJCQkJCQkJICAiICAgICBBTkQgTk9UIEVYSVNUUyAoXG4iCisJCQkJCQkJCQkgICIJCVNF TEVDVCAxXG4iCisJCQkJCQkJCQkgICIJCUZST00gcGdfY2F0YWxvZy5wZ19wdWJsaWNhdGlvbl9y ZWwgcHJcbiIKKwkJCQkJCQkJCSAgIgkJSk9JTiBwZ19jYXRhbG9nLnBnX2NsYXNzIHBjXG4iCisJ CQkJCQkJCQkgICIJCU9OIHByLnBycmVsaWQgPSBwYy5vaWRcbiIKKwkJCQkJCQkJCSAgIgkJV0hF UkUgcHIucHJyZWxpZCA9ICclcycgQU5EIHByLnBycHViaWQgPSBwLm9pZClcbiIsCisJCQkJCQkJ CQkgIG9pZCk7CisKKwkJCQlhcHBlbmRQUUV4cEJ1ZmZlclN0cigmYnVmLCAiT1JERVIgQlkgMTsi KTsKIAkJCX0KIAkJCWVsc2UKIAkJCXsKQEAgLTMxMzQsNiArMzE1MSwzNSBAQCBkZXNjcmliZU9u ZVRhYmxlRGV0YWlscyhjb25zdCBjaGFyICpzY2hlbWFuYW1lLAogCQkJUFFjbGVhcihyZXN1bHQp OwogCQl9CiAKKwkJLyogUHJpbnQgcHVibGljYXRpb24gdGhlIHJlbGF0aW9uIGlzIGV4Y2x1ZGVk IGV4cGxpY2l0bHkgKi8KKwkJaWYgKHBzZXQuc3ZlcnNpb24gPj0gMTkwMDAwKQorCQl7CisJCQlw cmludGZQUUV4cEJ1ZmZlcigmYnVmLAorCQkJCQkJCSAgIlNFTEVDVCBwdWJuYW1lXG4iCisJCQkJ CQkJICAiRlJPTSBwZ19jYXRhbG9nLnBnX3B1YmxpY2F0aW9uIHBcbiIKKwkJCQkJCQkgICJKT0lO IHBnX2NhdGFsb2cucGdfcHVibGljYXRpb25fcmVsIHByIE9OIHAub2lkID0gcHIucHJwdWJpZFxu IgorCQkJCQkJCSAgIldIRVJFIHByLnBycmVsaWQgPSAnJXMnXG4gQU5EIHByLnByZXhjZXB0XG4i CisJCQkJCQkJICAiT1JERVIgQlkgMTsiLCBvaWQpOworCisJCQlyZXN1bHQgPSBQU1FMZXhlYyhi dWYuZGF0YSk7CisJCQlpZiAoIXJlc3VsdCkKKwkJCQlnb3RvIGVycm9yX3JldHVybjsKKwkJCWVs c2UKKwkJCQl0dXBsZXMgPSBQUW50dXBsZXMocmVzdWx0KTsKKworCQkJaWYgKHR1cGxlcyA+IDAp CisJCQkJcHJpbnRUYWJsZUFkZEZvb3RlcigmY29udCwgXygiRXhjZXB0IFB1YmxpY2F0aW9uczoi KSk7CisKKwkJCS8qIE1pZ2h0IGJlIGFuIGVtcHR5IHNldCAtIHRoYXQncyBvayAqLworCQkJZm9y IChpID0gMDsgaSA8IHR1cGxlczsgaSsrKQorCQkJeworCQkJCXByaW50ZlBRRXhwQnVmZmVyKCZi dWYsICIgICAgXCIlc1wiIiwgUFFnZXR2YWx1ZShyZXN1bHQsIGksIDApKTsKKworCQkJCXByaW50 VGFibGVBZGRGb290ZXIoJmNvbnQsIGJ1Zi5kYXRhKTsKKwkJCX0KKwkJCVBRY2xlYXIocmVzdWx0 KTsKKwkJfQorCiAJCS8qCiAJCSAqIElmIHZlcmJvc2UsIHByaW50IE5PVCBOVUxMIGNvbnN0cmFp bnRzLgogCQkgKi8KQEAgLTY3NTMsOCArNjc5OSwxMiBAQCBkZXNjcmliZVB1YmxpY2F0aW9ucyhj b25zdCBjaGFyICpwYXR0ZXJuKQogCQkJCQkJCSAgIiAgICAgcGdfY2F0YWxvZy5wZ19wdWJsaWNh dGlvbl9yZWwgcHJcbiIKIAkJCQkJCQkgICJXSEVSRSBjLnJlbG5hbWVzcGFjZSA9IG4ub2lkXG4i CiAJCQkJCQkJICAiICBBTkQgYy5vaWQgPSBwci5wcnJlbGlkXG4iCi0JCQkJCQkJICAiICBBTkQg cHIucHJwdWJpZCA9ICclcydcbiIKLQkJCQkJCQkgICJPUkRFUiBCWSAxLDIiLCBwdWJpZCk7CisJ CQkJCQkJICAiICBBTkQgcHIucHJwdWJpZCA9ICclcydcbiIsIHB1YmlkKTsKKworCQkJaWYgKHBz ZXQuc3ZlcnNpb24gPj0gMTkwMDAwKQorCQkJCWFwcGVuZFBRRXhwQnVmZmVyKCZidWYsICIgIEFO RCBOT1QgcHIucHJleGNlcHRcbiIpOworCisJCQlhcHBlbmRQUUV4cEJ1ZmZlcigmYnVmLCAiT1JE RVIgQlkgMSwyIik7CiAJCQlpZiAoIWFkZEZvb3RlclRvUHVibGljYXRpb25EZXNjKCZidWYsIF8o IlRhYmxlczoiKSwgZmFsc2UsICZjb250KSkKIAkJCQlnb3RvIGVycm9yX3JldHVybjsKIApAQCAt Njc3Miw2ICs2ODIyLDIzIEBAIGRlc2NyaWJlUHVibGljYXRpb25zKGNvbnN0IGNoYXIgKnBhdHRl cm4pCiAJCQkJCWdvdG8gZXJyb3JfcmV0dXJuOwogCQkJfQogCQl9CisJCWVsc2UKKwkJeworCQkJ aWYgKHBzZXQuc3ZlcnNpb24gPj0gMTkwMDAwKQorCQkJeworCQkJCS8qIEdldCB0aGUgZXhjbHVk ZWQgdGFibGVzIGZvciB0aGUgc3BlY2lmaWVkIHB1YmxpY2F0aW9uICovCisJCQkJcHJpbnRmUFFF eHBCdWZmZXIoJmJ1ZiwKKwkJCQkJCQkJICAiU0VMRUNUIGNvbmNhdChjLnJlbG5hbWVzcGFjZTo6 cmVnbmFtZXNwYWNlLCAnLicsIGMucmVsbmFtZSlcbiIKKwkJCQkJCQkJICAiRlJPTSBwZ19jYXRh bG9nLnBnX2NsYXNzIGNcbiIKKwkJCQkJCQkJICAiICAgICBKT0lOIHBnX2NhdGFsb2cucGdfcHVi bGljYXRpb25fcmVsIHByIE9OIGMub2lkID0gcHIucHJyZWxpZFxuIgorCQkJCQkJCQkgICJXSEVS RSBwci5wcnB1YmlkID0gJyVzJ1xuIgorCQkJCQkJCQkgICIgIEFORCBwci5wcmV4Y2VwdFxuIgor CQkJCQkJCQkgICJPUkRFUiBCWSAxIiwgcHViaWQpOworCQkJCWlmICghYWRkRm9vdGVyVG9QdWJs aWNhdGlvbkRlc2MoJmJ1ZiwgXygiRXhjZXB0IHRhYmxlczoiKSwKKwkJCQkJCQkJCQkJCXRydWUs ICZjb250KSkKKwkJCQkJZ290byBlcnJvcl9yZXR1cm47CisJCQl9CisJCX0KIAogCQlwcmludFRh YmxlKCZjb250LCBwc2V0LnF1ZXJ5Rm91dCwgZmFsc2UsIHBzZXQubG9nZmlsZSk7CiAJCXByaW50 VGFibGVDbGVhbnVwKCZjb250KTsKZGlmZiAtLWdpdCBhL3NyYy9iaW4vcHNxbC90YWItY29tcGxl dGUuaW4uYyBiL3NyYy9iaW4vcHNxbC90YWItY29tcGxldGUuaW4uYwppbmRleCBiMWZmNmY2Y2Q5 NC4uYWI1Yzk5OTFiNTEgMTAwNjQ0Ci0tLSBhL3NyYy9iaW4vcHNxbC90YWItY29tcGxldGUuaW4u YworKysgYi9zcmMvYmluL3BzcWwvdGFiLWNvbXBsZXRlLmluLmMKQEAgLTM2MzcsNyArMzYzNywx NyBAQCBtYXRjaF9wcmV2aW91c193b3JkcyhpbnQgcGF0dGVybl9pZCwKIAllbHNlIGlmIChNYXRj aGVzKCJDUkVBVEUiLCAiUFVCTElDQVRJT04iLCBNYXRjaEFueSwgIkZPUiIsICJBTEwiKSkKIAkJ Q09NUExFVEVfV0lUSCgiVEFCTEVTIiwgIlNFUVVFTkNFUyIpOwogCWVsc2UgaWYgKE1hdGNoZXMo IkNSRUFURSIsICJQVUJMSUNBVElPTiIsIE1hdGNoQW55LCAiRk9SIiwgIkFMTCIsICJUQUJMRVMi KSkKLQkJQ09NUExFVEVfV0lUSCgiV0lUSCAoIik7CisJCUNPTVBMRVRFX1dJVEgoIkVYQ0VQVCBU QUJMRSAoIiwgIldJVEggKCIpOworCWVsc2UgaWYgKE1hdGNoZXMoIkNSRUFURSIsICJQVUJMSUNB VElPTiIsIE1hdGNoQW55LCAiRk9SIiwgIkFMTCIsICJUQUJMRVMiLCAiRVhDRVBUIikpCisJCUNP TVBMRVRFX1dJVEgoIlRBQkxFICgiKTsKKwllbHNlIGlmIChNYXRjaGVzKCJDUkVBVEUiLCAiUFVC TElDQVRJT04iLCBNYXRjaEFueSwgIkZPUiIsICJBTEwiLCAiVEFCTEVTIiwgIkVYQ0VQVCIsICJU QUJMRSIpKQorCQlDT01QTEVURV9XSVRIKCIoIik7CisJZWxzZSBpZiAoTWF0Y2hlcygiQ1JFQVRF IiwgIlBVQkxJQ0FUSU9OIiwgTWF0Y2hBbnksICJGT1IiLCAiQUxMIiwgIlRBQkxFUyIsICJFWENF UFQiLCAiVEFCTEUiLCAiKCIpKQorCQlDT01QTEVURV9XSVRIX1NDSEVNQV9RVUVSWShRdWVyeV9m b3JfbGlzdF9vZl90YWJsZXMpOworCWVsc2UgaWYgKE1hdGNoZXMoIkNSRUFURSIsICJQVUJMSUNB VElPTiIsIE1hdGNoQW55LCAiRk9SIiwgIkFMTCIsICJUQUJMRVMiLCAiRVhDRVBUIiwgIlRBQkxF IiwgIigiLCBNYXRjaEFueU4pICYmIGVuZHNfd2l0aChwcmV2X3dkLCAnLCcpKQorCQlDT01QTEVU RV9XSVRIX1NDSEVNQV9RVUVSWShRdWVyeV9mb3JfbGlzdF9vZl90YWJsZXMpOworCWVsc2UgaWYg KE1hdGNoZXMoIkNSRUFURSIsICJQVUJMSUNBVElPTiIsIE1hdGNoQW55LCAiRk9SIiwgIkFMTCIs ICJUQUJMRVMiLCAiRVhDRVBUIiwgIlRBQkxFIiwgIigiLCBNYXRjaEFueU4pICYmICFlbmRzX3dp dGgocHJldl93ZCwgJywnKSkKKwkJQ09NUExFVEVfV0lUSCgiKSIpOwogCWVsc2UgaWYgKE1hdGNo ZXMoIkNSRUFURSIsICJQVUJMSUNBVElPTiIsIE1hdGNoQW55LCAiRk9SIiwgIlRBQkxFUyIpKQog CQlDT01QTEVURV9XSVRIKCJJTiBTQ0hFTUEiKTsKIAllbHNlIGlmIChNYXRjaGVzKCJDUkVBVEUi LCAiUFVCTElDQVRJT04iLCBNYXRjaEFueSwgIkZPUiIsICJUQUJMRSIsIE1hdGNoQW55KSAmJiAh ZW5kc193aXRoKHByZXZfd2QsICcsJykpCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9jYXRhbG9n L3BnX3B1YmxpY2F0aW9uLmggYi9zcmMvaW5jbHVkZS9jYXRhbG9nL3BnX3B1YmxpY2F0aW9uLmgK aW5kZXggMjJmNDhiYjg5NzUuLjc2Y2UyZGU0NzczIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9j YXRhbG9nL3BnX3B1YmxpY2F0aW9uLmgKKysrIGIvc3JjL2luY2x1ZGUvY2F0YWxvZy9wZ19wdWJs aWNhdGlvbi5oCkBAIC0xNDYsMTQgKzE0NiwxNiBAQCB0eXBlZGVmIHN0cnVjdCBQdWJsaWNhdGlv blJlbEluZm8KIAlSZWxhdGlvbglyZWxhdGlvbjsKIAlOb2RlCSAgICp3aGVyZUNsYXVzZTsKIAlM aXN0CSAgICpjb2x1bW5zOworCWJvb2wJCWV4Y2VwdDsKIH0gUHVibGljYXRpb25SZWxJbmZvOwog CiBleHRlcm4gUHVibGljYXRpb24gKkdldFB1YmxpY2F0aW9uKE9pZCBwdWJpZCk7CiBleHRlcm4g UHVibGljYXRpb24gKkdldFB1YmxpY2F0aW9uQnlOYW1lKGNvbnN0IGNoYXIgKnB1Ym5hbWUsIGJv b2wgbWlzc2luZ19vayk7Ci1leHRlcm4gTGlzdCAqR2V0UmVsYXRpb25QdWJsaWNhdGlvbnMoT2lk IHJlbGlkKTsKK2V4dGVybiBib29sIEdldFJlbGF0aW9uUHVibGljYXRpb25zKE9pZCByZWxpZCwg TGlzdCAqKnB1YmlkcywgTGlzdCAqKmV4Y2VwdF9wdWJpZHMpOwogCiAvKi0tLS0tLS0tLQotICog RXhwZWN0ZWQgdmFsdWVzIGZvciBwdWJfcGFydG9wdCBwYXJhbWV0ZXIgb2YgR2V0UHVibGljYXRp b25SZWxhdGlvbnMoKSwKKyAqIEV4cGVjdGVkIHZhbHVlcyBmb3IgcHViX3BhcnRvcHQgcGFyYW1l dGVyIG9mCisgKiBHZXRQdWJsaWNhdGlvbkluY2x1ZGVkUmVsYXRpb25zKCksIGFuZCBHZXRQdWJs aWNhdGlvbkV4Y2x1ZGVkUmVsYXRpb25zKCksCiAgKiB3aGljaCBhbGxvd3MgY2FsbGVycyB0byBz cGVjaWZ5IHdoaWNoIHBhcnRpdGlvbnMgb2YgcGFydGl0aW9uZWQgdGFibGVzCiAgKiBtZW50aW9u ZWQgaW4gdGhlIHB1YmxpY2F0aW9uIHRoZXkgZXhwZWN0IHRvIHNlZS4KICAqCkBAIC0xNjgsOSAr MTcwLDEyIEBAIHR5cGVkZWYgZW51bSBQdWJsaWNhdGlvblBhcnRPcHQKIAlQVUJMSUNBVElPTl9Q QVJUX0FMTCwKIH0gUHVibGljYXRpb25QYXJ0T3B0OwogCi1leHRlcm4gTGlzdCAqR2V0UHVibGlj YXRpb25SZWxhdGlvbnMoT2lkIHB1YmlkLCBQdWJsaWNhdGlvblBhcnRPcHQgcHViX3BhcnRvcHQp OworZXh0ZXJuIExpc3QgKkdldFB1YmxpY2F0aW9uSW5jbHVkZWRSZWxhdGlvbnMoT2lkIHB1Ymlk LAorCQkJCQkJCQkJCQkgUHVibGljYXRpb25QYXJ0T3B0IHB1Yl9wYXJ0b3B0KTsKK2V4dGVybiBM aXN0ICpHZXRQdWJsaWNhdGlvbkV4Y2x1ZGVkUmVsYXRpb25zKE9pZCBwdWJpZCwKKwkJCQkJCQkJ CQkJIFB1YmxpY2F0aW9uUGFydE9wdCBwdWJfcGFydG9wdCk7CiBleHRlcm4gTGlzdCAqR2V0QWxs VGFibGVzUHVibGljYXRpb25zKHZvaWQpOwotZXh0ZXJuIExpc3QgKkdldEFsbFB1YmxpY2F0aW9u UmVsYXRpb25zKGNoYXIgcmVsa2luZCwgYm9vbCBwdWJ2aWFyb290KTsKK2V4dGVybiBMaXN0ICpH ZXRBbGxQdWJsaWNhdGlvblJlbGF0aW9ucyhPaWQgcHViaWQsIGNoYXIgcmVsa2luZCwgYm9vbCBw dWJ2aWFyb290KTsKIGV4dGVybiBMaXN0ICpHZXRQdWJsaWNhdGlvblNjaGVtYXMoT2lkIHB1Ymlk KTsKIGV4dGVybiBMaXN0ICpHZXRTY2hlbWFQdWJsaWNhdGlvbnMoT2lkIHNjaGVtYWlkKTsKIGV4 dGVybiBMaXN0ICpHZXRTY2hlbWFQdWJsaWNhdGlvblJlbGF0aW9ucyhPaWQgc2NoZW1haWQsCkBA IC0xODEsNyArMTg2LDcgQEAgZXh0ZXJuIExpc3QgKkdldFB1YlBhcnRpdGlvbk9wdGlvblJlbGF0 aW9ucyhMaXN0ICpyZXN1bHQsCiAJCQkJCQkJCQkJCVB1YmxpY2F0aW9uUGFydE9wdCBwdWJfcGFy dG9wdCwKIAkJCQkJCQkJCQkJT2lkIHJlbGlkKTsKIGV4dGVybiBPaWQJR2V0VG9wTW9zdEFuY2Vz dG9ySW5QdWJsaWNhdGlvbihPaWQgcHVib2lkLCBMaXN0ICphbmNlc3RvcnMsCi0JCQkJCQkJCQkJ CWludCAqYW5jZXN0b3JfbGV2ZWwpOworCQkJCQkJCQkJCQlpbnQgKmFuY2VzdG9yX2xldmVsLCBi b29sIHB1YmFsbHRhYmxlcyk7CiAKIGV4dGVybiBib29sIGlzX3B1Ymxpc2hhYmxlX3JlbGF0aW9u KFJlbGF0aW9uIHJlbCk7CiBleHRlcm4gYm9vbCBpc19zY2hlbWFfcHVibGljYXRpb24oT2lkIHB1 YmlkKTsKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NhdGFsb2cvcGdfcHVibGljYXRpb25fcmVs LmggYi9zcmMvaW5jbHVkZS9jYXRhbG9nL3BnX3B1YmxpY2F0aW9uX3JlbC5oCmluZGV4IDkyY2Mz NmRmZGY2Li5lN2Q3ZjNiYTg1YyAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvY2F0YWxvZy9wZ19w dWJsaWNhdGlvbl9yZWwuaAorKysgYi9zcmMvaW5jbHVkZS9jYXRhbG9nL3BnX3B1YmxpY2F0aW9u X3JlbC5oCkBAIC0zMSw2ICszMSw3IEBAIENBVEFMT0cocGdfcHVibGljYXRpb25fcmVsLDYxMDYs UHVibGljYXRpb25SZWxSZWxhdGlvbklkKQogCU9pZAkJCW9pZDsJCQkvKiBvaWQgKi8KIAlPaWQJ CQlwcnB1YmlkIEJLSV9MT09LVVAocGdfcHVibGljYXRpb24pOyAvKiBPaWQgb2YgdGhlIHB1Ymxp Y2F0aW9uICovCiAJT2lkCQkJcHJyZWxpZCBCS0lfTE9PS1VQKHBnX2NsYXNzKTsJLyogT2lkIG9m IHRoZSByZWxhdGlvbiAqLworCWJvb2wJCXByZXhjZXB0IEJLSV9ERUZBVUxUKGYpOwkvKiBleGNs dWRlIHRoZSByZWxhdGlvbiAqLwogCiAjaWZkZWYJQ0FUQUxPR19WQVJMRU4JCQkvKiB2YXJpYWJs ZS1sZW5ndGggZmllbGRzIHN0YXJ0IGhlcmUgKi8KIAlwZ19ub2RlX3RyZWUgcHJxdWFsOwkJLyog cXVhbGlmaWNhdGlvbnMgKi8KZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3B1Ymxp Y2F0aW9uY21kcy5oIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvcHVibGljYXRpb25jbWRzLmgKaW5k ZXggZjkwY2YxZWY4OTYuLjRhMTcwOTk0Zjc2IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jb21t YW5kcy9wdWJsaWNhdGlvbmNtZHMuaAorKysgYi9zcmMvaW5jbHVkZS9jb21tYW5kcy9wdWJsaWNh dGlvbmNtZHMuaApAQCAtMzIsMTAgKzMyLDExIEBAIGV4dGVybiBPYmplY3RBZGRyZXNzIEFsdGVy UHVibGljYXRpb25Pd25lcihjb25zdCBjaGFyICpuYW1lLCBPaWQgbmV3T3duZXJJZCk7CiBleHRl cm4gdm9pZCBBbHRlclB1YmxpY2F0aW9uT3duZXJfb2lkKE9pZCBwdWJpZCwgT2lkIG5ld093bmVy SWQpOwogZXh0ZXJuIHZvaWQgSW52YWxpZGF0ZVB1YmxpY2F0aW9uUmVscyhMaXN0ICpyZWxpZHMp OwogZXh0ZXJuIGJvb2wgcHViX3JmX2NvbnRhaW5zX2ludmFsaWRfY29sdW1uKE9pZCBwdWJpZCwg UmVsYXRpb24gcmVsYXRpb24sCi0JCQkJCQkJCQkJICAgTGlzdCAqYW5jZXN0b3JzLCBib29sIHB1 YnZpYXJvb3QpOworCQkJCQkJCQkJCSAgIExpc3QgKmFuY2VzdG9ycywgYm9vbCBwdWJ2aWFyb290 LAorCQkJCQkJCQkJCSAgIGJvb2wgcHViYWxsdGFibGVzKTsKIGV4dGVybiBib29sIHB1Yl9jb250 YWluc19pbnZhbGlkX2NvbHVtbihPaWQgcHViaWQsIFJlbGF0aW9uIHJlbGF0aW9uLAotCQkJCQkJ CQkJCUxpc3QgKmFuY2VzdG9ycywgYm9vbCBwdWJ2aWFyb290LAotCQkJCQkJCQkJCWNoYXIgcHVi Z2VuY29sc190eXBlLAorCQkJCQkJCQkJCUxpc3QgKmFuY2VzdG9ycywgYm9vbCBwdWJhbGx0YWJs ZXMsCisJCQkJCQkJCQkJYm9vbCBwdWJ2aWFyb290LCBjaGFyIHB1YmdlbmNvbHNfdHlwZSwKIAkJ CQkJCQkJCQlib29sICppbnZhbGlkX2NvbHVtbl9saXN0LAogCQkJCQkJCQkJCWJvb2wgKmludmFs aWRfZ2VuX2NvbCk7CiBleHRlcm4gdm9pZCBJbnZhbGlkYXRlUHViUmVsU3luY0NhY2hlKE9pZCBw dWJpZCwgYm9vbCBwdWJhbGx0YWJsZXMpOwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvbm9kZXMv cGFyc2Vub2Rlcy5oIGIvc3JjL2luY2x1ZGUvbm9kZXMvcGFyc2Vub2Rlcy5oCmluZGV4IGJjN2Fk YmE0YTBmLi4yZDgyOTU2M2NhZiAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvbm9kZXMvcGFyc2Vu b2Rlcy5oCisrKyBiL3NyYy9pbmNsdWRlL25vZGVzL3BhcnNlbm9kZXMuaApAQCAtNDI5OSw2ICs0 Mjk5LDcgQEAgdHlwZWRlZiBzdHJ1Y3QgUHVibGljYXRpb25UYWJsZQogCVJhbmdlVmFyICAgKnJl bGF0aW9uOwkJLyogcmVsYXRpb24gdG8gYmUgcHVibGlzaGVkICovCiAJTm9kZQkgICAqd2hlcmVD bGF1c2U7CS8qIHF1YWxpZmljYXRpb25zICovCiAJTGlzdAkgICAqY29sdW1uczsJCS8qIExpc3Qg b2YgY29sdW1ucyBpbiBhIHB1YmxpY2F0aW9uIHRhYmxlICovCisJYm9vbAkJZXhjZXB0OwkJCS8q IGV4Y2x1ZGUgdGhlIHJlbGF0aW9uICovCiB9IFB1YmxpY2F0aW9uVGFibGU7CiAKIC8qCkBAIC00 MzA3LDYgKzQzMDgsNyBAQCB0eXBlZGVmIHN0cnVjdCBQdWJsaWNhdGlvblRhYmxlCiB0eXBlZGVm IGVudW0gUHVibGljYXRpb25PYmpTcGVjVHlwZQogewogCVBVQkxJQ0FUSU9OT0JKX1RBQkxFLAkJ LyogQSB0YWJsZSAqLworCVBVQkxJQ0FUSU9OT0JKX0VYQ0VQVF9UQUJMRSwJLyogQSB0YWJsZSB0 byBiZSBleGNsdWRlZCAqLwogCVBVQkxJQ0FUSU9OT0JKX1RBQkxFU19JTl9TQ0hFTUEsCS8qIEFs bCB0YWJsZXMgaW4gc2NoZW1hICovCiAJUFVCTElDQVRJT05PQkpfVEFCTEVTX0lOX0NVUl9TQ0hF TUEsCS8qIEFsbCB0YWJsZXMgaW4gZmlyc3QgZWxlbWVudCBvZgogCQkJCQkJCQkJCQkgKiBzZWFy Y2hfcGF0aCAqLwpAQCAtNDMzNSw2ICs0MzM3LDcgQEAgdHlwZWRlZiBzdHJ1Y3QgUHVibGljYXRp b25BbGxPYmpTcGVjCiB7CiAJTm9kZVRhZwkJdHlwZTsKIAlQdWJsaWNhdGlvbkFsbE9ialR5cGUg cHVib2JqdHlwZTsJLyogdHlwZSBvZiB0aGlzIHB1YmxpY2F0aW9uIG9iamVjdCAqLworCUxpc3QJ ICAgKmV4Y2VwdF9vYmplY3RzOyAvKiBMaXN0IG9mIHB1YmxpY2F0aW9uIG9iamVjdCB0byBiZSBl eGNsdWRlZCAqLwogCVBhcnNlTG9jCWxvY2F0aW9uOwkJLyogdG9rZW4gbG9jYXRpb24sIG9yIC0x IGlmIHVua25vd24gKi8KIH0gUHVibGljYXRpb25BbGxPYmpTcGVjOwogCmRpZmYgLS1naXQgYS9z cmMvdGVzdC9yZWdyZXNzL2V4cGVjdGVkL3B1YmxpY2F0aW9uLm91dCBiL3NyYy90ZXN0L3JlZ3Jl c3MvZXhwZWN0ZWQvcHVibGljYXRpb24ub3V0CmluZGV4IGU3MmQxMzA4OTY3Li4zMWEzZDZmNDcx ZCAxMDA2NDQKLS0tIGEvc3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9wdWJsaWNhdGlvbi5vdXQK KysrIGIvc3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9wdWJsaWNhdGlvbi5vdXQKQEAgLTIxMywx MyArMjEzLDQyIEBAIE5vdC1udWxsIGNvbnN0cmFpbnRzOgogIHJlZ3Jlc3NfcHVibGljYXRpb25f dXNlciB8IHQgICAgICAgICAgfCBmICAgICAgICAgICAgIHwgdCAgICAgICB8IHQgICAgICAgfCBm ICAgICAgIHwgZiAgICAgICAgIHwgbm9uZSAgICAgICAgICAgICAgfCBmCiAoMSByb3cpCiAKK1NF VCBjbGllbnRfbWluX21lc3NhZ2VzID0gJ0VSUk9SJzsKKy0tIEV4Y2x1ZGUgdGFibGVzIHVzaW5n IEZPUiBBTEwgVEFCTEVTIEVYQ0VQVCBUQUJMRSAodGFibGVsaXN0KQorQ1JFQVRFIFBVQkxJQ0FU SU9OIHRlc3RwdWJfZm9yYWxsdGFibGVzX2V4Y2VwdHRhYmxlIEZPUiBBTEwgVEFCTEVTIEVYQ0VQ VCBUQUJMRSAodGVzdHB1Yl90YmwxLCB0ZXN0cHViX3RibDIpOworLS0gRXhjbHVkZSB0YWJsZXMg dXNpbmcgRk9SIEFMTCBUQUJMRVMgRVhDRVBUICh0YWJsZWxpc3QpCitDUkVBVEUgUFVCTElDQVRJ T04gdGVzdHB1Yl9mb3JhbGx0YWJsZXNfZXhjZXB0dGFibGUxIEZPUiBBTEwgVEFCTEVTIEVYQ0VQ VCAodGVzdHB1Yl90YmwxKTsKK1JFU0VUIGNsaWVudF9taW5fbWVzc2FnZXM7CitcZFJwKyB0ZXN0 cHViX2ZvcmFsbHRhYmxlc19leGNlcHR0YWJsZQorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgUHVibGljYXRpb24gdGVzdHB1Yl9mb3JhbGx0YWJsZXNfZXhjZXB0dGFi bGUKKyAgICAgICAgICBPd25lciAgICAgICAgICAgfCBBbGwgdGFibGVzIHwgQWxsIHNlcXVlbmNl cyB8IEluc2VydHMgfCBVcGRhdGVzIHwgRGVsZXRlcyB8IFRydW5jYXRlcyB8IEdlbmVyYXRlZCBj b2x1bW5zIHwgVmlhIHJvb3QgCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0t LS0rLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0t LS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLQorIHJlZ3Jlc3NfcHVibGljYXRpb25f dXNlciB8IHQgICAgICAgICAgfCBmICAgICAgICAgICAgIHwgdCAgICAgICB8IHQgICAgICAgfCB0 ICAgICAgIHwgdCAgICAgICAgIHwgbm9uZSAgICAgICAgICAgICAgfCBmCitFeGNlcHQgdGFibGVz OgorICAgICJwdWJsaWMudGVzdHB1Yl90YmwxIgorICAgICJwdWJsaWMudGVzdHB1Yl90YmwyIgor CitcZFJwKyB0ZXN0cHViX2ZvcmFsbHRhYmxlc19leGNlcHR0YWJsZTEKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgUHVibGljYXRpb24gdGVzdHB1Yl9mb3JhbGx0YWJs ZXNfZXhjZXB0dGFibGUxCisgICAgICAgICAgT3duZXIgICAgICAgICAgIHwgQWxsIHRhYmxlcyB8 IEFsbCBzZXF1ZW5jZXMgfCBJbnNlcnRzIHwgVXBkYXRlcyB8IERlbGV0ZXMgfCBUcnVuY2F0ZXMg fCBHZW5lcmF0ZWQgY29sdW1ucyB8IFZpYSByb290IAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0rLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0t LS0tLSstLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0KKyByZWdyZXNz X3B1YmxpY2F0aW9uX3VzZXIgfCB0ICAgICAgICAgIHwgZiAgICAgICAgICAgICB8IHQgICAgICAg fCB0ICAgICAgIHwgdCAgICAgICB8IHQgICAgICAgICB8IG5vbmUgICAgICAgICAgICAgIHwgZgor RXhjZXB0IHRhYmxlczoKKyAgICAicHVibGljLnRlc3RwdWJfdGJsMSIKKwogRFJPUCBUQUJMRSB0 ZXN0cHViX3RibDI7Ci1EUk9QIFBVQkxJQ0FUSU9OIHRlc3RwdWJfZm9yYWxsdGFibGVzLCB0ZXN0 cHViX2ZvcnRhYmxlLCB0ZXN0cHViX2ZvcnNjaGVtYSwgdGVzdHB1Yl9mb3JfdGJsX3NjaGVtYTsK LUNSRUFURSBUQUJMRSB0ZXN0cHViX3RibDMgKGEgaW50KTsKLUNSRUFURSBUQUJMRSB0ZXN0cHVi X3RibDNhIChiIHRleHQpIElOSEVSSVRTICh0ZXN0cHViX3RibDMpOworRFJPUCBQVUJMSUNBVElP TiB0ZXN0cHViX2ZvcmFsbHRhYmxlcywgdGVzdHB1Yl9mb3J0YWJsZSwgdGVzdHB1Yl9mb3JzY2hl bWEsIHRlc3RwdWJfZm9yX3RibF9zY2hlbWEsIHRlc3RwdWJfZm9yYWxsdGFibGVzX2V4Y2VwdHRh YmxlLCB0ZXN0cHViX2ZvcmFsbHRhYmxlc19leGNlcHR0YWJsZTE7CitDUkVBVEUgVEFCTEUgdGVz dHB1Yl90YmxfcGFyZW50IChhIGludCk7CitDUkVBVEUgVEFCTEUgdGVzdHB1Yl90YmxfY2hpbGQg KGIgdGV4dCkgSU5IRVJJVFMgKHRlc3RwdWJfdGJsX3BhcmVudCk7CiBTRVQgY2xpZW50X21pbl9t ZXNzYWdlcyA9ICdFUlJPUic7Ci1DUkVBVEUgUFVCTElDQVRJT04gdGVzdHB1YjMgRk9SIFRBQkxF IHRlc3RwdWJfdGJsMzsKLUNSRUFURSBQVUJMSUNBVElPTiB0ZXN0cHViNCBGT1IgVEFCTEUgT05M WSB0ZXN0cHViX3RibDM7CitDUkVBVEUgUFVCTElDQVRJT04gdGVzdHB1YjMgRk9SIFRBQkxFIHRl c3RwdWJfdGJsX3BhcmVudDsKK0NSRUFURSBQVUJMSUNBVElPTiB0ZXN0cHViNCBGT1IgVEFCTEUg T05MWSB0ZXN0cHViX3RibF9wYXJlbnQ7CistLSBFeGNsdWRlIHBhcmVudCB0YWJsZSwgb21pdHRp bmcgYm90aCBvZiAnT05MWScgYW5kICcqJworQ1JFQVRFIFBVQkxJQ0FUSU9OIHRlc3RwdWI1IEZP UiBBTEwgVEFCTEVTIEVYQ0VQVCBUQUJMRSAodGVzdHB1Yl90YmxfcGFyZW50KTsKKy0tIEVYQ0VQ VCB3aXRoIGFzdGVyaXNrOiBleGNsdWRlIHRhYmxlIGFuZCBhbGwgZGVzY2VuZGFudHMKK0NSRUFU RSBQVUJMSUNBVElPTiB0ZXN0cHViNiBGT1IgQUxMIFRBQkxFUyBFWENFUFQgVEFCTEUgKHRlc3Rw dWJfdGJsX3BhcmVudCAqKTsKKy0tIEVYQ0VQVCB3aXRoIE9OTFk6IGV4Y2x1ZGUgdGFibGUgYnV0 IG5vdCBkZXNjZW5kYW50cworQ1JFQVRFIFBVQkxJQ0FUSU9OIHRlc3RwdWI3IEZPUiBBTEwgVEFC TEVTIEVYQ0VQVCBUQUJMRSAoT05MWSB0ZXN0cHViX3RibF9wYXJlbnQpOwogUkVTRVQgY2xpZW50 X21pbl9tZXNzYWdlczsKIFxkUnArIHRlc3RwdWIzCiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQdWJsaWNhdGlvbiB0ZXN0cHViMwpAQCAtMjI3 LDggKzI1Niw4IEBAIFJFU0VUIGNsaWVudF9taW5fbWVzc2FnZXM7CiAtLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLSstLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0t LS0rLS0tLS0tLS0tKy0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLQog IHJlZ3Jlc3NfcHVibGljYXRpb25fdXNlciB8IGYgICAgICAgICAgfCBmICAgICAgICAgICAgIHwg dCAgICAgICB8IHQgICAgICAgfCB0ICAgICAgIHwgdCAgICAgICAgIHwgbm9uZSAgICAgICAgICAg ICAgfCBmCiBUYWJsZXM6Ci0gICAgInB1YmxpYy50ZXN0cHViX3RibDMiCi0gICAgInB1YmxpYy50 ZXN0cHViX3RibDNhIgorICAgICJwdWJsaWMudGVzdHB1Yl90YmxfY2hpbGQiCisgICAgInB1Ymxp Yy50ZXN0cHViX3RibF9wYXJlbnQiCiAKIFxkUnArIHRlc3RwdWI0CiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQdWJsaWNhdGlvbiB0ZXN0cHVi NApAQCAtMjM2LDEwICsyNjUsMzYgQEAgVGFibGVzOgogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0rLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0t LS0tLSstLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0KICByZWdyZXNz X3B1YmxpY2F0aW9uX3VzZXIgfCBmICAgICAgICAgIHwgZiAgICAgICAgICAgICB8IHQgICAgICAg fCB0ICAgICAgIHwgdCAgICAgICB8IHQgICAgICAgICB8IG5vbmUgICAgICAgICAgICAgIHwgZgog VGFibGVzOgotICAgICJwdWJsaWMudGVzdHB1Yl90YmwzIgorICAgICJwdWJsaWMudGVzdHB1Yl90 YmxfcGFyZW50IgorCitcZFJwKyB0ZXN0cHViNQorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgUHVibGljYXRpb24gdGVzdHB1YjUKKyAgICAgICAg ICBPd25lciAgICAgICAgICAgfCBBbGwgdGFibGVzIHwgQWxsIHNlcXVlbmNlcyB8IEluc2VydHMg fCBVcGRhdGVzIHwgRGVsZXRlcyB8IFRydW5jYXRlcyB8IEdlbmVyYXRlZCBjb2x1bW5zIHwgVmlh IHJvb3QgCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0rLS0tLS0tLS0t LS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLS0tKy0tLS0tLS0t LS0tLS0tLS0tLS0rLS0tLS0tLS0tLQorIHJlZ3Jlc3NfcHVibGljYXRpb25fdXNlciB8IHQgICAg ICAgICAgfCBmICAgICAgICAgICAgIHwgdCAgICAgICB8IHQgICAgICAgfCB0ICAgICAgIHwgdCAg ICAgICAgIHwgbm9uZSAgICAgICAgICAgICAgfCBmCitFeGNlcHQgdGFibGVzOgorICAgICJwdWJs aWMudGVzdHB1Yl90YmxfY2hpbGQiCisgICAgInB1YmxpYy50ZXN0cHViX3RibF9wYXJlbnQiCisK K1xkUnArIHRlc3RwdWI2CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBQdWJsaWNhdGlvbiB0ZXN0cHViNgorICAgICAgICAgIE93bmVyICAgICAg ICAgICB8IEFsbCB0YWJsZXMgfCBBbGwgc2VxdWVuY2VzIHwgSW5zZXJ0cyB8IFVwZGF0ZXMgfCBE ZWxldGVzIHwgVHJ1bmNhdGVzIHwgR2VuZXJhdGVkIGNvbHVtbnMgfCBWaWEgcm9vdCAKKy0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0rLS0tLS0t LS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLSst LS0tLS0tLS0tCisgcmVncmVzc19wdWJsaWNhdGlvbl91c2VyIHwgdCAgICAgICAgICB8IGYgICAg ICAgICAgICAgfCB0ICAgICAgIHwgdCAgICAgICB8IHQgICAgICAgfCB0ICAgICAgICAgfCBub25l ICAgICAgICAgICAgICB8IGYKK0V4Y2VwdCB0YWJsZXM6CisgICAgInB1YmxpYy50ZXN0cHViX3Ri bF9jaGlsZCIKKyAgICAicHVibGljLnRlc3RwdWJfdGJsX3BhcmVudCIKKworXGRScCsgdGVzdHB1 YjcKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFB1YmxpY2F0aW9uIHRlc3RwdWI3CisgICAgICAgICAgT3duZXIgICAgICAgICAgIHwgQWxsIHRh YmxlcyB8IEFsbCBzZXF1ZW5jZXMgfCBJbnNlcnRzIHwgVXBkYXRlcyB8IERlbGV0ZXMgfCBUcnVu Y2F0ZXMgfCBHZW5lcmF0ZWQgY29sdW1ucyB8IFZpYSByb290IAorLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0rLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0t Ky0tLS0tLS0tLSstLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0KKyBy ZWdyZXNzX3B1YmxpY2F0aW9uX3VzZXIgfCB0ICAgICAgICAgIHwgZiAgICAgICAgICAgICB8IHQg ICAgICAgfCB0ICAgICAgIHwgdCAgICAgICB8IHQgICAgICAgICB8IG5vbmUgICAgICAgICAgICAg IHwgZgorRXhjZXB0IHRhYmxlczoKKyAgICAicHVibGljLnRlc3RwdWJfdGJsX3BhcmVudCIKIAot RFJPUCBUQUJMRSB0ZXN0cHViX3RibDMsIHRlc3RwdWJfdGJsM2E7Ci1EUk9QIFBVQkxJQ0FUSU9O IHRlc3RwdWIzLCB0ZXN0cHViNDsKK0RST1AgVEFCTEUgdGVzdHB1Yl90YmxfcGFyZW50LCB0ZXN0 cHViX3RibF9jaGlsZDsKK0RST1AgUFVCTElDQVRJT04gdGVzdHB1YjMsIHRlc3RwdWI0LCB0ZXN0 cHViNSwgdGVzdHB1YjYsIHRlc3RwdWI3OwogLS0tIFRlc3RzIGZvciBwdWJsaWNhdGlvbnMgd2l0 aCBTRVFVRU5DRVMKIENSRUFURSBTRVFVRU5DRSByZWdyZXNzX3B1Yl9zZXEwOwogQ1JFQVRFIFNF UVVFTkNFIHB1Yl90ZXN0LnJlZ3Jlc3NfcHViX3NlcTE7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9y ZWdyZXNzL3NxbC9wdWJsaWNhdGlvbi5zcWwgYi9zcmMvdGVzdC9yZWdyZXNzL3NxbC9wdWJsaWNh dGlvbi5zcWwKaW5kZXggMDAzOTBhZWNkNDcuLjY4MTc0MjIzNTZkIDEwMDY0NAotLS0gYS9zcmMv dGVzdC9yZWdyZXNzL3NxbC9wdWJsaWNhdGlvbi5zcWwKKysrIGIvc3JjL3Rlc3QvcmVncmVzcy9z cWwvcHVibGljYXRpb24uc3FsCkBAIC0xMDUsMjAgKzEwNSwzOSBAQCBTRUxFQ1QgcHVibmFtZSwg cHViYWxsdGFibGVzIEZST00gcGdfcHVibGljYXRpb24gV0hFUkUgcHVibmFtZSA9ICd0ZXN0cHVi X2ZvcmFsbAogXGQrIHRlc3RwdWJfdGJsMgogXGRScCsgdGVzdHB1Yl9mb3JhbGx0YWJsZXMKIAor U0VUIGNsaWVudF9taW5fbWVzc2FnZXMgPSAnRVJST1InOworLS0gRXhjbHVkZSB0YWJsZXMgdXNp bmcgRk9SIEFMTCBUQUJMRVMgRVhDRVBUIFRBQkxFICh0YWJsZWxpc3QpCitDUkVBVEUgUFVCTElD QVRJT04gdGVzdHB1Yl9mb3JhbGx0YWJsZXNfZXhjZXB0dGFibGUgRk9SIEFMTCBUQUJMRVMgRVhD RVBUIFRBQkxFICh0ZXN0cHViX3RibDEsIHRlc3RwdWJfdGJsMik7CistLSBFeGNsdWRlIHRhYmxl cyB1c2luZyBGT1IgQUxMIFRBQkxFUyBFWENFUFQgKHRhYmxlbGlzdCkKK0NSRUFURSBQVUJMSUNB VElPTiB0ZXN0cHViX2ZvcmFsbHRhYmxlc19leGNlcHR0YWJsZTEgRk9SIEFMTCBUQUJMRVMgRVhD RVBUICh0ZXN0cHViX3RibDEpOworUkVTRVQgY2xpZW50X21pbl9tZXNzYWdlczsKKworXGRScCsg dGVzdHB1Yl9mb3JhbGx0YWJsZXNfZXhjZXB0dGFibGUKK1xkUnArIHRlc3RwdWJfZm9yYWxsdGFi bGVzX2V4Y2VwdHRhYmxlMQorCiBEUk9QIFRBQkxFIHRlc3RwdWJfdGJsMjsKLURST1AgUFVCTElD QVRJT04gdGVzdHB1Yl9mb3JhbGx0YWJsZXMsIHRlc3RwdWJfZm9ydGFibGUsIHRlc3RwdWJfZm9y c2NoZW1hLCB0ZXN0cHViX2Zvcl90Ymxfc2NoZW1hOworRFJPUCBQVUJMSUNBVElPTiB0ZXN0cHVi X2ZvcmFsbHRhYmxlcywgdGVzdHB1Yl9mb3J0YWJsZSwgdGVzdHB1Yl9mb3JzY2hlbWEsIHRlc3Rw dWJfZm9yX3RibF9zY2hlbWEsIHRlc3RwdWJfZm9yYWxsdGFibGVzX2V4Y2VwdHRhYmxlLCB0ZXN0 cHViX2ZvcmFsbHRhYmxlc19leGNlcHR0YWJsZTE7CiAKLUNSRUFURSBUQUJMRSB0ZXN0cHViX3Ri bDMgKGEgaW50KTsKLUNSRUFURSBUQUJMRSB0ZXN0cHViX3RibDNhIChiIHRleHQpIElOSEVSSVRT ICh0ZXN0cHViX3RibDMpOworQ1JFQVRFIFRBQkxFIHRlc3RwdWJfdGJsX3BhcmVudCAoYSBpbnQp OworQ1JFQVRFIFRBQkxFIHRlc3RwdWJfdGJsX2NoaWxkIChiIHRleHQpIElOSEVSSVRTICh0ZXN0 cHViX3RibF9wYXJlbnQpOwogU0VUIGNsaWVudF9taW5fbWVzc2FnZXMgPSAnRVJST1InOwotQ1JF QVRFIFBVQkxJQ0FUSU9OIHRlc3RwdWIzIEZPUiBUQUJMRSB0ZXN0cHViX3RibDM7Ci1DUkVBVEUg UFVCTElDQVRJT04gdGVzdHB1YjQgRk9SIFRBQkxFIE9OTFkgdGVzdHB1Yl90YmwzOworQ1JFQVRF IFBVQkxJQ0FUSU9OIHRlc3RwdWIzIEZPUiBUQUJMRSB0ZXN0cHViX3RibF9wYXJlbnQ7CitDUkVB VEUgUFVCTElDQVRJT04gdGVzdHB1YjQgRk9SIFRBQkxFIE9OTFkgdGVzdHB1Yl90YmxfcGFyZW50 OworLS0gRXhjbHVkZSBwYXJlbnQgdGFibGUsIG9taXR0aW5nIGJvdGggb2YgJ09OTFknIGFuZCAn KicKK0NSRUFURSBQVUJMSUNBVElPTiB0ZXN0cHViNSBGT1IgQUxMIFRBQkxFUyBFWENFUFQgVEFC TEUgKHRlc3RwdWJfdGJsX3BhcmVudCk7CistLSBFWENFUFQgd2l0aCBhc3RlcmlzazogZXhjbHVk ZSB0YWJsZSBhbmQgYWxsIGRlc2NlbmRhbnRzCitDUkVBVEUgUFVCTElDQVRJT04gdGVzdHB1YjYg Rk9SIEFMTCBUQUJMRVMgRVhDRVBUIFRBQkxFICh0ZXN0cHViX3RibF9wYXJlbnQgKik7CistLSBF WENFUFQgd2l0aCBPTkxZOiBleGNsdWRlIHRhYmxlIGJ1dCBub3QgZGVzY2VuZGFudHMKK0NSRUFU RSBQVUJMSUNBVElPTiB0ZXN0cHViNyBGT1IgQUxMIFRBQkxFUyBFWENFUFQgVEFCTEUgKE9OTFkg dGVzdHB1Yl90YmxfcGFyZW50KTsKIFJFU0VUIGNsaWVudF9taW5fbWVzc2FnZXM7CiBcZFJwKyB0 ZXN0cHViMwogXGRScCsgdGVzdHB1YjQKK1xkUnArIHRlc3RwdWI1CitcZFJwKyB0ZXN0cHViNgor XGRScCsgdGVzdHB1YjcKIAotRFJPUCBUQUJMRSB0ZXN0cHViX3RibDMsIHRlc3RwdWJfdGJsM2E7 Ci1EUk9QIFBVQkxJQ0FUSU9OIHRlc3RwdWIzLCB0ZXN0cHViNDsKK0RST1AgVEFCTEUgdGVzdHB1 Yl90YmxfcGFyZW50LCB0ZXN0cHViX3RibF9jaGlsZDsKK0RST1AgUFVCTElDQVRJT04gdGVzdHB1 YjMsIHRlc3RwdWI0LCB0ZXN0cHViNSwgdGVzdHB1YjYsIHRlc3RwdWI3OwogCiAtLS0gVGVzdHMg Zm9yIHB1YmxpY2F0aW9ucyB3aXRoIFNFUVVFTkNFUwogQ1JFQVRFIFNFUVVFTkNFIHJlZ3Jlc3Nf cHViX3NlcTA7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9zdWJzY3JpcHRpb24vbWVzb24uYnVpbGQg Yi9zcmMvdGVzdC9zdWJzY3JpcHRpb24vbWVzb24uYnVpbGQKaW5kZXggODVkMTBhODk5OTQuLmI4 ZTVjNTRjMzE0IDEwMDY0NAotLS0gYS9zcmMvdGVzdC9zdWJzY3JpcHRpb24vbWVzb24uYnVpbGQK KysrIGIvc3JjL3Rlc3Qvc3Vic2NyaXB0aW9uL21lc29uLmJ1aWxkCkBAIC00Niw2ICs0Niw3IEBA IHRlc3RzICs9IHsKICAgICAgICd0LzAzNF90ZW1wb3JhbC5wbCcsCiAgICAgICAndC8wMzVfY29u ZmxpY3RzLnBsJywKICAgICAgICd0LzAzNl9zZXF1ZW5jZXMucGwnLAorICAgICAgJ3QvMDM3X3Jl cF9jaGFuZ2VzX2V4Y2VwdF90YWJsZS5wbCcsCiAgICAgICAndC8xMDBfYnVncy5wbCcsCiAgICAg XSwKICAgfSwKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L3N1YnNjcmlwdGlvbi90LzAzN19yZXBfY2hh bmdlc19leGNlcHRfdGFibGUucGwgYi9zcmMvdGVzdC9zdWJzY3JpcHRpb24vdC8wMzdfcmVwX2No YW5nZXNfZXhjZXB0X3RhYmxlLnBsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwLi4zMGZmYjJhMzM5ZgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L3N1YnNjcmlwdGlv bi90LzAzN19yZXBfY2hhbmdlc19leGNlcHRfdGFibGUucGwKQEAgLTAsMCArMSwyMTggQEAKKwor IyBDb3B5cmlnaHQgKGMpIDIwMjEtMjAyNSwgUG9zdGdyZVNRTCBHbG9iYWwgRGV2ZWxvcG1lbnQg R3JvdXAKKworIyBMb2dpY2FsIHJlcGxpY2F0aW9uIHRlc3RzIGZvciBFWENFUFQgVEFCTEUgcHVi bGljYXRpb25zCit1c2Ugc3RyaWN0OwordXNlIHdhcm5pbmdzOwordXNlIFBvc3RncmVTUUw6OlRl c3Q6OkNsdXN0ZXI7Cit1c2UgUG9zdGdyZVNRTDo6VGVzdDo6VXRpbHM7Cit1c2UgVGVzdDo6TW9y ZTsKKworIyBJbml0aWFsaXplIHB1Ymxpc2hlciBub2RlCitteSAkbm9kZV9wdWJsaXNoZXIgPSBQ b3N0Z3JlU1FMOjpUZXN0OjpDbHVzdGVyLT5uZXcoJ3B1Ymxpc2hlcicpOworJG5vZGVfcHVibGlz aGVyLT5pbml0KGFsbG93c19zdHJlYW1pbmcgPT4gJ2xvZ2ljYWwnKTsKKyRub2RlX3B1Ymxpc2hl ci0+c3RhcnQ7CisKKyMgSW5pdGlhbGl6ZSBzdWJzY3JpYmVyIG5vZGUKK215ICRub2RlX3N1YnNj cmliZXIgPSBQb3N0Z3JlU1FMOjpUZXN0OjpDbHVzdGVyLT5uZXcoJ3N1YnNjcmliZXInKTsKKyRu b2RlX3N1YnNjcmliZXItPmluaXQoYWxsb3dzX3N0cmVhbWluZyA9PiAnbG9naWNhbCcpOworJG5v ZGVfc3Vic2NyaWJlci0+c3RhcnQ7CisKKyMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KKyMgRVhDRVBUIFRBQkxFIHRlc3QgY2FzZXMgZm9yIG5vcm1hbCB0YWJs ZXMKKyMgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KKyMgQ3Jl YXRlIHNjaGVtYXMgYW5kIHRhYmxlcyBvbiBwdWJsaXNoZXIKKyRub2RlX3B1Ymxpc2hlci0+c2Fm ZV9wc3FsKAorCSdwb3N0Z3JlcycsIHFxKAorCUNSRUFURSBTQ0hFTUEgc2NoMTsKKwlDUkVBVEUg VEFCTEUgc2NoMS50YWIxIEFTIFNFTEVDVCBnZW5lcmF0ZV9zZXJpZXMoMSwxMCkgQVMgYTsKKykp OworCisjIENyZWF0ZSBzY2hlbWFzIGFuZCB0YWJsZXMgb24gc3Vic2NyaWJlcgorJG5vZGVfc3Vi c2NyaWJlci0+c2FmZV9wc3FsKAorCSdwb3N0Z3JlcycsIHFxKAorCUNSRUFURSBTQ0hFTUEgc2No MTsKKwlDUkVBVEUgVEFCTEUgc2NoMS50YWIxIChhIGludCk7CispKTsKKworIyBTZXR1cCBsb2dp Y2FsIHJlcGxpY2F0aW9uCitteSAkcHVibGlzaGVyX2Nvbm5zdHIgPSAkbm9kZV9wdWJsaXNoZXIt PmNvbm5zdHIgLiAnIGRibmFtZT1wb3N0Z3Jlcyc7Ciskbm9kZV9wdWJsaXNoZXItPnNhZmVfcHNx bCgncG9zdGdyZXMnLAorCSJDUkVBVEUgUFVCTElDQVRJT04gdGFwX3B1Yl9zY2hlbWEgRk9SIEFM TCBUQUJMRVMgRVhDRVBUIFRBQkxFIChzY2gxLnRhYjEpIgorKTsKKworJG5vZGVfc3Vic2NyaWJl ci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsCisJIkNSRUFURSBTVUJTQ1JJUFRJT04gdGFwX3N1Yl9z Y2hlbWEgQ09OTkVDVElPTiAnJHB1Ymxpc2hlcl9jb25uc3RyJyBQVUJMSUNBVElPTiB0YXBfcHVi X3NjaGVtYSIKKyk7CisKKyMgV2FpdCBmb3IgaW5pdGlhbCB0YWJsZSBzeW5jIHRvIGZpbmlzaAor JG5vZGVfc3Vic2NyaWJlci0+d2FpdF9mb3Jfc3Vic2NyaXB0aW9uX3N5bmMoJG5vZGVfcHVibGlz aGVyLAorCSd0YXBfc3ViX3NjaGVtYScpOworCisjIENoZWNrIHRoZSB0YWJsZSBkYXRhIGRvZXMg bm90IHN5bmMgZm9yIGV4Y2x1ZGVkIHRhYmxlCitteSAkcmVzdWx0ID0gJG5vZGVfc3Vic2NyaWJl ci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsCisJIlNFTEVDVCBjb3VudCgqKSwgbWluKGEpLCBtYXgo YSkgRlJPTSBzY2gxLnRhYjEiKTsKK2lzKCRyZXN1bHQsIHFxKDB8fCksCisJJ2NoZWNrIHRoZXJl IGlzIG5vIGluaXRpYWwgZGF0YSBjb3BpZWQgZm9yIHRoZSBleGNsdWRlZCB0YWJsZScpOworCisj IFZlcmlmeSB0aGF0IGRhdGEgaW5zZXJ0ZWQgdG8gdGhlIGV4Y2x1ZGVkIHRhYmxlIGlzIG5vdCBy ZXBsaWNhdGVkLgorJG5vZGVfcHVibGlzaGVyLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywKKwkiSU5T RVJUIElOVE8gc2NoMS50YWIxIFZBTFVFUyhnZW5lcmF0ZV9zZXJpZXMoMTEsMjApKSIpOworCisk bm9kZV9wdWJsaXNoZXItPndhaXRfZm9yX2NhdGNodXAoJ3RhcF9zdWJfc2NoZW1hJyk7CisKKyRy ZXN1bHQgPSAkbm9kZV9zdWJzY3JpYmVyLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywKKwkiU0VMRUNU IGNvdW50KCopLCBtaW4oYSksIG1heChhKSBGUk9NIHNjaDEudGFiMSIpOworaXMoJHJlc3VsdCwg cXEoMHx8KSwgJ2NoZWNrIHJlcGxpY2F0ZWQgaW5zZXJ0cyBvbiBzdWJzY3JpYmVyJyk7CisKKyMg Y2xlYW51cAorJG5vZGVfcHVibGlzaGVyLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgIkRST1AgUFVC TElDQVRJT04gdGFwX3B1Yl9zY2hlbWEiKTsKKyRub2RlX3N1YnNjcmliZXItPnNhZmVfcHNxbCgn cG9zdGdyZXMnLCAiRFJPUCBTVUJTQ1JJUFRJT04gdGFwX3N1Yl9zY2hlbWEiKTsKKworIyA9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorIyBFWENFUFQgVEFCTEUg dGVzdCBjYXNlcyBmb3IgcGFydGl0aW9uZWQgdGFibGVzCisjIENoZWNrIGJlaGF2aW9yIG9mIEVY Q0VQVCBUQUJMRSB3aXRoIHB1Ymxpc2hfdmlhX3BhcnRpdGlvbl9yb290IG9uIGEKKyMgcGFydGl0 aW9uZWQgdGFibGUgYW5kIGl0cyBwYXJ0aXRpb25zLgorIyA9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQorIyBTZXR1cCBwYXJ0aXRpb25lZCB0YWJsZSBhbmQgcGFy dGl0aW9ucyBvbiB0aGUgcHVibGlzaGVyIHRoYXQgbWFwIHRvIG5vcm1hbAorIyB0YWJsZXMgb24g dGhlIHN1YnNjcmliZXIKKyRub2RlX3B1Ymxpc2hlci0+c2FmZV9wc3FsKAorCSdwb3N0Z3Jlcycs IHFxKAorCUNSRUFURSBUQUJMRSBzY2gxLnQxKGEgaW50KSBQQVJUSVRJT04gQlkgUkFOR0UoYSk7 CisJQ1JFQVRFIFRBQkxFIHNjaDEucGFydDEgUEFSVElUSU9OIE9GIHNjaDEudDEgRk9SIFZBTFVF UyBGUk9NICgwKSBUTyAoNSk7CisJQ1JFQVRFIFRBQkxFIHNjaDEucGFydDIgUEFSVElUSU9OIE9G IHNjaDEudDEgRk9SIFZBTFVFUyBGUk9NICg2KSBUTyAoMTApOworKSk7CisKKyRub2RlX3N1YnNj cmliZXItPnNhZmVfcHNxbCgKKwkncG9zdGdyZXMnLCBxcSgKKwlDUkVBVEUgVEFCTEUgc2NoMS50 MShhIGludCk7CisJQ1JFQVRFIFRBQkxFIHNjaDEucGFydDEoYSBpbnQpOworCUNSRUFURSBUQUJM RSBzY2gxLnBhcnQyKGEgaW50KTsKKykpOworCisjIEVYQ0VQVCBUQUJMRSAoc2NoMS5wYXJ0MSkg d2l0aCBwdWJsaXNoX3ZpYV9wYXJ0aXRpb25fcm9vdCA9IGZhbHNlCisjIEV4Y2x1ZGluZyBhIHBh cnRpdGlvbiB3aGlsZSBwdWJsaXNoX3ZpYV9wYXJ0aXRpb25fcm9vdCA9IGZhbHNlIHByZXZlbnRz CisjIHJlcGxpY2F0aW9uIG9mIHJvd3MgaW5zZXJ0ZWQgaW50byB0aGUgcGFydGl0aW9uZWQgdGFi bGUuCiskbm9kZV9wdWJsaXNoZXItPnNhZmVfcHNxbCgKKwkncG9zdGdyZXMnLCBxcSgKKwlDUkVB VEUgUFVCTElDQVRJT04gdGFwX3B1Yl9wYXJ0IEZPUiBBTEwgVEFCTEVTIEVYQ0VQVCBUQUJMRSAo c2NoMS5wYXJ0MSkgV0lUSCAocHVibGlzaF92aWFfcGFydGl0aW9uX3Jvb3QgPSBmYWxzZSk7CisJ SU5TRVJUIElOVE8gc2NoMS50MSBWQUxVRVMgKDEpLCAoNik7CispKTsKKyRub2RlX3N1YnNjcmli ZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLAorCSJDUkVBVEUgU1VCU0NSSVBUSU9OIHRhcF9zdWJf cGFydCBDT05ORUNUSU9OICckcHVibGlzaGVyX2Nvbm5zdHInIFBVQkxJQ0FUSU9OIHRhcF9wdWJf cGFydCIKKyk7Ciskbm9kZV9zdWJzY3JpYmVyLT53YWl0X2Zvcl9zdWJzY3JpcHRpb25fc3luYygk bm9kZV9wdWJsaXNoZXIsICd0YXBfc3ViX3BhcnQnKTsKKyRub2RlX3B1Ymxpc2hlci0+c2FmZV9w c3FsKCdwb3N0Z3JlcycsCisJIklOU0VSVCBJTlRPIHNjaDEudDEgVkFMVUVTICgyKSwgKDcpOyIp OworJG5vZGVfcHVibGlzaGVyLT53YWl0X2Zvcl9jYXRjaHVwKCd0YXBfc3ViX3BhcnQnKTsKKwor JHJlc3VsdCA9ICRub2RlX3N1YnNjcmliZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLCAiU0VMRUNU ICogRlJPTSBzY2gxLnQxIik7CitpcygkcmVzdWx0LCBxcSgpLCAnY2hlY2sgcm93cyBvbiBwYXJ0 aXRpb25lZCB0YWJsZScpOworCiskcmVzdWx0ID0gJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3Fs KCdwb3N0Z3JlcycsICJTRUxFQ1QgKiBGUk9NIHNjaDEucGFydDEiKTsKK2lzKCRyZXN1bHQsIHFx KCksICdjaGVjayByb3dzIG9uIGV4Y2x1ZGVkIHBhcnRpdGlvbicpOworCiskcmVzdWx0ID0gJG5v ZGVfc3Vic2NyaWJlci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsICJTRUxFQ1QgKiBGUk9NIHNjaDEu cGFydDIiKTsKK2lzKCAkcmVzdWx0LCBxcSg2Cis3KSwgJ2NoZWNrIHJvd3Mgb24gb3RoZXIgcGFy dGl0aW9uJyk7CisKKyRub2RlX3B1Ymxpc2hlci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsICJUUlVO Q0FURSBzY2gxLnQxIik7Ciskbm9kZV9wdWJsaXNoZXItPndhaXRfZm9yX2NhdGNodXAoJ3RhcF9z dWJfcGFydCcpOworJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsICJEUk9Q IFNVQlNDUklQVElPTiB0YXBfc3ViX3BhcnQiKTsKKyRub2RlX3B1Ymxpc2hlci0+c2FmZV9wc3Fs KCdwb3N0Z3JlcycsICJEUk9QIFBVQkxJQ0FUSU9OIHRhcF9wdWJfcGFydDsiKTsKKworIyBFWENF UFQgVEFCTEUgKHNjaDEudDEpIHdpdGggcHVibGlzaF92aWFfcGFydGl0aW9uX3Jvb3QgPSBmYWxz ZQorIyBFeGNsdWRpbmcgdGhlIHBhcnRpdGlvbmVkIHRhYmxlIHN0aWxsIGFsbG93cyByb3dzIGlu c2VydGVkIGludG8gdGhlCisjIHBhcnRpdGlvbmVkIHRhYmxlIHRvIGJlIHJlcGxpY2F0ZWQgdmlh IGl0cyBwYXJ0aXRpb25zLgorJG5vZGVfcHVibGlzaGVyLT5zYWZlX3BzcWwoCisJJ3Bvc3RncmVz JywgcXEoCisJQ1JFQVRFIFBVQkxJQ0FUSU9OIHRhcF9wdWJfcGFydCBGT1IgQUxMIFRBQkxFUyBF WENFUFQgVEFCTEUgKHNjaDEudDEpIFdJVEggKHB1Ymxpc2hfdmlhX3BhcnRpdGlvbl9yb290ID0g ZmFsc2UpOworCUlOU0VSVCBJTlRPIHNjaDEudDEgVkFMVUVTICgxKSwgKDYpOworKSk7Ciskbm9k ZV9zdWJzY3JpYmVyLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywKKwkiQ1JFQVRFIFNVQlNDUklQVElP TiB0YXBfc3ViX3BhcnQgQ09OTkVDVElPTiAnJHB1Ymxpc2hlcl9jb25uc3RyJyBQVUJMSUNBVElP TiB0YXBfcHViX3BhcnQiCispOworJG5vZGVfc3Vic2NyaWJlci0+d2FpdF9mb3Jfc3Vic2NyaXB0 aW9uX3N5bmMoJG5vZGVfcHVibGlzaGVyLCAndGFwX3N1Yl9wYXJ0Jyk7Ciskbm9kZV9wdWJsaXNo ZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLAorCSJJTlNFUlQgSU5UTyBzY2gxLnQxIFZBTFVFUyAo MiksICg3KTsiKTsKKyRub2RlX3B1Ymxpc2hlci0+d2FpdF9mb3JfY2F0Y2h1cCgndGFwX3N1Yl9w YXJ0Jyk7CisKKyRyZXN1bHQgPSAkbm9kZV9zdWJzY3JpYmVyLT5zYWZlX3BzcWwoJ3Bvc3RncmVz JywgIlNFTEVDVCAqIEZST00gc2NoMS50MSIpOworaXMoJHJlc3VsdCwgcXEoKSwgJ2NoZWNrIHJv d3Mgb24gcGFydGl0aW9uZWQgdGFibGUnKTsKKworJHJlc3VsdCA9ICRub2RlX3N1YnNjcmliZXIt PnNhZmVfcHNxbCgncG9zdGdyZXMnLCAiU0VMRUNUICogRlJPTSBzY2gxLnBhcnQxIik7Citpcygg JHJlc3VsdCwgcXEoMQorMiksICdjaGVjayByb3dzIG9uIGZpcnN0IHBhcnRpdGlvbicpOworCisk cmVzdWx0ID0gJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsICJTRUxFQ1Qg KiBGUk9NIHNjaDEucGFydDIiKTsKK2lzKCAkcmVzdWx0LCBxcSg2Cis3KSwgJ2NoZWNrIHJvd3Mg b24gc2Vjb25kIHBhcnRpdGlvbicpOworCiskbm9kZV9wdWJsaXNoZXItPnNhZmVfcHNxbCgncG9z dGdyZXMnLCAiVFJVTkNBVEUgc2NoMS50MSIpOworJG5vZGVfcHVibGlzaGVyLT53YWl0X2Zvcl9j YXRjaHVwKCd0YXBfc3ViX3BhcnQnKTsKKyRub2RlX3N1YnNjcmliZXItPnNhZmVfcHNxbCgncG9z dGdyZXMnLCAiRFJPUCBTVUJTQ1JJUFRJT04gdGFwX3N1Yl9wYXJ0Iik7Ciskbm9kZV9wdWJsaXNo ZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLCAiRFJPUCBQVUJMSUNBVElPTiB0YXBfcHViX3BhcnQ7 Iik7CisKKyMgRVhDRVBUIFRBQkxFIChzY2gxLnQxKSB3aXRoIHB1Ymxpc2hfdmlhX3BhcnRpdGlv bl9yb290ID0gdHJ1ZQorIyBXaGVuIHRoZSBwYXJ0aXRpb25lZCB0YWJsZSBpcyBleGNsdWRlZCBh bmQgcHVibGlzaF92aWFfcGFydGl0aW9uX3Jvb3QgaXMgdHJ1ZSwKKyMgbm8gcm93cyBmcm9tIHRo ZSB0YWJsZSBvciBpdHMgcGFydGl0aW9ucyBhcmUgcmVwbGljYXRlZC4KKyRub2RlX3B1Ymxpc2hl ci0+c2FmZV9wc3FsKAorCSdwb3N0Z3JlcycsIHFxKAorCUNSRUFURSBQVUJMSUNBVElPTiB0YXBf cHViX3BhcnQgRk9SIEFMTCBUQUJMRVMgRVhDRVBUIFRBQkxFIChzY2gxLnQxKSBXSVRIIChwdWJs aXNoX3ZpYV9wYXJ0aXRpb25fcm9vdCk7CisJSU5TRVJUIElOVE8gc2NoMS50MSBWQUxVRVMgKDEp LCAoNik7CispKTsKKyRub2RlX3N1YnNjcmliZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLAorCSJD UkVBVEUgU1VCU0NSSVBUSU9OIHRhcF9zdWJfcGFydCBDT05ORUNUSU9OICckcHVibGlzaGVyX2Nv bm5zdHInIFBVQkxJQ0FUSU9OIHRhcF9wdWJfcGFydCIKKyk7Ciskbm9kZV9zdWJzY3JpYmVyLT53 YWl0X2Zvcl9zdWJzY3JpcHRpb25fc3luYygkbm9kZV9wdWJsaXNoZXIsICd0YXBfc3ViX3BhcnQn KTsKKyRub2RlX3B1Ymxpc2hlci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsCisJIklOU0VSVCBJTlRP IHNjaDEudDEgVkFMVUVTICgyKSwgKDcpOyIpOworJG5vZGVfcHVibGlzaGVyLT53YWl0X2Zvcl9j YXRjaHVwKCd0YXBfc3ViX3BhcnQnKTsKKworJHJlc3VsdCA9ICRub2RlX3N1YnNjcmliZXItPnNh ZmVfcHNxbCgncG9zdGdyZXMnLCAiU0VMRUNUICogRlJPTSBzY2gxLnQxIik7CitpcygkcmVzdWx0 LCBxcSgpLCAnY2hlY2sgcm93cyBvbiBwYXJ0aXRpb25lZCB0YWJsZScpOworCiskcmVzdWx0ID0g JG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsICJTRUxFQ1QgKiBGUk9NIHNj aDEucGFydDEiKTsKK2lzKCRyZXN1bHQsIHFxKCksICdjaGVjayByb3dzIG9uIGZpcnN0IHBhcnRp dGlvbicpOworCiskcmVzdWx0ID0gJG5vZGVfc3Vic2NyaWJlci0+c2FmZV9wc3FsKCdwb3N0Z3Jl cycsICJTRUxFQ1QgKiBGUk9NIHNjaDEucGFydDIiKTsKK2lzKCRyZXN1bHQsIHFxKCksICdjaGVj ayByb3dzIG9uIHNlY29uZCBwYXJ0aXRpb24nKTsKKworJG5vZGVfcHVibGlzaGVyLT5zYWZlX3Bz cWwoJ3Bvc3RncmVzJywgIlRSVU5DQVRFIHNjaDEudDEiKTsKKyRub2RlX3B1Ymxpc2hlci0+d2Fp dF9mb3JfY2F0Y2h1cCgndGFwX3N1Yl9wYXJ0Jyk7Ciskbm9kZV9zdWJzY3JpYmVyLT5zYWZlX3Bz cWwoJ3Bvc3RncmVzJywgIkRST1AgU1VCU0NSSVBUSU9OIHRhcF9zdWJfcGFydCIpOworJG5vZGVf cHVibGlzaGVyLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgIkRST1AgUFVCTElDQVRJT04gdGFwX3B1 Yl9wYXJ0OyIpOworCisjIEVYQ0VQVCBUQUJMRSAoc2NoMS5wYXJ0MSkgd2l0aCBwdWJsaXNoX3Zp YV9wYXJ0aXRpb25fcm9vdCA9IHRydWUKKyMgV2hlbiBhIHBhcnRpdGlvbiBpcyBleGNsdWRlZCBi dXQgcHVibGlzaF92aWFfcGFydGl0aW9uX3Jvb3QgaXMgdHJ1ZSwKKyMgcm93cyBwdWJsaXNoZWQg dGhyb3VnaCB0aGUgcGFydGl0aW9uZWQgdGFibGUgY2FuIHN0aWxsIGJlIHJlcGxpY2F0ZWQuCisk bm9kZV9wdWJsaXNoZXItPnNhZmVfcHNxbCgKKwkncG9zdGdyZXMnLCBxcSgKKwlDUkVBVEUgUFVC TElDQVRJT04gdGFwX3B1Yl9wYXJ0IEZPUiBBTEwgVEFCTEVTIEVYQ0VQVCBUQUJMRSAoc2NoMS5w YXJ0MSkgV0lUSCAocHVibGlzaF92aWFfcGFydGl0aW9uX3Jvb3QpOworCUlOU0VSVCBJTlRPIHNj aDEudDEgVkFMVUVTICgxKSwgKDYpCispKTsKKyRub2RlX3N1YnNjcmliZXItPnNhZmVfcHNxbCgn cG9zdGdyZXMnLAorCSJDUkVBVEUgU1VCU0NSSVBUSU9OIHRhcF9zdWJfcGFydCBDT05ORUNUSU9O ICckcHVibGlzaGVyX2Nvbm5zdHInIFBVQkxJQ0FUSU9OIHRhcF9wdWJfcGFydCIKKyk7Ciskbm9k ZV9zdWJzY3JpYmVyLT53YWl0X2Zvcl9zdWJzY3JpcHRpb25fc3luYygkbm9kZV9wdWJsaXNoZXIs ICd0YXBfc3ViX3BhcnQnKTsKKyRub2RlX3B1Ymxpc2hlci0+c2FmZV9wc3FsKCdwb3N0Z3Jlcycs CisJIklOU0VSVCBJTlRPIHNjaDEudDEgVkFMVUVTICgyKSwgKDcpOyIpOworJG5vZGVfcHVibGlz aGVyLT53YWl0X2Zvcl9jYXRjaHVwKCd0YXBfc3ViX3BhcnQnKTsKKworJHJlc3VsdCA9CisgICRu b2RlX3N1YnNjcmliZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLCAiU0VMRUNUICogRlJPTSBzY2gx LnQxIE9SREVSIEJZIGEiKTsKK2lzKCAkcmVzdWx0LCBxcSgxCisyCis2Cis3KSwgJ2NoZWNrIHJv d3Mgb24gcGFydGl0aW9uZWQgdGFibGUnKTsKKworJHJlc3VsdCA9ICRub2RlX3N1YnNjcmliZXIt PnNhZmVfcHNxbCgncG9zdGdyZXMnLCAiU0VMRUNUICogRlJPTSBzY2gxLnBhcnQxIik7Citpcygk cmVzdWx0LCBxcSgpLCAnY2hlY2sgcm93cyBvbiBleGNsdWRlZCBwYXJ0aXRpb24nKTsKKworJHJl c3VsdCA9ICRub2RlX3N1YnNjcmliZXItPnNhZmVfcHNxbCgncG9zdGdyZXMnLCAiU0VMRUNUICog RlJPTSBzY2gxLnBhcnQyIik7CitpcygkcmVzdWx0LCBxcSgpLCAnY2hlY2sgcm93cyBvbiBvdGhl ciBwYXJ0aXRpb24nKTsKKworJG5vZGVfc3Vic2NyaWJlci0+c3RvcCgnZmFzdCcpOworJG5vZGVf cHVibGlzaGVyLT5zdG9wKCdmYXN0Jyk7CisKK2RvbmVfdGVzdGluZygpOwotLSAKMi4zNC4xCgo= --00000000000098f5a806460e3ee4--