Free jorbis 0.0.16 software for linux

GxSNMP is designed as a powerful network management package. GxSNMP project can incorporate the best features of existing commercial packages.
Our plan is to create a network managenemt suite for GNOME under the GNU public license (GPL).
The suite will be devided into a server part and a GUI part. The server part is responsible for discovering the network into a database and keeping the database up to date. It also listens for traps or notifications of the network devices and checks if the devices are alive.
The GUI part is responsible for drawing maps, MIB browsing, SNMP applications, traffic graphing. It will use the information gathered by the server part by connecting to the database. Most of the GUI part will me implemented as bonobo objects.
Main features:
- SNMP Data collector
- MIB Browser
- SNMP Table object
- SNMP Form object
- SNMP Graphics object (loading pixmaps according to SNMP variable values)
- Automatic Network discovery
- Bonobo Object support
- Distributed network management
- Network status monitor
- Script language
- Performance and health reporting
- SNMPv1/2c/3 compliance

libmiASMaELF is a library for generating relocatable object files that conform to the ELF format.

libmiASMaELF library has no complex class hierarchy, hence it is extremly easy to use, unlike most other libraries that accomplish the same task. Documentation and examples are provided to demonstrate the use of the library.

< b >How does one use the library?< /b >

/* hello.c */
#include < iostream >
#include < vector >
#include "libmiasmaelf.h"

int main(void )
{
char text[] = {
xB8, x04, x00, x00, x00, // mov eax, 4
xBB, x01, x00, x00, x00, // mov ebx, 1
xB9, x00, x00, x00, x00, // mov ecx, myvariable
xBA, x0E, x00, x00, x00, // mov edx, 14
xCD, x80, // int 0x80
xB8, x01, x00, x00, x00, // mov eax, 1
xCD, x80 // int 0x80
};

char data[] = {
x48, x65, x6C, x6C, x6F,
x2C, x20, x57, x6F, x72,
x6C, x64, x21, x0A
}; //Hello,World!

vector< char > vtext(&text[0], &text[29]);
vector< char > vdata(&data[0], &data[14]);
miasmaELF obj;

obj.InitializeELFHeader();
obj.InitializeSymbolTable();

obj.AddNewSection(".shstrtab",SHT_STRTAB, 0,0,0,0,0,0);
obj.AddNewSection(".text", SHT_PROGBITS,6,0,0,0,16,0);
obj.AddNewSection(".data", SHT_PROGBITS,3,0,0,0,16,0);
obj.AddNewSection(".symtab", SHT_SYMTAB, 0,0,
obj.GetSectionIndexOfType(SHT_STRTAB, ".strtab"),
0,
4,sizeof(Elf32_Sym));

obj.AddNewSection(".rel.text",SHT_REL,0,0,
obj.GetSectionIndexOfType(SHT_SYMTAB),
obj.GetSectionIndexOfType(SHT_PROGBITS, ".text"),
4,sizeof(Elf32_Rel));

obj.AddContents(vtext, obj.GetSectionIndexOfType(SHT_PROGBITS,".text"));
obj.AddContents(vdata, obj.GetSectionIndexOfType(SHT_PROGBITS,".data"));

obj.AddSymbol("_start",0,0, STB_WEAK, STT_FUNC,
obj.GetSectionIndexOfType(SHT_PROGBITS, ".text"));
obj.AddSymbol("myvariable",0,0, STB_GLOBAL, STT_OBJECT,
obj.GetSectionIndexOfType(SHT_PROGBITS, ".data"));

obj.AddRelocationEntry(11, obj.ReturnSymbolIndex("myvariable"),
R_386_RELATIVE,
obj.GetSectionIndexOfType(SHT_REL, ".rel.text"));

obj.PrepareFile();
obj.WriteFile("hello.o");
}

The library makes extensive use of vectors - a data structure that is a part of the Standard Template Library. We first create the machine language equivalents of every instruction and populate the vectors accordingly.

We then initialize the ELFHeader, the SymbolTable Initialization follows next. This is done after defining an object of type miasmaELF.

We then go on to initialize individual sections. The function

obj.GetSectionIndexOfType(SHT_PROGBITS, ".text")

is used when one wants to obtain the SectionIndex of a given section. We find this function helps greatly in linking the various structures that are described in elf.h. Here, it is used in building the section header of a particular section. It is imperative that the user of the library must have a general idea of the various structures that are involved.

We then invoke

obj.AddContents(vtext, obj.GetSectionIndexOfType(SHT_PROGBITS,".text"));

which add the contents to the text section. The 2nd argument to AddContents is the section that we are referring to. In this case it is the .text section, and from our example the Index=3.

We employ a similar technique to add Symbols and Relocation Entries. To finally write the file one must first must prepare it by invoking the function PrepareFile(...), and only then invoke WriteFile(FileName)

To compile hello.c one must link it with libmiasmaelf.o

Cortado Streaming applet is a Java applet which supports decoding of Ogg Vorbis, Ogg Theora, MJPEG and Smoke codecs directly in a browser window. Both audio and video are supported.
It contains:
- JST, a port of the GStreamer 0.10 design to Java
- jcraft, a copy of the JCraft JOgg/Jorbis code
- jheora, an implementation of Theora in Java
- codecs (currently only containing the Smoke codec, a variant on Jpeg)
- JST plugins for:
- HTTP source element
- Ogg and Multipart demuxers
- Theora, JPEG and Smoke video decoders
- Vorbis and MuLaw audio decoders
- Java 1.1 sun.audio API audio sink
- Java 1.4 javax.sound.sampled API audio sink
- examples
- applets
This release has support for:
- seeking in on-demand files
- the above-mentioned plugins
- basic HTTP authentication
- buffering

ipset pakcage is a framework inside the Linux 2.4.x and 2.6.x kernel, which can be administered by the ipset utility.
Depending on the type, currently an IP set may store IP addresses, (TCP/UDP) port numbers or IP addresses with MAC addresses in a way, which ensures lightning speed when matching an entry against a set.
If you want to:
store multiple IP addresses or port numbers and match against the collection by iptables at one swoop
dynamically update iptables rules against IP addresses or ports without performance penalty
express complex IP address and ports based rulesets with one single iptables rule and benefit from the speed of IP sets
then ipset may be the proper tool for you.
Main features:
ipmap
- The ipmap set type uses a memory range, where each bit represents one IP address and can store up to 65535 (B-class network) entries. You can store same size network addresses in an ipset as well and an IP address will be in the set if the network address it belongs to can be found in the set.
macipmap
- The macipmap set type uses a memory range, where each 8 bytes represents one IP and a MAC addresses. A macipmap set type can store up to 65535 (B-class network) IP addresses with MAC.
portmap
- The portmap set type uses a memory range, where each bit represents one port. A portmap type of set can store up to 65535 ports.
iphash
- The iphash set type uses a hash to store IP addresses where clashing is resolved by double-hashing and, as a last resort, by dynamically growing the hash. Same size network addresses can be stored in an iphash as well.
nethash
- The nethash set type also uses a hash to store CIDR netblocks, which may be of different sizes. The same techique is used to avoid clashes as at the iphash set type.
iptree
- The iptree set type uses a tree to store IP addresses, optionally with timeout values.
Bindings
IP sets allows you to bind an entry in a set to another set, which forms a relationship between the set element and the set it is bound to. The sets may have a default binding, which is valid for every set element for which there is no binding defined at all.
The bindings have no special meaning at the set level. However, you can benefit from them when using the set match of iptables. The set match will follow the bindings and will return a true (matched) value only if the packet parameters match all bindings it found.
Lets see an example:
# ipmap set storing the IP addresses of two machines
ipset -N servers ipmap --network 192.168.0.0/16
ipset -A servers 192.168.0.1
ipset -A servers 192.168.0.2
# portmap set storing the allowed ports for 192.168.0.2
ipset -N ports portmap --from 1 --to 1024
ipset -A ports 21
ipset -A ports 22
ipset -A ports 25
# Binding, which attaches ports to 192.168.0.2
ipset -B servers 192.168.0.2 -b ports
# iptables rule using the set match
...
iptables -A FORWARD -m set --set servers dst,dst -j ACCEPT
iptables -A FORWARD -j DROP
Now according to the iptables rules, sets and binding, the firewall will allow trough packets destined to any port on 192.168.0.1, while for 192.168.0.2 only the ports 21, 22 and 25 will be reachable.

ICMPScan scans the specified address, or addresses, for ICMP responses.

Usage:

icmpscan [ -EPTSNMAIRcvbn ] [ -A address ] [ -f filename ] [ -i interface ] [ -r retries ] [ -t timeout ] target [...]

Options:

-i, --interface
Listen on the specified interface. If unspecified, icmpscan will examine the routing table and select the most appropriate interface for each target address.
-c, --promisc
Put in interface into promiscuous mode. As this option increases the load on the system in general, it should only be used if spoofing of source packets address is enabled with the "-A" option.
-A, --address
Specify the source IP address of generated packets.
-t, --timeout
Specify the timeout, in milli-seconds, before retrying.
-r, --retries
Specify the number of attempts to elicit a particular ICMP response.
-f, --file
Read target list from the specified file.
-E, -P, --echo, --ping
Check of ICMP Echo responses.
-T, -S, --timestamp
Check for ICMP Timestamp responses.
-N, -M, --netmask
Check for ICMP Netmask responses.
-I, --info
Check for ICMP Info responses.
-R, --router
Check for ICMP Router Solicitation responses.
-v, --verbose
Increase the output verbosity.
-B, --debug

Target Specification

The simplest case is listing single hostnames or IP addresses on the command line. If you want to scan a subnet of IP addresses, you can append /mask to the hostname or IP address. mask must be between 0 (scan the whole Internet) and 32 (scan the single host specified). Use /24 to scan a class "C" address and /16 for a class "B". There is also a more powerful notation which lets you specify an IP address using lists/ranges for each element. Thus you can scan the whole class "B" network 192.168.*.* by specifying "192.168.*.*" or "192.168.0-255.0-255" or even "192.168.1-50,51-255.1,2,3,4,5-255". And of course you can use the mask notation: "192.168.0.0/16". These are all equivalent. If you use asterisks ("*"), remember that most shells require you to escape them with back slashes or protect them with quotes.

Examples:

The following example checks the first 16 addresses in the 192.168.1.0/24 netblock for all ICMP responses. The scan speed is increased by lowering the timeout value and setting the number of retries to 1:

> icmpscan -t 500 -r 1 192.168.1.0-16
192.168.1.0: Echo (From 192.168.1.17!)
192.168.1.0: Address Mask [255.255.255.0] (From 192.168.1.17!)
192.168.1.7: Echo
192.168.1.7: Timestamp [0x03ab2db0, 0x02d4c507, 0x02d4c507]
192.168.1.7: Address Mask [255.255.255.0]
192.168.1.8: Echo
192.168.1.8: Address Mask [255.255.255.0]
To display failed probes, increase the output verbosity:

> icmpscan -v 192.168.1.1
192.168.1.1: -- No response to Echo request --
192.168.1.1: -- No response to Timestamp request --
192.168.1.1: -- No response to Netmask request --
192.168.1.1: -- No response to Info request --
192.168.1.1: -- No response to Router Solicitation request --
Individual ICMP types can be checked for by listing their corresponding flags on the command line:

> icmpscan -v --echo --netmask 192.168.1.7
192.168.1.7: Echo
192.168.1.7: Address Mask [255.255.255.0]

geglmm 0.0.22 is a great tool for programmers. It provides C++ bindings for GEGL. It currently binds gegl 0.0.16 and is in an unstable state.

Automatic Firewall is a script that will automatically configure a firewall. If you are a broadband or dial-up user who doesnt have a firewall script, you need to get one to protect yourself. AutoFW is made to help you do that with no efforts.
Many people when connecting to the internet need a firewall script made for them so they can surf the net without being susceptible to various attacks. Most, if not all (until now :-), of the existing scripts are written for a large range of requirements and require some tweaking to make them work for a specific user. However many users do not know which parameters to fill in the script config file.
AutoFW intends to provide a simple firewall script that you just need to fire and forget. You make sure to run it on computer start-up or just before connecting to the net, and it will detect network condition and setup appropriate firewall rules for you.
In order to be "smart" AutoFW has to be limited, the current scope of AutoFW are standard broadband connections, it will also cover dial-up users and stand-alone servers.
AutoFW works only for Linux IPTables firewall and needs the iptables utility to update the firewall, it also needs the ifconfig utility, both of these are available on any standard install of a GNU/Linux machine.
AutoFW also needs the ip program which is part of the iproute2 package, sometimes also called iproute. It is available as a package for any standard GNU/Linux install, not it might not be installed in your particular.
There are two parts that do automatic detection, one is for interfaces and IPs and the other is for open listening ports.
The interface part looks at all the active interfaces in the machine and classifies them between internal and external. It does that by looking at the IPv4 address of the device. If it is one of:
127.0.0.0/8
10.0.0.0/8
172.16.0.0/12
192.168.0.0/16
it is considered to be an internal IP and thus an internal interface, otherwise it is an external IP and thus an external interface. There is no handling of an interface with both an internal and an external IP on it.
The listening ports are scanned for a known port and the accompanying known program name that binds to that port, known ports are opened later in the configuration stage.
The configuration itself is very simple for now, without many of the bell and whistles that exist in other scripts, but it works for the basic needs and provides adequate protection.
Enhancements:
- Internal systems are now protected, as well as servers and NAT gateways.