Changeset 109

Show
Ignore:
Timestamp:
12/13/06 17:16:04 (2 years ago)
Author:
kindlund
Message:

Finally got the core _compare() functionality to work.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • honeyclient/branches/bug/42/lib/HoneyClient/Agent/Integrity/Registry.pm

    r108 r109  
    816816 
    817817    # A hashtable reference, containing the latest change found. 
    818     my $change; 
     818    my $change = { }; 
    819819 
    820820    # While we are able to read the next key from either file... 
    …… 
    874874                        $change->{'key'} = $before_group; 
    875875                        $change->{'status'} = "changed"; 
    876                         push(@{$change->{'entries'}}, { 
    877                                 name      => $before_entry_name, 
    878                                 old_value => $before_entry_value, 
    879                                 new_value => $after_entry_value, 
    880                              }); 
     876                        $change->{'entries'}->{$before_entry_name} = { 
     877                            old_value => $before_entry_value, 
     878                            new_value => $after_entry_value, 
     879                        }; 
     880#                        push(@{$change->{'entries'}}, { 
     881#                                name      => $before_entry_name, 
     882#                                old_value => $before_entry_value, 
     883#                                new_value => $after_entry_value, 
     884#                             }); 
    881885 
    882886                        # Print the key name, if set. 
    …… 
    922926                        # in the after file. 
    923927#                        print "$before_entry_name\n"; 
    924                         push(@{$change->{'entries'}}, { 
    925                                 name      => $before_entry_name, 
     928                        # Check to see if some of this change data already exists... 
     929                        if (exists($change->{'entries'}->{$before_entry_name})) { 
     930 
     931                            # Sanity check: Looks like an earlier iteration populated 
     932                            # this change entry with a 'new_value'.  Let's make sure 
     933                            # the our 'old_value' and 'new_value' are truly different. 
     934                            if (defined($change->{'entries'}->{$before_entry_name}->{'new_value'}) && 
     935                                ($change->{'entries'}->{$before_entry_name}->{'new_value'} ne 
     936                                 $before_entry_value)) { 
     937 
     938                                # Okay, looks like they're different, so only update the old_value. 
     939                                $change->{'entries'}->{$before_entry_name}->{'old_value'} = $before_entry_value; 
     940                            } else { 
     941                                # Looks like they're the same value, so delete the entry completely. 
     942                                delete($change->{'entries'}->{$before_entry_name}); 
     943                            } 
     944                        } else { 
     945                            # If not, then update both old_value and new_value. 
     946                            $change->{'entries'}->{$before_entry_name} = { 
    926947                                old_value => $before_entry_value, 
    927948                                new_value => undef, 
    928                              }); 
     949                            }; 
     950                        } 
     951#                        push(@{$change->{'entries'}}, { 
     952#                                name      => $before_entry_name, 
     953#                                old_value => $before_entry_value, 
     954#                                new_value => undef, 
     955#                             }); 
    929956 
    930957                        # And get the next corresponding key/value pair from the before group. 
    …… 
    937964                        # Print the to key's value, marked as new. 
    938965#                        print "$after_entry_name=$after_entry_value$newMarker\n"; 
    939                         push(@{$change->{'entries'}}, { 
    940                                 name      => $after_entry_name, 
     966                        # Check to see if some of this change data already exists... 
     967                        if (exists($change->{'entries'}->{$after_entry_name})) { 
     968                            # Sanity check: Looks like an earlier iteration populated 
     969                            # this change entry with an 'old_value'.  Let's make sure 
     970                            # the our 'old_value' and 'new_value' are truly different. 
     971                            if (defined($change->{'entries'}->{$after_entry_name}->{'old_value'}) && 
     972                                ($change->{'entries'}->{$after_entry_name}->{'old_value'} ne 
     973                                 $after_entry_value)) { 
     974 
     975                                # Okay, looks like they're different, so only update the new_value. 
     976                                $change->{'entries'}->{$after_entry_name}->{'new_value'} = $after_entry_value; 
     977                            } else { 
     978                                # Looks like they're the same value, so delete the entry completely. 
     979                                delete($change->{'entries'}->{$after_entry_name}); 
     980                            } 
     981                        } else { 
     982                            # If not, then update both old_value and new_value. 
     983                            $change->{'entries'}->{$after_entry_name} = { 
    941984                                old_value => undef, 
    942985                                new_value => $after_entry_value, 
    943                              }); 
     986                            }; 
     987                        } 
     988#                        push(@{$change->{'entries'}}, { 
     989#                                name      => $after_entry_name, 
     990#                                old_value => undef, 
     991#                                new_value => $after_entry_value, 
     992#                             }); 
    944993 
    945994                        # And get the next corresponding key/value pair from the after group. 
    …… 
    9811030                $change->{'key'} = $before_group; 
    9821031                $change->{'status'} = "deleted"; 
     1032                $change->{'entries'} = { }; 
    9831033 
    9841034                # Save the length of the deleted group name. 
    …… 
    9931043                # While there are key/values within this before group. 
    9941044                while (defined($before_entry_name)) { 
    995                     push(@{$change->{'entries'}}, { 
    996                             name      => $before_entry_name, 
    997                             old_value => $before_entry_value, 
    998                             new_value => undef, 
    999                          }); 
     1045                    $change->{'entries'}->{$before_entry_name} = { 
     1046                        old_value => $before_entry_value, 
     1047                        new_value => undef, 
     1048                    }; 
     1049#                    push(@{$change->{'entries'}}, { 
     1050#                            name      => $before_entry_name, 
     1051#                            old_value => $before_entry_value, 
     1052#                            new_value => undef, 
     1053#                         }); 
    10001054 
    10011055                    # And get the next corresponding key/value pair from the before group. 
    …… 
    10171071            $change->{'key'} = $after_group; 
    10181072            $change->{'status'} = "added"; 
     1073            $change->{'entries'} = { }; 
    10191074 
    10201075            # Save the after group as a "new" group. 
    …… 
    10311086            while (defined($after_entry_name)) { 
    10321087 
    1033                 push(@{$change->{'entries'}}, { 
    1034                         name      => $after_entry_name, 
    1035                         old_value => undef, 
    1036                         new_value => $after_entry_value, 
    1037                      }); 
     1088                $change->{'entries'}->{$after_entry_name} = { 
     1089                    old_value => undef, 
     1090                    new_value => $after_entry_value, 
     1091                }; 
     1092 
     1093#                push(@{$change->{'entries'}}, { 
     1094#                        name      => $after_entry_name, 
     1095#                        old_value => undef, 
     1096#                        new_value => $after_entry_value, 
     1097#                     }); 
    10381098 
    10391099                # Print the new key name. 
    …… 
    10581118        } 
    10591119 
     1120        # Transform the 'entries' sub-key from a nested hash structure, 
     1121        # into an array of separate hashtables. 
     1122        if (exists($change->{'entries'})) { 
     1123            my $entries = [ ]; 
     1124            while (my ($key, $value) = each(%{$change->{'entries'}})) { 
     1125                push (@{$entries}, { 
     1126                        name      => $key, 
     1127                        old_value => $value->{'old_value'}, 
     1128                        new_value => $value->{'new_value'}, 
     1129                }); 
     1130            } 
     1131            $change->{'entries'} = $entries; 
     1132        } 
    10601133 
    10611134        # Dump the corresponding change, if there was any.