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);
}
