int AccountService::run(int port)
{	if (soap_valid_socket(this->master) || soap_valid_socket(bind(NULL, port, 100)))
	{	for (;;)
		{	if (!soap_valid_socket(accept()) || serve())
				return this->error;
			soap_destroy(this);
			soap_end(this);
		}
	}
	else
		return this->error;
	return SOAP_OK;
}

int WSHttpBinding_USCOREINWNMasterServerAPIService::run(int port)
{	if (soap_valid_socket(this->master) || soap_valid_socket(bind(NULL, port, 100)))
	{	for (;;)
		{	if (!soap_valid_socket(accept()) || serve())
				return this->error;
			soap_destroy(this);
			soap_end(this);
		}
	}
	else
		return this->error;
	return SOAP_OK;
}

int AdvancedSecurityServiceBindingService::run(int port)
{	if (soap_valid_socket(this->soap->master) || soap_valid_socket(bind(NULL, port, 100)))
	{	for (;;)
		{	if (!soap_valid_socket(accept()) || serve())
				return this->soap->error;
			soap_destroy(this->soap);
			soap_end(this->soap);
		}
	}
	else
		return this->soap->error;
	return SOAP_OK;
}

int BasicHttpBinding_USCOREICalculatorService::run(int port)
{   if (soap_valid_socket(this->soap->master) || soap_valid_socket(bind(NULL, port, 100)))
    {   for (;;)
        {   if (!soap_valid_socket(accept()) || serve())
                return this->soap->error;
            soap_destroy(this->soap);
            soap_end(this->soap);
        }
    }
    else
        return this->soap->error;
    return SOAP_OK;
}

void
test_get_query (void)
{
    const gchar *uri;
    GHashTable *query;

    uri = serve(client);

    query = gcut_take_new_hash_table_string_string("name", "value", NULL);
    soupcut_client_get(client, uri, "name", "value", NULL);

    gcut_assert_equal_hash_table_string_string(query, received_query);
}

/* Code executed by the client */
void *client_run(void *arg)
{
	client_t *client = (client_t *) arg;

	/* main loop of the client: fetch commands from window, interpret
	 * and handle them, return results to window. */
	char command[256];
	char response[256] = { 0 };	/* response must be null for the first call to serve */

	serve(client->win, response, command);
	while (handle_command(command, response, sizeof(response))) {
		pthread_mutex_lock(&run_lock);
		while( run_threads == 0 ){
			pthread_cond_wait(&ready_to_run, &run_lock);
		}
		pthread_mutex_unlock(&run_lock);

		serve(client->win, response, command);
	}
	client_destroy(client);
	return 0;
}

void *thread (void *vargp) {
	thread_args args;
	args = *((thread_args *) vargp);
	Pthread_detach(pthread_self());
	// handle segment fault: it is sometimes weird
	Signal(SIGSEGV, sigsegv_handler);
	// Valar Dohaeris
	serve(args.fd);
	// Valar Morghulis
	Close(args.fd);
	Free(vargp);
	return NULL;
}

dword SioTcps::Worker(void)
{
    SOCKET so = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (so == INVALID_SOCKET)
    {
        dword dw = WSAGetLastError();
        trace("socket: %d [%08X]\n", dw, dw);
        return dw;
    }

    SOCKADDR_IN sin;
    sin.sin_family = AF_INET;
    sin.sin_port   = htons(port);
    sin.sin_addr.S_un.S_addr = 0;

    if (bind(so, (SOCKADDR *)&sin, sizeof(sin)) != 0)
    {
        dword dw = WSAGetLastError();
        trace("bind: %d [%08X]\n", dw, dw);
        return dw;
    }

    if (listen(so, SOMAXCONN) != 0)
    {
        dword dw = WSAGetLastError();
        trace("listen: %d [%08X]\n", dw, dw);
        return dw;
    }

    do {
trace("Kronos server is accepting connections...\n");
        SOCKADDR_IN sinClient;
        int sinLen = sizeof(sinClient);
        dword soClient = accept(so, (SOCKADDR *)&sinClient, &sinLen);

        if (soClient != INVALID_SOCKET)
        {
            trace("Connection from %d.%d.%d.%d\n",
                sinClient.sin_addr.S_un.S_un_b.s_b1, sinClient.sin_addr.S_un.S_un_b.s_b2,
                sinClient.sin_addr.S_un.S_un_b.s_b3, sinClient.sin_addr.S_un.S_un_b.s_b4);

            serve(soClient);
        }
    } while (sin.sin_addr.S_un.S_addr == 0);
// John - you never get here.
// May be you need shutdown() same as in IGD480
trace("Kronos server exiting...\n");
    closesocket(so);
    return 0;
}

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

    char *eth, *ip1, *ip2;

    if (argc < 2) {
        printf("No www directory found\nUsage: %s wwwdir\n", argv[0]);
        return 1;
    }

    if (chdir(argv[1]) < 0) {
        printf("Could not change dir to '%s'\n", argv[1]);
        return 1;
    }

    eth = getenv("ETH");
    if (!eth) {
        printf("The ETH environment variable must be set!\n");
        return 1;
    }

    ip1 = getenv("IP1");
    ip2 = getenv("IP2");
    if (!ip1 || !ip2) {
        printf("The IP1 and IP2 environment variables must be set!\n");
        return 1;
    }

#if KEEP_SERVING
    /* keep calling serve() until it fails, then exit with error code */
    while (serve(argv[1])) { }
    printf("Listening failed\n");
    return 1;
#else
    /* call serve() and exit */
    return (!serve(argv[1]));
#endif

}

int
main(int argc, char** argv)
{
	int detach = (argc > 1 && !strncmp(argv[1],"-d",2)) ? 1 : 0;
	char* port = (argc > (1 + detach) ? argv[1 + detach] : SERVER_PORT);;
	char* tls_port = (argc > (2 + detach) ? argv[2 + detach] : TLS_SERVER_PORT);

	if (argc > 3) usage(argv[0]);
	if (argc > 1 && !strcmp(argv[1],"-r")) restart();

	demon(detach);	
	serve(atoi(port),atoi(tls_port));
	return 0;
}

void sMain()
{
  sGetMemHandler(sAMF_HEAP)->MakeThreadSafe(); // WTF?!

  {
    sThread serve(ServerThread);
    
    sCatchCtrlC();
    while(!sGotCtrlC())
      sSleep(100);
  }

  sPrintF(L"Server quit.\n");
}

void WaitForConnection(SocketServer* self)
{
	listen(self->Socket,1);

	SOCKET TempSock = SOCKET_ERROR;
	while(TempSock==SOCKET_ERROR)
	{
		TempSock = accept(self->Socket,NULL,NULL);
	}
	
	serve(self, TempSock);

	closesocket(TempSock);
}

int ConsoleObserverService::run(int port)
{	if (soap_valid_socket(bind(NULL, port, 100)))
	{	for (;;)
		{	if (!soap_valid_socket(accept()))
				return this->error;
			(void)serve();
			soap_destroy(this);
			soap_end(this);
		}
	}
	else
		return this->error;
	return SOAP_OK;
}

int server(int initfd) {
  // Create the shared queue
  queue_t q;
  int res;

  queue_init(&q, QUEUE_SIZE);

  // Create the consumer threads
  pthread_t cthreads[CONSUMERS_COUNT];
  unsigned i;
  for (i = 0; i < CONSUMERS_COUNT; i++) {
    res = pthread_create(&cthreads[i], NULL, &consumer_thread, &q);
    assert(res == 0);
  }

  // Create the listening socket
  int accsock = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
  assert(accsock >= 0);

  int true = 1;
  res = setsockopt(accsock, SOL_SOCKET, SO_REUSEADDR, &true, sizeof(true));
  assert(res == 0);

  struct sockaddr_in addr;
  memset(&addr, 0, sizeof(addr));
  addr.sin_family = AF_INET;
  addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
  addr.sin_port = htons(LISTEN_PORT);

  res = bind(accsock, (struct sockaddr*)&addr, sizeof(addr));
  assert(res == 0);

  res = listen(accsock, BACKLOG_SIZE);
  assert(res == 0);

  close(initfd);

  fprintf(stderr, "Server initialized\n");

  serve(&q, accsock);

  for (i = 0; i < CONSUMERS_COUNT; i++) {
    res = pthread_join(cthreads[i], NULL);
    assert(res == 0);
  }

  queue_deinit(&q);
  return 0;
}

int main(int argc, char** argv) {
  auto& main_prof = make_profiler("main");
  profile_start(main_prof);

  try {
    options opt = parse_cmdline(argc, argv);

    switch (opt.m_mode) {
      case options::init:
        init();
        break;
      case options::config:
        run_config(require_codedb_path(opt), opt);
        break;
      case options::build:
        build(require_codedb_path(opt), opt);
        break;
      case options::find:
        find(require_codedb_path(opt), opt);
        break;
      case options::serve:
        serve(require_codedb_path(opt), opt);
        break;
      case options::undefined:
        std::cout << "cdb: '" << opt.m_args[0]
                  << "' is not a cdb-command. See 'cdb --help'.\n";
        break;
      case options::help:
        help(opt);
        break;
      default:
        std::cout << "Not implemented '" << opt.m_args.at(0) << "'\n";
        break;
    }
  }
  catch (const regex_error& error) {
    std::string desc = error.what();
    if (!desc.empty()) desc[0] = std::toupper(desc[0]);

    std::cerr << "Error: invalid regex '" << error.m_expr << "'\n  " << desc
              << '\n';
  }
  catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << std::endl;
  }

  profile_stop(main_prof);
  profiler_report();
}

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

	stlink_t *sl = NULL;

	st_state_t state;
	memset(&state, 0, sizeof(state));
	// set defaults...
	state.stlink_version = 2;
	state.logging_level = DEFAULT_LOGGING_LEVEL;
	state.listen_port = DEFAULT_GDB_LISTEN_PORT;
	parse_options(argc, argv, &state);
	switch (state.stlink_version) {
	case 2:
		sl = stlink_open_usb(state.logging_level);
		if(sl == NULL) return 1;
		break;
	case 1:
		sl = stlink_v1_open(state.logging_level);
		if(sl == NULL) return 1;
		break;
        }

	printf("Chip ID is %08x, Core ID is  %08x.\n", sl->chip_id, sl->core_id);

	sl->verbose=0;

	current_memory_map = make_memory_map(sl);

#ifdef __MINGW32__
	WSADATA	wsadata;
	if (WSAStartup(MAKEWORD(2,2),&wsadata) !=0 ) {
		goto winsock_error;
	}
#endif

	while(serve(sl, state.listen_port, state.elf_filename) == 0);

#ifdef __MINGW32__
winsock_error:
	WSACleanup();
#endif

	/* Switch back to mass storage mode before closing. */
	stlink_run(sl);
	stlink_exit_debug_mode(sl);
	stlink_close(sl);

	return 0;
}

int
main(int argc, char *argv[])
{
    int fd;

    if (!parseargs(argc, argv))
        usage();
    else {
        fd = initserver(port, qlen);
        fprintf(stdout, "Server HTTP on port %d ...\n", port);
        serve(fd);
    }

    return 0;
}

void
umain(int argc, char **argv)
{
	static_assert(sizeof(struct File) == 256);
	binaryname = "fs";
	cprintf("FS is running\n");

	// Check that we are able to do I/O
	outw(0x8A00, 0x8A00);
	cprintf("FS can do I/O\n");

	serve_init();
	fs_init();
	serve();
}

SocksClient *SocksServer::takeIncoming()
{
    if(d->incomingConns.isEmpty())
        return 0;

    SocksClient *c = d->incomingConns.takeFirst();

    // we don't care about errors anymore
    disconnect(c, SIGNAL(error(int)), this, SLOT(connectionError()));

    // don't serve the connection until the event loop, to give the caller a chance to map signals
    QTimer::singleShot(0, c, SLOT(serve()));

    return c;
}

void
test_set_base_null (void)
{
    const gchar *uri;

    uri = serve(client);

    soupcut_client_set_base(client, NULL);

    cut_assert_equal_uint(SOUP_STATUS_MALFORMED,
                          soupcut_client_get(client, NULL, NULL));

    soupcut_client_get(client, uri, NULL);
    assert_response_equal_body(cut_take_printf("Hello %s", uri), client);
}