/** * New Pomelo package arrived callback. * * @param type Pomelo package type * @param data package body * @param len package body length * @param attach attach pointer pass to pc_pkg_parser_t */ void pc__pkg_cb(pc_pkg_type type, const char *data, size_t len, void *attach) { pc_client_t *client = (pc_client_t *)attach; int status = 0; switch(type) { case PC_PKG_HANDSHAKE: status = pc__handshake_resp(client, data, len); break; case PC_PKG_HEARBEAT: status = pc__heartbeat(client); break; case PC_PKG_DATA: status = pc__data(client, data, len); break; case PC_PKG_KICK: pc_emit_event(client, PC_EVENT_KICK, NULL); break; default: fprintf(stderr, "Unknown Pomelo package type: %d.\n", type); status = -1; break; } if(status == -1) { pc_client_stop(client); } }
void pc_client_destroy(pc_client_t *client) { if(PC_ST_INITED == client->state) { pc__client_clear(client); goto finally; } if(PC_ST_CLOSED == client->state) { pc__client_clear(client); goto finally; } // 1. asyn worker thread // 2. wait work thread exit // 3. free client uv_async_send(client->close_async); pc_client_join(client); if(PC_ST_CLOSED != client->state) { pc_client_stop(client); // wait uv_loop_t stop sleep(1); pc__client_clear(client); } finally: if(client->uv_loop) { uv_loop_delete(client->uv_loop); client->uv_loop = NULL; } free(client); }
void pc__client_reconnect_timer_cb(uv_timer_t* timer, int status) { /* unused */ (void)status; pc_client_t* client = (pc_client_t*)timer->data; pc_connect_t* conn_req = pc_connect_req_new(&client->addr); if (!conn_req) { fprintf(stderr, "out of memory"); pc_client_stop(client); } if(pc_connect(client, conn_req, NULL, pc__client_reconnected_cb)) { fprintf(stderr, "Fail to connect to server.\n"); pc_connect_req_destroy(conn_req); client->reconnecting = 0; pc_client_stop(client); } }
void pc__heartbeat_cb(uv_timer_t* heartbeat_timer, int status) { uv_timer_stop(heartbeat_timer); pc_client_t *client = (pc_client_t *)heartbeat_timer->data; if(status == -1) { fprintf(stderr, "Pomelo heartbeat timer error, %s\n", uv_err_name(uv_last_error(client->uv_loop))); pc_client_stop(client); return; } if(pc__heartbeat_req(client)) { pc_client_stop(client); return; } uv_timer_again(client->timeout_timer); }
// server push message "onHey" callback. void on_hey(pc_client_t *client, const char *event, void *data) { json_t *push_msg = (json_t *)data; const char *json_str = json_dumps(push_msg, 0); printf("on event: %s, serve push msg: %s\n", event, json_str); free((void *)json_str); // stop the working thread. pc_client_stop(client); }
static void pc__client_connect3_cb(pc_connect_t* req, int status) { if(status == -1) { pc_client_stop(req->client); pc_connect_req_destroy(req); return; } pc_emit_event(req->client, PC_EVENT_RECONNECT, req->client); pc_connect_req_destroy(req); }
void pc__client_reconnected_cb(pc_connect_t* conn_req, int status) { pc_client_t* client = conn_req->client; client->reconnecting = 0; uv_timer_stop(&client->reconnect_timer); if (status == 0) { client->reconnects = 0; pc_emit_event(client, PC_EVENT_RECONNECT, client); } else { pc_client_stop(client); } }
void pc__timeout_cb(uv_timer_t* timeout_timer, int status) { uv_timer_stop(timeout_timer); pc_client_t *client = (pc_client_t *)timeout_timer->data; if(status == -1) { fprintf(stderr, "Pomelo timeout timer error, %s\n", uv_err_name(uv_last_error(client->uv_loop))); } else { fprintf(stderr, "Pomelo client heartbeat timeout.\n"); } pc_client_stop(client); }
void on_request_gate_cb(pc_request_t *req, int status, json_t *resp) { if (status == -1) { printf("Fail to send request to server.\n"); } else if (status == 0) { connectorHost = json_string_value(json_object_get(resp, "host")); connectorPort = json_number_value(json_object_get(resp, "port")); pc_client_t *client = pc_client_new(); struct sockaddr_in address; memset(&address, 0, sizeof(struct sockaddr_in)); address.sin_family = AF_INET; address.sin_port = htons(connectorPort); address.sin_addr.s_addr = inet_addr(connectorHost); // add pomelo events listener pc_add_listener(client, "disconnect", on_disconnect); pc_add_listener(client, "onChat", on_chat); pc_add_listener(client, "onAdd", on_add); pc_add_listener(client, "onLeave", on_leave); printf("try to connect to connector server %s %d\n", connectorHost, connectorPort); // try to connect to server. if (pc_client_connect(client, &address)) { printf("fail to connect connector server.\n"); pc_client_destroy(client); return ; } const char *route = "connector.entryHandler.enter"; json_t *msg = json_object(); json_t *str = json_string(user); json_t *channel_str = json_string(channel); json_object_set_new(msg, "username", str); json_object_set_new(msg, "rid", channel_str); pc_request_t *request = pc_request_new(); printf("%s %s\n", user, channel); pc_request(client, request, route, msg, on_request_connector_cb); } // release relative resource with pc_request_t json_t *pc_msg = req->msg; pc_client_t *pc_client = req->client; json_decref(pc_msg); pc_request_destroy(req); pc_client_stop(pc_client); }
static void pc__heartbeat_req_cb(uv_write_t* req, int status) { void **data = (void **)req->data; pc_client_t *client = (pc_client_t *)data[0]; char *base = (char *)data[1]; free(base); free(data); free(req); if(status == -1) { fprintf(stderr, "Fail to write heartbeat async, %s.\n", uv_err_name(uv_last_error(client->uv_loop))); pc_client_stop(client); } }
// request callback void on_request_cb(pc_request_t *req, int status, json_t *resp) { if(status == -1) { printf("Fail to send request to server.\n"); } else if(status == 0) { printf("server response: %s\n", json_dumps(resp, 0)); } // release relative resource with pc_request_t json_t *msg = req->msg; json_decref(msg); pc_request_destroy(req); count--; if(count == 0) pc_client_stop(req->client); }
void on_request_cb(pc_request_t* req, int status, json_t* resp) { if (status == -1) { printf("Fail to request to server.\n"); } else if (status == 0) { char * json_str = json_dumps(resp, 0); if (json_str != NULL) { printf("server response:%s\n", json_str); free(json_str); } } json_t *msg = req->msg; pc_client_t *client = req->client; json_decref(msg); pc_request_destroy(req); pc_client_stop(client); }
void NetImpl::on_request_cb( pc_request_t* __req, int __status, json_t* __resp ) { if(__status == -1) { printf("Fail to send request to server.\n"); } else if(__status == 0) { char* __json_str = json_dumps(__resp, 0); if(__json_str != NULL) { printf("server response: %s\n", __json_str); free(__json_str); } } // release relative resource with pc_request_t json_t*__msg = __req->msg; pc_client_t* __client = __req->client; json_decref(__msg); pc_request_destroy(__req); // stop client pc_client_stop(__client); }
void Login::requstGateCallback(pc_request_t *req, int status, json_t *resp) { if(status == -1) { CCLOG("Fail to send request to server.\n"); } else if(status == 0) { connectorHost = json_string_value(json_object_get(resp, "host")); connectorPort = json_number_value(json_object_get(resp, "port")); CCLOG("%s %d", connectorHost,connectorPort); pc_client_t *client = pc_client_new(); struct sockaddr_in address; memset(&address, 0, sizeof(struct sockaddr_in)); address.sin_family = AF_INET; address.sin_port = htons(connectorPort); address.sin_addr.s_addr = inet_addr(connectorHost); // add pomelo events listener void (*on_disconnect)(pc_client_t *client, const char *event, void *data) = &Login::onDisconnectCallback; void (*on_chat)(pc_client_t *client, const char *event, void *data) = &Login::onChatCallback; void (*on_add)(pc_client_t *client, const char *event, void *data) = &Login::onAddCallback; void (*on_leave)(pc_client_t *client, const char *event, void *data) = &Login::onLeaveCallback; pc_add_listener(client, "disconnect", on_disconnect); pc_add_listener(client, "onChat", on_chat); pc_add_listener(client, "onAdd", on_add); pc_add_listener(client, "onLeave", on_leave); // try to connect to server. if(pc_client_connect(client, &address)) { CCLOG("fail to connect server.\n"); pc_client_destroy(client); return ; } const char *route = "connector.entryHandler.enter"; json_t *msg = json_object(); json_t *str = json_string(username.c_str()); json_t *channel_str = json_string(channel.c_str()); json_object_set(msg, "username", str); json_object_set(msg, "rid", channel_str); // decref for json object json_decref(str); json_decref(channel_str); pc_request_t *request = pc_request_new(); void (*connect_cb)(pc_request_t *req, int status, json_t *resp )= &Login::requstConnectorCallback; pc_request(client, request, route, msg, connect_cb); /* char *json_str = json_dumps(resp, 0); if(json_str != NULL) { CCLOG("server response: %s %d\n", connectorHost, connectorPort); free(json_str); } */ } // release relative resource with pc_request_t json_t *pc_msg = req->msg; pc_client_t *pc_client = req->client; json_decref(pc_msg); pc_request_destroy(req); pc_client_stop(pc_client); }