static int
lstart(lua_State *L) {
struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
int id = luaL_checkinteger(L, 1);
skynet_socket_start(ctx,id);
return 0;
}
static int
start_listen(struct gate *g, char * listen_addr) {
struct skynet_context * ctx = g->ctx;
char * portstr = strchr(listen_addr,':');
const char * host = "";
int port;
if (portstr == NULL) {
port = strtol(listen_addr, NULL, 10);
if (port <= 0) {
skynet_error(ctx, "Invalid gate address %s",listen_addr);
return 1;
}
} else {
port = strtol(portstr + 1, NULL, 10);
if (port <= 0) {
skynet_error(ctx, "Invalid gate address %s",listen_addr);
return 1;
}
portstr[0] = '\0';
host = listen_addr;
}
g->listen_id = skynet_socket_listen(ctx, host, port, BACKLOG);
if (g->listen_id < 0) {
return 1;
}
skynet_socket_start(ctx, g->listen_id);
return 0;
}
static int
start_service(struct otu *u, char * service_addr) {
struct skynet_context * ctx = u->ctx;
char * portstr = strchr(service_addr,':');
const char * host = "";
int port;
if (portstr == NULL) {
port = strtol(service_addr, NULL, 10);
if (port <= 0) {
skynet_error(ctx, "Invalid gate address %s",service_addr);
return 1;
}
} else {
port = strtol(portstr + 1, NULL, 10);
if (port <= 0) {
skynet_error(ctx, "Invalid gate address %s",service_addr);
return 1;
}
portstr[0] = '\0';
host = service_addr;
}
u->service_id = skynet_socket_udp(ctx, host, port) ;
if (u->service_id < 0) {
return 1;
}
skynet_socket_start(ctx, u->service_id);
return 0;
}
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);
}
// driver.start
// socket.start socket.lua
static int
lstart(lua_State *L) {
struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
int id = luaL_checkinteger(L, 1);
// skynet_socket_start skynet_socket
// socket_server_start socket_server
// send_request 'S'
// start_socket
skynet_socket_start(ctx,id);
return 0;
}
int
package_init(struct package * P, struct skynet_context *ctx, const char * param) {
int n = sscanf(param ? param : "", "%u %d", &P->manager, &P->fd);
if (n != 2 || P->manager == 0 || P->fd == 0) {
skynet_error(ctx, "Invalid param [%s]", param);
return 1;
}
skynet_socket_start(ctx, P->fd);
skynet_socket_nodelay(ctx, P->fd);
heartbeat(ctx, P);
skynet_callback(ctx, P, message_handler);
return 0;
}
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);
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) {
struct connection *c = &g->conn[id];
_report(g, "%d open %d %s:0",message->id,message->id,c->remote_name);
} else {
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';
skynet_socket_start(ctx, message->ud);
}
break;
}
}
