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 "config.h"
  33 #include "common.h"
  34 #include <netinet/in.h>
  35 #include <arpa/inet.h>
  36
  37 extern int socket_timeout;
  38 RETSIGTYPE socket_timeout_alarm_handler (int);
  39
  40 int process_tcp_request2 (char *, int, char *, char *, int);
  41 int process_tcp_request (char *, int, char *, char *, int);
  42 int process_udp_request (char *, int, char *, char *, int);
  43 int process_request (char *, int, int, char *, char *, int);
  44
  45 int my_tcp_connect (char *, int, int *);
  46 int my_udp_connect (char *, int, int *);
  47 int my_connect (char *, int, int *, int);
  48
  49 /* handles socket timeouts */
  50 void
  51 socket_timeout_alarm_handler (int sig)
  52 {
  53
  54         printf ("CRITICAL - Socket timeout after %d seconds\n", socket_timeout);
  55
  56         exit (STATE_CRITICAL);
  57 }
  58
  59
  60 /* connects to a host on a specified TCP port, sends a string,
  61    and gets a response */
  62 int
  63 process_tcp_request (char *server_address, int server_port,
  64         char *send_buffer, char *recv_buffer, int recv_size)
  65 {
  66         int result;
  67
  68         result = process_request (server_address, server_port,
  69                         IPPROTO_TCP, send_buffer, recv_buffer, recv_size);
  70
  71         return result;
  72 }
  73
  74
  75 /* connects to a host on a specified UDP port, sends a string, and gets a
  76     response */
  77 int
  78 process_udp_request (char *server_address, int server_port,
  79         char *send_buffer, char *recv_buffer, int recv_size)
  80 {
  81         int result;
  82
  83         result = process_request (server_address, server_port,
  84                         IPPROTO_UDP, send_buffer, recv_buffer, recv_size);
  85
  86         return result;
  87 }
  88
  89
  90
  91 /* connects to a host on a specified tcp port, sends a string, and gets a
  92          response. loops on select-recv until timeout or eof to get all of a
  93          multi-packet answer */
  94 int
  95 process_tcp_request2 (char *server_address, int server_port,
  96         char *send_buffer, char *recv_buffer, int recv_size)
  97 {
  98
  99         int result;
 100         int send_result;
 101         int recv_result;
 102         int sd;
 103         struct timeval tv;
 104         fd_set readfds;
 105         int recv_length = 0;
 106
 107         result = my_connect (server_address, server_port, &sd, IPPROTO_TCP);
 108         if (result != STATE_OK)
 109                 return STATE_CRITICAL;
 110
 111         send_result = send (sd, send_buffer, strlen (send_buffer), 0);
 112         if (send_result != strlen (send_buffer)) {
 113                 printf ("send() failed\n");
 114                 result = STATE_WARNING;
 115         }
 116
 117         while (1) {
 118                 /* wait up to the number of seconds for socket timeout
 119                    minus one for data from the host */
 120                 tv.tv_sec = socket_timeout - 1;
 121                 tv.tv_usec = 0;
 122                 FD_ZERO (&readfds);
 123                 FD_SET (sd, &readfds);
 124                 select (sd + 1, &readfds, NULL, NULL, &tv);
 125
 126                 /* make sure some data has arrived */
 127                 if (!FD_ISSET (sd, &readfds)) { /* it hasn't */
 128                         if (!recv_length) {
 129                                 strcpy (recv_buffer, "");
 130                                 printf ("No data was recieved from host!\n");
 131                                 result = STATE_WARNING;
 132                         }
 133                         else {                                                                          /* this one failed, but previous ones worked */
 134                                 recv_buffer[recv_length] = 0;
 135                         }
 136                         break;
 137                 }
 138                 else {                                                                                  /* it has */
 139                         recv_result =
 140                                 recv (sd, recv_buffer + recv_length,
 141                                         recv_size - recv_length - 1, 0);
 142                         if (recv_result == -1) {
 143                                 /* recv failed, bail out */
 144                                 strcpy (recv_buffer + recv_length, "");
 145                                 result = STATE_WARNING;
 146                                 break;
 147                         }
 148                         else if (recv_result == 0) {
 149                                 /* end of file ? */
 150                                 recv_buffer[recv_length] = 0;
 151                                 break;
 152                         }
 153                         else {                                                                          /* we got data! */
 154                                 recv_length += recv_result;
 155                                 if (recv_length >= recv_size - 1) {
 156                                         /* buffer full, we're done */
 157                                         recv_buffer[recv_size - 1] = 0;
 158                                         break;
 159                                 }
 160                         }
 161                 }
 162                 /* end if(!FD_ISSET(sd,&readfds)) */
 163         }
 164         /* end while(1) */
 165
 166         close (sd);
 167         return result;
 168 }
 169
 170 /* connects to a host on a specified port, sends a string, and gets a
 171    response */
 172 int
 173 process_request (char *server_address, int server_port, int proto,
 174         char *send_buffer, char *recv_buffer, int recv_size)
 175 {
 176         int result;
 177         int send_result;
 178         int recv_result;
 179         int sd;
 180         struct timeval tv;
 181         fd_set readfds;
 182
 183         result = STATE_OK;
 184
 185         result = my_connect (server_address, server_port, &sd, proto);
 186         if (result != STATE_OK)
 187                 return STATE_CRITICAL;
 188
 189         send_result = send (sd, send_buffer, strlen (send_buffer), 0);
 190         if (send_result != strlen (send_buffer)) {
 191                 printf ("send() failed\n");
 192                 result = STATE_WARNING;
 193         }
 194
 195         /* wait up to the number of seconds for socket timeout minus one
 196            for data from the host */
 197         tv.tv_sec = socket_timeout - 1;
 198         tv.tv_usec = 0;
 199         FD_ZERO (&readfds);
 200         FD_SET (sd, &readfds);
 201         select (sd + 1, &readfds, NULL, NULL, &tv);
 202
 203         /* make sure some data has arrived */
 204         if (!FD_ISSET (sd, &readfds)) {
 205                 strcpy (recv_buffer, "");
 206                 printf ("No data was recieved from host!\n");
 207                 result = STATE_WARNING;
 208         }
 209
 210         else {
 211                 recv_result = recv (sd, recv_buffer, recv_size - 1, 0);
 212                 if (recv_result == -1) {
 213                         strcpy (recv_buffer, "");
 214                         if (proto != IPPROTO_TCP)
 215                                 printf ("recv() failed\n");
 216                         result = STATE_WARNING;
 217                 }
 218                 else
 219                         recv_buffer[recv_result] = 0;
 220
 221                 /* terminate returned string */
 222                 recv_buffer[recv_size - 1] = 0;
 223         }
 224
 225         close (sd);
 226
 227         return result;
 228 }
 229
 230
 231 /* opens a connection to a remote host/tcp port */
 232 int
 233 my_tcp_connect (char *host_name, int port, int *sd)
 234 {
 235         int result;
 236
 237         result = my_connect (host_name, port, sd, IPPROTO_TCP);
 238
 239         return result;
 240 }
 241
 242
 243 /* opens a connection to a remote host/udp port */
 244 int
 245 my_udp_connect (char *host_name, int port, int *sd)
 246 {
 247         int result;
 248
 249         result = my_connect (host_name, port, sd, IPPROTO_UDP);
 250
 251         return result;
 252 }
 253
 254
 255 /* opens a tcp or udp connection to a remote host */
 256 int
 257 my_connect (char *host_name, int port, int *sd, int proto)
 258 {
 259         struct addrinfo hints;
 260         struct addrinfo *res;
 261         struct addrinfo *ptrp;
 262         char port_str[6];
 263         int result;
 264
 265         memset (&hints, 0, sizeof (hints));
 266         hints.ai_family = PF_UNSPEC;
 267         hints.ai_protocol = proto;
 268
 269         snprintf (port_str, sizeof (port_str), "%d", port);
 270         result = getaddrinfo (host_name, port_str, &hints, &res);
 271
 272         if (result != 0) {
 273                 printf ("%s\n", gai_strerror (result));
 274                 return STATE_UNKNOWN;
 275         }
 276         else {
 277                 while (res) {
 278                         /* attempt to create a socket */
 279                         *sd = socket (res->ai_family, (proto == IPPROTO_UDP) ?
 280                                 SOCK_DGRAM : SOCK_STREAM, res->ai_protocol);
 281
 282                         if (*sd < 0) {
 283                                 printf ("Socket creation failed\n");
 284                                 freeaddrinfo (res);
 285                                 return STATE_UNKNOWN;
 286                         }
 287
 288                         /* attempt to open a connection */
 289                         result = connect (*sd, res->ai_addr, res->ai_addrlen);
 290
 291                         if (result == 0)
 292                                 break;
 293
 294                         close (*sd);
 295                         res = res->ai_next;
 296                 }
 297                 freeaddrinfo (res);
 298         }
 299
 300         if (result == 0)
 301                 return STATE_OK;
 302         else {
 303                 printf ("%s\n", strerror(errno));
 304                 return STATE_CRITICAL;
 305         }
 306 }