/mandos/trunk

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2014-03-10 06:55:54 UTC
  • Revision ID: teddy@recompile.se-20140310065554-of3kz8jdhlll42l3
Use "struct sockaddr_storage" instead of a union in mandos-client.

Apparently using struct sockaddr_storage the way POSIX intended is
incompatible with strict aliasing, so turn that off in the Makefile.

* plugins.d/mandos-client.c (start_mandos_communication): Change "to"
                                                          from a union
                                                          to a struct
                                                          sockaddr_storage.
* Makefile (OPTIMIZE): Add "-fno-strict-aliasing".

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
11
 * Everything else is
12
 
 * Copyright © 2008-2014 Teddy Hogeborn
13
 
 * Copyright © 2008-2014 Björn Påhlsson
 
12
 * Copyright © 2008-2013 Teddy Hogeborn
 
13
 * Copyright © 2008-2013 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
136
136
 
137
137
bool debug = false;
138
138
static const char mandos_protocol_version[] = "1";
139
 
const char * argp_program_version = "mandos-client " VERSION;
140
 
const char * argp_program_bug_address = "<mandos@recompile.se>";
 
139
const char *argp_program_version = "mandos-client " VERSION;
 
140
const char *argp_program_bug_address = "<mandos@recompile.se>";
141
141
static const char sys_class_net[] = "/sys/class/net";
142
142
char *connect_to = NULL;
143
143
const char *hookdir = HOOKDIR;
183
183
  perror(print_text);
184
184
}
185
185
 
186
 
__attribute__((format (gnu_printf, 2, 3), nonnull))
 
186
__attribute__((format (gnu_printf, 2, 3)))
187
187
int fprintf_plus(FILE *stream, const char *format, ...){
188
188
  va_list ap;
189
189
  va_start (ap, format);
198
198
 * bytes. "buffer_capacity" is how much is currently allocated,
199
199
 * "buffer_length" is how much is already used.
200
200
 */
201
 
__attribute__((nonnull, warn_unused_result))
202
201
size_t incbuffer(char **buffer, size_t buffer_length,
203
202
                 size_t buffer_capacity){
204
203
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
217
216
}
218
217
 
219
218
/* Add server to set of servers to retry periodically */
220
 
__attribute__((nonnull, warn_unused_result))
221
219
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
222
220
                int af, server **current_server){
223
221
  int ret;
244
242
    new_server->next = new_server;
245
243
    new_server->prev = new_server;
246
244
    *current_server = new_server;
 
245
  /* Place the new server last in the list */
247
246
  } else {
248
 
    /* Place the new server last in the list */
249
247
    new_server->next = *current_server;
250
248
    new_server->prev = (*current_server)->prev;
251
249
    new_server->prev->next = new_server;
257
255
/* 
258
256
 * Initialize GPGME.
259
257
 */
260
 
__attribute__((nonnull, warn_unused_result))
261
 
static bool init_gpgme(const char * const seckey,
262
 
                       const char * const pubkey,
263
 
                       const char * const tempdir,
264
 
                       mandos_context *mc){
 
258
static bool init_gpgme(const char *seckey, const char *pubkey,
 
259
                       const char *tempdir, mandos_context *mc){
265
260
  gpgme_error_t rc;
266
261
  gpgme_engine_info_t engine_info;
267
262
  
268
263
  /*
269
264
   * Helper function to insert pub and seckey to the engine keyring.
270
265
   */
271
 
  bool import_key(const char * const filename){
 
266
  bool import_key(const char *filename){
272
267
    int ret;
273
268
    int fd;
274
269
    gpgme_data_t pgp_data;
355
350
 * Decrypt OpenPGP data.
356
351
 * Returns -1 on error
357
352
 */
358
 
__attribute__((nonnull, warn_unused_result))
359
353
static ssize_t pgp_packet_decrypt(const char *cryptotext,
360
354
                                  size_t crypto_size,
361
355
                                  char **plaintext,
481
475
  return plaintext_length;
482
476
}
483
477
 
484
 
__attribute__((warn_unused_result))
485
 
static const char *safer_gnutls_strerror(int value){
 
478
static const char * safer_gnutls_strerror(int value){
486
479
  const char *ret = gnutls_strerror(value);
487
480
  if(ret == NULL)
488
481
    ret = "(unknown)";
490
483
}
491
484
 
492
485
/* GnuTLS log function callback */
493
 
__attribute__((nonnull))
494
486
static void debuggnutls(__attribute__((unused)) int level,
495
487
                        const char* string){
496
488
  fprintf_plus(stderr, "GnuTLS: %s", string);
497
489
}
498
490
 
499
 
__attribute__((nonnull, warn_unused_result))
500
491
static int init_gnutls_global(const char *pubkeyfilename,
501
492
                              const char *seckeyfilename,
502
493
                              mandos_context *mc){
576
567
  return -1;
577
568
}
578
569
 
579
 
__attribute__((nonnull, warn_unused_result))
580
570
static int init_gnutls_session(gnutls_session_t *session,
581
571
                               mandos_context *mc){
582
572
  int ret;
639
629
                      __attribute__((unused)) const char *txt){}
640
630
 
641
631
/* Called when a Mandos server is found */
642
 
__attribute__((nonnull, warn_unused_result))
643
632
static int start_mandos_communication(const char *ip, in_port_t port,
644
633
                                      AvahiIfIndex if_index,
645
634
                                      int af, mandos_context *mc){
751
740
    goto mandos_end;
752
741
  }
753
742
  if(af == AF_INET6){
754
 
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
743
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);    
755
744
    if(IN6_IS_ADDR_LINKLOCAL
756
745
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
757
746
      if(if_index == AVAHI_IF_UNSPEC){
820
809
                  sizeof(struct sockaddr_in));
821
810
  }
822
811
  if(ret < 0){
823
 
    if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
 
812
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
824
813
      int e = errno;
825
814
      perror_plus("connect");
826
815
      errno = e;
1041
1030
  return retval;
1042
1031
}
1043
1032
 
1044
 
__attribute__((nonnull))
1045
1033
static void resolve_callback(AvahiSServiceResolver *r,
1046
1034
                             AvahiIfIndex interface,
1047
1035
                             AvahiProtocol proto,
1055
1043
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
1056
1044
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
1057
1045
                             flags,
1058
 
                             void *mc){
 
1046
                             void* mc){
1059
1047
  if(r == NULL){
1060
1048
    return;
1061
1049
  }
1114
1102
                            const char *domain,
1115
1103
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1116
1104
                            flags,
1117
 
                            void *mc){
 
1105
                            void* mc){
1118
1106
  if(b == NULL){
1119
1107
    return;
1120
1108
  }
1180
1168
  errno = old_errno;
1181
1169
}
1182
1170
 
1183
 
__attribute__((nonnull, warn_unused_result))
1184
1171
bool get_flags(const char *ifname, struct ifreq *ifr){
1185
1172
  int ret;
1186
1173
  error_t ret_errno;
1205
1192
  return true;
1206
1193
}
1207
1194
 
1208
 
__attribute__((nonnull, warn_unused_result))
1209
1195
bool good_flags(const char *ifname, const struct ifreq *ifr){
1210
1196
  
1211
1197
  /* Reject the loopback device */
1253
1239
 * corresponds to an acceptable network device.
1254
1240
 * (This function is passed to scandir(3) as a filter function.)
1255
1241
 */
1256
 
__attribute__((nonnull, warn_unused_result))
1257
1242
int good_interface(const struct dirent *if_entry){
1258
1243
  if(if_entry->d_name[0] == '.'){
1259
1244
    return 0;
1277
1262
/* 
1278
1263
 * This function determines if a network interface is up.
1279
1264
 */
1280
 
__attribute__((nonnull, warn_unused_result))
1281
1265
bool interface_is_up(const char *interface){
1282
1266
  struct ifreq ifr;
1283
1267
  if(not get_flags(interface, &ifr)){
1294
1278
/* 
1295
1279
 * This function determines if a network interface is running
1296
1280
 */
1297
 
__attribute__((nonnull, warn_unused_result))
1298
1281
bool interface_is_running(const char *interface){
1299
1282
  struct ifreq ifr;
1300
1283
  if(not get_flags(interface, &ifr)){
1308
1291
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
1309
1292
}
1310
1293
 
1311
 
__attribute__((nonnull, pure, warn_unused_result))
1312
1294
int notdotentries(const struct dirent *direntry){
1313
1295
  /* Skip "." and ".." */
1314
1296
  if(direntry->d_name[0] == '.'
1321
1303
}
1322
1304
 
1323
1305
/* Is this directory entry a runnable program? */
1324
 
__attribute__((nonnull, warn_unused_result))
1325
1306
int runnable_hook(const struct dirent *direntry){
1326
1307
  int ret;
1327
1308
  size_t sret;
1382
1363
  return 1;
1383
1364
}
1384
1365
 
1385
 
__attribute__((nonnull, warn_unused_result))
1386
1366
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1387
1367
                            mandos_context *mc){
1388
1368
  int ret;
1392
1372
  
1393
1373
  while(true){
1394
1374
    if(mc->current_server == NULL){
1395
 
      if(debug){
 
1375
      if (debug){
1396
1376
        fprintf_plus(stderr, "Wait until first server is found."
1397
1377
                     " No timeout!\n");
1398
1378
      }
1399
1379
      ret = avahi_simple_poll_iterate(s, -1);
1400
1380
    } else {
1401
 
      if(debug){
 
1381
      if (debug){
1402
1382
        fprintf_plus(stderr, "Check current_server if we should run"
1403
1383
                     " it, or wait\n");
1404
1384
      }
1421
1401
                     - ((intmax_t)waited_time.tv_sec * 1000))
1422
1402
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1423
1403
      
1424
 
      if(debug){
 
1404
      if (debug){
1425
1405
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1426
1406
                     block_time);
1427
1407
      }
1449
1429
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1450
1430
    }
1451
1431
    if(ret != 0){
1452
 
      if(ret > 0 or errno != EINTR){
 
1432
      if (ret > 0 or errno != EINTR){
1453
1433
        return (ret != 1) ? ret : 0;
1454
1434
      }
1455
1435
    }
1457
1437
}
1458
1438
 
1459
1439
/* Set effective uid to 0, return errno */
1460
 
__attribute__((warn_unused_result))
1461
1440
error_t raise_privileges(void){
1462
1441
  error_t old_errno = errno;
1463
1442
  error_t ret_errno = 0;
1470
1449
}
1471
1450
 
1472
1451
/* Set effective and real user ID to 0.  Return errno. */
1473
 
__attribute__((warn_unused_result))
1474
1452
error_t raise_privileges_permanently(void){
1475
1453
  error_t old_errno = errno;
1476
1454
  error_t ret_errno = raise_privileges();
1487
1465
}
1488
1466
 
1489
1467
/* Set effective user ID to unprivileged saved user ID */
1490
 
__attribute__((warn_unused_result))
1491
1468
error_t lower_privileges(void){
1492
1469
  error_t old_errno = errno;
1493
1470
  error_t ret_errno = 0;
1500
1477
}
1501
1478
 
1502
1479
/* Lower privileges permanently */
1503
 
__attribute__((warn_unused_result))
1504
1480
error_t lower_privileges_permanently(void){
1505
1481
  error_t old_errno = errno;
1506
1482
  error_t ret_errno = 0;
1512
1488
  return ret_errno;
1513
1489
}
1514
1490
 
1515
 
__attribute__((nonnull))
1516
 
void run_network_hooks(const char *mode, const char *interface,
 
1491
bool run_network_hooks(const char *mode, const char *interface,
1517
1492
                       const float delay){
1518
1493
  struct dirent **direntries;
1519
1494
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1547
1522
      if(hook_pid == 0){
1548
1523
        /* Child */
1549
1524
        /* Raise privileges */
1550
 
        if(raise_privileges_permanently() != 0){
1551
 
          perror_plus("Failed to raise privileges");
1552
 
          _exit(EX_NOPERM);
1553
 
        }
 
1525
        raise_privileges_permanently();
1554
1526
        /* Set group */
1555
1527
        errno = 0;
1556
1528
        ret = setgid(0);
1557
1529
        if(ret == -1){
1558
1530
          perror_plus("setgid");
1559
 
          _exit(EX_NOPERM);
1560
1531
        }
1561
1532
        /* Reset supplementary groups */
1562
1533
        errno = 0;
1563
1534
        ret = setgroups(0, NULL);
1564
1535
        if(ret == -1){
1565
1536
          perror_plus("setgroups");
1566
 
          _exit(EX_NOPERM);
1567
 
        }
1568
 
        ret = dup2(devnull, STDIN_FILENO);
1569
 
        if(ret == -1){
1570
 
          perror_plus("dup2(devnull, STDIN_FILENO)");
1571
 
          _exit(EX_OSERR);
1572
 
        }
1573
 
        ret = close(devnull);
1574
 
        if(ret == -1){
1575
 
          perror_plus("close");
1576
 
          _exit(EX_OSERR);
1577
 
        }
1578
 
        ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1579
 
        if(ret == -1){
1580
 
          perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1581
 
          _exit(EX_OSERR);
1582
 
        }
 
1537
        }
 
1538
        dup2(devnull, STDIN_FILENO);
 
1539
        close(devnull);
 
1540
        dup2(STDERR_FILENO, STDOUT_FILENO);
1583
1541
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1584
1542
        if(ret == -1){
1585
1543
          perror_plus("setenv");
1601
1559
          _exit(EX_OSERR);
1602
1560
        }
1603
1561
        char *delaystring;
1604
 
        ret = asprintf(&delaystring, "%f", (double)delay);
 
1562
        ret = asprintf(&delaystring, "%f", delay);
1605
1563
        if(ret == -1){
1606
1564
          perror_plus("asprintf");
1607
1565
          _exit(EX_OSERR);
1660
1618
    }
1661
1619
    close(devnull);
1662
1620
  }
 
1621
  return true;
1663
1622
}
1664
1623
 
1665
 
__attribute__((nonnull, warn_unused_result))
1666
1624
error_t bring_up_interface(const char *const interface,
1667
1625
                           const float delay){
 
1626
  int sd = -1;
1668
1627
  error_t old_errno = errno;
1669
 
  int ret;
 
1628
  error_t ret_errno = 0;
 
1629
  int ret, ret_setflags;
1670
1630
  struct ifreq network;
1671
1631
  unsigned int if_index = if_nametoindex(interface);
1672
1632
  if(if_index == 0){
1681
1641
  }
1682
1642
  
1683
1643
  if(not interface_is_up(interface)){
1684
 
    error_t ret_errno = 0, ioctl_errno = 0;
1685
 
    if(not get_flags(interface, &network)){
 
1644
    if(not get_flags(interface, &network) and debug){
1686
1645
      ret_errno = errno;
1687
1646
      fprintf_plus(stderr, "Failed to get flags for interface "
1688
1647
                   "\"%s\"\n", interface);
1689
 
      errno = old_errno;
1690
1648
      return ret_errno;
1691
1649
    }
1692
 
    network.ifr_flags |= IFF_UP; /* set flag */
 
1650
    network.ifr_flags |= IFF_UP;
1693
1651
    
1694
 
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1695
 
    if(sd == -1){
 
1652
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1653
    if(sd < 0){
1696
1654
      ret_errno = errno;
1697
1655
      perror_plus("socket");
1698
1656
      errno = old_errno;
1699
1657
      return ret_errno;
1700
1658
    }
1701
 
    
 
1659
  
1702
1660
    if(quit_now){
1703
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1704
 
      if(ret == -1){
1705
 
        perror_plus("close");
1706
 
      }
 
1661
      close(sd);
1707
1662
      errno = old_errno;
1708
1663
      return EINTR;
1709
1664
    }
1713
1668
                   interface);
1714
1669
    }
1715
1670
    
1716
 
    /* Raise privileges */
1717
 
    ret_errno = raise_privileges();
1718
 
    bool restore_loglevel = false;
1719
 
    if(ret_errno != 0){
1720
 
      perror_plus("Failed to raise privileges");
1721
 
    }
 
1671
    /* Raise priviliges */
 
1672
    raise_privileges();
 
1673
    
1722
1674
#ifdef __linux__
1723
 
    int ret_linux;
1724
 
    if(ret_errno == 0){
1725
 
      /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1726
 
         messages about the network interface to mess up the prompt */
1727
 
      ret_linux = klogctl(8, NULL, 5);
1728
 
      if(ret_linux == -1){
1729
 
        perror_plus("klogctl");
1730
 
      } else {
1731
 
        restore_loglevel = true;
1732
 
      }
 
1675
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
1676
       messages about the network interface to mess up the prompt */
 
1677
    int ret_linux = klogctl(8, NULL, 5);
 
1678
    bool restore_loglevel = true;
 
1679
    if(ret_linux == -1){
 
1680
      restore_loglevel = false;
 
1681
      perror_plus("klogctl");
1733
1682
    }
1734
1683
#endif  /* __linux__ */
1735
 
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1736
 
    ioctl_errno = errno;
 
1684
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1685
    ret_errno = errno;
1737
1686
#ifdef __linux__
1738
1687
    if(restore_loglevel){
1739
1688
      ret_linux = klogctl(7, NULL, 0);
1743
1692
    }
1744
1693
#endif  /* __linux__ */
1745
1694
    
1746
 
    /* If raise_privileges() succeeded above */
1747
 
    if(ret_errno == 0){
1748
 
      /* Lower privileges */
1749
 
      ret_errno = lower_privileges();
1750
 
      if(ret_errno != 0){
1751
 
        errno = ret_errno;
1752
 
        perror_plus("Failed to lower privileges");
1753
 
      }
1754
 
    }
 
1695
    /* Lower privileges */
 
1696
    lower_privileges();
1755
1697
    
1756
1698
    /* Close the socket */
1757
1699
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
1760
1702
    }
1761
1703
    
1762
1704
    if(ret_setflags == -1){
1763
 
      errno = ioctl_errno;
 
1705
      errno = ret_errno;
1764
1706
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1765
1707
      errno = old_errno;
1766
 
      return ioctl_errno;
 
1708
      return ret_errno;
1767
1709
    }
1768
1710
  } else if(debug){
1769
1711
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1787
1729
  return 0;
1788
1730
}
1789
1731
 
1790
 
__attribute__((nonnull, warn_unused_result))
1791
1732
error_t take_down_interface(const char *const interface){
1792
1733
  error_t old_errno = errno;
1793
1734
  struct ifreq network;
1798
1739
    return ENXIO;
1799
1740
  }
1800
1741
  if(interface_is_up(interface)){
1801
 
    error_t ret_errno = 0, ioctl_errno = 0;
 
1742
    error_t ret_errno = 0;
1802
1743
    if(not get_flags(interface, &network) and debug){
1803
1744
      ret_errno = errno;
1804
1745
      fprintf_plus(stderr, "Failed to get flags for interface "
1805
1746
                   "\"%s\"\n", interface);
1806
 
      errno = old_errno;
1807
1747
      return ret_errno;
1808
1748
    }
1809
1749
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1810
1750
    
1811
1751
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1812
 
    if(sd == -1){
 
1752
    if(sd < 0){
1813
1753
      ret_errno = errno;
1814
1754
      perror_plus("socket");
1815
1755
      errno = old_errno;
1821
1761
                   interface);
1822
1762
    }
1823
1763
    
1824
 
    /* Raise privileges */
1825
 
    ret_errno = raise_privileges();
1826
 
    if(ret_errno != 0){
1827
 
      perror_plus("Failed to raise privileges");
1828
 
    }
 
1764
    /* Raise priviliges */
 
1765
    raise_privileges();
 
1766
    
1829
1767
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1830
 
    ioctl_errno = errno;
 
1768
    ret_errno = errno;
1831
1769
    
1832
 
    /* If raise_privileges() succeeded above */
1833
 
    if(ret_errno == 0){
1834
 
      /* Lower privileges */
1835
 
      ret_errno = lower_privileges();
1836
 
      if(ret_errno != 0){
1837
 
        errno = ret_errno;
1838
 
        perror_plus("Failed to lower privileges");
1839
 
      }
1840
 
    }
 
1770
    /* Lower privileges */
 
1771
    lower_privileges();
1841
1772
    
1842
1773
    /* Close the socket */
1843
1774
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
1846
1777
    }
1847
1778
    
1848
1779
    if(ret_setflags == -1){
1849
 
      errno = ioctl_errno;
 
1780
      errno = ret_errno;
1850
1781
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1851
1782
      errno = old_errno;
1852
 
      return ioctl_errno;
 
1783
      return ret_errno;
1853
1784
    }
1854
1785
  } else if(debug){
1855
1786
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1863
1794
int main(int argc, char *argv[]){
1864
1795
  mandos_context mc = { .server = NULL, .dh_bits = 1024,
1865
1796
                        .priority = "SECURE256:!CTYPE-X.509:"
1866
 
                        "+CTYPE-OPENPGP", .current_server = NULL,
 
1797
                        "+CTYPE-OPENPGP", .current_server = NULL, 
1867
1798
                        .interfaces = NULL, .interfaces_size = 0 };
1868
1799
  AvahiSServiceBrowser *sb = NULL;
1869
1800
  error_t ret_errno;
1873
1804
  int exitcode = EXIT_SUCCESS;
1874
1805
  char *interfaces_to_take_down = NULL;
1875
1806
  size_t interfaces_to_take_down_size = 0;
1876
 
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
1877
 
  char old_tempdir[] = "/tmp/mandosXXXXXX";
1878
 
  char *tempdir = NULL;
 
1807
  char tempdir[] = "/tmp/mandosXXXXXX";
 
1808
  bool tempdir_created = false;
1879
1809
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1880
1810
  const char *seckey = PATHDIR "/" SECKEY;
1881
1811
  const char *pubkey = PATHDIR "/" PUBKEY;
2063
1993
    /* Work around Debian bug #633582:
2064
1994
       <http://bugs.debian.org/633582> */
2065
1995
    
2066
 
    /* Re-raise privileges */
2067
 
    ret_errno = raise_privileges();
2068
 
    if(ret_errno != 0){
2069
 
      errno = ret_errno;
2070
 
      perror_plus("Failed to raise privileges");
2071
 
    } else {
 
1996
    /* Re-raise priviliges */
 
1997
    if(raise_privileges() == 0){
2072
1998
      struct stat st;
2073
1999
      
2074
2000
      if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2114
2040
      }
2115
2041
    
2116
2042
      /* Lower privileges */
2117
 
      ret_errno = lower_privileges();
2118
 
      if(ret_errno != 0){
2119
 
        errno = ret_errno;
2120
 
        perror_plus("Failed to lower privileges");
2121
 
      }
 
2043
      lower_privileges();
2122
2044
    }
2123
2045
  }
2124
2046
  
2150
2072
      memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2151
2073
      argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2152
2074
    }
2153
 
    run_network_hooks("start", interfaces_hooks != NULL ?
2154
 
                      interfaces_hooks : "", delay);
 
2075
    if(not run_network_hooks("start", interfaces_hooks != NULL ?
 
2076
                             interfaces_hooks : "", delay)){
 
2077
      goto end;
 
2078
    }
2155
2079
  }
2156
2080
  
2157
2081
  if(not debug){
2285
2209
        break;
2286
2210
      }
2287
2211
      bool interface_was_up = interface_is_up(interface);
2288
 
      errno = bring_up_interface(interface, delay);
 
2212
      ret = bring_up_interface(interface, delay);
2289
2213
      if(not interface_was_up){
2290
 
        if(errno != 0){
 
2214
        if(ret != 0){
 
2215
          errno = ret;
2291
2216
          perror_plus("Failed to bring up interface");
2292
2217
        } else {
2293
 
          errno = argz_add(&interfaces_to_take_down,
2294
 
                           &interfaces_to_take_down_size,
2295
 
                           interface);
2296
 
          if(errno != 0){
 
2218
          ret_errno = argz_add(&interfaces_to_take_down,
 
2219
                               &interfaces_to_take_down_size,
 
2220
                               interface);
 
2221
          if(ret_errno != 0){
 
2222
            errno = ret_errno;
2297
2223
            perror_plus("argz_add");
2298
2224
          }
2299
2225
        }
2330
2256
    goto end;
2331
2257
  }
2332
2258
  
2333
 
  /* Try /run/tmp before /tmp */
2334
 
  tempdir = mkdtemp(run_tempdir);
2335
 
  if(tempdir == NULL and errno == ENOENT){
2336
 
      if(debug){
2337
 
        fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2338
 
                     run_tempdir, old_tempdir);
2339
 
      }
2340
 
      tempdir = mkdtemp(old_tempdir);
2341
 
  }
2342
 
  if(tempdir == NULL){
 
2259
  if(mkdtemp(tempdir) == NULL){
2343
2260
    perror_plus("mkdtemp");
2344
2261
    goto end;
2345
2262
  }
 
2263
  tempdir_created = true;
2346
2264
  
2347
2265
  if(quit_now){
2348
2266
    goto end;
2423
2341
      sleep((unsigned int)retry_interval);
2424
2342
    }
2425
2343
    
2426
 
    if(not quit_now){
 
2344
    if (not quit_now){
2427
2345
      exitcode = EXIT_SUCCESS;
2428
2346
    }
2429
2347
    
2531
2449
    }
2532
2450
  }
2533
2451
  
2534
 
  /* Re-raise privileges */
 
2452
  /* Re-raise priviliges */
2535
2453
  {
2536
 
    ret_errno = raise_privileges();
2537
 
    if(ret_errno != 0){
2538
 
      perror_plus("Failed to raise privileges");
2539
 
    } else {
2540
 
      
2541
 
      /* Run network hooks */
2542
 
      run_network_hooks("stop", interfaces_hooks != NULL ?
2543
 
                        interfaces_hooks : "", delay);
2544
 
      
2545
 
      /* Take down the network interfaces which were brought up */
2546
 
      {
2547
 
        char *interface = NULL;
2548
 
        while((interface=argz_next(interfaces_to_take_down,
2549
 
                                   interfaces_to_take_down_size,
2550
 
                                   interface))){
2551
 
          ret_errno = take_down_interface(interface);
2552
 
          if(ret_errno != 0){
2553
 
            errno = ret_errno;
2554
 
            perror_plus("Failed to take down interface");
2555
 
          }
2556
 
        }
2557
 
        if(debug and (interfaces_to_take_down == NULL)){
2558
 
          fprintf_plus(stderr, "No interfaces needed to be taken"
2559
 
                       " down\n");
2560
 
        }
2561
 
      }
2562
 
    }
2563
 
    ret_errno = lower_privileges_permanently();
2564
 
    if(ret_errno != 0){
2565
 
      perror_plus("Failed to lower privileges permanently");
2566
 
    }
 
2454
    raise_privileges();
 
2455
    
 
2456
    /* Run network hooks */
 
2457
    run_network_hooks("stop", interfaces_hooks != NULL ?
 
2458
                      interfaces_hooks : "", delay);
 
2459
    
 
2460
    /* Take down the network interfaces which were brought up */
 
2461
    {
 
2462
      char *interface = NULL;
 
2463
      while((interface=argz_next(interfaces_to_take_down,
 
2464
                                 interfaces_to_take_down_size,
 
2465
                                 interface))){
 
2466
        ret_errno = take_down_interface(interface);
 
2467
        if(ret_errno != 0){
 
2468
          errno = ret_errno;
 
2469
          perror_plus("Failed to take down interface");
 
2470
        }
 
2471
      }
 
2472
      if(debug and (interfaces_to_take_down == NULL)){
 
2473
        fprintf_plus(stderr, "No interfaces needed to be taken"
 
2474
                     " down\n");
 
2475
      }
 
2476
    }
 
2477
    
 
2478
    lower_privileges_permanently();
2567
2479
  }
2568
2480
  
2569
2481
  free(interfaces_to_take_down);
2570
2482
  free(interfaces_hooks);
2571
2483
  
2572
2484
  /* Removes the GPGME temp directory and all files inside */
2573
 
  if(tempdir != NULL){
 
2485
  if(tempdir_created){
2574
2486
    struct dirent **direntries = NULL;
2575
2487
    struct dirent *direntry = NULL;
2576
2488
    int numentries = scandir(tempdir, &direntries, notdotentries,
2577
2489
                             alphasort);
2578
 
    if(numentries > 0){
 
2490
    if (numentries > 0){
2579
2491
      for(int i = 0; i < numentries; i++){
2580
2492
        direntry = direntries[i];
2581
2493
        char *fullname = NULL;
2596
2508
 
2597
2509
    /* need to clean even if 0 because man page doesn't specify */
2598
2510
    free(direntries);
2599
 
    if(numentries == -1){
 
2511
    if (numentries == -1){
2600
2512
      perror_plus("scandir");
2601
2513
    }
2602
2514
    ret = rmdir(tempdir);