Open-ILS/src/perlmods/OpenILS/Utils/RemoteAccount.pm

   1 package   OpenILS::Utils::RemoteAccount;
   2
   3 # use OpenSRF::Utils::SettingsClient;
   4 use OpenSRF::Utils::Logger qw/:logger/;
   5
   6 use Data::Dumper;
   7 use Net::uFTP;
   8 use Net::SSH2;      # because uFTP doesn't handle SSH keys (yet?)
   9 use File::Temp;
  10 use File::Basename;
  11 use File::Spec;
  12 use Text::Glob qw( match_glob glob_to_regex );
  13 # use Error;
  14
  15 $Data::Dumper::Indent = 0;
  16
  17 use strict;
  18 use warnings;
  19
  20 use Carp;
  21
  22 our $AUTOLOAD;
  23
  24 our %keyfiles = ();
  25
  26 my %fields = (
  27     account_object  => undef,
  28     remote_host     => undef,
  29     remote_user     => undef,
  30     remote_password => undef,
  31     remote_account  => undef,
  32     remote_file     => undef,
  33     remote_path     => undef,   # not really doing anything with this... yet.
  34     ssh_privatekey  => undef,
  35     ssh_publickey   => undef,
  36     type            => undef,
  37     port            => undef,
  38     content         => undef,
  39     local_file      => undef,
  40     tempfile        => undef,
  41     error           => undef,
  42     single_ext      => undef,
  43     specific        => 0,
  44     debug           => 0,
  45 );
  46
  47
  48 =pod
  49
  50 The Remote Account module attempts to transfer a file to/from a remote server.
  51 Net::uFTP is used, encapsulating the available options of SCP, FTP and SFTP.
  52
  53 All information is expected to be gathered by the Event Definition through event parameters:
  54    ~ remote_host (required)
  55    ~ remote_user
  56    ~ remote_password
  57    ~ remote_account
  58    ~ ssh_privatekey
  59    ~ ssh_publickey
  60    ~ type (FTP, SFTP or SCP -- default FTP)
  61    ~ port
  62    ~ debug
  63
  64 The latter three are optionally passed to the Net::uFTP constructor.
  65
  66 Note: none of the parameters are actually required, except remote_host.
  67 That is because remote_user, remote_password and remote_account can all be
  68 extrapolated from other sources, as the Net::FTP docs describe:
  69
  70     If no arguments are given then Net::FTP uses the Net::Netrc package
  71         to lookup the login information for the connected host.
  72
  73     If no information is found then a login of anonymous is used.
  74
  75     If no password is given and the login is anonymous then anonymous@
  76         will be used for password.
  77
  78 Note that specifying a password will require you to specify a user.
  79 Similarly, specifying an account requires both user and password.
  80 That is, there are no assumed defaults when the latter arguments are used.
  81
  82 SSH KEYS:
  83
  84 The use of ssh keys is preferred.
  85
  86 We attempt to use SSH keys where they are specified or otherwise found
  87 in the runtime environment.  If only one key is specified, we attempt to derive
  88 the corresponding filename based on the ssh-keygen defaults.  If either key is
  89 specified, but both are not found (and readable) then the result is failure.  If
  90 no key is specified, but keys are found, the key-based connections will be attempted,
  91 but failure will be non-fatal.
  92
  93 =cut
  94
  95 sub plausible_dirs {
  96     # returns plausible locations of a .ssh subdir where SSH keys might be stashed
  97     # NOTE: these would need to be properly genericized w/ Makefule vars
  98     # in order to support Debian packaging and multiple EG's on one box.
  99     # Until that happens, we just rely on $HOME
 100
 101     my @bases = (
 102        # '/openils/conf',     # __EG_CONFIG_DIR__
 103     );
 104     ($ENV{HOME}) and unshift @bases, $ENV{HOME};
 105
 106     return grep {-d $_} map {"$_/.ssh"} @bases;
 107 }
 108
 109 sub local_keyfiles {
 110     # populates %keyfiles hash
 111     # %keyfiles maps SSH_PRIVATEKEY => SSH_PUBLICKEY
 112     my $self  = shift;
 113     my $force = (@_ ? shift : 0);
 114     return %keyfiles if (%keyfiles and not $force);   # caching
 115     $logger->info("Checking for SSH keyfiles" . ($force ? ' (ignoring cache)' : ''));
 116     %keyfiles = ();  # reset to empty
 117     my @dirs = plausible_dirs();
 118     $logger->debug(scalar(@dirs) . " plausible dirs: " . join(', ', @dirs));
 119     foreach my $dir (@dirs) {
 120         foreach my $key (qw/rsa dsa/) {
 121             my $private = "$dir/id_$key";
 122             my $public  = "$dir/id_$key.pub";
 123             unless (-r $private) {
 124                 $logger->debug("Key '$private' cannot be read: $!");
 125                 next;
 126             }
 127             unless (-r $public) {
 128                 $logger->debug("Key '$public' cannot be read: $!");
 129                 next;
 130             }
 131             $keyfiles{$private} = $public;
 132         }
 133     }
 134     return %keyfiles;
 135 }
 136
 137 sub param_keys {
 138     my $self = shift;
 139     my %keys = ();
 140     if ($self->ssh_publickey and not $self->ssh_privatekey) {
 141         my $private = $self->ssh_publickey;
 142         unless ($private and $private =~ s/\.pub$// and -r $self->ssh_privatekey) {        # try to guess missing private key name
 143             $logger->error("No ssh_privatekey specified or found to pair with " . $self->ssh_publickey);
 144             return;
 145         }
 146         $self->ssh_privatekey($private);
 147     }
 148     if ($self->ssh_privatekey and not $self->ssh_publickey) {
 149         my $pub = $self->ssh_privatekey . '.pub'; # guess missing public key name
 150         unless (-r $pub) {
 151             $logger->error("No ssh_publickey specified or found to pair with " . $self->ssh_privatekey);
 152             return;
 153         }
 154         $self->ssh_publickey($pub);
 155     }
 156
 157     # so now, we have either both ssh_p*keys params or neither
 158     foreach (qw/ssh_publickey ssh_privatekey/) {
 159         unless (-r $self->{$_}) {
 160             $logger->error("$_ '" . $self->{$_} . "' cannot be read: $!");
 161             return;                 # quit w/ error if we fail on any user-specified key
 162         }
 163     }
 164     $keys{$self->ssh_privatekey} = $self->ssh_publickey;
 165     return %keys;
 166 }
 167
 168 sub new_tempfile {
 169     my $self = shift;
 170     my $text = shift || $self->content || '';
 171     my $tmp  = File::Temp->new();      # magical self-destructing tempfile
 172     # print $tmp "THIS IS TEXT\n";
 173     print $tmp $text  or  $logger->error($self->_error("could not write to tempfile '$tmp'"));
 174     close $tmp;
 175     $self->tempfile($tmp);             # save the object
 176     $self->local_file($tmp->filename);  # save the filename
 177     $logger->info(_pkg("using tempfile $tmp"));
 178     return $self->local_file;           # return the filename
 179 }
 180
 181 sub outbound_file {
 182     my $self   = shift;
 183     my $params = shift;
 184
 185     unless (defined $self->content or $self->local_file) {   # content can be emptystring
 186         $logger->error($self->_error("No content or local_file specified -- nothing to send"));
 187         return;
 188     }
 189
 190     # tricky subtlety: we want to use the most recently specified options
 191     #   with priority order: filename, content, old filename, old content.
 192     #
 193     # The $params->{x} will already match $self->x after the secondary init,
 194     # so the checks using $params below are for whether the value was specified NOW (e.g. via put()) or not.
 195     #
 196     # if we got a new local_file value, we use it
 197     # else if the content is new to this call, build a new tempfile w/ it,
 198     # else use existing local_file,
 199     # else build new tempfile w/ content already specified via new()
 200
 201     return $params->{local_file} || (
 202         (defined $params->{content})          ?
 203          $self->new_tempfile($self->content)  :     # $self->content is same value as $params->{content}
 204         ($self->local_file || $self->new_tempfile($self->content))
 205     );
 206 }
 207
 208 sub key_check {
 209     my $self   = shift;
 210     my $params = shift;
 211
 212     return if ($params->{type} and $params->{type} eq 'FTP');   # Forget it, user specified regular FTP
 213     return if (   $self->type  and    $self->type  eq 'FTP');   # Forget it, user specified regular FTP
 214
 215     if ($self->ssh_publickey || $self->ssh_privatekey) {
 216         $self->specific(1);
 217         return $self->param_keys();  # we got one or both params, but they didn't pan out
 218     }
 219     return local_keyfiles();     # optional "force" arg could be used here to empty cache
 220 }
 221
 222
 223 # TOP LEVEL methods
 224 # TODO: delete for both uFTP and SSH2
 225 # TODO: handle IO::Scalar and IO::File for uFTP
 226
 227 sub get {
 228     my $self   = shift;
 229     my $params = shift;
 230     if (! ref $params) {
 231         $params = {remote_file => $params} ;
 232     }
 233
 234     $self->init($params);   # secondary init
 235
 236     $self->{get_args} = [$self->remote_file];      # same for scp_put and uFTP put
 237     push @{$self->{get_args}}, $self->local_file if defined $self->local_file;
 238
 239     # $self->content($content);
 240
 241     my %keys = $self->key_check($params);
 242     if (%keys) {
 243         my $try = $self->get_ssh2(\%keys, @{$self->{get_args}});
 244         return $try if $try;  # if we had keys and they worked, we're done
 245     }
 246
 247     # Otherwise, try w/ non-key uFTP methods
 248     return $self->get_uftp(@{$self->{get_args}});
 249 }
 250
 251 sub put {
 252     my $self   = shift;
 253     my $params = shift;
 254     if (! ref $params) {
 255         $params = {local_file => $params} ;
 256     }
 257
 258     $self->init($params);   # secondary init
 259
 260     my $local_file = $self->outbound_file($params) or return;
 261
 262     $self->{put_args} = [$local_file];      # same for scp_put and uFTP put
 263     if (defined $self->remote_path and not defined $self->remote_file) {
 264         my $rpath = $self->remote_path;
 265         my $fname = basename($local_file);
 266         if ($rpath =~ /^(.*)\*+(.*)$/) {    # if the path has an asterisk in it, like './incoming/*.tst'
 267             my $head = $1;
 268             my $tail = $2;
 269             if ($tail =~ /\//) {
 270                 $logger->warn($self->_error("remote path '$rpath' has dir slashes AFTER an asterisk.  Cannot determine target dir"));
 271                 return;
 272             }
 273             if ($self->single_ext) {
 274                 $tail =~ /\./ and $fname =~ s/\./_/g;    # if dot in tail, replace dots in fname (w/ _)
 275             }
 276             $self->remote_file($head . $fname . $tail);
 277         } else {
 278             $self->remote_file($rpath . '/' . $fname);   # if we know just the dir
 279         }
 280     }
 281
 282     if (defined $self->remote_file) {
 283         push @{$self->{put_args}}, $self->remote_file;   # user can specify remote_file name, optionally
 284     }
 285
 286     my %keys = $self->key_check($params);
 287     if (%keys) {
 288         $self->put_ssh2(\%keys, @{$self->{put_args}}) and return $self->remote_file;
 289         # if we had keys and they worked, we're done
 290     }
 291
 292     # Otherwise, try w/ non-key uFTP methods
 293     return $self->put_uftp(@{$self->{put_args}});
 294 }
 295
 296 sub ls {
 297     my $self   = shift;
 298     my $params = shift;
 299     my @targets = @_;
 300     if (! ref $params) {
 301         unshift @targets, ($params || '.');   # If it was just a string, it's the first target, else default pwd
 302         delete $self->{remote_file}; # overriding any target in the object previously.
 303         $params = {};                # make params a normal hashref again
 304     } else {
 305         if ($params->{remote_file} and @_) {
 306             $logger->warn($self->_error("Ignoring ls parameter remote_file for subsequent args"));
 307             delete $params->{remote_file};
 308         }
 309         $self->init($params);   # secondary init
 310         $self->remote_file and (! @targets) and push @targets, $self->remote_file;  # if remote_file is there, and there's nothing else, use it
 311         delete $self->{remote_file};
 312     }
 313
 314     $self->{ls_args} = \@targets;
 315
 316     my %keys = $self->key_check($params);
 317     if (%keys) {
 318         # $logger->info("*** calling ls_ssh2(keys, '" . join("', '", (scalar(@targets) ? map {defined $_ ? $_ : '' } @targets : ())) . "') with ssh keys");
 319         my @try = $self->ls_ssh2(\%keys, @targets);
 320         return @try if @try;  # if we had keys and they worked, we're done
 321     }
 322
 323     # Otherwise, try w/ non-key uFTP methods
 324     return $self->ls_uftp(@targets);
 325 }
 326
 327 # Checks if the filename part of a pathname has one or more glob characters
 328 # We split out the filename portion of the path
 329 # Detect glob or no glob.
 330 # returns: directory, regex for matching filenames
 331 sub glob_parse {
 332     my $self = shift;
 333     my $path = shift or return;
 334     my ($vol, $dir, $file) = File::Spec->splitpath($path); # we don't care about attempted globs in mid-filepath
 335     $file =~ /\*/ and return (File::Spec->catdir($vol, $dir), glob_to_regex($file));
 336     $file =~ /\?/ and return (File::Spec->catdir($vol, $dir), glob_to_regex($file));
 337     $logger->debug("No glob detected in '$path'");
 338     return;
 339 }
 340
 341
 342 # Internal Mechanics
 343
 344 sub _ssh2 {
 345     my $self = shift;
 346     $self->{ssh2} and return $self->{ssh2};     # caching
 347     my $keys = shift;
 348
 349     my $ssh2 = Net::SSH2->new();
 350     unless($ssh2->connect($self->remote_host)) {
 351         $logger->warn($self->error("SSH2 connect FAILED: $! " . join(" ", $ssh2->error)));
 352         return;     # we cannot connect
 353     }
 354
 355     my $success  = 0;
 356     my @privates = keys %$keys;
 357     my $count    = scalar @privates;
 358     foreach (@privates) {
 359         if ($self->auth_ssh2($ssh2, $self->auth_ssh2_args($_, $keys->{$_}))) {
 360             $success++;
 361             last;
 362         }
 363     }
 364     unless ($success) {
 365         $logger->error($self->error("All ($count) keypair(s) FAILED for " . $self->remote_host));
 366         return;
 367     }
 368     return $self->{ssh2} = $ssh2;
 369 }
 370
 371 sub auth_ssh2 {
 372     my $self = shift;
 373     my $ssh2 = shift;
 374     my %auth_args = @_;
 375     $ssh2 or return;
 376
 377     my $host = $auth_args{hostname}   || 'UNKNOWN';
 378     my $key  = $auth_args{privatekey} || 'UNKNOWN';
 379     my $msg  = "ssh2->auth by keypair for $host using $key";
 380     if ($ssh2->auth(%auth_args)) {
 381         $logger->info("Successful $msg");
 382          return 1;
 383     }
 384
 385     if ($self->specific) {
 386         $logger->error($self->error("Aborting. FAILED $msg: " . ($ssh2->error || '')));
 387     } else {
 388         $logger->warn($self->error("Unsuccessful keypair: FAILED $msg: " . ($ssh2->error || '')));
 389     }
 390     return;
 391 }
 392
 393 sub auth_ssh2_args {
 394     my $self = shift;
 395     my %auth_args = (
 396         privatekey => shift,
 397         publickey  => shift,
 398         rank => [qw/ publickey hostbased password /],
 399     );
 400     $self->remote_user     and $auth_args{username} = $self->remote_user    ;
 401     $self->remote_password and $auth_args{password} = $self->remote_password;
 402     $self->remote_host     and $auth_args{hostname} = $self->remote_host    ;
 403     return %auth_args;
 404 }
 405
 406 sub put_ssh2 {
 407     my $self = shift;
 408     my $keys = shift;    # could have many keypairs here
 409     unless (@_) {
 410         $logger->error($self->_error("put_ssh2 called without target: nothing to put!"));
 411         return;
 412     }
 413
 414     $logger->info("*** attempting put (" . join(", ", @_) . ") with ssh keys");
 415     my $ssh2 = $self->_ssh2($keys) or return;
 416     my $res;
 417     if ($res = $ssh2->scp_put( @_ )) {
 418         $logger->info(_pkg("successfully sent", $self->remote_host, join(' --> ', @_ )));
 419         return $res;
 420     }
 421     $logger->error($self->_error(sprintf "put with keys to %s failed with error: $!", $self->remote_host));
 422     return;
 423 }
 424
 425 sub get_ssh2 {
 426     my $self = shift;
 427     my $keys = shift;    # could have many keypairs here
 428     unless (@_) {
 429         $logger->error($self->_error("get_ssh2 called without target: nothing to get!"));
 430         return;
 431     }
 432
 433     $logger->info("*** get args: " . Dumper(\@_));
 434     $logger->info("*** attempting get (" . join(", ", map {$_ =~ /\S/ ? $_ : '*Object'} map {defined($_) ? $_ : '*Object'} @_) . ") with ssh keys");
 435     my $ssh2 = $self->_ssh2($keys) or return;
 436     my $res;
 437     if ($res = $ssh2->scp_get( @_ )) {
 438         $logger->info(_pkg("successfully got", $self->remote_host, join(' --> ', @_ )));
 439         return $res;
 440     }
 441     $logger->error($self->_error(sprintf "get with keys from %s failed with error: $!", $self->remote_host));
 442     return;
 443 }
 444
 445 sub ls_ssh2 {
 446     my $self = shift;
 447     my @list = $self->ls_ssh2_full(@_);
 448     @list and return sort map {$_->{slash_path}} @list;
 449 #   @list and return sort grep {$_->{name} !~ /./ and {$_->{name} !~ /./ } map {$_->{slash_path}} @list;
 450 }
 451
 452 sub ls_ssh2_full {
 453     my $self = shift;
 454     my $keys = shift;    # could have many keypairs here
 455     my @targets = grep {defined} @_;
 456
 457     $logger->info("*** attempting ls ('" . join("', '", @targets) . "') with ssh keys");
 458     my $ssh2 = $self->_ssh2($keys) or return;
 459     my $sftp = $ssh2->sftp         or return;
 460
 461     my @list = ();
 462     foreach my $target (@targets) {
 463         my ($dir, $file);
 464         my ($dirpath, $regex) = $self->glob_parse($target);
 465         $dir = $sftp->opendir($dirpath || $target);     # Try to open it like a directory
 466         unless ($dir) {
 467             $file = $sftp->stat($target);   # Otherwise, check it like a file
 468             if ($file) {
 469                 $file->{slash_path} = $self->_slash_path($target, $file->{name});     # it was a file, not a dir.  That's OK.
 470                 push @list, $file;
 471             } else {
 472                 $logger->warn($self->_error("sftp->opendir($target) failed: " . $sftp->error));
 473             }
 474             next;
 475         }
 476         my @pool = ();
 477         while ($file = $dir->read()) {
 478             $file->{slash_path} = $self->_slash_path($target, $file->{name});
 479             push @pool, $file;
 480         }
 481         if ($regex) {
 482             my $count = scalar(@pool);
 483             @pool = grep {$_->{name} =~ /$regex/} @pool;
 484             $logger->info("Glob regex($regex) matches " . scalar(@pool) . " of $count files");
 485         }
 486         push @list, @pool;
 487     }
 488     return @list;
 489
 490 }
 491
 492 sub _slash_path {    # not OO
 493     my $self = shift;
 494     my $dir  = shift || '.';
 495     my $file = shift || '';
 496     return $dir . ($dir =~ /\/$/ ? '' : '/') . $file;
 497 }
 498
 499 sub _uftp {
 500     my $self = shift;
 501     my %options = ();
 502     $self->{uftp} and return $self->{uftp};     # caching
 503     foreach (qw/debug type port/) {
 504         $options{$_} = $self->{$_} if $self->{$_};
 505     }
 506
 507     my $ftp = Net::uFTP->new($self->remote_host, %options);
 508     unless ($ftp) {
 509         $logger->error($self->_error('Net::uFTP->new("' . $self->remote_host . ", ...) FAILED: $@"));
 510         return;
 511     }
 512
 513     my @login_args = ();
 514     foreach (qw/remote_user remote_password remote_account/) {
 515         $self->{$_} or last;
 516         push @login_args, $self->{$_};
 517     }
 518     my $login_ok = 0;
 519     eval { $login_ok = $ftp->login(@login_args) };
 520     if ($@ or !$login_ok) {
 521         $logger->error($self->_error("failed login to", $self->remote_host,  "w/ args(" . join(',', @login_args) . ") : $@"));
 522         return;
 523     }
 524     return $self->{uftp} = $ftp;
 525 }
 526
 527 sub put_uftp {
 528     my $self = shift;
 529     my $ftp = $self->_uftp or return;
 530     my $filename;
 531     eval { $filename = $ftp->put(@{$self->{put_args}}) };
 532     if ($@ or ! $filename) {
 533         $logger->error($self->_error("put to", $self->remote_host, "failed with error: $@"));
 534         return;
 535     }
 536     $self->remote_file($filename);
 537     $logger->info(_pkg("successfully sent", $self->remote_host, $self->local_file, '-->', $filename));
 538     return $filename;
 539 }
 540
 541 sub get_uftp {
 542     my $self = shift;
 543     my $ftp = $self->_uftp or return;
 544     my $filename;
 545     eval { $filename = $ftp->get(@{$self->{get_args}}) };
 546     if ($@ or ! $filename) {
 547         $logger->error($self->_error("get from", $self->remote_host, "failed with error: $@"));
 548         return;
 549     }
 550     $self->local_file($filename);
 551     $logger->info(_pkg("successfully retrieved $filename <--", $self->remote_host . '/' . $self->remote_file));
 552     return $self->local_file;
 553 }
 554
 555 sub ls_uftp {
 556     my $self = shift;
 557     my $ftp = $self->_uftp or return;
 558     my @list;
 559     foreach (@_) {
 560         my @part;
 561         my ($dirpath, $regex) = $self->glob_parse($_);
 562         eval { @part = $ftp->ls($dirpath || $_) };
 563         if ($@) {
 564             $logger->error($self->_error("ls from",  $self->remote_host, "failed with error: $@"));
 565             next;
 566         }
 567         if ($regex) {
 568             my $count = scalar(@part);
 569             @part = grep {/$regex/} @part;
 570             $logger->info("Glob regex($regex) matches " . scalar(@part) . " of $count files");
 571         }
 572         push @list, @part;
 573     }
 574     return @list;
 575 }
 576
 577 sub delete_uftp {
 578     my $self = shift;
 579     my $ftp = $self->_uftp or return;
 580     return $ftp->delete(shift);
 581 }
 582
 583 sub _pkg {      # Not OO
 584     return __PACKAGE__ . ' : ' unless @_;
 585     return __PACKAGE__ . ' : ' . join(' ', @_);
 586 }
 587
 588 sub _error {
 589     my $self = shift;
 590     return _pkg($self->error(join(' ',@_)));
 591 }
 592
 593 sub init {
 594     my $self   = shift;
 595     my $params = shift;
 596     my @required = @_;  # qw(remote_host) ;     # nothing required now
 597
 598     if ($params->{account_object}) {    # if we got passed an object, we initialize off that first
 599         $self->{remote_host    } = $params->{account_object}->host;
 600         $self->{remote_user    } = $params->{account_object}->username;
 601         $self->{remote_password} = $params->{account_object}->password;
 602         $self->{remote_account } = $params->{account_object}->account;
 603         $self->{remote_path    } = $params->{account_object}->path;     # not really the same as remote_file, maybe expand on this later
 604     }
 605
 606     foreach (keys %{$self->{_permitted}}) {
 607         $self->{$_} = $params->{$_} if defined $params->{$_};   # possibly override settings from object
 608     }
 609
 610     foreach (@required) {
 611         unless ($self->{$_}) {
 612             $logger->error("Required parameter $_ not specified");
 613             return;
 614         }
 615     }
 616     return $self;
 617 }
 618
 619 sub new {
 620     my ($class, %args) = @_;
 621     my $self = { _permitted => \%fields, %fields };
 622
 623         bless $self, $class;
 624
 625     $self->init(\%args); # or croak "Initialization error caused by bad args";
 626     return $self;
 627 }
 628
 629 sub DESTROY {
 630         # in order to create, we must first ...
 631         my $self  = shift;
 632     $self->{ssh2} and $self->{ssh2}->disconnect();  # let the other end know we're done.
 633     $self->{uftp} and $self->{uftp}->quit();  # let the other end know we're done.
 634 }
 635
 636 sub AUTOLOAD {
 637         my $self  = shift;
 638         my $class = ref($self) or croak "AUTOLOAD error: $self is not an object";
 639         my $name  = $AUTOLOAD;
 640
 641         $name =~ s/.*://;   #   strip leading package stuff
 642
 643         unless (exists $self->{_permitted}->{$name}) {
 644                 croak "AUTOLOAD error: Cannot access '$name' field of class '$class'";
 645         }
 646
 647         if (@_) {
 648                 return $self->{$name} = shift;
 649         } else {
 650                 return $self->{$name};
 651         }
 652 }
 653
 654 1;
 655