#include <unistd.h>
|
#include <netdb.h>
|
#include <sys/socket.h>
|
#include <netinet/in.h>
|
#include <arpa/inet.h>
|
#include <net/if.h>
|
#include <sys/ioctl.h>
|
#include <signal.h>
|
|
#include "../socket_protocol.h"
|
#include "../thread_pool.h"
|
#include "../log_handle.h"
|
|
#include "server_api.h"
|
#include "server_core.h"
|
#include "capture_image.h"
|
#include "mini_shell.h"
|
#include "isp_handle.h"
|
#include "raw_flow_opt.h"
|
|
|
#define SERVER_THREADS_MAX 20
|
|
enum server_flag_e {
|
SERVER_FLAG_INIT_NOT = 0x00,
|
SERVER_FLAG_INIT_YES = 0x01,
|
SERVER_FLAG_STOP_NOT = 0x02,
|
SERVER_FLAG_STOP_YES = 0x03,
|
};
|
|
static int g_server_init_flag = SERVER_FLAG_INIT_NOT;
|
static int g_server_socket_fd = -1;
|
static int g_server_stop_flag = SERVER_FLAG_STOP_NOT;
|
|
/*
|
*length of question/answer cannot be greater than sock_packet.reserved in bytes
|
* for current, the lenght are both 16, sock_packet.reserved is 16
|
*/
|
#define SERVER_SOCK_QUESTION "wHo Am i? woOOo"
|
#define SERVER_SOCK_ANSWER "WHos yoUR daddY"
|
|
static int client_handle(int sock_fd)
|
{
|
int ret = -1;
|
static sock_packet comm_packet;
|
thread_work_func thread_func_ptr = NULL;
|
|
LOG("%s: starts - %d\n", __FUNCTION__, sock_fd);
|
|
// 1. ack question
|
pack_packet(&comm_packet);
|
comm_packet.cmd_ids[0] = SOCK_CMD_ACK;
|
comm_packet.cmd_ids[1] = SOCK_CMD_ACK_QUESTION;
|
comm_packet.ret = htonl(SOCK_CMD_RET_OK);
|
strcpy((char *)comm_packet.reserved, SERVER_SOCK_QUESTION);
|
|
ret = sock_write_check_packet(__FUNCTION__, sock_fd, &comm_packet, SOCK_CMD_ACK, SOCK_DEFAULT_TIMEOUT);
|
if (ret != SOCK_RW_CHECK_OK) {
|
LOG("%s: failed to write and check\n", __FUNCTION__);
|
close(sock_fd);
|
return -1;
|
}
|
|
if (comm_packet.cmd_ids[1] != SOCK_CMD_ACK_ANSWER ||
|
strncmp((const char *)comm_packet.reserved, SERVER_SOCK_ANSWER, sizeof(comm_packet.reserved))) {
|
((char *)comm_packet.reserved)[sizeof(comm_packet.reserved) - 1] = '\0';
|
LOG("%s: wrong answer: %d, %s\n", __FUNCTION__, comm_packet.cmd_ids[1], (const char *)comm_packet.reserved);
|
close(sock_fd);
|
return -1;
|
}
|
|
switch (comm_packet.cmd_ids[2]) {
|
case SOCK_TYPE_HEART_JUMP:
|
thread_func_ptr = &sock_handle_heart_jump_thread;
|
break;
|
case SOCK_TYPE_PREVIEW:
|
thread_func_ptr = &sock_handle_preview_thread;
|
break;
|
case SOCK_TYPE_CAPTURE:
|
thread_func_ptr = &sock_handle_capture_thread;
|
break;
|
case SOCK_TYPE_TUNING:
|
thread_func_ptr = &sock_handle_tuning_thread;
|
break;
|
case SOCK_TYPE_STATISTICS:
|
thread_func_ptr = &sock_handle_statistics_thread;
|
break;
|
case SOCK_TYPE_SCRIPT:
|
thread_func_ptr = &sock_handle_script_thread;
|
break;
|
case SOCK_TYPE_REGOPT:
|
thread_func_ptr = &sock_handle_register_thread;
|
break;
|
case SOCK_TYPE_AELV:
|
thread_func_ptr = &sock_handle_aelv_thread;
|
break;
|
case SOCK_TYPE_SET_INPUT:
|
thread_func_ptr = &sock_handle_set_input_thread;
|
break;
|
case SOCK_TYPE_RAW_FLOW:
|
thread_func_ptr = &sock_handle_raw_flow_thread;
|
break;
|
case SOCK_TYPE_ISP_VERSION:
|
thread_func_ptr = &sock_handle_isp_version_thread;
|
break;
|
#if 1
|
case SOCK_CMD_EXIT:
|
LOG("%s: recv exit\n", __FUNCTION__);
|
g_server_stop_flag = SERVER_FLAG_STOP_YES;
|
close(sock_fd);
|
return -1;
|
#endif
|
default:
|
LOG("%s: unknown request(%d)\n", __FUNCTION__, comm_packet.cmd_ids[2]);
|
close(sock_fd);
|
return -1;
|
}
|
|
// 3. add work
|
ret = add_work(thread_func_ptr, (void *)(intptr_t)sock_fd);
|
|
// 4. reply
|
//pack_packet(&comm_packet);
|
//comm_packet.cmd_ids[0] = SOCK_CMD_ACK;
|
comm_packet.cmd_ids[1] = SOCK_CMD_ACK_RET;
|
if (ret < 0) {
|
comm_packet.ret = htonl(SOCK_CMD_RET_FAILED);
|
ret = sock_write(sock_fd, (const void *)&comm_packet, sizeof(comm_packet), SOCK_DEFAULT_TIMEOUT);
|
close(sock_fd);
|
LOG("%s: threads out of range\n", __FUNCTION__);
|
return -1;
|
} else {
|
comm_packet.ret = htonl(SOCK_CMD_RET_OK);
|
ret = sock_write(sock_fd, (const void *)&comm_packet, sizeof(comm_packet), SOCK_DEFAULT_TIMEOUT);
|
}
|
|
return 0;
|
}
|
|
static void reset_server_params()
|
{
|
g_server_init_flag = SERVER_FLAG_INIT_NOT;
|
g_server_socket_fd = -1;
|
g_server_stop_flag = SERVER_FLAG_STOP_NOT;
|
}
|
|
/*
|
* get ip address by socket
|
* returns 0 if OK, -1 if something went wrong
|
*/
|
int get_sock_ip(int sock_fd, char *ip_addr)
|
{
|
struct ifconf if_config = { 0 };
|
struct ifreq *if_req = NULL;
|
char buf[512] = { 0 }, *ip0 = NULL;
|
int i = 0, ret = -1;
|
|
if (sock_fd < 0 || !ip_addr) {
|
return -1;
|
}
|
|
if_config.ifc_len = sizeof(buf);
|
if_config.ifc_buf = buf;
|
|
if (ioctl(sock_fd, SIOCGIFCONF, &if_config) < 0) {
|
return -1;
|
}
|
|
if_req = if_config.ifc_req;
|
for (i = if_config.ifc_len / sizeof(struct ifreq); i > 0; i--) {
|
ip0 = inet_ntoa(((struct sockaddr_in *)&(if_req->ifr_addr))->sin_addr);
|
LOG(" ip: %s, name: %s\n", ip0, if_req->ifr_name);
|
if (ret < 0 && strncmp(ip0, "127.0", 4) && !strncmp(if_req->ifr_name, "eth", 3)) {
|
strcpy(ip_addr, ip0);
|
ret = 0;
|
}
|
if_req++;
|
}
|
|
return ret;
|
}
|
|
/*
|
* init server
|
* returns 0 if init success, <0 if something went wrong
|
*/
|
int init_server(int port)
|
{
|
struct sockaddr_in server_socket_addr = { 0 };
|
char ip_addr[64] = { 0 }, *ip = NULL;
|
int ret = -1;
|
|
#ifdef FUNCTION_END_FLAG
|
#undef FUNCTION_END_FLAG
|
#endif
|
#define FUNCTION_END_FLAG _##__FUNCTION__##_END_
|
|
|
if (SERVER_FLAG_INIT_YES == g_server_init_flag) {
|
exit_server();
|
}
|
|
reset_server_params();
|
|
server_socket_addr.sin_family = AF_INET;
|
server_socket_addr.sin_port = htons(port);
|
server_socket_addr.sin_addr.s_addr = htons(INADDR_ANY);
|
|
// creat sever socket
|
ret = socket(AF_INET, SOCK_STREAM, 0);
|
if (-1 == ret) {
|
LOG("%s: failed to create socket(%d, %s)\n", __FUNCTION__, errno, strerror(errno));
|
return -1;
|
}
|
g_server_socket_fd = ret;
|
|
if (get_sock_ip(g_server_socket_fd, ip_addr) == 0) {
|
ip = ip_addr;
|
} else {
|
ip = "unknown host";
|
}
|
|
LOG("%s: ready to start server: %s:%d ++++++++++++++++++++++++\n", __FUNCTION__, ip, port)
|
|
// ignoral pipe error
|
signal(SIGPIPE, SIG_IGN);
|
|
// bind
|
ret = bind(g_server_socket_fd, (struct sockaddr*)&server_socket_addr, sizeof(server_socket_addr));
|
if (-1 == ret) {
|
LOG("%s: failed to bind socket(%d, %s)\n", __FUNCTION__, errno, strerror(errno));
|
goto FUNCTION_END_FLAG;
|
}
|
|
//listen
|
ret = listen(g_server_socket_fd, SERVER_THREADS_MAX);
|
if (-1 == ret) {
|
LOG("%s: failed to listen socket(%d, %s)\n", __FUNCTION__, errno, strerror(errno));
|
goto FUNCTION_END_FLAG;
|
}
|
|
LOG("%s: server starts: %s:%d ++++++++++++++++++++++++\n", __FUNCTION__, ip, port);
|
|
ret = init_thread_pool();
|
if (ret < 0) {
|
LOG("%s: failed to init thread pool\n", __FUNCTION__);
|
goto FUNCTION_END_FLAG;
|
}
|
|
ret = init_capture_module();
|
if (CAP_ERR_NONE != ret) {
|
LOG("%s: failed to init capture module\n", __FUNCTION__);
|
}
|
|
//ret = init_isp_module();
|
//if (ret < 0) {
|
// LOG("%s: failed to init isp module\n", __FUNCTION__);
|
//}
|
|
//ret = select_isp(0);
|
//if (ret < 0) {
|
// LOG("%s: failed to select isp 0\n", __FUNCTION__);
|
//}
|
|
|
/////
|
#if 0
|
msleep(1000);
|
LOG("%s: ready to select isp 0\n", __FUNCTION__);
|
ret = select_isp(0);
|
if (ret < 0) {
|
LOG("%s: failed to select isp 0\n", __FUNCTION__);
|
}
|
LOG("%s: ready to select isp 0, DONE\n", __FUNCTION__);
|
|
#endif
|
|
ret = init_mini_shell(NULL);
|
if (0 != ret) {
|
LOG("%s: failed to init mini shell\n", __FUNCTION__);
|
}
|
|
g_server_init_flag = SERVER_FLAG_INIT_YES;
|
LOG("%s: init done\n", __FUNCTION__);
|
return 0;
|
|
FUNCTION_END_FLAG:
|
close(g_server_socket_fd);
|
g_server_socket_fd = -1;
|
g_server_init_flag = SERVER_FLAG_INIT_NOT;
|
return ret;
|
}
|
|
|
/*
|
* run server
|
* this function will be running until get some exit message from client/server
|
* returns 0 if exit normal, <0 if something went wrong
|
*/
|
int run_server()
|
{
|
int ret = -1;
|
int client_socket = -1;
|
int try_times = 0;
|
struct sockaddr_in client_socket_addr;
|
socklen_t client_socket_addr_len = sizeof(client_socket_addr);
|
|
if (SERVER_FLAG_INIT_YES == g_server_init_flag) {
|
while (1) {
|
if (SERVER_FLAG_STOP_YES == g_server_stop_flag) {
|
LOG("%s: recv stop flag\n", __FUNCTION__);
|
return 0;
|
}
|
ret = CheckThreadsStatus();
|
if (ret & TH_STATUS_SERVER_QUIT) {
|
LOG("%s: recv STOP, ready to stop server(%08x)...\n", __FUNCTION__, ret);
|
try_times = 0;
|
while ((try_times++ < 100) && (ret & 0x00FFFFFF)) {
|
msleep(32);
|
ret = CheckThreadsStatus();
|
}
|
LOG("%s: exits(%d, %08x)\n", __FUNCTION__, try_times, ret);
|
return 0;
|
}
|
|
memset(&client_socket_addr, 0, sizeof(client_socket_addr));
|
client_socket = socket_accept(g_server_socket_fd,
|
(struct sockaddr*)&client_socket_addr, &client_socket_addr_len, SOCK_DEFAULT_TIMEOUT);
|
if (client_socket >= 0) {
|
ret = client_handle(client_socket);
|
} else {
|
if (!SHOULD_TRY_AGAIN()) {
|
LOG("%s: failed to accept(%d, %s)\n", __FUNCTION__, errno, strerror(errno));
|
return -1;
|
} else {
|
errno = 0;
|
}
|
}
|
|
msleep(1);
|
}
|
}
|
|
LOG("%s: not init yet\n", __FUNCTION__);
|
return -1;
|
}
|
|
/*
|
* exit server
|
* clean and exit
|
*/
|
void exit_server()
|
{
|
g_server_stop_flag = SERVER_FLAG_STOP_YES;
|
if (SERVER_FLAG_INIT_YES == g_server_init_flag) {
|
close(g_server_socket_fd);
|
g_server_socket_fd = -1;
|
g_server_init_flag = SERVER_FLAG_INIT_NOT;
|
}
|
|
exit_mini_shell();
|
exit_isp_module();
|
exit_capture_module();
|
exit_thread_pool();
|
|
LOG("%s: exits\n", __FUNCTION__);
|
}
|
|
|
