/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

* plugins.d/mandos-client.c (good_interface): Add error message.
  (up_interface): Use get_flags() and good_flags().  Also check the
                  IFF_RUNNING flags.
  (runnable_hook): Bug fix: Add NULL to execl() call.
  (main): Use network interfaces which are up and running in
          preference to any other interfaces.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
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() */
1152
1152
 * (This function is passed to scandir(3) as a filter function.)
1153
1153
 */
1154
1154
int good_interface(const struct dirent *if_entry){
1155
 
  int ret;
1156
1155
  if(if_entry->d_name[0] == '.'){
1157
1156
    return 0;
1158
1157
  }
 
1158
  
1159
1159
  struct ifreq ifr;
1160
 
 
1161
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
    }
1162
1165
    return 0;
1163
1166
  }
1164
1167
  
1174
1177
 * (This function is passed to scandir(3) as a filter function.)
1175
1178
 */
1176
1179
int up_interface(const struct dirent *if_entry){
1177
 
  ssize_t ssret;
1178
 
  char *flagname = NULL;
1179
1180
  if(if_entry->d_name[0] == '.'){
1180
1181
    return 0;
1181
1182
  }
1182
 
  int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
1183
 
                     if_entry->d_name);
1184
 
  if(ret < 0){
1185
 
    perror_plus("asprintf");
1186
 
    return 0;
1187
 
  }
1188
 
  int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
1189
 
  if(flags_fd == -1){
1190
 
    perror_plus("open");
1191
 
    free(flagname);
1192
 
    return 0;
1193
 
  }
1194
 
  free(flagname);
1195
 
  typedef short ifreq_flags;    /* ifreq.ifr_flags in netdevice(7) */
1196
 
  /* read line from flags_fd */
1197
 
  ssize_t to_read = 2+(sizeof(ifreq_flags)*2)+1; /* "0x1003\n" */
1198
 
  char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */
1199
 
  flagstring[(size_t)to_read] = '\0';
1200
 
  if(flagstring == NULL){
1201
 
    perror_plus("malloc");
1202
 
    close(flags_fd);
1203
 
    return 0;
1204
 
  }
1205
 
  while(to_read > 0){
1206
 
    ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1207
 
                                             (size_t)to_read));
1208
 
    if(ssret == -1){
1209
 
      perror_plus("read");
1210
 
      free(flagstring);
1211
 
      close(flags_fd);
1212
 
      return 0;
1213
 
    }
1214
 
    to_read -= ssret;
1215
 
    if(ssret == 0){
1216
 
      break;
1217
 
    }
1218
 
  }
1219
 
  close(flags_fd);
1220
 
  intmax_t tmpmax;
1221
 
  char *tmp;
1222
 
  errno = 0;
1223
 
  tmpmax = strtoimax(flagstring, &tmp, 0);
1224
 
  if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1225
 
                                         and not (isspace(*tmp)))
1226
 
     or tmpmax != (ifreq_flags)tmpmax){
1227
 
    if(debug){
1228
 
      fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
1229
 
              flagstring, if_entry->d_name);
1230
 
    }
1231
 
    free(flagstring);
1232
 
    return 0;
1233
 
  }
1234
 
  free(flagstring);
1235
 
  ifreq_flags flags = (ifreq_flags)tmpmax;
1236
 
  /* Reject the loopback device */
1237
 
  if(flags & IFF_LOOPBACK){
1238
 
    if(debug){
1239
 
      fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
 
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",
1240
1188
              if_entry->d_name);
1241
1189
    }
1242
1190
    return 0;
1243
1191
  }
1244
 
 
 
1192
  
1245
1193
  /* Reject down interfaces */
1246
 
  if(not (flags & IFF_UP)){
1247
 
    return 0;
1248
 
  }
1249
 
  
1250
 
  /* Accept point-to-point devices only if connect_to is specified */
1251
 
  if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
1252
 
    if(debug){
1253
 
      fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1254
 
              if_entry->d_name);
1255
 
    }
1256
 
    return 1;
1257
 
  }
1258
 
  /* Otherwise, reject non-broadcast-capable devices */
1259
 
  if(not (flags & IFF_BROADCAST)){
1260
 
    if(debug){
1261
 
      fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1262
 
              if_entry->d_name);
1263
 
    }
1264
 
    return 0;
1265
 
  }
1266
 
  /* Reject non-ARP interfaces (including dummy interfaces) */
1267
 
  if(flags & IFF_NOARP){
1268
 
    if(debug){
1269
 
      fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n",
1270
 
              if_entry->d_name);
1271
 
    }
1272
 
    return 0;
1273
 
  }
1274
 
  /* Accept this device */
1275
 
  if(debug){
1276
 
    fprintf(stderr, "Interface \"%s\" is acceptable\n",
1277
 
            if_entry->d_name);
 
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;
1278
1213
  }
1279
1214
  return 1;
1280
1215
}
1323
1258
    }
1324
1259
    return 0;
1325
1260
  }
1326
 
  if(not (st.st_mode & S_ISREG)){
 
1261
  if(not (S_ISREG(st.st_mode))){
1327
1262
    /* Not a regular file */
1328
1263
    return 0;
1329
1264
  }
1677
1612
        setenv("VERBOSE", debug ? "1" : "0", 1);
1678
1613
        setenv("MODE", "start", 1);
1679
1614
        /* setenv( XXX more here */
1680
 
        ret = execl(fullname, direntry->d_name, "start");
 
1615
        ret = execl(fullname, direntry->d_name, "start", NULL);
1681
1616
        perror_plus("execl");
1682
1617
      }
1683
1618
      free(fullname);
1694
1629
  
1695
1630
  if(interface[0] == '\0'){
1696
1631
    struct dirent **direntries;
1697
 
    ret = scandir(sys_class_net, &direntries, good_interface,
 
1632
    /* First look for interfaces that are up */
 
1633
    ret = scandir(sys_class_net, &direntries, up_interface,
1698
1634
                  alphasort);
 
1635
    if(ret == 0){
 
1636
      /* No up interfaces, look for any good interfaces */
 
1637
      free(direntries);
 
1638
      ret = scandir(sys_class_net, &direntries, good_interface,
 
1639
                    alphasort);
 
1640
    }
1699
1641
    if(ret >= 1){
1700
 
      /* Pick the first good interface */
 
1642
      /* Pick the first interface returned */
1701
1643
      interface = strdup(direntries[0]->d_name);
1702
1644
      if(debug){
1703
1645
        fprintf(stderr, "Using interface \"%s\"\n", interface);