/mandos/release

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

« back to all changes in this revision

Viewing changes to plugins.d/mandos-client.c

  • Committer: Teddy Hogeborn
  • Date: 2014-07-25 22:44:20 UTC
  • mto: (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 321.
  • Revision ID: teddy@recompile.se-20140725224420-4a5ct2ptt0hsc92z
Require Python 2.7.

This is in preparation for the eventual move to Python 3, which will
happen as soon as all Python modules required by Mandos are available.
The mandos-ctl and mandos-monitor programs are already portable
between Python 2.6 and Python 3 without changes; this change will
bring the requirement up to Python 2.7.

* INSTALL (Prerequisites/Libraries/Mandos Server): Document
                                                   requirement of
                                                   Python 2.7; remove
                                                   Python-argparse
                                                   which is in the
                                                   Python 2.7 standard
                                                   library.
* debian/control (Source: mandos/Build-Depends-Indep): Depend on
                                                       exactly the
                                                       python2.7
                                                       package and all
                                                       the Python 2.7
                                                       versions of the
                                                       python modules.
  (Package: mandos/Depends): - '' - but still depend on python (<=2.7)
                            and the generic versions of the Python
                            modules; this is for mandos-ctl and
                            mandos-monitor, both of which are
                            compatible with Python 3, and use
                            #!/usr/bin/python.
* mandos: Use #!/usr/bin/python2.7 instead of #!/usr/bin/python.

Show diffs side-by-side

added added

removed removed

Lines of Context:
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
11
 * Everything else is
12
 
 * Copyright © 2008-2011 Teddy Hogeborn
13
 
 * Copyright © 2008-2011 Björn Påhlsson
 
12
 * Copyright © 2008-2014 Teddy Hogeborn
 
13
 * Copyright © 2008-2014 Björn Påhlsson
14
14
 * 
15
15
 * This program is free software: you can redistribute it and/or
16
16
 * modify it under the terms of the GNU General Public License as
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
33
#ifndef _LARGEFILE_SOURCE
34
34
#define _LARGEFILE_SOURCE
35
 
#endif
 
35
#endif  /* not _LARGEFILE_SOURCE */
36
36
#ifndef _FILE_OFFSET_BITS
37
37
#define _FILE_OFFSET_BITS 64
38
 
#endif
 
38
#endif  /* not _FILE_OFFSET_BITS */
39
39
 
40
40
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
41
41
 
42
42
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
43
 
                                   stdout, ferror(), remove() */
44
 
#include <stdint.h>             /* uint16_t, uint32_t */
 
43
                                   stdout, ferror() */
 
44
#include <stdint.h>             /* uint16_t, uint32_t, intptr_t */
45
45
#include <stddef.h>             /* NULL, size_t, ssize_t */
46
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
47
47
                                   strtof(), abort() */
55
55
                                   opendir(), DIR */
56
56
#include <sys/stat.h>           /* open(), S_ISREG */
57
57
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
58
 
                                   inet_pton(), connect() */
59
 
#include <fcntl.h>              /* open() */
 
58
                                   inet_pton(), connect(),
 
59
                                   getnameinfo() */
 
60
#include <fcntl.h>              /* open(), unlinkat() */
60
61
#include <dirent.h>             /* opendir(), struct dirent, readdir()
61
62
                                 */
62
63
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
63
64
                                   strtoimax() */
64
 
#include <assert.h>             /* assert() */
65
65
#include <errno.h>              /* perror(), errno,
66
66
                                   program_invocation_short_name */
67
67
#include <time.h>               /* nanosleep(), time(), sleep() */
73
73
                                */
74
74
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
75
75
                                   getuid(), getgid(), seteuid(),
76
 
                                   setgid(), pause(), _exit() */
77
 
#include <arpa/inet.h>          /* inet_pton(), htons, inet_ntop() */
 
76
                                   setgid(), pause(), _exit(),
 
77
                                   unlinkat() */
 
78
#include <arpa/inet.h>          /* inet_pton(), htons() */
78
79
#include <iso646.h>             /* not, or, and */
79
80
#include <argp.h>               /* struct argp_option, error_t, struct
80
81
                                   argp_state, struct argp,
88
89
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
89
90
                                   WEXITSTATUS(), WTERMSIG() */
90
91
#include <grp.h>                /* setgroups() */
 
92
#include <argz.h>               /* argz_add_sep(), argz_next(),
 
93
                                   argz_delete(), argz_append(),
 
94
                                   argz_stringify(), argz_add(),
 
95
                                   argz_count() */
 
96
#include <netdb.h>              /* getnameinfo(), NI_NUMERICHOST,
 
97
                                   EAI_SYSTEM, gai_strerror() */
91
98
 
92
99
#ifdef __linux__
93
100
#include <sys/klog.h>           /* klogctl() */
135
142
static const char sys_class_net[] = "/sys/class/net";
136
143
char *connect_to = NULL;
137
144
const char *hookdir = HOOKDIR;
 
145
int hookdir_fd = -1;
 
146
uid_t uid = 65534;
 
147
gid_t gid = 65534;
138
148
 
139
149
/* Doubly linked list that need to be circularly linked when used */
140
150
typedef struct server{
141
151
  const char *ip;
142
 
  uint16_t port;
 
152
  in_port_t port;
143
153
  AvahiIfIndex if_index;
144
154
  int af;
145
155
  struct timespec last_seen;
149
159
 
150
160
/* Used for passing in values through the Avahi callback functions */
151
161
typedef struct {
152
 
  AvahiSimplePoll *simple_poll;
153
162
  AvahiServer *server;
154
163
  gnutls_certificate_credentials_t cred;
155
164
  unsigned int dh_bits;
157
166
  const char *priority;
158
167
  gpgme_ctx_t ctx;
159
168
  server *current_server;
 
169
  char *interfaces;
 
170
  size_t interfaces_size;
160
171
} mandos_context;
161
172
 
162
 
/* global context so signal handler can reach it*/
163
 
mandos_context mc = { .simple_poll = NULL, .server = NULL,
164
 
                      .dh_bits = 1024, .priority = "SECURE256"
165
 
                      ":!CTYPE-X.509:+CTYPE-OPENPGP",
166
 
                      .current_server = NULL };
 
173
/* global so signal handler can reach it*/
 
174
AvahiSimplePoll *simple_poll;
167
175
 
168
176
sig_atomic_t quit_now = 0;
169
177
int signal_received = 0;
170
178
 
171
179
/* Function to use when printing errors */
172
180
void perror_plus(const char *print_text){
 
181
  int e = errno;
173
182
  fprintf(stderr, "Mandos plugin %s: ",
174
183
          program_invocation_short_name);
 
184
  errno = e;
175
185
  perror(print_text);
176
186
}
177
187
 
 
188
__attribute__((format (gnu_printf, 2, 3), nonnull))
178
189
int fprintf_plus(FILE *stream, const char *format, ...){
179
190
  va_list ap;
180
191
  va_start (ap, format);
181
192
  
182
193
  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
183
194
                             program_invocation_short_name));
184
 
  return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
 
195
  return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
185
196
}
186
197
 
187
198
/*
189
200
 * bytes. "buffer_capacity" is how much is currently allocated,
190
201
 * "buffer_length" is how much is already used.
191
202
 */
 
203
__attribute__((nonnull, warn_unused_result))
192
204
size_t incbuffer(char **buffer, size_t buffer_length,
193
205
                 size_t buffer_capacity){
194
206
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
195
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
196
 
    if(buffer == NULL){
 
207
    char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
208
    if(new_buf == NULL){
 
209
      int old_errno = errno;
 
210
      free(*buffer);
 
211
      errno = old_errno;
 
212
      *buffer = NULL;
197
213
      return 0;
198
214
    }
 
215
    *buffer = new_buf;
199
216
    buffer_capacity += BUFFER_SIZE;
200
217
  }
201
218
  return buffer_capacity;
202
219
}
203
220
 
204
221
/* Add server to set of servers to retry periodically */
205
 
int add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
206
 
               int af){
 
222
__attribute__((nonnull, warn_unused_result))
 
223
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
 
224
                int af, server **current_server){
207
225
  int ret;
208
226
  server *new_server = malloc(sizeof(server));
209
227
  if(new_server == NULL){
210
228
    perror_plus("malloc");
211
 
    return -1;
 
229
    return false;
212
230
  }
213
231
  *new_server = (server){ .ip = strdup(ip),
214
232
                          .port = port,
216
234
                          .af = af };
217
235
  if(new_server->ip == NULL){
218
236
    perror_plus("strdup");
219
 
    return -1;
 
237
    free(new_server);
 
238
    return false;
 
239
  }
 
240
  ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
 
241
  if(ret == -1){
 
242
    perror_plus("clock_gettime");
 
243
#ifdef __GNUC__
 
244
#pragma GCC diagnostic push
 
245
#pragma GCC diagnostic ignored "-Wcast-qual"
 
246
#endif
 
247
    free((char *)(new_server->ip));
 
248
#ifdef __GNUC__
 
249
#pragma GCC diagnostic pop
 
250
#endif
 
251
    free(new_server);
 
252
    return false;
220
253
  }
221
254
  /* Special case of first server */
222
 
  if (mc.current_server == NULL){
 
255
  if(*current_server == NULL){
223
256
    new_server->next = new_server;
224
257
    new_server->prev = new_server;
225
 
    mc.current_server = new_server;
226
 
  /* Place the new server last in the list */
 
258
    *current_server = new_server;
227
259
  } else {
228
 
    new_server->next = mc.current_server;
229
 
    new_server->prev = mc.current_server->prev;
 
260
    /* Place the new server last in the list */
 
261
    new_server->next = *current_server;
 
262
    new_server->prev = (*current_server)->prev;
230
263
    new_server->prev->next = new_server;
231
 
    mc.current_server->prev = new_server;
232
 
  }
233
 
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
234
 
  if(ret == -1){
235
 
    perror_plus("clock_gettime");
236
 
    return -1;
237
 
  }
238
 
  return 0;
 
264
    (*current_server)->prev = new_server;
 
265
  }
 
266
  return true;
239
267
}
240
268
 
241
269
/* 
242
270
 * Initialize GPGME.
243
271
 */
244
 
static bool init_gpgme(const char *seckey, const char *pubkey,
245
 
                       const char *tempdir){
 
272
__attribute__((nonnull, warn_unused_result))
 
273
static bool init_gpgme(const char * const seckey,
 
274
                       const char * const pubkey,
 
275
                       const char * const tempdir,
 
276
                       mandos_context *mc){
246
277
  gpgme_error_t rc;
247
278
  gpgme_engine_info_t engine_info;
248
279
  
249
 
  
250
280
  /*
251
281
   * Helper function to insert pub and seckey to the engine keyring.
252
282
   */
253
 
  bool import_key(const char *filename){
 
283
  bool import_key(const char * const filename){
254
284
    int ret;
255
285
    int fd;
256
286
    gpgme_data_t pgp_data;
268
298
      return false;
269
299
    }
270
300
    
271
 
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
301
    rc = gpgme_op_import(mc->ctx, pgp_data);
272
302
    if(rc != GPG_ERR_NO_ERROR){
273
303
      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
274
304
                   gpgme_strsource(rc), gpgme_strerror(rc));
318
348
  }
319
349
  
320
350
  /* Create new GPGME "context" */
321
 
  rc = gpgme_new(&(mc.ctx));
 
351
  rc = gpgme_new(&(mc->ctx));
322
352
  if(rc != GPG_ERR_NO_ERROR){
323
353
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
324
354
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
337
367
 * Decrypt OpenPGP data.
338
368
 * Returns -1 on error
339
369
 */
 
370
__attribute__((nonnull, warn_unused_result))
340
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
341
372
                                  size_t crypto_size,
342
 
                                  char **plaintext){
 
373
                                  char **plaintext,
 
374
                                  mandos_context *mc){
343
375
  gpgme_data_t dh_crypto, dh_plain;
344
376
  gpgme_error_t rc;
345
377
  ssize_t ret;
371
403
  
372
404
  /* Decrypt data from the cryptotext data buffer to the plaintext
373
405
     data buffer */
374
 
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
406
  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
375
407
  if(rc != GPG_ERR_NO_ERROR){
376
408
    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
377
409
                 gpgme_strsource(rc), gpgme_strerror(rc));
378
410
    plaintext_length = -1;
379
411
    if(debug){
380
412
      gpgme_decrypt_result_t result;
381
 
      result = gpgme_op_decrypt_result(mc.ctx);
 
413
      result = gpgme_op_decrypt_result(mc->ctx);
382
414
      if(result == NULL){
383
415
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
384
416
      } else {
461
493
  return plaintext_length;
462
494
}
463
495
 
464
 
static const char * safer_gnutls_strerror(int value){
465
 
  const char *ret = gnutls_strerror(value); /* Spurious warning from
466
 
                                               -Wunreachable-code */
 
496
__attribute__((warn_unused_result))
 
497
static const char *safer_gnutls_strerror(int value){
 
498
  const char *ret = gnutls_strerror(value);
467
499
  if(ret == NULL)
468
500
    ret = "(unknown)";
469
501
  return ret;
470
502
}
471
503
 
472
504
/* GnuTLS log function callback */
 
505
__attribute__((nonnull))
473
506
static void debuggnutls(__attribute__((unused)) int level,
474
507
                        const char* string){
475
508
  fprintf_plus(stderr, "GnuTLS: %s", string);
476
509
}
477
510
 
 
511
__attribute__((nonnull, warn_unused_result))
478
512
static int init_gnutls_global(const char *pubkeyfilename,
479
 
                              const char *seckeyfilename){
 
513
                              const char *seckeyfilename,
 
514
                              mandos_context *mc){
480
515
  int ret;
481
516
  
482
517
  if(debug){
499
534
  }
500
535
  
501
536
  /* OpenPGP credentials */
502
 
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
537
  ret = gnutls_certificate_allocate_credentials(&mc->cred);
503
538
  if(ret != GNUTLS_E_SUCCESS){
504
539
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
505
540
                 safer_gnutls_strerror(ret));
515
550
  }
516
551
  
517
552
  ret = gnutls_certificate_set_openpgp_key_file
518
 
    (mc.cred, pubkeyfilename, seckeyfilename,
 
553
    (mc->cred, pubkeyfilename, seckeyfilename,
519
554
     GNUTLS_OPENPGP_FMT_BASE64);
520
555
  if(ret != GNUTLS_E_SUCCESS){
521
556
    fprintf_plus(stderr,
527
562
  }
528
563
  
529
564
  /* GnuTLS server initialization */
530
 
  ret = gnutls_dh_params_init(&mc.dh_params);
 
565
  ret = gnutls_dh_params_init(&mc->dh_params);
531
566
  if(ret != GNUTLS_E_SUCCESS){
532
567
    fprintf_plus(stderr, "Error in GnuTLS DH parameter"
533
568
                 " initialization: %s\n",
534
569
                 safer_gnutls_strerror(ret));
535
570
    goto globalfail;
536
571
  }
537
 
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
 
572
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
538
573
  if(ret != GNUTLS_E_SUCCESS){
539
574
    fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
540
575
                 safer_gnutls_strerror(ret));
541
576
    goto globalfail;
542
577
  }
543
578
  
544
 
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
579
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
545
580
  
546
581
  return 0;
547
582
  
548
583
 globalfail:
549
584
  
550
 
  gnutls_certificate_free_credentials(mc.cred);
 
585
  gnutls_certificate_free_credentials(mc->cred);
551
586
  gnutls_global_deinit();
552
 
  gnutls_dh_params_deinit(mc.dh_params);
 
587
  gnutls_dh_params_deinit(mc->dh_params);
553
588
  return -1;
554
589
}
555
590
 
556
 
static int init_gnutls_session(gnutls_session_t *session){
 
591
__attribute__((nonnull, warn_unused_result))
 
592
static int init_gnutls_session(gnutls_session_t *session,
 
593
                               mandos_context *mc){
557
594
  int ret;
558
595
  /* GnuTLS session creation */
559
596
  do {
571
608
  {
572
609
    const char *err;
573
610
    do {
574
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
611
      ret = gnutls_priority_set_direct(*session, mc->priority, &err);
575
612
      if(quit_now){
576
613
        gnutls_deinit(*session);
577
614
        return -1;
588
625
  
589
626
  do {
590
627
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
591
 
                                 mc.cred);
 
628
                                 mc->cred);
592
629
    if(quit_now){
593
630
      gnutls_deinit(*session);
594
631
      return -1;
604
641
  /* ignore client certificate if any. */
605
642
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
606
643
  
607
 
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
 
644
  gnutls_dh_set_prime_bits(*session, mc->dh_bits);
608
645
  
609
646
  return 0;
610
647
}
614
651
                      __attribute__((unused)) const char *txt){}
615
652
 
616
653
/* Called when a Mandos server is found */
617
 
static int start_mandos_communication(const char *ip, uint16_t port,
 
654
__attribute__((nonnull, warn_unused_result))
 
655
static int start_mandos_communication(const char *ip, in_port_t port,
618
656
                                      AvahiIfIndex if_index,
619
 
                                      int af){
 
657
                                      int af, mandos_context *mc){
620
658
  int ret, tcp_sd = -1;
621
659
  ssize_t sret;
622
 
  union {
623
 
    struct sockaddr_in in;
624
 
    struct sockaddr_in6 in6;
625
 
  } to;
 
660
  struct sockaddr_storage to;
626
661
  char *buffer = NULL;
627
662
  char *decrypted_buffer = NULL;
628
663
  size_t buffer_length = 0;
652
687
    return -1;
653
688
  }
654
689
  
655
 
  ret = init_gnutls_session(&session);
 
690
  /* If the interface is specified and we have a list of interfaces */
 
691
  if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
 
692
    /* Check if the interface is one of the interfaces we are using */
 
693
    bool match = false;
 
694
    {
 
695
      char *interface = NULL;
 
696
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
 
697
                                 interface))){
 
698
        if(if_nametoindex(interface) == (unsigned int)if_index){
 
699
          match = true;
 
700
          break;
 
701
        }
 
702
      }
 
703
    }
 
704
    if(not match){
 
705
      /* This interface does not match any in the list, so we don't
 
706
         connect to the server */
 
707
      if(debug){
 
708
        char interface[IF_NAMESIZE];
 
709
        if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
710
          perror_plus("if_indextoname");
 
711
        } else {
 
712
          fprintf_plus(stderr, "Skipping server on non-used interface"
 
713
                       " \"%s\"\n",
 
714
                       if_indextoname((unsigned int)if_index,
 
715
                                      interface));
 
716
        }
 
717
      }
 
718
      return -1;
 
719
    }
 
720
  }
 
721
  
 
722
  ret = init_gnutls_session(&session, mc);
656
723
  if(ret != 0){
657
724
    return -1;
658
725
  }
659
726
  
660
727
  if(debug){
661
728
    fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
662
 
                 PRIu16 "\n", ip, port);
 
729
                 PRIuMAX "\n", ip, (uintmax_t)port);
663
730
  }
664
731
  
665
732
  tcp_sd = socket(pf, SOCK_STREAM, 0);
677
744
  
678
745
  memset(&to, 0, sizeof(to));
679
746
  if(af == AF_INET6){
680
 
    to.in6.sin6_family = (sa_family_t)af;
681
 
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
747
    ((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
 
748
    ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
682
749
  } else {                      /* IPv4 */
683
 
    to.in.sin_family = (sa_family_t)af;
684
 
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
750
    ((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
 
751
    ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
685
752
  }
686
753
  if(ret < 0 ){
687
754
    int e = errno;
696
763
    goto mandos_end;
697
764
  }
698
765
  if(af == AF_INET6){
699
 
    to.in6.sin6_port = htons(port); /* Spurious warnings from
700
 
                                       -Wconversion and
701
 
                                       -Wunreachable-code */
702
 
    
703
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
704
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
705
 
                                -Wunreachable-code*/
 
766
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
767
    if(IN6_IS_ADDR_LINKLOCAL
 
768
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
706
769
      if(if_index == AVAHI_IF_UNSPEC){
707
770
        fprintf_plus(stderr, "An IPv6 link-local address is"
708
771
                     " incomplete without a network interface\n");
710
773
        goto mandos_end;
711
774
      }
712
775
      /* Set the network interface number as scope */
713
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
776
      ((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
714
777
    }
715
778
  } else {
716
 
    to.in.sin_port = htons(port); /* Spurious warnings from
717
 
                                     -Wconversion and
718
 
                                     -Wunreachable-code */
 
779
    ((struct sockaddr_in *)&to)->sin_port = htons(port);
719
780
  }
720
781
  
721
782
  if(quit_now){
729
790
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
730
791
        perror_plus("if_indextoname");
731
792
      } else {
732
 
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
733
 
                     "\n", ip, interface, port);
 
793
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
 
794
                     "\n", ip, interface, (uintmax_t)port);
734
795
      }
735
796
    } else {
736
 
      fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
737
 
                   ip, port);
 
797
      fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
 
798
                   ip, (uintmax_t)port);
738
799
    }
739
800
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
740
801
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
741
 
    const char *pcret;
742
802
    if(af == AF_INET6){
743
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
744
 
                        sizeof(addrstr));
 
803
      ret = getnameinfo((struct sockaddr *)&to,
 
804
                        sizeof(struct sockaddr_in6),
 
805
                        addrstr, sizeof(addrstr), NULL, 0,
 
806
                        NI_NUMERICHOST);
745
807
    } else {
746
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
747
 
                        sizeof(addrstr));
 
808
      ret = getnameinfo((struct sockaddr *)&to,
 
809
                        sizeof(struct sockaddr_in),
 
810
                        addrstr, sizeof(addrstr), NULL, 0,
 
811
                        NI_NUMERICHOST);
748
812
    }
749
 
    if(pcret == NULL){
750
 
      perror_plus("inet_ntop");
751
 
    } else {
752
 
      if(strcmp(addrstr, ip) != 0){
753
 
        fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
754
 
      }
 
813
    if(ret == EAI_SYSTEM){
 
814
      perror_plus("getnameinfo");
 
815
    } else if(ret != 0) {
 
816
      fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
 
817
    } else if(strcmp(addrstr, ip) != 0){
 
818
      fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
755
819
    }
756
820
  }
757
821
  
761
825
  }
762
826
  
763
827
  if(af == AF_INET6){
764
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
 
828
    ret = connect(tcp_sd, (struct sockaddr *)&to,
 
829
                  sizeof(struct sockaddr_in6));
765
830
  } else {
766
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
 
831
    ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
832
                  sizeof(struct sockaddr_in));
767
833
  }
768
834
  if(ret < 0){
769
 
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
 
835
    if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
770
836
      int e = errno;
771
837
      perror_plus("connect");
772
838
      errno = e;
818
884
    goto mandos_end;
819
885
  }
820
886
  
821
 
  /* Spurious warning from -Wint-to-pointer-cast */
822
 
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
 
887
  /* This casting via intptr_t is to eliminate warning about casting
 
888
     an int to a pointer type.  This is exactly how the GnuTLS Guile
 
889
     function "set-session-transport-fd!" does it. */
 
890
  gnutls_transport_set_ptr(session,
 
891
                           (gnutls_transport_ptr_t)(intptr_t)tcp_sd);
823
892
  
824
893
  if(quit_now){
825
894
    errno = EINTR;
930
999
  if(buffer_length > 0){
931
1000
    ssize_t decrypted_buffer_size;
932
1001
    decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
933
 
                                               &decrypted_buffer);
 
1002
                                               &decrypted_buffer, mc);
934
1003
    if(decrypted_buffer_size >= 0){
935
1004
      
936
1005
      written = 0;
984
1053
  return retval;
985
1054
}
986
1055
 
 
1056
__attribute__((nonnull))
987
1057
static void resolve_callback(AvahiSServiceResolver *r,
988
1058
                             AvahiIfIndex interface,
989
1059
                             AvahiProtocol proto,
997
1067
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
998
1068
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
999
1069
                             flags,
1000
 
                             AVAHI_GCC_UNUSED void* userdata){
1001
 
  assert(r);
 
1070
                             void *mc){
 
1071
  if(r == NULL){
 
1072
    return;
 
1073
  }
1002
1074
  
1003
1075
  /* Called whenever a service has been resolved successfully or
1004
1076
     timed out */
1005
1077
  
1006
1078
  if(quit_now){
 
1079
    avahi_s_service_resolver_free(r);
1007
1080
    return;
1008
1081
  }
1009
1082
  
1013
1086
    fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1014
1087
                 "'%s' of type '%s' in domain '%s': %s\n", name, type,
1015
1088
                 domain,
1016
 
                 avahi_strerror(avahi_server_errno(mc.server)));
 
1089
                 avahi_strerror(avahi_server_errno
 
1090
                                (((mandos_context*)mc)->server)));
1017
1091
    break;
1018
1092
    
1019
1093
  case AVAHI_RESOLVER_FOUND:
1025
1099
                     PRIdMAX ") on port %" PRIu16 "\n", name,
1026
1100
                     host_name, ip, (intmax_t)interface, port);
1027
1101
      }
1028
 
      int ret = start_mandos_communication(ip, port, interface,
1029
 
                                           avahi_proto_to_af(proto));
 
1102
      int ret = start_mandos_communication(ip, (in_port_t)port,
 
1103
                                           interface,
 
1104
                                           avahi_proto_to_af(proto),
 
1105
                                           mc);
1030
1106
      if(ret == 0){
1031
 
        avahi_simple_poll_quit(mc.simple_poll);
 
1107
        avahi_simple_poll_quit(simple_poll);
1032
1108
      } else {
1033
 
        ret = add_server(ip, port, interface,
1034
 
                         avahi_proto_to_af(proto));
 
1109
        if(not add_server(ip, (in_port_t)port, interface,
 
1110
                          avahi_proto_to_af(proto),
 
1111
                          &((mandos_context*)mc)->current_server)){
 
1112
          fprintf_plus(stderr, "Failed to add server \"%s\" to server"
 
1113
                       " list\n", name);
 
1114
        }
1035
1115
      }
1036
1116
    }
1037
1117
  }
1047
1127
                            const char *domain,
1048
1128
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1049
1129
                            flags,
1050
 
                            AVAHI_GCC_UNUSED void* userdata){
1051
 
  assert(b);
 
1130
                            void *mc){
 
1131
  if(b == NULL){
 
1132
    return;
 
1133
  }
1052
1134
  
1053
1135
  /* Called whenever a new services becomes available on the LAN or
1054
1136
     is removed from the LAN */
1062
1144
  case AVAHI_BROWSER_FAILURE:
1063
1145
    
1064
1146
    fprintf_plus(stderr, "(Avahi browser) %s\n",
1065
 
                 avahi_strerror(avahi_server_errno(mc.server)));
1066
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1147
                 avahi_strerror(avahi_server_errno
 
1148
                                (((mandos_context*)mc)->server)));
 
1149
    avahi_simple_poll_quit(simple_poll);
1067
1150
    return;
1068
1151
    
1069
1152
  case AVAHI_BROWSER_NEW:
1072
1155
       the callback function is called the Avahi server will free the
1073
1156
       resolver for us. */
1074
1157
    
1075
 
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1076
 
                                    name, type, domain, protocol, 0,
1077
 
                                    resolve_callback, NULL) == NULL)
 
1158
    if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
 
1159
                                    interface, protocol, name, type,
 
1160
                                    domain, protocol, 0,
 
1161
                                    resolve_callback, mc) == NULL)
1078
1162
      fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1079
1163
                   " %s\n", name,
1080
 
                   avahi_strerror(avahi_server_errno(mc.server)));
 
1164
                   avahi_strerror(avahi_server_errno
 
1165
                                  (((mandos_context*)mc)->server)));
1081
1166
    break;
1082
1167
    
1083
1168
  case AVAHI_BROWSER_REMOVE:
1102
1187
  signal_received = sig;
1103
1188
  int old_errno = errno;
1104
1189
  /* set main loop to exit */
1105
 
  if(mc.simple_poll != NULL){
1106
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1190
  if(simple_poll != NULL){
 
1191
    avahi_simple_poll_quit(simple_poll);
1107
1192
  }
1108
1193
  errno = old_errno;
1109
1194
}
1110
1195
 
 
1196
__attribute__((nonnull, warn_unused_result))
1111
1197
bool get_flags(const char *ifname, struct ifreq *ifr){
1112
1198
  int ret;
 
1199
  error_t ret_errno;
1113
1200
  
1114
1201
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1115
1202
  if(s < 0){
 
1203
    ret_errno = errno;
1116
1204
    perror_plus("socket");
 
1205
    errno = ret_errno;
1117
1206
    return false;
1118
1207
  }
1119
1208
  strcpy(ifr->ifr_name, ifname);
1120
1209
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1121
1210
  if(ret == -1){
1122
1211
    if(debug){
 
1212
      ret_errno = errno;
1123
1213
      perror_plus("ioctl SIOCGIFFLAGS");
 
1214
      errno = ret_errno;
1124
1215
    }
1125
1216
    return false;
1126
1217
  }
1127
1218
  return true;
1128
1219
}
1129
1220
 
 
1221
__attribute__((nonnull, warn_unused_result))
1130
1222
bool good_flags(const char *ifname, const struct ifreq *ifr){
1131
1223
  
1132
1224
  /* Reject the loopback device */
1174
1266
 * corresponds to an acceptable network device.
1175
1267
 * (This function is passed to scandir(3) as a filter function.)
1176
1268
 */
 
1269
__attribute__((nonnull, warn_unused_result))
1177
1270
int good_interface(const struct dirent *if_entry){
1178
1271
  if(if_entry->d_name[0] == '.'){
1179
1272
    return 0;
1195
1288
}
1196
1289
 
1197
1290
/* 
1198
 
 * This function determines if a directory entry in /sys/class/net
1199
 
 * corresponds to an acceptable network device which is up.
1200
 
 * (This function is passed to scandir(3) as a filter function.)
1201
 
 */
1202
 
int up_interface(const struct dirent *if_entry){
1203
 
  if(if_entry->d_name[0] == '.'){
1204
 
    return 0;
1205
 
  }
1206
 
  
1207
 
  struct ifreq ifr;
1208
 
  if(not get_flags(if_entry->d_name, &ifr)){
1209
 
    if(debug){
1210
 
      fprintf_plus(stderr, "Failed to get flags for interface "
1211
 
                   "\"%s\"\n", if_entry->d_name);
1212
 
    }
1213
 
    return 0;
1214
 
  }
1215
 
  
1216
 
  /* Reject down interfaces */
1217
 
  if(not (ifr.ifr_flags & IFF_UP)){
1218
 
    if(debug){
1219
 
      fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1220
 
                   if_entry->d_name);
1221
 
    }
1222
 
    return 0;
1223
 
  }
1224
 
  
1225
 
  /* Reject non-running interfaces */
1226
 
  if(not (ifr.ifr_flags & IFF_RUNNING)){
1227
 
    if(debug){
1228
 
      fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1229
 
                   if_entry->d_name);
1230
 
    }
1231
 
    return 0;
1232
 
  }
1233
 
  
1234
 
  if(not good_flags(if_entry->d_name, &ifr)){
1235
 
    return 0;
1236
 
  }
1237
 
  return 1;
1238
 
}
1239
 
 
 
1291
 * This function determines if a network interface is up.
 
1292
 */
 
1293
__attribute__((nonnull, warn_unused_result))
 
1294
bool interface_is_up(const char *interface){
 
1295
  struct ifreq ifr;
 
1296
  if(not get_flags(interface, &ifr)){
 
1297
    if(debug){
 
1298
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1299
                   "\"%s\"\n", interface);
 
1300
    }
 
1301
    return false;
 
1302
  }
 
1303
  
 
1304
  return (bool)(ifr.ifr_flags & IFF_UP);
 
1305
}
 
1306
 
 
1307
/* 
 
1308
 * This function determines if a network interface is running
 
1309
 */
 
1310
__attribute__((nonnull, warn_unused_result))
 
1311
bool interface_is_running(const char *interface){
 
1312
  struct ifreq ifr;
 
1313
  if(not get_flags(interface, &ifr)){
 
1314
    if(debug){
 
1315
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1316
                   "\"%s\"\n", interface);
 
1317
    }
 
1318
    return false;
 
1319
  }
 
1320
  
 
1321
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
 
1322
}
 
1323
 
 
1324
__attribute__((nonnull, pure, warn_unused_result))
1240
1325
int notdotentries(const struct dirent *direntry){
1241
1326
  /* Skip "." and ".." */
1242
1327
  if(direntry->d_name[0] == '.'
1249
1334
}
1250
1335
 
1251
1336
/* Is this directory entry a runnable program? */
 
1337
__attribute__((nonnull, warn_unused_result))
1252
1338
int runnable_hook(const struct dirent *direntry){
1253
1339
  int ret;
1254
1340
  size_t sret;
1262
1348
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1263
1349
                "abcdefghijklmnopqrstuvwxyz"
1264
1350
                "0123456789"
1265
 
                "_-");
 
1351
                "_.-");
1266
1352
  if((direntry->d_name)[sret] != '\0'){
1267
1353
    /* Contains non-allowed characters */
1268
1354
    if(debug){
1272
1358
    return 0;
1273
1359
  }
1274
1360
  
1275
 
  char *fullname = NULL;
1276
 
  ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1277
 
  if(ret < 0){
1278
 
    perror_plus("asprintf");
1279
 
    return 0;
1280
 
  }
1281
 
  
1282
 
  ret = stat(fullname, &st);
 
1361
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1283
1362
  if(ret == -1){
1284
1363
    if(debug){
1285
1364
      perror_plus("Could not stat hook");
1309
1388
  return 1;
1310
1389
}
1311
1390
 
1312
 
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
 
1391
__attribute__((nonnull, warn_unused_result))
 
1392
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
 
1393
                            mandos_context *mc){
1313
1394
  int ret;
1314
1395
  struct timespec now;
1315
1396
  struct timespec waited_time;
1316
1397
  intmax_t block_time;
1317
1398
  
1318
1399
  while(true){
1319
 
    if(mc.current_server == NULL){
1320
 
      if (debug){
 
1400
    if(mc->current_server == NULL){
 
1401
      if(debug){
1321
1402
        fprintf_plus(stderr, "Wait until first server is found."
1322
1403
                     " No timeout!\n");
1323
1404
      }
1324
1405
      ret = avahi_simple_poll_iterate(s, -1);
1325
1406
    } else {
1326
 
      if (debug){
 
1407
      if(debug){
1327
1408
        fprintf_plus(stderr, "Check current_server if we should run"
1328
1409
                     " it, or wait\n");
1329
1410
      }
1336
1417
      /* Calculating in ms how long time between now and server
1337
1418
         who we visted longest time ago. Now - last seen.  */
1338
1419
      waited_time.tv_sec = (now.tv_sec
1339
 
                            - mc.current_server->last_seen.tv_sec);
 
1420
                            - mc->current_server->last_seen.tv_sec);
1340
1421
      waited_time.tv_nsec = (now.tv_nsec
1341
 
                             - mc.current_server->last_seen.tv_nsec);
 
1422
                             - mc->current_server->last_seen.tv_nsec);
1342
1423
      /* total time is 10s/10,000ms.
1343
1424
         Converting to s from ms by dividing by 1,000,
1344
1425
         and ns to ms by dividing by 1,000,000. */
1346
1427
                     - ((intmax_t)waited_time.tv_sec * 1000))
1347
1428
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1348
1429
      
1349
 
      if (debug){
 
1430
      if(debug){
1350
1431
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1351
1432
                     block_time);
1352
1433
      }
1353
1434
      
1354
1435
      if(block_time <= 0){
1355
 
        ret = start_mandos_communication(mc.current_server->ip,
1356
 
                                         mc.current_server->port,
1357
 
                                         mc.current_server->if_index,
1358
 
                                         mc.current_server->af);
 
1436
        ret = start_mandos_communication(mc->current_server->ip,
 
1437
                                         mc->current_server->port,
 
1438
                                         mc->current_server->if_index,
 
1439
                                         mc->current_server->af, mc);
1359
1440
        if(ret == 0){
1360
 
          avahi_simple_poll_quit(mc.simple_poll);
 
1441
          avahi_simple_poll_quit(s);
1361
1442
          return 0;
1362
1443
        }
1363
1444
        ret = clock_gettime(CLOCK_MONOTONIC,
1364
 
                            &mc.current_server->last_seen);
 
1445
                            &mc->current_server->last_seen);
1365
1446
        if(ret == -1){
1366
1447
          perror_plus("clock_gettime");
1367
1448
          return -1;
1368
1449
        }
1369
 
        mc.current_server = mc.current_server->next;
 
1450
        mc->current_server = mc->current_server->next;
1370
1451
        block_time = 0;         /* Call avahi to find new Mandos
1371
1452
                                   servers, but don't block */
1372
1453
      }
1374
1455
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1375
1456
    }
1376
1457
    if(ret != 0){
1377
 
      if (ret > 0 or errno != EINTR){
 
1458
      if(ret > 0 or errno != EINTR){
1378
1459
        return (ret != 1) ? ret : 0;
1379
1460
      }
1380
1461
    }
1381
1462
  }
1382
1463
}
1383
1464
 
1384
 
bool run_network_hooks(const char *mode, const char *interface,
 
1465
/* Set effective uid to 0, return errno */
 
1466
__attribute__((warn_unused_result))
 
1467
error_t raise_privileges(void){
 
1468
  error_t old_errno = errno;
 
1469
  error_t ret_errno = 0;
 
1470
  if(seteuid(0) == -1){
 
1471
    ret_errno = errno;
 
1472
  }
 
1473
  errno = old_errno;
 
1474
  return ret_errno;
 
1475
}
 
1476
 
 
1477
/* Set effective and real user ID to 0.  Return errno. */
 
1478
__attribute__((warn_unused_result))
 
1479
error_t raise_privileges_permanently(void){
 
1480
  error_t old_errno = errno;
 
1481
  error_t ret_errno = raise_privileges();
 
1482
  if(ret_errno != 0){
 
1483
    errno = old_errno;
 
1484
    return ret_errno;
 
1485
  }
 
1486
  if(setuid(0) == -1){
 
1487
    ret_errno = errno;
 
1488
  }
 
1489
  errno = old_errno;
 
1490
  return ret_errno;
 
1491
}
 
1492
 
 
1493
/* Set effective user ID to unprivileged saved user ID */
 
1494
__attribute__((warn_unused_result))
 
1495
error_t lower_privileges(void){
 
1496
  error_t old_errno = errno;
 
1497
  error_t ret_errno = 0;
 
1498
  if(seteuid(uid) == -1){
 
1499
    ret_errno = errno;
 
1500
  }
 
1501
  errno = old_errno;
 
1502
  return ret_errno;
 
1503
}
 
1504
 
 
1505
/* Lower privileges permanently */
 
1506
__attribute__((warn_unused_result))
 
1507
error_t lower_privileges_permanently(void){
 
1508
  error_t old_errno = errno;
 
1509
  error_t ret_errno = 0;
 
1510
  if(setuid(uid) == -1){
 
1511
    ret_errno = errno;
 
1512
  }
 
1513
  errno = old_errno;
 
1514
  return ret_errno;
 
1515
}
 
1516
 
 
1517
__attribute__((nonnull))
 
1518
void run_network_hooks(const char *mode, const char *interface,
1385
1519
                       const float delay){
1386
 
  struct dirent **direntries;
1387
 
  struct dirent *direntry;
1388
 
  int ret;
1389
 
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1390
 
                         alphasort);
 
1520
  struct dirent **direntries = NULL;
 
1521
  if(hookdir_fd == -1){
 
1522
    hookdir_fd = open(hookdir, O_RDONLY);
 
1523
    if(hookdir_fd == -1){
 
1524
      if(errno == ENOENT){
 
1525
        if(debug){
 
1526
          fprintf_plus(stderr, "Network hook directory \"%s\" not"
 
1527
                       " found\n", hookdir);
 
1528
        }
 
1529
      } else {
 
1530
        perror_plus("open");
 
1531
      }
 
1532
      return;
 
1533
    }
 
1534
  }
 
1535
#ifdef __GLIBC__
 
1536
#if __GLIBC_PREREQ(2, 15)
 
1537
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
 
1538
                           runnable_hook, alphasort);
 
1539
#else  /* not __GLIBC_PREREQ(2, 15) */
 
1540
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1541
                         alphasort);
 
1542
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
1543
#else   /* not __GLIBC__ */
 
1544
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1545
                         alphasort);
 
1546
#endif  /* not __GLIBC__ */
1391
1547
  if(numhooks == -1){
1392
1548
    perror_plus("scandir");
1393
 
  } else {
1394
 
    int devnull = open("/dev/null", O_RDONLY);
1395
 
    for(int i = 0; i < numhooks; i++){
1396
 
      direntry = direntries[i];
1397
 
      char *fullname = NULL;
1398
 
      ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1399
 
      if(ret < 0){
 
1549
    return;
 
1550
  }
 
1551
  struct dirent *direntry;
 
1552
  int ret;
 
1553
  int devnull = open("/dev/null", O_RDONLY);
 
1554
  for(int i = 0; i < numhooks; i++){
 
1555
    direntry = direntries[i];
 
1556
    if(debug){
 
1557
      fprintf_plus(stderr, "Running network hook \"%s\"\n",
 
1558
                   direntry->d_name);
 
1559
    }
 
1560
    pid_t hook_pid = fork();
 
1561
    if(hook_pid == 0){
 
1562
      /* Child */
 
1563
      /* Raise privileges */
 
1564
      errno = raise_privileges_permanently();
 
1565
      if(errno != 0){
 
1566
        perror_plus("Failed to raise privileges");
 
1567
        _exit(EX_NOPERM);
 
1568
      }
 
1569
      /* Set group */
 
1570
      errno = 0;
 
1571
      ret = setgid(0);
 
1572
      if(ret == -1){
 
1573
        perror_plus("setgid");
 
1574
        _exit(EX_NOPERM);
 
1575
      }
 
1576
      /* Reset supplementary groups */
 
1577
      errno = 0;
 
1578
      ret = setgroups(0, NULL);
 
1579
      if(ret == -1){
 
1580
        perror_plus("setgroups");
 
1581
        _exit(EX_NOPERM);
 
1582
      }
 
1583
      ret = dup2(devnull, STDIN_FILENO);
 
1584
      if(ret == -1){
 
1585
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
1586
        _exit(EX_OSERR);
 
1587
      }
 
1588
      ret = close(devnull);
 
1589
      if(ret == -1){
 
1590
        perror_plus("close");
 
1591
        _exit(EX_OSERR);
 
1592
      }
 
1593
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
1594
      if(ret == -1){
 
1595
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
1596
        _exit(EX_OSERR);
 
1597
      }
 
1598
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
 
1599
      if(ret == -1){
 
1600
        perror_plus("setenv");
 
1601
        _exit(EX_OSERR);
 
1602
      }
 
1603
      ret = setenv("DEVICE", interface, 1);
 
1604
      if(ret == -1){
 
1605
        perror_plus("setenv");
 
1606
        _exit(EX_OSERR);
 
1607
      }
 
1608
      ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
 
1609
      if(ret == -1){
 
1610
        perror_plus("setenv");
 
1611
        _exit(EX_OSERR);
 
1612
      }
 
1613
      ret = setenv("MODE", mode, 1);
 
1614
      if(ret == -1){
 
1615
        perror_plus("setenv");
 
1616
        _exit(EX_OSERR);
 
1617
      }
 
1618
      char *delaystring;
 
1619
      ret = asprintf(&delaystring, "%f", (double)delay);
 
1620
      if(ret == -1){
1400
1621
        perror_plus("asprintf");
1401
 
        continue;
1402
 
      }
1403
 
      if(debug){
1404
 
        fprintf_plus(stderr, "Running network hook \"%s\"\n",
1405
 
                     direntry->d_name);
1406
 
      }
1407
 
      pid_t hook_pid = fork();
1408
 
      if(hook_pid == 0){
1409
 
        /* Child */
1410
 
        /* Raise privileges */
1411
 
        errno = 0;
1412
 
        ret = seteuid(0);
1413
 
        if(ret == -1){
1414
 
          perror_plus("seteuid");
1415
 
        }
1416
 
        /* Raise privileges even more */
1417
 
        errno = 0;
1418
 
        ret = setuid(0);
1419
 
        if(ret == -1){
1420
 
          perror_plus("setuid");
1421
 
        }
1422
 
        /* Set group */
1423
 
        errno = 0;
1424
 
        ret = setgid(0);
1425
 
        if(ret == -1){
1426
 
          perror_plus("setgid");
1427
 
        }
1428
 
        /* Reset supplementary groups */
1429
 
        errno = 0;
1430
 
        ret = setgroups(0, NULL);
1431
 
        if(ret == -1){
1432
 
          perror_plus("setgroups");
1433
 
        }
1434
 
        fprintf_plus(stderr, "Child: getuid() = %d\n", getuid());
1435
 
        fprintf_plus(stderr, "Child: geteuid() = %d\n", geteuid());
1436
 
        dup2(devnull, STDIN_FILENO);
1437
 
        close(devnull);
1438
 
        dup2(STDERR_FILENO, STDOUT_FILENO);
1439
 
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1440
 
        if(ret == -1){
1441
 
          perror_plus("setenv");
1442
 
          _exit(EX_OSERR);
1443
 
        }
1444
 
        ret = setenv("DEVICE", interface, 1);
1445
 
        if(ret == -1){
1446
 
          perror_plus("setenv");
1447
 
          _exit(EX_OSERR);
1448
 
        }
1449
 
        ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1450
 
        if(ret == -1){
1451
 
          perror_plus("setenv");
1452
 
          _exit(EX_OSERR);
1453
 
        }
1454
 
        ret = setenv("MODE", mode, 1);
1455
 
        if(ret == -1){
1456
 
          perror_plus("setenv");
1457
 
          _exit(EX_OSERR);
1458
 
        }
1459
 
        char *delaystring;
1460
 
        ret = asprintf(&delaystring, "%f", delay);
1461
 
        if(ret == -1){
1462
 
          perror_plus("asprintf");
1463
 
          _exit(EX_OSERR);
1464
 
        }
1465
 
        ret = setenv("DELAY", delaystring, 1);
1466
 
        if(ret == -1){
1467
 
          free(delaystring);
1468
 
          perror_plus("setenv");
1469
 
          _exit(EX_OSERR);
1470
 
        }
 
1622
        _exit(EX_OSERR);
 
1623
      }
 
1624
      ret = setenv("DELAY", delaystring, 1);
 
1625
      if(ret == -1){
1471
1626
        free(delaystring);
1472
 
        ret = execl(fullname, direntry->d_name, mode, NULL);
1473
 
        perror_plus("execl");
1474
 
      } else {
1475
 
        int status;
1476
 
        if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1477
 
          perror_plus("waitpid");
1478
 
          free(fullname);
1479
 
          continue;
1480
 
        }
1481
 
        if(WIFEXITED(status)){
1482
 
          if(WEXITSTATUS(status) != 0){
1483
 
            fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1484
 
                         " with status %d\n", direntry->d_name,
1485
 
                         WEXITSTATUS(status));
1486
 
            free(fullname);
1487
 
            continue;
1488
 
          }
1489
 
        } else if(WIFSIGNALED(status)){
1490
 
          fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1491
 
                       " signal %d\n", direntry->d_name,
1492
 
                       WTERMSIG(status));
1493
 
          free(fullname);
1494
 
          continue;
1495
 
        } else {
1496
 
          fprintf_plus(stderr, "Warning: network hook \"%s\""
1497
 
                       " crashed\n", direntry->d_name);
1498
 
          free(fullname);
1499
 
          continue;
1500
 
        }
1501
 
      }
1502
 
      free(fullname);
1503
 
      if(debug){
1504
 
        fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1505
 
                     direntry->d_name);
1506
 
      }
1507
 
    }
1508
 
    close(devnull);
1509
 
  }
1510
 
  return true;
 
1627
        perror_plus("setenv");
 
1628
        _exit(EX_OSERR);
 
1629
      }
 
1630
      free(delaystring);
 
1631
      if(connect_to != NULL){
 
1632
        ret = setenv("CONNECT", connect_to, 1);
 
1633
        if(ret == -1){
 
1634
          perror_plus("setenv");
 
1635
          _exit(EX_OSERR);
 
1636
        }
 
1637
      }
 
1638
      int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
 
1639
      if(hook_fd == -1){
 
1640
        perror_plus("openat");
 
1641
        _exit(EXIT_FAILURE);
 
1642
      }
 
1643
      if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
 
1644
        perror_plus("close");
 
1645
        _exit(EXIT_FAILURE);
 
1646
      }
 
1647
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
 
1648
                 environ) == -1){
 
1649
        perror_plus("fexecve");
 
1650
        _exit(EXIT_FAILURE);
 
1651
      }
 
1652
    } else {
 
1653
      int status;
 
1654
      if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
 
1655
        perror_plus("waitpid");
 
1656
        free(direntry);
 
1657
        continue;
 
1658
      }
 
1659
      if(WIFEXITED(status)){
 
1660
        if(WEXITSTATUS(status) != 0){
 
1661
          fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
 
1662
                       " with status %d\n", direntry->d_name,
 
1663
                       WEXITSTATUS(status));
 
1664
          free(direntry);
 
1665
          continue;
 
1666
        }
 
1667
      } else if(WIFSIGNALED(status)){
 
1668
        fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
 
1669
                     " signal %d\n", direntry->d_name,
 
1670
                     WTERMSIG(status));
 
1671
        free(direntry);
 
1672
        continue;
 
1673
      } else {
 
1674
        fprintf_plus(stderr, "Warning: network hook \"%s\""
 
1675
                     " crashed\n", direntry->d_name);
 
1676
        free(direntry);
 
1677
        continue;
 
1678
      }
 
1679
    }
 
1680
    if(debug){
 
1681
      fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
 
1682
                   direntry->d_name);
 
1683
    }
 
1684
    free(direntry);
 
1685
  }
 
1686
  free(direntries);
 
1687
  if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
 
1688
    perror_plus("close");
 
1689
  } else {
 
1690
    hookdir_fd = -1;
 
1691
  }
 
1692
  close(devnull);
 
1693
}
 
1694
 
 
1695
__attribute__((nonnull, warn_unused_result))
 
1696
error_t bring_up_interface(const char *const interface,
 
1697
                           const float delay){
 
1698
  error_t old_errno = errno;
 
1699
  int ret;
 
1700
  struct ifreq network;
 
1701
  unsigned int if_index = if_nametoindex(interface);
 
1702
  if(if_index == 0){
 
1703
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
1704
    errno = old_errno;
 
1705
    return ENXIO;
 
1706
  }
 
1707
  
 
1708
  if(quit_now){
 
1709
    errno = old_errno;
 
1710
    return EINTR;
 
1711
  }
 
1712
  
 
1713
  if(not interface_is_up(interface)){
 
1714
    error_t ret_errno = 0, ioctl_errno = 0;
 
1715
    if(not get_flags(interface, &network)){
 
1716
      ret_errno = errno;
 
1717
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1718
                   "\"%s\"\n", interface);
 
1719
      errno = old_errno;
 
1720
      return ret_errno;
 
1721
    }
 
1722
    network.ifr_flags |= IFF_UP; /* set flag */
 
1723
    
 
1724
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1725
    if(sd == -1){
 
1726
      ret_errno = errno;
 
1727
      perror_plus("socket");
 
1728
      errno = old_errno;
 
1729
      return ret_errno;
 
1730
    }
 
1731
    
 
1732
    if(quit_now){
 
1733
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1734
      if(ret == -1){
 
1735
        perror_plus("close");
 
1736
      }
 
1737
      errno = old_errno;
 
1738
      return EINTR;
 
1739
    }
 
1740
    
 
1741
    if(debug){
 
1742
      fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
 
1743
                   interface);
 
1744
    }
 
1745
    
 
1746
    /* Raise privileges */
 
1747
    ret_errno = raise_privileges();
 
1748
    if(ret_errno != 0){
 
1749
      errno = ret_errno;
 
1750
      perror_plus("Failed to raise privileges");
 
1751
    }
 
1752
    
 
1753
#ifdef __linux__
 
1754
    int ret_linux;
 
1755
    bool restore_loglevel = false;
 
1756
    if(ret_errno == 0){
 
1757
      /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
1758
         messages about the network interface to mess up the prompt */
 
1759
      ret_linux = klogctl(8, NULL, 5);
 
1760
      if(ret_linux == -1){
 
1761
        perror_plus("klogctl");
 
1762
      } else {
 
1763
        restore_loglevel = true;
 
1764
      }
 
1765
    }
 
1766
#endif  /* __linux__ */
 
1767
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1768
    ioctl_errno = errno;
 
1769
#ifdef __linux__
 
1770
    if(restore_loglevel){
 
1771
      ret_linux = klogctl(7, NULL, 0);
 
1772
      if(ret_linux == -1){
 
1773
        perror_plus("klogctl");
 
1774
      }
 
1775
    }
 
1776
#endif  /* __linux__ */
 
1777
    
 
1778
    /* If raise_privileges() succeeded above */
 
1779
    if(ret_errno == 0){
 
1780
      /* Lower privileges */
 
1781
      ret_errno = lower_privileges();
 
1782
      if(ret_errno != 0){
 
1783
        errno = ret_errno;
 
1784
        perror_plus("Failed to lower privileges");
 
1785
      }
 
1786
    }
 
1787
    
 
1788
    /* Close the socket */
 
1789
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1790
    if(ret == -1){
 
1791
      perror_plus("close");
 
1792
    }
 
1793
    
 
1794
    if(ret_setflags == -1){
 
1795
      errno = ioctl_errno;
 
1796
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
 
1797
      errno = old_errno;
 
1798
      return ioctl_errno;
 
1799
    }
 
1800
  } else if(debug){
 
1801
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
 
1802
                 interface);
 
1803
  }
 
1804
  
 
1805
  /* Sleep checking until interface is running.
 
1806
     Check every 0.25s, up to total time of delay */
 
1807
  for(int i=0; i < delay * 4; i++){
 
1808
    if(interface_is_running(interface)){
 
1809
      break;
 
1810
    }
 
1811
    struct timespec sleeptime = { .tv_nsec = 250000000 };
 
1812
    ret = nanosleep(&sleeptime, NULL);
 
1813
    if(ret == -1 and errno != EINTR){
 
1814
      perror_plus("nanosleep");
 
1815
    }
 
1816
  }
 
1817
  
 
1818
  errno = old_errno;
 
1819
  return 0;
 
1820
}
 
1821
 
 
1822
__attribute__((nonnull, warn_unused_result))
 
1823
error_t take_down_interface(const char *const interface){
 
1824
  error_t old_errno = errno;
 
1825
  struct ifreq network;
 
1826
  unsigned int if_index = if_nametoindex(interface);
 
1827
  if(if_index == 0){
 
1828
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
1829
    errno = old_errno;
 
1830
    return ENXIO;
 
1831
  }
 
1832
  if(interface_is_up(interface)){
 
1833
    error_t ret_errno = 0, ioctl_errno = 0;
 
1834
    if(not get_flags(interface, &network) and debug){
 
1835
      ret_errno = errno;
 
1836
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1837
                   "\"%s\"\n", interface);
 
1838
      errno = old_errno;
 
1839
      return ret_errno;
 
1840
    }
 
1841
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
 
1842
    
 
1843
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1844
    if(sd == -1){
 
1845
      ret_errno = errno;
 
1846
      perror_plus("socket");
 
1847
      errno = old_errno;
 
1848
      return ret_errno;
 
1849
    }
 
1850
    
 
1851
    if(debug){
 
1852
      fprintf_plus(stderr, "Taking down interface \"%s\"\n",
 
1853
                   interface);
 
1854
    }
 
1855
    
 
1856
    /* Raise privileges */
 
1857
    ret_errno = raise_privileges();
 
1858
    if(ret_errno != 0){
 
1859
      errno = ret_errno;
 
1860
      perror_plus("Failed to raise privileges");
 
1861
    }
 
1862
    
 
1863
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1864
    ioctl_errno = errno;
 
1865
    
 
1866
    /* If raise_privileges() succeeded above */
 
1867
    if(ret_errno == 0){
 
1868
      /* Lower privileges */
 
1869
      ret_errno = lower_privileges();
 
1870
      if(ret_errno != 0){
 
1871
        errno = ret_errno;
 
1872
        perror_plus("Failed to lower privileges");
 
1873
      }
 
1874
    }
 
1875
    
 
1876
    /* Close the socket */
 
1877
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1878
    if(ret == -1){
 
1879
      perror_plus("close");
 
1880
    }
 
1881
    
 
1882
    if(ret_setflags == -1){
 
1883
      errno = ioctl_errno;
 
1884
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
1885
      errno = old_errno;
 
1886
      return ioctl_errno;
 
1887
    }
 
1888
  } else if(debug){
 
1889
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
 
1890
                 interface);
 
1891
  }
 
1892
  
 
1893
  errno = old_errno;
 
1894
  return 0;
1511
1895
}
1512
1896
 
1513
1897
int main(int argc, char *argv[]){
 
1898
  mandos_context mc = { .server = NULL, .dh_bits = 1024,
 
1899
                        .priority = "SECURE256:!CTYPE-X.509:"
 
1900
                        "+CTYPE-OPENPGP", .current_server = NULL,
 
1901
                        .interfaces = NULL, .interfaces_size = 0 };
1514
1902
  AvahiSServiceBrowser *sb = NULL;
1515
 
  int error;
 
1903
  error_t ret_errno;
1516
1904
  int ret;
1517
1905
  intmax_t tmpmax;
1518
1906
  char *tmp;
1519
1907
  int exitcode = EXIT_SUCCESS;
1520
 
  const char *interface = "";
1521
 
  struct ifreq network;
1522
 
  int sd = -1;
1523
 
  bool take_down_interface = false;
1524
 
  uid_t uid;
1525
 
  gid_t gid;
1526
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1527
 
  bool tempdir_created = false;
 
1908
  char *interfaces_to_take_down = NULL;
 
1909
  size_t interfaces_to_take_down_size = 0;
 
1910
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
1911
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
1912
  char *tempdir = NULL;
1528
1913
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1529
1914
  const char *seckey = PATHDIR "/" SECKEY;
1530
1915
  const char *pubkey = PATHDIR "/" PUBKEY;
 
1916
  char *interfaces_hooks = NULL;
1531
1917
  
1532
1918
  bool gnutls_initialized = false;
1533
1919
  bool gpgme_initialized = false;
1595
1981
        .group = 2 },
1596
1982
      { .name = "retry", .key = 132,
1597
1983
        .arg = "SECONDS",
1598
 
        .doc = "Retry interval used when denied by the mandos server",
 
1984
        .doc = "Retry interval used when denied by the Mandos server",
1599
1985
        .group = 2 },
1600
1986
      { .name = "network-hook-dir", .key = 133,
1601
1987
        .arg = "DIR",
1624
2010
        connect_to = arg;
1625
2011
        break;
1626
2012
      case 'i':                 /* --interface */
1627
 
        interface = arg;
 
2013
        ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
 
2014
                                 arg, (int)',');
 
2015
        if(ret_errno != 0){
 
2016
          argp_error(state, "%s", strerror(ret_errno));
 
2017
        }
1628
2018
        break;
1629
2019
      case 's':                 /* --seckey */
1630
2020
        seckey = arg;
1673
2063
        argp_state_help(state, state->out_stream,
1674
2064
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1675
2065
      case 'V':                 /* --version */
1676
 
        fprintf_plus(state->out_stream,
1677
 
                     "Mandos plugin mandos-client: ");
1678
2066
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1679
2067
        exit(argp_err_exit_status);
1680
2068
        break;
1709
2097
    /* Work around Debian bug #633582:
1710
2098
       <http://bugs.debian.org/633582> */
1711
2099
    
1712
 
    /* Re-raise priviliges */
1713
 
    errno = 0;
1714
 
    ret = seteuid(0);
1715
 
    if(ret == -1){
1716
 
      perror_plus("seteuid");
 
2100
    /* Re-raise privileges */
 
2101
    ret_errno = raise_privileges();
 
2102
    if(ret_errno != 0){
 
2103
      errno = ret_errno;
 
2104
      perror_plus("Failed to raise privileges");
1717
2105
    } else {
1718
2106
      struct stat st;
1719
2107
      
1760
2148
      }
1761
2149
    
1762
2150
      /* Lower privileges */
1763
 
      errno = 0;
1764
 
      ret = seteuid(uid);
1765
 
      if(ret == -1){
1766
 
        perror_plus("seteuid");
 
2151
      ret_errno = lower_privileges();
 
2152
      if(ret_errno != 0){
 
2153
        errno = ret_errno;
 
2154
        perror_plus("Failed to lower privileges");
 
2155
      }
 
2156
    }
 
2157
  }
 
2158
  
 
2159
  /* Remove invalid interface names (except "none") */
 
2160
  {
 
2161
    char *interface = NULL;
 
2162
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2163
                                 interface))){
 
2164
      if(strcmp(interface, "none") != 0
 
2165
         and if_nametoindex(interface) == 0){
 
2166
        if(interface[0] != '\0'){
 
2167
          fprintf_plus(stderr, "Not using nonexisting interface"
 
2168
                       " \"%s\"\n", interface);
 
2169
        }
 
2170
        argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
 
2171
        interface = NULL;
1767
2172
      }
1768
2173
    }
1769
2174
  }
1770
2175
  
1771
2176
  /* Run network hooks */
1772
 
  if(not run_network_hooks("start", interface, delay)){
1773
 
    goto end;
 
2177
  {
 
2178
    if(mc.interfaces != NULL){
 
2179
      interfaces_hooks = malloc(mc.interfaces_size);
 
2180
      if(interfaces_hooks == NULL){
 
2181
        perror_plus("malloc");
 
2182
        goto end;
 
2183
      }
 
2184
      memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
 
2185
      argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
 
2186
    }
 
2187
    run_network_hooks("start", interfaces_hooks != NULL ?
 
2188
                      interfaces_hooks : "", delay);
1774
2189
  }
1775
2190
  
1776
2191
  if(not debug){
1777
2192
    avahi_set_log_function(empty_log);
1778
2193
  }
1779
2194
  
1780
 
  if(interface[0] == '\0'){
1781
 
    struct dirent **direntries;
1782
 
    /* First look for interfaces that are up */
1783
 
    ret = scandir(sys_class_net, &direntries, up_interface,
1784
 
                  alphasort);
1785
 
    if(ret == 0){
1786
 
      /* No up interfaces, look for any good interfaces */
1787
 
      free(direntries);
1788
 
      ret = scandir(sys_class_net, &direntries, good_interface,
1789
 
                    alphasort);
1790
 
    }
1791
 
    if(ret >= 1){
1792
 
      /* Pick the first interface returned */
1793
 
      interface = strdup(direntries[0]->d_name);
1794
 
      if(debug){
1795
 
        fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1796
 
      }
1797
 
      if(interface == NULL){
1798
 
        perror_plus("malloc");
1799
 
        free(direntries);
1800
 
        exitcode = EXIT_FAILURE;
1801
 
        goto end;
1802
 
      }
1803
 
      free(direntries);
1804
 
    } else {
1805
 
      free(direntries);
1806
 
      fprintf_plus(stderr, "Could not find a network interface\n");
1807
 
      exitcode = EXIT_FAILURE;
1808
 
      goto end;
1809
 
    }
1810
 
  }
1811
 
  
1812
2195
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1813
2196
     from the signal handler */
1814
2197
  /* Initialize the pseudo-RNG for Avahi */
1815
2198
  srand((unsigned int) time(NULL));
1816
 
  mc.simple_poll = avahi_simple_poll_new();
1817
 
  if(mc.simple_poll == NULL){
 
2199
  simple_poll = avahi_simple_poll_new();
 
2200
  if(simple_poll == NULL){
1818
2201
    fprintf_plus(stderr,
1819
2202
                 "Avahi: Failed to create simple poll object.\n");
1820
2203
    exitcode = EX_UNAVAILABLE;
1884
2267
    }
1885
2268
  }
1886
2269
  
1887
 
  /* If the interface is down, bring it up */
1888
 
  if(strcmp(interface, "none") != 0){
1889
 
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1890
 
    if(if_index == 0){
1891
 
      fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1892
 
      exitcode = EX_UNAVAILABLE;
1893
 
      goto end;
1894
 
    }
1895
 
    
1896
 
    if(quit_now){
1897
 
      goto end;
1898
 
    }
1899
 
    
1900
 
    /* Re-raise priviliges */
1901
 
    errno = 0;
1902
 
    ret = seteuid(0);
1903
 
    if(ret == -1){
1904
 
      perror_plus("seteuid");
1905
 
    }
1906
 
    
1907
 
#ifdef __linux__
1908
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1909
 
       messages about the network interface to mess up the prompt */
1910
 
    ret = klogctl(8, NULL, 5);
1911
 
    bool restore_loglevel = true;
1912
 
    if(ret == -1){
1913
 
      restore_loglevel = false;
1914
 
      perror_plus("klogctl");
1915
 
    }
1916
 
#endif  /* __linux__ */
1917
 
    
1918
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1919
 
    if(sd < 0){
1920
 
      perror_plus("socket");
1921
 
      exitcode = EX_OSERR;
1922
 
#ifdef __linux__
1923
 
      if(restore_loglevel){
1924
 
        ret = klogctl(7, NULL, 0);
1925
 
        if(ret == -1){
1926
 
          perror_plus("klogctl");
1927
 
        }
1928
 
      }
1929
 
#endif  /* __linux__ */
1930
 
      /* Lower privileges */
1931
 
      errno = 0;
1932
 
      ret = seteuid(uid);
1933
 
      if(ret == -1){
1934
 
        perror_plus("seteuid");
1935
 
      }
1936
 
      goto end;
1937
 
    }
1938
 
    strcpy(network.ifr_name, interface);
1939
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1940
 
    if(ret == -1){
1941
 
      perror_plus("ioctl SIOCGIFFLAGS");
1942
 
#ifdef __linux__
1943
 
      if(restore_loglevel){
1944
 
        ret = klogctl(7, NULL, 0);
1945
 
        if(ret == -1){
1946
 
          perror_plus("klogctl");
1947
 
        }
1948
 
      }
1949
 
#endif  /* __linux__ */
1950
 
      exitcode = EX_OSERR;
1951
 
      /* Lower privileges */
1952
 
      errno = 0;
1953
 
      ret = seteuid(uid);
1954
 
      if(ret == -1){
1955
 
        perror_plus("seteuid");
1956
 
      }
1957
 
      goto end;
1958
 
    }
1959
 
    if((network.ifr_flags & IFF_UP) == 0){
1960
 
      network.ifr_flags |= IFF_UP;
1961
 
      take_down_interface = true;
1962
 
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1963
 
      if(ret == -1){
1964
 
        take_down_interface = false;
1965
 
        perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1966
 
        exitcode = EX_OSERR;
1967
 
#ifdef __linux__
1968
 
        if(restore_loglevel){
1969
 
          ret = klogctl(7, NULL, 0);
1970
 
          if(ret == -1){
1971
 
            perror_plus("klogctl");
 
2270
  /* If no interfaces were specified, make a list */
 
2271
  if(mc.interfaces == NULL){
 
2272
    struct dirent **direntries = NULL;
 
2273
    /* Look for any good interfaces */
 
2274
    ret = scandir(sys_class_net, &direntries, good_interface,
 
2275
                  alphasort);
 
2276
    if(ret >= 1){
 
2277
      /* Add all found interfaces to interfaces list */
 
2278
      for(int i = 0; i < ret; ++i){
 
2279
        ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
 
2280
                             direntries[i]->d_name);
 
2281
        if(ret_errno != 0){
 
2282
          errno = ret_errno;
 
2283
          perror_plus("argz_add");
 
2284
          free(direntries[i]);
 
2285
          continue;
 
2286
        }
 
2287
        if(debug){
 
2288
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
 
2289
                       direntries[i]->d_name);
 
2290
        }
 
2291
        free(direntries[i]);
 
2292
      }
 
2293
      free(direntries);
 
2294
    } else {
 
2295
      if(ret == 0){
 
2296
        free(direntries);
 
2297
      }
 
2298
      fprintf_plus(stderr, "Could not find a network interface\n");
 
2299
      exitcode = EXIT_FAILURE;
 
2300
      goto end;
 
2301
    }
 
2302
  }
 
2303
  
 
2304
  /* Bring up interfaces which are down, and remove any "none"s */
 
2305
  {
 
2306
    char *interface = NULL;
 
2307
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2308
                                 interface))){
 
2309
      /* If interface name is "none", stop bringing up interfaces.
 
2310
         Also remove all instances of "none" from the list */
 
2311
      if(strcmp(interface, "none") == 0){
 
2312
        argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2313
                    interface);
 
2314
        interface = NULL;
 
2315
        while((interface = argz_next(mc.interfaces,
 
2316
                                     mc.interfaces_size, interface))){
 
2317
          if(strcmp(interface, "none") == 0){
 
2318
            argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2319
                        interface);
 
2320
            interface = NULL;
1972
2321
          }
1973
2322
        }
1974
 
#endif  /* __linux__ */
1975
 
        /* Lower privileges */
1976
 
        errno = 0;
1977
 
        ret = seteuid(uid);
1978
 
        if(ret == -1){
1979
 
          perror_plus("seteuid");
1980
 
        }
1981
 
        goto end;
1982
 
      }
1983
 
    }
1984
 
    /* Sleep checking until interface is running.
1985
 
       Check every 0.25s, up to total time of delay */
1986
 
    for(int i=0; i < delay * 4; i++){
1987
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1988
 
      if(ret == -1){
1989
 
        perror_plus("ioctl SIOCGIFFLAGS");
1990
 
      } else if(network.ifr_flags & IFF_RUNNING){
1991
2323
        break;
1992
2324
      }
1993
 
      struct timespec sleeptime = { .tv_nsec = 250000000 };
1994
 
      ret = nanosleep(&sleeptime, NULL);
1995
 
      if(ret == -1 and errno != EINTR){
1996
 
        perror_plus("nanosleep");
1997
 
      }
1998
 
    }
1999
 
    if(not take_down_interface){
2000
 
      /* We won't need the socket anymore */
2001
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2002
 
      if(ret == -1){
2003
 
        perror_plus("close");
2004
 
      }
2005
 
    }
2006
 
#ifdef __linux__
2007
 
    if(restore_loglevel){
2008
 
      /* Restores kernel loglevel to default */
2009
 
      ret = klogctl(7, NULL, 0);
2010
 
      if(ret == -1){
2011
 
        perror_plus("klogctl");
2012
 
      }
2013
 
    }
2014
 
#endif  /* __linux__ */
2015
 
    /* Lower privileges */
2016
 
    errno = 0;
2017
 
    /* Lower privileges */
2018
 
    ret = seteuid(uid);
2019
 
    if(ret == -1){
2020
 
      perror_plus("seteuid");
2021
 
    }
 
2325
      bool interface_was_up = interface_is_up(interface);
 
2326
      errno = bring_up_interface(interface, delay);
 
2327
      if(not interface_was_up){
 
2328
        if(errno != 0){
 
2329
          perror_plus("Failed to bring up interface");
 
2330
        } else {
 
2331
          errno = argz_add(&interfaces_to_take_down,
 
2332
                           &interfaces_to_take_down_size,
 
2333
                           interface);
 
2334
          if(errno != 0){
 
2335
            perror_plus("argz_add");
 
2336
          }
 
2337
        }
 
2338
      }
 
2339
    }
 
2340
    if(debug and (interfaces_to_take_down == NULL)){
 
2341
      fprintf_plus(stderr, "No interfaces were brought up\n");
 
2342
    }
 
2343
  }
 
2344
  
 
2345
  /* If we only got one interface, explicitly use only that one */
 
2346
  if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
 
2347
    if(debug){
 
2348
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
 
2349
                   mc.interfaces);
 
2350
    }
 
2351
    if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2022
2352
  }
2023
2353
  
2024
2354
  if(quit_now){
2025
2355
    goto end;
2026
2356
  }
2027
2357
  
2028
 
  ret = init_gnutls_global(pubkey, seckey);
 
2358
  ret = init_gnutls_global(pubkey, seckey, &mc);
2029
2359
  if(ret == -1){
2030
2360
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2031
2361
    exitcode = EX_UNAVAILABLE;
2038
2368
    goto end;
2039
2369
  }
2040
2370
  
2041
 
  if(mkdtemp(tempdir) == NULL){
 
2371
  /* Try /run/tmp before /tmp */
 
2372
  tempdir = mkdtemp(run_tempdir);
 
2373
  if(tempdir == NULL and errno == ENOENT){
 
2374
      if(debug){
 
2375
        fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
 
2376
                     run_tempdir, old_tempdir);
 
2377
      }
 
2378
      tempdir = mkdtemp(old_tempdir);
 
2379
  }
 
2380
  if(tempdir == NULL){
2042
2381
    perror_plus("mkdtemp");
2043
2382
    goto end;
2044
2383
  }
2045
 
  tempdir_created = true;
2046
2384
  
2047
2385
  if(quit_now){
2048
2386
    goto end;
2049
2387
  }
2050
2388
  
2051
 
  if(not init_gpgme(pubkey, seckey, tempdir)){
 
2389
  if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2052
2390
    fprintf_plus(stderr, "init_gpgme failed\n");
2053
2391
    exitcode = EX_UNAVAILABLE;
2054
2392
    goto end;
2064
2402
    /* Connect directly, do not use Zeroconf */
2065
2403
    /* (Mainly meant for debugging) */
2066
2404
    char *address = strrchr(connect_to, ':');
 
2405
    
2067
2406
    if(address == NULL){
2068
2407
      fprintf_plus(stderr, "No colon in address\n");
2069
2408
      exitcode = EX_USAGE;
2074
2413
      goto end;
2075
2414
    }
2076
2415
    
2077
 
    uint16_t port;
 
2416
    in_port_t port;
2078
2417
    errno = 0;
2079
2418
    tmpmax = strtoimax(address+1, &tmp, 10);
2080
2419
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
2081
 
       or tmpmax != (uint16_t)tmpmax){
 
2420
       or tmpmax != (in_port_t)tmpmax){
2082
2421
      fprintf_plus(stderr, "Bad port number\n");
2083
2422
      exitcode = EX_USAGE;
2084
2423
      goto end;
2085
2424
    }
2086
 
  
 
2425
    
2087
2426
    if(quit_now){
2088
2427
      goto end;
2089
2428
    }
2090
2429
    
2091
 
    port = (uint16_t)tmpmax;
 
2430
    port = (in_port_t)tmpmax;
2092
2431
    *address = '\0';
2093
2432
    /* Colon in address indicates IPv6 */
2094
2433
    int af;
2110
2449
    }
2111
2450
    
2112
2451
    while(not quit_now){
2113
 
      ret = start_mandos_communication(address, port, if_index, af);
 
2452
      ret = start_mandos_communication(address, port, if_index, af,
 
2453
                                       &mc);
2114
2454
      if(quit_now or ret == 0){
2115
2455
        break;
2116
2456
      }
2118
2458
        fprintf_plus(stderr, "Retrying in %d seconds\n",
2119
2459
                     (int)retry_interval);
2120
2460
      }
2121
 
      sleep((int)retry_interval);
 
2461
      sleep((unsigned int)retry_interval);
2122
2462
    }
2123
2463
    
2124
 
    if (not quit_now){
 
2464
    if(not quit_now){
2125
2465
      exitcode = EXIT_SUCCESS;
2126
2466
    }
2127
2467
    
2142
2482
    config.publish_domain = 0;
2143
2483
    
2144
2484
    /* Allocate a new server */
2145
 
    mc.server = avahi_server_new(avahi_simple_poll_get
2146
 
                                 (mc.simple_poll), &config, NULL,
2147
 
                                 NULL, &error);
 
2485
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
2486
                                 &config, NULL, NULL, &ret_errno);
2148
2487
    
2149
2488
    /* Free the Avahi configuration data */
2150
2489
    avahi_server_config_free(&config);
2153
2492
  /* Check if creating the Avahi server object succeeded */
2154
2493
  if(mc.server == NULL){
2155
2494
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2156
 
                 avahi_strerror(error));
 
2495
                 avahi_strerror(ret_errno));
2157
2496
    exitcode = EX_UNAVAILABLE;
2158
2497
    goto end;
2159
2498
  }
2165
2504
  /* Create the Avahi service browser */
2166
2505
  sb = avahi_s_service_browser_new(mc.server, if_index,
2167
2506
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2168
 
                                   NULL, 0, browse_callback, NULL);
 
2507
                                   NULL, 0, browse_callback,
 
2508
                                   (void *)&mc);
2169
2509
  if(sb == NULL){
2170
2510
    fprintf_plus(stderr, "Failed to create service browser: %s\n",
2171
2511
                 avahi_strerror(avahi_server_errno(mc.server)));
2182
2522
  if(debug){
2183
2523
    fprintf_plus(stderr, "Starting Avahi loop search\n");
2184
2524
  }
2185
 
 
2186
 
  ret = avahi_loop_with_timeout(mc.simple_poll,
2187
 
                                (int)(retry_interval * 1000));
 
2525
  
 
2526
  ret = avahi_loop_with_timeout(simple_poll,
 
2527
                                (int)(retry_interval * 1000), &mc);
2188
2528
  if(debug){
2189
2529
    fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2190
2530
                 (ret == 0) ? "successfully" : "with error");
2197
2537
  }
2198
2538
  
2199
2539
  /* Cleanup things */
 
2540
  free(mc.interfaces);
 
2541
  
2200
2542
  if(sb != NULL)
2201
2543
    avahi_s_service_browser_free(sb);
2202
2544
  
2203
2545
  if(mc.server != NULL)
2204
2546
    avahi_server_free(mc.server);
2205
2547
  
2206
 
  if(mc.simple_poll != NULL)
2207
 
    avahi_simple_poll_free(mc.simple_poll);
 
2548
  if(simple_poll != NULL)
 
2549
    avahi_simple_poll_free(simple_poll);
2208
2550
  
2209
2551
  if(gnutls_initialized){
2210
2552
    gnutls_certificate_free_credentials(mc.cred);
2222
2564
    mc.current_server->prev->next = NULL;
2223
2565
    while(mc.current_server != NULL){
2224
2566
      server *next = mc.current_server->next;
 
2567
#ifdef __GNUC__
 
2568
#pragma GCC diagnostic push
 
2569
#pragma GCC diagnostic ignored "-Wcast-qual"
 
2570
#endif
 
2571
      free((char *)(mc.current_server->ip));
 
2572
#ifdef __GNUC__
 
2573
#pragma GCC diagnostic pop
 
2574
#endif
2225
2575
      free(mc.current_server);
2226
2576
      mc.current_server = next;
2227
2577
    }
2228
2578
  }
2229
2579
  
2230
 
  /* Run network hooks */
2231
 
  run_network_hooks("stop", interface, delay);
2232
 
  
2233
 
  /* Re-raise priviliges */
 
2580
  /* Re-raise privileges */
2234
2581
  {
2235
 
    errno = 0;
2236
 
    ret = seteuid(0);
2237
 
    if(ret == -1){
2238
 
      perror_plus("seteuid");
 
2582
    ret_errno = raise_privileges();
 
2583
    if(ret_errno != 0){
 
2584
      errno = ret_errno;
 
2585
      perror_plus("Failed to raise privileges");
 
2586
    } else {
 
2587
      
 
2588
      /* Run network hooks */
 
2589
      run_network_hooks("stop", interfaces_hooks != NULL ?
 
2590
                        interfaces_hooks : "", delay);
 
2591
      
 
2592
      /* Take down the network interfaces which were brought up */
 
2593
      {
 
2594
        char *interface = NULL;
 
2595
        while((interface=argz_next(interfaces_to_take_down,
 
2596
                                   interfaces_to_take_down_size,
 
2597
                                   interface))){
 
2598
          ret_errno = take_down_interface(interface);
 
2599
          if(ret_errno != 0){
 
2600
            errno = ret_errno;
 
2601
            perror_plus("Failed to take down interface");
 
2602
          }
 
2603
        }
 
2604
        if(debug and (interfaces_to_take_down == NULL)){
 
2605
          fprintf_plus(stderr, "No interfaces needed to be taken"
 
2606
                       " down\n");
 
2607
        }
 
2608
      }
2239
2609
    }
2240
2610
    
2241
 
    /* Take down the network interface */
2242
 
    if(take_down_interface and geteuid() == 0){
2243
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
2244
 
      if(ret == -1){
2245
 
        perror_plus("ioctl SIOCGIFFLAGS");
2246
 
      } else if(network.ifr_flags & IFF_UP){
2247
 
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2248
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
2249
 
        if(ret == -1){
2250
 
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2251
 
        }
2252
 
      }
2253
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2254
 
      if(ret == -1){
2255
 
        perror_plus("close");
2256
 
      }
 
2611
    ret_errno = lower_privileges_permanently();
 
2612
    if(ret_errno != 0){
 
2613
      errno = ret_errno;
 
2614
      perror_plus("Failed to lower privileges permanently");
2257
2615
    }
2258
2616
  }
2259
 
  /* Lower privileges permanently */
2260
 
  errno = 0;
2261
 
  ret = setuid(uid);
2262
 
  if(ret == -1){
2263
 
    perror_plus("setuid");
2264
 
  }
 
2617
  
 
2618
  free(interfaces_to_take_down);
 
2619
  free(interfaces_hooks);
2265
2620
  
2266
2621
  /* Removes the GPGME temp directory and all files inside */
2267
 
  if(tempdir_created){
 
2622
  if(tempdir != NULL){
2268
2623
    struct dirent **direntries = NULL;
2269
 
    struct dirent *direntry = NULL;
2270
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2271
 
                             alphasort);
2272
 
    if (numentries > 0){
2273
 
      for(int i = 0; i < numentries; i++){
2274
 
        direntry = direntries[i];
2275
 
        char *fullname = NULL;
2276
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2277
 
                       direntry->d_name);
2278
 
        if(ret < 0){
2279
 
          perror_plus("asprintf");
2280
 
          continue;
2281
 
        }
2282
 
        ret = remove(fullname);
2283
 
        if(ret == -1){
2284
 
          fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2285
 
                       strerror(errno));
2286
 
        }
2287
 
        free(fullname);
 
2624
    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
 
2625
                                                  O_NOFOLLOW));
 
2626
    if(tempdir_fd == -1){
 
2627
      perror_plus("open");
 
2628
    } else {
 
2629
#ifdef __GLIBC__
 
2630
#if __GLIBC_PREREQ(2, 15)
 
2631
      int numentries = scandirat(tempdir_fd, ".", &direntries,
 
2632
                                 notdotentries, alphasort);
 
2633
#else  /* not __GLIBC_PREREQ(2, 15) */
 
2634
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2635
                               alphasort);
 
2636
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
2637
#else   /* not __GLIBC__ */
 
2638
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2639
                               alphasort);
 
2640
#endif  /* not __GLIBC__ */
 
2641
      if(numentries >= 0){
 
2642
        for(int i = 0; i < numentries; i++){
 
2643
          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
 
2644
          if(ret == -1){
 
2645
            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
 
2646
                         " \"%s\", 0): %s\n", tempdir,
 
2647
                         direntries[i]->d_name, strerror(errno));
 
2648
          }
 
2649
          free(direntries[i]);
 
2650
        }
 
2651
        
 
2652
        /* need to clean even if 0 because man page doesn't specify */
 
2653
        free(direntries);
 
2654
        if(numentries == -1){
 
2655
          perror_plus("scandir");
 
2656
        }
 
2657
        ret = rmdir(tempdir);
 
2658
        if(ret == -1 and errno != ENOENT){
 
2659
          perror_plus("rmdir");
 
2660
        }
2288
2661
      }
2289
 
    }
2290
 
 
2291
 
    /* need to clean even if 0 because man page doesn't specify */
2292
 
    free(direntries);
2293
 
    if (numentries == -1){
2294
 
      perror_plus("scandir");
2295
 
    }
2296
 
    ret = rmdir(tempdir);
2297
 
    if(ret == -1 and errno != ENOENT){
2298
 
      perror_plus("rmdir");
 
2662
      TEMP_FAILURE_RETRY(close(tempdir_fd));
2299
2663
    }
2300
2664
  }
2301
2665