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();
}
