Free avg definitions software for linux

About AVG Anti-Virus:

• AVG Professional Single Edition is perfectly designed to give you the maximum antivirus protection for your single home PC or workstation.
• It is simple to install and operate. No IT expertise is required and it can run in the background, providing uninterrupted protection. All file and e-mail activity is checked automatically, allowing you to get on with your work without worrying about viruses.
• It is extremely fast, reliable and light on resources, so, no matter how demanding a user you are, it will not slow down your performance.

Enhancements: Added detection of new variants of trojans SHeur2.ANNO, BackDoor.Hupigon5.LCW, SHeur2.ANOR, Downloader.Generic8.AXOI, PSW.Banker5.ONF, Generic13.BPUS.

NACE is a generic query engine used to automatically create host and service definitions for hosts on the network.

It is intended to be used in a shell script at regular intervals by an experienced Nagios administrator to perform a query against the supplied host list. It then creates host and service definitions using the parameters supplied in the query.

Natrium Engine project tracks groups of parts by letting users define the relationships between parts. Users create definitions for configurations and parts.

These are joined together to form a rule for parts in configurations. When a part is removed from or added to a configuration, all children of that part are also transferred. This has special applications to "living" inventory, or groups of disparate parts that need to be tracked as a group rather than individually.

For example, if a carburetor is made a separate configuration from an engine, then when removing it all parts associated with the carburetor are also removed. A facility is provided for tracking user-defined line-item costs of each part.

Layer-7 Packet Classifier for Linux is a packet classifier for Netfilter that identifies packets based on application layer (OSI layer 7) data. This means that it is able to classify packets as HTTP, FTP, Gnucleus, Kazaa, etc., regardless of ports.
It complements existing matches that classify based on port numbers, packet length, TOS bits, and so on. Combined with Linux QoS, it allows for full layer 7 packet shaping.
Main features:
- Patches for Linux 2.4 and 2.6
- Support for TCP, UDP and ICMP over IPv4
- Uses Netfilters connection tracking of FTP, IRC, etc
- Examines data across multiple packets
- Number of packets examined tunable on the fly through /proc
- Number of bytes examined tunable at module load time
- Distinguishes between new connections (those still being tested) and old unidentified connections
- Gives access to both Netfilter and QoS (rate limiting) features
- With the Netfilter "helper" match, you can distinguish between parent and child connections (e.g. ftp command/data)

libavg library is made for media presentations and installations that is meant to make Macromedia Director superflous.
Installations are scripted using an XML-based layout language and Python for interaction.
Multimedia on linux has made great progress. A few years ago, video support was very limited, low-latency-audio was impossible and getting jitter-free performance was a nightmare. This has changed, and all thats really missing is some glue that joins the different libraries. libavg is an effort to do for multimedia installations what the Gimp did for image editing, what OpenOffice did for word processing... and what Linux did for operating systems in general: give people an alternative thats free (as in speech, not beer).
Presumably, companies will be using avg too, but the main effort will be to support artists and designers that dont have the resources to buy commercial software. Of course, that means that the system needs to run well on old computers, while allowing the use of all features on modern pcs.
It should be almost as easy to build installations as it is to build a web page. Designing interactive systems will still need some programming skills, but this should be kept to a minimum. A avg installation consists of one or more xml files that describe screen layout(s) and corresponding python scripts that describe the dynamics of the installation: What to do when a user interacts with the system, some time has elapsed or any other input has arrived. The result is that the xml files are as easy to edit as html is - and many of the methods used for the interactive parts should be very familiar to anyone whos used javascript on a web page.
Enhancements:
- In addition to many minor improvements, this version adds support for dynamically adding nodes to and removing nodes from an active avg tree, thus making the library a lot more flexible.

AutoOpts 25:1 is included with AutoGen 5.7.1. AutoOpts project is a very powerful command line option parser consisting of a set of AutoGen templates and a run time library that nearly eliminates the hassle of parsing and documenting command line options. This package allows you to specify several program attributes, up to 100 option types and many attributes for each option.
Using your programs option definitions, AutoGen will expand the AutoOpts templates into two C source files and, optionally, a man page document and a tex-info ``invoking document section. The header and code files constitute all the information the AutoOpts library needs to parse and handle the command line, environment variables and initialization file (rc file) options. When your program runs, the AutoOpts library will then interpret these compiled data.
Additionally, if you wish to use ``getopt_long(3GNU) or getopt(3C) to parse the options instead of AutoOpts libopts library, you may do so. A template (getopt.tpl) is distributed with AutoOpts that will take restricted AutoOpts option definitions and produce the parsing loop that calls either ``getopt(3C) or ``getopt_long(3GNU). (Which depends on whether long options are enabled in your description.) Be aware, though, that it is significantly crippled when compared with the full set of AutoOpts Features
AutoOpts is available either under the terms of the Library GNU Public License, or, at your option, the terms of the advertising-clause-free BSD license.
Enhancements:
- Configuration file data for options with compound, structured argument values were not parsed correctly. This has been fixed.

Inline::C is a Perl module that can Write Perl Subroutines in C.

Inline::C is a module that allows you to write Perl subroutines in C. Since version 0.30 the Inline module supports multiple programming languages and each language has its own support module. This document describes how to use Inline with the C programming language. It also goes a bit into Perl C internals.

If you want to start working with programming examples right away, check out Inline::C-Cookbook. For more information on Inline in general, see Inline.

Usage

You never actually use Inline::C directly. It is just a support module for using Inline.pm with C. So the usage is always:
use Inline C => ...;
or
bind Inline C => ...;

Function Definitions

The Inline grammar for C recognizes certain function definitions (or signatures) in your C code. If a signature is recognized by Inline, then it will be available in Perl-space. That is, Inline will generate the "glue" necessary to call that function as if it were a Perl subroutine. If the signature is not recognized, Inline will simply ignore it, with no complaints. It will not be available from Perl-space, although it will be available from C-space.

Inline looks for ANSI/prototype style function definitions. They must be of the form:

return-type function-name ( type-name-pairs ) { ... }

The most common types are: int, long, double, char*, and SV*. But you can use any type for which Inline can find a typemap. Inline uses the typemap file distributed with Perl as the default. You can specify more typemaps with the TYPEMAPS configuration option.

A return type of void may also be used. The following are examples of valid function definitions.

int Foo(double num, char* str) {
void Foo(double num, char* str) {
SV* Foo() {
void Foo(SV*, ...) {
long Foo(int i, int j, ...) {

The following definitions would not be recognized:

Foo(int i) { # no return type
int Foo(float f) { # no (default) typemap for float
int Foo(num, str) double num; char* str; {
void Foo(void) { # void only valid for return type

Notice that Inline only looks for function definitions, not function prototypes. Definitions are the syntax directly preceeding a function body. Also Inline does not scan external files, like headers. Only the code passed to Inline is used to create bindings; although other libraries can linked in, and called from C-space.