/*
* @brief Handle a request for a child device.
* @param header the incoming_header
* @param param_data The param_data
* @param child_index The child device index.
*/
static int HandleChildRequest(const RDMHeader *header,
const uint8_t *param_data,
unsigned int child_index) {
if (header->command_class == DISCOVERY_COMMAND) {
// Always pass discovery commands through to the child.
return HandleRequest(header, param_data);
}
ChildDevice *device = &g_children[child_index];
// If GET QUEUED_MESSAGE and there is next or last message, see if we need to
// return it.
int response_size = RDM_RESPONDER_NO_RESPONSE;
if (header->command_class == GET_COMMAND &&
ntohs(header->param_id) == PID_QUEUED_MESSAGE &&
device->free_size_count != PROXY_BUFFERS_PER_CHILD &&
RDMUtil_IsUnicast(header->dest_uid)) {
response_size = MaybeRespondWithQueuedMessage(header, param_data,
child_index);
if (response_size) {
return response_size;
}
}
// If the request is unicast, and we're out of buffer space then NACK.
if (RDMUtil_IsUnicast(header->dest_uid) && device->next != NULL) {
return RDMResponder_BuildNack(header, NR_PROXY_BUFFER_FULL);
}
// Let the child handle the request.
response_size = HandleRequest(header, param_data);
const RDMHeader *response_header = (RDMHeader*) g_rdm_buffer;
// Only queue the frame if the message length is correct
if (response_size >= (int) sizeof(RDMHeader) + (int) RDM_CHECKSUM_LENGTH &&
((int) response_header->message_length + (int) RDM_CHECKSUM_LENGTH ==
response_size)) {
if (device->next == NULL) {
// Queue the response
device->next = device->free_list[device->free_size_count - 1];
device->free_size_count--;
memcpy(device->next->buffer, g_rdm_buffer, response_size);
response_size = RDMResponder_BuildAckTimer(header, ACK_TIMER_DELAY);
g_responder->queued_message_count = 1u;
} else {
// Something has gone wrong, and we don't have space to queue the
// response. Nack with a hardware fault.
return RDMResponder_BuildNack(header, NR_HARDWARE_FAULT);
}
}
return response_size;
}
vector<string>* Session::GetBlacklist(string configId) {
AuthRequest* authRequest = new AuthRequest(consumerKey, consumerSecret, configId, applicationName);
QueryMethod method = GET;
string url = host + "/blacklist." + format;
cout << endl << "url: " << url << endl;
int status = authRequest->authWebRequest(url, method);
vector<string>* result = new vector<string>();
if (status <= 202 && "" != authRequest->GetReceivedData()) {
Stub_Blacklist* stub = new Stub_Blacklist();
if (format == "xml") {
(static_cast<XmlSerializer*>(serializer))->Deserialize(authRequest->GetReceivedData(), stub);
} else {
(static_cast<JsonSerializer*>(serializer))->Deserialize(authRequest->GetReceivedData(), stub);
}
result = stub->GetBlacklistItems();
// @TODO don't forget that items are stored in stub, so if
// we delete items in stub's destructor - all items from result
// will be removed too.
// maybe we should use smart pointer?
delete stub;
}
HandleRequest(method, url, "");
HandleConfigurationResponse(status, authRequest);
delete authRequest;
return result;
}
void WebServer::HandleGetRequest(http_request message)
{
HTTPRequest request(message);
auto service = request.GetArgumentValue("service");
if (wms && service == "WMS")
{
return wms->HandleRequest(request);
}
else if (wmts && service == "WMTS")
{
return wmts->HandleRequest(request);
}
return HandleServiceException(request, "unknown service request");
}
void * StarServer(void * client)
{
http_request * request = CreateRequest();
int client_socket;
client_socket = *(int *)client;
int server_status;
server_status = GetContent(client_socket, request->buf, HTTP_REQUEST_BUF_MAX_LENGTH);
if(server_status)
{
if(server_status==-1)
ReturnError(400,client_socket);
if(server_status==-2)
ReturnError(414,client_socket);
}
else
{
int analysis_status = 0;
analysis_status = AnalysisRequest(request);
if(analysis_status)
ReturnError(analysis_status, client_socket);
else
HandleRequest(client_socket, request);
}
DestroyRequest(request);
close(client_socket);
return NULL;
}
void IrcBot::ReadHandler(const boost::system::error_code &error, std::size_t bytesRead)
{
if (shuttingDown)
{
return;
}
if (!error)
{
messageString = readBuffer.data();
std::cout << std::string(readBuffer.data(), bytesRead);
HandlePing(messageString);
// handle welcome message 001
if (messageString.find(serverWelcomeMessage) == 0)//if (messageString.find(":" + serverName + " 001") == 0)
{
Send(join);
}
HandleRequest(messageString);
if (activeGame != NONE)
{
HandleGameInput(messageString);
}
readBuffer.fill('\0');
sock.async_read_some(buffer(readBuffer), [this](boost::system::error_code ec, std::size_t bytesRead) { ReadHandler(ec, bytesRead); });
}
else
{
ConsoleMessage(error.message());
}
}
//This function will accept and process file Get messages from other peers
void StartQHandler(void)
{
int NewConnSocketNo;
int TempInt1;
int CurrPort = 18200;
CurrPort = qPort + 200;
struct sockaddr_in NewConnSocket;
//Listen for messages on MPrt for ever
printf("----QHandler Started\n");
if(listen(qPortSocket, 10) < 0)
{
printf("--------Node in an Unstable Condition, close the node App by keying Ctrl C---------\n");
exit(0);
//continue;
}
while(1)
{
//Listen for new Connections
TempInt1 = sizeof(NewConnSocket);
if((NewConnSocketNo = accept(qPortSocket, (struct sockaddr *) &NewConnSocket, &TempInt1)) < 0)
{
continue;
}
if((TempInt1 = fork()) == 0)
{
HandleRequest(NewConnSocketNo, NewConnSocket, CurrPort++);
exit(0);
}
}
}
void FileUpload::Execute()
{
if (HasRequest() && mState != eClient_STATE_CONNECTED) // 有上传请求 && 尚未连接
{
TryConnectServer();
}
if (mState == eClient_STATE_CONNECTED) // 已连接上
{
//if (CanSendData())
{
UploadRequest* Req = PopRequest();
if (Req)
{
if (HandleRequest(Req))
{
// Req已放入WaitingList, 暂不回收
}
else
{
AddResponse(*Req, false, "");
delete Req;
}
}
}
if (CanRecvData() && mRecvSize < MAX_RECV_BUFF_SIZE)
{
int Ret = recv(mSocket, &mRecvBuff[mRecvSize], MAX_RECV_BUFF_SIZE - mRecvSize, 0);
if (Ret == SOCKET_ERROR || Ret <= 0)
{
CloseSocket(eClient_STATE_ABORT, true); // TODO: 当服务器send主动关闭时 (应该至少还能recv一次, 没问题)
}
else
{
mRecvSize += Ret;
}
}
}
ServerResponse SrvRep;
if (TryDecodeRecvBuff(SrvRep))
{
auto Itr = mWaitingList.find(SrvRep.mSrvFileName);
if (Itr != mWaitingList.end())
{
auto Req = Itr->second;
if (Req)
{
AddResponse(*Req, SrvRep.mFlag == 0x00A2, SrvRep.mSrvFileName);
delete Req;
}
mWaitingList.erase(Itr);
}
}
WaitFor(1);
}
void SocksConnection::ReadFromSocket()
{
qDebug() << "SOCKS ReadFromSocket in state" << _state;
if(!_socket_open || !_socket->bytesAvailable()) return;
switch(_state) {
case ConnState_WaitingForMethodHeader:
HandleMethodHeader();
break;
case ConnState_WaitingForMethods:
HandleMethods();
break;
case ConnState_WaitingForRequestHeader:
HandleRequestHeader();
break;
case ConnState_WaitingForRequest:
HandleRequest();
break;
case ConnState_Connected:
HandleConnected();
break;
default:
qFatal("Unknown state");
break;
}
}
vector<Category*>* Session::GetCategories(string configId) {
AuthRequest* authRequest = new AuthRequest(consumerKey, consumerSecret, configId, applicationName);
QueryMethod method = GET;
string url = host + "/categories." + format;
cout << endl << "url: " << url << endl;
int status = authRequest->authWebRequest(url, method);
vector<Category*>* result = new vector<Category*>();
if (status <= 202 && "" != authRequest->GetReceivedData()) {
Stub_Categories* stub = new Stub_Categories();
if (format == "xml") {
(static_cast<XmlSerializer*>(serializer))->Deserialize(authRequest->GetReceivedData(), stub);
} else {
(static_cast<JsonSerializer*>(serializer))->Deserialize(authRequest->GetReceivedData(), stub);
}
result = stub->GetCategories();
delete stub;
}
HandleRequest(method, url, "");
HandleConfigurationResponse(status, authRequest);
delete authRequest;
return result;
}
HttpResponse *
EHS::RouteRequest ( HttpRequest * ipoHttpRequest ///< request info for service
)
{
// get the next path from the URI
std::string sNextPathPart = GetNextPathPart ( ipoHttpRequest->sUri );
EHS_TRACE ( "Info: Trying to route: '%s'\n", sNextPathPart.c_str ( ) );
// if there is no more path, call HandleRequest on this EHS object with
// whatever's left - or if we're not routing
if ( sNextPathPart.empty ( ) ||
m_oEHSServerParameters.find ( "norouterequest" ) !=
m_oEHSServerParameters.end ( ) ) {
// create an HttpRespose object for the client
HttpResponse * poHttpResponse =
new HttpResponse ( ipoHttpRequest->m_nRequestId,
ipoHttpRequest->m_poSourceEHSConnection );
// get the actual response and return code
poHttpResponse->m_nResponseCode =
HandleRequest ( ipoHttpRequest, poHttpResponse );
return poHttpResponse;
}
// if the path exists, check it against the map of EHSs
if ( oEHSMap [ sNextPathPart ] ) {
// if it exists, call RouteRequest with that EHS and the
// new shortened path
return oEHSMap [ sNextPathPart ]->RouteRequest ( ipoHttpRequest );
}
// if it doesn't exist, send an error back up saying resource doesn't exist
else {
EHS_TRACE ( "Info: Routing failed. Most likely caused by an invalid URL, not internal error\n" );
// send back a 404 response
HttpResponse * poHttpResponse = new HttpResponse ( ipoHttpRequest->m_nRequestId,
ipoHttpRequest->m_poSourceEHSConnection );
poHttpResponse->m_nResponseCode = HTTPRESPONSECODE_404_NOTFOUND;
poHttpResponse->SetBody ( "404 - Not Found", strlen ( "404 - Not Found" ) );
return poHttpResponse;
}
}
void* BaseWorker::Handle()
{
while (State != ENDED)
{
TakeRequests();
HandleRequest();
}
}
int main(int argc, char *argv[]) {
void *h1 = New(ConcreteHandleA);
void *h2 = New(ConcreteHandleB);
void *h3 = New(ConcreteHandleC);
SetSuccessor(h1, h2);
SetSuccessor(h2, h3);
HandleRequest(h1, 300);
HandleRequest(h1, 600);
HandleRequest(h1, 1500);
HandleRequest(h1, 3000);
Delete(h1);
Delete(h2);
Delete(h3);
return 0;
}
void Server::HandleConnection(int conn_fd) {
Request request(conn_fd);
if (!request.IsOK()) {
WLOG("Bad request, ignoring.");
return;
}
HandleRequest(request);
// TODO: Way to mark the content body as read, read it here if never read.
// This allows the handler to stream if need be.
// TODO: Could handle keep alive here.
request.Write();
}
void HTTP::HandlePacket(Packet& p)
{
String got;
got.assign(p.GetData(), p.GetSize());
LOG(got);
//handle request, close connection after handling
String response = HandleRequest(got);
auto foundIt = m_connections.find(p.GetAddress());
if(foundIt != m_connections.end())
foundIt->second.sock->Send(response.c_str(), response.size());
else
ERR("where did the connection go!?!?");
}
int
realapp ()
{
#ifdef WITH_MYSQL
mysql_library_init(0, NULL, NULL);
#endif
os_mutex_init (&crypt_lock);
os_mutex_init (&getpwnam_lock);
os_mutex_init (&getspnam_lock);
os_mutex_init (&localtime_lock);
os_mutex_init (&writerpipe_lock);
#ifndef _WIN32_
reloadconfig (SIGHUP);
signal (SIGCHLD, kidkiller);
signal (SIGPIPE, ignorer);
signal (SIGQUIT, closeup);
signal (SIGINT, closeup);
#else
reloadconfig (0);
#endif
#ifndef _WIN32_
if (runAsDaemon)
daemonize ();
else if (log_filename) {
int fh = open (log_filename, O_CREAT|O_TRUNC|O_RDWR, 0666);
if (fh == -1) {
fprintf(stderr, "failed to open logfile %s:%s\n", log_filename, strerror(errno));
fh = open ("/dev/null", O_RDWR);
}
close (1);
close (2);
dup2 (fh, 1);
dup2 (fh, 2);
}
#endif
log_log (NULL, LOG_EVT_SERVERSTART, 0, conf);
while (TRUE) {
if (!HandleRequest ()) {
#ifdef WITH_DEBUG
DEBUG_LOG ("Couldn't handle request.");
#endif
}
}
#ifdef WITH_MYSQL
mysql_library_end();
#endif
return EXIT_SUCCESS;
}
void EnumerateSlave (BYTE ThreadID) {
usbslave_ioctl_cb_t iocb;
BYTE SetupBuffer[9];
BYTE Status;
WaitForDevicesStarted();
dprint("\nSlave Openned, SETUP thread (%d) started", &ThreadID);
iocb.ioctl_code = VOS_IOCTL_USBSLAVE_WAIT_SETUP_RCVD;
iocb.request.setup_or_bulk_transfer.buffer = &SetupBuffer[0];
iocb.request.setup_or_bulk_transfer.size = sizeof(SetupBuffer);
while (1) {
Status = i_vos_dev_ioctl(ThreadID, hDevice[Slave], &iocb);
dprint("\nSetup received:", 0);
dprintBuffer(&SetupBuffer[0], sizeof(SetupBuffer));
HandleRequest(ThreadID, (usb_deviceRequest_t*)&SetupBuffer[0]);
}
}
void RpcHandler::HandleData(const QSharedPointer<ISender> &from,
const QVariantList &container)
{
if(container.size() < 2) {
return;
}
QString type = container.at(0).toString();
if(type == Request::RequestType ||
type == Request::NotificationType)
{
HandleRequest(Request(_responder, from, container));
} else if(type == Response::ResponseType) {
HandleResponse(Response(from, container));
} else {
qDebug() << "Received an unknown Rpc type:" << type;
}
}
int Session::QueueCollection(Collection* collection, string configId) {
AuthRequest* authRequest = new AuthRequest(consumerKey, consumerSecret, configId, applicationName);
QueryMethod method = POST;
string url = host + "/collection." + format;
cout << endl << "url: " << url << endl;
string body = "";
if (format == "xml") {
body = (static_cast<XmlSerializer*>(serializer))->Serialize(collection);
} else {
body = (static_cast<JsonSerializer*>(serializer))->Serialize(collection);
}
int result = authRequest->authWebRequest(url, method, body);
HandleCollAutoResponse(result, authRequest);
HandleRequest(method, url, body);
delete authRequest;
return result;
}
int Session::UpdateItems(string path, UpdateProxy<T>* proxy, string configId) {
AuthRequest* authRequest = new AuthRequest(consumerKey, consumerSecret, configId, applicationName);
QueryMethod method = POST;
string url = host + "/" + path + "." + format;
cout << endl << "url: " << url << endl;
string body = "";
if (format == "xml") {
body = (static_cast<XmlSerializer*>(serializer))->Serialize(proxy);
} else {
body = (static_cast<JsonSerializer*>(serializer))->Serialize(proxy);
}
int result = authRequest->authWebRequest(url, method, body);
HandleRequest(POST, url, body);
HandleConfigurationResponse(result, authRequest);
delete authRequest;
return result;
}
/* See description in header file. */
void WorkerThread::DoRealWorks()
{
while (!m_stop)
{
int ret = m_param.WaitForAction();
if (ret)
{
continue;
}
// PDEBUG ("Thread %lu is working...\n", TID2ULONG(m_tid));
PDEBUG ("Thread %p is working...\n", this);
Socket* sock = m_param.m_sock;
if (!sock)
{
continue;
}
while (true)
{
THMessagePtr msg = sock->Receive();
if (!msg)
{
m_param.m_busy = false;
sock->Close();
if (m_pPool)
{
m_pPool->ReturnThread(this);
}
PDEBUG ("Socket closed ...\n");
break;
}
// TODO: Add real work here.
THMessagePtr rsp = HandleRequest(msg);
// Send it back to client;
int n = sock->Send(rsp);
}
}
}
CollAnalyticData* Session::GetCollection(string collectionId, string configId) {
AuthRequest* authRequest = new AuthRequest(consumerKey, consumerSecret, configId, applicationName);
QueryMethod method = GET;
string url = host + "/collection/" + collectionId + "." + format;
cout << endl << "url: " << url << endl;
int status = authRequest->authWebRequest(url, method);
CollAnalyticData* result = new CollAnalyticData();
if (status <= 202 && "" != authRequest->GetReceivedData()) {
if (format == "xml") {
(static_cast<XmlSerializer*>(serializer))->Deserialize(authRequest->GetReceivedData(), result);
} else {
(static_cast<JsonSerializer*>(serializer))->Deserialize(authRequest->GetReceivedData(), result);
}
}
HandleRequest(method, url, "");
HandleConfigurationResponse(status, authRequest);
delete authRequest;
return result;
}
void CheckForCommands() {
int result = strlen(recv_buffer);
if (result == 0) // No pending commands
{ // Keep going till the commands have been received completely (the last character is an endline; recv_buffer better be big enough for at least one entire command)
do {
memset(temp_buffer, 0, RECV_BUFFER_SIZE);
result = NetRecvTCP(interfaceSocket, temp_buffer, RECV_BUFFER_SIZE - strlen(recv_buffer) - 1);
if (result > 0)
strcat(recv_buffer, temp_buffer);
} while (result > 0 && (strlen(recv_buffer) > 0 && strlen(recv_buffer) < RECV_BUFFER_SIZE - 1 && recv_buffer[strlen(recv_buffer) - 1] != '\n'));
}
if (result > 0)
HandleRequest();
else if (NetCheckForDisconnect()) {
DebugPrint("Broken connection.");
connected = false;
NetCloseTCP(interfaceSocket);
}
}
int Session::QueueBatch(vector<Document*>* documents, string configId) {
AuthRequest* authRequest = new AuthRequest(consumerKey, consumerSecret, configId, applicationName);
QueryMethod method = POST;
string url = host + "/document/batch." + format;
cout << endl << "url: " << url << endl;
Stub_Tasks* documentsStub = new Stub_Tasks(documents);
string body = "";
if (format == "xml") {
body = (static_cast<XmlSerializer*>(serializer))->Serialize(documentsStub);
} else {
body = (static_cast<JsonSerializer*>(serializer))->Serialize(documentsStub);
}
delete documentsStub;
int result = authRequest->authWebRequest(url, method, body);
HandleDocAutoResponse(result, authRequest);
HandleRequest(method, url, body);
delete authRequest;
return result;
}
Subscription* Session::VerifySubscription() {
AuthRequest* authRequest = new AuthRequest(consumerKey, consumerSecret, "", applicationName);
QueryMethod method = GET;
string url = host + "/subscription." + format;
cout << endl << "url: " << url << endl;
int status = authRequest->authWebRequest(url, method);
Subscription* result = new Subscription();
if (status <= 202 && "" != authRequest->GetReceivedData()) {
if (format == "xml") {
(static_cast<XmlSerializer*>(serializer))->Deserialize(authRequest->GetReceivedData(), result);
} else {
(static_cast<JsonSerializer*>(serializer))->Deserialize(authRequest->GetReceivedData(), result);
}
}
HandleRequest(method, url, "");
HandleConfigurationResponse(status, authRequest);
delete authRequest;
return result;
}
static int ProxyModel_HandleRequest(const RDMHeader *header,
const uint8_t *param_data) {
int response_size = 0;
// The proxy always gets first dibs on responding.
if (RDMUtil_RequiresAction(g_responder->uid, header->dest_uid)) {
response_size = HandleRequest(header, param_data);
if (response_size) {
return response_size;
}
}
unsigned int i = 0u;
for (; i < NUMBER_OF_CHILDREN; i++) {
if (RDMUtil_RequiresAction(g_children[i].responder.uid, header->dest_uid)) {
RDMResponder_SwitchResponder(&g_children[i].responder);
int response_size = HandleChildRequest(header, param_data, i);
RDMResponder_RestoreResponder();
if (response_size) {
return response_size;
}
}
}
return RDM_RESPONDER_NO_RESPONSE;
}
unsigned long WINAPI ThreadFunc(LPVOID lpParam)
{
SOCKET * s = (SOCKET *)lpParam;
char szTemp[STR_LEN], szRequest[STR_LEN] = {0};
char szRequestHeader[STR_LEN] = {0}, szRequestBody[STR_LEN] = {0};
char * pcTemp = 0;
int ret = 0;
int len = 0, nHeaderLength = 0, nContentLength = 0;
while (len = recv(*s, szTemp, STR_LEN, 0))
{
strncat(szRequest, szTemp, len);
if (szRequestHeader[0] == '\0')
{
/* Check if the header was completly received */
nHeaderLength = (int)(strstr(szRequest, "\r\n\r\n") - szRequest);
if (nHeaderLength > 0)
{
nHeaderLength += 2;
sprintf(szTemp, "Header length: %d", nHeaderLength);
Log(szTemp);
/* Copy the request header aside */
strncpy(szRequestHeader, szRequest, nHeaderLength);
pcTemp = stristr(szRequestHeader, "Content-Length:");
if (pcTemp)
{
/* Copy the "Content-Length" line */
strncpy(szTemp, pcTemp, (int)(strchr(pcTemp, '\r') - pcTemp));
Log(szTemp);
/* Get the content length */
len = strspn(&(szTemp[strlen("Content-Length:")]), " \t");
nContentLength = atoi(&(szTemp[strlen("Content-Length:") + len - 1]));
sprintf(szTemp, "Content-Length: %d", nContentLength);
Log(szTemp);
}
}
}
if (szRequestHeader[0]) /* Header parsing is complete */
{
if (nContentLength)
{
if (szRequestBody[0] == '\0')
{
strcpy(szTemp, &(szRequest[nHeaderLength + 2]));
}
if (strlen(szRequestBody) < nContentLength)
{
strcat(szRequestBody, szTemp);
}
}
if (strlen(szRequestBody) == nContentLength)
{
return HandleRequest(szRequest, szRequestHeader, szRequestBody, s);
}
}
}
return 0;
}
int CWebServer::AnswerToConnection(void *cls, struct MHD_Connection *connection,
const char *url, const char *method,
const char *version, const char *upload_data,
unsigned int *upload_data_size, void **con_cls)
#endif
{
if (cls == NULL || con_cls == NULL || *con_cls == NULL)
{
CLog::Log(LOGERROR, "CWebServer: invalid request received");
return MHD_NO;
}
CWebServer *server = reinterpret_cast<CWebServer*>(cls);
std::auto_ptr<ConnectionHandler> conHandler(reinterpret_cast<ConnectionHandler*>(*con_cls));
HTTPMethod methodType = GetMethod(method);
HTTPRequest request = { server, connection, conHandler->fullUri, url, methodType, version };
// remember if the request was new
bool isNewRequest = conHandler->isNew;
// because now it isn't anymore
conHandler->isNew = false;
// reset con_cls and set it if still necessary
*con_cls = NULL;
#ifdef WEBSERVER_DEBUG
if (isNewRequest)
{
std::multimap<std::string, std::string> headerValues;
GetRequestHeaderValues(connection, MHD_HEADER_KIND, headerValues);
std::multimap<std::string, std::string> getValues;
GetRequestHeaderValues(connection, MHD_GET_ARGUMENT_KIND, getValues);
CLog::Log(LOGDEBUG, "webserver [IN] %s %s %s", version, method, request.pathUrlFull.c_str());
if (!getValues.empty())
{
std::string tmp;
for (std::multimap<std::string, std::string>::const_iterator get = getValues.begin(); get != getValues.end(); ++get)
{
if (get != getValues.begin())
tmp += "; ";
tmp += get->first + " = " + get->second;
}
CLog::Log(LOGDEBUG, "webserver [IN] Query arguments: %s", tmp.c_str());
}
for (std::multimap<std::string, std::string>::const_iterator header = headerValues.begin(); header != headerValues.end(); ++header)
CLog::Log(LOGDEBUG, "webserver [IN] %s: %s", header->first.c_str(), header->second.c_str());
}
#endif
if (!IsAuthenticated(server, connection))
return AskForAuthentication(connection);
// check if this is the first call to AnswerToConnection for this request
if (isNewRequest)
{
// parse the Range header and store it in the request object
CHttpRanges ranges;
bool ranged = ranges.Parse(GetRequestHeaderValue(connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_RANGE));
// look for a IHTTPRequestHandler which can take care of the current request
for (std::vector<IHTTPRequestHandler *>::const_iterator it = m_requestHandlers.begin(); it != m_requestHandlers.end(); ++it)
{
IHTTPRequestHandler *requestHandler = *it;
if (requestHandler->CanHandleRequest(request))
{
// we found a matching IHTTPRequestHandler so let's get a new instance for this request
IHTTPRequestHandler *handler = requestHandler->Create(request);
// if we got a GET request we need to check if it should be cached
if (methodType == GET)
{
if (handler->CanBeCached())
{
bool cacheable = true;
// handle Cache-Control
std::string cacheControl = GetRequestHeaderValue(connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_CACHE_CONTROL);
if (!cacheControl.empty())
{
std::vector<std::string> cacheControls = StringUtils::Split(cacheControl, ",");
for (std::vector<std::string>::const_iterator it = cacheControls.begin(); it != cacheControls.end(); ++it)
{
std::string control = *it;
control = StringUtils::Trim(control);
// handle no-cache
if (control.compare(HEADER_VALUE_NO_CACHE) == 0)
cacheable = false;
}
}
if (cacheable)
{
// handle Pragma (but only if "Cache-Control: no-cache" hasn't been set)
std::string pragma = GetRequestHeaderValue(connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_PRAGMA);
if (pragma.compare(HEADER_VALUE_NO_CACHE) == 0)
cacheable = false;
}
CDateTime lastModified;
if (handler->GetLastModifiedDate(lastModified) && lastModified.IsValid())
{
// handle If-Modified-Since or If-Unmodified-Since
std::string ifModifiedSince = GetRequestHeaderValue(connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_IF_MODIFIED_SINCE);
std::string ifUnmodifiedSince = GetRequestHeaderValue(connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_IF_UNMODIFIED_SINCE);
CDateTime ifModifiedSinceDate;
CDateTime ifUnmodifiedSinceDate;
// handle If-Modified-Since (but only if the response is cacheable)
if (cacheable &&
ifModifiedSinceDate.SetFromRFC1123DateTime(ifModifiedSince) &&
lastModified.GetAsUTCDateTime() <= ifModifiedSinceDate)
{
struct MHD_Response *response = MHD_create_response_from_data(0, NULL, MHD_NO, MHD_NO);
if (response == NULL)
{
CLog::Log(LOGERROR, "CWebServer: failed to create a HTTP 304 response");
return MHD_NO;
}
return FinalizeRequest(handler, MHD_HTTP_NOT_MODIFIED, response);
}
// handle If-Unmodified-Since
else if (ifUnmodifiedSinceDate.SetFromRFC1123DateTime(ifUnmodifiedSince) &&
lastModified.GetAsUTCDateTime() > ifUnmodifiedSinceDate)
return SendErrorResponse(connection, MHD_HTTP_PRECONDITION_FAILED, methodType);
}
// handle If-Range header but only if the Range header is present
if (ranged && lastModified.IsValid())
{
std::string ifRange = GetRequestHeaderValue(connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_IF_RANGE);
if (!ifRange.empty() && lastModified.IsValid())
{
CDateTime ifRangeDate;
ifRangeDate.SetFromRFC1123DateTime(ifRange);
// check if the last modification is newer than the If-Range date
// if so we have to server the whole file instead
if (lastModified.GetAsUTCDateTime() > ifRangeDate)
ranges.Clear();
}
}
// pass the requested ranges on to the request handler
handler->SetRequestRanged(!ranges.IsEmpty());
}
}
// if we got a POST request we need to take care of the POST data
else if (methodType == POST)
{
conHandler->requestHandler = handler;
// get the content-type of the POST data
std::string contentType = GetRequestHeaderValue(connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_CONTENT_TYPE);
if (!contentType.empty())
{
// if the content-type is application/x-ww-form-urlencoded or multipart/form-data we can use MHD's POST processor
if (StringUtils::EqualsNoCase(contentType, MHD_HTTP_POST_ENCODING_FORM_URLENCODED) ||
StringUtils::EqualsNoCase(contentType, MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA))
{
// Get a new MHD_PostProcessor
conHandler->postprocessor = MHD_create_post_processor(connection, MAX_POST_BUFFER_SIZE, &CWebServer::HandlePostField, (void*)conHandler.get());
// MHD doesn't seem to be able to handle this post request
if (conHandler->postprocessor == NULL)
{
CLog::Log(LOGERROR, "CWebServer: unable to create HTTP POST processor for %s", url);
delete conHandler->requestHandler;
return SendErrorResponse(connection, MHD_HTTP_INTERNAL_SERVER_ERROR, methodType);
}
}
}
// otherwise we need to handle the POST data ourselves which is done in the next call to AnswerToConnection
// as ownership of the connection handler is passed to libmicrohttpd we must not destroy it
*con_cls = conHandler.release();
return MHD_YES;
}
return HandleRequest(handler);
}
}
}
// this is a subsequent call to AnswerToConnection for this request
else
{
// again we need to take special care of the POST data
if (methodType == POST)
{
if (conHandler->requestHandler == NULL)
{
CLog::Log(LOGERROR, "CWebServer: cannot handle partial HTTP POST for %s request because there is no valid request handler available", url);
return SendErrorResponse(connection, MHD_HTTP_INTERNAL_SERVER_ERROR, methodType);
}
// we only need to handle POST data if there actually is data left to handle
if (*upload_data_size > 0)
{
// either use MHD's POST processor
if (conHandler->postprocessor != NULL)
MHD_post_process(conHandler->postprocessor, upload_data, *upload_data_size);
// or simply copy the data to the handler
else
conHandler->requestHandler->AddPostData(upload_data, *upload_data_size);
// signal that we have handled the data
*upload_data_size = 0;
// we may need to handle more POST data which is done in the next call to AnswerToConnection
// as ownership of the connection handler is passed to libmicrohttpd we must not destroy it
*con_cls = conHandler.release();
return MHD_YES;
}
// we have handled all POST data so it's time to invoke the IHTTPRequestHandler
else
{
if (conHandler->postprocessor != NULL)
MHD_destroy_post_processor(conHandler->postprocessor);
return HandleRequest(conHandler->requestHandler);
}
}
// it's unusual to get more than one call to AnswerToConnection for none-POST requests, but let's handle it anyway
else
{
for (std::vector<IHTTPRequestHandler *>::const_iterator it = m_requestHandlers.begin(); it != m_requestHandlers.end(); ++it)
{
IHTTPRequestHandler *requestHandler = *it;
if (requestHandler->CanHandleRequest(request))
return HandleRequest(requestHandler->Create(request));
}
}
}
CLog::Log(LOGERROR, "CWebServer: couldn't find any request handler for %s", url);
return SendErrorResponse(connection, MHD_HTTP_NOT_FOUND, methodType);
}
int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* socket, int type_aux)
{
JackRequest::RequestType type = (JackRequest::RequestType)type_aux;
// Read data
switch (type) {
case JackRequest::kClientCheck: {
jack_log("JackRequest::ClientCheck");
JackClientCheckRequest req;
JackClientCheckResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->ClientCheck(req.fName, req.fUUID, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
CheckWriteName("JackRequest::ClientCheck", socket);
// Atomic ClientCheck followed by ClientOpen on same socket
if (req.fOpen) {
JackRequest header;
header.Read(socket);
return HandleRequest(socket, header.fType);
}
break;
}
case JackRequest::kClientOpen: {
jack_log("JackRequest::ClientOpen");
JackClientOpenRequest req;
JackClientOpenResult res;
CheckRead(req, socket);
fHandler->ClientAdd(socket, &req, &res);
CheckWriteName("JackRequest::ClientOpen", socket);
break;
}
case JackRequest::kClientClose: {
jack_log("JackRequest::ClientClose");
JackClientCloseRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);
CheckWriteRefNum("JackRequest::ClientClose", socket);
fHandler->ClientRemove(socket, req.fRefNum);
// Will cause the wrapping thread to stop
return -1;
}
case JackRequest::kActivateClient: {
JackActivateRequest req;
JackResult res;
jack_log("JackRequest::ActivateClient");
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->ClientActivate(req.fRefNum, req.fIsRealTime);
CheckWriteRefNum("JackRequest::ActivateClient", socket);
break;
}
case JackRequest::kDeactivateClient: {
jack_log("JackRequest::DeactivateClient");
JackDeactivateRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->ClientDeactivate(req.fRefNum);
CheckWriteRefNum("JackRequest::DeactivateClient", socket);
break;
}
case JackRequest::kRegisterPort: {
jack_log("JackRequest::RegisterPort");
JackPortRegisterRequest req;
JackPortRegisterResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fPortType, req.fFlags, req.fBufferSize, &res.fPortIndex);
CheckWriteRefNum("JackRequest::RegisterPort", socket);
break;
}
case JackRequest::kUnRegisterPort: {
jack_log("JackRequest::UnRegisterPort");
JackPortUnRegisterRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->PortUnRegister(req.fRefNum, req.fPortIndex);
CheckWriteRefNum("JackRequest::UnRegisterPort", socket);
break;
}
case JackRequest::kConnectNamePorts: {
jack_log("JackRequest::ConnectNamePorts");
JackPortConnectNameRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
CheckWriteRefNum("JackRequest::ConnectNamePorts", socket);
break;
}
case JackRequest::kDisconnectNamePorts: {
jack_log("JackRequest::DisconnectNamePorts");
JackPortDisconnectNameRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
CheckWriteRefNum("JackRequest::DisconnectNamePorts", socket);
break;
}
case JackRequest::kConnectPorts: {
jack_log("JackRequest::ConnectPorts");
JackPortConnectRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
CheckWriteRefNum("JackRequest::ConnectPorts", socket);
break;
}
case JackRequest::kDisconnectPorts: {
jack_log("JackRequest::DisconnectPorts");
JackPortDisconnectRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
CheckWriteRefNum("JackRequest::DisconnectPorts", socket);
break;
}
case JackRequest::kPortRename: {
jack_log("JackRequest::PortRename");
JackPortRenameRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->PortRename(req.fRefNum, req.fPort, req.fName);
CheckWriteRefNum("JackRequest::PortRename", socket);
break;
}
case JackRequest::kSetBufferSize: {
jack_log("JackRequest::SetBufferSize");
JackSetBufferSizeRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->SetBufferSize(req.fBufferSize);
CheckWrite("JackRequest::SetBufferSize", socket);
break;
}
case JackRequest::kSetFreeWheel: {
jack_log("JackRequest::SetFreeWheel");
JackSetFreeWheelRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->SetFreewheel(req.fOnOff);
CheckWrite("JackRequest::SetFreeWheel", socket);
#ifdef __ANDROID__
#ifdef WORKAROUND_QC_JACK_ALSA
/* for supporting qualcomm platform */
if(req.fOnOff == 0) {
usleep(300 * 1000);
kill(getpid(), SIGUSR2); //switch master driver via SIGUSR2 signal
usleep(300 * 1000);
kill(getpid(), SIGUSR2); //switch master driver via SIGUSR2 signal
usleep(300 * 1000);
fServer->GetEngine()->PortConnect(0, "out:__system_playback_1", "system:playback_1");
fServer->GetEngine()->PortConnect(0, "out:__system_playback_2", "system:playback_2");
fServer->GetEngine()->PortConnect(0, "system:capture_1", "in:__system_capture_1");
fServer->GetEngine()->PortConnect(0, "system:capture_2", "in:__system_capture_2");
}
#endif
#endif
break;
}
case JackRequest::kComputeTotalLatencies: {
jack_log("JackRequest::ComputeTotalLatencies");
JackComputeTotalLatenciesRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->ComputeTotalLatencies();
CheckWrite("JackRequest::ComputeTotalLatencies", socket);
break;
}
case JackRequest::kReleaseTimebase: {
jack_log("JackRequest::ReleaseTimebase");
JackReleaseTimebaseRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->ReleaseTimebase(req.fRefNum);
CheckWriteRefNum("JackRequest::ReleaseTimebase", socket);
break;
}
case JackRequest::kSetTimebaseCallback: {
jack_log("JackRequest::SetTimebaseCallback");
JackSetTimebaseCallbackRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->SetTimebaseCallback(req.fRefNum, req.fConditionnal);
CheckWriteRefNum("JackRequest::SetTimebaseCallback", socket);
break;
}
case JackRequest::kGetInternalClientName: {
jack_log("JackRequest::GetInternalClientName");
JackGetInternalClientNameRequest req;
JackGetInternalClientNameResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->GetInternalClientName(req.fIntRefNum, res.fName);
CheckWriteRefNum("JackRequest::GetInternalClientName", socket);
break;
}
case JackRequest::kInternalClientHandle: {
jack_log("JackRequest::InternalClientHandle");
JackInternalClientHandleRequest req;
JackInternalClientHandleResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->InternalClientHandle(req.fName, &res.fStatus, &res.fIntRefNum);
CheckWriteRefNum("JackRequest::InternalClientHandle", socket);
break;
}
case JackRequest::kInternalClientLoad: {
jack_log("JackRequest::InternalClientLoad");
JackInternalClientLoadRequest req;
JackInternalClientLoadResult res;
CheckRead(req, socket);
res.fResult = fServer->InternalClientLoad1(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, req.fUUID, &res.fStatus);
CheckWriteName("JackRequest::InternalClientLoad", socket);
break;
}
case JackRequest::kInternalClientUnload: {
jack_log("JackRequest::InternalClientUnload");
JackInternalClientUnloadRequest req;
JackInternalClientUnloadResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->InternalClientUnload(req.fIntRefNum, &res.fStatus);
CheckWriteRefNum("JackRequest::InternalClientUnload", socket);
break;
}
case JackRequest::kNotification: {
jack_log("JackRequest::Notification");
JackClientNotificationRequest req;
CheckRead(req, socket);
if (req.fNotify == kQUIT) {
jack_log("JackRequest::Notification kQUIT");
throw JackQuitException();
} else {
fServer->Notify(req.fRefNum, req.fNotify, req.fValue);
}
break;
}
case JackRequest::kSessionNotify: {
jack_log("JackRequest::SessionNotify");
JackSessionNotifyRequest req;
CheckRead(req, socket);
fServer->GetEngine()->SessionNotify(req.fRefNum, req.fDst, req.fEventType, req.fPath, socket, NULL);
break;
}
case JackRequest::kSessionReply: {
jack_log("JackRequest::SessionReply");
JackSessionReplyRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->SessionReply(req.fRefNum);
CheckWrite("JackRequest::SessionReply", socket);
break;
}
case JackRequest::kGetClientByUUID: {
jack_log("JackRequest::GetClientByUUID");
JackGetClientNameRequest req;
JackClientNameResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->GetClientNameForUUID(req.fUUID, res.fName);
CheckWrite("JackRequest::GetClientByUUID", socket);
break;
}
case JackRequest::kGetUUIDByClient: {
jack_log("JackRequest::GetUUIDByClient");
JackGetUUIDRequest req;
JackUUIDResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->GetUUIDForClientName(req.fName, res.fUUID);
CheckWrite("JackRequest::GetUUIDByClient", socket);
break;
}
case JackRequest::kReserveClientName: {
jack_log("JackRequest::ReserveClientName");
JackReserveNameRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->ReserveClientName(req.fName, req.fUUID);
CheckWrite("JackRequest::ReserveClientName", socket);
break;
}
case JackRequest::kClientHasSessionCallback: {
jack_log("JackRequest::ClientHasSessionCallback");
JackClientHasSessionCallbackRequest req;
JackResult res;
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->ClientHasSessionCallback(req.fName);
CheckWrite("JackRequest::ClientHasSessionCallback", socket);
break;
}
default:
jack_error("Unknown request %ld", type);
return -1;
}
return 0;
}
void RageWorkerThread::WorkerMain()
{
while(1)
{
bool bTimeToRunHeartbeat = false;
m_WorkerEvent.Lock();
while( m_iRequest == REQ_NONE && !bTimeToRunHeartbeat )
{
if( !m_WorkerEvent.Wait( m_fHeartbeat != -1? &m_NextHeartbeat:NULL ) )
bTimeToRunHeartbeat = true;
}
const int iRequest = m_iRequest;
m_iRequest = REQ_NONE;
m_WorkerEvent.Unlock();
/* If it's time to run a heartbeat, do so. */
if( bTimeToRunHeartbeat )
{
DoHeartbeat();
/* Wake up anyone waiting for a heartbeat. */
m_HeartbeatEvent.Lock();
m_HeartbeatEvent.Broadcast();
m_HeartbeatEvent.Unlock();
/* Schedule the next heartbeat. */
m_NextHeartbeat.Touch();
m_NextHeartbeat += m_fHeartbeat;
}
if( iRequest != REQ_NONE )
{
/* Handle the request. */
if( iRequest != REQ_SHUTDOWN )
{
CHECKPOINT_M( ssprintf("HandleRequest(%i)", iRequest) );
HandleRequest( iRequest );
CHECKPOINT_M( ssprintf("HandleRequest(%i) done", iRequest) );
}
/* Lock the mutex, to keep DoRequest where it is (if it's still running). */
/* The request is finished. If it timed out, clear the timeout flag and
* call RequestTimedOut, to allow cleaning up. */
m_WorkerEvent.Lock();
if( m_bTimedOut )
{
LOG->Trace( "Request %i timed out", iRequest );
/* The calling thread timed out. It's already gone and moved on, so
* it's our responsibility to clean up. No new requests will come in
* until we clear m_bTimedOut, so we can safely unlock and clean up. */
m_WorkerEvent.Unlock();
RequestTimedOut();
/* Clear the time-out flag, indicating that we can work again. */
m_bTimedOut = false;
CHECKPOINT;
}
else
{
CHECKPOINT_M( ssprintf("HandleRequest(%i) OK", iRequest) );
m_bRequestFinished = true;
/* We're finished. Wake up the requester. */
m_WorkerEvent.Broadcast();
m_WorkerEvent.Unlock();
}
}
if( iRequest == REQ_SHUTDOWN )
break;
}
}
Response *Route::Call(std::string url, std::string method,
std::vector<std::pair<std::string, std::string> > get,
std::vector<std::pair<std::string, std::string> > post) {
return HandleRequest(url, method, get, post);
}