aboutsummaryrefslogtreecommitdiff
path: root/src/netserver.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/netserver.c')
-rw-r--r--src/netserver.c1572
1 files changed, 1572 insertions, 0 deletions
diff --git a/src/netserver.c b/src/netserver.c
new file mode 100644
index 0000000..9534722
--- /dev/null
+++ b/src/netserver.c
@@ -0,0 +1,1572 @@
+/*
+
+ Copyright (C) 1993-2012 Hewlett-Packard Company
+ ALL RIGHTS RESERVED.
+
+ The enclosed software and documentation includes copyrighted works
+ of Hewlett-Packard Co. For as long as you comply with the following
+ limitations, you are hereby authorized to (i) use, reproduce, and
+ modify the software and documentation, and to (ii) distribute the
+ software and documentation, including modifications, for
+ non-commercial purposes only.
+
+ 1. The enclosed software and documentation is made available at no
+ charge in order to advance the general development of
+ high-performance networking products.
+
+ 2. You may not delete any copyright notices contained in the
+ software or documentation. All hard copies, and copies in
+ source code or object code form, of the software or
+ documentation (including modifications) must contain at least
+ one of the copyright notices.
+
+ 3. The enclosed software and documentation has not been subjected
+ to testing and quality control and is not a Hewlett-Packard Co.
+ product. At a future time, Hewlett-Packard Co. may or may not
+ offer a version of the software and documentation as a product.
+
+ 4. THE SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS".
+ HEWLETT-PACKARD COMPANY DOES NOT WARRANT THAT THE USE,
+ REPRODUCTION, MODIFICATION OR DISTRIBUTION OF THE SOFTWARE OR
+ DOCUMENTATION WILL NOT INFRINGE A THIRD PARTY'S INTELLECTUAL
+ PROPERTY RIGHTS. HP DOES NOT WARRANT THAT THE SOFTWARE OR
+ DOCUMENTATION IS ERROR FREE. HP DISCLAIMS ALL WARRANTIES,
+ EXPRESS AND IMPLIED, WITH REGARD TO THE SOFTWARE AND THE
+ DOCUMENTATION. HP SPECIFICALLY DISCLAIMS ALL WARRANTIES OF
+ MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+ 5. HEWLETT-PACKARD COMPANY WILL NOT IN ANY EVENT BE LIABLE FOR ANY
+ DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+ (INCLUDING LOST PROFITS) RELATED TO ANY USE, REPRODUCTION,
+ MODIFICATION, OR DISTRIBUTION OF THE SOFTWARE OR DOCUMENTATION.
+
+*/
+
+#include "netperf_version.h"
+
+char netserver_id[]="\
+@(#)netserver.c (c) Copyright 1993-2012 Hewlett-Packard Co. Version 2.6.0";
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#if HAVE_STRING_H
+# if !STDC_HEADERS && HAVE_MEMORY_H
+# include <memory.h>
+# endif
+# include <string.h>
+#endif
+
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+
+#if HAVE_LIMITS_H
+# include <limits.h>
+#endif
+
+#if HAVE_SYS_IPC_H
+#include <sys/ipc.h>
+#endif
+
+#if HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+
+#if HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+
+#if HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+#if HAVE_NETDB_H
+#include <netdb.h>
+#endif
+
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#if HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#if HAVE_ERRNO_H
+#include <errno.h>
+#endif
+
+#if HAVE_SIGNAL_H
+#include <signal.h>
+/* some OS's have SIGCLD defined as SIGCHLD */
+#ifndef SIGCLD
+#define SIGCLD SIGCHLD
+#endif /* SIGCLD */
+
+#endif
+
+#if !defined(HAVE_SETSID)
+#if HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
+#endif
+
+#ifdef WIN32
+#include <time.h>
+#include <winsock2.h>
+
+#if HAVE_WS2TCPIP_H
+#include <ws2tcpip.h>
+#endif
+
+#include <windows.h>
+
+#include "missing\stdint.h"
+
+#define strdup _strdup
+#define sleep(x) Sleep((x)*1000)
+#define netperf_socklen_t socklen_t
+#endif /* WIN32 */
+
+/* unconditional system includes */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <fcntl.h>
+
+/* netperf includes */
+#include "netlib.h"
+#include "nettest_bsd.h"
+
+#ifdef WANT_UNIX
+#include "nettest_unix.h"
+#endif /* WANT_UNIX */
+
+#ifdef WANT_DLPI
+#include "nettest_dlpi.h"
+#endif /* WANT_DLPI */
+
+#ifdef WANT_SCTP
+#include "nettest_sctp.h"
+#endif
+
+#include "netsh.h"
+
+#ifndef DEBUG_LOG_FILE_DIR
+#if defined(WIN32)
+#define DEBUG_LOG_FILE_DIR ""
+#elif defined(ANDROID)
+#define DEBUG_LOG_FILE_DIR "/data/local/tmp/"
+#else
+#define DEBUG_LOG_FILE_DIR "/tmp/"
+#endif
+#endif /* DEBUG_LOG_FILE_DIR */
+
+#ifndef DEBUG_LOG_FILE
+#define DEBUG_LOG_FILE DEBUG_LOG_FILE_DIR"netserver.debug"
+#endif
+
+#if !defined(PATH_MAX)
+#define PATH_MAX MAX_PATH
+#endif
+char FileName[PATH_MAX];
+
+char listen_port[10];
+
+struct listen_elt {
+ SOCKET fd;
+ struct listen_elt *next;
+};
+
+struct listen_elt *listen_list = NULL;
+
+SOCKET server_control;
+
+int child; /* are we the child of inetd or a parent netserver?
+ */
+int netperf_daemon;
+int daemon_parent = 0;
+int not_inetd;
+int want_daemonize;
+int spawn_on_accept;
+int suppress_debug = 0;
+
+extern char *optarg;
+extern int optind, opterr;
+
+/* char *passphrase = NULL; */
+
+static void
+init_netserver_globals() {
+
+#if defined(__VMS) || defined(VMWARE_UW)
+ spawn_on_accept = 0;
+ want_daemonize = 0;
+#else
+ spawn_on_accept = 1;
+#if defined(WIN32)
+ /* we only know how to spawn in WIN32, not daemonize */
+ want_daemonize = 0;
+#else
+ want_daemonize = 1;
+#endif /* WIN32 */
+#endif /* __VMS || VMWARE_UW */
+
+ child = 0;
+ not_inetd = 0;
+ netperf_daemon = 0;
+}
+
+void
+unlink_empty_debug_file() {
+
+#if !defined(WIN32)
+ struct stat buf;
+
+ if (stat(FileName,&buf)== 0) {
+
+ if (buf.st_size == 0)
+ unlink(FileName);
+ }
+#endif
+}
+
+/* it is important that set_server_sock() be called before this
+ routine as we depend on the control socket being dup()ed out of the
+ way when we go messing about with the streams. */
+void
+open_debug_file()
+{
+#if !defined WIN32
+#define NETPERF_NULL "/dev/null"
+#else
+#define NETPERF_NULL "nul"
+#endif
+
+ FILE *rd_null_fp;
+
+ if (where != NULL) fflush(where);
+
+ snprintf(FileName,
+ sizeof(FileName),
+#if defined(WIN32)
+ "%s\\%s_%d",
+ getenv("TEMP"),
+#else
+ "%s_%d",
+#endif
+ DEBUG_LOG_FILE,
+ getpid());
+ if ((where = fopen((suppress_debug) ? NETPERF_NULL : FileName,
+ "w")) == NULL) {
+ perror("netserver: debug file");
+ exit(1);
+ }
+
+#if !defined(WIN32)
+
+ chmod(FileName,0644);
+
+ /* redirect stdin to "/dev/null" */
+ rd_null_fp = fopen(NETPERF_NULL,"r");
+ if (NULL == rd_null_fp) {
+ fprintf(where,
+ "%s: opening of %s failed: %s (errno %d)\n",
+ __FUNCTION__,
+ NETPERF_NULL,
+ strerror(errno),
+ errno);
+ fflush(where);
+ exit(1);
+ }
+
+ if (close(STDIN_FILENO) == -1) {
+ fprintf(where,
+ "%s: close of STDIN_FILENO failed: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(where);
+ exit(1);
+ }
+
+ if (dup(fileno(rd_null_fp)) == -1) {
+ fprintf(where,
+ "%s: dup of rd_null_fp to stdin failed: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(where);
+ exit(1);
+ }
+
+ /* redirect stdout to "where" */
+ if (close(STDOUT_FILENO) == -1) {
+ fprintf(where,
+ "%s: close of STDOUT_FILENO failed: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(where);
+ exit(1);
+ }
+
+ if (dup(fileno(where)) == -1) {
+ fprintf(where,
+ "%s: dup of where to stdout failed: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(where);
+ exit(1);
+ }
+
+ /* redirect stderr to "where" */
+ if (close(STDERR_FILENO) == -1) {
+ fprintf(where,
+ "%s: close of STDERR_FILENO failed: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(where);
+ exit(1);
+ }
+
+ if (dup(fileno(where)) == -1) {
+ fprintf(where,
+ "%s: dup of where to stderr failed: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(where);
+ exit(1);
+ }
+
+#else
+
+ /* Hopefully, by closing stdout & stderr, the subsequent fopen calls
+ will get mapped to the correct std handles. */
+ fclose(stdout);
+
+ if ((where = fopen(FileName, "w")) == NULL) {
+ perror("netserver: fopen of debug file as new stdout failed!");
+ exit(1);
+ }
+
+ fclose(stderr);
+
+ if ((where = fopen(FileName, "w")) == NULL) {
+ fprintf(stdout, "fopen of debug file as new stderr failed!\n");
+ exit(1);
+ }
+
+#endif
+
+}
+
+/* so, either we are a child of inetd in which case server_sock should
+ be stdin, or we are a child of a netserver parent. there will be
+ logic here for all of it, including Windows. it is important that
+ this be called before open_debug_file() */
+
+void
+set_server_sock() {
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+#ifdef WIN32
+ server_sock = (SOCKET)GetStdHandle(STD_INPUT_HANDLE);
+#elif !defined(__VMS)
+ if (server_sock != INVALID_SOCKET) {
+ fprintf(where,"Yo, Iz ain't invalid!\n");
+ fflush(where);
+ exit(1);
+ }
+
+ /* we dup this to up the reference count so when we do redirection
+ of the io streams we don't accidentally toast the control
+ connection in the case of our being a child of inetd. */
+ server_sock = dup(0);
+
+#else
+ if ((server_sock =
+ socket(TCPIP$C_AUXS, SOCK_STREAM, 0)) == INVALID_SOCKET) {
+ fprintf(stderr,
+ "%s: failed to grab aux server socket: %s (errno %s)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(stderr);
+ exit(1);
+ }
+#endif
+
+}
+
+
+void
+create_listens(char hostname[], char port[], int af) {
+
+ struct addrinfo hints;
+ struct addrinfo *local_res;
+ struct addrinfo *local_res_temp;
+ int count, error;
+ int on = 1;
+ SOCKET temp_socket;
+ struct listen_elt *temp_elt;
+
+ if (debug) {
+ fprintf(stderr,
+ "%s: called with host '%s' port '%s' family %s(%d)\n",
+ __FUNCTION__,
+ hostname,
+ port,
+ inet_ftos(af),
+ af);
+ fflush(stderr);
+ }
+ memset(&hints,0,sizeof(hints));
+ hints.ai_family = af;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = IPPROTO_TCP;
+ hints.ai_flags = AI_PASSIVE;
+
+ count = 0;
+ do {
+ error = getaddrinfo((char *)hostname,
+ (char *)port,
+ &hints,
+ &local_res);
+ count += 1;
+ if (error == EAI_AGAIN) {
+ if (debug) {
+ fprintf(stderr,
+ "%s: Sleeping on getaddrinfo EAI_AGAIN\n",
+ __FUNCTION__);
+ fflush(stderr);
+ }
+ sleep(1);
+ }
+ } while ((error == EAI_AGAIN) && (count <= 5));
+
+ if (error) {
+ if (debug) {
+
+ fprintf(stderr,
+ "%s: could not resolve remote '%s' port '%s' af %d\n"
+ "\tgetaddrinfo returned %s (%d)\n",
+ __FUNCTION__,
+ hostname,
+ port,
+ af,
+ gai_strerror(error),
+ error);
+
+ }
+ return;
+ }
+
+ if (debug) {
+ dump_addrinfo(stderr, local_res, hostname, port, af);
+ }
+
+ local_res_temp = local_res;
+
+ while (local_res_temp != NULL) {
+
+ temp_socket = socket(local_res_temp->ai_family,SOCK_STREAM,0);
+
+ if (temp_socket == INVALID_SOCKET) {
+ if (debug) {
+ fprintf(stderr,
+ "%s could not allocate a socket: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(stderr);
+ }
+ local_res_temp = local_res_temp->ai_next;
+ continue;
+ }
+
+ /* happiness and joy, keep going */
+ if (setsockopt(temp_socket,
+ SOL_SOCKET,
+ SO_REUSEADDR,
+ (char *)&on ,
+ sizeof(on)) == SOCKET_ERROR) {
+ if (debug) {
+ fprintf(stderr,
+ "%s: warning: could not set SO_REUSEADDR: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(stderr);
+ }
+ }
+ /* still happy and joyful */
+
+ if ((bind(temp_socket,
+ local_res_temp->ai_addr,
+ local_res_temp->ai_addrlen) != SOCKET_ERROR) &&
+ (listen(temp_socket,1024) != SOCKET_ERROR)) {
+
+ /* OK, now add to the list */
+ temp_elt = (struct listen_elt *)malloc(sizeof(struct listen_elt));
+ if (temp_elt) {
+ temp_elt->fd = temp_socket;
+ if (listen_list) {
+ temp_elt->next = listen_list;
+ }
+ else {
+ temp_elt->next = NULL;
+ }
+ listen_list = temp_elt;
+ }
+ else {
+ fprintf(stderr,
+ "%s: could not malloc a listen_elt\n",
+ __FUNCTION__);
+ fflush(stderr);
+ exit(1);
+ }
+ }
+ else {
+ /* we consider a bind() or listen() failure a transient and try
+ the next address */
+ if (debug) {
+ fprintf(stderr,
+ "%s: warning: bind or listen call failure: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(stderr);
+ }
+ close(temp_socket);
+ }
+ local_res_temp = local_res_temp->ai_next;
+ }
+
+}
+
+void
+setup_listens(char name[], char port[], int af) {
+
+ int do_inet;
+ int no_name = 0;
+#ifdef AF_INET6
+ int do_inet6;
+#endif
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+
+ if (strcmp(name,"") == 0) {
+ no_name = 1;
+ switch (af) {
+ case AF_UNSPEC:
+ do_inet = 1;
+#ifdef AF_INET6
+ do_inet6 = 1;
+#endif
+ break;
+ case AF_INET:
+ do_inet = 1;
+#ifdef AF_INET6
+ do_inet6 = 0;
+#endif
+ break;
+#ifdef AF_INET6
+ case AF_INET6:
+ do_inet = 0;
+ do_inet6 = 1;
+ break;
+#endif
+ default:
+ do_inet = 1;
+ }
+ /* if we have IPv6, try that one first because it may be a superset */
+#ifdef AF_INET6
+ if (do_inet6)
+ create_listens("::0",port,AF_INET6);
+#endif
+ if (do_inet)
+ create_listens("0.0.0.0",port,AF_INET);
+ }
+ else {
+ create_listens(name,port,af);
+ }
+
+ if (listen_list) {
+ fprintf(stdout,
+ "Starting netserver with host '%s' port '%s' and family %s\n",
+ (no_name) ? "IN(6)ADDR_ANY" : name,
+ port,
+ inet_ftos(af));
+ fflush(stdout);
+ }
+ else {
+ fprintf(stderr,
+ "Unable to start netserver with '%s' port '%s' and family %s\n",
+ (no_name) ? "IN(6)ADDR_ANY" : name,
+ port,
+ inet_ftos(af));
+ fflush(stderr);
+ exit(1);
+ }
+}
+
+SOCKET
+set_fdset(struct listen_elt *list, fd_set *fdset) {
+
+ struct listen_elt *temp;
+ SOCKET max = INVALID_SOCKET;
+
+ FD_ZERO(fdset);
+
+ temp = list;
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter list %p fd_set %p\n",
+ __FUNCTION__,
+ list,
+ fdset);
+ fflush(where);
+ }
+
+ while (temp) {
+ if (temp->fd > max)
+ max = temp->fd;
+
+ if (debug) {
+ fprintf(where,
+ "setting %d in fdset\n",
+ temp->fd);
+ fflush(where);
+ }
+
+ FD_SET(temp->fd,fdset);
+
+ temp = temp->next;
+ }
+
+ return max;
+
+}
+
+void
+close_listens(struct listen_elt *list) {
+ struct listen_elt *temp;
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+ temp = list;
+
+ while (temp) {
+ close(temp->fd);
+ temp = temp->next;
+ }
+}
+
+static int
+recv_passphrase() {
+
+ /* may need to revisit the timeout. we only respond if there is an
+ error with receiving the passphrase */
+ if ((recv_request_timed_n(0,20) > 0) &&
+ (netperf_request.content.request_type == PASSPHRASE) &&
+ (!strcmp(passphrase,
+ (char *)netperf_request.content.test_specific_data))) {
+ /* it was okey dokey */
+ return 0;
+ }
+#if defined(SEND_PASSPHRASE_RESPONSE)
+ netperf_response.content.response_type = PASSPHRASE;
+ netperf_response.content.serv_errno = 403;
+ snprintf((char *)netperf_response.content.test_specific_data,
+ sizeof(netperf_response.content.test_specific_data),
+ "Sorry, unable to match with required passphrase\n");
+ send_response_n(0);
+#endif
+ fprintf(where,
+ "Unable to match required passphrase. Closing control connection\n");
+ fflush(where);
+
+ close(server_sock);
+ return -1;
+}
+
+/* This routine implements the "main event loop" of the netperf server
+ code. Code above it will have set-up the control connection so it
+ can just merrily go about its business, which is to "schedule"
+ performance tests on the server. */
+
+void
+process_requests()
+{
+
+ float temp_rate;
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+ /* if the netserver was started with a passphrase, look for it in
+ the first request to arrive. if there is no passphrase in the
+ first request we will end-up dumping the control connection. raj
+ 2012-01-23 */
+
+ if ((passphrase != NULL) && (recv_passphrase()))
+ return;
+
+ while (1) {
+
+ if (recv_request() <= 0) {
+ close(server_sock);
+ return;
+ }
+
+ switch (netperf_request.content.request_type) {
+
+ case DEBUG_ON:
+ netperf_response.content.response_type = DEBUG_OK;
+ if (!suppress_debug) {
+ debug++;
+
+ if (debug == 1) {
+ /* we just flipped-on debugging, dump the request because
+ recv_request/recv_request_n will not have dumped it as its
+ dump_request() call is conditional on debug being set. raj
+ 2011-07-08 */
+ dump_request();
+ }
+ }
+
+ send_response();
+ break;
+
+ case DEBUG_OFF:
+ if (debug)
+ debug--;
+ netperf_response.content.response_type = DEBUG_OK;
+ send_response();
+ /* we used to take the trouble to close the debug file, but SAF
+ asked a good question when he asked "Why?" and since I cannot
+ think of a good reason, I have removed the code. raj
+ 2011-07-08 */
+ break;
+
+ case DO_SYSINFO:
+ {
+ netperf_response.content.response_type = SYSINFO_RESPONSE;
+
+ snprintf((char *)netperf_response.content.test_specific_data,
+ sizeof(netperf_response.content.test_specific_data),
+ "%c%s%c%s%c%s%c%s",
+ ',',
+ "Deprecated",
+ ','
+, "Deprecated",
+ ',',
+ "Deprecated",
+ ',',
+ "Deprecated");
+
+ send_response_n(0);
+ break;
+ }
+
+ case CPU_CALIBRATE:
+ netperf_response.content.response_type = CPU_CALIBRATE;
+ temp_rate = calibrate_local_cpu(0.0);
+ bcopy((char *)&temp_rate,
+ (char *)netperf_response.content.test_specific_data,
+ sizeof(temp_rate));
+ bcopy((char *)&lib_num_loc_cpus,
+ (char *)netperf_response.content.test_specific_data +
+ sizeof(temp_rate),
+ sizeof(lib_num_loc_cpus));
+ if (debug) {
+ fprintf(where,
+ "netserver: sending CPU information: rate is %g num cpu %d\n",
+ temp_rate,
+ lib_num_loc_cpus);
+ fflush(where);
+ }
+
+ /* we need the cpu_start, cpu_stop in the looper case to kill
+ the child proceses raj 7/95 */
+
+#ifdef USE_LOOPER
+ cpu_start(1);
+ cpu_stop(1,&temp_rate);
+#endif /* USE_LOOPER */
+
+ send_response();
+ break;
+
+ case DO_TCP_STREAM:
+ recv_tcp_stream();
+ break;
+
+ case DO_TCP_MAERTS:
+ recv_tcp_maerts();
+ break;
+
+ case DO_TCP_RR:
+ recv_tcp_rr();
+ break;
+
+ case DO_TCP_CRR:
+ recv_tcp_conn_rr();
+ break;
+
+ case DO_TCP_CC:
+ recv_tcp_cc();
+ break;
+
+#ifdef DO_1644
+ case DO_TCP_TRR:
+ recv_tcp_tran_rr();
+ break;
+#endif /* DO_1644 */
+
+#ifdef DO_NBRR
+ case DO_TCP_NBRR:
+ recv_tcp_nbrr();
+ break;
+#endif /* DO_NBRR */
+
+ case DO_UDP_STREAM:
+ recv_udp_stream();
+ break;
+
+ case DO_UDP_RR:
+ recv_udp_rr();
+ break;
+
+#ifdef WANT_DLPI
+
+ case DO_DLPI_CO_RR:
+ recv_dlpi_co_rr();
+ break;
+
+ case DO_DLPI_CL_RR:
+ recv_dlpi_cl_rr();
+ break;
+
+ case DO_DLPI_CO_STREAM:
+ recv_dlpi_co_stream();
+ break;
+
+ case DO_DLPI_CL_STREAM:
+ recv_dlpi_cl_stream();
+ break;
+
+#endif /* WANT_DLPI */
+
+#ifdef WANT_UNIX
+
+ case DO_STREAM_STREAM:
+ recv_stream_stream();
+ break;
+
+ case DO_STREAM_RR:
+ recv_stream_rr();
+ break;
+
+ case DO_DG_STREAM:
+ recv_dg_stream();
+ break;
+
+ case DO_DG_RR:
+ recv_dg_rr();
+ break;
+
+#endif /* WANT_UNIX */
+
+#ifdef WANT_XTI
+ case DO_XTI_TCP_STREAM:
+ recv_xti_tcp_stream();
+ break;
+
+ case DO_XTI_TCP_RR:
+ recv_xti_tcp_rr();
+ break;
+
+ case DO_XTI_UDP_STREAM:
+ recv_xti_udp_stream();
+ break;
+
+ case DO_XTI_UDP_RR:
+ recv_xti_udp_rr();
+ break;
+
+#endif /* WANT_XTI */
+
+#ifdef WANT_SCTP
+ case DO_SCTP_STREAM:
+ recv_sctp_stream();
+ break;
+
+ case DO_SCTP_STREAM_MANY:
+ recv_sctp_stream_1toMany();
+ break;
+
+ case DO_SCTP_RR:
+ recv_sctp_rr();
+ break;
+
+ case DO_SCTP_RR_MANY:
+ recv_sctp_rr_1toMany();
+ break;
+#endif
+
+#ifdef WANT_SDP
+ case DO_SDP_STREAM:
+ recv_sdp_stream();
+ break;
+
+ case DO_SDP_MAERTS:
+ recv_sdp_maerts();
+ break;
+
+ case DO_SDP_RR:
+ recv_sdp_rr();
+ break;
+#endif
+
+#ifdef WANT_OMNI
+ case DO_OMNI:
+ recv_omni();
+ break;
+#endif
+
+ case PASSPHRASE:
+ if (debug) {
+ fprintf(where,"Ignoring an unexpected passphrase control message\n");
+ fflush(where);
+ }
+ break;
+
+ default:
+ fprintf(where,"unknown test number %d\n",
+ netperf_request.content.request_type);
+ fflush(where);
+ netperf_response.content.serv_errno=998;
+ send_response();
+ break;
+
+ }
+ }
+}
+
+/* the routine we call when we are going to spawn/fork/whatnot a child
+ process from the parent netserver daemon. raj 2011-07-08 */
+void
+spawn_child() {
+
+#if defined(HAVE_FORK)
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+
+ /* flush the usual suspects */
+ fflush(stdin);
+ fflush(stdout);
+ fflush(stderr);
+ fflush(where);
+
+ signal(SIGCLD,SIG_IGN);
+
+ switch (fork()) {
+ case -1:
+ fprintf(where,
+ "%s: fork() error %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(where);
+ exit(1);
+
+ case 0:
+ /* we are the child, but not of inetd. we don't know if we are
+ the child of a daemonized parent or not, so we still need to
+ worry about the standard file descriptors. raj 2011-07-11 */
+
+ close_listens(listen_list);
+ open_debug_file();
+
+ child = 1;
+ netperf_daemon = 0;
+ process_requests();
+ exit(0);
+ break;
+
+ default:
+ /* we are the parent, not a great deal to do here, but we may
+ want to reap some children */
+#if !defined(HAVE_SETSID)
+ /* Only call "waitpid()" if "setsid()" is not used. */
+ while(waitpid(-1, NULL, WNOHANG) > 0) {
+ if (debug) {
+ fprintf(where,
+ "%s: reaped a child process\n",
+ __FUNCTION__);
+ }
+ }
+#endif
+ break;
+ }
+
+#elif defined(WIN32)
+
+ BOOL b;
+ char *cmdline;
+ int cmdline_length;
+ int cmd_index;
+ PROCESS_INFORMATION pi;
+ STARTUPINFO si;
+ int i;
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+
+ /* create the cmdline array based on strlen(program) + 80 chars */
+ cmdline_length = strlen(program) + 80;
+ cmdline = malloc(cmdline_length + 1); // +1 for trailing null
+
+ memset(&si, 0 , sizeof(STARTUPINFO));
+ si.cb = sizeof(STARTUPINFO);
+
+ /* Pass the server_sock as stdin for the new process. Hopefully
+ this will continue to be created with the OBJ_INHERIT
+ attribute. */
+ si.hStdInput = (HANDLE)server_sock;
+ si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+ si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
+ si.dwFlags = STARTF_USESTDHANDLES;
+
+ /* Build cmdline for child process */
+ strcpy(cmdline, program);
+ cmd_index = strlen(cmdline);
+ if (verbosity > 1) {
+ cmd_index += snprintf(&cmdline[cmd_index],
+ cmdline_length - cmd_index,
+ " -v %d",
+ verbosity);
+ }
+ for (i=0; i < debug; i++) {
+ cmd_index += snprintf(&cmdline[cmd_index],
+ cmdline_length - cmd_index,
+ " -d");
+ }
+ cmd_index += snprintf(&cmdline[cmd_index],
+ cmdline_length - cmd_index,
+ " -I %x",
+ (int)(UINT_PTR)server_sock);
+
+ /* are these -i settings even necessary? the command line scanning
+ does not seem to do anything with them */
+ cmd_index += snprintf(&cmdline[cmd_index],
+ cmdline_length - cmd_index,
+ " -i %x",
+ (int)(UINT_PTR)server_control);
+ cmd_index += snprintf(&cmdline[cmd_index],
+ cmdline_length - cmd_index,
+ " -i %x",
+ (int)(UINT_PTR)where);
+
+ b = CreateProcess(NULL, /* Application Name */
+ cmdline,
+ NULL, /* Process security attributes */
+ NULL, /* Thread security attributes */
+ TRUE, /* Inherit handles */
+ 0, /* Creation flags
+ PROCESS_QUERY_INFORMATION, */
+ NULL, /* Enviornment */
+ NULL, /* Current directory */
+ &si, /* StartupInfo */
+ &pi);
+ if (!b)
+ {
+ perror("CreateProcessfailure: ");
+ free(cmdline); /* even though we exit :) */
+ exit(1);
+ }
+
+ /* We don't need the thread or process handles any more;
+ let them go away on their own timeframe. */
+
+ CloseHandle(pi.hThread);
+ CloseHandle(pi.hProcess);
+
+ /* the caller/parent will close server_sock */
+
+ free(cmdline);
+
+#else
+
+ fprintf(where,
+ "%s called on platform which cannot spawn children\n",
+ __FUNCTION__);
+ fflush(where);
+ exit(1);
+
+#endif /* HAVE_FORK */
+}
+
+void
+accept_connection(SOCKET listen_fd) {
+
+ struct sockaddr_storage peeraddr;
+ netperf_socklen_t peeraddrlen;
+#if defined(SO_KEEPALIVE)
+ int on = 1;
+#endif
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+ peeraddrlen = sizeof(peeraddr);
+
+ /* while server_control is only used by the WIN32 path, but why
+ bother ifdef'ing it? and besides, do we *really* need knowledge
+ of server_control in the WIN32 case? do we have to tell the
+ child about *all* the listen endpoints? raj 2011-07-08 */
+ server_control = listen_fd;
+
+ if ((server_sock = accept(listen_fd,
+ (struct sockaddr *)&peeraddr,
+ &peeraddrlen)) == INVALID_SOCKET) {
+ fprintf(where,
+ "%s: accept failure: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(where);
+ exit(1);
+ }
+
+#if defined(SO_KEEPALIVE)
+ /* we are not terribly concerned if this does not work, it is merely
+ duct tape added to belts and suspenders. raj 2011-07-08 */
+ setsockopt(server_sock,
+ SOL_SOCKET,
+ SO_KEEPALIVE,
+ (const char *)&on,
+ sizeof(on));
+#endif
+
+ if (spawn_on_accept) {
+ spawn_child();
+ /* spawn_child() only returns when we are the parent */
+ close(server_sock);
+ }
+ else {
+ process_requests();
+ }
+}
+
+void
+accept_connections() {
+
+ fd_set read_fds, write_fds, except_fds;
+ SOCKET high_fd, candidate;
+ int num_ready;
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+ while (1) {
+
+ FD_ZERO(&write_fds);
+ FD_ZERO(&except_fds);
+ high_fd = set_fdset(listen_list,&read_fds);
+
+#if !defined(WIN32)
+ num_ready = select(high_fd + 1,
+#else
+ num_ready = select(1,
+#endif
+ &read_fds,
+ &write_fds,
+ &except_fds,
+ NULL);
+
+ if (num_ready < 0) {
+ fprintf(where,
+ "%s: select failure: %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(where);
+ exit(1);
+ }
+
+ /* try to keep things simple */
+ candidate = 0;
+ while ((num_ready) && (candidate <= high_fd)) {
+ if (FD_ISSET(candidate,&read_fds)) {
+ accept_connection(candidate);
+ FD_CLR(candidate,&read_fds);
+ num_ready--;
+ }
+ else {
+ candidate++;
+ }
+ }
+ }
+}
+
+#ifndef WIN32
+#define SERVER_ARGS "DdfhL:n:Np:v:VZ:46"
+#else
+#define SERVER_ARGS "DdfhL:n:Np:v:VZ:46I:i:"
+#endif
+void
+scan_netserver_args(int argc, char *argv[]) {
+
+ int c;
+ char arg1[BUFSIZ], arg2[BUFSIZ];
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+ while ((c = getopt(argc, argv, SERVER_ARGS)) != EOF){
+ switch (c) {
+ case '?':
+ case 'h':
+ print_netserver_usage();
+ exit(1);
+ case 'd':
+ debug++;
+ suppress_debug = 0;
+ break;
+ case 'D':
+ /* perhaps one of these days we'll take an argument */
+ want_daemonize = 0;
+ not_inetd = 1;
+ break;
+ case 'f':
+ spawn_on_accept = 0;
+ not_inetd = 1;
+ break;
+#ifdef WIN32
+ case 'I':
+ child = TRUE;
+ break;
+ case 'i':
+ break;
+#endif
+ case 'L':
+ not_inetd = 1;
+ break_args_explicit(optarg,arg1,arg2);
+ if (arg1[0]) {
+ strncpy(local_host_name,arg1,sizeof(local_host_name));
+ }
+ if (arg2[0]) {
+ local_address_family = parse_address_family(arg2);
+ }
+ break;
+ case 'n':
+ shell_num_cpus = atoi(optarg);
+ if (shell_num_cpus > MAXCPUS) {
+ fprintf(stderr,
+ "netserver: This version can only support %d CPUs. Please"
+ "increase MAXCPUS in netlib.h and recompile.\n",
+ MAXCPUS);
+ fflush(stderr);
+ exit(1);
+ }
+ break;
+ case 'N':
+ suppress_debug = 1;
+ debug = 0;
+ break;
+ case 'p':
+ /* we want to open a listen socket at a specified port number */
+ strncpy(listen_port,optarg,sizeof(listen_port));
+ not_inetd = 1;
+ break;
+ case 'Z':
+ /* only copy as much of the passphrase as could fit in the
+ test-specific portion of a control message. Windows does not
+ seem to have a strndup() so just malloc and strncpy it. we
+ weren't checking the strndup() return so won't bother with
+ checking malloc(). we will though make certain we only
+ allocated it once in the event that someone puts -Z on the
+ command line more than once */
+ if (passphrase == NULL)
+ passphrase = malloc(sizeof(netperf_request.content.test_specific_data));
+ strncpy(passphrase,
+ optarg,
+ sizeof(netperf_request.content.test_specific_data));
+ passphrase[sizeof(netperf_request.content.test_specific_data) - 1] = '\0';
+ break;
+ case '4':
+ local_address_family = AF_INET;
+ break;
+ case '6':
+#if defined(AF_INET6)
+ local_address_family = AF_INET6;
+#else
+ local_address_family = AF_UNSPEC;
+#endif
+ break;
+ case 'v':
+ /* say how much to say */
+ verbosity = atoi(optarg);
+ break;
+ case 'V':
+ printf("Netperf version %s\n",NETPERF_VERSION);
+ exit(0);
+ break;
+
+ }
+ }
+}
+
+void
+daemonize() {
+#if defined(HAVE_FORK)
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+ /* flush the usual suspects */
+ fflush(stdin);
+ fflush(stdout);
+ fflush(stderr);
+
+ switch (fork()) {
+ case -1:
+ fprintf(stderr,
+ "%s: fork() error %s (errno %d)\n",
+ __FUNCTION__,
+ strerror(errno),
+ errno);
+ fflush(stderr);
+ exit(1);
+ case 0:
+
+ /* perhaps belt and suspenders, but if we dump core, perhaps
+ better to do so here. we won't worry about the call being
+ successful though. raj 2011-07-08 */
+ chdir(DEBUG_LOG_FILE_DIR);
+
+ /* we are the child. we should get a new "where" to match our new
+ pid */
+
+ open_debug_file();
+
+#ifdef HAVE_SETSID
+ setsid();
+#else
+ setpgrp();
+#endif /* HAVE_SETSID */
+
+ signal(SIGCLD, SIG_IGN);
+
+ /* ok, we can start accepting control connections now */
+ accept_connections();
+
+ default:
+ /* we are the parent, nothing to do but exit? */
+ exit(0);
+ }
+
+#else
+ fprintf(where,
+ "%s called on platform which cannot daemonize\n",
+ __FUNCTION__);
+ fflush(where);
+ exit(1);
+#endif /* HAVE_FORK */
+}
+
+static void
+check_if_inetd() {
+
+ if (debug) {
+ fprintf(where,
+ "%s: enter\n",
+ __FUNCTION__);
+ fflush(where);
+ }
+
+ if (not_inetd) {
+ return;
+ }
+ else {
+#if !defined(WIN32) && !defined(__VMS)
+ struct sockaddr_storage name;
+ netperf_socklen_t namelen;
+
+ namelen = sizeof(name);
+ if (getsockname(0,
+ (struct sockaddr *)&name,
+ &namelen) == SOCKET_ERROR) {
+ not_inetd = 1;
+ }
+ else {
+ not_inetd = 0;
+ child = 1;
+ }
+#endif
+ }
+}
+
+/* OK, so how does all this work you ask? Well, we are in a maze of
+ twisty options, all different. Netserver can be invoked as a child
+ of inetd or the VMS auxiliary server process, or a parent netserver
+ process. In those cases, we could/should follow the "child"
+ path. However, there are really two "child" paths through the
+ netserver code.
+
+ When this netserver is a child of a parent netserver in the
+ case of *nix, the child process will be created by a
+ spawn_child_process() in accept_connections() and will not hit the
+ "child" path here in main().
+
+ When this netserver is a child of a parent netserver in the case of
+ windows, the child process will have been spawned via a
+ Create_Process() call in spawn_child_process() in
+ accept_connections, but will flow through here again. We rely on
+ the scan_netserver_args() call to have noticed the magic option
+ that tells us we are a child process.
+
+ When this netserver is launched from the command line we will first
+ set-up the listen endpoint(s) for the controll connection. At that
+ point we decide if we want to and can become our own daemon, or
+ stay attached to the "terminal." When this happens under *nix, we
+ will again take a fork() path via daemonize() and will not come
+ back through main(). If we ever learn how to become our own daemon
+ under Windows, we will undoubtedly take a Create_Process() path
+ again and will come through main() once again - that is what the
+ "daemon" case here is all about.
+
+ It is hoped that this is all much clearer than the old spaghetti
+ code that netserver had become. raj 2011-07-11 */
+
+
+int _cdecl
+main(int argc, char *argv[]) {
+
+#ifdef WIN32
+ WSADATA wsa_data ;
+
+ /* Initialize the winsock lib do we still want version 2.2? */
+ if ( WSAStartup(MAKEWORD(2,2), &wsa_data) == SOCKET_ERROR ){
+ printf("WSAStartup() failed : %lu\n", GetLastError()) ;
+ return -1 ;
+ }
+#endif /* WIN32 */
+
+ /* Save away the program name */
+ program = (char *)malloc(strlen(argv[0]) + 1);
+ if (program == NULL) {
+ printf("malloc for program name failed!\n");
+ return -1 ;
+ }
+ strcpy(program, argv[0]);
+
+ init_netserver_globals();
+
+ netlib_init();
+
+ strncpy(local_host_name,"",sizeof(local_host_name));
+ local_address_family = AF_UNSPEC;
+ strncpy(listen_port,TEST_PORT,sizeof(listen_port));
+
+ scan_netserver_args(argc, argv);
+
+ check_if_inetd();
+
+ if (child) {
+ /* we are the child of either an inetd or parent netserver via
+ spawning (Windows) rather than fork()ing. if we were fork()ed
+ we would not be coming through this way. set_server_sock() must
+ be called before open_debug_file() or there is a chance that
+ we'll toast the descriptor when we do not wish it. */
+ set_server_sock();
+ open_debug_file();
+ process_requests();
+ }
+ else if (daemon_parent) {
+ /* we are the parent daemonized netserver
+ process. accept_connections() will decide if we want to spawn a
+ child process */
+ accept_connections();
+ }
+ else {
+ /* we are the top netserver process, so we have to create the
+ listen endpoint(s) and decide if we want to daemonize */
+ setup_listens(local_host_name,listen_port,local_address_family);
+ if (want_daemonize) {
+ daemonize();
+ }
+ accept_connections();
+ }
+
+ unlink_empty_debug_file();
+
+#ifdef WIN32
+ WSACleanup();
+#endif
+
+ return 0;
+
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-09 07:04:44 +0000