int Logic::process(void) {
if (!m_operationPermitted)
return CYNARA_API_OPERATION_NOT_ALLOWED;
bool completed;
while (true) {
int ret = completeConnection(completed);
if (!completed)
return ret;
if (processOut() && processIn())
return CYNARA_API_SUCCESS;
onDisconnected();
if (!connect())
return CYNARA_API_SERVICE_NOT_AVAILABLE;
}
}
/**
* @brief Implementation of internal transition DEVS
* function
*/
void internalTransition(vd::Time t) override
{
processOut(t, INTERNAL);
updateGuards(t, INTERNAL);
switch (devs_state) {
case INIT:
devs_state = COMPUTE;
break;
case COMPUTE:
devs_state = OUTPUT;
break;
case OUTPUT:
devs_state = COMPUTE;
break;
default:
throw vu::InternalError("default 2");
}
processIn(t, INTERNAL);
}
void confluentTransitions(vd::Time t,
const vd::ExternalEventList& ext) override
{
processOut(t, CONFLUENT);
handleExtEvt(t, ext);
updateGuards(t, CONFLUENT);
switch (devs_state) {
case INIT:
devs_state = COMPUTE;
break;
case COMPUTE:
devs_state=OUTPUT;
break;
case OUTPUT:
devs_state = COMPUTE;
break;
default:
throw vu::InternalError("default confluent");
}
processIn(t, CONFLUENT);
}
void externalTransition(const vd::ExternalEventList& event,
vd::Time t) override
{
processOut(t, EXTERNAL);
handleExtEvt(t, event);
updateGuards(t, EXTERNAL);
switch (devs_state) {
case INIT:
throw vu::InternalError("Error 3");
break;
case COMPUTE:
devs_state = COMPUTE;
break;
case OUTPUT:
throw vu::InternalError("Error 4");
break;
default:
throw vu::InternalError("default");
}
processIn(t, EXTERNAL);
}
/************** DEVS functions *****************/
vd::Time init(vd::Time time) override
{
devs_state = INIT;
processIn(time, INTERNAL);
return timeAdvance();
}
void processIn()
{
QByteArray buf = sock->readAll();
if(state == ReadHeader)
{
if(inBuf.size() + buf.size() > MAX_HEADERS_SIZE)
{
inBuf.clear();
respondBadRequest("Request header too large.");
return;
}
inBuf += buf;
// look for double newline
int at = -1;
int next;
for(int n = 0; n < inBuf.size(); ++n)
{
if(n + 1 < inBuf.size() && qstrncmp(inBuf.data() + n, "\n\n", 2) == 0)
{
at = n + 1;
next = n + 2;
break;
}
else if(n + 2 < inBuf.size() && qstrncmp(inBuf.data() + n, "\n\r\n", 3) == 0)
{
at = n + 1;
next = n + 3;
break;
}
}
if(at != -1)
{
QByteArray headerData = inBuf.mid(0, at);
reqBody = inBuf.mid(next);
inBuf.clear();
if(!processHeaderData(headerData))
{
respondBadRequest("Failed to parse request header.");
return;
}
bool methodAssumesBody = (method != "HEAD" && method != "GET" && method != "DELETE");
if(!reqHeaders.contains("Content-Length") && (reqHeaders.contains("Transfer-Encoding") || methodAssumesBody))
{
respondLengthRequired("Request requires Content-Length.");
return;
}
if(reqHeaders.contains("Content-Length"))
{
bool ok;
contentLength = reqHeaders.get("Content-Length").toInt(&ok);
if(!ok)
{
respondBadRequest("Bad Content-Length.");
return;
}
if(contentLength > MAX_BODY_SIZE)
{
respondBadRequest("Request body too large.");
return;
}
if(reqHeaders.get("Expect") == "100-continue")
{
QByteArray respData = "HTTP/";
if(version1dot0)
respData += "1.0 ";
else
respData += "1.1 ";
respData += "100 Continue\r\n\r\n";
pendingWritten += respData.size();
sock->write(respData);
}
state = ReadBody;
processIn();
}
else
{
state = WriteBody;
emit ready();
}
}
}
else if(state == ReadBody)
{
reqBody += buf;
if(reqBody.size() > contentLength)
{
respondBadRequest("Request body exceeded Content-Length.");
return;
}
if(reqBody.size() == contentLength)
{
state = WriteBody;
emit ready();
}
}
}
