int SparseAllocator::ReadRequest( int in, int out ) const { sRequest r; if ( ! ReadRequest( r, in, out ) ) { r.label = -1; } return r.label; }
/* Run GWBasic Shell */ void RunShell(GWBE_Environment* env) { assert(env != NULL); while (1) { ReadRequest(env->input); /* Interpretate user request */ gwbr_Run(env); } }
void Wavefront::AddRequest( int in, int out, int label, int in_pri, int out_pri ) { // count unique requests sRequest req; bool overwrite = ReadRequest(req, in, out); if(!overwrite || (req.in_pri < in_pri)) { _num_requests++; _last_in = in; _last_out = out; } DenseAllocator::AddRequest(in, out, label, in_pri, out_pri); }
void I2PControlService::HandleAccept( const boost::system::error_code& ecode, std::shared_ptr<boost::asio::ip::tcp::socket> socket) { if (ecode != boost::asio::error::operation_aborted) Accept(); if (!ecode) { LogPrint(eLogInfo, "New I2PControl request from ", socket->remote_endpoint()); std::this_thread::sleep_for(std::chrono::milliseconds(5)); ReadRequest(socket); } else { LogPrint(eLogError, "I2PControl accept error: ", ecode.message()); } }
void HandleConnection(PRFileDesc* aSocket, const UniquePRFileDesc& aModelSocket) { Connection conn(aSocket); nsresult rv = SetupTLS(&conn, aModelSocket.get()); if (NS_FAILED(rv)) { PR_SetError(PR_INVALID_STATE_ERROR, 0); PrintPRError("PR_Recv failed"); exit(1); } // TODO: On tests that are expected to fail (e.g. due to a revoked // certificate), the client will close the connection wtihout sending us the // request byte. In those cases, we should keep going. But, in the cases // where the connection is supposed to suceed, we should verify that we // successfully receive the request and send the response. rv = ReadRequest(&conn); if (NS_SUCCEEDED(rv)) { rv = ReplyToRequest(&conn); } }
void Connection::Process(bool executeAfterRead) { log_info("Process: fd=" << socket_.GetFileDescriptor()); bool newMessage = true; while (newMessage) { newMessage = false; if ((connectionState_ == READ_HEADER) && (!ReadHeader())) { connectionState_ = CLOSE_CONNECTION; break; } if ((connectionState_ == READ_REQUEST) && (!ReadRequest())) { connectionState_ = CLOSE_CONNECTION; break; } // When operating a thread pool, the main thread will read the request // but stop to transfer it to a worker thread for execution if (executeAfterRead) { if ((connectionState_ == EXECUTE_REQUEST) && (!ExecuteRequest())) { connectionState_ = CLOSE_CONNECTION; break; } } // When operating a thread pool, the main thread might need to continue // to write a long response to the socket after the connection is returned if (connectionState_ == WRITE_RESPONSE) { if (!WriteResponse()) { connectionState_ = CLOSE_CONNECTION; break; } newMessage = (connectionState_ == READ_HEADER) && (bufferLength_ > 0); } } }
int main() { int res = 0; //chdir(WorkDir); stdoutfd = dup(STDOUT_FILENO); stderrfd = dup(STDERR_FILENO); CreateConnection(); /*** when a connection comes ***/ for(;;) { clilen = sizeof(cli_addr); connfd = accept(listenfd, (struct sockaddr*)&cli_addr, &clilen); if(clientCount < LISTEN_MAX_NUM) { if(connfd < 0) { printf("error: accept error (errno: %d - %s)\n", errno, strerror(errno));fflush(stdout); close(connfd); bzero(&curClient, sizeof(curClient)); bzero(&cli_addr, sizeof(cli_addr)); clilen = 0; connfd = 0; } else { printf("accept\n");fflush(stdout); NewClient(); /*** read request ***/ if( (res = ReadRequest()) < 0) continue; /*** send status response ***/ write(curClient.fd, contentType, strlen(contentType)); write(curClient.fd, status200, strlen(status200)); /*** fork a child process for client ***/ if( (childPid = fork()) == -1) { printf("error: fork() error (errno: %d - %s)\n", errno, strerror(errno));fflush(stdout); Disconnect(); } else if(childPid == 0) { /*** child process: client work environment ***/ close(listenfd); listenfd = -1; /*** parse headers ***/ char method[5]; char target[HEADER_MAX_LEN]; char queryString[HEADER_MAX_LEN]; ParseMethod(method, target, queryString); /*** execute method ***/ ExectueMethod(); exit(0); } else { /*** parent process ***/ close(connfd); bzero(&curClient, sizeof(curClient)); bzero(&cli_addr, sizeof(cli_addr)); clilen = 0; connfd = 0; bzero(buffer, BUF_MAX_SIZE); bzero(request, sizeof(request)); } } } else { printf("error: too many clients now (errno: %d - %s)\n", errno, strerror(errno));fflush(stdout); close(connfd); bzero(&cli_addr, sizeof(cli_addr)); clilen = 0; connfd = 0; } } return 0; }
Dispatch() { int nready, result; int *clientReady; ClientPtr client; int op; nextFreeClientID = MINCLIENT; nClients = 0; clientReady = (int *) ALLOCATE_LOCAL(sizeof(int) * MaxClients); if (!clientReady) return; while (1) { /* wait for something */ nready = WaitForSomething(clientReady); while (!dispatchException && (--nready >= 0)) { client = currentClient = clients[clientReady[nready]]; /* Client can be NULL if CloseDownClient() is called during this dispatchException loop. */ if (client == (ClientPtr)NULL) continue; isItTimeToYield = FALSE; while (!isItTimeToYield) { result = ReadRequest(client); if (result <= 0) { if (result < 0) CloseDownClient(client); break; } client->sequence++; if (result > (MAX_REQUEST_SIZE << 2)) result = FSBadLength; else { op = MAJOROP; if (op >= NUM_PROC_VECTORS) result = ProcBadRequest (client); else result = (*client->requestVector[op]) (client); } if (result != FSSuccess) { if (client->noClientException != FSSuccess) CloseDownClient(client); break; } } FlushAllOutput (); } /* reset if server is a drone and has run out of clients */ if (drone_server && nClients == 0) { dispatchException |= DE_RESET; } if (dispatchException) { /* re-read the config file */ if (dispatchException & DE_RECONFIG) { NoticeF("Re-reading config file\n"); if (ReadConfigFile(configfilename) != FSSuccess) ErrorF("couldn't parse config file\n"); SetConfigValues(); dispatchException &= ~DE_RECONFIG; } /* flush all the caches */ if (dispatchException & DE_FLUSH) { NoticeF("flushing all caches\n"); CacheReset(); dispatchException &= ~DE_FLUSH; } /* reset */ if (dispatchException & DE_RESET) { NoticeF("resetting\n"); break; } /* die *now* */ if (dispatchException & DE_TERMINATE) { NoticeF("terminating\n"); kill_all_clients(); exit(0); break; } } } kill_all_clients(); dispatchException = 0; }