Free c apis software for linux

CyaSSL package is a fast, dual-licensed implementation of SSL for embedded and small footprint devices. It includes SSL client libraries and an SSL server implementation.
CyaSSL supports multiple APIs including an OpenSSL compatibility interface. TLS 1.1 is supported along with cipher suites for AES, 3DES, and RC4.
Installation:
To build on Linux, Solaris, *BSD, Mac OS X, or Cygwin:
./configure
make
from the ./testsuite/ directory run ./testsuite
to make a debug build:
./configure --enable-debug --disable-shared
make
Enhancements:
- This release adds increased error string support, better closed connection dectection, and OpenSSL type DES functionality.

Linux documentation can be found in man pages, info files, HOWTOs and FAQs, and elsewhere. (For example, also the kernel Documentation directory contains a lot of good stuff.) A nice index for the man pages in Fedora Core 2 is found at the superman site.

Man pages belonging to programs are usually distributed together with those programs. Therefore, the Linux man-pages distribution mainly contains the pages for system calls and library routines, special devices, and file formats.

However, it also contains documentation for a number of programs, in cases where the authors or maintainers of the program do not distribute man pages themselves.

Kfb (KDE Firebird Basictool) is a GUI administration tool for the Firebird database system. The application includes most functions offered by Firebird and introduces some new operations said to be impossible

Kfb is programmed with KDevelop (C++ and Qt). It is fully GUI and based mainly on IBPP, another open source project of C++ interface to Firebird APIs. Kfb also includes some other libraries, ncrypt and fbcopy, and all of them are open source projects.

Google Gears project is an open source Firefox extension that enables web applications to provide offline functionality using following JavaScript APIs:
- Store and serve application resources locally
- Store data locally in a fully-searchable relational database
- Run asynchronous Javascript to improve application responsiveness

Env::C is a Get/Set/Unset Environment Variables on the C level.

SYNOPSIS

use Env::C;

my $key = "USER";
$val = Env::C::getenv($key) || ;

Env::C::setenv($key, "foobar", [$override]);
$new_val = Env::C::getenv($key) || ;

Env::C::unsetenv($key);

my $ar_env = Env::C::getallenv();
print join "n", @$ar_env;

This module provides a Perl API for getenv(3), setenv(3) and unsetenv(3). It also can return all the environ variables.

Sometimes Perl invokes modules with underlaying C APIs which rely on certain environment variables to be set, if these variables are set in Perl and the glue code doesnt worry to set them on the C level, these variables might not be seen by the C level. This module shows what really the C level sees.

PyKCS11 is a full PKCS#11 wrapper for Python.
PyKCS11 let you access to almost all PKCS#11 functions and data types using any PKCS#11 library, such as the various modules supplied by smartcard vendors.
The wrapper comes with 2 interfaces: a low level and very thin interface over the original PKCS#11 API, generated using the SWIG compiler (designed for library tests); and an high level interface that offers a simpler access (with few limits) to the PKCS#11 APIs.
PyKCS11 is released under the GNU General Public License
Supported Platforms:
- Win32
- GNU/Linux
- Mac OS X
- FreeBSD (tested on 6.1)
- should also work on most UNIX

C/Invoke is a library for connecting to C libraries at runtime. This differs from the typical method of interfacing with C, which involves writing static definitions which are then compiled to a machine-dependant format. C/Invoke provides a runtime facility to build descriptions of C functions and to call them, passing them appropriate data and retrieving results.
C/Invoke provides a central repository of code to handle the platform-dependant details of marshaling C parameters and return values. Currently C/Invoke has been ported to GCC (GNU/Linux, *BSD) on the x86 and amd64 architectures, Microsoft Windows on x86, and Mac OS X on PowerPC. The development team is interested in adding more ports as they gain access to more diverse hardware.
Audience
The main audience of C/Invoke are users of high-level programming languages who wish to interface with C. At the moment, most languages can be extended with C libraries only by authoring modules in C using language-specific APIs. There are many problems with this approach; writing extension modules requires knowledge of the C language instead of the language the application is being written in, the APIs needed to implement the modules are often involved and complex, and the resulting libraries must be built and maintained on many different platforms.
However, once C/Invoke is integrated into a language, the situation changes dramatically; users of Lua (for example) can interface to C by writing Lua code alone. This means that the advantages of Lua (or other high-level languages) such as portability and ease of use can be combined with the low-level power of C. To call a C function, one merely declares a C prototype in the high-level code, similar to the P/Invoke functionality of Microsofts .NET Framework. A subroutine is then created in the high-level environment which hooks into a proxy generated to correctly call the given C function.
There are two ways to integrate C/Invoke into a language. One is to use the existing extension module interface of the language in the normal manner. This is the preferred method to integrate with a language which is already established and which would be hard to modify, such as Perl, Python, Ruby, Tcl, etc. The other way would be to link C/Invoke directly into the language runtime and make the declarative C services part of the syntax of the language.
The C/Invoke developers are always looking for volunteers to integrate with an existing language, or programming language authors who are interested in using C/Invoke directly.
Enhancements:
- Support for the SPARC architecure was added, and many bugs were fixed in the Lua language binding.

XINS is a technology used to define, create, and invoke remote APIs. XINS is specification-oriented.
When API specifications are written (in XML), XINS will transform them to HTML-based documentation and Java code for both the client-side and the server-side.
The communication is based on HTTP. XINS competes with the complex SOAP technology. Main design goals include simplicity, scalability, and testability.
XINS is not only a specification technology, but also an application development framework. It offers transaction logging, unique log documentation, and active code generation.
Whats New in 2.0 Stable Release:
- This release adds support for JSON calling conventions, shared error codes, and import of WSDL and XML Schema.
- Integration with the Spring framework and GWT has been improved.
- New examples with Groovy, REST, and the Dojo toolkit have been added.
- Many other small features and improvements have been done.
Whats New in 2.1 Alpha 2 Release:
XINS/Java Common Library:
- Fixed null values were put in the Map when using the BeanUtils#getParameters method.
- The ServletClassLoader can detect the xins-common.jar using the XINS_HOME environment variable if needed.
- Added automatic detection of the WAR file in the HTTPServletStarter when not passed as paramter.
- Added possibility to pass the ClassLoader mode to the HTTPServletStarter.
- Added new Ant task similar to the < xslt / > task with the option to never overwrite the destination files.
- Added possibility to handle several request at the same time in the internal Servlet container (multi-threaded).
XINS/Java Server Framework:
- Fixed the way the xins.properties was loaded when no org.xins.server.config is set was incorrect.
- Implement RFE #1624142: ACLs for calling conventions. /! The allow methods have a new argument (that can be null).
- Added getName and setName methods in the calling convention classes.
Generation of the opendoc:
- Added colors to the examples.
- Enlarged the example tables.
- Added colors to the table headers.
- Added the categories after the API description.
- Use Courier New font for element names.
- Added light gray borders to the tables.
- Reduce the use of bold fonts.
- Fixed missing uppercase for input and output section.
- Fixed the description of the function, parameters and error was just the first sentence.
- Fixed support for < em > element in descriptions.
- Fixed the "4" appearing before closing an element example.
Generated build file:
- Added javadoc-test-< api name > to get the Javadoc of the unit tests.
- Added possibility to execute the API using java -jar < api name >.war
- Replaced create-project.xslt and tools.xslt with build-create.xml and build-tools.xml as most of the code doesnt need to be dynamically generated.
- Added build-apis.xml which contains static content of the old generated build.xml. This result in the reduction of the size of the generated build.xml.
- Several bug fixes and optimalization during the refactoring.
- The dependency libraries have been added to the classpath for the run and test targets.
Documentation:
- Changed < style / > in < xslt / > in the xins-docs/build.xml.
Build- and release-process:
- Fixed incorrect location of the icon for the Windows installer.
Other:
- Fixed the package list for XINS and log4j.
- Added the package-list for JUnit.
- Added more debug sources for the nbbuild.xml of the petstore.