static PyObject*
run(PyObject* self, PyObject* args)
{
ServerInfo info;
PyObject* socket;
if(!PyArg_ParseTuple(args, "OO:server_run", &socket, &info.wsgi_app)) {
return NULL;
}
info.sockfd = PyObject_AsFileDescriptor(socket);
if (info.sockfd < 0) {
return NULL;
}
info.host = NULL;
if (PyObject_HasAttrString(socket, "getsockname")) {
PyObject* sockname = PyObject_CallMethod(socket, "getsockname", NULL);
if (sockname == NULL) {
return NULL;
}
if (PyTuple_CheckExact(sockname) && PyTuple_GET_SIZE(sockname) == 2) {
/* Standard (ipaddress, port) case */
info.host = PyTuple_GET_ITEM(sockname, 0);
info.port = PyTuple_GET_ITEM(sockname, 1);
}
}
_initialize_request_module();
server_run(&info);
Py_RETURN_NONE;
}
int main(int argc, char **argv)
{
struct sigaction actions;
parse_options(&argc, &argv);
if (asprintf(&libmemtrace, "%s/libmemtrace.so", lib_path) == -1)
fatal("asprintf (%s)", strerror(errno));
create_shmem();
main_pid = app_start((char **)(argv + 1));
atexit(cleanup);
signal(SIGINT, sigint_handler);
sigemptyset(&actions.sa_mask);
actions.sa_flags = SA_RESTART;
actions.sa_handler = sigchld_handler;
if (sigaction(SIGCHLD, &actions, NULL)) {
perror("sigaction(SIGCHLD)");
return 1;
}
create_socket();
create_comm();
init_server();
server_run();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
const uint16_t acceptor_port = (uint16_t)((argc >= 2) ? atoi(argv[1]) : 8080);
char const * const settings_file_name = ((argc >= 3) ? argv[2] : "settings.txt");
settings_t settings;
server_t server;
log_t log;
log_create(&log, stderr);
if (!load_settings(&settings, settings_file_name, &log))
{
return 1;
}
if (!server_create(&server, &log, &settings, acceptor_port))
{
settings_destroy(&settings);
return 1;
}
settings_destroy(&settings);
server_run(&server);
server_destroy(&server);
log_destroy(&log);
return 0;
}
static gpointer
server_in_background (BackgroundData *data)
{
int argc = data->argc;
char **argv = data->argv;
CORBA_Object servant = CORBA_OBJECT_NIL;
CORBA_char filename[] = "calculator.ref";
CORBA_Environment ev[1];
CORBA_exception_init(ev);
server_init (&argc, argv, &global_orb, &default_poa, ev);
etk_abort_if_exception(ev, "failed ORB init");
servant = server_activate_service (global_orb, default_poa, ev);
etk_abort_if_exception(ev, "failed activating service");
g_print ("Writing service reference to: %s\n\n", filename);
etk_export_object_to_file (global_orb,
servant,
filename,
ev);
etk_abort_if_exception(ev, "failed exporting IOR");
server_run (global_orb, ev);
etk_abort_if_exception(ev, "failed entering main loop");
server_cleanup (global_orb, default_poa, servant, ev);
etk_abort_if_exception(ev, "failed cleanup");
g_thread_exit (NULL);
}
int
main (int argc, char *argv[])
{
CORBA_Object servant = CORBA_OBJECT_NIL;
CORBA_char filename[] = "/tmp/test-ldata.ior";
CORBA_Environment ev[1];
CORBA_exception_init(ev);
server_init (&argc, argv, &global_orb, &root_poa, ev);
etk_abort_if_exception(ev, "failed ORB init");
servant = server_activate_service (global_orb, root_poa, ev);
etk_abort_if_exception(ev, "failed activating service");
g_print ("Writing service reference to: %s\n\n", filename);
etk_export_object_to_file (global_orb,
servant,
filename,
ev);
etk_abort_if_exception(ev, "failed exporting IOR");
server_run (global_orb, ev);
etk_abort_if_exception(ev, "failed entering main loop");
server_cleanup (global_orb, root_poa, servant, ev);
etk_abort_if_exception(ev, "failed cleanup");
exit (0);
}
status_e svc_generic_handler( struct service *sp, connection_s *cp )
{
if ( svc_parent_access_control( sp, cp ) == OK ) {
return( server_run( sp, cp ) ) ;
}
return( FAILED ) ;
}
void *tpcmaster_runner(void *callback) {
socket_server.master = 1;
socket_server.max_threads = 2;
memcpy(&socket_server.tpcmaster, &testmaster, sizeof(tpcmaster_t));
socket_server.tpcmaster.handle = tpcmaster_dummy_handle;
server_run("test", SLAVE_PORT, &socket_server, (callback_t) callback);
return NULL;
}
int main (int argc, char* argv[]) {
int f[2000];
oram_args_t *args = malloc(sizeof(oram_args_t));
args_parse(args, argc, argv);
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
if (args->mode == ORAM_MODE_SERVER) {
if (args->daemon == ORAM_DAEMON_STOP) {
if (daemon_stop(args) != 0) {
errf("cannot stop");
return -1;
}
return 0;
}
else if (args->daemon == ORAM_DAEMON_RESTART) {
if (daemon_stop(args) != 0) {
errf("cannot stop");
return -1;
}
if (daemon_start(args) != 0) {
errf("cannot start");
return -1;
}
}
else if (args->daemon == ORAM_DAEMON_START) {
if (daemon_start(args) != 0) {
errf("cannot start");
return -1;
}
}
server_run(args, &sv_ctx);
}
else {
client_ctx ctx;
oram_client_args ar;
ar.verbose = 1;
if (client_init(&ctx, &ar) < 0)
return -1;
// if (client_create(&ctx, 6000, 1) < 0)
// return -1;
if (client_load(&ctx, 1) < 0)
return -1;
unsigned char data[ORAM_BLOCK_SIZE];
int m;
for(m = 0;m < 100;m++) {
data[0] = m;
oblivious_access(m, ORAM_ACCESS_WRITE, data, &ctx);
}
for(m = 0;m < 100;m++) {
oblivious_access(m, ORAM_ACCESS_READ, data, &ctx);
f[m] = data[0];
}
for (m = 0;m < 100;m++)
assert(f[m] == m);
client_save(&ctx, 0);
}
return 0;
}
DWORD WINAPI ThreadFunc(LPVOID temp)
{
sever_init();
sock_init(myrefun);
mmf_init();
server_run();
sever_exit();
return 0;
}
int main() {
struct Server *s = malloc(sizeof(struct Server));
server_create(s, "/tmp/accounts.txt", "/tmp/requests");
//server_createAccount(s, 1231, "vascoFG", "bino", 0);
/*server_createAccount(s, 1234, "vascoFG", "bino", 0);
server_createAccount(s, 4321, "vascoFG", "bino", 0);*/
server_run(s);
return 0;
}
int main(int argc, char const *argv[]) {
server_init();
server_register_endpoint(init_chat_endpoint_implement("/chat"));
server_register_endpoint(init_whiteboard_endpoint_implement("/whiteboard"));
int port = 8000;
server_run(port);
return 0;
}
void server_loop(int tick)
{
// prepare for any script based spawns
object_script_spawn_start();
// run all server functions
scripts_run(tick);
server_run(tick);
// finish spawning any script based objects
object_script_spawn_finish();
}
int main(int argc, char **argv)
{
int sfd;
int cfd;
setenv("PCM_HOOK", "accept", 1);
setenv("PCM_POLICY_FILE", "../tests/01-accept.json", 1);
pcm_initialize();
sfd = server_run();
cfd = client_connect();
accept_connection(sfd);
return 0;
}
static int run(char *default_user_path, int port)
{
if (signal(SIGCHLD, SIG_IGN) == SIG_ERR)
return (dprintf(2, ERR_SET_SIGNAL), 0);
g_config.port = port;
g_config.sock_fd = -1;
g_config.client_sock_fd = -1;
g_config.parent_pid = getpid();
if ((g_config.sock_fd = server_create(INADDR_ANY, port, 1)) == -1)
return (dprintf(2, ERR_SERVER_CREATE, g_config.port), 0);
if (user_change_home("anonymous", default_user_path) == 0)
return (dprintf(2, ERR_USER_CHANGE_DIR), 0);
server_run();
close(g_config.sock_fd);
return (1);
}
int main(int argc, char** argv) {
int port = 8888;
server_t server;
if (argc > 1) {
if (argc > 2) {
printf("%s\n", USAGE);
return 1;
}
port = atoi(argv[1]);
}
server.master = 1;
server.max_threads = 3;
tpcmaster_init(&server.tpcmaster, 2, 2, 4, 4);
printf("TPC Master server started listening on port %d...\n", port);
server_run("localhost", port, &server, NULL);
}
int main(int argc, char **argv)
{
server_config config;
int err;
memset(&config, 0, sizeof(config));
config.bind_host = DEFAULT_BIND_HOST;
config.bind_port = DEFAULT_BIND_PORT;
config.idle_timeout = DEFAULT_IDLE_TIMEOUT;
parse_opts(&config, argc, argv);
err = server_run(&config, uv_default_loop());
if (err) {
exit(1);
}
return 0;
}
int main(int argc, char * argv[])
{
static server_context_t sc;
static glclient_context_t glcc;
int opt;
char my_ip[GLS_STRING_SIZE_PLUS];
char his_ip[GLS_STRING_SIZE_PLUS];
uint16_t my_port = 12346;
uint16_t his_port = 12345;
strncpy(my_ip, "127.0.0.1", GLS_STRING_SIZE);
strncpy(his_ip, "127.0.0.1", GLS_STRING_SIZE);
strncpy(glcc.joy_dev, "/dev/input/js0", GLS_STRING_SIZE);
while ((opt = getopt(argc, argv, "s:c:j:h")) != -1)
{
switch (opt)
{
case 's':
strncpy(his_ip, strtok(optarg, ":"), GLS_STRING_SIZE);
his_port = atoi(strtok(NULL, ":"));
break;
case 'c':
strncpy(my_ip, strtok(optarg, ":"), GLS_STRING_SIZE);
my_port = atoi(strtok(NULL, ":"));
break;
case 'j':
strncpy(glcc.joy_dev, optarg, GLS_STRING_SIZE);
break;
case 'h':
default:
printf("Usage: %s [-c my_ip_address:port] [-s server_ip_address:port] [-j joystick_device]\n", argv[0]);
return 0;
}
}
server_init(&sc);
set_server_address_port(&sc, my_ip, my_port);
set_client_address_port(&sc, his_ip, his_port);
set_client_user_context(&sc, &glcc);
server_run(&sc, glclient_thread);
return 0;
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
/* Initialize DirectFB including command line parsing. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
DirectFBError( "DirectFBInit() failed", ret );
return -1;
}
/* Parse the command line. */
if (!parse_command_line( argc, argv ))
return -2;
/* Run the server. */
return server_run();
}
int main(int argc, char *argv[])
{
//1. 配置解析
if (up_conf_init(argc, argv) <0){
ERR_PRINTF("up_conf_init failed.\n");
return -1;
}
//2.
if (server_init() < 0) {
ERR_PRINTF("server_init failed.\n");
return -1;
}
server_run();
return 0;
}
int main(int argc, char const *argv[])
{
struct sockaddr_in server_addr;
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_handler = SIG_IGN;
if(sigaction(SIGINT, &act, NULL) < 0) {
perror("sigaction");
}
sigemptyset(&act.sa_mask);
act.sa_handler = server_quit;
if(sigaction(SIGQUIT, &act, NULL) < 0) {
perror("sigaction");
}
if((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(EXIT_FAILURE);
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(9003);
inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);
if(bind(sock_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
perror("bind");
exit(EXIT_FAILURE);
}
if(listen(sock_fd, 0) < 0) {
perror("listen");
exit(EXIT_FAILURE);
}
printf("server is listening...\n");
server_init(sock_fd);
server_run();
return 0;
}
// Main function fo whole program
int main(int argc, char **argv) {
signal(SIGINT, sigint_handler);
if (argc < 3) {
log_msg(LOG_ERROR, "[SERVER] Server need's two parameters\n");
log_msg(LOG_ERROR, "[SERVER] Usage: chess_server <listen_address> <port>\n");
return EXIT_FAILURE;
}
if (!atoi(argv[2])) {
log_msg(LOG_ERROR, "[SERVER] Invalid port %s to listen on\n", argv[2]);
log_msg(LOG_ERROR, "[SERVER] Usage: chess_server <listen_address> <port>\n");
return EXIT_FAILURE;
}
initialize_logger(), server_run(argv[1], atoi(argv[2]));
return EXIT_SUCCESS;
}
int main ()
{
Status stat;
debug ("init");
stat = server_init (&server);
if (stat)
goto error;
debug ("run");
stat = server_run (&server);
if (stat)
goto error;
debug ("ok");
return G_OK;
error:
debug ("error");
return G_ERR;
}
/*
* The main server process
*/
int main(int argc, char **argv)
{
printf("%s\n", banner);
if (argc > 1) {
port = atoi(argv[1]);
} else {
port = DEFAULT_LISTEN_PORT;
}
printf("Starting chat server ...\n");
signal(SIGINT, shutdown_handler);
signal(SIGTERM, shutdown_handler);
// Initilize the server
server_init();
// Run the server
server_run();
return 0;
}
int main(int argc, char* argv[])
{
signal(SIGINT, sig_handler);
unsigned short port = 21;
if(argc == 2)
{
port = (unsigned short) atoi(argv[1]);
}
struct Command ftp_command;
// initialize command struct
command_init(&ftp_command);
// import commands...
feat_command_import(&ftp_command);
base_command_import(&ftp_command);
ext_command_import(&ftp_command);
command_register_connect(&ftp_command, client_connect);
command_register_disconnect(&ftp_command, client_disconnect);
// initialize server struct
server_init(&ftp_server, &ftp_command, port);
std::cout << "Started server!" << std::endl;
uint32_t ret = server_run(&ftp_server);
std::cout << "Server stopped (code: " << ret << ")!" << std::endl;
server_free(&ftp_server);
command_free(&ftp_command);
return 0;
}
int main(int argc, char ** argv){
//if is given parameters for add user
if(argc>2){
//check for username in login file
FILE * login_file = fopen("login","r");
if(login_file){
//find given username in login file
char username[BUFFER_SIZE],password[BUFFER_SIZE];
while(fgets(username,BUFFER_SIZE,login_file)!=NULL){
fgets(password,BUFFER_SIZE,login_file);
username[strlen(username)-1]='\0';
password[strlen(password)-1]='\0';
//if we found suitable username and password credentials are OK
if(!strcmp(argv[2],username)){
printf("Username already exists !!!!\n");
fclose(login_file);
return 0;
}
}
fclose(login_file);
}
char password[BUFFER_SIZE],password1[BUFFER_SIZE];
//ask for password
getpassword("Password: "******"Retype password: "******"login","a");
fprintf(f,"%s\n",argv[2]);
fprintf(f,"%s\n",password);
fclose(f);
}
//passwords are not same
else
printf("Passwords are different!!!\n");
//exiting
return 0;
}
//check for running server
FILE * f = fopen(serverLock,"r");
if(f){
printf("Another instance of server is running !!!\n");
fclose(f);
return 0;
}
//create server.lock
f = fopen(serverLock,"w");
fclose(f);
//print message to server console
printf("To quit press q and then enter.\n");
//create child process for processing queries
int mypid = 0;
int pid = fork();
if(pid > (pid_t)0){
//child process
mypid = pid;
server_init();
server_run();
}
else{
//main process
while(1){
char c;
scanf("%c",&c);
//if q is pressed terminate child process - processing queries
if(c=='q'){
printf("Are you sure you want to end the server?\n");
printf("Please confirm (y/n): ");
scanf("%s",&c);
if(c=='y'){
kill(mypid,SIGTERM);
exit(0);
}
}
}
}
//exit
return 0;
}
int main(int ac, char *av[])
{
int c, i;
u_config_t *cfg = NULL, *vhost;
while ((c = getopt(ac, av, "b:hf:Rs:v")) != -1)
{
switch (c)
{
case 'b':
if (sscanf(optarg, "%zu", &g_ctx.bsz) != 1)
usage(av[0]);
break;
case 'f':
g_ctx.conf = optarg;
break;
case 'v':
g_ctx.verbose = true;
break;
case 's':
if (sscanf(optarg, "%lld", (long long *)&g_ctx.sep.tv_sec) != 1)
usage(av[0]);
break;
case 'R':
g_ctx.rel_refs = true;
break;
case 'h':
default:
usage(av[0]);
}
}
/* Load configuration from file. */
dbg_err_ifm(u_config_load_from_file(g_ctx.conf, &cfg),
"error loading %s", g_ctx.conf);
/* Initialize libevent and evcoap machinery. */
dbg_err_ifm(server_init(), "evcoap initialization failed");
/* Bind configured addresses. */
dbg_err_ifm(server_bind(cfg), "server socket setup failed");
/* Setup configured virtual hosts. */
for (i = 0; (vhost = u_config_get_child_n(cfg, "vhost", i)) != NULL; ++i)
dbg_err_ifm(vhost_setup(vhost), "configuration error");
dbg_err_ifm(i == 0, "no origins configured");
#if 0
/* Attach create() as the URI fallback handler. */
dbg_err_ifm(ec_register_fb(g_ctx.coap, create, NULL),
"error registering fallback");
#endif
dbg_err_ifm(server_run(), "server run failed");
return EXIT_SUCCESS;
err:
if (cfg)
u_config_free(cfg);
server_term();
return EXIT_FAILURE;
}
int main(int argc, char *argv[])
{
int src_GUID = -1, dst_GUID = -1;
/* parameter parsing */
while(1) {
int option_index = 0, c = 0;
static struct option long_options[] =
{
{"h", no_argument, 0, 0},
{"help", no_argument, 0, 0},
{"v", no_argument, 0, 0},
{"version", no_argument, 0, 0},
{"orbit", no_argument, 0, 0},
{"d", no_argument, 0, 0},
{"m", required_argument, 0, 0},
{"o", required_argument, 0, 0},
{"storm", no_argument, 0, 0},
{"train", no_argument, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long_only(argc, argv, "", long_options, &option_index);
/* no more options to parse */
if(c == -1) break;
/* unrecognized option */
if(c == '?')
{
help();
return 0;
}
switch(option_index)
{
/* h, help */
case 0:
case 1:
help();
return 0;
break;
/* v, version */
case 2:
case 3:
printf("Real-Time CPS Server Version: 0.1\n" \
"Compilation Date.....: unknown\n" \
"Compilation Time.....: unknown\n");
return 0;
break;
/* orbit, run in orbit mode */
case 4:
orbit = 1;
break;
/* debug mode */
case 5:
debug = 1;
break;
/* mine GUID */
case 6:
src_GUID = strtol(optarg, NULL, 10);
break;
/* other's GUID */
case 7:
dst_GUID = strtol(optarg, NULL, 10);
break;
/* storm mode */
case 8:
storm = 1;
break;
/* train mode */
case 9:
train = 1;
break;
default:
help();
return 0;
}
}
if (!orbit)
{
/* register signal handler for <CTRL>+C in order to clean up */
if(signal(SIGINT, signal_handler) == SIG_ERR)
{
printf("could not register signal handler\n");
exit(EXIT_FAILURE);
}
}
// init the mutex lock
if (pthread_mutex_init(&user_map_lock, NULL) != 0
|| pthread_mutex_init(&queue_map_lock, NULL) != 0
|| pthread_mutex_init(&sem_map_lock, NULL) != 0)
{
printf("\n mutex init failed\n");
return 1;
}
if (orbit)
{
if (src_GUID != -1 && dst_GUID != -1)
{
if (debug) printf("src_GUID: %d, dst_GUID: %d\n", src_GUID, dst_GUID);
/* init new Message Distributor */
MsgD.init(src_GUID, dst_GUID, debug);
}
else
{
printf("ERROR: please enter src_GUID and dst_GUID with flags -m & -o\n");
exit(1);
}
}
if (train)
{
// now train with the database
ImgMatch::init_DB(100,"/demo/img/","./indexImgTable","ImgIndex.yml");
return 0;
}
server_run();
return 0;
}
void *socket_server_run_thread(void* aux) {
server_run(SOCKET_SERVER_HOST, SOCKET_SERVER_PORT, &testserver, socket_server_run_callback);
return NULL;
}
int main(int argc, char **argv) {
int follower_port = 16201, leader_port = 16200;
char *follower_hostname = "127.0.0.1", *leader_hostname = "127.0.0.1";
int index = 0;
if (index < argc) {
switch (argc - index - 1) {
case 1:
index += 1;
if (argv[index][0] != '-') {
follower_port = atoi(argv[index]);
break;
} else {
goto usage;
}
case 2:
index += 1;
if (argv[index][0] != '-') {
follower_port = atoi(argv[index]);
} else {
goto usage;
}
if (argv[index + 1][0] != '-') {
leader_port = atoi(argv[index + 1]);
} else {
goto usage;
}
break;
}
}
printf("Follower server started on port %d\n", follower_port);
printf("Connecting to leader at %s:%d... \n", leader_hostname, leader_port);
tpcfollower_t follower;
server_t server;
server.leader = 0;
server.max_threads = 3;
char follower_name[20];
sprintf(follower_name, "follower-port%d", follower_port);
tpcfollower_init(&follower, follower_name, 2, follower_hostname, follower_port);
/* Need to send registration to the leader.*/
int ret, sockfd = connect_to(leader_hostname, leader_port, 0);
if (sockfd < 0) {
printf("Error registering follower! "
"Could not connect to leader on host %s at port %d\n",
leader_hostname, leader_port);
return 1;
}
ret = tpcfollower_register_leader(&follower, sockfd);
if (ret < 0) {
printf("Error registering follower with leader! "
"Received an error message back from leader.\n");
return 1;
}
close(sockfd);
server.tpcfollower = follower;
server_run(follower_hostname, follower_port, &server);
return 0;
usage:
printf("%s\n", USAGE);
return 1;
}
int main (int argc, char* const argv[])
{
struct in_addr local_address;
uint16_t port;
int next_option;
/* Store the program name, which we'll use in error messages.*/
program_name = argv[0];
/* Set defaults for options. Bind the server to all local addresses,
and assign an unused port automatically. */
local_address.s_addr = INADDR_ANY;
port = htons(8080);//default port 8080
/* Don't print verbose messages. */
verbose = 0;
/* Load modules from the directory containing this executable. */
module_dir = get_self_executable_directory ();
assert (module_dir != NULL);
/* Parse options. */
do {
next_option =
getopt_long (argc, argv, short_options, long_options, NULL);
switch (next_option) {
case 'a':
/* User specified -a or --address. */
{
struct hostent* local_host_name;
/* Look up the hostname the user specified. */
local_host_name = gethostbyname (optarg);
if (local_host_name == NULL || local_host_name->h_length == 0)
/* Could not resolve the name. */
error (optarg, "invalid host name");
else
/* Hostname is OK, so use it. */
local_address.s_addr =
*((int*) (local_host_name->h_addr_list[0]));
}
break;
case 'h':
/* User specified -h or --help.*/
print_usage (0);
break;
case 'm':
/* User specified -m or --module-dir.*/
{
struct stat dir_info;
/* Check that it exists. */
if (access (optarg, F_OK) != 0)
error (optarg, "module directory does not exist");
/* Check that it is accessible. */
if (access (optarg, R_OK | X_OK) != 0)
error (optarg, "module directory is not accessible");
/* Make sure that it is a directory. */
if (stat (optarg, &dir_info) != 0 || !S_ISDIR (dir_info.st_mode))
error (optarg, "not a directory");
/* It looks OK, so use it. */
module_dir = strdup (optarg);
}
break;
case 'p':
/* User specified -p or --port. */
{
long value;
char* end;
value = strtol (optarg, &end, 10);
if (*end != '\0')
/* The user specified nondigits in the port number. */
print_usage (1);
/* The port number needs to be converted to network (big endian)
byte order. */
port = (uint16_t) htons (value);
}
break;
case 'v':
/* User specified -v or --verbose.*/
verbose = 1;
break;
case '?':
/* User specified an unrecognized option.*/
print_usage (1);
case -1:
/* Done with options. */
break;
default:
abort ();
}
} while (next_option != -1);
/* This program takes no additional arguments.
user specified any. */
if (optind != argc)
print_usage (1);
/*Issue an error if the Print the module directory, if we're running verbose. */
if (verbose)
printf ("modules will be loaded from %s\n", module_dir);
/* Run the server. */
server_run (local_address, port);
return 0;
}
