static void allowConnection(Dict* args, void* vcontext, String* txid)
{
struct Context* context = (struct Context*) vcontext;
String* publicKeyOfAuthorizedNode =
Dict_getString(args, String_CONST("publicKeyOfAuthorizedNode"));
String* ip6Address = Dict_getString(args, String_CONST("ip6Address"));
String* ip4Address = Dict_getString(args, String_CONST("ip4Address"));
uint8_t pubKey[32];
uint8_t ip6Addr[16];
uint8_t ip6ToGive[16];
uint8_t ip4ToGive[4];
char* error;
int ret;
if (!ip6Address && !ip4Address) {
error = "Must specify ip6Address or ip4Address";
} else if ((ret = Key_parse(publicKeyOfAuthorizedNode, pubKey, ip6Addr)) != 0) {
error = Key_parse_strerror(ret);
} else if (ip6Address && evutil_inet_pton(AF_INET6, ip6Address->bytes, ip6ToGive) < 1) {
error = "malformed ip6Address";
} else if (ip4Address && evutil_inet_pton(AF_INET, ip4Address->bytes, ip4ToGive) < 1) {
error = "malformed ip4Address";
} else {
int conn = IpTunnel_allowConnection(pubKey,
(ip6Address) ? ip6ToGive : NULL,
(ip4Address) ? ip4ToGive : NULL,
context->ipTun);
sendResponse(conn, txid, context->admin);
return;
}
sendError(error, txid, context->admin);
}
int
sock_pton (const char *addr_str, uint16_t port, struct sockaddr_storage *sa)
{
struct sockaddr_in *saddr = (struct sockaddr_in *) sa;
#ifndef WIN32
struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *) sa;
#endif
if (evutil_inet_pton (AF_INET, addr_str, &saddr->sin_addr) == 1 ) {
saddr->sin_family = AF_INET;
saddr->sin_port = htons (port);
return 0;
}
#ifndef WIN32
else if (evutil_inet_pton (AF_INET6, addr_str, &saddr6->sin6_addr) == 1)
{
saddr6->sin6_family = AF_INET6;
saddr6->sin6_port = htons (port);
return 0;
}
#endif
return -1;
}
void
regress_dns_server_cb(struct evdns_server_request *req, void *data)
{
struct regress_dns_server_table *tab = data;
const char *question;
if (req->nquestions != 1)
TT_DIE(("Only handling one question at a time; got %d",
req->nquestions));
question = req->questions[0]->name;
while (tab->q && evutil_ascii_strcasecmp(question, tab->q) &&
strcmp("*", tab->q))
++tab;
if (tab->q == NULL)
TT_DIE(("Unexpected question: '%s'", question));
++tab->seen;
if (!strcmp(tab->anstype, "err")) {
int err = atoi(tab->ans);
tt_assert(! evdns_server_request_respond(req, err));
return;
} else if (!strcmp(tab->anstype, "errsoa")) {
int err = atoi(tab->ans);
char soa_record[] =
"\x04" "dns1" "\x05" "icann" "\x03" "org" "\0"
"\x0a" "hostmaster" "\x05" "icann" "\x03" "org" "\0"
"\x77\xde\x5e\xba" /* serial */
"\x00\x00\x1c\x20" /* refreshtime = 2h */
"\x00\x00\x0e\x10" /* retry = 1h */
"\x00\x12\x75\x00" /* expiration = 14d */
"\x00\x00\x0e\x10" /* min.ttl = 1h */
;
evdns_server_request_add_reply(
req, EVDNS_AUTHORITY_SECTION,
"example.com", EVDNS_TYPE_SOA, EVDNS_CLASS_INET,
42, sizeof(soa_record) - 1, 0, soa_record);
tt_assert(! evdns_server_request_respond(req, err));
return;
} else if (!strcmp(tab->anstype, "A")) {
struct in_addr in;
evutil_inet_pton(AF_INET, tab->ans, &in);
evdns_server_request_add_a_reply(req, question, 1, &in.s_addr,
100);
} else if (!strcmp(tab->anstype, "AAAA")) {
struct in6_addr in6;
evutil_inet_pton(AF_INET6, tab->ans, &in6);
evdns_server_request_add_aaaa_reply(req,
question, 1, &in6.s6_addr, 100);
} else {
TT_DIE(("Weird table entry with type '%s'", tab->anstype));
}
tt_assert(! evdns_server_request_respond(req, 0))
return;
end:
tt_want(! evdns_server_request_drop(req));
}
static void
regress_sockaddr_port_parse(void *ptr)
{
struct sockaddr_storage ss;
int i, r;
for (i = 0; sa_port_ents[i].parse; ++i) {
struct sa_port_ent *ent = &sa_port_ents[i];
int len = sizeof(ss);
memset(&ss, 0, sizeof(ss));
r = evutil_parse_sockaddr_port(ent->parse, (struct sockaddr*)&ss, &len);
if (r < 0) {
if (ent->safamily)
TT_FAIL(("Couldn't parse %s!", ent->parse));
continue;
} else if (! ent->safamily) {
TT_FAIL(("Shouldn't have been able to parse %s!", ent->parse));
continue;
}
if (ent->safamily == AF_INET) {
struct sockaddr_in sin;
memset(&sin, 0, sizeof(sin));
#ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
sin.sin_len = sizeof(sin);
#endif
sin.sin_family = AF_INET;
sin.sin_port = htons(ent->port);
r = evutil_inet_pton(AF_INET, ent->addr, &sin.sin_addr);
if (1 != r) {
TT_FAIL(("Couldn't parse ipv4 target %s.", ent->addr));
} else if (memcmp(&sin, &ss, sizeof(sin))) {
TT_FAIL(("Parse for %s was not as expected.", ent->parse));
} else if (len != sizeof(sin)) {
TT_FAIL(("Length for %s not as expected.",ent->parse));
}
} else {
struct sockaddr_in6 sin6;
memset(&sin6, 0, sizeof(sin6));
#ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN
sin6.sin6_len = sizeof(sin6);
#endif
sin6.sin6_family = AF_INET6;
sin6.sin6_port = htons(ent->port);
r = evutil_inet_pton(AF_INET6, ent->addr, &sin6.sin6_addr);
if (1 != r) {
TT_FAIL(("Couldn't parse ipv6 target %s.", ent->addr));
} else if (memcmp(&sin6, &ss, sizeof(sin6))) {
TT_FAIL(("Parse for %s was not as expected.", ent->parse));
} else if (len != sizeof(sin6)) {
TT_FAIL(("Length for %s not as expected.",ent->parse));
}
}
}
}
gboolean is_ipaddr_valid (const char *ip)
{
unsigned char buf[sizeof(struct in6_addr)];
if (evutil_inet_pton(AF_INET, ip, buf) == 1)
return TRUE;
if (evutil_inet_pton(AF_INET6, ip, buf) == 1)
return TRUE;
return FALSE;
}
bool
tr_address_from_string (tr_address * dst, const char * src)
{
bool ok;
if ((ok = evutil_inet_pton (AF_INET, src, &dst->addr) == 1))
dst->type = TR_AF_INET;
if (!ok) /* try IPv6 */
if ((ok = evutil_inet_pton (AF_INET6, src, &dst->addr) == 1))
dst->type = TR_AF_INET6;
return ok;
}
static void
fail_server_cb(struct evdns_server_request *req, void *data)
{
const char *question;
int *count = data;
struct in_addr in;
/* Drop the first N requests that we get. */
if (*count > 0) {
--*count;
tt_want(! evdns_server_request_drop(req));
return;
}
if (req->nquestions != 1)
TT_DIE(("Only handling one question at a time; got %d",
req->nquestions));
question = req->questions[0]->name;
if (!evutil_ascii_strcasecmp(question, "google.com")) {
/* Detect a probe, and get out of the loop. */
event_base_loopexit(exit_base, NULL);
}
evutil_inet_pton(AF_INET, "16.32.64.128", &in);
evdns_server_request_add_a_reply(req, question, 1, &in.s_addr,
100);
tt_assert(! evdns_server_request_respond(req, 0))
return;
end:
tt_want(! evdns_server_request_drop(req));
}
void
regress_dns_server_cb(struct evdns_server_request *req, void *data)
{
struct regress_dns_server_table *tab = data;
const char *question;
if (req->nquestions != 1)
TT_DIE(("Only handling one question at a time; got %d",
req->nquestions));
question = req->questions[0]->name;
while (tab->q && evutil_ascii_strcasecmp(question, tab->q) &&
strcmp("*", tab->q))
++tab;
if (tab->q == NULL)
TT_DIE(("Unexpected question: '%s'", question));
++tab->seen;
if (!strcmp(tab->anstype, "err")) {
int err = atoi(tab->ans);
tt_assert(! evdns_server_request_respond(req, err));
return;
} else if (!strcmp(tab->anstype, "A")) {
struct in_addr in;
evutil_inet_pton(AF_INET, tab->ans, &in);
evdns_server_request_add_a_reply(req, question, 1, &in.s_addr,
100);
} else if (!strcmp(tab->anstype, "AAAA")) {
struct in6_addr in6;
evutil_inet_pton(AF_INET6, tab->ans, &in6);
evdns_server_request_add_aaaa_reply(req,
question, 1, &in6.s6_addr, 100);
} else {
TT_DIE(("Weird table entry with type '%s'", tab->anstype));
}
tt_assert(! evdns_server_request_respond(req, 0))
return;
end:
tt_want(! evdns_server_request_drop(req));
}
static void
regress_ipv6_parse(void *ptr)
{
#ifdef AF_INET6
int i, j;
for (i = 0; ipv6_entries[i].addr; ++i) {
char written[128];
struct ipv6_entry *ent = &ipv6_entries[i];
struct in6_addr in6;
int r;
r = evutil_inet_pton(AF_INET6, ent->addr, &in6);
if (r == 0) {
if (ent->status != BAD)
TT_FAIL(("%s did not parse, but it's a good address!",
ent->addr));
continue;
}
if (ent->status == BAD) {
TT_FAIL(("%s parsed, but we expected an error", ent->addr));
continue;
}
for (j = 0; j < 4; ++j) {
/* Can't use s6_addr32 here; some don't have it. */
ev_uint32_t u =
((ev_uint32_t)in6.s6_addr[j*4 ] << 24) |
((ev_uint32_t)in6.s6_addr[j*4+1] << 16) |
((ev_uint32_t)in6.s6_addr[j*4+2] << 8) |
((ev_uint32_t)in6.s6_addr[j*4+3]);
if (u != ent->res[j]) {
TT_FAIL(("%s did not parse as expected.", ent->addr));
continue;
}
}
if (ent->status == CANONICAL) {
const char *w = evutil_inet_ntop(AF_INET6, &in6, written,
sizeof(written));
if (!w) {
TT_FAIL(("Tried to write out %s; got NULL.", ent->addr));
continue;
}
if (strcmp(written, ent->addr)) {
TT_FAIL(("Tried to write out %s; got %s", ent->addr, written));
continue;
}
}
}
#else
TT_BLATHER(("Skipping IPv6 address parsing."));
#endif
}
static void
regress_ipv4_parse(void *ptr)
{
int i;
for (i = 0; ipv4_entries[i].addr; ++i) {
char written[128];
struct ipv4_entry *ent = &ipv4_entries[i];
struct in_addr in;
int r;
r = evutil_inet_pton(AF_INET, ent->addr, &in);
if (r == 0) {
if (ent->status != BAD) {
TT_FAIL(("%s did not parse, but it's a good address!",
ent->addr));
}
continue;
}
if (ent->status == BAD) {
TT_FAIL(("%s parsed, but we expected an error", ent->addr));
continue;
}
if (ntohl(in.s_addr) != ent->res) {
TT_FAIL(("%s parsed to %lx, but we expected %lx", ent->addr,
(unsigned long)ntohl(in.s_addr),
(unsigned long)ent->res));
continue;
}
if (ent->status == CANONICAL) {
const char *w = evutil_inet_ntop(AF_INET, &in, written,
sizeof(written));
if (!w) {
TT_FAIL(("Tried to write out %s; got NULL.", ent->addr));
continue;
}
if (strcmp(written, ent->addr)) {
TT_FAIL(("Tried to write out %s; got %s",
ent->addr, written));
continue;
}
}
}
}
bool TcpClient::connect(const char *ip, uint16_t port)
{
if (NULL != _bev)
{
return false;
}
_bev = bufferevent_socket_new(_loop.getBase(), SOCKET_FD_INVALID,
BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE | BEV_OPT_DEFER_CALLBACKS);
if(NULL == _bev)
{
return false;
}
bufferevent_setcb(_bev, readCallback, writeCallback, eventCallback, this);
if (-1 == bufferevent_enable(_bev, EV_READ | EV_WRITE))
{
bufferevent_free(_bev);
_bev = NULL;
return false;
}
struct sockaddr_in serverAddr;
memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
evutil_inet_pton(AF_INET, ip, &serverAddr.sin_addr);
serverAddr.sin_port = htons(port);
if (-1 == bufferevent_socket_connect(_bev, (struct sockaddr *)&serverAddr, sizeof(serverAddr)))
{
bufferevent_free(_bev);
_bev = NULL;
return false;
}
evutil_make_socket_nonblocking(getSocket());
return true;
}
static int tr_globalAddress(int af, void* addr, int* addr_len)
{
struct sockaddr_storage ss;
socklen_t sslen = sizeof(ss);
struct sockaddr_in sin;
struct sockaddr_in6 sin6;
struct sockaddr* sa;
socklen_t salen;
int rc;
switch (af)
{
case AF_INET:
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
evutil_inet_pton(AF_INET, "91.121.74.28", &sin.sin_addr);
sin.sin_port = htons(6969);
sa = (struct sockaddr*)&sin;
salen = sizeof(sin);
break;
case AF_INET6:
memset(&sin6, 0, sizeof(sin6));
sin6.sin6_family = AF_INET6;
/* In order for address selection to work right, this should be
a native IPv6 address, not Teredo or 6to4. */
evutil_inet_pton(AF_INET6, "2001:1890:1112:1::20", &sin6.sin6_addr);
sin6.sin6_port = htons(6969);
sa = (struct sockaddr*)&sin6;
salen = sizeof(sin6);
break;
default:
return -1;
}
rc = get_source_address(sa, salen, (struct sockaddr*)&ss, &sslen);
if (rc < 0)
{
return -1;
}
if (global_unicast_address((struct sockaddr*)&ss) == 0)
{
return -1;
}
switch (af)
{
case AF_INET:
if (*addr_len < 4)
{
return -1;
}
memcpy(addr, &((struct sockaddr_in*)&ss)->sin_addr, 4);
*addr_len = 4;
return 1;
case AF_INET6:
if (*addr_len < 16)
{
return -1;
}
memcpy(addr, &((struct sockaddr_in6*)&ss)->sin6_addr, 16);
*addr_len = 16;
return 1;
default:
return -1;
}
}
void test_protocol()
{
/* get new string buffer */
cstring *version_msg_cstr = cstr_new_sz(256);
cstring *inv_msg_cstr = cstr_new_sz(256);
struct sockaddr_in test_sa, test_sa_check;
memset(&test_sa, 0, sizeof(test_sa));
memset(&test_sa_check, 0, sizeof(test_sa_check));
test_sa.sin_family = AF_INET;
struct sockaddr_in6 test_sa6, test_sa6_check;
test_sa6.sin6_family = AF_INET6;
test_sa6.sin6_port = htons(1024);
evutil_inet_pton(AF_INET, "10.0.0.1", &test_sa.sin_addr); // store IP in antelope
char i6buf[1024];
memset(&i6buf, 0, 1024);
evutil_inet_pton(AF_INET6, "::1", &test_sa6.sin6_addr);
btc_p2p_address ipv6Test;
btc_p2p_address_init(&ipv6Test);
btc_addr_to_p2paddr((struct sockaddr *)&test_sa6, &ipv6Test);
btc_p2paddr_to_addr(&ipv6Test, (struct sockaddr *)&test_sa6_check);
memset(&i6buf, 0, 1024);
u_assert_int_eq(test_sa6.sin6_port, test_sa6_check.sin6_port);
/* copy socket_addr to p2p addr */
btc_p2p_address fromAddr;
btc_p2p_address_init(&fromAddr);
btc_p2p_address toAddr;
btc_p2p_address_init(&toAddr);
btc_addr_to_p2paddr((struct sockaddr *)&test_sa, &toAddr);
btc_p2paddr_to_addr(&toAddr, (struct sockaddr *)&test_sa_check);
u_assert_int_eq(test_sa.sin_port, test_sa_check.sin_port);
evutil_inet_ntop(AF_INET, &test_sa_check.sin_addr, i6buf, 1024);
u_assert_str_eq(i6buf, "10.0.0.1");
/* create a inv message struct */
btc_p2p_inv_msg inv_msg, inv_msg_check;
memset(&inv_msg, 0, sizeof(inv_msg));
uint256 hash = {0};
btc_p2p_msg_inv_init(&inv_msg, 1, hash);
btc_p2p_msg_inv_ser(&inv_msg, inv_msg_cstr);
struct const_buffer buf_inv = {inv_msg_cstr->str, inv_msg_cstr->len};
u_assert_int_eq(btc_p2p_msg_inv_deser(&inv_msg_check, &buf_inv), true);
u_assert_int_eq(inv_msg_check.type, 1);
u_assert_mem_eq(inv_msg_check.hash, inv_msg.hash, sizeof(inv_msg.hash));
cstr_free(inv_msg_cstr, true);
/* create a version message struct */
btc_p2p_version_msg version_msg;
memset(&version_msg, 0, sizeof(version_msg));
/* create a serialized version message */
btc_p2p_msg_version_init(&version_msg, &fromAddr, &toAddr, "client", false);
btc_p2p_msg_version_ser(&version_msg, version_msg_cstr);
/* create p2p message */
cstring *p2p_msg = btc_p2p_message_new((unsigned const char *)&btc_chainparams_main.netmagic, BTC_MSG_VERSION, version_msg_cstr->str, version_msg_cstr->len);
struct const_buffer buf = {p2p_msg->str, p2p_msg->len};
btc_p2p_msg_hdr hdr;
btc_p2p_deser_msghdr(&hdr, &buf);
u_assert_mem_eq(hdr.netmagic, &btc_chainparams_main.netmagic, 4);
u_assert_str_eq(hdr.command, BTC_MSG_VERSION);
u_assert_int_eq(hdr.data_len, version_msg_cstr->len);
u_assert_int_eq(buf.len, hdr.data_len);
u_assert_int_eq(buf.len, hdr.data_len);
u_assert_mem_eq(buf.p, version_msg_cstr->str, hdr.data_len);
btc_p2p_version_msg v_msg_check;
u_assert_int_eq(btc_p2p_msg_version_deser(&v_msg_check, &buf), true);
u_assert_int_eq(v_msg_check.version, BTC_PROTOCOL_VERSION);
u_assert_str_eq(v_msg_check.useragent, "client");
u_assert_int_eq(v_msg_check.start_height, 0);
cstr_free(p2p_msg, true);
cstr_free(version_msg_cstr, true);
/* getheaders */
uint256 genesis_hash = {0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0xd6, 0x68, 0x9c, 0x08, 0x5a, 0xe1, 0x65, 0x83, 0x1e, 0x93, 0x4f, 0xf7, 0x63, 0xae, 0x46, 0xa2, 0xa6, 0xc1, 0x72, 0xb3, 0xf1, 0xb6, 0x0a, 0x8c, 0xe2, 0x6f};
vector *blocklocators = vector_new(1, NULL);
vector_add(blocklocators, genesis_hash);
cstring *getheader_msg = cstr_new_sz(256);
btc_p2p_msg_getheaders(blocklocators, NULL, getheader_msg);
p2p_msg = btc_p2p_message_new((unsigned const char *)&btc_chainparams_main.netmagic, BTC_MSG_GETHEADERS, getheader_msg->str, getheader_msg->len);
buf.p = p2p_msg->str;
buf.len = p2p_msg->len;
btc_p2p_deser_msghdr(&hdr, &buf);
u_assert_str_eq(hdr.command, BTC_MSG_GETHEADERS);
u_assert_int_eq(hdr.data_len, getheader_msg->len);
uint256 hashstop_check;
vector *blocklocators_check = vector_new(1, free);
btc_p2p_deser_msg_getheaders(blocklocators_check, hashstop_check, &buf);
u_assert_mem_eq(NULLHASH, hashstop_check, sizeof(hashstop_check));
uint8_t *hash_loc_0 = vector_idx(blocklocators_check, 0);
u_assert_mem_eq(genesis_hash, hash_loc_0, sizeof(genesis_hash));
/* cleanup */
cstr_free(getheader_msg, true);
vector_free(blocklocators, true);
vector_free(blocklocators_check, true);
cstr_free(p2p_msg, true);
}
/**
* Start server.
*
* @return 0 if successful, otherwise -1.
*/
int ad_server_start(ad_server_t *server) {
DEBUG("Starting a server.");
// Set default options that were not set by user..
set_undefined_options(server);
// Hookup libevent's log message.
if (_ad_log_level >= AD_LOG_DEBUG) {
event_set_log_callback(libevent_log_cb);
if (_ad_log_level >= AD_LOG_DEBUG2) {
event_enable_debug_mode();
}
}
// Parse addr
int port = ad_server_get_option_int(server, "server.port");
char *addr = ad_server_get_option(server, "server.addr");
struct sockaddr *sockaddr = NULL;
size_t sockaddr_len = 0;
if (addr[0] == '/') { // Unix socket.
struct sockaddr_un unixaddr;
bzero((void *) &unixaddr, sizeof(struct sockaddr_un));
if (strlen(addr) >= sizeof(unixaddr.sun_path)) {
errno = EINVAL;
DEBUG("Too long unix socket name. '%s'", addr);
return -1;
}
unixaddr.sun_family = AF_UNIX;
strcpy(unixaddr.sun_path, addr); // no need of strncpy()
sockaddr = (struct sockaddr *) &unixaddr;
sockaddr_len = sizeof(unixaddr);
} else if (strstr(addr, ":")) { // IPv6
struct sockaddr_in6 ipv6addr;
bzero((void *) &ipv6addr, sizeof(struct sockaddr_in6));
ipv6addr.sin6_family = AF_INET6;
ipv6addr.sin6_port = htons(port);
evutil_inet_pton(AF_INET6, addr, &ipv6addr.sin6_addr);
sockaddr = (struct sockaddr *) &ipv6addr;
sockaddr_len = sizeof(ipv6addr);
} else { // IPv4
struct sockaddr_in ipv4addr;
bzero((void *) &ipv4addr, sizeof(struct sockaddr_in));
ipv4addr.sin_family = AF_INET;
ipv4addr.sin_port = htons(port);
ipv4addr.sin_addr.s_addr =
(IS_EMPTY_STR(addr)) ? INADDR_ANY : inet_addr(addr);
sockaddr = (struct sockaddr *) &ipv4addr;
sockaddr_len = sizeof(ipv4addr);
}
// SSL
if (!server->sslctx && ad_server_get_option_int(server, "server.enable_ssl")) {
char *cert_path = ad_server_get_option(server, "server.ssl_cert");
char *pkey_path = ad_server_get_option(server, "server.ssl_pkey");
server->sslctx = init_ssl(cert_path, pkey_path);
if (server->sslctx == NULL) {
ERROR("Couldn't load certificate file(%s) or private key file(%s).",
cert_path, pkey_path);
return -1;
}
DEBUG("SSL Initialized.");
}
// Bind
if (! server->evbase) {
server->evbase = event_base_new();
if (! server->evbase) {
ERROR("Failed to create a new event base.");
return -1;
}
}
// Create a eventfd for notification channel.
int notifyfd = eventfd(0, 0);
server->notify_buffer = bufferevent_socket_new(server->evbase, notifyfd, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(server->notify_buffer, NULL, notify_cb, NULL, server);
if (! server->listener) {
server->listener = evconnlistener_new_bind(
server->evbase, listener_cb, (void *)server,
LEV_OPT_THREADSAFE | LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE,
ad_server_get_option_int(server, "server.backlog"),
sockaddr, sockaddr_len);
if (! server->listener) {
ERROR("Failed to bind on %s:%d", addr, port);
return -1;
}
}
// Listen
INFO("Listening on %s:%d%s", addr, port, ((server->sslctx) ? " (SSL)" : ""));
int exitstatus = 0;
if (ad_server_get_option_int(server, "server.thread")) {
DEBUG("Launching server as a thread.")
server->thread = NEW_OBJECT(pthread_t);
pthread_create(server->thread, NULL, &server_loop, (void *)server);
//pthread_detach(server->thread);
} else {
int *retval = server_loop(server);
exitstatus = *retval;
free(retval);
close_server(server);
if (ad_server_get_option_int(server, "server.free_on_stop")) {
ad_server_free(server);
}
}
return exitstatus;
}
int main(int argc, char *argv[])
{
int i;
int ret;
// CONTAINER *tmp;
int resume = 0;
struct sockaddr_in sin;
int16_t port;
FILE *file;
char *line;
char *ip;
srandom(time(NULL));
ret = log4c_init();
if (ret != 0) {
printf("log4c_init failed[%d]\n", ret);
return ret;
}
mycat = log4c_category_get("six13log.log.app");
if (!mycat) {
printf("log4c_category_get(\"six13log.log.app.application1\"); failed\n");
return (0);
}
obj_count_loger = log4c_category_get("count_obj_cate");
if (!obj_count_loger) {
printf("log4c_category_get(\"six13log.log.app.application2\"); failed\n");
return (0);
}
for (i = 1; i < argc; ++i) {
if (strcmp(argv[i], "-d") == 0) {
change_to_deamon();
--argc;
break;
}
}
if (argc > 1)
resume = 1;
ret = load_all_config();
if (ret != 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "load all config fail[%d]\n", ret);
return (-1);
}
ret = init_gm_system();
if (ret != 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "init gm system fail[%d]\n", ret);
return (-1);
}
sc_interface = load_game_script();
if (!sc_interface) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "load script fail[%d]\n");
return (-1);
}
log4c_category_log(mycat, LOG4C_PRIORITY_INFO, "game_srv run");
role_rbdata_init_head();
file = fopen("../server_info.ini", "r");
if (!file) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "open server_info.ini failed[%d]", errno);
return (-1);
}
line = get_first_key(file, "game_srv_key");
key = strtoul(get_value(line), NULL, 0);
if (key == 0 || key == ULONG_MAX) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "config file wrong, no game_srv_key");
return (-1);
}
if (alloc_shared_mem(resume) != 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "alloc_shared_mem[%d] failed", resume);
return (-1);
}
ret = init_all_objs(resume);
if (ret != 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "init_all_objs[%d] failed[%d]", resume, ret);
return (-1);
}
ret = create_all_static_scene();
if (ret != 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "creeate_all_static_scene[%d] failed[%d]", resume, ret);
return (-1);
}
// test_fight();
// return (0);
ret = game_event_init();
if (ret != 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "game_event_init failed[%d]", ret);
return (-1);
}
line = get_first_key(file, "conn_srv_ip");
for (i = 0; i < MAX_CONN_SRV && line != NULL; ++i) {
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
conn_server[i].cb_recv = gamesrv_cb_conn_recv;
ip = get_value(line);
if (!ip)
break;
line = get_next_key(file, "conn_srv_port");
if (!line)
break;
port = atoi(get_value(line));
if (port <= 0)
break;
line = get_next_key(file, "conn_srv_ip");
sin.sin_port = htons(port);
ret = evutil_inet_pton(AF_INET, ip, &sin.sin_addr);
if (ret != 1) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "evutil_inet_pton failed[%d], ip[%s] port[%d]", ret, ip, port);
return (-1);
}
ret = game_add_connect_event((struct sockaddr *)&sin, sizeof(sin), &conn_server[i]);
if (ret < 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "game_add_connect_event to conn server failed[%d], ip[%s] port[%d]", ret, ip, port);
return (-1);
}
conn_server[i].fd = ret;
}
if (i == 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "config file wrong, no conn_srv");
return (-1);
}
max_conn_srv = i;
line = get_first_key(file, "db_srv_ip");
for (i = 0; i < MAX_ROLEDB_SRV && line != NULL; ++i) {
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
roledb_server[i].cb_recv = gamesrv_cb_roledb_recv;
ip = get_value(line);
if (!ip)
break;
line = get_next_key(file, "db_srv_port");
if (!line)
break;
port = atoi(get_value(line));
if (port <= 0)
break;
line = get_next_key(file, "db_srv_ip");
sin.sin_port = htons(port);
ret = evutil_inet_pton(AF_INET, ip, &sin.sin_addr);
if (ret != 1) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "evutil_inet_pton failed[%d], ip[%s] port[%d]", ret, ip, port);
return (-1);
}
ret = game_add_connect_event((struct sockaddr *)&sin, sizeof(sin), &roledb_server[i]);
if (ret < 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "game_add_connect_event to conn server failed[%d], ip[%s] port[%d]", ret, ip, port);
return (-1);
}
roledb_server[i].fd = ret;
}
if (i == 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "config file wrong, no roldb_srv");
return (-1);
}
max_roledb_srv = i;
active_roledb_srv = &roledb_server[0];
fclose(file);
struct timeval t1 = {5, 0};
add_timer(t1, &log_object_timer);
log_object_timer.ev_callback = cb_log_object_timer;
ret = event_base_loop(base, 0);
log4c_category_log(mycat, LOG4C_PRIORITY_INFO, "event_base_loop stoped[%d]", ret);
/*
tmp = create_container();
tmp = create_container();
tmp = create_container();
destory_container(tmp);
tmp = create_container();
destory_container(tmp);
tmp = create_container();
*/
/*
GAME_CIRCLEQ_FOREACH(tmp, pool_container_freed, base.list_free) {
printf("tmp[idx] = %d:%d\n", tmp->base.list_free.idx, tmp->base.list_used.idx);
}
printf("\n ================== \n");
GAME_CIRCLEQ_FOREACH(tmp, pool_container_used, base.list_used) {
printf("tmp[idx] = %d:%d\n", tmp->base.list_free.idx, tmp->base.list_used.idx);
}
*/
return (0);
}
