Return to wait_unix.c CVS log

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

Annotation of embedaddon/mtr/packet/wait_unix.c, revision 1.1.1.1

1.1       misho       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
                     15:     along with this program; if not, write to the Free Software
                     16:     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
                     17: */
                     18: 
                     19: #include "wait.h"
                     20: 
                     21: #include <assert.h>
                     22: #include <errno.h>
                     23: #include <stdbool.h>
                     24: #include <stdio.h>
                     25: #include <stdlib.h>
                     26: #include <string.h>
                     27: #include <sys/select.h>
                     28: 
                     29: /*
                     30:     Gather all the file descriptors which should wake our select call when
                     31:     they become readable.
                     32: */
                     33: static
                     34: int gather_read_fds(
                     35:     const struct command_buffer_t *command_buffer,
                     36:     const struct net_state_t *net_state,
                     37:     fd_set * read_set,
                     38:     fd_set * write_set)
                     39: {
                     40:     int nfds;
                     41:     int probe_nfds;
                     42:     int ip4_socket = net_state->platform.ip4_recv_socket;
                     43:     int ip6_socket = net_state->platform.ip6_recv_socket;
                     44:     int command_stream = command_buffer->command_stream;
                     45: 
                     46:     FD_ZERO(read_set);
                     47:     FD_ZERO(write_set);
                     48: 
                     49:     FD_SET(command_stream, read_set);
                     50:     nfds = command_stream + 1;
                     51: 
                     52:     FD_SET(ip4_socket, read_set);
                     53:     if (ip4_socket >= nfds) {
                     54:         nfds = ip4_socket + 1;
                     55:     }
                     56: 
                     57:     FD_SET(ip6_socket, read_set);
                     58:     if (ip6_socket >= nfds) {
                     59:         nfds = ip6_socket + 1;
                     60:     }
                     61: 
                     62:     probe_nfds = gather_probe_sockets(net_state, write_set);
                     63:     if (probe_nfds > nfds) {
                     64:         nfds = probe_nfds;
                     65:     }
                     66: 
                     67:     return nfds;
                     68: }
                     69: 
                     70: /*
                     71:     Sleep until we receive a new probe response, a new command on the
                     72:     command stream, or a probe timeout.  On Unix systems, this means
                     73:     we use select to wait on file descriptors for the command stream
                     74:     and the raw recieve socket.
                     75: */
                     76: void wait_for_activity(
                     77:     struct command_buffer_t *command_buffer,
                     78:     struct net_state_t *net_state)
                     79: {
                     80:     int nfds;
                     81:     fd_set read_set;
                     82:     fd_set write_set;
                     83:     struct timeval probe_timeout;
                     84:     struct timeval *select_timeout;
                     85:     int ready_count;
                     86: 
                     87:     nfds =
                     88:         gather_read_fds(command_buffer, net_state, &read_set, &write_set);
                     89: 
                     90:     while (true) {
                     91:         select_timeout = NULL;
                     92: 
                     93:         /*  Use the soonest probe timeout time as our maximum wait time  */
                     94:         if (get_next_probe_timeout(net_state, &probe_timeout)) {
                     95:             assert(probe_timeout.tv_sec >= 0);
                     96:             select_timeout = &probe_timeout;
                     97:         }
                     98: 
                     99:         ready_count =
                    100:             select(nfds, &read_set, &write_set, NULL, select_timeout);
                    101: 
                    102:         /*
                    103:            If we didn't have an error, either one of our descriptors is
                    104:            readable, or we timed out.  So we can now return.
                    105:          */
                    106:         if (ready_count != -1) {
                    107:             break;
                    108:         }
                    109: 
                    110:         /*
                    111:            We will get EINTR if we received a signal during the select, so
                    112:            retry in that case.  We may get EAGAIN if "the kernel was
                    113:            (perhaps temporarily) unable to allocate the requested number of
                    114:            file descriptors."  I haven't seen this in practice, but selecting
                    115:            again seems like the right thing to do.
                    116:          */
                    117:         if (errno != EINTR && errno != EAGAIN) {
                    118:             /*  We don't expect other errors, so report them  */
                    119:             perror("unexpected select error");
                    120:             exit(EXIT_FAILURE);
                    121:         }
                    122:     }
                    123: }