static int
_cb(struct skynet_context * ctx, void * ud, int type, int session, uint32_t source, const void * msg, size_t sz) {
struct gate *g = ud;
switch(type) {
case PTYPE_TEXT:
_ctrl(g , msg , (int)sz);
break;
case PTYPE_CLIENT: {
if (sz <=4 ) {
skynet_error(ctx, "Invalid client message from %x",source);
break;
}
// The last 4 bytes in msg are the id of socket, write following bytes to it
const uint8_t * idbuf = msg + sz - 4;
uint32_t uid = idbuf[0] | idbuf[1] << 8 | idbuf[2] << 16 | idbuf[3] << 24;
int id = hashid_lookup(&g->hash, uid);
if (id>=0) {
// don't send id (last 4 bytes)
skynet_socket_send(ctx, uid, (void*)msg, sz-4);
// return 1 means don't free msg
return 1;
} else {
skynet_error(ctx, "Invalid client id %d from %x",(int)uid,source);
break;
}
}
case PTYPE_SOCKET:
// recv socket message from skynet_socket
dispatch_socket_message(g, msg, (int)(sz-sizeof(struct skynet_socket_message)));
break;
}
return 0;
}
bool sendToClinet(const PkgHead& pkg_head, const google::protobuf::Message& message)
{
char buff[MAX_BUFF];
char *p = buff;
int32_t pkg_head_size = sizeof(pkg_head);
int32_t pkg_body_size = message.ByteSize();
int32_t pkg_total_size = pkg_head_size + pkg_body_size;
__BEGIN_PROC__
//消息头
int32_t *header = (int32_t *)p;
*header = htonl(pkg_total_size);
p += sizeof(*header);
int32_t send_len = sizeof(*header) + pkg_total_size;
if(send_len > MAX_BUFF)
{
LOG_ERROR(0, "there is no enough buff. buff size:%d, real size:%d", MAX_BUFF, send_len);
break;
}
//协议包头
PkgHead *p_pkg_head = (PkgHead *)p;
*p_pkg_head = pkg_head;
p_pkg_head->body_len = pkg_body_size;
p_pkg_head->pack();
p += sizeof(PkgHead);
//协议包体
if (!message.SerializeToArray(p, pkg_body_size))
{
LOG_ERROR(0, "message.SerializeToArray failed");
break;
}
int32_t ret = 0;
ret = skynet_socket_send(0, pkg_head.client_fd, buff, send_len);
if(-1 == ret)
{
LOG_ERROR(0, "skynet_socket_send failed");
break;
}
LOG_DEBUG(0, "send_len:%d pkg_body_len:%d", send_len, pkg_body_size);
return true;
__END_PROC__
return false;
}
static int
lsend(lua_State *L) {
struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
int id = luaL_checkinteger(L, 1);
int sz = 0;
void *buffer = get_buffer(L, 2, &sz);
int err = skynet_socket_send(ctx, id, buffer, sz);
lua_pushboolean(L, !err);
return 1;
}
static void
_send_package(struct skynet_context *ctx, int fd, const void * buffer, size_t sz) {
uint8_t * sendbuf = (uint8_t *)skynet_malloc(sz+4);
to_bigendian(sendbuf, sz);
memcpy(sendbuf+4, buffer, sz);
if (skynet_socket_send(ctx, fd, sendbuf, sz+4)) {
skynet_error(ctx, "Send to %d error", fd);
}
}
static void
_send_remote(struct skynet_context * ctx, int fd, const char * buffer, size_t sz, struct remote_message_header * cookie) {
uint32_t sz_header = sz+sizeof(*cookie);
uint8_t * sendbuf = (uint8_t *)skynet_malloc(sz_header+4);
to_bigendian(sendbuf, sz_header);
memcpy(sendbuf+4, buffer, sz);
_header_to_message(cookie, sendbuf+4+sz);
if (skynet_socket_send(ctx, fd, sendbuf, sz_header+4)) {
skynet_error(ctx, "Remote send to %d error", fd);
}
}
static void
send_out(struct skynet_context *ctx, struct package *P, const void *msg, size_t sz) {
if (sz > 0xffff) {
skynet_error(ctx, "package too long (%08x)", (uint32_t)sz);
return;
}
uint8_t *p = skynet_malloc(sz + 2);
p[0] = (sz & 0xff00) >> 8;
p[1] = sz & 0xff;
memcpy(p+2, msg, sz);
skynet_socket_send(ctx, P->fd, p, sz+2);
}
static void
_send_to(struct master *m, int id, const void * buf, int sz, uint32_t handle) {
uint8_t * buffer= (uint8_t *)skynet_malloc(4 + sz + 12);
to_bigendian(buffer, sz+12);
memcpy(buffer+4, buf, sz);
to_bigendian(buffer+4+sz, 0);
to_bigendian(buffer+4+sz+4, handle);
to_bigendian(buffer+4+sz+8, 0);
sz += 4 + 12;
if (skynet_socket_send(m->ctx, m->remote_fd[id], buffer, sz)) {
skynet_error(m->ctx, "Harbor %d : send error", id);
}
}
static int
lsend(lua_State *L) {
struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
int id = luaL_checkinteger(L, 1);
void *buffer;
int sz;
if (lua_isuserdata(L,2)) {
buffer = lua_touserdata(L,2);
sz = luaL_checkinteger(L,3);
} else {
size_t len = 0;
const char * str = luaL_checklstring(L, 2, &len);
buffer = malloc(len);
memcpy(buffer, str, len);
sz = (int)len;
}
int err = skynet_socket_send(ctx, id, buffer, sz);
lua_pushboolean(L, !err);
return 1;
}
