/* main - TCP setup, listen, and accept */
int main( int argc, char **argv )
{
struct sockaddr_in local;
struct sockaddr_in peer;
socklen_t peerlen;
SOCKET s1;
SOCKET s;
int c;
int rcvbufsz = 32 * 1024;
const int on = 1;
INIT();
opterr = 0;
while ( ( c = getopt( argc, argv, "b:" ) ) != EOF )
{
switch ( c )
{
case 'b' :
rcvbufsz = atoi( optarg );
break;
case '?' :
error( 1, 0, "illegal option: %c\n", c );
}
}
set_address( NULL, "9000", &local, "tcp" );
s = socket( AF_INET, SOCK_STREAM, 0 );
if ( !isvalidsock( s ) )
error( 1, errno, "socket call failed" );
if ( setsockopt( s, SOL_SOCKET, SO_REUSEADDR,
( char * )&on, sizeof( on ) ) )
error( 1, errno, "setsockopt SO_REUSEADDR failed" );
if ( setsockopt( s, SOL_SOCKET, SO_RCVBUF,
( char * )&rcvbufsz, sizeof( rcvbufsz ) ) )
error( 1, errno, "setsockopt SO_RCVBUF failed" );
if ( bind( s, ( struct sockaddr * ) &local,
sizeof( local ) ) )
error( 1, errno, "bind failed" );
listen( s, 5 );
do
{
peerlen = sizeof( peer );
s1 = accept( s, ( struct sockaddr * )&peer, &peerlen );
if ( !isvalidsock( s1 ) )
error( 1, errno, "accept failed" );
server( s1, rcvbufsz );
CLOSE( s1 );
} while ( 0 );
EXIT( 0 );
}
inline int io_ensure_sbuf(sbuf *buf, int fd, size_t length)
{
int rc = 1;
size_t ntrans = 0;
assert_not(buf, NULL);
assert(isvalidsock(fd) && "not a valid socket");
// make sure there's enough for the payload
while((size_t)sbuf_data_avail(buf) < length) {
// need to read more
rc = io_read_sbuf(fd, buf, &ntrans);
if(!rc || errno) {
if(errno && errno != EBADF) {
fail("unexpected error reading from socket");
}
errno = 0;
break;
}
check(ntrans != 0, "attempted read returned 0 length");
if(ntrans < length) {
dbg("attempted read returned %zu rather than %zu with %jd avail", ntrans, length, (intmax_t)sbuf_data_avail(buf));
}
}
ensure(return rc);
}
/* udp_client - set up a UDP client */
SOCKET udp_client( char *hname, char *sname,
struct sockaddr_in *sap )
{
SOCKET s;
set_address( hname, sname, sap, "udp" );
s = socket( AF_INET, SOCK_DGRAM, 0 );
if ( !isvalidsock( s ) )
error( 1, errno, "socket call failed" );
return s;
}
/* udp_server - set up a UDP server */
SOCKET udp_server( char *hname, char *sname )
{
SOCKET s;
struct sockaddr_in local;
set_address( hname, sname, &local, "udp" );
s = socket( AF_INET, SOCK_DGRAM, 0 );
if ( !isvalidsock( s ) )
error( 1, errno, "socket call failed" );
if ( bind( s, ( struct sockaddr * ) &local,
sizeof( local ) ) )
error( 1, errno, "bind failed" );
return s;
}
int main( int argc, char **argv )
{
struct sockaddr_in local;
SOCKET s;
SOCKET s1;
int rc;
char buf[ 1024 ];
INIT();
s = socket( PF_INET, SOCK_STREAM, 0 );
if ( !isvalidsock( s ) )
error( 1, errno, "Could not allocate socket" );
bzero( &local, sizeof( local ) );
local.sin_family = AF_INET;
local.sin_port = htons( 9000 );
local.sin_addr.s_addr = htonl( INADDR_ANY );
if ( bind( s, ( struct sockaddr * )&local,
sizeof( local ) ) < 0 )
error( 1, errno, "Could not bind socket" );
if ( listen( s, NLISTEN ) < 0 )
error( 1, errno, "listen failed" );
s1 = accept( s, NULL, NULL );
if ( !isvalidsock( s1 ) )
error( 1, errno, "accept failed" );
for ( ;; )
{
rc = recv( s1, buf, sizeof( buf ), 0 );
if ( rc < 0 )
error( 1, errno, "recv failed" );
/*@.bp*/
if ( rc == 0 )
error( 1, 0, "Client disconnected\n" );
rc = send( s1, buf, rc, 0 );
if ( rc < 0 )
error( 1, errno, "send failed" );
}
}
int main(int argc, char **argv){
struct sockaddr_in peer;
SOCKET s;
set_address(argv[1], argv[2], &peer, "tcp");
s = socket(AF_INET, SOCK_STREAM, 0);
if(!isvalidsock(s))
error(1, errno, "socket call failed");
if(connect(s, (struct sockaddr *)&peer, sizeof(peer)))
error(1, errno, "connect failed!");
client(s, &peer);
EXIT(0);
}
/* tcp_client - set up for a TCP client */
SOCKET tcp_client( char *hname, char *sname )
{
struct sockaddr_in peer;
SOCKET s;
set_address( hname, sname, &peer, "tcp" );
s = socket( AF_INET, SOCK_STREAM, 0 );
if ( !isvalidsock( s ) )
error( 1, errno, "socket call failed" );
if ( connect( s, ( struct sockaddr * )&peer,
sizeof( peer ) ) )
error( 1, errno, "connect failed" );
return s;
}
int main(int argc,char **argv)
{
struct sockaddr_in peer;
SOCKET s;
SOCKET s1;
int peerlen = sizeof(peer);
int n;
char buf[10];
INIT();
if(argc == 2)
{
s = tcp_server(NULL,argv[1]);
}
else
{
s = tcp_server(argv[1],argv[2]);
}
s1 = accept(s,(struct sockaddr*)&peer,(socklen_t *)&peerlen);
if(!isvalidsock(s1))
{
error(1,errno,"accept failed");
}
for(;;)
{
n = readvrec(s1,buf,sizeof(buf));
if(n < 0)
{
error(0,errno,"readvrec returned error");
}
else if(n == 0)
{
error(1,0,"client disconnected\n");
}
else
{
write(1,buf,n);
}
}
EXIT(0);
}
int main ( int argc, char **argv)
{
struct sockaddr_in peer;
SOCKET s;
INIT();
set_address(argv[1], argv[2], &peer, "upd");
s = socket(AF_INET, SOCK_DGRAM, 0);
if (!isvalidsock(s))
error(1, errno, "error in call socket()");
if (connect(s, (struct sockaddr *)&peer, sizeof(peer)))
error (1, errno, "error in call connect");
udpclient(s, &peer);
EXIT(0);
}
int main( int argc, char **argv )
{
char *bp;
SOCKET s;
SOCKET s1;
INIT();
init_smb( TRUE );
s = tcp_server( NULL, argv[ 1 ] );
s1 = accept( s, NULL, NULL );
if ( !isvalidsock( s1 ) )
error( 1, errno, "accept failure" );
for ( ;; )
{
bp = smbrecv( s1 );
fputs( bp, stdout );
smbfree( bp );
}
EXIT( 0 );
}
int main( int argc, char **argv )
{
SOCKET s;
SOCKET s1;
int rc;
int i = 1;
int pkt[ 3 ];
INIT();
s = tcp_server( NULL, argv[ 1 ] );
s1 = accept( s, NULL, NULL );
if ( !isvalidsock( s1 ) )
error( 1, errno, "accept failure" );
for ( ;; )
{
rc = recv( s1, ( char * )pkt, sizeof( pkt ), 0 );
if ( rc != TWOINTS && rc != THREEINTS )
error( 1, 0, "recv returned %d\n", rc );
printf( "Packet %d has %d values in %d bytes\n",
i++, ntohl( pkt[ 0 ] ), rc );
}
}
/* main - initialization and event loop */
int main( int argc, char **argv )
{
SOCKET s;
struct protoent *pp;
int rc;
char icmpdg[ 1024 ];
INIT();
pp = getprotobyname( "icmp" );
if ( pp == NULL )
error( 1, errno, "getprotobyname failed" );
s = socket( AF_INET, SOCK_RAW, pp->p_proto );
if ( !isvalidsock( s ) )
error( 1, errno, "socket failed" );
for ( ;; )
{
rc = recvfrom( s, icmpdg, sizeof( icmpdg ), 0,
NULL, NULL );
if ( rc < 0 )
error( 1, errno, "recvfrom failed" );
print_dg( icmpdg, rc );
}
}
int main( int argc, char **argv )
{
SOCKET s;
SOCKET s1;
int rc;
int len;
int counter = 1;
char buf[ 120 ];
INIT();
s = tcp_server( NULL, argv[ 1 ] );
s1 = accept( s, NULL, NULL );
if ( !isvalidsock( s1 ) )
error( 1, errno, "accept failed" );
while ( ( rc = readline( s1, buf, sizeof( buf ) ) ) > 0 )
{
sleep( 5 );
len = sprintf( buf, "received message %d\n", counter++ );
rc = send( s1, buf, len, 0 );
if ( rc < 0 )
error( 1, errno, "send failed" );
}
EXIT( 0 );
}
/* tcp_server - set up for a TCP server */
SOCKET tcp_server( char *hname, char *sname )
{
struct sockaddr_in local;
SOCKET s;
const int on = 1;
set_address( hname, sname, &local, "tcp" );
s = socket( AF_INET, SOCK_STREAM, 0 );
if ( !isvalidsock( s ) )
error( 1, errno, "socket call failed" );
if ( setsockopt( s, SOL_SOCKET, SO_REUSEADDR,
( char * )&on, sizeof( on ) ) )
error( 1, errno, "setsockopt failed" );
if ( bind( s, ( struct sockaddr * ) &local,
sizeof( local ) ) )
error( 1, errno, "bind failed" );
if ( listen( s, NLISTEN ) )
error( 1, errno, "listen failed" );
return s;
}
int main( int argc, char **argv )
{
fd_set allfd;
fd_set readfd;
char msg[ 1024 ];
struct sockaddr_in peer;
struct timeval tv;
SOCKET s;
SOCKET sdata;
SOCKET shb;
int rc;
int maxfd1;
int missed_heartbeats = 0;
socklen_t peerlen = sizeof( peer );
char hbmsg[ 1 ];
INIT();
s = tcp_server( NULL, argv[ 1 ] );
sdata = accept( s, ( struct sockaddr * )&peer,
&peerlen );
if ( !isvalidsock( sdata ) )
error( 1, errno, "accept failed" );
rc = readn( sdata, ( char * )&peer.sin_port,
sizeof( peer.sin_port ) );
if ( rc < 0 )
error( 1, errno, "error reading port number" );
shb = socket( PF_INET, SOCK_STREAM, 0 );
if ( !isvalidsock( shb ) )
error( 1, errno, "shb socket failure" );
rc = connect( shb, ( struct sockaddr * )&peer, peerlen );
if ( rc )
error( 1, errno, "shb connect error" );
tv.tv_sec = T1 + T2;
tv.tv_usec = 0;
FD_ZERO( &allfd );
FD_SET( sdata, &allfd );
FD_SET( shb, &allfd );
maxfd1 = ( sdata > shb ? sdata : shb ) + 1;
/* end part1 */
/* include part2 */
for ( ;; )
{
readfd = allfd;
rc = select( maxfd1, &readfd, NULL, NULL, &tv );
if ( rc < 0 )
error( 1, errno, "select failure" );
if ( rc == 0 ) /* timed out */
{
if ( ++missed_heartbeats > 3 )
error( 1, 0, "connection dead\n" );
error( 0, 0, "missed heartbeat #%d\n",
missed_heartbeats );
tv.tv_sec = T2;
continue;
}
if ( FD_ISSET( shb, &readfd ) )
{
rc = recv( shb, hbmsg, 1, 0 );
if ( rc == 0 )
error( 1, 0, "client terminated\n" );
if ( rc < 0 )
error( 1, errno, "shb recv failure" );
rc = send( shb, hbmsg, 1, 0 );
if ( rc < 0 )
error( 1, errno, "shb send failure" );
}
if ( FD_ISSET( sdata, &readfd ) )
{
rc = recv( sdata, msg, sizeof( msg ), 0 );
if ( rc == 0 )
error( 1, 0, "client terminated\n" );
if ( rc < 0 )
error( 1, errno, "recv failure" );
/* process data */
}
missed_heartbeats = 0;
tv.tv_sec = T1 + T2;
}
EXIT( 0 );
}
int main( int argc, char* argv[] )
{
if ( argc != 4 )
{
std::cout << "error parameters. usage: " << argv[0] << " ip port packetinteval";
return -1;
}
Log::init();
float packetinteval = atof( argv[3] );
if ( packetinteval <= 0.001 )
{
packetinteval = 0.5;
}
socketstartup();
SOCKET serversockfd = tcp_server( argv[1], argv[2] );
int myerrno = getLastSocketError();
if ( ! isvalidsock( serversockfd ) )
{
std::cout << "create tcp server error. errno=" << myerrno << std::endl;
msleep( packetinteval * 1000 );// 1/10 of packetinteval*1000
return -1;
}
char recvbuf[MAX_BUF_SIZE];
char msgbuf[MAX_BUF_SIZE];
memset( msgbuf, 'A', sizeof( msgbuf ) );
for ( ;; )
{
Log::trace( "OK, tcp server is running, and waiting for client connection." );
struct sockaddr_in clientaddr;
socklen_t addrlen = sizeof( clientaddr );
memset( &clientaddr, 0, addrlen );
SOCKET clientfd = accept( serversockfd, (struct sockaddr*)&clientaddr, &addrlen );
int myerrno = getLastSocketError();
if ( ! isvalidsock( clientfd ) )
{
std::cout << "accept error. errno=" << myerrno << std::endl;
msleep( packetinteval * 1000 );// 1/10 of packetinteval*1000
continue;
}
int sendcount = 0;
int recvcount = 0;
int recverrorcount = 0;
for ( ;; )
{
int sendn = send( clientfd, msgbuf, sizeof( msgbuf ), 0 );
int myerrno = getLastSocketError();
if ( -1 == sendn )
{
static int errorcount = 0;
if ( 10 == errorcount++ )
{
break;
}
std::cout << "send error. errno=" << myerrno;
msleep( packetinteval * 1000 );// 1/10 of packetinteval*1000
continue;
}
Log::trace( "send a message to client." );
sendcount++;
int recvn = recv( clientfd, recvbuf, sizeof(msgbuf), 0 );
if ( sizeof(msgbuf) == recvn )
{
bool brecvwrite = true;
for ( int i = 0; i < sizeof(msgbuf); ++i )
{
if ( recvbuf[i] != 'A' && recvbuf[i] != 'q' && recvbuf[i] != 'Q' )
{
brecvwrite = false;
break;
}
}
if ( brecvwrite )
{
Log::trace( "recv a message from client." );
recvcount++;
}
else
{
Log::trace( "recv message content is wrong." );
recverrorcount++;
}
}
else
{
static int errorcount = 0;
if ( 10 == errorcount++ )
{
Log::trace( "recv message error." );
break;
}
}
if ( recvbuf[0] == 'q' || recvbuf[0] == 'Q' )
{
std::ostringstream log;
log << "===========================================================";
log << "\n\tRecv count=" << recvcount
<< "\n\tSend count=" << sendcount
<< "\n\tRecv error count=" << recverrorcount;
log << "\n===========================================================";
Log::trace( log.str() );
CLOSE_SOCKET( clientfd );
break;
}
msleep( (unsigned int)(packetinteval * 1000) );
} // end of send-recv for(;;)
}//end of accept loop for(;;)
CLOSE_SOCKET( serversockfd );
return 0;
}
int main( int argc, char* argv[] )
{
if ( argc != 4 )
{
std::cout << "error parameters. usage: " << argv[0] << " ip port packetnum";
return -1;
}
Log::init();
int packetnum = atoi( argv[3] );
if ( packetnum < 0 )
{
packetnum = 100;
}
socketstartup();
SOCKET clientfd = tcp_client( argv[1], argv[2] );
if ( !isvalidsock( clientfd ) )
{
Log::trace( "cannot connect server" );
return -1;
}
char recvbuf[MAX_BUF_SIZE];
int sendcount = 0;
int recvcount = 0;
int recverrorcount = 0;
for ( ;; )
{
int recvn = recv( clientfd, recvbuf, sizeof( recvbuf ), 0 );
if ( sizeof( recvbuf ) == recvn )
{
bool brecvwrite = true;
for ( int i = 0; i < sizeof( recvbuf ); ++i )
{
if ( recvbuf[i] != 'A' )
{
brecvwrite = false;
break;
}
}
if ( brecvwrite )
{
#ifdef H_OS_WINDOWS
static DWORD tmLastRecvMsg = 0;
DWORD tnow = GetTickCount();
double fdiff = (double)( tnow - tmLastRecvMsg ) / 1000.0f;
if ( fdiff > 2.0 )
{
std::ostringstream log;
log << "recv a message from server, but it is too long, interval:" << fdiff << "s.";
Log::error( log.str() );
}
else
{
Log::trace( "recv a message from server." );
}
tmLastRecvMsg = tnow;
#else
Log::trace( "recv a message from server." );
#endif
recvcount++;
}
else
{
Log::trace( "recv message, but the content is wrong." );
recverrorcount++;
}
}
else
{
static int errorcount = 0;
if ( 10 == errorcount++ )
{
break;
}
}
if ( recvcount == packetnum )
{
memset( recvbuf, 'q', sizeof(recvbuf) );
}
int sendn = 0;
do
{
sendn = send( clientfd, recvbuf, sizeof( recvbuf ), 0 );
if ( -1 == sendn )
{
static int errorcount = 0;
if ( 10 == errorcount++ )
{
break;
}
std::cout << "send error. errno=" << getLastSocketError();
msleep( 100 );
}
else
{
//Log::trace( " send a message to client." );
sendcount++;
break;
}
}
while ( -1 == sendn );
if ( recvcount == packetnum )
{
std::ostringstream log;
log << "===========================================================";
log << "\n\tRecv count=" << recvcount
<< "\n\tSend count=" << sendcount
<< "\n\tRecv error count=" << recverrorcount;
log << "\n===========================================================";
Log::trace( log.str() );
CLOSE_SOCKET( clientfd );
break;
}
} // end of send-recv for(;;)
return 0;
}