char* NTServerMessage::RecvFromServer()
{
if (fCacheData == PR_TRUE)
{
fCacheData = PR_FALSE;
return parseMessage(msgbuff);
}
if (fPendingRead_ == PR_TRUE)
{
fPendingRead_ = PR_FALSE;
if (lpOverlapped_ == NULL)
return 0; // Error
DWORD dwBytesRead = 0;
BOOL fRetVal = GetOverlappedResult(msgFd_,
lpOverlapped_,
&dwBytesRead,
TRUE); // blocking
if (!fRetVal)
return 0; // Error
if (msgbytesRead == 0) // ReadFile might have returned 0
msgbytesRead = dwBytesRead;
return parseMessage(msgbuff);
}
char* buffer = msgbuff;
int bufferLen = sizeof(msgbuff);
DWORD dwBytesRead = 0;
// Blocking Call
if (ReadFile(msgFd_, buffer, bufferLen, &msgbytesRead, NULL) == TRUE)
{
return parseMessage(buffer);
}
return 0;
}
/** read new data from the socket
*
* @return
*
* History:
* - 2010/08/03: STEELJ - Initial Version.
*/
void CAdChannel::readData()
{
if (m_socket->state() != QAbstractSocket::ConnectedState)
{
return;
}
if (m_unprocessedData.size() > 0)
{
QByteArray data = m_socket->readAll();
m_unprocessedData.append(data);
QBuffer buffer(&m_unprocessedData);
buffer.open(QIODevice::ReadOnly);
while (fullMessageAvailable(buffer))
{
parseMessage(buffer);
}
}
else
{
while (m_socket && fullMessageAvailable(*m_socket))
{
parseMessage(*m_socket);
}
if (m_socket && m_socket->bytesAvailable() > 0)
{
QByteArray data = m_socket->readAll();
m_unprocessedData.append(data);
}
}
}
bool
HeapSnapshot::init(JSContext* cx, const uint8_t* buffer, uint32_t size)
{
if (!nodes.init() || !frames.init())
return false;
ArrayInputStream stream(buffer, size);
GzipInputStream gzipStream(&stream);
// First is the metadata.
protobuf::Metadata metadata;
if (!parseMessage(gzipStream, metadata))
return false;
if (metadata.has_timestamp())
timestamp.emplace(metadata.timestamp());
// Next is the root node.
protobuf::Node root;
if (!parseMessage(gzipStream, root))
return false;
// Although the id is optional in the protobuf format for future proofing, we
// can't currently do anything without it.
if (NS_WARN_IF(!root.has_id()))
return false;
rootId = root.id();
// The set of all node ids we've found edges pointing to.
NodeIdSet edgeReferents(cx);
if (NS_WARN_IF(!edgeReferents.init()))
return false;
if (NS_WARN_IF(!saveNode(root, edgeReferents)))
return false;
// Finally, the rest of the nodes in the core dump.
while (StreamHasData(gzipStream)) {
protobuf::Node node;
if (!parseMessage(gzipStream, node))
return false;
if (NS_WARN_IF(!saveNode(node, edgeReferents)))
return false;
}
// Check the set of node ids referred to by edges we found and ensure that we
// have the node corresponding to each id. If we don't have all of them, it is
// unsafe to perform analyses of this heap snapshot.
for (auto range = edgeReferents.all(); !range.empty(); range.popFront()) {
if (NS_WARN_IF(!nodes.has(range.front())))
return false;
}
return true;
}
void QTwitchChat::connect()
{
if( channelName_ == "" )
return;
if( isShowSystemMessages() )
emit newMessage( new QChatMessage( TWITCH_SERVICE, TWITCH_USER, "Connecting to " + channelName_ + "...", "", this ) );
if( socket_)
{
if( socket_->state() == QAbstractSocket::ConnectedState )
return;
/*else
reconnect();*/
}
socket_ = new QTcpSocket();
QObject::connect( socket_, SIGNAL( connected() ), this, SLOT( onConnected() ) );
QObject::connect( socket_, SIGNAL( readyRead() ), this, SLOT( parseMessage() ) );
QObject::connect( socket_, SIGNAL( error( QAbstractSocket::SocketError ) ), this, SLOT( onSocketError() ) );
//QObject::connect( socket_, SIGNAL( disconnected() ), this, SLOT( reconnect() ) );
socket_->connectToHost( DEFAULT_TWITCH_CHAT_HOST_NAME, DEFAULT_TWITCH_CHAT_PORT_NUMBER );
}
MessagePattern &
MessagePattern::parse(const UnicodeString &pattern, UParseError *parseError, UErrorCode &errorCode) {
preParse(pattern, parseError, errorCode);
parseMessage(0, 0, 0, UMSGPAT_ARG_TYPE_NONE, parseError, errorCode);
postParse();
return *this;
}
void sendFileTo(char* message, int to, int from){
char *file_contents;
long input_file_size;
//remove \n at end of string
message[strlen(message)-1]=0;
FILE* input_file = fopen(message,"r");
if(input_file != NULL){
fseek(input_file, 0, SEEK_END);
input_file_size = ftell(input_file);
rewind(input_file);
file_contents = malloc(input_file_size * (sizeof(char)));
fread(file_contents, sizeof(char), input_file_size, input_file);
fclose(input_file);
char* buf;
int size = input_file_size+sizeof(message)+MAX_USR_LENGTH + 30;
char tmp[size];
memset(tmp,0,size);
strcat(tmp,"ENDOFFILE");
strcat(tmp," ; ");
strcat(tmp,file_contents);
buf = parseMessage(tmp,strlen(tmp));
printf("N%s\n",buf);
printf("Envoie au client : %d\n",to);
if (Writeline(ctx.socketFd[to], buf, strlen(buf)+1) < 0){
debugTrace("Message issue");
}
else {
debugTrace("Message sent\n");
}
free(buf);
}
}
LLTemplateParser::LLTemplateParser(LLTemplateTokenizer & tokens):
mVersion(0.f),
mMessages()
{
// the version number should be the first thing in the file
if (tokens.want("version"))
{
// version number
std::string vers_string = tokens.next();
mVersion = (F32)atof(vers_string.c_str());
llinfos << "### Message template version " << mVersion << " ###" << llendl;
}
else
{
llerrs << "Version must be first in the message template, found "
<< tokens.next() << llendl;
}
while(LLMessageTemplate * templatep = parseMessage(tokens))
{
if (templatep->getDeprecation() != MD_DEPRECATED)
{
mMessages.push_back(templatep);
}
}
if(!tokens.wantEOF())
{
llerrs << "Expected end of template or a message, instead found: "
<< tokens.next() << " at " << tokens.line() << llendl;
}
}
int NetworkedClient::receive(int timeout){
char buf[NETWORKED_MODULE_RECEIVE_BUFFER_SIZE];
Address remote;
int size=socket.recvFrom(remote, buf, NETWORKED_MODULE_RECEIVE_BUFFER_SIZE, timeout);
// std::cout << __PRETTY_FUNCTION__ << "begin" << std::endl;
if (remote.getHost()==0xffffffff){
// std::cout << __PRETTY_FUNCTION__ << " broadcast HOST" << std::endl;
elapsedTimeoutReceived();
return 0;
} else {
PeerInfoMap::iterator peer=peers.find(remote);
if (peer==peers.end()){
PeerInfo pinfo;
peers.insert(std::make_pair(remote,pinfo));
peer=peers.find(remote);
std::cout << "registering supplier HOST= " <<remote.getHost() << " port=" << remote.getPort() <<std::endl;
}
gettimeofday(&peer->second.lastPingTime, 0);
socket.sendTo(remote,"",0);
// std::cout << "Parsing" << std::endl;
if (size)
parseMessage(size, buf);
return size;
}
}
void *reader(void *info) {
int i = 0;
clientNode *thisClient = (clientNode*) info;
char recvLine[MAXLINE + 1];
char **lines = NULL;
ssize_t n;
printf("[Uma conexao aberta]\n");
//Loop de leitura de mensagens
while ((n=read(thisClient->socket, recvLine, MAXLINE)) > 0) {
recvLine[n] = '\0';
printf("[Cliente %d enviou:] ", thisClient->socket);
if ((fputs(recvLine, stdout)) == EOF) {
perror("fputs :( \n");
exit(6);
}
lines = getLines(recvLine); //Quebra a mensagem em linhas
for(i = 0; lines[i] != NULL; i++) {
parseMessage(lines[i], thisClient);
}
free(lines);
}
delNode(thisClient);
printf("[Uma conexao fechada]\n");
return NULL;
}
void YSE::SOUND::implementationObject::sync() {
if (head.load() == nullptr) {
objectStatus = OBJECT_DONE;
// sound head is destructed, so stop and remove
if (status_dsp != SS_STOPPED || status_dsp != SS_WANTSTOSTOP) {
status_dsp = SS_WANTSTOSTOP;
}
else if (status_dsp == SS_STOPPED) {
objectStatus = OBJECT_RELEASE;
}
return;
}
messageObject message;
while (messages.try_pop(message)) {
parseMessage(message);
}
// sync dsp values
currentVolume_upd = currentVolume_dsp;
head.load()->time = currentFilePos;
head.load()->volume = currentVolume_dsp;
status_upd = status_dsp;
head.load()->status = status_upd;
}
void sendAll(unsigned char* message, int actuel){
int i = 0;
char* buf;
int size = strlen((char*)message)+MAX_USR_LENGTH + 20;
char tmp[size];
for(i=0;i<LISTENQ;i++){
memset(tmp,0,size);
if(ctx.socketFd[i] != -1 && (i != actuel)){
strcat(tmp,usrDatas[actuel].name);
strcat(tmp," : ");
strcat(tmp,(char*)message);
buf = parseMessage(tmp,strlen(tmp));
printf("Envoie au client : %d\n",i);
if (Writeline(ctx.socketFd[i], buf, strlen(buf)+1) < 0){
debugTrace("Message issue");
}
else {
debugTrace("Message sent\n");
}
free(buf);
}
}
}
string TgTypeParser::parseMessage(const Message::Ptr& object) const {
if (!object) {
return "";
}
string result;
result += '{';
appendToJson(result, "message_id", object->messageId);
appendToJson(result, "from", parseUser(object->from));
appendToJson(result, "date", object->date);
appendToJson(result, "chat", parseChat(object->chat));
appendToJson(result, "forward_from", parseUser(object->forwardFrom));
appendToJson(result, "forward_date", object->forwardDate);
appendToJson(result, "reply_to_message", parseMessage(object->replyToMessage));
appendToJson(result, "text", object->text);
appendToJson(result, "audio", parseAudio(object->audio));
appendToJson(result, "document", parseDocument(object->document));
appendToJson(result, "photo", parseArray(&TgTypeParser::parsePhotoSize, object->photo));
appendToJson(result, "sticker", parseSticker(object->sticker));
appendToJson(result, "video", parseVideo(object->video));
appendToJson(result, "contact", parseContact(object->contact));
appendToJson(result, "location", parseLocation(object->location));
appendToJson(result, "new_chat_participant", parseUser(object->newChatParticipant));
appendToJson(result, "left_chat_participant", parseUser(object->leftChatParticipant));
appendToJson(result, "new_chat_title", object->newChatTitle);
appendToJson(result, "new_chat_photo", parseArray(&TgTypeParser::parsePhotoSize, object->newChatPhoto));
appendToJson(result, "delete_chat_photo", object->deleteChatPhoto);
appendToJson(result, "group_chat_created", object->groupChatCreated);
appendToJson(result, "caption", object->caption);
result.erase(result.length() - 1);
result += '}';
return result;
}
DWORD IRCMsgThread::Run() {
onSysMsg(L"IRCMsgThread Start");
iStatus=IRC_NORMAL;
IRCMsgQueue.clear();
unsigned int bufferlen;
std::string recvstring,msg,umsg; //TwitchIRC use MultiByte
while(!bKillThread ) {
//Receive First
bufferlen=0;
memset(buffer, 0, DEFAULT_BUFLEN);
if(TheSocketPtr->recv_data((char*)buffer, bufferlen)) { //Disconnected
iStatus=IRC_DISCONNECTED;
break;
}
recvstring=std::string(buffer,bufferlen);
//onDebugMsg(L"%ls",from_utf8(recvstring).c_str());
if(recvstring.compare(":tmi.twitch.tv NOTICE * :Login unsuccessful\r\n")==0 || //Twitch
recvstring.compare(":tmi.twitch.tv NOTICE * :Error encountered while attempting login\r\n")==0 ){ //Justin
Sleep(100); //Wait for logging
onSysMsg(L"Login unsuccessful");
iStatus=IRC_WRONGLOGIN;
break;
}//else if(recvstring.compare(":[email protected] PRIVMSG #append :break\r\n")==0){TheSocketPtr->CloseSocket();}
//Basic parsing: make it into a string, check for PING, if not-send for further parsing.
std::stringstream recvstr(recvstring);
while( recvstr.tellg() < bufferlen ) {
std::getline(recvstr,msg,'\n');
//Old Style
//:[email protected] PRIVMSG #ptken :what song is this ?
//PING LAG1967655232
//int colon_pos = (int)msg.find(":");
//if (msg[0] != ':' && colon_pos > 0) msg=msg.substr(colon_pos); //if an irc message begins with " ", then trim the leading spaces
//
//New Style
// @color=#FF4500;display-name=Gm470520;emotes=;mod=0;room-id=47281189;subscriber=1;turbo=0;user-id=24255667;user-type= :[email protected] PRIVMSG #tetristhegrandmaster3 :這片到底在沖三小w
int at_pos = (int)msg.find("@");
if (msg[0] != '@' && at_pos > 0) msg=msg.substr(at_pos); //if an irc message begins with " ", then trim the leading spaces
if (msg[msg.length()-1]=='\r') msg=msg.substr(0,msg.length()-1); //trim the CR: getline only trim the LF
log(from_utf8(msg), LogType(RECEIVE)); //Although log file is in UTF8....using vswprintf
//Ping Check
umsg=msg.substr(0,5);
ToUpperString(umsg);
if (!umsg.compare("PING ")) sendRaw( L"PONG " + from_utf8(msg.substr(5)) ); // respond to PINGs //Reply Immediately
//Then parse the message
else parseMessage(from_utf8(msg));
}
Sleep(100);
}
//Determine the reason to break the loop.
if(!bKillThread) {
if(iStatus==IRC_DISCONNECTED) onSysMsg(L"IRCMsgThread: Disconnect Unexpectedly");
if(iStatus==IRC_WRONGLOGIN) onSysMsg(L"IRCMsgThread: Wrong Login Information");
}
else iStatus=IRC_CLOSED;
//onDebugMsg(L"[Last Buffer]%ls",from_utf8(recvstring).c_str());
onSysMsg(L"IRCMsgThread Close");
thread=0;
return 0;
}
void render(BelaContext *context, void *userData)
{
// receive OSC messages, parse them, and send back an acknowledgment
while (oscServer.messageWaiting()){
parseMessage(oscServer.popMessage());
oscClient.queueMessage(oscClient.newMessage.to("/osc-acknowledge").add(5).add(4.2f).add(std::string("OSC message received")).end());
}
}
CRemoteControlMessage::CRemoteControlMessage(alt_u8* pMessage, int iLength)
{
parseHeader(pMessage, iLength);
if(m_bValid)
{
m_bValid = false;
parseMessage(pMessage+4, iLength-4);
}}
void AbletonGui::update() {
if (!abletonActive) return;
while (osc.hasWaitingMessages()) {
ofxOscMessage msg;
osc.getNextMessage(msg);
parseMessage(msg);
}
}
void ClientConnection::recv() {
message.append(socket->readAll());
int pos;
while((pos = message.indexOf("\n\r")) > -1) {
parseMessage(QString(message.left(pos+2)));
message = message.mid(pos+2);
}
}
bool
HeapSnapshot::init(const uint8_t* buffer, uint32_t size)
{
if (!nodes.init() || !frames.init() || !strings.init())
return false;
ArrayInputStream stream(buffer, size);
GzipInputStream gzipStream(&stream);
// First is the metadata.
protobuf::Metadata metadata;
if (!parseMessage(gzipStream, metadata))
return false;
if (metadata.has_timestamp())
timestamp.emplace(metadata.timestamp());
// Next is the root node.
protobuf::Node root;
if (!parseMessage(gzipStream, root))
return false;
// Although the id is optional in the protobuf format for future proofing, we
// can't currently do anything without it.
if (NS_WARN_IF(!root.has_id()))
return false;
rootId = root.id();
if (NS_WARN_IF(!saveNode(root)))
return false;
// Finally, the rest of the nodes in the core dump.
while (StreamHasData(gzipStream)) {
protobuf::Node node;
if (!parseMessage(gzipStream, node))
return false;
if (NS_WARN_IF(!saveNode(node)))
return false;
}
return true;
}
void ServerClient::parser()
{
while(m_running)
{
Packet packet;
packet.read(m_socket);
if(packet.isValid())
{
NetworkHeader header = (NetworkHeader)packet.get<uint8_t>();
switch(header)
{
case NetworkHeader::Login:
parseConnect(packet);
break;
case NetworkHeader::Logout:
parseDisconnect(packet);
break;
case NetworkHeader::Message:
parseMessage(packet);
break;
case NetworkHeader::AddChatMessage:
parseAddChatMessage(packet);
break;
case NetworkHeader::MoveCreature:
parseMoveCreature(packet);
break;
case NetworkHeader::TurnCreature:
parseTurnCreature(packet);
break;
case NetworkHeader::AddObject:
parseAddObject(packet);
break;
default:
g_logger->write(LogLevel::Information, "[ServerClient::parser] Received a packet with unknown header (%X)", header);
break;
}
}
else
{
g_logger->write(LogLevel::Information, "[ServerClient::parser] Client disconnected");
break;
}
sf::sleep(sf::milliseconds(10));
}
m_socket->disconnect();
}
int handleRegisterMessages(blist messages, cli *client){
int i = -1;
if (messages){
for(i = 0; (i < messages->qty) && !(client->nick && client->user); i++){
msg *parsedMessage = parseMessage(messages->entry[i]);
dispatchRegister(parsedMessage, client);
}
}
return i;
}
void TeenAgentEngine::displayCutsceneMessage(uint16 addr, uint16 position) {
SceneEvent event(SceneEvent::kCreditsMessage);
event.message = parseMessage(addr);
event.dst.x = position % 320;
event.dst.y = position / 320;
event.lan = 7;
scene->push(event);
}
void TeenAgentEngine::displayAsyncMessageInSlot(uint16 addr, byte slot, uint16 first_frame, uint16 last_frame, byte color) {
SceneEvent event(SceneEvent::kMessage);
event.message = parseMessage(addr);
event.slot = slot + 1;
event.color = color;
event.first_frame = first_frame;
event.last_frame = last_frame;
scene->push(event);
}
void handleMessages (blist messageList, cli *client){
msg *parsed;
bstring *enteries = messageList->entry;
int len = messageList->qty;
int i;
for(i = 0; i < len; i++){
parsed = parseMessage(enteries[i]);
dispatchUser(parsed, client);
}
}
/*
* Constructor. Used to reassemble object from Byte stream.
* pMessage : Byte-Array containing the fields of the subMessage
* iLength : Length of the said array
*/
CADCInfoMessage::CADCInfoMessage(alt_u8 *pMessage, int iLength)
{
parseHeader(pMessage, iLength);
if(m_bValid)
{
m_bValid = false;
parseMessage(pMessage+4, iLength-4);
}
}
void YSE::CHANNEL::implementationObject::sync() {
if (head.load() == nullptr) {
objectStatus = OBJECT_RELEASE;
return;
}
messageObject message;
while (messages.try_pop(message)) {
parseMessage(message);
}
}
/*
* Server listens and waits for messages from clients.
*/
int waitForMessage(void) {
int sockfd, newsockfd, portno;
socklen_t clilen;
struct sockaddr_in serv_addr, cli_addr;
/* Create a new socket */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
fprintf(stderr,"Error: failed to open socket\n");
return -1;
}
/* Initialize server address structure */
bzero((char *) &serv_addr, sizeof(serv_addr));
portno = SERVERPORT;
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno); /* convert port number to network byte order */
/* Attempt to bind the socket to the host address */
if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
fprintf(stderr,"Error: failed to bind\n");
return -1;
}
/* handle at most 5 connections */
listen(sockfd, 5);
clilen = sizeof(cli_addr);
while (1) {
/* Block until a client connects */
newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0) {
fprintf(stderr,"Error: failed to accept\n");
return -1;
}
/* Create process to handle client message */
int pid = fork();
if (pid < 0) {
fprintf(stderr,"Error: failed to fork\n");
}
if (pid == 0) {
close(sockfd);
/* Parse message from client */
parseMessage(newsockfd);
exit(0);
}
else {
close(newsockfd);
}
}
close(sockfd);
return 1;
}
GraspitProtobufConnection::GraspitProtobufConnection(QObject *parent, QTcpSocket *socket,
unsigned int maximum_len) :
QObject(parent),
sock(socket),
maxLen(maximum_len),
rereadLatency(100)
{
sock->setReadBufferSize(maxLen);
connect(sock, SIGNAL(readyRead()),this,SLOT(parseMessage()));
msg = new GraspitProtobufMessage;
}
bool YSE::SYNTH::implementationObject::sync() {
if (head == nullptr) {
return false;
}
messageObject message;
while (messages.try_pop(message)) {
parseMessage(message);
}
return true;
}
string TgTypeParser::parseUpdate(const Update::Ptr& object) const {
if (!object) {
return "";
}
string result;
result += '{';
appendToJson(result, "update_id", object->updateId);
appendToJson(result, "message", parseMessage(object->message));
result.erase(result.length() - 1);
result += '}';
return result;
}
void TeenAgentEngine::displayAsyncMessage(uint16 addr, uint16 position, uint16 first_frame, uint16 last_frame, byte color) {
SceneEvent event(SceneEvent::kMessage);
event.message = parseMessage(addr);
event.slot = 0;
event.color = color;
event.dst.x = position % 320;
event.dst.y = position / 320;
event.first_frame = first_frame;
event.last_frame = last_frame;
scene->push(event);
}
