int main(int argc, char* argv[]) { int port; int serverSocket, clientSocket; struct httpParams httpParam; system("clear"); if (argc != 2) { fprintf(stderr, "Usage: %s <Server Port>\n", argv[0]); exit(1); } port = atoi(argv[1]); serverSocket = initializeServer(port); while(1) { clientSocket = getRequest(serverSocket); readFromClient(clientSocket); httpParam = prepareGetQuery(); sendToClient(clientSocket, httpParam); exit(1); } }
static int32 initializeHandshake(sslConn_t *clnConn, sslConn_t *svrConn, testCipherSpec_t cipherSuite, sslSessionId_t *sid) { int32 rc; rc = initializeServer(svrConn, cipherSuite); rc = initializeClient(clnConn, cipherSuite, sid); return rc; }
void RhrController::addClient(const Port *client) { if (!m_clients.empty()) { CERR << "not servicing client port " << *client << std::endl; } m_clients.insert(client); if (!m_rhr) { initializeServer(); } sendConfigObject(); tryConnect(); }
void server(int port) { int listenSocket = 0; int socket = 0; int processId = 0; char clientIp[16]; unsigned short *clientPort = NULL; // Set up the server initializeServer(&listenSocket, &port); // Loop to monitor the server socket while (1) { clientPort = (unsigned short*)malloc(sizeof(unsigned short)); // Block here and wait for new connections if ((socket = acceptConnectionIpPort(&listenSocket, clientIp, clientPort)) == -1) { systemFatal("Can't Accept Client"); } // Spawn process to deal with client processId = fork(); if (processId == 0) { close(listenSocket); // Process the child connection processConnection(socket, clientIp, (int)*clientPort); // Once we are done, exit free(clientPort); return; } else if (processId > 0) { // Since I am the parent, keep on going close(socket); free(clientPort); continue; } else { // Fork failed, should shut down as this is a serious issue systemFatal("Fork Failed To Create Child To Deal With Client"); } } printf("Server Closing!\n"); }
int main(int argc, char* argv[]){ if(argc > 2){ directory = argv[1]; struct stat st = {0}; if (stat(directory, &st) == -1) { mkdir(directory, 0700); } int port = atoi(argv[2]); initializeServer(port); return 0; } else{ printf("USAGE: ./dfs <SERVER DIRECTORY> <PORT NUMBER>\n"); } return 0; }
int __cdecl main(int argc, char *argv[]) { WORD wVersionRequested; WSADATA wsaData; int err; /* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */ wVersionRequested = MAKEWORD(2, 2); err = WSAStartup(wVersionRequested, &wsaData); if (err != 0) { /* Tell the user that we could not find a usable */ /* Winsock DLL. */ printf("WSAStartup failed with error: %d\n", err); return 1; } /* Confirm that the WinSock DLL supports 2.2.*/ /* Note that if the DLL supports versions greater */ /* than 2.2 in addition to 2.2, it will still return */ /* 2.2 in wVersion since that is the version we */ /* requested. */ if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) { /* Tell the user that we could not find a usable */ /* WinSock DLL. */ printf("Could not find a usable version of Winsock.dll\n"); WSACleanup(); return 1; } if (initializeServer() == -1) { printf("Could not initialize the server\n"); WSACleanup(); return 1; } /* Call WSACleanup when done using the Winsock dll */ WSACleanup(); }
Poco::Net::Context::Ptr ofSSLManager::getDefaultServerContext() { initializeServer(); // make sure it's initialized with something return Poco::Net::SSLManager::instance().defaultServerContext(); }
bool RhrController::handleParam(const vistle::Parameter *p) { if (p == m_rhrBasePort || p == m_rhrRemoteEndpoint || p == m_rhrRemotePort) { return initializeServer(); } else if (p == m_rhrConnectionMethod) { if ((m_rhrConnectionMethod->getValue() != ViaHub && m_forwardPort != 0) || m_forwardPort != m_rhrBasePort->getValue()) { if (m_module->rank() == 0) { if (m_forwardPort) m_module->removePortMapping(m_forwardPort); } m_forwardPort = 0; } switch (m_rhrConnectionMethod->getValue()) { case AutomaticHostname: { break; } case UserHostname: { break; } case ViaHub: { if (m_forwardPort != m_rhrBasePort->getValue()) { m_forwardPort = m_rhrBasePort->getValue(); if (m_module->rank() == 0) m_module->requestPortMapping(m_forwardPort, m_rhrBasePort->getValue()); } break; } case AutomaticReverse: { break; } case UserReverse: { break; } } return initializeServer(); } else if (p == m_depthPrec) { if (m_depthPrec->getValue() == 0) m_prec = 16; else m_prec = 24; if (m_rhr) m_rhr->setDepthPrecision(m_prec); return true; } else if (p == m_depthZfp) { m_zfp = m_depthZfp->getValue(); if (m_rhr) m_rhr->enableDepthZfp(m_zfp); return true; } else if (p == m_depthZfpMode) { m_zfpMode = (DepthCompressionParameters::ZfpMode)m_depthZfpMode->getValue(); if (m_rhr) m_rhr->setZfpMode(m_zfpMode); } else if (p == m_depthQuant) { m_quant = m_depthQuant->getValue(); if (m_rhr) m_rhr->enableQuantization(m_quant); return true; } else if (p == m_depthCompressMode) { m_depthCompress = (message::CompressionMode)m_depthCompressMode->getValue(); if (m_rhr) m_rhr->setDepthCompression(m_depthCompress); } else if (p == m_rgbaEncoding) { m_rgbaCodec = (CompressionParameters::ColorCodec)m_rgbaEncoding->getValue(); if (m_rhr) m_rhr->setColorCodec(m_rgbaCodec); return true; } else if (p == m_rgbaCompressMode) { m_rgbaCompress = (message::CompressionMode)m_rgbaCompressMode->getValue(); if (m_rhr) m_rhr->setColorCompression(m_rgbaCompress); } else if (p == m_sendTileSizeParam) { m_sendTileSize = m_sendTileSizeParam->getValue(); if (m_rhr) m_rhr->setTileSize(m_sendTileSize[0], m_sendTileSize[1]); return true; } else if (p == m_dumpImagesParam) { m_dumpImages = m_dumpImagesParam->getValue() != 0; if (m_rhr) m_rhr->setDumpImages(m_dumpImages); } return false; }
RhrController::RhrController(vistle::Module *module, int displayRank) : m_module(module) , m_imageOutPort(nullptr) , m_displayRank(displayRank) , m_rhrConnectionMethod(nullptr) , m_rhrLocalEndpoint(nullptr) , m_rhrBasePort(nullptr) , m_forwardPort(0) , m_rgbaEncoding(nullptr) , m_rgbaCodec(CompressionParameters::Jpeg_YUV444) , m_rgbaCompressMode(nullptr) , m_rgbaCompress(message::CompressionNone) , m_depthPrec(nullptr) , m_prec(24) , m_depthQuant(nullptr) , m_quant(true) , m_depthZfp(nullptr) , m_zfp(false) , m_depthZfpMode(nullptr) , m_zfpMode(DepthCompressionParameters::ZfpFixedRate) , m_depthCompressMode(nullptr) , m_depthCompress(message::CompressionLz4) , m_sendTileSizeParam(nullptr) , m_sendTileSize((vistle::Integer)256, (vistle::Integer)256) { m_imageOutPort = m_module->createOutputPort("image_out", "connect to COVER"); m_rhrConnectionMethod = module->addIntParameter("rhr_connection_method", "how local/remote endpoint should be determined", AutomaticHostname, Parameter::Choice); module->V_ENUM_SET_CHOICES(m_rhrConnectionMethod, ConnectionMethod); m_rhrBasePort = module->addIntParameter("rhr_base_port", "listen port for RHR server", 31590); module->setParameterRange(m_rhrBasePort, (Integer)1, (Integer)((1<<16)-1)); m_rhrLocalEndpoint = module->addStringParameter("rhr_local_address", "address where clients should connect to", "localhost"); m_rhrRemotePort = module->addIntParameter("rhr_remote_port", "port where renderer should connect to", 31589); module->setParameterRange(m_rhrRemotePort, (Integer)1, (Integer)((1<<16)-1)); m_rhrRemoteEndpoint = module->addStringParameter("rhr_remote_host", "address where renderer should connect to", "localhost"); m_rhrAutoRemotePort = module->addIntParameter("_rhr_auto_remote_port", "port where renderer should connect to", 0); module->setParameterRange(m_rhrAutoRemotePort, (Integer)0, (Integer)((1<<16)-1)); m_rhrAutoRemoteEndpoint = module->addStringParameter("_rhr_auto_remote_host", "address where renderer should connect to", "localhost"); m_sendTileSizeParam = module->addIntVectorParameter("send_tile_size", "edge lengths of tiles used during sending", m_sendTileSize); module->setParameterRange(m_sendTileSizeParam, IntParamVector(1,1), IntParamVector(16384, 16384)); std::vector<std::string> choices; m_rgbaEncoding = module->addIntParameter("color_codec", "codec for image data", m_rgbaCodec, Parameter::Choice); module->V_ENUM_SET_CHOICES_SCOPE(m_rgbaEncoding, CompressionParameters::ColorCodec, CompressionParameters); m_rgbaCompressMode = module->addIntParameter("color_compress", "compression for RGBA messages", m_rgbaCompress, Parameter::Choice); module->V_ENUM_SET_CHOICES(m_rgbaCompressMode, message::CompressionMode); m_depthZfp = module->addIntParameter("depth_zfp", "compress depth with zfp floating point compressor", (Integer)m_zfp, Parameter::Boolean); m_depthZfpMode = module->addIntParameter("zfp_mode", "Accuracy:, Precision:, Rate: ", (Integer)m_zfpMode, Parameter::Choice); module->V_ENUM_SET_CHOICES_SCOPE(m_depthZfpMode, DepthCompressionParameters::ZfpMode, DepthCompressionParameters); m_depthCompressMode = module->addIntParameter("depth_compress", "entropy compression for depth data", (Integer)m_depthCompress, Parameter::Choice); module->V_ENUM_SET_CHOICES(m_depthCompressMode, message::CompressionMode); m_depthQuant = module->addIntParameter("depth_quant", "DXT-like depth quantization", (Integer)m_quant, Parameter::Boolean); m_depthPrec = module->addIntParameter("depth_prec", "quantized depth precision", (Integer)(m_prec==24), Parameter::Choice); choices.clear(); choices.push_back("16 bit + 4 bits/pixel"); choices.push_back("24 bit + 3 bits/pixel"); module->setParameterChoices(m_depthPrec, choices); m_dumpImagesParam = module->addIntParameter("rhr_dump_images", "dump image data to disk", (Integer)m_dumpImages, Parameter::Boolean); initializeServer(); }