void * runServiceFtpsThread(void * arg){
ClientConnection * conn = (ClientConnection*) arg;
MpsRequest * req;
do{
req = receiveRequest(conn->clientSocket);
if(isSysCallOpen(req)){
executeSysCallOpen(req , conn);
}else if( isSysCallClose(req)){
executeSysCallClose(req, conn);
}else if( isSysCallFlush(req)){
executeSysCallFlush(req, conn);
}else if( isSysCallRead(req)){
executeSysCallRead(req, conn);
}else if( isSysCallWrite(req)){
executeSysCallWrite(req, conn);
}
}while(isKssRunningStatus() && isKssOperationalStatus());
close(conn->clientSocket);
free(conn);
return EXIT_SUCCESS;
}
/*!
Receives and decode requests untils there is requests to receive.
\warning Requests will be received but not decoded.
\sa vpNetwork::receive()
\sa vpNetwork::receiveRequestFrom()
\sa vpNetwork::receiveRequestOnce()
\sa vpNetwork::receiveRequestOnceFrom()
\sa vpNetwork::receiveAndDecodeRequest()
\sa vpNetwork::receiveAndDecodeRequestFrom()
\sa vpNetwork::receiveAndDecodeRequestOnce()
\sa vpNetwork::receiveAndDecodeRequestOnceFrom()
*/
std::vector<int> vpNetwork::receiveAndDecodeRequest()
{
std::vector<int> res = receiveRequest();
for(unsigned int i = 0 ; i < res.size() ; i++)
if(res[i] != -1)
request_list[(unsigned)res[i]]->decode();
return res;
}
frmProgress * QNapiApp::progress()
{
if(!f_progress)
{
f_progress = new frmProgress();
if(!f_progress) abort();
connect(this, SIGNAL(request(QString)),
f_progress, SLOT(receiveRequest(QString)));
connect(this, SIGNAL(downloadFile(const QString &)),
f_progress, SLOT(receiveRequest(const QString &)));
}
Delegator::Delegator(zmq::context_t& context, const DelegatorSettings& settings, bool& running)
: context_(context),
requester_(context, ZMQ_ROUTER, "toRequester"),
heartbeat_(context, ZMQ_PAIR, "toHBRouter"),
network_(context, ZMQ_ROUTER, "toNetwork"),
router_("main", {&requester_, &heartbeat_, &network_}),
msPollRate_(settings.msPollRate),
hbSettings_(settings.heartbeat),
running_(running),
nextJobId_(0),
nJobTypes_(settings.nJobTypes)
{
// Initialise the local sockets
requester_.bind(DELEGATOR_SOCKET_ADDR);
heartbeat_.bind(SERVER_HB_SOCKET_ADDR);
network_.setFallback([&](const Message& m) { sendFailed(m); });
std::string address = "tcp://*:" + std::to_string(settings.port);
network_.bind(address);
LOG(INFO) << "Delegator listening on tcp://*:" + std::to_string(settings.port);
// Specify the Delegator functionality
auto fDisconnect = [&](const Message& m) { disconnectWorker(m); };
auto fNewWorker = [&](const Message &m)
{
//forwarding to HEARTBEAT
heartbeat_.send(m);
std::string worker = m.address.front();
if (workers_.count(worker) == 0)
connectWorker(m);
};
auto fRcvRequest = [&](const Message &m) { receiveRequest(m); };
auto fRcvResult = [&](const Message &m) { receiveResult(m); };
auto fForwardToHB = [&](const Message& m) { heartbeat_.send(m); };
auto fForwardToNetwork = [&](const Message& m) { network_.send(m); };
auto fForwardToHBAndDisconnect = [&](const Message& m)
{ fForwardToHB(m); fDisconnect(m); };
// Bind functionality to the router
const uint REQUESTER_SOCKET = 0, HB_SOCKET = 1, NETWORK_SOCKET = 2;
router_.bind(REQUESTER_SOCKET, REQUEST, fRcvRequest);
router_.bind(NETWORK_SOCKET, HELLO, fNewWorker);
router_.bind(NETWORK_SOCKET, RESULT, fRcvResult);
router_.bind(NETWORK_SOCKET, HEARTBEAT, fForwardToHB);
router_.bind(NETWORK_SOCKET, GOODBYE, fForwardToHBAndDisconnect);
router_.bind(HB_SOCKET, HEARTBEAT, fForwardToNetwork);
router_.bind(HB_SOCKET, GOODBYE, fDisconnect);
auto fOnPoll = [&] () {onPoll();};
router_.bindOnPoll(fOnPoll);
}
void RemoteControl::operator()(list<Directions>* directions, mutex* m)
{
windowsSocketStart();
establishServerSocket();
while (1)
{
establishClientSocket();
try
{
request = receiveRequest();
method = getMethodOfRequest(request);
path = getRequestedPath(request);
if (getTypeOfRequest() == GET_DIRECTIONS)
{
unique_lock<mutex> lk(*m);
string xml = generateXMLForDirections(*directions);
lk.unlock();
sendResponce(xml);
}
else if (getTypeOfRequest() == SET_DIRECTIONS)
{
payload = getPayloadOfPOST(request);
unique_lock<mutex> lk(*m);
importDirectionsFromXML(payload, directions);
lk.unlock();
sendResponce("");
}
else if (getTypeOfRequest() == IMPORT_OPML)
{
payload = getPayloadOfPOST(request);
unique_lock<mutex> lk(*m);
importOPML(payload);
lk.unlock();
}
else if (getTypeOfRequest() == EXPORT_OPML)
{
// TODO
}
else
throw RemoteControlException(ERROR, "Invalid URL");
}
catch(...)
{
log(ERROR, "Problems in RemoteContol");
}
close(clientSock);
}
}
bool MaekawaAlgorithm::requestCriticalSection(){
printf("----Node %d is trying to request critical section\n",processID);
sequenceNo++;
struct Packet request;
request.TYPE = REQUEST;
request.ORIGIN = processID;
request.SEQ = sequenceNo;
request.sender = -1;
//reset relinquishList
for(int i = 0; i < relinquishList.size(); i++){
printf("----relinquishList size: %lu. Member removed: %d \n",relinquishList.size(),relinquishList.back());
relinquishList.pop_back();
}
//add request to the node queue
queue->add(request);
printf("----The request is: (%lu , %d) \n",sequenceNo,processID);
// //broadcast request to all processes in its quorum
// for(int j = 0; j < quorumsize; j++){
// com.sendMessageToID(request,quorum[processID][j]);
// printf("----Node %d has sent REQUEST message to %d \n",processID,quorum[processID][j]);
// }
//broadcast request to all other process in its quorum
for(int j = 0; j < quorumsize; j++){
if(quorum[processID][j] != processID){
com.sendMessageToID(request,quorum[processID][j]);
printf("----Node %d has sent REQUEST message to %d \n",processID,quorum[processID][j]);
}
else if(quorum[processID][j] == processID){
//The node itself will immediately receive it's request
printf("----Node %d has sent REQUEST message to itself \n",processID);
receiveRequest(request);
}
}
//hasSentLockedMessagetoItself = true;
return true;
}
int openCChannel(){
struct mq_attr attr;
attr.mq_maxmsg = 10;
attr.mq_msgsize = sizeof msg;
sprintf(cltname, "/client_%d_queue", getpid());
if ( (qin = mq_open(cltname, O_RDONLY|O_CREAT, 0666, &attr)) == -1 )
fatal("Error mq_open qin");
request_t req;
req = receiveRequest();
if(req.reqID != ANS){
printf("error\n");
return ERROR;
}
char serverPath[50];
sprintf(serverPath, "/server_%d_queue", req.par1);
if ( (qout = mq_open(serverPath, O_WRONLY|O_CREAT, 0666, &attr)) == -1 )
fatal("Error mq_open qout");
return OK;
}
/*
* Main routine of our mini time server
*/
int
main(int argc, char* argv[])
{
establishRedirection("mtimesrv.log", REDIR_OUT_APPEND, STDOUT_FILENO | STDERR_FILENO);
printf("\nMicro Time Server\nVersion: %s\n\n", MTIMESRV_VERSION);
init();
daemonize();
/* main server loop */
while(1)
{
ipc_packet_data.sem_id = status.sem_id;
ipc_packet_data.reqresp = &request;
if(receiveRequest(&ipc_packet_data) < 0)
{
ipcerror("mtimesrv::main():receiveRequest() - failed");
exit(1);
}
/* Dispatch requests */
switch(request.command)
{
case IDLE:
printf("Idle\n");
fflush(stdout);
break;
case TIME:
sendTime();
break;
case OPEN:
registerClient();
break;
case VERSION:
sendVersion();
break;
case TERMINATE:
terminate();
break;
case PING:
processPing();
break;
default:
printf("Unsupported command (%d) from a client (PID=%d)... Ignored.\n", request.command, request.client_pid);
fflush(stdout);
break;
}
/* Reset the request buffer */
memset(&request, 0, sizeof(request_t));
}
return 0;
}
