static int
run_event_loop (const ACE_TCHAR rendezvous[])
{
ACE_LSOCK_Acceptor peer_acceptor;
// Create a server address.
ACE_UNIX_Addr server_addr (rendezvous);
ACE_OS::unlink (rendezvous);
// Create a server.
if (peer_acceptor.open (server_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("open")),
1);
else if (peer_acceptor.get_local_addr (server_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("get_local_addr")),
-1);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("starting server %C\n"),
server_addr.get_path_name ()));
// Keep these guys out here to prevent excessive constructor
// calls...
ACE_LSOCK_Stream new_stream;
// Performs the iterative server activities.
for (;;)
{
ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT);
if (peer_acceptor.accept (new_stream, 0, &timeout) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("accept")));
continue;
}
#if defined (ACE_HAS_THREADS)
if (ACE_Thread_Manager::instance ()->spawn ((ACE_THR_FUNC) server,
reinterpret_cast<void *> (new_stream.get_handle ()),
THR_DETACHED) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("spawn")),
1);
#else
server (reinterpret_cast<void *> (new_stream.get_handle ()));
#endif /* ACE_HAS_THREADS */
}
ACE_NOTREACHED (return 0;)
}
// ---------------------------------------------------------------------------
TcpClient::Ptr TcpClient::CreateTcpClient(boost::asio::io_service& io_service,
const std::string addr, uint16 port){
boost::asio::ip::tcp::endpoint server_addr(
boost::asio::ip::address().from_string(addr), port);
return TcpClient::Ptr(new TcpClient(io_service, server_addr));
}
static void *
client (void *arg)
{
ACE_INET_Addr *remote_addr = (ACE_INET_Addr *) arg;
ACE_INET_Addr server_addr (remote_addr->get_port_number (),
ACE_IPV6_LOCALHOST);
ACE_SOCK_Stream cli_stream;
ACE_SOCK_Connector con;
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) starting non-blocking connect\n")));
// Initiate timed, non-blocking connection with server.
// Attempt a non-blocking connect to the server.
if (con.connect (cli_stream, server_addr,
(ACE_Time_Value *) &ACE_Time_Value::zero) == -1)
{
if (errno != EWOULDBLOCK)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("connection failed")));
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) starting timed connect\n")));
// Check if non-blocking connection is in progress,
// and wait up to ACE_DEFAULT_TIMEOUT seconds for it to complete.
ACE_Time_Value tv (ACE_DEFAULT_TIMEOUT);
if (con.complete (cli_stream, &server_addr, &tv) == -1)
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("connection failed")), 0);
else
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) connected to %C\n"),
server_addr.get_host_name ()));
}
if (cli_stream.disable (ACE_NONBLOCK) == -1)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("disable")));
// Send data to server (correctly handles "incomplete writes").
for (const char *c = ACE_ALPHABET; *c != '\0'; c++)
if (cli_stream.send_n (c, 1) == -1)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("send_n")));
// Explicitly close the writer-side of the connection.
if (cli_stream.close_writer () == -1)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("close_writer")));
char buf[1];
// Wait for handshake with server.
if (cli_stream.recv_n (buf, 1) != 1)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("recv_n")));
// Close the connection completely.
if (cli_stream.close () == -1)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("close")));
return 0;
}
void
Log::parse_open_listener_i (void)
{
char *addr = ACE_OS::strchr(this->info_,'<') +1;
char *c = ACE_OS::strchr(addr,'>');
*c = '\0';
Endpoint server_addr(addr);
this->hostproc_->add_listen_endpoint(server_addr);
}
int connection::connect(char *hostname_opt_port, int tcp_nodelay, int sockbufsiz) {
if(!hostname_opt_port) return 1;
char *hostname_with_port;
// Check to see if portnumber is specified in the hostnameport
// If not, append :80
if(!ACE_OS::strchr(hostname_opt_port,':')) {
hostname_with_port = new char[ACE_OS::strlen(hostname_opt_port) + 3];
ACE_OS::sprintf(hostname_with_port, "%s:%d", hostname_opt_port, 80);
}
else {
hostname_with_port = hostname_opt_port;
}
// Beyond this point, hostname_with_port is of the form hostname:port
ACE_INET_Addr server_addr(hostname_with_port);
// Connect to server
ACE_SOCK_Connector con;
if(con.connect(stream_, server_addr) == -1) {
ACE_OS::perror("ACE_SOCK_Connector::connect");
return 1;
}
// tcp_nodelay processing.
// turn off weird ack things
if(tcp_nodelay) {
struct protoent *p = ACE_OS::getprotobyname ("tcp");
int one = 1;
if (p && stream_.set_option (p->p_proto,
TCP_NODELAY,
(char *)& one,
sizeof (one)))
{
ACE_OS::perror("tcp_nodelay");
return 1;
}
}
if(sockbufsiz)
if (stream_.set_option (SOL_SOCKET,
SO_RCVBUF,
(char *) &sockbufsiz,
sizeof sockbufsiz) == -1)
{
ACE_OS::perror("socket_queue_size");
return 1;
}
return 0;
}
TcpConnect::Ptr TcpClient::ConnectServer(boost::asio::io_service& io_service,
const std::string addr, uint16 port, CallBackConnect call_back){
TcpConnect::Ptr connect(new TcpConnect(io_service));
boost::asio::ip::tcp::endpoint server_addr(
boost::asio::ip::address().from_string(addr), port);
connect->socket().async_connect(server_addr,
boost::bind(&TcpClient::HandleStaticServerConnect, connect,
boost::asio::placeholders::error, call_back));
return connect;
}
int main(int argc, char** argv)
{
module_init();
// specify what services and tools will run in config file, then run
dsn_run(argc, argv, true);
// TODO: external echo lib test
dsn_mimic_app("client", 1);
dsn::rpc_address server_addr("localhost", 27001);
dsn::example::echo_client client(server_addr);
std::string resp;
client.ping("hihihihihihii", resp);
return 0;
}
static int
run_event_loop (u_short port)
{
// Create the acceptors.
ACE_MEM_Acceptor acceptor;
ACE_MEM_Addr server_addr (port);
// Create acceptors, reuse the address.
if (acceptor.open (server_addr, 1) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"open"),
1);
else if (acceptor.get_local_addr (server_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"get_local_addr"),
1);
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) starting server at port %d\n",
server_addr.get_port_number ()));
// Keep these objects out here to prevent excessive constructor
// calls within the loop.
ACE_MEM_Stream new_stream;
// blocking wait on accept.
if (acceptor.accept (new_stream) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"accept"),
-1);
char buf[MAXPATHLEN];
int len = 0;
while ((len = new_stream.recv (buf, MAXPATHLEN)) != -1)
{
ACE_DEBUG ((LM_DEBUG, "%s\n", buf));
new_stream.send (buf, len);
}
return new_stream.fini ();
}
bool P2PProxyClientSession::ProceesSystemCommand(const char *data,
uint16 len)
{
ASSERT(signal_thread_->IsCurrent());
LOG_P2P(P2P_PROXY_SOCKET_DATA) << "process System command";
///////////////////////////////////////////////////////////////////////////
//BUSINESS LOGIC NOTE (GuangleiHe, 11/28/2013)
//There didn't used P2PRTSPCommand to parse the data.
//P2PRTSPCommand only known by P2PSystemCommandFactory
///////////////////////////////////////////////////////////////////////////
//Step 1. Parse the system command.
uint32 p2p_system_command_type;
uint32 server_socket;
uint32 client_socket;
uint32 client_connection_ip;
uint16 client_connection_port;
if(!ParseCommand(data,len,&p2p_system_command_type,&server_socket,
&client_socket,&client_connection_ip,&client_connection_port)){
LOG(LS_ERROR) << "Parse the p2p system command error";
return false;
}
//////////////////////////////////////////////////////////////////////////
if(p2p_system_command_type == P2P_SYSTEM_CREATE_CLIENT_SOCKET){
LOG_P2P(P2P_PROXY_SOCKET_LOGIC) << "Create New Client Socket";
//Step 1. Create AsyncSocket object.
talk_base::AsyncSocket *int_socket
= worker_thread_->socketserver()->CreateAsyncSocket(SOCK_STREAM);
talk_base::SocketAddress server_addr(client_connection_ip,client_connection_port);
new P2PProxyClientSocketBinding(new P2PProxyEndSocket(this,server_socket),
int_socket,server_addr);
}
else if(p2p_system_command_type == P2P_SYSTEM_SOCKET_CLOSE){
LOG_P2P(P2P_PROXY_SOCKET_LOGIC) << "close server socket ";
is_self_close = false;
P2PProxySocket *res = GetP2PProxySocket(server_socket);
if(res != NULL)
res->OnP2PClose(this);
}
return true;
}
static int
run_client (void)
{
ACE_MEM_Connector connector;
ACE_MEM_Stream stream;
ACE_MEM_Addr server_addr (ACE_DEFAULT_SERVER_PORT);
if (connector.connect (stream, server_addr.get_remote_addr ()) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "connect"), -1);
char buf [MAXPATHLEN];
while (fgets (buf, MAXPATHLEN, stdin) >0)
{
stream.send (buf, ACE_OS::strlen (buf)+1);
stream.recv (buf, MAXPATHLEN);
ACE_DEBUG ((LM_DEBUG, "Echo: %s\n", buf));
}
return 0;
}
static void *
client (void *arg)
{
ACE_INET_Addr *remote_addr = reinterpret_cast<ACE_INET_Addr *> (arg);
ACE_INET_Addr server_addr (remote_addr->get_port_number (),
"::1");
ACE_SOCK_Stream cli_stream;
ACE_SOCK_Connector con;
ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Connecting to port %d\n"),
server_addr.get_port_number()));
// Initiate connection with server; don't wait forever
if (con.connect (cli_stream,
server_addr,
&timeout) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("connection failed")));
return 0;
}
// if connect succesful, what is the max port number we connected
// up to now.
int connected_port = server_addr.get_port_number ();
if (connected_port > max_connected_port)
max_connected_port = connected_port;
cli_stream.close ();
return 0;
}
int main(int argc, char* argv[])
{
int ch;
acl::string server_addr("127.0.0.1:8888"), file("./xml.txt");
acl::string stype("xml"), charset("gb2312");
while ((ch = getopt(argc, argv, "hs:f:t:c:")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 'f':
file = optarg;
break;
case 't':
stype = optarg;
break;
case 'c':
charset = optarg;
break;
default:
usage(argv[0]);
return 0;
}
}
// 将日志输出至屏幕
acl::log::stdout_open(true);
// 开始运行
http_request_test request(server_addr, file, stype, charset);
request.run();
return 0;
}
void *
client (void *arg)
{
ACE_INET_Addr *remote_addr = reinterpret_cast<ACE_INET_Addr *> (arg);
ACE_INET_Addr server_addr (remote_addr->get_port_number (),
ACE_LOCALHOST,
AF_INET);
ACE_SOCK_Stream cli_stream;
ACE_SOCK_Connector con;
ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Connecting to port %d\n"),
server_addr.get_port_number()));
// Initiate connection with server; don't wait forever
if (con.connect (cli_stream,
server_addr,
&timeout) == -1)
{
#if defined (ACE_VXWORKS)
if (errno == ETIME)
{
if ( ++retry_port_<6 )
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Going to retry port %d\n"),
server_addr.get_port_number()));
}
}
if ( retry_port_>5 )
{
retry_port_ = 0;
#endif
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("connection failed")));
#if defined (ACE_VXWORKS)
}
#endif
return 0;
}
#if defined (ACE_VXWORKS)
retry_port_ = 0;
#endif
// if connect succesful, what is the max port number we connected
// up to now.
int connected_port = server_addr.get_port_number ();
if (connected_port > max_connected_port)
max_connected_port = connected_port;
cli_stream.close ();
return 0;
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
u_short port = 0;
if (argc == 1)
{
// This is the "master" process.
ACE_START_TEST (ACE_TEXT ("MEM_Stream_Test"));
create_reactor ();
ACE_MEM_Addr server_addr (port);
reset_handler (NUMBER_OF_REACTIVE_CONNECTIONS);
test_reactive (argc > 0 ? argv[0] : ACE_TEXT ("MEM_Stream_Test"), server_addr);
ACE_Reactor::instance ()->reset_reactor_event_loop ();
#if !defined (ACE_WIN32) && defined (_ACE_USE_SV_SEM)
ACE_ERROR ((LM_DEBUG,
ACE_TEXT ("\n *** Platform only supports non-scalable SysV semaphores ***\n\n")));
#endif /* !ACE_WIN32 && _ACE_USE_SV_SEM */
reset_handler (NUMBER_OF_MT_CONNECTIONS);
test_concurrent (argc > 0 ? argv[0] : ACE_TEXT ("MEM_Stream_Test"), server_addr);
ACE_END_TEST;
return 0;
}
else
{
// We end up here if this is a child process spawned for one of
// the test passes. command line is: -p <port> -r (reactive) |
// -m (multithreaded)
ACE_TCHAR lognm[MAXPATHLEN];
int mypid (ACE_OS::getpid ());
ACE_OS::sprintf(lognm, ACE_TEXT ("MEM_Stream_Test-%d"), mypid);
ACE_START_TEST (lognm);
ACE_Get_Opt opts (argc, argv, ACE_TEXT ("p:rm"));
int opt, iport, status;
ACE_MEM_IO::Signal_Strategy model = ACE_MEM_IO::Reactive;
while ((opt = opts()) != -1)
{
switch (opt)
{
case 'p':
iport = ACE_OS::atoi (opts.opt_arg ());
port = static_cast <u_short> (iport);
break;
case 'r':
model = ACE_MEM_IO::Reactive;
break;
case 'm':
model = ACE_MEM_IO::MT;
break;
default:
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Invalid option (-p <port> -r | -m)\n")),
1);
}
}
status = run_client (port, model);
ACE_END_TEST;
return status;
}
}
static void *
client (void *arg)
{
ACE_INET_Addr *remote_addr = (ACE_INET_Addr *) arg;
ACE_INET_Addr server_addr (remote_addr->get_port_number (),
ACE_DEFAULT_SERVER_HOST);
ACE_INET_Addr client_addr;
ACE_SOCK_Stream cli_stream;
ACE_SOCK_Connector con;
#if defined (ACE_HAS_BROKEN_NON_BLOCKING_CONNECTS)
ACE_Time_Value *timeout = 0;
#else
ACE_Time_Value tv (ACE_DEFAULT_TIMEOUT);
ACE_Time_Value *timeout = &tv;
#endif /* ACE_HAS_BROKEN_NON_BLOCKING_CONNECTS */
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) starting timed connect\n")));
// Initiate timed connection with server.
// Attempt a timed connect to the server.
if (con.connect (cli_stream,
server_addr,
timeout) == -1)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("connection failed")));
return 0;
}
if (cli_stream.get_local_addr (client_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("get_local_addr")),
0);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) connected client at %d\n"),
client_addr.get_port_number ()));
if (cli_stream.disable (ACE_NONBLOCK) == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("disable")));
// Send data to server (correctly handles "incomplete writes").
for (const char *c = ACE_ALPHABET; *c != '\0'; c++)
if (cli_stream.send_n (c, 1) == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("send_n")));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) closing writer\n")));
// Explicitly close the writer-side of the connection.
if (cli_stream.close_writer () == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("close_writer")));
char buf[1];
// Wait for handshake with server.
if (cli_stream.recv_n (buf, 1) != 1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("recv_n")));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) received handshake from server\n")));
// Close the connection completely.
if (cli_stream.close () == -1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("close")));
return 0;
}
/*
int cshit3(struct conn_info * sci, int fx) {
int cnt = 0, cnt2=0;
int nnl = sci->resend_buf.frames.rel_head;
int nnf = sci->resend_buf.free_frames.rel_head;
while(nnl > -1) {
cnt++;
nnl = sci->resend_buf.frames_buf[nnl].rel_next;
}
while(nnf > -1) {
cnt++;
nnf = sci->resend_buf.frames_buf[nnf].rel_next;
}
vtun_syslog(LOG_INFO, "%d count l: %d f: %d", fx, cnt, cnt2);
return 0;
}
*/
void client(struct vtun_host *host)
{
struct sockaddr_in my_addr,svr_addr;
struct sigaction sa;
int s, opt, reconnect, sss, len;
int shm_new = 0;
struct sockaddr_un remote;
vtun_syslog(LOG_INFO,"vtrunkd client ver %s %s started",VTUN_VER, BUILD_DATE);
memset(&sa,0,sizeof(sa));
sa.sa_handler=SIG_IGN;
sa.sa_flags = SA_NOCLDWAIT;
sigaction(SIGHUP,&sa,NULL);
sigaction(SIGQUIT,&sa,NULL);
sigaction(SIGPIPE,&sa,NULL);
sigaction(SIGCHLD,&sa,NULL);
sa.sa_handler=sig_term;
sigaction(SIGTERM,&sa,NULL);
sigaction(SIGINT,&sa,NULL);
// now init everything...
int shmid;
key_t key;
struct conn_info *shm_conn_info;
struct timeval cur_time;
/*
* We'll name our shared memory segment
* "5678".
*/
key = SHM_TUN_KEY;
/*
* First, try to open shm
*/
if ((shmid = shmget(key, sizeof(struct conn_info), 0666)) < 0) {
/*
* Create the segment.
*/
vtun_syslog(LOG_INFO,"client: init new shm...");
if ((shmid = shmget(key, sizeof(struct conn_info), IPC_CREAT | 0666)) < 0) {
vtun_syslog(LOG_ERR,"shmget 2 size %d", sizeof(struct conn_info));
exit(1);
}
shm_new = 1;
} else {
vtun_syslog(LOG_INFO,"client: reusing shm...");
shm_new = 0;
}
/*
* Now we attach the segment to our data space.
*/
if ((shm_conn_info = shmat(shmid, NULL, 0)) == (struct conn_info *) -1) {
vtun_syslog(LOG_ERR,"shmat 2");
exit(1);
}
//cshit3(&shm_conn_info[0], 36);
// now try to connect to socket if shm_new ==0
if(!shm_new) {
if ((sss = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
vtun_syslog(LOG_ERR, "socket 44");
exit(1);
}
remote.sun_family = AF_UNIX;
strcpy(remote.sun_path, shm_conn_info[0].devname);
len = strlen(remote.sun_path) + sizeof(remote.sun_family);
if ( (shm_conn_info->rdy) && (connect(sss, (struct sockaddr *)&remote, len) == -1)) {
vtun_syslog(LOG_INFO, "SHM ready but socket not open! Assuming we're only process running;");
shm_new = 1; // could not connect; assume we're new!
} else {
vtun_syslog(LOG_INFO, "Socket connected OK seems all OK");
}
close(sss);
}
if(shm_new) {
vtun_syslog(LOG_INFO, "client doing memset");
memset(shm_conn_info, 0, sizeof(struct conn_info));
}
//cshit3(&shm_conn_info[0], 37);
client_term = 0; reconnect = 0;
while( (!client_term) || (client_term == VTUN_SIG_HUP) ){
if( reconnect && (client_term != VTUN_SIG_HUP) ){
if( vtun.persist || host->persist ){
/* Persist mode. Sleep and reconnect. */
sleep(5);
} else {
/* Exit */
break;
}
} else {
reconnect = 1;
}
set_title("%s init initializing", host->host);
/* Set server address */
if( server_addr(&svr_addr, host) < 0 )
continue;
/* Set local address */
if( local_addr(&my_addr, host, 0) < 0 )
continue;
/* We have to create socket again every time
* we want to connect, since STREAM sockets
* can be successfully connected only once.
*/
if( (s = socket(AF_INET,SOCK_STREAM,0))==-1 ){
vtun_syslog(LOG_ERR,"Can't create socket. %s(%d)",
strerror(errno), errno);
continue;
}
//cshit3(&shm_conn_info[0], 38);
/* Required when client is forced to bind to specific port */
opt=1;
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
#ifndef W_O_SO_MARK
if(host->RT_MARK != -1) {
if (setsockopt(s, SOL_SOCKET, SO_MARK, &host->RT_MARK, sizeof(host->RT_MARK))) {
vtun_syslog(LOG_ERR,"client socket rt mark error %s(%d)",
strerror(errno), errno);
break;
}
}
#endif
if( bind(s,(struct sockaddr *)&my_addr,sizeof(my_addr)) ){
vtun_syslog(LOG_ERR,"Can't bind socket. %s(%d)",
strerror(errno), errno);
continue;
}
/*
* Clear speed and flags which will be supplied by server.
*/
host->spd_in = host->spd_out = 0;
host->flags &= VTUN_CLNT_MASK;
io_init();
set_title("%s connecting to %s", host->host, vtun.svr_name);
vtun_syslog(LOG_INFO,"Connecting to %s", vtun.svr_name);
if( connect_t(s,(struct sockaddr *) &svr_addr, host->timeout) ){
vtun_syslog(LOG_INFO,"Connect to %s failed. %s(%d)", vtun.svr_name,
strerror(errno), errno);
} else {
if( auth_client(s, host) ){
vtun_syslog(LOG_INFO,"Session %s[%s] opened",host->host,vtun.svr_name);
host->rmt_fd = s;
//cshit3(&shm_conn_info[0], 39);
/* Start the tunnel */
client_term = tunnel(host, 0);
gettimeofday(&cur_time, NULL);
shm_conn_info->alive = cur_time.tv_sec; // show we are alive and trying to reconnect still.. (or fd_server will quit)
vtun_syslog(LOG_INFO,"Session %s[%s] closed",host->host,vtun.svr_name);
} else {
vtun_syslog(LOG_INFO,"Connection denied by %s",vtun.svr_name);
}
}
close(s);
free_sopt(&host->sopt);
}
vtun_syslog(LOG_INFO, "Exit");
return;
}
static int
TestRemoteServer(const char* hostname, unsigned int port, bool verify_cert, NPT_Result expected_cert_verif_result)
{
printf("[1] Connecting to %s...\n", hostname);
NPT_Socket* client_socket = new NPT_TcpClientSocket();
NPT_IpAddress server_ip;
NPT_Result result = server_ip.ResolveName(hostname);
if (NPT_FAILED(result)) {
printf("!ERROR cannot resolve hostname\n");
return 1;
}
NPT_SocketAddress server_addr(server_ip, port);
result = client_socket->Connect(server_addr);
printf("[2] Connection result = %d (%s)\n", result, NPT_ResultText(result));
if (NPT_FAILED(result)) {
printf("!ERROR\n");
return 1;
}
NPT_InputStreamReference input;
NPT_OutputStreamReference output;
client_socket->GetInputStream(input);
client_socket->GetOutputStream(output);
delete client_socket;
NPT_TlsContextReference context(new NPT_TlsContext(NPT_TLS_CONTEXT_OPTION_VERIFY_LATER));
/* self-signed cert */
result = context->LoadKey(NPT_TLS_KEY_FORMAT_PKCS8, TestClient_p8_1, TestClient_p8_1_len, "neptune");
CHECK(result == NPT_SUCCESS);
result = context->SelfSignCertificate("MyClientCommonName", "MyClientOrganization", "MyClientOrganizationalName");
NPT_DataBuffer ta_data;
NPT_Base64::Decode(EquifaxCA, NPT_StringLength(EquifaxCA), ta_data);
result = context->AddTrustAnchor(ta_data.GetData(), ta_data.GetDataSize());
if (NPT_FAILED(result)) {
printf("!ERROR: context->AddTrustAnchor() \n");
return 1;
}
result = context->AddTrustAnchors(NptTlsDefaultTrustAnchors);
if (NPT_FAILED(result)) {
printf("!ERROR: context->AddTrustAnchors() \n");
return 1;
}
NPT_TlsClientSession session(context, input, output);
printf("[3] Performing Handshake\n");
result = session.Handshake();
printf("[4] Handshake Result = %d (%s)\n", result, NPT_ResultText(result));
if (NPT_FAILED(result)) {
printf("!ERROR\n");
return 1;
}
PrintSessionInfo(session);
if (verify_cert) {
result = session.VerifyPeerCertificate();
printf("[9] Certificate Verification Result = %d (%s)\n", result, NPT_ResultText(result));
if (result != expected_cert_verif_result) {
printf("!ERROR, cert verification expected %d, got %d\n", expected_cert_verif_result, result);
return 1;
}
}
NPT_InputStreamReference ssl_input;
NPT_OutputStreamReference ssl_output;
session.GetInputStream(ssl_input);
session.GetOutputStream(ssl_output);
printf("[10] Getting / Document\n");
ssl_output->WriteString("GET / HTTP/1.0\n\n");
for (;;) {
unsigned char buffer[1];
NPT_Size bytes_read = 0;
result = ssl_input->Read(&buffer[0], 1, &bytes_read);
if (NPT_SUCCEEDED(result)) {
CHECK(bytes_read == 1);
printf("%c", buffer[0]);
} else {
if (result != NPT_ERROR_EOS && result != NPT_ERROR_CONNECTION_ABORTED) {
printf("!ERROR: Read() returned %d (%s)\n", result, NPT_ResultText(result));
}
break;
}
}
printf("[9] SUCCESS\n");
return 0;
}
static void *
client (void *arg)
{
ACE_INET_Addr *remote_addr = reinterpret_cast<ACE_INET_Addr *> (arg);
ACE_INET_Addr server_addr (remote_addr->get_port_number (),
ACE_LOCALHOST);
ACE_SOCK_Stream cli_stream;
ACE_SOCK_Connector con;
ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Connecting to port %d\n"),
server_addr.get_port_number()));
// Initiate connection with server; don't wait forever
if (con.connect (cli_stream,
server_addr,
&timeout) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("connection failed")));
Test_Result = 1;
return 0;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) connected to %s\n"),
ACE_TEXT_CHAR_TO_TCHAR(server_addr.get_host_name ())));
//******************* TEST 1 ******************************
//
// Send the 255 byte buffer in 5 chunks. The
// server will verify that the correct data is sent, and that there
// is no more and no less.
u_char buffer[255];
size_t i;
// The server will verify that this data pattern gets there intact.
for (i = 0; i < sizeof buffer; ++i)
buffer[i] = static_cast<u_char> (i);
ACE_TCHAR const test_file[] = ACE_TEXT ("Sendfile_Test_File");
ACE_HANDLE in_fd =
ACE_OS::open (test_file,
O_CREAT | O_RDWR | O_TRUNC,
ACE_DEFAULT_FILE_PERMS);
ACE_ASSERT (in_fd != ACE_INVALID_HANDLE);
ACE_OS::unlink (test_file);
ssize_t const byte_count =
ACE_OS::write (in_fd, buffer, sizeof (buffer));
ACE_ASSERT (byte_count == static_cast<ssize_t> (sizeof (buffer)));
off_t offset = 0;
ssize_t len =
ACE_OS::sendfile (cli_stream.get_handle (),
in_fd,
&offset,
byte_count);
if (len == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("Test 1, sendfile failed")));
Test_Result = 1;
goto cleanup;
}
else
ACE_ASSERT (len == 255);
//******************* TEST 2 ******************************
//
// The same data is coming back - receive it using recv (size_t n,
// ...) and compare it to the original data.
u_char buffer2[255];
// Give it a chance to get here
ACE_OS::sleep (2);
len = cli_stream.recv (4,
buffer2,
150,
&buffer2[150],
105);
if (len != 255)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p; len is %d, but should be 255!\n"),
len));
}
ACE_ASSERT (len == 255);
for (i = 0; i < 255; i++)
if (buffer2[i] != buffer[i])
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) Test 2, rcvd byte %d is %d, not %d\n"),
i, buffer2[i], buffer[i]));
Test_Result = 1;
}
cleanup:
cli_stream.close ();
(void) ACE_OS::close (in_fd);
return 0;
}
void client(struct vtun_host *host)
{
struct sockaddr_in my_addr,svr_addr;
struct sigaction sa;
int s, opt, reconnect;
vtun_syslog(LOG_INFO,"VTun client ver %s started",VTUN_VER);
memset(&sa,0,sizeof(sa));
sa.sa_handler=SIG_IGN;
sa.sa_flags = SA_NOCLDWAIT;
sigaction(SIGHUP,&sa,NULL);
sigaction(SIGQUIT,&sa,NULL);
sigaction(SIGPIPE,&sa,NULL);
sigaction(SIGCHLD,&sa,NULL);
sa.sa_handler=sig_term;
sigaction(SIGTERM,&sa,NULL);
sigaction(SIGINT,&sa,NULL);
client_term = 0; reconnect = 0;
while( (!client_term) || (client_term == VTUN_SIG_HUP) ){
if( reconnect && (client_term != VTUN_SIG_HUP) ){
if( vtun.persist || host->persist ){
/* Persist mode. Sleep and reconnect. */
sleep(5);
} else {
/* Exit */
break;
}
} else {
reconnect = 1;
}
set_title("%s init initializing", host->host);
/* Set server address */
if( server_addr(&svr_addr, host) < 0 )
continue;
/* Set local address */
if( local_addr(&my_addr, host, 0) < 0 )
continue;
/* We have to create socket again every time
* we want to connect, since STREAM sockets
* can be successfully connected only once.
*/
if( (s = socket(AF_INET,SOCK_STREAM,0))==-1 ){
vtun_syslog(LOG_ERR,"Can't create socket. %s(%d)",
strerror(errno), errno);
continue;
}
/* Required when client is forced to bind to specific port */
opt=1;
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
if( bind(s,(struct sockaddr *)&my_addr,sizeof(my_addr)) ){
vtun_syslog(LOG_ERR,"Can't bind socket. %s(%d)",
strerror(errno), errno);
continue;
}
/*
* Clear speed and flags which will be supplied by server.
*/
host->spd_in = host->spd_out = 0;
host->flags &= VTUN_CLNT_MASK;
io_init();
set_title("%s connecting to %s", host->host, vtun.svr_name);
if (!vtun.quiet)
vtun_syslog(LOG_INFO,"Connecting to %s", vtun.svr_name);
if( connect_t(s,(struct sockaddr *) &svr_addr, host->timeout) ){
if (!vtun.quiet || errno != ETIMEDOUT)
vtun_syslog(LOG_INFO,"Connect to %s failed. %s(%d)", vtun.svr_name,
strerror(errno), errno);
} else {
if( auth_client(s, host) ){
vtun_syslog(LOG_INFO,"Session %s[%s] opened",host->host,vtun.svr_name);
host->rmt_fd = s;
/* Start the tunnel */
client_term = tunnel(host);
vtun_syslog(LOG_INFO,"Session %s[%s] closed",host->host,vtun.svr_name);
} else {
vtun_syslog(LOG_INFO,"Connection denied by %s",vtun.svr_name);
}
}
close(s);
free_sopt(&host->sopt);
}
vtun_syslog(LOG_INFO, "Exit");
return;
}
//Obviously, this is the main program.
//At first it prints the welcome screen, bind the server port and start ACE_Reactor coupled with ACE_Acceptor.
//Then it will call ACE_Reactor::run_reactor_event_loop() in a infinite loop (it breaks if ACE returns any error).
int main(int argc, char **argv) {
//=========================================
// SETUP SIGNALS HANDLING
//=========================================
//Abnormal termination, such as instigated by the abort function. (Abort.)
signal(SIGABRT, handle_signal);
//Erroneous arithmetic operation, such as divide by 0 or overflow. (Floating point exception.)
signal(SIGFPE, handle_signal);
//An ‘invalid object program’ has been detected. This usually means that there is an illegal instruction in the program. (Illegal instruction.)
signal(SIGILL, handle_signal);
//Interactive attention signal; on interactive systems this is usually generated by typing some ‘break-in’ key at the terminal. (Interrupt.)
signal(SIGINT, handle_signal);
//Invalid storage access; most frequently caused by attempting to store some value in an object pointed to by a bad pointer. (Segment violation.)
signal(SIGSEGV, handle_signal);
//Termination request made to the program. (Terminate.)
signal(SIGTERM, handle_signal);
//=========================================
// STARTUP MESSAGE
//=========================================
std::cout <<
"NN NN NN NN NN NN " << std::endl <<
"NNNN NN NNNN NN NN NN NNNNN " << std::endl <<
"NN NN NN NN NN NN NNNN NN " << std::endl <<
"NN NN NN NN NN NN NN NN NN NN " << std::endl <<
"NN NN NN NN NN NN NN NN NN NNN " << std::endl <<
"NN NNNN NN NNNN NN NN NN NN " << std::endl <<
"NN NNN NN NNN NN NNN NNNN " << std::endl <<
"-------------------------------" << std::endl <<
"- Type: Realm server" << std::endl <<
"- Protocol version: " << NNY_PROTOCOL_VERSION << std::endl <<
"- MySQL version: " << MYSQL_SERVER_VERSION << std::endl <<
"-------------------------------" << std::endl;
//=========================================
// SETTING UP THE DATABASE
//=========================================
//======== Connection
if (!database::connect(g_db, "127.0.0.1", "nnyv3", "", "nnyv3", 3306)) {
std::cout << "We were unable to contact the MySQL database!" << std::endl;
} else {
std::cout << "Connected to the MySQL database." << std::endl;
}
//======== Send a query and save the result
database::result db_result = database::query(g_db, "SELECT version_nb FROM version", database::STORE_RESULT);
//======== Now we can check the result like this
if (db_result) {
database::row row = database::fetch_row(db_result); //there's only one row, we don't need a loop here
int version_nb = database::toInt(row[0]);
if (version_nb != CONFIG_SUPPORTED_DATABASE) {
std::cout << "This server supports only the v" << CONFIG_SUPPORTED_DATABASE << " database; yours is still using v" << version_nb << "." << std::endl;
}
database::free_result(db_result);
}
//=========================================
// SETTING UP WORLDLINK MANAGER
//=========================================
WORLDLINKMGR::instance()->loadWorldsFromDB(g_db);
std::cout << "World server list loaded." << std::endl;
//=========================================
// SETTING UP : `ACE_Acceptor`
//=========================================
std::cout << "Setting up acceptor..." << std::endl;
//Server port number.
const u_short port = 6131;
ACE_INET_Addr server_addr(port);
//Initialize server endpoint an register with the Reactor.
ACE_Acceptor<PacketHandler,ACE_SOCK_ACCEPTOR> acceptor(server_addr, ACE_Reactor::instance(), ACE_NONBLOCK);
//=========================================
// MAIN PROGRAM LOOP : `ACE_Reactor`
// It handles ACE_Acceptor events (like connections/deconnections) and incoming packets.
//=========================================
// Main event loop that handles packets
std::cout << "Server is now running!" << std::endl;
while(true) {
// dont move this outside the loop, the reactor will modify it
//ACE_Time_Value interval(0, 100000);
//ACE_Reactor::instance()->handle_events();
//if (ACE_Reactor::instance()->run_reactor_event_loop(interval) == -1)
if (ACE_Reactor::instance()->run_reactor_event_loop() == -1) {
std::cout << "[Debug] Reactor event loop broken! What happened?!" << std::endl;
break;
}
}
//===================================
// EXIT
//===================================
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
int ch, cocurrent = 1, count = 10, length = 1024;
bool keep_alive = false, use_ssl = false;
acl::string server_addr("127.0.0.1:1443");
acl::string domain;
// ³õʼ»¯ acl ¿â
acl::acl_cpp_init();
acl::log::stdout_open(true);
while ((ch = getopt(argc, argv, "hs:c:n:kSH:")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 'c':
cocurrent = atoi(optarg);
break;
case 'n':
count = atoi(optarg);
break;
case 'k':
keep_alive = true;
break;
case 's':
server_addr = optarg;
break;
case 'S':
use_ssl = true;
break;
case 'H':
domain = optarg;
break;
default:
break;
}
}
if (domain.empty())
domain = server_addr;
static acl::polarssl_conf ssl_conf;
struct timeval begin;
gettimeofday(&begin, NULL);
#if 0
std::list<https_client*> threads;
for (int i = 0; i < cocurrent; i++)
{
// ´´½¨Ïß³Ì
https_client* thread = new https_client(server_addr, domain,
keep_alive, count, length);
if (use_ssl)
thread->set_ssl_conf(&ssl_conf);
// ÉèÖô´½¨µÄÏß³ÌΪ·Ç·ÖÀëģʽ£¬ÒÔ±ãÓÚÏÂÃæ¿ÉÒÔµ÷Ó thread::wait
// µÈ´ýÏ߳̽áÊø
thread->set_detachable(false);
// ½«Ï̷߳ÅÔÚ¶ÓÁÐÖÐ
threads.push_back(thread);
// Æô¶¯Ïß³Ì
thread->start();
}
std::list<https_client*>::iterator it = threads.begin();
for (; it != threads.end(); ++it)
{
// µÈ´ýÏ߳̽áÊø
if ((*it)->wait(NULL) == false)
printf("wait one thread(%lu) error\r\n",
(*it)->thread_id());
/*
else
printf("wait one thread(%lu) ok\r\n",
(*it)->thread_id());
*/
// ɾ³ý¶¯Ì¬´´½¨µÄÏ̶߳ÔÏó
delete *it;
}
#else
(void) length;
std::list<https_request*> threads;
for (int i = 0; i < cocurrent; i++)
{
// ´´½¨Ïß³Ì
https_request* thread = new https_request(server_addr,
use_ssl ? &ssl_conf : NULL);
// ÉèÖô´½¨µÄÏß³ÌΪ·Ç·ÖÀëģʽ£¬ÒÔ±ãÓÚÏÂÃæ¿ÉÒÔµ÷Ó thread::wait
// µÈ´ýÏ߳̽áÊø
thread->set_detachable(false);
// ½«Ï̷߳ÅÔÚ¶ÓÁÐÖÐ
threads.push_back(thread);
// Æô¶¯Ïß³Ì
thread->start();
}
// sleep(2);
std::list<https_request*>::iterator it = threads.begin();
for (; it != threads.end(); ++it)
{
// µÈ´ýÏ߳̽áÊø
if ((*it)->wait(NULL) == false)
printf("wait one thread(%lu) error\r\n",
(*it)->thread_id());
else
printf("wait one thread(%lu) ok\r\n",
(*it)->thread_id());
// ɾ³ý¶¯Ì¬´´½¨µÄÏ̶߳ÔÏó
delete *it;
}
#endif
struct timeval end;
gettimeofday(&end, NULL);
double spent = util::stamp_sub(&end, &begin);
printf("total: %d, spent: %.2f, speed: %.f\r\n", count,
spent, (count * 1000) / (spent > 1 ? spent : 1));
printf("enter any key to exit\r\n");
getchar();
return 0;
}
static void *
client (void *arg)
{
client_data info;
info.me = client_id++;
int info_len = sizeof (client_data);
client_arg *data = (client_arg*) arg;
ACE_CLASSIX_Port_Core *server_port = data->server;
ACE_CLASSIX_Port server_addr(*server_port);
ACE_Barrier *barrier = data->wait;
//===================================================================
// Stream & Connector
//
// ACE_CLASSIX_Stream cli_stream(*server_port);
ACE_CLASSIX_Stream cli_stream;
// create a stream where the local SAP uses the actor's default port.
ACE_CLASSIX_CLD_Connector con;
// create a connector for the stream
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Connecting local and peer SAPs\n"));
// Connect local and peer SAPs.
barrier->wait();
//===================================================================
// Attempt a connect to the server...
// A local port will be created as a local SAP
if (con.connect (cli_stream, server_addr) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) %p\n",
"connection failed"),
0);
}
ACE_CLASSIX_Port client_addr;
if (cli_stream.local_sap().get_addr (client_addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) %p\n", "get_local_addr"), 0);
else
ACE_DEBUG ((LM_DEBUG, "(%P|%t) connected client at %d\n",
client_addr.get_handle ()));
//===================================================================
// Insert the local SAP to the test group
ACE_CLASSIX_Group_Stamp group(TEST_STAMP);
// group that the client's port is in
if (group.insert(&client_addr) == -1)
ACE_ERROR_RETURN((LM_ERROR,
"Failed to insert local SAP of client %d in to the"
"group \n"), -1);
//===================================================================
// Do not use Reactor, so disable local port from being monitored
int result = cli_stream.unselectable();
if (result != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) failed to disable local port(%d)\n",
result), -1);
//===================================================================
// Send data to server (correctly handles "incomplete writes").
char *c = ACE_ALPHABET;
do
{
ACE_OS::thr_yield();
info.c = *c;
if (cli_stream.send_n (&info, info_len) != info_len)
ACE_ERROR ((LM_ERROR, "(%P|%t) %p\n", "send_n"));
}while(*c++ != '\0');
//===================================================================
// Close writer
// ACE_DEBUG ((LM_DEBUG, "(%P|%t) closing writer\n"));
// Explicitly close the writer-side of the connection.
//if (cli_stream.close_writer () == -1)
// ACE_ERROR ((LM_ERROR, "(%P|%t) %p\n", "close_writer"));
// Wait for handshake with server.
client_data response;
do
{
if (cli_stream.ipcRecv_n (&response, info_len) != info_len)
ACE_ERROR ((LM_ERROR, "(%P|%t) %p\n", "recv_n"));
}
while (response.me != info.me);
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) received handshake from server\n"));
// Close the connection completely.
if (cli_stream.close () == -1)
ACE_ERROR ((LM_ERROR, "(%P|%t) %p\n", "close"));
return 0;
}
static void *
client (void *arg)
{
ACE_INET_Addr *remote_addr = reinterpret_cast<ACE_INET_Addr *> (arg);
ACE_INET_Addr server_addr (remote_addr->get_port_number (),
ACE_IPV6_LOCALHOST);
ACE_SOCK_Stream cli_stream;
ACE_SOCK_Connector con;
ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Connecting to port %d\n"),
server_addr.get_port_number()));
// Initiate connection with server; don't wait forever
if (con.connect (cli_stream,
server_addr,
&timeout) == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("connection failed")));
Test_Result = 1;
return 0;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) connected to %C\n"),
server_addr.get_host_name ()));
//******************* TEST 1 ******************************
//
// Do a iovec sendv - send the 255 byte buffer in 5 chunks. The
// server will verify that the correct data is sent, and that there
// is no more and no less.
u_char buffer[255];
size_t i;
ssize_t len;
// The server will verify that this data pattern gets there intact.
for (i = 0; i < sizeof buffer; ++i)
buffer[i] = static_cast<u_char> (i);
iovec iov[5];
iov[0].iov_base = reinterpret_cast<char *> (&buffer[0]);
iov[0].iov_len = 50;
iov[1].iov_base = reinterpret_cast<char *> (&buffer[50]);
iov[1].iov_len = 25;
iov[2].iov_base = reinterpret_cast<char *> (&buffer[75]);
iov[2].iov_len = 150;
iov[3].iov_base = reinterpret_cast<char *> (&buffer[225]);
iov[3].iov_len = 29;
iov[4].iov_base = reinterpret_cast<char *> (&buffer[254]);
iov[4].iov_len = 1;
len = cli_stream.sendv (iov, 5);
if (len == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n"),
ACE_TEXT ("Test 1, sendv failed")));
Test_Result = 1;
}
else
ACE_TEST_ASSERT (len == 255);
//******************* TEST 2 ******************************
//
// The same data is coming back - receive it using recv (size_t n,
// ...) and compare it to the original data.
u_char buffer2[255];
// Give it a chance to get here
ACE_OS::sleep (2);
len = cli_stream.recv (4,
buffer2,
150,
&buffer2[150],
105);
if (len != 255)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p; len is %d, but should be 255!\n"),
len));
}
ACE_TEST_ASSERT (len == 255);
for (i = 0; i < 255; i++)
if (buffer2[i] != buffer[i])
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) Test 2, rcvd byte %d is %d, not %d\n"),
i, buffer2[i], buffer[i]));
Test_Result = 1;
}
//******************* TEST 3 ******************************
//
// Do a send_n of a large size. The receive should sleep some to
// cause the data reception to be delayed, which will fill up the
// TCP window and cause send_n to block at some point. The particular
// case this tests only needs to be exercised if the socket is
// non-blocking, so set that first.
ssize_t sent;
char buff[Test3_Send_Size];
ACE_TEST_ASSERT (cli_stream.enable (ACE_NONBLOCK) != -1);
for (i = 0; i < Test3_Loops; ++i)
{
errno = 0;
sent = cli_stream.send_n (buff, sizeof (buff));
if (sent != sizeof (buff) && errno != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) Test 3, pass %d, sent %d, %p\n"),
i, sent, ACE_TEXT ("error")));
Test_Result = 1; // Fail
}
}
cli_stream.close ();
return 0;
}
int
main(int /*argc*/, char** /*argv*/)
{
TestPrivateKeys();
/* test a connection */
const char* hostname = "koala.bok.net";
printf("[1] Connecting to %s...\n", hostname);
NPT_Socket* client_socket = new NPT_TcpClientSocket();
NPT_IpAddress server_ip;
server_ip.ResolveName(hostname);
NPT_SocketAddress server_addr(server_ip, 443);
NPT_Result result = client_socket->Connect(server_addr);
printf("[2] Connection result = %d (%s)\n", result, NPT_ResultText(result));
if (NPT_FAILED(result)) {
printf("!ERROR\n");
return 1;
}
NPT_InputStreamReference input;
NPT_OutputStreamReference output;
client_socket->GetInputStream(input);
client_socket->GetOutputStream(output);
NPT_TlsContextReference context(new NPT_TlsContext());
NPT_TlsClientSession session(context, input, output);
printf("[3] Performing Handshake\n");
result = session.Handshake();
printf("[4] Handshake Result = %d (%s)\n", result, NPT_ResultText(result));
if (NPT_FAILED(result)) {
printf("!ERROR\n");
return 1;
}
NPT_DataBuffer session_id;
result = session.GetSessionId(session_id);
CHECK(result == NPT_SUCCESS);
CHECK(session_id.GetDataSize() > 0);
printf("[5] Session ID: ");
printf(NPT_HexString(session_id.GetData(), session_id.GetDataSize()).GetChars());
printf("\n");
NPT_TlsCertificateInfo cert_info;
result = session.GetPeerCertificateInfo(cert_info);
CHECK(result == NPT_SUCCESS);
printf("[6] Fingerprints:\n");
printf("MD5: %s\n", NPT_HexString(cert_info.fingerprint.md5, sizeof(cert_info.fingerprint.md5), ":").GetChars());
printf("SHA1: %s\n", NPT_HexString(cert_info.fingerprint.sha1, sizeof(cert_info.fingerprint.sha1), ":").GetChars());
printf("Subject Certificate:\n");
printf(" Common Name = %s\n", cert_info.subject.common_name.GetChars());
printf(" Organization = %s\n", cert_info.subject.organization.GetChars());
printf(" Organizational Name = %s\n", cert_info.subject.organizational_name.GetChars());
printf("Issuer Certificate:\n");
printf(" Common Name = %s\n", cert_info.issuer.common_name.GetChars());
printf(" Organization = %s\n", cert_info.issuer.organization.GetChars());
printf(" Organizational Name = %s\n", cert_info.issuer.organizational_name.GetChars());
printf("\n");
printf("[7] Cipher Type = %d (%s)\n", session.GetCipherSuiteId(), GetCipherSuiteName(session.GetCipherSuiteId()));
NPT_InputStreamReference ssl_input;
NPT_OutputStreamReference ssl_output;
session.GetInputStream(ssl_input);
session.GetOutputStream(ssl_output);
printf("[8] Getting / Document\n");
ssl_output->WriteString("GET / HTTP/1.0\n\n");
for (;;) {
unsigned char buffer[1];
NPT_Size bytes_read = 0;
result = ssl_input->Read(&buffer[0], 1, &bytes_read);
if (NPT_SUCCEEDED(result)) {
CHECK(bytes_read == 1);
printf("%c", buffer[0]);
} else {
if (result != NPT_ERROR_EOS) {
printf("!ERROR: Read() returned %d (%s)\n", result, NPT_ResultText(result));
}
break;
}
}
printf("[9] SUCCESS\n");
}
int main(int argc, char **argv) {
//=========================================
// STARTUP MESSAGE
//=========================================
std::cout << "NN NN NN NN NN NN " << std::endl;
std::cout << "NNNN NN NNNN NN NN NN NNNNN " << std::endl;
std::cout << "NN NN NN NN NN NN NNNN NN " << std::endl;
std::cout << "NN NN NN NN NN NN NN NN NN NN " << std::endl;
std::cout << "NN NN NN NN NN NN NN NN NN NNN " << std::endl;
std::cout << "NN NNNN NN NNNN NN NN NN NN " << std::endl;
std::cout << "NN NNN NN NNN NN NNN NNNN " << std::endl;
std::cout << "-------------------------------" << std::endl;
std::cout << "- Type: World server" << std::endl;
std::cout << "- Protocol version: " << NNY_PROTOCOL_VERSION << std::endl;
//std::cout << "- Config filename: " << CONFIG_FILENAME << std::endl;
std::cout << "-------------------------------" << std::endl;
//TestRunnable test;
//test.start();
//=========================================
// ALL TODOs
//=========================================
/// \todo We need a log system!
//=========================================
// MYSQL DATABASE
//=========================================
/*
std::cerr << "Connecting to MySQL database... ";
if (g_database.connect(CONFIG_MYSQL_SERVER, CONFIG_MYSQL_USERNAME, CONFIG_MYSQL_PASSWORD, CONFIG_MYSQL_DATABASE)) {
std::cerr << "OK!" << std::endl;
checkDatabaseVersion();
} else {
std::cerr << "Failed!" << std::endl;
std::cerr << "@ERROR: Unable to connect to the MySQL database! Please check world.conf file!" << std::endl;
//pauseServer();
}
*/
//=========================================
// MAP GRID
// Create the Grid and the default map 0
//=========================================
/*
std::cerr << "Creating map grid... ";
g_grid.createMap(0); //default map
std::cerr << "OK!" << std::endl;
*/
//=========================================
// ACCEPTOR
// Note: NULL means the server will listen
// on IP address 0.0.0.0
//=========================================
//Acceptor acceptor(NULL, CONFIG_SERVER_PORT);
//=========================================
// REALM CONNECTOR
// Create a threaded class and start it
//=========================================
//Create the realm connector object
//ThreadRealmConnector threadRealmConnector;
//Start the thread
//threadRealmConnector.start();
//=========================================
// WAITING FOR CONNECTIONS
// [MAIN PROGRAM LOOP]
//=========================================
std::cout << "Setting up acceptor..." << std::endl;
// Server port number.
const u_short port = 6132;
ACE_INET_Addr server_addr(port);
// Initialize server endpoint an register with the Reactor.
ACE_Acceptor<PacketHandler,ACE_SOCK_ACCEPTOR> acceptor(server_addr, ACE_Reactor::instance(), ACE_NONBLOCK);
// Main event loop that handles packets
std::cout << "Server is now running!" << std::endl;
while(true) {
// dont move this outside the loop, the reactor will modify it
//ACE_Time_Value interval(0, 100000);
//ACE_Reactor::instance()->handle_events();
//if (ACE_Reactor::instance()->run_reactor_event_loop(interval) == -1)
if (ACE_Reactor::instance()->run_reactor_event_loop() == -1) {
std::cout << "[Debug] Reactor event loop broken! What happened?!" << std::endl;
break;
}
}
//===================================
// Exit
//===================================
return 0;
}
