File Coverage

blib/lib/Config/OpenSSH/Authkey.pm

Criterion	Covered	Total	%
statement	85	90	94.4
branch	25	34	73.5
condition	6	14	42.8
subroutine	18	19	94.7
pod	12	12	100.0
total	146	169	86.3

# -*- Perl -*-
#
# Methods to interact with OpenSSH authorized_keys file data.

package Config::OpenSSH::Authkey;

use strict;
use warnings;

use Carp qw/croak/;
use Config::OpenSSH::Authkey::Entry ();

use IO::Handle qw(getline);

our $VERSION = '1.04';

######################################################################
#
# Utility Methods - Internal

{
  # Utility class for comments or blank lines in authorized_keys files
  package Config::OpenSSH::Authkey::MetaEntry;

  sub new {
    my $class = shift;
    my $entry = shift;
    bless \$entry, $class;
  }

  sub as_string {
    ${ $_[0] };
  }
}

######################################################################
#
# Class methods

sub new {
  my $class = shift;
  my $options_ref = shift || {};

  my $self = {
    _fh                  => undef,
    _keys                => [],
    _seen_keys           => {},
    _auto_store          => 0,
    _tag_dups            => 0,
    _nostore_nonkey_data => 0
  };

  for my $pref (qw/auto_store tag_dups nostore_nonkey_data/) {
    if ( exists $options_ref->{$pref} ) {
      $self->{"_$pref"} = $options_ref->{$pref} ? 1 : 0;
    }
  }

  bless $self, $class;
  return $self;
}

######################################################################
#
# Instance methods

sub fh {
  my $self = shift;
  my $fh = shift || croak 'fh requires a filehandle';

  $self->{_fh} = $fh;
  return $self;
}

sub file {
  my $self = shift;
  my $file = shift || croak 'file requires a file';

  my $fh;
  open( $fh, '<', $file ) or croak $!;
  $self->{_fh} = $fh;

  return $self;
}

sub iterate {
  my $self = shift;
  croak 'no filehandle to iterate on' if !defined $self->{_fh};

  my $line = $self->{_fh}->getline;
  return defined $line ? $self->parse($line) : ();
}

sub consume {
  my $self = shift;
  croak 'no filehandle to consume' if !defined $self->{_fh};

  my $old_auto_store = $self->auto_store();
  $self->auto_store(1);

  while ( my $line = $self->{_fh}->getline ) {
    $self->parse($line);
  }

  $self->auto_store($old_auto_store);

  return $self;
}

sub parse {
  my $self = shift;
  my $data = shift || croak 'need data to parse';

  my $entry;

  if ( $data =~ m/^\s*(?:#|$)/ ) {
    chomp($data);
    $entry = Config::OpenSSH::Authkey::MetaEntry->new($data);
    if ( $self->{_auto_store} and !$self->{_nostore_nonkey_data} ) {
      push @{ $self->{_keys} }, $entry;
    }
  } else {
    $entry = Config::OpenSSH::Authkey::Entry->new($data);
    if ( $self->{_tag_dups} ) {
      if ( exists $self->{_seen_keys}->{ $entry->key } ) {
        $entry->duplicate_of( $self->{_seen_keys}->{ $entry->key } );
      } else {
        $self->{_seen_keys}->{ $entry->key } = $entry;
      }
    }
    push @{ $self->{_keys} }, $entry if $self->{_auto_store};
  }

  return $entry;
}

sub get_stored_keys {
  shift->{_keys};
}

sub reset_store {
  my $self = shift;
  $self->{_seen_keys} = {};
  $self->{_keys}      = [];
  return $self;
}

sub reset_dups {
  my $self = shift;
  $self->{_seen_keys} = {};
  return $self;
}

sub auto_store {
  my $self    = shift;
  my $setting = shift;
  if ( defined $setting ) {
    $self->{_auto_store} = $setting ? 1 : 0;
  }
  return $self->{_auto_store};
}

sub tag_dups {
  my $self    = shift;
  my $setting = shift;
  if ( defined $setting ) {
    $self->{_tag_dups} = $setting ? 1 : 0;
  }
  return $self->{_tag_dups};
}

sub nostore_nonkey_data {
  my $self    = shift;
  my $setting = shift;
  if ( defined $setting ) {
    $self->{_nostore_nonkey_data} = $setting ? 1 : 0;
  }
  return $self->{_nostore_nonkey_data};
}

1;

__END__