static int mod_host_init(jack_client_t* client, int socket_port)
{
#ifdef HAVE_FFTW335
/* Make fftw thread-safe */
fftw_make_planner_thread_safe();
fftwf_make_planner_thread_safe();
#endif
/* Setup the protocol */
protocol_add_command(EFFECT_ADD, effects_add_cb);
protocol_add_command(EFFECT_REMOVE, effects_remove_cb);
protocol_add_command(EFFECT_PRESET_LOAD, effects_preset_load_cb);
protocol_add_command(EFFECT_PRESET_SAVE, effects_preset_save_cb);
protocol_add_command(EFFECT_PRESET_SHOW, effects_preset_show_cb);
protocol_add_command(EFFECT_CONNECT, effects_connect_cb);
protocol_add_command(EFFECT_DISCONNECT, effects_disconnect_cb);
protocol_add_command(EFFECT_BYPASS, effects_bypass_cb);
protocol_add_command(EFFECT_PARAM_SET, effects_set_param_cb);
protocol_add_command(EFFECT_PARAM_GET, effects_get_param_cb);
protocol_add_command(EFFECT_PARAM_MON, effects_monitor_param_cb);
protocol_add_command(MONITOR_ADDR_SET, monitor_addr_set_cb);
protocol_add_command(MIDI_LEARN, midi_learn_cb);
protocol_add_command(MIDI_MAP, midi_map_cb);
protocol_add_command(MIDI_UNMAP, midi_unmap_cb);
protocol_add_command(CPU_LOAD, cpu_load_cb);
protocol_add_command(LOAD_COMMANDS, load_cb);
protocol_add_command(SAVE_COMMANDS, save_cb);
protocol_add_command(BUNDLE_ADD, bundle_add);
protocol_add_command(BUNDLE_REMOVE, bundle_remove);
/* skip help and quit for internal client */
if (client == NULL)
{
protocol_add_command(HELP, help_cb);
protocol_add_command(QUIT, quit_cb);
}
/* Startup the effects */
if (effects_init(client))
return -1;
/* Setup the socket */
if (socket_start(socket_port, SOCKET_MSG_BUFFER_SIZE) < 0)
return -1;
socket_set_receive_cb(protocol_parse);
return 0;
}
static void ofp_socket_loop()
{
printf("using file %s\n", ip_conf_filename);
ofp_phish_desc_hash_table_locked_t descsLocked = ofp_phish_desc_ht_lock(config_desc_hash);
int result = config_ip_desc_add_file(descsLocked, ip_conf_filename);
OVH_ASSERT(1 == result);
ofp_phish_desc_ht_unlock(descsLocked);
socket_start(ofp_socket_test_message_cb, ofp_socket_test_error_cb);
printf("Waiting for incoming connections...\n");
while(!prgm_exit_requested)
{
}
descsLocked = ofp_phish_desc_ht_lock(config_desc_hash);
ofp_phish_desc_ht_free_elements(descsLocked);
ofp_phish_desc_ht_unlock(descsLocked);
socket_stop();
}
int main(int argc, char **argv) {
/* Run main garbage collector when quiting the daemon */
gc_attach(main_gc);
/* Catch all exit signals for gc */
gc_catch();
loglevel = LOG_INFO;
log_file_disable();
log_shell_enable();
char *logfile = malloc(strlen(LOG_FILE)+1);
strcpy(logfile, LOG_FILE);
log_file_set(logfile);
sfree((void *)&logfile);
prevMessage = malloc(4);
memset(prevMessage, '\0', 4);
progname = malloc(14);
strcpy(progname, "splash-daemon");
struct socket_callback_t socket_callback;
struct options_t *options = NULL;
char *args = NULL;
char buffer[BUFFER_SIZE];
int f;
options_add(&options, 'H', "help", no_value, 0, NULL);
options_add(&options, 'V', "version", no_value, 0, NULL);
options_add(&options, 'D', "nodaemon", no_value, 0, NULL);
while (1) {
int c;
c = options_parse(&options, argc, argv, 1, &args);
if (c == -1)
break;
switch(c) {
case 'H':
printf("Usage: %s [options]\n", progname);
printf("\t -H --help\t\tdisplay usage summary\n");
printf("\t -V --version\t\tdisplay version\n");
printf("\t -S --settings\t\tsettings file\n");
printf("\t -D --nodaemon\t\tdo not daemonize and\n");
printf("\t\t\t\tshow debug information\n");
return (EXIT_SUCCESS);
break;
case 'V':
printf("%s %s\n", progname, "1.0");
return (EXIT_SUCCESS);
break;
case 'D':
nodaemon=1;
break;
default:
printf("Usage: %s [options]\n", progname);
return (EXIT_FAILURE);
break;
}
}
options_delete(options);
pid_file = malloc(sizeof(PID_FILE)+1);
strcpy(pid_file, PID_FILE);
template_file = malloc(14);
strcpy(template_file, "template.json");
if((f = open(pid_file, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)) != -1) {
if(read(f, buffer, BUFFER_SIZE) != -1) {
//If the file is empty, create a new process
if(!atoi(buffer)) {
running = 0;
} else {
//Check if the process is running
kill(atoi(buffer), 0);
//If not, create a new process
if(errno == ESRCH) {
running = 0;
}
}
}
} else {
logprintf(LOG_ERR, "could not open / create pid_file %s", pid_file);
return EXIT_FAILURE;
}
close(f);
if(nodaemon == 1 || running == 1) {
log_level_set(LOG_DEBUG);
}
if(running == 1) {
nodaemon=1;
logprintf(LOG_NOTICE, "already active (pid %d)", atoi(buffer));
return EXIT_FAILURE;
}
if(nodaemon == 0) {
deamonize();
socket_start(PORT);
fb_init();
} else {
socket_start(PORT);
}
if(template_read(template_file) == EXIT_FAILURE) {
logprintf(LOG_NOTICE, "failed to read template file %s", template_file);
main_gc();
return EXIT_FAILURE;
}
if(nodaemon == 1) {
//template_print();
}
//initialise all socket_clients and handshakes to 0 so not checked
memset(socket_clients, 0, sizeof(socket_clients));
socket_callback.client_disconnected_callback = NULL;
socket_callback.client_connected_callback = NULL;
socket_callback.client_data_callback = &socket_parse_data;
main_draw();
/* Make sure the server part is non-blocking by creating a new thread */
pthread_create(&pth, NULL, &update_progress, (void *)NULL);
socket_wait((void *)&socket_callback);
while(main_loop) {
sleep(1);
}
return EXIT_FAILURE;
}
int main(int argc, char **argv)
{
int verbose, socket_port, interactive;
/* Command line options */
struct arg_lit *_verbose = arg_lit0("v", "verbose,debug", "verbose messages");
struct arg_int *_socket = arg_int0("p", "socket-port", "<port>", "socket port definition");
struct arg_lit *_interactive = arg_lit0("i", "interactive", "interactive mode");
struct arg_lit *_help = arg_lit0("h", "help", "print this help and exit");
struct arg_end *_end = arg_end(20);
void *argtable[] = {_verbose, _socket, _interactive, _help, _end};
if (arg_nullcheck(argtable))
{
fprintf(stderr, "argtable error: insufficient memory\n");
exit(EXIT_FAILURE);
}
/* Default value of command line arguments */
_socket->ival[0] = SOCKET_DEFAULT_PORT;
/* Run the argument parser */
if (arg_parse(argc, argv, argtable) == 0)
{
if (_help->count > 0)
{
fprintf(stdout, "Usage: %s", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_glossary(stdout, argtable, " %-30s %s\n");
exit(EXIT_SUCCESS);
}
verbose = _verbose->count;
socket_port = _socket->ival[0];
interactive = _interactive->count;
}
else
{
arg_print_errors(stderr, _end, argv[0]);
exit(EXIT_FAILURE);
}
arg_freetable(argtable, sizeof(argtable)/sizeof(argtable[0]));
/* If verbose or interactive, don't fork */
if (!verbose && !interactive)
{
int pid;
pid = fork();
if (pid != 0)
{
printf("Forking... child PID: %d\n", pid);
FILE *fd;
fd = fopen(PID_FILE, "w");
if (fd == NULL)
{
fprintf(stderr, "can't open PID File\n");
}
else
{
fprintf(fd, "%d\n", pid);
fclose(fd);
}
exit(EXIT_SUCCESS);
}
}
/* Setup the protocol */
protocol_add_command(EFFECT_ADD, effects_add_cb);
protocol_add_command(EFFECT_REMOVE, effects_remove_cb);
protocol_add_command(EFFECT_CONNECT, effects_connect_cb);
protocol_add_command(EFFECT_DISCONNECT, effects_disconnect_cb);
protocol_add_command(EFFECT_BYPASS, effects_bypass_cb);
protocol_add_command(EFFECT_PARAM_SET, effects_set_param_cb);
protocol_add_command(EFFECT_PARAM_GET, effects_get_param_cb);
protocol_add_command(EFFECT_PARAM_MON, effects_monitor_param_cb);
protocol_add_command(MONITOR_ADDR_SET, monitor_addr_set_cb);
protocol_add_command(LOAD_COMMANDS, load_cb);
protocol_add_command(SAVE_COMMANDS, save_cb);
protocol_add_command(HELP, help_cb);
protocol_add_command(QUIT, quit_cb);
/* Startup the effects */
if (effects_init()) return -1;
/* Setup the socket */
if (socket_start(socket_port, SOCKET_MSG_BUFFER_SIZE) < 0) {
exit(EXIT_FAILURE);
}
socket_set_receive_cb(protocol_parse);
/* Interactice mode */
if (interactive) interactive_mode();
/* Verbose */
protocol_verbose(verbose);
while (1) socket_run();
protocol_remove_commands();
socket_finish();
effects_finish();
return 0;
}
