示例#1
0
int
main(int argc, char *argv[])
{
    int soc;
    /* 引数にポート番号が指定されているか? */
    if (argc <= 1) {
        (void) fprintf(stderr,"server port\n");
        return (EX_USAGE);
    }
    /* サーバソケットの準備 */
    if ((soc = server_socket(argv[1])) == -1) {
        (void) fprintf(stderr,"server_socket(%s):error\n", argv[1]);
        return (EX_UNAVAILABLE);
    }
    (void) fprintf(stdout, "ready for accept\n");
    /* アクセプトループ */
    accept_loop(soc);

    /* for (;;) { */
    /*     (void) fprintf(stdout, "just sleep\n"); */
    /*     sleep(5); */
    /* } */

    /* ソケットクローズ */
    (void) close(soc);
    return (EX_OK);
}
int main(int argc, char *argv[]){
  int soc;

  if(argc <= 1){
    fprintf(stderr, "server port\n");
    return(EX_USAGE);
  }

  if(argc >= 3 && argv[2][0] == 'n'){
    fprintf(stderr, "Nonblocking mode\n");
    g_mode = 'n';
  } else {
    g_mode = 'b';
  }
  
  if((soc = server_socket(argv[1])) == -1){
    fprintf(stderr, "server_socket(%s):error\n", argv[1]);
    return(EX_UNAVAILABLE);
  }
  fprintf(stderr, "ready for accept\n");
  
  accept_loop(soc);

  close(soc);
  return(EX_OK);
}
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;
}
示例#4
0
static int server(int offset)
{
	struct sockaddr_in saddr_in;
	struct sockaddr addr;
	unsigned int len;
	int sk, opt;

	bind_to_cpu(offset);
	if (nice(-20) < 0)
		perror("nice");

	sk = socket(PF_INET, SOCK_STREAM, 0);
	if (sk < 0)
		return error("socket");

	opt = 1;
	if (setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
		return error("setsockopt");

	saddr_in.sin_addr.s_addr = htonl(INADDR_ANY);
	saddr_in.sin_port = htons(net_port + offset);

	if (bind(sk, (struct sockaddr *) &saddr_in, sizeof(saddr_in)) < 0)
		return error("bind");

	if (listen(sk, 1) < 0)
		return error("listen");

	len = sizeof(addr);
	if (getsockname(sk, &addr, &len) < 0)
		return error("getsockname");

	return accept_loop(sk);
}
示例#5
0
void serve(int sockfd)
{
        if (listen(sockfd, 0) == -1) {
                perror("Cannot listen");
                exit(1);
        }

        accept_loop(sockfd);
}
示例#6
0
int
start_server()
{
	int soc;
	if ((soc = server_socket(PORT)) == -1) {
		(void) fprintf(stderr, "server_socket(%s):error\n", PORT);
		return (EX_UNAVAILABLE);
	}
	(void) fprintf(stderr, "ready for accept\n");
	accept_loop(soc);
	(void) close(soc);
	return 0;
}
示例#7
0
/* and in here we also loop for exosip events*/
void acceptor_process(dp_config *cfg)
{
	
	
	int i,k;
	unsigned int sock;
	
	LOG(L_INFO,"INFO:Acceptor process starting up...\n");
	
	listening_socks = pkg_malloc((cfg->acceptors_cnt+1)*sizeof(int));
	if (!listening_socks){
		LOG_NO_MEM("pkg",(cfg->acceptors_cnt+1)*sizeof(int));
		goto done;
	}
	memset(listening_socks,0,(cfg->acceptors_cnt+1)*sizeof(int));	
	k=0;
	for(i=0;i<cfg->acceptors_cnt;i++)
		if (create_socket(cfg->acceptors[i].port,cfg->acceptors[i].bind,&sock)){
			listening_socks[k++]=sock;			
		}	

	
	LOG(L_INFO,"INFO:... Acceptor opened sockets. Entering accept loop ...\n");		
	accept_loop();
	
	for(i=0;listening_socks[i];i++)
		close(listening_socks[i]);
	
	if (listening_socks) pkg_free(listening_socks);
#ifdef CDP_FOR_SER
#else
#ifdef PKG_MALLOC
	#ifdef PKG_MALLOC
		LOG(memlog, "Acceptor Memory status (pkg):\n");
		//pkg_status();
		#ifdef pkg_sums
			pkg_sums();
		#endif 
	#endif
#endif
		dp_del_pid(getpid());		
#endif		
done:		
	LOG(L_INFO,"INFO:... Acceptor process finished\n");
	exit(0);
}
int main(int argc, char *argv[]){
  int soc;

  if(argc <= 2){
    fprintf(stderr, "server1 address port\n");
    return(EX_USAGE);
  }
  
  if((soc = server_socket_by_hostname(argv[1], argv[2])) == -1){
    fprintf(stderr, "server_socket(%s, %s):error\n", argv[1], argv[2]);
    return(EX_UNAVAILABLE);
  }
  fprintf(stderr, "ready for accept\n");
  
  accept_loop(soc);

  close(soc);
  return(EX_OK);
}
示例#9
0
int
main(int argc, char *argv[], char *envp[])
{

    struct sigaction sa;
    int soc;
    /* 引数にポート番号が指定されているか? */
    if (argc <= 1) {
        (void) fprintf(stderr,"re-exec port\n");
        return (EX_USAGE);
    }

    if (argc == 3) {
        (void) fprintf(stderr,"skip daemonize\n");
    } else {
        /* デーモン化 */
        (void) daemonize(0, 0);
    }

    /* コマンドライン引数、環境変数のアドレスをグローバルに保持 */
    argc_ = &argc;
    argv_ = &argv;
    envp_ = &envp;
    /* SIGHUPのシグナルハンドラを指定 */
    (void) sigaction(SIGHUP, (struct sigaction *) NULL, &sa);
    sa.sa_handler = sig_hangup_handler;
    sa.sa_flags = SA_NODEFER;
    (void) sigaction(SIGHUP, &sa, (struct sigaction *) NULL);
    (void) fprintf(stderr, "sigaction():end\n");
    /* サーバソケットの準備 */
    if ((soc = server_socket(argv[1])) == -1) {
        (void) fprintf(stderr,"server_socket(%s):error\n", argv[1]);
        return (EX_UNAVAILABLE);
    }
    (void) fprintf(stderr, "ready for accept\n");
    /* アクセプトループ */
    accept_loop(soc);
    /* ソケットクローズ */
    (void) close(soc);
    return (EX_OK);
}
示例#10
0
int
main(int argc, char **argv)
{
    int ret;

    init_vars();
    init_args(argc, argv);

    ret = init_coroutine_env();
    if (ret != 0)
    {
        fprintf(stderr, "init async_coro failed\n");
        exit(-1);
    }

    if (accept_loop() != RET_SUCCESS)
    {
        fprintf(stderr, "accept_loop() failed\n");
        exit(-1);
    }

    return 0;
}
示例#11
0
int main(int argc, char ** argv)
{
	char *server, *service;
	struct addrinfo *addr_info, *p, hints;
	int ret, i;
	int sockets[128];
	int numsockets = 0;

	setProgName(argv[0]);	/* For our infoPrint/errorPrint functions */

	if (argc <= 1)
	{
		errorPrint("Simple Echo-Server");
		errorPrint("Usage: %s [BINDADDR] [SERVICE]", argv[0]);
		errorPrint("Example: %s localhost 8080", argv[0]);
		exit(1);
	}
	if (argc == 3) {
		server = argv[1];
		service = argv[2];
	} else {
		server = NULL;
		service = argv[1];
	}

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_protocol = IPPROTO_TCP;
	hints.ai_flags = AI_PASSIVE | AI_V4MAPPED;

	/* RTFM: getaddrinfo */
	ret = getaddrinfo(server, service, &hints, &addr_info);
	if (ret)
	{
		errorPrint("Error in getaddrinfo: %s", gai_strerror(ret));
		exit(1);
	}

	p = addr_info;
	while (p)
	{
		int s;
		char dst[INET6_ADDRSTRLEN];
		char service[INET6_ADDRSTRLEN];
		int on = 1;

		/* Create socket for found family */		
		s = socket(p->ai_family, p->ai_socktype, 0);

		if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
			errorPrint("Error in setsockopt: %s", strerror(errno)); /* maybe not so fatal, continue */
		}
		if (p->ai_family == AF_INET6) {
			if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) < 0) {
				errorPrint("Error in setsockopt: %s", strerror(errno));
			}
		}

		/* RTFM: getnameinfo */
		getnameinfo(p->ai_addr,
				p->ai_addrlen,
				dst,
				sizeof(dst),
				service,
				sizeof(service),
				NI_NUMERICHOST | NI_NUMERICSERV);

		infoPrint("Trying %s:%s ... ",dst, service);

		/* Try to bind socket */
		if (bind(s, p->ai_addr, p->ai_addrlen) == 0) {
			if (listen(s, 1) < 0) {
				errorPrint("listen failed: %s", strerror(errno));
				close(s);
			} else 	{
				infoPrint("bind successful");
				sockets[numsockets++] = s;
			}
		} else {
			errorPrint("bind failed: %s", strerror(errno));
			close(s);
		}

		p = p->ai_next;
	}

	freeaddrinfo(addr_info);
	infoPrint("Waiting for connections...");
	accept_loop(sockets, numsockets);
	for (i=0; i<numsockets; i++) {
		close(sockets[i]);
	}
	return 0;
}
示例#12
0
文件: listener.c 项目: kwlzn/watchman
bool w_start_listener(const char *path)
{
  pthread_mutexattr_t mattr;
#ifndef _WIN32
  struct sigaction sa;
  sigset_t sigset;
#endif
  void *ignored;
#ifdef HAVE_LIBGIMLI_H
  volatile struct gimli_heartbeat *hb = NULL;
#endif
  struct timeval tv;
  int n_clients = 0;

  listener_thread = pthread_self();

  pthread_mutexattr_init(&mattr);
  pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
  pthread_mutex_init(&w_client_lock, &mattr);
  pthread_mutexattr_destroy(&mattr);

#ifdef HAVE_LIBGIMLI_H
  hb = gimli_heartbeat_attach();
#endif

#if defined(HAVE_KQUEUE) || defined(HAVE_FSEVENTS)
  {
    struct rlimit limit;
# ifndef __OpenBSD__
    int mib[2] = { CTL_KERN,
#  ifdef KERN_MAXFILESPERPROC
      KERN_MAXFILESPERPROC
#  else
      KERN_MAXFILES
#  endif
    };
# endif
    int maxperproc;

    getrlimit(RLIMIT_NOFILE, &limit);

# ifndef __OpenBSD__
    size_t len;

    len = sizeof(maxperproc);
    sysctl(mib, 2, &maxperproc, &len, NULL, 0);
    w_log(W_LOG_ERR, "file limit is %" PRIu64
        " kern.maxfilesperproc=%i\n",
        limit.rlim_cur, maxperproc);
# else
    maxperproc = limit.rlim_max;
    w_log(W_LOG_ERR, "openfiles-cur is %" PRIu64
        " openfiles-max=%i\n",
        limit.rlim_cur, maxperproc);
# endif

    if (limit.rlim_cur != RLIM_INFINITY &&
        maxperproc > 0 &&
        limit.rlim_cur < (rlim_t)maxperproc) {
      limit.rlim_cur = maxperproc;

      if (setrlimit(RLIMIT_NOFILE, &limit)) {
        w_log(W_LOG_ERR,
          "failed to raise limit to %" PRIu64 " (%s).\n",
          limit.rlim_cur,
          strerror(errno));
      } else {
        w_log(W_LOG_ERR,
            "raised file limit to %" PRIu64 "\n",
            limit.rlim_cur);
      }
    }

    getrlimit(RLIMIT_NOFILE, &limit);
#ifndef HAVE_FSEVENTS
    if (limit.rlim_cur < 10240) {
      w_log(W_LOG_ERR,
          "Your file descriptor limit is very low (%" PRIu64 "), "
          "please consult the watchman docs on raising the limits\n",
          limit.rlim_cur);
    }
#endif
  }
#endif

  proc_pid = (int)getpid();
  if (gettimeofday(&tv, NULL) == -1) {
    w_log(W_LOG_ERR, "gettimeofday failed: %s\n", strerror(errno));
    return false;
  }
  proc_start_time = (uint64_t)tv.tv_sec;

#ifndef _WIN32
  signal(SIGPIPE, SIG_IGN);

  /* allow SIGUSR1 and SIGCHLD to wake up a blocked thread, without restarting
   * syscalls */
  memset(&sa, 0, sizeof(sa));
  sa.sa_handler = wakeme;
  sa.sa_flags = 0;
  sigaction(SIGUSR1, &sa, NULL);
  sigaction(SIGCHLD, &sa, NULL);

  // Block SIGCHLD everywhere
  sigemptyset(&sigset);
  sigaddset(&sigset, SIGCHLD);
  sigprocmask(SIG_BLOCK, &sigset, NULL);

  listener_fd = get_listener_socket(path);
  if (listener_fd == -1) {
    return false;
  }
  w_set_cloexec(listener_fd);
#endif

  if (pthread_create(&reaper_thread, NULL, child_reaper, NULL)) {
    w_log(W_LOG_FATAL, "pthread_create(reaper): %s\n",
        strerror(errno));
    return false;
  }

  if (!clients) {
    clients = w_ht_new(2, &client_hash_funcs);
  }

  w_state_load();

#ifdef HAVE_LIBGIMLI_H
  if (hb) {
    gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
  } else {
    w_setup_signal_handlers();
  }
#else
  w_setup_signal_handlers();
#endif
  w_set_nonblock(listener_fd);

  // Now run the dispatch
#ifndef _WIN32
  accept_loop();
#else
  named_pipe_accept_loop(path);
#endif

#ifndef _WIN32
  /* close out some resources to persuade valgrind to run clean */
  close(listener_fd);
  listener_fd = -1;
#endif

  // Wait for clients, waking any sleeping clients up in the process
  do {
    w_ht_iter_t iter;

    pthread_mutex_lock(&w_client_lock);
    n_clients = w_ht_size(clients);

    if (w_ht_first(clients, &iter)) do {
      struct watchman_client *client = w_ht_val_ptr(iter.value);
      w_event_set(client->ping);
    } while (w_ht_next(clients, &iter));

    pthread_mutex_unlock(&w_client_lock);

    w_log(W_LOG_ERR, "waiting for %d clients to terminate\n", n_clients);
    usleep(2000);
  } while (n_clients > 0);

  w_root_free_watched_roots();

  pthread_join(reaper_thread, &ignored);
  cfg_shutdown();

  return true;
}
void main(void)
{
    svr_fd = SetupSocket();
    accept_loop(svr_fd);
}
示例#14
0
bool w_start_listener(const char *path)
{
#ifndef _WIN32
  struct sigaction sa;
  sigset_t sigset;
#endif
  void *ignored;

  listener_thread = pthread_self();

#ifdef HAVE_LIBGIMLI_H
  hb = gimli_heartbeat_attach();
#endif

#if defined(HAVE_KQUEUE) || defined(HAVE_FSEVENTS)
  {
    struct rlimit limit;
# ifndef __OpenBSD__
    int mib[2] = { CTL_KERN,
#  ifdef KERN_MAXFILESPERPROC
      KERN_MAXFILESPERPROC
#  else
      KERN_MAXFILES
#  endif
    };
# endif
    int maxperproc;

    getrlimit(RLIMIT_NOFILE, &limit);

# ifndef __OpenBSD__
    {
      size_t len;

      len = sizeof(maxperproc);
      sysctl(mib, 2, &maxperproc, &len, NULL, 0);
      w_log(W_LOG_ERR, "file limit is %" PRIu64
          " kern.maxfilesperproc=%i\n",
          limit.rlim_cur, maxperproc);
    }
# else
    maxperproc = limit.rlim_max;
    w_log(W_LOG_ERR, "openfiles-cur is %" PRIu64
        " openfiles-max=%i\n",
        limit.rlim_cur, maxperproc);
# endif

    if (limit.rlim_cur != RLIM_INFINITY &&
        maxperproc > 0 &&
        limit.rlim_cur < (rlim_t)maxperproc) {
      limit.rlim_cur = maxperproc;

      if (setrlimit(RLIMIT_NOFILE, &limit)) {
        w_log(W_LOG_ERR,
          "failed to raise limit to %" PRIu64 " (%s).\n",
          limit.rlim_cur,
          strerror(errno));
      } else {
        w_log(W_LOG_ERR,
            "raised file limit to %" PRIu64 "\n",
            limit.rlim_cur);
      }
    }

    getrlimit(RLIMIT_NOFILE, &limit);
#ifndef HAVE_FSEVENTS
    if (limit.rlim_cur < 10240) {
      w_log(W_LOG_ERR,
          "Your file descriptor limit is very low (%" PRIu64 "), "
          "please consult the watchman docs on raising the limits\n",
          limit.rlim_cur);
    }
#endif
  }
#endif

#ifndef _WIN32
  signal(SIGPIPE, SIG_IGN);

  /* allow SIGUSR1 and SIGCHLD to wake up a blocked thread, without restarting
   * syscalls */
  memset(&sa, 0, sizeof(sa));
  sa.sa_handler = wakeme;
  sa.sa_flags = 0;
  sigaction(SIGUSR1, &sa, NULL);
  sigaction(SIGCHLD, &sa, NULL);

  // Block SIGCHLD everywhere
  sigemptyset(&sigset);
  sigaddset(&sigset, SIGCHLD);
  sigprocmask(SIG_BLOCK, &sigset, NULL);

  listener_fd = get_listener_socket(path);
  if (listener_fd == -1) {
    return false;
  }
  w_set_cloexec(listener_fd);
#endif

  if (!clients) {
    clients = w_ht_new(2, NULL);
  }

#ifdef HAVE_LIBGIMLI_H
  if (hb) {
    gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
  } else {
    w_setup_signal_handlers();
  }
#else
  w_setup_signal_handlers();
#endif
  w_set_nonblock(listener_fd);

  // Now run the dispatch
#ifndef _WIN32
  accept_loop();
#else
  named_pipe_accept_loop(path);
#endif

#ifndef _WIN32
  /* close out some resources to persuade valgrind to run clean */
  close(listener_fd);
  listener_fd = -1;
#endif

  // Wait for clients, waking any sleeping clients up in the process
  {
    int interval = 2000;
    int last_count = 0, n_clients = 0;
    const int max_interval = 1000000; // 1 second

    do {
      w_ht_iter_t iter;

      pthread_mutex_lock(&w_client_lock);
      n_clients = w_ht_size(clients);

      if (w_ht_first(clients, &iter)) do {
        struct watchman_client *client = w_ht_val_ptr(iter.value);
        w_event_set(client->ping);

#ifndef _WIN32
        // If we've been waiting around for a while, interrupt
        // the client thread; it may be blocked on a write
        if (interval >= max_interval) {
          pthread_kill(client->thread_handle, SIGUSR1);
        }
#endif
      } while (w_ht_next(clients, &iter));

      pthread_mutex_unlock(&w_client_lock);

      if (n_clients != last_count) {
        w_log(W_LOG_ERR, "waiting for %d clients to terminate\n", n_clients);
      }
      usleep(interval);
      interval = MIN(interval * 2, max_interval);
    } while (n_clients > 0);
  }

  pthread_join(reaper_thread, &ignored);
  cfg_shutdown();

  return true;
}
示例#15
0
int main (int argc, char ** argv)
{
	int sockFd = SetupSock(65535, AF_INET, "eth0");
	signal(SIGCHLD, SIG_IGN);
	accept_loop(sockFd, ff);
}