/mandos/release

/* $Id$ */

 

/* PLEASE NOTE *

 * This file demonstrates how to use Avahi's core API, this is

 * the embeddable mDNS stack for embedded applications.

 * End user applications should *not* use this API and should use

 * the D-Bus or C APIs, please see

 * client-browse-services.c and glib-integration.c

 * 

 * I repeat, you probably do *not* want to use this example.

/***

  This file is part of avahi.

 

  avahi is free software; you can redistribute it and/or modify it

  under the terms of the GNU Lesser General Public License as

  published by the Free Software Foundation; either version 2.1 of the

  License, or (at your option) any later version.

 

  avahi is distributed in the hope that it will be useful, but WITHOUT

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General

  Public License for more details.

 

  You should have received a copy of the GNU Lesser General Public

  License along with avahi; if not, write to the Free Software

  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

  USA.

***/

#include <sys/types.h>          /* socket(), setsockopt(), inet_pton() */

#include <sys/socket.h>         /* socket(), setsockopt(), struct sockaddr_in6, struct in6_addr, inet_pton() */

#include <gnutls/gnutls.h>      /* ALL GNUTLS STUFF */

#include <gnutls/openpgp.h>     /* gnutls with openpgp stuff */

#ifndef CERT_ROOT

#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"

#endif

#define CERTFILE CERT_ROOT "openpgp-client.txt"

#define KEYFILE CERT_ROOT "openpgp-client-key.txt"

ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){

  size_t new_packet_capacity = 0;

  size_t new_packet_length = 0;

  gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);

  /* Decrypt data from the FILE pointer to the plaintext data buffer */

/*   gpgme_decrypt_result_t result; */

/*   result = gpgme_op_decrypt_result(ctx); */

/*   fprintf(stderr, "Unsupported algorithm: %s\n", result->unsupported_algorithm); */

/*   fprintf(stderr, "Wrong key usage: %d\n", result->wrong_key_usage); */

/*   if(result->file_name != NULL){ */

/*     fprintf(stderr, "File name: %s\n", result->file_name); */

/*   } */

/*   gpgme_recipient_t recipient; */

/*   recipient = result->recipients; */

/*   if(recipient){ */

/*     while(recipient != NULL){ */

/*       fprintf(stderr, "Public key algorithm: %s\n", */

/*            gpgme_pubkey_algo_name(recipient->pubkey_algo)); */

/*       fprintf(stderr, "Key ID: %s\n", recipient->keyid); */

/*       fprintf(stderr, "Secret key available: %s\n", */

/*            recipient->status == GPG_ERR_NO_SECKEY ? "No" : "Yes"); */

/*       recipient = recipient->next; */

/*     } */

/*   } */

 

  gpgme_data_seek(dh_plain, 0, SEEK_SET);

      *new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);

    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);

      /* If password is empty, then a incorrect error will be printed */

   /* Delete the GPGME plaintext data buffer */

void debuggnutls(int level, const char* string){

  /* Uncomment to enable full debuggin on the gnutls library */

  /*   gnutls_global_set_log_level(11); */

  /*   gnutls_global_set_log_function(debuggnutls); */

 

 

    fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));

 

    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);

      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",

       ret, CERTFILE, KEYFILE);

 

  //Gnutls server initialization

 

 

 

  // Gnutls session creation

    fprintf(stderr, "Error in gnutls session initialization: %s\n",

 

    fprintf(stderr, "Gnutls error: %s\n",

 

 

  gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);

void empty_log(AvahiLogLevel level, const char *txt){}

int start_mandos_communcation(char *ip, uint16_t port){

  struct in6_addr ip_addr;

 

  ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, "eth0", 5);

  if(tcp_sd < 0) {

    perror("setsockopt bindtodevice");

  memset(&to,0,sizeof(to));

  ret = inet_pton(AF_INET6, ip, &ip_addr);

  to.sin6_port = htons(port);

  to.sin6_scope_id = if_nametoindex("eth0");

    

  

  gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);

 

    fprintf(stderr, "\n*** Handshake failed ***\n");

    gnutls_perror (ret);

  //retrive password

        fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");

      buffer_length += ret;

 

    if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) == 0){

    } else {

      fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);

      free(decrypted_buffer);

 

  //shutdown procedure

    AVAHI_GCC_UNUSED AvahiIfIndex interface,

    AvahiStringList *txt,

    AvahiLookupResultFlags flags,

    assert(r);

 

    /* Called whenever a service has been resolved successfully or timed out */

 

    switch (event) {

        case AVAHI_RESOLVER_FAILURE:

            fprintf(stderr, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_server_errno(server)));

            break;

 

        case AVAHI_RESOLVER_FOUND: {

          char ip[AVAHI_ADDRESS_STR_MAX];

            avahi_address_snprint(ip, sizeof(ip), address);

            int ret = start_mandos_communcation(ip, port);

            if (ret == 0){

              exit(EXIT_SUCCESS);

            } else {

              exit(EXIT_FAILURE);

            }

        }

    avahi_s_service_resolver_free(r);

    assert(b);

 

    /* Called whenever a new services becomes available on the LAN or is removed from the LAN */

 

 

        case AVAHI_BROWSER_FAILURE:

            

            fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));

            avahi_simple_poll_quit(simple_poll);

            return;

 

        case AVAHI_BROWSER_NEW:

            /* We ignore the returned resolver object. In the callback

               function we free it. If the server is terminated before

               the callback function is called the server will free

               the resolver for us. */

            

            if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))

                fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));

            

            break;

 

        case AVAHI_BROWSER_REMOVE:

            break;

 

        case AVAHI_BROWSER_ALL_FOR_NOW:

        case AVAHI_BROWSER_CACHE_EXHAUSTED:

            break;

    int ret = 1;

    avahi_set_log_function(empty_log);

    srand(time(NULL));

        goto fail;

/*     /\* Set a unicast DNS server for wide area DNS-SD *\/ */

/*     avahi_address_parse("193.11.177.11", AVAHI_PROTO_UNSPEC, &config.wide_area_servers[0]); */

/*     config.n_wide_area_servers = 1; */

/*     config.enable_wide_area = 1; */

    

    server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);

    /* Check wether creating the server object succeeded */

        fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));

        goto fail;

    if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {

        fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));

        goto fail;

    ret = 0;

    

fail:

    return ret;