/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to plugins.d/password-request.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-29 05:53:59 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080829055359-wkdasnyxtylmnxus
* mandos.xml (EXAMPLE): Replaced all occurences of command name with
                        "&COMMANDNAME;".

* plugins.d/password-prompt.c (main): Improved some documentation
                                      strings.  Do perror() of
                                      tcgetattr() fails.  Add debug
                                      output if interrupted by signal.
                                      Loop over write() instead of
                                      using fwrite() when outputting
                                      password.  Add debug output if
                                      getline() returns 0, unless it
                                      was caused by a signal.  Add
                                      exit status code to debug
                                      output.

* plugins.d/password-prompt.xml: Changed all single quotes to double
                                 quotes for consistency.  Removed
                                 <?xml-stylesheet>.
  (ENTITY TIMESTAMP): New.  Automatically updated by Emacs time-stamp
                      by using Emacs local variables.
  (/refentry/refentryinfo/title): Changed to "Mandos Manual".
  (/refentry/refentryinfo/productname): Changed to "Mandos".
  (/refentry/refentryinfo/date): New; set to "&TIMESTAMP;".
  (/refentry/refentryinfo/copyright): Split copyright holders.
  (/refentry/refnamediv/refpurpose): Improved wording.
  (SYNOPSIS): Fix to use correct markup.  Add short options.
  (DESCRIPTION, OPTIONS): Improved wording.
  (OPTIONS): Improved wording.  Use more correct markup.  Document
             short options.
  (EXIT STATUS): Add text.
  (ENVIRONMENT): Document use of "cryptsource" and "crypttarget".
  (FILES): REMOVED.
  (BUGS): Add text.
  (EXAMPLE): Added some examples.
  (SECURITY): Added text.
  (SEE ALSO): Remove reference to mandos(8).  Add reference to
              crypttab(5).

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/password-request.c
32
32
#define _LARGEFILE_SOURCE
33
33
#define _FILE_OFFSET_BITS 64
34
34
 
35
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
 
35
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
36
36
 
37
 
#include <stdio.h>
38
 
#include <assert.h>
39
 
#include <stdlib.h>
40
 
#include <time.h>
41
 
#include <net/if.h>             /* if_nametoindex */
42
 
#include <sys/ioctl.h>          /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
43
 
                                   SIOCSIFFLAGS */
 
37
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
 
38
                                   stdout, ferror() */
 
39
#include <stdint.h>             /* uint16_t, uint32_t */
 
40
#include <stddef.h>             /* NULL, size_t, ssize_t */
 
41
#include <stdlib.h>             /* free(), EXIT_SUCCESS, EXIT_FAILURE,
 
42
                                   srand() */
 
43
#include <stdbool.h>            /* bool, true */
 
44
#include <string.h>             /* memset(), strcmp(), strlen(),
 
45
                                   strerror(), asprintf(), strcpy() */
 
46
#include <sys/ioctl.h>          /* ioctl */
 
47
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
 
48
                                   sockaddr_in6, PF_INET6,
 
49
                                   SOCK_STREAM, INET6_ADDRSTRLEN,
 
50
                                   uid_t, gid_t */
 
51
#include <inttypes.h>           /* PRIu16 */
 
52
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
 
53
                                   struct in6_addr, inet_pton(),
 
54
                                   connect() */
 
55
#include <assert.h>             /* assert() */
 
56
#include <errno.h>              /* perror(), errno */
 
57
#include <time.h>               /* time() */
44
58
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
45
 
                                   SIOCSIFFLAGS */
 
59
                                   SIOCSIFFLAGS, if_indextoname(),
 
60
                                   if_nametoindex(), IF_NAMESIZE */
 
61
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
 
62
                                   getuid(), getgid(), setuid(),
 
63
                                   setgid() */
 
64
#include <netinet/in.h>
 
65
#include <arpa/inet.h>          /* inet_pton(), htons */
 
66
#include <iso646.h>             /* not, and */
 
67
#include <argp.h>               /* struct argp_option, error_t, struct
 
68
                                   argp_state, struct argp,
 
69
                                   argp_parse(), ARGP_KEY_ARG,
 
70
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
46
71
 
 
72
/* Avahi */
 
73
/* All Avahi types, constants and functions
 
74
 Avahi*, avahi_*,
 
75
 AVAHI_* */
47
76
#include <avahi-core/core.h>
48
77
#include <avahi-core/lookup.h>
49
78
#include <avahi-core/log.h>
51
80
#include <avahi-common/malloc.h>
52
81
#include <avahi-common/error.h>
53
82
 
54
 
/* Mandos client part */
55
 
#include <sys/types.h>          /* socket(), inet_pton() */
56
 
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
57
 
                                   struct in6_addr, inet_pton() */
58
 
#include <gnutls/gnutls.h>      /* All GnuTLS stuff */
59
 
#include <gnutls/openpgp.h>     /* GnuTLS with openpgp stuff */
 
83
/* GnuTLS */
 
84
#include <gnutls/gnutls.h>      /* All GnuTLS types, constants and
 
85
                                   functions:
 
86
                                   gnutls_*
 
87
                                   init_gnutls_session(),
 
88
                                   GNUTLS_* */
 
89
#include <gnutls/openpgp.h>     /* gnutls_certificate_set_openpgp_key_file(),
 
90
                                   GNUTLS_OPENPGP_FMT_BASE64 */
60
91
 
61
 
#include <unistd.h>             /* close() */
62
 
#include <netinet/in.h>
63
 
#include <stdbool.h>            /* true */
64
 
#include <string.h>             /* memset */
65
 
#include <arpa/inet.h>          /* inet_pton() */
66
 
#include <iso646.h>             /* not */
67
 
#include <net/if.h>             /* IF_NAMESIZE */
68
 
#include <argp.h>               /* struct argp_option,
69
 
                                   struct argp_state, struct argp,
70
 
                                   argp_parse() */
71
92
/* GPGME */
72
 
#include <errno.h>              /* perror() */
73
 
#include <gpgme.h>
 
93
#include <gpgme.h>              /* All GPGME types, constants and
 
94
                                   functions:
 
95
                                   gpgme_*
 
96
                                   GPGME_PROTOCOL_OpenPGP,
 
97
                                   GPG_ERR_NO_* */
74
98
 
75
99
#define BUFFER_SIZE 256
76
100
 
77
101
bool debug = false;
78
102
static const char *keydir = "/conf/conf.d/mandos";
79
103
static const char mandos_protocol_version[] = "1";
80
 
const char *argp_program_version = "mandosclient 0.9";
 
104
const char *argp_program_version = "password-request 1.0";
81
105
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
82
106
 
83
107
/* Used for passing in values through the Avahi callback functions */
190
214
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
191
215
            gpgme_strsource(rc), gpgme_strerror(rc));
192
216
    plaintext_length = -1;
 
217
    if (debug){
 
218
      gpgme_decrypt_result_t result;
 
219
      result = gpgme_op_decrypt_result(ctx);
 
220
      if (result == NULL){
 
221
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
222
      } else {
 
223
        fprintf(stderr, "Unsupported algorithm: %s\n",
 
224
                result->unsupported_algorithm);
 
225
        fprintf(stderr, "Wrong key usage: %u\n",
 
226
                result->wrong_key_usage);
 
227
        if(result->file_name != NULL){
 
228
          fprintf(stderr, "File name: %s\n", result->file_name);
 
229
        }
 
230
        gpgme_recipient_t recipient;
 
231
        recipient = result->recipients;
 
232
        if(recipient){
 
233
          while(recipient != NULL){
 
234
            fprintf(stderr, "Public key algorithm: %s\n",
 
235
                    gpgme_pubkey_algo_name(recipient->pubkey_algo));
 
236
            fprintf(stderr, "Key ID: %s\n", recipient->keyid);
 
237
            fprintf(stderr, "Secret key available: %s\n",
 
238
                    recipient->status == GPG_ERR_NO_SECKEY
 
239
                    ? "No" : "Yes");
 
240
            recipient = recipient->next;
 
241
          }
 
242
        }
 
243
      }
 
244
    }
193
245
    goto decrypt_end;
194
246
  }
195
247
  
197
249
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
198
250
  }
199
251
  
200
 
  if (debug){
201
 
    gpgme_decrypt_result_t result;
202
 
    result = gpgme_op_decrypt_result(ctx);
203
 
    if (result == NULL){
204
 
      fprintf(stderr, "gpgme_op_decrypt_result failed\n");
205
 
    } else {
206
 
      fprintf(stderr, "Unsupported algorithm: %s\n",
207
 
              result->unsupported_algorithm);
208
 
      fprintf(stderr, "Wrong key usage: %d\n",
209
 
              result->wrong_key_usage);
210
 
      if(result->file_name != NULL){
211
 
        fprintf(stderr, "File name: %s\n", result->file_name);
212
 
      }
213
 
      gpgme_recipient_t recipient;
214
 
      recipient = result->recipients;
215
 
      if(recipient){
216
 
        while(recipient != NULL){
217
 
          fprintf(stderr, "Public key algorithm: %s\n",
218
 
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
219
 
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
220
 
          fprintf(stderr, "Secret key available: %s\n",
221
 
                  recipient->status == GPG_ERR_NO_SECKEY
222
 
                  ? "No" : "Yes");
223
 
          recipient = recipient->next;
224
 
        }
225
 
      }
226
 
    }
227
 
  }
228
 
  
229
252
  /* Seek back to the beginning of the GPGME plaintext data buffer */
230
253
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
231
254
    perror("pgpme_data_seek");
278
301
}
279
302
 
280
303
static const char * safer_gnutls_strerror (int value) {
281
 
  const char *ret = gnutls_strerror (value);
 
304
  const char *ret = gnutls_strerror (value); /* Spurious warning */
282
305
  if (ret == NULL)
283
306
    ret = "(unknown)";
284
307
  return ret;
291
314
}
292
315
 
293
316
static int init_gnutls_global(mandos_context *mc,
294
 
                              const char *pubkeyfile,
295
 
                              const char *seckeyfile){
 
317
                              const char *pubkeyfilename,
 
318
                              const char *seckeyfilename){
296
319
  int ret;
297
320
  
298
321
  if(debug){
299
322
    fprintf(stderr, "Initializing GnuTLS\n");
300
323
  }
301
 
 
302
 
  if ((ret = gnutls_global_init ())
303
 
      != GNUTLS_E_SUCCESS) {
 
324
  
 
325
  ret = gnutls_global_init();
 
326
  if (ret != GNUTLS_E_SUCCESS) {
304
327
    fprintf (stderr, "GnuTLS global_init: %s\n",
305
328
             safer_gnutls_strerror(ret));
306
329
    return -1;
315
338
  }
316
339
  
317
340
  /* OpenPGP credentials */
318
 
  if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
319
 
      != GNUTLS_E_SUCCESS) {
320
 
    fprintf (stderr, "GnuTLS memory error: %s\n",
 
341
  gnutls_certificate_allocate_credentials(&mc->cred);
 
342
  if (ret != GNUTLS_E_SUCCESS){
 
343
    fprintf (stderr, "GnuTLS memory error: %s\n", /* Spurious
 
344
                                                     warning */
321
345
             safer_gnutls_strerror(ret));
322
346
    gnutls_global_deinit ();
323
347
    return -1;
325
349
  
326
350
  if(debug){
327
351
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
328
 
            " and keyfile %s as GnuTLS credentials\n", pubkeyfile,
329
 
            seckeyfile);
 
352
            " and keyfile %s as GnuTLS credentials\n", pubkeyfilename,
 
353
            seckeyfilename);
330
354
  }
331
355
  
332
356
  ret = gnutls_certificate_set_openpgp_key_file
333
 
    (mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
 
357
    (mc->cred, pubkeyfilename, seckeyfilename,
 
358
     GNUTLS_OPENPGP_FMT_BASE64);
334
359
  if (ret != GNUTLS_E_SUCCESS) {
335
360
    fprintf(stderr,
336
361
            "Error[%d] while reading the OpenPGP key pair ('%s',"
337
 
            " '%s')\n", ret, pubkeyfile, seckeyfile);
 
362
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
338
363
    fprintf(stdout, "The GnuTLS error is: %s\n",
339
364
            safer_gnutls_strerror(ret));
340
365
    goto globalfail;
360
385
 
361
386
 globalfail:
362
387
 
363
 
  gnutls_certificate_free_credentials (mc->cred);
364
 
  gnutls_global_deinit ();
 
388
  gnutls_certificate_free_credentials(mc->cred);
 
389
  gnutls_global_deinit();
365
390
  return -1;
366
391
 
367
392
}
432
457
  }
433
458
  
434
459
  if(debug){
435
 
    fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
436
 
            ip, port);
 
460
    fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
 
461
            "\n", ip, port);
437
462
  }
438
463
  
439
464
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
450
475
    fprintf(stderr, "Binding to interface %s\n", interface);
451
476
  }
452
477
  
453
 
  memset(&to,0,sizeof(to));     /* Spurious warning */
 
478
  memset(&to, 0, sizeof(to));
454
479
  to.in6.sin6_family = AF_INET6;
455
480
  /* It would be nice to have a way to detect if we were passed an
456
481
     IPv4 address here.   Now we assume an IPv6 address. */
463
488
    fprintf(stderr, "Bad address: %s\n", ip);
464
489
    return -1;
465
490
  }
466
 
  to.in6.sin6_port = htons(port);       /* Spurious warning */
 
491
  to.in6.sin6_port = htons(port); /* Spurious warning */
467
492
  
468
493
  to.in6.sin6_scope_id = (uint32_t)if_index;
469
494
  
470
495
  if(debug){
471
 
    fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
 
496
    fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
 
497
            port);
472
498
    char addrstr[INET6_ADDRSTRLEN] = "";
473
499
    if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
474
500
                 sizeof(addrstr)) == NULL){
515
541
  }
516
542
  
517
543
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
518
 
  
519
 
  ret = gnutls_handshake (session);
 
544
 
 
545
  do{
 
546
    ret = gnutls_handshake (session);
 
547
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
520
548
  
521
549
  if (ret != GNUTLS_E_SUCCESS){
522
550
    if(debug){
554
582
      case GNUTLS_E_AGAIN:
555
583
        break;
556
584
      case GNUTLS_E_REHANDSHAKE:
557
 
        ret = gnutls_handshake (session);
 
585
        do{
 
586
          ret = gnutls_handshake (session);
 
587
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
558
588
        if (ret < 0){
559
589
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
560
590
          gnutls_perror (ret);
605
635
    } else {
606
636
      retval = -1;
607
637
    }
 
638
  } else {
 
639
    retval = -1;
608
640
  }
609
641
  
610
642
  /* Shutdown procedure */
631
663
                             flags,
632
664
                             void* userdata) {
633
665
  mandos_context *mc = userdata;
634
 
  assert(r);                    /* Spurious warning */
 
666
  assert(r);
635
667
  
636
668
  /* Called whenever a service has been resolved successfully or
637
669
     timed out */
649
681
      char ip[AVAHI_ADDRESS_STR_MAX];
650
682
      avahi_address_snprint(ip, sizeof(ip), address);
651
683
      if(debug){
652
 
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %d) on"
653
 
                " port %d\n", name, host_name, ip, interface, port);
 
684
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
 
685
                PRIu16 ") on port %d\n", name, host_name, ip,
 
686
                interface, port);
654
687
      }
655
688
      int ret = start_mandos_communication(ip, port, interface, mc);
656
689
      if (ret == 0){
657
 
        exit(EXIT_SUCCESS);
 
690
        avahi_simple_poll_quit(mc->simple_poll);
658
691
      }
659
692
    }
660
693
  }
672
705
                             flags,
673
706
                             void* userdata) {
674
707
  mandos_context *mc = userdata;
675
 
  assert(b);                    /* Spurious warning */
 
708
  assert(b);
676
709
  
677
710
  /* Called whenever a new services becomes available on the LAN or
678
711
     is removed from the LAN */
714
747
 
715
748
/* Combines file name and path and returns the malloced new
716
749
   string. some sane checks could/should be added */
717
 
static const char *combinepath(const char *first, const char *second){
718
 
  size_t f_len = strlen(first);
719
 
  size_t s_len = strlen(second);
720
 
  char *tmp = malloc(f_len + s_len + 2);
721
 
  if (tmp == NULL){
 
750
static char *combinepath(const char *first, const char *second){
 
751
  char *tmp;
 
752
  int ret = asprintf(&tmp, "%s/%s", first, second);
 
753
  if(ret < 0){
722
754
    return NULL;
723
755
  }
724
 
  if(f_len > 0){
725
 
    memcpy(tmp, first, f_len);  /* Spurious warning */
726
 
  }
727
 
  tmp[f_len] = '/';
728
 
  if(s_len > 0){
729
 
    memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
730
 
  }
731
 
  tmp[f_len + 1 + s_len] = '\0';
732
756
  return tmp;
733
757
}
734
758
 
745
769
    gid_t gid;
746
770
    char *connect_to = NULL;
747
771
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
748
 
    const char *pubkeyfile = "pubkey.txt";
749
 
    const char *seckeyfile = "seckey.txt";
 
772
    char *pubkeyfilename = NULL;
 
773
    char *seckeyfilename = NULL;
 
774
    const char *pubkeyname = "pubkey.txt";
 
775
    const char *seckeyname = "seckey.txt";
750
776
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
751
777
                          .dh_bits = 1024, .priority = "SECURE256"};
752
778
    bool gnutls_initalized = false;
804
830
          keydir = arg;
805
831
          break;
806
832
        case 's':
807
 
          seckeyfile = arg;
 
833
          seckeyname = arg;
808
834
          break;
809
835
        case 'p':
810
 
          pubkeyfile = arg;
 
836
          pubkeyname = arg;
811
837
          break;
812
838
        case 129:
813
839
          errno = 0;
822
848
          break;
823
849
        case ARGP_KEY_ARG:
824
850
          argp_usage (state);
 
851
        case ARGP_KEY_END:
825
852
          break;
826
 
          case ARGP_KEY_END:
827
 
            break;
828
853
        default:
829
854
          return ARGP_ERR_UNKNOWN;
830
855
        }
835
860
                           .args_doc = "",
836
861
                           .doc = "Mandos client -- Get and decrypt"
837
862
                           " passwords from mandos server" };
838
 
      argp_parse (&argp, argc, argv, 0, 0, NULL);
 
863
      ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
 
864
      if (ret == ARGP_ERR_UNKNOWN){
 
865
        fprintf(stderr, "Unknown error while parsing arguments\n");
 
866
        exitcode = EXIT_FAILURE;
 
867
        goto end;
 
868
      }
839
869
    }
840
870
      
841
 
    pubkeyfile = combinepath(keydir, pubkeyfile);
842
 
    if (pubkeyfile == NULL){
 
871
    pubkeyfilename = combinepath(keydir, pubkeyname);
 
872
    if (pubkeyfilename == NULL){
843
873
      perror("combinepath");
844
874
      exitcode = EXIT_FAILURE;
845
875
      goto end;
846
876
    }
847
877
    
848
 
    seckeyfile = combinepath(keydir, seckeyfile);
849
 
    if (seckeyfile == NULL){
 
878
    seckeyfilename = combinepath(keydir, seckeyname);
 
879
    if (seckeyfilename == NULL){
850
880
      perror("combinepath");
 
881
      exitcode = EXIT_FAILURE;
851
882
      goto end;
852
883
    }
853
884
 
854
 
    ret = init_gnutls_global(&mc, pubkeyfile, seckeyfile);
 
885
    ret = init_gnutls_global(&mc, pubkeyfilename, seckeyfilename);
855
886
    if (ret == -1){
856
 
      fprintf(stderr, "init_gnutls_global\n");
 
887
      fprintf(stderr, "init_gnutls_global failed\n");
 
888
      exitcode = EXIT_FAILURE;
857
889
      goto end;
858
890
    } else {
859
891
      gnutls_initalized = true;
860
892
    }
861
 
 
 
893
    
 
894
    /* If the interface is down, bring it up */
 
895
    {
 
896
      sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
897
      if(sd < 0) {
 
898
        perror("socket");
 
899
        exitcode = EXIT_FAILURE;
 
900
        goto end;
 
901
      }
 
902
      strcpy(network.ifr_name, interface);
 
903
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
904
      if(ret == -1){
 
905
        perror("ioctl SIOCGIFFLAGS");
 
906
        exitcode = EXIT_FAILURE;
 
907
        goto end;
 
908
      }
 
909
      if((network.ifr_flags & IFF_UP) == 0){
 
910
        network.ifr_flags |= IFF_UP;
 
911
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
912
        if(ret == -1){
 
913
          perror("ioctl SIOCSIFFLAGS");
 
914
          exitcode = EXIT_FAILURE;
 
915
          goto end;
 
916
        }
 
917
      }
 
918
      close(sd);
 
919
    }
 
920
    
862
921
    uid = getuid();
863
922
    gid = getgid();
864
 
 
 
923
    
865
924
    ret = setuid(uid);
866
925
    if (ret == -1){
867
926
      perror("setuid");
905
964
      goto end;
906
965
    }
907
966
    
908
 
    /* If the interface is down, bring it up */
909
 
    {
910
 
      sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
911
 
      if(sd < 0) {
912
 
        perror("socket");
913
 
        exitcode = EXIT_FAILURE;
914
 
        goto end;
915
 
      }
916
 
      strcpy(network.ifr_name, interface); /* Spurious warning */
917
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
918
 
      if(ret == -1){
919
 
        perror("ioctl SIOCGIFFLAGS");
920
 
        exitcode = EXIT_FAILURE;
921
 
        goto end;
922
 
      }
923
 
      if((network.ifr_flags & IFF_UP) == 0){
924
 
        network.ifr_flags |= IFF_UP;
925
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
926
 
        if(ret == -1){
927
 
          perror("ioctl SIOCSIFFLAGS");
928
 
          exitcode = EXIT_FAILURE;
929
 
          goto end;
930
 
        }
931
 
      }
932
 
      close(sd);
933
 
    }
934
 
    
935
967
    if (not debug){
936
968
      avahi_set_log_function(empty_log);
937
969
    }
1009
1041
 
1010
1042
    if (mc.simple_poll != NULL)
1011
1043
        avahi_simple_poll_free(mc.simple_poll);
1012
 
    free(pubkeyfile);
1013
 
    free(seckeyfile);
 
1044
    free(pubkeyfilename);
 
1045
    free(seckeyfilename);
1014
1046
 
1015
1047
    if (gnutls_initalized){
1016
 
      gnutls_certificate_free_credentials (mc.cred);
 
1048
      gnutls_certificate_free_credentials(mc.cred);
1017
1049
      gnutls_global_deinit ();
1018
1050
    }
1019
1051