path: root/src/libdisfluid/main.c

#include <config.h>

#define STREQ(a, b) (strcmp ((a), (b)) == 0)
#define STRNEQ(a, b) (! (STREQ (a, b)))

#include <errno.h>
#include <fcntl.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
#include "gettext.h"
#include "relocatable.h"
#include "attribute.h"
#include <disfluid.h>

#define _(String) dgettext (PACKAGE, (String))
#define N_(String) (String)

#include "disfluid-authors.h"
#include "disfluid-cache-entry.h"
#include "disfluid-cache-entry-key.h"
#include "disfluid-cache-entry-hash.h"
#include "disfluid-tests.h"
#include "disfluid-version.h"

const char *
disfluid_version (void)
{
  return version ();
}

int
disfluid_is_nightly (void)
{
  return is_nightly ();
}

const char *
disfluid_website (void)
{
  return website ();
}

const char *
disfluid_whats_new (void)
{
  return whats_new ();
}

const char *
disfluid_major_version (void)
{
  return major_version ();
}

char *
disfluid_run_tests (size_t *n_tests, size_t *n_errors)
{
  return run_tests (n_tests, n_errors);
}

size_t
disfluid_count_authors (void)
{
  return count_authors ();
}

const char *
disfluid_author_name (size_t i)
{
  return author_name (i);
}

const char *
disfluid_author_email (size_t i)
{
  return author_email (i);
}

const char *
disfluid_author_uri (size_t i)
{
  return author_uri (i);
}

int
disfluid_author_is_developer (size_t i)
{
  return author_is_developer (i);
}

int
disfluid_author_is_designer (size_t i)
{
  return author_is_designer (i);
}

int
disfluid_author_is_artist (size_t i)
{
  return author_is_artist (i);
}

int
disfluid_author_is_documenter (size_t i)
{
  return author_is_documenter (i);
}

const char *
disfluid_translation_credits (void)
{
  return translation_credits ();
}

size_t
disfluid_cache_entry_size (size_t max_key, size_t max_header, size_t max_body)
{
  return cache_entry_size (max_key, max_header, max_body);
}

size_t
disfluid_cache_entry_alignment (void)
{
  return cache_entry_alignment ();
}

void
disfluid_cache_entry_init (struct disfluid_cache_entry *entry,
			   size_t max_key, size_t max_header, size_t max_body)
{
  cache_entry_init (entry, max_key, max_header, max_body);
}

void
disfluid_cache_entry_minimum_size (const struct disfluid_cache_entry *entry,
				   size_t *min_key, size_t *min_header,
				   size_t *min_body)
{
  cache_entry_minimum_size (entry, min_key, min_header, min_body);
}

int
disfluid_cache_entry_copy (struct disfluid_cache_entry *restrict dest,
			   const struct disfluid_cache_entry *restrict src)
{
  return cache_entry_copy (dest, src);
}

struct disfluid_cache_entry *
disfluid_cache_entry_alloc (size_t max_key, size_t max_header,
			    size_t max_body)
{
  return cache_entry_alloc (max_key, max_header, max_body);
}

struct disfluid_cache_entry *
disfluid_cache_entry_dup (const struct disfluid_cache_entry *entry)
{
  return cache_entry_dup (entry);
}

void
disfluid_cache_entry_free (struct disfluid_cache_entry *entry)
{
  return cache_entry_free (entry);
}

void
disfluid_cache_entry_set_request_date (struct disfluid_cache_entry *entry,
				       const struct timespec *date)
{
  cache_entry_set_request_date (entry, date);
}

void
disfluid_cache_entry_set_response_date (struct disfluid_cache_entry *entry,
					const struct timespec *date)
{
  cache_entry_set_response_date (entry, date);
}

void
disfluid_cache_entry_invalidate (struct disfluid_cache_entry *entry)
{
  cache_entry_invalidate (entry);
}

void
disfluid_cache_entry_set_invalidated (struct disfluid_cache_entry *entry,
				      int invalidated)
{
  cache_entry_set_invalidated (entry, invalidated);
}

int
disfluid_cache_entry_set_key (struct disfluid_cache_entry *entry,
			      const char *key)
{
  return cache_entry_set_key (entry, key);
}

int
disfluid_cache_entry_set_response_header (struct disfluid_cache_entry *entry,
					  const char *header)
{
  return cache_entry_set_response_header (entry, header);
}

int
disfluid_cache_entry_set_response_body (struct disfluid_cache_entry *entry,
					size_t body_length, const char *body)
{
  return cache_entry_set_response_body (entry, body_length, body);
}

void
disfluid_cache_entry_get_request_date (const struct disfluid_cache_entry
				       *entry, struct timespec *date)
{
  cache_entry_get_request_date (entry, date);
}

void
disfluid_cache_entry_get_response_date (const struct disfluid_cache_entry
					*entry, struct timespec *date)
{
  cache_entry_get_response_date (entry, date);
}

int
disfluid_cache_entry_is_invalidated (const struct disfluid_cache_entry *entry)
{
  return cache_entry_is_invalidated (entry);
}

int
disfluid_cache_entry_load (struct disfluid_cache_entry *entry,
			   int load_key,
			   int load_header,
			   int load_body,
			   ssize_t (*read_impl) (void *, void *, size_t),
			   int (*skip) (void *, size_t), void *context)
{
  return cache_entry_load (entry, load_key, load_header, load_body, read_impl,
			   skip, context);
}

int
disfluid_cache_entry_save (const struct disfluid_cache_entry *entry,
			   ssize_t (*write_impl) (void *, const void *,
						  size_t), void *context)
{
  return cache_entry_save (entry, write_impl, context);
}

int
disfluid_cache_entry_read (struct disfluid_cache_entry *entry,
			   int read_key,
			   int read_header, int read_body, int fd)
{
  return cache_entry_read (entry, read_key, read_header, read_body, fd);
}

int
disfluid_cache_entry_fread (struct disfluid_cache_entry *entry,
			    int read_key,
			    int read_header, int read_body, FILE * f)
{
  return cache_entry_fread (entry, read_key, read_header, read_body, f);
}

int
disfluid_cache_entry_write (const struct disfluid_cache_entry *entry, int fd)
{
  return cache_entry_write (entry, fd);
}

int
disfluid_cache_entry_fwrite (const struct disfluid_cache_entry *entry,
			     FILE * f)
{
  return cache_entry_fwrite (entry, f);
}

int
disfluid_compute_cache_key (const char *request_scheme,
			    const char *request_header,
			    const char *response_header,
			    size_t max_key, char *key)
{
  return compute_cache_key (request_scheme, request_header, response_header,
			    max_key, key);
}

int
disfluid_hash_primary_cache_key (const char *method,
				 const char *uri,
				 const char *password,
				 size_t password_length,
				 size_t max_hash, char *hash)
{
  return hash_primary_cache_key (method, uri, password, password_length,
				 max_hash, hash);
}