Home | History | Annotate | Download | only in netperf 
      1 /*
      2 
      3 	   Copyright (C) 1993-2007 Hewlett-Packard Company
      4                          ALL RIGHTS RESERVED.
      5 
      6   The enclosed software and documentation includes copyrighted works
      7   of Hewlett-Packard Co. For as long as you comply with the following
      8   limitations, you are hereby authorized to (i) use, reproduce, and
      9   modify the software and documentation, and to (ii) distribute the
     10   software and documentation, including modifications, for
     11   non-commercial purposes only.
     12 
     13   1.  The enclosed software and documentation is made available at no
     14       charge in order to advance the general development of
     15       high-performance networking products.
     16 
     17   2.  You may not delete any copyright notices contained in the
     18       software or documentation. All hard copies, and copies in
     19       source code or object code form, of the software or
     20       documentation (including modifications) must contain at least
     21       one of the copyright notices.
     22 
     23   3.  The enclosed software and documentation has not been subjected
     24       to testing and quality control and is not a Hewlett-Packard Co.
     25       product. At a future time, Hewlett-Packard Co. may or may not
     26       offer a version of the software and documentation as a product.
     27 
     28   4.  THE SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS".
     29       HEWLETT-PACKARD COMPANY DOES NOT WARRANT THAT THE USE,
     30       REPRODUCTION, MODIFICATION OR DISTRIBUTION OF THE SOFTWARE OR
     31       DOCUMENTATION WILL NOT INFRINGE A THIRD PARTY'S INTELLECTUAL
     32       PROPERTY RIGHTS. HP DOES NOT WARRANT THAT THE SOFTWARE OR
     33       DOCUMENTATION IS ERROR FREE. HP DISCLAIMS ALL WARRANTIES,
     34       EXPRESS AND IMPLIED, WITH REGARD TO THE SOFTWARE AND THE
     35       DOCUMENTATION. HP SPECIFICALLY DISCLAIMS ALL WARRANTIES OF
     36       MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
     37 
     38   5.  HEWLETT-PACKARD COMPANY WILL NOT IN ANY EVENT BE LIABLE FOR ANY
     39       DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
     40       (INCLUDING LOST PROFITS) RELATED TO ANY USE, REPRODUCTION,
     41       MODIFICATION, OR DISTRIBUTION OF THE SOFTWARE OR DOCUMENTATION.
     42 
     43 */
     44 
     45 #include "netperf_version.h"
     46 
     47 char	netserver_id[]="\
     48 @(#)netserver.c (c) Copyright 1993-2007 Hewlett-Packard Co. Version 2.4.3";
     49 
     50  /***********************************************************************/
     51  /*									*/
     52  /*	netserver.c							*/
     53  /*									*/
     54  /*	This is the server side code for the netperf test package. It	*/
     55  /* will operate either stand-alone, or as a child of inetd. In this	*/
     56  /* way, we insure that it can be installed on systems with or without	*/
     57  /* root permissions (editing inetd.conf). Essentially, this code is	*/
     58  /* the analog to the netsh.c code.					*/
     59  /*									*/
     60  /***********************************************************************/
     61 
     62 
     63 /************************************************************************/
     64 /*									*/
     65 /*	Global include files						*/
     66 /*									*/
     67 /************************************************************************/
     68 #ifdef HAVE_CONFIG_H
     69 #include "config.h"
     70 #endif
     71 
     72 #if HAVE_STRING_H
     73 # if !STDC_HEADERS && HAVE_MEMORY_H
     74 #  include <memory.h>
     75 # endif
     76 # include <string.h>
     77 #endif
     78 #if HAVE_STRINGS_H
     79 # include <strings.h>
     80 #endif
     81 #if HAVE_LIMITS_H
     82 # include <limits.h>
     83 #endif
     84 #include <sys/types.h>
     85 #include <stdio.h>
     86 #ifndef WIN32
     87 #include <errno.h>
     88 #include <signal.h>
     89 #endif
     90 #if !defined(WIN32) && !defined(__VMS)
     91 #include <sys/ipc.h>
     92 #endif /* !defined(WIN32) && !defined(__VMS) */
     93 #include <fcntl.h>
     94 #ifdef WIN32
     95 #include <time.h>
     96 #include <winsock2.h>
     97 #define netperf_socklen_t socklen_t
     98 /* we need to find some other way to decide to include ws2 */
     99 /* if you are trying to compile on Windows 2000 or NT 4 you will */
    100 /* probably have to define DONT_IPV6 */
    101 #ifndef DONT_IPV6
    102 #include <ws2tcpip.h>
    103 #endif  /* DONT_IPV6 */
    104 #include <windows.h>
    105 #define sleep(x) Sleep((x)*1000)
    106 #else
    107 #ifndef MPE
    108 #include <sys/time.h>
    109 #endif /* MPE */
    110 #include <sys/ioctl.h>
    111 #include <sys/socket.h>
    112 #include <sys/stat.h>
    113 #include <netinet/in.h>
    114 #include <netdb.h>
    115 #include <unistd.h>
    116 #ifndef DONT_WAIT
    117 #include <sys/wait.h>
    118 #endif /* DONT_WAIT */
    119 #endif /* WIN32 */
    120 #include <stdlib.h>
    121 #ifdef __VMS
    122 #include <tcpip$inetdef.h>
    123 #include <unixio.h>
    124 #endif /* __VMS */
    125 #include "netlib.h"
    126 #include "nettest_bsd.h"
    127 
    128 #ifdef WANT_UNIX
    129 #include "nettest_unix.h"
    130 #endif /* WANT_UNIX */
    131 
    132 #ifdef WANT_DLPI
    133 #include "nettest_dlpi.h"
    134 #endif /* WANT_DLPI */
    135 
    136 #ifdef WANT_SCTP
    137 #include "nettest_sctp.h"
    138 #endif
    139 
    140 #include "netsh.h"
    141 
    142 #ifndef DEBUG_LOG_FILE
    143 #ifndef WIN32
    144 #define DEBUG_LOG_FILE "/tmp/netperf.debug"
    145 #else
    146 #define DEBUG_LOG_FILE "c:\\temp\\netperf.debug"
    147 #endif  /* WIN32 */
    148 #endif /* DEBUG_LOG_FILE */
    149 
    150  /* some global variables */
    151 
    152 FILE	*afp;
    153 char    listen_port[10];
    154 extern	char	*optarg;
    155 extern	int	optind, opterr;
    156 
    157 #ifndef WIN32
    158 #define SERVER_ARGS "dL:n:p:v:V46"
    159 #else
    160 #define SERVER_ARGS "dL:n:p:v:V46I:i:"
    161 #endif
    162 
    163 /* perhaps one day we will use this as part of only opening a debug
    164    log file if debug is set, of course we have to be wary of the base
    165    use of "where" and so probably always need "where" pointing
    166    "somewhere" or other. */
    167 void
    168 open_debug_file()
    169 {
    170 #ifndef WIN32
    171 #ifndef PATH_MAX
    172 #define PATH_MAX MAX_PATH
    173 #endif
    174   char FileName[PATH_MAX];   /* for opening the debug log file */
    175   strcpy(FileName, DEBUG_LOG_FILE);
    176 
    177   if (where != NULL) fflush(where);
    178 
    179   snprintf(&FileName[strlen(FileName)], sizeof(FileName) - strlen(FileName), "_%d", getpid());
    180   if ((where = fopen(FileName, "w")) == NULL) {
    181     perror("netserver: debug file");
    182     exit(1);
    183   }
    184 
    185   chmod(FileName,0644);
    186 #endif
    187 
    188 }
    189  /* This routine implements the "main event loop" of the netperf	*/
    190  /* server code. Code above it will have set-up the control connection	*/
    191  /* so it can just merrily go about its business, which is to		*/
    192  /* "schedule" performance tests on the server.				*/
    193 
    194 void
    195 process_requests()
    196 {
    197 
    198   float	temp_rate;
    199 
    200   if (debug)    open_debug_file();
    201 
    202 
    203   while (1) {
    204     recv_request();
    205 
    206     switch (netperf_request.content.request_type) {
    207 
    208     case DEBUG_ON:
    209       netperf_response.content.response_type = DEBUG_OK;
    210       /*  dump_request already present in recv_request; redundant? */
    211       if (!debug) {
    212 	debug++;
    213 	open_debug_file();
    214 	dump_request();
    215       }
    216       send_response();
    217       break;
    218 
    219     case DEBUG_OFF:
    220       if (debug)
    221 	debug--;
    222       netperf_response.content.response_type = DEBUG_OK;
    223       send_response();
    224       /* +SAF why??? */
    225       if (!debug)
    226       {
    227 	fclose(where);
    228 #if !defined(WIN32) && !defined(MPE) && !defined(__VMS)
    229 	/* For Unix: reopen the debug write file descriptor to "/dev/null" */
    230 	/* and redirect stdout to it.					   */
    231 	fflush (stdout);
    232 	where = fopen ("/dev/null", "w");
    233 	if (where == NULL)
    234 	{
    235 	  perror ("netserver: reopening debug fp for writing: /dev/null");
    236 	  exit   (1);
    237 	}
    238 	if (close (STDOUT_FILENO) == -1)
    239 	{
    240 	  perror ("netserver: closing stdout file descriptor");
    241 	  exit   (1);
    242 	}
    243 	if (dup (fileno (where))  == -1)
    244 	{
    245 	  perror ("netserver: duplicate /dev/null write file descr. to stdout");
    246 	  exit   (1);
    247 	}
    248 #endif /* !WIN32 !MPE !__VMS */
    249       }
    250       break;
    251 
    252     case CPU_CALIBRATE:
    253       netperf_response.content.response_type = CPU_CALIBRATE;
    254       temp_rate = calibrate_local_cpu(0.0);
    255       bcopy((char *)&temp_rate,
    256 	    (char *)netperf_response.content.test_specific_data,
    257 	    sizeof(temp_rate));
    258       bcopy((char *)&lib_num_loc_cpus,
    259 	    (char *)netperf_response.content.test_specific_data + sizeof(temp_rate),
    260 	    sizeof(lib_num_loc_cpus));
    261       if (debug) {
    262 	fprintf(where,"netserver: sending CPU information:");
    263 	fprintf(where,"rate is %g num cpu %d\n",temp_rate,lib_num_loc_cpus);
    264 	fflush(where);
    265       }
    266 
    267       /* we need the cpu_start, cpu_stop in the looper case to kill the */
    268       /* child proceses raj 7/95 */
    269 
    270 #ifdef USE_LOOPER
    271       cpu_start(1);
    272       cpu_stop(1,&temp_rate);
    273 #endif /* USE_LOOPER */
    274 
    275       send_response();
    276       break;
    277 
    278     case DO_TCP_STREAM:
    279       recv_tcp_stream();
    280       break;
    281 
    282     case DO_TCP_MAERTS:
    283       recv_tcp_maerts();
    284       break;
    285 
    286     case DO_TCP_RR:
    287       recv_tcp_rr();
    288       break;
    289 
    290     case DO_TCP_CRR:
    291       recv_tcp_conn_rr();
    292       break;
    293 
    294     case DO_TCP_CC:
    295       recv_tcp_cc();
    296       break;
    297 
    298 #ifdef DO_1644
    299     case DO_TCP_TRR:
    300       recv_tcp_tran_rr();
    301       break;
    302 #endif /* DO_1644 */
    303 
    304 #ifdef DO_NBRR
    305     case DO_TCP_NBRR:
    306       recv_tcp_nbrr();
    307       break;
    308 #endif /* DO_NBRR */
    309 
    310     case DO_UDP_STREAM:
    311       recv_udp_stream();
    312       break;
    313 
    314     case DO_UDP_RR:
    315       recv_udp_rr();
    316       break;
    317 
    318 #ifdef WANT_DLPI
    319 
    320     case DO_DLPI_CO_RR:
    321       recv_dlpi_co_rr();
    322       break;
    323 
    324     case DO_DLPI_CL_RR:
    325       recv_dlpi_cl_rr();
    326       break;
    327 
    328     case DO_DLPI_CO_STREAM:
    329       recv_dlpi_co_stream();
    330       break;
    331 
    332     case DO_DLPI_CL_STREAM:
    333       recv_dlpi_cl_stream();
    334       break;
    335 
    336 #endif /* WANT_DLPI */
    337 
    338 #ifdef WANT_UNIX
    339 
    340     case DO_STREAM_STREAM:
    341       recv_stream_stream();
    342       break;
    343 
    344     case DO_STREAM_RR:
    345       recv_stream_rr();
    346       break;
    347 
    348     case DO_DG_STREAM:
    349       recv_dg_stream();
    350       break;
    351 
    352     case DO_DG_RR:
    353       recv_dg_rr();
    354       break;
    355 
    356 #endif /* WANT_UNIX */
    357 
    358 #ifdef WANT_XTI
    359     case DO_XTI_TCP_STREAM:
    360       recv_xti_tcp_stream();
    361       break;
    362 
    363     case DO_XTI_TCP_RR:
    364       recv_xti_tcp_rr();
    365       break;
    366 
    367     case DO_XTI_UDP_STREAM:
    368       recv_xti_udp_stream();
    369       break;
    370 
    371     case DO_XTI_UDP_RR:
    372       recv_xti_udp_rr();
    373       break;
    374 
    375 #endif /* WANT_XTI */
    376 
    377 #ifdef WANT_SCTP
    378     case DO_SCTP_STREAM:
    379       recv_sctp_stream();
    380       break;
    381 
    382     case DO_SCTP_STREAM_MANY:
    383       recv_sctp_stream_1toMany();
    384       break;
    385 
    386     case DO_SCTP_RR:
    387       recv_sctp_rr();
    388       break;
    389 
    390     case DO_SCTP_RR_MANY:
    391       recv_sctp_rr_1toMany();
    392       break;
    393 #endif
    394 
    395 #ifdef WANT_SDP
    396     case DO_SDP_STREAM:
    397       recv_sdp_stream();
    398       break;
    399 
    400     case DO_SDP_MAERTS:
    401       recv_sdp_maerts();
    402       break;
    403 
    404     case DO_SDP_RR:
    405       recv_sdp_rr();
    406       break;
    407 #endif
    408 
    409     default:
    410       fprintf(where,"unknown test number %d\n",
    411 	      netperf_request.content.request_type);
    412       fflush(where);
    413       netperf_response.content.serv_errno=998;
    414       send_response();
    415       break;
    416 
    417     }
    418   }
    419 }
    420 
    421 /*
    422  set_up_server()
    423 
    424  set-up the server listen socket. we only call this routine if the
    425  user has specified a port number on the command line or we believe we
    426  are not a child of inetd or its platform-specific equivalent */
    427 
    428 /*KC*/
    429 
    430 void
    431 set_up_server(char hostname[], char port[], int af)
    432 {
    433 
    434   struct addrinfo     hints;
    435   struct addrinfo     *local_res;
    436   struct addrinfo     *local_res_temp;
    437 
    438   struct sockaddr_storage     peeraddr;
    439   netperf_socklen_t                 peeraddr_len = sizeof(peeraddr);
    440 
    441   SOCKET server_control;
    442   int on=1;
    443   int count;
    444   int error;
    445   int not_listening;
    446 
    447 #if !defined(WIN32) && !defined(MPE) && !defined(__VMS)
    448   FILE *rd_null_fp;    /* Used to redirect from "/dev/null". */
    449   FILE *wr_null_fp;    /* Used to redirect to   "/dev/null". */
    450 #endif /* !WIN32 !MPE !__VMS */
    451 
    452   if (debug) {
    453     fprintf(stderr,
    454             "set_up_server called with host '%s' port '%s' remfam %d\n",
    455             hostname,
    456 	    port,
    457             af);
    458     fflush(stderr);
    459   }
    460 
    461   memset(&hints,0,sizeof(hints));
    462   hints.ai_family = af;
    463   hints.ai_socktype = SOCK_STREAM;
    464   hints.ai_protocol = IPPROTO_TCP;
    465   hints.ai_flags = AI_PASSIVE;
    466 
    467   count = 0;
    468   do {
    469     error = getaddrinfo((char *)hostname,
    470                         (char *)port,
    471                         &hints,
    472                         &local_res);
    473     count += 1;
    474     if (error == EAI_AGAIN) {
    475       if (debug) {
    476         fprintf(stderr,"Sleeping on getaddrinfo EAI_AGAIN\n");
    477         fflush(stderr);
    478       }
    479       sleep(1);
    480     }
    481   } while ((error == EAI_AGAIN) && (count <= 5));
    482 
    483   if (error) {
    484     fprintf(stderr,
    485 	    "set_up_server: could not resolve remote '%s' port '%s' af %d",
    486 	    hostname,
    487 	    port,
    488 	    af);
    489     fprintf(stderr,"\n\tgetaddrinfo returned %d %s\n",
    490 	    error,
    491 	    gai_strerror(error));
    492     exit(-1);
    493   }
    494 
    495   if (debug) {
    496     dump_addrinfo(stderr, local_res, hostname, port, af);
    497   }
    498 
    499   not_listening = 1;
    500   local_res_temp = local_res;
    501 
    502   while((local_res_temp != NULL) && (not_listening)) {
    503 
    504     fprintf(stderr,
    505 	    "Starting netserver at port %s\n",
    506 	    port);
    507 
    508     server_control = socket(local_res_temp->ai_family,SOCK_STREAM,0);
    509 
    510     if (server_control == INVALID_SOCKET) {
    511       perror("set_up_server could not allocate a socket");
    512       exit(-1);
    513     }
    514 
    515     /* happiness and joy, keep going */
    516     if (setsockopt(server_control,
    517 		   SOL_SOCKET,
    518 		   SO_REUSEADDR,
    519 		   (char *)&on ,
    520 		   sizeof(on)) == SOCKET_ERROR) {
    521       if (debug) {
    522 	perror("warning: set_up_server could not set SO_REUSEADDR");
    523       }
    524     }
    525     /* still happy and joyful */
    526 
    527     if ((bind (server_control,
    528 	       local_res_temp->ai_addr,
    529 	       local_res_temp->ai_addrlen) != SOCKET_ERROR) &&
    530 	(listen (server_control,5) != SOCKET_ERROR))  {
    531       not_listening = 0;
    532       break;
    533     }
    534     else {
    535       /* we consider a bind() or listen() failure a transient and try
    536 	 the next address */
    537       if (debug) {
    538 	perror("warning: set_up_server failed a bind or listen call\n");
    539       }
    540       local_res_temp = local_res_temp->ai_next;
    541       continue;
    542     }
    543   }
    544 
    545   if (not_listening) {
    546     fprintf(stderr,
    547 	    "set_up_server could not establish a listen endpoint for %s port %s with family %s\n",
    548 	    host_name,
    549 	    port,
    550 	    inet_ftos(af));
    551     fflush(stderr);
    552     exit(-1);
    553   }
    554   else {
    555     printf("Starting netserver at hostname %s port %s and family %s\n",
    556 	   hostname,
    557 	   port,
    558 	   inet_ftos(af));
    559   }
    560 
    561   /*
    562     setpgrp();
    563     */
    564 
    565 #if !defined(WIN32) && !defined(MPE) && !defined(__VMS)
    566   /* Flush the standard I/O file descriptors before forking. */
    567   fflush (stdin);
    568   fflush (stdout);
    569   fflush (stderr);
    570   switch (fork())
    571     {
    572     case -1:
    573       perror("netperf server error");
    574       exit(1);
    575 
    576     case 0:
    577       /* Redirect stdin from "/dev/null". */
    578       rd_null_fp = fopen ("/dev/null", "r");
    579       if (rd_null_fp == NULL)
    580       {
    581 	perror ("netserver: opening for reading: /dev/null");
    582 	exit   (1);
    583       }
    584       if (close (STDIN_FILENO) == -1)
    585       {
    586 	perror ("netserver: closing stdin file descriptor");
    587 	exit   (1);
    588       }
    589       if (dup (fileno (rd_null_fp)) == -1)
    590       {
    591 	perror ("netserver: duplicate /dev/null read file descr. to stdin");
    592 	exit   (1);
    593       }
    594 
    595       /* Redirect stdout to the debug write file descriptor. */
    596       if (close (STDOUT_FILENO) == -1)
    597       {
    598 	perror ("netserver: closing stdout file descriptor");
    599 	exit   (1);
    600       }
    601       if (dup (fileno (where))  == -1)
    602       {
    603 	perror ("netserver: duplicate the debug write file descr. to stdout");
    604 	exit   (1);
    605       }
    606 
    607       /* Redirect stderr to "/dev/null". */
    608       wr_null_fp = fopen ("/dev/null", "w");
    609       if (wr_null_fp == NULL)
    610       {
    611 	perror ("netserver: opening for writing: /dev/null");
    612 	exit   (1);
    613       }
    614       if (close (STDERR_FILENO) == -1)
    615       {
    616 	perror ("netserver: closing stderr file descriptor");
    617 	exit   (1);
    618       }
    619       if (dup (fileno (wr_null_fp))  == -1)
    620       {
    621 	perror ("netserver: dupicate /dev/null write file descr. to stderr");
    622 	exit   (1);
    623       }
    624 
    625 #ifndef NO_SETSID
    626       setsid();
    627 #else
    628       setpgrp();
    629 #endif /* NO_SETSID */
    630 
    631  /* some OS's have SIGCLD defined as SIGCHLD */
    632 #ifndef SIGCLD
    633 #define SIGCLD SIGCHLD
    634 #endif /* SIGCLD */
    635 
    636       signal(SIGCLD, SIG_IGN);
    637 
    638 #endif /* !WIN32 !MPE !__VMS */
    639 
    640       for (;;)
    641 	{
    642 	  if ((server_sock=accept(server_control,
    643 				  (struct sockaddr *)&peeraddr,
    644 				  &peeraddr_len)) == INVALID_SOCKET)
    645 	    {
    646 	      printf("server_control: accept failed errno %d\n",errno);
    647 	      exit(1);
    648 	    }
    649 #if defined(MPE) || defined(__VMS)
    650 	  /*
    651 	   * Since we cannot fork this process , we cant fire any threads
    652 	   * as they all share the same global data . So we better allow
    653 	   * one request at at time
    654 	   */
    655 	  process_requests() ;
    656 #elif WIN32
    657 		{
    658 			BOOL b;
    659 			char cmdline[80];
    660 			PROCESS_INFORMATION pi;
    661 			STARTUPINFO si;
    662 			int i;
    663 
    664 			memset(&si, 0 , sizeof(STARTUPINFO));
    665 			si.cb = sizeof(STARTUPINFO);
    666 
    667 			/* Pass the server_sock as stdin for the new process. */
    668 			/* Hopefully this will continue to be created with the OBJ_INHERIT attribute. */
    669 			si.hStdInput = (HANDLE)server_sock;
    670 			si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    671 			si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
    672 			si.dwFlags = STARTF_USESTDHANDLES;
    673 
    674 			/* Build cmdline for child process */
    675 			strcpy(cmdline, program);
    676 			if (verbosity > 1) {
    677 				snprintf(&cmdline[strlen(cmdline)], sizeof(cmdline) - strlen(cmdline), " -v %d", verbosity);
    678 			}
    679 			for (i=0; i < debug; i++) {
    680 				snprintf(&cmdline[strlen(cmdline)], sizeof(cmdline) - strlen(cmdline), " -d");
    681 			}
    682 			snprintf(&cmdline[strlen(cmdline)], sizeof(cmdline) - strlen(cmdline), " -I %x", (int)(UINT_PTR)server_sock);
    683 			snprintf(&cmdline[strlen(cmdline)], sizeof(cmdline) - strlen(cmdline), " -i %x", (int)(UINT_PTR)server_control);
    684 			snprintf(&cmdline[strlen(cmdline)], sizeof(cmdline) - strlen(cmdline), " -i %x", (int)(UINT_PTR)where);
    685 
    686 			b = CreateProcess(NULL,	 /* Application Name */
    687 					cmdline,
    688 					NULL,    /* Process security attributes */
    689 					NULL,    /* Thread security attributes */
    690 					TRUE,    /* Inherit handles */
    691 					0,	   /* Creation flags  PROCESS_QUERY_INFORMATION,  */
    692 					NULL,    /* Enviornment */
    693 					NULL,    /* Current directory */
    694 					&si,	   /* StartupInfo */
    695 					&pi);
    696 			if (!b)
    697 			{
    698 				perror("CreateProcessfailure: ");
    699 				exit(1);
    700 			}
    701 
    702 			/* We don't need the thread or process handles any more; let them */
    703 			/* go away on their own timeframe. */
    704 
    705 			CloseHandle(pi.hThread);
    706 			CloseHandle(pi.hProcess);
    707 
    708 			/* And close the server_sock since the child will own it. */
    709 
    710 			close(server_sock);
    711 		}
    712 #else
    713       signal(SIGCLD, SIG_IGN);
    714 
    715 	  switch (fork())
    716 	    {
    717 	    case -1:
    718 	      /* something went wrong */
    719 	      exit(1);
    720 	    case 0:
    721 	      /* we are the child process */
    722 	      close(server_control);
    723 	      process_requests();
    724 	      exit(0);
    725 	      break;
    726 	    default:
    727 	      /* we are the parent process */
    728 	      close(server_sock);
    729 	      /* we should try to "reap" some of our children. on some */
    730 	      /* systems they are being left as defunct processes. we */
    731 	      /* will call waitpid, looking for any child process, */
    732 	      /* with the WNOHANG feature. when waitpid return a zero, */
    733 	      /* we have reaped all the children there are to reap at */
    734 	      /* the moment, so it is time to move on. raj 12/94 */
    735 #ifndef DONT_WAIT
    736 #ifdef NO_SETSID
    737 	      /* Only call "waitpid()" if "setsid()" is not used. */
    738 	      while(waitpid(-1, NULL, WNOHANG) > 0) { }
    739 #endif /* NO_SETSID */
    740 #endif /* DONT_WAIT */
    741 	      break;
    742 	    }
    743 #endif /* !WIN32 !MPE !__VMS */
    744 	} /*for*/
    745 #if !defined(WIN32) && !defined(MPE) && !defined(__VMS)
    746       break; /*case 0*/
    747 
    748     default:
    749       exit (0);
    750 
    751     }
    752 #endif /* !WIN32 !MPE !__VMS */
    753 }
    754 
    755 #ifdef WIN32
    756 
    757   /* With Win2003, WinNT's POSIX subsystem is gone and hence so is */
    758   /* fork. */
    759 
    760   /* But hopefully the kernel support will continue to exist for some */
    761   /* time. */
    762 
    763   /* We are not counting on the child address space copy_on_write */
    764   /* support, since it isn't exposed except through the NT native APIs */
    765   /* (which is not public). */
    766 
    767   /* We will try to use the InheritHandles flag in CreateProcess.  It */
    768   /* is in the public API, though it is documented as "must be FALSE". */
    769 
    770   /* So where we would have forked, we will now create a new process. */
    771   /* I have added a set of command line switches to specify a list of */
    772   /* handles that the child should close since they shouldn't have */
    773   /* been inherited ("-i#"), and a single switch to specify the handle */
    774   /* for the server_sock ("I#"). */
    775 
    776   /* A better alternative would be to re-write NetPerf to be */
    777   /* multi-threaded; i.e., move all of the various NetPerf global */
    778   /* variables in to thread specific structures.  But this is a bigger */
    779   /* effort than I want to tackle at this time.  (And I doubt that the */
    780   /* HP-UX author sees value in this effort). */
    781 
    782 #endif
    783 
    784 int _cdecl
    785 main(int argc, char *argv[])
    786 {
    787 
    788   int	c;
    789   int   not_inetd = 0;
    790 #ifdef WIN32
    791   BOOL  child = FALSE;
    792 #endif
    793   char arg1[BUFSIZ], arg2[BUFSIZ];
    794 #ifndef PATH_MAX
    795 #define PATH_MAX MAX_PATH
    796 #endif
    797   char FileName[PATH_MAX];   /* for opening the debug log file */
    798 
    799   struct sockaddr name;
    800   netperf_socklen_t namelen = sizeof(name);
    801 
    802 
    803 #ifdef WIN32
    804 	WSADATA	wsa_data ;
    805 
    806 	/* Initialize the winsock lib ( version 2.2 ) */
    807 	if ( WSAStartup(MAKEWORD(2,2), &wsa_data) == SOCKET_ERROR ){
    808 		printf("WSAStartup() failed : %d\n", GetLastError()) ;
    809 		return 1 ;
    810 	}
    811 #endif /* WIN32 */
    812 
    813 	/* Save away the program name */
    814 	program = (char *)malloc(strlen(argv[0]) + 1);
    815 	if (program == NULL) {
    816 		printf("malloc(%d) failed!\n", strlen(argv[0]) + 1);
    817 		return 1 ;
    818 	}
    819 	strcpy(program, argv[0]);
    820 
    821   netlib_init();
    822 
    823   /* Scan the command line to see if we are supposed to set-up our own */
    824   /* listen socket instead of relying on inetd. */
    825 
    826   /* first set a copy of initial values */
    827   strncpy(local_host_name,"0.0.0.0",sizeof(local_host_name));
    828   local_address_family = AF_UNSPEC;
    829   strncpy(listen_port,TEST_PORT,sizeof(listen_port));
    830 
    831   while ((c = getopt(argc, argv, SERVER_ARGS)) != EOF) {
    832     switch (c) {
    833     case '?':
    834     case 'h':
    835       print_netserver_usage();
    836       exit(1);
    837     case 'd':
    838       /* we want to set the debug file name sometime */
    839       debug++;
    840       break;
    841     case 'L':
    842       not_inetd = 1;
    843       break_args_explicit(optarg,arg1,arg2);
    844       if (arg1[0]) {
    845 	strncpy(local_host_name,arg1,sizeof(local_host_name));
    846       }
    847       if (arg2[0]) {
    848 	local_address_family = parse_address_family(arg2);
    849 	/* if only the address family was set, we may need to set the
    850 	   local_host_name accordingly. since our defaults are IPv4
    851 	   this should only be necessary if we have IPv6 support raj
    852 	   2005-02-07 */
    853 #if defined (AF_INET6)
    854 	if (!arg1[0]) {
    855 	  strncpy(local_host_name,"::0",sizeof(local_host_name));
    856 	}
    857 #endif
    858       }
    859       break;
    860     case 'n':
    861       shell_num_cpus = atoi(optarg);
    862       if (shell_num_cpus > MAXCPUS) {
    863 	fprintf(stderr,
    864 		"netserver: This version can only support %d CPUs. Please",
    865 		MAXCPUS);
    866 	fprintf(stderr,
    867 		"           increase MAXCPUS in netlib.h and recompile.\n");
    868 	fflush(stderr);
    869 	exit(1);
    870       }
    871       break;
    872     case 'p':
    873       /* we want to open a listen socket at a */
    874       /* specified port number */
    875       strncpy(listen_port,optarg,sizeof(listen_port));
    876       not_inetd = 1;
    877       break;
    878     case '4':
    879       local_address_family = AF_INET;
    880       break;
    881     case '6':
    882 #if defined(AF_INET6)
    883       local_address_family = AF_INET6;
    884       strncpy(local_host_name,"::0",sizeof(local_host_name));
    885 #else
    886       local_address_family = AF_UNSPEC;
    887 #endif
    888       break;
    889     case 'v':
    890       /* say how much to say */
    891       verbosity = atoi(optarg);
    892       break;
    893     case 'V':
    894       printf("Netperf version %s\n",NETPERF_VERSION);
    895       exit(0);
    896       break;
    897 #ifdef WIN32
    898 /*+*+SAF */
    899 	case 'I':
    900 		child = TRUE;
    901 		/* This is the handle we expect to inherit. */
    902 		/*+*+SAF server_sock = (HANDLE)atoi(optarg); */
    903 		break;
    904 	case 'i':
    905 		/* This is a handle we should NOT inherit. */
    906 		/*+*+SAF CloseHandle((HANDLE)atoi(optarg)); */
    907 		break;
    908 #endif
    909 
    910     }
    911   }
    912 
    913   /* +*+SAF I need a better way to find inherited handles I should close! */
    914   /* +*+SAF Use DuplicateHandle to force inheritable attribute (or reset it)? */
    915 
    916 /*  unlink(DEBUG_LOG_FILE); */
    917 
    918   strcpy(FileName, DEBUG_LOG_FILE);
    919 
    920 #ifndef WIN32
    921   snprintf(&FileName[strlen(FileName)], sizeof(FileName) - strlen(FileName), "_%d", getpid());
    922   if ((where = fopen(FileName, "w")) == NULL) {
    923     perror("netserver: debug file");
    924     exit(1);
    925   }
    926 #else
    927   {
    928 
    929     if (child) {
    930       snprintf(&FileName[strlen(FileName)], sizeof(FileName) - strlen(FileName), "_%x", getpid());
    931     }
    932 
    933     /* Hopefully, by closing stdout & stderr, the subsequent
    934        fopen calls will get mapped to the correct std handles. */
    935     fclose(stdout);
    936 
    937     if ((where = fopen(FileName, "w")) == NULL) {
    938       perror("netserver: fopen of debug file as new stdout failed!");
    939       exit(1);
    940     }
    941 
    942     fclose(stderr);
    943 
    944     if ((where = fopen(FileName, "w")) == NULL) {
    945       fprintf(stdout, "fopen of debug file as new stderr failed!\n");
    946       exit(1);
    947     }
    948   }
    949 #endif
    950 
    951 #ifndef WIN32
    952   chmod(DEBUG_LOG_FILE,0644);
    953 #endif
    954 
    955 #if WIN32
    956   if (child) {
    957 	  server_sock = (SOCKET)GetStdHandle(STD_INPUT_HANDLE);
    958   }
    959 #endif
    960 
    961   /* if we are not a child of an inetd or the like, then we should
    962    open a socket and hang listens off of it. otherwise, we should go
    963    straight into processing requests. the do_listen() routine will sit
    964    in an infinite loop accepting connections and forking child
    965    processes. the child processes will call process_requests */
    966 
    967   /* If fd 0 is not a socket then assume we're not being called */
    968   /* from inetd and start server socket on the default port. */
    969   /* this enhancement comes from vwelch (at) ncsa.uiuc.edu (Von Welch) */
    970   if (not_inetd) {
    971     /* the user specified a port number on the command line */
    972     set_up_server(local_host_name,listen_port,local_address_family);
    973   }
    974 #ifdef WIN32
    975   /* OK, with Win2003 WinNT's POSIX subsystem is gone, and hence so is */
    976   /* fork.  But hopefully the kernel support will continue to exist */
    977   /* for some time.  We are not counting on the address space */
    978   /* copy_on_write support, since it isn't exposed except through the */
    979   /* NT native APIs (which are not public).  We will try to use the */
    980   /* InheritHandles flag in CreateProcess though since this is public */
    981   /* and is used for more than just POSIX so hopefully it won't go */
    982   /* away. */
    983   else if (TRUE) {
    984     if (child) {
    985       process_requests();
    986     } else {
    987       strncpy(listen_port,TEST_PORT,sizeof(listen_port));
    988       set_up_server(local_host_name,listen_port,local_address_family);
    989     }
    990   }
    991 #endif
    992 #if !defined(__VMS)
    993   else if (getsockname(0, &name, &namelen) == SOCKET_ERROR) {
    994     /* we may not be a child of inetd */
    995     if (errno == ENOTSOCK) {
    996       strncpy(listen_port,TEST_PORT,sizeof(listen_port));
    997       set_up_server(local_host_name,listen_port,local_address_family);
    998     }
    999   }
   1000 #endif /* !defined(__VMS) */
   1001   else {
   1002     /* we are probably a child of inetd, or are being invoked via the
   1003        VMS auxilliarly server mechanism */
   1004 #if !defined(__VMS)
   1005     server_sock = 0;
   1006 #else
   1007     if ( (server_sock = socket(TCPIP$C_AUXS, SOCK_STREAM, 0)) == INVALID_SOCKET )
   1008     {
   1009       perror("Failed to grab aux server socket" );
   1010       exit(1);
   1011     }
   1012 
   1013 #endif /* !defined(__VMS) */
   1014     process_requests();
   1015   }
   1016 #ifdef WIN32
   1017 	/* Cleanup the winsock lib */
   1018 	WSACleanup();
   1019 #endif
   1020 
   1021   return(0);
   1022 }
   1023