Beispiel #1
0
void server_destroy(server_t* server)
{
	if(server->running)
		server_stop(server);
	free(server->clients);
	free(server);
}
Beispiel #2
0
void sig_handler(int signo)
{
	if(signo == SIGINT)
	{
		server_stop(&ftp_server);
	}
}
Beispiel #3
0
/* funzione utilizzate per la creazione di semafori, memorie e code di messaggi.
 * ritorna 1 se tutte le risorse sono allocate correttamente, 0 altrimenti.  */
int server_start() {
	log_date(LOG_PATH, "(start) Avvio server");
	get_date(start_date);
	// Creazione di semafori, memorie e code di messaggi
	if ((semid = semget(SEMKEY, SEM_TOT, 0600 | IPC_CREAT)) == -1) errorlog(LOG_PATH, "Semafori non allocati");

	if ((shmid = shmget(SHMKEY, sizeof(repo), 0600 | IPC_CREAT)) == -1) errorlog(
			LOG_PATH, "Area di memoria Repository non allocata");

	if ((shmlog = shmget(BUFFER_SHMKEY, sizeof(buffer), 0600 | IPC_CREAT)) == -1) errorlog(
			LOG_PATH, "Area di memoria LOG non allocata");

	if ((shmls = shmget(LS_SHMKEY, sizeof(numlettori), 0600 | IPC_CREAT)) == -1) errorlog(
			LOG_PATH, "Area di memoria LETTORI/SCRITTORI non allocata");

	if ((shmauth = shmget(AUTH_SHMKEY, sizeof(auth), 0600 | IPC_CREAT)) == -1) errorlog(
			LOG_PATH, "Area di memoria AUTORIZZAZIONI non allocata");

	if ((shmpush = shmget(PUSH_SHMKEY, sizeof(push), 0600 | IPC_CREAT)) == -1) errorlog(
			LOG_PATH, "Area di memoria PUSH non allocata");

	if ((msgid = msgget(MSGKEY, IPC_CREAT | 0600)) == -1) errorlog(LOG_PATH,
			"Coda messaggi non allocata");

	// Controllo errori all'avvio */
	if (semid == -1 || shmid == -1 || shmlog == -1 || shmls == -1 || shmauth == -1
			|| shmpush == -1 || msgid == -1) server_stop();

	if (!setup()) {
		errorlog(LOG_PATH, "(start) File del repository iniziale non trovato");
		return 0;
	}
	return 1;
}
Beispiel #4
0
int main()
{
	//init win32 socket
#ifdef __WIN32__
	static WSADATA wsa_data; 
	int result = WSAStartup((WORD)(1<<8|1), &wsa_data); //初始化WinSocket动态连接库
	if( result != 0 ) // 初始化失败
		return -1;
#endif
#ifndef __WIN32__
	signal( SIGPIPE, SIG_IGN );	//ignore send,recv SIGPIPE error
#endif
	NEW( websrv, sizeof(webserver) );
	memset( websrv, 0, sizeof(webserver) );
	server_create( websrv, "config.xml" );
	server_start( websrv );
	do_console();
	server_stop( websrv );
	server_end( websrv );
	DEL( websrv );

#ifdef __WIN32__
	WSACleanup();
#endif
	memory_end();
	return 0;
}
int socket_server_multiple_test(void) {
  pthread_t server_thread, timeout_thread, request_threads[20];

  testserver.master = 0;
  testserver.max_threads = 20;
  testserver.kvserver.handle = &socket_server_request_handler;

  pthread_create(&server_thread, NULL, socket_server_run_thread, NULL);
  pthread_mutex_lock(&socket_server_test_lock);
  while (!server_running)
    pthread_cond_wait(&socket_server_test_cond, &socket_server_test_lock);
  pthread_mutex_unlock(&socket_server_test_lock);
  for (int i = 0; i < 20; i++)
    pthread_create(&request_threads[i], NULL, socket_server_request_thread, NULL);

  pthread_create(&timeout_thread, NULL, socket_server_timeout_thread, NULL);

  pthread_mutex_lock(&socket_server_test_lock);
  while (!complete) 
    pthread_cond_wait(&socket_server_completion_cond, &socket_server_test_lock);
  pthread_cond_broadcast(&socket_server_test_cond);
  pthread_mutex_unlock(&socket_server_test_lock);

  for (int i = 0; i < 20; i++)
    pthread_join(request_threads[i], NULL);

  server_stop(&testserver);
  ASSERT_EQUAL(synch, 0);
  return 1;
}
Beispiel #6
0
static void __stop(int unused)
{
    #pragma ref unused

    static bool stopped = false;

    if (stopped)
    {
        return;
    }

    stopped = true;
    puts("Stopping morrigan.");
    if (input)
    {
        bdestroy(input);
    }
    net_stop();
    game_stop();
    server_stop();
    if (l)
    {
        landscape_destroy(l);
        l = NULL;
    }
}
Beispiel #7
0
static void sigint_cb( evutil_socket_t fd, short what, void *ctx )
{
        (void)fd;
        (void)what;
        (void)ctx;
        ED2KD_LOGNFO("caught SIGINT, terminating...");
        server_stop();
}
Beispiel #8
0
void server_fini (void)
{
    if (server_init_done) {
        server_init_done = false;

        server_stop();
    }
}
Beispiel #9
0
static void main_server_on_signal(int sig) {
	if (sig == SIGINT) {
		server_stop();

		printf("\n");
		exit(0);
	}
}
Beispiel #10
0
static void hid_server_remove(struct btd_profile *p,
						struct btd_adapter *adapter)
{
	server_stop(adapter_get_address(adapter));

	adapters = g_slist_remove(adapters, adapter);
	btd_adapter_unref(adapter);
}
void
ox_nrmgr_delete(struct nr_mgr* self)
{
    int i = 0;
    for(; i < self->reactor_num; ++i)
    {
        ox_thread_delete(self->reactors[i].thread);
    }

    i = 0;
    for(; i < self->reactor_num; ++i)
    {
        struct net_reactor* reactor = self->reactors+i;

        ox_stack_delete(reactor->waitclose_list);
        ox_stack_delete(reactor->waitsend_list);

        ox_rwlist_force_flush(reactor->free_sendmsg_list);
        reactor_freesendmsg_handle(reactor);
        ox_rwlist_delete(reactor->free_sendmsg_list);
        ox_rwlist_delete(reactor->logic_msglist);
        ox_rwlist_delete(reactor->enter_list);

        {
            struct rwlist_s*    rwlist = reactor->fromlogic_rwlist;
            struct rwlist_msg_data* rwlist_msg = NULL;
            ox_rwlist_force_flush(reactor->fromlogic_rwlist);

            while((rwlist_msg = (struct rwlist_msg_data*)ox_rwlist_pop(rwlist, 0)) != NULL)
            {
                if(rwlist_msg->msg_type == RMT_SENDMSG)
                {
                    free(rwlist_msg->data.send.data);
                }
                else if(rwlist_msg->msg_type == RMT_CLOSE)
                {
                }
                else if(rwlist_msg->msg_type == RMT_REQUEST_CLOSE)
                {
                }
                else if(rwlist_msg->msg_type == RMT_REQUEST_FREENETMSG)
                {
                    free(rwlist_msg->data.free.msg);
                }
            }

            ox_rwlist_delete(reactor->fromlogic_rwlist);
        }
        

        server_stop(reactor->server);
    }

    free(self->reactors);

    free(self);
}
Beispiel #12
0
/**
 * @brief Signal handler for server.
 *
 * @param sig - Signal No. provided by system
 */
void server_sig_handler(int sig)
{
	switch(sig) {
	case SIGTERM:
		server_stop();
		break;
	default:
		break;
	}
}
Beispiel #13
0
static void hid_server_remove(struct btd_adapter *adapter)
{
	bdaddr_t src;

	adapter_get_address(adapter, &src);

	server_stop(&src);

	adapters = g_slist_remove(adapters, adapter);
	btd_adapter_unref(adapter);
}
Beispiel #14
0
/* this function will be called by the SCM to request an action */
DWORD WINAPI HandlerEx(DWORD dwControl, DWORD dwEventType, 
        LPVOID lpEventData, LPVOID lpContext)
{
    enum { DENY_ACTION = 0xff };

    switch(dwControl)
    {
    case SERVICE_CONTROL_INTERROGATE:
        u_dbg("SERVICE_CONTROL_INTERROGATE" );
        SetServiceStatus(ctx->hServiceStatus, &ctx->status);
        return NO_ERROR;

    case SERVICE_CONTROL_STOP:
        u_dbg("SERVICE_CONTROL_STOP");

        if(ctx->status.dwCurrentState == SERVICE_STOPPED)
            return NO_ERROR; /* service already stopped */

        /* start the stop procedure, move to stop_pending state */
        ctx->status.dwCheckPoint = 1;
        ctx->status.dwWaitHint = 2000;
        ctx->status.dwCurrentState = SERVICE_STOP_PENDING; 
        SetServiceStatus(ctx->hServiceStatus, &ctx->status);

        server_stop(ctx->server);
        return NO_ERROR;

    case SERVICE_CONTROL_PAUSE:
        u_dbg("SERVICE_CONTROL_PAUSE");
        break;

    case SERVICE_CONTROL_CONTINUE:
        u_dbg("SERVICE_CONTROL_CONTINUE");
        break;

    case SERVICE_CONTROL_SHUTDOWN:
        u_dbg("SERVICE_CONTROL_SHUTDOWN");
        break;

    case SERVICE_CONTROL_PARAMCHANGE:
        u_dbg("SERVICE_CONTROL_PARAMCHANGE");
        break;

    default:
        u_dbg("SERVICE_CONTROL_UNKNOWN!!!!");
    }
    if(dwControl > 127 && dwControl < 255)
    {
        /* user defined control code */
        u_dbg("SERVICE_CONTROL_USER_DEFINED");
    }

    return ERROR_CALL_NOT_IMPLEMENTED;
}
Beispiel #15
0
int tpcmaster_run_test(void) {
    setup_slaves();
    pthread_t runner;
    pthread_create(&runner, NULL, &tpcmaster_runner, tpcmaster_test_connect);
    pthread_mutex_lock(&tpcmaster_lock);
    while (done == 0)
        pthread_cond_wait(&tpcmaster_cond, &tpcmaster_lock);
    pthread_mutex_unlock(&tpcmaster_lock);
    server_stop(&socket_server);
    cleanup_slaves();
    return 1;
}
Beispiel #16
0
void game_free(Game * game)
{
	if (game == NULL)
		return;

	server_stop(game);

	g_assert(game->player_list_use_count == 0);
	if (game->server_port != NULL)
		g_free(game->server_port);
	params_free(game->params);
	g_free(game);
}
Beispiel #17
0
int
server_destroy(SERVER *sp)
{
    server_stop(sp);

    pthread_attr_destroy(&sp->ca_detached);
    pthread_mutex_destroy(&sp->clients_mtx);
    pthread_cond_destroy(&sp->clients_cv); 

    if (sp->fd >= 0)
	s_close(sp->fd);

    a_free(sp);
}
Beispiel #18
0
/*! \brief Event loop listening for signals and remote commands. */
static void event_loop(server_t *server)
{
	uint8_t buf[KNOT_WIRE_MAX_PKTSIZE];
	size_t buflen = sizeof(buf);

	/* Read control socket configuration. */
	conf_val_t listen_val = conf_get(conf(), C_CTL, C_LISTEN);
	conf_val_t rundir_val = conf_get(conf(), C_SRV, C_RUNDIR);
	char *rundir = conf_abs_path(&rundir_val, NULL);
	struct sockaddr_storage addr = conf_addr(&listen_val, rundir);
	free(rundir);

	/* Bind to control interface (error logging is inside the function. */
	int remote = remote_bind(&addr);

	sigset_t empty;
	(void)sigemptyset(&empty);

	/* Run event loop. */
	for (;;) {
		int ret = remote_poll(remote, &empty);

		/* Events. */
		if (ret > 0) {
			ret = remote_process(server, &addr, remote, buf, buflen);
			if (ret == KNOT_CTL_STOP) {
				break;
			}
		}

		/* Interrupts. */
		if (sig_req_stop) {
			break;
		}
		if (sig_req_reload) {
			sig_req_reload = false;
			server_reload(server, conf()->filename);
		}
	}

	server_stop(server);

	/* Close remote control interface. */
	remote_unbind(&addr, remote);

	/* Wait for server to finish. */
	server_wait(server);
}
Beispiel #19
0
int main(const int argc, const char* argv[])
{
	struct server s;
	s.port = DEFAULT_PORT;

	// Process user arguments.
	process_args(&s, argv, argc);

#ifdef DEBUG
	fprintf(stderr, "Server: Creating barber process.\n");
#endif

	int pid = fork();
	if (pid == -1) {
		perror("Error while creating barber process");
		return EXIT_FAILURE;
	}

	if (!pid) { // Barber (child) process.
		barber();
	}
	else {
		// Ignore SIGCHLD. 
		signal(SIGCHLD, SIG_IGN);

		// Initialize server socket and bind it.
		if (server_init(&s, s.port) == -1) {
			perror("Error while init. of server");
			return EXIT_FAILURE;
		}

		printf("Server is running on port: %d\n", s.port);
		server_start(&s); // Run Forest, run!

		// Stop server, free memory and wait.
		server_stop(&s);
	}

	// Try removing semaphores.
	int semaphores = semaphores_init(getuid());
	semctl(semaphores, 0, IPC_RMID, NULL);

	return EXIT_SUCCESS;
}
Beispiel #20
0
// ------------------------------------ main ------------------------------------------------------------
int main(int argc, char *argv[]) {
	if (strcmp(argv[argc-1],"start") != 0 && strcmp(argv[argc-1],"stop") != 0) {		// print help
		printf("Creates or controls a server on this computer at port %d\n",PORT_NUMBER);
		printf("Usage: mystore4 {start | stop}\n   or   mystore4 {portno} {start | stop}\n");
		printf("For the server to process any input, precede the sent message with a \"u\"");
		printf("If first char is \"q\", then we're telling the server to quit\n");
		printf("For any other string, server returns \"Huh?\"\n");
		return 0;
	}
	
	if (argc == 3)
		portno = atoi(argv[1]);
		
	if (strcmp(argv[argc-1],"start") == 0)
		server_start();
	else
		server_stop();
	return 0;
}
Beispiel #21
0
void do_console()
{
	char buf[1024];
	while(1)
	{
		scanf( "%s", buf );
		if( strcmp( buf, "quit" ) == 0 ){
			break;
		}else if( strcmp( buf, "stop" ) == 0 ){
			server_stop( websrv );
		}else if( strcmp( buf, "start" ) == 0 ){
			server_start( websrv );
		}else if( strcmp( buf, "clear" ) == 0 ){
			server_clear( websrv );
		}else if( strcmp( buf, "reload" ) == 0 ){
			server_reload( websrv );
		}else if( strcmp( buf, "print" ) == 0 ){
			server_print( websrv );
			memory_print();
		}else{
			SLEEP(3); //Temperory fixed for linux nohup!
		}
	}
}
Beispiel #22
0
static void hid_server_remove(struct btd_profile *p,
						struct btd_adapter *adapter)
{
	server_stop(adapter_get_address(adapter));
}
Beispiel #23
0
void WINAPI TimeServiceMain(DWORD dwArgc, LPTSTR *lpszArgv) 
{
#ifdef _WIN64
   unsigned __int64 dwCompKey  = CK_SERVICECONTROL;
#else
   DWORD dwCompKey  = CK_SERVICECONTROL;
#endif
   DWORD fdwControl = SERVICE_CONTROL_RUN;
   DWORD dwBytesTransferred;
   OVERLAPPED *po;
   SERVICE_STATUS ss;
   SERVICE_STATUS_HANDLE hSS;
   BOOL bPasswordCompileEmbedded = 0;

// We must get the private password for connecting to this machine.
// The password can be compiled into the server any of the following ways......


//  1 way - the easiest way, just uncomment and put any value between the quotes
//  then remove the code between --Load External Password Begin & End-- below
//  ***** example of very simple integrated password ********
//  GString strPassword("Password");
//	GString strPort("80");
//	GString strRoot;
//	bPasswordCompileEmbedded = 1;


//  Another way - a most secure way to embed the password.
//  ***** example of integrated password ********
//  GString strPassword;
//	MakePassword(strPassword);    // Go read the MakePassword() routine above.
//	GString strPort("80");
//	GString strRoot;
//	bPasswordCompileEmbedded = 1;


//              OR

// The password can be retrieved from an external disk location.
// Passwords can be obtained from disk in two different ways.
// Either in a registry key matching the (probably renamed) 
// executable file that is this server, OR by loading a 
// predefined file name at a predefined location. 
// This file must be present while starting the server, but can be
// removed once this process has fully started.


//  --Load External Password Begin--
GString strPassword;
GString strPort;
GString strRoot;

if (!bPasswordCompileEmbedded)
{
	GString strThisEXEName(GetThisEXEName());
	GString strStartupKey;

	// use our runtime image name as the registry key
	char buf[512];
	long lSize = sizeof(buf);
	if (RegQueryValue(HKEY_CLASSES_ROOT,(const char *)strThisEXEName,buf,&lSize) == ERROR_SUCCESS)
	{
		// uudecode the startup key
		BUFFER b;
		BufferInit(&b);
		unsigned int nDecoded;
		uudecode(buf, &b, &nDecoded, false);
		strStartupKey.write((const char *)b.pBuf,nDecoded);
		BufferTerminate(&b);
	}

	GString strStartupData;
	if (strStartupKey.Length())
	{
		// look for a file in the root of the file system (c:\)
		// with the same name as this .exe
		GString strFile("c:\\");
		strFile += strThisEXEName;


		// load the crypted disk file into clear text memory
		char *pDest;
		int nDestLen;
		GString strErrorOut;
		if (FileDecryptToMemory(strStartupKey, strFile, &pDest, &nDestLen, strErrorOut))
		{
			// parse into the profile data structures
			pDest[7 + nDestLen] = 0; // null terminate it
			strStartupData.write(&pDest[7], nDestLen + 1); // and cap the GString 
		}
		else
		{
			// if the file was not in the root of the file system
			// see if there is an environment setting directing
			// this server to look for the file in another location
			// The variable name is dynamic, matching this .exe name
			// and the environment variable value must be a fully
			// qualified path and file name to the startup file.
			if (getenv(strThisEXEName))
			{
				if (FileDecryptToMemory(strStartupKey, getenv(strThisEXEName), &pDest, &nDestLen, strErrorOut))
				{
					// parse into the profile data structures
					strStartupData.write(&pDest[7], nDestLen-7);
				}
			}
		}

		// parse stored settings in startup file to startup variables
		if (strStartupData.Length())
		{
			GStringList lstOptions("&&",strStartupData);
			GStringIterator it(&lstOptions);

			if (it()) strPassword = it++;
			if (it()) strRoot = it++; // currently not used
			if (it()) strPort = it++;
		}
	}
}

//  --Load External Password End--

	GString strFile;
	GString strConfigFileDefault;
	GString strErrorOut;
	int bSetStartupFile = 0;

#ifdef _WIN32
	SetPriorityClass(GetCurrentProcess(),HIGH_PRIORITY_CLASS); // = 1 point above normal
#endif


   // Create the completion port and save its handle in a global
   // variable so that the Handler function can access it.
   g_hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, CK_PIPE, 0);

   // Give SCM the address of this service's Handler
   // NOTE: hSS does not have to be closed.
   hSS = RegisterServiceCtrlHandler((const char *)strServerName, TimeServiceHandler);

   // Do what the service should do.
   // Initialize the members that never change
   ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS; 
   ss.dwControlsAccepted = SERVICE_ACCEPT_STOP | 
      SERVICE_ACCEPT_PAUSE_CONTINUE | SERVICE_ACCEPT_SHUTDOWN;

   do {
      switch (dwCompKey) {
      case CK_SERVICECONTROL:
         // We got a new control code
         ss.dwWin32ExitCode = NO_ERROR; 
         ss.dwServiceSpecificExitCode = 0; 
         ss.dwCheckPoint = 0; 
         ss.dwWaitHint = 0;

         if (fdwControl == SERVICE_CONTROL_INTERROGATE) {
            SetServiceStatus(hSS, &ss);
            break;
         }

         // Determine which PENDING state to return
         if (dwSrvCtrlToPend[fdwControl] != 0) {
            ss.dwCurrentState = dwSrvCtrlToPend[fdwControl]; 
            ss.dwCheckPoint = 0;
            ss.dwWaitHint = 500;   // half a second
            SetServiceStatus(hSS, &ss);
         }

         switch (fdwControl) {
            case SERVICE_CONTROL_RUN:
            case SERVICE_CONTROL_CONTINUE:
				try
				{
					if (strRoot.Length() && strPort.Length())
					{
						GString strCfgData;
						strCfgData.Format(pzBoundStartupConfig,(const char *)strRoot,(const char *)strPort);
						SetProfile(new GProfile((const char *)strCfgData, (int)strCfgData.Length(), 0));

						if (!server_start())
						{
							ss.dwCurrentState = SERVICE_STOPPED; 
							ss.dwCheckPoint = ss.dwWaitHint = 0;
							SetServiceStatus(hSS, &ss);
							break;
						}
					}
					else
					{
						// No password compiled in - and no valid startup file found
						for(int i=0; i<3;i++)
						{
							// three beeps
							MessageBeep(0);
							Sleep(1000);
						}
						ss.dwCurrentState = SERVICE_STOPPED; 
						ss.dwCheckPoint = ss.dwWaitHint = 0;
						SetServiceStatus(hSS, &ss);
						break;
					}
				}
				catch ( GException &)
				{
					ss.dwCurrentState = SERVICE_STOPPED; 
					ss.dwCheckPoint = ss.dwWaitHint = 0;
					SetServiceStatus(hSS, &ss);
					break;
				}



				if (dwSrvPendToState[ss.dwCurrentState] != 0) 
				{
					ss.dwCurrentState = dwSrvPendToState[ss.dwCurrentState]; 
					ss.dwCheckPoint = ss.dwWaitHint = 0;
					SetServiceStatus(hSS, &ss);
				}
				break;

            case SERVICE_CONTROL_PAUSE:
            case SERVICE_CONTROL_STOP:
            case SERVICE_CONTROL_SHUTDOWN:
                server_stop();
				if (dwSrvPendToState[ss.dwCurrentState] != 0) 
				{
					ss.dwCurrentState = dwSrvPendToState[ss.dwCurrentState]; 
					ss.dwCheckPoint = ss.dwWaitHint = 0;
					SetServiceStatus(hSS, &ss);
				}
				break;
         }

         // Determine which complete state to return
         break;

      }

      if (ss.dwCurrentState != SERVICE_STOPPED) {
         // Sleep until a control code comes in or a client connects
         GetQueuedCompletionStatus(g_hIOCP, &dwBytesTransferred,
            &dwCompKey, &po, INFINITE);
         fdwControl = dwBytesTransferred;
      }
   } while (ss.dwCurrentState != SERVICE_STOPPED);

   // Cleanup and stop this service
   CloseHandle(g_hIOCP);   
}
Beispiel #24
0
int main( int argc, char *argv[] )
{
        size_t i;
        int ret, opt, longIndex = 0;
        struct event *evsig_int;
#ifdef _WIN32
        WSADATA WSAData;
#endif
        pthread_t tcp_thread, *job_threads;

        if ( evutil_secure_rng_init() < 0 ) {
                ED2KD_LOGERR("failed to seed random number generator");
                return EXIT_FAILURE;
        }

        /* parse command line arguments */
        opt = getopt_long( argc, argv, optString, longOpts, &longIndex );
        while( opt != -1 ) {
                switch( opt ) {
                case 'v':
                        display_version();
                        return EXIT_SUCCESS;

                case 'g': {
                        unsigned char hash[ED2K_HASH_SIZE];
                        char hex_hash[sizeof(hash)*2+1];
                        get_random_user_hash(hash);
                        bin2hex(hash, hex_hash, sizeof(hex_hash));
                        puts(hex_hash);
                        return EXIT_SUCCESS;
                }

                case 'h':
                        display_usage();
                        return EXIT_SUCCESS;

                default:
                        return EXIT_FAILURE;
                }
                opt = getopt_long( argc, argv, optString, longOpts, &longIndex );
        }

#ifdef _WIN32
        if ( 0 != WSAStartup(0x0201, &WSAData) ) {
                ED2KD_LOGERR("WSAStartup failed!");
                return EXIT_FAILURE;
        }
#endif

        if ( !server_load_config(NULL) ) {
                ED2KD_LOGERR("failed to load configuration file");
                return EXIT_FAILURE;
        }

        display_libevent_info();

#ifdef EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED
        ret = evthread_use_windows_threads();
#elif EVTHREAD_USE_PTHREADS_IMPLEMENTED
        ret = evthread_use_pthreads();
#else
#error "unable to determine threading model"
#endif
        if ( ret < 0 ) {
                ED2KD_LOGERR("failed to init libevent threading model");
                return EXIT_FAILURE;
        }

        g_srv.evbase_main = event_base_new();
        if ( NULL == g_srv.evbase_main ) {
                ED2KD_LOGERR("failed to create main event loop");
                return EXIT_FAILURE;
        }
        g_srv.evbase_tcp = event_base_new();
        if ( NULL == g_srv.evbase_tcp ) {
                ED2KD_LOGERR("failed to create tcp event loop");
                return EXIT_FAILURE;
        }

        evsig_int = evsignal_new(g_srv.evbase_main, SIGINT, sigint_cb, NULL);
        evsignal_add(evsig_int, NULL);

        // common timers timevals
        g_srv.portcheck_timeout_tv = event_base_init_common_timeout(g_srv.evbase_tcp, &g_srv.cfg->portcheck_timeout_tv);
        g_srv.status_notify_tv = event_base_init_common_timeout(g_srv.evbase_tcp, &g_srv.cfg->status_notify_tv);

        if ( !db_create() ) {
                ED2KD_LOGERR("failed to create database");
                return EXIT_FAILURE;
        }

        g_srv.thread_count = omp_get_num_procs() + 1;

        pthread_cond_init(&g_srv.job_cond, NULL);
        pthread_mutex_init(&g_srv.job_mutex, NULL);
        TAILQ_INIT(&g_srv.jqueue);

        job_threads = (pthread_t *)malloc(g_srv.thread_count * sizeof(*job_threads));

        // start tcp worker threads
        for ( i=0; i<g_srv.thread_count; ++i ) {
                pthread_create(&job_threads[i], NULL, server_job_worker, NULL);
        }

        // start tcp dispatch thread
        pthread_create(&tcp_thread, NULL, server_base_worker, g_srv.evbase_tcp);

        // start tcp listen loop
        if ( !server_listen() ) {
                ED2KD_LOGERR("failed to start server listener");
                server_stop();
        }

        pthread_join(tcp_thread, NULL);

        while ( EBUSY == pthread_cond_destroy(&g_srv.job_cond) ) {
                pthread_cond_broadcast(&g_srv.job_cond);
                //pthread_yield();
        }

        pthread_mutex_destroy(&g_srv.job_mutex);

        for ( i=0; i<g_srv.thread_count; ++i ) {
                pthread_join(job_threads[i], NULL);
        }

        free(job_threads);

        // todo: free job queue items

        evconnlistener_free(g_srv.tcp_listener);
        event_free(evsig_int);
        event_base_free(g_srv.evbase_tcp);
        event_base_free(g_srv.evbase_main);

        if ( db_destroy() < 0 ) {
                ED2KD_LOGERR("failed to destroy database");
        }

        server_free_config();

        return EXIT_SUCCESS;
}
Beispiel #25
0
int
main(int argc, char * const argv[])
{
	int stream_sock[] = {0, 0, 0};  /* tcp4, tcp6, UNIX */
	int stream_socklen = sizeof(stream_sock) / sizeof(stream_sock[0]);
	int dgram_sock[] = {0, 0};  /* udp4, udp6 */
	int dgram_socklen = sizeof(dgram_sock) / sizeof(dgram_sock[0]);
	char id;
	unsigned short listenport = 2003;
	int ch;
	size_t numaggregators;
	size_t numcomputes;
	server *internal_submission;
	char *listeninterface = NULL;
	server **servers;
	char *allowed_chars = NULL;
	int i;
	enum { SUB, CUM } smode = CUM;

	if (gethostname(relay_hostname, sizeof(relay_hostname)) < 0)
		snprintf(relay_hostname, sizeof(relay_hostname), "127.0.0.1");

	while ((ch = getopt(argc, argv, ":hvdmstf:i:l:p:w:b:q:S:c:H:")) != -1) {
		switch (ch) {
			case 'v':
				do_version();
				break;
			case 'd':
				if (mode == TEST) {
					mode = DEBUGTEST;
				} else {
					mode = DEBUG;
				}
				break;
			case 'm':
				smode = SUB;
				break;
			case 's':
				mode = SUBMISSION;
				break;
			case 't':
				if (mode == DEBUG) {
					mode = DEBUGTEST;
				} else {
					mode = TEST;
				}
				break;
			case 'f':
				config = optarg;
				break;
			case 'i':
				listeninterface = optarg;
				break;
			case 'l':
				relay_logfile = optarg;
				break;
			case 'p':
				listenport = (unsigned short)atoi(optarg);
				if (listenport == 0) {
					fprintf(stderr, "error: port needs to be a number >0\n");
					do_usage(1);
				}
				break;
			case 'w':
				workercnt = (char)atoi(optarg);
				if (workercnt <= 0) {
					fprintf(stderr, "error: workers needs to be a number >0\n");
					do_usage(1);
				}
				break;
			case 'b':
				batchsize = atoi(optarg);
				if (batchsize <= 0) {
					fprintf(stderr, "error: batch size needs to be a number >0\n");
					do_usage(1);
				}
				break;
			case 'q':
				queuesize = atoi(optarg);
				if (queuesize <= 0) {
					fprintf(stderr, "error: queue size needs to be a number >0\n");
					do_usage(1);
				}
				break;
			case 'S':
				collector_interval = atoi(optarg);
				if (collector_interval <= 0) {
					fprintf(stderr, "error: sending interval needs to be "
							"a number >0\n");
					do_usage(1);
				}
				break;
			case 'c':
				allowed_chars = optarg;
				break;
			case 'H':
				snprintf(relay_hostname, sizeof(relay_hostname), "%s", optarg);
				break;
			case '?':
			case ':':
				do_usage(1);
				break;
			case 'h':
			default:
				do_usage(0);
				break;
		}
	}
	if (optind == 1 || config == NULL)
		do_usage(1);


	/* seed randomiser for dispatcher and aggregator "splay" */
	srand(time(NULL));

	if (workercnt == 0)
		workercnt = mode == SUBMISSION ? 2 : get_cores();

	/* any_of failover maths need batchsize to be smaller than queuesize */
	if (batchsize > queuesize) {
		fprintf(stderr, "error: batchsize must be smaller than queuesize\n");
		exit(-1);
	}

	if (relay_logfile != NULL && mode != TEST && mode != DEBUGTEST) {
		FILE *f = fopen(relay_logfile, "a");
		if (f == NULL) {
			fprintf(stderr, "error: failed to open logfile '%s': %s\n",
					relay_logfile, strerror(errno));
			exit(-1);
		}
		relay_stdout = f;
		relay_stderr = f;
	} else {
		relay_stdout = stdout;
		relay_stderr = stderr;
	}
	relay_can_log = 1;

	logout("starting carbon-c-relay v%s (%s), pid=%d\n",
			VERSION, GIT_VERSION, getpid());
	fprintf(relay_stdout, "configuration:\n");
	fprintf(relay_stdout, "    relay hostname = %s\n", relay_hostname);
	fprintf(relay_stdout, "    listen port = %u\n", listenport);
	if (listeninterface != NULL)
		fprintf(relay_stdout, "    listen interface = %s\n", listeninterface);
	fprintf(relay_stdout, "    workers = %d\n", workercnt);
	fprintf(relay_stdout, "    send batch size = %d\n", batchsize);
	fprintf(relay_stdout, "    server queue size = %d\n", queuesize);
	fprintf(relay_stdout, "    statistics submission interval = %ds\n",
			collector_interval);
	if (allowed_chars != NULL)
		fprintf(relay_stdout, "    extra allowed characters = %s\n",
				allowed_chars);
	if (mode == DEBUG || mode == DEBUGTEST)
		fprintf(relay_stdout, "    debug = true\n");
	else if (mode == SUBMISSION)
		fprintf(relay_stdout, "    submission = true\n");
	fprintf(relay_stdout, "    routes configuration = %s\n", config);
	fprintf(relay_stdout, "\n");

	if (router_readconfig(&clusters, &routes,
				config, queuesize, batchsize) == 0)
	{
		logerr("failed to read configuration '%s'\n", config);
		return 1;
	}
	router_optimise(&routes);

	numaggregators = aggregator_numaggregators();
	numcomputes = aggregator_numcomputes();
#define dbg (mode == DEBUG || mode == DEBUGTEST ? 2 : 0)
	if (numaggregators > 10 && !dbg) {
		fprintf(relay_stdout, "parsed configuration follows:\n"
				"(%zd aggregations with %zd computations omitted "
				"for brevity)\n", numaggregators, numcomputes);
		router_printconfig(relay_stdout, 0, clusters, routes);
	} else {
		fprintf(relay_stdout, "parsed configuration follows:\n");
		router_printconfig(relay_stdout, 1 + dbg, clusters, routes);
	}
	fprintf(relay_stdout, "\n");

	/* shortcut for rule testing mode */
	if (mode == TEST || mode == DEBUGTEST) {
		char metricbuf[METRIC_BUFSIZ];
		char *p;

		fflush(relay_stdout);
		while (fgets(metricbuf, sizeof(metricbuf), stdin) != NULL) {
			if ((p = strchr(metricbuf, '\n')) != NULL)
				*p = '\0';
			router_test(metricbuf, routes);
		}

		exit(0);
	}

	if (signal(SIGINT, exit_handler) == SIG_ERR) {
		logerr("failed to create SIGINT handler: %s\n", strerror(errno));
		return 1;
	}
	if (signal(SIGTERM, exit_handler) == SIG_ERR) {
		logerr("failed to create SIGTERM handler: %s\n", strerror(errno));
		return 1;
	}
	if (signal(SIGQUIT, exit_handler) == SIG_ERR) {
		logerr("failed to create SIGQUIT handler: %s\n", strerror(errno));
		return 1;
	}
	if (signal(SIGHUP, hup_handler) == SIG_ERR) {
		logerr("failed to create SIGHUP handler: %s\n", strerror(errno));
		return 1;
	}
	if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
		logerr("failed to ignore SIGPIPE: %s\n", strerror(errno));
		return 1;
	}

	workers = malloc(sizeof(dispatcher *) * (1 + workercnt + 1));
	if (workers == NULL) {
		logerr("failed to allocate memory for workers\n");
		return 1;
	}

	if (bindlisten(stream_sock, &stream_socklen,
				dgram_sock, &dgram_socklen,
				listeninterface, listenport) < 0) {
		logerr("failed to bind on port %s:%d: %s\n",
				listeninterface == NULL ? "" : listeninterface,
				listenport, strerror(errno));
		return -1;
	}
	for (ch = 0; ch < stream_socklen; ch++) {
		if (dispatch_addlistener(stream_sock[ch]) != 0) {
			logerr("failed to add listener\n");
			return -1;
		}
	}
	for (ch = 0; ch < dgram_socklen; ch++) {
		if (dispatch_addlistener_udp(dgram_sock[ch]) != 0) {
			logerr("failed to listen to datagram socket\n");
			return -1;
		}
	}
	if ((workers[0] = dispatch_new_listener()) == NULL)
		logerr("failed to add listener\n");

	if (allowed_chars == NULL)
		allowed_chars = "-_:#";
	logout("starting %d workers\n", workercnt);
	for (id = 1; id < 1 + workercnt; id++) {
		workers[id + 0] = dispatch_new_connection(routes, allowed_chars);
		if (workers[id + 0] == NULL) {
			logerr("failed to add worker %d\n", id);
			break;
		}
	}
	workers[id + 0] = NULL;
	if (id < 1 + workercnt) {
		logerr("shutting down due to errors\n");
		keep_running = 0;
	}

	/* server used for delivering metrics produced inside the relay,
	 * that is collector (statistics) and aggregator (aggregations) */
	if ((internal_submission = server_new("internal", listenport, CON_PIPE,
					NULL, 3000 + (numcomputes * 3), batchsize)) == NULL)
	{
		logerr("failed to create internal submission queue, shutting down\n");
		keep_running = 0;
	}

	if (numaggregators > 0) {
		logout("starting aggregator\n");
		if (!aggregator_start(internal_submission)) {
			logerr("shutting down due to failure to start aggregator\n");
			keep_running = 0;
		}
	}

	logout("starting statistics collector\n");
	collector_start(&workers[1], clusters, internal_submission, smode == CUM);

	logout("startup sequence complete\n");

	/* workers do the work, just wait */
	while (keep_running)
		sleep(1);

	logout("shutting down...\n");
	/* make sure we don't accept anything new anymore */
	for (ch = 0; ch < stream_socklen; ch++)
		dispatch_removelistener(stream_sock[ch]);
	destroy_usock(listenport);
	logout("listeners for port %u closed\n", listenport);
	/* since workers will be freed, stop querying the structures */
	collector_stop();
	logout("collector stopped\n");
	if (numaggregators > 0) {
		aggregator_stop();
		logout("aggregator stopped\n");
	}
	server_shutdown(internal_submission);
	/* give a little time for whatever the collector/aggregator wrote,
	 * to be delivered by the dispatchers */
	usleep(500 * 1000);  /* 500ms */
	/* make sure we don't write to our servers any more */
	logout("stopped worker");
	for (id = 0; id < 1 + workercnt; id++)
		dispatch_stop(workers[id + 0]);
	for (id = 0; id < 1 + workercnt; id++) {
		dispatch_shutdown(workers[id + 0]);
		fprintf(relay_stdout, " %d", id + 1);
		fflush(relay_stdout);
	}
	fprintf(relay_stdout, "\n");
	router_shutdown();
	servers = router_getservers(clusters);
	logout("stopped server");
	for (i = 0; servers[i] != NULL; i++)
		server_stop(servers[i]);
	for (i = 0; servers[i] != NULL; i++) {
		server_shutdown(servers[i]);
		fprintf(relay_stdout, " %d", i + 1);
		fflush(relay_stdout);
	}
	fprintf(relay_stdout, "\n");
	logout("routing stopped\n");

	router_free(clusters, routes);
	free(workers);
	return 0;
}
Beispiel #26
0
int main(int argc, char *argv[]) {

	/* Richiesta di shutdown server */
	if (argc > 1) if (!strcmp(argv[1], "shutdown") || !strcmp(argv[1], "-f")) shutdown();
	else {
		printf("Errore parametro in input\n\n");
		exit(0);
	}

	/* Avvio del server */
	server_start();
	int termina = FALSE;
	do {
		// Sono il padre
		if (termina && number_msges_in_queue(msgid) == 0)
			server_stop();
		if (padre == -1) {
			errorlog(LOG_PATH, "Impossibile eseguire la fork");
			server_stop();
		}
		// In attesa di messaggi dal client
		if(msg_receive(&req, msgl, msgid, 1) < 0) {
			errorlog(LOG_PATH, "Impossibile ricevere messaggi");
			server_stop();
		}
		if (req.pid == -2)
			termina = TRUE;
		else {
			// Statistiche
			counter_r++;
			if(req.todo == M_DOWN || req.todo == M_DALL)
				counter_d++;
			else if(req.todo == M_ADD || req.todo == M_UPD)
				counter_u++;
			else if(req.todo == M_PUSH)
				counter_p++;
			else if(req.todo == M_AUTH && req.pwd != -1) //Non conto i logout
				 counter_a++;
			// Fine Statistiche

			waitS(SEM_SERVER);  //WAIT su semaforo per avere al massimo 5 figli del server
			padre = fork();
		}
	} while (padre);

	/* Sono il figlio */
	if (!padre) {
		// Invio di un pacchetto dal server al client
		if (req.todo == M_DOWN) download_one();

		// Riceve un pacchetto dal client da aggiungere
		else if (req.todo == M_ADD) aggiungi_pkg();

		// Riceve un pacchetto dal client da aggiornare
		else if (req.todo == M_UPD) aggiorna_pkg();

		// Richiesta di tutto il repository da parte del cliente
		else if (req.todo == M_DALL) download_all();

		// Autenticazione clienti di upload
		else if (req.todo == M_AUTH) autentica();

		// Registrazione client push
		else if (req.todo == M_PUSH) registra_push();

		else writebuf("(unknow)\t %d Richiesta non riconosciuta [ERRORE] \n", req.pid);

		//WAIT su semaforo per lasciare la possibilità ad un altro figlio del server di generarsi
		signalS(SEM_SERVER);
	}
	return 0;
}
Beispiel #27
0
int main(int argc, char* args[])
{
    //Start up SDL and create window
    int screenmode = 0;
    if (argc > 1) {
        screenmode = std::stoi(args[1]);
    }
    if (!init(screenmode))
    {
        printf("Failed to initialize!\n");
    }
    else
    {
        Menu menu = Menu();
        //Load media
        if (!menu.init())
        {
            printf("Failed to load media!\n");
        }
        else
        {
            //Main loop flag
            bool quit = false;
            int state = STATE_MENU;
            int mode = M_SINGLEPLAYER;

            rngGfx.seed(time(NULL));

            glLoadIdentity();
            glTranslated(-1, 1, 0);
            glScaled(2.0 / SCREEN_WIDTH, -2.0 / SCREEN_HEIGHT, 1.0);

            const Uint8 *keyboard = SDL_GetKeyboardState(NULL);
            //Event handler
            SDL_Event e;
            frame = 0;
            unsigned int endTime = SDL_GetTicks();

            GameLogic g;
            //While application is running
            while (!quit)
            {
                endTime = endTime + 17;
                frame++;
                if (frame % 3 == 0) endTime--;
                //Handle events on queue
                SDL_Scancode keydown = SDL_SCANCODE_UNKNOWN;
                while (SDL_PollEvent(&e) != 0)
                {
                    //User requests quit
                    if (e.type == SDL_QUIT)
                    {
                        quit = true;
                    }
                    if (e.type == SDL_MOUSEMOTION) {
                        //Get the mouse offsets 
                        mouseX = e.motion.x;
                        mouseY = e.motion.y;
                        if (screenmode == 1 || screenmode == 3) {
                            mouseX /= 1.5;
                            mouseY /= 1.5;
                        }
                    }
                    if (e.type == SDL_MOUSEBUTTONDOWN || e.type == SDL_MOUSEBUTTONUP) {
                        mouseX = e.button.x;
                        mouseY = e.button.y;
                        if (e.button.button == SDL_BUTTON_LEFT)
                            clicked = (e.button.state == SDL_PRESSED);
                        if (screenmode == 1 || screenmode == 3) {
                            mouseX /= 1.5;
                            mouseY /= 1.5;
                        }
                    }
                    if (e.type == SDL_KEYDOWN) {
                        keydown = e.key.keysym.scancode;
                    }
                }
                if (keyboard[SDL_SCANCODE_ESCAPE]) {
                    quit = true;
                }
                //Clear screen
                glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
                glClear(GL_COLOR_BUFFER_BIT);
                switch (state) {
                    case STATE_MENU:
                        g = GameLogic();
                        g.write_other_players = SDL_CreateMutex();		  
                        mode = menu.step( mouseX,  mouseY,  clicked, keyboard, keydown);//returns mode if changed, 0 if no change
                        if (mode != 0) {
                            std::cout << mode;
			                state = (mode == M_SERVER) ? STATE_WAIT_FOR_CLIENT : STATE_BEGINGAME;
                        }
                        menu.draw( mouseX,  mouseY);
                        break;
		            case STATE_WAIT_FOR_CLIENT:
			            uint32_t rng_seed;
			            IPaddress ip;
                        glColor3f(1.0f, .4f, .9f);
                        menu.draw_text(80, 300, "Waiting for client");
                        menu.draw_text(180, 400, "to connect");
			            if (server_begin(&rng_seed, &ip))
			            {
			                state = STATE_BEGINGAME;
			                g.addOtherPlayer(100, 100, 0, ip);
			                rngGame.seed(rng_seed);
			                SDL_CreateThread(receive_packets, "Network", &g);
			            }
		                break;
                    case STATE_BEGINGAME:
                        if (mode == M_CLIENT)
                        {
                            //Client
                            uint32_t rng_seed = time(NULL);
                            g.addOtherPlayer(100, 100, 0, client_begin(menu.tmpip, rng_seed));
                            rngGame.seed(rng_seed);
                            SDL_CreateThread(receive_packets, "Network", &g);
                        }
                        if (mode == M_SINGLEPLAYER)
                        {
                            rngGame.seed(time(NULL));
                        }
                        g.rings.init();
                        state = STATE_GAMEPLAY;//don't break, continue directly to gameplay
                    case STATE_GAMEPLAY: 
                        g.step(keyboard);
                        g.draw();
                        if (g.rings.thisRing >= 20) {
                            g.haveWon = g.haveWon || ((g.multiplayer && g.opponent_rings < 20) || !g.multiplayer);
                            glColor3f(1.0f, .4f, .9f);
                            if (g.haveWon)
                                menu.draw_text(10, 10, "You won");
                            else
                                menu.draw_text(10, 10, "You lost");

                            menu.draw_text(10, 110, "Time taken:");
                            menu.draw_text(10 + chrw * 11, 110, const_cast<char *>((std::to_string(g.timeFlying)).c_str()));
                            menu.draw_text(10, 200, "Press Enter to return");
                            menu.draw_text(10, 300, "to menu");
                            if (keydown == SDL_SCANCODE_RETURN) {
                                state = STATE_MENU;
                                if (mode == M_CLIENT || mode == M_SERVER)
                                    server_stop();
                            }
                        }
                        else {
                            glColor3f(0.0f, 1.0f, 0.0f);
                            if (g.rings.thisRing >= 10)
                                menu.draw_text(10, 10, const_cast<char *>((std::to_string(g.rings.thisRing)).c_str()));
                            else
                                menu.draw_text(10 + chrw, 10, const_cast<char *>((std::to_string(g.rings.thisRing)).c_str()));
                            menu.draw_text(10 + 2 * chrw, 10, "/20");
                            glColor3f(1.0f, 0.0f, 0.0f);
                            if (g.multiplayer)
                            {
                                if (g.opponent_rings >= 10)
                                    menu.draw_text(10, 30, const_cast<char *>((std::to_string(g.opponent_rings)).c_str()));
                                else
                                    menu.draw_text(10 + chrw, 30, const_cast<char *>((std::to_string(g.opponent_rings)).c_str()));

                                menu.draw_text(10 + 2 * chrw, 30, "/20");				
                            }
                        }
                        break;
                    }
                menu.drawGrid();
                //Update screen
                SDL_GL_SwapWindow(gWindow);
                if (SDL_GetTicks() < endTime) {
                    //Sleep the remaining frame time
                    SDL_Delay(endTime-SDL_GetTicks());
                }
                else {
                    //std::cout << SDL_GetTicks()-endTime << "\n";
                }
            }
        }
    }

    //Free resources and close SDL
    close();

    return 0;
}
Beispiel #28
0
static  void    handler(int signo)
{
    server_stop() ;
    signal(signo, SIG_DFL) ;
}
Beispiel #29
0
char *test_server_stop()
{
    mu_assert("Stopping server", server_stop() == 0);
    return 0;
}
static void ietadm_request_exec(struct ietadm_req *req, struct ietadm_rsp *rsp)
{
	int err = 0;

	log_debug(1, "%u %u %" PRIu64 " %u %u", req->rcmnd, req->tid,
		  req->sid, req->cid, req->lun);

	switch (req->rcmnd) {
	case C_TRGT_NEW:
		err = cops->target_add(&req->tid, req->u.trgt.name);
		break;
	case C_TRGT_DEL:
		err = cops->target_del(req->tid);
		break;
	case C_TRGT_UPDATE:
		if (req->u.trgt.type & (1 << key_session))
			err = cops->param_set(req->tid, req->sid,
					      key_session,
					      req->u.trgt.session_partial,
					      req->u.trgt.session_param);

		if (err < 0)
			goto out;

		if (req->u.trgt.type & (1 << key_target))
			err = cops->param_set(req->tid, req->sid, key_target,
					      req->u.trgt.target_partial,
					      req->u.trgt.target_param);
		break;
	case C_TRGT_SHOW:
		err = ki->param_get(req->tid, req->sid, key_target,
				    req->u.trgt.target_param);
		break;

	case C_SESS_NEW:
	case C_SESS_DEL:
	case C_SESS_UPDATE:
		break;
	case C_SESS_SHOW:
		err = ki->param_get(req->tid, req->sid, key_session,
				    req->u.trgt.session_param);
		break;

	case C_LUNIT_NEW:
		err = cops->lunit_add(req->tid, req->lun, req->u.lunit.args);
		break;
	case C_LUNIT_DEL:
		err = cops->lunit_del(req->tid, req->lun);
		break;
	case C_LUNIT_UPDATE:
	case C_LUNIT_SHOW:
		break;

	case C_CONN_NEW:
	case C_CONN_DEL:
		err = ki->conn_destroy(req->tid, req->sid, req->cid);
		break;
	case C_CONN_UPDATE:
	case C_CONN_SHOW:
		break;

	case C_ACCT_NEW:
		err = cops->account_add(req->tid, req->u.acnt.auth_dir, req->u.acnt.user,
					req->u.acnt.pass);
		break;
	case C_ACCT_DEL:
		err = cops->account_del(req->tid, req->u.acnt.auth_dir, req->u.acnt.user);
		break;
	case C_ACCT_UPDATE:
	case C_ACCT_SHOW:
		break;
	case C_SYS_NEW:
		break;
	case C_SYS_DEL:
		err = server_stop();
		break;
	case C_SYS_UPDATE:
	case C_SYS_SHOW:
		break;
	default:
		break;
	}

out:
	rsp->err = err;
}