/**\brief 通过本地socket接收响应字符串
* \param fd socket
* \param[out] buf 缓冲区
* \param len 缓冲区大小
* \return
* - AM_SUCCESS 成功
* - 其他值 错误代码
*/
AM_ErrorCode_t AM_LocalGetResp(int fd, char *buf, int len)
{
AM_ErrorCode_t ret;
int bytes;
assert(buf);
ret = try_read(fd, (char*)&bytes, sizeof(int));
if(ret!=AM_SUCCESS)
{
AM_DEBUG(1, "read local socket failed");
return ret;
}
if(len<bytes)
{
AM_DEBUG(1, "respond buffer is too small");
return AM_FAILURE;
}
ret = try_read(fd, buf, bytes);
if(ret!=AM_SUCCESS)
{
AM_DEBUG(1, "read local socket failed");
return ret;
}
return AM_SUCCESS;
}
static void receive(int fd, const char* fd_path)
{
unsigned char c;
while ( true )
{
if ( !try_read(fd, fd_path, &c) )
return;
if ( c != 0xF7 )
continue;
if ( !try_read(fd, fd_path, &c) )
return;
if ( c == 0xFF )
break;
}
while ( true )
{
if ( !try_read(fd, fd_path, &c) )
return;
if ( c == 0xF7 )
{
if ( !try_read(fd, fd_path, &c) )
return;
if ( c == 0xFE )
break;
if ( c == 0xFD )
try_write(1, "stdout", 0xF7);
continue;
}
try_write(1, "stdout", c);
}
}
int bcrypt_gensalt(int factor, char salt[BCRYPT_HASHSIZE])
{
int fd;
char input[RANDBYTES];
int workf;
char *aux;
fd = open("/dev/urandom", O_RDONLY);
if (fd == -1)
return 1;
if (try_read(fd, input, RANDBYTES) != 0) {
if (try_close(fd) != 0)
return 4;
return 2;
}
if (try_close(fd) != 0)
return 3;
/* Generate salt. */
workf = (factor < 4 || factor > 31)?12:factor;
aux = crypt_gensalt_rn("$2a$", workf, input, RANDBYTES,
salt, BCRYPT_HASHSIZE);
return (aux == NULL)?5:0;
}
int bcrypt_gensalt(int factor, char salt[BCRYPT_HASHSIZE])
{
char input[RANDBYTES];
int workf;
char *aux;
#ifdef WIN32
BCryptGenRandom(NULL, input, RANDBYTES, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
#else
int fd;
fd = open("/dev/urandom", O_RDONLY);
if (fd == -1)
return 1;
if (try_read(fd, input, RANDBYTES) != 0) {
if (try_close(fd) != 0)
return 4;
return 2;
}
if (try_close(fd) != 0)
return 3;
#endif
/* Generate salt. */
workf = (factor < 4 || factor > 31)?12:factor;
aux = crypt_gensalt_rn("$2a$", workf, input, RANDBYTES,
salt, BCRYPT_HASHSIZE);
return (aux == NULL)?5:0;
}
int init()
{
temperature = try_read();
if (temperature < 0) {
return -1;
}
thread_.start(LOWPRIO);
return 0;
}
bool SocketServer::Stream::process()
{
bool const can_read = select_spec->read_out.find(fildes) != select_spec->read_out.end();
bool const can_write = select_spec->write_out.find(fildes) != select_spec->write_out.end();
try
{
if(can_read)
{
if(can_write)
{
if(swap_order)
{
try_write();
bool const wait = write_state == state_Wait;
try_read();
if(wait && write_state != state_Wait) { swap_order = false; cerr << "RESTORING READ/WRITE ORDER" << endl; }
}
else
{
try_read();
bool const wait = read_state == state_Wait;
try_write();
if(wait && read_state != state_Wait) { swap_order = true; cerr << "REVERSING READ/WRITE ORDER" << endl; }
}
}
else try_read();
}
else if(can_write) try_write();
}
catch(IOException &e)
{
cerr << "I/O error: "<<e.what() << endl;
select_spec->read_in.erase(fildes);
select_spec->write_in.erase(fildes);
return false;
}
bool const close = write_state == state_Closed && read_state == state_Closed;
if(!close && !async_resumption_enabled &&
read_state != state_Ready && write_state != state_Ready)
throw runtime_error("Connection implementation malfunction: Dead-locked");
return !close;
}
//разбор меша
void ParseMesh (Parser::Iterator mesh_iter)
{
static const char* METHOD_NAME = "media::geometry::XmlMeshLibraryLoader::ParseMesh";
//чтение имён: меша, индексного буфера (если есть)
const char *id = get<const char*> (*mesh_iter, "id"),
*name = get<const char*> (*mesh_iter, "name", id),
*ib_id = "";
try_read (*mesh_iter, "index_buffer", ib_id);
//создание меша
Mesh mesh;
mesh.Rename (name);
//поиск вершинных буферов
for (Parser::AttributeIterator vb_iter=make_attribute_iterator (*mesh_iter, "vertex_buffers.#text"); vb_iter; ++vb_iter)
{
VertexBufferMap::iterator iter = vertex_buffers.find (*vb_iter);
if (iter == vertex_buffers.end ())
throw xtl::make_argument_exception (METHOD_NAME, "vertex_buffers[i]", *vb_iter, "Vertex buffer not found");
mesh.Attach (iter->second);
}
//поиск индексного буфера
IndexBuffer* ib = 0;
if (*ib_id)
{
IndexBufferMap::iterator ib_iter = index_buffers.find (ib_id);
if (ib_iter == index_buffers.end ())
throw xtl::make_argument_exception (METHOD_NAME, "index_buffer", ib_id, "Index buffer not found");
ib = &ib_iter->second;
}
if (ib)
mesh.Attach (*ib);
//чтение примитивов
for_each_child (*mesh_iter, "primitives.primitive", xtl::bind (&XmlMeshLibraryLoader::ParsePrimitive, this, _1, xtl::ref (mesh)));
//присоединение меша к модели
library.Attach (id, mesh);
}
//разбор вершинного буфера
void ParseVertexBuffer (Parser::Iterator vb_iter)
{
static const char* METHOD_NAME = "media::geometry::XmlMeshLibraryLoader::ParseVertexBuffer";
//чтение идентификатора буфера
const char* id = get<const char*> (*vb_iter, "id");
//создание вершинного буфера
VertexBuffer vb;
//разбор потока вершинных весов
const char* weights_id = "";
try_read (*vb_iter, "weights", weights_id);
if (*weights_id)
{
VertexWeightStreamMap::iterator weights_iter = vertex_weights.find (weights_id);
if (weights_iter == vertex_weights.end ())
throw xtl::make_argument_exception (METHOD_NAME, "weights", weights_id, "Weights stream not found");
vb.AttachWeights (weights_iter->second);
}
//разбор вершинных потоков
for (Parser::AttributeIterator i=make_attribute_iterator (*vb_iter, "streams.#text"); i; ++i)
{
const char* id = *i;
VertexStreamMap::iterator stream_iter = vertex_streams.find (id);
if (stream_iter == vertex_streams.end ())
throw xtl::make_argument_exception (METHOD_NAME, "streams[i]", id, "Vertex stream not found");
vb.Attach (stream_iter->second);
}
//регистрация вершинного буфера
vertex_buffers.insert_pair (id, vb);
}
static void _sock_dispatch(eventloop_t *loop, event_t *ev) {
(void)loop;
socket_t *sock = container_of(ev, socket_t, ev);
stream.set_mask(sock->istm, 0);
if ((ev->mask & (EVMASK_WRITE | EVMASK_ERROR)) == EVMASK_WRITE) {
if (try_write(sock)) {
ev->mask |= EVMASK_ERROR;
}
}
if ((ev->mask & (EVMASK_READ | EVMASK_ERROR)) == EVMASK_READ) {
if (try_read(sock)) {
ev->mask |= EVMASK_ERROR;
}
}
sock->cb(sock, ev->mask, ev->ud);
}
static void transmit(int fd, const char* fd_path)
{
try_write(fd, fd_path, 0xF7);
try_write(fd, fd_path, 0xFF);
unsigned char c;
while ( try_read(0, "stdin", &c) )
{
if ( c == 0xF7 )
{
try_write(fd, fd_path, 0xF7);
try_write(fd, fd_path, 0xFD);
continue;
}
try_write(fd, fd_path, c);
}
try_write(fd, fd_path, 0xF7);
try_write(fd, fd_path, 0xFE);
}
/*
* parse the first line (by first_line_fn) and headers
* return -1 if the message is too long or non-standard
*/
static int
parse_general_http(struct parser *req, int (*first_line_fn)(struct parser *p))
{
enum parse_state p_state = REQUEST_LINE;
while (1) {
if (req->parse_start >= req->parse_end) {
int ret = try_read(req, (req->recv_buf_end - req->parse_end));
if (ret == 0 || ret == -1) { /* 0 means client closed */
syslog(LOG_INFO, "early close");
return -1;
}
}
char *p = line_end(req);
if (!p) {
syslog(LOG_CRIT, "The headers are too long to handle");
return -1;
}
switch (p_state) {
case REQUEST_LINE:
if (first_line_fn(req) == -1) {
syslog(LOG_CRIT, "The 1st line is bad");
return -1;
}
p_state = HEADER_LINES;
break;
case HEADER_LINES:
if (p == req->parse_start) { /* meeting 2 CRLF: end of headers */
req->parse_start += 2;
return 0;
}
if (parse_header_line(req) == -1) {
syslog(LOG_CRIT, "The header line is bad");
return -1;
}
break;
}
}
}
bool connection_engine::process_nothrow(int flags) {
if (closed()) return false;
if (flags & WRITE) try_write();
dispatch();
if (flags & READ) try_read();
dispatch();
if (connection_.closed() && !closed()) {
dispatch();
while (can_write()) {
try_write(); // Flush final data.
}
// no transport errors.
close_transport(ctx_);
}
if (closed()) {
pn_transport_unbind(ctx_->transport);
dispatch();
try { io_close(); } catch(const io_error&) {} // Tell the IO to close.
}
return !closed();
}
int server_try_recv(server* s, void* data, unsigned size)
{
return try_read(s->fd, data, size);
}
char *bcrypt_hash(UDF_INIT *initid, UDF_ARGS *args, char *res, unsigned long *len, char *is_null, char *err) {
int ret, fd;
char *aux;
char randb[RANDBYTES];
char pass[PASS_MAXLEN+1];
char salt[BCRYPT_HASHSIZE];
long long workfactor;
/* password */
if (!args->args[0]) {
*is_null = 1;
return 0;
} else {
if ((ret = my_str_to_c_str(pass, sizeof(pass), args->args[0], args->lengths[0])) != 0) {
*is_null = 1;
return 0;
}
}
/* work factor */
if (args->args[1]) {
workfactor = *(long long*) args->args[1];
} else {
workfactor = WORKFACTOR_DEFAULT;
}
if (workfactor < WORKFACTOR_MIN) {
workfactor = WORKFACTOR_MIN;
} else if (workfactor > WORKFACTOR_MAX) {
workfactor = WORKFACTOR_MAX;
}
/* start salt generation */
if ((fd = open("/dev/urandom", O_RDONLY)) < 0) {
*is_null = 1;
return 0;
}
if (try_read(fd, randb, RANDBYTES) != 0) {
try_close(fd);
*is_null = 1;
return 0;
}
if (try_close(fd) != 0) {
*is_null = 1;
return 0;
}
if ((aux = crypt_gensalt_rn("$2b$", workfactor, randb, RANDBYTES, salt, BCRYPT_HASHSIZE)) == NULL) {
*is_null = 1;
return 0;
}
/* end salt generation */
/* compute password hash */
if ((aux = crypt_rn(pass, salt, res, BCRYPT_HASHSIZE)) == NULL) {
*is_null = 1;
return 0;
}
*len = strlen(res);
return res;
}
static void main_loop(HANDLE serial_hdl)
{
HANDLE stdin_hdl;
HANDLE hdls[2];
OVERLAPPED ov = {0};
unsigned char ser_in;
unsigned char std_in;
DWORD rlen;
stdin_hdl = GetStdHandle(STD_INPUT_HANDLE);
if (stdin_hdl == INVALID_HANDLE_VALUE) {
pwinerror("GetStdHandle");
return;
}
FlushConsoleInputBuffer(stdin_hdl);
PurgeComm(serial_hdl,
PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
/* Make incoming packet turn ov.hEvent signaled. */
if (try_read(serial_hdl, &ser_in, sizeof(ser_in), &ov))
goto out;
/* Smaller index has the priority when events occur at the same time. */
hdls[0] = stdin_hdl;
hdls[1] = ov.hEvent;
for (;;) {
int event = WaitForMultipleObjects(ARRAY_SIZE(hdls), hdls,
FALSE, INFINITE);
switch (event) {
case WAIT_OBJECT_0:
if (!is_key_down_event(stdin_hdl, &std_in))
continue;
printf("got data on stdin: %c\n", std_in);
if (std_in == 'q')
goto out;
if (write(serial_hdl, &std_in, sizeof(std_in)))
goto out;
break;
case WAIT_OBJECT_0 + 1:
GetOverlappedResult(serial_hdl, &ov, &rlen, FALSE);
if (rlen > 0)
printf("\t\t\t\tgot data on serial: 0x%02x\n",
ser_in);
else
printf("serial read timeout\n");
/* Next try */
ResetEvent(ov.hEvent);
if (try_read(serial_hdl, &ser_in, sizeof(ser_in), &ov))
goto out;
break;
default:
pwinerror("WaitForMultipleObjects");
goto out;
}
}
out:
CancelIo(serial_hdl);
CloseHandle(ov.hEvent);
CloseHandle(stdin_hdl);
}
void run() {
long time, delta;
int ret, cli_idx, cli;
nfds_t nfds;
if (allocate_mem() < 0) {
free_mem();
return;
}
cli_cnt = 0;
nfds = 2;
fd_all[0].fd = pcap_fd;
fd_all[0].events = POLLIN;
fd_all[1].fd = listenfd;
fd_all[1].events = POLLIN;
for (cli = 0; cli < max_client; ++cli)
avai_no[cli] = max_client - cli - 1;
avai_cnt = max_client;
result.item[max_query - 1].next = -1;
for (ret = max_query - 2; ret >= 0; --ret)
result.item[ret].next = ret + 1;
result.avai = 0;
waiting.item[max_query - 1].next = -1;
for (ret = max_query - 2; ret >= 0; --ret)
waiting.item[ret].next = ret + 1;
waiting.avai = 0;
waiting.head = -1;
for (cli = 0; cli < max_client; ++cli) {
in_buffer[cli].len = 0;
in_buffer[cli].newline = in_buffer[cli].buf;
out_buffer[cli].head = 0;
out_buffer[cli].tail = 0;
out_buffer[cli].tot = 0;
pending[cli].in = -1;
pending[cli].out = -1;
}
fprintf(stderr, "max_client: %d, max_query: %d. Exceeded will be rejected.\n", max_client, max_query);
time = -1;
while (running) {
pop_waiting();
if (time == -1)
delta = 1000;
else
delta = time - gettime();
while (delta >= 0) {
for (cli_idx = 0; cli_idx < cli_cnt; ++cli_idx) {
cli = cli_no[cli_idx];
push_waiting(cli);
if ((fd_cli[cli_idx].events & POLLIN) == 0 && in_buffer[cli].len != GUK_MAX_QUERY_LEN)
fd_cli[cli_idx].events |= POLLIN;
}
if ((ret = poll(fd_all, nfds, delta + 1)) > 0) {
if (fd_all[0].revents == POLLIN)
gk_cm_read_cap();
ret = (fd_all[1].revents == POLLIN); // ret here stand for new connection available
nfds -= 2;
for (cli_idx = 0; cli_idx < cli_cnt; ++cli_idx) {
if (fd_cli[cli_idx].revents & (POLLERR | POLLNVAL | POLLHUP)) {
fprintf(stderr, "Connection closed or broken.");
close_client(cli_idx);
--nfds;
continue;
}
cli = cli_no[cli_idx];
if (fd_cli[cli_idx].revents & POLLOUT) {
do {
pop_result(cli);
} while (try_write(cli));
if (all_written(cli))
fd_cli[cli_idx_of[cli]].events &= ~POLLOUT;
last_act[cli] = gettime();
}
if (fd_cli[cli_idx].revents & POLLIN) {
while (try_read(cli)) {
push_waiting(cli);
}
if (in_buffer[cli].len == GUK_MAX_QUERY_LEN)
fd_cli[cli_idx].events &= ~POLLIN;
last_act[cli] = gettime();
}
else if (ret && is_idle(cli) && gettime() - last_act[cli] >= (GUK_SERV_TIMEOUT * 1000)) {
fprintf(stderr, "Client timeout. ");
close_client(cli_idx);
--nfds;
}
}
/* remove closed clients */
for (cli_idx = 0; cli_cnt > (int)nfds; ) {
while (cli_idx < (int)nfds && fd_cli[cli_idx].fd >= 0)
++cli_idx;
if (cli_idx == (int)nfds) {
cli_cnt = cli_idx;
break;
}
else {
while (fd_cli[--cli_cnt].fd < 0);
memcpy(fd_cli + cli_idx, fd_cli + cli_cnt, sizeof(struct pollfd));
cli_idx_of[(cli_no[cli_idx] = cli_no[cli_cnt])] = cli_idx;
}
}
nfds += 2;
if (ret)
while (cli_cnt < max_client && accept_client() == 0)
++nfds;
}
else if (ret < 0)
perror("poll");
time = gk_cm_conn_next_time();
if (time == -1)
delta = 1000;
else
delta = time - gettime();
}
time = gk_cm_conn_step();
}
gk_cm_finalize();
for (cli_idx = 0; cli_idx < cli_cnt; ++cli_idx) {
cli = cli_no[cli_idx];
do {
pop_result(cli);
} while (try_write(cli));
}
for (cli_idx = 0; cli_idx < cli_cnt; ++cli_idx)
close_client(cli_idx);
free_mem();
}
