summaryrefslogtreecommitdiff
path: root/Master/tlpkg/tlperl.straw/lib/Crypt/OpenPGP/Plaintext.pm
blob: 892bf15679d9c14fb18106b321de116ecd08743e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package Crypt::OpenPGP::Plaintext;
use strict;

use Crypt::OpenPGP::Buffer;
use Crypt::OpenPGP::ErrorHandler;
use base qw( Crypt::OpenPGP::ErrorHandler );

sub new {
    my $class = shift;
    my $pt = bless { }, $class;
    $pt->init(@_);
}

sub data { $_[0]->{data} }
sub mode { $_[0]->{mode} }

sub init {
    my $pt = shift;
    my %param = @_;
    if (my $data = $param{Data}) {
        $pt->{data} = $data;
        $pt->{mode} = $param{Mode} || 'b';
        $pt->{timestamp} = time;
        $pt->{filename} = $param{Filename} || '';
    }
    $pt;
}

sub parse {
    my $class = shift;
    my($buf) = @_;
    my $pt = $class->new;
    $pt->{mode} = $buf->get_char;
    $pt->{filename} = $buf->get_bytes($buf->get_int8);
    $pt->{timestamp} = $buf->get_int32;
    $pt->{data} = $buf->get_bytes( $buf->length - $buf->offset );
    $pt;
}

sub save {
    my $pt = shift;
    my $buf = Crypt::OpenPGP::Buffer->new;
    $buf->put_char($pt->{mode});
    $buf->put_int8(length $pt->{filename});
    $buf->put_bytes($pt->{filename});
    $buf->put_int32($pt->{timestamp});
    $buf->put_bytes($pt->{data});
    $buf->bytes;
}

1;
__END__

=head1 NAME

Crypt::OpenPGP::Plaintext - A plaintext, literal-data packet

=head1 SYNOPSIS

    use Crypt::OpenPGP::Plaintext;

    my $data = 'foo bar';
    my $file = 'foo.txt';

    my $pt = Crypt::OpenPGP::Plaintext->new(
                             Data     => $data,
                             Filename => $file,
                    );
    my $serialized = $pt->save;

=head1 DESCRIPTION

I<Crypt::OpenPGP::Plaintext> implements plaintext literal-data packets,
and is essentially just a container for a string of octets, along
with some meta-data about the plaintext.

=head1 USAGE

=head2 Crypt::OpenPGP::Plaintext->new( %arg )

Creates a new plaintext data packet object and returns that object.
If there are no arguments in I<%arg>, the object is created with an
empty data container; this is used, for example, in I<parse> (below),
to create an empty packet which is then filled from the data in the
buffer.

If you wish to initialize a non-empty object, I<%arg> can contain:

=over 4

=item * Data

A block of octets that make up the plaintext data.

This argument is required (for a non-empty object).

=item * Filename

The name of the file that this data came from, or the name of a file
where it should be saved upon extraction from the packet (after
decryption, for example, if this packet is going to be encrypted).

=item * Mode

The mode in which the data is formatted. Valid values are C<t> and
C<b>, meaning "text" and "binary", respectively.

This argument is optional; I<Mode> defaults to C<b>.

=back

=head2 $pt->save

Returns the serialized form of the plaintext object, which is the
plaintext data, preceded by some meta-data describing the data.

=head2 Crypt::OpenPGP::Plaintext->parse($buffer)

Given I<$buffer>, a I<Crypt::OpenPGP::Buffer> object holding (or
with offset pointing to) a plaintext data packet, returns a new
I<Crypt::OpenPGP::Ciphertext> object, initialized with the data
in the buffer.

=head2 $pt->data

Returns the plaintext data.

=head2 $pt->mode

Returns the mode of the packet (either C<t> or C<b>).

=head1 AUTHOR & COPYRIGHTS

Please see the Crypt::OpenPGP manpage for author, copyright, and
license information.

=cut