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 *
dns_lookup (void *vdata)
{
DNSLookupData *data = vdata;
struct evutil_addrinfo hints;
struct evutil_addrinfo *answer = NULL;
int err;
void *addr;
char *addr_str;
socklen_t size;
/* Build the hints to tell getaddrinfo how to act. */
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET; /* only use IPv4 now. */
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP; /* We want a TCP socket */
/* Only return addresses we can use. */
hints.ai_flags = EVUTIL_AI_ADDRCONFIG;
/* Look up the hostname. */
err = evutil_getaddrinfo(data->peer->public_addr, NULL, &hints, &answer);
if (err != 0) {
ccnet_warning("Error while resolving '%s': %s\n",
data->peer->public_addr, evutil_gai_strerror(err));
return vdata;
}
/* just use the first answer */
if (answer->ai_family == AF_INET) {
size = INET_ADDRSTRLEN;
addr = &((struct sockaddr_in *)(answer->ai_addr))->sin_addr;
} else if (answer->ai_family == AF_INET6) {
size = INET6_ADDRSTRLEN;
addr = &((struct sockaddr_in6 *)(answer->ai_addr))->sin6_addr;
} else
goto out;
addr_str = (char *)calloc(size, sizeof(char));
if (addr_str == NULL) {
ccnet_error("Out of memory\n");
goto out;
}
if (!inet_ntop(answer->ai_family, addr, addr_str, size)) {
ccnet_warning("Peer %s domain name %s lookup fail\n",
data->peer->name, data->peer->public_addr);
free(addr_str);
goto out;
}
data->addr_str = addr_str;
out:
evutil_freeaddrinfo (answer);
return vdata;
}
static int load_rsakey(CcnetSession *session)
{
char *path;
FILE *fp;
RSA *key;
path = g_build_filename(session->config_dir, PEER_KEYFILE, NULL);
if (!g_file_test(path, G_FILE_TEST_EXISTS))
ccnet_error ("Can't load rsa private key from %s\n", path);
if ((fp = g_fopen(path, "rb")) == NULL)
ccnet_error ("Can't open private key file %s: %s\n", path,
strerror(errno));
if ((key = PEM_read_RSAPrivateKey(fp, NULL, NULL, NULL)) == NULL)
ccnet_error ("Can't open load key file %s: format error\n", path);
fclose(fp);
session->privkey = key;
session->pubkey = private_key_to_pub(key);
g_free(path);
return 0;
}
int
ccnet_session_prepare (CcnetSession *session, const char *config_dir_r, gboolean test_config)
{
char *misc_path;
int ret;
if (ccnet_session_load_config (session, config_dir_r) < 0)
return -1;
misc_path = g_build_filename (session->config_dir, "misc", NULL);
if (checkdir_with_mkdir (misc_path) < 0) {
ccnet_error ("mkdir %s error", misc_path);
return -1;
}
/* config db */
session->config_db = ccnet_session_config_open_db (misc_path);
if (!session->config_db) {
ccnet_warning ("Failed to open config db.\n");
return -1;
}
/* call subclass prepare */
ret = CCNET_SESSION_GET_CLASS (session)->prepare(session);
if (ret < 0)
return ret;
/* peer */
ccnet_peer_manager_prepare(session->peer_mgr);
g_signal_connect (session->peer_mgr, "peer-auth-done",
G_CALLBACK(on_peer_auth_done), session);
/* permission manager */
ccnet_perm_manager_prepare (session->perm_mgr);
g_free (misc_path);
if (test_config) {
return 0;
} else {
/* Open localhost, if failed, then the program will exists. This is used
* to prevent two instance of ccnet on the same port.
*/
listen_on_localhost (session);
/* refresh pubinfo on every startup */
save_pubinfo (session);
}
return 0;
}
static CcnetDB *
open_sqlite_db (CcnetUserManager *manager)
{
CcnetDB *db = NULL;
char *db_dir;
char *db_path;
db_dir = g_build_filename (manager->session->config_dir, "PeerMgr", NULL);
if (checkdir_with_mkdir(db_dir) < 0) {
ccnet_error ("Cannot open db dir %s: %s\n", db_dir,
strerror(errno));
return NULL;
}
g_free (db_dir);
db_path = g_build_filename (manager->session->config_dir, "PeerMgr",
"usermgr.db", NULL);
db = ccnet_db_new_sqlite (db_path);
g_free (db_path);
return db;
}
int
ccnet_session_load_config (CcnetSession *session, const char *config_dir_r)
{
int ret = 0;
char *config_file, *config_dir;
char *id = 0, *name = 0, *port_str = 0, *lport_str,
*user_name = 0;
#ifdef CCNET_SERVER
char *service_url;
#endif
int port, local_port = 0;
unsigned char sha1[20];
GKeyFile *key_file;
config_dir = ccnet_expand_path (config_dir_r);
if (checkdir(config_dir) < 0) {
ccnet_error ("Config dir %s does not exist or is not "
"a directory.\n", config_dir);
return -1;
}
config_file = g_build_filename (config_dir, SESSION_CONFIG_FILENAME, NULL);
key_file = g_key_file_new ();
g_key_file_set_list_separator (key_file, ',');
if (!g_key_file_load_from_file (key_file, config_file,
G_KEY_FILE_KEEP_COMMENTS, NULL))
{
ccnet_warning ("Can't load config file %s.\n", config_file);
return -1;
}
id = ccnet_key_file_get_string (key_file, "General", "ID");
user_name = ccnet_key_file_get_string (key_file, "General", "USER_NAME");
name = ccnet_key_file_get_string (key_file, "General", "NAME");
#ifdef CCNET_SERVER
service_url = ccnet_key_file_get_string (key_file, "General", "SERVICE_URL");
#endif
port_str = ccnet_key_file_get_string (key_file, "Network", "PORT");
lport_str = ccnet_key_file_get_string (key_file, "Client", "PORT");
if (port_str == NULL)
port = DEFAULT_PORT;
else
port = atoi (port_str);
if (lport_str != NULL)
local_port = atoi (lport_str);
if ( (id == NULL) || (strlen (id) != SESSION_ID_LENGTH)
|| (hex_to_sha1 (id, sha1) < 0) ) {
ccnet_error ("Wrong ID\n");
ret = -1;
goto onerror;
}
memcpy (session->base.id, id, 40);
session->base.id[40] = '\0';
session->base.name = g_strdup(name);
session->base.user_name = g_strdup(user_name);
session->base.public_port = port;
#ifdef CCNET_SERVER
session->base.service_url = g_strdup(service_url);
#endif
session->config_file = config_file;
session->config_dir = config_dir;
session->local_port = local_port;
session->keyf = key_file;
load_rsakey(session);
ret = 0;
onerror:
g_free (id);
g_free (name);
g_free (user_name);
g_free (port_str);
#ifdef CCNET_SERVER
g_free (service_url);
#endif
return ret;
}
