virtual int initialize()
{
set_batch_process(false);
set_listen_port(MOCK_SERVER_LISTEN_PORT);
set_dev_name("bond0");
set_packet_factory(&factory_);
set_default_queue_size(100);
set_thread_count(1);
set_packet_factory(&factory_);
ObSingleServer::initialize();
return OB_SUCCESS;
}
int read_config_file(char *config_filename)
{
FILE *fd;
char *p;
char textline[LINEBUFFER];
int ret;
if ((fd = fopen(config_filename, "r")) == NULL)
return 1;
while (fgets(textline, LINEBUFFER - 1, fd) != NULL) {
/* We ignore blank lines and comments */
if (textline[0] == '\n' || textline[0] == '#')
continue;
p = strtok(textline, " \t\n");
if (strncasecmp("server", p, 4) == 0) {
int ret;
p = strtok(NULL, " \t\n");
ret = set_server(p);
if (ret) {
/* error */
fflush(stderr);
fflush(stdout);
fprintf(stderr, "Server IP unknown.\n");
exit(1);
}
} else if (strncasecmp("logfile", p, 7) == 0) {
p = strtok(NULL, " \t\n");
open_log(p);
} else if (strncasecmp("background", p, 10) == 0) {
p = strtok(NULL, " \t\n");
set_background(p);
} else if (strncasecmp("logo", p, 4) == 0) {
p = strtok(NULL, " \t\n");
set_logo(p);
} else if (strncasecmp("foreground", p, 10) == 0) {
p = strtok(NULL, " \t\n");
set_foreground(p);
} else if (strncasecmp("port", p, 4) == 0) {
p = strtok(NULL, " \t\n");
set_listen_port(p);
}
}
ret = fclose(fd);
return ret;
}
/* The class */
Opal::Sip::EndPoint::EndPoint (Opal::CallManager & _manager,
Ekiga::ServiceCore & _core,
unsigned _listen_port)
: SIPEndPoint (_manager),
manager (_manager),
core (_core),
presence_core (*(dynamic_cast<Ekiga::PresenceCore *> (core.get ("presence-core")))),
runtime (*(dynamic_cast<Ekiga::Runtime *> (core.get ("runtime")))),
account_core (*(dynamic_cast<Ekiga::AccountCore *> (core.get ("account-core"))))
{
Ekiga::ChatCore* chat_core;
protocol_name = "sip";
uri_prefix = "sip:";
listen_port = _listen_port;
chat_core = dynamic_cast<Ekiga::ChatCore *> (core.get ("chat-core"));
dialect = new SIP::Dialect (core, sigc::mem_fun (this, &Opal::Sip::EndPoint::send_message));
chat_core->add_dialect (*dialect);
/* Timeouts */
SetAckTimeout (PTimeInterval (0, 32));
SetPduCleanUpTimeout (PTimeInterval (0, 1));
SetInviteTimeout (PTimeInterval (0, 6));
SetNonInviteTimeout (PTimeInterval (0, 6));
SetRetryTimeouts (500, 4000);
SetMaxRetries (8);
/* Start listener */
set_listen_port (listen_port);
/* Update the User Agent */
SetUserAgent ("Ekiga/" PACKAGE_VERSION);
/* Ready to take calls */
manager.AddRouteEntry("sip:.* = pc:<db>");
manager.AddRouteEntry("pc:.* = sip:<da>");
/* NAT Binding */
SetNATBindingRefreshMethod (SIPEndPoint::EmptyRequest);
Ekiga::PersonalDetails *details = dynamic_cast<Ekiga::PersonalDetails *> (_core.get ("personal-details"));
if (details)
publish (*details);
}
void
Opal::Sip::EndPoint::setup (std::string setting)
{
if (setting.empty () || setting == "listen-port") {
set_listen_port (settings->get_int ("listen-port"));
}
if (setting.empty () || setting == "binding-timeout") {
set_nat_binding_delay (settings->get_int ("binding-timeout"));
}
if (setting.empty () || setting == "outbound-proxy-host") {
set_outbound_proxy (settings->get_string ("outbound-proxy-host"));
}
if (setting.empty () || setting == "dtmf-mode") {
set_dtmf_mode (settings->get_enum ("dtmf-mode"));
}
if (setting.empty () || setting == "forward-host") {
set_forward_uri (settings->get_string ("forward-host"));
}
}
void Opal::Sip::CallManager::setup (const std::string & setting)
{
if (!endpoint.IsReady ()) {
endpoint.ready.connect (boost::bind (&Opal::Sip::CallManager::setup, this, ""));
return;
}
if (setting.empty () || setting == "instance-id") {
std::string instance_id = sip_settings->get_string ("instance-id");
if (!instance_id.empty ())
sip_endpoint.SetInstanceID (instance_id);
}
if (setting.empty () || setting == "listen-port")
set_listen_port (sip_settings->get_int ("listen-port"));
if (setting.empty () || setting == "keepalive-interval") {
int delay = sip_settings->get_int ("keepalive-interval");
PTRACE (4, "Opal::Sip::CallManager\tKeepalive interval set to " << delay);
sip_endpoint.SetKeepAlive (PTimeInterval (0, delay), SIPEndPoint::KeepAliveByOPTION);
}
if (setting.empty () || setting == "dtmf-mode")
set_dtmf_mode (sip_settings->get_enum ("dtmf-mode"));
/* Setup the various forwarding targets.
* The no answer delay is defined in the opal-call-manager (our parent).
*/
if (setting.empty () || setting == "forward-on-no-anwer" || setting == "forward-host")
sip_endpoint.SetNoAnswerForwardTarget (call_forwarding_settings->get_bool ("forward-on-no-answer") ? sip_settings->get_string ("forward-host") : "");
if (setting.empty () || setting == "forward-on-busy" || setting == "forward-host")
sip_endpoint.SetBusyForwardTarget (call_forwarding_settings->get_bool ("forward-on-busy") ? sip_settings->get_string ("forward-host") : "");
if (setting.empty () || setting == "always-forward" || setting == "forward-host")
sip_endpoint.SetUnconditionalForwardTarget (call_forwarding_settings->get_bool ("always-forward") ? sip_settings->get_string ("forward-host") : "");
Opal::CallManager::setup (setting);
}
/* The class */
Opal::Sip::EndPoint::EndPoint (Opal::CallManager & _manager,
Ekiga::ServiceCore& core):
SIPEndPoint (_manager),
manager (_manager)
{
boost::shared_ptr<Ekiga::ChatCore> chat_core = core.get<Ekiga::ChatCore> ("chat-core");
protocol_name = "sip";
uri_prefix = "sip:";
listen_port = gm_conf_get_int (SIP_KEY "listen_port");
listen_port = (listen_port > 0 ? listen_port : 5060);
dialect = boost::shared_ptr<SIP::Dialect>(new SIP::Dialect (core, boost::bind (&Opal::Sip::EndPoint::send_message, this, _1, _2)));
chat_core->add_dialect (dialect);
/* Timeouts */
SetAckTimeout (PTimeInterval (0, 32));
SetPduCleanUpTimeout (PTimeInterval (0, 1));
SetInviteTimeout (PTimeInterval (0, 60));
SetNonInviteTimeout (PTimeInterval (0, 6));
SetRetryTimeouts (500, 4000);
SetMaxRetries (8);
/* Start listener */
set_listen_port (listen_port);
/* Update the User Agent */
SetUserAgent ("Ekiga/" PACKAGE_VERSION);
/* Ready to take calls */
manager.AddRouteEntry("sip:.* = pc:*");
manager.AddRouteEntry("pc:.* = sip:<da>");
/* NAT Binding */
SetNATBindingRefreshMethod (SIPEndPoint::Options);
}
int ObChunkServer::initialize()
{
int ret = OB_SUCCESS;
// do not handle batch packet.
// process packet one by one.
set_batch_process(false);
// read configure item value from configure file.
// this step is the very first thing.
ret = param_.load_from_config();
// set listen port
if (OB_SUCCESS == ret)
{
ret = set_listen_port(param_.get_chunk_server_port());
}
if (OB_SUCCESS == ret)
{
ret = set_dev_name(param_.get_dev_name());
if (OB_SUCCESS == ret)
{
ret = set_self(param_.get_dev_name(),
param_.get_chunk_server_port());
}
}
// task queue and work thread count
if (OB_SUCCESS == ret)
{
ret = set_default_queue_size(param_.get_task_queue_size());
}
if (OB_SUCCESS == ret)
{
ret = set_thread_count(param_.get_task_thread_count());
}
if (OB_SUCCESS == ret)
{
ret = set_min_left_time(param_.get_task_left_time());
}
// set packet factory object.
if (OB_SUCCESS == ret)
{
ret = set_packet_factory(&packet_factory_);
}
// initialize client_manager_ for server remote procedure call.
if (OB_SUCCESS == ret)
{
ret = client_manager_.initialize(get_transport(), get_packet_streamer());
}
if (OB_SUCCESS == ret)
{
ret = rs_rpc_stub_.init( param_.get_root_server(), &client_manager_);
}
if (OB_SUCCESS == ret)
{
ret = tablet_manager_.init(¶m_);
}
// server initialize, including start transport,
// listen port, accept socket data from client
if (OB_SUCCESS == ret)
{
ret = ObSingleServer::initialize();
}
if (OB_SUCCESS == ret)
{
ret = service_.initialize(this);
}
return ret;
}
int ObMergeServer::initialize()
{
int ret = OB_SUCCESS;
// disable batch process mode
set_batch_process(false);
if (ret == OB_SUCCESS)
{
// set max memory size limit
ob_set_memory_size_limit(ms_config_.memory_size_limit_percentage
* sysconf(_SC_PHYS_PAGES)
* sysconf(_SC_PAGE_SIZE) / 100);
}
if (ret == OB_SUCCESS)
{
memset(&server_handler_, 0, sizeof(easy_io_handler_pt));
server_handler_.encode = ObTbnetCallback::encode;
server_handler_.decode = ObTbnetCallback::decode;
server_handler_.process = ObMergeCallback::process;
//server_handler_.batch_process
server_handler_.get_packet_id = ObTbnetCallback::get_packet_id;
server_handler_.on_disconnect = ObTbnetCallback::on_disconnect;
server_handler_.user_data = this;
}
if (ret == OB_SUCCESS)
{
ret = set_listen_port((int32_t)ms_config_.port);
}
if (ret == OB_SUCCESS)
{
ret = set_dev_name(ms_config_.devname);
if (OB_SUCCESS == ret)
{
ret = set_self(ms_config_.devname,
(int32_t)ms_config_.port);
}
}
if (ret == OB_SUCCESS)
{
set_self_to_thread_queue(self_);
}
if (ret == OB_SUCCESS)
{
ret = init_root_server();
}
if (ret == OB_SUCCESS)
{
ret = set_default_queue_size((int32_t)ms_config_.task_queue_size);
}
if (ret == OB_SUCCESS)
{
ret = set_io_thread_count((int32_t)ms_config_.io_thread_count);
}
if (ret == OB_SUCCESS)
{
ret = set_thread_count((int32_t)ms_config_.task_thread_count);
}
if (ret == OB_SUCCESS)
{
log_interval_count_ = ms_config_.log_interval_count;
ret = set_min_left_time(ms_config_.task_left_time);
}
if (ret == OB_SUCCESS)
{
ret = frozen_data_cache_.init(ms_config_.frozen_data_cache_size);
}
if (ret == OB_SUCCESS)
{
ret = insert_cache_.init(ms_config_.bloom_filter_cache_size);
}
if (ret == OB_SUCCESS)
{
ret = scan_req_pool_.init();
}
if (ret == OB_SUCCESS)
{
ret = get_req_pool_.init();
}
if (ret == OB_SUCCESS)
{
ret = task_timer_.init();
}
if (OB_SUCCESS == ret)
{
ret = client_manager_.initialize(eio_, &server_handler_);
}
if (ret == OB_SUCCESS)
{
ret = ObSingleServer::initialize();
}
if (ret == OB_SUCCESS)
{
ret = service_.initialize(this);
}
return ret;
}
void Opal::H323::CallManager::setup (const std::string & setting)
{
if (!endpoint.IsReady ()) {
endpoint.ready.connect (boost::bind (&Opal::H323::CallManager::setup, this, ""));
return;
}
if (setting.empty () || setting == "listen-port")
set_listen_port (h323_settings->get_int ("listen-port"));
if (setting.empty () || setting == "maximum-video-tx-bitrate") {
// maximum_video_tx_bitrate is the max video bitrate specified by the user
// add to it 10% (approx.) accounting for audio,
// and multiply it by 10 as needed by SetInitialBandwidth
int maximum_video_tx_bitrate = video_codecs_settings->get_int ("maximum-video-tx-bitrate");
h323_endpoint.SetInitialBandwidth (OpalBandwidth::Tx, maximum_video_tx_bitrate > 0 ? maximum_video_tx_bitrate * 11 : 100000);
PTRACE (4, "Opal::H323::EndPoint\tSet maximum/initial tx bandwidth to " << maximum_video_tx_bitrate * 11);
}
if (setting.empty () || setting == "enable-h245-tunneling") {
h323_endpoint.DisableH245Tunneling (!h323_settings->get_bool ("enable-h245-tunneling"));
PTRACE (4, "Opal::H323::EndPoint\tH.245 Tunneling: " << h323_settings->get_bool ("enable-h245-tunneling"));
}
if (setting.empty () || setting == "enable-early-h245") {
h323_endpoint.DisableH245inSetup (!h323_settings->get_bool ("enable-early-h245"));
PTRACE (4, "Opal::H323::EndPoint\tEarly H.245: " << h323_settings->get_bool ("enable-early-h245"));
}
if (setting.empty () || setting == "enable-fast-connect") {
h323_endpoint.DisableFastStart (!h323_settings->get_bool ("enable-fast-connect"));
PTRACE (4, "Opal::H323::EndPoint\tFast Connect: " << h323_settings->get_bool ("enable-fast-connect"));
}
if (setting.empty () || setting == "dtmf-mode") {
set_dtmf_mode (h323_settings->get_enum ("dtmf-mode"));
}
/* Setup the various forwarding targets.
* The no answer delay is defined in the opal-call-manager (our parent).
*/
if (setting.empty () || setting == "forward-on-no-anwer" || setting == "forward-host")
h323_endpoint.SetNoAnswerForwardTarget (call_forwarding_settings->get_bool ("forward-on-no-answer") ? h323_settings->get_string ("forward-host") : "");
if (setting.empty () || setting == "forward-on-busy" || setting == "forward-host")
h323_endpoint.SetBusyForwardTarget (call_forwarding_settings->get_bool ("forward-on-busy") ? h323_settings->get_string ("forward-host") : "");
if (setting.empty () || setting == "always-forward" || setting == "forward-host")
h323_endpoint.SetUnconditionalForwardTarget (call_forwarding_settings->get_bool ("always-forward") ? h323_settings->get_string ("forward-host") : "");
if (setting.empty () || setting == "video-role") {
/*
CallManager::VideoOptions options;
endpoint.get_video_options (options);
options.extended_video_roles = h323_settings->get_enum ("video-role");
endpoint.set_video_options (options);
*/
std::cout << "FIXME" << std::endl;
}
if (setting.empty () || setting == "enable-h239") {
h323_endpoint.SetDefaultH239Control(h323_settings->get_bool ("enable-h239"));
PTRACE (4, "Opal::H323::EndPoint\tH.239 Control: " << h323_settings->get_bool ("enable-h239"));
}
// We do not call the parent setup () method as it is also handled
// by our Opal::Sip::CallManager
}
int main(int argc, char *argv[])
{
/* getopt */
int next_option;
int ret;
int will_block = 0;
/*! short options. See man getopt */
const char *const short_options = "hc:l:L:b:f:xp:s:";
/*! the array for the long options. */
const struct option long_options[] = {
{"help", 0, NULL, 'h'},
{"config", 1, NULL, 'c'},
{"logfile", 1, NULL, 'L'},
{"background", 1, NULL, 'b'},
{"foreground", 1, NULL, 'f'},
{"logo", 1, NULL, 'l'},
{"blocked", 0, NULL, 'x'},
{"port", 1, NULL, 'p'},
{"server", 1, NULL, 's'},
{NULL, 0, NULL, 0}
};
/* Initializing exit function */
if (atexit(f_atexit) != 0) {
fprintf(stderr, "failed to register f_atexit() exit function\n");
exit(EXIT_FAILURE);
}
if (signal(SIGINT, sig_ctrlc) == SIG_ERR) {
fprintf(stderr, "Warning - Could not set CTRL-C handler\n");
}
/* First, set defaults */
set_listen_port(PORT);
set_foreground(FOREGROUND_IMAGE);
set_logo(LOGO_IMAGE);
/* Second, read entries from default config file.
* They will eventually be replaced by command line settings. */
read_config_file(CONFIGFILE);
/* Then, overwrite with command line options... */
do {
next_option = getopt_long(argc, argv, short_options, long_options, NULL);
switch (next_option) {
case 'h': /* -h or --help */
print_usage();
exit(1);
case 'c':/* -c or --config */
/* Things like "mdclient -p 7000 -c /etc/mymedusa.conf"
* when port is set to a different value in /etc/mymedusa.conf
* may result in an unpredictable value for listen_port. Just don't do that. */
read_config_file(strdup(optarg));
break;
case 'p': /* -p or --port */
set_listen_port(strdup(optarg));
break;
case 'x': /* -x or --blocked */
will_block = 1;
break;
case 'b': /* -b or --background */
set_background(strdup(optarg));
break;
case 'l': /* -l or --logo */
set_logo(strdup(optarg));
break;
case 'f': /* -f or --foreground */
set_foreground(strdup(optarg));
break;
case 'L': /* -L or --logfile */
close_log();
open_log(strdup(optarg));
break;
case 's': /* -s or --server */
ret = set_server(strdup(optarg));
if (ret) {
/* error */
fflush(stderr);
fflush(stdout);
fprintf(stderr, "Server IP unknown.\n");
exit(1);
}
break;
case '?':/* The user specified an invalid option */
/* Write usage info on the screen */
print_usage();
exit(1);
case -1: /* No more options */
break;
default: /* Garbage */
abort();
}
} while (next_option != -1);
if (will_block) {
if (lockScreen() < 0) {
write_log_fmt("Could not open display.\n");
exit(EXIT_FAILURE);
}
}
write_log_fmt("Starting...\n");
listen_network();
close_log();
return 0;
}
