status_t
MainLoop()
{
do {
ssize_t size = port_buffer_size(gRequestPort);
if (size < B_OK)
return 0;
void* buffer = malloc(size);
if (buffer == NULL)
return B_NO_MEMORY;
int32 code;
size = read_port(gRequestPort, &code, buffer, size);
if (size < B_OK) {
free(buffer);
return 0;
}
status_t result = ParseRequest(code, buffer);
free(buffer);
if (result != B_OK)
return 0;
} while (true);
}
unsigned __stdcall ClientThread(void *pVoid)
{
int nRet;
BYTE buf[1024];
LPREQUEST lpReq = (LPREQUEST)pVoid;
//
// Count this client
//
IncrementClientCount();
//
// Recv the request data
//
if (!RecvRequest(lpReq, buf, sizeof(buf)))
{
CloseConnection(lpReq);
free(lpReq);
DecrementClientCount();
return 0;
}
//
// Parse the request info
//
nRet = ParseRequest(lpReq, buf);
if (nRet)
{
SendError(lpReq, nRet);
CloseConnection(lpReq);
free(lpReq);
DecrementClientCount();
return 0;
}
//
// Send the file to the client
//
SendFile(lpReq);
//
// Clean up
CloseConnection(lpReq);
free(pVoid);
//
// Subtract this client
//
DecrementClientCount();
return 0;
}
/*****************************************************************************
* Run: main thread
*****************************************************************************/
static void *Run( void *data )
{
services_discovery_t *p_sd = data;
services_discovery_sys_t *p_sys = p_sd->p_sys;
vlc_mutex_lock( &p_sys->lock );
mutex_cleanup_push( &p_sys->lock );
for( ;; )
{
while( !p_sys->b_update )
vlc_cond_wait( &p_sys->wait, &p_sys->lock );
int canc = vlc_savecancel ();
msg_Dbg( p_sd, "Update required" );
if( p_sys->update_type == UPDATE_URLS )
{
char* psz_urls = var_GetNonEmptyString( p_sd, "podcast-urls" );
ParseUrls( p_sd, psz_urls );
free( psz_urls );
}
else if( p_sys->update_type == UPDATE_REQUEST )
{
ParseRequest( p_sd );
}
p_sys->b_update = false;
for( int i = 0; i < p_sd->p_sys->i_input; i++ )
{
input_thread_t *p_input = p_sd->p_sys->pp_input[i];
if( p_input->b_eof || p_input->b_error )
{
input_Stop( p_input, false );
vlc_thread_join( p_input );
vlc_object_release( p_input );
p_sd->p_sys->pp_input[i] = NULL;
REMOVE_ELEM( p_sys->pp_input, p_sys->i_input, i );
i--;
}
}
vlc_restorecancel (canc);
}
vlc_cleanup_pop();
assert(0); /* dead code */
}
/*****************************************************************************
* Run: main thread
*****************************************************************************/
VLC_NORETURN
static void *Run( void *data )
{
services_discovery_t *p_sd = data;
services_discovery_sys_t *p_sys = p_sd->p_sys;
vlc_mutex_lock( &p_sys->lock );
mutex_cleanup_push( &p_sys->lock );
for( ;; )
{
while( !p_sys->b_update )
vlc_cond_wait( &p_sys->wait, &p_sys->lock );
int canc = vlc_savecancel ();
msg_Dbg( p_sd, "Update required" );
if( p_sys->update_type == UPDATE_URLS )
{
char *psz_urls = var_GetNonEmptyString( p_sd->p_parent,
"podcast-urls" );
ParseUrls( p_sd, psz_urls );
free( psz_urls );
}
else if( p_sys->update_type == UPDATE_REQUEST )
ParseRequest( p_sd );
p_sys->b_update = false;
for( int i = 0; i < p_sd->p_sys->i_input; i++ )
{
input_thread_t *p_input = p_sd->p_sys->pp_input[i];
int state = var_GetInteger( p_input, "state" );
if( state == END_S || state == ERROR_S )
{
input_Stop( p_input );
input_Close( p_input );
p_sd->p_sys->pp_input[i] = NULL;
REMOVE_ELEM( p_sys->pp_input, p_sys->i_input, i );
i--;
}
}
vlc_restorecancel (canc);
}
vlc_cleanup_pop();
vlc_assert_unreachable(); /* dead code */
}
/*
** Searches for HTTP Request Line before going into transparent mode
*/
PRIVATE int HTTPReceive_put_block (HTStream * me, const char * b, int l)
{
if (!me->transparent) {
const char *p=b;
while (l>0 && *p!=CR && *p!=LF) l--, p++;
HTChunk_putb(me->buffer, b, p-b);
if (*p==CR || *p==LF) {
int status = ParseRequest(me);
HTChunk_clear(me->buffer);
if (status != HT_OK) return status;
me->transparent = YES;
b=p;
}
}
if (l > 0) {
int status = PUTBLOCK(b, l);
if (status == HT_LOADED) me->transparent = NO;
return status;
}
return HT_OK;
}
std::string HandleRequest(const std::string& request_json)
{
try
{
static const std::string OK = ""; // TODO maybe improve this use the same variable defined by "HardwareCmd".
HWRequest hw_req = ParseRequest(request_json);
LOG_TRACE(L"执行硬件调用请求:" + str_2_wstr("[" + hw_req.cmd + "," +hw_req.file_id + "," + hw_req.seq + "]"));
HardwareCmd::Reply reply = m_hw_cmd_map.at(hw_req.cmd + hw_req.file_id).Execute(hw_req.data);
std::string answer = "";
if (boost::iequals(OK, reply.error_code)) // Succeed.
answer = hw_req.cmd + "_ack";
else
answer = hw_req.cmd + "_failed";
std::string reply_json = MakeResultJSON(answer, hw_req.file_id, reply.error_code, hw_req.seq, reply.data);
LOG_TRACE(L"执行硬件调用结果:" + str_2_wstr("[" + hw_req.cmd + "," + hw_req.file_id + "," + hw_req.seq + "] [" + reply.error_code + "]") + +L"\n");
return reply_json;
}
catch (std::exception& ex)
{
LOG_FATAL(L"执行硬件调用请求发生异常，异常信息： " + str_2_wstr(ex.what()) + L"\n");
return "";
}
}
// 接收请求
bool CTyHttpSvr::RecvRequest()
{
if (GetReservedBufSize(CTySocket::typeWrite) < 1024*100)
SetReservedBufSize(CTySocket::typeWrite, 1024*100);
char *pszRequest = new char[1024*10];
char *pCurrent = pszRequest;
while(!IsClosed())
{
// 每次只接收1字节
if (1 == Select_Receive(pCurrent, 1))
{
++pCurrent;
// 接完4个字节后,可判断是否已全接完
if((pCurrent>pszRequest+4) && (memcmp(pCurrent-4, "\r\n\r\n", 4)==0))
break;
}
}
ParseRequest(pszRequest);
if (m_mapRequestKeyValue["RequestType"] == "POST")
{
m_mapRequestKeyValue["RequestUrl"] += "?";
int nRecvLen = Select_Receive(pszRequest, 1024);
if (nRecvLen > 0)
{
pszRequest[nRecvLen] = '\0';
m_mapRequestKeyValue["RequestUrl"] += pszRequest;
}
}
delete [] pszRequest;
return true;
}
WebRequest* FeatureImportHandler::ParseRequest(rude::CGI& cgi, const char* mapName)
{
return ParseRequest(cgi);
}
void Traite(CLIENT *client)
{
char PlcName[30];
char TagName[50];
char writevalue[20];
char requete[MAXBUFFERSIZE];
memset(PlcName,0,sizeof(PlcName));
memset(TagName,0,sizeof(TagName));
memset(writevalue,0,sizeof(writevalue));
memset(requete,0,sizeof(requete));
memcpy(requete,client->InBuffer.data,client->InBuffer.size);
Log(LOG_DEBUG,"Entering Traite for %p (%s)[%i]\n",client,requete,client->InBuffer.size);
if (ParseRequest(PlcName,TagName,writevalue,requete)== SUCCESS)
{
Log(LOG_DEBUG,"Traite for %s@%s=%s \n", TagName, PlcName, writevalue);
if(strncasecmp(PlcName,"@",1)==0)
{
Affiche(client->FD,TagName);
client->InBuffer.size=0;
return;
}
PLC *plc=FindPLC(PlcName,&PLCs);
if (plc!=NULL)
{
TAG *tag=FindTag(TagName,PlcName,&TAGs);
if (tag!=NULL)
{ /* Tag exist */
Log(LOG_DEBUG,"\t=Tag %s already exist (%p)\n",TagName,tag);
} else
{
tag=malloc(sizeof(TAG));
if (tag!=NULL)
{
Log(LOG_DEBUG,"\t+Creating Tag %s (%p) on %s\n",TagName,tag,plc->PlcName);
memset(tag,0,sizeof(TAG));
strncpy(tag->TagName,TagName,strlen(TagName));
tag->Plc=plc;
plc->References++;
AddChListe(&TAGs,tag);
} else
{
Log(LOG_CRIT, "Erreur à l'ajout du tag (%s)\n",strerror(errno));
return;
}
}
if ((time(NULL)-tag->Time_Value)<UPDATE_RATE)
{
Log(LOG_DEBUG,"\t=Reading buffered value for Tag %s\n",TagName);
Reply(client->FD,"[%s]%s=%f\n",plc->PlcName,TagName,tag->Value);
} else
{
if (ReadTag(tag)>0) Reply(client->FD,"[%s]%s=%f\n",plc->PlcName,TagName,tag->Value);
else Reply(client->FD,"[%s]%s=Erreur\n",plc->PlcName,TagName);
}
//Reply(client->FD,"TuxReader : %s (Path : %s) Tag : %s\n",plc->PlcName,plc->PlcPath,TagName);
} else
{
Reply(client->FD,"[%s]%s=PLC not found in Config file\n",plc->PlcName,TagName);
/* Test Gardian
int *a=(int*)(NULL);
*a=10;*/
}
} else
{
Reply(client->FD,"%s=Request error\n",client->InBuffer.data);
}
client->InBuffer.size=0;
}
WebRequest* SaveMapHandler::ParseRequest(rude::CGI& cgi, const char* mapName)
{
return ParseRequest(cgi);
}
int main()
{
char **postvars = NULL; /* POST request data repository */
char **getvars = NULL; /* GET request data repository */
int form_method; /* POST = 1, GET = 0 */
s_info *info = &sinfo;
form_method = getRequestMethod();
if (form_method == POST) {
getvars = getGETvars();
postvars = getPOSTvars();
} else if (form_method == GET) {
getvars = getGETvars();
}
MakeSessionFiles(info);
ParseRequest(form_method, getvars, postvars, info);
CheckRequest(form_method, getvars, postvars, info);
switch (info->run) {
case ACQUIRE:
AllocateMemory(form_method, getvars, postvars, info);
MakeFileInit(info, form_method, getvars, postvars);
MakeFileSamples(form_method, getvars, postvars, info);
free(info->samples);
system(info->pGNUPLOT);
DoHTML(info, form_method, getvars, postvars);
break;
case REPLOT:
MakeFileInit(info, form_method, getvars, postvars);
system(info->pGNUPLOT);
DoHTML(info, form_method, getvars, postvars);
break;
case START_SERVER:
stop_server(form_method, getvars, postvars, info);
DoHTML(info, form_method, getvars, postvars);
AllocateMemory(form_method, getvars, postvars, info);
MakeFileSamples(form_method, getvars, postvars, info);
free(info->samples);
start_server(form_method, getvars, postvars, info);
break;
case STOP_SERVER:
DoHTML(info, form_method, getvars, postvars);
stop_server(form_method, getvars, postvars, info);
break;
case MULTIMETER:
break;
case SHOWSAMPLES:
break;
case GNUPLOT_FILES:
DoHTML(info, form_method, getvars, postvars);
break;
default:
break;
}
cleanUp(form_method, getvars, postvars);
CleanupSessionFiles(info);
exit(0);
}
void Platform::DoRequest(int clientSock)
{
Request request = ParseRequest(clientSock);
}
WebRequest* AddRasterHandler::ParseRequest(rude::CGI& cgi,const char* mapName)
{
return ParseRequest(cgi);
}
//--------------------------------------------------------------------------------
// ParseInput
//--------------------------------------------------------------------------------
void TIASServer::ParseInput()
{
UByte ctrlByte;
Boolean lastFrame;
Boolean ackedFrame;
UByte iasReturnCode;
TIASAttribute* iasEntry = nil;
// An operation frame has been received - parse it and decide what to do with it
fGetPutBuffer->Seek(0, kPosBeg);
ctrlByte = fGetPutBuffer->Get();
lastFrame = ctrlByte & kIASFrameLstBit;
ackedFrame = ctrlByte & kIASFrameAckBit;
XTRACE(kParseInputEvent, ctrlByte, fReceiveState);
switch(fReceiveState) {
case kIASServerReceiveStart:
if (ackedFrame) {
// Must be an ack from my previous response (or some other bogus data)
// Keep looking
}
else {
fOpCode = ctrlByte & kIASFrameOpCodeMask;
if (lastFrame) {
if (fOpCode == kIASOpGetValueByClass) {
iasEntry = ParseRequest(iasReturnCode);
}
else {
iasEntry = nil;
iasReturnCode = kIASRetUnsupported;
}
}
else {
fReceiveState = kIASServerReceiveWaitFinal;
}
}
break;
case kIASServerReceiveWaitFinal:
// I didn't accept the request, so all I want to do is get the
// final frame of the request so I can reject it.
XASSERT(!ackedFrame);
if (lastFrame) {
// I don't really care if they sent an ack w/final, so ignore it
ackedFrame = false;
// Return no such class for too large get value by class requests
// Return unsupported for all other requests
iasEntry = nil;
iasReturnCode = fOpCode == kIASOpGetValueByClass ? kIASRetNoSuchClass : kIASRetUnsupported;
}
break;
default:
break;
}
// Either respond to the current request or continue accepting more of the request
if (lastFrame && !ackedFrame) {
// Reply to the request
SendResponse(iasReturnCode, iasEntry);
// Reset the receive state
fOpCode = kIASOpUnassigned;
fReceiveState = kIASServerReceiveStart;
}
else if (fReceiveState == kIASServerReceiveWaitFinal) {
// Ack the frame I don't want/care about
fGetPutBuffer->Seek(0, kPosBeg);
fGetPutBuffer->Put(fOpCode | kIASFrameAckBit);
PutStart();
}
else {
// Post another get
GetStart();
}
} // TIASServer::ParseInput
WebRequest* CreateServiceHandler::ParseRequest(rude::CGI& cgi, const char* mapName)
{
return ParseRequest(cgi);
}
WebRequest* WProcessEngine::ParseRequest(rude::CGI& cgi, const char* mapName)
{
return ParseRequest(cgi);
}
WebRequest* GetPreviewHandler::ParseRequest(rude::CGI& cgi,const char* mapName)
{
return ParseRequest(cgi);
}
