int NaClSrpcServerLoop(NaClSrpcImcDescType imc_socket_desc,
const NaClSrpcHandlerDesc methods[],
void* instance_data) {
NaClSrpcService* service;
/* Ensure we are passed a valid socket descriptor. */
if (NACL_INVALID_DESCRIPTOR == imc_socket_desc) {
NaClSrpcLog(NACL_SRPC_LOG_ERROR,
"NaClSrpcServerLoop: bad imc_socket_desc\n");
return 0;
}
/* Allocate the service structure. */
service = (struct NaClSrpcService*) malloc(sizeof(*service));
if (NULL == service) {
NaClSrpcLog(NACL_SRPC_LOG_ERROR,
"NaClSrpcServerLoop: service malloc failed\n");
return 0;
}
/* Build the service descriptor. */
if (!NaClSrpcServiceHandlerCtor(service, methods)) {
NaClSrpcLog(NACL_SRPC_LOG_ERROR,
"NaClSrpcServerLoop: NaClSrpcServiceHandlerCtor failed\n");
free(service);
return 0;
}
/* Process the RPCs. ServerLoop takes ownership of service. */
return ServerLoop(service, imc_socket_desc, instance_data);
}
void RunServer(void *pData)
{
try
{
// start server, assume started
Server::Get()->SetRunning(true);
// launch server loop (blocking call)
ServerLoop();
}
catch(...)
{
// server failed to start
OutputDebugString("Exception caught: ServerLoop failed.\n");
// stop server
Server::Get()->Stop();
}
// update ui, ignonred if not visible
//SendMessage(gConfigWnd, APP_EN_START, 0, (LPARAM)(BOOL)TRUE);
//SendMessage(gConfigWnd, APP_EN_STOP, 0, (LPARAM)(BOOL)FALSE);
// server has shut down
OutputDebugString("Server: Server Shutdown.\n");
Server::Get()->SetRunning(false);
}
int EntryPoint(void) {
SOCKET s;
StartLogger(TEXT(LOGFILE));
if(StartWinsock() != 0)
return -1;
s = CreateListenSocket(SERVER_PORT);
if((s == SOCKET_ERROR) || (s == INVALID_SOCKET))
return -1;
ServerLoop(s);
WSACleanup();
return 1;
}
main (int argc, char *argv[])
{
int socketFD;
int connectionFD;
char buffer[80];
int ret;
int port;
int schem;
if (argc < 3)
{
strcpy (buffer, "Usage: ServerSocket PortNumber ServerScheme [MaxClients]\n");
write (2, buffer, strlen (buffer));
exit (1);
}
port = atoi(argv[1]);
schem = atoi(argv[2]);
#ifdef DEBUG
printf("port: %s\n", argv[1]);
printf("schem: %s\n",argv[2]);
#endif
MAX_CLIENTS = 100;
if(argc == 4)
MAX_CLIENTS = atoi(argv[3]);
NUM_CONECTIONS = 0;
socketFD = createServerSocket (port);
if (socketFD < 0)
{
perror ("Error creating socket\n");
exit (1);
}
setScheme(schem);
signal(SIGCHLD,func_sigchild); // reprogramacio del signal sigchld, quan un fill acaba descompta el nombre de conexions totals
while (1) {
#ifdef DEBUG
printf("Conexions: [%d/%d]\n",NUM_CONECTIONS, MAX_CLIENTS);
#endif
ServerLoop(socketFD);
}
}
int main(int argc, char *argv[])
{
long_t master;
int32_t Signal;
GMI_RESULT Result = GMI_SUCCESS;
struct soap soap;
sigset_t NewMask;
sigset_t OldMask;
struct sigaction Sa;
//signal
Sa.sa_handler = SignalHandler;
sigfillset(&Sa.sa_mask);
Sa.sa_flags = SA_NOMASK;
sigemptyset(&NewMask);
for (Signal = 1; Signal <= _NSIG; ++Signal)
{
if ( ( Signal == SIGIO )
|| ( Signal == SIGPOLL )
|| ( Signal == SIGINT )
|| ( Signal == SIGQUIT )
|| ( Signal == SIGHUP )
|| ( Signal == SIGPIPE )
|| ( Signal == SIGSEGV )
)
{
sigaction(Signal, &Sa, NULL);
}
else
{
sigaddset(&NewMask, Signal);
}
}
sigprocmask(SIG_BLOCK, &NewMask, &OldMask);
//get debug opt
const char_t *OptString = "ei";
struct option Opts[] = {
{"error", no_argument, NULL, 'e'},
{"info", no_argument, NULL, 'i'},
{0, 0, 0, 0},
};
int C;
boolean_t ErrLog = false;
boolean_t InfoLog = false;
while ((C = getopt_long(argc, argv, OptString, Opts, NULL)) != -1)
{
switch (C)
{
case 'e':
ErrLog = true;
break;
case 'i':
InfoLog = true;
break;
default:
break;
}
printf("opts:%d:%d\n", ErrLog, InfoLog);
}
//log init
Result = LogInitial(ErrLog, InfoLog);
if (FAILED(Result))
{
ONVIF_ERROR("LogInitial fail, Result = 0x%lx\n", Result);
return Result;
}
//daemon register to daemon server
Result = DaemonRegister();
if (FAILED(Result))
{
ONVIF_ERROR("DaemonRegister fail, Result = 0x%lx\n", Result);
DEBUG_LOG(g_DefaultLogClient, e_DebugLogLevel_Exception, " DaemonRegister fail, Result = 0x%lx\n", Result);
return Result;
}
//system initial
Result = SysInitialize(GMI_ONVIF_AUTH_PORT);
if (FAILED(Result))
{
DaemonUnregister();
ONVIF_ERROR("SysInitialize fail, Result = 0x%lx\n", Result);
DEBUG_LOG(g_DefaultLogClient, e_DebugLogLevel_Exception, " SysInitialize fail, Result = 0x%lx\n", Result);
return Result;
}
//get onvif port, rtsp port
uint16_t SessionId = 0;
uint32_t AuthValue = 0;
SysPkgNetworkPort SysNetworkPort;
Result = SysGetNetworkPort(SessionId, AuthValue, &SysNetworkPort);
if (FAILED(Result))
{
g_ONVIF_Port = DEFAULT_SERVER_PORT;
g_RTSP_Port = DEFAULT_RTSP_PORT;
ONVIF_ERROR("SysGetNetworkPort fail, Result = 0x%lx\n", Result);
}
else
{
g_ONVIF_Port = SysNetworkPort.s_ONVIF_Port;
g_RTSP_Port = SysNetworkPort.s_RTSP_Port;
}
ONVIF_INFO("ONVIF_Port %d, RTSP_Port %d\n", g_ONVIF_Port, g_RTSP_Port);
//ptz service
__tptz__Initialize();
//soap server init
soap_init1(&soap, SOAP_ENC_MTOM);
soap.socket_flags = MSG_NOSIGNAL;
soap.accept_flags |= SO_LINGER;
soap.connect_flags |= SO_LINGER;
soap.linger_time = 2;
soap.bind_flags = SO_REUSEADDR;
soap.send_timeout = 2;
soap.recv_timeout = 2;
soap.accept_timeout = 10;
soap.connect_timeout = 10;
soap.keep_alive = 5;
soap_set_mode(&soap, SOAP_C_UTFSTRING);
master = soap_bind(&soap, NULL, g_ONVIF_Port, 30);
if (!soap_valid_socket(master))
{
ONVIF_ERROR("soap_bind fail, Result = 0x%lx\n", Result);
DEBUG_LOG(g_DefaultLogClient, e_DebugLogLevel_Exception, " soap_bind fail, Result = 0x%lx\n", Result);
soap_print_fault(&soap, stderr);
SysDeinitialize();
DaemonUnregister();
exit(1);
}
//main server start
ServerLoop(&soap);
ONVIF_INFO("soap_end start\n");
//soap release
soap_end(&soap);
soap_done(&soap);
ONVIF_INFO("soap_end stop\n");
//ptz deinitialize
__tptz__Deinitialize();
ONVIF_INFO("SysDeinitialize start\n");
SysDeinitialize();
ONVIF_INFO("SysDeinitialize end\n");
ONVIF_INFO("DaemonUnregister start\n");
//daemon unregister
DaemonUnregister();
ONVIF_INFO("DaemonUnregister end\n");
return 0;
}
int SSL_SOCKET :: ServerInit(bool NoLoop)
{
SECURITY_STATUS ss = 0;
/* if (wcslen(un))
{
// Find certificate in the store
// Open Certificate Store
hCS = CertOpenSystemStore(0,_T("MY"));
if (!hCS)
return -1;
CERT_RDN cert_rdn;
CERT_RDN_ATTR cert_rdn_attr;
cert_rdn.cRDNAttr = 1;
cert_rdn.rgRDNAttr = &cert_rdn_attr;
cert_rdn_attr.pszObjId = szOID_COMMON_NAME;
cert_rdn_attr.dwValueType = CERT_RDN_ANY_TYPE;
cert_rdn_attr.Value.cbData = (DWORD)wcslen(un);
cert_rdn_attr.Value.pbData = (BYTE *)un;
OurCertificate = CertFindCertificateInStore(hCS, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING ,0,cft,&cert_rdn,NULL);
}*/
if (IsExternalCert)
{
;
}
else
{
//BOOL AX;
OurCertificate = CreateOurCertificate();
}
// Configure our SSL SChannel
memset(&m_SchannelCred,0,sizeof(m_SchannelCred));
m_SchannelCred.dwVersion = SCHANNEL_CRED_VERSION;
m_SchannelCred.dwFlags |= SCH_CRED_NO_DEFAULT_CREDS;
m_SchannelCred.dwFlags = SCH_CRED_NO_DEFAULT_CREDS | SCH_CRED_NO_SYSTEM_MAPPER | SCH_CRED_REVOCATION_CHECK_CHAIN;
m_SchannelCred.hRootStore = hCS;
m_SchannelCred.dwMinimumCipherStrength = 128;
if (OurCertificate)
{
m_SchannelCred.cCreds = 1;
m_SchannelCred.paCred = &OurCertificate;
}
// AcquireCredentialsHandle
ss = AcquireCredentialsHandle(0,SCHANNEL_NAME,SECPKG_CRED_INBOUND,0,&m_SchannelCred,0,0,&hCred,0);
// ss = AcquireCredentialsHandle(0,UNISP_NAME,SECPKG_CRED_INBOUND,0,&m_SchannelCred,0,0,&hCred,0);
if (FAILED(ss))
return -1;
if (NoLoop)
return 0;
return ServerLoop();
}
// Start up our server
bool CServerSocket::StartServer( )
{
//struct sockaddr_in ain;
sock = socket( AF_INET, SOCK_STREAM, 0 );
if (sock == INVALID_SOCKET)
{
Log( MSG_FATALERROR, "Could not create a socket : %s", strerror(errno) );
return false;
}
int optval = 1;
if(setsockopt(sock, SOL_SOCKET,SO_KEEPALIVE,(const char*)&optval,sizeof(optval))==-1)
{
Log(MSG_ERROR, "setsockopt:SO_KEEPALIVE" );
}
setsockopt(sock, IPPROTO_TCP,TCP_NODELAY,(const char*)&optval,sizeof(optval));
ain.sin_family = AF_INET;
ain.sin_addr.s_addr = INADDR_ANY;
ain.sin_port = htons( port );
memset(&(ain.sin_zero), '\0', 8);
if ( bind( sock, (const sockaddr*)&ain, sizeof( struct sockaddr ) ) )
{
Log( MSG_FATALERROR, "Could not bind socket: %s", strerror(errno) );
closesocket( sock );
sock = INVALID_SOCKET;
return false;
}
if ( listen( sock, SOMAXCONN ) == -1 )
{
Log( MSG_FATALERROR, "Could not listen on socket : %s", strerror(errno) );
closesocket( sock );
sock = INVALID_SOCKET;
return false;
}
if (LOG_THISSERVER == LOG_CHARACTER_SERVER)
{
//struct sockaddr_in ain;
sckISC = socket( AF_INET, SOCK_STREAM, 0 );
if (sckISC == INVALID_SOCKET) {
Log( MSG_ERROR, "Could not create valid ISC socket (WSK2 ERROR: %i)", WSAGetLastError( ) );
return false;
}
int optval = 1;
if(setsockopt(sckISC, SOL_SOCKET,SO_KEEPALIVE,(const char*)&optval,sizeof(optval))==-1)
{
Log(MSG_ERROR, "setsockopt:SO_KEEPALIVE" );
}
setsockopt(sckISC, IPPROTO_TCP,TCP_NODELAY,(const char*)&optval,sizeof(optval));
sain.sin_family = AF_INET;
sain.sin_addr.s_addr = INADDR_ANY;
sain.sin_port = htons( Config.CharsPort);//29110 );
memset(&(sain.sin_zero), '\0', 8);
if ( bind( sckISC, (const sockaddr*)&sain, sizeof( struct sockaddr ) ) )
{
Log( MSG_FATALERROR, "Could not bind socket: %s", strerror(errno) );
closesocket( sckISC );
sckISC = INVALID_SOCKET;
return false;
}
if ( listen( sckISC, SOMAXCONN ) == -1 )
{
Log( MSG_FATALERROR, "Could not listen on socket : %s", strerror(errno) );
closesocket( sckISC );
sckISC = INVALID_SOCKET;
return false;
}
Log( MSG_INFO, "opened ISC poort %i",29110 );
}
if (LOG_THISSERVER == LOG_WORLD_SERVER)
{
struct sockaddr_in ain;
sckISC = socket( AF_INET, SOCK_STREAM, 0 );
if (sckISC == INVALID_SOCKET) {
Log( MSG_ERROR, "Could not create valid ISC socket (WSK2 ERROR: %i)", WSAGetLastError( ) );
return false;
}
ain.sin_family = AF_INET;
ain.sin_addr.s_addr = inet_addr(Config.CharIP);//( "127.0.0.1" );
ain.sin_port = htons( Config.CharPort);//29110 );
if ( connect( sckISC, (const sockaddr*)&ain, sizeof( ain ) ) == SOCKET_ERROR ) {
Log( MSG_ERROR, "Could not connect to ISC (WSK2 ERROR: %i)", WSAGetLastError( ) );
closesocket( sckISC );
sckISC = INVALID_SOCKET;
return false;
}
sckISCII = socket( AF_INET, SOCK_STREAM, 0 );
if (sckISCII == INVALID_SOCKET) {
Log( MSG_ERROR, "Could not create valid ISC socket (WSK2 ERROR: %i)", WSAGetLastError( ) );
return false;
}
int optval = 1;
if(setsockopt(sckISCII, SOL_SOCKET,SO_KEEPALIVE,(const char*)&optval,sizeof(optval))==-1)
{
Log(MSG_ERROR, "setsockopt:SO_KEEPALIVE" );
}
setsockopt(sckISCII, IPPROTO_TCP,TCP_NODELAY,(const char*)&optval,sizeof(optval));
sain.sin_family = AF_INET;
sain.sin_addr.s_addr = INADDR_ANY;
sain.sin_port = htons( Config.WorldsPort );//29210 );
memset(&(sain.sin_zero), '\0', 8);
if ( bind( sckISCII, (const sockaddr*)&sain, sizeof( struct sockaddr ) ) )
{
Log( MSG_FATALERROR, "Could not bind socket: %s", strerror(errno) );
closesocket( sckISCII );
sckISCII = INVALID_SOCKET;
return false;
}
if ( listen( sckISCII, SOMAXCONN ) == -1 )
{
Log( MSG_FATALERROR, "Could not listen on socket : %s", strerror(errno) );
closesocket( sckISCII );
sckISCII = INVALID_SOCKET;
return false;
}
Log( MSG_INFO, "opened ISC poort %i",Config.WorldsPort );//29210 );
}
if (LOG_THISSERVER == LOG_LOGIN_SERVER)
{
/* struct sockaddr_in ain; */
sckISC = socket( AF_INET, SOCK_STREAM, 0 );
if (sckISC == INVALID_SOCKET) {
Log( MSG_ERROR, "Could not create valid ISC socket (WSK2 ERROR: %i)", WSAGetLastError( ) );
return false;
}
if (listen(sckISC, SOMAXCONN) == -1)
{
Log(MSG_FATALERROR, "Could not listen on socket : %s", strerror(errno));
closesocket(sckISC);
sckISC = INVALID_SOCKET;
return false;
}
}
isActive = true;
if ( !this->OnServerReady( ) )
{
Log( MSG_FATALERROR, "Server could not start" );
closesocket( sock );
sock = INVALID_SOCKET;
isActive = false;
return false;
}
Log( MSG_INFO, "Server started on port %i and is listening.", port );
//ISCThread( );
ServerLoop( );
// Nothing past here is ever really called
OnServerDie( );
closesocket( sock );
return true;
}
void StartHost( char const *host_name,
char const *service,
int addr_family = AF_INET )
{
addrinfo hints;
addrinfo *addr;
if (nullptr == host_name) {
host_name = "localhost";
}
memset( &hints, 0, sizeof(hints) );
// Which network layer it's using - usually want to UNSPEC, since it doesn't matter. But since we're hard coding
// the client sides connection, we will likely want to use AF_INET when we want to bind an address
hints.ai_family = addr_family;
hints.ai_socktype = SOCK_STREAM; // STREAM based, determines transport layer (TCP)
hints.ai_flags = AI_PASSIVE; // used for binding/listening
int status = getaddrinfo( host_name, service, &hints, &addr );
if (status != 0) {
printf( "Failed to create socket address: %s\n", gai_strerror(status) );
return;
}
addrinfo *iter;
char addr_name[INET6_ADDRSTRLEN];
SOCKET host_socket = INVALID_SOCKET;
for (iter = addr; iter != nullptr; iter = iter->ai_next) {
inet_ntop( iter->ai_family, GetInAddr(iter->ai_addr), addr_name, INET6_ADDRSTRLEN );
printf( "Trying to bind addr: family[%i] type[%i] %s : %s\n",
iter->ai_family,
iter->ai_socktype,
addr_name, service );
host_socket = socket( iter->ai_family, iter->ai_socktype, iter->ai_protocol );
if (host_socket == INVALID_SOCKET) {
int error = WSAGetLastError();
printf( "Failed to create socket: Socket Error[%i]\n", error );
continue;
}
int result = bind( host_socket, iter->ai_addr, (int)(iter->ai_addrlen) );
if (SOCKET_ERROR == result) {
closesocket(host_socket);
host_socket = INVALID_SOCKET;
int error = WSAGetLastError();
printf( "Failed to bind: Socket Error[%i]\n", error );
continue;
}
break;
}
freeaddrinfo(addr);
if (host_socket == INVALID_SOCKET) {
printf( "Could not create host.\n" );
return;
}
printf( "Socket bound...\n" );
// DO HOST STUFF!
// To be continued...
ServerLoop( host_socket );
// DONE WITH HOST STUFF!
closesocket(host_socket);
host_socket = INVALID_SOCKET;
}
