Reading Fixed-Length Records (Perl Cookbook, 2nd Edition)

## 8.15. Reading Fixed-Length Records

### 8.15.1. Problem

You want to read a file whose records have a fixed length.

### 8.15.2. Solution

Use `read` and `unpack`:

>     # $RECORDSIZE is the length of a record, in bytes.
>     # $TEMPLATE is the unpack template for the record
>     # FILE is the file to read from
>     # @FIELDS is an array, one element per field

>     until ( eof(FILE) ) {
>         read(FILE, $record, $RECORDSIZE) =  = $RECORDSIZE
>             or die "short read\n";
>         @FIELDS = unpack($TEMPLATE, $record);
>     }

### 8.15.3. Discussion

Because the file in question is not a text file, you can't use `<FH>` or IO::Handle's `getline` method to read records. Instead, you must simply `read` a particular number of bytes into a variable. This variable contains one record's data, which you decode using `unpack` with the appropriate format.

For binary data, the catch is determining that format. When reading data written by a C program, this can mean peeking at C include files or manpages describing the structure layout, and this requires knowledge of C. It also requires that you become unnaturally chummy with your C compiler, because otherwise it's hard to predict field padding and alignment (such as the `x2` in the format used in Recipe 8.24). If you're lucky enough to be on a Berkeley Unix system or a system supporting gcc, then you may be able to use the c2ph tool distributed with Perl to cajole your C compiler into helping you with this.

The tailwtmp program at the end of this chapter uses the format described in utmp(5) under Linux, and works on its /var/log/wtmp and /var/run/utmp files. Once you commit to working in binary format, machine dependencies creep in fast. It probably won't work unaltered on your system, but the procedure is still illustrative. Here is the relevant layout from the C include file on Linux:

>     #define UT_LINESIZE           12
>     #define UT_NAMESIZE           8
>     #define UT_HOSTSIZE           16

>     struct utmp {                       /* here are the pack template codes */
>         short ut_type;                  /* s for short, must be padded      */
>         pid_t ut_pid;                   /* i for integer                    */
>         char ut_line[UT_LINESIZE];      /* A12 for 12-char string           */
>         char ut_id[2];                  /* A2, but need x2 for alignment    */
>         time_t ut_time;                 /* l for long                       */
>         char ut_user[UT_NAMESIZE];      /* A8 for 8-char string             */
>         char ut_host[UT_HOSTSIZE];      /* A16 for 16-char string           */
>         long ut_addr;                   /* l for long                       */
>     };

Once you figure out the binary layout, feed that (in this case, "`s` `x2` `i` `A12` `A2` `x2` `l` `A8` `A16` `l`") to `pack` with an empty field list to determine the record's size. Remember to check the return value of `read` to make sure you got the number of bytes you asked for.

If your records are text strings, use the "`a`" or "`A`" unpack templates.

Fixed-length records are useful in that the nth record begins at byte offset `SIZE` `*` `(`n`-1)` in the file, where `SIZE` is the size of a single record. See the indexing code in Recipe 8.8 for an example.

### 8.15.4. See Also

The `unpack`, `pack`, and `read` functions in perlfunc(1) and in Chapter 29 of Programming Perl; Recipe 1.1

Copyright © 2003 O'Reilly & Associates. All rights reserved.