← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libnetpacket-perl/trusty

« back to all changes in this revision

Viewing changes to .pc/whatis.patch/lib/NetPacket/USBMon.pm

  • Committer: Package Import Robot
  • Author(s): Florian Schlichting
  • Date: 2013-12-04 23:49:19 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20131204234919-5ebhy77qln1p1fis
Tags: 1.4.4-1
* Import Upstream version 1.4.4
* Drop spelling.patch, whatis.patch: both applied upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/whatis.patch/lib/NetPacket/USBMon.pm
1
 
package NetPacket::USBMon;
2
 
BEGIN {
3
 
  $NetPacket::USBMon::AUTHORITY = 'cpan:YANICK';
4
 
}
5
 
{
6
 
  $NetPacket::USBMon::VERSION = '1.4.2';
7
 
}
8
 
 
9
 
use strict;
10
 
use vars qw(@ISA @EXPORT_OK %EXPORT_TAGS);
11
 
use NetPacket;
12
 
 
13
 
BEGIN {
14
 
    @ISA = qw(Exporter NetPacket);
15
 
 
16
 
    @EXPORT_OK = qw(
17
 
                    USB_TYPE_SUBMISSION USB_TYPE_CALLBACK USB_TYPE_ERROR
18
 
                    USB_XFER_TYPE_ISO USB_XFER_TYPE_INTR
19
 
                    USB_XFER_TYPE_CONTROL USB_XFER_TYPE_BULK
20
 
                    USB_FLAG_SETUP_IRRELEVANT USB_FLAG_SETUP_RELEVANT
21
 
                    USB_FLAG_DATA_ERROR USB_FLAG_DATA_INCOMING
22
 
                    USB_FLAG_DATA_OUTGOING USB_FLAG_DATA_PRESENT
23
 
                    USB_TYPE_VENDOR
24
 
    );
25
 
 
26
 
    %EXPORT_TAGS =(
27
 
    ALL         => \@EXPORT_OK,
28
 
    types       => [qw(USB_TYPE_SUBMISSION USB_TYPE_CALLBACK
29
 
                       USB_TYPE_ERROR)],
30
 
    xfer_types  => [qw(USB_XFER_TYPE_ISO USB_XFER_TYPE_INTR
31
 
                       USB_XFER_TYPE_CONTROL USB_XFER_TYPE_BULK)],
32
 
    setup_flags => [qw(USB_FLAG_SETUP_IRRELEVANT USB_FLAG_SETUP_RELEVANT)],
33
 
    data_flags  => [qw(USB_FLAG_DATA_ERROR USB_FLAG_DATA_INCOMING
34
 
                       USB_FLAG_DATA_OUTGOING USB_FLAG_DATA_PRESENT)],
35
 
    setup_types => [qw(USB_TYPE_VENDOR)],
36
 
);
37
 
 
38
 
}
39
 
 
40
 
use constant USB_TYPE_SUBMISSION        => 'S';
41
 
use constant USB_TYPE_CALLBACK          => 'C';
42
 
use constant USB_TYPE_ERROR             => 'E';
43
 
 
44
 
use constant USB_XFER_TYPE_ISO          => 0;
45
 
use constant USB_XFER_TYPE_INTR         => 1;
46
 
use constant USB_XFER_TYPE_CONTROL      => 2;
47
 
use constant USB_XFER_TYPE_BULK         => 3;
48
 
 
49
 
use constant USB_FLAG_SETUP_IRRELEVANT  => '-';
50
 
use constant USB_FLAG_SETUP_RELEVANT    => chr(0);
51
 
 
52
 
use constant USB_FLAG_DATA_ERROR        => 'E';
53
 
use constant USB_FLAG_DATA_INCOMING     => '<';
54
 
use constant USB_FLAG_DATA_OUTGOING     => '>';
55
 
use constant USB_FLAG_DATA_PRESENT      => chr(0);
56
 
 
57
 
use constant USB_TYPE_VENDOR            => 0x40;
58
 
 
59
 
sub decode
60
 
{
61
 
    my $class = shift;
62
 
    my $packet = shift;
63
 
    my $parent = shift;
64
 
 
65
 
    my($id, $type, $xfer_type, $epnum, $devnum, $busnum, $flag_setup,
66
 
        $flag_data, $ts_sec, $ts_usec, $status, $length, $len_cap,
67
 
        $s, $interval, $start_frame, $xfer_flags, $ndesc, $rest) =
68
 
        unpack('a8CCCCSCCa8liIIa8llLLa*', $packet);
69
 
 
70
 
    # Try to grok quads. We may loose some address information with 32-bit
71
 
    # Perl parsing 64-bit captures, or timestamp after 2038. Still the best
72
 
    # we can do.
73
 
    eval {
74
 
      $id = unpack ('Q', $id);
75
 
      $ts_sec = unpack ('Q', $ts_sec);
76
 
    };
77
 
    if ($@) {
78
 
      ($id) = unpack ('LL', $id);
79
 
      ($ts_sec) = unpack ('LL', $ts_sec);
80
 
    }
81
 
 
82
 
    my $self = {
83
 
        _parent         => $parent,
84
 
        _frame          => $packet,
85
 
 
86
 
        id              => $id,
87
 
        type            => chr($type),
88
 
        xfer_type       => $xfer_type,
89
 
        ep              => {
90
 
            num         => ($epnum & 0x7f),
91
 
            dir         => ($epnum & 0x80 ? 'IN' : 'OUT'),
92
 
        },
93
 
        devnum          => $devnum,
94
 
        busnum          => $busnum,
95
 
        flag_setup      => chr($flag_setup),
96
 
        flag_data       => chr($flag_data),
97
 
        ts_sec          => $ts_sec,
98
 
        ts_usec         => $ts_usec,
99
 
        status          => $status,
100
 
        length          => $length,
101
 
        len_cap         => $len_cap,
102
 
        interval        => $interval,
103
 
        start_frame     => $start_frame,
104
 
        xfer_flags      => $xfer_flags,
105
 
        ndesc           => $ndesc,
106
 
    };
107
 
 
108
 
    # Setup
109
 
    if ($self->{flag_setup} ne USB_FLAG_SETUP_IRRELEVANT) {
110
 
        my $setup = {};
111
 
        my $rest;
112
 
 
113
 
       ($setup->{bmRequestType}, $setup->{bRequest}, $rest)
114
 
            = unpack('CCa*', $s);
115
 
 
116
 
        if ($setup->{bmRequestType} & USB_TYPE_VENDOR) {
117
 
           ($setup->{wValue}, $setup->{wIndex},
118
 
                $setup->{wLength}) = unpack('S3', $rest);
119
 
        } else {
120
 
            # Unknown setup request;
121
 
            $setup->{data} = $rest;
122
 
        }
123
 
 
124
 
        $self->{setup} = $setup;
125
 
    }
126
 
 
127
 
    # Isochronous descriptors
128
 
    if ($self->{xfer_type} == USB_XFER_TYPE_ISO) {
129
 
        my $iso = {};
130
 
       ($iso->{error_count}, $iso->{numdesc}) = unpack('ii', $s);
131
 
        $self->{iso} = $iso;
132
 
    }
133
 
 
134
 
    # Data
135
 
    warn 'Payload length mismatch'
136
 
        if length($rest) ne $self->{len_cap};
137
 
    $self->{data} = $rest;
138
 
 
139
 
    return bless $self, $class;
140
 
}
141
 
 
142
 
1;
143
 
 
144
 
__END__
145
 
 
146
 
=pod
147
 
 
148
 
=head1 NAME
149
 
 
150
 
NetPacket::USBMon
151
 
 
152
 
=head1 VERSION
153
 
 
154
 
version 1.4.2
155
 
 
156
 
=head1 SYNOPSIS
157
 
 
158
 
  use NetPacket::USBMon;
159
 
 
160
 
  $usb = NetPacket::USBMon->decode($raw_pkt);
161
 
 
162
 
=head1 DESCRIPTION
163
 
 
164
 
C<NetPacket::USBMon> is a L<NetPacket> decoder of USB packets captured via
165
 
Linux USBMon interface.
166
 
 
167
 
=head2 Methods
168
 
 
169
 
=over
170
 
 
171
 
=item C<NetPacket::USBMon-E<gt>decode([RAW PACKET])>
172
 
 
173
 
Decode a USB packet.
174
 
 
175
 
=back
176
 
 
177
 
=head2 Instance data
178
 
 
179
 
The instance data for the C<NetPacket::UDP> object consists of
180
 
the following fields.
181
 
 
182
 
=over
183
 
 
184
 
=item id
185
 
 
186
 
An in-kernel address of the USB Request Block (URB). Stays the same for the
187
 
transaction submission and completion.
188
 
 
189
 
Might be truncatted when reading a 64-bit capture with 32-bit file.
190
 
 
191
 
=item type
192
 
 
193
 
URB type. Character 'S', 'C' or 'E', for constants USB_TYPE_SUBMISSION,
194
 
USB_TYPE_CALLBACK or USB_TYPE_ERROR.
195
 
 
196
 
=item xfer_type
197
 
 
198
 
Transfer type. USB_XFER_TYPE_ISO, USB_XFER_TYPE_INTR, USB_XFER_TYPE_CONTROL
199
 
or USB_XFER_TYPE_BULK.
200
 
 
201
 
=item ep
202
 
 
203
 
Endpoint identification.
204
 
 
205
 
=over 8
206
 
 
207
 
=item num
208
 
 
209
 
Endpoint number.
210
 
 
211
 
=item dir
212
 
 
213
 
Transfer direction. "IN" or "OUT".
214
 
 
215
 
=back
216
 
 
217
 
=item devnum
218
 
 
219
 
Device address.
220
 
 
221
 
=item busnum
222
 
 
223
 
Bus number.
224
 
 
225
 
=item flag_setup
226
 
 
227
 
Indicates whether setup is present and makes sense.
228
 
 
229
 
=item flag_data
230
 
 
231
 
Indicates whether data is present and makes sense.
232
 
 
233
 
=item ts_sec
234
 
 
235
 
Timestamp seconds since epoch. Subject to truncation with 32-bit Perl,
236
 
which should be fine until 2038.
237
 
 
238
 
=item ts_usec
239
 
 
240
 
Timestamp microseconds.
241
 
 
242
 
=item status
243
 
 
244
 
URB status. Negative errno.
245
 
 
246
 
=item length
247
 
 
248
 
Length of data (submitted or actual).
249
 
 
250
 
=item len_cap
251
 
 
252
 
Delivered length
253
 
 
254
 
=item setup
255
 
 
256
 
Only present for packets with setup_flag turned on.
257
 
Some contents are dependent on actual request type.
258
 
 
259
 
=over 8
260
 
 
261
 
=item bmRequestType
262
 
 
263
 
=item bRequest
264
 
 
265
 
=item wValue
266
 
 
267
 
=item wIndex
268
 
 
269
 
=item wLength
270
 
 
271
 
=back
272
 
 
273
 
=item iso
274
 
 
275
 
Only present for isochronous transfers.
276
 
 
277
 
=over 8
278
 
 
279
 
=item error_count
280
 
 
281
 
=item numdesc
282
 
 
283
 
=back
284
 
 
285
 
=item interval
286
 
 
287
 
Isochronous packet response rate.
288
 
 
289
 
=item start_frame
290
 
 
291
 
Only applicable to isochronous transfers.
292
 
 
293
 
=item xfer_flags
294
 
 
295
 
A copy of URB's transfer_flags.
296
 
 
297
 
=item ndesc
298
 
 
299
 
Actual number of isochronous descriptors.
300
 
 
301
 
=item data
302
 
 
303
 
Packet payload.
304
 
 
305
 
=back
306
 
 
307
 
=head2 Exports
308
 
 
309
 
=over
310
 
 
311
 
=item default
312
 
 
313
 
none
314
 
 
315
 
=item exportable
316
 
 
317
 
USB_TYPE_SUBMISSION, USB_TYPE_CALLBACK, USB_TYPE_ERROR, USB_XFER_TYPE_ISO,
318
 
USB_XFER_TYPE_INTR, USB_XFER_TYPE_CONTROL, USB_XFER_TYPE_BULK,
319
 
USB_FLAG_SETUP_IRRELEVANT, USB_FLAG_SETUP_RELEVANT, USB_FLAG_DATA_ERROR,
320
 
USB_FLAG_DATA_INCOMING, USB_FLAG_DATA_OUTGOING, USB_FLAG_DATA_PRESENT,
321
 
USB_TYPE_VENDOR
322
 
 
323
 
=item tags
324
 
 
325
 
The following tags group together related exportable items.
326
 
 
327
 
=over
328
 
 
329
 
=item C<:types>
330
 
 
331
 
USB_TYPE_SUBMISSION, USB_TYPE_CALLBACK, USB_TYPE_ERROR
332
 
 
333
 
=item C<:xfer_types>
334
 
 
335
 
USB_XFER_TYPE_ISO, USB_XFER_TYPE_INTR, USB_XFER_TYPE_CONTROL, USB_XFER_TYPE_BULK
336
 
 
337
 
=item C<:setup_flags>
338
 
 
339
 
USB_FLAG_SETUP_IRRELEVANT, USB_FLAG_SETUP_RELEVANT
340
 
 
341
 
=item C<:data_flags>
342
 
 
343
 
USB_FLAG_DATA_ERROR, USB_FLAG_DATA_INCOMING, USB_FLAG_DATA_OUTGOING,
344
 
USB_FLAG_DATA_PRESENT
345
 
 
346
 
=item C<:setup_types>
347
 
 
348
 
USB_TYPE_VENDOR
349
 
 
350
 
=item C<:ALL>
351
 
 
352
 
All the above exportable items.
353
 
 
354
 
=back
355
 
 
356
 
=back
357
 
 
358
 
=head1 COPYRIGHT
359
 
 
360
 
Copyright (c) 2013 Lubomir Rintel.
361
 
 
362
 
This module is free software. You can redistribute it and/or
363
 
modify it under the same terms as Perl itself.
364
 
 
365
 
=head1 AUTHOR
366
 
 
367
 
Lubomir Rintel E<lt>lkundrak@v3.skE<gt>
368
 
 
369
 
=cut