plugins/netutils.c

   1 /****************************************************************************
   2 *
   3 * Nagios plugins network utilities
   4 *
   5 * License: GPL
   6 * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
   7 *
   8 * Last Modified: $Date$
   9 *
  10 * Description:
  11 *
  12 * This file contains commons functions used in many of the plugins.
  13 *
  14 * License Information:
  15 *
  16 * This program is free software; you can redistribute it and/or modify
  17 * it under the terms of the GNU General Public License as published by
  18 * the Free Software Foundation; either version 2 of the License, or
  19 * (at your option) any later version.
  20 *
  21 * This program is distributed in the hope that it will be useful,
  22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 * GNU General Public License for more details.
  25 *
  26 * You should have received a copy of the GNU General Public License
  27 * along with this program; if not, write to the Free Software
  28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29 *
  30 ****************************************************************************/
  31
  32 #include "common.h"
  33 #include "netutils.h"
  34
  35 int socket_timeout = DEFAULT_SOCKET_TIMEOUT;
  36 int econn_refuse_state = STATE_CRITICAL;
  37 int was_refused = FALSE;
  38
  39 /* handles socket timeouts */
  40 void
  41 socket_timeout_alarm_handler (int sig)
  42 {
  43         if (sig == SIGALRM)
  44                 printf ("CRITICAL - Socket timeout after %d seconds\n", socket_timeout);
  45         else
  46                 printf ("CRITICAL - Abnormal timeout after %d seconds\n", socket_timeout);
  47
  48         exit (STATE_CRITICAL);
  49 }
  50
  51
  52 /* connects to a host on a specified TCP port, sends a string,
  53    and gets a response */
  54 int
  55 process_tcp_request (char *server_address, int server_port,
  56         char *send_buffer, char *recv_buffer, int recv_size)
  57 {
  58         int result;
  59
  60         result = process_request (server_address, server_port,
  61                         IPPROTO_TCP, send_buffer, recv_buffer, recv_size);
  62
  63         return result;
  64 }
  65
  66
  67 /* connects to a host on a specified UDP port, sends a string, and gets a
  68     response */
  69 int
  70 process_udp_request (char *server_address, int server_port,
  71         char *send_buffer, char *recv_buffer, int recv_size)
  72 {
  73         int result;
  74
  75         result = process_request (server_address, server_port,
  76                         IPPROTO_UDP, send_buffer, recv_buffer, recv_size);
  77
  78         return result;
  79 }
  80
  81
  82
  83 /* connects to a host on a specified tcp port, sends a string, and gets a
  84          response. loops on select-recv until timeout or eof to get all of a
  85          multi-packet answer */
  86 int
  87 process_tcp_request2 (char *server_address, int server_port,
  88         char *send_buffer, char *recv_buffer, int recv_size)
  89 {
  90
  91         int result;
  92         int send_result;
  93         int recv_result;
  94         int sd;
  95         struct timeval tv;
  96         fd_set readfds;
  97         int recv_length = 0;
  98
  99         result = my_connect (server_address, server_port, &sd, IPPROTO_TCP);
 100         if (result != STATE_OK)
 101                 return STATE_CRITICAL;
 102
 103         send_result = send (sd, send_buffer, strlen (send_buffer), 0);
 104         if (send_result<0 || (size_t)send_result!=strlen(send_buffer)) {
 105                 printf ("send() failed\n");
 106                 result = STATE_WARNING;
 107         }
 108
 109         while (1) {
 110                 /* wait up to the number of seconds for socket timeout
 111                    minus one for data from the host */
 112                 tv.tv_sec = socket_timeout - 1;
 113                 tv.tv_usec = 0;
 114                 FD_ZERO (&readfds);
 115                 FD_SET (sd, &readfds);
 116                 select (sd + 1, &readfds, NULL, NULL, &tv);
 117
 118                 /* make sure some data has arrived */
 119                 if (!FD_ISSET (sd, &readfds)) { /* it hasn't */
 120                         if (!recv_length) {
 121                                 strcpy (recv_buffer, "");
 122                                 printf ("No data was recieved from host!\n");
 123                                 result = STATE_WARNING;
 124                         }
 125                         else {                                                                          /* this one failed, but previous ones worked */
 126                                 recv_buffer[recv_length] = 0;
 127                         }
 128                         break;
 129                 }
 130                 else {                                                                                  /* it has */
 131                         recv_result =
 132                                 recv (sd, recv_buffer + recv_length,
 133                                         recv_size - recv_length - 1, 0);
 134                         if (recv_result == -1) {
 135                                 /* recv failed, bail out */
 136                                 strcpy (recv_buffer + recv_length, "");
 137                                 result = STATE_WARNING;
 138                                 break;
 139                         }
 140                         else if (recv_result == 0) {
 141                                 /* end of file ? */
 142                                 recv_buffer[recv_length] = 0;
 143                                 break;
 144                         }
 145                         else {                                                                          /* we got data! */
 146                                 recv_length += recv_result;
 147                                 if (recv_length >= recv_size - 1) {
 148                                         /* buffer full, we're done */
 149                                         recv_buffer[recv_size - 1] = 0;
 150                                         break;
 151                                 }
 152                         }
 153                 }
 154                 /* end if(!FD_ISSET(sd,&readfds)) */
 155         }
 156         /* end while(1) */
 157
 158         close (sd);
 159         return result;
 160 }
 161
 162 /* connects to a host on a specified port, sends a string, and gets a
 163    response */
 164 int
 165 process_request (char *server_address, int server_port, int proto,
 166         char *send_buffer, char *recv_buffer, int recv_size)
 167 {
 168         int result;
 169         int send_result;
 170         int recv_result;
 171         int sd;
 172         struct timeval tv;
 173         fd_set readfds;
 174
 175         result = STATE_OK;
 176
 177         result = my_connect (server_address, server_port, &sd, proto);
 178         if (result != STATE_OK)
 179                 return STATE_CRITICAL;
 180
 181         send_result = send (sd, send_buffer, strlen (send_buffer), 0);
 182         if (send_result<0 || (size_t)send_result!=strlen(send_buffer)) {
 183                 printf ("send() failed\n");
 184                 result = STATE_WARNING;
 185         }
 186
 187         /* wait up to the number of seconds for socket timeout minus one
 188            for data from the host */
 189         tv.tv_sec = socket_timeout - 1;
 190         tv.tv_usec = 0;
 191         FD_ZERO (&readfds);
 192         FD_SET (sd, &readfds);
 193         select (sd + 1, &readfds, NULL, NULL, &tv);
 194
 195         /* make sure some data has arrived */
 196         if (!FD_ISSET (sd, &readfds)) {
 197                 strcpy (recv_buffer, "");
 198                 printf ("No data was recieved from host!\n");
 199                 result = STATE_WARNING;
 200         }
 201
 202         else {
 203                 recv_result = recv (sd, recv_buffer, recv_size - 1, 0);
 204                 if (recv_result == -1) {
 205                         strcpy (recv_buffer, "");
 206                         if (proto != IPPROTO_TCP)
 207                                 printf ("recv() failed\n");
 208                         result = STATE_WARNING;
 209                 }
 210                 else
 211                         recv_buffer[recv_result] = 0;
 212
 213                 /* terminate returned string */
 214                 recv_buffer[recv_size - 1] = 0;
 215         }
 216
 217         close (sd);
 218
 219         return result;
 220 }
 221
 222
 223 /* opens a connection to a remote host/tcp port */
 224 int
 225 my_tcp_connect (char *host_name, int port, int *sd)
 226 {
 227         int result;
 228
 229         result = my_connect (host_name, port, sd, IPPROTO_TCP);
 230
 231         return result;
 232 }
 233
 234
 235 /* opens a connection to a remote host/udp port */
 236 int
 237 my_udp_connect (char *host_name, int port, int *sd)
 238 {
 239         int result;
 240
 241         result = my_connect (host_name, port, sd, IPPROTO_UDP);
 242
 243         return result;
 244 }
 245
 246
 247 /* opens a tcp or udp connection to a remote host */
 248 int
 249 my_connect (char *host_name, int port, int *sd, int proto)
 250 {
 251         struct addrinfo hints;
 252         struct addrinfo *res;
 253         char port_str[6];
 254         int result;
 255
 256         memset (&hints, 0, sizeof (hints));
 257         hints.ai_family = PF_UNSPEC;
 258         hints.ai_protocol = proto;
 259
 260         snprintf (port_str, sizeof (port_str), "%d", port);
 261         result = getaddrinfo (host_name, port_str, &hints, &res);
 262
 263         if (result != 0) {
 264                 printf ("%s\n", gai_strerror (result));
 265                 return STATE_UNKNOWN;
 266         }
 267         else {
 268                 while (res) {
 269                         /* attempt to create a socket */
 270                         *sd = socket (res->ai_family, (proto == IPPROTO_UDP) ?
 271                                       SOCK_DGRAM : SOCK_STREAM, res->ai_protocol);
 272
 273                         if (*sd < 0) {
 274                                 printf ("Socket creation failed\n");
 275                                 freeaddrinfo (res);
 276                                 return STATE_UNKNOWN;
 277                         }
 278
 279                         /* attempt to open a connection */
 280                         result = connect (*sd, res->ai_addr, res->ai_addrlen);
 281
 282                         if (result == 0) {
 283                                 was_refused = FALSE;
 284                                 break;
 285                         }
 286
 287                         if (result < 0) {
 288                                 switch (errno) {
 289                                 case ECONNREFUSED:
 290                                         switch (econn_refuse_state) {
 291                                         case STATE_OK:
 292                                         case STATE_WARNING:
 293                                                 was_refused = TRUE;
 294                                         }
 295                                         break;
 296                                 }
 297                         }
 298
 299                         close (*sd);
 300                         res = res->ai_next;
 301                 }
 302                 freeaddrinfo (res);
 303         }
 304
 305         if (result == 0)
 306                 return STATE_OK;
 307         else if (was_refused)
 308                 return econn_refuse_state;
 309         else {
 310                 printf ("%s\n", strerror(errno));
 311                 return STATE_CRITICAL;
 312         }
 313 }
 314
 315 int
 316 is_host (char *address)
 317 {
 318         if (is_addr (address) || is_hostname (address))
 319                 return (TRUE);
 320
 321         return (FALSE);
 322 }
 323
 324 int
 325 is_addr (char *address)
 326 {
 327         if (is_inet_addr (address))
 328                 return (TRUE);
 329
 330 #ifdef USE_IPV6
 331         if (is_inet6_addr (address))
 332                 return (TRUE);
 333 #endif
 334
 335         return (FALSE);
 336 }
 337
 338 int
 339 resolve_host_or_addr (char *address, int family)
 340 {
 341         struct addrinfo hints;
 342         struct addrinfo *res;
 343         int retval;
 344
 345         memset (&hints, 0, sizeof (hints));
 346         hints.ai_family = family;
 347         retval = getaddrinfo (address, NULL, &hints, &res);
 348
 349         if (retval != 0)
 350                 return FALSE;
 351         else {
 352                 freeaddrinfo (res);
 353                 return TRUE;
 354         }
 355 }
 356
 357 int
 358 is_inet_addr (char *address)
 359 {
 360         return resolve_host_or_addr (address, AF_INET);
 361 }
 362
 363 #ifdef USE_IPV6
 364 int
 365 is_inet6_addr (char *address)
 366 {
 367         return resolve_host_or_addr (address, AF_INET6);
 368 }
 369 #endif
 370
 371 int
 372 is_hostname (char *s1)
 373 {
 374 #ifdef USE_IPV6
 375         return resolve_host_or_addr (s1, AF_UNSPEC);
 376 #else
 377         return resolve_host_or_addr (s1, AF_INET);
 378 #endif
 379 }
 380