static void
_ctrl(struct gate * g, const void * msg, int sz) {
struct skynet_context * ctx = g->ctx;
char tmp[sz+1];
memcpy(tmp, msg, sz);
tmp[sz] = '\0';
char * command = tmp;
int i;
if (sz == 0)
return;
for (i=0;i<sz;i++) {
if (command[i]==' ') {
break;
}
}
if (memcmp(command,"kick",i)==0) {
_parm(tmp, sz, i);
int uid = strtol(command , NULL, 10);
int id = hashid_lookup(&g->hash, uid);
if (id>=0) {
skynet_socket_close(ctx, uid);
}
return;
}
if (memcmp(command,"forward",i)==0) {
_parm(tmp, sz, i);
char * client = tmp;
char * idstr = strsep(&client, " ");
if (client == NULL) {
return;
}
int id = strtol(idstr , NULL, 10);
char * agent = strsep(&client, " ");
if (client == NULL) {
return;
}
uint32_t agent_handle = strtoul(agent+1, NULL, 16);
uint32_t client_handle = strtoul(client+1, NULL, 16);
_forward_agent(g, id, agent_handle, client_handle);
return;
}
if (memcmp(command,"broker",i)==0) {
_parm(tmp, sz, i);
g->broker = skynet_queryname(ctx, command);
return;
}
if (memcmp(command,"start",i) == 0) {
skynet_socket_start(ctx, g->listen_id);
return;
}
if (memcmp(command, "close", i) == 0) {
if (g->listen_id >= 0) {
skynet_socket_close(ctx, g->listen_id);
g->listen_id = -1;
}
return;
}
skynet_error(ctx, "[gate] Unkown command : %s", command);
}
static int
lclose(lua_State *L) {
int id = luaL_checkinteger(L,1);
struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
skynet_socket_close(ctx, id);
return 0;
}
void
master_release(struct master * m) {
int i;
struct skynet_context *ctx = m->ctx;
for (i=0;i<REMOTE_MAX;i++) {
int fd = m->remote_fd[i];
if (fd >= 0) {
assert(ctx);
skynet_socket_close(ctx, fd); // 关闭socket fd
}
free(m->remote_addr[i]);
}
for (i=0;i<HASH_SIZE;i++) {
struct name * node = m->map.node[i];
while (node) {
struct name * next = node->next;
free(node);
node = next;
}
}
free(m);
}
void
gate_release(struct gate *g) {
int i;
struct skynet_context *ctx = g->ctx;
for (i=0;i<g->max_connection;i++) {
struct connection *c = &g->conn[i];
if (c->id >=0) {
skynet_socket_close(ctx, c->id);
}
}
if (g->listen_id >= 0) {
skynet_socket_close(ctx, g->listen_id);
}
messagepool_free(&g->mp);
hashid_clear(&g->hash);
skynet_free(g->conn);
skynet_free(g);
}
static void
close_harbor(struct master *m, int harbor_id) {
if (m->connected[harbor_id]) {
struct skynet_context * context = m->ctx;
skynet_socket_close(context, m->remote_fd[harbor_id]);
m->remote_fd[harbor_id] = -1;
m->connected[harbor_id] = false;
}
}
HARBOR_API void
harbor_release(struct harbor *h) {
struct skynet_context *ctx = h->ctx;
if (h->master_fd >= 0) {
skynet_socket_close(ctx, h->master_fd);
}
skynet_free(h->master_addr);
skynet_free(h->local_addr);
int i;
for (i=0;i<REMOTE_MAX;i++) {
if (h->remote_fd[i] >= 0) {
skynet_socket_close(ctx, h->remote_fd[i]);
skynet_free(h->remote_addr[i]);
}
}
_hash_delete(h->map);
skynet_free(h);
}
static void
close_harbor(struct harbor *h, int fd) {
int id = harbor_id(h,fd);
if (id == 0)
return;
skynet_error(h->ctx, "Harbor %d closed",id);
skynet_socket_close(h->ctx, fd);
h->remote_fd[id] = -1;
h->connected[id] = false;
}
// driver.close(id)
// socket.close_fd(fd)
// socket.lua
static int
lclose(lua_State *L) {
int id = luaL_checkinteger(L,1);
struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
// skynet_socket_close skynet_socket
// socket_server_close socket_server
// send_request 'K'
// close_socket
skynet_socket_close(ctx, id);
return 0;
}
static void
close_harbor(struct harbor *h, int id) {
struct slave *s = &h->s[id];
s->status = STATUS_DOWN;
if (s->fd) {
skynet_socket_close(h->ctx, s->fd);
}
if (s->queue) {
release_queue(s->queue);
s->queue = NULL;
}
}
void
otu_release(struct otu *u) {
struct skynet_context *ctx = u->ctx;
if (u->service_id >= 0) {
skynet_socket_close(ctx, u->service_id);
}
hashid64_clear(&u->hash);
skynet_free(u->peer);
skynet_free(u);
}
static void
_update_remote_address(struct harbor *h, int harbor_id, const char * ipaddr) {
if (harbor_id == h->id) {
return;
}
assert(harbor_id > 0 && harbor_id< REMOTE_MAX);
struct skynet_context * context = h->ctx;
if (h->remote_fd[harbor_id] >=0) {
skynet_socket_close(context, h->remote_fd[harbor_id]);
skynet_free(h->remote_addr[harbor_id]);
h->remote_addr[harbor_id] = NULL;
}
h->remote_fd[harbor_id] = _connect_to(h, ipaddr, false);
h->connected[harbor_id] = false;
}
static void
dispatch_message(struct gate *g, struct connection *c, int id, void * data, int sz) {
databuffer_push(&c->buffer,&g->mp, data, sz);
for (;;) {
int size = databuffer_readheader(&c->buffer, &g->mp, g->header_size);
if (size < 0) {
return;
} else if (size > 0) {
if (size >= 0x1000000) {
struct skynet_context * ctx = g->ctx;
databuffer_clear(&c->buffer,&g->mp);
skynet_socket_close(ctx, id);
skynet_error(ctx, "Recv socket message > 16M");
return;
} else {
_forward(g, c, size);
databuffer_reset(&c->buffer);
}
}
}
}
static void
dispatch_socket_message(struct gate *g, const struct skynet_socket_message * message, int sz) {
struct skynet_context * ctx = g->ctx;
switch(message->type) {
case SKYNET_SOCKET_TYPE_DATA: {
int id = hashid_lookup(&g->hash, message->id);
if (id>=0) {
struct connection *c = &g->conn[id];
dispatch_message(g, c, message->id, message->buffer, message->ud);
} else {
skynet_error(ctx, "Drop unknown connection %d message", message->id);
skynet_socket_close(ctx, message->id);
skynet_free(message->buffer);
}
break;
}
case SKYNET_SOCKET_TYPE_CONNECT: {
if (message->id == g->listen_id) {
// start listening
break;
}
int id = hashid_lookup(&g->hash, message->id);
if (id<0) {
skynet_error(ctx, "Close unknown connection %d", message->id);
skynet_socket_close(ctx, message->id);
}
break;
}
case SKYNET_SOCKET_TYPE_CLOSE:
case SKYNET_SOCKET_TYPE_ERROR: {
int id = hashid_remove(&g->hash, message->id);
if (id>=0) {
struct connection *c = &g->conn[id];
databuffer_clear(&c->buffer,&g->mp);
memset(c, 0, sizeof(*c));
c->id = -1;
_report(g, "%d close", message->id);
}
break;
}
case SKYNET_SOCKET_TYPE_ACCEPT:
// report accept, then it will be get a SKYNET_SOCKET_TYPE_CONNECT message
assert(g->listen_id == message->id);
if (hashid_full(&g->hash)) {
skynet_socket_close(ctx, message->ud);
} else {
struct connection *c = &g->conn[hashid_insert(&g->hash, message->ud)];
if (sz >= sizeof(c->remote_name)) {
sz = sizeof(c->remote_name) - 1;
}
c->id = message->ud;
memcpy(c->remote_name, message+1, sz);
c->remote_name[sz] = '\0';
_report(g, "%d open %d %s:0",c->id, c->id, c->remote_name);
skynet_error(ctx, "socket open: %x", c->id);
}
break;
case SKYNET_SOCKET_TYPE_WARNING:
skynet_error(ctx, "fd (%d) send buffer (%d)K", message->id, message->ud);
break;
}
}