/**\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(); }