perlfilter - Online in de cloud

PROGRAMMA:

NAAM

perlfilter - Bronfilters

PRODUCTBESCHRIJVING

Dit artikel gaat over een weinig bekende functie van Perl genaamd (bron) filters. Bronfilters
verander de programmatekst van een module voordat Perl deze ziet, net zoals een C-preprocessor verandert
de brontekst van een C-programma voordat de compiler deze ziet. Dit artikel vertelt je meer
over wat bronfilters zijn, hoe ze werken en hoe u uw eigen filters kunt schrijven.

Het oorspronkelijke doel van bronfilters was om u de programmabron te laten coderen
toevallige piraterij te voorkomen. Dit is niet alles wat ze kunnen doen, zoals je snel zult leren. Maar eerst de
basics.

BEGRIPPEN

Voordat de Perl-interpreter een Perl-script kan uitvoeren, moet deze het eerst uit een bestand lezen
in het geheugen voor paring en compilatie. Als dat script zelf andere scripts bevat met
een "use" of "require" verklaring, dan zal elk van deze scripts uit hun
desbetreffende bestanden ook.

Beschouw nu elke logische verbinding tussen de Perl-parser en een afzonderlijk bestand als een
(bron) stream. Er wordt een bronstream gemaakt wanneer de Perl-parser een bestand opent en doorgaat
blijft bestaan ​​als de broncode in het geheugen wordt gelezen en wordt vernietigd als Perl klaar is
het parseren van het bestand. Als de parser een instructie "require" of "use" in een bron tegenkomt
stream, wordt er speciaal voor dat bestand een nieuwe en afzonderlijke stream gemaakt.

Het onderstaande diagram vertegenwoordigt een enkele bronstroom, met de bronstroom van een Perl
scriptbestand aan de linkerkant in de Perl-parser aan de rechterkant. Dit is hoe Perl normaal gesproken werkt
opereert.

bestand -------> parser

Er zijn twee belangrijke punten om te onthouden:

1. Hoewel er op elk moment een willekeurig aantal bronstromen kan bestaan,
er zal er maar één actief zijn.

2. Elke bronstream is aan slechts één bestand gekoppeld.

Een bronfilter is een speciaal soort Perl-module die een bron onderschept en wijzigt
streamen voordat het de parser bereikt. Een bronfilter verandert ons diagram als volgt:

bestand ----> filter ----> parser

Als dat niet zo logisch is, overweeg dan de analogie van een commandopijplijn. Zeg dat je dat hebt gedaan
een shellscript dat is opgeslagen in het gecomprimeerde bestand proef.gz. De eenvoudige pijplijnopdracht hieronder
voert het script uit zonder dat er een tijdelijk bestand hoeft te worden gemaakt om het niet-gecomprimeerde bestand op te slaan.

gunzip -c proef.gz | sch

In dit geval kan de gegevensstroom uit de pijplijn als volgt worden weergegeven:

trial.gz ----> gunzip ----> sh

Met bronfilters kunt u de tekst van uw script gecomprimeerd opslaan en een bron gebruiken
filter om het te decomprimeren voor de parser van Perl:

gecomprimeerde gunzip
Perl-programma ---> bronfilter ---> parser

GEBRUIK MAKEND VAN FILTERS

Dus hoe gebruik je een bronfilter in een Perl-script? Hierboven zei ik dat er een bronfilter is
gewoon een speciaal soort module. Zoals bij alle Perl-modules wordt een bronfilter aangeroepen met a
gebruik verklaring.

Stel dat u uw Perl-broncode vóór uitvoering via de C-preprocessor wilt doorgeven. Zoals
gebeurt, wordt de bronfilterdistributie geleverd met een C-preprocessorfiltermodule genaamd
Filter::cpp.

Hieronder staat een voorbeeldprogramma, "cpp_test", dat gebruik maakt van dit filter. Lijn nummers
zijn toegevoegd zodat er gemakkelijk naar specifieke regels kan worden verwezen.

1: gebruik Filter::cpp;
2: #define WAAR 1
3: $a = WAAR;
4: print "a = $a\n";

Wanneer u dit script uitvoert, maakt Perl een bronstream voor het bestand. Vóór de parser
verwerkt een van de regels uit het bestand, de bronstream ziet er als volgt uit:

cpp_test ---------> parser

Regel 1, "use Filter::cpp", bevat en installeert de filtermodule "cpp". Allemaal bron
filters werken op deze manier. De use-instructie wordt vóór het compileren gecompileerd en uitgevoerd
als er meer van het bestand wordt gelezen, wordt het cpp-filter aan de bronstream erachter gekoppeld
de scènes. De gegevensstroom ziet er nu als volgt uit:

cpp_test ----> cpp-filter ----> parser

Terwijl de parser de tweede en volgende regels uit de bronstroom leest, voert hij deze in
lijnen door het bronfilter "cpp" voordat ze worden verwerkt. Het "cpp"-filter eenvoudigweg
passeert elke lijn door de echte C-preprocessor. De uitvoer van de C-preprocessor is
vervolgens door het filter terug in de bronstroom geplaatst.

.-> cpp --.
| |
| |
| <-'
cpp_test ----> cpp-filter ----> parser

De parser ziet dan de volgende code:

gebruik Filter::cpp;
$ a = 1;
print "a = $a\n";

Laten we eens kijken wat er gebeurt als de gefilterde code een andere module bevat die in gebruik is:

1: gebruik Filter::cpp;
2: #define WAAR 1
3: gebruik Fred;
4: $a = WAAR;
5: print "a = $a\n";

Het "cpp"-filter is niet van toepassing op de tekst van de Fred-module, alleen op de tekst van de
bestand dat het gebruikte ("cpp_test"). Hoewel de use-instructie op regel 3 door de
cpp-filter, de module die wordt opgenomen ("Fred") zal dat niet doen. De bronstreams zien er zo uit
dit nadat regel 3 is geparseerd en voordat regel 4 is geparseerd:

cpp_test ---> cpp-filter ---> parser (INACTIEF)

Fred.pm ----> parser

Zoals je kunt zien, is er een nieuwe stream gemaakt voor het lezen van de bron van "Fred.pm". Dit
stream blijft actief totdat "Fred.pm" volledig is geparseerd. De bronstream voor
"cpp_test" zal nog steeds bestaan, maar is inactief. Zodra de parser klaar is met lezen
Fred.pm, de bijbehorende bronstream wordt vernietigd. De bronstream voor
"cpp_test" wordt dan weer actief en de parser leest regel 4 en daaropvolgende regels uit
"cpp_test".

U kunt meer dan één bronfilter voor één bestand gebruiken. Op dezelfde manier kunt u de
hetzelfde filter in zoveel bestanden als u wilt.

Als u bijvoorbeeld een uu-gecodeerd en gecomprimeerd bronbestand hebt, is het mogelijk om een
uudecode-filter en een decompressiefilter zoals deze:

gebruik Filter::uudecode; gebruik Filter::uitpakken;
M'XL(".H<US4''V9I;F%L')Q;>7/;1I;_>_I3=&E=%:F*I"T?22Q/
M6]9*
...

Zodra de eerste regel is verwerkt, ziet de stroom er als volgt uit:

bestand ---> uudecode ---> decomprimeren ---> parser
filterfilter

Gegevens stromen door filters in dezelfde volgorde waarin ze in het bronbestand verschijnen. De uudecode
filter verscheen vóór het decomprimeringsfilter, dus het bronbestand zal eerder uudecodeerd zijn
het is ongecomprimeerd.

SCHRIJVEN A BRON FILTER

Er zijn drie manieren om uw eigen bronfilter te schrijven. Je kunt het in C schrijven, gebruik een
extern programma als filter, of schrijf het filter in Perl. Ik zal de eerste twee niet behandelen
elk detail, dus ik zal ze eerst uit de weg ruimen. Het filter schrijven in Perl is dat wel
het handigst, dus ik zal er de meeste ruimte aan besteden.

SCHRIJVEN A BRON FILTER IN C

De eerste van de drie beschikbare technieken is om het filter volledig in C te schrijven
externe module maakt u rechtstreeks interfaces met de bronfilterhooks die door worden geleverd
Parel.

Het voordeel van deze techniek is dat u volledige controle heeft over de uitvoering
van uw filter. Het grote nadeel is de grotere complexiteit die nodig is om het
filter - je moet niet alleen de bronfilterhaken begrijpen, maar je hebt ook een
redelijke kennis van Perl-lef. Een van de weinige keren dat het de moeite waard is om deze moeite te doen
is bij het schrijven van een bronscrambler. Het "decoderen" filter (dat de broncode decodeert
voordat Perl het parseert) opgenomen in de bronfilterdistributie is een voorbeeld van een C
bronfilter (zie Decoderingsfilters hieronder).

decryptie filters
Alle decryptiefilters werken volgens het principe van ‘security through obscurity’.
Ongeacht hoe goed u een decoderingsfilter schrijft en hoe sterk uw codering is
Het algoritme is dat iedereen die vastberaden genoeg is, de originele broncode kan achterhalen. De
De reden hiervoor is vrij eenvoudig: zodra het decoderingsfilter de bron weer heeft gedecodeerd
in zijn oorspronkelijke vorm, zullen fragmenten ervan in het geheugen van de computer worden opgeslagen als Perl
parseert het. De bron is misschien maar een korte tijd in het geheugen aanwezig, maar voor iedereen
het bezit van een debugger, vaardigheid en veel geduld kan uiteindelijk uw
programma.

Dat gezegd hebbende, er zijn een aantal stappen die kunnen worden genomen om het leven moeilijk te maken
de potentiële kraker. Het belangrijkste: schrijf uw decoderingsfilter in C en
koppel de decoderingsmodule statisch aan het Perl-binaire bestand. Voor meer tips om te maken
het leven is moeilijk voor de potentiële kraker, zie het dossier decoderen.pm in de bron
distributie van filters.

CREREN A BRON FILTER AS A SCHEIDEN UITVOERBAAR

Een alternatief voor het schrijven van het filter in C is het maken van een afzonderlijk uitvoerbaar bestand in het
taal van uw keuze. Het afzonderlijke uitvoerbare bestand leest van standaardinvoer en doet wat dan ook
verwerking is noodzakelijk en schrijft de gefilterde gegevens naar standaarduitvoer. "Filter::cpp" is
een voorbeeld van een bronfilter geïmplementeerd als een afzonderlijk uitvoerbaar bestand - het uitvoerbare bestand is de
C-preprocessor gebundeld met uw C-compiler.

De bronfilterdistributie bevat twee modules die deze taak vereenvoudigen:
"Filter::exec" en "Filter::sh". Met beide kunt u elk extern uitvoerbaar bestand uitvoeren. Beiden gebruiken een
coprocess om de gegevensstroom naar en uit het externe uitvoerbare bestand te controleren. (Voor
details over coprocessen, zie Stephens, WR, "Advanced Programming in the UNIX
Milieu." Addison-Wesley, ISBN 0-210-56317-7, pagina's 441-445.) Het verschil tussen
Deze is dat "Filter::exec" de externe opdracht rechtstreeks voortbrengt, terwijl "Filter::sh"
spawnt een shell om het externe commando uit te voeren. (Unix gebruikt de Bourne-shell; NT gebruikt de
cmd shell.) Door een shell te spawnen kunt u gebruik maken van de shell-metatekens en
omleidingsfaciliteiten.

Hier is een voorbeeldscript dat "Filter::sh" gebruikt:

gebruik Filter::sh 'tr XYZ PQR';
$ a = 1;
print "XYZ a = $a\n";

De uitvoer die u krijgt wanneer het script wordt uitgevoerd:

PQR a = 1

Het schrijven van een bronfilter als afzonderlijk uitvoerbaar bestand werkt prima, maar levert kleine prestaties op
boete wordt opgelopen. Als u bijvoorbeeld het kleine voorbeeld hierboven uitvoert, wordt een separaat
Er wordt een subproces gemaakt om het Unix-commando "tr" uit te voeren. Elk gebruik van het filter vereist
een eigen subproces. Als het maken van subprocessen duur is op uw systeem, wilt u dit misschien wel
om een ​​van de andere opties voor het maken van bronfilters te overwegen.

SCHRIJVEN A BRON FILTER IN PERL

De eenvoudigste en meest draagbare optie die beschikbaar is voor het maken van uw eigen bronfilter is om
schrijf het volledig in Perl. Om dit te onderscheiden van de vorige twee technieken, zal ik dat doen
noem het een Perl-bronfilter.

Om te helpen begrijpen hoe u een Perl-bronfilter schrijft, hebben we een voorbeeld nodig om te bestuderen. Hier is
een compleet bronfilter dat rot13-decodering uitvoert. (Rot13 is een zeer eenvoudige codering
schema dat wordt gebruikt in Usenet-berichten om de inhoud van aanstootgevende berichten te verbergen. Het beweegt elke
letter dertien plaatsen vooruit, zodat A N wordt, B O en Z M.)

pakket Rot13;

gebruik Filter::Util::Bel;

sub-import {
mijn ($type) = @_;
mijn ($ref) = [];
filter_add(zegen $ref);
}

subfilter {
mijn ($zelf) = @_;
mijn ($status);

tr/n-za-mN-ZA-M/a-zA-Z/
als ($status = filter_read()) > 0;
$status;
}

1;

Alle Perl-bronfilters zijn geïmplementeerd als Perl-klassen en hebben dezelfde basisstructuur
zoals het voorbeeld hierboven.

Ten eerste voegen we de module "Filter::Util::Call" toe, die een aantal functies exporteert
in de naamruimte van uw filter. Het hierboven getoonde filter gebruikt twee van deze functies:
"filter_add()" en "filter_read()".

Vervolgens maken we het filterobject en koppelen dit aan de bronstream door het
"importeren" functie. Als u Perl goed genoeg kent, weet u dat "importeren" wordt genoemd
automatisch elke keer dat een module wordt opgenomen met een gebruiksinstructie. Dit maakt "importeren"
de ideale plek om zowel een filterobject te maken als te installeren.

In het voorbeeldfilter wordt het object ($ref) net als elk ander Perl-object gezegend. Ons
voorbeeld gebruikt een anonieme array, maar dit is geen vereiste. Omdat dit voorbeeld
hoeft geen contextinformatie op te slaan, we hadden een scalair of hash kunnen gebruiken
referentie net zo goed. In de volgende sectie worden contextgegevens gedemonstreerd.

De koppeling tussen het filterobject en de bronstream wordt gemaakt met de
"filter_add()"-functie. Hiervoor is een filterobject nodig als parameter ($ref in dit geval) en
installeert het in de bronstream.

Ten slotte is er de code die daadwerkelijk filtert. Voor dit type Perl-bron
filter, wordt al het filteren gedaan in een methode genaamd "filter()". (Het is ook mogelijk
schrijf een Perl-bronfilter met behulp van een afsluiting. Zie de handleiding "Filter::Util::Call" voor
meer details.) Het wordt elke keer aangeroepen als de Perl-parser een andere bronregel nodig heeft
proces. De "filter()"-methode leest op zijn beurt regels uit de bronstream met behulp van de
"filter_read()"-functie.

Als er een regel beschikbaar was uit de bronstream, retourneert "filter_read()" een statuswaarde
groter dan nul en voegt de regel toe aan $_. Een statuswaarde van nul duidt op het einde van de
bestand, minder dan nul betekent een fout. Er wordt verwacht dat de filterfunctie zelf zijn
status op dezelfde manier, en plaats de gefilterde regel die u wilt schrijven naar de bronstream
$_. Het gebruik van $_ verklaart de beknoptheid van de meeste Perl-bronfilters.

Om gebruik te kunnen maken van het rot13-filter hebben we een manier nodig om het bronbestand te coderen
rot13-formaat. Het onderstaande script, "mkrot13", doet precies dat.

die "gebruik mkrot13 bestandsnaam\n" tenzij @ARGV;
mijn $in = $ARGV[0];
mijn $out = "$in.tmp";
open(IN, "<$in") of die "Kan bestand $in: $!\n niet openen";
open(OUT, ">$out") of die "Kan bestand $out niet openen: $!\n";

print UIT "gebruik Rot13;\n";
terwijl ( ) {
tr/a-zA-Z/n-za-mN-ZA-M/;
afdrukken;
}

sluit IN;
sluit UIT;
$in ontkoppelen;
hernoem $uit, $in;

Als we dit versleutelen met "mkrot13":

print "hallo fred \n";

het resultaat zal dit zijn:

gebruik Rot13;
cevag "uryyb serq\a";

Als u het uitvoert, wordt deze uitvoer geproduceerd:

hallo fred

GEBRUIK MAKEND VAN CONTEXT: HET DEBUG FILTER

Het rot13-voorbeeld was een triviaal voorbeeld. Hier is nog een demonstratie waar er een paar te zien zijn
meer eigenschappen.

Stel dat u tijdens de ontwikkeling veel foutopsporingscode in uw Perl-script wilde opnemen,
maar je wilde niet dat het beschikbaar was in het vrijgegeven product. Bronfilters bieden uitkomst.
Om het voorbeeld eenvoudig te houden, stellen we dat u de foutopsporingsuitvoer zo wilt hebben
bestuurd door een omgevingsvariabele, "DEBUG". Foutopsporingscode is ingeschakeld als de variabele
bestaat, anders is het uitgeschakeld.

Twee speciale markeringslijnen plaatsen de foutopsporingscode, zoals deze:

## DEBUG_BEGIN
if ($jaar > 1999) {
waarschuw "Debug: millenniumbug in jaar $year\n";
}
## DEBUG_END

Het filter zorgt ervoor dat Perl de code tussen de en 'DEBUG_END'
markeringen alleen wanneer de omgevingsvariabele "DEBUG" bestaat. Dat betekent dat wanneer "DEBUG"
bestaat, moet de bovenstaande code onveranderd door het filter worden doorgegeven. De markeringslijnen
kunnen ook worden doorgegeven zoals ze zijn, omdat de Perl-parser ze als commentaarregels zal zien.
Als "DEBUG" niet is ingesteld, hebben we een manier nodig om de foutopsporingscode uit te schakelen. Een eenvoudige manier om dit te bereiken
dat wil zeggen om de regels tussen de twee markeringen om te zetten in commentaar:

## DEBUG_BEGIN
#if ($jaar > 1999) {
# warn "Debug: millenniumbug in jaar $jaar\n";
#}
## DEBUG_END

Hier is het volledige Debug-filter:

pakket Debuggen;

gebruik strikt;
gebruik waarschuwingen;
gebruik Filter::Util::Bel;

gebruik constante TRUE => 1;
gebruik constante FALSE => 0;

sub-import {
mijn ($type) = @_;
mijn (%context) = (
Ingeschakeld => $ENV{DEBUG} gedefinieerd,
InTraceBlock => ONWAAR,
Bestandsnaam => (beller)[1],
Lijnnr => 0,
LaatsteBegin => 0,
);
filter_add(zegen \%context);
}

sub Die {
mijn ($zelf) = dienst;
mijn ($bericht) = dienst;
mijn ($line_no) = shift || $self->{LastBegin};
die "$message op $self->{Bestandsnaam} regel $line_no.\n"
}

subfilter {
mijn ($zelf) = @_;
mijn ($status);
$status = filter_lezen();
++ $self->{Lijnnr};

# behandel eerst de EOF/fout
als ($status <= 0) {
$self->Die("DEBUG_BEGIN heeft geen DEBUG_END")
als $self->{InTraceBlock};
retourneer $status;
}

if ($self->{InTraceBlock}) {
als (/^\s*##\s*DEBUG_BEGIN/ ) {
$self->Die("Geneste DEBUG_BEGIN", $self->{LineNo})
} elsif (/^\s*##\s*DEBUG_END/) {
$self->{InTraceBlock} = ONWAAR;
}

# commentaar op de foutopsporingsregels wanneer het filter is uitgeschakeld
s/^/#/ als ! $self->{Ingeschakeld};
} elsif ( /^\s*##\s*DEBUG_BEGIN/ ) {
$self->{InTraceBlock} = WAAR;
$self->{LastBegin} = $self->{LineNo};
} elsif ( /^\s*##\s*DEBUG_END/ ) {
$self->Die("DEBUG_END heeft geen DEBUG_BEGIN", $self->{LineNo});
}
retourneer $status;
}

1;

Het grote verschil tussen dit filter en het vorige voorbeeld is het gebruik van contextgegevens
in het filterobject. Het filterobject is gebaseerd op een hash-referentie en wordt gebruikt om te behouden
verschillende stukjes contextinformatie tussen aanroepen van de filterfunctie. Op twee na allemaal
de hashvelden worden gebruikt voor foutrapportage. De eerste van deze twee, Ingeschakeld, wordt gebruikt door
het filter om te bepalen of de foutopsporingscode aan de Perl-parser moet worden doorgegeven. De
ten tweede is InTraceBlock waar als het filter een regel "DEBUG_BEGIN" is tegengekomen, maar
is de volgende regel "DEBUG_END" nog niet tegengekomen.

Als je alle foutcontroles negeert die het grootste deel van de code doet, is de essentie van het filter
is als volgt:

subfilter {
mijn ($zelf) = @_;
mijn ($status);
$status = filter_lezen();

# behandel eerst de EOF/fout
retourneer $status als $status <= 0;
if ($self->{InTraceBlock}) {
als (/^\s*##\s*DEBUG_END/) {
$self->{InTraceBlock} = ONWAAR
}

# commentaar op foutopsporingsregels wanneer het filter is uitgeschakeld
s/^/#/ als ! $self->{Ingeschakeld};
} elsif ( /^\s*##\s*DEBUG_BEGIN/ ) {
$self->{InTraceBlock} = WAAR;
}
retourneer $status;
}

Wees gewaarschuwd: net zoals de C-preprocessor C niet kent, kent het Debug-filter Perl niet.
Je kunt het heel gemakkelijk voor de gek houden:

afdrukken <
##DEBUG_BEGIN
EOM

Afgezien van dit soort dingen kun je zien dat er met een bescheiden hoeveelheid code veel kan worden bereikt.

CONCLUSIE

U begrijpt nu beter wat een bronfilter is, en misschien heeft u zelfs een
mogelijk gebruik voor hen. Als je zin hebt om met bronfilters te spelen, maar er een beetje van nodig hebt
inspiratie, hier zijn enkele extra functies die u aan het Debug-filter kunt toevoegen.

Eerst een makkelijke. In plaats van foutopsporingscode te hebben die alles of niets is, zou dat zo zijn
veel nuttiger om te kunnen bepalen welke specifieke blokken foutopsporingscode worden ontvangen
inbegrepen. Probeer de syntaxis voor debug-blokken uit te breiden, zodat ze allemaal kunnen worden geïdentificeerd. De
De inhoud van de omgevingsvariabele "DEBUG" kan vervolgens worden gebruikt om te bepalen welke blokken worden opgehaald
inbegrepen.

Zodra je individuele blokken kunt identificeren, kun je proberen ze te laten nesten. Dat is niet zo
ook moeilijk.

Hier is een interessant idee waarbij het Debug-filter niet betrokken is. Momenteel Perl
subroutines hebben vrij beperkte ondersteuning voor formele parameterlijsten. U kunt de
aantal parameters en hun type, maar u moet ze nog steeds handmatig uit het
@_ stel jezelf op. Schrijf een bronfilter waarmee u een benoemde parameterlijst kunt hebben.
Zo'n filter zou dit veranderen:

sub MijnSub ($eerste, $tweede, @rest) { ... }

in dit:

sub MijnSub($$@) {
mijn ($eerste) = dienst;
mijn ($seconde) = dienst;
mijn (@rest) = @_;
...
}

Tenslotte, als je zin hebt in een echte uitdaging, probeer dan eens een volwaardige Perl-macro te schrijven
preprocessor als bronfilter. Leen de handige functies van de C-preprocessor en
alle andere macroprocessors die u kent. Het lastige is om te kiezen hoeveel kennis je hebt
Perl's syntaxis die u wilt dat uw filter heeft.

Beperkingen

Bronfilters werken alleen op tekenreeksniveau en zijn dus zeer beperkt in hun mogelijkheden
wijzig de broncode direct. Het kan geen commentaar, geciteerde strings, heredocs detecteren, dat is het wel
geen vervanging voor een echte parser. Het enige stabiele gebruik voor bronfilters is
encryptie, compressie of de byteloader, om binaire code terug te vertalen naar de broncode.

Zie bijvoorbeeld de beperkingen in Switch, dat bronfilters gebruikt, en dat dus niet doet
werk binnen een string eval, de aanwezigheid van regexes met ingebedde nieuwe regels die dat wel zijn
gespecificeerd met onbewerkte /.../ scheidingstekens en hebben geen modificator //x zijn niet te onderscheiden
uit codefragmenten die beginnen met de divisieoperator /. Als tijdelijke oplossing moet u gebruiken
m/.../ of m?...? voor zulke patronen. Ook de aanwezigheid van regexes gespecificeerd met raw ?...?
scheidingstekens kunnen mysterieuze fouten veroorzaken. De oplossing is om m?...? in plaats van. Zien
http://search.cpan.org/perldoc?Schakelaar#BEPERKINGEN

Momenteel zijn de interne bufferlengtes beperkt tot slechts 32 bits.

DINGEN TO KIJK OUT VOOR

Sommige filters slaan de "GEGEVENS"-hendel in de war
Sommige bronfilters gebruiken de "DATA"-ingang om het aanroepende programma te lezen. Tijdens gebruik
Bij deze bronfilters kunt u niet op dit handvat vertrouwen, noch een bepaald soort verwachten
van gedrag als je ermee aan de slag gaat. Filters gebaseerd op Filter::Util::Call (en dus
Filter::Simple) wijzigen de bestandshandle "DATA" niet.

VEREISTEN

De Source Filters-distributie is beschikbaar op CPAN, in

CPAN/modules/per-module/Filter

Vanaf Perl 5.8 Filter::Util::Call (het kerngedeelte van de bronfilters
distributie) maakt deel uit van de standaard Perl-distributie. Ook inbegrepen is een vriendelijker
interface genaamd Filter::Simple, door Damian Conway.

Gebruik perlfilter online met behulp van onworks.net-services