std::string& port, bool& print_errors) {

const std::string PORT = "5001";

const std::string LOCAL_LOOP = "127.0.0.1";

const std::string USAGE =

"usage:\n"

" ./chat_server [-h] [-e] [port]\n"

" -h print usage\n"

" -e print all error messages to console\n"

" default port = " + PORT + "\n"

" server IP address (fixed) = " + LOCAL_LOOP + " (local loop)";

const std::string HELP_PRM = "-h";

const std::string ERR_PRM = "-e";

// set default values

ip_addr = LOCAL_LOOP;

port = PORT;

if (argc > 3 || (argc == 2 && argv[1] == HELP_PRM)) {

std::cout << USAGE << std::endl;

return EXIT_FAILURE;

}

if (argc == 2) {

if (argv[1] == ERR_PRM) {

print_errors = true;

} else {

port = argv[1];

}

}

if (argc == 3) {

if (argv[1] == ERR_PRM) {

print_errors = true;

port = argv[2];

} else {

std::cout << USAGE << std::endl;

return EXIT_FAILURE;

}

}

return EXIT_SUCCESS;

{

const std::string LOCAL = "[local] ";

const std::string SYSTEM = "[system] ";

const std::string SERVER = "[server] ";

const std::string DELIM = "\a"; // alert (bell)

std::string ip_addr;

std::string port;

bool print_errors = false;

bool finished = false;

if (process_args(argc, argv, ip_addr, port, print_errors) == EXIT_FAILURE) {

return EXIT_FAILURE;

}

// work guard - handles @c std::thread and @c asio::io_context management

chops::net::worker wk;

wk.start();

// handles all @c io_interfaces

// REVIEW WITH CLIFF

chops::net::send_to_all<chops::net::tcp_io> sta;

/* lamda handlers */

// receive text from client, send out to others

const auto msg_hndlr = [finished, &sta, &DELIM](const_buf buf, io_output io_out, endpoint ep) {

if (finished) {

return false;

}

// retransmit message

const std::string s (static_cast<const char*> (buf.data()), buf.size());

if (s == "quit" + DELIM) {

// send 'quit' to originator

// originator needs message for io_state_change halt

io_out.send(buf.data(), buf.size());

} else {

// not 'quit' (normal message)

// so send message to all but originator

// REVIEW WITH CLIFF - send to all?

sta.send(buf.data(), buf.size(), io_out);

}

return true;

};

const auto io_state_chng_hndlr = [&sta, &msg_hndlr, &DELIM]

(io_interface iof, std::size_t n, bool flag) {

// add to or remove @c io_interface from list in sta

sta(iof, n, flag);

if (flag) {

auto e{iof.start_io(DELIM, msg_hndlr)};

}

};

const auto err_func = [&print_errors](io_interface iof, std::error_code err) {

if (print_errors) {

std::cerr << err << ", " << err.message() << std::endl;

}

};

// create @c net_ip instance

chops::net::net_ip server(wk.get_io_context());

// make @c tcp_acceptor, ruitn @c network_entity

auto net_entity = server.make_tcp_acceptor(port.c_str());

assert(net_entity.is_valid());

// start network entity, emplace handlers

auto se{net_entity.start(io_state_chng_hndlr, err_func)};

std::cout << "chops-net-ip chat server demo" << std::endl;

std::cout << " port: " << port << std::endl;

if (print_errors) {

std::cout << " all error messages printed to console" << std::endl;

}

while (!finished) {

std::string s;

std::cout << "press return to exit" << std::endl;

getline(std::cin, s);

// ignore any user input

// notify clients of server shutdown

s = "server shutting down..." + DELIM;

sta.send(s.data(), s.size());

finished = true;

}

// delay so message gets sent

std::this_thread::sleep_for(std::chrono::milliseconds(1000));

// shutdown

std::cerr << "shutdown...\n";

auto e{net_entity.stop()};

std::this_thread::sleep_for(std::chrono::milliseconds(200));

wk.stop();

return EXIT_SUCCESS;