int main(int argc, char const* argv[]) {
server_t* s;
sigset_t mask;
siginfo_t info;
struct sigaction action;
if(argc == 1) {
if(!server_create(&s, "../calories.csv", NULL)) {
if(!server_create(&s, "./calories.csv", NULL)) {
printf("File '%s' fot found\n", "calories.csv");
exit(1);
}
}
} else if(argc == 2) {
if(!server_create(&s, "../calories.csv", argv[1])) {
if(!server_create(&s, "./calories.csv", argv[1])) {
printf("File '%s' fot found\n", "calories.csv");
exit(1);
}
}
} else {
printf("%s\n", SERVER_MAIN_HELP);
exit(1);
}
printf("Press CTRL+C to shutdown the server\n");
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigprocmask(SIG_BLOCK, &mask, NULL);
sigemptyset(&action.sa_mask);
action.sa_flags = SA_SIGINFO;
sigaction(SIGCHLD, &action, NULL);
if(server_start(s)) {
while(true) {
// signal() is NOT thread safe!
// And since the server doesn't block signal handling is "not" needed ...
if(sigwaitinfo(&mask, &info) == -1) {
perror("sigwaitinfo() failed");
exit(1);
}
switch(info.si_signo) {
case SIGINT:
server_destroy(s);
return 0;
}
}
} else {
server_destroy(s);
}
}
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;
}
int main(int argc, char *argv[]){
bool parameters_valid = parameters_are_valid(argc, argv);
char client_mode[MODE_LENGTH+1] = CLIENT_MODE;
char server_mode[MODE_LENGTH+1] = SERVER_MODE;
bool mode_is_client = (strcmp(argv[POS_MODE], client_mode) == OK);
bool mode_is_server = (strcmp(argv[POS_MODE], server_mode) == OK);
if (mode_is_client && parameters_valid){
client_t client;
client_init(&client, argv[POS_HOSTNAME_C], argv[POS_PORT_C]);
client_send_fname(&client, argv[POS_SERVER_FILE_NAME], argv[POS_BLOCK_SIZE]);
client_send_chksms(&client, argv[POS_OLD_FILE_NAME], argv[POS_NEW_FILE_NAME]);
client_destroy(&client);
return SYSTEM_EXIT;
}else if (mode_is_server && parameters_valid){
server_t server;
server_init(&server, NULL, argv[POS_PORT_S]);
server_receive_file_name(&server);
server_save_chksms(&server);
server_compare_and_send_chksms(&server);
server_destroy(&server);
return SYSTEM_EXIT;
}
return PARAMETER_ERROR;
}
int main(int argc, const char *argv[])
{
if (argc != 3)
{
print_usage();
return 1;
}
setup_signal_handlers();
server *s = server_create((uint16_t)atoi(argv[1]), argv[2]);
server_listen(s);
printf("Listening...\n");
fflush(stdout);
while (running)
{
server_wait(s);
}
printf("Shutting down...\n");
fflush(stdout);
server_close(s);
server_destroy(s);
return 0;
}
void client_finalize()
{
ASSERT(max_ep > 0);
cqueue_finalize();
FREE_ALIGN(client_table);
server_destroy();
}
void server_game_end() {
int clientno;
for (clientno = 0; clientno < MAXCLIENTS; clientno++) {
if (CLIENT_USED(&clients[clientno]) && clients[clientno].kick_at_end_of_game)
server_destroy(&clients[clientno], "game ended");
}
}
void setRun( char *rel, char *val )
{
if( strcmp(rel,"=")!=0 ) { unknown_com(); return; }
if( strcmp(val,"EXIT")==0 ) {
strcpy( slot_Run, "EXIT" );
if( prop_Run == AutoOutput ) inqRun();
#ifdef WIN32
Sleep(3000);
#else
sleep(3);
#endif
if( s_mode ) {
server_destroy();
}
exit(0);
} else if( s_mode && strcmp(val,"CLOSE")==0 ) {
server_close_client();
} else if( strcmp(val,"LIVE")==0 ) {
strcpy( slot_Run, "LIVE" );
if( prop_Run == AutoOutput ) inqRun();
} else if( strcmp(val,"SLEEP")==0 ) {
sleep(5);
} else {
unknown_com();
}
}
static void server_readable(int fd, short event, void *arg) {
client_t *client = (client_t*)arg;
// Der Client wurde 'extern' gekickt, allerdings noch
// nicht entfernt. Dann wird dieser Readcallback aufgerufen,
// sollte allerdings nichts mehr machen.
if (client->kill_me)
return;
int ret = evbuffer_read(client->in_buf, fd, 128);
if (ret < 0) {
server_destroy(client, strerror(errno));
} else if (ret == 0) {
server_destroy(client, "eof reached");
} else if (EVBUFFER_LENGTH(client->in_buf) > 8192) {
server_destroy(client, "line too long. go away.");
} else {
char *line;
while ((line = evbuffer_readline(client->in_buf))) {
lua_pushliteral(L, "on_client_input");
lua_rawget(L, LUA_GLOBALSINDEX);
lua_pushnumber(L, client_num(client));
lua_pushstring(L, line);
free(line);
// Cycles fuer die Verarbeitung hochsetzen
lua_set_cycles(L, 0xFFFFFF);
// Input verarbeiten
output_client = client;
if (lua_pcall(L, 2, 0, 0) != 0) {
fprintf(stderr, "error calling on_client_input: %s\n", lua_tostring(L, -1));
server_writeto(client, lua_tostring(L, -1), lua_strlen(L, -1));
lua_pop(L, 1);
}
output_client = NULL;
// Kill Me Flag waehrend Aufruf von on_client_input
// gesetzt? Direkt rausschmeissen!
if (client->kill_me) {
server_destroy(client, client->kill_me);
return;
}
}
}
}
void nth_site_destroy(nth_site_t *site)
{
if (site == NULL)
return;
if (site->site_auth)
auth_mod_unref(site->site_auth), site->site_auth = NULL;
if (site->site_server->srv_sites == site) {
server_destroy(site->site_server);
}
}
int
main(int argc, char *argv[]) {
server_type_t server_type;
int port;
read_args(argc, argv, &port, &server_type);
server_t *server = server_new(server_type, port);
server_set_accept_callback(server, on_client_accepted);
server_set_data_callback(server, on_incoming_data);
server_set_close_callback(server, on_client_closed);
server_loop(server);
server_destroy(server);
return 0;
}
void server_shutdown() {
int clientno;
for (clientno = 0; clientno < MAXCLIENTS; clientno++) {
if (CLIENT_USED(&clients[clientno]))
server_destroy(&clients[clientno], "server shutdown");
}
listener_shutdown();
#ifdef WIN32
WSACleanup();
#endif
}
void *
start_server_thread_func (void *ptr)
{
client_thread = false;
client_t *client = (client_t *)ptr;
server_t *server = server_new (&client->buffer);
server->server_signal = &client->server_signal;
server->client_signal = &client->client_signal;
mutex_unlock (client->server_started_mutex);
prctl (PR_SET_TIMERSLACK, 1);
pthread_t id = pthread_self ();
int online_cpus = sysconf (_SC_NPROCESSORS_ONLN);
int available_cpus = sysconf (_SC_NPROCESSORS_CONF);
if (online_cpus > 1) {
cpu_set_t cpu_set;
CPU_ZERO (&cpu_set);
if (pthread_getaffinity_np (id, sizeof (cpu_set_t), &cpu_set) == 0) {
/* find first cpu to run on */
int cpu = 0;
int i;
for (i = 1; i < available_cpus; i++) {
if (CPU_ISSET (i, &cpu_set)) {
cpu = i;
break;
}
}
/* force server to run on cpu1 */
if (cpu == 0)
cpu = 1;
if (cpu != 0) {
for (i = 0; i < available_cpus; i++) {
if (i != cpu)
CPU_CLR (i, &cpu_set);
}
CPU_SET (cpu, &cpu_set);
pthread_setaffinity_np (id, sizeof (cpu_set_t), &cpu_set);
}
}
}
server_start_work_loop (server);
server_destroy(server);
return NULL;
}
static void server_writable(int fd, short event, void *arg) {
client_t *client = (client_t*)arg;
#ifndef NO_CONSOLE_CLIENT
// HACK um die Ausgabe des Consolenclients an
// stdout statt stdin zu schicken.
if (fd == STDIN_FILENO) fd = STDOUT_FILENO;
#endif
// Kompressionsrest flushen
server_flush_compression(client);
// Schreiben
int ret = evbuffer_write(client->out_buf, fd);
if (ret < 0) {
server_destroy(client, strerror(errno));
} else if (ret == 0) {
server_destroy(client, "null write?");
} else {
if (EVBUFFER_LENGTH(client->out_buf) > 0)
event_add(&client->wr_event, NULL);
}
}
int main(int argc, char** argv)
{
uv_loop_t* loop;
loop = uv_default_loop();
server_initialize(loop, &_server);
server_start(&_server);
fprintf(stderr, "socket-server starts...\n");
uv_run(loop);
server_destroy(&_server);
return 0;
}
int main(int argc, char** argv)
{
server_t* server = server_create("config.xml");
if(server == NULL) return 0;
char buf[512] = {0};
for(;;)
{
//sleep(1);
fgets(buf, 512, stdin);
if(strncmp(buf, "quit", strlen("quit")) == 0) break;
}
server_destroy(server);
return 0;
}
static void
client_destroy (client_t **self_p)
{
assert (self_p);
if (*self_p) {
client_t *self = *self_p;
fmq_config_destroy (&self->config);
int server_nbr;
for (server_nbr = 0; server_nbr < self->nbr_servers; server_nbr++) {
server_t *server = self->servers [server_nbr];
server_destroy (&server);
}
// Destroy subscriptions
while (zlist_size (self->subs)) {
sub_t *sub = (sub_t *) zlist_pop (self->subs);
sub_destroy (&sub);
}
zlist_destroy (&self->subs);
free (self);
*self_p = NULL;
}
}
// Finally here's the server thread itself, which polls its two
// sockets and processes incoming messages
static void
server_thread (void *args, zctx_t *ctx, void *pipe)
{
server_t *self = server_new (ctx, pipe);
zmq_pollitem_t items [] = {
{ self->pipe, 0, ZMQ_POLLIN, 0 },
{ self->router, 0, ZMQ_POLLIN, 0 }
};
self->monitor_at = zclock_time () + self->monitor;
while (!self->stopped && !zctx_interrupted) {
// Calculate tickless timer, up to interval seconds
uint64_t tickless = zclock_time () + self->monitor;
zhash_foreach (self->clients, client_tickless, &tickless);
// Poll until at most next timer event
int rc = zmq_poll (items, 2,
(tickless - zclock_time ()) * ZMQ_POLL_MSEC);
if (rc == -1)
break; // Context has been shut down
// Process incoming message from either socket
if (items [0].revents & ZMQ_POLLIN)
server_control_message (self);
if (items [1].revents & ZMQ_POLLIN)
server_client_message (self);
// Send heartbeats to idle clients as needed
zhash_foreach (self->clients, client_ping, self);
// If clock went past timeout, then monitor server
if (zclock_time () >= self->monitor_at) {
monitor_the_server (self, NULL);
self->monitor_at = zclock_time () + self->monitor;
}
}
server_destroy (&self);
}
/**
* main function
**/
int main(int argc, char ** argv)
{
int ret;
int serviceid = 80;
g_server = server_new();
atexit(stop);
signal(SIGINT, terminate);
ServicesFactory *factory = servicesfactory_new();
servicesfactory_add(factory, serviceid, NULL, serviceinet_new);
Connector *connector = connector_new(factory, serviceid);
connector_readparameters(connector, argv, argc);
server_addconnector(g_server, connector);
ret = server_main(g_server);
server_destroy(g_server);
servicesfactory_destroy(factory);
return ret;
}
void server_tick() {
lua_set_cycles(L, 0xFFFFFF);
lua_pushliteral(L, "server_tick");
lua_rawget(L, LUA_GLOBALSINDEX);
if (lua_pcall(L, 0, 0, 0) != 0) {
fprintf(stderr, "error calling server_tick: %s\n", lua_tostring(L, -1));
lua_pop(L, 1);
}
event_loop(EVLOOP_NONBLOCK);
// Ungefaehr jede Sekunde alle zu kickenden Clients entfernen.
static int kicktick = 0;
if (++kicktick % 10 == 0) {
int clientno;
for (clientno = 0; clientno < MAXCLIENTS; clientno++) {
if (!CLIENT_USED(&clients[clientno]))
continue;
if (clients[clientno].kill_me)
server_destroy(&clients[clientno], clients[clientno].kill_me);
}
}
}
void run(void)
{
server_t *server;
char line[4096];
int n_wait = 0;
server = server_create(m_port);
while (m_semaphore.wait(n_wait) != 0) {
if (server_readline(server, line, sizeof(line)) == 0) {
int len;
len = strcspn(line, "\n\r");
if (len == 0)
continue;
line[len] = 0;
addImage(m_gui, line, false);
n_wait = 0;
} else {
n_wait = 10;
}
}
server_destroy(server);
}
server_t *server_create(url_t const *url,
tag_type_t tag, tag_value_t value, ...)
{
server_t *srv;
msg_mclass_t const *mclass = NULL;
tp_name_t tpn[1] = {{ NULL }};
su_root_t *root = NULL;
http_server_t const *server = NULL;
int persistent = 0;
char const *server_str = SERVER_VERSION;
ta_list ta;
ta_start(ta, tag, value);
tl_gets(ta_args(ta),
NTHTAG_ROOT_REF(root),
NTHTAG_MCLASS_REF(mclass),
TPTAG_REUSE_REF(persistent),
HTTPTAG_SERVER_REF(server),
HTTPTAG_SERVER_STR_REF(server_str),
TAG_END());
if (!root || !url ||
(url->url_type != url_http && url->url_type != url_https)
|| !(srv = su_home_new(sizeof(*srv)))) {
ta_end(ta);
return NULL;
}
tpn->tpn_proto = url_tport_default((enum url_type_e)url->url_type);
tpn->tpn_canon = url->url_host;
tpn->tpn_host = url->url_host;
tpn->tpn_port = url_port(url);
srv->srv_tports = tport_tcreate(srv, nth_server_class, root,
TPTAG_IDLE(600000),
TPTAG_TIMEOUT(300000),
ta_tags(ta));
srv->srv_persistent = persistent;
srv->srv_max_bodylen = 1 << 30; /* 1 GB */
if (tport_tbind(srv->srv_tports, tpn, http_tports,
TAG_END()) >= 0 ||
tport_tbind(srv->srv_tports, tpn, http_no_tls_tports,
TAG_END()) >= 0) {
srv->srv_root = root;
srv->srv_mclass = mclass ? mclass : http_default_mclass();
srv->srv_mflags = MSG_DO_CANONIC;
if (server)
srv->srv_server = http_server_dup(srv->srv_home, server);
else
srv->srv_server = http_server_make(srv->srv_home, server_str);
tport_get_params(srv->srv_tports,
TPTAG_QUEUESIZE_REF(srv->srv_queuesize),
TAG_END());
}
else {
SU_DEBUG_1(("nth_server_create: cannot bind transports "
URL_FORMAT_STRING "\n",
URL_PRINT_ARGS(url)));
server_destroy(srv), srv = NULL;
}
ta_end(ta);
return srv;
}
int main(int argc, char *argv[])
{
int opt;
bdaddr_t src_addr;
int dev_id = -1;
int fd;
int sec = BT_SECURITY_LOW;
uint8_t src_type = BDADDR_LE_PUBLIC;
uint16_t mtu = 0;
sigset_t mask;
bool hr_visible = false;
struct server *server;
while ((opt = getopt_long(argc, argv, "+hvrs:t:m:i:",
main_options, NULL)) != -1) {
switch (opt) {
case 'h':
usage();
return EXIT_SUCCESS;
case 'v':
verbose = true;
break;
case 'r':
hr_visible = true;
break;
case 's':
if (strcmp(optarg, "low") == 0)
sec = BT_SECURITY_LOW;
else if (strcmp(optarg, "medium") == 0)
sec = BT_SECURITY_MEDIUM;
else if (strcmp(optarg, "high") == 0)
sec = BT_SECURITY_HIGH;
else {
fprintf(stderr, "Invalid security level\n");
return EXIT_FAILURE;
}
break;
case 't':
if (strcmp(optarg, "random") == 0)
src_type = BDADDR_LE_RANDOM;
else if (strcmp(optarg, "public") == 0)
src_type = BDADDR_LE_PUBLIC;
else {
fprintf(stderr,
"Allowed types: random, public\n");
return EXIT_FAILURE;
}
break;
case 'm': {
int arg;
arg = atoi(optarg);
if (arg <= 0) {
fprintf(stderr, "Invalid MTU: %d\n", arg);
return EXIT_FAILURE;
}
if (arg > UINT16_MAX) {
fprintf(stderr, "MTU too large: %d\n", arg);
return EXIT_FAILURE;
}
mtu = (uint16_t) arg;
break;
}
case 'i':
dev_id = hci_devid(optarg);
if (dev_id < 0) {
perror("Invalid adapter");
return EXIT_FAILURE;
}
break;
default:
fprintf(stderr, "Invalid option: %c\n", opt);
return EXIT_FAILURE;
}
}
argc -= optind;
argv -= optind;
optind = 0;
if (argc) {
usage();
return EXIT_SUCCESS;
}
if (dev_id == -1)
bacpy(&src_addr, BDADDR_ANY);
else if (hci_devba(dev_id, &src_addr) < 0) {
perror("Adapter not available");
return EXIT_FAILURE;
}
fd = l2cap_le_att_listen_and_accept(&src_addr, sec, src_type);
if (fd < 0) {
fprintf(stderr, "Failed to accept L2CAP ATT connection\n");
return EXIT_FAILURE;
}
mainloop_init();
server = server_create(fd, mtu, hr_visible);
if (!server) {
close(fd);
return EXIT_FAILURE;
}
if (mainloop_add_fd(fileno(stdin),
EPOLLIN | EPOLLRDHUP | EPOLLHUP | EPOLLERR,
prompt_read_cb, server, NULL) < 0) {
fprintf(stderr, "Failed to initialize console\n");
server_destroy(server);
return EXIT_FAILURE;
}
printf("Running GATT server\n");
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_cb, NULL, NULL);
print_prompt();
mainloop_run();
printf("\n\nShutting down...\n");
server_destroy(server);
return EXIT_SUCCESS;
}
/**
* @TEST Params (Testing purpose only)
* @ server 3590
* @ client 127.0.0.1 3590 /home/santiago/workspace/tp1_new/Debug/ejemplo1 /home/santiago/workspace/tp1_new/Debug/outputFile /home/santiago/workspace/tp1_new/Debug/ejemplo2 4
* TODO Document the new and changed stuff
*/
int main(int argc, char *argv[]) {
//Initialize our app state
APP_STATE state = APP_STATE_UNDEFINED;
/**
* If we have at least the type parameter (this means client/server)
* then we should at least be able to operate and let the app flow handle
* the result.
* Which is pretty obvious it will fail since theres nothing to pull
* from the server.
* @Refactor maybe ?
*/
if (argc > 1) {
//Initialize a socket we will be using
socket_t mSocket;
socket_init(&mSocket);
//If client
if (!strcmp(argv[1], HOST_CLIENT)) {
client_t mClient;
client_init(&mClient, &mSocket, argv[4], argv[5], argv[6]);
int chunkSize = atoi(argv[7]);
/**
* This is the core of the client.
* Here it will connect the socket with the given params,
* Send the server the specifications of the pull,
* Parse its src file in checksums, send the list and
* listen for the remote changes, while writing them to the
* ouput file.
*/
client_start(&mClient, argv[2], argv[3], &chunkSize, &state);
client_destroy(&mClient);
}
//If server
/**
* @note: I have done them like this (and not in if/else)
* since its not specified how the app should react to
* a random param name (eg ./app random). In this case, it just closes
* and nothing happens
*/
if (!strcmp(argv[1], HOST_SERVER)) {
server_t mServer;
server_init(&mServer, &mSocket);
/**
* This is the core of the server.
* Here it will bind and listen to the supplied port,
* Receive the specifications of the pull and the checksum list
* Iterate through its own updated file while looking for differences
* sending them to the client, so contents are identical
*/
server_start(&mServer, argv[2], &state);
server_destroy(&mServer);
}
//Close the file descriptor
socket_close(&mSocket);
} else {
//Notify about usage if no args passed
printf("Fail to receive arguments\n");
printf("For client use: \"client\" @host @port");
printf("@src @dst @remote @chunkSize\n");
printf("For server use: \"server\" @port");
state = APP_STATE_ERROR;
}
return state;
}
int main( int argc, char **argv )
{
int n, i;
char *com;
fp_err = stderr;
init_conf();
com = argv[0];
--argc; ++argv;
while( argc > 0 && argv[0][0] == '-' ) {
switch( argv[0][1] ) {
case 'C':
if( argc < 2 ) usage( com );
read_conf( argv[1] );
--argc; ++argv;
break;
/*******↓for server mode *******/
case 'p':
/* 引数が不正な場合はエラー出力 */
if( argc < 2 ) usage( com );
/* ポート番号の読み込み */
i = atoi( argv[1] );
if (i > 1024) {
nPort = i;
}
s_mode = 1;
--argc; ++argv;
break;
/*******↑***********************/
case 'v':
printf( "%s\n", moduleVersion );
printf( "%s\n", protocolVersion );
exit(0);
default:
usage( com );
}
--argc; ++argv;
}
set_default_conf();
initialize();
n = setjmp( ebuf );
if( n > 0 ) chasen_process = 0; /* to restart 'chasen' process */
for( ;; ) {
#ifdef PRINTDATA
TmpMsg( "> " );
#endif
n_arg = read_command( v_arg );
#ifdef PRINTDATA
{
int i;
TmpMsg( "command is \n" );
for( i=0; i<n_arg; ++i ) {
TmpMsg( " %d: %s\n", i+1, v_arg[i] );
}
}
#endif
/* 「o」 で set Speak = NOW のショートカット */
if( strcmp(v_arg[0],"o")==0 ) {
setSpeak( "=", "NOW" );
continue;
}
if( n_arg < 2 ) { unknown_com(); continue; }
switch( commandID( v_arg[0] ) ) {
case C_set:
if( n_arg < 4 ) { unknown_com(); break; }
switch( slotID( v_arg[1] ) ) {
case S_Run: setRun( v_arg[2], v_arg[3] ); break;
case S_Speaker: setSpeaker( v_arg[2], v_arg[3] ); break;
case S_Alpha: setAlpha( v_arg[2], v_arg[3] ); break;
case S_Postfilter_coef: setPostfilter_coef( v_arg[2], v_arg[3] ); break;
case S_Text: setText( v_arg[2], v_arg[3] ); break;
case S_Speak: setSpeak( v_arg[2], v_arg[3] ); break;
case S_SaveRAW: setSave( v_arg[2], v_arg[3] ); break;
case S_Save: setSave( v_arg[2], v_arg[3] ); break;
case S_LoadRAW: setSpeechFile( v_arg[2], v_arg[3], RAW ); break;
case S_SpeechFile: setSpeechFile( v_arg[2], v_arg[3], RAW ); break;
case S_SaveWAV: setSaveWAV( v_arg[2], v_arg[3] ); break;
case S_LoadWAV: setSpeechFile( v_arg[2], v_arg[3], WAV ); break;
case S_SavePros: setSavePros( v_arg[2], v_arg[3] ); break;
case S_LoadPros: setProsFile( v_arg[2], v_arg[3] ); break;
case S_ProsFile: setProsFile( v_arg[2], v_arg[3] ); break;
case S_ParsedText: setParsedText( v_arg[2], v_arg[3] ); break;
case S_Speak_syncinterval: setSpeakSyncinterval( v_arg[2], v_arg[3] ); break;
case S_AutoPlay:
slot_Auto_play = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_AutoPlayDelay:
slot_Auto_play_delay = atoi( v_arg[3] ); break;
case S_Log: setLog( v_arg[2], v_arg[3] ); break;
case S_Log_conf:
slot_Log_conf = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Log_text:
slot_Log_text = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Log_arranged_text:
slot_Log_arranged_text = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Log_chasen:
slot_Log_chasen = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Log_tag:
slot_Log_tag = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Log_phoneme:
slot_Log_phoneme = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Log_mora:
slot_Log_mora = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Log_morph:
slot_Log_morph = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Log_aphrase:
slot_Log_aphrase = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Log_breath:
slot_Log_breath = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Log_sentence:
slot_Log_sentence = setLogYesNo( v_arg[2], v_arg[3] ); break;
case S_Err: setErr( v_arg[2], v_arg[3] ); break;
default:
unknown_com();
}
break;
case C_inq:
switch( slotID( v_arg[1] ) ) {
case S_Run: inqRun(); break;
case S_ModuleVersion: inqModuleVersion(); break;
case S_ProtocolVersion: inqProtocolVersion(); break;
case S_SpeakerSet: inqSpeakerSet(); break;
case S_Speaker: inqSpeaker(); break;
case S_SpeechFile: inqSpeechFile(); break;
case S_ProsFile: inqProsFile(); break;
case S_AutoPlay: inqAutoPlay(); break;
case S_AutoPlayDelay: inqAutoPlayDelay(); break;
case S_Text_text: inqTextText(); break;
case S_Text_pho: inqTextPho(); break;
case S_Text_dur: inqTextDur(); break;
case S_Speak_text: inqSpeakText(); break;
case S_Speak_pho: inqSpeakPho(); break;
case S_Speak_dur: inqSpeakDur(); break;
case S_Speak_utt: inqSpeakUtt(); break;
case S_Speak_len: inqSpeakLen(); break;
case S_Speak_stat: inqSpeakStat(); break;
case S_Speak_syncinterval: inqSpeakSyncinterval(); break;
case S_Log:
RepMsg( "rep Log = %s\n", slot_Log_file ); break;
case S_Log_conf:
RepMsg( "rep Log.conf = %s\n", YesNoSlot(S_Log_conf) ); break;
case S_Log_text:
RepMsg( "rep Log.text = %s\n", YesNoSlot(S_Log_text) ); break;
case S_Log_arranged_text:
RepMsg( "rep Log.arranged_text = %s\n", YesNoSlot(S_Log_arranged_text) ); break;
case S_Log_chasen:
RepMsg( "rep Log.chasen = %s\n", YesNoSlot(S_Log_chasen) ); break;
case S_Log_tag:
RepMsg( "rep Log.tag = %s\n", YesNoSlot(S_Log_tag) ); break;
case S_Log_phoneme:
RepMsg( "rep Log.phoneme = %s\n", YesNoSlot(S_Log_phoneme) ); break;
case S_Log_mora:
RepMsg( "rep Log.mora = %s\n", YesNoSlot(S_Log_mora) ); break;
case S_Log_morph:
RepMsg( "rep Log.morph = %s\n", YesNoSlot(S_Log_morph) ); break;
case S_Log_aphrase:
RepMsg( "rep Log.aphrase = %s\n", YesNoSlot(S_Log_aphrase) ); break;
case S_Log_breath:
RepMsg( "rep Log.breath = %s\n", YesNoSlot(S_Log_breath) ); break;
case S_Log_sentence:
RepMsg( "rep Log.sentence = %s\n", YesNoSlot(S_Log_sentence) ); break;
case S_Err:
RepMsg( "rep Err = %s\n", slot_Err_file ); break;
default:
unknown_com();
}
break;
case C_prop:
{ SlotProp prop;
if( strcmp(v_arg[2],"=")!=0 ) { unknown_com(); break; }
if( strcmp(v_arg[3],"AutoOutput")==0 ) {
prop = AutoOutput;
} else if(strcmp(v_arg[3],"NoAutoOutput")==0 ) {
prop = NoAutoOutput;
} else {
unknown_com(); break;
}
switch( slotID( v_arg[1] ) ) {
case S_Run: prop_Run = prop; break;
case S_ModuleVersion: prop_ModuleVersion = prop; break;
case S_ProtocolVersion: prop_ProtocolVersion = prop; break;
case S_SpeakerSet: prop_SpeakerSet = prop; break;
case S_Speaker: prop_Speaker = prop; break;
case S_SpeechFile: prop_SpeechFile = prop; break;
case S_ProsFile: prop_ProsFile = prop; break;
case S_Text: prop_Text = prop; break;
case S_Text_text: prop_Text_text = prop; break;
case S_Text_pho: prop_Text_pho = prop; break;
case S_Text_dur: prop_Text_dur = prop; break;
case S_Speak: prop_Speak = prop; break;
case S_Speak_text: prop_Speak_text = prop; break;
case S_Speak_pho: prop_Speak_pho = prop; break;
case S_Speak_dur: prop_Speak_dur = prop; break;
case S_Speak_utt: prop_Speak_utt = prop; break;
case S_Speak_len: prop_Speak_len = prop; break;
case S_Speak_stat: prop_Speak_stat = prop; break;
case S_Speak_syncinterval: prop_Speak_syncinterval = prop; break;
default:
unknown_com();
}
}
break;
default:
unknown_com();
}
}
if( s_mode ) {
server_destroy ();
}
exit(0);
}
static void
s_server_free (void *argument)
{
server_t *server = (server_t *) argument;
server_destroy (&server);
}
SERVER *
server_init(int fd,
const struct sockaddr_gen *sg,
int backlog,
int max_clients,
void (*handler)(CLIENT *cp))
{
static int one = 1;
socklen_t slen;
SERVER *sp;
if (debug)
fprintf(stderr, "server_init(%d, ..., %d, %d, ...): Start\n",
fd, backlog, max_clients);
A_NEW(sp);
sp->fd = -1;
sp->state = 0;
pthread_attr_init(&sp->ca_detached);
pthread_attr_setdetachstate(&sp->ca_detached,
PTHREAD_CREATE_DETACHED);
pthread_mutex_init(&sp->clients_mtx, NULL);
pthread_cond_init(&sp->clients_cv, NULL);
sp->clients_cur = 0;
sp->clients_max = max_clients;
if (fd < 0)
{
if (sg == NULL)
{
syslog(LOG_ERR,
"server_init: NULL address and no file descriptor");
server_destroy(sp);
if (debug)
fprintf(stderr, "server_init(): End: Failure\n");
return NULL;
}
sp->sin = *sg;
sp->fd = socket(SGFAM(sp->sin), SOCK_STREAM, 0);
#ifdef HAVE_IPV6
if (sp->fd < 0 &&
(errno == EAFNOSUPPORT || errno == EPFNOSUPPORT) &&
SGFAM(sp->sin) == AF_INET6)
{
#if 0
/* Try to convert to IPv4 format... */
struct in6_addr *addr6 = (struct in6_addr *) SGADDRP(sp->sin);
if (IN6_IS_ADDR_V4MAPPED(addr6))
{
UINT32 addr4 = addr6->s6_addr32[3];
SGFAM(sp->sin) = AF_INET;
* (UINT32 *) SGADDRP(sp->sin) = addr4;
}
#endif
/* Let's try with an IPv4 socket - who knows, it might work */
errno = 0;
sp->fd = socket(PF_INET, SOCK_STREAM, 0);
}
#endif
if (sp->fd < 0)
{
syslog(LOG_ERR, "socket(%s, SOCK_STREAM) failed (errno=%d): %m",
(SGFAM(sp->sin) == AF_INET ? "AF_INET" : "AF_INET6"),
errno);
server_destroy(sp);
if (debug)
fprintf(stderr, "server_init(): End: Failure\n");
return NULL;
}
(void) setsockopt(sp->fd, SOL_SOCKET, SO_REUSEADDR,
(void *) &one, sizeof(one));
if (s_bind(sp->fd, (struct sockaddr *) &sp->sin,
SGSOCKSIZE(sp->sin)) < 0)
{
char buf1[16];
syslog(LOG_ERR, "bind(%d,%s:%d) failed: %m",
sp->fd,
s_inet_ntox(&sp->sin, buf1, sizeof(buf1)),
ntohs(SGPORT(sp->sin)));
server_destroy(sp);
if (debug)
fprintf(stderr, "server_init(): End: Failure\n");
return NULL;
}
}
else
{
sp->fd = fd;
slen = sizeof(sp->sin);
getsockname(sp->fd, (struct sockaddr *) &sp->sin, &slen);
}
/* We do this outside the 'if' clause to support broken
Inetd implementations */
if (backlog >= 0 && listen(sp->fd, backlog) < 0)
{
syslog(LOG_ERR, "listen(%d, %d) failed: %m", sp->fd, backlog);
server_destroy(sp);
if (debug)
fprintf(stderr, "server_init(): End: Failure\n");
return NULL;
}
sp->handler = handler;
if (debug)
fprintf(stderr, "server_init(): End: OK\n");
return sp;
}
