void
ccnet_conn_listen_init (CcnetConnManager *manager)
{
evutil_socket_t socket;
CcnetSession *session = manager->session;
if (session->base.public_port == 0) {
ccnet_message ("Do not listen for incoming peers\n");
return;
}
socket = ccnet_net_bind_tcp (session->base.public_port, 1);
if (socket >= 0) {
ccnet_message ("Opened port %d to listen for "
"incoming peer connections\n", session->base.public_port);
manager->bind_socket = socket;
listen (manager->bind_socket, 5);
} else {
ccnet_error ("Couldn't open port %d to listen for "
"incoming peer connections (errno %d - %s)",
session->base.public_port, errno, strerror(errno) );
exit (1);
}
manager->listen_timer = ccnet_timer_new (listen_pulse, manager,
LISTEN_INTERVAL);
}
static void
save_peerinfo (CcnetSession *session)
{
FILE *fp;
char *path;
char filename[64];
sprintf(filename, "%s%s", session->base.id, ".peer");
path = g_build_filename (session->config_dir, "misc", filename, NULL);
if ((fp = g_fopen(path, "wb")) == NULL) {
ccnet_warning ("Open public info file %s error: %s\n",
path, strerror(errno));
g_free (path);
return;
}
g_free (path);
ccnet_message ("Update pubinfo file\n");
session->myself->public_port = session->base.public_port;
GString *str = ccnet_peer_to_string (session->myself);
fputs (str->str, fp);
fclose (fp);
g_string_free (str, TRUE);
}
void
ccnet_session_on_exit (CcnetSession *session)
{
time_t t;
ccnet_peer_manager_on_exit (session->peer_mgr);
ccnet_session_save (session);
t = time(NULL);
ccnet_message ("Exit at %s\n", ctime(&t));
ccnet_session_free (session);
}
static void listen_on_localhost (CcnetSession *session)
{
int sockfd;
if ( (sockfd = ccnet_net_bind_v4 ("127.0.0.1", &session->local_port)) < 0) {
printf ("listen on localhost failed\n");
exit (1);
}
ccnet_message ("Listen on 127.0.0.1 %d\n", session->local_port);
listen (sockfd, 5);
event_set (&session->local_event, sockfd, EV_READ | EV_PERSIST,
accept_local_client, session);
event_add (&session->local_event, NULL);
}
void
ccnet_session_save_config (CcnetSession *session)
{
GError *error = NULL;
char *str;
FILE *fp;
ccnet_message ("[Session] Saving configure file\n");
if (session->saving_pub) {
/* only update timestamp when pubinfo changes */
save_pubinfo (session);
session->saving_pub = 0;
}
g_key_file_set_string (session->keyf, "General", "NAME",
session->base.name);
g_key_file_set_string (session->keyf, "General", "ID",
session->base.id);
g_key_file_set_string (session->keyf, "General", "USER_NAME",
session->base.user_name);
#ifdef CCNET_SERVER
g_key_file_set_string (session->keyf, "General", "SERVICE_URL",
session->base.service_url?session->base.service_url:"");
#endif
g_key_file_set_integer (session->keyf, "Network", "PORT",
session->base.public_port);
g_key_file_set_integer (session->keyf, "Client", "PORT", session->local_port);
str = g_key_file_to_data (session->keyf, NULL, &error);
if (error) {
ccnet_warning ("Can't save unauth peer info: %s\n",
error->message);
return;
}
if ((fp = g_fopen (session->config_file, "wb")) == NULL) {
ccnet_warning ("Can't save session conf: %s\n", strerror(errno));
g_free (str);
return;
}
fputs (str, fp);
fclose (fp);
g_free (str);
return;
}
static void on_get_resolve_peer_pub_info_done (CcnetProcessor *processor,
gboolean success, void *data)
{
if (success) {
gboolean should_continue;
should_continue = ccnet_peer_manager_on_peer_resolved (
processor->peer->manager, processor->peer);
if (!should_continue)
return;
start_keepalive (processor->peer);
} else {
ccnet_message ("Get resolved peer pub info failed\n");
ccnet_peer_manager_on_peer_resolve_failed (
processor->peer->manager, processor->peer);
}
}
static void
handle_response (CcnetProcessor *processor,
char *code, char *code_msg,
char *content, int clen)
{
if (g_strcmp0(code, SC_OK) == 0) {
ccnet_message ("[Send Logout] Successfully send logout to relay %.10s\n",
processor->peer->id);
processor->peer->logout_started = FALSE;
/* processor->peer->bind_status = BIND_NO; */
ccnet_processor_done (processor, TRUE);
} else {
ccnet_warning ("[Send Logout] Error: get repsonse: %s, %s.\n", code, code_msg);
processor->peer->logout_started = FALSE;
/* processor->peer->bind_status = BIND_YES; */
ccnet_processor_done (processor, FALSE);
}
}
static void accept_local_client (int fd, short event, void *vsession)
{
CcnetSession *session = vsession;
CcnetPacketIO *io;
int connfd;
CcnetPeer *peer;
static int local_id = 0;
connfd = accept (fd, NULL, 0);
ccnet_message ("Accepted a local client\n");
io = ccnet_packet_io_new_incoming (session, NULL, connfd);
peer = ccnet_peer_new (session->base.id);
peer->name = g_strdup_printf("local-%d", local_id++);
peer->is_local = TRUE;
ccnet_peer_set_io (peer, io);
ccnet_peer_set_net_state (peer, PEER_CONNECTED);
ccnet_peer_manager_add_local_peer (session->peer_mgr, peer);
g_object_unref (peer);
}
static void handle_update (CcnetProcessor *processor,
char *code, char *code_msg,
char *content, int clen)
{
CcnetMessage *msg;
if (processor->peer->is_local) {
msg = ccnet_message_from_string_local (content, clen);
ccnet_send_message (processor->session, msg);
ccnet_message_unref (msg);
} else {
msg = ccnet_message_from_string (content, clen);
if (!msg) {
g_warning ("Wrong message format.\n");
ccnet_processor_done (processor, FALSE);
return;
}
msg->rtime = time(NULL);
ccnet_debug ("[msg] Received a message : %s - %.10s\n",
msg->app, msg->body);
int ret = ccnet_recv_message (processor->session, msg);
if (ret == -1) {
ccnet_message ("[msg] Message from %.8s permission error\n",
msg->from);
ccnet_processor_send_response (processor, SC_PERM_ERR,
SS_PERM_ERR, NULL, 0);
ccnet_processor_done (processor, TRUE);
ccnet_message_unref (msg);
return;
}
ccnet_message_unref (msg);
}
ccnet_processor_send_response (processor, "200", "OK", NULL, 0);
ccnet_processor_done (processor, TRUE);
}
int
main (int argc, char **argv)
{
int c;
char *config_dir;
char *cluster_config_dir = NULL;
char *log_file = 0;
const char *debug_str = 0;
int daemon_mode = 0;
int redirect = 0;
const char *log_level_str = "debug";
config_dir = DEFAULT_CONFIG_DIR;
#ifdef WIN32
argv = get_argv_utf8 (&argc);
#endif
while ((c = getopt_long (argc, argv, short_options,
long_options, NULL)) != EOF) {
switch (c) {
case 'h':
usage();
exit(0);
break;
case 'v':
exit (1);
break;
case 'c':
config_dir = optarg;
break;
case 'C':
cluster_config_dir = optarg;
break;
case 'f':
log_file = optarg;
break;
case 'D':
debug_str = optarg;
break;
case 'd':
daemon_mode = 1;
break;
case 'P':
pidfile = optarg;
break;
case 'r':
redirect = 1;
break;
default:
fprintf (stderr, "unknown option \"-%c\"\n", (char)c);
usage();
exit (1);
}
}
argc -= optind;
argv += optind;
if (config_dir == NULL) {
fprintf (stderr, "Missing config dir\n");
exit (1);
}
if (cluster_config_dir == NULL) {
fprintf (stderr, "Missing cluster config dir\n");
exit (1);
}
#ifndef WIN32
if (daemon_mode)
daemon (1, 0);
#endif
#if !GLIB_CHECK_VERSION(2, 36, 0)
g_type_init ();
#endif
/* log */
if (!debug_str)
debug_str = g_getenv("CCNET_DEBUG");
ccnet_debug_set_flags_string (debug_str);
config_dir = ccnet_expand_path (config_dir);
if (!log_file) {
char *logdir = g_build_filename (cluster_config_dir, "logs", NULL);
checkdir_with_mkdir (logdir);
g_free (logdir);
log_file = g_build_filename (cluster_config_dir, "logs", "ccnet.log", NULL);
}
if (ccnet_log_init (log_file, log_level_str) < 0) {
fprintf (stderr, "ccnet_log_init error: %s, %s\n", strerror(errno),
log_file);
exit (1);
}
srand (time(NULL));
session = (CcnetSession *)ccnet_outer_session_new ();
if (!session) {
fputs ("Error: failed to start ccnet session, "
"see log file for the detail.\n", stderr);
return -1;
}
inner_session = (CcnetSession *)ccnet_inner_session_new ();
if (!inner_session) {
fputs ("Error: failed to start cluster ccnet session, "
"see log file for the detail.\n", stderr);
return -1;
}
event_init ();
evdns_init ();
if (ccnet_session_prepare(session, config_dir) < 0) {
fputs ("Error: failed to start ccnet session, "
"see log file for the detail.\n", stderr);
return -1;
}
if (ccnet_session_prepare(inner_session, cluster_config_dir) < 0) {
fputs ("Error: failed to start cluster ccnet session, "
"see log file for the detail.\n", stderr);
return -1;
}
/* write pidfile after session_prepare success, if there is
* another instance of ccnet session_prepare will failed.
*/
if (pidfile) {
if (write_pidfile (pidfile) < 0) {
ccnet_message ("Failed to write pidfile\n");
return -1;
}
}
atexit (on_ccnet_exit);
#ifndef WIN32
setSigHandlers();
#endif
ccnet_session_start (session);
ccnet_session_start (inner_session);
ccnet_start_rpc(session);
/* actually enter the event loop */
cluster_mgr = ccnet_cluster_manager_new ();
ccnet_cluster_manager_start (cluster_mgr);
if (redirect)
cluster_mgr->redirect = 1;
event_dispatch ();
return 0;
}
/**
* return %TRUE if an outgoing connection is started, %FALSE otherwise.
*
* When peer's ip address is not looked up yet, an dns request will be sent,
* and when dns done, this function will be called again.
*/
gboolean
ccnet_conn_manager_connect_peer (CcnetConnManager *manager, CcnetPeer *peer)
{
CcnetPacketIO *io;
/* int interval; */
const char *addr = NULL;
int port = 0;
if (peer->in_connection)
return FALSE;
/* time_t now = time(NULL); */
if (peer->net_state == PEER_CONNECTED)
return FALSE;
if (peer->dns_addr)
addr = peer->dns_addr;
else if (!peer->redirected) {
if (!peer->public_addr)
goto err_connect;
if (is_valid_ipaddr(peer->public_addr))
addr = peer->public_addr;
else {
dns_lookup_peer (peer);
return TRUE; /* same as out going is started */
}
} else {
if (!peer->redirect_addr)
goto err_connect;
if (is_valid_ipaddr(peer->redirect_addr))
addr = peer->redirect_addr;
else {
dns_lookup_peer (peer);
return TRUE; /* same as out going is started */
}
}
if (!addr)
goto err_connect;
if (!peer->redirected)
port = peer->public_port;
else
port = peer->redirect_port;
ccnet_peer_update_address (peer, addr, port);
/* interval = get_reconnect_interval_secs (peer); */
/* if (now - peer->last_try_time < interval) { */
/* ccnet_debug ("[Conn] Less than interval: (%d - %d = %d, %d)\n", */
/* now, peer->last_try_time, now - peer->last_try_time, */
/* interval); */
/* return FALSE; */
/* } */
/* peer->last_try_time = now; */
if (peer->num_fails == 0) {
/* print log for the first time */
ccnet_message ("[Conn] Start outgoing connect to %s(%.10s) %s:%d\n",
peer->name, peer->id, addr, port);
} else {
ccnet_debug ("[Conn] Start outgoing connect to %s(%.10s) %s:%d\n",
peer->name, peer->id, addr, port);
}
io = ccnet_packet_io_new_outgoing (manager->session, addr, port);
if (io == NULL) {
/* ccnet_warning ("Failed to create socket for peer %s (%.10s)\n",
peer->name, peer->id); */
goto err_connect;
} else {
peer->in_connection = 1;
ccnet_handshake_new (manager->session, peer, io,
myHandshakeDoneCB, manager);
return TRUE;
}
err_connect:
peer->num_fails++;
return FALSE;
}
int
main (int argc, char **argv)
{
int c;
char *config_dir;
char *log_file = 0;
const char *debug_str = 0;
int daemon_mode = 0;
const char *log_level_str = "debug";
config_dir = DEFAULT_CONFIG_DIR;
#ifdef WIN32
argv = get_argv_utf8 (&argc);
#endif
while ((c = getopt_long (argc, argv, short_options,
long_options, NULL)) != EOF) {
switch (c) {
case 'h':
usage();
exit(0);
break;
case 'v':
exit (1);
break;
case 'c':
config_dir = optarg;
break;
case 'f':
log_file = optarg;
break;
case 'D':
debug_str = optarg;
break;
case 'd':
daemon_mode = 1;
break;
default:
usage();
exit (1);
}
}
argc -= optind;
argv += optind;
if (config_dir == NULL) {
fprintf (stderr, "Missing config dir\n");
exit (1);
}
#ifndef WIN32
#ifndef __APPLE__
if (daemon_mode)
daemon (1, 0);
#endif
#else
WSADATA wsadata;
WSAStartup(0x0101, &wsadata);
#endif
g_type_init ();
/* log */
if (!debug_str)
debug_str = g_getenv("CCNET_DEBUG");
ccnet_debug_set_flags_string (debug_str);
config_dir = ccnet_expand_path (config_dir);
if (!log_file) {
char *logdir = g_build_filename (config_dir, "logs", NULL);
checkdir_with_mkdir (logdir);
g_free (logdir);
log_file = g_build_filename (config_dir, "logs", "ccnet.log", NULL);
}
if (ccnet_log_init (log_file, log_level_str) < 0) {
fprintf (stderr, "ccnet_log_init error: %s, %s\n", strerror(errno),
log_file);
exit (1);
}
ccnet_message ("starting ccnet "PACKAGE_VERSION"\n");
srand (time(NULL));
session = (CcnetSession *)ccnet_daemon_session_new ();
if (!session) {
fputs ("Error: failed to start ccnet session, "
"see log file for the detail.\n", stderr);
return -1;
}
event_init ();
evdns_init ();
if (ccnet_session_prepare(session, config_dir) < 0) {
fputs ("Error: failed to start ccnet session, "
"see log file for the detail.\n", stderr);
return -1;
}
#ifndef WIN32
setSigHandlers();
#endif
ccnet_session_start (session);
ccnet_start_rpc(session);
/* actually enter the event loop */
/* event_set_log_callback (logFunc); */
event_dispatch ();
return 0;
}
int
main (int argc, char **argv)
{
int c;
char *config_dir = DEFAULT_CONFIG_DIR;
char *seafile_dir = NULL;
char *central_config_dir = NULL;
char *logfile = NULL;
const char *debug_str = NULL;
int daemon_mode = 1;
int is_master = 0;
CcnetClient *client;
char *ccnet_debug_level_str = "info";
char *seafile_debug_level_str = "debug";
int cloud_mode = 0;
#ifdef WIN32
argv = get_argv_utf8 (&argc);
#endif
while ((c = getopt_long (argc, argv, short_options,
long_options, NULL)) != EOF)
{
switch (c) {
case 'h':
exit (1);
break;
case 'v':
exit (1);
break;
case 'c':
config_dir = optarg;
break;
case 'd':
seafile_dir = g_strdup(optarg);
break;
case 'F':
central_config_dir = g_strdup(optarg);
break;
case 'f':
daemon_mode = 0;
break;
case 'l':
logfile = g_strdup(optarg);
break;
case 'D':
debug_str = optarg;
break;
case 'g':
ccnet_debug_level_str = optarg;
break;
case 'G':
seafile_debug_level_str = optarg;
break;
case 'm':
is_master = 1;
break;
case 'P':
pidfile = optarg;
break;
case 'C':
cloud_mode = 1;
break;
default:
usage ();
exit (1);
}
}
argc -= optind;
argv += optind;
#ifndef WIN32
if (daemon_mode) {
#ifndef __APPLE__
daemon (1, 0);
#else /* __APPLE */
/* daemon is deprecated under APPLE
* use fork() instead
* */
switch (fork ()) {
case -1:
seaf_warning ("Failed to daemonize");
exit (-1);
break;
case 0:
/* all good*/
break;
default:
/* kill origin process */
exit (0);
}
#endif /* __APPLE */
}
#endif /* !WIN32 */
cdc_init ();
#if !GLIB_CHECK_VERSION(2, 35, 0)
g_type_init();
#endif
#if !GLIB_CHECK_VERSION(2,32,0)
g_thread_init (NULL);
#endif
if (!debug_str)
debug_str = g_getenv("SEAFILE_DEBUG");
seafile_debug_set_flags_string (debug_str);
if (seafile_dir == NULL)
seafile_dir = g_build_filename (config_dir, "seafile", NULL);
if (logfile == NULL)
logfile = g_build_filename (seafile_dir, "seafile.log", NULL);
if (seafile_log_init (logfile, ccnet_debug_level_str,
seafile_debug_level_str) < 0) {
seaf_warning ("Failed to init log.\n");
exit (1);
}
client = ccnet_init (central_config_dir, config_dir);
if (!client)
exit (1);
register_processors (client);
start_rpc_service (client, cloud_mode);
create_sync_rpc_clients (central_config_dir, config_dir);
create_async_rpc_clients (client);
seaf = seafile_session_new (central_config_dir, seafile_dir, client);
if (!seaf) {
seaf_warning ("Failed to create seafile session.\n");
exit (1);
}
seaf->is_master = is_master;
seaf->ccnetrpc_client = ccnetrpc_client;
seaf->async_ccnetrpc_client = async_ccnetrpc_client;
seaf->ccnetrpc_client_t = ccnetrpc_client_t;
seaf->async_ccnetrpc_client_t = async_ccnetrpc_client_t;
seaf->client_pool = ccnet_client_pool_new (central_config_dir, config_dir);
seaf->cloud_mode = cloud_mode;
load_history_config ();
g_free (seafile_dir);
g_free (logfile);
set_signal_handlers (seaf);
/* init seaf */
if (seafile_session_init (seaf) < 0)
exit (1);
if (seafile_session_start (seaf) < 0)
exit (1);
if (pidfile) {
if (write_pidfile (pidfile) < 0) {
ccnet_message ("Failed to write pidfile\n");
return -1;
}
}
atexit (on_seaf_server_exit);
/* Create a system default repo to contain the tutorial file. */
schedule_create_system_default_repo (seaf);
ccnet_main (client);
return 0;
}
int
main (int argc, char **argv)
{
int c;
char *config_dir = DEFAULT_CONFIG_DIR;
char *seafile_dir = NULL;
char *logfile = NULL;
int daemon_mode = 1;
CcnetClient *client;
char *ccnet_debug_level_str = "info";
char *monitor_debug_level_str = "debug";
#ifdef WIN32
argv = get_argv_utf8 (&argc);
#endif
while ((c = getopt_long (argc, argv, short_options,
long_options, NULL)) != EOF)
{
switch (c) {
case 'h':
exit (1);
break;
case 'v':
exit (1);
break;
case 'c':
config_dir = optarg;
break;
case 'd':
seafile_dir = g_strdup(optarg);
break;
case 'f':
daemon_mode = 0;
break;
case 'l':
logfile = g_strdup(optarg);
break;
case 'g':
ccnet_debug_level_str = optarg;
break;
case 'G':
monitor_debug_level_str = optarg;
break;
case 'P':
pidfile = optarg;
break;
default:
usage ();
exit (1);
}
}
argc -= optind;
argv += optind;
#ifndef WIN32
if (daemon_mode)
daemon (1, 0);
#endif
g_type_init ();
if (seafile_dir == NULL) {
usage ();
exit (1);
}
if (logfile == NULL)
logfile = g_build_filename (seafile_dir, "monitor.log", NULL);
if (seafile_log_init (logfile, ccnet_debug_level_str,
monitor_debug_level_str) < 0) {
seaf_warning ("Failed to init log.\n");
exit (1);
}
client = ccnet_init (config_dir);
if (!client)
exit (1);
register_processors (client);
start_rpc_service (client);
seaf = seafile_session_new (seafile_dir, client);
if (!seaf) {
seaf_warning ("Failed to create seafile monitor.\n");
exit (1);
}
if (seafile_session_init (seaf) < 0) {
seaf_warning ("Failed to init seafile monitor.\n");
exit (1);
}
g_free (seafile_dir);
g_free (logfile);
set_signal_handlers (seaf);
seafile_session_start (seaf);
if (pidfile) {
if (write_pidfile (pidfile) < 0) {
ccnet_message ("Failed to write pidfile\n");
return -1;
}
}
atexit (on_seaf_mon_exit);
ccnet_main (client);
return 0;
}
int
main (int argc, char **argv)
{
int c;
char *config_dir = DEFAULT_CONFIG_DIR;
char *seafile_dir = NULL;
char *logfile = NULL;
const char *debug_str = NULL;
int daemon_mode = 1;
int is_master = 0;
CcnetClient *client;
char *ccnet_debug_level_str = "info";
char *seafile_debug_level_str = "debug";
int cloud_mode = 0;
while ((c = getopt_long (argc, argv, short_options,
long_options, NULL)) != EOF)
{
switch (c) {
case 'h':
exit (1);
break;
case 'v':
exit (1);
break;
case 'c':
config_dir = optarg;
break;
case 'd':
seafile_dir = g_strdup(optarg);
break;
case 'f':
daemon_mode = 0;
break;
case 'l':
logfile = g_strdup(optarg);
break;
case 'D':
debug_str = optarg;
break;
case 'g':
ccnet_debug_level_str = optarg;
break;
case 'G':
seafile_debug_level_str = optarg;
break;
case 'm':
is_master = 1;
case 'P':
pidfile = optarg;
break;
case 'C':
cloud_mode = 1;
break;
default:
usage ();
exit (1);
}
}
argc -= optind;
argv += optind;
#ifndef WIN32
if (daemon_mode)
daemon (1, 0);
#endif
g_type_init ();
#if !GLIB_CHECK_VERSION(2,32,0)
g_thread_init (NULL);
#endif
if (!debug_str)
debug_str = g_getenv("SEAFILE_DEBUG");
seafile_debug_set_flags_string (debug_str);
client = ccnet_init (config_dir);
if (!client)
exit (1);
register_processors (client);
start_rpc_service (client, cloud_mode);
create_sync_rpc_clients (config_dir);
create_async_rpc_clients (client);
if (seafile_dir == NULL)
seafile_dir = g_build_filename (config_dir, "seafile", NULL);
if (logfile == NULL)
logfile = g_build_filename (seafile_dir, "seafile.log", NULL);
seaf = seafile_session_new (seafile_dir, client);
if (!seaf) {
fprintf (stderr, "Failed to create seafile session.\n");
exit (1);
}
seaf->is_master = is_master;
seaf->ccnetrpc_client = ccnetrpc_client;
seaf->async_ccnetrpc_client = async_ccnetrpc_client;
seaf->ccnetrpc_client_t = ccnetrpc_client_t;
seaf->async_ccnetrpc_client_t = async_ccnetrpc_client_t;
seaf->client_pool = ccnet_client_pool_new (config_dir);
seaf->cloud_mode = cloud_mode;
load_history_config ();
if (seafile_log_init (logfile, ccnet_debug_level_str,
seafile_debug_level_str) < 0) {
fprintf (stderr, "Failed to init log.\n");
exit (1);
}
g_free (seafile_dir);
g_free (logfile);
set_signal_handlers (seaf);
/* init seaf */
if (seafile_session_init (seaf) < 0)
exit (1);
if (seafile_session_start (seaf) < 0)
exit (1);
if (pidfile) {
if (write_pidfile (pidfile) < 0) {
ccnet_message ("Failed to write pidfile\n");
return -1;
}
}
atexit (on_seaf_server_exit);
ccnet_main (client);
return 0;
}
static void
myHandshakeDoneCB (CcnetHandshake *handshake,
CcnetPacketIO *io,
int is_connected,
const char *peer_id,
void *vmanager)
{
CcnetConnManager *manager = vmanager;
CcnetPeerManager *peerMgr = manager->session->peer_mgr;
CcnetPeer *peer;
if (!is_connected) {
if (ccnet_packet_io_is_incoming (io)) {
ccnet_warning ("[conn] incoming handshake fails.\n");
ccnet_packet_io_free (io);
return;
}
/* temporally use peer, so don't need to increase the reference */
peer = handshake->peer;
if (peer->num_fails == 0) {
/* print error for the first time */
ccnet_message ("[Conn] peer %s(%.10s) connection fails\n",
peer->name, peer->id);
} else {
ccnet_debug ("[Conn] peer %s(%.10s) connection fails\n",
peer->name, peer->id);
}
if (peer->net_state == PEER_CONNECTED) {
ccnet_debug ("[Conn] But Peer %s(%.10s) is already connected me.\n",
peer->name, peer->id);
} else if (peer->net_state == PEER_DOWN){
ccnet_peer_shutdown(peer);
}
ccnet_packet_io_free (io);
peer->num_fails++;
peer->in_connection = 0;
return;
}
if (!ccnet_packet_io_is_incoming (io)) {
peer = handshake->peer;
peer->in_connection = 0;
if (peer->to_resolve) {
if (!peer_id_valid(peer_id)) {
/* TODO: Remove the peer */
ccnet_warning ("[Conn] Resolving: Received invalid peer id\n");
return;
}
ccnet_debug ("[Conn] Resolving: Peer %.8s is resolved\n", peer_id);
memcpy (peer->id, peer_id, 40);
peer->id[40] = '\0';
on_resolve_peer_connected (peer, io);
return;
}
/* ref for using the peer below */
g_object_ref (peer);
} else {
/* incoming */
if (peer_id == NULL) {
ccnet_warning ("Unknown peer (no-id) connecting\n");
ccnet_packet_io_free (io);
return;
}
peer = ccnet_peer_manager_get_peer (peerMgr, peer_id);
if (!peer) {
ccnet_message ("Unknown peer %s connecting\n", peer_id);
peer = ccnet_peer_new (peer_id);
ccnet_peer_manager_add_peer (peerMgr, peer);
set_peer_address_from_socket(peer, io);
peer->last_up = time(NULL);
on_unauthed_peer_connected (peer, io);
g_object_unref (peer);
return;
}
set_peer_address_from_socket(peer, io);
peer->last_up = time(NULL);
}
/* hold a reference on the peer */
if (peer->net_state == PEER_CONNECTED) {
ccnet_message ("[Conn] Peer %s (%.10s) is already connected. "
"Discarding this handshake.\n",
peer->name, peer->id);
ccnet_packet_io_free (io);
g_object_unref (peer);
return;
}
ccnet_message ("[Conn] Peer %s (%.10s) connected\n",
peer->name, peer->id);
peer->num_fails = 0;
on_peer_connected (peer, io);
g_object_unref (peer);
}
int
main (int argc, char **argv)
{
int c;
char *config_dir;
char *log_file = 0;
const char *debug_str = 0;
int daemon_mode = 0;
int max_users = 0;
const char *log_level_str = "debug";
gboolean test_config = FALSE;
config_dir = DEFAULT_CONFIG_DIR;
#ifdef WIN32
argv = get_argv_utf8 (&argc);
#endif
while ((c = getopt_long (argc, argv, short_options,
long_options, NULL)) != EOF) {
switch (c) {
case 'h':
usage();
exit(0);
break;
case 'v':
exit (1);
break;
case 'c':
config_dir = optarg;
break;
case 'f':
log_file = optarg;
break;
case 'D':
debug_str = optarg;
break;
case 'd':
daemon_mode = 1;
break;
case 'P':
pidfile = optarg;
break;
case 'M':
max_users = atoi(optarg);
break;
case 't':
test_config = TRUE;
break;
default:
fprintf (stderr, "unknown option \"-%c\"\n", (char)c);
usage();
exit (1);
}
}
argc -= optind;
argv += optind;
if (config_dir == NULL) {
fprintf (stderr, "Missing config dir\n");
exit (1);
}
if (test_config) {
/* test ccnet configuration and exit */
return test_ccnet_config (config_dir, max_users);
}
#ifndef WIN32
#ifndef __APPLE__
if (daemon_mode)
daemon (1, 0);
#endif
#else
WSADATA wsadata;
WSAStartup(0x0101, &wsadata);
#endif
g_type_init ();
/* log */
if (!debug_str)
debug_str = g_getenv("CCNET_DEBUG");
ccnet_debug_set_flags_string (debug_str);
config_dir = ccnet_expand_path (config_dir);
if (!log_file) {
char *logdir = g_build_filename (config_dir, "logs", NULL);
checkdir_with_mkdir (logdir);
g_free (logdir);
log_file = g_build_filename (config_dir, "logs", "ccnet.log", NULL);
}
if (ccnet_log_init (log_file, log_level_str) < 0) {
fprintf (stderr, "ccnet_log_init error: %s, %s\n", strerror(errno),
log_file);
exit (1);
}
srand (time(NULL));
session = (CcnetSession *)ccnet_server_session_new ();
if (!session) {
fputs ("Error: failed to start ccnet session, "
"see log file for the detail.\n", stderr);
return -1;
}
event_init ();
evdns_init ();
ccnet_user_manager_set_max_users (((struct CcnetServerSession *)session)->user_mgr, max_users);
if (ccnet_session_prepare(session, config_dir, FALSE) < 0) {
fputs ("Error: failed to start ccnet session, "
"see log file for the detail.\n", stderr);
return -1;
}
/* write pidfile after session_prepare success, if there is
* another instance of ccnet session_prepare will failed.
*/
if (pidfile) {
if (write_pidfile (pidfile) < 0) {
ccnet_message ("Failed to write pidfile\n");
return -1;
}
}
atexit (on_ccnet_exit);
#ifndef WIN32
setSigHandlers();
#endif
ccnet_session_start (session);
ccnet_start_rpc(session);
/* actually enter the event loop */
event_dispatch ();
return 0;
}
