// Constructor
SipTlsServer::SipTlsServer(int port,
SipUserAgent* userAgent,
UtlBoolean bUseNextAvailablePort,
const char* szBindAddr) :
// Use PORT_NONE here to prevent SipTcpServer from opening a socket.
SipTcpServer(PORT_NONE,
userAgent,
"SipTlsServer-%d",
FALSE,
NULL,
SIP_TRANSPORT_TLS)
{
Os::Logger::instance().log(FAC_SIP, PRI_DEBUG,
"SipTlsServer[%s]::_ '%s' %s port %d szBindAddr = '%s'",
getName().data(), mName.data(),
bUseNextAvailablePort ? "use next available" : "specific",
port, szBindAddr);
// mServerPort is set to PORT_NONE by SipTcpServer::SipTcpServer.
mServerPort = port;
mpServerBrokerListener = new SipServerBrokerListener(this);
mIsSecureTransport = true;
Os::Logger::instance().log(FAC_SIP, PRI_DEBUG,
"SipTlsServer[%s]::_ port %d",
getName().data(), mServerPort);
if (szBindAddr && 0 != strcmp(szBindAddr, "0.0.0.0"))
{
mDefaultIp = szBindAddr;
createServerSocket(szBindAddr, mServerPort, bUseNextAvailablePort);
}
else
{
int numAddresses = 0;
const HostAdapterAddress* adapterAddresses[MAX_IP_ADDRESSES];
getAllLocalHostIps(adapterAddresses, numAddresses);
for (int i = 0; i < numAddresses; i++)
{
createServerSocket(adapterAddresses[i]->mAddress.data(),
mServerPort,
bUseNextAvailablePort);
if (0 == i)
{
// use the first IP address in the array
// for the 'default ip'
mDefaultIp = adapterAddresses[i]->mAddress.data();
}
delete adapterAddresses[i];
}
}
// Correct mDefaultPort, which is set to SIP_PORT in SipProtocolServerBase.
mDefaultPort = SIP_TLS_PORT;
}
// Constructor
SipUdpServer::SipUdpServer(int port,
SipUserAgent* userAgent,
const char* natPingUrl,
int natPingFrequencySeconds,
const char* natPingMethod,
int udpReadBufferSize,
UtlBoolean bUseNextAvailablePort,
const char* szBoundIp) :
SipProtocolServerBase(userAgent, "UDP", "SipUdpServer-%d"),
mStunRefreshSecs(28),
mStunOptions(0)
{
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"SipUdpServer::_ port = %d, bUseNextAvailablePort = %d, szBoundIp = '%s'",
port, bUseNextAvailablePort, szBoundIp);
if (szBoundIp && 0 != strcmp(szBoundIp, "0.0.0.0"))
{
mDefaultIp = szBoundIp;
int serverSocketPort = port;
createServerSocket(szBoundIp, serverSocketPort, bUseNextAvailablePort, udpReadBufferSize);
}
else
{
int numAddresses = 0;
const HostAdapterAddress* adapterAddresses[MAX_IP_ADDRESSES];
getAllLocalHostIps(adapterAddresses, numAddresses);
for (int i = 0; i < numAddresses; i++)
{
int serverSocketPort = port;
createServerSocket(adapterAddresses[i]->mAddress.data(),
serverSocketPort,
bUseNextAvailablePort,
udpReadBufferSize);
if (0 == i)
{
// use the first IP address in the array
// for the 'default ip'
mDefaultIp = adapterAddresses[i]->mAddress.data();
}
delete adapterAddresses[i];
}
}
if(natPingUrl && *natPingUrl)
mNatPingUrl = natPingUrl;
if(natPingMethod && *natPingMethod)
mNatPingMethod = natPingMethod;
else
mNatPingMethod = "PING";
mNatPingFrequencySeconds = natPingFrequencySeconds;
}
// Constructor
SipTlsServer::SipTlsServer(int port,
SipUserAgent* userAgent,
UtlBoolean bUseNextAvailablePort,
UtlString certNickname,
UtlString certPassword,
UtlString dbLocation,
const char* szBindAddr) :
SipProtocolServerBase(userAgent, "TLS", "SipTlsServer %d"),
mCertNickname(certNickname),
mCertPassword(certPassword),
mDbLocation(dbLocation),
mTlsInitCode(OS_SUCCESS)
{
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"SipTlsServer::_ port = %d, bUseNextAvailablePort = %d",
port, bUseNextAvailablePort);
mServerPort = port ;
mpServerBrokerListener = new SipServerBrokerListener(this);
#ifdef _DISABLE_MULTIPLE_INTERFACE_SUPPORT
szBindAddr = "0.0.0.0" ;
#endif
OsSysLog::add(FAC_SIP,PRI_DEBUG,"SipTlsServer::~ port %d", port);
if (szBindAddr && 0 != strcmp(szBindAddr, "0.0.0.0"))
{
mDefaultIp = szBindAddr;
createServerSocket(szBindAddr, mServerPort, bUseNextAvailablePort);
}
else
{
int numAddresses = MAX_IP_ADDRESSES;
const HostAdapterAddress* adapterAddresses[MAX_IP_ADDRESSES];
getAllLocalHostIps(adapterAddresses, numAddresses);
for (int i = 0; i < numAddresses; i++)
{
createServerSocket(adapterAddresses[i]->mAddress.data(),
mServerPort,
bUseNextAvailablePort);
if (0 == i)
{
// use the first IP address in the array
// for the 'default ip'
mDefaultIp = adapterAddresses[i]->mAddress.data();
}
delete adapterAddresses[i];
}
}
mDefaultPort = SIP_TLS_PORT;
}
int startServices(int *echoFD, int *dtFD)
{
int echoSockFD;
int daytimeSockFD;
int rc,rc1;
rc = createServerSocket(ECHO_PORT,&echoSockFD) ;
rc1 = createServerSocket(DAYTIME_PORT,&daytimeSockFD) ;
rc = rc + rc1;
*echoFD = echoSockFD;
*dtFD = daytimeSockFD;
return rc;
}
// Constructor
SipUdpServer::SipUdpServer(int port,
SipUserAgent* userAgent,
int udpReadBufferSize,
UtlBoolean bUseNextAvailablePort,
const char* szBoundIp) :
SipProtocolServerBase(userAgent,
SIP_TRANSPORT_UDP,
"SipUdpServer-%d"),
mStunRefreshSecs(28),
mStunOptions(0)
{
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"SipUdpServer[%s]::_ port = %d, bUseNextAvailablePort = %d, szBoundIp = '%s'",
getName().data(), port, bUseNextAvailablePort, szBoundIp);
if (szBoundIp && 0 != strcmp(szBoundIp, "0.0.0.0"))
{
// If an address was supplied, only open a socket on that address.
mDefaultIp = szBoundIp;
int serverSocketPort = port;
createServerSocket(szBoundIp, serverSocketPort, bUseNextAvailablePort,
udpReadBufferSize);
}
else
{
// If no address was supplied, get all local addresses and open
// sockets on all of them.
int numAddresses = 0;
const HostAdapterAddress* adapterAddresses[MAX_IP_ADDRESSES];
getAllLocalHostIps(adapterAddresses, numAddresses);
if (numAddresses >= 1)
{
// Use the first IP address in the array for the 'default IP address'.
mDefaultIp = adapterAddresses[0]->mAddress.data();
}
for (int i = 0; i < numAddresses; i++)
{
int serverSocketPort = port;
createServerSocket(adapterAddresses[i]->mAddress.data(),
serverSocketPort,
bUseNextAvailablePort,
udpReadBufferSize);
delete adapterAddresses[i];
}
}
}
int main(){
struct sockaddr_in addr, cliaddr;
socklen_t cliaddrlen = sizeof(cliaddr);
// create the socket
int fd = createServerSocket(addr, cliaddr, sizeof(cliaddr));
// receive msg-es
while(1){
// accept a connection
printf("> Accepting connection \n");
int connfd = accept(fd, (struct sockaddr*) &cliaddr, &cliaddrlen);
if(connfd == -1){
printf("! Error in accepting connection");
}
// announce the connection
// announce_client(&cliaddr.sin_addr);
// create the thread
printf("> Creating thread \n");
pthread_t tid;
int flag = pthread_create(&tid, // ID
NULL, // attributes
receiveMsg, // routine
&connfd); // arguments of routine
if(flag<0){
perror("! Error in creating a thread.");
}
}
printf("> Exit server");
close(fd);
return 0;
}
static int server(void){
int ret=0;
struct socket* _clientSocket;
struct socket * _socket = createServerSocket();
if(!_socket)
{
printk("server socket created failed\n");
return -1;
}
while (1){
/*listen*/
ret=_socket->ops->listen(_socket,10);
if(ret<0){
printk("server: listen error\n");
return ret;
}
printk("server:listen ok!\n");
ret=_socket->ops->accept(_socket,_clientSocket,10);
if(ret<0){
printk("server:accept error!\n");
return ret;
}
printk("server: accept ok, Connection Established\n");
processConnection(_clientSocket);
}
sock_release(_socket);
}
void Connection::init(int port)
{
int serverFd = createServerSocket();
sockaddr_in address = bindSocket(serverFd, port);
serverSocket = new Socket(-1, serverFd, address);
listen(serverFd, MAX_CONNECTIONS);
}
LineServer *createLineServer(char *port, LineServerCallback callback)
{
LineServer *result = ALLOCATE_OBJECT(LineServer);
result->state = RPC_SERVER_STATE_STOPPED;
result->open_connections = 0;
result->socket = createServerSocket(port);
result->callback = callback;
return result;
}
shared_ptr<TSimpleServer> TSimpleServerCreator::createSimpleServer() {
shared_ptr<TSimpleServer> server;
if (duplexProtocolFactory_.get() != nullptr) {
server.reset(new TSimpleServer(processor_,
createServerSocket(),
getDuplexTransportFactory(),
duplexProtocolFactory_));
} else {
server.reset(new TSimpleServer(processor_,
createServerSocket(),
transportFactory_,
getProtocolFactory()));
}
SyncServerCreator::configureServer(server);
return server;
}
static void
on_create(HWND hWnd)
{
LOGFONT lf = {0};
HFONT hfont;
CreateWindow(
TEXT("STATIC"),
NULL,
WS_CHILD | WS_VISIBLE | SS_CENTER,
0, 0,
500, 100,
hWnd,
(HMENU)(IDC_PRIM),
hInst,
NULL);
lf.lfHeight = 36;
lf.lfPitchAndFamily = FF_SWISS;
hfont = CreateFontIndirect(&lf);
SendDlgItemMessage(hWnd, IDC_PRIM,
WM_SETFONT, (WPARAM)hfont, TRUE);
CreateWindow(
TEXT("STATIC"),
NULL,
WS_CHILD | WS_VISIBLE | SS_CENTER,
0, 100,
500, 100,
hWnd,
(HMENU)(IDC_SEC),
hInst,
NULL);
lf.lfHeight = 24;
lf.lfPitchAndFamily = FF_SWISS;
hfont = CreateFontIndirect(&lf);
SendDlgItemMessage(hWnd, IDC_SEC,
WM_SETFONT, (WPARAM)hfont, TRUE);
CreateWindow(
TEXT("STATIC"),
NULL,
WS_CHILD | SS_CENTER,
0, 100,
500, 100,
hWnd,
(HMENU)(IDC_WATCHDOG_TIMER),
hInst,
NULL);
createServerSocket();
WSAAsyncSelect(mySocket, hWnd,
M_PACKET,
FD_READ);
}
// main()
int main() {
printf("beginning of program in C\n");
//struct lightBulb bulb;
struct timeEmulate bulbTime;
int i, level[10];
bool isHealth = true;
pthread_t threadPush, threadTime;
pthread_mutex_init(&lock, NULL);
printf("Do we get here?\n");
// Obtain socket FD using PORT_WEATHER to communicate with weather.py
int servSockWeather = createServerSocket(PORT_WEATHER);
pthread_mutex_lock(&lock);
bulb.health = 0;
pthread_mutex_unlock(&lock);
bulbTime.hour = 0;
bulbTime.min = 0;
for (i = 0; i < 10; i++){
level[i] = i+1;
}
printf("do we get to this in main?\n");
/* Two threads that run in background to update the time of the bulb and also push/pull notifications periodically to
* Parse Cloud
*/
pthread_create(&threadPush, NULL, threadPushNotifications, NULL);
pthread_create(&threadTime, NULL, updateBulbTime, (void *)(&bulbTime));
//MOVED THIS FROM ITS ORIGINAL SPOT
updateIntensity(0, NULL);
printf("what about here?\n");
while(1)
{
char str[4];
updateBasedOnTime(&bulbTime, level, servSockWeather);
// doesn't get to here...printf("after UBOT?");
sprintf(str, "%d", getIntensity(&bulb));
clientSendSocket(PORT_INTENSITY, str);
printf("Main loop thing\n");
while (bulb.health == 2)
{
if (isHealth)
{
updateOnParse("Intensity", 0);
updateOnParse("Health", 2);
//updateOnParse("Intensity", 0, "Health", 2);
isHealth = false;
printf("Bulb Health is screwed up\n");
}
} // Avoid crazy looping during bulb DAMAGED condition. Optimization to avoid excess CPU cycle usage.
isHealth = true;
}
return 0;
}
void initializeSockets() {
int i;
dbg_clear(DBG_SIM, "SIM: Initializing sockets\n");
pthread_mutex_init(&(tos_state.pause_lock), NULL);
pthread_cond_init(&(tos_state.pause_cond), NULL);
pthread_cond_init(&(tos_state.pause_ack_cond), NULL);
for (i = 0; i < MAX_CLIENT_CONNECTIONS; i++) {
commandClients[i] = -1;
eventClients[i] = -1;
batchState[i] = 0;
}
eventMask = 0xffff;
commandServerSocket = createServerSocket(COMMAND_PORT);
eventServerSocket = createServerSocket(EVENT_PORT);
pthread_mutex_init(&eventClientsLock, NULL);
pthread_cond_init(&eventClientsCond, NULL);
pthread_create(&eventAcceptThread, NULL, eventAcceptThreadFunc, NULL);
pthread_create(&commandReadThread, NULL, commandReadThreadFunc, NULL);
socketsInitialized = 1;
}
OlySocket::OlySocket(int port, bool multiple) {
#ifdef WIN32
WSADATA wsaData;
if (WSAStartup(0x0202, &wsaData) != 0) {
logg->logError(__FILE__, __LINE__, "Windows socket initialization failed");
handleException();
}
#endif
if (multiple) {
createServerSocket(port);
} else {
createSingleServerConnection(port);
}
}
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);
}
}
/**
* initSocket
*
* Création d'un socket en parcourant tous les ports depuis 1025 à la recherche
* d'un port disponible
*
* @param {int *} port Va être complété avec le port utilisé
*
* @return {SOCKET} Le socket
*/
SOCKET initSocket(int *port) {
int p = 1025;
int listener;
while ((listener = createServerSocket(p)) == -1) {
p++;
close(listener);
if (p > 65535) {
break;
}
}
if (listener >= 0) {
*port = p;
if (listen(listener, MAX_QUEUE) == -1) {
perror("listen()");
exit(EXIT_FAILURE);
}
}
return listener;
}
main (int argc, char *argv[])
{
int socketFD;
int connectionFD;
char buffer[80];
int ret;
int port;
if (argc != 2)
{
strcpy (buffer, "Usage: ServerSocket PortNumber\n");
write (2, buffer, strlen (buffer));
exit (1);
}
port = atoi(argv[1]);
socketFD = createServerSocket(port);
if (socketFD < 0)
{
perror ("Error creating socket\n");
exit (1);
}
while (1) {
connectionFD = acceptNewConnections (socketFD);
if (connectionFD < 0)
{
perror ("Error establishing connection \n");
deleteSocket(socketFD);
exit (1);
}
doServiceFork(connectionFD);
}
}
int main() {
//TODO: thread pool
struct sockaddr_in addr, cliaddr;
socklen_t cliaddrlen = sizeof(cliaddr);
// create the socket
int fd = createServerSocket(addr);
// receive msg-es
while (1) { // THREAD POOL MISSING
// accept a connection
printf("> Accepting connection \n");
int* connfd = malloc(sizeof(int));
*connfd = accept(fd, (struct sockaddr*) &cliaddr, &cliaddrlen);
if (*connfd == -1) {
printf("! Error in accepting connection");
}
// announce the connection
// create the thread
printf("> Creating thread \n");
pthread_t tid;
int flag = pthread_create(&tid, // ID
NULL, // attributes
receiveMsg, // routine
connfd); // arguments of routine
if (flag < 0) {
sendErrorServer(connfd);
perror("! Error in creating a thread.");
}
}
printf("> Exit server");
// there should be a release for the CONNFD here, but there is no logical exit from the server
close(fd); // close the socket
return 0;
}
int main()
{
int sockfd1,sockfd2;
sockfd1 = createServerSocket(8233);
if(sockfd1 == -1)
{
LINLOG("failed to create server socket\n");
return 1;
}
sockfd2 = createServerSocket(8234);
if(sockfd2 == -1)
{
LINLOG("failed to create server socket\n");
close(sockfd1);
return 1;
}
int epollfd = epoll_create(1);
if(epollfd == -1)
{
LINLOG("failed to create epoll\n");
close(sockfd1);
close(sockfd2);
return 1;
}
struct epoll_event ev;
memset(&ev,0,sizeof(ev));
ev.events = EPOLLIN;
ev.data.fd = sockfd1;
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd1, &ev) == -1) {
LINLOG("failed to add epoll event to sockfd1 %d\n",errno);
close(sockfd1);
close(sockfd2);
close(epollfd);
return 1;
}
memset(&ev,0,sizeof(ev));
ev.events = EPOLLIN;
ev.data.fd = sockfd2;
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd2, &ev) == -1) {
LINLOG("failed to add epoll event sockfd2 %d\n",errno);
close(sockfd1);
close(sockfd2);
close(epollfd);
return 1;
}
for (;;) {
memset(&ev,0,sizeof(ev));
int nfds = epoll_wait(epollfd, &ev, 1, -1);
if (nfds == -1) {
LINLOG("epoll_wait:%d",errno);
close(sockfd1);
close(sockfd2);
close(epollfd);
return 1;
}
printf("got event from %d in %d,%d\n",ev.data.fd,sockfd1,sockfd2);
sockaddr_in local;
socklen_t size = sizeof(local);
int clientfd = accept(ev.data.fd,(sockaddr*)&local,&size);
if(clientfd == -1)
{
LINLOG("failed to accept:%d\n",errno);
close(sockfd1);
close(sockfd2);
close(epollfd);
return 1;
}
close(clientfd);
}
close(sockfd1);
close(sockfd2);
close(epollfd);
return 0;
}
void OlySocket::createSingleServerConnection(int port) {
createServerSocket(port);
mSocketID = acceptConnection();
closeServerSocket();
}
static void connectServer(const char *stty, const char *dev) {
int fdmax, newfd;
fd_set master, read_fds;
FD_ZERO(&master);
FD_ZERO(&read_fds);
int serverfd;
serverfd = createServerSocket(dev);
if (serverfd < 0) {
syslog(LOG_ERR, "mTerm_server: Failed to create server socket\n");
return;
}
struct ttyRaw* tty_sol;
tty_sol = setTty(openTty(stty), 1);
if (!tty_sol) {
syslog(LOG_ERR, "mTerm_server: Failed to set tty to raw mode\n");
close(serverfd);
return;
}
struct bufStore* buf;
buf = createBuffer(dev, FILE_SIZE_BYTES);
if (!buf || (buf->buf_fd < 0)) {
syslog(LOG_ERR, "mTerm_server: Failed to create the log file\n");
closeTty(tty_sol);
close(serverfd);
return;
}
FD_SET(serverfd, &master);
FD_SET(tty_sol->fd,&master);
fdmax = (serverfd > tty_sol->fd) ? serverfd : tty_sol->fd;
for(;;) {
read_fds = master;
if (select(fdmax + 1, &read_fds, NULL, NULL, NULL) == -1) {
syslog(LOG_ERR, "mTerm_server: Server socket: select error\n");
break;
}
if (FD_ISSET(serverfd, &read_fds)) {
newfd = acceptClient(serverfd);
if (newfd < 0) {
syslog(LOG_ERR, "mTerm_server: Error on accepting client\n");
} else {
FD_SET(newfd, &master);
if (newfd > fdmax) {
fdmax = newfd;
}
}
}
if (FD_ISSET(tty_sol->fd, &read_fds)) {
if ( processSol(&master, serverfd, fdmax, tty_sol->fd, buf) < 0) {
break;
}
}
int i;
for(i = 0; i <= fdmax; i++) {
if (FD_ISSET(i, &read_fds)) {
if ((i == serverfd) || (i == tty_sol->fd)) {
continue;
} else {
processClient(&master, i, tty_sol->fd, buf);
}
}
}
}
closeTty(tty_sol);
close(serverfd);
closeBuffer(buf);
}
