/*----------------------------------------------------------------------
| PLT_ThreadTask::Run
+---------------------------------------------------------------------*/
void
PLT_ThreadTask::Run()
{
// NPT_TimeStamp now;
// NPT_System::GetCurrentTimeStamp(now);
// NPT_System::SetRandomSeed(now.m_NanoSeconds);
if (m_Delay) {
NPT_TimeStamp start, now;
NPT_System::GetCurrentTimeStamp(start);
do {
NPT_System::GetCurrentTimeStamp(now);
if (now >= start + m_Delay) break;
} while(!IsAborting(100));
}
if (!IsAborting(0)) {
DoInit();
DoRun();
}
if (m_TaskManager) {
m_TaskManager->RemoveTask(this);
}
}
/*----------------------------------------------------------------------
| PLT_SsdpDeviceAnnounceUnicastTask::DoRun
+---------------------------------------------------------------------*/
void
PLT_SsdpDeviceAnnounceTask::DoRun()
{
NPT_Result res = NPT_SUCCESS;
NPT_List<NPT_NetworkInterface*> if_list;
while (1) {
NPT_CHECK_LABEL_FATAL(PLT_UPnPMessageHelper::GetNetworkInterfaces(if_list, true),
cleanup);
// if we're announcing our arrival, sends a byebye first (NMPR compliance)
if (m_IsByeByeFirst == true) {
m_IsByeByeFirst = false;
res = if_list.Apply(PLT_SsdpAnnounceInterfaceIterator(m_Device, true, m_IsBroadcast));
if (NPT_FAILED(res)) goto cleanup;
// schedule to announce alive in 300 ms
if (NPT_FAILED(res) || IsAborting((NPT_Timeout)300)) break;
}
res = if_list.Apply(PLT_SsdpAnnounceInterfaceIterator(m_Device, false, m_IsBroadcast));
cleanup:
if_list.Apply(NPT_ObjectDeleter<NPT_NetworkInterface>());
if_list.Clear();
if (NPT_FAILED(res) || IsAborting(m_Repeat.m_Seconds*1000)) break;
};
}
/*----------------------------------------------------------------------
| PLT_CtrlPointHouseKeepingTask::DoRun
+---------------------------------------------------------------------*/
void
PLT_CtrlPointHouseKeepingTask::DoRun()
{
while (!IsAborting(m_Timer.m_Seconds*1000)) {
if (m_CtrlPoint) {
m_CtrlPoint->DoHouseKeeping();
}
}
}
/*----------------------------------------------------------------------
| PLT_HttpServerSocketTask::DoRun
+---------------------------------------------------------------------*/
void
PLT_HttpServerSocketTask::DoRun()
{
NPT_BufferedInputStreamReference buffered_input_stream;
NPT_HttpRequestContext context;
NPT_Result res = NPT_SUCCESS;
bool headers_only;
bool keep_alive = false;
// create a buffered input stream to parse HTTP request
NPT_InputStreamReference input_stream;
NPT_CHECK_LABEL_SEVERE(GetInputStream(input_stream), done);
NPT_CHECK_POINTER_LABEL_FATAL(input_stream.AsPointer(), done);
buffered_input_stream = new NPT_BufferedInputStream(input_stream);
while (!IsAborting(0)) {
NPT_HttpRequest* request = NULL;
NPT_HttpResponse* response = NULL;
// reset keep-alive to exit task on read failure
keep_alive = false;
// wait for a request
res = Read(buffered_input_stream, request, &context);
if (NPT_FAILED(res) || (request == NULL))
goto cleanup;
// process request and setup response
res = RespondToClient(*request, context, response);
if (NPT_FAILED(res) || (response == NULL))
goto cleanup;
// check if client requested keep-alive
keep_alive = PLT_HttpHelper::IsConnectionKeepAlive(*request);
headers_only = request->GetMethod() == NPT_HTTP_METHOD_HEAD;
// send response, pass keep-alive request from client
// (it can be overridden if response handler did not allow it)
res = Write(response, keep_alive, headers_only);
// on write error, reset keep_alive so we can close this connection
if (NPT_FAILED(res)) keep_alive = false;
cleanup:
// cleanup
delete request;
delete response;
if (!keep_alive && !m_StayAliveForever) {
return;
}
}
done:
return;
}
/*----------------------------------------------------------------------
| PLT_SsdpDeviceAnnounceUnicastTask::DoRun
+---------------------------------------------------------------------*/
void
PLT_SsdpDeviceAnnounceTask::DoRun()
{
NPT_List<NPT_NetworkInterface*> if_list;
while (1) {
NPT_CHECK_LABEL_FATAL(PLT_UPnPMessageHelper::GetNetworkInterfaces(if_list, false),
cleanup);
// if we're announcing our arrival, sends a byebye first (NMPR compliance)
if (m_IsByeByeFirst == true) {
m_IsByeByeFirst = false;
if (m_ExtraBroadcast) {
if_list.Apply(PLT_SsdpAnnounceInterfaceIterator(m_Device, true, m_ExtraBroadcast));
}
// multicast now
if_list.Apply(PLT_SsdpAnnounceInterfaceIterator(m_Device, true, false));
// schedule to announce alive in 200 ms
if (IsAborting(200)) break;
}
if (m_ExtraBroadcast) {
if_list.Apply(PLT_SsdpAnnounceInterfaceIterator(m_Device, false, m_ExtraBroadcast));
}
// multicast now
if_list.Apply(PLT_SsdpAnnounceInterfaceIterator(m_Device, false, false));
cleanup:
if_list.Apply(NPT_ObjectDeleter<NPT_NetworkInterface>());
if_list.Clear();
if (IsAborting((NPT_Timeout)m_Repeat.ToMillis())) break;
};
}
void CThreadTask::Run()
{
m_Started.SetValue(1);
if ((float)m_Delay > 0.f)
{
// more than 100ms, loop so we can abort it
if ((float)m_Delay > 0.1f)
{
TimeStamp start, now, stamp;
HelperSystem::GetCurrentTimeStamp(start);
do
{
HelperSystem::GetCurrentTimeStamp(now);
stamp = start + m_Delay;
if (now >= stamp) break;
} while (!IsAborting(100));
}
else
{
HelperSystem::Sleep(m_Delay);
}
}
// loop
if (!IsAborting(0))
{
DoInit();
DoRun();
}
if (m_Manager)
m_Manager->RemoveTask(this);
else if (m_AutoDestroy)
delete this;
}
bool MsgConnection::SendRequest(MsgPacket* request) {
if(IsAborting()) {
return false;
}
// restore connection if needed
if(GetConnectionLost() && !Reconnect()) {
return false;
}
if(!request->write(m_socket, m_timeout)) {
SetConnectionLost();
return false;
}
return true;
}
bool MsgConnection::ReadResponse(MsgPacket* p) {
if(IsAborting()) {
return false;
}
// restore connection if needed
if(GetConnectionLost() && !Reconnect()) {
return false;
}
bool bClosed = false;
bool rc = MsgPacket::read(m_socket, bClosed, p, m_timeout);
if(bClosed) {
SetConnectionLost();
return false;
}
return rc;
}
/*----------------------------------------------------------------------
| PLT_HttpListenTask::DoRun
+---------------------------------------------------------------------*/
void
PLT_HttpListenTask::DoRun()
{
while (!IsAborting(0)) {
NPT_Socket* client = NULL;
NPT_Result result = m_Socket->WaitForNewClient(client, 5000, NPT_SOCKET_FLAG_CANCELLABLE);
if (NPT_FAILED(result)) {
// cleanup just in case
if (client) delete client;
// normal error
if (result == NPT_ERROR_TIMEOUT) continue;
// exit on other errors ?
NPT_LOG_WARNING_2("PLT_HttpListenTask exiting with %d (%s)", result, NPT_ResultText(result));
break;
} else {
PLT_ThreadTask* task = new PLT_HttpServerTask(m_Handler, client);
m_TaskManager->StartTask(task);
}
}
}
/*----------------------------------------------------------------------
| PLT_HttpServerSocketTask::DoRun
+---------------------------------------------------------------------*/
void
PLT_SsdpSearchTask::DoRun()
{
NPT_HttpResponse* response = NULL;
PLT_HttpClient client;
NPT_Timeout timeout = 30;
NPT_HttpRequestContext context;
do {
// get the address of the server
NPT_IpAddress server_address;
NPT_CHECK_LABEL_SEVERE(server_address.ResolveName(
m_Request->GetUrl().GetHost(),
timeout),
done);
NPT_SocketAddress address(server_address,
m_Request->GetUrl().GetPort());
// send 2 requests in a row
NPT_OutputStreamReference output_stream(
new PLT_OutputDatagramStream(m_Socket,
4096,
&address));
NPT_CHECK_LABEL_SEVERE(client.SendRequest(
output_stream,
*m_Request),
done);
NPT_CHECK_LABEL_SEVERE(client.SendRequest(
output_stream,
*m_Request),
done);
output_stream = NULL;
// keep track of when we sent the request
NPT_TimeStamp last_send;
NPT_System::GetCurrentTimeStamp(last_send);
while (!IsAborting(0)) {
// read response
PLT_InputDatagramStreamReference input_stream(
new PLT_InputDatagramStream(m_Socket));
NPT_InputStreamReference stream = input_stream;
NPT_Result res = client.WaitForResponse(stream,
*m_Request,
context,
response);
// callback to process response
if (NPT_SUCCEEDED(res)) {
// get source info
NPT_SocketInfo info;
input_stream->GetInfo(info);
context.SetLocalAddress(info.local_address);
context.SetRemoteAddress(info.remote_address);
// process response
ProcessResponse(NPT_SUCCESS, m_Request, context, response);
delete response;
response = NULL;
} else if (res != NPT_ERROR_TIMEOUT) {
NPT_LOG_WARNING_1("PLT_SsdpSearchTask got an error (%d) waiting for response", res);
}
input_stream = NULL;
// check if it's time to resend request
NPT_TimeStamp now;
NPT_System::GetCurrentTimeStamp(now);
if (now >= last_send + (long)m_Timeout/1000)
break;
}
} while (!IsAborting(0) && m_Repeat);
done:
return;
}
