/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

* plugins.d/mandos-client.c (main): Add "DELAY" environment variable.
                                    Check return value from setenv().

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
26
26
 * along with this program.  If not, see
27
27
 * <http://www.gnu.org/licenses/>.
28
28
 * 
29
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
29
 * Contact the authors at <mandos@recompile.se>.
30
30
 */
31
31
 
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
53
53
                                   sockaddr_in6, PF_INET6,
54
54
                                   SOCK_STREAM, uid_t, gid_t, open(),
55
55
                                   opendir(), DIR */
56
 
#include <sys/stat.h>           /* open() */
 
56
#include <sys/stat.h>           /* open(), S_ISREG */
57
57
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
58
58
                                   inet_pton(), connect() */
59
59
#include <fcntl.h>              /* open() */
123
123
#define PATHDIR "/conf/conf.d/mandos"
124
124
#define SECKEY "seckey.txt"
125
125
#define PUBKEY "pubkey.txt"
 
126
#define HOOKDIR "/lib/mandos/network-hooks.d"
126
127
 
127
128
bool debug = false;
128
129
static const char mandos_protocol_version[] = "1";
129
130
const char *argp_program_version = "mandos-client " VERSION;
130
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
131
const char *argp_program_bug_address = "<mandos@recompile.se>";
131
132
static const char sys_class_net[] = "/sys/class/net";
132
133
char *connect_to = NULL;
133
134
 
187
188
  return buffer_capacity;
188
189
}
189
190
 
 
191
/* Add server to set of servers to retry periodically */
190
192
int add_server(const char *ip, uint16_t port,
191
193
                 AvahiIfIndex if_index,
192
194
                 int af){
204
206
    perror_plus("strdup");
205
207
    return -1;
206
208
  }
207
 
  /* unique case of first server */
 
209
  /* Special case of first server */
208
210
  if (mc.current_server == NULL){
209
211
    new_server->next = new_server;
210
212
    new_server->prev = new_server;
211
213
    mc.current_server = new_server;
212
 
  /* Placing the new server last in the list */
 
214
  /* Place the new server last in the list */
213
215
  } else {
214
216
    new_server->next = mc.current_server;
215
217
    new_server->prev = mc.current_server->prev;
282
284
    return false;
283
285
  }
284
286
  
285
 
    /* Set GPGME home directory for the OpenPGP engine only */
 
287
  /* Set GPGME home directory for the OpenPGP engine only */
286
288
  rc = gpgme_get_engine_info(&engine_info);
287
289
  if(rc != GPG_ERR_NO_ERROR){
288
290
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
1084
1086
  errno = old_errno;
1085
1087
}
1086
1088
 
1087
 
/* 
1088
 
 * This function determines if a directory entry in /sys/class/net
1089
 
 * corresponds to an acceptable network device.
1090
 
 * (This function is passed to scandir(3) as a filter function.)
1091
 
 */
1092
 
int good_interface(const struct dirent *if_entry){
1093
 
  ssize_t ssret;
1094
 
  char *flagname = NULL;
1095
 
  if(if_entry->d_name[0] == '.'){
1096
 
    return 0;
1097
 
  }
1098
 
  int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
1099
 
                     if_entry->d_name);
1100
 
  if(ret < 0){
1101
 
    perror_plus("asprintf");
1102
 
    return 0;
1103
 
  }
1104
 
  int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
1105
 
  if(flags_fd == -1){
1106
 
    perror_plus("open");
1107
 
    free(flagname);
1108
 
    return 0;
1109
 
  }
1110
 
  free(flagname);
1111
 
  typedef short ifreq_flags;    /* ifreq.ifr_flags in netdevice(7) */
1112
 
  /* read line from flags_fd */
1113
 
  ssize_t to_read = 2+(sizeof(ifreq_flags)*2)+1; /* "0x1003\n" */
1114
 
  char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */
1115
 
  flagstring[(size_t)to_read] = '\0';
1116
 
  if(flagstring == NULL){
1117
 
    perror_plus("malloc");
1118
 
    close(flags_fd);
1119
 
    return 0;
1120
 
  }
1121
 
  while(to_read > 0){
1122
 
    ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1123
 
                                             (size_t)to_read));
1124
 
    if(ssret == -1){
1125
 
      perror_plus("read");
1126
 
      free(flagstring);
1127
 
      close(flags_fd);
1128
 
      return 0;
1129
 
    }
1130
 
    to_read -= ssret;
1131
 
    if(ssret == 0){
1132
 
      break;
1133
 
    }
1134
 
  }
1135
 
  close(flags_fd);
1136
 
  intmax_t tmpmax;
1137
 
  char *tmp;
1138
 
  errno = 0;
1139
 
  tmpmax = strtoimax(flagstring, &tmp, 0);
1140
 
  if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1141
 
                                         and not (isspace(*tmp)))
1142
 
     or tmpmax != (ifreq_flags)tmpmax){
 
1089
bool get_flags(const char *ifname, struct ifreq *ifr){
 
1090
  int ret;
 
1091
  
 
1092
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1093
  if(s < 0){
 
1094
    perror_plus("socket");
 
1095
    return false;
 
1096
  }
 
1097
  strcpy(ifr->ifr_name, ifname);
 
1098
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
 
1099
  if(ret == -1){
1143
1100
    if(debug){
1144
 
      fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
1145
 
              flagstring, if_entry->d_name);
 
1101
      perror_plus("ioctl SIOCGIFFLAGS");
1146
1102
    }
1147
 
    free(flagstring);
1148
 
    return 0;
 
1103
    return false;
1149
1104
  }
1150
 
  free(flagstring);
1151
 
  ifreq_flags flags = (ifreq_flags)tmpmax;
 
1105
  return true;
 
1106
}
 
1107
 
 
1108
bool good_flags(const char *ifname, const struct ifreq *ifr){
 
1109
  
1152
1110
  /* Reject the loopback device */
1153
 
  if(flags & IFF_LOOPBACK){
 
1111
  if(ifr->ifr_flags & IFF_LOOPBACK){
1154
1112
    if(debug){
1155
1113
      fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1156
 
              if_entry->d_name);
 
1114
              ifname);
1157
1115
    }
1158
 
    return 0;
 
1116
    return false;
1159
1117
  }
1160
1118
  /* Accept point-to-point devices only if connect_to is specified */
1161
 
  if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
 
1119
  if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1162
1120
    if(debug){
1163
1121
      fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1164
 
              if_entry->d_name);
 
1122
              ifname);
1165
1123
    }
1166
 
    return 1;
 
1124
    return true;
1167
1125
  }
1168
1126
  /* Otherwise, reject non-broadcast-capable devices */
1169
 
  if(not (flags & IFF_BROADCAST)){
 
1127
  if(not (ifr->ifr_flags & IFF_BROADCAST)){
1170
1128
    if(debug){
1171
1129
      fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1172
 
              if_entry->d_name);
 
1130
              ifname);
1173
1131
    }
1174
 
    return 0;
 
1132
    return false;
1175
1133
  }
1176
1134
  /* Reject non-ARP interfaces (including dummy interfaces) */
1177
 
  if(flags & IFF_NOARP){
 
1135
  if(ifr->ifr_flags & IFF_NOARP){
1178
1136
    if(debug){
1179
 
      fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n",
1180
 
              if_entry->d_name);
 
1137
      fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n", ifname);
1181
1138
    }
1182
 
    return 0;
 
1139
    return false;
1183
1140
  }
 
1141
  
1184
1142
  /* Accept this device */
1185
1143
  if(debug){
1186
 
    fprintf(stderr, "Interface \"%s\" is acceptable\n",
1187
 
            if_entry->d_name);
 
1144
    fprintf(stderr, "Interface \"%s\" is good\n", ifname);
 
1145
  }
 
1146
  return true;
 
1147
}
 
1148
 
 
1149
/* 
 
1150
 * This function determines if a directory entry in /sys/class/net
 
1151
 * corresponds to an acceptable network device.
 
1152
 * (This function is passed to scandir(3) as a filter function.)
 
1153
 */
 
1154
int good_interface(const struct dirent *if_entry){
 
1155
  if(if_entry->d_name[0] == '.'){
 
1156
    return 0;
 
1157
  }
 
1158
  
 
1159
  struct ifreq ifr;
 
1160
  if(not get_flags(if_entry->d_name, &ifr)){
 
1161
    if(debug){
 
1162
      fprintf(stderr, "Failed to get flags for interface \"%s\"\n",
 
1163
              if_entry->d_name);
 
1164
    }
 
1165
    return 0;
 
1166
  }
 
1167
  
 
1168
  if(not good_flags(if_entry->d_name, &ifr)){
 
1169
    return 0;
 
1170
  }
 
1171
  return 1;
 
1172
}
 
1173
 
 
1174
/* 
 
1175
 * This function determines if a directory entry in /sys/class/net
 
1176
 * corresponds to an acceptable network device which is up.
 
1177
 * (This function is passed to scandir(3) as a filter function.)
 
1178
 */
 
1179
int up_interface(const struct dirent *if_entry){
 
1180
  if(if_entry->d_name[0] == '.'){
 
1181
    return 0;
 
1182
  }
 
1183
  
 
1184
  struct ifreq ifr;
 
1185
  if(not get_flags(if_entry->d_name, &ifr)){
 
1186
    if(debug){
 
1187
      fprintf(stderr, "Failed to get flags for interface \"%s\"\n",
 
1188
              if_entry->d_name);
 
1189
    }
 
1190
    return 0;
 
1191
  }
 
1192
  
 
1193
  /* Reject down interfaces */
 
1194
  if(not (ifr.ifr_flags & IFF_UP)){
 
1195
    if(debug){
 
1196
      fprintf(stderr, "Rejecting down interface \"%s\"\n",
 
1197
              if_entry->d_name);
 
1198
    }
 
1199
    return 0;
 
1200
  }
 
1201
  
 
1202
  /* Reject non-running interfaces */
 
1203
  if(not (ifr.ifr_flags & IFF_RUNNING)){
 
1204
    if(debug){
 
1205
      fprintf(stderr, "Rejecting non-running interface \"%s\"\n",
 
1206
              if_entry->d_name);
 
1207
    }
 
1208
    return 0;
 
1209
  }
 
1210
  
 
1211
  if(not good_flags(if_entry->d_name, &ifr)){
 
1212
    return 0;
1188
1213
  }
1189
1214
  return 1;
1190
1215
}
1200
1225
  return 1;
1201
1226
}
1202
1227
 
 
1228
/* Is this directory entry a runnable program? */
 
1229
int runnable_hook(const struct dirent *direntry){
 
1230
  int ret;
 
1231
  struct stat st;
 
1232
  
 
1233
  if((direntry->d_name)[0] == '\0'){
 
1234
    /* Empty name? */
 
1235
    return 0;
 
1236
  }
 
1237
  
 
1238
  /* Save pointer to last character */
 
1239
  char *end = strchr(direntry->d_name, '\0')-1;
 
1240
  
 
1241
  if(*end == '~'){
 
1242
    /* Backup name~ */
 
1243
    return 0;
 
1244
  }
 
1245
  
 
1246
  if(((direntry->d_name)[0] == '#')
 
1247
     and (*end == '#')){
 
1248
    /* Temporary #name# */
 
1249
    return 0;
 
1250
  }
 
1251
  
 
1252
  /* XXX more rules here */
 
1253
  
 
1254
  ret = stat(direntry->d_name, &st);
 
1255
  if(ret == -1){
 
1256
    if(debug){
 
1257
      perror_plus("Could not stat plugin");
 
1258
    }
 
1259
    return 0;
 
1260
  }
 
1261
  if(not (S_ISREG(st.st_mode))){
 
1262
    /* Not a regular file */
 
1263
    return 0;
 
1264
  }
 
1265
  if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
 
1266
    /* Not executable */
 
1267
    return 0;
 
1268
  }
 
1269
  return 1;
 
1270
}
 
1271
 
1203
1272
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
1204
1273
  int ret;
1205
1274
  struct timespec now;
1206
1275
  struct timespec waited_time;
1207
1276
  intmax_t block_time;
1208
 
 
 
1277
  
1209
1278
  while(true){
1210
1279
    if(mc.current_server == NULL){
1211
1280
      if (debug){
1236
1305
      block_time = ((retry_interval
1237
1306
                     - ((intmax_t)waited_time.tv_sec * 1000))
1238
1307
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1239
 
 
 
1308
      
1240
1309
      if (debug){
1241
 
        fprintf(stderr, "Blocking for %ld ms\n", block_time);
 
1310
        fprintf(stderr, "Blocking for %" PRIdMAX " ms\n", block_time);
1242
1311
      }
1243
 
 
 
1312
      
1244
1313
      if(block_time <= 0){
1245
1314
        ret = start_mandos_communication(mc.current_server->ip,
1246
1315
                                         mc.current_server->port,
1411
1480
        errno = 0;
1412
1481
        retry_interval = strtod(arg, &tmp);
1413
1482
        if(errno != 0 or tmp == arg or *tmp != '\0'
1414
 
           or (retry_interval * 1000) > INT_MAX){
 
1483
           or (retry_interval * 1000) > INT_MAX
 
1484
           or retry_interval < 0){
1415
1485
          argp_error(state, "Bad retry interval");
1416
1486
        }
1417
1487
        break;
1455
1525
      goto end;
1456
1526
    }
1457
1527
  }
 
1528
    
 
1529
  {
 
1530
    /* Work around Debian bug #633582:
 
1531
       <http://bugs.debian.org/633582> */
 
1532
    struct stat st;
 
1533
    
 
1534
    /* Re-raise priviliges */
 
1535
    errno = 0;
 
1536
    ret = seteuid(0);
 
1537
    if(ret == -1){
 
1538
      perror_plus("seteuid");
 
1539
    }
 
1540
    
 
1541
    if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
 
1542
      int seckey_fd = open(seckey, O_RDONLY);
 
1543
      if(seckey_fd == -1){
 
1544
        perror_plus("open");
 
1545
      } else {
 
1546
        ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
 
1547
        if(ret == -1){
 
1548
          perror_plus("fstat");
 
1549
        } else {
 
1550
          if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
1551
            ret = fchown(seckey_fd, uid, gid);
 
1552
            if(ret == -1){
 
1553
              perror_plus("fchown");
 
1554
            }
 
1555
          }
 
1556
        }
 
1557
        TEMP_FAILURE_RETRY(close(seckey_fd));
 
1558
      }
 
1559
    }
 
1560
    
 
1561
    if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
 
1562
      int pubkey_fd = open(pubkey, O_RDONLY);
 
1563
      if(pubkey_fd == -1){
 
1564
        perror_plus("open");
 
1565
      } else {
 
1566
        ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
 
1567
        if(ret == -1){
 
1568
          perror_plus("fstat");
 
1569
        } else {
 
1570
          if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
1571
            ret = fchown(pubkey_fd, uid, gid);
 
1572
            if(ret == -1){
 
1573
              perror_plus("fchown");
 
1574
            }
 
1575
          }
 
1576
        }
 
1577
        TEMP_FAILURE_RETRY(close(pubkey_fd));
 
1578
      }
 
1579
    }
 
1580
    
 
1581
    /* Lower privileges */
 
1582
    errno = 0;
 
1583
    ret = seteuid(uid);
 
1584
    if(ret == -1){
 
1585
      perror_plus("seteuid");
 
1586
    }
 
1587
  }
 
1588
  
 
1589
  /* Find network hooks and run them */
 
1590
  {
 
1591
    struct dirent **direntries;
 
1592
    struct dirent *direntry;
 
1593
    int numhooks = scandir(HOOKDIR, &direntries, runnable_hook,
 
1594
                           alphasort);
 
1595
    int devnull = open("/dev/null", O_RDONLY);
 
1596
    for(int i = 0; i < numhooks; i++){
 
1597
      direntry = direntries[0];
 
1598
      char *fullname = NULL;
 
1599
      ret = asprintf(&fullname, "%s/%s", tempdir,
 
1600
                     direntry->d_name);
 
1601
      if(ret < 0){
 
1602
        perror_plus("asprintf");
 
1603
        continue;
 
1604
      }
 
1605
      pid_t hook_pid = fork();
 
1606
      if(hook_pid == 0){
 
1607
        /* Child */
 
1608
        dup2(devnull, STDIN_FILENO);
 
1609
        close(devnull);
 
1610
        dup2(STDERR_FILENO, STDOUT_FILENO);
 
1611
        ret = setenv("DEVICE", interface, 1);
 
1612
        if(ret == -1){
 
1613
          perror_plus("setenv");
 
1614
          exit(1);
 
1615
        }
 
1616
        ret = setenv("VERBOSE", debug ? "1" : "0", 1);
 
1617
        if(ret == -1){
 
1618
          perror_plus("setenv");
 
1619
          exit(1);
 
1620
        }
 
1621
        ret = setenv("MODE", "start", 1);
 
1622
        if(ret == -1){
 
1623
          perror_plus("setenv");
 
1624
          exit(1);
 
1625
        }
 
1626
        char *delaystring;
 
1627
        ret = asprintf(&delaystring, "%f", delay);
 
1628
        if(ret == -1){
 
1629
          perror_plus("asprintf");
 
1630
          exit(1);
 
1631
        }
 
1632
        ret = setenv("DELAY", delaystring, 1);
 
1633
        if(ret == -1){
 
1634
          free(delaystring);
 
1635
          perror_plus("setenv");
 
1636
          exit(1);
 
1637
        }
 
1638
        free(delaystring);
 
1639
        ret = execl(fullname, direntry->d_name, "start", NULL);
 
1640
        perror_plus("execl");
 
1641
      }
 
1642
      free(fullname);
 
1643
      if(quit_now){
 
1644
        goto end;
 
1645
      }
 
1646
    }
 
1647
    close(devnull);
 
1648
  }
1458
1649
  
1459
1650
  if(not debug){
1460
1651
    avahi_set_log_function(empty_log);
1461
1652
  }
1462
 
 
 
1653
  
1463
1654
  if(interface[0] == '\0'){
1464
1655
    struct dirent **direntries;
1465
 
    ret = scandir(sys_class_net, &direntries, good_interface,
 
1656
    /* First look for interfaces that are up */
 
1657
    ret = scandir(sys_class_net, &direntries, up_interface,
1466
1658
                  alphasort);
 
1659
    if(ret == 0){
 
1660
      /* No up interfaces, look for any good interfaces */
 
1661
      free(direntries);
 
1662
      ret = scandir(sys_class_net, &direntries, good_interface,
 
1663
                    alphasort);
 
1664
    }
1467
1665
    if(ret >= 1){
1468
 
      /* Pick the first good interface */
 
1666
      /* Pick the first interface returned */
1469
1667
      interface = strdup(direntries[0]->d_name);
1470
1668
      if(debug){
1471
1669
        fprintf(stderr, "Using interface \"%s\"\n", interface);
1773
1971
    
1774
1972
    port = (uint16_t)tmpmax;
1775
1973
    *address = '\0';
1776
 
    address = connect_to;
1777
1974
    /* Colon in address indicates IPv6 */
1778
1975
    int af;
1779
 
    if(strchr(address, ':') != NULL){
 
1976
    if(strchr(connect_to, ':') != NULL){
1780
1977
      af = AF_INET6;
 
1978
      /* Accept [] around IPv6 address - see RFC 5952 */
 
1979
      if(connect_to[0] == '[' and address[-1] == ']')
 
1980
        {
 
1981
          connect_to++;
 
1982
          address[-1] = '\0';
 
1983
        }
1781
1984
    } else {
1782
1985
      af = AF_INET;
1783
1986
    }
 
1987
    address = connect_to;
1784
1988
    
1785
1989
    if(quit_now){
1786
1990
      goto end;
1787
1991
    }
1788
 
 
 
1992
    
1789
1993
    while(not quit_now){
1790
1994
      ret = start_mandos_communication(address, port, if_index, af);
1791
1995
      if(quit_now or ret == 0){
1792
1996
        break;
1793
1997
      }
1794
 
      sleep((int)retry_interval or 1);
1795
 
    };
1796
 
 
 
1998
      if(debug){
 
1999
        fprintf(stderr, "Retrying in %d seconds\n",
 
2000
                (int)retry_interval);
 
2001
      }
 
2002
      sleep((int)retry_interval);
 
2003
    }
 
2004
    
1797
2005
    if (not quit_now){
1798
2006
      exitcode = EXIT_SUCCESS;
1799
2007
    }
1800
 
 
 
2008
    
1801
2009
    goto end;
1802
2010
  }
1803
2011
  
1900
2108
    }
1901
2109
  }
1902
2110
  
 
2111
  /* XXX run network hooks "stop" here  */
 
2112
  
1903
2113
  /* Take down the network interface */
1904
2114
  if(take_down_interface){
1905
2115
    /* Re-raise priviliges */
1936
2146
  if(tempdir_created){
1937
2147
    struct dirent **direntries = NULL;
1938
2148
    struct dirent *direntry = NULL;
1939
 
    ret = scandir(tempdir, &direntries, notdotentries, alphasort);
1940
 
    if (ret > 0){
1941
 
      for(int i = 0; i < ret; i++){
 
2149
    int numentries = scandir(tempdir, &direntries, notdotentries,
 
2150
                             alphasort);
 
2151
    if (numentries > 0){
 
2152
      for(int i = 0; i < numentries; i++){
1942
2153
        direntry = direntries[i];
1943
2154
        char *fullname = NULL;
1944
2155
        ret = asprintf(&fullname, "%s/%s", tempdir,
1956
2167
      }
1957
2168
    }
1958
2169
 
1959
 
    /* need to be cleaned even if ret == 0 because man page doesn't
1960
 
       specify */
 
2170
    /* need to clean even if 0 because man page doesn't specify */
1961
2171
    free(direntries);
1962
 
    if (ret == -1){
 
2172
    if (numentries == -1){
1963
2173
      perror_plus("scandir");
1964
2174
    }
1965
2175
    ret = rmdir(tempdir);