Implement new frontend functions for CGI frontend

Added function to serve requests from any frontend

This function serves requests from any frontend. This would be common
code among all frontends. That's why implementing in the core makes more
sense.

Added functions to handle errors, entries or feeds in frontend

Added get_request function to the frontend

Added request structure

This is needed to allow the core to know about the request made to the
frontend. A request will need to represent more things besides a type
and the requested object, like the entry or data provided, in the case
of a POST or PUT, for example.

Fixed memory leak when setting error message

Removed parameter name from header

Enumerate entries at the start of the program

This is required to set the request mappings, so the frontend can
identify the backend request needed to retrieve an entry.

CGI frontend now requests a feed or an entry depending on the request

Frontend maps request to Atom ID before retrieving resource

Backend now retrieves a request, not an Atom ID

We map an Atom ID to a backend request and, then, retrieve this request
from the backend.

The frontend tells if a request is a feed or not

Remove Atom Resource

This is required as the next step is to make the frontend decide if the
requested resource is a feed or an entry, instead of the backend.

Added functions to convert AtomID from and to frontend and backend requests

Set up mappings when enumerating entries

Register CGI frontend in main context

Added CGI frontend structure implementation

Added frontend requests mapping

Create frontend structure with map_entries function

Initialize is_feed function for backends to NULL

Moved core implementation to the library

Update entry xml node before using it

Fixed setting an entry title

Use an array instead of a list for the entries in a feed

When converting feed to xml node, set the atom namespace

Allow more than one author, as required by specification

The Atom RFC allows more than one author, which we didn't. Now, an entry
have an array of authors, which can be added to or retrieved. The header
also had the wrong function names.

Fixed the use of a dangling reference

When unreferencing the info object, the name attribute would be
released, resulting in a bug when trying to copy it right after that.
So, we unreference the info object in the end of the loop now.

Fixed memory leak when enumerating entries

Added map from atom:IDs to backend requests

Use local variables when calling backend enumerate function

When enumerating entries, return the requests backend understands

To be able to map atom:IDs to backend requests, let the backend return
the mapping when enumerating the entries.

Do not output error when trying to parse XML data

Ignore if an entry cannot be read when enumerating files

Retrieve an entry if backend can tell it's not a feed

Return error if backend is not able to tell a feed from an entry

Added a .gitignore file to ignore building and built files

Return after returning an error

Convert GIOError too when converting from GError to AtomError

If GIO cannot enumerate directory, set error and return

Return NULL instead of an empty feed in case of a backend error

Avoid a crash if there is no index configured

Dummy IRI parsing. Needed to fix segfault bug, when freeing person's URI

Fix typo for AtomCtx type

Include AtomID header into main Atom header

Introducing AtomID, which is used in core, instead of IRI

Build iri directory before other directories

Library includes every module and sample main program links with it

GIO is the default backend for sample main program

Return a copy of the internal node, caller is the owner

If backend cannot enumerate entries, return 0 entries with NULL array

If entry or feed is NULL, so should be the resource

CGI frontend uses AtomResource instead of AtomEntry

Retrieve resource returns either an entry or a feed

Added AtomResource as a generalization for entries and feeds

Renamed retrieve_resource to retrieve_entry

Create feed using entries from backend

Get string from AtomFeed

Atom namespace is in a common header now

Generate feed with many entries

Distribute XML headers

Create a xml node from an AtomEntry

Modify interface to get string from entry

libxml2 may return document with null root node

If it is not possible to parse document, return NULL

AtomEntry requires AtomPerson

AtomEntry has some of the interesting nodes as properties

Reading AtomPerson from a XML node

URI property is of IRI type, not string

Create a XML node from an AtomPerson

Copy IRI when setting AtomPerson uri

Added more interface for IRI

You can set scheme and host part of IRIs now. You can also get it as a
string, which should be revised, because of the needed separators. You
can also make a copy of a IRI.

Include IRI header into AtomPerson header and this into main header

Added AtomPerson structure

Distribute headers in pkgincludedir instead of includedir

Copies error message from GError

Recover from errors when reading XML

Unused old Atom type variable in main

Fixes build with missing comma

Finished chaging some Atom into AtomEntry types

Registered implementation of enumerate_entries for GIO backend

Implement enumeration of entries for GIO backend

Does not unref a GFile when creating an Atom, do it in the caller

Given a GFile, return an Atom, so we can use it for enumeration

When enumerating/summarizing many entries into one feed, we may need to
read each entry. Making it easier to do this with a function and using
it for retrieving the resource itself.

Added backend interface to enumerate entries

Changed from Atom to AtomEntry and atom_ to atom_entry_

Merge branch 'master' into entry

Conflicts:

Makefile.am
atom/Makefile.am
atom/entry.c
configure.ac

Get atom entry implementation from libatom. Some changes needed in
headers and usage of it.

Moving atom entry implementation to merge it with atompub

AtomEntry is now an opaque structure and may be read from a file

Description of requirements for IRIs

Some comments about what need to be done for text constructs

Interface to retrieve data in a buffer and its size

Added function to create an atom entry with a namespace prefix

Atom namespace is now a macro

First commit of an atom format library

Autoconf and automake support, with license file. The interface is just
to create and delete an entry. It is not even published in a header. The
implementation uses libxml2. However, the interface should not expose
this and allow the implementation to change.

New error interface: migrated core, backends and frontends to it

Fixed leak in Atom entry

Does not leak memory with ctx and backend

Use new backend interface in main program

Functions to create new backend and usage of it in existing backends

Added a backend per context