/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: 2012-06-13 22:06:57 UTC
  • mto: (237.7.144 trunk)
  • mto: This revision was merged to the branch mainline in revision 302.
  • Revision ID: teddy@recompile.se-20120613220657-qvq7c7nrndl3t413
* plugins.d/mandos-client.c (get_flags): Don't clobber errno.
  (up_interface): Removed; replaced with "interface_is_up".
  (interface_is_up, interface_is_running,
   lower_privileges_permanently, take_down_interface): New.
  (bring_up_interface): Return "error_t".  Use new functions
                        "interface_is_up", "get_flags", and
                        "interface_is_running".
  (main): Save all interfaces either autodetected or specified with
          --interface in argz vector "interfaces".  Save interfaces to
          take down on exit in argz vector "interfaces_to_take_down".
          Save interface names for DEVICE variable to network hooks as
          argz_vector "interfaces_hooks".  Bug fix: Be privileged
          while stopping network hooks.
* plugins.d/mandos-client.xml (SYNOPSIS): Changed --interface synopsis.
  (DESCRIPTION): Updated to document use of all interfaces.
  (OPTIONS): Updated description of "--interface".
* network-hooks.d/bridge: Parse comma-separated DEVICE environment
                          variable.
* network-hooks.d/openvpn: - '' -
* network-hooks.d/wireless: - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
88
88
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
89
89
                                   WEXITSTATUS(), WTERMSIG() */
90
90
#include <grp.h>                /* setgroups() */
 
91
#include <argz.h>               /* argz_add_sep(), argz_next(),
 
92
                                   argz_delete(), argz_append(),
 
93
                                   argz_stringify(), argz_add(),
 
94
                                   argz_count() */
91
95
 
92
96
#ifdef __linux__
93
97
#include <sys/klog.h>           /* klogctl() */
1121
1125
 
1122
1126
bool get_flags(const char *ifname, struct ifreq *ifr){
1123
1127
  int ret;
 
1128
  error_t ret_errno;
1124
1129
  
1125
1130
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1126
1131
  if(s < 0){
 
1132
    ret_errno = errno;
1127
1133
    perror_plus("socket");
 
1134
    errno = ret_errno;
1128
1135
    return false;
1129
1136
  }
1130
1137
  strcpy(ifr->ifr_name, ifname);
1131
1138
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1132
1139
  if(ret == -1){
1133
1140
    if(debug){
 
1141
      ret_errno = errno;
1134
1142
      perror_plus("ioctl SIOCGIFFLAGS");
 
1143
      errno = ret_errno;
1135
1144
    }
1136
1145
    return false;
1137
1146
  }
1206
1215
}
1207
1216
 
1208
1217
/* 
1209
 
 * This function determines if a directory entry in /sys/class/net
1210
 
 * corresponds to an acceptable network device which is up.
1211
 
 * (This function is passed to scandir(3) as a filter function.)
1212
 
 */
1213
 
int up_interface(const struct dirent *if_entry){
1214
 
  if(if_entry->d_name[0] == '.'){
1215
 
    return 0;
1216
 
  }
1217
 
  
1218
 
  struct ifreq ifr;
1219
 
  if(not get_flags(if_entry->d_name, &ifr)){
1220
 
    if(debug){
1221
 
      fprintf_plus(stderr, "Failed to get flags for interface "
1222
 
                   "\"%s\"\n", if_entry->d_name);
1223
 
    }
1224
 
    return 0;
1225
 
  }
1226
 
  
1227
 
  /* Reject down interfaces */
1228
 
  if(not (ifr.ifr_flags & IFF_UP)){
1229
 
    if(debug){
1230
 
      fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1231
 
                   if_entry->d_name);
1232
 
    }
1233
 
    return 0;
1234
 
  }
1235
 
  
1236
 
  /* Reject non-running interfaces */
1237
 
  if(not (ifr.ifr_flags & IFF_RUNNING)){
1238
 
    if(debug){
1239
 
      fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1240
 
                   if_entry->d_name);
1241
 
    }
1242
 
    return 0;
1243
 
  }
1244
 
  
1245
 
  if(not good_flags(if_entry->d_name, &ifr)){
1246
 
    return 0;
1247
 
  }
1248
 
  return 1;
 
1218
 * This function determines if a network interface is up.
 
1219
 */
 
1220
bool interface_is_up(const char *interface){
 
1221
  struct ifreq ifr;
 
1222
  if(not get_flags(interface, &ifr)){
 
1223
    if(debug){
 
1224
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1225
                   "\"%s\"\n", interface);
 
1226
    }
 
1227
    return false;
 
1228
  }
 
1229
  
 
1230
  return (bool)(ifr.ifr_flags & IFF_UP);
 
1231
}
 
1232
 
 
1233
/* 
 
1234
 * This function determines if a network interface is running
 
1235
 */
 
1236
bool interface_is_running(const char *interface){
 
1237
  struct ifreq ifr;
 
1238
  if(not get_flags(interface, &ifr)){
 
1239
    if(debug){
 
1240
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1241
                   "\"%s\"\n", interface);
 
1242
    }
 
1243
    return false;
 
1244
  }
 
1245
  
 
1246
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
1249
1247
}
1250
1248
 
1251
1249
int notdotentries(const struct dirent *direntry){
1393
1391
}
1394
1392
 
1395
1393
/* Set effective uid to 0, return errno */
1396
 
int raise_privileges(void){
1397
 
  int old_errno = errno;
1398
 
  int ret_errno = 0;
1399
 
  errno = 0;
 
1394
error_t raise_privileges(void){
 
1395
  error_t old_errno = errno;
 
1396
  error_t ret_errno = 0;
1400
1397
  if(seteuid(0) == -1){
 
1398
    ret_errno = errno;
1401
1399
    perror_plus("seteuid");
1402
1400
  }
1403
 
  ret_errno = errno;
1404
1401
  errno = old_errno;
1405
1402
  return ret_errno;
1406
1403
}
1407
1404
 
1408
1405
/* Set effective and real user ID to 0.  Return errno. */
1409
 
int raise_privileges_permanently(void){
1410
 
  int old_errno = errno;
1411
 
  int ret_errno = raise_privileges();
 
1406
error_t raise_privileges_permanently(void){
 
1407
  error_t old_errno = errno;
 
1408
  error_t ret_errno = raise_privileges();
1412
1409
  if(ret_errno != 0){
1413
1410
    errno = old_errno;
1414
1411
    return ret_errno;
1415
1412
  }
1416
 
  errno = 0;
1417
1413
  if(setuid(0) == -1){
 
1414
    ret_errno = errno;
1418
1415
    perror_plus("seteuid");
1419
1416
  }
1420
 
  ret_errno = errno;
1421
1417
  errno = old_errno;
1422
1418
  return ret_errno;
1423
1419
}
1424
1420
 
1425
1421
/* Set effective user ID to unprivileged saved user ID */
1426
 
int lower_privileges(void){
1427
 
  int old_errno = errno;
1428
 
  int ret_errno = 0;
1429
 
  errno = 0;
 
1422
error_t lower_privileges(void){
 
1423
  error_t old_errno = errno;
 
1424
  error_t ret_errno = 0;
1430
1425
  if(seteuid(uid) == -1){
 
1426
    ret_errno = errno;
1431
1427
    perror_plus("seteuid");
1432
1428
  }
1433
 
  ret_errno = errno;
 
1429
  errno = old_errno;
 
1430
  return ret_errno;
 
1431
}
 
1432
 
 
1433
/* Lower privileges permanently */
 
1434
error_t lower_privileges_permanently(void){
 
1435
  error_t old_errno = errno;
 
1436
  error_t ret_errno = 0;
 
1437
  if(setuid(uid) == -1){
 
1438
    ret_errno = errno;
 
1439
    perror_plus("setuid");
 
1440
  }
1434
1441
  errno = old_errno;
1435
1442
  return ret_errno;
1436
1443
}
1561
1568
  return true;
1562
1569
}
1563
1570
 
1564
 
int bring_up_interface(const char * const interface, const float delay){
 
1571
error_t bring_up_interface(const char *const interface,
 
1572
                           const float delay){
1565
1573
  int sd = -1;
1566
 
  int old_errno = errno;
1567
 
  int ret_errno = 0;
1568
 
  int ret;
 
1574
  error_t old_errno = errno;
 
1575
  error_t ret_errno = 0;
 
1576
  int ret, ret_setflags;
1569
1577
  struct ifreq network;
1570
 
  AvahiIfIndex if_index = (AvahiIfIndex)if_nametoindex(interface);
 
1578
  unsigned int if_index = if_nametoindex(interface);
1571
1579
  if(if_index == 0){
1572
1580
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1573
1581
    errno = old_errno;
1579
1587
    return EINTR;
1580
1588
  }
1581
1589
  
1582
 
  /* Re-raise priviliges */
1583
 
  raise_privileges();
1584
 
  
1585
 
#ifdef __linux__
1586
 
  /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1587
 
     messages about the network interface to mess up the prompt */
1588
 
  ret = klogctl(8, NULL, 5);
1589
 
  bool restore_loglevel = true;
1590
 
  if(ret == -1){
1591
 
    restore_loglevel = false;
1592
 
    perror_plus("klogctl");
1593
 
  }
1594
 
#endif  /* __linux__ */
1595
 
    
1596
 
  sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1597
 
  if(sd < 0){
1598
 
    ret_errno = errno;
1599
 
    perror_plus("socket");
1600
 
#ifdef __linux__
1601
 
    if(restore_loglevel){
1602
 
      ret = klogctl(7, NULL, 0);
1603
 
      if(ret == -1){
1604
 
        perror_plus("klogctl");
1605
 
      }
1606
 
    }
1607
 
#endif  /* __linux__ */
1608
 
    /* Lower privileges */
1609
 
    lower_privileges();
1610
 
    errno = old_errno;
1611
 
    return ret_errno;
1612
 
  }
1613
 
  strcpy(network.ifr_name, interface);
1614
 
  ret = ioctl(sd, SIOCGIFFLAGS, &network);
1615
 
  if(ret == -1){
1616
 
    ret_errno = errno;
1617
 
    perror_plus("ioctl SIOCGIFFLAGS");
1618
 
#ifdef __linux__
1619
 
    if(restore_loglevel){
1620
 
      ret = klogctl(7, NULL, 0);
1621
 
      if(ret == -1){
1622
 
        perror_plus("klogctl");
1623
 
      }
1624
 
    }
1625
 
#endif  /* __linux__ */
1626
 
    /* Lower privileges */
1627
 
    lower_privileges();
1628
 
    errno = old_errno;
1629
 
    return ret_errno;
1630
 
  }
1631
 
  if((network.ifr_flags & IFF_UP) == 0){
 
1590
  if(not interface_is_up(interface)){
 
1591
    if(not get_flags(interface, &network) and debug){
 
1592
      ret_errno = errno;
 
1593
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1594
                   "\"%s\"\n", interface);
 
1595
      return ret_errno;
 
1596
    }
1632
1597
    network.ifr_flags |= IFF_UP;
1633
 
    ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1598
    
 
1599
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1600
    if(sd < 0){
 
1601
      ret_errno = errno;
 
1602
      perror_plus("socket");
 
1603
      errno = old_errno;
 
1604
      return ret_errno;
 
1605
    }
 
1606
  
 
1607
    if(quit_now){
 
1608
      close(sd);
 
1609
      errno = old_errno;
 
1610
      return EINTR;
 
1611
    }
 
1612
    
 
1613
    if(debug){
 
1614
      fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
 
1615
                   interface);
 
1616
    }
 
1617
    
 
1618
    /* Raise priviliges */
 
1619
    raise_privileges();
 
1620
    
 
1621
#ifdef __linux__
 
1622
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
1623
       messages about the network interface to mess up the prompt */
 
1624
    int ret_linux = klogctl(8, NULL, 5);
 
1625
    bool restore_loglevel = true;
 
1626
    if(ret_linux == -1){
 
1627
      restore_loglevel = false;
 
1628
      perror_plus("klogctl");
 
1629
    }
 
1630
#endif  /* __linux__ */
 
1631
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1632
    ret_errno = errno;
 
1633
#ifdef __linux__
 
1634
    if(restore_loglevel){
 
1635
      ret_linux = klogctl(7, NULL, 0);
 
1636
      if(ret_linux == -1){
 
1637
        perror_plus("klogctl");
 
1638
      }
 
1639
    }
 
1640
#endif  /* __linux__ */
 
1641
    
 
1642
    /* Lower privileges */
 
1643
    lower_privileges();
 
1644
    
 
1645
    /* Close the socket */
 
1646
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
1634
1647
    if(ret == -1){
1635
 
      ret_errno = errno;
 
1648
      perror_plus("close");
 
1649
    }
 
1650
    
 
1651
    if(ret_setflags == -1){
 
1652
      errno = ret_errno;
1636
1653
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1637
 
#ifdef __linux__
1638
 
      if(restore_loglevel){
1639
 
        ret = klogctl(7, NULL, 0);
1640
 
        if(ret == -1){
1641
 
          perror_plus("klogctl");
1642
 
        }
1643
 
      }
1644
 
#endif  /* __linux__ */
1645
 
        /* Lower privileges */
1646
 
      lower_privileges();
1647
1654
      errno = old_errno;
1648
1655
      return ret_errno;
1649
1656
    }
 
1657
  } else if(debug){
 
1658
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
 
1659
                 interface);
1650
1660
  }
 
1661
  
1651
1662
  /* Sleep checking until interface is running.
1652
1663
     Check every 0.25s, up to total time of delay */
1653
1664
  for(int i=0; i < delay * 4; i++){
1654
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1655
 
    if(ret == -1){
1656
 
      perror_plus("ioctl SIOCGIFFLAGS");
1657
 
    } else if(network.ifr_flags & IFF_RUNNING){
 
1665
    if(interface_is_running(interface)){
1658
1666
      break;
1659
1667
    }
1660
1668
    struct timespec sleeptime = { .tv_nsec = 250000000 };
1663
1671
      perror_plus("nanosleep");
1664
1672
    }
1665
1673
  }
1666
 
  /* Close the socket */
1667
 
  ret = (int)TEMP_FAILURE_RETRY(close(sd));
1668
 
  if(ret == -1){
1669
 
    perror_plus("close");
 
1674
  
 
1675
  errno = old_errno;
 
1676
  return 0;
 
1677
}
 
1678
 
 
1679
error_t take_down_interface(const char *const interface){
 
1680
  int sd = -1;
 
1681
  error_t old_errno = errno;
 
1682
  error_t ret_errno = 0;
 
1683
  int ret, ret_setflags;
 
1684
  struct ifreq network;
 
1685
  unsigned int if_index = if_nametoindex(interface);
 
1686
  if(if_index == 0){
 
1687
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
1688
    errno = old_errno;
 
1689
    return ENXIO;
1670
1690
  }
1671
 
#ifdef __linux__
1672
 
  if(restore_loglevel){
1673
 
    /* Restores kernel loglevel to default */
1674
 
    ret = klogctl(7, NULL, 0);
 
1691
  if(interface_is_up(interface)){
 
1692
    if(not get_flags(interface, &network) and debug){
 
1693
      ret_errno = errno;
 
1694
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1695
                   "\"%s\"\n", interface);
 
1696
      return ret_errno;
 
1697
    }
 
1698
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
 
1699
    
 
1700
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1701
    if(sd < 0){
 
1702
      ret_errno = errno;
 
1703
      perror_plus("socket");
 
1704
      errno = old_errno;
 
1705
      return ret_errno;
 
1706
    }
 
1707
    
 
1708
    if(debug){
 
1709
      fprintf_plus(stderr, "Taking down interface \"%s\"\n",
 
1710
                   interface);
 
1711
    }
 
1712
    
 
1713
    /* Raise priviliges */
 
1714
    raise_privileges();
 
1715
    
 
1716
    ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
1717
    ret_errno = errno;
 
1718
    
 
1719
    /* Lower privileges */
 
1720
    lower_privileges();
 
1721
    
 
1722
    /* Close the socket */
 
1723
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
1675
1724
    if(ret == -1){
1676
 
      perror_plus("klogctl");
1677
 
    }
 
1725
      perror_plus("close");
 
1726
    }
 
1727
    
 
1728
    if(ret_setflags == -1){
 
1729
      errno = ret_errno;
 
1730
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
1731
      errno = old_errno;
 
1732
      return ret_errno;
 
1733
    }
 
1734
  } else if(debug){
 
1735
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
 
1736
                 interface);
1678
1737
  }
1679
 
#endif  /* __linux__ */
1680
 
  /* Lower privileges */
1681
 
  lower_privileges();
 
1738
  
1682
1739
  errno = old_errno;
1683
1740
  return 0;
1684
1741
}
1685
1742
 
1686
1743
int main(int argc, char *argv[]){
1687
1744
  AvahiSServiceBrowser *sb = NULL;
1688
 
  int error;
 
1745
  error_t ret_errno;
1689
1746
  int ret;
1690
1747
  intmax_t tmpmax;
1691
1748
  char *tmp;
1692
1749
  int exitcode = EXIT_SUCCESS;
1693
 
  const char *interface = "";
1694
 
  struct ifreq network;
1695
 
  int sd = -1;
1696
 
  bool take_down_interface = false;
 
1750
  char *interfaces = NULL;
 
1751
  size_t interfaces_size = 0;
 
1752
  char *interfaces_to_take_down = NULL;
 
1753
  size_t interfaces_to_take_down_size = 0;
1697
1754
  char tempdir[] = "/tmp/mandosXXXXXX";
1698
1755
  bool tempdir_created = false;
1699
1756
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1700
1757
  const char *seckey = PATHDIR "/" SECKEY;
1701
1758
  const char *pubkey = PATHDIR "/" PUBKEY;
 
1759
  char *interfaces_hooks = NULL;
 
1760
  size_t interfaces_hooks_size = 0;
1702
1761
  
1703
1762
  bool gnutls_initialized = false;
1704
1763
  bool gpgme_initialized = false;
1795
1854
        connect_to = arg;
1796
1855
        break;
1797
1856
      case 'i':                 /* --interface */
1798
 
        interface = arg;
 
1857
        ret_errno = argz_add_sep(&interfaces, &interfaces_size, arg,
 
1858
                                 (int)',');
 
1859
        if(ret_errno != 0){
 
1860
          argp_error(state, "%s", strerror(ret_errno));
 
1861
        }
1799
1862
        break;
1800
1863
      case 's':                 /* --seckey */
1801
1864
        seckey = arg;
1933
1996
    }
1934
1997
  }
1935
1998
  
 
1999
  /* Remove empty interface names */
 
2000
  {
 
2001
    char *interface = NULL;
 
2002
    while((interface = argz_next(interfaces, interfaces_size,
 
2003
                                 interface))){
 
2004
      if(if_nametoindex(interface) == 0){
 
2005
        if(interface[0] != '\0' and strcmp(interface, "none") != 0){
 
2006
          fprintf_plus(stderr, "Not using nonexisting interface"
 
2007
                       " \"%s\"\n", interface);
 
2008
        }
 
2009
        argz_delete(&interfaces, &interfaces_size, interface);
 
2010
        interface = NULL;
 
2011
      }
 
2012
    }
 
2013
  }
 
2014
  
1936
2015
  /* Run network hooks */
1937
 
  if(not run_network_hooks("start", interface, delay)){
1938
 
    goto end;
 
2016
  {
 
2017
    ret_errno = argz_append(&interfaces_hooks, &interfaces_hooks_size,
 
2018
                            interfaces, interfaces_size);
 
2019
    if(ret_errno != 0){
 
2020
      errno = ret_errno;
 
2021
      perror_plus("argz_append");
 
2022
      goto end;
 
2023
    }
 
2024
    argz_stringify(interfaces_hooks, interfaces_hooks_size, (int)',');
 
2025
    if(not run_network_hooks("start", interfaces_hooks, delay)){
 
2026
      goto end;
 
2027
    }
1939
2028
  }
1940
2029
  
1941
2030
  if(not debug){
1942
2031
    avahi_set_log_function(empty_log);
1943
2032
  }
1944
2033
  
1945
 
  if(interface[0] == '\0'){
1946
 
    struct dirent **direntries;
1947
 
    /* First look for interfaces that are up */
1948
 
    ret = scandir(sys_class_net, &direntries, up_interface,
1949
 
                  alphasort);
1950
 
    if(ret == 0){
1951
 
      /* No up interfaces, look for any good interfaces */
1952
 
      free(direntries);
1953
 
      ret = scandir(sys_class_net, &direntries, good_interface,
1954
 
                    alphasort);
1955
 
    }
1956
 
    if(ret >= 1){
1957
 
      /* Pick the first interface returned */
1958
 
      interface = strdup(direntries[0]->d_name);
1959
 
      if(debug){
1960
 
        fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1961
 
      }
1962
 
      if(interface == NULL){
1963
 
        perror_plus("malloc");
1964
 
        free(direntries);
1965
 
        exitcode = EXIT_FAILURE;
1966
 
        goto end;
1967
 
      }
1968
 
      free(direntries);
1969
 
    } else {
1970
 
      free(direntries);
1971
 
      fprintf_plus(stderr, "Could not find a network interface\n");
1972
 
      exitcode = EXIT_FAILURE;
1973
 
      goto end;
1974
 
    }
1975
 
  }
1976
 
  
1977
2034
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1978
2035
     from the signal handler */
1979
2036
  /* Initialize the pseudo-RNG for Avahi */
2049
2106
    }
2050
2107
  }
2051
2108
  
2052
 
  /* If the interface is down, bring it up */
2053
 
  if((interface[0] != '\0') and (strcmp(interface, "none") != 0)){
2054
 
    ret = bring_up_interface(interface, delay);
2055
 
    if(ret != 0){
2056
 
      errno = ret;
2057
 
      perror_plus("Failed to bring up interface");
 
2109
  /* If no interfaces were specified, make a list */
 
2110
  if(interfaces == NULL){
 
2111
    struct dirent **direntries;
 
2112
    /* Look for any good interfaces */
 
2113
    ret = scandir(sys_class_net, &direntries, good_interface,
 
2114
                  alphasort);
 
2115
    if(ret >= 1){
 
2116
      /* Add all found interfaces to interfaces list */
 
2117
      for(int i = 0; i < ret; ++i){
 
2118
        ret_errno = argz_add(&interfaces, &interfaces_size,
 
2119
                             direntries[i]->d_name);
 
2120
        if(ret_errno != 0){
 
2121
          perror_plus("argz_add");
 
2122
          continue;
 
2123
        }
 
2124
        if(debug){
 
2125
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
 
2126
                       direntries[i]->d_name);
 
2127
        }
 
2128
      }
 
2129
      free(direntries);
 
2130
    } else {
 
2131
      free(direntries);
 
2132
      fprintf_plus(stderr, "Could not find a network interface\n");
 
2133
      exitcode = EXIT_FAILURE;
 
2134
      goto end;
 
2135
    }
 
2136
  }
 
2137
  
 
2138
  /* If we only got one interface, explicitly use only that one */
 
2139
  if(argz_count(interfaces, interfaces_size) == 1){
 
2140
    if(debug){
 
2141
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
 
2142
                   interfaces);
 
2143
    }
 
2144
    if_index = (AvahiIfIndex)if_nametoindex(interfaces);
 
2145
  }
 
2146
  
 
2147
  /* Bring up interfaces which are down */
 
2148
  if(not (argz_count(interfaces, interfaces_size) == 1
 
2149
          and strcmp(interfaces, "none") == 0)){
 
2150
    char *interface = NULL;
 
2151
    while((interface = argz_next(interfaces, interfaces_size,
 
2152
                                 interface))){
 
2153
      bool interface_was_up = interface_is_up(interface);
 
2154
      ret = bring_up_interface(interface, delay);
 
2155
      if(not interface_was_up){
 
2156
        if(ret != 0){
 
2157
          errno = ret;
 
2158
          perror_plus("Failed to bring up interface");
 
2159
        } else {
 
2160
          ret_errno = argz_add(&interfaces_to_take_down,
 
2161
                               &interfaces_to_take_down_size,
 
2162
                               interface);
 
2163
        }
 
2164
      }
 
2165
    }
 
2166
    free(interfaces);
 
2167
    interfaces = NULL;
 
2168
    interfaces_size = 0;
 
2169
    if(debug and (interfaces_to_take_down == NULL)){
 
2170
      fprintf_plus(stderr, "No interfaces were brought up\n");
2058
2171
    }
2059
2172
  }
2060
2173
  
2182
2295
    /* Allocate a new server */
2183
2296
    mc.server = avahi_server_new(avahi_simple_poll_get
2184
2297
                                 (mc.simple_poll), &config, NULL,
2185
 
                                 NULL, &error);
 
2298
                                 NULL, &ret_errno);
2186
2299
    
2187
2300
    /* Free the Avahi configuration data */
2188
2301
    avahi_server_config_free(&config);
2191
2304
  /* Check if creating the Avahi server object succeeded */
2192
2305
  if(mc.server == NULL){
2193
2306
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2194
 
                 avahi_strerror(error));
 
2307
                 avahi_strerror(ret_errno));
2195
2308
    exitcode = EX_UNAVAILABLE;
2196
2309
    goto end;
2197
2310
  }
2265
2378
    }
2266
2379
  }
2267
2380
  
2268
 
  /* Run network hooks */
2269
 
  run_network_hooks("stop", interface, delay);
2270
 
  
2271
2381
  /* Re-raise priviliges */
2272
2382
  {
2273
2383
    raise_privileges();
2274
2384
    
2275
 
    /* Take down the network interface */
2276
 
    if(take_down_interface and geteuid() == 0){
2277
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
2278
 
      if(ret == -1){
2279
 
        perror_plus("ioctl SIOCGIFFLAGS");
2280
 
      } else if(network.ifr_flags & IFF_UP){
2281
 
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2282
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
2283
 
        if(ret == -1){
2284
 
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
2385
    /* Run network hooks */
 
2386
    run_network_hooks("stop", interfaces_hooks, delay);
 
2387
    
 
2388
    /* Take down the network interfaces which were brought up */
 
2389
    {
 
2390
      char *interface = NULL;
 
2391
      while((interface=argz_next(interfaces_to_take_down,
 
2392
                                 interfaces_to_take_down_size,
 
2393
                                 interface))){
 
2394
        ret_errno = take_down_interface(interface);
 
2395
        if(ret_errno != 0){
 
2396
          errno = ret_errno;
 
2397
          perror_plus("Failed to take down interface");
2285
2398
        }
2286
2399
      }
2287
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2288
 
      if(ret == -1){
2289
 
        perror_plus("close");
 
2400
      if(debug and (interfaces_to_take_down == NULL)){
 
2401
        fprintf_plus(stderr, "No interfaces needed to be taken"
 
2402
                     " down\n");
2290
2403
      }
2291
2404
    }
2292
 
  }
2293
 
  /* Lower privileges permanently */
2294
 
  errno = 0;
2295
 
  ret = setuid(uid);
2296
 
  if(ret == -1){
2297
 
    perror_plus("setuid");
2298
 
  }
 
2405
    
 
2406
    lower_privileges_permanently();
 
2407
  }
 
2408
  
 
2409
  free(interfaces_to_take_down);
 
2410
  free(interfaces_hooks);
2299
2411
  
2300
2412
  /* Removes the GPGME temp directory and all files inside */
2301
2413
  if(tempdir_created){