/*

* Copyright (c) 2013 - present Adobe Systems Incorporated. All rights reserved.

*

* Permission is hereby granted, free of charge, to any person obtaining a

* copy of this software and associated documentation files (the "Software"),

* to deal in the Software without restriction, including without limitation

* the rights to use, copy, modify, merge, publish, distribute, sublicense,

* and/or sell copies of the Software, and to permit persons to whom the

* Software is furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

* DEALINGS IN THE SOFTWARE.

*

*/

#include "appshell_node_process.h"

#include "appshell_node_process_internal.h"

#include <sstream>

#include <vector>

#include <cstdio>

static std::string buffer("");

static int commandCount = 0;

// Processes a single command from the node process. May call

// platform-specific functions in order to do this. Any platform-specific

// functions must be declared in a file used on all platforms and then

// implemented on all platforms. Because this is not the main communication

// channel with the client, the protocol is left very simple. Individual

// messages are separated by two newlines. Arguments in a message are

// separated by "|" characters. The first argument is the command name, and

// the remaining arguments are dependent on the command.

//

// The number of total commands is expected to be very small. Right now,

// the only commands are "ping" (a keep-alive command) and "port", which

// records the port number that the node websocket server is currently using.

void processCommand (const std::string &command) {

std::vector<std::string> args;

std::size_t start, end;

std::ostringstream responseStream("");

std::string response("");

// parse arguments

start = 0;

end = command.find("|", start);

while (end != std::string::npos) {

args.push_back(command.substr(start, end-start));

start = end + 1;

end = command.find("|", start);

}

args.push_back(command.substr(start));

if (args.size() > 1) {

if (args[1] == "ping") {

responseStream << "\n\n" << (commandCount++) << "|pong|" << args[0] << "\n\n";

} else if (args[1] == "port" && args.size() > 2) {

int port = 0;

std::istringstream(args[2]) >> port;

setNodeState(port);

}

}

response = responseStream.str();

if (response.size() > 0) {

sendData(response);

}

}

// Called any time the command buffer is modified. Parses the entire buffer,

// removing any full commands. Calls processCommand on each full command.

void parseCommandBuffer() {

std::size_t i;

std::string command("");

i = buffer.find("\n\n");

while (i != std::string::npos) {

if (i > 0) {

// every command is prefixed *and* suffixed with "\n\n", so half the time

// we'll get an empty "command"

command = buffer.substr(0, i);

processCommand(command);

}

// Always erase up to and including the newlines we found, even if it was an

// empty command.

buffer.erase(0, i+2);

// Find again

i = buffer.find("\n\n");

}

}

// Adds incoming data to the command buffer and then initiates parsing.

void processIncomingData(const std::string &data) {

if (buffer.max_size() < buffer.size() + data.size()) {

// If we don't have room to store this data, that means that we have a

// buffer that has 4 GB of data without any command separators.

// This indicates that we don't have a command in the buffer, so we can just

// throw it all out and start over. (This shouldn't ever happen.)

fprintf(stderr, "Buffer for node stdout exceeded max size (4GB), clearing buffer.");

buffer = "";

}

buffer += data;

parseCommandBuffer();

}