void *openspy_mod_run(modLoadOptions *options)
{
int sda,sd;
socklen_t psz;
struct sockaddr_in peer;
memset(&peer,0,sizeof(peer));
int on=1;
memcpy(&servoptions,options,sizeof(modLoadOptions));
conn = mysql_init(NULL);
mysql_options(conn,MYSQL_OPT_RECONNECT, (char *)&on);
/* Connect to database */
if (!mysql_real_connect(conn, servoptions.mysql_server,
servoptions.mysql_user, servoptions.mysql_password, servoptions.mysql_database, 0, NULL, CLIENT_MULTI_RESULTS)) {
fprintf(stderr, "%s\n", mysql_error(conn));
return NULL;
}
peer.sin_port = htons(SEARCHPORT);
peer.sin_family = AF_INET;
peer.sin_addr.s_addr = servoptions.bindIP;
sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on))
< 0) return NULL;
if(bind(sd, (struct sockaddr *)&peer, sizeof(struct sockaddr_in))
< 0) return NULL;
if(listen(sd, SOMAXCONN)
< 0) return NULL;
for(;;) {
psz = sizeof(struct sockaddr_in);
sda = accept(sd, (struct sockaddr *)&peer, &psz);
if(sda <= 0) continue;
if(!do_db_check()) {
sendError(sda,"Database Error: try again later");
close(sda);
continue; //TODO: send database error message
}
handleConnection(sda);
}
}
void ServerApp::run(void) {
// Opens the socket
m_sock.open();
// Make it reuse the address if possible
m_sock.setSocketOptions(NAbstractSocket::REUSE_ADDRESS);
// Listens
m_sock.execListen();
NMessage::print() << "Server is up an running";
// Starts receiving connections
while (true) {
NTcpSocket *client = NULL;
NMessage::print() << "Waiting for connection";
client = m_sock.waitForConnected();
handleConnection(client);
NWarning::print() << "Client disconnected";
// Release memory
delete client;
}
}
void startNetwork(int port) {
//// Begin Socket code... take CIS432 interested in what this all means
struct sockaddr_in serv_addr;
struct sockaddr_in clnt_addr;
socklen_t clnt_len;
int srvsockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if(srvsockfd < 0) {
printf("Socket could not be acquired!\n");
return;
}
bzero((char*)&serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
((char*)&serv_addr.sin_addr.s_addr)[0] = 127;
((char*)&serv_addr.sin_addr.s_addr)[1] = 0;
((char*)&serv_addr.sin_addr.s_addr)[2] = 0;
((char*)&serv_addr.sin_addr.s_addr)[3] = 1;
serv_addr.sin_port = htons(port);
if(bind(srvsockfd,(struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
printf("Socket bind failed!\n");
return;
}
if(listen(srvsockfd,1)<0) {
printf("Impossible listen failure\n");
return;
}
clnt_len = sizeof(clnt_addr);
//// End Socket code... take CIS432 interested in what this all means
//
// !! need to repeat this part in a way that doesn't lock up the program
//
while(1) {
int sockfd = accept(srvsockfd, (struct sockaddr*) &clnt_addr, &clnt_len);
handleConnection(sockfd);
}
}
/*
* Constructor for the Server class, sets up the ui and begins handling connections.
*/
Server::Server(QWidget *parent) : QMainWindow(parent)
{
setupUi(this);
// Startup TCP server
tcpServer = new QTcpServer(this);
// Exit if server fails to start
if (!tcpServer->listen(QHostAddress::Any, 1500)) {
QMessageBox::critical(this, tr("FaceServer"), tr("Unable to start the server: %1.").arg(tcpServer->errorString()));
close();
return;
}
QString ipAddress;
QList<QHostAddress> ipAddressesList = QNetworkInterface::allAddresses();
// use the first non-localhost IPv4 address
for (int i = 0; i < ipAddressesList.size(); ++i) {
if (ipAddressesList.at(i) != QHostAddress::LocalHost && ipAddressesList.at(i).toIPv4Address()) {
ipAddress = ipAddressesList.at(i).toString();
break;
}
}
// if we did not find one, use IPv4 localhost
if (ipAddress.isEmpty())
ipAddress = QHostAddress(QHostAddress::LocalHost).toString();
// Update statusLabel
statusLabel->setText(tr("The server is running on\n\nIP: %1\nport: %2\n\n").arg(ipAddress).arg(tcpServer->serverPort()));
// Setup connections
connect(tcpServer, SIGNAL(newConnection()), this, SLOT(handleConnection()));
connect(kickButton, SIGNAL(clicked()), this, SLOT(kickSelected()));
}
void serverListen(int port) {
int listenfd = socket(AF_INET, SOCK_STREAM,0);
static struct sockaddr_in serverAddress;
static struct sockaddr_in clientAddress;
serverAddress.sin_family = AF_INET;
//serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddress.sin_addr.s_addr = htonl((127<<24)|1); //127.0.0.1
serverAddress.sin_port = htons(port);
if (listenfd<0) fail("Couldn't create listen socket");
if ( bind(listenfd,(struct sockaddr*)&serverAddress,sizeof(serverAddress)) <0 )
fail("couldn't bind socket");
if (listen(listenfd,64) < 0)
fail("listen() failed");
for(;;) {
int length = sizeof(clientAddress);
int socketfd = accept(listenfd,(struct sockaddr *) &clientAddress, &length);
if (socketfd < 0) fail("failure on accept()");
int pid = fork();
if (pid < 0) fail("fork Failed!?");
if (pid == 0) {
close(listenfd);
handleConnection(socketfd);
fail("We should never have gotten to this line of code");
}
close(socketfd);
}
}
bool Server::start() {
connect(m_tcp_server, SIGNAL(newConnection()), this, SLOT(handleConnection()));
return m_tcp_server->listen(QHostAddress::LocalHost, 0);
}
int main(int argc, char *argv[])
{
struct sockaddr_in relay_addr, client_addr, server_addr;
int in_port, out_port, sockfd, client_socket;
socklen_t addr_len;
if (argc != 4)
{
fprintf(stderr, "usage: relay <incoming_port> <server_ip_addr> <server_port>\n");
exit(1);
}
/* parse port numbers */
in_port = atoi(argv[1]);
if (in_port < MIN_PORT || in_port > MAX_PORT)
{
fprintf(stderr, "relay: Invalid Incoming Port Number\n");
exit(1);
}
out_port = atoi(argv[3]);
if (out_port < MIN_PORT || out_port > MAX_PORT)
{
fprintf(stderr, "relay: Invalid Outgoing Port Number\n");
exit(1);
}
/* build relay address data structure */
memset((char *)&relay_addr, 0, sizeof(relay_addr));
relay_addr.sin_family = AF_INET;
relay_addr.sin_addr.s_addr = INADDR_ANY;
relay_addr.sin_port = htons(in_port);
/* build server address data structure */
memset((char *)&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
if(inet_pton(AF_INET, argv[2], &server_addr.sin_addr) == 0)
{
fprintf(stderr, "relay: Malformed Server IP Address\n");
exit(1);
}
server_addr.sin_port = htons(out_port);
/* setup passive open */
if ((sockfd = socket(PF_INET, SOCK_STREAM, 0 /*default protocol*/)) < 0)
printErrorAndExit("relay: socket");
if (bind(sockfd, (struct sockaddr *)&relay_addr, sizeof(relay_addr)) < 0)
printErrorAndExit("relay: bind");
listen(sockfd, MAX_PENDING);
/* wait for connection, then receive and handle */
while (TRUE)
{
addr_len = sizeof(client_addr);
if ((client_socket = accept(sockfd, (struct sockaddr *)&client_addr, &addr_len)) < 0)
printErrorAndExit("relay: accept");
handleConnection(client_socket, &server_addr);
}
close(sockfd);
return 0;
}
void ConnectionsConfigWidget::saveConfiguration(void)
{
try
{
attribs_map attribs;
/* If add or update buttons are enabled when saving the configs indicates
that user forgot to click on these buttons and register the connection,
so in order to do not lost the data pgModeler will ask to save the connection. */
if(add_tb->isEnabled() || update_tb->isEnabled())
{
Messagebox msg_box;
msg_box.show(trUtf8("There is a connection being created or edited! Do you want to save it?"),
Messagebox::ALERT_ICON, Messagebox::YES_NO_BUTTONS);
if(msg_box.result()==QDialog::Accepted)
handleConnection();
}
config_params[GlobalAttributes::CONNECTIONS_CONF].clear();
/* Workaround: When there is no connection, to prevent saving an empty file, is necessary to
fill the attribute CONNECTIONS with white spaces */
if(connections.empty())
config_params[GlobalAttributes::CONNECTIONS_CONF][ParsersAttributes::CONNECTIONS]=QString(" ");
else
{
for(Connection *conn : connections)
{
attribs=conn->getConnectionParams();
if(attribs[Connection::PARAM_SERVER_FQDN].isEmpty())
attribs[Connection::PARAM_SERVER_FQDN]=attribs[Connection::PARAM_SERVER_IP];
attribs[ParsersAttributes::ALIAS]=attribs[Connection::PARAM_ALIAS];
attribs[ParsersAttributes::AUTO_BROWSE_DB]=(conn->isAutoBrowseDB() ? ParsersAttributes::_TRUE_ : QString());
attribs[ParsersAttributes::CONNECTION_TIMEOUT]=attribs[Connection::PARAM_CONN_TIMEOUT];
schparser.ignoreUnkownAttributes(true);
config_params[GlobalAttributes::CONNECTIONS_CONF][ParsersAttributes::CONNECTIONS]+=
schparser.getCodeDefinition(GlobalAttributes::TMPL_CONFIGURATIONS_DIR +
GlobalAttributes::DIR_SEPARATOR +
GlobalAttributes::SCHEMAS_DIR +
GlobalAttributes::DIR_SEPARATOR +
GlobalAttributes::CONNECTIONS_CONF +
GlobalAttributes::SCHEMA_EXT,
attribs);
schparser.ignoreUnkownAttributes(false);
}
}
schparser.ignoreUnkownAttributes(true);
BaseConfigWidget::saveConfiguration(GlobalAttributes::CONNECTIONS_CONF, config_params);
schparser.ignoreUnkownAttributes(false);
}
catch(Exception &e)
{
throw Exception(e.getErrorMessage(),e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
}
}
int main( int /* argc */, char ** /* argv */ ) {
struct sigaction sa;
sa.sa_handler = & sigterm;
sigemptyset( &sa.sa_mask );
sa.sa_flags = 0;
int rv = sigaction( SIGTERM, & sa, NULL );
if( rv != 0 ) {
fprintf( stderr, "sigaction() failed (%d): '%s', aborting.\n", errno, strerror( errno ) );
exit( 5 );
}
rv = sigaction( SIGINT, & sa, NULL );
if( rv != 0 ) {
fprintf( stderr, "sigaction() failed (%d): '%s', aborting.\n", errno, strerror( errno ) );
exit( 5 );
}
int listenSocket = socket( PF_INET, SOCK_STREAM, 0 );
if( listenSocket == -1 ) {
fprintf( stderr, "socket() failed (%d): '%s'; aborting.\n", errno, strerror( errno ) );
exit( 1 );
}
/*
* listen()ing to an unbound port selects a random free port automagically.
*
struct sockaddr_in listenAddr;
listenAddr.sin_family = AF_INET;
listenAddr.sin_port = htons( 21737 );
listenAddr.sin_addr.s_addr = INADDR_ANY;
rv = bind( listenSocket, (struct sockaddr *)(& listenAddr), sizeof( listenAddr ) );
if( rv != 0 ) {
fprintf( stderr, "bind() failed (%d): '%s'; aborting.\n", errno, strerror( errno ) );
exit( 2 );
}
*/
rv = listen( listenSocket, 0 );
if( rv != 0 ) {
fprintf( stderr, "listen() failed (%d): '%s'; aborting.\n", errno, strerror( errno ) );
exit( 3 );
}
struct sockaddr_in listenAddr;
socklen_t listenAddrLen = sizeof( struct sockaddr_in );
rv = getsockname( listenSocket, (struct sockaddr *)(& listenAddr), & listenAddrLen );
if( rv != 0 ) {
fprintf( stderr, "getsockname() failed (%d): '%s'; aborting.\n", errno, strerror( errno ) );
exit( 5 );
}
if( listenAddrLen != sizeof( struct sockaddr_in ) ) {
fprintf( stderr, "getsockname() returned bogus address, aborting.\n" );
exit( 6 );
}
fprintf( stdout, "listen_port = %d\n", ntohs( listenAddr.sin_port ) );
rv = fflush( stdout );
if( rv != 0 ) {
fprintf( stderr, "fflush( stdout ) failed (%d): '%s'; aborting.\n", errno, strerror( errno ) );
exit( 7 );
}
registerAllHandlers();
registerTestUsers();
while( 1 ) {
struct sockaddr_in remoteAddr;
socklen_t raSize = sizeof( remoteAddr );
int remoteSocket = accept( listenSocket, (struct sockaddr *)(& remoteAddr), & raSize );
if( remoteSocket == -1 ) {
fprintf( stderr, "accept() failed(%d): '%s'; aborting.\n", errno, strerror( errno ) );
exit( 4 );
}
handleConnection( remoteSocket );
}
return 0;
} // end main()
void Server::start( const char *port_number, const char *dir )
{
/// -- Building and binding socket >>
int socket_file_descriptor, new_socket_file_descriptor;
int yes = 1;
int rv;
struct addrinfo hints, *servinfo, *p;
struct sockaddr_storage client_address;
struct sigaction sig_action;
socklen_t sin_size;
char s[INET6_ADDRSTRLEN];
memset( &hints, 0, sizeof hints );
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
if (( rv = getaddrinfo( NULL, port_number, &hints, &servinfo )) != 0 ) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
exit(1);
}
for ( p = servinfo; p != NULL; p = p->ai_next ) {
if (( socket_file_descriptor = socket( p->ai_family, p->ai_socktype, p->ai_protocol)) == -1 ){
perror("Server error on socket creation");
continue;
}
if ( setsockopt( socket_file_descriptor, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1 ){
perror("Critical error setsockopt");
exit(1);
}
if ( bind( socket_file_descriptor, p->ai_addr, p->ai_addrlen) == -1 ){
close(socket_file_descriptor);
perror("Server error on binding to port");
continue;
}
break;
}
if ( p == NULL ){
fprintf(stderr, "Critical error, failed to bind\n");
exit(2);
}
freeaddrinfo(servinfo);
/// -- Building and binding socket ^^
if ( listen( socket_file_descriptor, 10) == -1 ){
perror("Critical error on call to listen");
exit(1);
}
sig_action.sa_handler = sigchld_handler;
sigemptyset(&sig_action.sa_mask);
sig_action.sa_flags = SA_RESTART;
if ( sigaction(SIGCHLD, &sig_action, NULL) == -1){
perror("Critical error on sigaction");
exit(1);
}
printf("Server is running and waiting for connections on port %s\n", port_number);
// - change working dir -
if (chdir( dir ) == -1) {
printf("Error in Changing Directory: %d\n", errno);
} else {
char crdir[FILENAME_MAX];
printf("Directory Changed to: %s\n", getcwd(crdir, sizeof(crdir)));
}
// - change workind dir -
while(1){
sin_size = sizeof client_address;
new_socket_file_descriptor = accept( socket_file_descriptor, (struct sockaddr *) &client_address, &sin_size);
if ( new_socket_file_descriptor == -1){
perror("Server error on accept");
continue;
}
inet_ntop( client_address.ss_family, get_in_addr((struct sockaddr *) &client_address), s, sizeof s);
printf("[%d]Server received connection from %s\n", getpid(), s);
if ( !fork() ){
handleConnection(socket_file_descriptor, new_socket_file_descriptor);
}
close(new_socket_file_descriptor);
}
}
int main(int argc, char *argv[])
{
if (argc < 2) {
errorAndExit("Missing second argument (port number).\n");
}
// share clientIds between processes
client1 = mmap(NULL, sizeof *client1, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
client2 = mmap(NULL, sizeof *client2, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
client3 = mmap(NULL, sizeof *client3, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
client4 = mmap(NULL, sizeof *client4, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
client5 = mmap(NULL, sizeof *client5, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
// create socket with socket() syscall
int socketFd = socket(AF_INET, SOCK_STREAM, 0);
if (socketFd < 0) {
errorAndExit("Error opening socket.\n");
}
// bind socket to address
struct sockaddr_in serverAddress;
memset((char *) &serverAddress, '\0', sizeof(serverAddress));
serverAddress.sin_family = AF_INET;
serverAddress.sin_addr.s_addr = INADDR_ANY;
serverAddress.sin_port = htons(atoi(argv[1])); // argv[1] contains port number
if (bind(socketFd, (struct sockaddr *) &serverAddress, sizeof(serverAddress)) < 0) {
errorAndExit("Error binding to server address. Maybe port is already in use?\n");
}
// listen for connections
listen(socketFd, 5); // allow up to 5 pending connections
// accept connections as they come in
while (1) {
struct sockaddr_in clientAddress;
socklen_t clientLength = sizeof(clientAddress);
int newSocketFd = accept(socketFd, (struct sockaddr *) &clientAddress, &clientLength);
if (newSocketFd < 0) {
errorAndExit("Error accepting socket connection.\n");
}
pid_t pid = fork(); // fork a new process
if (pid < 0) {
errorAndExit("Error on fork() syscall.\n");
}
if (pid == 0) {
printf("New child process.\n");
close(socketFd);
handleConnection(newSocketFd);
exit(0);
}
close(newSocketFd);
}
// close socket
close(socketFd);
return 0;
}
TcpServer::TcpServer(QObject *parent) : QObject(parent)
{
server = new QTcpServer(this);
connect(server, SIGNAL(newConnection()) , this, SLOT(handleConnection()));
}
int main(int ac, char **av) {
ssize_t l;
char buf[2000];
int r;
int n;
/* Socket variables */
int s, exp;
u_int yes=1;
int port;
struct sockaddr_in me, them;
socklen_t sl = sizeof(struct sockaddr_in);
struct pollfd fds[2];
/*Initialization*/{
port=3811;
bzero(&me,sizeof(me));
me.sin_family= AF_INET;
me.sin_port=htons(port);
s=socket(AF_INET,SOCK_DGRAM,0);
bind(s,(struct sockaddr *)&me,sizeof(me));
exp=socket(AF_INET,SOCK_STREAM,0);
setsockopt(exp,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes));
bind(exp,(struct sockaddr *)&me,sizeof(me));
listen(exp,10);
bzero(&fds,sizeof(fds));
fcntl(s,F_SETFL,O_NONBLOCK);
fcntl(exp,F_SETFL,O_NONBLOCK);
fds[0].fd = s;
fds[0].events |= POLLIN;
fds[1].fd = exp, fds[1].events |= POLLIN;
db_create(&db,NULL,0);
db->set_cachesize(db, 0, 512*1024*1024, 0);
db->open(db,NULL,"stats.db",NULL,DB_BTREE,DB_CREATE|DB_TRUNCATE,0);
signal(SIGHUP,hup);
signal(SIGINT,die);
signal(SIGTERM,die);
signal(SIGCHLD,child);
signal(SIGUSR1,truncatedb);
daemon(1,0);
}
/* Loop! loop! loop! */
for(;;) {
n=0;
r=poll(fds,2,-1);
/* Process incoming UDP queue */
while(( fds[0].revents & POLLIN ) &&
((l=recvfrom(s,&buf,1500,0,NULL,NULL))!=-1)) {
if (l==EAGAIN)
break;
handleMessage((char *)&buf,l);
n++;
/* Still handle export connections under high load */
if (n==5000)
break;
}
/* Process incoming TCP queue */
while((fds[1].revents & POLLIN ) &&
((r=accept(exp,(struct sockaddr *)&them,&sl))!=-1)) {
if (r==EWOULDBLOCK)
break;
handleConnection(r);
}
}
return(0);
}
