#!/usr/bin/perl -w
use strict;
#deletes first numbytes of a file

#### DO NOT USE #####

#use constant BLOCKSIZE => 128*1024;
#
#die "Usage: $0 numbytes file [file ...]\n" unless @ARGV > 2;
#
#my $trunc_bytes = shift @ARGV;
#my $files_done = 0;
#
#for(@ARGV) {
#    open(my $fh, "+<", $_) or (warn "Couldn't open $_: $!\n", next);
#    if(-s $fh > $trunc_bytes ) {
#        seek $fh, 0, $trunc_bytes;
#        while(my $bytes_read = read $fh, my $buffer, BLOCKSIZE) {
#            seek $fh, 1, -$bytes_read -$trunc_bytes;
#            print $fh $buffer;
#            seek $fh, 1, $trunc_bytes;
#        }
#    }
#    truncate $fh, tell $fh;
#    close $fh;
#    $files_done++;
#}
#
#exit $files_done == 0;

#### DO NOT USE #####
[download]

Makeshifts last the longest.

Untested, but no glaring mistakes obvious to me. If you see any, yell at me.

You need @ARGV > 1 because > 2 will fail for the minimum of two args.

Your WHENCE arguments to your seeks are all second instead of third where they belong.

As long as that inner while loop is entered, that last truncate() will always occur immediately after your read fails. Which means you will be at the end of the file and, since you truncate from tell() to the end, you won't truncate anything.

Update: Here is mine. It's based on yours but I've fixed the errors and simplified it a bit (as far as functionality goes.) I also introduce the $total_in variable to make the math a little clearer. Addendum: Aristotle found a bug in this code which surfaces when the last read is exactly BLOCKSIZE bytes long. See his reply and my reply to his reply for two different fixes.

#!/usr/bin/perl -w
use strict;

use constant BLOCKSIZE => 128 * 1024;

die "Usage: $0 numbytes file" unless @ARGV > 1;
my $remove_bytes = shift @ARGV;
my $file         = shift @ARGV;

open(my $fh, "+<", $file) or die "Couldn't open $file: $!\n";

if(-s $fh > $remove_bytes ) {
    seek $fh, $remove_bytes, 0;
    my $total_in = 0;
    while(my $bytes_in = read $fh, my $buf, BLOCKSIZE) {
        seek $fh, $total_in, 0;
        print $fh $buf;
        last if $bytes_in < BLOCKSIZE;
        $total_in += $bytes_in;
        seek $fh, $remove_bytes + $total_in, 0;
    }
}
truncate $fh, tell $fh;
[download]

-sauoq
"My two cents aren't worth a dime.";

Yikes! In fact there are more bugs and more severe bugs in mine than you point out.

That the die was of course meant to have an if and not an unless clause, is only a minor problem. The seeks are cosmetics too - shame on me.

But the "late truncate" was a nasty thinko indeed. Unfortunately your fix of testing the read length against the block size won't work correctly either, since it fails when the last read gets exactly BLOCKSIZE bytes directly before the end of the file.

The cool thing about the real fix is I got rid of the if that was bothering me before. I had a gut feeling that a correct solution should not require extra tests for small files that get truncated to zero and indeed, it doesn't.

#!/usr/bin/perl -w
use strict;
#deletes first numbytes of a file

use constant BLOCKSIZE => 128*1024;

die "Usage: $0 numbytes file [file ...]\n" if @ARGV < 2;

my $trunc_bytes = shift @ARGV;
my $files_done = 0;

for(@ARGV) {
    my $fh;
    unless(open $fh, "+<", $_) {
        warn "Couldn't open $_: $!\n";
        next;
    }
    my $filesize = -s $fh;
    while($filesize > $trunc_bytes + tell $fh) {
        seek $fh, $trunc_bytes, 1;
        my $bytes_read = read($fh, my $buffer, BLOCKSIZE);
        seek $fh, -$bytes_read -$trunc_bytes, 1;
        print $fh $buffer;
    }
    truncate $fh, tell $fh;
    close $fh;
    $files_done++;
}

exit ($files_done == 0);
[download]

I left my old code in place for comparisons.

Update: added a couple brackets and changed open(..) or .. into unless(open ..) {..}.

Update 2: pulled my $fh out of the open.

Makeshifts last the longest.