int main(int argc, char* argv[])
{
if (argc < 4) {
std::cout << "Usage: " << argv[0] << "<host> <port> <local/remote>" << std::endl;
exit(1);
}
NetworkOptions options;
options.set_host(argv[1]);
options.set_port(atoi(argv[2]));
options.set_max_packet_size(1024);
if (strcmp(argv[3], "local") == 0) {
options.set_socket_family(PF_UNIX);
options.set_sin_path("/tmp/__echoserver__");
} else {
options.set_socket_family(PF_INET);
}
bool perf = false;
if (argc > 4 && strcmp(argv[4], "perf") == 0)
perf = true;
EventLoopImpl ss;
EchoClient echo_client(&ss, options, perf);
echo_client.Start();
ss.loop();
return 0;
}
void test_echo_service()
{
service_class_thread = nullptr;
// Create a server on port 12345
fr::socket::socket_server<fr::socket::server_body<echo_service> > my_echo_server(12345);
my_echo_server.thread_spawned.connect(boost::bind(&test_client_server::set_service_class_thread, this, _1));
boost::thread *server_thread = my_echo_server.start();
// Give the server time to start
boost::this_thread::yield();
fr::socket::socket_client echo_client("localhost", 12345);
std::string expected("Hello, sockets!");
std::string actual;
echo_client.streams->stream_out << expected << std::endl;
getline(echo_client.streams->stream_in, actual);
// std::cout << std::endl << "Expected: \"" << expected << "\"" << std::endl;
// std::cout << "Actual: \"" << actual << "\"" << std::endl;
CPPUNIT_ASSERT(expected == actual);
my_echo_server.shutdown();
// Poke the echo server so it exits. IRL using blocking reads in
// your server code opens a sack of pain. For this test, it was
// a significantly smaller sack of pain than having to deal with
// select and signals or polling the stream and building the
// string up that way. No matter how you go about it, there's always
// a good bit of suck associated with threaded I/O.
echo_client.streams->stream_out << std::endl;
if (nullptr == service_class_thread) {
CPPUNIT_FAIL("Service class thread never signaled");
}
service_class_thread->join();
delete service_class_thread;
server_thread->join();
}
uint future_prod(future *fut)
{
int i, j;
j = (int)fut;
j = echo_client();
future_set(fut, &j);
return OK;
}
int main(int argc, char** argv)
{
if (argc != 3)
{
fprintf(stderr, "USAGE:%s serverAddr serverPort\n", argv[0]);
exit(-1);
}
signal(SIGPIPE, sig_pipe);
int connport = atoi(argv[2]);
struct sockaddr_in connaddr;
connaddr.sin_family = AF_INET;
inet_pton(AF_INET, argv[1], &(connaddr.sin_addr.s_addr));
connaddr.sin_port = htons(connport);
socklen_t connaddrlen = sizeof(connaddr);
int connnu = 1;
int connfd[connnu];
for (int i = 0; i < connnu; i++)
{
connfd[i] = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in clientaddr;
clientaddr.sin_family = AF_INET;
if ((inet_aton("192.168.13.200", (in_addr*)&clientaddr.sin_addr.s_addr)) == 0)
{
}
//clientaddr.sin_addr.s_addr = htonl("192.168.13.200");
clientaddr.sin_port = htons(0);
int binderror = 0;
if ( 0 > (binderror = bind(connfd[i], (struct sockaddr*)&clientaddr, sizeof(clientaddr))))
{
perror("bind error when port is 0");
}
printf("binderror:%d\n", binderror);
if (connfd[i] == -1)
{
}
if (FAILED == connect(connfd[i], (const struct sockaddr*)&connaddr, connaddrlen))
{
perror("connect error.");
exit(-1);
}
}
echo_client(stdin, connfd[0]);
}
int main(int argc, char** argv)
{
if (argc != 3) {
std::cout << "usage: serv_ip serv_port" << std::endl;
return 0;
}
udp_echo_client echo_client(argv[1], atoi(argv[2]));
echo_client.start();
return 0;
}
int main(int argc, char *argv[])
{
struct addrinfo *result;
int sfd;
int status;
const char *host;
const char *port;
const char *msg;
if (argc < 3)
{
fprintf(stderr, "Usage: %s host port msg\n", argv[0]);
exit(__LINE__);
}
host = argv[1];
port = argv[2];
msg = argv[3];
/* Get address information on specified host and port. */
status = get_server_addr_info(host, port, &result);
if (status != 0)
{
exit(status);
}
/* Go through each addrinfo and try to open a socket an
* connect to it. Either use the first one or exit.
*/
status = get_connected_socket(result, &sfd);
if (status != 0)
{
exit(status);
}
freeaddrinfo(result);
/* Send specified message as a separat datagram and read
* the response from the server.
*/
status = echo_client(sfd, msg);
if (status != 0)
{
exit(status);
}
return 0;
}
static void fiber_accept(void *ctx)
{
ACL_VSTREAM *sstream = (ACL_VSTREAM *) ctx;
for (;;) {
ACL_VSTREAM *cstream = acl_vstream_accept(sstream, NULL, 0);
if (cstream == NULL) {
printf("acl_vstream_accept error %s\r\n",
acl_last_serror());
break;
}
printf("accept one\r\n");
echo_client(cstream);
}
acl_vstream_close(sstream);
}
int main()
{
int socketfd[5];
int ret;
int i;
for (i=0; i<5; i++) {
socketfd[i] = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (socketfd[i] < 0) {
ERR_EXIT("socket");
}
struct sockaddr_in serveraddr;
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(5188);
serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
ret = connect(socketfd[i], (const struct sockaddr *)&serveraddr,
(socklen_t)sizeof(serveraddr));
if (ret < 0) {
ERR_EXIT("connect");
}
struct sockaddr_in localaddr;
socklen_t addrlen = sizeof(localaddr);
//int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
ret = getsockname(socketfd[i], (struct sockaddr *)&localaddr, &addrlen);
if (ret < 0)
exit(EXIT_FAILURE);
printf("local ip address: %s, local port:%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));
}
echo_client(socketfd[0]);
return 0;
}
int test_inner(void)
{
pj_caching_pool caching_pool;
const char *filename;
int line;
int rc = 0;
mem = &caching_pool.factory;
pj_log_set_level(3);
pj_log_set_decor(param_log_decor);
rc = pj_init();
if (rc != 0) {
app_perror("pj_init() error!!", rc);
return rc;
}
//pj_dump_config();
pj_caching_pool_init( &caching_pool, NULL, 0 );
#if INCLUDE_ERRNO_TEST
DO_TEST( errno_test() );
#endif
#if INCLUDE_EXCEPTION_TEST
DO_TEST( exception_test() );
#endif
#if INCLUDE_OS_TEST
DO_TEST( os_test() );
#endif
#if INCLUDE_RAND_TEST
DO_TEST( rand_test() );
#endif
#if INCLUDE_LIST_TEST
DO_TEST( list_test() );
#endif
#if INCLUDE_POOL_TEST
DO_TEST( pool_test() );
#endif
#if INCLUDE_POOL_PERF_TEST
DO_TEST( pool_perf_test() );
#endif
#if INCLUDE_STRING_TEST
DO_TEST( string_test() );
#endif
#if INCLUDE_FIFOBUF_TEST
DO_TEST( fifobuf_test() );
#endif
#if INCLUDE_RBTREE_TEST
DO_TEST( rbtree_test() );
#endif
#if INCLUDE_HASH_TEST
DO_TEST( hash_test() );
#endif
#if INCLUDE_TIMESTAMP_TEST
DO_TEST( timestamp_test() );
#endif
#if INCLUDE_ATOMIC_TEST
DO_TEST( atomic_test() );
#endif
#if INCLUDE_MUTEX_TEST
DO_TEST( mutex_test() );
#endif
#if INCLUDE_TIMER_TEST
DO_TEST( timer_test() );
#endif
#if INCLUDE_SLEEP_TEST
DO_TEST( sleep_test() );
#endif
#if INCLUDE_THREAD_TEST
DO_TEST( thread_test() );
#endif
#if INCLUDE_SOCK_TEST
DO_TEST( sock_test() );
#endif
#if INCLUDE_SOCK_PERF_TEST
DO_TEST( sock_perf_test() );
#endif
#if INCLUDE_SELECT_TEST
DO_TEST( select_test() );
#endif
#if INCLUDE_UDP_IOQUEUE_TEST
DO_TEST( udp_ioqueue_test() );
#endif
#if PJ_HAS_TCP && INCLUDE_TCP_IOQUEUE_TEST
DO_TEST( tcp_ioqueue_test() );
#endif
#if INCLUDE_IOQUEUE_PERF_TEST
DO_TEST( ioqueue_perf_test() );
#endif
#if INCLUDE_IOQUEUE_UNREG_TEST
DO_TEST( udp_ioqueue_unreg_test() );
#endif
#if INCLUDE_ACTIVESOCK_TEST
DO_TEST( activesock_test() );
#endif
#if INCLUDE_FILE_TEST
DO_TEST( file_test() );
#endif
#if INCLUDE_SSLSOCK_TEST
DO_TEST( ssl_sock_test() );
#endif
#if INCLUDE_ECHO_SERVER
//echo_server();
//echo_srv_sync();
udp_echo_srv_ioqueue();
#elif INCLUDE_ECHO_CLIENT
if (param_echo_sock_type == 0)
param_echo_sock_type = pj_SOCK_DGRAM();
echo_client( param_echo_sock_type,
param_echo_server,
param_echo_port);
#endif
goto on_return;
on_return:
pj_caching_pool_destroy( &caching_pool );
PJ_LOG(3,("test", ""));
pj_thread_get_stack_info(pj_thread_this(), &filename, &line);
PJ_LOG(3,("test", "Stack max usage: %u, deepest: %s:%u",
pj_thread_get_stack_max_usage(pj_thread_this()),
filename, line));
if (rc == 0)
PJ_LOG(3,("test", "Looks like everything is okay!.."));
else
PJ_LOG(3,("test", "Test completed with error(s)"));
pj_shutdown();
return 0;
}
