//============================================================================
// TTestClient::Execute : Execute the test.
//----------------------------------------------------------------------------
void TTestClient::Execute(void)
{ NString theValue;
NNetworkMessage theMsg;
// Send a message to everyone
theMsg = CreateMessage(kTestClientBroadcastMsg, kNEntityEveryone);
theMsg.SetValue(kTestTokenKey, kTokenClientBroadcast);
mState += kStateClientSentMessage;
SendMessage(theMsg);
// Send a message to the server
theMsg = CreateMessage(kTestClientServerMsg, kNEntityServer);
theMsg.SetValue(kTestTokenKey, kTokenClientServer);
mState += kStateClientSentMessage;
SendMessage(theMsg);
// Wait for a response
while (!mIsDone)
NThread::Sleep();
}
/**
* @ingroup SipUserAgent
* @brief REFER 메시지를 생성한다.
* @returns 성공하면 REFER 메시지를 리턴하고 그렇지 않으면 NULL 을 리턴한다.
*/
CSipMessage * CSipDialog::CreateRefer( )
{
CSipMessage * pclsMessage = CreateMessage( SIP_METHOD_REFER );
if( pclsMessage == NULL ) return NULL;
return pclsMessage;
}
/**
* @ingroup SipUserAgent
* @brief INFO 메시지를 생성한다.
* @returns 성공하면 PRACK 메시지를 리턴하고 그렇지 않으면 NULL 을 리턴한다.
*/
CSipMessage * CSipDialog::CreateInfo( )
{
CSipMessage * pclsMessage = CreateMessage( SIP_METHOD_INFO );
if( pclsMessage == NULL ) return NULL;
return pclsMessage;
}
/**
* @ingroup SipUserAgent
* @brief BYE 메시지를 생성한다.
* @returns 성공하면 BYE 메시지를 리턴하고 그렇지 않으면 NULL 을 리턴한다.
*/
CSipMessage * CSipDialog::CreateBye( )
{
CSipMessage * pclsMessage = CreateMessage( SIP_METHOD_BYE );
if( pclsMessage == NULL ) return NULL;
return pclsMessage;
}
/** @return Widget for this log listing item*/
virtual TSharedRef<SWidget> GenerateWidget()
{
// See if we have any valid tokens which match the column name
const TArray< TSharedRef<IMessageToken> >& MessageTokens = Message->GetMessageTokens();
// Collect entire message for tooltip
FText FullMessage = Message->ToText();
// Create the horizontal box and add the icon
TSharedPtr<SHorizontalBox> HorzBox;
TSharedRef<SWidget> CellContent =
SNew(SBorder)
.OnMouseButtonUp(this, &SMessageLogListingItem::Message_OnMouseButtonUp)
.BorderImage(FEditorStyle::GetBrush("NoBorder"))
.Padding( FMargin(2.f, 2.f, 2.f, 1.f) )
[
SAssignNew(HorzBox, SHorizontalBox)
.ToolTipText(FullMessage)
];
check(HorzBox.IsValid());
// Iterate over parts of the message and create widgets for them
for (auto TokenIt = MessageTokens.CreateConstIterator(); TokenIt; ++TokenIt)
{
const TSharedRef<IMessageToken>& Token = *TokenIt;
CreateMessage( HorzBox, Token );
}
return CellContent;
}
/* Send interrupt notification to the phone or
* read data from the accelerometer and send it to the phone
*/
static void AccelerometerSendDataHandler(void)
{
tMessage Msg = {3, AccelIndMsg, MSG_OPT_NONE, NULL};
if (CreateMessage(&Msg))
{
if (Control & DRDYE_DATA_AVAILABLE || (Control & WUF_ENABLE))
{
AccelerometerRead(Control & DRDYE_DATA_AVAILABLE ? KIONIX_XOUT_L : KIONIX_XOUT_HPF_L,
Data, XYZ_DATA_LENGTH);
Msg.pBuffer[0] = Data[1];
Msg.pBuffer[1] = Data[3];
Msg.pBuffer[2] = Data[5];
RouteMsg(&Msg);
// PrintQ(Msg.pBuffer, 3);
}
else if (Control & TILT_ENABLE_TPE)
{
AccelerometerRead(KIONIX_TILT_POS_CUR, Msg.pBuffer, ONE_BYTE);
Msg.Length = 1;
RouteMsg(&Msg);
PrintH(Msg.pBuffer[0]); PrintR();
}
AccelerometerRead(KIONIX_INT_REL, Data, ONE_BYTE); //clear int
}
}
/**
* @ingroup SipUserAgent
* @brief NOTIFY 메시지를 생성한다.
* @returns 성공하면 NOTIFY 메시지를 리턴하고 그렇지 않으면 NULL 을 리턴한다.
*/
CSipMessage * CSipDialog::CreateNotify( )
{
CSipMessage * pclsMessage = CreateMessage( SIP_METHOD_NOTIFY );
if( pclsMessage == NULL ) return NULL;
return pclsMessage;
}
PackedMessage_t MemProtocol::CreateLeaseMessage(int leaseSize,int leaseDuration)
{
char * payload = new char[sizeof(int)+sizeof(int)];
memcpy(payload, &leaseSize, sizeof(int));
memcpy(payload+sizeof(int), &leaseDuration, sizeof(int));
return CreateMessage(Lease, payload, sizeof(int) + sizeof(int));
}
/**
Create a clone of a message based on protocol and id
*/
Message* LocalTransport::Clone(Message* msg)
{
uint32_t proto = msg->GetProtcolCRC();
uint32_t code = msg->GetCode();
Message* cloned = CreateMessage(proto, code);
cloned->Copy(msg);
return cloned;
}
/**
* @ingroup SipUserAgent
* @brief CANCEL 메시지를 생성한다.
* @returns 성공하면 CANCEL 메시지를 리턴하고 그렇지 않으면 NULL 을 리턴한다.
*/
CSipMessage * CSipDialog::CreateCancel( )
{
CSipMessage * pclsMessage = CreateMessage( SIP_METHOD_CANCEL );
if( pclsMessage == NULL ) return NULL;
pclsMessage->AddVia( m_pclsSipStack->m_clsSetup.m_strLocalIp.c_str(), m_pclsSipStack->m_clsSetup.GetLocalPort( m_eTransport ), m_strViaBranch.c_str(), m_eTransport );
return pclsMessage;
}
void InitGraphics(int argc, char *argv[])
{
Dimension width, height;
XEvent event;
static String fallback_resources[] = {
"*xcheck*background: #e0e0e0",
"*xcheck*fontList: -*-helvetica-bold-r-normal--14-*-*-*-*-*-*-*",
"*xcheck*font: -*-helvetica-bold-r-normal--14-*-*-*-*-*-*-*",
"*xcheck*XmText.background: #b0e0c0",
NULL,
};
XtSetLanguageProc(NULL,NULL,NULL);
toplevel = XtVaAppInitialize(
&app,"App-Class",
NULL,0,
&argc,argv,
fallback_resources,
NULL);
mainWidget = XtVaCreateManagedWidget("mw", xmMainWindowWidgetClass, toplevel, NULL);
dpy = XtDisplay(mainWidget);
gc = XCreateGC(dpy,DefaultRootWindow(dpy),(int)NULL,NULL);
XSetLineAttributes(dpy,gc,2,LineSolid,CapButt,JoinMiter);
colormap = CreateColorMap(mainWidget);
menubar = CreateMenuBar(mainWidget);
workwin = CreateWorkWin(mainWidget);
message = CreateMessage(mainWidget);
XtVaSetValues(mainWidget,
XmNcolormap,colormap,
XmNmenuBar,menubar,
XmNworkWindow,workwin,
XmNmessageWindow,message,
NULL);
XtRealizeWidget(toplevel);
do {
XtAppNextEvent(app,&event);
XtDispatchEvent(&event);
}
while(event.type != Expose);
XtVaGetValues(toplevel,XmNheight,&height,XmNwidth,&width,NULL);
XtVaSetValues(toplevel,
XmNwidth, width,
XmNheight, height,
XmNmaxWidth, width,
XmNmaxHeight, height,
XmNminWidth, width,
XmNminHeight, height,
XmNallowShellResize, False,
NULL);
HandleEvents();
strcpy(xval[0],"human");
strcpy(xval[1],"computer");
strcpy(xval[2],"10.0");
}
void BufferIOEvent::Send(const Message& msg) {
MessagePtr msg_ptr = CreateMessage(msg);
#ifdef _BINARY_MSG_EXTEND_PACKAGING
if (msg_type_ == MessageType::BINARY) {
BinaryMessage* bmsg = static_cast<BinaryMessage*>(msg_ptr.get());
bmsg->Header()->msg_id = ++msg_seq_;
}
#endif
SendInner(msg_ptr);
}
//-----------------------------------------------------------------------------
// Purpose: Creates a reply to the message
// Input : *msgName -
// *msgToReplyTo -
// Output : ISendMessage
//-----------------------------------------------------------------------------
ISendMessage *CTrackerNET::CreateReply(int msgID, IReceiveMessage *msgToReplyTo)
{
ISendMessage *reply = CreateMessage(msgID);
// setup reply
reply->SetNetAddress(msgToReplyTo->NetAddress());
reply->SetSessionID(msgToReplyTo->SessionID());
reply->SetEncrypted(msgToReplyTo->WasEncrypted());
return reply;
}
/**
* @ingroup SipUserAgent
* @brief ACK 메시지를 생성한다.
* @param iStatusCode SIP INVITE 응답 코드
* @returns 성공하면 ACK 메시지를 리턴하고 그렇지 않으면 NULL 을 리턴한다.
*/
CSipMessage * CSipDialog::CreateAck( int iStatusCode )
{
CSipMessage * pclsMessage = CreateMessage( SIP_METHOD_ACK );
if( pclsMessage == NULL ) return NULL;
if( iStatusCode / 100 != 2 )
{
pclsMessage->AddVia( m_pclsSipStack->m_clsSetup.m_strLocalIp.c_str(), m_pclsSipStack->m_clsSetup.GetLocalPort( m_eTransport ), m_strViaBranch.c_str(), m_eTransport );
}
return pclsMessage;
}
void BufferIOEvent::Send(const char *data, uint32_t len, bool bmsg_has_hdr) {
MessagePtr msg_ptr = CreateMessage(msg_type_, data, len, bmsg_has_hdr);
if (msg_type_ == MessageType::BINARY) {
BinaryMessage* bmsg = static_cast<BinaryMessage*>(msg_ptr.get());
#ifdef _BINARY_MSG_EXTEND_PACKAGING
bmsg->Header()->msg_id = ++msg_seq_;
#endif
printf("[BufferIOEvent::Send] HDR: %s\n", bmsg->Header()->ToString().c_str());
}
printf("[BufferIOEvent::Send] message size: %ld\n", msg_ptr->Size());
SendInner(msg_ptr);
}
void MessageMQ::AppendData(const char* data, uint32_t size) {
size_t feeds = 0;
while (feeds < size) {
if (Last()->Completion()) {
mq_.push(CreateMessage(msg_type_));
}
feeds += Last()->AppendData(&data[feeds], size - feeds);
if (Last()->Completion()) {
printf("[MessageMQ] Recieved a complation message, type: %d, size: %lu\n", Last()->Type(), Last()->Size());
}
}
}
static MessagePtr Parse(const char* buf, int len, ErrorCode* error)
{
MessagePtr message;
typedef google::protobuf::int32 int32;
// check sum
int32 expectedCheckSum = async::detail::AsInt32(buf + len - kHeaderLen);
int32 checkSum = static_cast<int32>(0
/*::adler32(1,
reinterpret_cast<const Bytef*>(buf),
static_cast<int>(len - kHeaderLen))*/);
if (checkSum == expectedCheckSum)
{
// get message type name
int32 nameLen = async::detail::AsInt32(buf);
if (nameLen >= 2 && nameLen <= len - 2 * kHeaderLen)
{
std::string typeName(buf + kHeaderLen, buf + kHeaderLen + nameLen - 1);
// create message object
message.reset(CreateMessage(typeName));
if (message)
{
// parse from buffer
const char* data = buf + kHeaderLen + nameLen;
int32 dataLen = len - nameLen - 2 * kHeaderLen;
if (message->ParseFromArray(data, dataLen))
{
*error = kNoError;
}
else
{
*error = kParseError;
}
}
else
{
*error = kUnknownMessageType;
}
}
else
{
*error = kInvalidNameLen;
}
}
else
{
*error = kCheckSumError;
}
return message;
}
void ChangeMode(unsigned char Option)
{
// PrintF("- ChgModInd:0x%02x", Option);
// PrintF(" PgTp %d Pg: %d", PageType, CurrentPage[PageType]);
unsigned char Mode = Option & MODE_MASK;
tMessage Msg = {1, ModeChangeIndMsg, (CurrentIdleScreen() << 4) | Mode, NULL};
if (CreateMessage(&Msg))
{
Msg.pBuffer[0] = (Option >> 4) ? Option >> 4 : eScUpdateComplete;
RouteMsg(&Msg);
}
BOOL SipMessageCallback(char *string, char *ip, int port)
{
MESSAGE *message = CreateMessage();
SetMessageAddr(message, ip);
SetMessagePort(message, port);
if (ParseMessage(string, message) < 0) {
return FALSE;
}
return SipMessageInput(message);
}
TEST(TryingMessageBuildTestGroup, TryingMessageCallIdTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
struct CallIdHeader *inviteCallId = (struct CallIdHeader *)MessageGetHeader(HEADER_NAME_CALLID, invite);
struct CallIdHeader *tryingCallId = (struct CallIdHeader *)MessageGetHeader(HEADER_NAME_CALLID, trying);
CHECK_TRUE(CallIdHeaderMatched(inviteCallId, tryingCallId));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
TEST(TryingMessageBuildTestGroup, TryingMessageCSeqTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
struct CSeqHeader *inviteCSeq = (struct CSeqHeader *)MessageGetHeader(HEADER_NAME_CSEQ, invite);
struct CSeqHeader *tryingCSeq = (struct CSeqHeader *)MessageGetHeader(HEADER_NAME_CSEQ, trying);
CHECK_TRUE(CSeqHeadersMatched(inviteCSeq, tryingCSeq));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
TEST(TryingMessageBuildTestGroup, TryingMessageViaTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
VIA_HEADER *inviteVia = (VIA_HEADER *)MessageGetHeader(HEADER_NAME_VIA, invite);
VIA_HEADER *tryingVia = (VIA_HEADER *)MessageGetHeader(HEADER_NAME_VIA, trying);
CHECK_TRUE(ViaHeaderMatched(inviteVia, tryingVia));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
TEST(TryingMessageBuildTestGroup, TryingMessageFromHeaderTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
CONTACT_HEADER *inviteFrom = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_FROM, invite);
CONTACT_HEADER *tryingFrom = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_FROM, trying);
CHECK_TRUE(ContactHeaderMatched(inviteFrom, tryingFrom));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
MESSAGE *BuildRequest(struct Dialog *dialog, SIP_METHOD method)
{
MESSAGE *message = CreateMessage();
struct HeaderBuilderMap *p = RequestHeaderBuilderMap;
SetMessageDestIpaddr(message, dialog);
SetMessageType(message, MESSAGE_TYPE_REQUEST);
SetMessageRequestLine(message, BuildRequestLine(dialog, method));
for ( ; p->headerName != NULL; p++ ) {
MessageAddHeader(message, p->buildRequestHeader(message, dialog));
}
return message;
}
/**
* @ingroup SipUserAgent
* @brief PRACK 메시지를 생성한다.
* @returns 성공하면 PRACK 메시지를 리턴하고 그렇지 않으면 NULL 을 리턴한다.
*/
CSipMessage * CSipDialog::CreatePrack( )
{
if( m_iRSeq == -1 ) return NULL;
CSipMessage * pclsMessage = CreateMessage( SIP_METHOD_PRACK );
if( pclsMessage == NULL ) return NULL;
char szRAck[101];
snprintf( szRAck, sizeof(szRAck), "%d %d INVITE", m_iRSeq, m_iSeq );
pclsMessage->AddHeader( "RAck", szRAck );
return pclsMessage;
}
TEST(TryingMessageBuildTestGroup, TryingMessageToWithTagTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE_WITH_TO_TAG, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
CONTACT_HEADER *inviteTo = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_TO, invite);
CONTACT_HEADER *tryingTo = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_TO, trying);
CHECK_TRUE(ContactHeaderMatched(inviteTo, tryingTo));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
PackedMessage_t MemProtocol::CreateDataMessage(const char *buffer, long bufferSize, int leaseId, MessageType type)
{
long size = sizeof(int) + sizeof(long) + bufferSize;
char * payload = new char[size];
int offset = 0 ;
memcpy(payload,&leaseId,sizeof(int));
offset+= sizeof(int);
memcpy(payload +offset,&bufferSize,sizeof(long));
offset += sizeof(long);
memcpy(payload +offset,buffer,bufferSize);
return CreateMessage(type, payload, size);
}
TEST(TryingMessageBuildTestGroup, TryingMessageStatusLineTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
struct StatusLine *status = MessageGetStatusLine(trying);
CHECK_TRUE(status != NULL);
STRCMP_EQUAL(SIP_VERSION, StatusLineGetSipVersion(status));
CHECK_EQUAL(100, StatusLineGetStatusCode(status));
STRCMP_EQUAL("Trying", StatusLineGetReasonPhrase(status));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
int KiekkoNetwork::SendMsg(SendPackage pckg)
{
char* buf = CreateMessage(pckg);
if (send(ConnectSocket, buf, sendLength, 0) == SOCKET_ERROR)
{
printf("sendto(...) failed! Error code : %d\n", WSAGetLastError());
return 1;
}
if (paskafix)
{
recvThreadMutex.unlock();
paskafix = false;
}
return 0;
}
MESSAGE *BuildAckMessageWithinClientTransaction(MESSAGE *invite)
{
assert(invite != NULL);
MESSAGE *ack = CreateMessage();
struct RequestLine *rl = RequestLineDup(MessageGetRequestLine(invite));
SetMessageType(ack, MESSAGE_TYPE_REQUEST);
RequestLineSetMethod(rl, SIP_METHOD_NAME_ACK);
SetMessageRequestLine(ack, rl);
AddResponseHeaders(ack, invite);
struct CSeqHeader *cseq = (struct CSeqHeader *)MessageGetHeader(HEADER_NAME_CSEQ, ack);
CSeqHeaderSetMethod(cseq, SIP_METHOD_NAME_ACK);
return ack;
}
