/**@brief Authorize WRITE request event handler. * * @details Handles WRITE events from the BLE stack. * * @param[in] p_sc_ctrlpt SC Ctrlpt structure. * @param[in] p_gatts_evt GATTS Event received from the BLE stack. * */ static void on_rw_authorize_request(ble_agsensor_t * p_agsensor, ble_gatts_evt_t * p_gatts_evt) { ble_gatts_evt_rw_authorize_request_t * p_auth_req = &p_gatts_evt->params.authorize_request; if (p_auth_req->type == BLE_GATTS_AUTHORIZE_TYPE_WRITE) { if ( (p_gatts_evt->params.authorize_request.request.write.op != BLE_GATTS_OP_PREP_WRITE_REQ) && (p_gatts_evt->params.authorize_request.request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) && (p_gatts_evt->params.authorize_request.request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL) ) { if (p_auth_req->request.write.handle == p_agsensor->configuration_handles.value_handle) { on_write(p_agsensor, &p_auth_req->request.write); } if (p_auth_req->request.write.handle == p_agsensor->data_handles.value_handle) { on_write(p_agsensor, &p_auth_req->request.write); } } } }
/**@brief Authorize WRITE request event handler. * * @details Handles WRITE events from the BLE stack. * * @param[in] p_sc_ctrlpt SC Ctrlpt structure. * @param[in] p_gatts_evt GATTS Event received from the BLE stack. * */ static void on_rw_authorize_request(ble_dfu__nordic__t * p_dfu__nordic_, ble_gatts_evt_t * p_gatts_evt) { ble_gatts_evt_rw_authorize_request_t * p_auth_req = &p_gatts_evt->params.authorize_request; if (p_auth_req->type == BLE_GATTS_AUTHORIZE_TYPE_WRITE) { if ( (p_gatts_evt->params.authorize_request.request.write.op != BLE_GATTS_OP_PREP_WRITE_REQ) && (p_gatts_evt->params.authorize_request.request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) && (p_gatts_evt->params.authorize_request.request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL) ) { if (p_auth_req->request.write.handle == p_dfu__nordic_->dfu_packet_handles.value_handle) { on_write(p_dfu__nordic_, &p_auth_req->request.write); } if (p_auth_req->request.write.handle == p_dfu__nordic_->dfu_control_point_handles.value_handle) { on_write(p_dfu__nordic_, &p_auth_req->request.write); } } } }
void eventLoop( HANDLE hIocp ) { DWORD bytesTransferred = 0; SP_TestClient * client = NULL; SP_TestEvent * event = NULL; BOOL isSuccess = GetQueuedCompletionStatus( hIocp, &bytesTransferred, (DWORD*)&client, (OVERLAPPED**)&event, 100 ); DWORD lastError = WSAGetLastError(); if( ! isSuccess ) { if( NULL != client ) { gStat.mGQCSFail++; close_client( client ); } return; } if( SP_TestEvent::eEventRecv == event->mType ) { on_read( client, event ); return; } if( SP_TestEvent::eEventSend == event->mType ) { on_write( client, event ); return; } }
void nrf_ble_cgms_on_ble_evt(nrf_ble_cgms_t * p_cgms, ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: p_cgms->conn_handle = p_ble_evt->evt.gap_evt.conn_handle; p_cgms->cgms_com_state = STATE_NO_COMM; break; case BLE_GAP_EVT_DISCONNECTED: p_cgms->conn_handle = BLE_CONN_HANDLE_INVALID; break; case BLE_GATTS_EVT_WRITE: on_write(p_cgms, p_ble_evt); break; case BLE_EVT_TX_COMPLETE: on_tx_complete(p_cgms, p_ble_evt); break; case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST: on_rw_authorize_request(p_cgms, &p_ble_evt->evt.gatts_evt); break; case BLE_GATTS_EVT_HVC: on_hvc(p_cgms, p_ble_evt); break; default: // No implementation needed. break; } }
void ble_bas_on_ble_evt(ble_bas_t * p_bas, ble_evt_t * p_ble_evt) { if (p_bas == NULL || p_ble_evt == NULL) { return; } switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_bas, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_bas, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_bas, p_ble_evt); break; default: // No implementation needed. break; } }
void ble_dfu_on_ble_evt(ble_dfu_t * p_dfu, ble_evt_t * p_ble_evt) { VERIFY_PARAM_NOT_NULL_VOID(p_dfu); VERIFY_PARAM_NOT_NULL_VOID(p_ble_evt); switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_dfu, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_dfu, p_ble_evt); break; case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST: on_rw_authorize_req(p_dfu, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_dfu, p_ble_evt); break; default: // no implementation break; } }
void ble_hrs_on_ble_evt(uint16_t * p_peripheral_conn_handle, ble_hrs_t * p_hrs, ble_evt_t * p_ble_evt) { uint16_t peripheral_conn_handle = * p_peripheral_conn_handle; //todo; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: if(p_ble_evt->evt.gap_evt.params.connected.role == BLE_GAP_ROLE_PERIPH) //If this side is BLE_GAP_ROLE_PERIPH then BLE_GAP_EVT_CONNECTED comes from peer central { on_connect(p_hrs, p_ble_evt); } break; case BLE_GAP_EVT_DISCONNECTED: if(p_ble_evt->evt.gap_evt.conn_handle == peripheral_conn_handle) { on_disconnect(p_hrs, p_ble_evt); } break; case BLE_GATTS_EVT_WRITE: on_write(p_hrs, p_ble_evt); break; case BLE_GATTC_EVT_HVX: on_peer_peripheral_hvx(p_hrs, p_ble_evt); default: // No implementation needed. break; } }
void ble_conn_params_on_ble_evt(ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_ble_evt); break; case BLE_GAP_EVT_CONN_PARAM_UPDATE: on_conn_params_update(p_ble_evt); break; default: // No implementation needed. break; } }
int tcp_data_handler::send( packet *p,int delay_flag) { if(m_id.fd < 0 || m_connect_status != STATUS_CONNECTED ) return -1 ; int size = p->encode_size() ; if(size < 1 ) return -1 ; if(m_sbuf.space_size() < size && m_sbuf.resize(m_sbuf.capacity() + size )!=0) { return -1 ; } size = p->encode(m_sbuf.space(),m_sbuf.space_size()) ; if ( size < 1 ) return -1 ; m_sbuf.push_data(size) ; if(m_reactor && (m_write_flag == 0) ) { if(m_reactor->mod_handler(m_id.fd,this, base_reactor::EVENT_READ | base_reactor::EVENT_WRITE)==0 ) { m_write_flag = 1; } } if(delay_flag == 0) on_write(m_id.fd) ; return 0 ; }
void ble_hts_on_ble_evt(ble_hts_t * p_hts, ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_hts, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_hts, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_hts, p_ble_evt); break; case BLE_GATTS_EVT_HVC: on_hvc(p_hts, p_ble_evt); break; default: // No implementation needed. break; } }
void ble_dfu_on_ble_evt(ble_dfu_t * p_dfu, ble_evt_t * p_ble_evt) { if ((p_dfu == NULL) || (p_ble_evt == NULL)) { return; } if (p_dfu->evt_handler != NULL) { switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_dfu, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_dfu, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_dfu, p_ble_evt); break; case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST: on_rw_authorize_req(p_dfu, p_ble_evt); break; default: // No implementation needed. break; } } }
int worker_epoll_start(int epoll_fd, unsigned int max_events, int channel_fd) { int nfds; struct epoll_event events[max_events]; nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, EPOLL_DELAY); if(nfds == -1) { perror("epoll_wait"); return L_HTTP_FAIL; } for(int n = 0; n < nfds; ++n) { if (events[n].data.fd == channel_fd) { //if((epoll_fd, listen_sock) == L_HTTP_FAIL) // continue; if(on_channel(epoll_fd, channel_fd) == L_HTTP_FAIL) continue; } else if(events[n].events & EPOLLIN)//如果是已经连接的用户,并且收到数据,那么进行读入。 { if(on_read(epoll_fd, events[n].data.fd) == L_HTTP_FAIL) { on_close(epoll_fd, events[n].data.fd); continue; } } else if(events[n].events & EPOLLOUT) // 如果有数据发送 { on_write(epoll_fd, events[n].data.fd); on_close(epoll_fd, events[n].data.fd); } } return L_HTTP_SUCCESS; }
void ble_lc_on_ble_event(ble_lc_t * p_lc, ble_evt_t * p_ble_evt) { if ((p_lc == NULL) || (p_ble_evt == NULL)) { return; } switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_lc, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_lc, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_lc, p_ble_evt); break; case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST: on_read(p_lc, p_ble_evt); break; default: // Nothing needed break; } }
void ble_iqo_on_ble_evt(ble_iqo_t * p_iqo, ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_iqo, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_iqo, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_iqo, p_ble_evt); break; case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST: on_rw_authorize_request(p_iqo, p_ble_evt); break; default: // No implementation needed. break; } }
void ble_nus_on_ble_evt(ble_nus_t * p_nus, ble_evt_t * p_ble_evt) { if ((p_nus == NULL) || (p_ble_evt == NULL)) { return; } switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_nus, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_nus, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: // host에서 data를 write 할때 들어옴. on_write(p_nus, p_ble_evt); break; default: // No implementation needed. break; } }
/** * @brief notify incoming io event */ void http_event::on_event() { if (this->get_state() == "read_head") { on_read_head(); } else if (this->get_state() == "read_body") { on_read_body(); } else { on_write(); } }
int app::handle_write(app_connection * n){ n->post_send(); if(!n->get_wait_to_send_data_len()){ return on_write(n); } else{ return 0; } }
void ble_ias_on_ble_evt(ble_ias_t * p_ias, ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) { case BLE_GATTS_EVT_WRITE: on_write(p_ias, p_ble_evt); break; default: break; } }
void ble_ias_on_ble_evt(ble_ias_t * p_ias, ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) { case BLE_GATTS_EVT_WRITE: on_write(p_ias, p_ble_evt); break; default: // No implementation needed. break; } }
/**@brief Function for handling the Application's BLE Stack events. * * @param[in] p_ble_evt Bluetooth stack event. */ static void on_ble_evt(ble_evt_t * p_ble_evt) { uint32_t err_code; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle; break; case BLE_GAP_EVT_DISCONNECTED: m_conn_handle = BLE_CONN_HANDLE_INVALID; application_timers_stop(); // Go to system-off mode err_code = sd_power_system_off(); APP_ERROR_CHECK(err_code); break; case BLE_GATTS_EVT_SYS_ATTR_MISSING: err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, BLE_GATTS_SYS_ATTR_FLAG_SYS_SRVCS | BLE_GATTS_SYS_ATTR_FLAG_USR_SRVCS); APP_ERROR_CHECK(err_code); break; case BLE_GAP_EVT_TIMEOUT: if (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISING) { // Go to system-off mode (this function will not return; wakeup will cause a reset). err_code = sd_power_system_off(); APP_ERROR_CHECK(err_code); } break; case BLE_GATTS_EVT_WRITE: on_write(p_ble_evt); break; default: // No implementation needed. break; } }
/**@brief Authorize WRITE request event handler. * * @details Handles WRITE events from the BLE stack. * * @param[in] p_sc_ctrlpt SC Ctrlpt structure. * @param[in] p_gatts_evt GATTS Event received from the BLE stack. * */ static void on_rw_authorize_request(ble_display_service_t * p_display_service, ble_gatts_evt_t * p_gatts_evt) { ble_gatts_evt_rw_authorize_request_t * p_auth_req = &p_gatts_evt->params.authorize_request; if (p_auth_req->type == BLE_GATTS_AUTHORIZE_TYPE_WRITE) { if ((p_gatts_evt->params.authorize_request.request.write.op != BLE_GATTS_OP_PREP_WRITE_REQ) && (p_gatts_evt->params.authorize_request.request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) && (p_gatts_evt->params.authorize_request.request.write.op != BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL)) { if (p_auth_req->request.write.handle == p_display_service->record_number_handles.value_handle) { on_write(p_display_service, &p_auth_req->request.write); } } } }
/*! * \brief Write to a File handle. * * Example usage: * * \code{.cpp} * size_t n; * * if (file.write(file, buf, sizeof(buf), &bytesWritten) * != FileStatus::OK) { * printf("Failed to write file: %s\n", file.error_string().c_str()); * } * \endcode * * \param[in] buf Buffer to write from * \param[in] size Buffer size * \param[out] bytes_written Output number of bytes that were written. This * parameter cannot be NULL. * * \return * * #FileStatus::OK if some bytes were written * * #FileStatus::RETRY if the same operation should be reattempted * * #FileStatus::UNSUPPORTED if the handle source does not support writing * * \<= #FileStatus::WARN if an error occurs */ FileStatus File::write(const void *buf, size_t size, size_t *bytes_written) { GET_PIMPL_OR_RETURN(FileStatus::FATAL); ENSURE_STATE(FileState::OPENED); auto ret = FileStatus::UNSUPPORTED; if (!bytes_written) { set_error(FileError::PROGRAMMER_ERROR, "%s: bytes_written is NULL", __func__); ret = FileStatus::FATAL; } else { ret = on_write(buf, size, bytes_written); } if (ret <= FileStatus::FATAL) { priv->state = FileState::FATAL; } return ret; }
void ble_bas_on_ble_evt(ble_bas_t * p_bas, ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_bas, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_bas, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_bas, p_ble_evt); break; default: break; } }
/**@brief Function for handling BLE events. * * @param[in] p_dfu__nordic_ DFU (Nordic) Service structure. * @param[in] p_ble_evt Event received from the BLE stack. */ void ble_dfu__nordic__on_ble_evt(ble_dfu__nordic__t * p_dfu__nordic_, ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_dfu__nordic_, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_dfu__nordic_, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_dfu__nordic_, &p_ble_evt->evt.gatts_evt.params.write); break; case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST: on_rw_authorize_request(p_dfu__nordic_, &p_ble_evt->evt.gatts_evt); break; default: //No implementation needed. break; } }
void ble_doorlock_on_ble_evt(ble_evt_t * p_ble_evt) { ble_doorlock_t *p_doorlock = &m_doorlock; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_doorlock, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_doorlock, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_doorlock, p_ble_evt); break; default: // No implementation needed. break; } }
void ble_nus_on_ble_evt(ble_nus_t * p_nus, ble_evt_t * p_ble_evt) { if ((p_nus == NULL) || (p_ble_evt == NULL)) { return; } #if ((DEBUG_UART_EN) && (ENABLE_BLE_DEBUG)) //DbgPrintf("id=%x\r\n",p_ble_evt->header.evt_id); #endif switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_nus, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_nus, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: #if ((DEBUG_UART_EN) && (ENABLE_BLE_DEBUG)) //DbgPrintf("common_evt.conn_handle=%x\r\n,gap_evt.conn_handle=%x\r\n,l2cap_evt.conn_handle=%x\r\n,gattc_evt.conn_handle=%x\r\n,gatts_evt.conn_handle=%x\r\n", // p_ble_evt->evt.common_evt.conn_handle, // p_ble_evt->evt.gap_evt.conn_handle, // p_ble_evt->evt.l2cap_evt.conn_handle, // p_ble_evt->evt.gattc_evt.conn_handle, // p_ble_evt->evt.gatts_evt.conn_handle // ); #endif on_write(p_nus, p_ble_evt); break; default: // No implementation needed. break; } }
/* * Function for handling the BLE events. * * param[in] p_temp Temp Service structure. * param[in] p_ble_evt Event received from the BLE stack. */ void ble_temp_on_ble_evt(ble_temp_t * p_temp, ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: PUTS("evt_id: CONNECTED"); on_connect(p_temp, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_temp, p_ble_evt); PUTS("Stop temp timer"); APP_ERROR_CHECK(app_timer_stop(m_temperature_timer_id)); break; case BLE_GATTS_EVT_WRITE: on_write(p_temp, p_ble_evt); break; case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST: break; case BLE_GATTS_EVT_SYS_ATTR_MISSING: break; case BLE_GATTS_EVT_HVC: break; case BLE_GATTS_EVT_SC_CONFIRM: break; case BLE_GATTS_EVT_TIMEOUT: break; default: break; } }
void ble_luxsync_on_ble_evt(ble_luxsync_t * p_luxsync, ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_luxsync, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_luxsync, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_luxsync, p_ble_evt); break; case BLE_EVT_TX_COMPLETE: sendDataFlag = 1; if(flag_send_data) { send_data_stream_ble(p_luxsync, fetchMoreData, 0); if ( fetchMoreData ) fetchMoreData = 0; } //heart_rate_meas_send(); break; default: // No implementation needed. break; } }
void ble_cscs_on_ble_evt(ble_cscs_t * p_cscs, ble_evt_t * p_ble_evt) { ble_sc_ctrlpt_on_ble_evt(&(p_cscs->ctrl_pt), p_ble_evt); switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: on_connect(p_cscs, p_ble_evt); break; case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_cscs, p_ble_evt); break; case BLE_GATTS_EVT_WRITE: on_write(p_cscs, p_ble_evt); break; default: // No implementation needed. break; } }
void ble_dp_on_ble_evt(ble_dp_t * p_dp, ble_evt_t * p_ble_evt) { switch (p_ble_evt->header.evt_id) //See ble_gap.h line 409 { /**< Connection established. */ case BLE_GAP_EVT_CONNECTED: on_connect(p_dp, p_ble_evt); break; /**< Disconnected from peer. */ case BLE_GAP_EVT_DISCONNECTED: on_disconnect(p_dp, p_ble_evt); break; /**< Write operation performed. */ case BLE_GATTS_EVT_WRITE: on_write(p_dp, p_ble_evt); break; default: break; } }