int main (int argc, char **argv)
{
  gsk_init_without_threads (&argc, &argv);

  g_printerr ("TCP/IP server/client... ");
  addr = gsk_socket_address_ipv4_localhost (10306);
  create_server (addr);
  client_count = 0;
  create_client (addr);
  while (!done_test)
    gsk_main_loop_run (gsk_main_loop_default(), -1, NULL);
  g_object_unref (listener);
  listener = NULL;
  g_object_unref (addr);
  addr = NULL;
  g_printerr (" done.\n");

  client_count = 0;
  done_test = FALSE;

  g_printerr ("Local-socket server/client... ");
#define TEST_LOCAL_SOCKET_FNAME	"./test-socket-sc"
  addr = gsk_socket_address_local_new (TEST_LOCAL_SOCKET_FNAME);
  create_server (addr);
  client_count = 0;
  create_client (addr);
  while (!done_test)
    gsk_main_loop_run (gsk_main_loop_default(), -1, NULL);
  g_object_unref (listener);
  g_object_unref (addr);
  g_printerr (" done.\n");

  return 0;
}

/*
static struct sigaction sa={
   .sa_handler = SIG_IGN
};
*/
int server(int port, int maxevents)
{
 
  // sigaction(SIGINT, &sa, 0);
  // sigaction(SIGTERM, &sa, 0);  
   
   int srv_fd = -1;
   int epoll_fd = -1;
	reactor* r = 0;
	event_handler* seh = 0;
   
   if((srv_fd=create_server(port,"127.0.0.1")) == -1){
      return -1;
   }
   if((epoll_fd = create_epoll(srv_fd, maxevents)) == -1){
      return -1;
   }
   r = create_reactor(epoll_fd, maxevents);
	seh = create_acceptor(srv_fd, r);
	r->add_eh(r, seh);
   r->event_loop(r);
   
   destroy_reactor(r);
   os_close(srv_fd);
   os_close(epoll_fd);
	return 0;
}

int main()
{
    int listenfd = create_server(2000), connfd, i, pid, ret;
    char line[1000];
    pthread_t tid;
    struct request *r; 

    for (; ;) {
        if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL))<0) {
            perror("accept error : ");
            return -1;
        }
        getline(line, connfd);
        if ((ret = validate_request(line, connfd))>0) {
	    r = (struct request *)malloc(sizeof(struct request));
            r->request_t = ret;
            strcpy(r->req, line);
	    r->connfd = connfd;
	    printf("creating thread\n");
            ret = pthread_create(&tid, NULL, handle_request, (void *)r);
	}
        else {
	    close(connfd);
	}
    }
    close(listenfd);
    return 0;
}

int			main(int argc, char *argv[])
{
	int					sock;
	int					cs;
	unsigned int		cslen;
	struct sockaddr_in	csin;
	pid_t				pid;

	signal(SIGCHLD, SIG_IGN);
	if (argc != 2)
		usage(argv[0]);
	sock = create_server(ft_atoi(argv[1]));
	while ((cs = accept(sock, (struct sockaddr *)&csin, &cslen)) > 0)
	{
		if ((pid = fork()) == -1)
			return (-1);
		if (pid == 0)
		{
			soon(cs);
			exit(0);
			return (0);
		}
	}
	close(cs);
	close(sock);
	return (0);
}

int main(int argc, char* argv[])
{
	int ret;
	// create server
	ret = create_server();
	if(ret != 0)
	{
		printf("create server error\n");
		return -1;
	}

	// send broad cast
	ret = send_broadcast();
	if(ret != 0)
	{
		printf("send broadcast error\n");
		return -2;
	}

	// accept client
	ret = accept_client();
	if(ret != 0)
	{
		printf("accept_client error\n");
		return -3;
	}

	return 0;
}

void start_server(const char *ip, unsigned short port)
{
    //signal(SIGPIPE, SIG_IGN);
    signal(SIGPIPE, sig_handler);
    
    create_sock_list();
    start_timer();

    int err = 0;

    // create a TCP socket, bind and listen
    server_sock = socket(AF_INET, SOCK_STREAM, 0);
    fcntl(server_sock, F_SETFL, O_NONBLOCK);

    struct sockaddr_in addr;
    memset(&addr, 0 , sizeof(addr));
    addr.sin_family = AF_INET;
    //addr.sin_addr.s_addr = htons(INADDR_ANY);
    addr.sin_addr.s_addr = inet_addr(ip);
    addr.sin_port = htons(port);

    err = bind(server_sock, (struct sockaddr *) &addr, sizeof(addr));
    if(err)
    {
	   printf("bind error: %m\n"); 
    }

    listen(server_sock, 10);

    
    g_server = create_server(server_sock);
 

    return 0;
}

int main(int argc , char *argv[])
{
  int socket_desc;
  int * clients = malloc(sizeof(int) * 4);
  char buffer[32] = {0};
  fd_set readfs;
  
  init_soft_war();
  my_actopt(g_tab, 6, argc, argv);
  build_map();
  show_info_server();
  if (soft_war.type == 0)
    {
      socket_desc = create_server(soft_war.port);
      clients = accept_for_clients(socket_desc);
      put_clients_on_map();
      while (1)
	 {
	   select_for_soft_war(clients, &readfs, buffer);
	 }
    }
  else
    {
      play(argc, argv);
    }
  return (0);
}

int main(int argc, char **argv)
{
	signal(SIGINT, sigstop);
	signal(SIGQUIT, sigstop);
	signal(SIGTERM, sigstop);

	if ((fd_iav = open("/dev/iav", O_RDWR, 0)) < 0) {
		perror("open /dev/iav");
		return -1;
	}

	if (init_param(argc, argv) < 0) {
		usage();
		return -1;
	}

	parse_default_configs();

	if (create_server() < 0) {
		APP_ERROR("create_server");
		return -1;
	}
	main_handle();

	#if 0
	while (1) {
		main_loop();
	}
	#endif
	while (1) {
		sleep(1);
	}

	return 0;
}

int main(int argc, char *argv[]) {
    int server, port = PORT, opt_idx = 0, c;

    static struct option long_options[] = {
        { "debug", no_argument, &debug, 1 },
        { "port", required_argument, 0, 'p' }
    };

    while ((c = getopt_long(argc, argv, "p:", long_options, &opt_idx)) != -1) {
        switch (c) {
            case 'p': port = atoi(optarg); break;
            case '?':                      break;
        }
    }

    if ((server = create_server(port)) == -1) {
        return -1;
    }

    if (!debug) {
        daemon(0, 0);
    }

    accept_loop(server, handle_client);

    return 0;
}

int main(){
    signal(SIGINT, destroy_server);    
    char server_path[BUFFER];
    CREATE_SERVER_FIFO_NAME(server_path);
    create_server();
    char* client_pid = NULL;
    char hack;
    long pid = 0;
    FILE* server_fd = fopen(server_path, "r+");
    size_t len = 0;
    ssize_t read;

    while((read = getline(&client_pid, &len, server_fd)) != -1){
        fread(&hack, sizeof(char), 1, server_fd);
        pid = strtol(client_pid, NULL, 10);
        if(fork() == 0){
            printf("Creating server for Client %ld\n", pid);
            baby_server_read(pid);
        }
        if(signal(SIGINT, destroy_server) == SIG_ERR){
            printf("Signal didn't work");
        }
    }

    return 0;
}

void BuildServer::onItemClicked( QTableWidgetItem *item )
{
    qDebug() << "BuildServer: onItemClicked and emit toBuildTCP()" ;
    IP = tableWidget->item( item->row() , 1 )->text() ;
    connect( this , SIGNAL( toBuildTCP() ) , peopVSpeop , SLOT( create_server() ) ) ;
    emit toBuildTCP() ;   
}

void	ft_init(t_serv *e, char *av)
{
	e->counter = 0;
	e->port = ft_atoi(av);
	e->sock = create_server(e->port);
	getcwd(e->home, 1024);
	e->pwd = ft_strdup(e->home);
}

void do_sendfile(void)
{
	int in_fd;
	struct stat sb;
	off_t after_pos;
	int wait_status;
	int wait_stat;

	out_fd = create_server();

	if ((in_fd = open(in_file, O_RDONLY)) < 0) {
		tst_brkm(TBROK, cleanup, "open failed: %d", errno);
	 }
	if (stat(in_file, &sb) < 0) {
		tst_brkm(TBROK, cleanup, "stat failed: %d", errno);
	 }

	TEST(sendfile(out_fd, in_fd, NULL, sb.st_size));
	if ((after_pos = lseek(in_fd, 0, SEEK_CUR)) < 0) {
		tst_brkm(TBROK, cleanup,
			 "lseek after invoking sendfile failed: %d", errno);
	 }

	if (STD_FUNCTIONAL_TEST) {
		/* Close the sockets */
		shutdown(sockfd, SHUT_RDWR);
		shutdown(s, SHUT_RDWR);
		if (TEST_RETURN != sb.st_size) {
			tst_resm(TFAIL, "sendfile(2) failed to return "
				 "expected value, expected: %"PRId64", "
				 "got: %ld", (int64_t)sb.st_size, TEST_RETURN);
			kill(child_pid, SIGKILL);
		} else if (after_pos != sb.st_size) {
			tst_resm(TFAIL, "sendfile(2) failed to update "
				 " the file position of in_fd, "
				 "expected file position: %"PRId64", "
				 "actual file position %"PRId64,
				 (int64_t)sb.st_size, (int64_t)after_pos);
			kill(child_pid, SIGKILL);
		} else {
			tst_resm(TPASS, "functionality of sendfile() is "
				 "correct");
			wait_status = waitpid(-1, &wait_stat, 0);
		}
	} else {
		tst_resm(TPASS, "call succeeded");
		/* Close the sockets */
		shutdown(sockfd, SHUT_RDWR);
		shutdown(s, SHUT_RDWR);
		if (TEST_RETURN != sb.st_size) {
			kill(child_pid, SIGKILL);
		} else {
			wait_status = waitpid(-1, &wait_stat, 0);
		}
	}

	close(in_fd);
}

int main(int argc, char *argv[]) {
    Server *server = create_server();

    server->port = PORT;
    server->handler = &handler;
    server_start(server);

    return 0;
}

int main() {
  int fd[2] = {-1, -1};
  int server = -1, client = -1;
  FILE *fp = NULL;
  FILE *fp2 = NULL;
  fp = fopen("a.txt", "w");
  if (fp == NULL) {
    fprintf(stderr, "fopen(a.txt) failed: %s\n", strerror(errno));
    goto ERR_FOPEN;
  }
  fd[0] = fileno(fp);
  printf("a.txt:%d\n", fd[0]);

  fp2 = fopen("aa.txt", "w");
  if (fp2 == NULL) {
    fprintf(stderr, "fopen(aa.txt) failed: %s\n", strerror(errno));
    goto ERR_FOPEN;
  }
  fd[1] = fileno(fp2);
  printf("aa.txt:%d\n", fd[1]);
  server = create_server();
  if (server < 0) {
    fprintf(stderr, "create_server failed\n");
    goto ERR_CREATE_SERVER;
  }
  while(1) {
    client = accept(server, NULL, NULL);
    fprintf(stderr, "client accept %d\n", client);
    if (client < 0) {
      fprintf(stderr, "accept failed\n");
      goto ERR_ACCEPT;
    }

    if (send_file_descriptor(client, fd) < 0) {
      fprintf(stderr, "send_file_descriptor failed: %s\n", strerror(errno));
      goto ERR_SEND_FILE_DESCRIPTOR;
    }

    if (shutdown(client, SHUT_RDWR) < 0) {
      fprintf(stderr, "shutdown failed: %s\n", strerror(errno));
      goto ERR_SHUTDOWN;
    }
  }

ERR_SHUTDOWN:
ERR_SEND_FILE_DESCRIPTOR:
  close(client);
ERR_ACCEPT:
  close(server);
ERR_CREATE_SERVER:
  fclose(fp);
  fclose(fp2);
ERR_FOPEN:
  return 0;
}

void do_sendfile(int prot, int pass_unmapped_buffer)
{
	OFF_T *protected_buffer;
	int in_fd;
	struct stat sb;

	protected_buffer = mmap(NULL,
				sizeof(*protected_buffer),
				prot, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
	if (protected_buffer == MAP_FAILED) {
		tst_brkm(TBROK, cleanup, "mmap failed: %d", errno);
	}

	out_fd = create_server();

	if ((in_fd = open(in_file, O_RDONLY)) < 0) {
		tst_brkm(TBROK, cleanup, "open failed: %d", errno);
	}
	if (stat(in_file, &sb) < 0) {
		tst_brkm(TBROK, cleanup, "stat failed: %d", errno);
	}

	if (pass_unmapped_buffer) {
		if (munmap(protected_buffer, sizeof(*protected_buffer)) < 0) {
			tst_brkm(TBROK, cleanup, "munmap failed: %d", errno);
		}
	}

	TEST(sendfile(out_fd, in_fd, protected_buffer, sb.st_size));

	if (TEST_RETURN != -1) {
		tst_resm(TFAIL, "call succeeded unexpectedly");
	} else {
		TEST_ERROR_LOG(TEST_ERRNO);

		if (TEST_ERRNO != EFAULT) {
			tst_resm(TFAIL, "sendfile returned unexpected "
				 "errno, expected: %d, got: %d",
				 EFAULT, TEST_ERRNO);
		} else {
			tst_resm(TPASS, "sendfile() returned %d : %s",
				 TEST_ERRNO, strerror(TEST_ERRNO));
		}
	}

	shutdown(sockfd, SHUT_RDWR);
	shutdown(s, SHUT_RDWR);
	kill(child_pid, SIGKILL);
	close(in_fd);

	if (!pass_unmapped_buffer) {
		/* Not unmapped yet. So do it now. */
		munmap(protected_buffer, sizeof(*protected_buffer));
	}
}

int main()
{ int i;
  int server_socket = create_server();
  client_data * * client_list = malloc(max_users * sizeof(*client_list));
  for (i = 0; i < max_users; i += 1)
    client_list[i] = malloc(sizeof(client_data));
  for (i = 0; i < max_users; i += 1)
  { client_list[i]->initial_one = '0';
    client_list[i]->initial_two = '0';
    client_list[i]->room_socket = 0; }
  manage_clients(server_socket, client_list); }

int	main(int ac, char **av)
{
  t_ftp	f;

  f.port = (ac < 2 ? PORT_DEFAULT : av[1]);
  if (create_server(&f) == TRUE)
    while ((f.cs = xaccept(f.s, NULL, NULL)) > 0)
      get_client(&f);
  close(f.s);
  return (TRUE);
}

int		main(int argc, char **argv)
{
	int	sock;

	if (argc != 2)
		shell_perror("USAGE: ./serveur [port]");
	sock = create_server(ft_atoi(argv[1]));
	server(sock);
	close(sock);
	return (0);
}

/**
 * Creates a new server connection.
 *
 * The method creates a server connection instance
 * but does not put it in listen mode.
 * Anyway it selects and reserves a free channel to listen for
 * incoming connections on after the listen method is called.
 *
 * @param auth    JAVACALL_TRUE if authication is required
 * @param authz   JAVACALL_TRUE if authorization is required
 * @param enc     JAVACALL_TRUE if required to be encrypted
 * @param master  JAVACALL_TRUE if required to be a connection's master
 * @param pHandle pointer to connection handle variable,
 *               new connection handle returned in result.
 * @param cn pointer to variable, where reserved channel is returned in.
 *
 * @retval JAVACALL_OK on success,
 * @retval JAVACALL_FAIL otherwise
 */
javacall_result javacall_bt_rfcomm_create_server(
        javacall_bool auth,
        javacall_bool authz,
        javacall_bool enc,
        javacall_bool master,
        /*OUT*/javacall_handle* pHandle,
        /*OUT*/int* pCn)
{
    return create_server(RFCOMM, 
        -1, -1, auth, authz, enc, master, pHandle, pCn);
}