int create_client(){
// kode for å koble til og server og sende og motta melding
// Rekkefølge
// * Lage socket - socket() og sette variablene i sockaddr_in
// * Koble til - connect()
// * Motta velkomstmelding - recv()
// * Sende og motta meldinger - send()
// Lager socket og initialisere en sockaddr_in og setter dens verdier.
struct sockaddr_in *server_addr;
struct sockaddr_in temp;
server_addr = &temp;
int socketfd;
int socket_pair[2];
struct socket_pack sp;
pthread_t channel;
socketfd = socket(AF_INET, SOCK_STREAM,0);
if(socketfd== -1){
printf("error opening socket");
return -1;
}
struct in_addr host_addr;
if(inet_pton(AF_INET, HOST,&host_addr) <=0){
printf("error creating host address");
return -1;
}
server_addr->sin_port = htons(PORT);
server_addr->sin_addr = host_addr;
server_addr->sin_family = AF_INET;
// Kobler til serveren ved hjelp av socketen og server_addr som er castet fra sockaddr_in til sockaddr
if(connect(socketfd, (struct sockaddr* )server_addr,sizeof(*server_addr)) == -1){
printf("error connecting to server");
return -1;
}
socketpair(PF_LOCAL, SOCK_STREAM, 0, socket_pair);
sp.intern_com = socket_pair[0];
sp.extern_com = socketfd;
pthread(&channel, NULL, server_client_comunication, (void *) &sp);
return socket_pair[0]
}
void* Server::servicing(void* arg)
{
Server* server = (Server*)arg;
Service serv = server->service;
server->lock.lock();
bool flag = server->runn;
server->lock.unlock();
while(flag)
{
int new_fd = server->Accept();
if (new_fd == -1)
{
perror("accept");
continue;
}
else
{
Thread pthread(serv, &new_fd);
pthread.execute();
}
}
return NULL;
}
pid_t createChildProcess(string serverRootDirectory,int sp[],int sockfd)
{
pid_t pid;
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sp) == -1)
{
perror("socketpair");
exit(1);
}
if((pid=fork())==0)
{
char pidStr[10];
memset(pidStr, 0, 10);
sprintf(pidStr, "%ld", (long)getpid());
string lgname = "CHServer-";
lgname.append(pidStr);
Logger plogger = LoggerFactory::getLogger(lgname);
servd = serverRootDirectory;
string filename;
stringstream ss;
ss << serverRootDirectory;
ss << getpid();
ss >> filename;
filename.append(".cntrl");
plogger << ("generated file " + filename) << endl;
ofstream cntrlfile;
cntrlfile.open(filename.c_str());
cntrlfile << "Process Running" << endl;
cntrlfile.close();
close(sockfd);
//SelEpolKqEvPrt selEpolKqEvPrtHandler;
//selEpolKqEvPrtHandler.initialize(sp[1]);
ThreadPool pool;
if(!isThreadprq)
{
pool.init(30);
}
struct stat buffer;
while(stat (serverCntrlFileNm.c_str(), &buffer) == 0)
{
/*int nfds = selEpolKqEvPrtHandler.getEvents();
if (nfds == -1)
{
perror("poller wait child process");
plogger << "\n----------poller child process----" << endl;
}
else*/
{
int fd = receive_fd(sp[1]);
//selEpolKqEvPrtHandler.reRegisterServerSock();
#ifdef OS_MINGW
u_long bMode = 0;
ioctlsocket(fd, FIONBIO, &bMode);
#else
fcntl(fd, F_SETFL, O_SYNC);
#endif
char buf[10];
memset(buf, 0, 10);
int err;
if((err=recv(fd,buf,10,MSG_PEEK))==0)
{
close(fd);
plogger << "Socket conn closed before being serviced" << endl;
continue;
}
try
{
if(isThreadprq)
{
ServiceTask *task = new ServiceTask(fd,serverRootDirectory);
Thread pthread(&service, task);
pthread.execute();
}
else
{
ServiceTask *task = new ServiceTask(fd,serverRootDirectory);
task->setCleanUp(true);
pool.submit(task);
}
}
catch(const char* err)
{
plogger << "Exception occurred while processing ServiceTask request - " << err << endl;
}
catch(...)
{
plogger << "Standard exception occurred while processing ServiceTask request " << endl;
}
}
}
}
pid_t createChildProcess(string serverRootDirectory,int sp[],int sockfd)
{
pid_t pid;
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sp) == -1)
{
perror("socketpair");
exit(1);
}
if((pid=fork())==0)
{
SSLHandler sSLHandler;
dlib = dlopen(Constants::INTER_LIB_FILE.c_str(), RTLD_NOW);
logger << endl <<dlib << endl;
if(dlib==NULL)
{
logger << dlerror() << endl;
logger.info("Could not load Library");
}
else
logger.info("Library loaded successfully");
if(isSSLEnabled)
{
/*HTTPS related*/
//client_auth=CLIENT_AUTH_REQUIRE;
/* Build our SSL context*/
ctx = sSLHandler.initialize_ctx((char*)configurationData.key_file.c_str(),(char*)configurationData.sec_password.c_str(),
configurationData.ca_list);
sSLHandler.load_dh_params(ctx,(char*)configurationData.dh_file.c_str());
SSL_CTX_set_session_id_context(ctx,
(const unsigned char*)&SSLHandler::s_server_session_id_context,
sizeof SSLHandler::s_server_session_id_context);
/* Set our cipher list */
if(ciphers){
SSL_CTX_set_cipher_list(ctx,ciphers);
}
if(configurationData.client_auth==2)
SSL_CTX_set_verify(ctx,SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,0);
else
SSL_CTX_set_verify(ctx,SSL_VERIFY_PEER,0);
}
servd = serverRootDirectory;
string filename;
stringstream ss;
ss << serverRootDirectory;
ss << getpid();
ss >> filename;
filename.append(".cntrl");
logger << "generated file " << filename << flush;
ofstream cntrlfile;
cntrlfile.open(filename.c_str());
cntrlfile << "Process Running" << flush;
cntrlfile.close();
struct msghdr msg;
struct iovec iov;
char buf[1];
int rv;
int connfd = -1;
char ccmsg[CMSG_SPACE(sizeof(connfd))];
struct cmsghdr *cmsg;
iov.iov_base = buf;
iov.iov_len = 1;
msg.msg_name = 0;
msg.msg_namelen = 0;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
/* old BSD implementations should use msg_accrights instead of
* msg_control; the interface is different. */
msg.msg_control = ccmsg;
msg.msg_controllen = sizeof(ccmsg); /* ? seems to work... */
close(sockfd);
fd_set master; // master file descriptor list
fd_set read_fds; // temp file descriptor list for select()
int fdmax; // maximum file descriptor number
FD_ZERO(&master); // clear the master and temp sets
FD_ZERO(&read_fds);
FD_SET(sp[1], &master);
// keep track of the biggest file descriptor
fdmax = sp[1]; // so far, it's this on
ThreadPool pool;
if(!isThreadprq)
{
pool.init(thrdpsiz,30,true);
}
PropFileReader pread;
propMap params = pread.getProperties(serverRootDirectory+"resources/security.prop");
logger << params.size() <<endl;
while(1)
{
read_fds = master; // copy it
int nfds = select(fdmax+1, &read_fds, NULL, NULL, NULL);
if (nfds == -1)
{
perror("select_wait child process");
logger << "\n----------epoll_wait child process----" << flush;
//break;
}
else
{
for(int n=0;n<=fdmax;n++)
{
if (FD_ISSET(n, &read_fds))
{
//int fd = receive_fd(sp[j][1]);
rv = recvmsg(n, &msg, 0);
if (rv == -1)
{
perror("recvmsg");
logger << "\n----------error occurred----" << flush;
exit(1);
}
cmsg = CMSG_FIRSTHDR(&msg);
if (!cmsg->cmsg_type == SCM_RIGHTS)
{
fprintf(stderr, "got control message of unknown type %d\n",cmsg->cmsg_type);
exit(1);
}
int fd = *(int*)CMSG_DATA(cmsg);
fcntl(fd, F_SETFL,O_SYNC);
char buf[10];
int err;
if((err=recv(fd,buf,10,MSG_PEEK))==0)
{
close(fd);
logger << "\nsocket conn closed before being serviced" << flush;
continue;
}
if(isThreadprq)
{
ServiceTask *task = new ServiceTask(n,serverRootDirectory,¶ms,
isSSLEnabled, ctx, sSLHandler, configurationData, dlib);
Thread pthread(&service, task);
pthread.execute();
delete task;
}
else
{
ServiceTask *task = new ServiceTask(n,serverRootDirectory,¶ms,
isSSLEnabled, ctx, sSLHandler, configurationData, dlib);
pool.execute(*task);
}
}
}
}
}
}
void* NBServer::servicing(void* arg)
{
NBServer* server = static_cast<NBServer*>(arg);
Service serv = server->service;
server->lock.lock();
bool flag = server->runn;
server->lock.unlock();
server->selEpolKqEvPrtHandler.initialize(server->sock);
SOCKET new_fd;
int nfds; // listen on sock_fd, new connection on new_fd
#ifdef OS_MINGW
struct sockaddr_in their_addr;
#else
struct sockaddr_storage their_addr;
#endif
socklen_t sin_size;
while(flag)
{
nfds = server->selEpolKqEvPrtHandler.getEvents();
if (nfds == -1)
{
perror("event handler main process");
if(errno==EBADF)
server->logger << "\nInavlid fd" <<flush;
else if(errno==EFAULT)
server->logger << "\nThe memory area pointed to by events is not accessible" <<flush;
else if(errno==EINTR)
server->logger << "\ncall was interrupted by a signal handler before any of the requested events occurred" <<flush;
else if(errno==EINVAL)
server->logger << "not a poll file descriptor, or maxevents is less than or equal to zero" << endl;
else
server->logger << "\nnot an epoll file descriptor" <<flush;
}
for(int n=0;n<nfds;n++)
{
SOCKET descriptor = server->selEpolKqEvPrtHandler.getDescriptor(n);
if (descriptor == server->sock)
{
new_fd = -1;
sin_size = sizeof their_addr;
new_fd = accept(server->sock, (struct sockaddr *)&their_addr, &sin_size);
if (new_fd == -1)
{
perror("accept");
continue;
}
else
{
server->selEpolKqEvPrtHandler.reRegisterServerSock();
server->selEpolKqEvPrtHandler.registerForEvent(new_fd);
}
}
else if (descriptor!=-1)
{
server->selEpolKqEvPrtHandler.unRegisterForEvent(descriptor);
char buf[10];
memset(buf, 0, sizeof(buf));
int err;
if((err=recv(descriptor,buf,10,MSG_PEEK))==0)
{
closesocket(descriptor);
continue;
}
#ifdef OS_MINGW
u_long bMode = 0;
ioctlsocket(descriptor, FIONBIO, &bMode);
#else
fcntl(descriptor, F_SETFL, O_SYNC);
#endif
Thread pthread(serv, &descriptor);
pthread.execute();
}
}
}
return NULL;
}
