Copied missing files from the subversion repository.

diff --git a/debian/collectd-sensors.files b/debian/collectd-sensors.files
new file mode 100644 (file)
index 0000000..049bd84
--- /dev/null
+++ b/debian/collectd-sensors.files
@@ -0,0 +1 @@
+usr/lib/collectd/sensors.so*

diff --git a/debian/collectd.dirs b/debian/collectd.dirs
new file mode 100644 (file)
index 0000000..43d94e7
--- /dev/null
+++ b/debian/collectd.dirs
@@ -0,0 +1,4 @@
+usr/lib/collectd
+usr/sbin
+etc/init.d
+var/lib/collectd

diff --git a/debian/collectd.docs b/debian/collectd.docs
new file mode 100644 (file)
index 0000000..dc63960
--- /dev/null
+++ b/debian/collectd.docs
@@ -0,0 +1,6 @@
+AUTHORS
+COPYING
+ChangeLog
+INSTALL
+NEWS
+README

diff --git a/debian/collectd.files b/debian/collectd.files
new file mode 100644 (file)
index 0000000..2713ed4
--- /dev/null
+++ b/debian/collectd.files
@@ -0,0 +1 @@
+usr/sbin/collectd

diff --git a/debian/compat b/debian/compat
new file mode 100644 (file)
index 0000000..b8626c4
--- /dev/null
+++ b/debian/compat
@@ -0,0 +1 @@
+4

diff --git a/src/libping/Makefile.am b/src/libping/Makefile.am
new file mode 100644 (file)
index 0000000..dacb727
--- /dev/null
+++ b/src/libping/Makefile.am
@@ -0,0 +1,40 @@
+##
+## lib/Makefile.am
+##
+## Copyright (C) 2000 Jeffrey Fulmer <jdfulmer@armstrong.com>
+## This file is part of libping
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 2 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, write to the Free Software
+## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+##
+
+AUTOMAKE_OPTIONS = foreign no-dependencies
+
+noinst_LTLIBRARIES    = libping.la 
+ 
+libping_la_LDFLAGS = -version-info 1:0:0
+
+libping_la_SOURCES =  \
+echo.c     echo.h     \
+http.c     http.h     \
+memory.c   memory.h   \
+ping.c     ping.h     \
+private.c  private.h  \
+pop3.c     pop3.h     \
+sock.c     sock.h     \
+smtp.c     smtp.h     \
+url.c      url.h      \
+util.c     util.h     \
+linux.h    setup.h
+

diff --git a/src/libping/config.h.in b/src/libping/config.h.in
new file mode 100644 (file)
index 0000000..13b2b0f
--- /dev/null
+++ b/src/libping/config.h.in
@@ -0,0 +1,122 @@
+/* src/libping/config.h.in.  Generated automatically from configure.in by autoheader.  */
+
+/* Define to empty if the keyword does not work.  */
+#undef const
+
+/* Define if you have <sys/wait.h> that is POSIX.1 compatible.  */
+#undef HAVE_SYS_WAIT_H
+
+/* Define to `int' if <sys/types.h> doesn't define.  */
+#undef pid_t
+
+/* Define to `unsigned' if <sys/types.h> doesn't define.  */
+#undef size_t
+
+/* Define if you have the ANSI C header files.  */
+#undef STDC_HEADERS
+
+/* Define if you can safely include both <sys/time.h> and <time.h>.  */
+#undef TIME_WITH_SYS_TIME
+
+/* Define if you have the gethostbyname function.  */
+#undef HAVE_GETHOSTBYNAME
+
+/* Define if you have the gettimeofday function.  */
+#undef HAVE_GETTIMEOFDAY
+
+/* Define if you have the memcpy function.  */
+#undef HAVE_MEMCPY
+
+/* Define if you have the select function.  */
+#undef HAVE_SELECT
+
+/* Define if you have the socket function.  */
+#undef HAVE_SOCKET
+
+/* Define if you have the strcasecmp function.  */
+#undef HAVE_STRCASECMP
+
+/* Define if you have the strchr function.  */
+#undef HAVE_STRCHR
+
+/* Define if you have the strcmp function.  */
+#undef HAVE_STRCMP
+
+/* Define if you have the strdup function.  */
+#undef HAVE_STRDUP
+
+/* Define if you have the strlen function.  */
+#undef HAVE_STRLEN
+
+/* Define if you have the strncasecmp function.  */
+#undef HAVE_STRNCASECMP
+
+/* Define if you have the strncmp function.  */
+#undef HAVE_STRNCMP
+
+/* Define if you have the strncpy function.  */
+#undef HAVE_STRNCPY
+
+/* Define if you have the strstr function.  */
+#undef HAVE_STRSTR
+
+/* Define if you have the strtol function.  */
+#undef HAVE_STRTOL
+
+/* Define if you have the <arpa/inet.h> header file.  */
+#undef HAVE_ARPA_INET_H
+
+/* Define if you have the <dlfcn.h> header file.  */
+#undef HAVE_DLFCN_H
+
+/* Define if you have the <errno.h> header file.  */
+#undef HAVE_ERRNO_H
+
+/* Define if you have the <fcntl.h> header file.  */
+#undef HAVE_FCNTL_H
+
+/* Define if you have the <netdb.h> header file.  */
+#undef HAVE_NETDB_H
+
+/* Define if you have the <netinet/in.h> header file.  */
+#undef HAVE_NETINET_IN_H
+
+/* Define if you have the <signal.h> header file.  */
+#undef HAVE_SIGNAL_H
+
+/* Define if you have the <sys/resource.h> header file.  */
+#undef HAVE_SYS_RESOURCE_H
+
+/* Define if you have the <sys/select.h> header file.  */
+#undef HAVE_SYS_SELECT_H
+
+/* Define if you have the <sys/socket.h> header file.  */
+#undef HAVE_SYS_SOCKET_H
+
+/* Define if you have the <sys/time.h> header file.  */
+#undef HAVE_SYS_TIME_H
+
+/* Define if you have the <sys/times.h> header file.  */
+#undef HAVE_SYS_TIMES_H
+
+/* Define if you have the <sys/types.h> header file.  */
+#undef HAVE_SYS_TYPES_H
+
+/* Define if you have the <unistd.h> header file.  */
+#undef HAVE_UNISTD_H
+
+/* Define if you have the resolv library (-lresolv).  */
+#undef HAVE_LIBRESOLV
+
+/* Define if you have the rrd library (-lrrd).  */
+#undef HAVE_LIBRRD
+
+/* Define if you have the socket library (-lsocket).  */
+#undef HAVE_LIBSOCKET
+
+/* Name of package */
+#undef PACKAGE
+
+/* Version number of package */
+#undef VERSION
+

diff --git a/src/libping/echo.c b/src/libping/echo.c
new file mode 100644 (file)
index 0000000..263cbc6
--- /dev/null
+++ b/src/libping/echo.c
@@ -0,0 +1,153 @@
+/**
+ * ECHO module
+ *
+ * Copyright (C) 2001,2002 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif/*HAVE_CONFIG_H*/ 
+
+#include <sock.h>
+#include <echo.h>
+#include <util.h>
+#include <stdlib.h>
+#include <stdio.h>  
+#include <errno.h>
+#include <setup.h>
+#include <string.h>
+
+#include "memory.h"
+
+#define MAXLINE  81921
+
+int 
+send_data( CONN *C, int bytes )
+{
+  char buf[MAXLINE];
+  char rec[MAXLINE];
+  int  ret;
+  int  x, n;
+
+  bytes = (bytes>MAXLINE-3)?MAXLINE-3:bytes;
+
+  memset( buf, 0, bytes+3 );
+  memset( rec, 0, bytes+3 );
+
+  for( x = 0; x < bytes; x++ )
+    buf[x] = '#';
+
+  (void)strcat( buf, "\015\012" );
+
+  if( JOEsocket_write( C, buf, sizeof( buf )) < 0 ){
+    return -1; 
+  }
+
+  if(( n = JOEreadline( C, rec, sizeof( rec ))) < 0 ){
+    return -1;
+  }
+
+  if(( ret = strlen( rec )) > 0 ){ 
+    return 1;
+  }
+  else
+    return -1;
+}
+
+int
+myecho( ECHODATA *E )
+{
+  CONN *C;               /* threadsafe connection */
+  int ret;               /* return conditional    */
+  struct timeval mytime;
+ 
+  C = (CONN*)xmalloc( sizeof( CONN )); 
+  C->port    = 7; 
+  C->timeout = ( E->timeout == 0 )?60:E->timeout;  
+
+  (void) gettimeofday( &mytime, (struct timezone *)NULL);  
+
+  if(( C->sock = JOEsocket( C, E->hostname )) < 0 ){
+    return -1;
+  }
+
+  ret = send_data( C, E->bytes );
+  
+  E->rtt = elapsed_time( &mytime );
+  return ret;
+}
+
+int
+echohost( const char *hostname, int b )
+{
+  ECHODATA *E;
+ 
+  E = (ECHODATA*)xmalloc( sizeof( ECHODATA ));
+  E->hostname = (char*)strdup( hostname );
+  E->bytes   = b;
+  E->timeout = 0;  
+  return ( myecho( E ));
+}
+ 
+int
+echothost( const char *hostname, int b, int t )
+{
+  ECHODATA *E;
+ 
+  E = (ECHODATA*)xmalloc( sizeof( ECHODATA ));
+  E->hostname = (char*)strdup( hostname );
+  E->bytes   = b;
+  E->timeout = t; 
+ 
+  return ( myecho( E ));
+}
+
+int
+techohost( const char *hostname, int b )
+{
+  ECHODATA *E;
+  int ret;
+ 
+  E = (ECHODATA*)xmalloc( sizeof( ECHODATA ));
+  E->hostname = (char*)strdup( hostname );
+  E->bytes   = b;
+  E->timeout = 0; 
+ 
+  ret = myecho( E );
+ 
+  if( ret > 0 ){ return E->rtt; }
+  else         { return ret; }
+}
+ 
+int
+techothost( const char *hostname, int b, int t )
+{
+  ECHODATA *E; 
+  int ret;
+  
+  E = (ECHODATA*)xmalloc( sizeof( ECHODATA )); 
+  E->hostname = (char*)strdup( hostname );
+  E->bytes   = b;
+  E->timeout = t; 
+
+  ret = myecho( E );
+  if( ret > 0 ){ return E->rtt; }
+  else         { return ret; }
+ 
+} 
+

diff --git a/src/libping/echo.h b/src/libping/echo.h
new file mode 100644 (file)
index 0000000..38a9a25
--- /dev/null
+++ b/src/libping/echo.h
@@ -0,0 +1,37 @@
+/**
+ * ECHO Header
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#ifndef  ECHO_H
+#define  ECHO_H
+
+typedef struct
+{
+  char     *hostname; 
+  int      timeout;
+  int      bytes;
+  int      rtt;
+} ECHODATA; 
+
+int echohost( const char *hostname, int bytes );
+ 
+int echothost( const char *hostname, int bytes, int t ); 
+
+#endif/*ECHO_H*/

diff --git a/src/libping/http.c b/src/libping/http.c
new file mode 100644 (file)
index 0000000..2b54277
--- /dev/null
+++ b/src/libping/http.c
@@ -0,0 +1,340 @@
+/**
+ * HTTP/HTTPS protocol support 
+ *
+ * Copyright (C) 2000, 2001, 2002 by
+ * Jeffrey Fulmer - <jdfulmer@armstrong.com>
+ * This file is distributed as part of Libping
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif/*HAVE_CONFIG_H*/
+ 
+#include <sock.h>
+#include <http.h>
+#include <util.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <setup.h>
+
+#include "memory.h"
+
+#define MAXFILE 10240
+
+int
+myhttp( HTTPDATA *H )
+{
+  CONN    *C;    /* threadsafe connection */
+  URL     U;     /* defined in url.h      */
+  HEADERS *head; /* HTTP header structure */ 
+  int     bytes; /* bytes read from srv.  */
+  char    *tmp;  /* tmp storage for url   */
+  struct  timeval mytime; 
+
+  tmp = strdup( H->url ); 
+  U = add_url( tmp );
+ 
+  C = (CONN*)xmalloc( sizeof( CONN ));
+  C->port    = U.port;
+  C->timeout = ( H->timeout == 0 )?60:H->timeout;
+
+  (void) gettimeofday( &mytime, (struct timezone *)NULL);
+ 
+  if(( C->sock = JOEsocket( C, U.hostname )) <= 0 ){
+    return -1;
+  }
+
+  JOEhttp_send( C, U.hostname, U.pathname );
+  head  = JOEhttp_read_headers( C, U.hostname );
+  if( !head ){ 
+    JOEclose( C ); 
+    free( C ); 
+    return -1; 
+  }
+  
+  bytes =  JOEhttp_read( C, 0 );
+  if( bytes < 1 ){ 
+    JOEclose( C ); 
+    free( C ); 
+    free( head ); 
+    return -1; 
+  }
+  
+  JOEclose( C );
+
+  H->rtt = elapsed_time( &mytime ); 
+ 
+  if( head->code > 499 ){ return -1; }
+  else                  { return  1; } 
+}
+
+/**
+ * returns int, ( < 0 == error )
+ * formats and sends an HTTP/1.0 request
+ */
+void
+JOEhttp_send( CONN *C, char *host, char *path )
+{
+  int rlen;
+  char *protocol; 
+  char *keepalive;
+  char request[1024]; 
+  char fullpath[2048];
+
+  sprintf( fullpath, "%s", path );
+
+  memset( request, 0, sizeof( request ));
+
+  /* HTTP protocol string */
+  protocol  = "HTTP/1.0";
+  keepalive = "close";
+  
+  rlen=snprintf(
+    request, sizeof( request ),
+    "GET %s %s\015\012"
+    "Host: %s\015\012"
+    "Accept: */*\015\012"
+    "Accept-Encoding: * \015\012"
+    "User-Agent: JoeDog 1.00 [libping]\015\012"
+    "Connection: %s\015\012\015\012",
+    fullpath, protocol, host, keepalive
+  );
+  
+  if( rlen < 0 || rlen > sizeof(request)  ){ 
+    perror("http_send: request buffer overrun!"); 
+    exit( 1 ); 
+  }
+
+  if(( JOEsocket_check( C, WRITE )) < 0 ){
+    perror( "JOEsocket: not writeable" );
+    return;
+  } 
+
+  JOEsocket_write( C, request, rlen );
+
+  return;
+}
+
+/**
+ * returns int, ( < 0 == error )
+ * formats and sends an HTTP/1.0 request
+ */
+void
+JOEhttp_post( CONN *C, char *host, char *path, char *data, size_t len )
+{
+  int  rlen;
+  char request[1024]; 
+  char *protocol; 
+  char *keepalive;
+  char fullpath[2048];
+  
+  sprintf( fullpath, "%s", path );
+
+  memset( request, 0, sizeof( request ));
+
+  /* HTTP protocol string */
+  protocol  = "HTTP/1.0";
+  keepalive = "close";
+    
+  rlen=snprintf(
+    request, sizeof( request ),
+    "POST %s %s\015\012"
+    "Host: %s\015\012"
+    "Accept: */*\015\012"
+    "Accept-Encoding: * \015\012"
+    "User-Agent: JoeDog 1.00 [libping]\015\012"
+    "Connection: %s\015\012"
+    "Content-type: application/x-www-form-urlencoded\015\012"
+    "Content-length: %d\015\012\015\012"
+    "%*.*s\015\012",
+    fullpath, protocol, host, keepalive, len, len, len, data
+  );
+
+  if( rlen < 0 || rlen > sizeof(request) ){ 
+    perror("http_post: request buffer overrun!"); 
+    exit( 1 ); 
+  }
+
+  if(( JOEsocket_check( C, WRITE )) < 0 ){
+    perror( "JOEsocket: not writeable" );
+    return;
+  } 
+
+  JOEsocket_write( C, request, rlen );
+
+  return;
+}
+
+/**
+ * returns HEADERS struct
+ * reads from http/https socket and parses
+ * header information into the struct.
+ */
+HEADERS *
+JOEhttp_read_headers( CONN *C, char *host )
+{ 
+  int  x;           /* while loop index      */
+  int  n;           /* assign socket_read    */
+  char c;           /* assign char read      */
+  char line[512];   /* assign chars read     */
+  HEADERS *h;       /* struct to hold it all */
+  h = (HEADERS*)malloc( sizeof(HEADERS));
+  memset( h, 0, sizeof( HEADERS ));
+  
+  if(( JOEsocket_check( C, READ )) < 0 ){
+    perror( "JOEsocket: not readable" );
+    return NULL;
+  } 
+
+  h->redirection[0]=0;
+
+  while( TRUE ){
+    x = 0;
+    memset( &line, 0, sizeof( line ));
+    while(( n = JOEsocket_read( C, &c, 1 )) == 1 ){
+      line[x] = c; 
+      if(( line[0] == '\n' ) || ( line[1] == '\n' )){ 
+        return h;
+      }
+      if( line[x] == '\n' ) break;
+      x ++;
+    }
+    line[x]=0;
+    /* strip trailing CR */
+    if (x > 0 && line[x-1] == '\r') line[x-1]=0;
+    if( strncasecmp( line, "http", 4 ) == 0 ){
+      strncpy( h->head, line, 8 );
+      h->code = atoi( line + 9 ); 
+    }
+    if( strncasecmp( line, "content-length: ", 16 ) == 0 ){ 
+      h->length = atol( line + 16 ); 
+    }
+    if( strncasecmp( line, "connection: ", 12 ) == 0 ){
+      if ( strncasecmp( line+12, "keep-alive", 10 ) == 0 ){
+        h->keepalive = 1;
+      }
+      else if( strncasecmp( line+12, "close", 5 ) == 0 ){
+        h->keepalive = 0;
+      }
+    }
+
+    if( strncasecmp(line, "location: ", 10) == 0) {
+      if (strlen(line) - 10 > sizeof(h->redirection) - 1) {
+       perror( "redirection URL too long, ignored");
+      }
+      else {
+        strcpy(h->redirection, line+10);
+      }  
+    }
+
+    if( n <  0 ){ 
+      perror("JOEhttp_read_headers"); 
+      return( NULL ); 
+    } /* socket closed */
+  } /* end of while TRUE */
+
+  return h;
+}
+
+/**
+ * returns int
+ * reads a http/https socket
+ * ( you know what I mean :)
+ */
+ssize_t
+JOEhttp_read( CONN *C, int len )
+{ 
+  int  n;
+  size_t bytes=0;
+  char body[MAXFILE];
+
+  if(( JOEsocket_check( C, READ )) < 0 ){
+    perror( "JOEsocket: not readable" );
+    return -1;
+  } 
+
+  memset( &body, 0, MAXFILE );  
+  while( TRUE ){
+    if(( n = JOEsocket_read( C, body, MAXFILE)) == 0 ){
+      break;
+    } 
+    /* IGV: should be accumulating bytes read, not just 
+       recording those in the last packet */
+    bytes += n;
+  }
+  return( bytes );
+}
+
+int
+pinghttp( char *hostname )
+{
+  HTTPDATA *H;
+ 
+  H = (HTTPDATA*)xmalloc( sizeof( HTTPDATA ));
+  H->url     = (char*)strdup( hostname );
+  H->timeout = 0;
+ 
+  return( myhttp( H )); 
+}
+ 
+int
+pingthttp( char *hostname, int t )
+{
+  HTTPDATA *H;
+ 
+  H = (HTTPDATA*)xmalloc( sizeof( HTTPDATA ));
+  H->url     = (char*)strdup( hostname );
+  H->timeout = t;
+ 
+  return( myhttp( H )); 
+}
+ 
+int
+tpinghttp( char *hostname )
+{
+  HTTPDATA *H;
+  int ret;
+ 
+  H = (HTTPDATA*)xmalloc( sizeof( HTTPDATA ));
+  H->url     = (char*)strdup( hostname );
+  H->timeout = 0;
+ 
+  ret = myhttp( H ); 
+
+  if( ret > 0 ){ return H->rtt; }
+  else         { return ret; }
+}
+ 
+int
+tpingthttp( char *hostname, int t )
+{
+  HTTPDATA *H;
+  int ret;
+ 
+  H = (HTTPDATA*)xmalloc( sizeof( HTTPDATA ));
+  H->url     = (char*)strdup( hostname );
+  H->timeout = t;
+ 
+  ret = myhttp( H );
+
+  if( ret > 0 ){ return H->rtt; }
+  else         { return ret;    }
+} 
+
+

diff --git a/src/libping/http.h b/src/libping/http.h
new file mode 100644 (file)
index 0000000..5e65c44
--- /dev/null
+++ b/src/libping/http.h
@@ -0,0 +1,82 @@
+/**
+ * JOE http header file
+ *
+ * Copyright (C) 2000, 2001, 2002 by
+ * Jeffrey Fulmer - <jdfulmer@armstrong.com>
+ * This file is distributed as part of Siege 
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef HTTP_H
+#define HTTP_H
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sock.h>
+
+#ifndef HAVE_SNPRINTF
+# define portable_snprintf  snprintf
+# define portable_vsnprintf vsnprintf
+#endif
+
+typedef struct
+{
+  char   *url;
+  int    rtt;
+  int    timeout;
+} HTTPDATA;
+
+typedef struct headers
+{
+  char                head[64];
+  int                 code;
+  unsigned long int   length;
+  char                cookie[128];
+  char                redirection[128];
+  int                 keepalive;
+} HEADERS;
+
+int myhttp( HTTPDATA *H ); 
+
+/**
+ * construct a HTTP GET request with "my" 
+ * data and send it to the server host.
+ */
+void JOEhttp_send( CONN *C, char *host, char *path );
+
+/**
+ * construct a HTTP POST request with "my"
+ * data and send it to server host.
+ */
+void JOEhttp_post( CONN *C, char *host, char *path, char *data, size_t len );
+
+/**
+ * read http headers
+ * int socket
+ */
+HEADERS * JOEhttp_read_headers( CONN *C, char * );
+
+/**
+ * read http content
+ * int socket
+ */
+ssize_t JOEhttp_read( CONN *C, int len );
+
+#endif /* HTTP_H */
+

diff --git a/src/libping/linux.h b/src/libping/linux.h
new file mode 100644 (file)
index 0000000..bf73018
--- /dev/null
+++ b/src/libping/linux.h
@@ -0,0 +1,66 @@
+#define ICMP_ECHOREPLY          0 
+#define ICMP_ECHO               8
+#define ICMP_MINLEN             8
+
+struct ip {
+#if (BYTE_ORDER == LITTLE_ENDIAN || BYTE_ORDER == PDP_ENDIAN)
+        u_char  ip_hl:4,                /* header length */
+                ip_v:4;                 /* version */
+#else
+        u_char  ip_v:4,                 /* version */
+                ip_hl:4;                /* header length */
+#endif
+        u_char  ip_tos;                 /* type of service */
+        short   ip_len;                 /* total length */
+        u_short ip_id;                  /* identification */
+        short   ip_off;                 /* fragment offset field */
+#define IP_DF 0x4000                    /* dont fragment flag */
+#define IP_MF 0x2000                    /* more fragments flag */
+        u_char  ip_ttl;                 /* time to live */
+        u_char  ip_p;                   /* protocol */
+        u_short ip_sum;                 /* checksum */
+        struct  in_addr ip_src,ip_dst;  /* source and dest address */
+};
+
+#define n_short u_short                 /* normally defined in in_systm.h */
+#define n_long  u_int                   /* redefine for 64-bit machines */
+#define n_time  u_int                   /* redefine for 64-bit machines */
+
+struct icmp {
+        u_char  icmp_type;              /* type of message, see below */
+        u_char  icmp_code;              /* type sub code */
+        u_short icmp_cksum;             /* ones complement cksum of struct */
+        union {
+                u_char ih_pptr;                 /* ICMP_PARAMPROB */
+                struct in_addr ih_gwaddr;       /* ICMP_REDIRECT */
+                struct ih_idseq {
+                        n_short icd_id;
+                        n_short icd_seq;
+                } ih_idseq;
+                int ih_void;
+        } icmp_hun;
+#define icmp_pptr       icmp_hun.ih_pptr
+#define icmp_gwaddr     icmp_hun.ih_gwaddr
+#define icmp_id         icmp_hun.ih_idseq.icd_id
+#define icmp_seq        icmp_hun.ih_idseq.icd_seq
+#define icmp_void       icmp_hun.ih_void
+        union {
+                struct id_ts {
+                        n_time its_otime;
+                        n_time its_rtime;
+                        n_time its_ttime;
+                } id_ts;
+                struct id_ip  {
+                        struct ip idi_ip;
+                        /* options and then 64 bits of data */
+                } id_ip;
+                n_long  id_mask;
+                char    id_data[1];
+        } icmp_dun;
+#define icmp_otime      icmp_dun.id_ts.its_otime
+#define icmp_rtime      icmp_dun.id_ts.its_rtime
+#define icmp_ttime      icmp_dun.id_ts.its_ttime
+#define icmp_ip         icmp_dun.id_ip.idi_ip
+#define icmp_mask       icmp_dun.id_mask
+#define icmp_data       icmp_dun.id_data
+};

diff --git a/src/libping/memory.c b/src/libping/memory.c
new file mode 100644 (file)
index 0000000..5dfd358
--- /dev/null
+++ b/src/libping/memory.c
@@ -0,0 +1,72 @@
+/**
+ * MEMORY module
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#include <stdio.h>
+#include <memory.h>
+#include <strings.h>
+
+/**
+ * xrealloc    replaces realloc
+ */
+void * 
+xrealloc( void *object, size_t size )
+{
+  void *new;
+  if( object )
+    new = realloc( object, size );
+  else
+    new = malloc( size );
+  if( !new ){
+    perror( "Memory exhausted" );
+    exit( 1 );
+  }
+  return new;
+} /** end xrealloc **/
+
+/**
+ * xmalloc     replaces malloc
+ */
+void *
+xmalloc( size_t size )
+{
+  void *new  =  malloc( size );
+  if( !new ){
+    perror( "Memory exhausted" );
+    exit( 1 );
+  }
+  
+  return new;
+} /** end of xmalloc **/
+
+/**
+ * xcalloc     replaces calloc
+ */
+void *
+xcalloc( size_t num, size_t size )
+{
+  void *new  =  xmalloc( num * size );
+  bzero( new, num * size );
+
+  return new;
+} /** end of xcalloc **/
+
+
+

diff --git a/src/libping/memory.h b/src/libping/memory.h
new file mode 100644 (file)
index 0000000..b4785fb
--- /dev/null
+++ b/src/libping/memory.h
@@ -0,0 +1,43 @@
+/**
+ * MEMORY header
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#ifndef MEMORY_H
+#define MEMORY_H
+
+#include <stdlib.h>
+
+/**
+ * a controlled realloc
+ */
+void * xrealloc( void *, size_t );
+
+/**
+ * a controlled malloc
+ */
+void * xmalloc ( size_t );
+
+/**
+ * a controlled calloc
+ */
+void * xcalloc ( size_t, size_t );  
+
+
+#endif /* MEMORY_H */

diff --git a/src/libping/ping.h b/src/libping/ping.h
new file mode 100644 (file)
index 0000000..4db0964
--- /dev/null
+++ b/src/libping/ping.h
@@ -0,0 +1,81 @@
+/**
+ * PING header
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#ifndef PING_H
+#define PING_H
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif/*HAVE_CONFIG_H*/
+
+#include <stdio.h>
+
+#ifdef  HAVE_UNISTD_H
+# include <unistd.h>
+#endif/*HAVE_UNISTD_H*/
+
+#ifdef  HAVE_STDLIB_H
+# include <stdlib.h>
+#endif/*HAVE_STDLIB_H*/
+
+#ifdef HAVE_SYS_TIMES_H
+# include <sys/times.h>
+#endif /*HAVE_SYS_TIMES_H*/
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif /*TIME_WITH_SYS_TIME*/
+
+#include <string.h>
+#include <netinet/in_systm.h>
+#include <netinet/in.h>
+
+#ifdef  HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif/*HAVE_SYS_SOCKET_H*/
+
+#ifdef  HAVE_ARPA_INET_H
+# include <arpa/inet.h>
+#endif/*HAVE_ARPA_INET_H*/
+
+#ifdef  HAVE_NETDB_H
+# include <netdb.h>
+#endif/*HAVE_NETDB_H*/
+
+#if defined( __linux__ )
+# include "linux.h"
+#else
+# include <netinet/ip.h>
+# include <netinet/ip_icmp.h>
+#endif /* defined(__linux__) */   
+
+int pinghost  ( const char *hostname );
+int pingthost ( const char *hostname, int t );
+int tpinghost ( const char *hostname );
+int tpingthost( const char *hostname, int t );
+
+#endif/*PING_H*/

diff --git a/src/libping/pop3.c b/src/libping/pop3.c
new file mode 100644 (file)
index 0000000..1c60eb7
--- /dev/null
+++ b/src/libping/pop3.c
@@ -0,0 +1,175 @@
+/**
+ * POP3 module
+ *
+ * Copyright (C) 2001, 2002 by
+ * Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#include <pop3.h>
+#include <setup.h>
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif/*HAVE_CONFIG_H*/
+
+#include <sock.h>
+#include <util.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+ 
+#ifdef HAVE_SYS_TIMES_H
+# include <sys/times.h>
+#endif /*HAVE_SYS_TIMES_H*/
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif /*TIME_WITH_SYS_TIME*/ 
+
+#include <signal.h>
+#include <setjmp.h> 
+
+#include "memory.h"
+
+#define MSGBUF  1024
+
+int send_cmd( CONN *C, char *cmd, char *val );
+
+int
+mypop3( POP3DATA *P )
+{
+  CONN *C;
+  char buf[MSGBUF];
+  int ret  = 0;
+  struct timeval mytime;
+
+  C = (CONN*)xmalloc( sizeof( CONN ));
+  C->port    =   110;
+  C->timeout = ( P->timeout == 0 )?60:P->timeout; 
+  
+  if(( C->sock = JOEsocket( C, P->hostname )) <= 0 ){
+    return -1;
+  }   
+
+  /* set the rrt timer */
+  (void) gettimeofday( &mytime, (struct timezone *)NULL); 
+
+  if(( ret = JOEreadline( C, buf, MSGBUF )) < 0 ){
+    return ret;
+  }
+  if( !strncmp( buf, "+OK", 3 )) ret = 1; 
+    
+  if(( ret = send_cmd( C, "QUIT", NULL )) < 0 ){
+    return ret; 
+  }
+
+  JOEclose( C );
+  P->rtt = elapsed_time( &mytime ); 
+
+  return ret;
+}
+
+int
+send_cmd( CONN *C, char *cmd, char *val )
+{
+  char buf[256];
+  char rec[MSGBUF];
+
+  if( val )
+    snprintf( buf, sizeof( buf ), "%s %s\r\n", cmd, val );
+  else
+    snprintf( buf, sizeof( buf ), "%s\r\n", cmd );
+
+  if( JOEsocket_write( C, buf, sizeof( buf ))  < 0 )
+    return -1;
+
+  JOEreadline( C, rec, MSGBUF );
+  *rec='\0';
+
+  if( !strncmp( rec, "-ERR", 4 )){
+    return -1;
+  }
+
+  return 1; 
+}
+
+int 
+pingpop3( const char *hostname )
+{
+  POP3DATA *P;
+ 
+  P = (POP3DATA*)xmalloc( sizeof( POP3DATA ));
+  P->hostname = (char*)strdup( hostname );
+  P->timeout = 0;
+ 
+  return mypop3( P );
+}
+
+int
+pingtpop3( const char *hostname, int t )
+{
+  POP3DATA *P;
+  int ret;
+ 
+  P = (POP3DATA*)xmalloc( sizeof( POP3DATA ));
+  P->hostname = (char*)strdup( hostname );
+  P->timeout = t;
+ 
+  ret = mypop3( P ); 
+
+  return mypop3( P );
+}
+
+int
+tpingpop3( const char *hostname )
+{
+  POP3DATA *P;
+  int ret;
+ 
+  P = (POP3DATA*)xmalloc( sizeof( POP3DATA ));
+  P->hostname = (char*)strdup( hostname );
+  P->timeout = 0;
+ 
+  ret = mypop3( P ); 
+
+  if( ret > 0 ){ return P->rtt; }
+  else         { return ret; }
+}
+ 
+int
+tpingtpop3( const char *hostname, int t )
+{
+  POP3DATA *P;
+  int ret;
+ 
+  P = (POP3DATA*)xmalloc( sizeof( POP3DATA ));
+  P->hostname = (char*)strdup( hostname );
+  P->timeout = t; 
+  
+  ret = mypop3( P );
+ 
+  if( ret > 0 ){ return P->rtt; }
+  else         { return ret; }
+ 
+} 

diff --git a/src/libping/pop3.h b/src/libping/pop3.h
new file mode 100644 (file)
index 0000000..2ceaf88
--- /dev/null
+++ b/src/libping/pop3.h
@@ -0,0 +1,39 @@
+/**
+ * POP3 header
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#ifndef  POP3_H
+#define  POP3_H
+
+typedef struct
+{
+  char   *hostname;
+  int    rtt;
+  int    timeout;
+} POP3DATA;
+
+int mypop3( POP3DATA *P );
+
+int pingpop3 ( const char *hostname );
+int pingtpop3( const char *hostname, int t );
+int tpingpop3( const char *hostname );
+int tpingtpop3( const char *hostname, int t ); 
+
+#endif /*POP3_H*/

diff --git a/src/libping/private.c b/src/libping/private.c
new file mode 100644 (file)
index 0000000..48a01af
--- /dev/null
+++ b/src/libping/private.c
@@ -0,0 +1,32 @@
+/**
+ * PING lib private data type
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include "private.h"
+
+struct ping_priv
+ping_priv_default (void)
+{
+  struct ping_priv datum;
+  datum.ident = IDENT_DEFAULT;
+  datum.timo = TIMO_DEFAULT;
+  return datum;
+}

diff --git a/src/libping/private.h b/src/libping/private.h
new file mode 100644 (file)
index 0000000..66f081e
--- /dev/null
+++ b/src/libping/private.h
@@ -0,0 +1,37 @@
+/**
+ * PING lib private data type
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef PING_PRIVATE_H
+#define PING_PRIVATE_H 
+
+#define IDENT_DEFAULT 0
+#define TIMO_DEFAULT 2
+
+struct ping_priv {
+  int   ident;
+  int   timo;
+  int   rrt;
+  int   sock;
+};
+
+struct ping_priv ping_priv_default (void);
+#endif /* Def: PING_PRIVATE_H */

diff --git a/src/libping/setup.h b/src/libping/setup.h
new file mode 100644 (file)
index 0000000..7b87749
--- /dev/null
+++ b/src/libping/setup.h
@@ -0,0 +1,32 @@
+#ifndef SETUP_H
+#define SETUP_H
+
+#ifdef HAVE_SYS_TIMES_H
+# include <sys/times.h>
+#endif /*HAVE_SYS_TIMES_H*/
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif /*TIME_WITH_SYS_TIME*/
+
+#ifndef  TRUE
+# define TRUE           1
+#endif /*TRUE*/
+#ifndef  FALSE
+# define FALSE          0 
+#endif /*FALSE*/
+
+#ifndef  EXIT_SUCCESS
+# define EXIT_SUCCESS   0
+#endif /*EXIT_SUCESS*/
+#ifndef  EXIT_FAILURE
+# define EXIT_FAILURE   1
+#endif /*EXIT_FAILURE*/ 
+
+#endif/*SETUP_H*/

diff --git a/src/libping/smtp.c b/src/libping/smtp.c
new file mode 100644 (file)
index 0000000..71fa0f5
--- /dev/null
+++ b/src/libping/smtp.c
@@ -0,0 +1,169 @@
+/**
+ * SMTP module
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif/*HAVE_CONFIG_H*/ 
+
+#include <setup.h>
+#include <sock.h>
+#include <smtp.h>
+#include <util.h> 
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef HAVE_SYS_TIMES_H
+# include <sys/times.h>
+#endif /*HAVE_SYS_TIMES_H*/
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif /*TIME_WITH_SYS_TIME*/
+
+#include "memory.h"
+ 
+#define  MSGBUF 2048 
+
+int smtp_cmd( CONN *C, char *format, ... ); 
+
+int
+mysmtp( SMTPDATA *S )
+{
+  CONN *C;
+  char buf[MSGBUF];
+  int ret  = 0;
+  struct timeval mytime;
+
+  C = (CONN*)xmalloc( sizeof( CONN ));
+  C->port    =   25;
+  C->timeout = ( S->timeout == 0 )?60:S->timeout; 
+ 
+  /* set the rtt timer */
+  (void) gettimeofday( &mytime, (struct timezone *)NULL); 
+
+  if(( C->sock=JOEsocket( C, S->hostname ))    < 0 ){ JOEclose( C ); return -1;  } 
+  if(( ret = JOEreadline( C, buf, MSGBUF ))    < 0 ){ JOEclose( C ); return ret; }
+  if(( ret = smtp_cmd( C, "%s", "HELO dude" )) < 0 ){ JOEclose( C ); return ret; }
+  if(( ret = smtp_cmd( C, "%s", "QUIT"   ))    < 0 ){ JOEclose( C ); return ret; }
+  JOEclose( C );
+
+  S->rtt = elapsed_time( &mytime );
+  
+  return 1;
+}
+
+int
+smtp_cmd( CONN *C, char *format, ... )
+{
+  va_list args;
+  char buf[MSGBUF];
+  char rec[MSGBUF];
+  int  ret;
+  
+  bzero( buf, sizeof( buf ));
+  bzero( rec, sizeof( rec));  
+
+  va_start( args, format );
+  if(( vsnprintf( buf, MSGBUF-3, format, args )) < 0 ){
+    perror( "message too large" );
+    exit( 1 );
+  }
+  
+  (void)strcat( buf, "\015\012" );
+  
+  if( JOEsocket_write( C, buf, sizeof( buf )) < 0 )
+    return -1;
+
+  if(( ret = JOEreadline( C, rec, MSGBUF )) <= 0 ){ 
+    return -1; 
+  }
+  *rec='\0';
+
+  va_end( args );
+  if(( ret = atoi( rec )) > 400 ){ 
+    return -1; 
+  } else return 1;
+}
+
+int 
+pingsmtp( const char *hostname )
+{
+  SMTPDATA *S;
+ 
+  S = (SMTPDATA*)xmalloc( sizeof( SMTPDATA ));
+  S->hostname = (char*)strdup( hostname );
+  S->timeout = 0;
+ 
+  return mysmtp( S );
+}
+
+int 
+pingtsmtp( const char *hostname, int t )
+{
+  SMTPDATA *S;
+ 
+  S = (SMTPDATA*)xmalloc( sizeof( SMTPDATA ));
+  S->hostname = (char*)strdup( hostname );
+  S->timeout = t;
+ 
+  return mysmtp( S );
+}
+
+int
+tpingsmtp( const char *hostname )
+{
+  SMTPDATA *S;
+  int ret;
+ 
+  S = (SMTPDATA*)xmalloc( sizeof( SMTPDATA ));
+  S->hostname = (char*)strdup( hostname );
+  S->timeout = 0;
+ 
+  ret = mysmtp( S ); 
+ 
+  if( ret > 0 ){ return S->rtt; }
+  else         { return ret; }
+}
+ 
+int
+tpingtsmtp( const char *hostname, int t )
+{
+  SMTPDATA *S;
+  int ret;
+ 
+  S = (SMTPDATA*)xmalloc( sizeof( SMTPDATA ));
+  S->hostname = (char*)strdup( hostname );
+  S->timeout = t;
+ 
+  ret = mysmtp( S ); 
+ 
+  if( ret > 0 ){ return S->rtt; }
+  else         { return ret; }
+ 
+} 

diff --git a/src/libping/smtp.h b/src/libping/smtp.h
new file mode 100644 (file)
index 0000000..74b4c60
--- /dev/null
+++ b/src/libping/smtp.h
@@ -0,0 +1,39 @@
+/**
+ * SMTP header
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#ifndef  SMTP_H
+#define  SMTP_H
+
+typedef struct
+{
+  char   *hostname;
+  int    rtt;
+  int    timeout;
+} SMTPDATA;
+
+int mysmtp( SMTPDATA *S );
+
+int pingsmtp ( const char *hostname );
+int pingtsmtp( const char *hostname, int t );
+int tpingsmtp( const char *hostname );
+int tpingtsmtp( const char *hostname, int t ); 
+
+#endif /*SMTP_H*/

diff --git a/src/libping/sock.c b/src/libping/sock.c
new file mode 100644 (file)
index 0000000..88938f2
--- /dev/null
+++ b/src/libping/sock.c
@@ -0,0 +1,493 @@
+/**
+ * LIBPING socket library
+ *
+ * Copyright (C) 2000, 2001, 2002 by
+ * Jeffrey Fulmer - <jdfulmer@armstrong.com>
+ * This file is distributed as part of libping
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifdef  HAVE_CONFIG_H
+# include <config.h>
+#endif/*HAVE_CONFIG_H*/
+
+#include <stdio.h>
+#include <sock.h>
+#include <fcntl.h>
+
+#ifdef  HAVE_ARPA_INET_H
+# include <arpa/inet.h>
+#endif/*HAVE_ARPA_INET_H*/
+ 
+#ifdef  HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif/*HAVE_SYS_SOCKET_H*/ 
+
+#ifdef  HAVE_NETINET_IN_H
+# include <netinet/in.h>
+#endif/*HAVE_NETINET_IN_H*/
+ 
+#ifdef  HAVE_NETDB_H
+# include <netdb.h>
+#endif/*HAVE_NETDB_H*/
+
+#ifdef  HAVE_SSL
+# include <openssl/rand.h>
+#endif/*HAVE_SSL */
+
+#include <setup.h>
+#include <errno.h>
+#include <string.h>
+
+/** 
+ * local prototypes 
+ */
+int mknblock( int socket, int nonblock );
+ssize_t socket_write( int sock, const void *vbuf, size_t len );  
+ssize_t ssl_socket_write( CONN *C, const void *vbuf, size_t len );
+
+/**
+ * JOEsocket
+ * returns int, socket handle
+ */
+int
+JOEsocket( CONN *C, const char *hn )
+{
+  int conn;
+  struct timeval timeout;
+  int res;
+  int herrno;
+  int error;
+  socklen_t          len;
+  struct linger      ling;
+  struct sockaddr_in cli; 
+  struct hostent     *hp;
+  struct hostent     hent; 
+  char hbf[9000]; 
+
+#if defined(_AIX)
+  char *aixbuf;
+  int  rc;
+#endif/*_AIX*/ 
+
+#ifdef  HAVE_SSL
+  int serr; 
+  char buf[1024]; 
+  C->ssl  = NULL;
+  C->ctx  = NULL;
+#endif/*HAVE_SSL*/
+
+  C->sock = -1;
+  
+  if( C->prot == HTTPS ){
+    #ifdef HAVE_SSL
+      SSL_load_error_strings();
+      SSLeay_add_ssl_algorithms();
+      C->ctx = SSL_CTX_new( SSLv3_client_method());
+      if( C->ctx == NULL ){ perror( "SSL: ctx is NULL" ); }
+      /* http://www.openssl.org/support/faq.html#USER1
+       * Perhaps someday I'll learn to read the FAQ
+       * first and then code second, but probably not.
+       * Not all OSes have /dev/urandom, we must seed
+       * the PRNG
+       */
+      memset( buf, 0, sizeof( buf ));
+      RAND_seed( buf, sizeof( buf ));
+      C->ssl = SSL_new( C->ctx );
+      SSL_set_connect_state( C->ssl );
+    #else
+      return -1;
+    #endif /* HAVE_SSL */
+  }
+
+  /* create a socket, return -1 on failure */
+  if(( C->sock = socket( AF_INET, SOCK_STREAM, 0 )) < 0 ){
+    return -1;
+  }
+ 
+#if defined(__GLIBC__)
+  /* for systems using GNU libc */
+  if(( gethostbyname_r( hn, &hent, hbf, sizeof(hbf), &hp, &herrno ) < 0 )){
+    hp = NULL;
+  }
+#elif defined(sun)
+  /* Solaris 5++ */
+  hp = gethostbyname_r( hn, &hent, hbf, sizeof(hbf), &herrno );
+#elif defined(_AIX)
+  aixbuf = (char*)xmalloc( 9000 );
+  rc  = gethostbyname_r(hn, (struct hostent *)aixbuf,
+                       (struct hostent_data *)(aixbuf + sizeof(struct hostent)));
+  hp = (struct hostent*)aixbuf;
+#elif ( defined(hpux) || defined(__osf__) )
+  hp = gethostbyname( hn );
+  herrno = h_errno;
+#else
+  /* simply hoping that gethostbyname is thread-safe */
+  hp = gethostbyname( hn );
+  herrno = h_errno;
+#endif/*OS SPECIFICS*/ 
+
+  if( hp == NULL ) return -1;
+  bzero( &cli, sizeof( cli ));
+  bcopy( (char*)hp->h_addr, (char*)&cli.sin_addr, hp->h_length );
+  cli.sin_family = AF_INET;
+  cli.sin_port = htons( C->port );
+
+  ling.l_onoff  = 1;
+  ling.l_linger = 0;
+  if( setsockopt( C->sock, SOL_SOCKET, SO_LINGER, &ling, sizeof( ling )) < 0 ){ 
+    return -1;    
+  }
+
+  /**
+   * connect to the host 
+   * evaluate the server response and check for
+   * readability/writeability of the socket....
+   */ 
+  conn = connect( C->sock, (struct sockaddr *)&cli, sizeof(struct sockaddr_in));
+  if( conn < 0 ){
+    JOEclose( C );
+    return -1;
+  }
+  else if( conn == 0 ){
+    goto FINISH; /* immediate connection */
+  }
+  else{
+    /** 
+     * we have a connection, set the
+     * socket to non-blocking and test
+     * its integrity.
+     */
+    if(( mknblock( C->sock, TRUE )) < 0 ){
+      return -1;
+    }
+    FD_ZERO(&C->rset);
+    FD_ZERO(&C->wset);
+    FD_SET( C->sock, &C->rset );    
+    FD_SET( C->sock, &C->wset );    
+    memset((void *)&timeout, '\0', sizeof( struct timeval ));
+    /**
+     * the default timeout is set in init.c, it's
+     * value can be changed by the user in .siegerc,
+     * but we'll still use a ternary condition since
+     * you can't be too safe....
+     */ 
+    timeout.tv_sec  = (C->timeout > 0)?C->timeout:60;
+    timeout.tv_usec = 0;
+
+    if(( res = select( C->sock+1, &C->rset, &C->wset, NULL, &timeout )) < 1 ){
+      perror( "JOEsocket: connection timed out." );
+      close( C->sock );
+      return -1; 
+    }
+    if( FD_ISSET( C->sock, &C->rset) || FD_ISSET( C->sock, &C->wset )){
+      len = sizeof(error);
+      if( getsockopt( C->sock, SOL_SOCKET, SO_ERROR, &error, &len ) < 0 )
+        return(-1); 
+    }
+  } /* end of connect conditional */
+
+FINISH:
+  /**
+   * make the socket blocking again.
+   */
+  if(( mknblock( C->sock, FALSE )) < 0 ){
+    perror( "JOEsocket: unable to set socket to non-blocking." );
+    return -1;
+  } 
+ 
+  /* if requested, encrypt the transaction  */
+  if( C->prot == HTTPS ){
+    #ifdef HAVE_SSL
+      /* currently a fatal error, should it be? */
+      if(( SSL_set_fd( C->ssl, C->sock )) < 0 ){
+        perror( "unable to create secure socket!" );
+        exit( 0 );
+      }
+      if(( serr = SSL_connect( C->ssl )) < 0 ){
+        int problem = SSL_get_error( C->ssl, serr );
+        fprintf( stderr, "SSL_connect: want to %s more...\n",
+               ( problem == SSL_ERROR_WANT_READ) ? "read" : "write");
+        return -1;
+      }
+      SSL_get_cipher( C->ssl );
+    #else
+      return -1;
+    #endif /* HAVE_SSL */
+  }
+  
+  return((C->sock>0)?C->sock:-1);
+}
+
+/**
+ * makes the socket non-blocking,
+ * calls select with timeout and
+ * returns the socket to blocking.
+ */
+int
+JOEsocket_check( CONN *C, SDSET test )
+{
+  int res;
+  struct timeval timeout;
+ 
+  FD_ZERO(&C->rset);
+  FD_ZERO(&C->wset);
+  FD_SET( C->sock, &C->rset );
+  FD_SET( C->sock, &C->wset );
+  memset((void *)&timeout, '\0', sizeof( struct timeval ));
+
+  if(( mknblock( C->sock, TRUE )) < 0 ){
+    perror( "SIMBOTsocket: unable to set socket to non-blocking." );
+    return -1;
+  }
+ 
+  timeout.tv_sec  = ( C->timeout > 0)?C->timeout:60;
+  timeout.tv_usec = 0;
+ 
+  switch( test ){
+  case READ:
+    if(( res = select( C->sock+1, &C->rset, NULL, NULL, &timeout )) < 1 ){
+      close( C->sock );
+      return -1;
+    }
+    break;
+  case WRITE:
+    if(( res = select( C->sock+1, NULL, &C->wset, NULL, &timeout )) < 1 ){
+      close( C->sock );
+      return -1;
+    }
+    break;
+  case RDWR:
+    if(( res = select( C->sock+1, &C->rset, &C->wset, NULL, &timeout )) < 1 ){
+      close( C->sock );
+      return -1;
+    }
+    break;
+  }
+ 
+  if(( mknblock( C->sock, FALSE )) < 0 ){
+    perror( "SIMBOTsocket: unable to set socket to non-blocking." );
+    return -1;
+  }
+  FD_CLR( C->sock, &C->rset );
+ 
+  return 0;
+}
+
+/**
+ * local function
+ * set socket to non-blocking
+ */
+int
+mknblock( int sock, int nonblock )
+{
+#if HAVE_FCNTL_H 
+  int flags;
+  int retval;
+
+  flags = fcntl( sock, F_GETFL, 0 );
+  if( flags < 0 ){
+    perror("fcntl");
+    return -1;
+  }
+  if( nonblock ){ 
+    flags |=  O_NDELAY;
+  }
+  else{
+    flags &= ~O_NDELAY;
+  }
+  retval = fcntl( sock, F_SETFL, flags);
+  if( retval < 0 ){
+    perror("fcntl");
+    return -1;
+  } 
+  return retval;
+#elif defined( FIONBIO )
+  ioctl_t status;
+ 
+  status = nb ? 1 : 0;
+  return ioctl( sd, FIONBIO, &status );
+#else
+  return -1;
+#endif
+}  
+
+/**
+ * local function
+ * returns ssize_t
+ * writes vbuf to sock
+ */
+ssize_t
+socket_write( int sock, const void *vbuf, size_t len )
+{
+  size_t      n;
+  ssize_t     w;
+  const char *buf;
+ 
+  buf = vbuf;
+  n   = len;
+  while( n > 0 ){
+    if(( w = write( sock, buf, n )) <= 0 ){
+      if( errno == EINTR )
+        w = 0;
+      else
+        return( -1 );
+    }
+    n    -= w;
+    buf += n;
+  }
+  return( len );
+}
+
+/**
+ * local function
+ * returns ssize_t
+ * writes vbuf to sock
+ */
+ssize_t
+ssl_socket_write( CONN *C, const void *vbuf, size_t len )
+{
+#ifdef HAVE_SSL
+  size_t      n;
+  ssize_t     w;
+  const char *buf;
+
+  buf = vbuf;
+  n   = len;
+  while( n > 0 ){
+    if(( w = SSL_write( C->ssl, buf, n )) <= 0 ){
+      if( errno == EINTR )
+        w = 0;
+      else
+        return( -1 );
+    }
+    n    -= w;
+    buf += n;
+  }
+  return( len );
+#else
+  perror( "protocol not supported" );
+  return -1;
+#endif/*HAVE_SSL*/
+}
+
+ssize_t
+JOEreadline( CONN *C, char *ptr, size_t len )
+{
+  int n;
+ 
+  do{
+    n = read( C->sock, ptr, 1 );
+  } while( n > 0 && *ptr++ != '\n' );
+ 
+  *ptr++=0;
+  return( n > 0 );
+} 
+
+ssize_t
+JOEsocket_read( CONN *C, void *vbuf, size_t len )
+{
+  size_t      n;
+  ssize_t     r;
+  char *buf;
+  
+  buf = vbuf;
+  n   = len;
+  
+  if( C->prot == HTTPS ){
+  #ifdef HAVE_SSL
+    while( n > 0 ){ 
+      if(( r = SSL_read( C->ssl, buf, n )) < 0 ){
+        if( errno == EINTR )
+          r = 0;
+        else
+          return( -1 );
+      }
+      else if( r == 0 ) break; 
+      n   -= r;
+      buf += r;
+    }   /* end of while    */
+  #endif/*HAVE_SSL*/
+  }  
+  else{
+    while( n > 0 ){
+      if(( r = read( C->sock, buf, n )) < 0 ){
+        if( errno == EINTR )
+          r = 0;
+        else
+          return( -1 );
+      }
+      else if( r == 0 ) break;
+      n   -= r;
+      buf += r;
+    } /* end of while */ 
+  }   /* end of else  */
+
+  return( len - n );  
+}  
+
+/**
+ * returns void
+ * socket_write wrapper function.
+ */
+int
+JOEsocket_write( CONN *C, const void *buf, size_t len )
+{
+  int bytes;
+
+  if( C->prot == HTTPS ){
+    /* handle HTTPS protocol */
+    #ifdef HAVE_SSL
+    if(( bytes = ssl_socket_write( C, buf, len )) != len ){
+      perror( "JOEssl_socket_write: ERROR" );
+      return -1;
+    }
+    #else
+      perror( "JOEssl_socket_write: protocol NOT supported" );
+      return -1;
+    #endif/*HAVE_SSL*/
+  }
+  else{
+    /* assume HTTP */
+    if(( bytes = socket_write( C->sock, buf, len )) != len ){
+      perror( "JOEsocket_write: ERROR" );
+      return -1;
+    }
+  }
+
+  return 0;
+} 
+
+/**
+ * returns void
+ * frees ssl resources if using ssl and
+ * closes the connection and the socket.
+ */
+void
+JOEclose( CONN *C )
+{
+  #ifdef  HAVE_SSL
+    if( C->prot == HTTPS ){
+      SSL_shutdown( C->ssl );
+    }
+    SSL_free( C->ssl );
+    SSL_CTX_free( C->ctx );
+  #endif/*HAVE_SSL*/
+  close( C->sock ); 
+
+  return;
+} 
+
+

diff --git a/src/libping/sock.h b/src/libping/sock.h
new file mode 100644 (file)
index 0000000..4fe7061
--- /dev/null
+++ b/src/libping/sock.h
@@ -0,0 +1,135 @@
+/**
+ * LIBPING socket header file
+ *
+ * Copyright (C) 2000, 2001, 2002 by
+ * Jeffrey Fulmer - <jdfulmer@armstrong.com>
+ * This file is distributed as part of libping
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef SOCK_H
+#define SOCK_H
+
+#ifdef  HAVE_ARPA_INET_H
+# include <arpa/inet.h>
+#endif/*HAVE_ARPA_INET_H*/
+ 
+#ifdef  HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif/*HAVE_SYS_SOCKET_H*/
+
+#ifdef  HAVE_UNISTD_H
+# include <unistd.h>
+#endif/*HAVE_UNISTD_H*/ 
+ 
+#ifdef  HAVE_NETINET_IN_H
+# include <netinet/in.h>
+#endif/*HAVE_NETINET_IN_H*/
+
+#ifdef HAVE_SYS_TIMES_H
+# include <sys/times.h>
+#endif /*HAVE_SYS_TIMES_H*/
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif/*TIME_WITH_SYS_TIME*/ 
+ 
+#ifdef  HAVE_NETDB_H
+# include <netdb.h>
+#endif/*HAVE_NETDB_H*/ 
+
+#ifdef  HAVE_SSL
+# include <openssl/ssl.h>
+# include <openssl/err.h>
+# include <openssl/rsa.h>
+# include <openssl/crypto.h>
+# include <openssl/x509.h>
+# include <openssl/pem.h>
+#endif/*HAVE_SSL*/
+
+#include <url.h>
+
+typedef enum
+{
+  S_CONNECTING = 1,
+  S_READING    = 2,
+  S_WRITING    = 4,
+  S_DONE       = 8
+} STATUS; 
+
+typedef enum
+{
+  READ  = 0,
+  WRITE = 1,
+  RDWR  = 2
+} SDSET;  
+
+typedef struct
+{
+  int      sock;
+  int      port;
+  int      timeout;
+  STATUS   status;
+  PROTOCOL prot;
+#ifdef  HAVE_SSL
+  SSL      *ssl;
+  SSL_CTX  *ctx;
+#endif/*HAVE_SSL*/
+  fd_set   rset;
+  fd_set   wset;
+} CONN; 
+
+/**
+ * create socket 
+ * const char *hostname
+ * const char *service
+ */
+int JOEsocket( CONN *conn, const char *hostname );
+
+/**
+ * checks the socket for both
+ * readability, writeability or both.
+ */
+int JOEsocket_check( CONN *C, SDSET S );
+
+/** 
+ * write int sock 
+ * from char *buf, 
+ * unsigned int length 
+ */
+int JOEsocket_write( CONN *conn, const void *b, size_t n );
+
+/** 
+ * read int sock, 
+ * into void *buf, 
+ * size_t length 
+ */
+ssize_t JOEread_byte( CONN *conn, void *buf, size_t len ); 
+ssize_t JOEreadline( CONN *C, char *ptr, size_t len ); 
+ssize_t JOEsocket_read( CONN *conn, void *buf, size_t len ); 
+
+/** 
+ * close int socket 
+ */
+void JOEclose( CONN *C );
+
+#endif /* SOCK_H */
+

diff --git a/src/libping/url.c b/src/libping/url.c
new file mode 100644 (file)
index 0000000..77b68ed
--- /dev/null
+++ b/src/libping/url.c
@@ -0,0 +1,331 @@
+/**
+ * URL Processing
+ *
+ * Copyright (C) 2000, 2001, 2002 by
+ * Jeffrey Fulmer - <jdfulmer@armstrong.com>
+ * This file is distributed as part of Siege 
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
+ *
+ */
+#ifdef  HAVE_CONFIG_H
+# include <config.h>
+#endif/*HAVE_CONFIG_H*/
+ 
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#ifdef STDC_HEADERS
+# include <string.h>
+#else
+# ifndef HAVE_STRCHR
+#  define strchr index
+#  define strrchr rindex
+# endif
+char *strchr (), *strrchr ();
+# ifndef HAVE_MEMCPY
+#  define memcpy(d, s, n) bcopy ((s), (d), (n))
+#  define memmove(d, s, n) bcopy ((s), (d), (n))
+# endif
+#endif
+#include <errno.h>
+#include <url.h>
+#include <util.h>
+#include <setup.h>
+
+/*HARDCODED ALERT*/
+#define PLENGTH 84  /* length of the *prot[] array */
+
+/** 
+ * ALERT: using hardcoded array lengths below,
+ * if you change this array, then redefine PLENGTH
+ * 
+ * Currently http(prot[25]) and https(prot[26]) are 
+ * the only supported protocols.  But all w3c supported 
+ * protocols are listed for URL evaluation.
+ */  
+static char *prot[] = {
+  "about:",      "addrbook:",  "acap:",      "afp:",
+  "afs:",        "callto:",    "chttp:",     "cid:",
+  "clsid:",      "data:",      "date:",      "DAV:",
+  "dns:",        "eid:",       "fax:",       "file:",
+  "finger:",     "freenet:",   "ftp:",       "gopher:",
+  "gsm:",        "h323:",      "h324:",      "hdl:",
+  "hnews:",      "http:",      "https:",     "iioploc:",
+  "ilu:",        "imap:",      "IOR:",       "irc:",
+  "isbn:",       "java:",      "JavaRMI:",   "javascript:",
+  "jdbc:",       "ldap:",      "lid:",       "lifn:",
+  "livescript:", "lrq:",       "mailto:",    "mailserver:",
+  "md5:",        "mid:",       "mocha:",     "modem:",
+  "news:",       "nfs:",       "nntp:",      "opaquelocktoken:"
+  "path:",       "phone:",     "pop:",       "pop3:",
+  "printer:",    "prospero:",  "res:",       "rtsp:",
+  "rvp:",        "rwhois:",    "rx:",        "sdp:",
+  "sip:",        "shttp:",     "snews:",     "STANF:",
+  "t120:",       "tel:",       "telephone:", "telnet:",
+  "tip:",        "tn3270:",    "tv:",        "uuid:",
+  "urn:",        "vemmi:",     "videotex:",  "view:",
+  "wais:",       "whois++:",   "whodp:",     "z39.50r:",
+  "z39.50s:"
+  
+};
+
+/**
+ * int value of the length of the protocol 
+ * string passed to the function.
+ */     
+int
+protocol_length( char *url )
+{
+  int x;
+  /** 
+   * hardcoded protocol length!! see explanation above...
+   */
+  for( x = 0; x < PLENGTH; x ++ ){ 
+    if( strncasecmp( url, prot[x], strlen( prot[x] )) == 0 )
+      return strlen( prot[x] );
+  } 
+  return 0;    
+}
+
+/**
+ * If a person edits an html file on the
+ * Microsoft platform and copies it to a 
+ * UNIX server, we are left to deal with 
+ * ^M chars messing with our minds...
+ */
+char *
+trim( char *str )
+{
+  char *s=str;
+ 
+  if( str == NULL ) return NULL;
+ 
+  /* advance the ptr */
+  while( *s ) s++;
+ 
+  /* chomp the white space */
+  while( str < s && isspace( *( s-1 )))
+    *s-- = '\0';
+ 
+  *s = '\0';
+ 
+  return str; /* UNIX friendly */
+} 
+
+/**
+ * boolean, returns true if the protocol is 
+ * supported by siege, false if it is not.
+ */ 
+int
+is_supported( char* url )
+{
+  if( strncasecmp( url, prot[25], strlen( prot[25] )) == 0 )
+    return TRUE;
+  if( strncasecmp( url, prot[26], strlen( prot[26] )) == 0 )
+    #ifdef HAVE_SSL
+      return TRUE;
+    #else
+      return FALSE;
+    #endif /* HAVE_SSL */
+  else
+    return FALSE;
+}
+
+/**
+ * get_protocol
+ * returns protocol char*
+ */
+PROTOCOL
+get_protocol( const char *url )
+{
+  if( strncasecmp( url, prot[25], strlen( prot[25] )) == 0 )
+    return HTTP;
+  if( strncasecmp( url, prot[26], strlen( prot[26] )) == 0 )
+    #ifdef HAVE_SSL
+      return HTTPS;
+    #else
+      return HTTP;
+    #endif /* HAVE_SSL */
+  else
+    return UNSPRTD;
+}
+
+/**
+ * get_default_port
+ */
+int
+get_default_port( PROTOCOL p )
+{
+  if( p == HTTP )
+    return 80;
+  if( p == HTTPS )
+    #ifdef HAVE_SSL
+      return 443;
+    #else
+      return 80;
+    #endif /* HAVE_SSL */
+  else
+    return 80; 
+}
+
+char *
+url_encode( char *str )
+{
+  int size = 0;
+  char *ch, *bk;
+  char *p, *buf;
+  static char unsafe[]     = "<>{}#%|\"\\^~[]`@:\033";
+  static char char2hex[16] = "0123456789ABCDEF";
+
+  bk = ch  = str;
+  do{
+    if( strchr( unsafe, *ch ))
+      size += 2;
+    ch++; size ++;
+  } while( *ch );
+
+  buf = (char*)malloc( size +1 );
+  p   = buf;
+  ch  = bk;
+  do{
+    if( strchr( unsafe, *ch )){
+      const char c = *ch;
+      *p++ = '%';
+      *p++ = char2hex[(c >> 4) & 0xf];
+      *p++ = char2hex[c & 0xf];
+    }
+    else{
+      *p++ = *ch;
+    }
+    ch ++;
+  } while( *ch );
+
+  *p = '\0';
+  return( buf );
+}
+
+/**
+ * process_post_data
+ * populates URL->postdata with POST information
+ * returns int
+ */
+char *
+process_post_data( char *datap )
+{
+  for( ; isspace(*datap); datap++ ){
+    /* Advance past white space */
+  }
+  if( *datap == '<' ){
+    /* Get Data from file */
+    return NULL;
+  }
+  else{
+    return datap;
+  }
+}
+
+URL
+build_url( char *url )
+{
+  URL U;                   /* defined in setup.h  */
+  int one, two, thr, fou;  /* placement counters. */ 
+  char *post_cmd=NULL;     /* POST directive for server */
+  char *tmp;
+
+  post_cmd = strstr( url, " POST" ); 
+  if( post_cmd != NULL ){
+    /* How do we deal with handling the multi-headed url_t arrays */
+    U.calltype = URL_POST;
+    *post_cmd = 0;
+    post_cmd += 5;
+    U.postdata = (char*)strdup( process_post_data( post_cmd ));
+    U.postlen  = strlen( U.postdata );
+  }
+  else{
+    U.calltype   = URL_GET;
+    U.postdata   = NULL;
+    U.posttemp   = NULL;
+    U.postlen    = 0;
+  }
+  if(( one = protocol_length( url )) > 0 && is_supported( url ) == TRUE ){
+    one += 2;
+  }
+  else if(( one = protocol_length( url )) > 0 && is_supported( url ) == FALSE ){
+    U.protocol = UNSPRTD;
+    one += 2;
+    perror( "unsupported protocol" );
+  }
+  else{
+    /* we are dealing with who knows what */
+    tmp = (char*)strstr( url, "://" );
+    if( tmp != NULL ){
+      one = (strlen(url) - (strlen(tmp) - 3 ));
+    }
+    else{
+      one = 0;  /* no specified protocol, assuming http: */
+    }
+  }
+
+  two = one;
+  while( url[two] && url[two] != ':' && url[two] != '/' ) two++; 
+
+  if( url[two] == ':' ){
+    fou = two;
+    while( url[two] && url[two] != '/' ){
+      two++;
+    }
+  }
+  else{ fou = two; }
+  if( url[two] == '/' ){ thr = two; }
+  else                 { thr = strlen( url ); } 
+
+  /* here we piece it all together */
+  if( one == 0 ){
+    U.protocol = HTTP;
+  }
+  else{
+    U.protocol = get_protocol( url );
+  }
+  U.hostname   = (char*)strdup(substring( url, one, ( fou - one )));
+  if( fou == two ){
+    U.port = get_default_port( U.protocol );
+  }
+  else{
+    U.port = atoi(substring( url, fou+1, (thr-(fou+1))));
+  }
+  if(( U.pathname = (char *)strdup(substring( url, thr, strlen( url )))) == NULL ){
+    U.pathname = (char *)strdup( "/" ); 
+  }
+  U.pathname = (strlen(U.pathname)==0)?strcpy(U.pathname, "/"):U.pathname; 
+  trim( U.pathname );
+
+  free( url ); 
+  return( U );
+}
+
+/**
+ * add_url
+ * parses char * then populates and 
+ * returns a URL with appropriate data.
+ */
+URL
+add_url( char *url )
+{
+
+  return build_url( url );
+}
+
+

diff --git a/src/libping/url.h b/src/libping/url.h
new file mode 100644 (file)
index 0000000..648d845
--- /dev/null
+++ b/src/libping/url.h
@@ -0,0 +1,69 @@
+/**
+ * URL support
+ *
+ * Copyright (C) 2000, 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of Siege
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --
+ */
+#ifndef  URL_H
+#define  URL_H
+
+typedef enum
+{
+  HTTP    = 1,
+  HTTPS   = 2,
+  ECHO    = 4,
+  SMTP    = 8,
+  POP3    = 16,
+  UNSPRTD = 32
+} PROTOCOL; 
+
+/**
+ * enum DIRECTIVE
+ * HTTP request directive
+ */
+typedef enum
+{
+  URL_GET   = 0,
+  URL_POST  = 1
+} DIRECTIVE;
+
+/**
+ * URL struct URL
+ */
+typedef struct
+{
+  PROTOCOL protocol;       /* currently only http/https   */
+  char *hostname;          /* DNS entry or IP address     */
+  int  port;               /* tcp port num, defs: 80, 443 */
+  char *pathname;          /* path to http resource.      */
+  DIRECTIVE calltype;      /* request: GET/POST/HEAD etc. */
+  size_t postlen;
+  char *postdata;
+  char *posttemp;
+} URL;
+
+int  protocol_length( char *url ); 
+int  is_supported( char* url );
+int  get_default_port( PROTOCOL p );
+PROTOCOL get_protocol( const char *url );
+void insert_childid( URL *U, int mypid );
+char *process_post_data( char *datap );
+URL  build_url( char *url );
+URL  add_url( char *url );
+
+#endif/*URL_H*/

diff --git a/src/libping/util.c b/src/libping/util.c
new file mode 100644 (file)
index 0000000..040ac8d
--- /dev/null
+++ b/src/libping/util.c
@@ -0,0 +1,110 @@
+/**
+ * UTILITY module
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <util.h>
+
+#ifdef STDC_HEADERS
+# include <string.h>
+#else
+# ifndef HAVE_STRCHR
+#  define strchr index
+#  define strrchr rindex
+# endif /* HAVE_STRCHR */
+char *strchr (), *strrchr ();
+# ifndef HAVE_MEMCPY
+#  define memcpy(d, s, n) bcopy ((s), (d), (n))
+#  define memmove(d, s, n) bcopy ((s), (d), (n))
+# endif /* HAVE_MEMCPY  */
+#endif  /* STDC_HEADERS */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "memory.h"
+
+/**
+ * elapsed_time
+ * returns an int value for the difference
+ * between now and starttime in milliseconds.
+ */
+int
+elapsed_time( struct timeval *starttime ){
+  struct timeval *newtime;
+  int elapsed;
+  newtime = (struct timeval*)malloc( sizeof(struct timeval));
+  gettimeofday(newtime,NULL);
+  elapsed = 0;
+  
+  if(( newtime->tv_usec - starttime->tv_usec) > 0 ){
+    elapsed += (newtime->tv_usec - starttime->tv_usec)/1000 ;
+  }
+  else{
+    elapsed += ( 1000000 + newtime->tv_usec - starttime->tv_usec ) /1000;
+    newtime->tv_sec--;
+  }
+  if(( newtime->tv_sec - starttime->tv_sec ) > 0 ){
+    elapsed += 1000 * ( newtime->tv_sec - starttime->tv_sec );
+  }
+  if( elapsed < 1 )
+    elapsed = 1;
+  
+  free( newtime );
+  return( elapsed );
+} 
+
+/**
+ * substring        
+ * returns a char pointer from int start 
+ * to int length.
+ */
+char * 
+substring (char *buffer, int start, int length)
+{
+  char *sub;
+  sub = xmalloc (sizeof (char) * (length + 1));
+       
+  if ((length < 1) || (start < 0) || (start > strlen (buffer)))
+    return NULL;
+
+  if (strlen (buffer) < length){
+    sub = (char*) strdup (buffer);
+    return buffer;
+  }
+
+  if (sub == NULL){
+    perror( "insufficient memory." );
+    exit( 1 );
+  }
+
+  memset (sub, 0, length + 1);
+
+  buffer += start;
+  memcpy (sub, buffer, length);
+
+  return sub;
+}
+

diff --git a/src/libping/util.h b/src/libping/util.h
new file mode 100644 (file)
index 0000000..d02b85c
--- /dev/null
+++ b/src/libping/util.h
@@ -0,0 +1,48 @@
+/**
+ * UTILITY header
+ *
+ * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
+ * This file is part of LIBPING
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#ifndef UTIL_H
+#define UTIL_H
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif/*HAVE_CONFIG_H*/ 
+
+#ifdef  HAVE_SYS_TIMES_H
+# include <sys/times.h>
+#endif/*HAVE_SYS_TIMES_H*/
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif /*HAVE_SYS_TIME_H*/
+#endif  /*TIME_WITH_SYS_TIME*/  
+
+int elapsed_time( struct timeval *starttime );
+
+char * substring( char *, int, int );
+
+#endif  /* UTIL_H */
+