int main(int argc, char *argv[])
{
sp_t sp;
int ret;
if (argc == 1 || (argc > 1 && !strcmp(argv[1], "-?")))
{
fprintf(stderr, "%s", Sump_usage);
fprintf(stderr, "\nSUMP Pump version %s\n", sp_get_version());
return (1);
}
ret = sp_start(&sp, NULL,
"-utf_8 "
"-in_file=<stdin> "
"-in_buf_size=1m "
"-out_file[0]=<stdout> "
#if defined(SUMP_PIPE_STDERR)
"-outputs=2 "
"-out_file[1]=<stderr> "
"-out_buf_size[1]=4k "
#endif
"%s", sp_argv_to_str(argv + 1, argc - 1));
if (ret != SP_OK)
{
fprintf(stderr, "sump: %s\n", sp_get_error_string(sp, ret));
return (1);
}
if ((ret = sp_wait(sp)) != SP_OK)
{
fprintf(stderr, "sump: %s\n", sp_get_error_string(sp, ret));
return (1);
}
return (0);
}
// return type
int
socket_server_poll(struct socket_server *ss, struct socket_message * result, int * more) {
for (;;) {
if (ss->checkctrl) {
if (has_cmd(ss)) {
int type = ctrl_cmd(ss, result);
if (type != -1)
return type;
else
continue;
} else {
ss->checkctrl = 0;
}
}
if (ss->event_index == ss->event_n) {
ss->event_n = sp_wait(ss->event_fd, ss->ev, MAX_EVENT);
ss->checkctrl = 1;
if (more) {
*more = 0;
}
ss->event_index = 0;
if (ss->event_n <= 0) {
ss->event_n = 0;
return -1;
}
}
struct event *e = &ss->ev[ss->event_index++];
struct socket *s = e->s;
if (s == NULL) {
// dispatch pipe message at beginning
continue;
}
switch (s->type) {
case SOCKET_TYPE_CONNECTING:
return report_connect(ss, s, result);
case SOCKET_TYPE_LISTEN:
if (report_accept(ss, s, result)) {
return SOCKET_ACCEPT;
}
break;
case SOCKET_TYPE_INVALID:
fprintf(stderr, "socket-server: invalid socket\n");
break;
default:
if (e->write) {
int type = send_buffer(ss, s, result);
if (type == -1)
break;
return type;
}
if (e->read) {
int type = forward_message(ss, s, result);
if (type == -1)
break;
return type;
}
break;
}
}
}
static void
eventwait(struct silly_socket *ss)
{
for (;;) {
ss->eventcount = sp_wait(ss->spfd, ss->eventbuff, ss->eventcap);
ss->eventindex = 0;
if (ss->eventcount < 0) {
fprintf(stderr, "[socket] eventwait:%d\n", errno);
continue;
}
break;
}
return ;
}
int main(int argc, char *argv[])
{
sp_t sp;
int ret;
ret = sp_start(&sp, reducefixed,
"-REC_SIZE=14 -GROUP_BY -OUT_FILE[0]=rout.txt %s",
sp_argv_to_str(argv + 1, argc - 1));
if (ret != SP_OK)
{
fprintf(stderr, "sp_start: %s\n", sp_get_error_string(sp, ret));
return (1);
}
if ((ret = sp_wait(sp)) != SP_OK)
{
fprintf(stderr, "sp_wait: %s\n", sp_get_error_string(sp, ret));
return (1);
}
/* Free sump pump resources. Not necessary for an exiting program but
* called here for testing purposes */
sp_free(&sp);
return (0);
}
// return type
// 事件循环主函数
int
socket_server_poll(struct socket_server *ss, struct socket_message * result, int * more) {
for (;;) {
// 如果需要监测指令
if (ss->checkctrl) {
// 如果有指令输入
if (has_cmd(ss)) {
// 读入指令并执行对应逻辑
int type = ctrl_cmd(ss, result);
if (type != -1) {
// 正常执行
clear_closed_event(ss, result, type);
return type;
} else
continue;
} else {
ss->checkctrl = 0;
}
}
if (ss->event_index == ss->event_n) {
// 如果事件循环无可读事件，等待新的事件产生
// 同时打开指令监测标识
ss->event_n = sp_wait(ss->event_fd, ss->ev, MAX_EVENT);
ss->checkctrl = 1;
if (more) {
*more = 0;
}
ss->event_index = 0;
if (ss->event_n <= 0) {
ss->event_n = 0;
return -1;
}
}
// 读取一个事件
struct event *e = &ss->ev[ss->event_index++];
struct socket *s = e->s;
if (s == NULL) {
// dispatch pipe message at beginning
continue;
}
switch (s->type) {
case SOCKET_TYPE_CONNECTING:
// 返回 SOCKET_OPEN，修改socket为CONNECTED类型
return report_connect(ss, s, result);
case SOCKET_TYPE_LISTEN: {
// 返回 SOCKET_ACCEPT，生成被动套接字
int ok = report_accept(ss, s, result);
if (ok > 0) {
return SOCKET_ACCEPT;
} if (ok < 0 ) {
return SOCKET_ERROR;
}
// when ok == 0, retry
break;
}
case SOCKET_TYPE_INVALID:
fprintf(stderr, "socket-server: invalid socket\n");
break;
default:
// 读取数据
if (e->read) {
// 如果事件可读
int type;
// forward_message_tcp/udp 正常返回 SOCKET_DATA
if (s->protocol == PROTOCOL_TCP) {
type = forward_message_tcp(ss, s, result);
} else {
type = forward_message_udp(ss, s, result);
if (type == SOCKET_UDP) {
// try read again
--ss->event_index;
return SOCKET_UDP;
}
}
if (e->write && type != SOCKET_CLOSE && type != SOCKET_ERROR) {
// 如果同时可写，回滚索引关闭可写标识，等待下一次循环进入可写逻辑
// Try to dispatch write message next step if write flag set.
e->read = false;
--ss->event_index;
}
if (type == -1)
break;
return type;
}
// 写入数据
if (e->write) {
// 如果事件可写
// 发送链表缓冲区数据
int type = send_buffer(ss, s, result);
if (type == -1)
break;
return type;
}
break;
}
}
}
int navilink_open_sp_port(struct sp_port* port, NavilinkDevice* device)
{
enum sp_return result = sp_open(port, SP_MODE_READ_WRITE);
if (result != SP_OK) {
CATCH_LIBSERIAL_ERROR(device);
goto error_cleanup_port;
}
struct sp_port_config* config = NULL;
result = sp_new_config(&config);
if (result != SP_OK) {
CATCH_LIBSERIAL_ERROR(device);
goto error_clean_config;
}
// Set the config
sp_set_baudrate(port, 115200);
sp_set_bits(port, 8);
sp_set_parity(port, SP_PARITY_NONE);
sp_set_stopbits(port, 1);
sp_set_flowcontrol(port, SP_FLOWCONTROL_NONE);
sp_set_config(port, config);
// Allocate events buffer
struct sp_event_set* event_set = NULL;
sp_new_event_set(&event_set);
sp_add_port_events(event_set, port, SP_EVENT_TX_READY);
//Wait for the port to be ready
result = sp_wait(event_set, 5000);
if (result != SP_OK) {
CATCH_LIBSERIAL_ERROR(device);
goto error_clean_event_set;
}
device->serial_port = port;
device->event_set = event_set;
//Check that this is a Navilink device
int res = navilink_check_protocol(device);
if (res < 0) {
goto error_clean_event_set;
}
// Retrieve the informations about the device
res = navilink_query_information(device, &device->informations);
if (res < 0) {
goto error_clean_event_set;
}
// Retrieve the firmware version
res = navilink_query_firmware_version(device, &device->firmware_version);
if (res < 0) {
goto error_clean_event_set;
}
return 0;
error_clean_event_set:
sp_free_event_set(event_set);
error_clean_config:
sp_free_config(config);
error_cleanup_port:
sp_free_port(port);
return -1;
}
// return type
int
socket_server_poll(struct socket_server *ss, struct socket_message * result, int * more) {
for (;;) {
if (ss->checkctrl) {
if (has_cmd(ss)) {
int type = ctrl_cmd(ss, result);
if (type != -1) {
clear_closed_event(ss, result, type);
return type;
} else
continue;
} else {
ss->checkctrl = 0;
}
}
if (ss->event_index == ss->event_n) {
ss->event_n = sp_wait(ss->event_fd, ss->ev, MAX_EVENT);
ss->checkctrl = 1;
if (more) {
*more = 0;
}
ss->event_index = 0;
if (ss->event_n <= 0) {
ss->event_n = 0;
return -1;
}
}
struct event *e = &ss->ev[ss->event_index++];
struct socket *s = e->s;
if (s == NULL) {
// dispatch pipe message at beginning
continue;
}
switch (s->type) {
case SOCKET_TYPE_CONNECTING:
return report_connect(ss, s, result);
case SOCKET_TYPE_LISTEN:
if (report_accept(ss, s, result)) {
return SOCKET_ACCEPT;
}
break;
case SOCKET_TYPE_INVALID:
fprintf(stderr, "socket-server: invalid socket\n");
break;
default:
if (e->read) {
int type;
if (s->protocol == PROTOCOL_TCP) {
type = forward_message_tcp(ss, s, result);
} else {
type = forward_message_udp(ss, s, result);
if (type == SOCKET_UDP) {
// try read again
--ss->event_index;
return SOCKET_UDP;
}
}
if (e->write) {
// Try to dispatch write message next step if write flag set.
e->read = false;
--ss->event_index;
}
if (type == -1)
break;
clear_closed_event(ss, result, type);
return type;
}
if (e->write) {
int type = send_buffer(ss, s, result);
if (type == -1)
break;
clear_closed_event(ss, result, type);
return type;
}
break;
}
}
}
