Free valgrind 3.3.0 software for linux

wview is a linux/*BSD/unix/MacOSX-Darwin application that controls a Davis Vantage Pro or Vantage Pro2 weather station console to retrieve archive records and current conditions.

The archive records are stored in the Davis WLK file format (thus Weatherlink generated archive files can be used by wview). Archive records may optionally be stored in a relational database (MySQL or PostgreSQL).

At a user-defined interval, wview will use the archive history and current conditions to generate weather images (buckets and graphs) and HTML web pages based on configurable HTML templates. Optionally, the web pages can be transferred to a remote web server via an ftp or secure ssh process included with wview.

Optionally, the wview alarm daemon wvalarmd can be enabled to deliver current conditions to TCP socket clients as a near real-time data feed engine. wvalarmd can also be configured to function as a weather data alarm generator to user specified scripts or binaries. Optionally, your station data can be submitted to the CWOP system for use by NOAA and others or to the Weather Underground.

wview can be easily configured for international or US units, labels and text. wview supports serial and USB data loggers. wview natively supports connectivity with a terminal server or serial server via TCP sockets - no intermediate software required to make the ethernet port "look" like a serial port.

RFC (Remote Filesystem Checker) is a set of scripts that aims to help System-Administrators run a filesystem-checker (like tripwire, aide and so on...) from a "master-node" to several "slave-nodes" using ssh, scp, sudo and few other common shell commands.
Main features:
- crate/update FileSystem-Checkers (FSC) database
- execute FSC and create a log-report
- allow parallel execution, mass-check and mass-upgrade!
- support non-interactive operations
- use scp/ssh for all connections
- use an arbitrary port for ssh/scp connections (may be different for each host!)
- send (ONE) email to administrator(s)
- rotate logs, databases and other files
- support for AFICK, AIDE and INTEGRIT FileSystem-Checkers
- check users creation/removal
- check group creation/removal
- check if someone changes UID, GID or shell
- check for groups members or ID changes
- check for SUID/SGID on remote host via a separate PERL script
- check if remote-host is up before run checks on it (via nmap)
- kill the processes that take too long (you can set an arbitrary timeout value)

The Perl script testmail checks e-mail available at the POP3 server (including SSL), filters it according to the defined rules, and depending on the selected method gets the messages to the local mailbox and/or removes it from the server.
Testmail uses Perl Mail-POP3Client, Net-Ping, and Socket modules and helps you escape from spam.
Enhancements:
- This release allows the user to use SSL and a specifically selected port (for example, for a Gmail mailbox).
- Testmail now uses Mail-POP3Client module instead of the libnet module.
- Configuration files were changed to add PORT, USESSL, AUTH_MODE, and DEBUG options.
- Some rejecting rules were improved.

Swift is a fully OOP Library for sending e-mails from PHP websites and applications. Swift Mailer does not rely on PHPs native mail() function which is known for using high server resources when sending multiple emails. Instead, Swift communicates directly with an SMTP server or a MTA binary to send mail quickly and efficiently.
Swift is comparable to PHPMailer except that it implements an extremely flexible and innovative plugin system meaning you can get the most out of sending emails from your PHP applications. The interface for Swift is both tighter and more intuitive.
I started developing Swift because I moderate a popular PHP forum and its clear from some of the posts we see that PHPs native mail() function just doesnt quite cut it among developers unless you know a lot about how to build emails and you only need to send one message.
The only other popular alternative was PHPMailer which is great, but it just struck me that maybe developers might want something with a little more "umff"! So I wrote Swift initially for the communtity at the PHP Developers Network Forums and have decided to release it now under the LGPL. Enjoy!
Main features:
- Send uses one single connection to the SMTP server or MTA
- Doesnt rely on mail()
- Custom Headers
- Multiple encoding options
- TLS Support - for Gmail servers
- Embedded Images
- Builds and sends Multipart messages
- Sends single-part emails as usual
- Fast Cc and Bcc handling
- Batch emailing with multiple Tos or without
- Support for multiple attachments
- Set message priority
- Request Read Receipts
- Sendmail (or other binary) support
- Pluggable SMTP Authentication (LOGIN, PLAIN, MD5-CRAM, POP Before SMTP)
- Anti-Flooding support (reconnect every X emails) via plugin
- Secure Socket Layer connections (SSL)
- Loadable plugin support with event handling features

Eigen project is a lightweight C++ template library for vector and matrix math, a.k.a. linear algebra.
Unlike most other linear algebra libraries, Eigen focuses on the simple mathematical needs of applications: games and other OpenGL apps, spreadsheets and other office apps, etc. Eigen is dedicated to providing optimal speed with GCC.
- Its fixed-size classes are specially optimized for small sizes up to 4, although it is theoretically possible to specialize them to any size. They never cause dynamic memory applications and the simple operations on them are as fast as is possible at least for sizes up to 4 (see below).
- Its dynamic-size classes are more flexible and suitable for larger sizes.
Main features:
- No dependency. Only relies on the C++ Standard Library, and only does so for a few things.
- As a consequence: very good portability.
- Very good performance (tested with GCC, should apply to other compilers as well):
- The fixed-size classes are optimal in the sense that theyre just plain C arrays with methods manipulating them. They never cause dynamic memory allocations. Checked with valgrind.
- The assembly code generated by GCC has been carefully checked to make sure that loop unrolling and function inlining work as expected with "g++ -O2" and "g++ -O3".
- For the loops that GCC fails to unroll (mostly nested loops), we provide hand-unrolled versions for sizes up to 4.
- There is no "virtual" keyword in Eigen.
- Eigen never trades performance for syntactic sugar. When some method introduces a significant language overhead (e.g. returns an object by value), we provide an alternative method doing the same thing faster but without the syntactic sugar.
- Provides easy-to-use classes for solving systems of linear equations.
- Provides easy-to-use functions for linear regression analysis.
- Can perform LU decompositions and use them to invert matrices, compute rank, kernel, etc.
- Integrates nicely with OpenGL:
- Provides functions and classes for projective geometry.
- Stores matrices in column-dominant order, hence matrices can be directly passed between OpenGL and Eigen.
- Uses an OpenGL-like typedef naming scheme, for instance Vector3f for vectors of floats of size 3.
- Robust:
- Only uses algorithms that are guaranteed to work in all cases. For example, the LU decomposition is done with complete pivoting, which means that it works for all square matrices, even singular ones.
- Covered by extensive unit-tests.
- Thread-safe, though thats only as a consequence of staying simple and not trying to do advanced stuff like buffer sharing.
- Floating-point-correct. Eigen has a clear, simple and sound policy with respect to the inherent problems of IEEE754 floating-point arithmetic.
- Fully supports std::complex for matrices and vectors over the complex numbers.
- Is a pure template library and consists only of header files. Thus, using Eigen will only add a build-time dependency to your project.
- Uses standard asserts, controlled as usual by NDEBUG. To achieve optimal performance, turn them off by defining NDEBUG, e.g.
Enhancements:
- This release supports fixed-size classes that are optimized for small sizes of up to four dimensions for 3D geometry and OpenGL.
- Dynamic classes are more flexible and suitable for larger data.

Nemiver is an project to write a standalone graphical debugger that integrates
well in the GNOME desktop environment. The project currently features a backend which uses the well known GNU Debugger gdb.

General

- In addition to the toolbar buttons, you can toggle breakpoints simply by clicking in the margin on the line you want to break on.
- hovering over a variable name for longer than 1 second should show its value as a tooltip window if the variable is in scope

Sessions

Nemiver uses an sqlite database to store basic information about a debugging
session so you can resume where you left off last time. Whenever you start
debugging, a new session is created for you automatically (unless you explicitly
request to resume an existing session).

On exit, your session will automatically be saved. Information saved with your session includes breakpoints, program arguments, working directory path, environment variables, etc. Additionally, you can save the current session to the database on demand by selecting File > Save Session to Disk.

To resume a previously saved debugging session, you can either specify the
session ID to the --executesession command line option or select File > Saved
Sessions... > [select session] from the User interface.

Source Directories

Some versions of the GDB debugger dont provide full pathname information for breakpoints, etc. In this case, you may need to specify which directories to search for source files. These can be specified by manually adding source directories in the Preferences dialog. In the future there will be a more explicit prompt asking the user to locate the requested file when nemiver cant determine the absolute path of a file on its own.

Extending Nemiver

Nemiver is a bit more than just a simple GUI debugger. It is actually a platform which can be extended with plugins and dynamically loaded modules. The libnemivercommon library provides the basic functionality for loading dynamic modules and enabling the plugin architecture of Nemiver. You can create additional plugins for nemiver, and you can even create entirely new perspectives for the nemiver workbench.

Currently, only the debugging perspective is provided, but others could be added in the future (e.g. a perspective for profiling tools such as oprofile, valgrind / massif, etc).

Nemiver also provides an event-based debugger library (which currently features a gdb backend, but others could be added in the future) that could be re-used by other projects seeking to implement a debugger as a part of an IDE, for example.