Free provided as the service attribute value in the servicehost directive could not be found software for linux

Google Data Objective-C Client provides a framework and source code that make it easy to access data through Google Data APIs.
The Google data APIs provide a simple protocol for reading and writing data on the web. Many Google services provide a Google data API.
Each of the following Google services provides a Google data API:
- Base
- Blogger
- Calendar
- Spreadsheets
- Picasa Web Albums
- Notebook
Additional services with Google data APIs that are not yet supported by the Objective-C Client Library:
- Code Search
- Google Apps Provisioning

Create New Template Service Menu is a context menu item for KDE and Konqueror that automates adding Create New... menu entries from existing files. It adds a "Create Template" item to the Actions submenu of the context menu. It consists of a service menu .desktop file and a shell script.
KDE Create New Template Service Menu
This service menu removes the hassle of hand-coding Create New... menu entries. It is accessed by right-clicking regular file icons on the desktop or in Konqueror, pointing to Actions, and selecting Create Template.
It consists of a service menu .desktop file and a Bash shell script. The Create Template service menu runs a shell script that brings up two dialogs--one for choosing an icon to associate with the Create New... menu entry, and the other for entering the menu item text itself. It uses this information to write a Create New... menu item .desktop file. The shell script bases the name of the .desktop file on the name of the document file clicked on from the desktop and places a copy of the file in the .sources subdirectory of ~/.kde/share/templates.
The service menu should be placed in ~/.kde/share/apps/konqueror/servicemenus and the shell script in ~/bin.
I suggest that users first install the Simple Service Menu Installer available from http://www.kde-apps.org/content/download.php?content=23760&id=1. That service menu provides the same service for installable service menus that mine does for document templates and will greatly simplify the process of installing this service menu. After downloading that service menu just right-click on it, point to Actions, point to Install Service, and click one of the options available on the submenu. Then to install my service menu, just follow the same proceedure and place the shell script in your personal ~/bin directory.
From that point on you will have a nice, simple method of adding both installable service menus and templates to the KDE context menu.
This project is released under the terms of the GNU GPL v.2.0.
Enhancements:
- Changed menu icons to more appropriate ones.

LDAP User Management System (LUMS) provides a set of basic LDAP API functions for PHP and a strong configuration language. The project can then be used to create Web services or can be used in any PHP script.
The language allows the administrator to define LDAP object types along with their corresponding attributes.
Each attribute may be defined as required as multivalued with a type (string, binary, dn, telephone, mail, etc.) and can be user inserted, constant, auto incremented, or function created. Attribute uniqueness is supported.
It exports the following LDAP operations:
- function LUMS_ldap_search($L_binddn,$L_bindpassword,$L_basedn,$L_scope,$L_filter,$L_attrs_array)
Returns an $info object with the search results or a string with an error
- function LUMS_ldap_add_entry($L_binddn, $L_bindpassword,$L_object_type,$L_entrydn,$L_entry_info)
Returns 0 for success or string with error
- function LUMS_ldap_change_password($L_binddn, $L_bindpassword,$L_entrydn,$L_newpassword)
Returns 0 for success or string with error
- function LUMS_ldap_modify_entry($L_binddn, $L_bindpassword, $L_object_type, $L_entrydn, $L_change_info)
Returns 0 for success or string with error
- function LUMS_ldap_delete_entry($L_binddn, $L_bindpassword, $L_object_type, $L_entrydn)
Returns 0 for success or string with error
- function LUMS_ldap_rename_entry($L_binddn, $L_bindpassword, $L_object_type, $L_entrydn, $L_newrdn, $L_newparent, $L_deleteoldrdn)
Enhancements:
- Add a virtual attribute which is not stored on ldap but can be useful when creating other attribute values
- Add mapping between an indexing attribute value to other attribute values
- Fix a few typos
- Perform the same checks for all value types not just uservalue
- Lower case all passed attribute names

Net::SynchroEdit::Service is a Perl extension for SynchroEdit response service functionality.

SYNOPSIS

use Net::SynchroEdit::Service;

my $conn = new Net::SynchroEdit::Service;
$conn->connect("localhost", 7962, "root", "secret");

Net::SynchroEdit::Service provides a complete set of methods for manipulating a SynchroEdit server via the response service. The optional Net::SynchroEdit::Controller and Net::SynchroEdit::Session modules can be used in conjunction with the Service module to acquire e.g. the create_from_file method (Controller).

Net::DBus::Tutorial::ExportingObjects is a Perl module that contains tutorials on providing a DBus service.

This document provides a tutorial on providing a DBus service using the Perl Net::DBus application bindings. This examples in this document will be based on the code from the Music::Player distribution, which is a simple DBus service providing a music track player.

CREATING AN OBJECT

The first step in creating an object is to create a new package which inherits from Net::DBus::Object. The Music::Player::Manager object provides an API for managing the collection of music player backends for different track types. To start with, lets create the skeleton of the package & its constructor. The constructor of the super type, Net::DBus::Object expects to be given to parameters, a handle to the Net::DBus::Service owning the object, and a path under which the object shall be exported. Since the manager class is intended to be a singleton object, we can hard code the path to it within the constructor:

package Music::Player::Manager;

use base qw(Net::DBus);

sub new {
my $class = shift;
my $service = shift;
my $self = $class->SUPER::new($service, "/music/player/manager");

bless $self, $class;

return $self;
}

1;

Now, as mentioned, the manager with handle a number of different player backends. So we need to provide methods for registering new backends, and querying for backends capable of playing a particular file type. So modifying the above code we add a hash table in the constructor, to store the backends:

sub new {
my $class = shift;
my $service = shift;
my $self = $class->SUPER::new($service, "/music/player/manager");

$self->{backends} = {};

bless $self, $class;

return $self;
}

And now a method to register a new backend. This takes a Perl module name and uses it to instantiate a backend. Since the backends are also going to be DBus objects, we need to pass in a reference to the service we are attached to, along with a path under which to register the backend.

We use the get_service method to retreieve a reference to the service the manager is attached to, and attach the player backend to this same service: When a method on DBus object is invoked, the first parameter is the object reference ($self), and the remainder are the parameters provided to the method call. Thus writing a method implementation on a DBUs is really no different to normal object oriented Perl (cf perltoot):

sub register_backend {
my $self = shift;
my $name = shift;
my $module = shift;

eval "use $module";
if ($@) {
die "cannot load backend $module: $@" ;
}

$self->{backends} = $module->new($self->get_service,
"/music/player/backend/$name");
}

Looking at this one might wonder what happens if the die method is triggered. In such a scenario, rather than terminating the service process, the error will be caught and propagated back to the remote caller to deal with.

The player backends provide a method get_track_types which returns an array reference of the music track types they support. We can use this method to provide an API to allow easy retrieval of a backend for a particular track type. This method will return a path with which the backend object can be accessed

sub find_backend {
my $self = shift;
my $extension = shift;

foreach my $name (keys %{$self->{backends}}) {
my $backend = $self->{backends}->{$name};
foreach my $type (@{$backend->get_track_types}) {
if ($type eq $extension) {
return $backend->get_object_path;
}
}
}

die "no backend for type $extension";
}

Lets take a quick moment to consider how this method would be used to play a music track. If youve not already done so, refresh your memory from Net::DBus::Tutorial::UsingObjects. Now, we have an MP3 file which we wish to play, so we search for the path to a backend, then retrieve the object for it, and play the track:

...get the music player service...
# Ask for a path to a player for mp3 files
my $path = $service->find_backend("mp3");
# $path now contains /music/player/backend/mpg123
# and we can get the backend object
my $backend = $service->get_object($path);
# and finally play the track
$backend->play("/vol/music/beck/guero/09-scarecrow.mp3");

IRC Services are Services for IRC Networks (or just Services for short) provides for definitive nickname and channel ownership, automatic channel mode setting, memo (short message) storage and retrieval, and greater IRC operator control over the network.
Main features:
- Nickname management. Services allows users to "register" nicknames, and will prevent users other than the registrant from using them. Services also maintains information about each registered nickname, including the last time the nicks owner was online as well as a URL and E-mail address that can be set by the user.
- Channel management. Like nicknames, Services allows users to register channels as well. A channels owner can give privileges to other users of the channel, such as auto-opping or the ability to set various channel options, or conversely deny other users the ability to obtain channel operator privileges or even enter the channel altogether. Services will remember the topic on the channel even after the last user leaves, and can automatically set modes on the channel whenever a user joins it.
- Messages to offline users. Probably every IRC user has gone through the experience of waiting and waiting for someone to come online in order to pass a message along or ask a question. Services alleviates this with a "memo" system, allowing users to leave messages for other users even if the recipient is not online at the time; the recipient will be notified of the memo the next time they log on.
- Centralized network control. Services includes features which allow IRC operators greater control over the IRC network through a single point, and also defines multiple privilege levels for IRC operators with respect to Services itself. For example, IRC operators with sufficient privileges can use Services to set modes on any channel; it is also possible to ban users or groups of users from connecting to the network entirely, and such bans ("autokills" in Services terminology) will remain active even if a server, or Services itself, splits from the network.
Furthermore, each of these sets of features can be configured or disabled to match individual networks policies.
Whats New in 5.1pre4 Development Release:
- This release corrects various minor issues in the previous beta release and updates the ratbox protocol module to better support current versions of the ircd-ratbox server (note that versions earlier than 2.1 are no longer supported).
Whats New in 5.0.61 Stable Release:
- This release fixes a bug which allows users to crash Services on x86-64 (and potentially other non-x86) platforms.

Logging Services project is intended to provide cross-language logging services for purposes of application debugging and auditing.
We should also mention that thanks to the relentless efforts of many developers, we have a basic level of interoperability between the following projects:
- Log4Cxx (c++)
- Log4j
- Log4Net
- Log4Perl
- Log4PHP
- Log4PLSQL
- JDK1.4s util.logging framework
There is still much work ahead bringing in the various projects to work together within the Logging Services Project. The process is likely to take a little while. In the mean time, we will continue to do what we like best, that is developing open source software.
This is a project of the Apache Software Foundation (ASF). Like all Apache projects, we encourage a collaborative, consensus-based development process. We offer an open and pragmatic software license, and we strive to create software of the highest quality. The ASF is organized into several projects, which like Logging Services project may contain multiple sub-projects.