Free access version control software for linux

A Simple Version Control System is an easy to install and easy to to use version/revision control system.
ASVCS differs from most other version control systems in that ASVCS is designed to keep track of files in place. ASVCS does not allow any changes to be made to files, all changes require the users to change files externally with FTP or SSH access.
ASVCS is very easy to setup and use. Users do not need to work with repository, branches, commit and check-out files. All a user needs to do is upload the changes files and click Update or if enabled just wait for it to be updated automatically.
ASVCS is ideal for small projects or personal use, though it can also be used by large project how do not need or want the complexity of most version control systems.
Main features:
- asy to install and use
- Written in PHP
- Can track binary or text files
- Automatic file tracking (requires cron support)
- Diffs of revisions
- Easy user access management
- Entirely Web based
- Skinable
- Open source (MIT/expat license)

Rule Set Based Access Control (RSBAC) is a Free Software security extension for current Linux kernels. Rule Set Based Access Control is based on the Generalized Framework for Access Control (GFAC) by Abrams and LaPadula and provides a flexible system of access control based on several modules.
All security relevant system calls are extended by security enforcement code. This code calls the central decision component, which in turn calls all active decision modules and generates a combined decision. This decision is then enforced by the system call extensions.
Main features:
- Free Open Source (GPL) Linux kernel security solution
- Independent of governments and big companies
- Several well-known and new security models, like MAC, ACL and RC
- On-access virus scanning with the Dazuko interface
- Detailed control over individual user and program network accesses
- Fully access controlled kernel level user management
- Any combination of security models possible
- Easily extensible: write your own model for runtime registration
- Support for latest kernels and stable for production use
Enhancements:
- This release relates to kernel 2.4.34.5 and 2.6.22.1.
- There are important fixes with some compilation errors and an important bug with User Management password hashing, introduced with the newer 2.6 kernel crypto API.
- Some security has been added with safety measures against null pointers.

PHP Generic Access Control List is a PHP class that offers Web developers a simple, yet immensely powerful "drop in" permission system for their current Web-based applications.
Main features:
- Split into two classes, and a seperate administration interface.
1. GACL class: Designed to be very small (517 lines of code including comments) and very fast, this class strictly takes care of the permission checks.
2. GACL_API class: Designed to be robust and flexible, this class takes care of creating/editing/deleting objects, groups and ACLs.
3. phpGACL Administration Interface: A set of scripts that allow for the easy administration of the entire GACL universe using only your browser.
- NOT limited to typical "read/write/execute" permissions similar to some flavours of *nix
- User definable "Access Control Objects" (ACO). These are objects which control what access is available to "requesters" (see below).
- Several examples:
- Enable - Projects
- View - Projects, View Own - Projects
- Edit - Projects, Edit Own - Projects
- Delete - Projects, Delete Own - Projects, UnDelete - Projects, UnDelete Own - Projects
- Add - Projects
- System down for Maintenance
- View - The letter "e" ;)
- User definable "Access Request Objects" (ARO). These are objects which request access from an "Access Control Object" (above) examples would be:
- Users/Accounts
- IP Addresses
- Browsers/Browser capabilities (JS/Flash/DHTML)
- User definable "Access eXtension Objects" (AXO). These are objects which extend permissions to a 3rd layer, optionally allowing you to set fine grained permissions on each individual item in your application, or even row in your database. AXOs are often used in cases where you only want to give a user access to a specific project or contact.
- Several examples:
- Projects - Project ID: 3474 (Accounting Software)
- Projects - Project ID: 3484 (Financial Software)
- Contacts - Contact ID: 4775 John Doe
- Contacts - Contact ID: 4795 John Doe
- Tree based ARO/AXO Object grouping with inheritance.
- Contains functionality to easily program add-ons. Examples would be for product pricing, or quantity limitations.
- One function application integration: acl_check()
- Simply pass this function four parameters, it doesnt get any easier!
- Supports the most popular databases using the ADODB database abstraction layer. (MySQL, PostgreSQL, Oracle, MSSQL)
- Complete web based administration interface.
- Scalable. A real-world working version with many added layers of complexity supports over 60,000 Accounts, 200 Groups and 300 ACOs.
Requierments:
- PHP 4.x or greater
- SQL database. (MySQL 3x/4.0.15+, PostgreSQL 7.2+, Oracle 9i+, MS-SQL 2000+)
Enhancements:
- This release contains several minor bugfixes and a fix for a major bug with del_object(), which caused transactions to abort prematurely.
- It also contains a slightly improved installer with Informix support, less possibility of conflicting code with other applications, and upgraded ADODB and Smarty packages.

CVSPermissions is a toolkit that will allow CVS administrators to set up directory level access control in CVS for multiple CVS users.
This toolkit is a collection of shell scripts and CVS configuration to achieve the access control functionality.
Enhancements:
- This release implements changes to all the grep patterns to accurately search for strings.

Simple Xmms Control is a a simple SuperKaramba theme that provides XMMS control. Icons are from nuoveXT icon theme.

All suggestions are welcome!

AdaControl is a free (GMGPL) tool that detects the use of various kinds of constructs in Ada programs. AdaControls first goal is to control proper usage of style or programming rules, but it can also be used as a powerful tool to search for use (or non-use) of various forms of programming styles or design patterns. Searched elements range from very simple, like the occurrence of certaine entities, declarations, or statements, to very sophisticated, like verifying that certain programming patterns are being obeyed..
Which elements or constructs are searched is defined by a set of rules; the following table gives a short summary of rules currently checked by AdaControl. The number in parentheses after the rule name gives the number of subrules, if any. Considering all possible rules and subrules, this makes 216 tests that can be performed currently by AdaControl!
- Abnormal_Function_Return Controls a design pattern that ensures that a function always returns a result .
- Allocators Controls ocurrences of allocators, either all of them, or those targeting specified types.
- Array_Declarations (x2) Controls several metrics in array declarations.
- Barrier_Expressions Controls elements allowed in the expression of protected entries barriers
- Case_Statement (x4) Controls several metrics in case statements.
- Control_Characters Controls occurrences of control characters (like tabs) in the source.
- Declarations (x75) Controls occurrences of certain Ada declarations.
- Default_Parameter Controls subprogram calls and generic instantiations that use (or not) the default value for a given parameter.
- Directly_Accessed_Globals Controls a design pattern that ensures that all global variables are accessed only through dedicated subprograms.
- Entities Controls occurrences of any Ada entity.
- Entity_Inside_Exception Controls occurrences of entities inside exception handlers.
- Exception_Propagation (x4) Controls that certain subprograms (or tasks) cannot propagate exceptions, or that no elaboration can propagate exceptions.
- Expressions (x9) Controls usage of certain forms of expressions
- Global_References Controls unsynchronized accesses to global variables.
- Header_Comments (x2) Controls the presence of comments at the start of each module.
- If_For_Case Controls if statements that could be replaced by case statements.
- Instantiations Controls generic instantiations, either all of them, or those that use specified entities.
- Insufficient_Parameters Controls the use of positional parameters in calls where the value does not provide sufficient information.
- Local_Hiding Controls occurrences of local identifiers that hide an identical outer one.
- Local_Instantiation Controls instantiations in local scopes.
- Max_Blank_Lines Controls the occurrence of more than a specified number of consecutive empty lines.
- Max_Call_Depth Controls the maximum depth of subprogram calls.
- Max_Line_Length Controls maximal length of source lines.
- Max_Nesting Controls scopes nested more deeply than a given limit.
- Max_Parameters (x6) Controls the maximum numbers of parameters in callable entities (procedures, functions and entries)
- Max_Statement_Nesting (x5) Controls composite statements nested more deeply than a given limit.
- Movable_Accept_Statements Controls statements that could be moved outside an accept statement.
- Naming_Convention Controls the form of allowed (or forbidden) names in declarations.
- No_Safe_Initialization Controls a design pattern that ensures that any variable is initialized before being used.
- Non_Static (x3) Controls non static expressions in index or discriminant constraints, or in instantiations.
- Not_Elaboration_Calls Controls subprogram calls performed from places outside package elaboration code.
- Other_Dependencies Controls semantic dependencies to other units than those indicated
- Parameter_Aliasing Controls subprograms and entry calls where a variable is provided to more than one [in] out parameter.
- Potentially_Blocking_Operations Controls the use of potentially blocking operations from within protected operations.
- Pragmas Controls the use of specific pragmas.
- Real_Operators Controls occurrences of = or /= operators on real types.
- Reduceable_Scope Controls declarations that could be move to more deeply nested scopes.
- Representation_Clauses Controls occurrences of representation clauses.
- Return_Type Controls the use of certain kinds of types as return types of functions.
- Side_Effect_Parameters Controls subprogram calls and generic instantiations that call functions with side effect, thus creating a dependance to the order of evaluation.
- Silent_Exceptions Controls exception handlers that do not reraise exceptions nor call indicated subprograms.
- Simplifiable_Expressions (x4) Controls occurrences of various forms of expressions that could be simplified.
- Special_Comments Controls the presence of certain string patterns in comments.
- Statements (x42) Controls occurrences of Ada statements.
- Style (x12) Controls various forms of constructs generally recommended in style rules.
- Terminating_Tasks Controls a design pattern that ensures that tasks never terminate.
- Uncheckable (x3) Controls constructs that are not statically checkable by other rules
- Unnecessary_Use_Clause Controls use clauses on packages, where no element of the package is referred to within the scope of the use clause.
- Unsafe_Paired_Calls Controls a design pattern that ensures that certain calls are allways paired (like P/V procedures).
- Unsafe_Unchecked_Conversion Controls instantiations of Unchecked_Conversion between types of different or unspecified sizes.
- Usage (x5) Controls usage of objects under certain conditions (in package specifications, read, written modified...).
- Use_Clauses Controls occurrences of use clauses, except for indicated packages.
- With_Clauses (x3) Controls proper usage of with clauses.
Enhancements:
- This release adds rules to check that header comments match a given pattern.
- It has indication of possible false positives and false negatives due to non-statically analyzable constructs.
- There is a fine definition of constructs allowed in entry barriers (including the one of the Ravenscar profile).
- There is better integration into GPS, and much more.

BlueCoat Control Center allows people with BlueCoat proxies to monitor their proxy infrastructure. BlueCoat Control Center utilizes Tcl, MySQL and PHP.

Advanced URLs are polled, and the data is presented back through PHP. Syslog and real-time access log data can also be used to show proxy utilization and alerts.

mod_access_rbl2 is an Apache module that can control access to a site using DNSbl lookups.

Installation:

Use the options --disable-module=access --add-module=mod_access_rbl.c
to configure then build as normal.

Use:

This adds the options:

allow via [dns-server]
deny via [dns-server]

that can be used anywhere other allow and deny statements can be. The [dns-server] can be any dns server that answers queries like the MAPS RBL server. (The IP address of the client, with the quads reversed, is prepended before any dns lookup. If an address is returned, there is a match.)

Example:

order allow,deny
allow from all
deny via rbl.maps.vix.com

This will deny all requests from systems listed in the MAPS RBL. See http://mail-abuse.org/rbl/ for details on the MAPS RBL project.

Performance impact:

This module will perform a dns lookup every time a "deny via" access is tested. Perhaps future versions can have a cache of recently tested systems.

Impact when not using this new feature should be negligible.