/*************************************************************************** * Copyright (C) 2001 by Rick L. Vinyard, Jr. * * rvinyard@cs.nmsu.edu * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU Lesser General Public License as * * published by the Free Software Foundation version 2.1. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ #include <conexus/conexus.h> #include <iostream> int main(int argc, char* argv[]) { Conexus::init(); // declare the local TCP connection point Conexus::IPv4::TCP tcp; // declare the address object that will be used to specify the destination Conexus::IPv4::Address addr; // The data to send char data[] = "0123456789"; // Some default values for host and port char defaulthost[] = "127.0.0.1"; char* host = defaulthost; int port = 1500; // Check to see if user provided command line arguments and change // host and port variables if necessary if (argc > 1) host = argv[1]; if (argc > 2) port = atoi(argv[2]); // Set the address object to the destination hostname and port addr.set_address(host); addr.set_port(port); tcp.connect(addr); // Example of using the connect and send method. The send method doesn't // require an address, but instead requires a connected UDP object and // just sends to the connected destination. tcp.write(data, 11); std::cout << "1 transmitted" << std::endl; Conexus::Data d(data, 11); tcp << d; std::cout << "2 transmitted" << std::endl; return 0; }
/*************************************************************************** * Copyright (C) 2001 by Rick L. Vinyard, Jr. * * rvinyard@cs.nmsu.edu * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU Lesser General Public License as * * published by the Free Software Foundation version 2.1. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ #include <conexus/conexus.h> #include <sys/types.h> #include <unistd.h> #include <iostream> #include <vector> std::vector<Conexus::Endpoint::pointer> connections; void on_new_connection(Conexus::Endpoint::pointer endpoint); void print_data1(Conexus::Data d); void print_data2(Conexus::Data d); void print_data3(Conexus::Data d); int main() { // Initialize the Conexus library // This is needed because we will use threaded servers and this // will do all the behind the scenes work to initialize pthreads Conexus::init(); // Declare the udp object Conexus::IPv4::TCPServer tcp; // Set the port tcp.local_interface().set_port(1500); // The server connect method connects a provided sigc++ slot that will be called // back when the server receives any data. tcp.signal_new_endpoint().connect(sigc::ptr_fun(&on_new_connection)); // Start the server. The server will spawn a separate thread to service // received data, so this call will immediately return after the thread // is spawned. tcp.start(); std::cout << "Main thread pid: " << pthread_self() << std::endl; // Set up a loop that will run for 20 seconds and print the time every 5 // seconds. Since the server is threaded, the sleep(1) call will not effect // the servicing thread. std::cout << "Starting..." << std::endl; for (int i=1; i <= 20; i++) { if (i%5 == 0) std::cout << "Time: " << i << std::endl; sleep(1); } // Stop the server and prepare for shutdown tcp.stop(); return 0; } void on_new_connection(Conexus::Endpoint::pointer endpoint) { endpoint->signal_data().connect(sigc::ptr_fun(&print_data1)); endpoint->signal_data().connect(sigc::ptr_fun(&print_data2)); endpoint->signal_data().connect(sigc::ptr_fun(&print_data3)); endpoint->start(); connections.push_back(endpoint); } // These are the three callback functions. Each simply prints out the data received. void print_data1(Conexus::Data d) { std::cout << "Responding thread pid: " << pthread_self() << std::endl; std::cout << "<1> Received " << d.size(); if (d.size() > 0) std::cout << " bytes of data (" << *((uint64_t*)(Conexus::Data::Octet*)d) << ") [" << d << "]"; std::cout << std::endl; } void print_data2(Conexus::Data d) { std::cout << "Responding thread pid: " << pthread_self() << std::endl; std::cout << "<2> Received " << d.size(); if (d.size() > 0) std::cout << " bytes of data (" << *((uint64_t*)(Conexus::Data::Octet*)d) << ") [" << d << "]"; std::cout << std::endl; } void print_data3(Conexus::Data d) { std::cout << "Responding thread pid: " << pthread_self() << std::endl; std::cout << "<3> Received " << d.size(); if (d.size() > 0) std::cout << " bytes of data (" << *((uint64_t*)(Conexus::Data::Octet*)d) << ") [" << d << "]"; std::cout << std::endl; }
/*************************************************************************** * Copyright (C) 2001 by Rick L. Vinyard, Jr. * * rvinyard@cs.nmsu.edu * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU Lesser General Public License as * * published by the Free Software Foundation version 2.1. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ #include <conexus/conexus.h> #include <iostream> void print_data(Conexus::Data d); int main(int argc, char* argv[]) { Conexus::init(); // declare the local UDP connection point Conexus::IPv4::TCP tcp; // declare the address object that will be used to specify the destination Conexus::IPv4::Address addr; // The data to send char data[] = "0123456789"; // Some default values for host and port char defaulthost[] = "127.0.0.1"; char* host = defaulthost; int port = 1500; // Check to see if user provided command line arguments and change // host and port variables if necessary if (argc > 1) host = argv[1]; if (argc > 2) port = atoi(argv[2]); // Set the address object to the destination hostname and port addr.set_address(host); addr.set_port(port); tcp.connect(addr); tcp.signal_data().connect(sigc::ptr_fun(&print_data)); // Start the server. The server will spawn a separate thread to service // received data, so this call will immediately return after the thread // is spawned. tcp.start(); std::cout << "Main thread pid: " << pthread_self() << std::endl; // Set up a loop that will run for 20 seconds and print the time every 5 // seconds. Since the server is threaded, the sleep(1) call will not effect // the servicing thread. std::cout << "Starting..." << std::endl; for (int i=1; i <= 20; i++) { if (i%5 == 0) std::cout << "Time: " << i << std::endl; if (i == 3) { std::cout << "1 transmitted" << std::endl; tcp.write(data, 11); } if (i == 6) { Conexus::Data d(data, 11); std::cout << "2 transmitted" << std::endl; tcp << d; } sleep(1); } // Stop the server and prepare for shutdown tcp.stop(); return 0; } void print_data(Conexus::Data d) { std::cout << "Responding thread pid: " << pthread_self() << std::endl; std::cout << "<**> Echo Received " << d.size(); if (d.size() > 0) std::cout << " bytes of data (" << *((uint64_t*)(Conexus::Data::Octet*)d) << ") [" << d << "]"; std::cout << std::endl; }
/*************************************************************************** * Copyright (C) 2001 by Rick L. Vinyard, Jr. * * rvinyard@cs.nmsu.edu * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU Lesser General Public License as * * published by the Free Software Foundation version 2.1. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the * * Free Software Foundation, Inc., * * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ #include <conexus/conexus.h> #include <sys/types.h> #include <unistd.h> #include <iostream> #include <vector> std::vector<Conexus::Endpoint::pointer> connections; void on_new_connection(Conexus::Endpoint::pointer endpoint); void echo_data(Conexus::Data d, Conexus::Endpoint::pointer endpoint); int main() { // Initialize the Conexus library // This is needed because we will use threaded servers and this // will do all the behind the scenes work to initialize pthreads Conexus::init(); // Declare the udp object Conexus::IPv4::TCPServer tcp; // Set the port tcp.local_interface().set_port(1500); // The server connect method connects a provided sigc++ slot that will be called // back when the server receives any data. tcp.signal_new_endpoint().connect(sigc::ptr_fun(&on_new_connection)); // Start the server. The server will spawn a separate thread to service // received data, so this call will immediately return after the thread // is spawned. tcp.start(); std::cout << "Main thread pid: " << pthread_self() << std::endl; // Set up a loop that will run for 20 seconds and print the time every 5 // seconds. Since the server is threaded, the sleep(1) call will not effect // the servicing thread. std::cout << "Starting..." << std::endl; for (int i=1; i <= 20; i++) { if (i%5 == 0) std::cout << "Time: " << i << std::endl; sleep(1); } // Stop the server and prepare for shutdown tcp.stop(); return 0; } void on_new_connection(Conexus::Endpoint::pointer endpoint) { endpoint->signal_data().connect(sigc::bind(sigc::ptr_fun(&echo_data),endpoint)); endpoint->start(); connections.push_back(endpoint); } // These are the three callback functions. Each simply prints out the data received. void echo_data(Conexus::Data d, Conexus::Endpoint::pointer endpoint) { std::cout << "Responding thread pid: " << pthread_self() << std::endl; std::cout << "<**> Received " << d.size(); if (d.size() > 0) std::cout << " bytes of data (" << *((uint64_t*)(Conexus::Data::Octet*)d) << ") [" << d << "]"; std::cout << std::endl; endpoint->write(d); }