Free header software for linux

Header Spy is an extension which shows HTTP headers on statusbar.
Main features:
- Up to 5 statusbar panels;
- Request and response headers;
- Custom headers;
- Tooltip headers;
- Menu with headers for statusbar panels;

Ogg::Vorbis::Header is an object-oriented interface to Ogg Vorbis information and comment fields.

SYNOPSIS

use Ogg::Vorbis::Header;
my $ogg = Ogg::Vorbis::Header->new("song.ogg");
while (my ($k, $v) = each %{$ogg->info}) {
print "$k: $vn";
}
foreach my $com ($ogg->comment_tags) {
print "$com: $_n" foreach $ogg->comment($com);
}
$ogg->add_comments("good", "no", "ok", "yes");
$ogg->delete_comment("ok");
$ogg->write_vorbis;

This module presents an object-oriented interface to Ogg Vorbis files which allows user to view Vorbis info and comments and to modify or add comments.

CONSTRUCTORS

new ($filename)

Partially opens an Ogg Vorbis file to ensure it exists and is actually a Vorbis stream. It then closes the filehandle. It does not fill in the objects data fields. These fields will be automatically filled the first time they are accessed using the objects instance methods. Returns undef if there is a problem opening the file or the file is not valid Ogg Vorbis.

load ([$filename])

Opens an Ogg Vorbis file, reads its information, and then closes the filehandle. Returns undef if there is a problem opening the file or the file is not valid Ogg Vorbis. This is both a constructor and an instance method. The filename is required in constructor context, but should be left out when you call this as an instance method on an object. When called as an instance method, it (re)loads the info and comment data from the file. This can be used to reset the state of the object if write_vorbis hasnt been called. Note that the path parameter is ignored in instance context.

INSTANCE METHODS

These methods may be called on actual Header objects, using the -> operator or indirect objects as you prefer.

info ([$key])

Returns a reference to a hash containing format information about the Vorbis file. Hash fields are: version, channels, rate, bitrate_upper, bitrate_nominal, bitrate_lower, and bitrate_window, length. The bitrate_window value is currently unused by the vorbis codec. You can modify the referenced hash if you want, but I wouldnt suggest it.

The optional key parameter allows you to extract a single value from the internal hash (passed by value, not reference). If the key is invalid, undef is returned.

comment_tags ()

Returns an array holding the key values of each comment field. You can then use these values to access specific fields using comment. This may seem somewhat clunky at first but it will speed up most programs. In addition, it makes it easier to support the Ogg Vorbis comment standard which allows multiple fields with the same key.

comment ($key)

Returns a list of comments given a key. If the key does not exist, returns undef.

add_comments ($key, $value, [$key, $value, ...])

Adds comments with the given keys and values. Takes an array of alternating keys and values as parameters. Keys and values should be valid ascii in the range 0x20 - 0x7D and the key should exclude 0x3D (=). This is a subset of the Vorbis standard which allows this range for the key field and all of utf8 for the value field. This will be fixed in future a release.

If an odd-length array is passed in the routine will fail and return undef. Key and value will be trimmed of characters which do not match the format requirement.

edit_comment ($key, $value, [$num])

Edits a given comment field. The optional num field is used to differentiate between two comments with the same key. If no num is supplied, the first value--as reported by comment--is modified. If the key or num are invalid, nothing is done and undef is returned. If all goes well, the old value is returned.

delete_comment ($key, [$num])

Deletes the comment given by key. The optional num value can be used to specify which comment to delete, given duplicate keys. Leaving num out will result in only the first instance being deleted. Returns undef if key or num are invalid. If all goes well, the value of the deleted comment is returned.

clear_comments ([@keys])

Deletes all of the comments which match keys in the input array or all of the comments in the stream if called with no arguments. Returns undef if any key is invalid, although all keys in the input array up until that key will be cleared. Returns true otherwise.

write_vorbis ()

Write object to its backing file. No comment modifications will be seen in the file until this operation is performed.

path ()

Returns the path/filename of the file the object represents.

XML::Mini::Element::Header Perl module is used internally to represent < ? xml blah="hohoho" ? > type headers.

You shouldnt need to use it directly, see XML::Mini::Elements header() method.

Requirements:

• Thunderbird 1.0 1.5.0.* ALL
• Mozilla 1.7.7 1.7.7 ALL

SIMD Cross-platform headers is a cross- platform, cross-compiler, cross CPU C/C++ header collection that aids the creation portable vectorized (SIMD) C/C++ code.
SIMD Cross-platform headerst supports (or partially supports) x86 (MMX/SSE/SSE2) GCC and MSVC, PPC Altivec GCC and CodeWarrior, ARM GCC, and software-emulated SIMD.
NOTE: Code must be 16-byte aligned. Align to 16 when allocating memory.
X86/XSCALE (Intel) vs. PowerPC/MIPS
While the PowerPC and MIPS SIMD instructions take 2 source vectors and a destination vector, the Intel platforms only take a source and destination. Example:
PPC/MIPS can do:
C = A + B
X86 can only do:
A = A + B (or A+=B)
Code written either way will work on the X86, and still be faster than 387 math, but preserving the registers takes significant overhead (Disassemble the test program for an example. The prints preserve, the disassembly test does not.) For the fastest code between systems, write your SIMD math as the X86 expects, manually preserving SIMD variables.
At least GCC for PPC doesnt seem to have any issues figuring out how to deal with a source and destination memory address being the same.
Enhancements:
- Created file with some i386, GCC dialect

Apache2::Filter::HTTPHeadersFixup is a Perl module to manipulate Apache 2 HTTP Headers.

Synopsis

# MyApache/FixupInputHTTPHeaders.pm
package MyApache::FixupInputHTTPHeaders;

use strict;
use warnings FATAL => all;

use base qw(Apache2::Filter::HTTPHeadersFixup);

sub manip {
my ($class, $ra_headers) = @_;

# modify a header
for (@$ra_headers) {
s/^(Foo).*/$1: Moahaha/;
}

# push header (dont forget "n"!)
push @$ra_headers, "Bar: MidBarn";
}
1;

# httpd.conf
< VirtualHost Zoot >
PerlModule MyApache::FixupInputHTTPHeaders
PerlInputFilterHandler MyApache::FixupInputHTTPHeaders
< /VirtualHost >

# similar for output headers

Apache2::Filter::HTTPHeadersFixup is a super class which provides an easy way to manipulate HTTP headers without invoking any mod_perl HTTP handlers. This is accomplished by using input and/or output connection filters.

It supports KeepAlive connections.

This class cannot be used as is. It has to be sub-classed. Read on.

MIME::Head is a MIME message header (a subclass of Mail::Header).

SYNOPSIS

Before reading further, you should see MIME::Tools to make sure that you understand where this module fits into the grand scheme of things. Go on, do it now. Ill wait.

Ready? Ok...

Construction

### Create a new, empty header, and populate it manually:
$head = MIME::Head->new;
$head->replace(content-type, text/plain; charset=US-ASCII);
$head->replace(content-length, $len);

### Parse a new header from a filehandle:
$head = MIME::Head->read(*STDIN);

### Parse a new header from a file, or a readable pipe:
$testhead = MIME::Head->from_file("/tmp/test.hdr");
$a_b_head = MIME::Head->from_file("cat a.hdr b.hdr |");

Output

### Output to filehandle:
$head->print(*STDOUT);

### Output as string:
print STDOUT $head->as_string;
print STDOUT $head->stringify;

Getting field contents

### Is this a reply?
$is_reply = 1 if ($head->get(Subject) =~ /^Re: /);

### Get receipt information:
print "Last received from: ", $head->get(Received, 0), "n";
@all_received = $head->get(Received);

### Print the subject, or the empty string if none:
print "Subject: ", $head->get(Subject,0), "n";

### Too many hops? Count em and see!
if ($head->count(Received) > 5) { ...

### Test whether a given field exists
warn "missing subject!" if (! $head->count(subject));
Setting field contents
### Declare this to be an HTML header:
$head->replace(Content-type, text/html);
Manipulating field contents
### Get rid of internal newlines in fields:
$head->unfold;

### Decode any Q- or B-encoded-text in fields (DEPRECATED):
$head->decode;

Getting high-level MIME information

### Get/set a given MIME attribute:
unless ($charset = $head->mime_attr(content-type.charset)) {
$head->mime_attr("content-type.charset" => "US-ASCII");
}

### The content type (e.g., "text/html"):
$mime_type = $head->mime_type;

### The content transfer encoding (e.g., "quoted-printable"):
$mime_encoding = $head->mime_encoding;

### The recommended name when extracted:
$file_name = $head->recommended_filename;

### The boundary text, for multipart messages:
$boundary = $head->multipart_boundary;

Yasper (Yet Another Smart Pointer) is a sweet and simple single-header smart pointer for C++.

Why write another C++ smart pointer?

There are two high quality libraries that include smart pointers: Loki and Boost. Alexandrescus Loki SmartPtr is customizable to a fault. I find policy templates unspeakably ugly and dont need the extra options. Boosts shared_ptr is quite nice, but is too restrictive and introduces undesirable dependency on the massive Boost library. What I need is a small, simple smart pointer: yasper.

Philosophy

small (contained in single header)
simple (nothing fancy in the code, easy to understand)
maximum compatibility (drop in replacement for dumb pointers)

The last point can be dangerous, since yasper permits risky (yet useful) actions (such as assignment to raw pointers and manual release) disallowed by other implementations. Be careful, only use those features if you know what youre doing!