Return to wait_unix.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr / packet

mtr 0.94

    1: /*
    2:     mtr  --  a network diagnostic tool
    3:     Copyright (C) 2016  Matt Kimball
    4: 
    5:     This program is free software; you can redistribute it and/or modify
    6:     it under the terms of the GNU General Public License version 2 as
    7:     published by the Free Software Foundation.
    8: 
    9:     This program is distributed in the hope that it will be useful,
   10:     but WITHOUT ANY WARRANTY; without even the implied warranty of
   11:     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   12:     GNU General Public License for more details.
   13: 
   14:     You should have received a copy of the GNU General Public License along
   15:     with this program; if not, write to the Free Software Foundation, Inc.,
   16:     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
   17: */
   18: 
   19: #include "wait.h"
   20: 
   21: #include <assert.h>
   22: #include <errno.h>
   23: #ifdef HAVE_ERROR_H
   24: #include <error.h>
   25: #else
   26: #include "portability/error.h"
   27: #endif
   28: #include <stdbool.h>
   29: #include <stdio.h>
   30: #include <stdlib.h>
   31: #include <string.h>
   32: #include <sys/select.h>
   33: 
   34: /*
   35:     Gather all the file descriptors which should wake our select call when
   36:     they become readable.
   37: */
   38: static
   39: int gather_read_fds(
   40:     const struct command_buffer_t *command_buffer,
   41:     const struct net_state_t *net_state,
   42:     fd_set * read_set,
   43:     fd_set * write_set)
   44: {
   45:     int nfds;
   46:     int probe_nfds;
   47:     int ip4_socket;
   48:     int ip6_socket;
   49:     int command_stream = command_buffer->command_stream;
   50: 
   51:     FD_ZERO(read_set);
   52:     FD_ZERO(write_set);
   53: 
   54:     FD_SET(command_stream, read_set);
   55:     nfds = command_stream + 1;
   56: 
   57:     if (net_state->platform.ip4_socket_raw) {
   58:         ip4_socket = net_state->platform.ip4_recv_socket;
   59:         FD_SET(ip4_socket, read_set);
   60:         if (ip4_socket >= nfds) {
   61:             nfds = ip4_socket + 1;
   62:         }
   63:     } else {
   64:         ip4_socket = net_state->platform.ip4_txrx_icmp_socket;
   65:         FD_SET(ip4_socket, read_set);
   66:         if (ip4_socket >= nfds) {
   67:             nfds = ip4_socket + 1;
   68:         }
   69:         ip4_socket = net_state->platform.ip4_txrx_udp_socket;
   70:         FD_SET(ip4_socket, read_set);
   71:         if (ip4_socket >= nfds) {
   72:             nfds = ip4_socket + 1;
   73:         }
   74:     }
   75: 
   76:     if (net_state->platform.ip6_socket_raw) {
   77:         ip6_socket = net_state->platform.ip6_recv_socket;
   78:         FD_SET(ip6_socket, read_set);
   79:         if (ip6_socket >= nfds) {
   80:             nfds = ip6_socket + 1;
   81:         }
   82:     } else {
   83:         ip6_socket = net_state->platform.ip6_txrx_icmp_socket;
   84:         FD_SET(ip6_socket, read_set);
   85:         if (ip6_socket >= nfds) {
   86:             nfds = ip6_socket + 1;
   87:         }
   88:         ip6_socket = net_state->platform.ip6_txrx_udp_socket;
   89:         FD_SET(ip6_socket, read_set);
   90:         if (ip6_socket >= nfds) {
   91:             nfds = ip6_socket + 1;
   92:         }
   93:     }
   94: 
   95:     probe_nfds = gather_probe_sockets(net_state, write_set);
   96:     if (probe_nfds > nfds) {
   97:         nfds = probe_nfds;
   98:     }
   99: 
  100:     return nfds;
  101: }
  102: 
  103: /*
  104:     Sleep until we receive a new probe response, a new command on the
  105:     command stream, or a probe timeout.  On Unix systems, this means
  106:     we use select to wait on file descriptors for the command stream
  107:     and the raw receive socket.
  108: */
  109: void wait_for_activity(
  110:     struct command_buffer_t *command_buffer,
  111:     struct net_state_t *net_state)
  112: {
  113:     int nfds;
  114:     fd_set read_set;
  115:     fd_set write_set;
  116:     struct timeval probe_timeout;
  117:     struct timeval *select_timeout;
  118:     int ready_count;
  119: 
  120:     nfds =
  121:         gather_read_fds(command_buffer, net_state, &read_set, &write_set);
  122: 
  123:     while (true) {
  124:         select_timeout = NULL;
  125: 
  126:         /*  Use the soonest probe timeout time as our maximum wait time  */
  127:         if (get_next_probe_timeout(net_state, &probe_timeout)) {
  128:             assert(probe_timeout.tv_sec >= 0);
  129:             select_timeout = &probe_timeout;
  130:         }
  131: 
  132:         ready_count =
  133:             select(nfds, &read_set, &write_set, NULL, select_timeout);
  134: 
  135:         /*
  136:            If we didn't have an error, either one of our descriptors is
  137:            readable, or we timed out.  So we can now return.
  138:          */
  139:         if (ready_count != -1) {
  140:             break;
  141:         }
  142: 
  143:         /*
  144:            We will get EINTR if we received a signal during the select, so
  145:            retry in that case.  We may get EAGAIN if "the kernel was
  146:            (perhaps temporarily) unable to allocate the requested number of
  147:            file descriptors."  I haven't seen this in practice, but selecting
  148:            again seems like the right thing to do.
  149:          */
  150:         if (errno != EINTR && errno != EAGAIN) {
  151:             /*  We don't expect other errors, so report them  */
  152:             error(EXIT_FAILURE, errno, "unexpected select error");
  153:         }
  154:     }
  155: }