void YesNoHandler::Input(void* arg, const std::string &input) { std::string text = input; Lower(text); if (text == "y" || text == "yes") { _cb((Socket*)arg, true, _arg); } _cb((Socket*)arg, false, _arg); }
void Restorable::restore() { if (!_cb) return; _cb(this, _userData); }
ruleExecInfo_t& get_rei(irods::callback& _cb) { ruleExecInfo_t* rei{nullptr}; irods::error ret{_cb(std::string("unsafe_ms_ctx"), &rei)}; if (!ret.ok()) { THROW(ret.code(), "failed to get rei"); } return *rei; }
//------------------------------------------------------------------- void pbOscReceiver::receive0() { while (oscReceiver.hasWaitingMessages() ) { count++; ofxOscMessage m; oscReceiver.getNextMessage( &m ); if ( _cb ) { _cb( m ); } } }
void timer_task::exec() { _cb(_context); if (_interval_milliseconds > 0) { //_state must be TASK_STATE_RUNNING here dbg_dassert(_state.load(std::memory_order_relaxed) == TASK_STATE_RUNNING, "corrupted timer task state"); _state.store(TASK_STATE_READY, std::memory_order_release); set_delay(_interval_milliseconds); } }
void TextBlockHandler::Input(void* arg, const std::string &input) { if (input == ".") { _cb((Socket*)arg, _lines, _arg); return; } if (_lines) { _lines->push_back(input); } }
void timer_task::exec() { if (dsn_likely(_cb != nullptr)) { _cb(); } // valid interval, we reset task state to READY if (dsn_likely(_interval_milliseconds > 0)) { dassert(set_retry(true), "timer task set retry failed, with state = %s", enum_to_string(state())); set_delay(_interval_milliseconds); } }
void timer_task::exec() { task_state RUNNING_STATE = TASK_STATE_RUNNING; _cb(_param); if (_interval_milliseconds > 0) { if (_state.compare_exchange_strong(RUNNING_STATE, TASK_STATE_READY)) { set_delay(_interval_milliseconds); } } }
void FileOpLock::DoWaitCallback() { DWORD dwBytes; if (!GetOverlappedResult(g_hFile, &g_o, &dwBytes, TRUE)) { DebugPrintf("Oplock Failed\n"); } if (_cb) { _cb(); } DebugPrintf("Closing Handle\n"); CloseHandle(g_hFile); g_hFile = INVALID_HANDLE_VALUE; SetEvent(g_hLockCompleted); }
void TimerPollable::on_can_read() { if (_removeme) { return; } uint64_t nevents = 0; int r = read(_fd, &nevents, sizeof(nevents)); if (r < 0) { return; } if (_wrapper) { _wrapper->start_cb(); } _cb(); if (_wrapper) { _wrapper->end_cb(); } }
void LMEConnection::_apfChannelOpenDirect(unsigned char *rxBuffer, unsigned int bytesRead, UINT32 *senderChannel, int *status) { unsigned char *pCurrent; APF_GENERIC_HEADER *pHeader = (APF_GENERIC_HEADER *)rxBuffer; if (bytesRead < sizeof(APF_GENERIC_HEADER) + ntohl(pHeader->StringLength) + 7 + (5 * sizeof(UINT32))) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } pCurrent = rxBuffer + sizeof(APF_GENERIC_HEADER) + APF_STR_SIZE_OF(APF_OPEN_CHANNEL_REQUEST_DIRECT); LMEChannelOpenRequestMessage channelOpenRequest; channelOpenRequest.ChannelType = LMEChannelOpenRequestMessage::DIRECT; channelOpenRequest.SenderChannel = ntohl(*((UINT32 *)pCurrent)); if (senderChannel) { *senderChannel = channelOpenRequest.SenderChannel; } pCurrent += sizeof(UINT32); channelOpenRequest.InitialWindow = ntohl(*((UINT32 *)pCurrent)); pCurrent += 2 * sizeof(UINT32); UINT32 len = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); channelOpenRequest.Address.append((char *)pCurrent, len); pCurrent += len; channelOpenRequest.Port = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); _cb(_cbParam, &channelOpenRequest, sizeof(channelOpenRequest), status); }
int call(const DBT *key_, const DBT *val_) { return _cb(Slice(*key_), Slice(*val_)); }
static void _sjpcm_callback(void *pkt, void *param) { if (_cb) _cb(); }
/*receive ack from remote:set finish flag*/ void ISend::onReceive(unsigned char *dat, unsigned char len) { if (_cb != NULL) _cb(dat, len); return; }
void Callback::call(void* d) const { _cb(d); }
void LineHandler::Input(void* arg, const std::string &input) { std::string data = input; _cb((Socket*)arg, data, _arg); }
static int forward_cb(struct skynet_context * context, void * ud, int type, int session, uint32_t source, const void * msg, size_t sz) { _cb(context, ud, type, session, source, msg, sz); // don't delete msg in forward mode. return 1; }
void trigger() { _cb(); _timer.expires_from_now(boost::posix_time::seconds(_seconds)); start(); }
void LMEConnection::_apfUserAuthRequest(unsigned char *rxBuffer, unsigned int bytesRead, int *status) { unsigned char *pCurrent = rxBuffer; ++pCurrent; LMEUserAuthRequestMessage userAuthRequest; UINT32 len = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); if ((bytesRead - (pCurrent - rxBuffer)) < len) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } userAuthRequest.Username.append((char *)pCurrent, len); pCurrent += len; if ((unsigned int)(bytesRead - (pCurrent - rxBuffer)) < sizeof(UINT32)) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } len = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); if ((bytesRead - (pCurrent - rxBuffer)) < len) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } userAuthRequest.ServiceName.append((char *)pCurrent, len); pCurrent += len; if ((unsigned int)(bytesRead - (pCurrent - rxBuffer)) < sizeof(UINT32)) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } len = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); if ((bytesRead - (pCurrent - rxBuffer)) < len) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } userAuthRequest.MethodName.append((char *)pCurrent, len); pCurrent += len; if (_strnicmp(userAuthRequest.MethodName.c_str(), APF_AUTH_PASSWORD, userAuthRequest.MethodName.size()) == 0) { if ((unsigned int)(bytesRead - (pCurrent - rxBuffer)) < sizeof(UINT32) + 1) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } ++pCurrent; len = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); if ((bytesRead - (pCurrent - rxBuffer)) < len) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } AuthPasswordData authData; authData.Password.append((char *)pCurrent, len); pCurrent += len; userAuthRequest.MethodData = &authData; } _cb(_cbParam, &userAuthRequest, sizeof(userAuthRequest), status); }
void DummySink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned /*durationInMicroseconds*/) { // We've just received a frame of data. (Optionally) print out information about it: if(numTruncatedBytes > 0) { printf("============== warnning, live555 truncate %d bytes =================\n", numTruncatedBytes); } #ifdef DEBUG_PRINT_EACH_RECEIVED_FRAME if (fStreamId != NULL) envir() << "Stream \"" << fStreamId << "\"; "; envir() << fSubsession.mediumName() << "/" << fSubsession.codecName() << ":\tReceived " << frameSize << " bytes"; if (numTruncatedBytes > 0) envir() << " (with " << numTruncatedBytes << " bytes truncated)"; char uSecsStr[6+1]; // used to output the 'microseconds' part of the presentation time sprintf(uSecsStr, "%06u", (unsigned)presentationTime.tv_usec); envir() << ".\tPresentation time: " << (unsigned)presentationTime.tv_sec << "." << uSecsStr; if (fSubsession.rtpSource() != NULL && !fSubsession.rtpSource()->hasBeenSynchronizedUsingRTCP()) { envir() << "!"; // mark the debugging output to indicate that this presentation time is not RTCP-synchronized } envir() << "\n"; #endif // 分辨率已经发生变化,不再上报数据 if (_drop) { printf("############################### drop frame\n"); return; } if(_cb) { RtspFrameInfo info; info.videoFPS = fSubsession.videoFPS(); info.videoWidth = fSubsession.videoWidth(); info.videoHeight = fSubsession.videoHeight(); info.frequency = fSubsession.rtpTimestampFrequency(); info.channels = fSubsession.numChannels(); info.profile_level_id = fSubsession.fmtp_profile_level_id(); strncpy((char*)&(info.mediaName), fSubsession.mediumName(), sizeof(info.mediaName)); strncpy((char*)&(info.codecName), fSubsession.codecName(), sizeof(info.codecName)); info.timestamp = presentationTime; if(fSubsession.rtpSource() != NULL && !fSubsession.rtpSource()->hasBeenSynchronizedUsingRTCP()) { info.syncUseRTCP = false; } else { info.syncUseRTCP = true; } if(strcmp(fSubsession.mediumName(), "audio") == 0) { if (strcmp(fSubsession.codecName(), "MPEG4-GENERIC") == 0) { info.isHeader = 0; _cb(_channel, frameSize, (char*)fReceiveBuffer, info); } else if (strcmp(fSubsession.codecName(), "L16") == 0) { int i = fSubsession.numChannels(); info.isHeader = 0; _cb(_channel, frameSize, (char*)fReceiveBuffer, info); } } else if(strcmp(fSubsession.mediumName(), "video") == 0) { if(strcmp(fSubsession.codecName(), "H264") == 0) { unsigned char start_code[4] = {0x00, 0x00, 0x00, 0x01}; if(!_sentHeader) { _sentHeader = true; unsigned numSpropRecords; if(fSubsession.fmtp_spropparametersets() && 0 < strlen(fSubsession.fmtp_spropparametersets())) { SPropRecord* sPropRecords = parseSPropParameterSets(fSubsession.fmtp_spropparametersets(), numSpropRecords); printf("====================== proparamset: [%d]%s =================\n", numSpropRecords, fSubsession.fmtp_spropparametersets()); if(numSpropRecords > 0) { int headerLen = 0; int validRecordNum = 0; for(unsigned int i = 0; i < numSpropRecords; i++) { printf("spropparameter first byte = %x\n", sPropRecords[i].sPropBytes[0]); if(((sPropRecords[i].sPropBytes[0] & 0x1f) == 7) || ((sPropRecords[i].sPropBytes[0] & 0x1f) == 8)) { headerLen += sPropRecords[i].sPropLength; validRecordNum += 1; } } headerLen += sizeof(start_code) * validRecordNum; char* headerData = new char[headerLen]; int offset = 0; for(unsigned int i = 0; i < numSpropRecords; i++) { if(((sPropRecords[i].sPropBytes[0] & 0x1f) == 7) || ((sPropRecords[i].sPropBytes[0] & 0x1f) == 8)) { memcpy(headerData + offset, start_code, 4); offset += 4; memcpy(headerData + offset, sPropRecords[i].sPropBytes, sPropRecords[i].sPropLength); offset += sPropRecords[i].sPropLength; } } uint16_t w = 0; uint16_t h = 0; if (H264Parse::GetResolution((uint8_t*)headerData, headerLen, &w, &h)) { _w = w; _h = h; } info.isHeader = 1; _cb(_channel, headerLen, headerData, info); delete [] headerData; } } } else { if ((fReceiveBuffer[0] & 0x1f) == 7) { uint16_t w = 0; uint16_t h = 0; if (H264Parse::GetResolution((uint8_t*)fReceiveBuffer, frameSize, &w, &h)) { if (_w == 0 || _h == 0) { _w = w; _h = h; } else if ((_w != w) || (_h != h)) { printf("=====33333333========= %dx%d, %dx%d\n", _w, _h, w, h); _drop = true; } } } } if (!_drop) { info.isHeader = 0; char* newData = new char[sizeof(start_code) + frameSize]; memcpy(newData, start_code, sizeof(start_code)); memcpy(newData + sizeof(start_code), (char*)fReceiveBuffer, frameSize); _cb(_channel, frameSize + sizeof(start_code), newData, info); delete [] newData; } } else if(strcmp(fSubsession.codecName(), "MP4V-ES") == 0) { #ifdef SEND_CONFIG_HEADER unsigned configLen; unsigned char* configData = parseGeneralConfigStr(fSubsession.fmtp_config(), configLen); info.isHeader = 1; _cb(_channel, configLen, (char*)configData, info); #endif info.isHeader = 0; _cb(_channel, frameSize, (char*)fReceiveBuffer, info); } else { info.isHeader = 0; _cb(_channel, frameSize, (char*)fReceiveBuffer, info); } } } // Then continue, to request the next frame of data: continuePlaying(); }
void LMEConnection::_doRX() { unsigned int bytesRead; int status = 1; _threadStartedEvent.set(); unsigned char *rxBuffer = new unsigned char[_heci.GetBufferSize()]; while (true) { bytesRead = (unsigned int)_receiveMessage(rxBuffer, _heci.GetBufferSize()); if ((int)bytesRead < 0) { PRINT("Error receiving data from HECI\n"); Deinit(); break; } if (bytesRead == 0) { // ERROR continue; } PRINT("Received from LME %d bytes (msg type %02d)\n", bytesRead, rxBuffer[0]); if (!_checkMinMsgSize(rxBuffer, bytesRead)) { PRINT("Error receiving data from HECI\n"); Deinit(); break; } if (plugin.preprocess(rxBuffer, bytesRead) == LMS_DROPPED) { continue; } switch (rxBuffer[0]) { case APF_DISCONNECT: { LMEDisconnectMessage disconnectMessage( (APF_DISCONNECT_REASON_CODE)ntohl( ((APF_DISCONNECT_MESSAGE *)rxBuffer)->ReasonCode)); _cb(_cbParam, &disconnectMessage, sizeof(disconnectMessage), &status); } break; case APF_SERVICE_REQUEST: { APF_SERVICE_REQUEST_MESSAGE *pMessage = (APF_SERVICE_REQUEST_MESSAGE *)rxBuffer; LMEServiceRequestMessage serviceRequestMessage; serviceRequestMessage.ServiceName.append( (char *)(pMessage->ServiceName), ntohl(pMessage->ServiceNameLength)); _cb(_cbParam, &serviceRequestMessage, sizeof(serviceRequestMessage), &status); } break; case APF_USERAUTH_REQUEST: _apfUserAuthRequest(rxBuffer, bytesRead, &status); break; case APF_GLOBAL_REQUEST: _apfGlobalRequest(rxBuffer, bytesRead, &status); break; case APF_CHANNEL_OPEN: _apfChannelOpen(rxBuffer, bytesRead, &status); break; case APF_CHANNEL_OPEN_CONFIRMATION: { APF_CHANNEL_OPEN_CONFIRMATION_MESSAGE *pMessage = (APF_CHANNEL_OPEN_CONFIRMATION_MESSAGE *)rxBuffer; LMEChannelOpenReplaySuccessMessage channelOpenReply; channelOpenReply.RecipientChannel = ntohl(pMessage->RecipientChannel); channelOpenReply.SenderChannel = ntohl(pMessage->SenderChannel); channelOpenReply.InitialWindow = ntohl(pMessage->InitialWindowSize); _cb(_cbParam, &channelOpenReply, sizeof(channelOpenReply), &status); } break; case APF_CHANNEL_OPEN_FAILURE: { APF_CHANNEL_OPEN_FAILURE_MESSAGE *pMessage = (APF_CHANNEL_OPEN_FAILURE_MESSAGE *)rxBuffer; LMEChannelOpenReplayFailureMessage channelOpenReply; channelOpenReply.RecipientChannel = ntohl(pMessage->RecipientChannel); channelOpenReply.ReasonCode = (OPEN_FAILURE_REASON)(ntohl(pMessage->ReasonCode)); _cb(_cbParam, &channelOpenReply, sizeof(channelOpenReply), &status); } break; case APF_CHANNEL_CLOSE: { APF_CHANNEL_CLOSE_MESSAGE *pMessage = (APF_CHANNEL_CLOSE_MESSAGE *)rxBuffer; LMEChannelCloseMessage channelClose; channelClose.RecipientChannel = ntohl(pMessage->RecipientChannel); _cb(_cbParam, &channelClose, sizeof(channelClose), &status); } break; case APF_CHANNEL_DATA: { APF_CHANNEL_DATA_MESSAGE *pMessage = (APF_CHANNEL_DATA_MESSAGE *)rxBuffer; LMEChannelDataMessage channelData(ntohl(pMessage->RecipientChannel), ntohl(pMessage->DataLength), pMessage->Data); _cb(_cbParam, &channelData, sizeof(channelData), &status); } break; case APF_CHANNEL_WINDOW_ADJUST: { APF_WINDOW_ADJUST_MESSAGE *pMessage = (APF_WINDOW_ADJUST_MESSAGE *)rxBuffer; LMEChannelWindowAdjustMessage channelWindowAdjust; channelWindowAdjust.RecipientChannel = ntohl(pMessage->RecipientChannel); channelWindowAdjust.BytesToAdd = ntohl(pMessage->BytesToAdd); _cb(_cbParam, &channelWindowAdjust, sizeof(channelWindowAdjust), &status); } break; case APF_PROTOCOLVERSION: { APF_PROTOCOL_VERSION_MESSAGE *pMessage = (APF_PROTOCOL_VERSION_MESSAGE *)rxBuffer; LMEProtocolVersionMessage protVersion; protVersion.MajorVersion = ntohl(pMessage->MajorVersion); protVersion.MinorVersion = ntohl(pMessage->MinorVersion); protVersion.TriggerReason = (APF_TRIGGER_REASON)ntohl(pMessage->TriggerReason); _cb(_cbParam, &protVersion, sizeof(protVersion), &status); } break; default: // Uknown request. Ignore break; } if (IsInitialized()) { plugin.postprocess(rxBuffer, bytesRead, status); } } if (rxBuffer != NULL) { delete[] rxBuffer; } }
void LMEConnection::_apfGlobalRequest(unsigned char *rxBuffer, unsigned int bytesRead, int *status) { unsigned char *pCurrent; APF_GENERIC_HEADER *pHeader = (APF_GENERIC_HEADER *)rxBuffer; if (_strnicmp((char *)pHeader->String, APF_GLOBAL_REQUEST_STR_TCP_FORWARD_REQUEST, APF_STR_SIZE_OF(APF_GLOBAL_REQUEST_STR_TCP_FORWARD_REQUEST)) == 0) { LMETcpForwardRequestMessage tcpForwardRequest; unsigned int hsize = sizeof(APF_GENERIC_HEADER) + APF_STR_SIZE_OF(APF_GLOBAL_REQUEST_STR_TCP_FORWARD_REQUEST) + sizeof(UINT8); pCurrent = rxBuffer + hsize; bytesRead -= hsize; if (bytesRead < sizeof(UINT32)) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } UINT32 len = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); if (bytesRead < (sizeof(UINT32) + len + sizeof(UINT32))) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } tcpForwardRequest.Address.append((char *)pCurrent, len); pCurrent += len; tcpForwardRequest.Port = ntohl(*((UINT32 *)pCurrent)); _cb(_cbParam, &tcpForwardRequest, sizeof(tcpForwardRequest), status); } else if (_strnicmp((char *)pHeader->String, APF_GLOBAL_REQUEST_STR_TCP_FORWARD_CANCEL_REQUEST, APF_STR_SIZE_OF(APF_GLOBAL_REQUEST_STR_TCP_FORWARD_CANCEL_REQUEST)) == 0) { LMETcpForwardCancelRequestMessage tcpForwardCancelRequest; unsigned int hsize = sizeof(APF_GENERIC_HEADER) + APF_STR_SIZE_OF(APF_GLOBAL_REQUEST_STR_TCP_FORWARD_CANCEL_REQUEST) + sizeof(UINT8); pCurrent = rxBuffer + hsize; bytesRead -= hsize; if (bytesRead < sizeof(UINT32)) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } UINT32 len = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); if (bytesRead < (sizeof(UINT32) + len + sizeof(UINT32))) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } tcpForwardCancelRequest.Address.append((char *)pCurrent, len); pCurrent += len; tcpForwardCancelRequest.Port = ntohl(*((UINT32 *)pCurrent)); _cb(_cbParam, &tcpForwardCancelRequest, sizeof(tcpForwardCancelRequest), status); } else if (_strnicmp((char *)pHeader->String, APF_GLOBAL_REQUEST_STR_UDP_SEND_TO, APF_STR_SIZE_OF(APF_GLOBAL_REQUEST_STR_UDP_SEND_TO)) == 0) { unsigned int hsize = sizeof(APF_GENERIC_HEADER) + APF_STR_SIZE_OF(APF_GLOBAL_REQUEST_STR_UDP_SEND_TO) + sizeof(UINT8); pCurrent = rxBuffer + hsize; bytesRead -= hsize; if (bytesRead < sizeof(UINT32)) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } UINT32 len = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); if (bytesRead < (sizeof(UINT32) + len + sizeof(UINT32))) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } bytesRead -= (sizeof(UINT32) + len + sizeof(UINT32)); std::string address; address.append((char *)pCurrent, len); pCurrent += len; UINT32 port = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); if (bytesRead < sizeof(UINT32)) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } // Skip Originator IP and Port len = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); if (bytesRead < (sizeof(UINT32) + len + sizeof(UINT32))) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } bytesRead -= (sizeof(UINT32) + len + sizeof(UINT32)); pCurrent += len; pCurrent += sizeof(UINT32); if (bytesRead < sizeof(UINT32)) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } // Retrieve Data len = ntohl(*((UINT32 *)pCurrent)); pCurrent += sizeof(UINT32); if (bytesRead < (sizeof(UINT32) + len)) { PRINT("Error receiving data from HECI\n"); Deinit(); return; } LMEUdpSendToMessage udpSendTo(address, port, len, pCurrent); _cb(_cbParam, &udpSendTo, sizeof(udpSendTo), status); } }
virtual void DealNodeProto(IKernel * kernel, const s32 nodeType, const s32 nodeId, const void * context, const s32 size) { OArgs args(context, size); _cb(kernel, nodeType, nodeId, args); }