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