From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 20360 invoked by alias); 16 Nov 2008 08:20:22 -0000 Received: (qmail 19709 invoked by uid 22791); 16 Nov 2008 08:20:17 -0000 X-Spam-Check-By: sourceware.org Received: from ti-out-0910.google.com (HELO ti-out-0910.google.com) (209.85.142.185) by sourceware.org (qpsmtpd/0.31) with ESMTP; Sun, 16 Nov 2008 08:18:58 +0000 Received: by ti-out-0910.google.com with SMTP id d10so1447415tib.12 for ; Sun, 16 Nov 2008 00:18:55 -0800 (PST) Received: by 10.110.16.9 with SMTP id 9mr3493989tip.6.1226823535028; Sun, 16 Nov 2008 00:18:55 -0800 (PST) Received: by 10.110.103.3 with HTTP; Sun, 16 Nov 2008 00:18:54 -0800 (PST) Message-ID: Date: Sun, 16 Nov 2008 21:55:00 -0000 From: teawater To: "gdb-patches@sourceware.org" Subject: [RFA] Resubmit process record and replay, 3/10 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_Part_40467_2637849.1226823534989" X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2008-11/txt/msg00411.txt.bz2 ------=_Part_40467_2637849.1226823534989 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit Content-Disposition: inline Content-length: 13691 This patch add the process record and replay target. This is the core part of process record and replay. 2008-11-16 Hui Zhu Process record and replay target. * Makefile.in (record.c): New file. * record.c, record.h: New file. Makefile.in | 4 b/record.c | 1156 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ b/record.h | 99 +++++ 3 files changed, 1257 insertions(+), 2 deletions(-) Following is the diff with the previous patch: @@ -1,6 +1,6 @@ --- a/Makefile.in +++ b/Makefile.in -@@ -657,7 +657,7 @@ SFILES = ada-exp.y ada-lang.c ada-typepr +@@ -657,7 +657,7 @@ valarith.c valops.c valprint.c value.c varobj.c vec.c \ wrapper.c \ xml-tdesc.c xml-support.c \ @@ -9,7 +9,7 @@ LINTFILES = $(SFILES) $(YYFILES) $(CONFIG_SRCS) init.c -@@ -808,7 +808,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $ +@@ -808,7 +808,7 @@ solib.o solib-null.o \ prologue-value.o memory-map.o xml-support.o \ target-descriptions.o target-memory.o xml-tdesc.o xml-builtin.o \ @@ -18,9 +18,9 @@ TSOBS = inflow.o ---- a/record.c +--- a//dev/null +++ b/record.c -@@ -0,0 +1,1143 @@ +@@ -0,0 +1,1156 @@ +/* Process record and replay target for GDB, the GNU debugger. + + Copyright (C) 2008 Free Software Foundation, Inc. @@ -29,7 +29,7 @@ + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by -+ the Free Software Foundation; either version 2 of the License, or ++ the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, @@ -265,9 +265,12 @@ + + if (target_read_memory (addr, rec->u.mem.val, len)) + { -+ fprintf_unfiltered (gdb_stdlog, -+ "Process record: read memory addr = 0x%s len = %d error.\n", -+ paddr_nz (addr), len); ++ if (record_debug) ++ { ++ fprintf_unfiltered (gdb_stdlog, ++ "Process record: error reading memory at addr = 0x%s len = %d.\n", ++ paddr_nz (addr), len); ++ } + xfree (rec->u.mem.val); + xfree (rec); + return (-1); @@ -311,13 +314,13 @@ + gdb_assert (record_insn_num <= record_insn_max_num); + if (record_insn_num == record_insn_max_num) + { -+ /* Ask user how to do */ ++ /* Ask user what to do */ + if (record_stop_at_limit) + { + int q; + if (set_terminal) + target_terminal_ours (); -+ q = yquery (_("The record instruction number (record-insn-number) is equal to record-insn-number-max. Do you want to close record/replay stop when record/replay buffer becomes full(record-stop-at-limit) then auto delete first record_t?")); ++ q = yquery (_("Do you want to auto delete previous execute log entries when record/replay buffer becomes full (record-stop-at-limit)?")); + if (set_terminal) + target_terminal_inferior (); + if (q) @@ -326,7 +329,7 @@ + } + else + { -+ error (_("Process record: record stop the program.")); ++ error (_("Process record: inferior program stopped.")); + } + } + } @@ -363,9 +366,9 @@ + ret = gdbarch_process_record (gdbarch, + regcache_read_pc (record_regcache)); + if (ret > 0) -+ error (_("Process record pause the program.")); ++ error (_("Process record: inferior program stopped.")); + if (ret < 0) -+ error (_("Process record record message error.")); ++ error (_("Process record: failed to record execution log.")); + + discard_cleanups (old_cleanups); + @@ -417,7 +420,7 @@ + } + if (target_async_permitted) + { -+ error (_("Process record target can't debug the GNU/Linux inferior in asynchronous mode (linux-async).")); ++ error (_("Process record target can't debug inferior in asynchronous mode (target-async).")); + } + + if (!gdbarch_process_record_p (current_gdbarch)) @@ -429,7 +432,7 @@ + if (RECORD_IS_USED) + { + if (!nquery -+ (_("Process record target already running, do you want delete the old record log?"))) ++ (_("Process record target already running, do you want to delete the old record log?"))) + { + return; + } @@ -554,10 +557,10 @@ + act.sa_flags = SA_RESTART; + if (sigaction (SIGINT, &act, &old_act)) + { -+ perror_with_name (_("Process record: sigaction")); ++ perror_with_name (_("Process record: sigaction failed")); + } + /* If GDB is in terminal_inferior, it will not get the signal. -+ And in GDB replay mode, GDB don't need to in terminal_inferior ++ And in GDB replay mode, GDB doesn't need to in terminal_inferior + because inferior will not executed. + Then set it to terminal_ours to make GDB get the signal. */ + target_terminal_ours (); @@ -620,7 +623,7 @@ + if (target_read_memory + (record_list->u.mem.addr, mem, record_list->u.mem.len)) + { -+ error (_("Process record: read memory addr = 0x%s len = %d error."), ++ error (_("Process record: error reading memory at addr = 0x%s len = %d."), + paddr_nz (record_list->u.mem.addr), + record_list->u.mem.len); + } @@ -629,7 +632,7 @@ + record_list->u.mem.len)) + { + error (_ -+ ("Process record: write memory addr = 0x%s len = %d error."), ++ ("Process record: error writing memory at addr = 0x%s len = %d."), + paddr_nz (record_list->u.mem.addr), + record_list->u.mem.len); + } @@ -657,7 +660,7 @@ + if (first_record_end && execution_direction == EXEC_REVERSE) + { + /* When reverse excute, the first record_end is the part of -+ current instruction. */ ++ current instruction. */ + first_record_end = 0; + } + else @@ -723,7 +726,7 @@ + + if (sigaction (SIGALRM, &old_act, NULL)) + { -+ perror_with_name (_("Process record: sigaction")); ++ perror_with_name (_("Process record: sigaction failed")); + } + +replay_out: @@ -754,7 +757,7 @@ +} + +static void -+record_detach (char *args, int from_tty) ++record_detach (struct target_ops *ops, char *args, int from_tty) +{ + if (record_debug) + { @@ -765,7 +768,7 @@ +} + +static void -+record_mourn_inferior (void) ++record_mourn_inferior (struct target_ops *ops) +{ + if (record_debug) + { @@ -807,7 +810,7 @@ + if (record_arch_list_add_reg (i)) + { + record_list_release (record_arch_list_tail); -+ error (_("Process record: record message error.")); ++ error (_("Process record: failed to record execution log.")); + } + } + } @@ -816,13 +819,13 @@ + if (record_arch_list_add_reg (regnum)) + { + record_list_release (record_arch_list_tail); -+ error (_("Process record: record message error.")); ++ error (_("Process record: failed to record execution log.")); + } + } + if (record_arch_list_add_end (0)) + { + record_list_release (record_arch_list_tail); -+ error (_("Process record: record message error.")); ++ error (_("Process record: failed to record execution log.")); + } + record_list->next = record_arch_list_head; + record_arch_list_head->prev = record_list; @@ -853,13 +856,13 @@ + { + n = + nquery (_ -+ ("Becuse GDB is in replay mode, changing the value of a register will destroy the record from this point forward. Change all register?")); ++ ("Becuse GDB is in replay mode, changing the value of a register will make the execute log unusable from this point onward. Change all register?")); + } + else + { + n = + nquery (_ -+ ("Becuse GDB is in replay mode, changing the value of a register will destroy the record from this point forward. Change register %s?"), ++ ("Becuse GDB is in replay mode, changing the value of a register will make the execute log unusable from this point onward. Change register %s?"), + gdbarch_register_name (get_regcache_arch (regcache), + regno)); + } @@ -867,7 +870,7 @@ + if (!n) + { + /* Invalidate the value of regcache that set in function -+ "regcache_raw_write". */ ++ "regcache_raw_write". */ + if (regno < 0) + { + int i; @@ -883,7 +886,7 @@ + regcache_invalidate (regcache, regno); + } + -+ error (_("Process record cancel the operation.")); ++ error (_("Process record canceled the operation.")); + } + + /* Destroy the record from here forward. */ @@ -911,7 +914,7 @@ + if (RECORD_IS_REPLAY) + { + /* Let user choice if he want to write memory or not. */ -+ if (!nquery (_("Because GDB is in replay mode, writing to memory will destroy the record from this point forward. Write memory at address 0x%s?"), ++ if (!nquery (_("Because GDB is in replay mode, writing to memory will make the execute log unusable from this point onward. Write memory at address 0x%s?"), + paddr_nz (offset))) + { + return -1; @@ -930,13 +933,23 @@ + if (record_arch_list_add_mem (offset, len)) + { + record_list_release (record_arch_list_tail); -+ fprintf_unfiltered (gdb_stdlog, _("Process record: record message error.")); ++ if (record_debug) ++ { ++ fprintf_unfiltered (gdb_stdlog, ++ _ ++ ("Process record: failed to record execution log.")); ++ } + return -1; + } + if (record_arch_list_add_end (0)) + { + record_list_release (record_arch_list_tail); -+ fprintf_unfiltered (gdb_stdlog, _("Process record: record message error.")); ++ if (record_debug) ++ { ++ fprintf_unfiltered (gdb_stdlog, ++ _ ++ ("Process record: failed to record execution log.")); ++ } + return -1; + } + record_list->next = record_arch_list_head; @@ -1040,14 +1053,14 @@ + { + if (RECORD_IS_REPLAY) + { -+ if (!from_tty || query (_("Process record: delete the log from this point forward and begin to record the running message at current PC?"))) ++ if (!from_tty || query (_("Delete the log from this point forward and begin to record the running message at current PC?"))) + { + record_list_release_next (); + } + } + else + { -+ printf_unfiltered (_("Process record: already at end of record list.\n")); ++ printf_unfiltered (_("Already at end of record list.\n")); + } + + } @@ -1064,7 +1077,7 @@ +{ + if (RECORD_IS_USED) + { -+ if (!record_list || !from_tty || query (_("Process record: delete recorded log and stop recording?"))) ++ if (!record_list || !from_tty || query (_("Delete recorded log and stop recording?"))) + { + unpush_target (&record_ops); + } @@ -1082,7 +1095,7 @@ +{ + if (record_insn_num > record_insn_max_num && record_insn_max_num) + { -+ printf_unfiltered (_("Process record: record instructions number is bigger than record instructions max number. Auto delete the first ones.\n")); ++ printf_unfiltered (_("Record instructions number is bigger than record instructions max number. Auto delete the first ones?\n")); + + while (record_insn_num > record_insn_max_num) + { @@ -1107,7 +1120,7 @@ + /* Init record_maskall. */ + if (sigfillset (&record_maskall) == -1) + { -+ perror_with_name (_("Process record: sigfillset")); ++ perror_with_name (_("Process record: sigfillset failed")); + } + + /* Init record_first. */ @@ -1137,7 +1150,7 @@ + other affect to GDB such as call function "no_shared_libraries". + So I add special commands to GDB. */ + add_com ("delrecord", class_obscure, cmd_record_delete, -+ _("When process record target running in replay mode, delete the next running messages and begin to record the running message at current address.")); ++ _("Delete the rest of execution log and start recording it anew.")); + add_com_alias ("dr", "delrecord", class_obscure, 1); + add_com ("stoprecord", class_obscure, cmd_record_stop, + _("Stop the record/replay target.")); @@ -1146,12 +1159,12 @@ + /* Record instructions number limit command. */ + add_setshow_boolean_cmd ("record-stop-at-limit", no_class, + &record_stop_at_limit, -+ _("Set record/replay stop when record/replay buffer becomes full."), -+ _("Show record/replay stop when record/replay buffer becomes full."), _("\ ++ _("Set whether record/replay stop when record/replay buffer becomes full."), ++ _("Show whether record/replay stop when record/replay buffer becomes full."), _("\ +Enable is default value.\n\ -+When enable, if the record/replay buffer becomes full,\n\ -+ask user how to do.\n\ -+When disable, if the record/replay buffer becomes full,\n\ ++When enabled, if the record/replay buffer becomes full,\n\ ++ask user what to do.\n\ ++When disabled, if the record/replay buffer becomes full,\n\ +delete it and start new recording."), NULL, NULL, &setlist, &showlist); + add_setshow_zinteger_cmd ("record-insn-number-max", no_class, + &record_insn_max_num, @@ -1164,7 +1177,7 @@ + add_info ("record-insn-number", show_record_insn_number, _("\ +Show the current number of instructions in the record/replay buffer.")); +} ---- a/record.h +--- a//dev/null +++ b/record.h @@ -0,0 +1,99 @@ +/* Process record and replay target for GDB, the GNU debugger. @@ -1175,7 +1188,7 @@ + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by -+ the Free Software Foundation; either version 2 of the License, or ++ the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, ------=_Part_40467_2637849.1226823534989 Content-Type: text/plain; name=3-record_target.txt Content-Transfer-Encoding: base64 X-Attachment-Id: f_fnlf1kq80 Content-Disposition: attachment; filename=3-record_target.txt Content-length: 46031 LS0tIGEvTWFrZWZpbGUuaW4KKysrIGIvTWFrZWZpbGUuaW4KQEAgLTY1Nyw3 ICs2NTcsNyBAQAogCXZhbGFyaXRoLmMgdmFsb3BzLmMgdmFscHJpbnQuYyB2 YWx1ZS5jIHZhcm9iai5jIHZlYy5jIFwKIAl3cmFwcGVyLmMgXAogCXhtbC10 ZGVzYy5jIHhtbC1zdXBwb3J0LmMgXAotCWluZmVyaW9yLmMKKwlpbmZlcmlv ci5jIHJlY29yZC5jCiAKIExJTlRGSUxFUyA9ICQoU0ZJTEVTKSAkKFlZRklM RVMpICQoQ09ORklHX1NSQ1MpIGluaXQuYwogCkBAIC04MDgsNyArODA4LDcg QEAKIAlzb2xpYi5vIHNvbGliLW51bGwubyBcCiAJcHJvbG9ndWUtdmFsdWUu byBtZW1vcnktbWFwLm8geG1sLXN1cHBvcnQubyBcCiAJdGFyZ2V0LWRlc2Ny aXB0aW9ucy5vIHRhcmdldC1tZW1vcnkubyB4bWwtdGRlc2MubyB4bWwtYnVp bHRpbi5vIFwKLQlpbmZlcmlvci5vCisJaW5mZXJpb3IubyByZWNvcmQubwog CiBUU09CUyA9IGluZmxvdy5vCiAKLS0tIGEvL2Rldi9udWxsCisrKyBiL3Jl Y29yZC5jCkBAIC0wLDAgKzEsMTE1NiBAQAorLyogUHJvY2VzcyByZWNvcmQg YW5kIHJlcGxheSB0YXJnZXQgZm9yIEdEQiwgdGhlIEdOVSBkZWJ1Z2dlci4K KworICAgQ29weXJpZ2h0IChDKSAyMDA4IEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLgorCisgICBUaGlzIGZpbGUgaXMgcGFydCBvZiBHREIuCisK KyAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJl ZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgICBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieQorICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsg ZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IKKyAgIChhdCB5 b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisKKyAgIFRoaXMgcHJv Z3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg YmUgdXNlZnVsLAorICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRo b3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAgIE1FUkNIQU5U QUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g IFNlZSB0aGUKKyAgIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisKKyAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBh IGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgICBh bG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElmIG5vdCwgc2VlIDxodHRwOi8v d3d3LmdudS5vcmcvbGljZW5zZXMvPi4gICovCisKKyNpbmNsdWRlICJkZWZz LmgiCisjaW5jbHVkZSAidGFyZ2V0LmgiCisjaW5jbHVkZSAiZ2RiY21kLmgi CisjaW5jbHVkZSAicmVnY2FjaGUuaCIKKyNpbmNsdWRlICJpbmZlcmlvci5o IgorI2luY2x1ZGUgImdkYnRocmVhZC5oIgorI2luY2x1ZGUgInJlY29yZC5o IgorCisjaW5jbHVkZSA8c2lnbmFsLmg+CisKKyNkZWZpbmUgREVGQVVMVF9S RUNPUkRfSU5TTl9NQVhfTlVNCTIwMDAwMAorCitpbnQgcmVjb3JkX2RlYnVn ID0gMDsKKworcmVjb3JkX3QgcmVjb3JkX2ZpcnN0OworcmVjb3JkX3QgKnJl Y29yZF9saXN0ID0gJnJlY29yZF9maXJzdDsKK3JlY29yZF90ICpyZWNvcmRf YXJjaF9saXN0X2hlYWQgPSBOVUxMOworcmVjb3JkX3QgKnJlY29yZF9hcmNo X2xpc3RfdGFpbCA9IE5VTEw7CitzdHJ1Y3QgcmVnY2FjaGUgKnJlY29yZF9y ZWdjYWNoZSA9IE5VTEw7CisKKy8qIDEgYXNrIHVzZXIuIDAgYXV0byBkZWxl dGUgdGhlIGxhc3QgcmVjb3JkX3QuICAqLworc3RhdGljIGludCByZWNvcmRf c3RvcF9hdF9saW1pdCA9IDE7CitzdGF0aWMgaW50IHJlY29yZF9pbnNuX21h eF9udW0gPSBERUZBVUxUX1JFQ09SRF9JTlNOX01BWF9OVU07CitzdGF0aWMg aW50IHJlY29yZF9pbnNuX251bSA9IDA7CisKK3N0cnVjdCB0YXJnZXRfb3Bz IHJlY29yZF9vcHM7CitpbnQgcmVjb3JkX3Jlc3VtZV9zdGVwID0gMDsKK3N0 YXRpYyBpbnQgcmVjb3JkX2dldF9zaWcgPSAwOworc3RhdGljIHNpZ3NldF90 IHJlY29yZF9tYXNrYWxsOworc3RhdGljIGludCByZWNvcmRfbm90X3JlY29y ZCA9IDA7CitpbnQgcmVjb3JkX3dpbGxfc3RvcmVfcmVnaXN0ZXJzID0gMDsK KworZXh0ZXJuIHN0cnVjdCBicF9sb2NhdGlvbiAqYnBfbG9jYXRpb25fY2hh aW47CisKKy8qIFRoZSByZWFsIGJlbmVhdGggZnVuY3Rpb24gcG9pbnRlcnMu ICAqLwordm9pZCAoKnJlY29yZF9iZW5lYXRoX3RvX3Jlc3VtZSkgKHB0aWRf dCwgaW50LCBlbnVtIHRhcmdldF9zaWduYWwpOworcHRpZF90ICgqcmVjb3Jk X2JlbmVhdGhfdG9fd2FpdCkgKHB0aWRfdCwgc3RydWN0IHRhcmdldF93YWl0 c3RhdHVzICopOwordm9pZCAoKnJlY29yZF9iZW5lYXRoX3RvX3N0b3JlX3Jl Z2lzdGVycykgKHN0cnVjdCByZWdjYWNoZSAqLCBpbnQgcmVnbm8pOworTE9O R0VTVCAoKnJlY29yZF9iZW5lYXRoX3RvX3hmZXJfcGFydGlhbCkgKHN0cnVj dCB0YXJnZXRfb3BzICogb3BzLAorCQkJCQkgICBlbnVtIHRhcmdldF9vYmpl Y3Qgb2JqZWN0LAorCQkJCQkgICBjb25zdCBjaGFyICphbm5leCwKKwkJCQkJ ICAgZ2RiX2J5dGUgKiByZWFkYnVmLAorCQkJCQkgICBjb25zdCBnZGJfYnl0 ZSAqIHdyaXRlYnVmLAorCQkJCQkgICBVTE9OR0VTVCBvZmZzZXQsIExPTkdF U1QgbGVuKTsKK2ludCAoKnJlY29yZF9iZW5lYXRoX3RvX2luc2VydF9icmVh a3BvaW50KSAoc3RydWN0IGJwX3RhcmdldF9pbmZvICopOworaW50ICgqcmVj b3JkX2JlbmVhdGhfdG9fcmVtb3ZlX2JyZWFrcG9pbnQpIChzdHJ1Y3QgYnBf dGFyZ2V0X2luZm8gKik7CisKK3N0YXRpYyB2b2lkCityZWNvcmRfbGlzdF9y ZWxlYXNlIChyZWNvcmRfdCAqIHJlYykKK3sKKyAgcmVjb3JkX3QgKnRtcDsK KworICBpZiAoIXJlYykKKyAgICByZXR1cm47CisKKyAgd2hpbGUgKHJlYy0+ bmV4dCkKKyAgICB7CisgICAgICByZWMgPSByZWMtPm5leHQ7CisgICAgfQor CisgIHdoaWxlIChyZWMtPnByZXYpCisgICAgeworICAgICAgdG1wID0gcmVj OworICAgICAgcmVjID0gcmVjLT5wcmV2OworICAgICAgaWYgKHRtcC0+dHlw ZSA9PSByZWNvcmRfcmVnKQorCXsKKwkgIHhmcmVlICh0bXAtPnUucmVnLnZh bCk7CisJfQorICAgICAgZWxzZSBpZiAodG1wLT50eXBlID09IHJlY29yZF9t ZW0pCisJeworCSAgeGZyZWUgKHRtcC0+dS5tZW0udmFsKTsKKwl9CisgICAg ICB4ZnJlZSAodG1wKTsKKyAgICB9CisKKyAgaWYgKHJlYyAhPSAmcmVjb3Jk X2ZpcnN0KQorICAgIHsKKyAgICAgIHhmcmVlIChyZWMpOworICAgIH0KK30K Kworc3RhdGljIHZvaWQKK3JlY29yZF9saXN0X3JlbGVhc2VfbmV4dCAodm9p ZCkKK3sKKyAgcmVjb3JkX3QgKnJlYyA9IHJlY29yZF9saXN0OworICByZWNv cmRfdCAqdG1wID0gcmVjLT5uZXh0OworICByZWMtPm5leHQgPSBOVUxMOwor ICB3aGlsZSAodG1wKQorICAgIHsKKyAgICAgIHJlYyA9IHRtcC0+bmV4dDsK KyAgICAgIGlmICh0bXAtPnR5cGUgPT0gcmVjb3JkX3JlZykKKwl7CisJICBy ZWNvcmRfaW5zbl9udW0tLTsKKwl9CisgICAgICBlbHNlIGlmICh0bXAtPnR5 cGUgPT0gcmVjb3JkX3JlZykKKwl7CisJICB4ZnJlZSAodG1wLT51LnJlZy52 YWwpOworCX0KKyAgICAgIGVsc2UgaWYgKHRtcC0+dHlwZSA9PSByZWNvcmRf bWVtKQorCXsKKwkgIHhmcmVlICh0bXAtPnUubWVtLnZhbCk7CisJfQorICAg ICAgeGZyZWUgKHRtcCk7CisgICAgICB0bXAgPSByZWM7CisgICAgfQorfQor CitzdGF0aWMgdm9pZAorcmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdCAodm9p ZCkKK3sKKyAgcmVjb3JkX3QgKnRtcCA9IE5VTEw7CisgIGVudW0gcmVjb3Jk X3R5cGUgdHlwZTsKKworICBpZiAoIXJlY29yZF9maXJzdC5uZXh0KQorICAg IHsKKyAgICAgIHJldHVybjsKKyAgICB9CisKKyAgd2hpbGUgKDEpCisgICAg eworICAgICAgdHlwZSA9IHJlY29yZF9maXJzdC5uZXh0LT50eXBlOworCisg ICAgICBpZiAodHlwZSA9PSByZWNvcmRfcmVnKQorCXsKKwkgIHhmcmVlIChy ZWNvcmRfZmlyc3QubmV4dC0+dS5yZWcudmFsKTsKKwl9CisgICAgICBlbHNl IGlmICh0eXBlID09IHJlY29yZF9tZW0pCisJeworCSAgeGZyZWUgKHJlY29y ZF9maXJzdC5uZXh0LT51Lm1lbS52YWwpOworCX0KKyAgICAgIHRtcCA9IHJl Y29yZF9maXJzdC5uZXh0OworICAgICAgcmVjb3JkX2ZpcnN0Lm5leHQgPSB0 bXAtPm5leHQ7CisgICAgICB4ZnJlZSAodG1wKTsKKworICAgICAgaWYgKCFy ZWNvcmRfZmlyc3QubmV4dCkKKwl7CisJICBnZGJfYXNzZXJ0IChyZWNvcmRf aW5zbl9udW0gPT0gMSk7CisJICBicmVhazsKKwl9CisKKyAgICAgIHJlY29y ZF9maXJzdC5uZXh0LT5wcmV2ID0gJnJlY29yZF9maXJzdDsKKworICAgICAg aWYgKHR5cGUgPT0gcmVjb3JkX2VuZCkKKwl7CisJICBicmVhazsKKwl9Cisg ICAgfQorCisgIHJlY29yZF9pbnNuX251bS0tOworfQorCisvKiBBZGQgYSBy ZWNvcmRfdCB0byByZWNvcmRfYXJjaF9saXN0LiAgKi8KK3N0YXRpYyB2b2lk CityZWNvcmRfYXJjaF9saXN0X2FkZCAocmVjb3JkX3QgKiByZWMpCit7Cisg IGlmIChyZWNvcmRfYXJjaF9saXN0X3RhaWwpCisgICAgeworICAgICAgcmVj b3JkX2FyY2hfbGlzdF90YWlsLT5uZXh0ID0gcmVjOworICAgICAgcmVjLT5w cmV2ID0gcmVjb3JkX2FyY2hfbGlzdF90YWlsOworICAgICAgcmVjb3JkX2Fy Y2hfbGlzdF90YWlsID0gcmVjOworICAgIH0KKyAgZWxzZQorICAgIHsKKyAg ICAgIHJlY29yZF9hcmNoX2xpc3RfaGVhZCA9IHJlYzsKKyAgICAgIHJlY29y ZF9hcmNoX2xpc3RfdGFpbCA9IHJlYzsKKyAgICB9Cit9CisKKy8qIFJlY29y ZCB0aGUgdmFsdWUgb2YgYSByZWdpc3RlciAoIm51bSIpIHRvIHJlY29yZF9h cmNoX2xpc3QuICAqLworaW50CityZWNvcmRfYXJjaF9saXN0X2FkZF9yZWcg KGludCBudW0pCit7CisgIHJlY29yZF90ICpyZWM7CisKKyAgaWYgKHJlY29y ZF9kZWJ1ZyA+IDEpCisgICAgeworICAgICAgZnByaW50Zl91bmZpbHRlcmVk IChnZGJfc3RkbG9nLAorCQkJICAiUHJvY2VzcyByZWNvcmQ6IGFkZCByZWdp c3RlciBudW0gPSAlZCB0byByZWNvcmQgbGlzdC5cbiIsIAorCQkJICBudW0p OworICAgIH0KKworICByZWMgPSAocmVjb3JkX3QgKikgeG1hbGxvYyAoc2l6 ZW9mIChyZWNvcmRfdCkpOworICByZWMtPnUucmVnLnZhbCA9IChnZGJfYnl0 ZSAqKSB4bWFsbG9jIChNQVhfUkVHSVNURVJfU0laRSk7CisgIHJlYy0+cHJl diA9IE5VTEw7CisgIHJlYy0+bmV4dCA9IE5VTEw7CisgIHJlYy0+dHlwZSA9 IHJlY29yZF9yZWc7CisgIHJlYy0+dS5yZWcubnVtID0gbnVtOworCisgIHJl Z2NhY2hlX3Jhd19yZWFkIChyZWNvcmRfcmVnY2FjaGUsIG51bSwgcmVjLT51 LnJlZy52YWwpOworCisgIHJlY29yZF9hcmNoX2xpc3RfYWRkIChyZWMpOwor CisgIHJldHVybiAoMCk7Cit9CisKKy8qIFJlY29yZCB0aGUgdmFsdWUgb2Yg YSByZWdpb24gb2YgbWVtb3J5IHdob3NlIGFkZHJlc3MgaXMgImFkZHIiIGFu ZAorICAgbGVuZ3RoIGlzICJsZW4iIHRvIHJlY29yZF9hcmNoX2xpc3QuICAq LworCitpbnQKK3JlY29yZF9hcmNoX2xpc3RfYWRkX21lbSAoQ09SRV9BRERS IGFkZHIsIGludCBsZW4pCit7CisgIHJlY29yZF90ICpyZWM7CisKKyAgaWYg KHJlY29yZF9kZWJ1ZyA+IDEpCisgICAgeworICAgICAgZnByaW50Zl91bmZp bHRlcmVkIChnZGJfc3RkbG9nLAorCQkJICAiUHJvY2VzcyByZWNvcmQ6IGFk ZCBtZW0gYWRkciA9IDB4JXMgbGVuID0gJWQgdG8gcmVjb3JkIGxpc3QuXG4i LAorCQkJICBwYWRkcl9ueiAoYWRkciksIGxlbik7CisgICAgfQorCisgIGlm ICghYWRkcikKKyAgICB7CisgICAgICByZXR1cm4gKDApOworICAgIH0KKwor ICByZWMgPSAocmVjb3JkX3QgKikgeG1hbGxvYyAoc2l6ZW9mIChyZWNvcmRf dCkpOworICByZWMtPnUubWVtLnZhbCA9IChnZGJfYnl0ZSAqKSB4bWFsbG9j IChsZW4pOworICByZWMtPnByZXYgPSBOVUxMOworICByZWMtPm5leHQgPSBO VUxMOworICByZWMtPnR5cGUgPSByZWNvcmRfbWVtOworICByZWMtPnUubWVt LmFkZHIgPSBhZGRyOworICByZWMtPnUubWVtLmxlbiA9IGxlbjsKKworICBp ZiAodGFyZ2V0X3JlYWRfbWVtb3J5IChhZGRyLCByZWMtPnUubWVtLnZhbCwg bGVuKSkKKyAgICB7CisgICAgICBpZiAocmVjb3JkX2RlYnVnKQorCXsKKwkg IGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKKwkJCSAgICAgICJQ cm9jZXNzIHJlY29yZDogZXJyb3IgcmVhZGluZyBtZW1vcnkgYXQgYWRkciA9 IDB4JXMgbGVuID0gJWQuXG4iLAorCQkJICAgICAgcGFkZHJfbnogKGFkZHIp LCBsZW4pOworCX0KKyAgICAgIHhmcmVlIChyZWMtPnUubWVtLnZhbCk7Cisg ICAgICB4ZnJlZSAocmVjKTsKKyAgICAgIHJldHVybiAoLTEpOworICAgIH0K KworICByZWNvcmRfYXJjaF9saXN0X2FkZCAocmVjKTsKKworICByZXR1cm4g KDApOworfQorCisvKiBBZGQgYSByZWNvcmRfZW5kIHR5cGUgcmVjb3JkX3Qg dG8gcmVjb3JkX2FyY2hfbGlzdC4gICovCitpbnQKK3JlY29yZF9hcmNoX2xp c3RfYWRkX2VuZCAoaW50IG5lZWRfZGFzbSkKK3sKKyAgcmVjb3JkX3QgKnJl YzsKKworICBpZiAocmVjb3JkX2RlYnVnID4gMSkKKyAgICB7CisgICAgICBm cHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csCisJCQkgICJQcm9jZXNz IHJlY29yZDogYWRkIGVuZCBuZWVkX2Rhc20gPSAlZCB0byBhcmNoIGxpc3Qu XG4iLAorCQkJICBuZWVkX2Rhc20pOworICAgIH0KKworICByZWMgPSAocmVj b3JkX3QgKikgeG1hbGxvYyAoc2l6ZW9mIChyZWNvcmRfdCkpOworICByZWMt PnByZXYgPSBOVUxMOworICByZWMtPm5leHQgPSBOVUxMOworICByZWMtPnR5 cGUgPSByZWNvcmRfZW5kOworCisgIHJlYy0+dS5uZWVkX2Rhc20gPSBuZWVk X2Rhc207CisKKyAgcmVjb3JkX2FyY2hfbGlzdF9hZGQgKHJlYyk7CisKKyAg cmV0dXJuICgwKTsKK30KKworc3RhdGljIHZvaWQKK3JlY29yZF9jaGVja19p bnNuX251bSAoaW50IHNldF90ZXJtaW5hbCkKK3sKKyAgaWYgKHJlY29yZF9p bnNuX21heF9udW0pCisgICAgeworICAgICAgZ2RiX2Fzc2VydCAocmVjb3Jk X2luc25fbnVtIDw9IHJlY29yZF9pbnNuX21heF9udW0pOworICAgICAgaWYg KHJlY29yZF9pbnNuX251bSA9PSByZWNvcmRfaW5zbl9tYXhfbnVtKQorCXsK KwkgIC8qIEFzayB1c2VyIHdoYXQgdG8gZG8gKi8KKwkgIGlmIChyZWNvcmRf c3RvcF9hdF9saW1pdCkKKwkgICAgeworCSAgICAgIGludCBxOworCSAgICAg IGlmIChzZXRfdGVybWluYWwpCisJCXRhcmdldF90ZXJtaW5hbF9vdXJzICgp OworCSAgICAgIHEgPSB5cXVlcnkgKF8oIkRvIHlvdSB3YW50IHRvIGF1dG8g ZGVsZXRlIHByZXZpb3VzIGV4ZWN1dGUgbG9nIGVudHJpZXMgd2hlbiByZWNv cmQvcmVwbGF5IGJ1ZmZlciBiZWNvbWVzIGZ1bGwgKHJlY29yZC1zdG9wLWF0 LWxpbWl0KT8iKSk7CisJICAgICAgaWYgKHNldF90ZXJtaW5hbCkKKwkJdGFy Z2V0X3Rlcm1pbmFsX2luZmVyaW9yICgpOworCSAgICAgIGlmIChxKQorCQl7 CisJCSAgcmVjb3JkX3N0b3BfYXRfbGltaXQgPSAwOworCQl9CisJICAgICAg ZWxzZQorCQl7CisJCSAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBpbmZl cmlvciBwcm9ncmFtIHN0b3BwZWQuIikpOworCQl9CisJICAgIH0KKwl9Cisg ICAgfQorfQorCisvKiBCZWZvcmUgaW5mZXJpb3Igc3RlcCAod2hlbiBHREIg cmVjb3JkIHRoZSBydW5uaW5nIG1lc3NhZ2UsIGluZmVyaW9yCisgICBvbmx5 IGNhbiBzdGVwKSwgR0RCIHdpbGwgY2FsbCB0aGlzIGZ1bmN0aW9uIHRvIHJl Y29yZCB0aGUgdmFsdWVzIHRvCisgICByZWNvcmRfbGlzdC4gIFRoaXMgZnVu Y3Rpb24gd2lsbCBjYWxsIGdkYmFyY2hfcHJvY2Vzc19yZWNvcmQgdG8KKyAg IHJlY29yZCB0aGUgcnVubmluZyBtZXNzYWdlIG9mIGluZmVyaW9yIGFuZCBz ZXQgdGhlbSB0bworICAgcmVjb3JkX2FyY2hfbGlzdCwgYW5kIGFkZCBpdCB0 byByZWNvcmRfbGlzdC4gICovCisKK3N0YXRpYyB2b2lkCityZWNvcmRfbWVz c2FnZV9jbGVhbnVwcyAodm9pZCAqaWdub3JlKQoreworICByZWNvcmRfbGlz dF9yZWxlYXNlIChyZWNvcmRfYXJjaF9saXN0X3RhaWwpOworICBzZXRfZXhl Y3V0aW5nIChpbmZlcmlvcl9wdGlkLCAwKTsKKyAgbm9ybWFsX3N0b3AgKCk7 Cit9CisKK3ZvaWQKK3JlY29yZF9tZXNzYWdlIChzdHJ1Y3QgZ2RiYXJjaCAq Z2RiYXJjaCkKK3sKKyAgaW50IHJldDsKKyAgc3RydWN0IGNsZWFudXAgKm9s ZF9jbGVhbnVwcyA9IG1ha2VfY2xlYW51cCAocmVjb3JkX21lc3NhZ2VfY2xl YW51cHMsIDApOworCisgIC8qIENoZWNrIHJlY29yZF9pbnNuX251bS4gICov CisgIHJlY29yZF9jaGVja19pbnNuX251bSAoMSk7CisKKyAgcmVjb3JkX2Fy Y2hfbGlzdF9oZWFkID0gTlVMTDsKKyAgcmVjb3JkX2FyY2hfbGlzdF90YWls ID0gTlVMTDsKKyAgcmVjb3JkX3JlZ2NhY2hlID0gZ2V0X2N1cnJlbnRfcmVn Y2FjaGUgKCk7CisKKyAgcmV0ID0gZ2RiYXJjaF9wcm9jZXNzX3JlY29yZCAo Z2RiYXJjaCwgCisJCQkJcmVnY2FjaGVfcmVhZF9wYyAocmVjb3JkX3JlZ2Nh Y2hlKSk7CisgIGlmIChyZXQgPiAwKQorICAgIGVycm9yIChfKCJQcm9jZXNz IHJlY29yZDogaW5mZXJpb3IgcHJvZ3JhbSBzdG9wcGVkLiIpKTsKKyAgaWYg KHJldCA8IDApCisgICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBmYWls ZWQgdG8gcmVjb3JkIGV4ZWN1dGlvbiBsb2cuIikpOworCisgIGRpc2NhcmRf Y2xlYW51cHMgKG9sZF9jbGVhbnVwcyk7CisKKyAgcmVjb3JkX2xpc3QtPm5l eHQgPSByZWNvcmRfYXJjaF9saXN0X2hlYWQ7CisgIHJlY29yZF9hcmNoX2xp c3RfaGVhZC0+cHJldiA9IHJlY29yZF9saXN0OworICByZWNvcmRfbGlzdCA9 IHJlY29yZF9hcmNoX2xpc3RfdGFpbDsKKworICBpZiAocmVjb3JkX2luc25f bnVtID09IHJlY29yZF9pbnNuX21heF9udW0gJiYgcmVjb3JkX2luc25fbWF4 X251bSkKKyAgICB7CisgICAgICByZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0 ICgpOworICAgIH0KKyAgZWxzZQorICAgIHsKKyAgICAgIHJlY29yZF9pbnNu X251bSsrOworICAgIH0KK30KKworLyogVGhpbmdzIHRvIGNsZWFuIHVwIGlm IHdlIFFVSVQgb3V0IG9mIGZ1bmN0aW9uIHRoYXQgc2V0CisgICByZWNvcmRf bm90X3JlY29yZC4gICovCitzdGF0aWMgdm9pZAorcmVjb3JkX25vdF9yZWNv cmRfY2xlYW51cHMgKHZvaWQgKmlnbm9yZSkKK3sKKyAgcmVjb3JkX25vdF9y ZWNvcmQgPSAwOworfQorCit2b2lkCityZWNvcmRfbm90X3JlY29yZF9zZXQg KHZvaWQpCit7CisgIHN0cnVjdCBjbGVhbnVwICpvbGRfY2xlYW51cHMgPSBt YWtlX2NsZWFudXAgKHJlY29yZF9ub3RfcmVjb3JkX2NsZWFudXBzLCAwKTsK KyAgcmVjb3JkX25vdF9yZWNvcmQgPSAxOworfQorCitzdGF0aWMgdm9pZAor cmVjb3JkX29wZW4gKGNoYXIgKm5hbWUsIGludCBmcm9tX3R0eSkKK3sKKyAg aWYgKHJlY29yZF9kZWJ1ZykKKyAgICB7CisgICAgICBmcHJpbnRmX3VuZmls dGVyZWQgKGdkYl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogcmVjb3JkX29w ZW5cbiIpOworICAgIH0KKworICAvKiBjaGVjayBleGVjICovCisgIGlmICgh dGFyZ2V0X2hhc19leGVjdXRpb24pCisgICAgeworICAgICAgZXJyb3IgKF8o IlByb2Nlc3MgcmVjb3JkOiB0aGUgcHJvZ3JhbSBpcyBub3QgYmVpbmcgcnVu LiIpKTsKKyAgICB9CisgIGlmIChub25fc3RvcCkKKyAgICB7CisgICAgICBl cnJvciAoXygiUHJvY2VzcyByZWNvcmQgdGFyZ2V0IGNhbid0IGRlYnVnIGlu ZmVyaW9yIGluIG5vbi1zdG9wIG1vZGUgKG5vbi1zdG9wKS4iKSk7CisgICAg fQorICBpZiAodGFyZ2V0X2FzeW5jX3Blcm1pdHRlZCkKKyAgICB7CisgICAg ICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQgdGFyZ2V0IGNhbid0IGRlYnVn IGluZmVyaW9yIGluIGFzeW5jaHJvbm91cyBtb2RlICh0YXJnZXQtYXN5bmMp LiIpKTsKKyAgICB9CisKKyAgaWYgKCFnZGJhcmNoX3Byb2Nlc3NfcmVjb3Jk X3AgKGN1cnJlbnRfZ2RiYXJjaCkpCisgICAgeworICAgICAgZXJyb3IgKF8o IlByb2Nlc3MgcmVjb3JkOiB0aGUgY3VycmVudCBhcmNoaXRlY3R1cmUgZG9l c24ndCBzdXBwb3J0IHJlY29yZCBmdW5jdGlvbi4iKSk7CisgICAgfQorCisg IC8qIENoZWNrIGlmIHJlY29yZCB0YXJnZXQgaXMgYWxyZWFkeSBydW5uaW5n ICovCisgIGlmIChSRUNPUkRfSVNfVVNFRCkKKyAgICB7CisgICAgICBpZiAo IW5xdWVyeQorCSAgKF8oIlByb2Nlc3MgcmVjb3JkIHRhcmdldCBhbHJlYWR5 IHJ1bm5pbmcsIGRvIHlvdSB3YW50IHRvIGRlbGV0ZSB0aGUgb2xkIHJlY29y ZCBsb2c/IikpKQorCXsKKwkgIHJldHVybjsKKwl9CisgICAgfQorCisgIHB1 c2hfdGFyZ2V0ICgmcmVjb3JkX29wcyk7CisKKyAgLyogUmVzZXQgKi8KKyAg cmVjb3JkX2luc25fbnVtID0gMDsKKyAgcmVjb3JkX2xpc3QgPSAmcmVjb3Jk X2ZpcnN0OworICByZWNvcmRfbGlzdC0+bmV4dCA9IE5VTEw7Cit9CisKK3N0 YXRpYyB2b2lkCityZWNvcmRfY2xvc2UgKGludCBxdWl0dGluZykKK3sKKyAg aWYgKHJlY29yZF9kZWJ1ZykKKyAgICB7CisgICAgICBmcHJpbnRmX3VuZmls dGVyZWQgKGdkYl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogcmVjb3JkX2Ns b3NlXG4iKTsKKyAgICB9CisgIHJlY29yZF9saXN0X3JlbGVhc2UgKHJlY29y ZF9saXN0KTsKK30KKworc3RhdGljIHZvaWQKK3JlY29yZF9yZXN1bWUgKHB0 aWRfdCBwdGlkLCBpbnQgc3RlcCwgZW51bSB0YXJnZXRfc2lnbmFsIHNpZ2du YWwpCit7CisgIHJlY29yZF9yZXN1bWVfc3RlcCA9IHN0ZXA7CisKKyAgaWYg KCFSRUNPUkRfSVNfUkVQTEFZKQorICAgIHsKKyAgICAgIHJlY29yZF9tZXNz YWdlIChjdXJyZW50X2dkYmFyY2gpOworICAgICAgcmVjb3JkX2JlbmVhdGhf dG9fcmVzdW1lIChwdGlkLCAxLCBzaWdnbmFsKTsKKyAgICB9Cit9CisKK3N0 YXRpYyB2b2lkCityZWNvcmRfc2lnX2hhbmRsZXIgKGludCBzaWdubykKK3sK KyAgaWYgKHJlY29yZF9kZWJ1ZykKKyAgICB7CisgICAgICBmcHJpbnRmX3Vu ZmlsdGVyZWQgKGdkYl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogZ2V0IGEg c2lnbmFsXG4iKTsKKyAgICB9CisgIHJlY29yZF9yZXN1bWVfc3RlcCA9IDE7 CisgIHJlY29yZF9nZXRfc2lnID0gMTsKK30KKworc3RhdGljIHZvaWQKK3Jl Y29yZF93YWl0X2NsZWFudXBzICh2b2lkICppZ25vcmUpCit7CisgIGlmIChl eGVjdXRpb25fZGlyZWN0aW9uID09IEVYRUNfUkVWRVJTRSkKKyAgICB7Cisg ICAgICBpZiAocmVjb3JkX2xpc3QtPm5leHQpCisJeworCSAgcmVjb3JkX2xp c3QgPSByZWNvcmRfbGlzdC0+bmV4dDsKKwl9CisgICAgfQorICBlbHNlCisg ICAgeworICAgICAgcmVjb3JkX2xpc3QgPSByZWNvcmRfbGlzdC0+cHJldjsK KyAgICB9CisgIHNldF9leGVjdXRpbmcgKGluZmVyaW9yX3B0aWQsIDApOwor ICBub3JtYWxfc3RvcCAoKTsKK30KKworLyogcmVjb3JkX3dhaXQKKyAgIElu IHJlcGxheSBtb2RlLCB0aGlzIGZ1bmN0aW9uIGV4YW1pbmVzIHRoZSByZWNv cmRlZCBsb2cgYW5kCisgICBkZXRlcm1pbmVzIHdoZXJlIHRvIHN0b3AuICAq LworCitzdGF0aWMgcHRpZF90CityZWNvcmRfd2FpdCAocHRpZF90IHB0aWQs IHN0cnVjdCB0YXJnZXRfd2FpdHN0YXR1cyAqc3RhdHVzKQoreworICBpZiAo cmVjb3JkX2RlYnVnKQorICAgIHsKKyAgICAgIGZwcmludGZfdW5maWx0ZXJl ZCAoZ2RiX3N0ZGxvZywKKwkJCSAgIlByb2Nlc3MgcmVjb3JkOiByZWNvcmRf d2FpdCByZWNvcmRfcmVzdW1lX3N0ZXAgPSAlZFxuIiwKKwkJCSAgcmVjb3Jk X3Jlc3VtZV9zdGVwKTsKKyAgICB9CisKKyAgaWYgKCFSRUNPUkRfSVNfUkVQ TEFZKQorICAgIHsKKyAgICAgIHJldHVybiByZWNvcmRfYmVuZWF0aF90b193 YWl0IChwdGlkLCBzdGF0dXMpOworICAgIH0KKyAgZWxzZQorICAgIHsKKyAg ICAgIHN0cnVjdCBzaWdhY3Rpb24gYWN0LCBvbGRfYWN0OworICAgICAgaW50 IG5lZWRfZGFzbSA9IDA7CisgICAgICBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2Nh Y2hlID0gZ2V0X2N1cnJlbnRfcmVnY2FjaGUgKCk7CisgICAgICBpbnQgY29u dGludWVfZmxhZyA9IDE7CisgICAgICBpbnQgZmlyc3RfcmVjb3JkX2VuZCA9 IDE7CisgICAgICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFudXBzID0gbWFr ZV9jbGVhbnVwIChyZWNvcmRfd2FpdF9jbGVhbnVwcywgMCk7CisgICAgICBD T1JFX0FERFIgdG1wX3BjOworCisgICAgICBzdGF0dXMtPmtpbmQgPSBUQVJH RVRfV0FJVEtJTkRfU1RPUFBFRDsKKworICAgICAgLyogQ2hlY2sgYnJlYWtw b2ludCB3aGVuIGZvcndhcmQgZXhlY3V0ZS4gICovCisgICAgICBpZiAoZXhl Y3V0aW9uX2RpcmVjdGlvbiA9PSBFWEVDX0ZPUldBUkQpCisJeworCSAgdG1w X3BjID0gcmVnY2FjaGVfcmVhZF9wYyAocmVnY2FjaGUpOworCSAgaWYgKGJy ZWFrcG9pbnRfaW5zZXJ0ZWRfaGVyZV9wICh0bXBfcGMpKQorCSAgICB7CisJ ICAgICAgaWYgKHJlY29yZF9kZWJ1ZykKKwkJeworCQkgIGZwcmludGZfdW5m aWx0ZXJlZCAoZ2RiX3N0ZGxvZywKKwkJCQkgICAgICAiUHJvY2VzcyByZWNv cmQ6IGJyZWFrIGF0IDB4JXMuXG4iLAorCQkJCSAgICAgIHBhZGRyX256ICh0 bXBfcGMpKTsKKwkJfQorCSAgICAgIGlmIChnZGJhcmNoX2RlY3JfcGNfYWZ0 ZXJfYnJlYWsgKGdldF9yZWdjYWNoZV9hcmNoIChyZWdjYWNoZSkpCisJCSAg JiYgIXJlY29yZF9yZXN1bWVfc3RlcCkKKwkJeworCQkgIHJlZ2NhY2hlX3dy aXRlX3BjIChyZWdjYWNoZSwKKwkJCQkgICAgIHRtcF9wYyArCisJCQkJICAg ICBnZGJhcmNoX2RlY3JfcGNfYWZ0ZXJfYnJlYWsKKwkJCQkgICAgIChnZXRf cmVnY2FjaGVfYXJjaCAocmVnY2FjaGUpKSk7CisJCX0KKwkgICAgICBnb3Rv IHJlcGxheV9vdXQ7CisJICAgIH0KKwl9CisKKyAgICAgIHJlY29yZF9nZXRf c2lnID0gMDsKKyAgICAgIGFjdC5zYV9oYW5kbGVyID0gcmVjb3JkX3NpZ19o YW5kbGVyOworICAgICAgYWN0LnNhX21hc2sgPSByZWNvcmRfbWFza2FsbDsK KyAgICAgIGFjdC5zYV9mbGFncyA9IFNBX1JFU1RBUlQ7CisgICAgICBpZiAo c2lnYWN0aW9uIChTSUdJTlQsICZhY3QsICZvbGRfYWN0KSkKKwl7CisJICBw ZXJyb3Jfd2l0aF9uYW1lIChfKCJQcm9jZXNzIHJlY29yZDogc2lnYWN0aW9u IGZhaWxlZCIpKTsKKwl9CisgICAgICAvKiBJZiBHREIgaXMgaW4gdGVybWlu YWxfaW5mZXJpb3IsIGl0IHdpbGwgbm90IGdldCB0aGUgc2lnbmFsLgorICAg ICAgICAgQW5kIGluIEdEQiByZXBsYXkgbW9kZSwgR0RCIGRvZXNuJ3QgbmVl ZCB0byBpbiB0ZXJtaW5hbF9pbmZlcmlvcgorICAgICAgICAgYmVjYXVzZSBp bmZlcmlvciB3aWxsIG5vdCBleGVjdXRlZC4KKyAgICAgICAgIFRoZW4gc2V0 IGl0IHRvIHRlcm1pbmFsX291cnMgdG8gbWFrZSBHREIgZ2V0IHRoZSBzaWdu YWwuICAqLworICAgICAgdGFyZ2V0X3Rlcm1pbmFsX291cnMgKCk7CisKKyAg ICAgIC8qIEluIEVYRUNfRk9SV0FSRCBtb2RlLCByZWNvcmRfbGlzdCBwb2lu dCB0byB0aGUgdGFpbCBvZiBwcmV2CisgICAgICAgICBpbnN0cnVjdGlvbi4g ICovCisgICAgICBpZiAoZXhlY3V0aW9uX2RpcmVjdGlvbiA9PSBFWEVDX0ZP UldBUkQgJiYgcmVjb3JkX2xpc3QtPm5leHQpCisgICAgICAgIHsKKwkgIHJl Y29yZF9saXN0ID0gcmVjb3JkX2xpc3QtPm5leHQ7CisJfQorCisgICAgICAv KiBMb29wIG92ZXIgdGhlIHJlY29yZF9saXN0LCBsb29raW5nIGZvciB0aGUg bmV4dCBwbGFjZSB0bworCSBzdG9wLiAgKi8KKyAgICAgIGRvCisJeworCSAg LyogQ2hlY2sgZm9yIGJlZ2lubmluZyBhbmQgZW5kIG9mIGxvZy4gICovCisJ ICBpZiAoZXhlY3V0aW9uX2RpcmVjdGlvbiA9PSBFWEVDX1JFVkVSU0UgCisJ ICAgICAgJiYgcmVjb3JkX2xpc3QgPT0gJnJlY29yZF9maXJzdCkKKwkgICAg eworCSAgICAgIC8qIEhpdCBiZWdpbm5pbmcgb2YgcmVjb3JkIGxvZyBpbiBy ZXZlcnNlLiAgKi8KKwkgICAgICBzdGF0dXMtPmtpbmQgPSBUQVJHRVRfV0FJ VEtJTkRfTk9fSElTVE9SWTsKKwkgICAgICBicmVhazsKKwkgICAgfQorCSAg aWYgKGV4ZWN1dGlvbl9kaXJlY3Rpb24gIT0gRVhFQ19SRVZFUlNFICYmICFy ZWNvcmRfbGlzdC0+bmV4dCkKKwkgICAgeworCSAgICAgIC8qIEhpdCBlbmQg b2YgcmVjb3JkIGxvZyBnb2luZyBmb3J3YXJkLiAgKi8KKwkgICAgICBzdGF0 dXMtPmtpbmQgPSBUQVJHRVRfV0FJVEtJTkRfTk9fSElTVE9SWTsKKwkgICAg ICBicmVhazsKKwkgICAgfQorCisJICAvKiBzZXQgcHRpZCwgcmVnaXN0ZXIg YW5kIG1lbW9yeSBhY2NvcmRpbmcgdG8gcmVjb3JkX2xpc3QgKi8KKwkgIGlm IChyZWNvcmRfbGlzdC0+dHlwZSA9PSByZWNvcmRfcmVnKQorCSAgICB7CisJ ICAgICAgLyogcmVnICovCisJICAgICAgZ2RiX2J5dGUgcmVnW01BWF9SRUdJ U1RFUl9TSVpFXTsKKwkgICAgICBpZiAocmVjb3JkX2RlYnVnID4gMSkKKwkJ eworCQkgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKKwkJCQkg ICAgICAiUHJvY2VzcyByZWNvcmQ6IHJlY29yZF9yZWcgMHglcyB0byBpbmZl cmlvciBudW0gPSAlZC5cbiIsCisJCQkJICAgICAgcGFkZHJfbnogKChDT1JF X0FERFIpcmVjb3JkX2xpc3QpLAorCQkJCSAgICAgIHJlY29yZF9saXN0LT51 LnJlZy5udW0pOworCQl9CisJICAgICAgcmVnY2FjaGVfY29va2VkX3JlYWQg KHJlZ2NhY2hlLCByZWNvcmRfbGlzdC0+dS5yZWcubnVtLCByZWcpOworCSAg ICAgIHJlZ2NhY2hlX2Nvb2tlZF93cml0ZSAocmVnY2FjaGUsIHJlY29yZF9s aXN0LT51LnJlZy5udW0sCisJCQkJICAgICByZWNvcmRfbGlzdC0+dS5yZWcu dmFsKTsKKwkgICAgICBtZW1jcHkgKHJlY29yZF9saXN0LT51LnJlZy52YWws IHJlZywgTUFYX1JFR0lTVEVSX1NJWkUpOworCSAgICB9CisJICBlbHNlIGlm IChyZWNvcmRfbGlzdC0+dHlwZSA9PSByZWNvcmRfbWVtKQorCSAgICB7CisJ ICAgICAgLyogbWVtICovCisJICAgICAgZ2RiX2J5dGUgKm1lbSA9IGFsbG9j YSAocmVjb3JkX2xpc3QtPnUubWVtLmxlbik7CisJICAgICAgaWYgKHJlY29y ZF9kZWJ1ZyA+IDEpCisJCXsKKwkJICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdk Yl9zdGRsb2csCisJCQkJICAgICAgIlByb2Nlc3MgcmVjb3JkOiByZWNvcmRf bWVtIDB4JXMgdG8gaW5mZXJpb3IgYWRkciA9IDB4JXMgbGVuID0gJWQuXG4i LAorCQkJCSAgICAgIHBhZGRyX256ICgoQ09SRV9BRERSKXJlY29yZF9saXN0 KSwKKwkJCQkgICAgICBwYWRkcl9ueiAocmVjb3JkX2xpc3QtPnUubWVtLmFk ZHIpLAorCQkJCSAgICAgIHJlY29yZF9saXN0LT51Lm1lbS5sZW4pOworCQl9 CisJICAgICAgaWYgKHRhcmdldF9yZWFkX21lbW9yeQorCQkgIChyZWNvcmRf bGlzdC0+dS5tZW0uYWRkciwgbWVtLCByZWNvcmRfbGlzdC0+dS5tZW0ubGVu KSkKKwkJeworCQkgIGVycm9yIChfKCJQcm9jZXNzIHJlY29yZDogZXJyb3Ig cmVhZGluZyBtZW1vcnkgYXQgYWRkciA9IDB4JXMgbGVuID0gJWQuIiksCisJ CQkgcGFkZHJfbnogKHJlY29yZF9saXN0LT51Lm1lbS5hZGRyKSwKKwkJCSBy ZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsKKwkJfQorCSAgICAgIGlmICh0YXJn ZXRfd3JpdGVfbWVtb3J5CisJCSAgKHJlY29yZF9saXN0LT51Lm1lbS5hZGRy LCByZWNvcmRfbGlzdC0+dS5tZW0udmFsLAorCQkgICByZWNvcmRfbGlzdC0+ dS5tZW0ubGVuKSkKKwkJeworCQkgIGVycm9yIChfCisJCQkgKCJQcm9jZXNz IHJlY29yZDogZXJyb3Igd3JpdGluZyBtZW1vcnkgYXQgYWRkciA9IDB4JXMg bGVuID0gJWQuIiksCisJCQkgcGFkZHJfbnogKHJlY29yZF9saXN0LT51Lm1l bS5hZGRyKSwKKwkJCSByZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsKKwkJfQor CSAgICAgIG1lbWNweSAocmVjb3JkX2xpc3QtPnUubWVtLnZhbCwgbWVtLCBy ZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsKKwkgICAgfQorCSAgZWxzZQorCSAg ICB7CisJICAgICAgaWYgKHJlY29yZF9kZWJ1ZyA+IDEpCisJCXsKKwkJICBm cHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csCisJCQkJICAgICAgIlBy b2Nlc3MgcmVjb3JkOiByZWNvcmRfZW5kIDB4JXMgdG8gaW5mZXJpb3IgbmVl ZF9kYXNtID0gJWQuXG4iLAorCQkJCSAgICAgIHBhZGRyX256ICgoQ09SRV9B RERSKXJlY29yZF9saXN0KSwKKwkJCQkgICAgICByZWNvcmRfbGlzdC0+dS5u ZWVkX2Rhc20pOworCQl9CisKKwkgICAgICBpZiAoZXhlY3V0aW9uX2RpcmVj dGlvbiA9PSBFWEVDX0ZPUldBUkQpCisJCXsKKwkJICBuZWVkX2Rhc20gPSBy ZWNvcmRfbGlzdC0+dS5uZWVkX2Rhc207CisJCX0KKwkgICAgICBpZiAobmVl ZF9kYXNtKQorCQl7CisJCSAgZ2RiYXJjaF9wcm9jZXNzX3JlY29yZF9kYXNt IChjdXJyZW50X2dkYmFyY2gpOworCQl9CisKKwkgICAgICBpZiAoZmlyc3Rf cmVjb3JkX2VuZCAmJiBleGVjdXRpb25fZGlyZWN0aW9uID09IEVYRUNfUkVW RVJTRSkKKwkJeworCQkgIC8qIFdoZW4gcmV2ZXJzZSBleGN1dGUsIHRoZSBm aXJzdCByZWNvcmRfZW5kIGlzIHRoZSBwYXJ0IG9mCisJCSAgICAgY3VycmVu dCBpbnN0cnVjdGlvbi4gICovCisJCSAgZmlyc3RfcmVjb3JkX2VuZCA9IDA7 CisJCX0KKwkgICAgICBlbHNlCisJCXsKKwkJICAvKiBJbiBFWEVDX1JFVkVS U0UgbW9kZSwgdGhpcyBpcyB0aGUgcmVjb3JkX2VuZCBvZiBwcmV2CisJCSAg ICAgaW5zdHJ1Y3Rpb24uCisJCSAgICAgSW4gRVhFQ19GT1JXQVJEIG1vZGUs IHRoaXMgaXMgdGhlIHJlY29yZF9lbmQgb2YgY3VycmVudAorCQkgICAgIGlu c3RydWN0aW9uLiAgKi8KKwkJICAvKiBzdGVwICovCisJCSAgaWYgKHJlY29y ZF9yZXN1bWVfc3RlcCkKKwkJICAgIHsKKwkJICAgICAgaWYgKHJlY29yZF9k ZWJ1ZyA+IDEpCisJCQl7CisJCQkgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2Ri X3N0ZGxvZywgIlByb2Nlc3MgcmVjb3JkOiBzdGVwLlxuIik7CisJCQl9CisJ CSAgICAgIGNvbnRpbnVlX2ZsYWcgPSAwOworCQkgICAgfQorCisJCSAgLyog Y2hlY2sgYnJlYWtwb2ludCAqLworCQkgIHRtcF9wYyA9IHJlZ2NhY2hlX3Jl YWRfcGMgKHJlZ2NhY2hlKTsKKwkJICBpZiAoYnJlYWtwb2ludF9pbnNlcnRl ZF9oZXJlX3AgKHRtcF9wYykpCisJCSAgICB7CisJCSAgICAgIGlmIChyZWNv cmRfZGVidWcpCisJCQl7CisJCQkgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2Ri X3N0ZGxvZywKKwkJCQkJICAgICAgIlByb2Nlc3MgcmVjb3JkOiBicmVhayBh dCAweCVzLlxuIiwKKwkJCQkJICAgICAgcGFkZHJfbnogKHRtcF9wYykpOwor CQkJfQorCQkgICAgICBpZiAoZ2RiYXJjaF9kZWNyX3BjX2FmdGVyX2JyZWFr IChnZXRfcmVnY2FjaGVfYXJjaCAocmVnY2FjaGUpKQorCQkJICAmJiBleGVj dXRpb25fZGlyZWN0aW9uID09IEVYRUNfRk9SV0FSRAorCQkJICAmJiAhcmVj b3JkX3Jlc3VtZV9zdGVwKQorIAkJCXsKKwkJCSAgcmVnY2FjaGVfd3JpdGVf cGMgKHJlZ2NhY2hlLAorCQkJCQkgICAgIHRtcF9wYyArCisJCQkJCSAgICAg Z2RiYXJjaF9kZWNyX3BjX2FmdGVyX2JyZWFrCisJCQkJCSAgICAgKGdldF9y ZWdjYWNoZV9hcmNoIChyZWdjYWNoZSkpKTsKKyAJCQl9CisJCSAgICAgIGNv bnRpbnVlX2ZsYWcgPSAwOworCQkgICAgfQorCQl9CisJICAgICAgaWYgKGV4 ZWN1dGlvbl9kaXJlY3Rpb24gPT0gRVhFQ19SRVZFUlNFKQorCQl7CisJCSAg bmVlZF9kYXNtID0gcmVjb3JkX2xpc3QtPnUubmVlZF9kYXNtOworCQl9CisJ ICAgIH0KKworbmV4dDoKKwkgIGlmIChjb250aW51ZV9mbGFnKQorCSAgICB7 CisJICAgICAgaWYgKGV4ZWN1dGlvbl9kaXJlY3Rpb24gPT0gRVhFQ19SRVZF UlNFKQorCQl7CisJCSAgaWYgKHJlY29yZF9saXN0LT5wcmV2KQorCQkgICAg cmVjb3JkX2xpc3QgPSByZWNvcmRfbGlzdC0+cHJldjsKKwkJfQorCSAgICAg IGVsc2UKKwkJeworCQkgIGlmIChyZWNvcmRfbGlzdC0+bmV4dCkKKwkJICAg IHJlY29yZF9saXN0ID0gcmVjb3JkX2xpc3QtPm5leHQ7CisJCX0KKwkgICAg fQorCX0KKyAgICAgIHdoaWxlIChjb250aW51ZV9mbGFnKTsKKworICAgICAg aWYgKHNpZ2FjdGlvbiAoU0lHQUxSTSwgJm9sZF9hY3QsIE5VTEwpKQorCXsK KwkgIHBlcnJvcl93aXRoX25hbWUgKF8oIlByb2Nlc3MgcmVjb3JkOiBzaWdh Y3Rpb24gZmFpbGVkIikpOworCX0KKworcmVwbGF5X291dDoKKyAgICAgIGlm IChyZWNvcmRfZ2V0X3NpZykKKwl7CisJICBzdGF0dXMtPnZhbHVlLnNpZyA9 IFRBUkdFVF9TSUdOQUxfSU5UOworCX0KKyAgICAgIGVsc2UKKwl7CisJICBz dGF0dXMtPnZhbHVlLnNpZyA9IFRBUkdFVF9TSUdOQUxfVFJBUDsKKwl9CisK KyAgICAgIGRpc2NhcmRfY2xlYW51cHMgKG9sZF9jbGVhbnVwcyk7CisgICAg fQorCisgIHJldHVybiBpbmZlcmlvcl9wdGlkOworfQorCitzdGF0aWMgdm9p ZAorcmVjb3JkX2Rpc2Nvbm5lY3QgKHN0cnVjdCB0YXJnZXRfb3BzICp0YXJn ZXQsIGNoYXIgKmFyZ3MsIGludCBmcm9tX3R0eSkKK3sKKyAgaWYgKHJlY29y ZF9kZWJ1ZykKKyAgICB7CisgICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdk Yl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogcmVjb3JkX2Rpc2Nvbm5lY3Rc biIpOworICAgIH0KKyAgdW5wdXNoX3RhcmdldCAoJnJlY29yZF9vcHMpOwor ICB0YXJnZXRfZGlzY29ubmVjdCAoYXJncywgZnJvbV90dHkpOworfQorCitz dGF0aWMgdm9pZAorcmVjb3JkX2RldGFjaCAoc3RydWN0IHRhcmdldF9vcHMg Km9wcywgY2hhciAqYXJncywgaW50IGZyb21fdHR5KQoreworICBpZiAocmVj b3JkX2RlYnVnKQorICAgIHsKKyAgICAgIGZwcmludGZfdW5maWx0ZXJlZCAo Z2RiX3N0ZGxvZywgIlByb2Nlc3MgcmVjb3JkOiByZWNvcmRfZGV0YWNoXG4i KTsKKyAgICB9CisgIHVucHVzaF90YXJnZXQgKCZyZWNvcmRfb3BzKTsKKyAg dGFyZ2V0X2RldGFjaCAoYXJncywgZnJvbV90dHkpOworfQorCitzdGF0aWMg dm9pZAorcmVjb3JkX21vdXJuX2luZmVyaW9yIChzdHJ1Y3QgdGFyZ2V0X29w cyAqb3BzKQoreworICBpZiAocmVjb3JkX2RlYnVnKQorICAgIHsKKyAgICAg IGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywgIlByb2Nlc3MgcmVj b3JkOiByZWNvcmRfbW91cm5faW5mZXJpb3JcbiIpOworICAgIH0KKyAgdW5w dXNoX3RhcmdldCAoJnJlY29yZF9vcHMpOworICB0YXJnZXRfbW91cm5faW5m ZXJpb3IgKCk7Cit9CisKKy8qIENsb3NlIHByb2Nlc3MgcmVjb3JkIHRhcmdl dCBiZWZvcmUga2lsbCB0aGUgaW5mZXJpb3IgcHJvY2Vzcy4gICovCitzdGF0 aWMgdm9pZAorcmVjb3JkX2tpbGwgKHZvaWQpCit7CisgIGlmIChyZWNvcmRf ZGVidWcpCisgICAgeworICAgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJf c3RkbG9nLCAiUHJvY2VzcyByZWNvcmQ6IHJlY29yZF9raWxsXG4iKTsKKyAg ICB9CisgIHVucHVzaF90YXJnZXQgKCZyZWNvcmRfb3BzKTsKKyAgdGFyZ2V0 X2tpbGwgKCk7Cit9CisKKy8qIFJlY29yZCByZWdpc3RlcnMgY2hhbmdlIChi eSB1c2VyIG9yIGJ5IEdEQikgdG8gbGlzdCBhcyBhbiBpbnN0cnVjdGlvbi4g ICovCitzdGF0aWMgdm9pZAorcmVjb3JkX3JlZ2lzdGVyc19jaGFuZ2UgKHN0 cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUsIGludCByZWdudW0pCit7CisgIC8q IENoZWNrIHJlY29yZF9pbnNuX251bS4gICovCisgIHJlY29yZF9jaGVja19p bnNuX251bSAoMCk7CisKKyAgcmVjb3JkX2FyY2hfbGlzdF9oZWFkID0gTlVM TDsKKyAgcmVjb3JkX2FyY2hfbGlzdF90YWlsID0gTlVMTDsKKworICByZWNv cmRfcmVnY2FjaGUgPSBnZXRfY3VycmVudF9yZWdjYWNoZSAoKTsKKworICBp ZiAocmVnbnVtIDwgMCkKKyAgICB7CisgICAgICBpbnQgaTsKKyAgICAgIGZv ciAoaSA9IDA7IGkgPCBnZGJhcmNoX251bV9yZWdzIChnZXRfcmVnY2FjaGVf YXJjaCAocmVnY2FjaGUpKTsgaSsrKQorCXsKKwkgIGlmIChyZWNvcmRfYXJj aF9saXN0X2FkZF9yZWcgKGkpKQorCSAgICB7CisJICAgICAgcmVjb3JkX2xp c3RfcmVsZWFzZSAocmVjb3JkX2FyY2hfbGlzdF90YWlsKTsKKwkgICAgICBl cnJvciAoXygiUHJvY2VzcyByZWNvcmQ6IGZhaWxlZCB0byByZWNvcmQgZXhl Y3V0aW9uIGxvZy4iKSk7CisJICAgIH0KKwl9CisgICAgfQorICBlbHNlCisg ICAgeworICAgICAgaWYgKHJlY29yZF9hcmNoX2xpc3RfYWRkX3JlZyAocmVn bnVtKSkKKwl7CisJICByZWNvcmRfbGlzdF9yZWxlYXNlIChyZWNvcmRfYXJj aF9saXN0X3RhaWwpOworCSAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBm YWlsZWQgdG8gcmVjb3JkIGV4ZWN1dGlvbiBsb2cuIikpOworCX0KKyAgICB9 CisgIGlmIChyZWNvcmRfYXJjaF9saXN0X2FkZF9lbmQgKDApKQorICAgIHsK KyAgICAgIHJlY29yZF9saXN0X3JlbGVhc2UgKHJlY29yZF9hcmNoX2xpc3Rf dGFpbCk7CisgICAgICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQ6IGZhaWxl ZCB0byByZWNvcmQgZXhlY3V0aW9uIGxvZy4iKSk7CisgICAgfQorICByZWNv cmRfbGlzdC0+bmV4dCA9IHJlY29yZF9hcmNoX2xpc3RfaGVhZDsKKyAgcmVj b3JkX2FyY2hfbGlzdF9oZWFkLT5wcmV2ID0gcmVjb3JkX2xpc3Q7CisgIHJl Y29yZF9saXN0ID0gcmVjb3JkX2FyY2hfbGlzdF90YWlsOworCisgIGlmIChy ZWNvcmRfaW5zbl9udW0gPT0gcmVjb3JkX2luc25fbWF4X251bSAmJiByZWNv cmRfaW5zbl9tYXhfbnVtKQorICAgIHsKKyAgICAgIHJlY29yZF9saXN0X3Jl bGVhc2VfZmlyc3QgKCk7CisgICAgfQorICBlbHNlCisgICAgeworICAgICAg cmVjb3JkX2luc25fbnVtKys7CisgICAgfQorfQorCitzdGF0aWMgdm9pZAor cmVjb3JkX3N0b3JlX3JlZ2lzdGVycyAoc3RydWN0IHJlZ2NhY2hlICpyZWdj YWNoZSwgaW50IHJlZ25vKQoreworICBpZiAoIXJlY29yZF9ub3RfcmVjb3Jk KQorICAgIHsKKyAgICAgIGlmIChSRUNPUkRfSVNfUkVQTEFZKQorCXsKKwkg IGludCBuOworCSAgc3RydWN0IGNsZWFudXAgKm9sZF9jbGVhbnVwczsKKwor CSAgLyogTGV0IHVzZXIgY2hvaWNlIGlmIGhlIHdhbnQgdG8gd3JpdGUgcmVn aXN0ZXIgb3Igbm90LiAgKi8KKwkgIGlmIChyZWdubyA8IDApCisJICAgIHsK KwkgICAgICBuID0KKwkJbnF1ZXJ5IChfCisJCQkoIkJlY3VzZSBHREIgaXMg aW4gcmVwbGF5IG1vZGUsIGNoYW5naW5nIHRoZSB2YWx1ZSBvZiBhIHJlZ2lz dGVyIHdpbGwgbWFrZSB0aGUgZXhlY3V0ZSBsb2cgdW51c2FibGUgZnJvbSB0 aGlzIHBvaW50IG9ud2FyZC4gIENoYW5nZSBhbGwgcmVnaXN0ZXI/IikpOwor CSAgICB9CisJICBlbHNlCisJICAgIHsKKwkgICAgICBuID0KKwkJbnF1ZXJ5 IChfCisJCQkoIkJlY3VzZSBHREIgaXMgaW4gcmVwbGF5IG1vZGUsIGNoYW5n aW5nIHRoZSB2YWx1ZSBvZiBhIHJlZ2lzdGVyIHdpbGwgbWFrZSB0aGUgZXhl Y3V0ZSBsb2cgdW51c2FibGUgZnJvbSB0aGlzIHBvaW50IG9ud2FyZC4gIENo YW5nZSByZWdpc3RlciAlcz8iKSwKKwkJCWdkYmFyY2hfcmVnaXN0ZXJfbmFt ZSAoZ2V0X3JlZ2NhY2hlX2FyY2ggKHJlZ2NhY2hlKSwKKwkJCQkJICAgICAg IHJlZ25vKSk7CisJICAgIH0KKworCSAgaWYgKCFuKQorCSAgICB7CisJICAg ICAgLyogSW52YWxpZGF0ZSB0aGUgdmFsdWUgb2YgcmVnY2FjaGUgdGhhdCBz ZXQgaW4gZnVuY3Rpb24KKwkgICAgICAgICAicmVnY2FjaGVfcmF3X3dyaXRl Ii4gICovCisJICAgICAgaWYgKHJlZ25vIDwgMCkKKwkJeworCQkgIGludCBp OworCQkgIGZvciAoaSA9IDA7CisJCSAgICAgICBpIDwgZ2RiYXJjaF9udW1f cmVncyAoZ2V0X3JlZ2NhY2hlX2FyY2ggKHJlZ2NhY2hlKSk7CisJCSAgICAg ICBpKyspCisJCSAgICB7CisJCSAgICAgIHJlZ2NhY2hlX2ludmFsaWRhdGUg KHJlZ2NhY2hlLCBpKTsKKwkJICAgIH0KKwkJfQorCSAgICAgIGVsc2UKKwkJ eworCQkgIHJlZ2NhY2hlX2ludmFsaWRhdGUgKHJlZ2NhY2hlLCByZWdubyk7 CisJCX0KKworCSAgICAgIGVycm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW5j ZWxlZCB0aGUgb3BlcmF0aW9uLiIpKTsKKwkgICAgfQorCisJICAvKiBEZXN0 cm95IHRoZSByZWNvcmQgZnJvbSBoZXJlIGZvcndhcmQuICAqLworCSAgcmVj b3JkX2xpc3RfcmVsZWFzZV9uZXh0ICgpOworCX0KKworICAgICAgcmVjb3Jk X3JlZ2lzdGVyc19jaGFuZ2UgKHJlZ2NhY2hlLCByZWdubyk7CisgICAgfQor ICByZWNvcmRfYmVuZWF0aF90b19zdG9yZV9yZWdpc3RlcnMgKHJlZ2NhY2hl LCByZWdubyk7Cit9CisKKy8qIHJlY29yZF94ZmVyX3BhcnRpYWwgLS0gYmVo YXZpb3IgaXMgY29uZGl0aW9uYWwgb24gUkVDT1JEX0lTX1JFUExBWS4KKyAg IEluIHJlcGxheSBtb2RlLCB3ZSBjYW5ub3Qgd3JpdGUgbWVtb3J5IHVubGVz IHdlIGFyZSB3aWxsaW5nIHRvIAorICAgaW52YWxpZGF0ZSB0aGUgcmVjb3Jk L3JlcGxheSBsb2cgZnJvbSB0aGlzIHBvaW50IGZvcndhcmQuICAqLworCitz dGF0aWMgTE9OR0VTVAorcmVjb3JkX3hmZXJfcGFydGlhbCAoc3RydWN0IHRh cmdldF9vcHMgKm9wcywgZW51bSB0YXJnZXRfb2JqZWN0IG9iamVjdCwKKwkJ ICAgICBjb25zdCBjaGFyICphbm5leCwgZ2RiX2J5dGUgKiByZWFkYnVmLAor CQkgICAgIGNvbnN0IGdkYl9ieXRlICogd3JpdGVidWYsIFVMT05HRVNUIG9m ZnNldCwgTE9OR0VTVCBsZW4pCit7CisgIGlmICghcmVjb3JkX25vdF9yZWNv cmQKKyAgICAgICYmIChvYmplY3QgPT0gVEFSR0VUX09CSkVDVF9NRU1PUlkK KwkgIHx8IG9iamVjdCA9PSBUQVJHRVRfT0JKRUNUX1JBV19NRU1PUlkpICYm IHdyaXRlYnVmKQorICAgIHsKKyAgICAgIGlmIChSRUNPUkRfSVNfUkVQTEFZ KQorCXsKKwkgIC8qIExldCB1c2VyIGNob2ljZSBpZiBoZSB3YW50IHRvIHdy aXRlIG1lbW9yeSBvciBub3QuICAqLworCSAgaWYgKCFucXVlcnkgKF8oIkJl Y2F1c2UgR0RCIGlzIGluIHJlcGxheSBtb2RlLCB3cml0aW5nIHRvIG1lbW9y eSB3aWxsIG1ha2UgdGhlIGV4ZWN1dGUgbG9nIHVudXNhYmxlIGZyb20gdGhp cyBwb2ludCBvbndhcmQuICBXcml0ZSBtZW1vcnkgYXQgYWRkcmVzcyAweCVz PyIpLAorCQkgICAgICAgcGFkZHJfbnogKG9mZnNldCkpKQorCSAgICB7CisJ ICAgICAgcmV0dXJuIC0xOworCSAgICB9CisKKwkgIC8qIERlc3Ryb3kgdGhl IHJlY29yZCBmcm9tIGhlcmUgZm9yd2FyZC4gICovCisJICByZWNvcmRfbGlz dF9yZWxlYXNlX25leHQgKCk7CisJfQorCisgICAgICAvKiBDaGVjayByZWNv cmRfaW5zbl9udW0gKi8KKyAgICAgIHJlY29yZF9jaGVja19pbnNuX251bSAo MCk7CisKKyAgICAgIC8qIFJlY29yZCByZWdpc3RlcnMgY2hhbmdlIHRvIGxp c3QgYXMgYW4gaW5zdHJ1Y3Rpb24uICAqLworICAgICAgcmVjb3JkX2FyY2hf bGlzdF9oZWFkID0gTlVMTDsKKyAgICAgIHJlY29yZF9hcmNoX2xpc3RfdGFp bCA9IE5VTEw7CisgICAgICBpZiAocmVjb3JkX2FyY2hfbGlzdF9hZGRfbWVt IChvZmZzZXQsIGxlbikpCisJeworCSAgcmVjb3JkX2xpc3RfcmVsZWFzZSAo cmVjb3JkX2FyY2hfbGlzdF90YWlsKTsKKwkgIGlmIChyZWNvcmRfZGVidWcp CisJICAgIHsKKwkgICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRs b2csCisJCQkJICBfCisJCQkJICAoIlByb2Nlc3MgcmVjb3JkOiBmYWlsZWQg dG8gcmVjb3JkIGV4ZWN1dGlvbiBsb2cuIikpOworCSAgICB9CisJICByZXR1 cm4gLTE7CisJfQorICAgICAgaWYgKHJlY29yZF9hcmNoX2xpc3RfYWRkX2Vu ZCAoMCkpCisJeworCSAgcmVjb3JkX2xpc3RfcmVsZWFzZSAocmVjb3JkX2Fy Y2hfbGlzdF90YWlsKTsKKwkgIGlmIChyZWNvcmRfZGVidWcpCisJICAgIHsK KwkgICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csCisJCQkJ ICBfCisJCQkJICAoIlByb2Nlc3MgcmVjb3JkOiBmYWlsZWQgdG8gcmVjb3Jk IGV4ZWN1dGlvbiBsb2cuIikpOworCSAgICB9CisJICByZXR1cm4gLTE7CisJ fQorICAgICAgcmVjb3JkX2xpc3QtPm5leHQgPSByZWNvcmRfYXJjaF9saXN0 X2hlYWQ7CisgICAgICByZWNvcmRfYXJjaF9saXN0X2hlYWQtPnByZXYgPSBy ZWNvcmRfbGlzdDsKKyAgICAgIHJlY29yZF9saXN0ID0gcmVjb3JkX2FyY2hf bGlzdF90YWlsOworCisgICAgICBpZiAocmVjb3JkX2luc25fbnVtID09IHJl Y29yZF9pbnNuX21heF9udW0gJiYgcmVjb3JkX2luc25fbWF4X251bSkKKwl7 CisJICByZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0ICgpOworCX0KKyAgICAg IGVsc2UKKwl7CisJICByZWNvcmRfaW5zbl9udW0rKzsKKwl9CisgICAgfQor CisgIHJldHVybiByZWNvcmRfYmVuZWF0aF90b194ZmVyX3BhcnRpYWwgKG9w cywgb2JqZWN0LCBhbm5leCwgcmVhZGJ1ZiwKKwkJCQkJIHdyaXRlYnVmLCBv ZmZzZXQsIGxlbik7Cit9CisKKy8qIHJlY29yZF9pbnNlcnRfYnJlYWtwb2lu dAorICAgcmVjb3JkX3JlbW92ZV9icmVha3BvaW50CisgICBCZWhhdmlvciBp cyBjb25kaXRpb25hbCBvbiBSRUNPUkRfSVNfUkVQTEFZLgorICAgV2Ugd2ls bCBub3QgYWN0dWFsbHkgaW5zZXJ0IG9yIHJlbW92ZSBicmVha3BvaW50cyB3 aGVuIHJlcGxheWluZy4gICovCisKK3N0YXRpYyBpbnQKK3JlY29yZF9pbnNl cnRfYnJlYWtwb2ludCAoc3RydWN0IGJwX3RhcmdldF9pbmZvICpicF90Z3Qp Cit7CisgIGlmICghUkVDT1JEX0lTX1JFUExBWSkKKyAgICB7CisgICAgICBy ZXR1cm4gcmVjb3JkX2JlbmVhdGhfdG9faW5zZXJ0X2JyZWFrcG9pbnQgKGJw X3RndCk7CisgICAgfQorCisgIHJldHVybiAwOworfQorCitzdGF0aWMgaW50 CityZWNvcmRfcmVtb3ZlX2JyZWFrcG9pbnQgKHN0cnVjdCBicF90YXJnZXRf aW5mbyAqYnBfdGd0KQoreworICBpZiAoIVJFQ09SRF9JU19SRVBMQVkpCisg ICAgeworICAgICAgcmV0dXJuIHJlY29yZF9iZW5lYXRoX3RvX3JlbW92ZV9i cmVha3BvaW50IChicF90Z3QpOworICAgIH0KKworICByZXR1cm4gMDsKK30K Kworc3RhdGljIGludAorcmVjb3JkX2Nhbl9leGVjdXRlX3JldmVyc2UgKHZv aWQpCit7CisgIHJldHVybiAxOworfQorCitzdGF0aWMgdm9pZAoraW5pdF9y ZWNvcmRfb3BzICh2b2lkKQoreworICByZWNvcmRfb3BzLnRvX3Nob3J0bmFt ZSA9ICJyZWNvcmQiOworICByZWNvcmRfb3BzLnRvX2xvbmduYW1lID0gIlBy b2Nlc3MgcmVjb3JkIGFuZCByZXBsYXkgdGFyZ2V0IjsKKyAgcmVjb3JkX29w cy50b19kb2MgPQorICAgICJMb2cgcHJvZ3JhbSB3aGlsZSBleGVjdXRpbmcg YW5kIHJlcGxheSBleGVjdXRpb24gZnJvbSBsb2cuIjsKKyAgcmVjb3JkX29w cy50b19vcGVuID0gcmVjb3JkX29wZW47CisgIHJlY29yZF9vcHMudG9fY2xv c2UgPSByZWNvcmRfY2xvc2U7CisgIHJlY29yZF9vcHMudG9fcmVzdW1lID0g cmVjb3JkX3Jlc3VtZTsKKyAgcmVjb3JkX29wcy50b193YWl0ID0gcmVjb3Jk X3dhaXQ7CisgIHJlY29yZF9vcHMudG9fZGlzY29ubmVjdCA9IHJlY29yZF9k aXNjb25uZWN0OworICByZWNvcmRfb3BzLnRvX2RldGFjaCA9IHJlY29yZF9k ZXRhY2g7CisgIHJlY29yZF9vcHMudG9fbW91cm5faW5mZXJpb3IgPSByZWNv cmRfbW91cm5faW5mZXJpb3I7CisgIHJlY29yZF9vcHMudG9fa2lsbCA9IHJl Y29yZF9raWxsOworICByZWNvcmRfb3BzLnRvX2NyZWF0ZV9pbmZlcmlvciA9 IGZpbmRfZGVmYXVsdF9jcmVhdGVfaW5mZXJpb3I7CS8qIE1ha2UgcmVjb3Jk IHN1cHBwb3J0IGNvbW1hbmQgInJ1biIuICAqLworICByZWNvcmRfb3BzLnRv X3N0b3JlX3JlZ2lzdGVycyA9IHJlY29yZF9zdG9yZV9yZWdpc3RlcnM7Cisg IHJlY29yZF9vcHMudG9feGZlcl9wYXJ0aWFsID0gcmVjb3JkX3hmZXJfcGFy dGlhbDsKKyAgcmVjb3JkX29wcy50b19pbnNlcnRfYnJlYWtwb2ludCA9IHJl Y29yZF9pbnNlcnRfYnJlYWtwb2ludDsKKyAgcmVjb3JkX29wcy50b19yZW1v dmVfYnJlYWtwb2ludCA9IHJlY29yZF9yZW1vdmVfYnJlYWtwb2ludDsKKyAg cmVjb3JkX29wcy50b19jYW5fZXhlY3V0ZV9yZXZlcnNlID0gcmVjb3JkX2Nh bl9leGVjdXRlX3JldmVyc2U7CisgIHJlY29yZF9vcHMudG9fc3RyYXR1bSA9 IHJlY29yZF9zdHJhdHVtOworICByZWNvcmRfb3BzLnRvX21hZ2ljID0gT1BT X01BR0lDOworfQorCitzdGF0aWMgdm9pZAorc2hvd19yZWNvcmRfZGVidWcg KHN0cnVjdCB1aV9maWxlICpmaWxlLCBpbnQgZnJvbV90dHksCisJCSAgIHN0 cnVjdCBjbWRfbGlzdF9lbGVtZW50ICpjLCBjb25zdCBjaGFyICp2YWx1ZSkK K3sKKyAgZnByaW50Zl9maWx0ZXJlZCAoZmlsZSwgXygiRGVidWdnaW5nIG9m IHByb2Nlc3MgcmVjb3JkIHRhcmdldCBpcyAlcy5cbiIpLCB2YWx1ZSk7Cit9 CisKKy8qIGNtZF9yZWNvcmRfc3RhcnQgLS0gYWxpYXMgZm9yICJ0YXJnZXQg cmVjb3JkIi4gICovCisKK3N0YXRpYyB2b2lkCitjbWRfcmVjb3JkX3N0YXJ0 IChjaGFyICphcmdzLCBpbnQgZnJvbV90dHkpCit7CisgIGV4ZWN1dGVfY29t bWFuZCAoInRhcmdldCByZWNvcmQiLCBmcm9tX3R0eSk7Cit9CisKKy8qIGNt ZF9yZWNvcmRfZGVsZXRlIC0tIHRydW5jYXRlIHRoZSByZWNvcmQgbG9nIGZy b20gdGhlIHByZXNlbnQgcG9pbnQKKyAgIG9mIHJlcGxheSB1bnRpbCB0aGUg ZW5kLiAgKi8KKworc3RhdGljIHZvaWQKK2NtZF9yZWNvcmRfZGVsZXRlIChj aGFyICphcmdzLCBpbnQgZnJvbV90dHkpCit7CisgIGlmIChSRUNPUkRfSVNf VVNFRCkKKyAgICB7CisgICAgICBpZiAoUkVDT1JEX0lTX1JFUExBWSkKKwl7 CisJICBpZiAoIWZyb21fdHR5IHx8IHF1ZXJ5IChfKCJEZWxldGUgdGhlIGxv ZyBmcm9tIHRoaXMgcG9pbnQgZm9yd2FyZCBhbmQgYmVnaW4gdG8gcmVjb3Jk IHRoZSBydW5uaW5nIG1lc3NhZ2UgYXQgY3VycmVudCBQQz8iKSkpCisJICAg IHsKKwkgICAgICByZWNvcmRfbGlzdF9yZWxlYXNlX25leHQgKCk7CisJICAg IH0KKwl9CisgICAgICBlbHNlCisJeworCSAgcHJpbnRmX3VuZmlsdGVyZWQg KF8oIkFscmVhZHkgYXQgZW5kIG9mIHJlY29yZCBsaXN0LlxuIikpOworCX0K KworICAgIH0KKyAgZWxzZQorICAgIHsKKyAgICAgIHByaW50Zl91bmZpbHRl cmVkIChfKCJQcm9jZXNzIHJlY29yZCBpcyBub3Qgc3RhcnRlZC5cbiIpKTsK KyAgICB9Cit9CisKKy8qIGNtZF9yZWNvcmRfc3RvcCAtLSBpbXBsZW1lbnQg dGhlICJzdG9wcmVjb3JkIiBjb21tYW5kLiAgKi8KKworc3RhdGljIHZvaWQK K2NtZF9yZWNvcmRfc3RvcCAoY2hhciAqYXJncywgaW50IGZyb21fdHR5KQor eworICBpZiAoUkVDT1JEX0lTX1VTRUQpCisgICAgeworICAgICAgaWYgKCFy ZWNvcmRfbGlzdCB8fCAhZnJvbV90dHkgfHwgcXVlcnkgKF8oIkRlbGV0ZSBy ZWNvcmRlZCBsb2cgYW5kIHN0b3AgcmVjb3JkaW5nPyIpKSkKKwl7CisJICB1 bnB1c2hfdGFyZ2V0ICgmcmVjb3JkX29wcyk7CisJfQorICAgIH0KKyAgZWxz ZQorICAgIHsKKyAgICAgIHByaW50Zl91bmZpbHRlcmVkIChfKCJQcm9jZXNz IHJlY29yZCBpcyBub3Qgc3RhcnRlZC5cbiIpKTsKKyAgICB9Cit9CisKKy8q IHNldF9yZWNvcmRfaW5zbl9tYXhfbnVtIC0tIHNldCB1cHBlciBsaW1pdCBv ZiByZWNvcmQgbG9nIHNpemUuICAqLworCitzdGF0aWMgdm9pZAorc2V0X3Jl Y29yZF9pbnNuX21heF9udW0gKGNoYXIgKmFyZ3MsIGludCBmcm9tX3R0eSwg c3RydWN0IGNtZF9saXN0X2VsZW1lbnQgKmMpCit7CisgIGlmIChyZWNvcmRf aW5zbl9udW0gPiByZWNvcmRfaW5zbl9tYXhfbnVtICYmIHJlY29yZF9pbnNu X21heF9udW0pCisgICAgeworICAgICAgcHJpbnRmX3VuZmlsdGVyZWQgKF8o IlJlY29yZCBpbnN0cnVjdGlvbnMgbnVtYmVyIGlzIGJpZ2dlciB0aGFuIHJl Y29yZCBpbnN0cnVjdGlvbnMgbWF4IG51bWJlci4gIEF1dG8gZGVsZXRlIHRo ZSBmaXJzdCBvbmVzP1xuIikpOworCisgICAgICB3aGlsZSAocmVjb3JkX2lu c25fbnVtID4gcmVjb3JkX2luc25fbWF4X251bSkKKwl7CisJICByZWNvcmRf bGlzdF9yZWxlYXNlX2ZpcnN0ICgpOworCX0KKyAgICB9Cit9CisKKy8qIHNo b3dfcmVjb3JkX2luc25fbnVtYmVyIC0tIHByaW50IHRoZSBjdXJyZW50IGlu ZGV4CisgICBpbnRvIHRoZSByZWNvcmQgbG9nIChudW1iZXIgb2YgaW5zbnMg cmVjb3JkZWQgc28gZmFyKS4gICovCisKK3N0YXRpYyB2b2lkCitzaG93X3Jl Y29yZF9pbnNuX251bWJlciAoY2hhciAqaWdub3JlLCBpbnQgZnJvbV90dHkp Cit7CisgIHByaW50Zl91bmZpbHRlcmVkIChfKCJSZWNvcmQgaW5zdHJ1Y3Rp b24gbnVtYmVyIGlzICVkLlxuIiksCisJCSAgICAgcmVjb3JkX2luc25fbnVt KTsKK30KKwordm9pZAorX2luaXRpYWxpemVfcmVjb3JkICh2b2lkKQorewor ICAvKiBJbml0IHJlY29yZF9tYXNrYWxsLiAgKi8KKyAgaWYgKHNpZ2ZpbGxz ZXQgKCZyZWNvcmRfbWFza2FsbCkgPT0gLTEpCisgICAgeworICAgICAgcGVy cm9yX3dpdGhfbmFtZSAoXygiUHJvY2VzcyByZWNvcmQ6IHNpZ2ZpbGxzZXQg ZmFpbGVkIikpOworICAgIH0KKworICAvKiBJbml0IHJlY29yZF9maXJzdC4g ICovCisgIHJlY29yZF9maXJzdC5wcmV2ID0gTlVMTDsKKyAgcmVjb3JkX2Zp cnN0Lm5leHQgPSBOVUxMOworICByZWNvcmRfZmlyc3QudHlwZSA9IHJlY29y ZF9lbmQ7CisgIHJlY29yZF9maXJzdC51Lm5lZWRfZGFzbSA9IDA7CisKKyAg aW5pdF9yZWNvcmRfb3BzICgpOworICBhZGRfdGFyZ2V0ICgmcmVjb3JkX29w cyk7CisKKyAgYWRkX3NldHNob3dfemludGVnZXJfY21kICgicmVjb3JkIiwg bm9fY2xhc3MsICZyZWNvcmRfZGVidWcsCisJCQkgICAgXygiU2V0IGRlYnVn Z2luZyBvZiByZWNvcmQvcmVwbGF5IGZlYXR1cmUuIiksCisJCQkgICAgXygi U2hvdyBkZWJ1Z2dpbmcgb2YgcmVjb3JkL3JlcGxheSBmZWF0dXJlLiIpLAor CQkJICAgIF8KKwkJCSAgICAoIldoZW4gZW5hYmxlZCwgZGVidWdnaW5nIG91 dHB1dCBmb3IgcmVjb3JkL3JlcGxheSBmZWF0dXJlIGlzIGRpc3BsYXllZC4i KSwKKwkJCSAgICBOVUxMLCBzaG93X3JlY29yZF9kZWJ1ZywgJnNldGRlYnVn bGlzdCwKKwkJCSAgICAmc2hvd2RlYnVnbGlzdCk7CisKKyAgYWRkX2NvbSAo InJlY29yZCIsIGNsYXNzX29ic2N1cmUsIGNtZF9yZWNvcmRfc3RhcnQsCisJ ICAgXygiQWJicmV2aWF0ZWQgZm9ybSBvZiBcInRhcmdldCByZWNvcmRcIiBj b21tYW5kLiIpKTsKKworICBhZGRfY29tX2FsaWFzICgicmVjIiwgInJlY29y ZCIsIGNsYXNzX29ic2N1cmUsIDEpOworCisgIC8qIFhYWDogSSB0cnkgdG8g dXNlIHNvbWUgc2ltcGxlIGNvbW1hbmRzIHN1Y2ggYXMgImRpc2Nvbm5lY3Qi IGFuZAorICAgICAiZGV0YWNoIiB0byBzdXBwb3J0IHRoaXMgZnVuY3Rpb25z LiAgQnV0IHRoZXNlIGNvbW1hbmRzIGFsbCBoYXZlCisgICAgIG90aGVyIGFm ZmVjdCB0byBHREIgc3VjaCBhcyBjYWxsIGZ1bmN0aW9uICJub19zaGFyZWRf bGlicmFyaWVzIi4KKyAgICAgU28gSSBhZGQgc3BlY2lhbCBjb21tYW5kcyB0 byBHREIuICAqLworICBhZGRfY29tICgiZGVscmVjb3JkIiwgY2xhc3Nfb2Jz Y3VyZSwgY21kX3JlY29yZF9kZWxldGUsCisJICAgXygiRGVsZXRlIHRoZSBy ZXN0IG9mIGV4ZWN1dGlvbiBsb2cgYW5kIHN0YXJ0IHJlY29yZGluZyBpdCBh bmV3LiIpKTsKKyAgYWRkX2NvbV9hbGlhcyAoImRyIiwgImRlbHJlY29yZCIs IGNsYXNzX29ic2N1cmUsIDEpOworICBhZGRfY29tICgic3RvcHJlY29yZCIs IGNsYXNzX29ic2N1cmUsIGNtZF9yZWNvcmRfc3RvcCwKKwkgICBfKCJTdG9w IHRoZSByZWNvcmQvcmVwbGF5IHRhcmdldC4iKSk7CisgIGFkZF9jb21fYWxp YXMgKCJzciIsICJzdG9wcmVjb3JkIiwgY2xhc3Nfb2JzY3VyZSwgMSk7CisK KyAgLyogUmVjb3JkIGluc3RydWN0aW9ucyBudW1iZXIgbGltaXQgY29tbWFu ZC4gICovCisgIGFkZF9zZXRzaG93X2Jvb2xlYW5fY21kICgicmVjb3JkLXN0 b3AtYXQtbGltaXQiLCBub19jbGFzcywKKwkJCSAgICAmcmVjb3JkX3N0b3Bf YXRfbGltaXQsCisJCQkgICAgXygiU2V0IHdoZXRoZXIgcmVjb3JkL3JlcGxh eSBzdG9wIHdoZW4gcmVjb3JkL3JlcGxheSBidWZmZXIgYmVjb21lcyBmdWxs LiIpLAorCQkJICAgIF8oIlNob3cgd2hldGhlciByZWNvcmQvcmVwbGF5IHN0 b3Agd2hlbiByZWNvcmQvcmVwbGF5IGJ1ZmZlciBiZWNvbWVzIGZ1bGwuIiks IF8oIlwKK0VuYWJsZSBpcyBkZWZhdWx0IHZhbHVlLlxuXAorV2hlbiBlbmFi bGVkLCBpZiB0aGUgcmVjb3JkL3JlcGxheSBidWZmZXIgYmVjb21lcyBmdWxs LFxuXAorYXNrIHVzZXIgd2hhdCB0byBkby5cblwKK1doZW4gZGlzYWJsZWQs IGlmIHRoZSByZWNvcmQvcmVwbGF5IGJ1ZmZlciBiZWNvbWVzIGZ1bGwsXG5c CitkZWxldGUgaXQgYW5kIHN0YXJ0IG5ldyByZWNvcmRpbmcuIiksIE5VTEws IE5VTEwsICZzZXRsaXN0LCAmc2hvd2xpc3QpOworICBhZGRfc2V0c2hvd196 aW50ZWdlcl9jbWQgKCJyZWNvcmQtaW5zbi1udW1iZXItbWF4Iiwgbm9fY2xh c3MsCisJCQkgICAgJnJlY29yZF9pbnNuX21heF9udW0sCisJCQkgICAgXygi U2V0IHJlY29yZC9yZXBsYXkgYnVmZmVyIGxpbWl0LiIpLAorCQkJICAgIF8o IlNob3cgcmVjb3JkL3JlcGxheSBidWZmZXIgbGltaXQuIiksIF8oIlwKK1Nl dCB0aGUgbWF4aW11bSBudW1iZXIgb2YgaW5zdHJ1Y3Rpb25zIHRvIGJlIHN0 b3JlZCBpbiB0aGVcblwKK3JlY29yZC9yZXBsYXkgYnVmZmVyLiAgWmVybyBt ZWFucyB1bmxpbWl0ZWQgKGRlZmF1bHQgMjAwMDAwKS4iKSwgCisJCQkgICAg c2V0X3JlY29yZF9pbnNuX21heF9udW0sIAorCQkJICAgIE5VTEwsICZzZXRs aXN0LCAmc2hvd2xpc3QpOworICBhZGRfaW5mbyAoInJlY29yZC1pbnNuLW51 bWJlciIsIHNob3dfcmVjb3JkX2luc25fbnVtYmVyLCBfKCJcCitTaG93IHRo ZSBjdXJyZW50IG51bWJlciBvZiBpbnN0cnVjdGlvbnMgaW4gdGhlIHJlY29y ZC9yZXBsYXkgYnVmZmVyLiIpKTsKK30KLS0tIGEvL2Rldi9udWxsCisrKyBi L3JlY29yZC5oCkBAIC0wLDAgKzEsOTkgQEAKKy8qIFByb2Nlc3MgcmVjb3Jk IGFuZCByZXBsYXkgdGFyZ2V0IGZvciBHREIsIHRoZSBHTlUgZGVidWdnZXIu CisKKyAgIENvcHlyaWdodCAoQykgMjAwOCBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb24sIEluYy4KKworICAgVGhpcyBmaWxlIGlzIHBhcnQgb2YgR0RCLgor CisgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICAgaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBw dWJsaXNoZWQgYnkKKyAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247 IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yCisgICAoYXQg eW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICBUaGlzIHBy b2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxs IGJlIHVzZWZ1bCwKKyAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0 aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgICBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlCisgICBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorCisgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQg YSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICAg YWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNlZSA8aHR0cDov L3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLworCisjaWZuZGVmIF9SRUNP UkRfSF8KKyNkZWZpbmUgX1JFQ09SRF9IXworCisjZGVmaW5lIFJFQ09SRF9J U19VU0VEICAgXAorICAgICAoY3VycmVudF90YXJnZXQuYmVuZWF0aCA9PSAm cmVjb3JkX29wcykKKyNkZWZpbmUgUkVDT1JEX0lTX1JFUExBWSBcCisgICAg IChyZWNvcmRfbGlzdC0+bmV4dCB8fCBleGVjdXRpb25fZGlyZWN0aW9uID09 IEVYRUNfUkVWRVJTRSkKKwordHlwZWRlZiBzdHJ1Y3QgcmVjb3JkX3JlZ19z Cit7CisgIGludCBudW07CisgIGdkYl9ieXRlICp2YWw7Cit9IHJlY29yZF9y ZWdfdDsKKwordHlwZWRlZiBzdHJ1Y3QgcmVjb3JkX21lbV9zCit7CisgIENP UkVfQUREUiBhZGRyOworICBpbnQgbGVuOworICBnZGJfYnl0ZSAqdmFsOwor fSByZWNvcmRfbWVtX3Q7CisKK2VudW0gcmVjb3JkX3R5cGUKK3sKKyAgcmVj b3JkX2VuZCA9IDAsCisgIHJlY29yZF9yZWcsCisgIHJlY29yZF9tZW0KK307 CisKKy8qIFRoaXMgaXMgdGhlIGNvcmUgc3RydWN0IG9mIHJlY29yZCBmdW5j dGlvbi4KKyAgIEFuIGVudGl0eSBvZiByZWNvcmRfdCBpcyBhIHJlY29yZCBv ZiB0aGUgdmFsdWUgY2hhbmdlIG9mIGEgcmVnaXN0ZXIKKyAgICgicmVjb3Jk X3JlZyIpIG9yIGEgcGFydCBvZiBtZW1vcnkgKCJyZWNvcmRfbWVtIikuIEFu ZCBFYWNoIGluc3RydWN0aW9uIG11c3QKKyAgIGhhcyBhIHJlY29yZF90ICgi cmVjb3JkX2VuZCIpIHRoYXQgcG9pbnQgb3V0IHRoaXMgaXMgdGhlIGxhc3Qg cmVjb3JkX3Qgb2YKKyAgIHRoaXMgaW5zdHJ1Y3Rpb24uCisgICBFYWNoIHJl Y29yZF90IGlzIGxpbmtlZCB0byAicmVjb3JkX2xpc3QiIGJ5ICJwcmV2IiBh bmQgIm5leHQiLiAKKyAqLwordHlwZWRlZiBzdHJ1Y3QgcmVjb3JkX3MKK3sK KyAgc3RydWN0IHJlY29yZF9zICpwcmV2OworICBzdHJ1Y3QgcmVjb3JkX3Mg Km5leHQ7CisgIGVudW0gcmVjb3JkX3R5cGUgdHlwZTsKKyAgdW5pb24KKyAg eworICAgIC8qIHJlZyAqLworICAgIHJlY29yZF9yZWdfdCByZWc7CisgICAg LyogbWVtICovCisgICAgcmVjb3JkX21lbV90IG1lbTsKKyAgICAvKiBlbmQg Ki8KKyAgICBpbnQgbmVlZF9kYXNtOworICB9IHU7Cit9IHJlY29yZF90Owor CitleHRlcm4gaW50IHJlY29yZF9kZWJ1ZzsKK2V4dGVybiByZWNvcmRfdCAq cmVjb3JkX2xpc3Q7CitleHRlcm4gcmVjb3JkX3QgKnJlY29yZF9hcmNoX2xp c3RfaGVhZDsKK2V4dGVybiByZWNvcmRfdCAqcmVjb3JkX2FyY2hfbGlzdF90 YWlsOworZXh0ZXJuIHN0cnVjdCByZWdjYWNoZSAqcmVjb3JkX3JlZ2NhY2hl OworCitleHRlcm4gc3RydWN0IHRhcmdldF9vcHMgcmVjb3JkX29wczsKK2V4 dGVybiBpbnQgcmVjb3JkX3Jlc3VtZV9zdGVwOworCitleHRlcm4gaW50IHJl Y29yZF9hcmNoX2xpc3RfYWRkX3JlZyAoaW50IG51bSk7CitleHRlcm4gaW50 IHJlY29yZF9hcmNoX2xpc3RfYWRkX21lbSAoQ09SRV9BRERSIGFkZHIsIGlu dCBsZW4pOworZXh0ZXJuIGludCByZWNvcmRfYXJjaF9saXN0X2FkZF9lbmQg KGludCBuZWVkX2Rhc20pOworZXh0ZXJuIHZvaWQgcmVjb3JkX21lc3NhZ2Ug KHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoKTsKK2V4dGVybiB2b2lkIHJlY29y ZF9ub3RfcmVjb3JkX3NldCAodm9pZCk7CisKK2V4dGVybiB2b2lkICgqcmVj b3JkX2JlbmVhdGhfdG9fcmVzdW1lKSAocHRpZF90LCBpbnQsIGVudW0gdGFy Z2V0X3NpZ25hbCk7CitleHRlcm4gcHRpZF90ICgqcmVjb3JkX2JlbmVhdGhf dG9fd2FpdCkgKHB0aWRfdCwgc3RydWN0IHRhcmdldF93YWl0c3RhdHVzICop OworZXh0ZXJuIHZvaWQgKCpyZWNvcmRfYmVuZWF0aF90b19zdG9yZV9yZWdp c3RlcnMpIChzdHJ1Y3QgcmVnY2FjaGUgKiwgaW50IHJlZ25vKTsKK2V4dGVy biBMT05HRVNUICgqcmVjb3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFsKSAo c3RydWN0IHRhcmdldF9vcHMgKiBvcHMsCisJCQkJCQkgIGVudW0gdGFyZ2V0 X29iamVjdCBvYmplY3QsCisJCQkJCQkgIGNvbnN0IGNoYXIgKmFubmV4LAor CQkJCQkJICBnZGJfYnl0ZSAqIHJlYWRidWYsCisJCQkJCQkgIGNvbnN0IGdk Yl9ieXRlICogd3JpdGVidWYsCisJCQkJCQkgIFVMT05HRVNUIG9mZnNldCwK KwkJCQkJCSAgTE9OR0VTVCBsZW4pOworZXh0ZXJuIGludCAoKnJlY29yZF9i ZW5lYXRoX3RvX2luc2VydF9icmVha3BvaW50KSAoc3RydWN0IGJwX3Rhcmdl dF9pbmZvICopOworZXh0ZXJuIGludCAoKnJlY29yZF9iZW5lYXRoX3RvX3Jl bW92ZV9icmVha3BvaW50KSAoc3RydWN0IGJwX3RhcmdldF9pbmZvICopOwor CisjZW5kaWYgLyogX1JFQ09SRF9IXyAqLwo= ------=_Part_40467_2637849.1226823534989--