diff options
Diffstat (limited to 'netlib.h')
| -rw-r--r-- | netlib.h | 621 |
1 files changed, 621 insertions, 0 deletions
diff --git a/netlib.h b/netlib.h new file mode 100644 index 0000000..5b6900e --- /dev/null +++ b/netlib.h @@ -0,0 +1,621 @@ +/* + Copyright (C) 1993-2005 Hewlett-Packard Company +*/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#if defined(HAVE_SYS_SOCKET_H) +# include <sys/socket.h> +#endif +#if defined(HAVE_NETDB_H) +# include <netdb.h> +#endif +#if !defined(HAVE_GETADDRINFO) || !defined(HAVE_GETNAMEINFO) +# include "missing/getaddrinfo.h" +#endif + +#define PAD_TIME 4 +/* library routine specifc defines */ +#define MAXSPECDATA 62 /* how many ints worth of data */ + /* can tests send... */ +#define MAXTIMES 4 /* how many times may we loop */ + /* to calibrate */ +#define MAXCPUS 256 /* how many CPU's can we track */ +#define MAXMESSAGESIZE 65536 +#define MAXALIGNMENT 16384 +#define MAXOFFSET 4096 +#define DATABUFFERLEN MAXMESSAGESIZE+MAXALIGNMENT+MAXOFFSET + +#define DEBUG_ON 1 +#define DEBUG_OFF 2 +#define DEBUG_OK 3 +#define NODE_IDENTIFY 4 +#define CPU_CALIBRATE 5 + +#define DO_TCP_STREAM 10 +#define TCP_STREAM_RESPONSE 11 +#define TCP_STREAM_RESULTS 12 + +#define DO_TCP_RR 13 +#define TCP_RR_RESPONSE 14 +#define TCP_RR_RESULTS 15 + +#define DO_UDP_STREAM 16 +#define UDP_STREAM_RESPONSE 17 +#define UDP_STREAM_RESULTS 18 + +#define DO_UDP_RR 19 +#define UDP_RR_RESPONSE 20 +#define UDP_RR_RESULTS 21 + +#define DO_DLPI_CO_STREAM 22 +#define DLPI_CO_STREAM_RESPONSE 23 +#define DLPI_CO_STREAM_RESULTS 24 + +#define DO_DLPI_CO_RR 25 +#define DLPI_CO_RR_RESPONSE 26 +#define DLPI_CO_RR_RESULTS 27 + +#define DO_DLPI_CL_STREAM 28 +#define DLPI_CL_STREAM_RESPONSE 29 +#define DLPI_CL_STREAM_RESULTS 30 + +#define DO_DLPI_CL_RR 31 +#define DLPI_CL_RR_RESPONSE 32 +#define DLPI_CL_RR_RESULTS 33 + +#define DO_TCP_CRR 34 +#define TCP_CRR_RESPONSE 35 +#define TCP_CRR_RESULTS 36 + +#define DO_STREAM_STREAM 37 +#define STREAM_STREAM_RESPONSE 38 +#define STREAM_STREAM_RESULTS 39 + +#define DO_STREAM_RR 40 +#define STREAM_RR_RESPONSE 41 +#define STREAM_RR_RESULTS 42 + +#define DO_DG_STREAM 43 +#define DG_STREAM_RESPONSE 44 +#define DG_STREAM_RESULTS 45 + +#define DO_DG_RR 46 +#define DG_RR_RESPONSE 47 +#define DG_RR_RESULTS 48 + +#define DO_FORE_STREAM 49 +#define FORE_STREAM_RESPONSE 50 +#define FORE_STREAM_RESULTS 51 + +#define DO_FORE_RR 52 +#define FORE_RR_RESPONSE 53 +#define FORE_RR_RESULTS 54 + +#define DO_HIPPI_STREAM 55 +#define HIPPI_STREAM_RESPONSE 56 +#define HIPPI_STREAM_RESULTS 57 + +#define DO_HIPPI_RR 52 +#define HIPPI_RR_RESPONSE 53 +#define HIPPI_RR_RESULTS 54 + +#define DO_XTI_TCP_STREAM 55 +#define XTI_TCP_STREAM_RESPONSE 56 +#define XTI_TCP_STREAM_RESULTS 57 + +#define DO_XTI_TCP_RR 58 +#define XTI_TCP_RR_RESPONSE 59 +#define XTI_TCP_RR_RESULTS 60 + +#define DO_XTI_UDP_STREAM 61 +#define XTI_UDP_STREAM_RESPONSE 62 +#define XTI_UDP_STREAM_RESULTS 63 + +#define DO_XTI_UDP_RR 64 +#define XTI_UDP_RR_RESPONSE 65 +#define XTI_UDP_RR_RESULTS 66 + +#define DO_XTI_TCP_CRR 67 +#define XTI_TCP_CRR_RESPONSE 68 +#define XTI_TCP_CRR_RESULTS 69 + +#define DO_TCP_TRR 70 +#define TCP_TRR_RESPONSE 71 +#define TCP_TRR_RESULTS 72 + +#define DO_TCP_NBRR 73 +#define TCP_NBRR_RESPONSE 74 +#define TCP_NBRR_RESULTS 75 + +#define DO_TCPIPV6_STREAM 76 +#define TCPIPV6_STREAM_RESPONSE 77 +#define TCPIPV6_STREAM_RESULTS 78 + +#define DO_TCPIPV6_RR 79 +#define TCPIPV6_RR_RESPONSE 80 +#define TCPIPV6_RR_RESULTS 81 + +#define DO_UDPIPV6_STREAM 82 +#define UDPIPV6_STREAM_RESPONSE 83 +#define UDPIPV6_STREAM_RESULTS 84 + +#define DO_UDPIPV6_RR 85 +#define UDPIPV6_RR_RESPONSE 86 +#define UDPIPV6_RR_RESULTS 87 + +#define DO_TCPIPV6_CRR 88 +#define TCPIPV6_CRR_RESPONSE 89 +#define TCPIPV6_CRR_RESULTS 90 + +#define DO_TCPIPV6_TRR 91 +#define TCPIPV6_TRR_RESPONSE 92 +#define TCPIPV6_TRR_RESULTS 93 + +#define DO_TCP_MAERTS 94 +#define TCP_MAERTS_RESPONSE 95 +#define TCP_MAERTS_RESULTS 96 + +#define DO_LWPSTR_STREAM 100 +#define LWPSTR_STREAM_RESPONSE 110 +#define LWPSTR_STREAM_RESULTS 120 + +#define DO_LWPSTR_RR 130 +#define LWPSTR_RR_RESPONSE 140 +#define LWPSTR_RR_RESULTS 150 + +#define DO_LWPDG_STREAM 160 +#define LWPDG_STREAM_RESPONSE 170 +#define LWPDG_STREAM_RESULTS 180 + +#define DO_LWPDG_RR 190 +#define LWPDG_RR_RESPONSE 200 +#define LWPDG_RR_RESULTS 210 + +#define DO_TCP_CC 300 +#define TCP_CC_RESPONSE 301 +#define TCP_CC_RESULTS 302 + +/* The DNS_RR test has been removed from netperf but we leave these + here for historical purposes. Those wanting to do DNS_RR tests + should use netperf4 instead. */ +#define DO_DNS_RR 400 +#define DNS_RR_RESPONSE 401 +#define DNS_RR_RESULTS 402 + +#define DO_SCTP_STREAM 500 +#define SCTP_STREAM_RESPONSE 501 +#define SCTP_STREAM_RESULT 502 + +#define DO_SCTP_STREAM_MANY 510 +#define SCTP_STREAM_MANY_RESPONSE 511 +#define SCTP_STREAM_MANY_RESULT 512 + +#define DO_SCTP_RR 520 +#define SCTP_RR_RESPONSE 521 +#define SCTP_RR_RESULT 502 + +#define DO_SCTP_RR_MANY 530 +#define SCTP_RR_MANY_RESPONSE 531 +#define SCTP_RR_MANY_RESULT 532 + +#define DO_SDP_STREAM 540 +#define SDP_STREAM_RESPONSE 541 +#define SDP_STREAM_RESULTS 542 + +#define DO_SDP_RR 543 +#define SDP_RR_RESPONSE 544 +#define SDP_RR_RESULTS 545 + +#define DO_SDP_MAERTS 546 +#define SDP_MAERTS_RESPONSE 547 +#define SDP_MAERTS_RESULTS 548 + +#define DO_SDP_CRR 549 +#define SDP_CRR_RESPONSE 550 +#define SDP_CRR_RESULTS 551 + +#define DO_SDP_CC 552 +#define SDP_CC_RESPONSE 553 +#define SDP_CC_RESULTS 554 + +#if HAVE_INTTYPES_H +# include <inttypes.h> +#else +# if HAVE_STDINT_H +# include <stdint.h> +# endif +#endif + +enum sock_buffer{ + SEND_BUFFER, + RECV_BUFFER +}; + + /* some of the fields in these structures are going to be doubles and */ + /* such. so, we probably want to ensure that they will start on */ + /* "double" boundaries. this will break compatability to pre-2.1 */ + /* releases, but then, backwards compatability has never been a */ + /* stated goal of netperf. raj 11/95 */ + +union netperf_request_struct { + struct { + int request_type; + int dummy; + int test_specific_data[MAXSPECDATA]; + } content; + double dummy; +}; + +union netperf_response_struct { + struct { + int response_type; + int serv_errno; + int test_specific_data[MAXSPECDATA]; + } content; + double dummy; +}; + +struct ring_elt { + struct ring_elt *next; /* next element in the ring */ + char *buffer_base; /* in case we have to free it at somepoint */ + char *buffer_ptr; /* the aligned and offset pointer */ +}; + +/* +*+ SAF Sorry about the hacks with errno; NT made me do it :( + + WinNT does define an errno. + It is mostly a legacy from the XENIX days. + + Depending upon the version of the C run time that is linked in, it is + either a simple variable (like UNIX code expects), but more likely it + is the address of a procedure to return the error number. So any + code that sets errno is likely to be overwriting the address of this + procedure. Worse, only a tiny fraction of NT's errors get set + through errno. + + So I have changed the netperf code to use a define Set_errno when + that is it's intent. On non-windows platforms this is just an + assignment to errno. But on NT this calls SetLastError. + + I also define errno (now only used on right side of assignments) + on NT to be GetLastError. + + Similarly, perror is defined on NT, but it only accesses the same + XENIX errors that errno covers. So on NT this is redefined to be + Perror and it expands all GetLastError texts. */ + + +#ifdef WIN32 +/* INVALID_SOCKET == INVALID_HANDLE_VALUE == (unsigned int)(~0) */ +/* SOCKET_ERROR == -1 */ +#define ENOTSOCK WSAENOTSOCK +#define EINTR WSAEINTR +#define ENOBUFS WSAENOBUFS +#define EWOULDBLOCK WSAEWOULDBLOCK +#define EAFNOSUPPORT WSAEAFNOSUPPORT +/* I don't use a C++ style of comment because it upsets some C + compilers, possibly even when it is inside an ifdef WIN32... */ +/* from public\sdk\inc\crt\errno.h */ +#define ENOSPC 28 + +#ifdef errno +/* delete the one from stdlib.h */ +/*#define errno (*_errno()) */ +#undef errno +#endif +#define errno GetLastError() +#define Set_errno(num) SetLastError((num)) + +#define perror(text) PrintWin32Error(stderr, (text)) +#define Print_errno(stream, text) PrintWin32Error((stream), (text)) + +extern void PrintWin32Error(FILE *stream, LPSTR text); + +#if !defined(NT_PERF) && !defined(USE_LOOPER) +#define NT_PERF +#endif +#else +/* Really shouldn't use manifest constants! */ +/*+*+SAF There are other examples of "== -1" and "<0" that probably */ +/*+*+SAF should be cleaned up as well. */ +#define INVALID_SOCKET -1 +#define SOCKET_ERROR -1 + +#define SOCKET int +#define Set_errno(num) errno = (num) + +#define Print_errno(stream, text) fprintf((stream), "%s errno %d\n", (text), errno) +#endif + +/* Robin & Rick's kludge to try to have a timer signal EINTR by closing */ +/* the socket from another thread can also return several other errors. */ +/* Let's define a macro to hide all of this. */ + +#ifndef WIN32 +#define SOCKET_EINTR(return_value) (errno == EINTR) +#define SOCKET_EADDRINUSE(return_value) (errno == EADDRINUSE) +#define SOCKET_EADDRNOTAVAIL(return_value) (errno == EADDRNOTAVAIL) + +#else + +/* not quite sure I like the extra cases for WIN32 but that is what my + WIN32 expert sugested. I'm not sure what WSA's to put for + EADDRINUSE */ + +#define SOCKET_EINTR(return_value) \ + (((return_value) == SOCKET_ERROR) && \ + ((errno == EINTR) || \ + (errno == WSAECONNABORTED) || \ + (errno == WSAECONNRESET) )) +#define SOCKET_EADDRINUSE(return_value) \ + (((return_value) == SOCKET_ERROR) && \ + ((errno == WSAEADDRINUSE) )) +#define SOCKET_EADDRNOTAVAIL(return_value) \ + (((return_value) == SOCKET_ERROR) && \ + ((errno == WSAEADDRNOTAVAIL) )) +#endif + +#ifdef HAVE_SENDFILE + +struct sendfile_ring_elt { + struct sendfile_ring_elt *next; /* next element in the ring */ + int fildes; /* the file descriptor of the source + file */ + off_t offset; /* the offset from the beginning of + the file for this send */ + size_t length; /* the number of bytes to send - + this is redundant with the + send_size variable but I decided + to include it anyway */ + struct iovec *hdtrl; /* a pointer to a header/trailer + that we do not initially use and + so should be set to NULL when the + ring is setup. */ + int flags; /* the flags to pass to sendfile() - + presently unused and should be + set to zero when the ring is + setup. */ +}; + +#endif /* HAVE_SENDFILE */ + + /* the diferent codes to denote the type of CPU utilization */ + /* methods used */ +#define CPU_UNKNOWN 0 +#define HP_IDLE_COUNTER 1 +#define PSTAT 2 +#define TIMES 3 +#define LOOPER 4 +#define GETRUSAGE 5 +#define NT_METHOD 6 +#define KSTAT 7 +#define PROC_STAT 8 +#define SYSCTL 9 +#define PERFSTAT 10 +#define KSTAT_10 11 +#define OSX 12 + +#define BADCH ('?') + +#ifndef NETLIB +#ifdef WIN32 +#ifndef _GETOPT_ +#define _GETOPT_ + +int getopt(int argc, char **argv, char *optstring); + +extern char *optarg; /* returned arg to go with this option */ +extern int optind; /* index to next argv element to process */ +extern int opterr; /* should error messages be printed? */ +extern int optopt; /* */ + +#endif /* _GETOPT_ */ + +extern SOCKET win_kludge_socket, win_kludge_socket2; +#endif /* WIN32 */ + +extern int local_proc_affinity, remote_proc_affinity; + +/* these are to allow netperf to be run easily through those evil, + end-to-end breaking things known as firewalls */ +extern char local_data_port[10]; +extern char remote_data_port[10]; + +extern char *local_data_address; +extern char *remote_data_address; + +extern int local_data_family; +extern int remote_data_family; + +extern union netperf_request_struct netperf_request; +extern union netperf_response_struct netperf_response; + +extern float lib_local_cpu_util; +extern float lib_elapsed; +extern float lib_local_maxrate; + +extern char libfmt; + +extern int cpu_method; +extern int lib_num_loc_cpus; +extern int lib_num_rem_cpus; +extern SOCKET server_sock; +extern int times_up; +extern FILE *where; +extern int loops_per_msec; +extern float lib_local_per_cpu_util[]; + +extern void netlib_init(); +extern int netlib_get_page_size(); +extern void install_signal_catchers(); +extern void establish_control(char hostname[], + char port[], + int af, + char local_hostname[], + char local_port[], + int local_af); +extern void shutdown_control(); +extern void init_stat(); +extern void send_request(); +extern void recv_response(); +extern void send_response(); +extern void recv_request(); +extern void dump_request(); +extern void dump_addrinfo(FILE *dumploc, struct addrinfo *info, + char *host, char *port, int family); +extern void start_timer(int time); +extern void stop_timer(); +extern void cpu_start(int measure_cpu); +extern void cpu_stop(int measure_cpu, float *elapsed); +extern void calculate_confidence(int confidence_iterations, + float time, + double result, + float loc_cpu, + float rem_cpu, + float loc_sd, + float rem_sd); +extern void retrieve_confident_values(float *elapsed_time, + double *thruput, + float *local_cpu_utilization, + float *remote_cpu_utilization, + float *local_service_demand, + float *remote_service_demand); +extern void display_confidence(); +extern void set_sock_buffer(SOCKET sd, + enum sock_buffer which, + int requested_size, + int *effective_sizep); +extern char *format_units(); + +extern char *inet_ftos(int family); +extern char *inet_ttos(int type); +extern char *inet_ptos(int protocol); +extern double ntohd(double net_double); +extern double htond(double host_double); +extern int inet_nton(int af, const void *src, char *dst, int cnt); +extern void libmain(); +extern double calc_thruput(double units_received); +extern double calc_thruput_interval(double units_received,double elapsed); +extern double calc_thruput_omni(double units_received); +extern double calc_thruput_interval_omni(double units_received,double elapsed); +extern float calibrate_local_cpu(float local_cpu_rate); +extern float calibrate_remote_cpu(); +extern void bind_to_specific_processor(int processor_affinity,int use_cpu_map); +extern int set_nonblock (SOCKET sock); + +#ifndef WIN32 + +/* WIN32 requires that at least one of the file sets to select be + non-null. Since msec_sleep routine is only called by nettest_dlpi & + nettest_unix, let's duck this issue. */ + +extern int msec_sleep( int msecs ); +#endif /* WIN32 */ +extern float calc_cpu_util(float elapsed_time); +extern float calc_service_demand(double units_sent, + float elapsed_time, + float cpu_utilization, + int num_cpus); +extern float calc_service_demand_trans(double units_sent, + float elapsed_time, + float cpu_utilization, + int num_cpus); +#if defined(__hpux) +extern void catcher(int, siginfo_t *,void *); +#else +extern void catcher(int); +#endif /* __hpux */ +extern struct ring_elt *allocate_buffer_ring(); +extern void access_buffer(char *buffer_ptr, + int length, + int dirty_count, + int clean_count); + +#ifdef HAVE_ICSC_EXS +extern struct ring_elt *allocate_exs_buffer_ring(); +#endif /* HAVE_ICSC_EXS */ +#ifdef HAVE_SENDFILE +extern struct sendfile_ring_elt *alloc_sendfile_buf_ring(); +#endif /* HAVE_SENDFILE */ +#ifdef WANT_DLPI +/* it seems that AIX in its finite wisdom has some bogus define in an + include file which defines "rem_addr" which then screws-up this extern + unless we change the names to protect the guilty. reported by Eric + Jones */ +extern int dl_connect(int fd, unsigned char *remote_addr, int remote_addr_len); +extern int dl_bind(int fd, int sap, int mode, char *dlsap_ptr, int *dlsap_len); +extern int dl_open(char devfile[], int ppa); +#endif /* WANT_DLPI */ +extern char format_cpu_method(int method); +extern unsigned int convert(char *string); +extern unsigned int convert_timespec(char *string); + +#ifdef WANT_INTERVALS +extern void start_itimer(unsigned int interval_len_msec); +#endif + /* these are all for the confidence interval stuff */ +extern double confidence; + +#endif + +#ifdef WIN32 +#define close(x) closesocket(x) +#define strcasecmp(a,b) _stricmp(a,b) +#define getpid() ((int)GetCurrentProcessId()) +#endif + +#ifdef WIN32 +#if 0 +/* Should really use safe string functions; but not for now... */ +#include <strsafe.h> +/* Microsoft has deprecated _snprintf; it isn't guarenteed to null terminate the result buffer. */ +/* They want us to call StringCbPrintf instead; it always null terminates the string. */ +#endif + +#define snprintf _snprintf +#endif + +/* Define a macro to align a buffer with an offset from a power of 2 + boundary. */ + +#ifndef WIN32 +#define ULONG_PTR unsigned long +#endif + +#define ALIGN_BUFFER(BufPtr, Align, Offset) \ + (char *)(( (ULONG_PTR)(BufPtr) + \ + (ULONG_PTR) (Align) -1) & \ + ~((ULONG_PTR) (Align) - 1)) + (ULONG_PTR)(Offset) + + /* if your system has bcopy and bzero, include it here, otherwise, we */ + /* will try to use memcpy aand memset. fix from Bruce Barnett @ GE. */ +#if defined(hpux) || defined (__VMS) +#define HAVE_BCOPY +#define HAVE_BZERO +#endif + +#ifdef WIN32 +#define HAVE_MIN +#else +#define _stdcall +#define _cdecl +#endif + +#ifndef HAVE_BCOPY +#define bcopy(s,d,h) memcpy((d),(s),(h)) +#endif /* HAVE_BCOPY */ + +#ifndef HAVE_BZERO +#define bzero(p,h) memset((p),0,(h)) +#endif /* HAVE_BZERO */ + +#ifndef HAVE_MIN +#define min(a,b) ((a < b) ? a : b) +#endif /* HAVE_MIN */ + +#ifdef USE_PERFSTAT +# include <libperfstat.h> +#endif |