/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-2013 Teddy Hogeborn
13
 
 * Copyright © 2008-2013 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() */
 
43
                                   stdout, ferror() */
44
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(),
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,
72
73
                                */
73
74
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
74
75
                                   getuid(), getgid(), seteuid(),
75
 
                                   setgid(), pause(), _exit() */
76
 
#include <arpa/inet.h>          /* inet_pton(), htons, inet_ntop() */
 
76
                                   setgid(), pause(), _exit(),
 
77
                                   unlinkat() */
 
78
#include <arpa/inet.h>          /* inet_pton(), htons() */
77
79
#include <iso646.h>             /* not, or, and */
78
80
#include <argp.h>               /* struct argp_option, error_t, struct
79
81
                                   argp_state, struct argp,
91
93
                                   argz_delete(), argz_append(),
92
94
                                   argz_stringify(), argz_add(),
93
95
                                   argz_count() */
 
96
#include <netdb.h>              /* getnameinfo(), NI_NUMERICHOST,
 
97
                                   EAI_SYSTEM, gai_strerror() */
94
98
 
95
99
#ifdef __linux__
96
100
#include <sys/klog.h>           /* klogctl() */
138
142
static const char sys_class_net[] = "/sys/class/net";
139
143
char *connect_to = NULL;
140
144
const char *hookdir = HOOKDIR;
 
145
int hookdir_fd = -1;
141
146
uid_t uid = 65534;
142
147
gid_t gid = 65534;
143
148
 
180
185
  perror(print_text);
181
186
}
182
187
 
183
 
__attribute__((format (gnu_printf, 2, 3)))
 
188
__attribute__((format (gnu_printf, 2, 3), nonnull))
184
189
int fprintf_plus(FILE *stream, const char *format, ...){
185
190
  va_list ap;
186
191
  va_start (ap, format);
195
200
 * bytes. "buffer_capacity" is how much is currently allocated,
196
201
 * "buffer_length" is how much is already used.
197
202
 */
 
203
__attribute__((nonnull, warn_unused_result))
198
204
size_t incbuffer(char **buffer, size_t buffer_length,
199
205
                 size_t buffer_capacity){
200
206
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
201
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
202
 
    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;
203
213
      return 0;
204
214
    }
 
215
    *buffer = new_buf;
205
216
    buffer_capacity += BUFFER_SIZE;
206
217
  }
207
218
  return buffer_capacity;
208
219
}
209
220
 
210
221
/* Add server to set of servers to retry periodically */
 
222
__attribute__((nonnull, warn_unused_result))
211
223
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
212
224
                int af, server **current_server){
213
225
  int ret;
222
234
                          .af = af };
223
235
  if(new_server->ip == NULL){
224
236
    perror_plus("strdup");
 
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);
225
252
    return false;
226
253
  }
227
254
  /* Special case of first server */
229
256
    new_server->next = new_server;
230
257
    new_server->prev = new_server;
231
258
    *current_server = new_server;
232
 
  /* Place the new server last in the list */
233
259
  } else {
 
260
    /* Place the new server last in the list */
234
261
    new_server->next = *current_server;
235
262
    new_server->prev = (*current_server)->prev;
236
263
    new_server->prev->next = new_server;
237
264
    (*current_server)->prev = new_server;
238
265
  }
239
 
  ret = clock_gettime(CLOCK_MONOTONIC, &(*current_server)->last_seen);
240
 
  if(ret == -1){
241
 
    perror_plus("clock_gettime");
242
 
    return false;
243
 
  }
244
266
  return true;
245
267
}
246
268
 
247
269
/* 
248
270
 * Initialize GPGME.
249
271
 */
250
 
static bool init_gpgme(const char *seckey, const char *pubkey,
251
 
                       const char *tempdir, mandos_context *mc){
 
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){
252
277
  gpgme_error_t rc;
253
278
  gpgme_engine_info_t engine_info;
254
279
  
255
280
  /*
256
281
   * Helper function to insert pub and seckey to the engine keyring.
257
282
   */
258
 
  bool import_key(const char *filename){
 
283
  bool import_key(const char * const filename){
259
284
    int ret;
260
285
    int fd;
261
286
    gpgme_data_t pgp_data;
342
367
 * Decrypt OpenPGP data.
343
368
 * Returns -1 on error
344
369
 */
 
370
__attribute__((nonnull, warn_unused_result))
345
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
346
372
                                  size_t crypto_size,
347
373
                                  char **plaintext,
467
493
  return plaintext_length;
468
494
}
469
495
 
470
 
static const char * safer_gnutls_strerror(int value){
 
496
__attribute__((warn_unused_result))
 
497
static const char *safer_gnutls_strerror(int value){
471
498
  const char *ret = gnutls_strerror(value);
472
499
  if(ret == NULL)
473
500
    ret = "(unknown)";
475
502
}
476
503
 
477
504
/* GnuTLS log function callback */
 
505
__attribute__((nonnull))
478
506
static void debuggnutls(__attribute__((unused)) int level,
479
507
                        const char* string){
480
508
  fprintf_plus(stderr, "GnuTLS: %s", string);
481
509
}
482
510
 
 
511
__attribute__((nonnull, warn_unused_result))
483
512
static int init_gnutls_global(const char *pubkeyfilename,
484
513
                              const char *seckeyfilename,
485
514
                              mandos_context *mc){
559
588
  return -1;
560
589
}
561
590
 
 
591
__attribute__((nonnull, warn_unused_result))
562
592
static int init_gnutls_session(gnutls_session_t *session,
563
593
                               mandos_context *mc){
564
594
  int ret;
621
651
                      __attribute__((unused)) const char *txt){}
622
652
 
623
653
/* Called when a Mandos server is found */
 
654
__attribute__((nonnull, warn_unused_result))
624
655
static int start_mandos_communication(const char *ip, in_port_t port,
625
656
                                      AvahiIfIndex if_index,
626
657
                                      int af, mandos_context *mc){
627
658
  int ret, tcp_sd = -1;
628
659
  ssize_t sret;
629
 
  union {
630
 
    struct sockaddr_in in;
631
 
    struct sockaddr_in6 in6;
632
 
  } to;
 
660
  struct sockaddr_storage to;
633
661
  char *buffer = NULL;
634
662
  char *decrypted_buffer = NULL;
635
663
  size_t buffer_length = 0;
716
744
  
717
745
  memset(&to, 0, sizeof(to));
718
746
  if(af == AF_INET6){
719
 
    to.in6.sin6_family = (sa_family_t)af;
720
 
    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);
721
749
  } else {                      /* IPv4 */
722
 
    to.in.sin_family = (sa_family_t)af;
723
 
    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);
724
752
  }
725
753
  if(ret < 0 ){
726
754
    int e = errno;
735
763
    goto mandos_end;
736
764
  }
737
765
  if(af == AF_INET6){
738
 
    to.in6.sin6_port = htons(port);    
739
 
#ifdef __GNUC__
740
 
#pragma GCC diagnostic push
741
 
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
742
 
#endif
743
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
744
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower */
745
 
#ifdef __GNUC__
746
 
#pragma GCC diagnostic pop
747
 
#endif
 
766
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
767
    if(IN6_IS_ADDR_LINKLOCAL
 
768
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
748
769
      if(if_index == AVAHI_IF_UNSPEC){
749
770
        fprintf_plus(stderr, "An IPv6 link-local address is"
750
771
                     " incomplete without a network interface\n");
752
773
        goto mandos_end;
753
774
      }
754
775
      /* Set the network interface number as scope */
755
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
776
      ((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
756
777
    }
757
778
  } else {
758
 
    to.in.sin_port = htons(port);
 
779
    ((struct sockaddr_in *)&to)->sin_port = htons(port);
759
780
  }
760
781
  
761
782
  if(quit_now){
778
799
    }
779
800
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
780
801
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
781
 
    const char *pcret;
782
802
    if(af == AF_INET6){
783
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
784
 
                        sizeof(addrstr));
 
803
      ret = getnameinfo((struct sockaddr *)&to,
 
804
                        sizeof(struct sockaddr_in6),
 
805
                        addrstr, sizeof(addrstr), NULL, 0,
 
806
                        NI_NUMERICHOST);
785
807
    } else {
786
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
787
 
                        sizeof(addrstr));
 
808
      ret = getnameinfo((struct sockaddr *)&to,
 
809
                        sizeof(struct sockaddr_in),
 
810
                        addrstr, sizeof(addrstr), NULL, 0,
 
811
                        NI_NUMERICHOST);
788
812
    }
789
 
    if(pcret == NULL){
790
 
      perror_plus("inet_ntop");
791
 
    } else {
792
 
      if(strcmp(addrstr, ip) != 0){
793
 
        fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
794
 
      }
 
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);
795
819
    }
796
820
  }
797
821
  
801
825
  }
802
826
  
803
827
  if(af == AF_INET6){
804
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
 
828
    ret = connect(tcp_sd, (struct sockaddr *)&to,
 
829
                  sizeof(struct sockaddr_in6));
805
830
  } else {
806
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
 
831
    ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
832
                  sizeof(struct sockaddr_in));
807
833
  }
808
834
  if(ret < 0){
809
 
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
 
835
    if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
810
836
      int e = errno;
811
837
      perror_plus("connect");
812
838
      errno = e;
1027
1053
  return retval;
1028
1054
}
1029
1055
 
 
1056
__attribute__((nonnull))
1030
1057
static void resolve_callback(AvahiSServiceResolver *r,
1031
1058
                             AvahiIfIndex interface,
1032
1059
                             AvahiProtocol proto,
1040
1067
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
1041
1068
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
1042
1069
                             flags,
1043
 
                             void* mc){
 
1070
                             void *mc){
1044
1071
  if(r == NULL){
1045
1072
    return;
1046
1073
  }
1049
1076
     timed out */
1050
1077
  
1051
1078
  if(quit_now){
 
1079
    avahi_s_service_resolver_free(r);
1052
1080
    return;
1053
1081
  }
1054
1082
  
1099
1127
                            const char *domain,
1100
1128
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1101
1129
                            flags,
1102
 
                            void* mc){
 
1130
                            void *mc){
1103
1131
  if(b == NULL){
1104
1132
    return;
1105
1133
  }
1165
1193
  errno = old_errno;
1166
1194
}
1167
1195
 
 
1196
__attribute__((nonnull, warn_unused_result))
1168
1197
bool get_flags(const char *ifname, struct ifreq *ifr){
1169
1198
  int ret;
1170
1199
  error_t ret_errno;
1189
1218
  return true;
1190
1219
}
1191
1220
 
 
1221
__attribute__((nonnull, warn_unused_result))
1192
1222
bool good_flags(const char *ifname, const struct ifreq *ifr){
1193
1223
  
1194
1224
  /* Reject the loopback device */
1236
1266
 * corresponds to an acceptable network device.
1237
1267
 * (This function is passed to scandir(3) as a filter function.)
1238
1268
 */
 
1269
__attribute__((nonnull, warn_unused_result))
1239
1270
int good_interface(const struct dirent *if_entry){
1240
1271
  if(if_entry->d_name[0] == '.'){
1241
1272
    return 0;
1259
1290
/* 
1260
1291
 * This function determines if a network interface is up.
1261
1292
 */
 
1293
__attribute__((nonnull, warn_unused_result))
1262
1294
bool interface_is_up(const char *interface){
1263
1295
  struct ifreq ifr;
1264
1296
  if(not get_flags(interface, &ifr)){
1275
1307
/* 
1276
1308
 * This function determines if a network interface is running
1277
1309
 */
 
1310
__attribute__((nonnull, warn_unused_result))
1278
1311
bool interface_is_running(const char *interface){
1279
1312
  struct ifreq ifr;
1280
1313
  if(not get_flags(interface, &ifr)){
1288
1321
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
1289
1322
}
1290
1323
 
 
1324
__attribute__((nonnull, pure, warn_unused_result))
1291
1325
int notdotentries(const struct dirent *direntry){
1292
1326
  /* Skip "." and ".." */
1293
1327
  if(direntry->d_name[0] == '.'
1300
1334
}
1301
1335
 
1302
1336
/* Is this directory entry a runnable program? */
 
1337
__attribute__((nonnull, warn_unused_result))
1303
1338
int runnable_hook(const struct dirent *direntry){
1304
1339
  int ret;
1305
1340
  size_t sret;
1313
1348
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1314
1349
                "abcdefghijklmnopqrstuvwxyz"
1315
1350
                "0123456789"
1316
 
                "_-");
 
1351
                "_.-");
1317
1352
  if((direntry->d_name)[sret] != '\0'){
1318
1353
    /* Contains non-allowed characters */
1319
1354
    if(debug){
1323
1358
    return 0;
1324
1359
  }
1325
1360
  
1326
 
  char *fullname = NULL;
1327
 
  ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1328
 
  if(ret < 0){
1329
 
    perror_plus("asprintf");
1330
 
    return 0;
1331
 
  }
1332
 
  
1333
 
  ret = stat(fullname, &st);
 
1361
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1334
1362
  if(ret == -1){
1335
1363
    if(debug){
1336
1364
      perror_plus("Could not stat hook");
1360
1388
  return 1;
1361
1389
}
1362
1390
 
 
1391
__attribute__((nonnull, warn_unused_result))
1363
1392
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1364
1393
                            mandos_context *mc){
1365
1394
  int ret;
1369
1398
  
1370
1399
  while(true){
1371
1400
    if(mc->current_server == NULL){
1372
 
      if (debug){
 
1401
      if(debug){
1373
1402
        fprintf_plus(stderr, "Wait until first server is found."
1374
1403
                     " No timeout!\n");
1375
1404
      }
1376
1405
      ret = avahi_simple_poll_iterate(s, -1);
1377
1406
    } else {
1378
 
      if (debug){
 
1407
      if(debug){
1379
1408
        fprintf_plus(stderr, "Check current_server if we should run"
1380
1409
                     " it, or wait\n");
1381
1410
      }
1398
1427
                     - ((intmax_t)waited_time.tv_sec * 1000))
1399
1428
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1400
1429
      
1401
 
      if (debug){
 
1430
      if(debug){
1402
1431
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1403
1432
                     block_time);
1404
1433
      }
1426
1455
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1427
1456
    }
1428
1457
    if(ret != 0){
1429
 
      if (ret > 0 or errno != EINTR){
 
1458
      if(ret > 0 or errno != EINTR){
1430
1459
        return (ret != 1) ? ret : 0;
1431
1460
      }
1432
1461
    }
1434
1463
}
1435
1464
 
1436
1465
/* Set effective uid to 0, return errno */
 
1466
__attribute__((warn_unused_result))
1437
1467
error_t raise_privileges(void){
1438
1468
  error_t old_errno = errno;
1439
1469
  error_t ret_errno = 0;
1440
1470
  if(seteuid(0) == -1){
1441
1471
    ret_errno = errno;
1442
 
    perror_plus("seteuid");
1443
1472
  }
1444
1473
  errno = old_errno;
1445
1474
  return ret_errno;
1446
1475
}
1447
1476
 
1448
1477
/* Set effective and real user ID to 0.  Return errno. */
 
1478
__attribute__((warn_unused_result))
1449
1479
error_t raise_privileges_permanently(void){
1450
1480
  error_t old_errno = errno;
1451
1481
  error_t ret_errno = raise_privileges();
1455
1485
  }
1456
1486
  if(setuid(0) == -1){
1457
1487
    ret_errno = errno;
1458
 
    perror_plus("seteuid");
1459
1488
  }
1460
1489
  errno = old_errno;
1461
1490
  return ret_errno;
1462
1491
}
1463
1492
 
1464
1493
/* Set effective user ID to unprivileged saved user ID */
 
1494
__attribute__((warn_unused_result))
1465
1495
error_t lower_privileges(void){
1466
1496
  error_t old_errno = errno;
1467
1497
  error_t ret_errno = 0;
1468
1498
  if(seteuid(uid) == -1){
1469
1499
    ret_errno = errno;
1470
 
    perror_plus("seteuid");
1471
1500
  }
1472
1501
  errno = old_errno;
1473
1502
  return ret_errno;
1474
1503
}
1475
1504
 
1476
1505
/* Lower privileges permanently */
 
1506
__attribute__((warn_unused_result))
1477
1507
error_t lower_privileges_permanently(void){
1478
1508
  error_t old_errno = errno;
1479
1509
  error_t ret_errno = 0;
1480
1510
  if(setuid(uid) == -1){
1481
1511
    ret_errno = errno;
1482
 
    perror_plus("setuid");
1483
1512
  }
1484
1513
  errno = old_errno;
1485
1514
  return ret_errno;
1486
1515
}
1487
1516
 
1488
 
bool run_network_hooks(const char *mode, const char *interface,
 
1517
__attribute__((nonnull))
 
1518
void run_network_hooks(const char *mode, const char *interface,
1489
1519
                       const float delay){
1490
 
  struct dirent **direntries;
 
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__ */
 
1547
  if(numhooks == -1){
 
1548
    perror_plus("scandir");
 
1549
    return;
 
1550
  }
1491
1551
  struct dirent *direntry;
1492
1552
  int ret;
1493
 
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1494
 
                         alphasort);
1495
 
  if(numhooks == -1){
1496
 
    if(errno == ENOENT){
1497
 
      if(debug){
1498
 
        fprintf_plus(stderr, "Network hook directory \"%s\" not"
1499
 
                     " found\n", hookdir);
1500
 
      }
1501
 
    } else {
1502
 
      perror_plus("scandir");
 
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);
1503
1559
    }
1504
 
  } else {
1505
 
    int devnull = open("/dev/null", O_RDONLY);
1506
 
    for(int i = 0; i < numhooks; i++){
1507
 
      direntry = direntries[i];
1508
 
      char *fullname = NULL;
1509
 
      ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1510
 
      if(ret < 0){
 
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){
1511
1621
        perror_plus("asprintf");
1512
 
        continue;
1513
 
      }
1514
 
      if(debug){
1515
 
        fprintf_plus(stderr, "Running network hook \"%s\"\n",
1516
 
                     direntry->d_name);
1517
 
      }
1518
 
      pid_t hook_pid = fork();
1519
 
      if(hook_pid == 0){
1520
 
        /* Child */
1521
 
        /* Raise privileges */
1522
 
        raise_privileges_permanently();
1523
 
        /* Set group */
1524
 
        errno = 0;
1525
 
        ret = setgid(0);
1526
 
        if(ret == -1){
1527
 
          perror_plus("setgid");
1528
 
        }
1529
 
        /* Reset supplementary groups */
1530
 
        errno = 0;
1531
 
        ret = setgroups(0, NULL);
1532
 
        if(ret == -1){
1533
 
          perror_plus("setgroups");
1534
 
        }
1535
 
        dup2(devnull, STDIN_FILENO);
1536
 
        close(devnull);
1537
 
        dup2(STDERR_FILENO, STDOUT_FILENO);
1538
 
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1539
 
        if(ret == -1){
1540
 
          perror_plus("setenv");
1541
 
          _exit(EX_OSERR);
1542
 
        }
1543
 
        ret = setenv("DEVICE", interface, 1);
1544
 
        if(ret == -1){
1545
 
          perror_plus("setenv");
1546
 
          _exit(EX_OSERR);
1547
 
        }
1548
 
        ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1549
 
        if(ret == -1){
1550
 
          perror_plus("setenv");
1551
 
          _exit(EX_OSERR);
1552
 
        }
1553
 
        ret = setenv("MODE", mode, 1);
1554
 
        if(ret == -1){
1555
 
          perror_plus("setenv");
1556
 
          _exit(EX_OSERR);
1557
 
        }
1558
 
        char *delaystring;
1559
 
        ret = asprintf(&delaystring, "%f", delay);
1560
 
        if(ret == -1){
1561
 
          perror_plus("asprintf");
1562
 
          _exit(EX_OSERR);
1563
 
        }
1564
 
        ret = setenv("DELAY", delaystring, 1);
1565
 
        if(ret == -1){
1566
 
          free(delaystring);
1567
 
          perror_plus("setenv");
1568
 
          _exit(EX_OSERR);
1569
 
        }
 
1622
        _exit(EX_OSERR);
 
1623
      }
 
1624
      ret = setenv("DELAY", delaystring, 1);
 
1625
      if(ret == -1){
1570
1626
        free(delaystring);
1571
 
        if(connect_to != NULL){
1572
 
          ret = setenv("CONNECT", connect_to, 1);
1573
 
          if(ret == -1){
1574
 
            perror_plus("setenv");
1575
 
            _exit(EX_OSERR);
1576
 
          }
1577
 
        }
1578
 
        if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1579
 
          perror_plus("execl");
1580
 
          _exit(EXIT_FAILURE);
1581
 
        }
 
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;
1582
1673
      } else {
1583
 
        int status;
1584
 
        if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1585
 
          perror_plus("waitpid");
1586
 
          free(fullname);
1587
 
          continue;
1588
 
        }
1589
 
        if(WIFEXITED(status)){
1590
 
          if(WEXITSTATUS(status) != 0){
1591
 
            fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1592
 
                         " with status %d\n", direntry->d_name,
1593
 
                         WEXITSTATUS(status));
1594
 
            free(fullname);
1595
 
            continue;
1596
 
          }
1597
 
        } else if(WIFSIGNALED(status)){
1598
 
          fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1599
 
                       " signal %d\n", direntry->d_name,
1600
 
                       WTERMSIG(status));
1601
 
          free(fullname);
1602
 
          continue;
1603
 
        } else {
1604
 
          fprintf_plus(stderr, "Warning: network hook \"%s\""
1605
 
                       " crashed\n", direntry->d_name);
1606
 
          free(fullname);
1607
 
          continue;
1608
 
        }
1609
 
      }
1610
 
      free(fullname);
1611
 
      if(debug){
1612
 
        fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1613
 
                     direntry->d_name);
1614
 
      }
1615
 
    }
1616
 
    close(devnull);
1617
 
  }
1618
 
  return true;
 
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);
1619
1693
}
1620
1694
 
 
1695
__attribute__((nonnull, warn_unused_result))
1621
1696
error_t bring_up_interface(const char *const interface,
1622
1697
                           const float delay){
1623
 
  int sd = -1;
1624
1698
  error_t old_errno = errno;
1625
 
  error_t ret_errno = 0;
1626
 
  int ret, ret_setflags;
 
1699
  int ret;
1627
1700
  struct ifreq network;
1628
1701
  unsigned int if_index = if_nametoindex(interface);
1629
1702
  if(if_index == 0){
1638
1711
  }
1639
1712
  
1640
1713
  if(not interface_is_up(interface)){
1641
 
    if(not get_flags(interface, &network) and debug){
 
1714
    error_t ret_errno = 0, ioctl_errno = 0;
 
1715
    if(not get_flags(interface, &network)){
1642
1716
      ret_errno = errno;
1643
1717
      fprintf_plus(stderr, "Failed to get flags for interface "
1644
1718
                   "\"%s\"\n", interface);
 
1719
      errno = old_errno;
1645
1720
      return ret_errno;
1646
1721
    }
1647
 
    network.ifr_flags |= IFF_UP;
 
1722
    network.ifr_flags |= IFF_UP; /* set flag */
1648
1723
    
1649
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1650
 
    if(sd < 0){
 
1724
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1725
    if(sd == -1){
1651
1726
      ret_errno = errno;
1652
1727
      perror_plus("socket");
1653
1728
      errno = old_errno;
1654
1729
      return ret_errno;
1655
1730
    }
1656
 
  
 
1731
    
1657
1732
    if(quit_now){
1658
 
      close(sd);
 
1733
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1734
      if(ret == -1){
 
1735
        perror_plus("close");
 
1736
      }
1659
1737
      errno = old_errno;
1660
1738
      return EINTR;
1661
1739
    }
1665
1743
                   interface);
1666
1744
    }
1667
1745
    
1668
 
    /* Raise priviliges */
1669
 
    raise_privileges();
 
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
    }
1670
1752
    
1671
1753
#ifdef __linux__
1672
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1673
 
       messages about the network interface to mess up the prompt */
1674
 
    int ret_linux = klogctl(8, NULL, 5);
1675
 
    bool restore_loglevel = true;
1676
 
    if(ret_linux == -1){
1677
 
      restore_loglevel = false;
1678
 
      perror_plus("klogctl");
 
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
      }
1679
1765
    }
1680
1766
#endif  /* __linux__ */
1681
 
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1682
 
    ret_errno = errno;
 
1767
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1768
    ioctl_errno = errno;
1683
1769
#ifdef __linux__
1684
1770
    if(restore_loglevel){
1685
1771
      ret_linux = klogctl(7, NULL, 0);
1689
1775
    }
1690
1776
#endif  /* __linux__ */
1691
1777
    
1692
 
    /* Lower privileges */
1693
 
    lower_privileges();
 
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
    }
1694
1787
    
1695
1788
    /* Close the socket */
1696
1789
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
1699
1792
    }
1700
1793
    
1701
1794
    if(ret_setflags == -1){
1702
 
      errno = ret_errno;
 
1795
      errno = ioctl_errno;
1703
1796
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1704
1797
      errno = old_errno;
1705
 
      return ret_errno;
 
1798
      return ioctl_errno;
1706
1799
    }
1707
1800
  } else if(debug){
1708
1801
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1726
1819
  return 0;
1727
1820
}
1728
1821
 
 
1822
__attribute__((nonnull, warn_unused_result))
1729
1823
error_t take_down_interface(const char *const interface){
1730
 
  int sd = -1;
1731
1824
  error_t old_errno = errno;
1732
 
  error_t ret_errno = 0;
1733
 
  int ret, ret_setflags;
1734
1825
  struct ifreq network;
1735
1826
  unsigned int if_index = if_nametoindex(interface);
1736
1827
  if(if_index == 0){
1739
1830
    return ENXIO;
1740
1831
  }
1741
1832
  if(interface_is_up(interface)){
 
1833
    error_t ret_errno = 0, ioctl_errno = 0;
1742
1834
    if(not get_flags(interface, &network) and debug){
1743
1835
      ret_errno = errno;
1744
1836
      fprintf_plus(stderr, "Failed to get flags for interface "
1745
1837
                   "\"%s\"\n", interface);
 
1838
      errno = old_errno;
1746
1839
      return ret_errno;
1747
1840
    }
1748
1841
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1749
1842
    
1750
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1751
 
    if(sd < 0){
 
1843
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1844
    if(sd == -1){
1752
1845
      ret_errno = errno;
1753
1846
      perror_plus("socket");
1754
1847
      errno = old_errno;
1760
1853
                   interface);
1761
1854
    }
1762
1855
    
1763
 
    /* Raise priviliges */
1764
 
    raise_privileges();
1765
 
    
1766
 
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1767
 
    ret_errno = errno;
1768
 
    
1769
 
    /* Lower privileges */
1770
 
    lower_privileges();
 
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
    }
1771
1875
    
1772
1876
    /* Close the socket */
1773
 
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1877
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
1774
1878
    if(ret == -1){
1775
1879
      perror_plus("close");
1776
1880
    }
1777
1881
    
1778
1882
    if(ret_setflags == -1){
1779
 
      errno = ret_errno;
 
1883
      errno = ioctl_errno;
1780
1884
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1781
1885
      errno = old_errno;
1782
 
      return ret_errno;
 
1886
      return ioctl_errno;
1783
1887
    }
1784
1888
  } else if(debug){
1785
1889
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1793
1897
int main(int argc, char *argv[]){
1794
1898
  mandos_context mc = { .server = NULL, .dh_bits = 1024,
1795
1899
                        .priority = "SECURE256:!CTYPE-X.509:"
1796
 
                        "+CTYPE-OPENPGP", .current_server = NULL, 
 
1900
                        "+CTYPE-OPENPGP", .current_server = NULL,
1797
1901
                        .interfaces = NULL, .interfaces_size = 0 };
1798
1902
  AvahiSServiceBrowser *sb = NULL;
1799
1903
  error_t ret_errno;
1803
1907
  int exitcode = EXIT_SUCCESS;
1804
1908
  char *interfaces_to_take_down = NULL;
1805
1909
  size_t interfaces_to_take_down_size = 0;
1806
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1807
 
  bool tempdir_created = false;
 
1910
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
1911
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
1912
  char *tempdir = NULL;
1808
1913
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1809
1914
  const char *seckey = PATHDIR "/" SECKEY;
1810
1915
  const char *pubkey = PATHDIR "/" PUBKEY;
1811
1916
  char *interfaces_hooks = NULL;
1812
 
  size_t interfaces_hooks_size = 0;
1813
1917
  
1814
1918
  bool gnutls_initialized = false;
1815
1919
  bool gpgme_initialized = false;
1993
2097
    /* Work around Debian bug #633582:
1994
2098
       <http://bugs.debian.org/633582> */
1995
2099
    
1996
 
    /* Re-raise priviliges */
1997
 
    if(raise_privileges() == 0){
 
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");
 
2105
    } else {
1998
2106
      struct stat st;
1999
2107
      
2000
2108
      if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2040
2148
      }
2041
2149
    
2042
2150
      /* Lower privileges */
2043
 
      lower_privileges();
 
2151
      ret_errno = lower_privileges();
 
2152
      if(ret_errno != 0){
 
2153
        errno = ret_errno;
 
2154
        perror_plus("Failed to lower privileges");
 
2155
      }
2044
2156
    }
2045
2157
  }
2046
2158
  
2070
2182
        goto end;
2071
2183
      }
2072
2184
      memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2073
 
      interfaces_hooks_size = mc.interfaces_size;
2074
 
      argz_stringify(interfaces_hooks, interfaces_hooks_size,
2075
 
                     (int)',');
2076
 
    }
2077
 
    if(not run_network_hooks("start", interfaces_hooks != NULL ?
2078
 
                             interfaces_hooks : "", delay)){
2079
 
      goto end;
2080
 
    }
 
2185
      argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
 
2186
    }
 
2187
    run_network_hooks("start", interfaces_hooks != NULL ?
 
2188
                      interfaces_hooks : "", delay);
2081
2189
  }
2082
2190
  
2083
2191
  if(not debug){
2161
2269
  
2162
2270
  /* If no interfaces were specified, make a list */
2163
2271
  if(mc.interfaces == NULL){
2164
 
    struct dirent **direntries;
 
2272
    struct dirent **direntries = NULL;
2165
2273
    /* Look for any good interfaces */
2166
2274
    ret = scandir(sys_class_net, &direntries, good_interface,
2167
2275
                  alphasort);
2171
2279
        ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2172
2280
                             direntries[i]->d_name);
2173
2281
        if(ret_errno != 0){
 
2282
          errno = ret_errno;
2174
2283
          perror_plus("argz_add");
 
2284
          free(direntries[i]);
2175
2285
          continue;
2176
2286
        }
2177
2287
        if(debug){
2178
2288
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
2179
2289
                       direntries[i]->d_name);
2180
2290
        }
 
2291
        free(direntries[i]);
2181
2292
      }
2182
2293
      free(direntries);
2183
2294
    } else {
2184
 
      free(direntries);
 
2295
      if(ret == 0){
 
2296
        free(direntries);
 
2297
      }
2185
2298
      fprintf_plus(stderr, "Could not find a network interface\n");
2186
2299
      exitcode = EXIT_FAILURE;
2187
2300
      goto end;
2210
2323
        break;
2211
2324
      }
2212
2325
      bool interface_was_up = interface_is_up(interface);
2213
 
      ret = bring_up_interface(interface, delay);
 
2326
      errno = bring_up_interface(interface, delay);
2214
2327
      if(not interface_was_up){
2215
 
        if(ret != 0){
2216
 
          errno = ret;
 
2328
        if(errno != 0){
2217
2329
          perror_plus("Failed to bring up interface");
2218
2330
        } else {
2219
 
          ret_errno = argz_add(&interfaces_to_take_down,
2220
 
                               &interfaces_to_take_down_size,
2221
 
                               interface);
 
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
          }
2222
2337
        }
2223
2338
      }
2224
2339
    }
2253
2368
    goto end;
2254
2369
  }
2255
2370
  
2256
 
  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){
2257
2381
    perror_plus("mkdtemp");
2258
2382
    goto end;
2259
2383
  }
2260
 
  tempdir_created = true;
2261
2384
  
2262
2385
  if(quit_now){
2263
2386
    goto end;
2338
2461
      sleep((unsigned int)retry_interval);
2339
2462
    }
2340
2463
    
2341
 
    if (not quit_now){
 
2464
    if(not quit_now){
2342
2465
      exitcode = EXIT_SUCCESS;
2343
2466
    }
2344
2467
    
2399
2522
  if(debug){
2400
2523
    fprintf_plus(stderr, "Starting Avahi loop search\n");
2401
2524
  }
2402
 
 
 
2525
  
2403
2526
  ret = avahi_loop_with_timeout(simple_poll,
2404
2527
                                (int)(retry_interval * 1000), &mc);
2405
2528
  if(debug){
2441
2564
    mc.current_server->prev->next = NULL;
2442
2565
    while(mc.current_server != NULL){
2443
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
2444
2575
      free(mc.current_server);
2445
2576
      mc.current_server = next;
2446
2577
    }
2447
2578
  }
2448
2579
  
2449
 
  /* Re-raise priviliges */
 
2580
  /* Re-raise privileges */
2450
2581
  {
2451
 
    raise_privileges();
2452
 
    
2453
 
    /* Run network hooks */
2454
 
    run_network_hooks("stop", interfaces_hooks != NULL ?
2455
 
                      interfaces_hooks : "", delay);
2456
 
    
2457
 
    /* Take down the network interfaces which were brought up */
2458
 
    {
2459
 
      char *interface = NULL;
2460
 
      while((interface=argz_next(interfaces_to_take_down,
2461
 
                                 interfaces_to_take_down_size,
2462
 
                                 interface))){
2463
 
        ret_errno = take_down_interface(interface);
2464
 
        if(ret_errno != 0){
2465
 
          errno = ret_errno;
2466
 
          perror_plus("Failed to take down interface");
2467
 
        }
2468
 
      }
2469
 
      if(debug and (interfaces_to_take_down == NULL)){
2470
 
        fprintf_plus(stderr, "No interfaces needed to be taken"
2471
 
                     " down\n");
2472
 
      }
2473
 
    }
2474
 
    
2475
 
    lower_privileges_permanently();
 
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
      }
 
2609
    }
 
2610
    
 
2611
    ret_errno = lower_privileges_permanently();
 
2612
    if(ret_errno != 0){
 
2613
      errno = ret_errno;
 
2614
      perror_plus("Failed to lower privileges permanently");
 
2615
    }
2476
2616
  }
2477
2617
  
2478
2618
  free(interfaces_to_take_down);
2479
2619
  free(interfaces_hooks);
2480
2620
  
2481
2621
  /* Removes the GPGME temp directory and all files inside */
2482
 
  if(tempdir_created){
 
2622
  if(tempdir != NULL){
2483
2623
    struct dirent **direntries = NULL;
2484
 
    struct dirent *direntry = NULL;
2485
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2486
 
                             alphasort);
2487
 
    if (numentries > 0){
2488
 
      for(int i = 0; i < numentries; i++){
2489
 
        direntry = direntries[i];
2490
 
        char *fullname = NULL;
2491
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2492
 
                       direntry->d_name);
2493
 
        if(ret < 0){
2494
 
          perror_plus("asprintf");
2495
 
          continue;
2496
 
        }
2497
 
        ret = remove(fullname);
2498
 
        if(ret == -1){
2499
 
          fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2500
 
                       strerror(errno));
2501
 
        }
2502
 
        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
        }
2503
2661
      }
2504
 
    }
2505
 
 
2506
 
    /* need to clean even if 0 because man page doesn't specify */
2507
 
    free(direntries);
2508
 
    if (numentries == -1){
2509
 
      perror_plus("scandir");
2510
 
    }
2511
 
    ret = rmdir(tempdir);
2512
 
    if(ret == -1 and errno != ENOENT){
2513
 
      perror_plus("rmdir");
 
2662
      TEMP_FAILURE_RETRY(close(tempdir_fd));
2514
2663
    }
2515
2664
  }
2516
2665