398 lines
8.8 KiB
C
398 lines
8.8 KiB
C
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <pthread.h>
|
|
#include <errno.h>
|
|
#include <sys/prctl.h>
|
|
|
|
#include "dataserver_rb.h"
|
|
#include "dataserver_reader.h"
|
|
#include "dataserver_reader_inner.h"
|
|
#include "dataserver_message.h"
|
|
#include "dataserver_process.h"
|
|
#include "dataserver_utils.h"
|
|
#include "dataserver_inner.h"
|
|
|
|
#include "list.h"
|
|
|
|
#ifdef LOG_LOGCAT
|
|
|
|
#define LOG_TAG "ccdataserver"
|
|
#include <log/log.h>
|
|
#define ds_inf(_fmt_,...) ALOGI("%s:%d "_fmt_, __func__, __LINE__, ##__VA_ARGS__)
|
|
#define ds_err(_fmt_,...) ALOGE("%s:%d "_fmt_, __func__, __LINE__, ##__VA_ARGS__)
|
|
|
|
#else
|
|
|
|
#define ds_inf(_fmt_,...) printf("I %s:%d "_fmt_"\n", __func__, __LINE__, ##__VA_ARGS__)
|
|
#define ds_err(_fmt_,...) printf("E %s:%d "_fmt_"\n", __func__, __LINE__, ##__VA_ARGS__)
|
|
|
|
#endif
|
|
|
|
|
|
/*ret:
|
|
* -1: next
|
|
* -3: error
|
|
*/
|
|
int ds_connection_manage_data_in(ds_connection_t *conn)
|
|
{
|
|
/*Assume the size is no more than these values*/
|
|
#define MAX_MESSAGE_SIZE 1024
|
|
#define MAX_RESP_SIZE 1024
|
|
|
|
uint8_t buf[MAX_MESSAGE_SIZE];
|
|
uint8_t b_resp[MAX_RESP_SIZE];
|
|
|
|
int ret = 0;
|
|
int n;
|
|
|
|
n = conn->read(conn, buf, sizeof(ds_msg_head_t));
|
|
if (n < 0)
|
|
return -3;
|
|
|
|
if (n == 0)
|
|
return -1;
|
|
|
|
if (n != sizeof(ds_msg_head_t)) {
|
|
ds_err("invalid msg, ignore. n[%d]", n);
|
|
return -1;
|
|
}
|
|
|
|
ds_msg_head_t *h = (ds_msg_head_t *)buf;
|
|
|
|
char s[64];
|
|
d2s(s, sizeof(s), (uint8_t *)&h->magic, 4);
|
|
|
|
ds_inf("sess[%p] fd[%d]: recv(%d) msg[m:%s t:%d, l:%d]",
|
|
conn, conn->fd, n, s, h->type, h->size);
|
|
|
|
n = conn->read(conn, h->body, h->size);
|
|
if (n < 0)
|
|
return -3;
|
|
|
|
if (n != h->size) {
|
|
ds_err("invalid msg, ignore");
|
|
return -1;
|
|
}
|
|
|
|
switch (h->type) {
|
|
|
|
case DS_T_CNTL:
|
|
ret = process_control_msg(conn, h->body, h->size, b_resp, sizeof(b_resp));
|
|
if (ret) {
|
|
ds_msg_head_t h_resp = {
|
|
.magic = DS_MAGIC,
|
|
.type = DS_T_RESP,
|
|
.size = ret,
|
|
};
|
|
ret = conn->write(conn, &h_resp, sizeof(h_resp));
|
|
if (ret < 0)
|
|
return -3;
|
|
ret = conn->write(conn, b_resp, h_resp.size);
|
|
if (ret < 0)
|
|
return -3;
|
|
} else {
|
|
ds_err("[ERROR] failed to process control msg");
|
|
|
|
strcpy((char *)b_resp, "ko");
|
|
ds_msg_head_t h_resp = {
|
|
.magic = DS_MAGIC,
|
|
.type = DS_T_RESP,
|
|
.size = 3,
|
|
};
|
|
ret = conn->write(conn, &h_resp, sizeof(h_resp));
|
|
if (ret < 0)
|
|
return -3;
|
|
ret = conn->write(conn, b_resp, h_resp.size);
|
|
if (ret < 0)
|
|
return -3;
|
|
}
|
|
break;
|
|
|
|
case DS_T_RESP:
|
|
ret = process_response_msg(conn, h->body, h->size);
|
|
break;
|
|
|
|
case DS_T_EVNT:
|
|
ret = process_event_msg(conn, h->body, h->size);
|
|
break;
|
|
|
|
case DS_T_DATA:
|
|
ret = process_data_msg(conn, h->body, h->size);
|
|
break;
|
|
|
|
case 0x80:/*request disconnect*/
|
|
ds_inf("data in break due to exit requested");
|
|
return -3;
|
|
|
|
default:
|
|
ds_err("unknown msg type[%d]", h->type);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*ret:
|
|
* -1: next
|
|
* -3: error
|
|
*/
|
|
int ds_connection_manage_data_out(ds_connection_t *conn)
|
|
{
|
|
#define DS_CONN_BUF_MAX_SIZE (1024 * 5 + 128)
|
|
|
|
int flag = ds_rb_get_flag_timeout(&conn->rb, 10/*timeout:10ms*/);
|
|
|
|
if (flag & DS_RB_FLAG_EXIT) {
|
|
ds_inf("data out break due to exit requested");
|
|
return 0;
|
|
}
|
|
|
|
if (!(flag & DS_RB_FLAG_READY))
|
|
return -1;
|
|
|
|
if (!(flag & DS_RB_FLAG_OVERFLOW)) {
|
|
size_t size = 0;
|
|
|
|
if (flag & DS_RB_FLAG_BLOCK) {/*block mode*/
|
|
size_t bs = 0;
|
|
int ret = ds_rb_dequeue_block(&conn->rb, &bs);
|
|
if (ret == 0 && bs > 0) {
|
|
ssize_t avai = ds_rb_avail(&conn->rb);
|
|
if (avai < size) {
|
|
ds_err("avai(%zd) < bs(%zu), something incorrect",
|
|
avai, size);
|
|
return -3;
|
|
}
|
|
size = bs;
|
|
|
|
if (size > DS_CONN_BUF_MAX_SIZE) {
|
|
ds_err("DS_CONN_BUF_MAX_SIZE(%d) is not suitable for block mode, meet(%zd)",
|
|
DS_CONN_BUF_MAX_SIZE, size);
|
|
return -3;
|
|
}
|
|
}
|
|
|
|
} else {//stream mode
|
|
size = ds_rb_avail(&conn->rb);
|
|
if (size > DS_CONN_BUF_MAX_SIZE)
|
|
size = DS_CONN_BUF_MAX_SIZE;
|
|
}
|
|
|
|
if (size) {
|
|
|
|
if (!conn->buf) {
|
|
conn->buf = (uint8_t *)malloc(DS_CONN_BUF_MAX_SIZE);
|
|
|
|
if (!conn->buf) {
|
|
ds_err("memory fail");
|
|
return -3;
|
|
}
|
|
}
|
|
|
|
ds_rb_read(&conn->rb, conn->buf, size);
|
|
|
|
ds_msg_head_t h_data = {
|
|
.magic = DS_MAGIC,
|
|
.type = DS_T_DATA,
|
|
.size = size,
|
|
};
|
|
int ret = conn->write(conn, &h_data, sizeof(h_data));
|
|
if (ret < 0)
|
|
return -3;
|
|
ret = conn->write(conn, conn->buf, size);
|
|
if (ret < 0)
|
|
return -3;
|
|
|
|
conn->data_cnt_out += size;
|
|
}
|
|
|
|
} else {
|
|
|
|
char s_overflow[] = "rb_overflow";
|
|
|
|
ds_msg_head_t h_evnt = {
|
|
.magic = DS_MAGIC,
|
|
.type = DS_T_EVNT,
|
|
.size = sizeof(s_overflow),
|
|
};
|
|
int ret = conn->write(conn, &h_evnt, sizeof(h_evnt));
|
|
if (ret < 0)
|
|
return -3;
|
|
ret = conn->write(conn, s_overflow, h_evnt.size);
|
|
if (ret < 0)
|
|
return -3;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void _ds_conn_lock(void *g, int lock)
|
|
{
|
|
ds_connection_t *conn = (ds_connection_t *)g;
|
|
if (lock)
|
|
pthread_mutex_lock(&conn->lock);
|
|
else
|
|
pthread_mutex_unlock(&conn->lock);
|
|
}
|
|
|
|
ds_connection_t* ds_connection_create(void)
|
|
{
|
|
ds_connection_t *conn =
|
|
(ds_connection_t *)calloc(1, sizeof(ds_connection_t));
|
|
|
|
if (conn) {
|
|
|
|
INIT_LIST_HEAD(&conn->controls);
|
|
|
|
pthread_mutex_init(&conn->lock, NULL);
|
|
|
|
ds_rb_init_lock(&conn->rb, _ds_conn_lock, conn);
|
|
|
|
return conn;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int ds_connection_start(ds_server_t *server, ds_connection_t *conn, void *priv)
|
|
{
|
|
int ret = 0;
|
|
|
|
conn->server = server;
|
|
|
|
if (conn->init)
|
|
ret = conn->init(conn, priv);
|
|
|
|
if (ret != 0)
|
|
return -1;
|
|
|
|
if (conn->start) {
|
|
conn->active = 1;
|
|
conn->wr_active = 1;
|
|
conn->rd_active = 1;
|
|
ret = conn->start(conn);
|
|
}
|
|
|
|
if (ret == 0) {
|
|
list_add_tail(&conn->head, &server->conns);
|
|
|
|
} else {
|
|
conn->active = 0;
|
|
conn->wr_active = 0;
|
|
conn->rd_active = 0;
|
|
|
|
if (conn->deinit)
|
|
conn->deinit(conn);
|
|
|
|
free(conn);
|
|
|
|
ds_err("connection fd[%d], failed to start session due to thread failure, err(%d)",
|
|
server->fd, ret);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ds_connection_stop(ds_connection_t *conn)
|
|
{
|
|
int ret = 0;
|
|
|
|
list_del(&conn->head);
|
|
|
|
if (conn->stop)
|
|
conn->stop(conn);
|
|
|
|
if (conn->dbg_free)
|
|
conn->dbg_free(conn);
|
|
|
|
if (conn->deinit)
|
|
conn->deinit(conn);
|
|
|
|
free(conn);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*cleanup in the end of conn session task*/
|
|
int ds_connection_cleanup(ds_connection_t *conn)
|
|
{
|
|
ds_inf("connection [%p] cleanup", conn);
|
|
|
|
conn->active = 0;
|
|
|
|
ds_reader_stop(conn->device, &ds_data_fn, conn);
|
|
|
|
pthread_mutex_lock(&conn->lock);
|
|
if (conn->buf) {
|
|
free(conn->buf);
|
|
conn->buf = 0;
|
|
}
|
|
pthread_mutex_unlock(&conn->lock);
|
|
|
|
ds_rb_deinit(&conn->rb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int ds_server_start(ds_server_t *server, void *arg1, void *arg2, void*(*task)(void*))
|
|
{
|
|
int ret = 0;
|
|
|
|
/*init the server inst*/
|
|
INIT_LIST_HEAD(&server->conns);
|
|
|
|
if (server->init)
|
|
ret = server->init(server, arg1, arg2);
|
|
|
|
if (ret != 0)
|
|
return -1;
|
|
|
|
server->running = 1;
|
|
ret = pthread_create(&server->thread, NULL, task, server);
|
|
if (ret != 0) {
|
|
server->running = 0;
|
|
ds_err("failed to start server due to thread failure. err(%d)", ret);
|
|
|
|
if (server->deinit)
|
|
server->deinit(server);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ds_server_stop(ds_server_t *server)
|
|
{
|
|
server->running = 0;
|
|
|
|
if (server->stop)
|
|
server->stop(server);
|
|
|
|
ds_inf("server stopping...");
|
|
|
|
pthread_join(server->thread, NULL);
|
|
|
|
if (server->deinit)
|
|
server->deinit(server);
|
|
|
|
ds_inf("server stopped.");
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ds_server_cleanup_connections(ds_server_t *server, int force)
|
|
{
|
|
ds_connection_t *conn, *conn_tmp;
|
|
list_for_each_entry_safe(conn, conn_tmp, &server->conns, head) {
|
|
|
|
if (!force && conn->active)
|
|
continue;
|
|
|
|
ds_connection_stop(conn);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|