static void WINAPI internet_status_callback(HINTERNET internet, DWORD_PTR context, DWORD internet_status, LPVOID status_info, DWORD status_info_len) { Protocol *protocol = (Protocol*)context; switch(internet_status) { case INTERNET_STATUS_RESOLVING_NAME: TRACE("%p INTERNET_STATUS_RESOLVING_NAME\n", protocol); report_progress(protocol, BINDSTATUS_FINDINGRESOURCE, (LPWSTR)status_info); break; case INTERNET_STATUS_CONNECTING_TO_SERVER: TRACE("%p INTERNET_STATUS_CONNECTING_TO_SERVER\n", protocol); report_progress(protocol, BINDSTATUS_CONNECTING, (LPWSTR)status_info); break; case INTERNET_STATUS_SENDING_REQUEST: TRACE("%p INTERNET_STATUS_SENDING_REQUEST\n", protocol); report_progress(protocol, BINDSTATUS_SENDINGREQUEST, (LPWSTR)status_info); break; case INTERNET_STATUS_REDIRECT: TRACE("%p INTERNET_STATUS_REDIRECT\n", protocol); report_progress(protocol, BINDSTATUS_REDIRECTING, (LPWSTR)status_info); break; case INTERNET_STATUS_REQUEST_COMPLETE: request_complete(protocol, status_info); break; case INTERNET_STATUS_HANDLE_CREATED: TRACE("%p INTERNET_STATUS_HANDLE_CREATED\n", protocol); IInternetProtocol_AddRef(protocol->protocol); break; case INTERNET_STATUS_HANDLE_CLOSING: TRACE("%p INTERNET_STATUS_HANDLE_CLOSING\n", protocol); if(*(HINTERNET *)status_info == protocol->request) { protocol->request = NULL; if(protocol->protocol_sink) { IInternetProtocolSink_Release(protocol->protocol_sink); protocol->protocol_sink = NULL; } if(protocol->bind_info.cbSize) { ReleaseBindInfo(&protocol->bind_info); memset(&protocol->bind_info, 0, sizeof(protocol->bind_info)); } }else if(*(HINTERNET *)status_info == protocol->connection) { protocol->connection = NULL; } IInternetProtocol_Release(protocol->protocol); break; default: WARN("Unhandled Internet status callback %d\n", internet_status); } }
static void request_complete_list(struct usba_ep *ep, struct list_head *list, int status) { struct usba_request *req, *tmp_req; list_for_each_entry_safe(req, tmp_req, list, queue) { list_del_init(&req->queue); request_complete(ep, req, status); }
static void on_read(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { if (nread < 0) { if (buf->base) free(buf->base); /* FIXME uv_shutdown_t* shutdown_req = (uv_shutdown_t*) malloc(sizeof(uv_shutdown_t)); if (shutdown_req == NULL) { fprintf(stderr, "Allocate error\n"); uv_close((uv_handle_t*) stream, on_close); return; } uv_shutdown(shutdown_req, stream, on_shutdown); */ uv_close((uv_handle_t*) stream, on_close); return; } if (nread == 0) { free(buf->base); return; } http_request* request = calloc(1, sizeof(http_request)); if (request == NULL) { free(buf->base); fprintf(stderr, "Allocate error: %s\n", strerror(errno)); uv_close((uv_handle_t*) stream, on_close); return; } stream->data = request; request->handle = (uv_handle_t*) stream; request->num_headers = sizeof(request->headers) / sizeof(request->headers[0]); int nparsed = phr_parse_request( buf->base, buf->len, &request->method, &request->method_len, &request->path, &request->path_len, &request->minor_version, request->headers, &request->num_headers, 0); if (nparsed < 0) { free(request); free(buf->base); fprintf(stderr, "Invalid request\n"); uv_close((uv_handle_t*) stream, on_close); return; } /* int cl = content_length(request); if (cl >= 0 && cl < buf->len - nparsed) { free(request); free(buf->base); return; } */ /* TODO: handle reading whole payload */ request->payload = buf->base + nparsed; request->payload_len = buf->len - nparsed; request_complete(request); free(buf->base); }
static void data_in_do_read(nxe_ostream* os, nxe_istream* is) { nxd_http_client_proto* hcp=(nxd_http_client_proto*)((char*)os-offsetof(nxd_http_client_proto, data_in)); nxe_loop* loop=os->super.loop; if (hcp->state==HCP_WAITING_FOR_RESPONSE) { nxe_unset_timer(loop, NXWEB_TIMER_READ, &hcp->timer_read); nxe_unset_timer(loop, NXWEB_TIMER_100CONTINUE, &hcp->timer_100_continue); nxe_set_timer(loop, NXWEB_TIMER_READ, &hcp->timer_read); nxb_make_room(hcp->nxb, NXWEB_MAX_REQUEST_HEADERS_SIZE); hcp->state=HCP_RECEIVING_HEADERS; } if (hcp->state==HCP_RECEIVING_HEADERS) { int size; nxe_flags_t flags=0; void* ptr=nxb_get_room(hcp->nxb, &size); int bytes_received=ISTREAM_CLASS(is)->read(is, os, ptr, size, &flags); if (bytes_received) { nxb_blank_fast(hcp->nxb, bytes_received); int read_buf_size; char* read_buf=nxb_get_unfinished(hcp->nxb, &read_buf_size); char* end_of_headers; char* start_of_body; if ((end_of_headers=_nxweb_find_end_of_http_headers(read_buf, read_buf_size, &start_of_body))) { nxb_finish_stream(hcp->nxb, 0); memset(&hcp->resp, 0, sizeof(hcp->resp)); hcp->resp.nxb=hcp->nxb; hcp->resp.cdstate.monitor_only=hcp->chunked_do_not_decode; if (_nxweb_parse_http_response(&hcp->resp, read_buf, end_of_headers)) { // bad response nxe_unset_timer(loop, NXWEB_TIMER_READ, &hcp->timer_read); nxe_ostream_unset_ready(os); nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_BAD_RESPONSE); return; } if (hcp->receiving_100_continue) { hcp->receiving_100_continue=0; if (hcp->resp.status_code==100) { // back to sending request body nxe_ostream_unset_ready(&hcp->data_in); nxe_unset_timer(loop, NXWEB_TIMER_READ, &hcp->timer_read); nxe_set_timer(loop, NXWEB_TIMER_WRITE, &hcp->timer_write); nxe_istream_set_ready(loop, &hcp->data_out); hcp->state=HCP_SENDING_BODY; return; } else { nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_NO_100CONTINUE); } } char* read_buf_end=read_buf+read_buf_size; if (start_of_body<read_buf_end) { hcp->first_body_chunk=start_of_body; hcp->first_body_chunk_end=read_buf_end; nxe_size_t first_body_chunk_size=hcp->first_body_chunk_end-hcp->first_body_chunk; if (hcp->resp.chunked_encoding) { int r=_nxweb_decode_chunked_stream(&hcp->resp.cdstate, hcp->first_body_chunk, &first_body_chunk_size); hcp->first_body_chunk_end=hcp->first_body_chunk+first_body_chunk_size; if (r<0) nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_RESPONSE_CHUNKED_ENCODING_ERROR); else if (r>0) hcp->response_body_complete=1; } else if (first_body_chunk_size >= hcp->resp.content_length && hcp->resp.content_length>=0) { hcp->response_body_complete=1; } } else { hcp->first_body_chunk=0; hcp->first_body_chunk_end=0; } nxe_ostream_unset_ready(os); nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_RESPONSE_RECEIVED); if (hcp->resp.content_length && !hcp->req->head_method) { // is body expected? hcp->state=HCP_RECEIVING_BODY; nxe_istream_set_ready(loop, &hcp->resp_body_out); if (hcp->resp_body_out.pair) { nxe_ostream_set_ready(loop, os); } } else { // rearm connection request_complete(hcp, loop); } } else { if (read_buf_size>=NXWEB_MAX_REQUEST_HEADERS_SIZE) { // bad response (headers too large) nxe_unset_timer(loop, NXWEB_TIMER_READ, &hcp->timer_read); nxe_ostream_unset_ready(os); nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_BAD_RESPONSE); return; } } } } else if (hcp->state==HCP_RECEIVING_BODY) { nxe_ostream* next_os=hcp->resp_body_out.pair; if (next_os) { if (next_os->ready) OSTREAM_CLASS(next_os)->do_read(next_os, &hcp->resp_body_out); if (!next_os->ready) { nxe_ostream_unset_ready(os); nxe_istream_set_ready(loop, &hcp->resp_body_out); // get notified when next_os becomes ready again } } else { nxweb_log_error("no connected device for hcp->resp_body_out"); nxe_ostream_unset_ready(os); } } }
static nxe_size_t resp_body_out_read(nxe_istream* is, nxe_ostream* os, void* ptr, nxe_size_t size, nxe_flags_t* flags) { nxd_http_client_proto* hcp=(nxd_http_client_proto*)((char*)is-offsetof(nxd_http_client_proto, resp_body_out)); nxe_loop* loop=is->super.loop; if (hcp->request_complete) { nxweb_log_error("hcp->request_complete - resp_body_out_read() should not be called"); *flags|=NXEF_EOF; nxe_istream_unset_ready(is); return 0; } if (hcp->state!=HCP_RECEIVING_BODY) { nxe_istream_unset_ready(is); nxe_ostream_set_ready(loop, &hcp->data_in); // get notified when prev_is ready return 0; } nxe_size_t bytes_received=0; if (hcp->first_body_chunk) { nxe_size_t first_body_chunk_size=hcp->first_body_chunk_end-hcp->first_body_chunk; if (first_body_chunk_size<=size) { bytes_received=first_body_chunk_size; memcpy(ptr, hcp->first_body_chunk, bytes_received); hcp->first_body_chunk=0; hcp->first_body_chunk_end=0; } else { bytes_received=size; memcpy(ptr, hcp->first_body_chunk, size); hcp->first_body_chunk+=size; } hcp->resp.content_received+=bytes_received; if (hcp->response_body_complete) { // rearm connection request_complete(hcp, loop); nxe_istream_unset_ready(is); *flags|=NXEF_EOF; return bytes_received; } ptr+=bytes_received; size-=bytes_received; } if (size>0) { nxe_istream* prev_is=hcp->data_in.pair; if (prev_is) { nxe_size_t bytes_received2=0; nxe_flags_t rflags=0; if (prev_is->ready) bytes_received2=ISTREAM_CLASS(prev_is)->read(prev_is, &hcp->data_in, ptr, size, &rflags); if (!prev_is->ready) { nxe_istream_unset_ready(is); nxe_ostream_set_ready(loop, &hcp->data_in); // get notified when prev_is becomes ready again } if (hcp->resp.chunked_encoding) { int r=_nxweb_decode_chunked_stream(&hcp->resp.cdstate, ptr, &bytes_received2); hcp->resp.content_received+=bytes_received2; bytes_received+=bytes_received2; if (r<0) nxe_publish(&hcp->events_pub, (nxe_data)NXD_HCP_RESPONSE_CHUNKED_ENCODING_ERROR); else if (r>0) hcp->response_body_complete=1; } else { hcp->resp.content_received+=bytes_received2; bytes_received+=bytes_received2; if (hcp->resp.content_received >= hcp->resp.content_length && hcp->resp.content_length>=0) { hcp->response_body_complete=1; } } if (hcp->response_body_complete) { // rearm connection request_complete(hcp, loop); nxe_istream_unset_ready(is); *flags|=NXEF_EOF; return bytes_received; } } else { if (!prev_is) nxweb_log_error("no connected device for hcp->data_in"); nxe_istream_unset_ready(is); } } return bytes_received; }
static bool can_read_data(struct io *io, void *user_data) { struct mgmt *mgmt = user_data; struct mgmt_hdr *hdr; struct mgmt_ev_cmd_complete *cc; struct mgmt_ev_cmd_status *cs; ssize_t bytes_read; uint16_t opcode, event, index, length; bytes_read = read(mgmt->fd, mgmt->buf, mgmt->len); if (bytes_read < 0) return false; util_hexdump('>', mgmt->buf, bytes_read, mgmt->debug_callback, mgmt->debug_data); if (bytes_read < MGMT_HDR_SIZE) return true; hdr = mgmt->buf; event = btohs(hdr->opcode); index = btohs(hdr->index); length = btohs(hdr->len); if (bytes_read < length + MGMT_HDR_SIZE) return true; switch (event) { case MGMT_EV_CMD_COMPLETE: cc = mgmt->buf + MGMT_HDR_SIZE; opcode = btohs(cc->opcode); util_debug(mgmt->debug_callback, mgmt->debug_data, "[0x%04x] command 0x%04x complete: 0x%02x", index, opcode, cc->status); request_complete(mgmt, cc->status, opcode, index, length - 3, mgmt->buf + MGMT_HDR_SIZE + 3); break; case MGMT_EV_CMD_STATUS: cs = mgmt->buf + MGMT_HDR_SIZE; opcode = btohs(cs->opcode); util_debug(mgmt->debug_callback, mgmt->debug_data, "[0x%04x] command 0x%02x status: 0x%02x", index, opcode, cs->status); request_complete(mgmt, cs->status, opcode, index, 0, NULL); break; default: util_debug(mgmt->debug_callback, mgmt->debug_data, "[0x%04x] event 0x%04x", index, event); process_notify(mgmt, event, index, length, mgmt->buf + MGMT_HDR_SIZE); break; } if (mgmt->destroyed) return false; return true; }
static gboolean received_data(GIOChannel *channel, GIOCondition cond, gpointer user_data) { struct mgmt *mgmt = user_data; struct mgmt_hdr *hdr; struct mgmt_ev_cmd_complete *cc; struct mgmt_ev_cmd_status *cs; ssize_t bytes_read; uint16_t opcode, event, index, length; if (cond & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) return FALSE; bytes_read = read(mgmt->fd, mgmt->buf, mgmt->len); if (bytes_read < 0) return TRUE; util_hexdump('>', mgmt->buf, bytes_read, mgmt->debug_callback, mgmt->debug_data); if (bytes_read < MGMT_HDR_SIZE) return TRUE; hdr = mgmt->buf; event = btohs(hdr->opcode); index = btohs(hdr->index); length = btohs(hdr->len); if (bytes_read < length + MGMT_HDR_SIZE) return TRUE; switch (event) { case MGMT_EV_CMD_COMPLETE: cc = mgmt->buf + MGMT_HDR_SIZE; opcode = btohs(cc->opcode); util_debug(mgmt->debug_callback, mgmt->debug_data, "[0x%04x] command 0x%04x complete: 0x%02x", index, opcode, cc->status); request_complete(mgmt, cc->status, opcode, index, length - 3, mgmt->buf + MGMT_HDR_SIZE + 3); break; case MGMT_EV_CMD_STATUS: cs = mgmt->buf + MGMT_HDR_SIZE; opcode = btohs(cs->opcode); util_debug(mgmt->debug_callback, mgmt->debug_data, "[0x%04x] command 0x%02x status: 0x%02x", index, opcode, cs->status); request_complete(mgmt, cs->status, opcode, index, 0, NULL); break; default: util_debug(mgmt->debug_callback, mgmt->debug_data, "[0x%04x] event 0x%04x", index, event); process_notify(mgmt, event, index, length, mgmt->buf + MGMT_HDR_SIZE); break; } if (mgmt->destroyed) return FALSE; return TRUE; }
static void do_profiler_stats(const struct b2r2_blt_request * const req, const struct b2r2_blt_profiling_info * const info) { s32 blt_px; s32 blt_time; s32 blt_mpix_per_second; if (time_before(jiffies, profiler_stats.sampling_start_time_jiffies)) { /* Flush cached entries */ clear_profiling_info(cache, BLIT_CACHE_SIZE, req); return; } /* Save fastest and slowest blit */ blt_px = info->pixels; blt_time = nsec_2_usec((s32)(info->nsec_active_in_cpu + info->nsec_active_in_b2r2)); blt_mpix_per_second = get_mpix_per_second(blt_px, blt_time); if (blt_mpix_per_second <= profiler_stats.min_mpix_per_second) { profiler_stats.min_mpix_per_second = blt_mpix_per_second; memcpy(&profiler_stats.min_blt_request, &req->user_req, sizeof(profiler_stats.min_blt_request)); memcpy(&profiler_stats.min_blt_profiling_info, info, sizeof(struct b2r2_blt_profiling_info)); } if (blt_mpix_per_second >= profiler_stats.max_mpix_per_second) { profiler_stats.max_mpix_per_second = blt_mpix_per_second; memcpy(&profiler_stats.max_blt_request, &req->user_req, sizeof(profiler_stats.max_blt_request)); memcpy(&profiler_stats.max_blt_profiling_info, info, sizeof(struct b2r2_blt_profiling_info)); } profiler_stats.num_pixels[info->core_id] += blt_px; profiler_stats.num_usecs[info->core_id] += blt_time; /* Save stats to cache */ if (!request_complete(cache, BLIT_CACHE_SIZE, req, info)) { save_profiling_info(cache, BLIT_CACHE_SIZE, info); return; } /* Calculate the stats for the entire blit job */ blt_px = get_accumulated_pixels(cache, BLIT_CACHE_SIZE, req, info); blt_time = get_accumulated_usecs(cache, BLIT_CACHE_SIZE, req, info); /* Flush cached entries */ clear_profiling_info(cache, BLIT_CACHE_SIZE, req); /* Accumulate stats */ profiler_stats.accumulated_num_pixels += blt_px; profiler_stats.accumulated_num_usecs += blt_time; profiler_stats.num_blts_done++; /* Print stats when we reach the configured number of blits to use */ if (profiler_stats.num_blts_done >= profiler_stats_blts_used) { print_profiler_stats(); reset_profiler_stats(); /* * The printouts initiated above can disturb the next * measurement so we delay it two seconds to give the * printouts a chance to finish. */ profiler_stats.sampling_start_time_jiffies = jiffies + (2 * HZ); } }