xref: /dports/audio/liblo/liblo-0.31/src/server_thread.c

/*
 *  Copyright (C) 2014 Steve Harris et al. (see AUTHORS)
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as
 *  published by the Free Software Foundation; either version 2.1 of the
 *  License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  $Id$
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef HAVE_LIBPTHREAD
#include <pthread.h>
#endif
#include <sys/types.h>

#if defined(WIN32) || defined(_MSC_VER)
#include <winsock2.h>
#include <ws2tcpip.h>
#include <process.h>
#else
#include <unistd.h>
#include <netdb.h>
#include <sys/socket.h>
#endif

#include "lo_types_internal.h"
#include "lo/lo.h"
#include "lo/lo_throw.h"

#ifdef HAVE_WIN32_THREADS
static unsigned __stdcall thread_func(void *data);
#else
static void* thread_func(void *data);
#endif

lo_server_thread lo_server_thread_new(const char *port,
                                      lo_err_handler err_h)
{
    return lo_server_thread_new_with_proto(port, LO_DEFAULT, err_h);
}

static lo_server_thread alloc_server_thread(lo_server s)
{
    lo_server_thread st;

    if (!s)
        return NULL;

    st = (lo_server_thread) malloc(sizeof(struct _lo_server_thread));

    st->s = s;
    st->active = 0;
    st->done = 0;
    st->cb_init = NULL;
    st->cb_cleanup = NULL;
    st->user_data = NULL;
    return st;
}

lo_server_thread lo_server_thread_new_multicast(const char *group,
                                                const char *port,
                                                lo_err_handler err_h)
{
    lo_server_thread st = alloc_server_thread(
        lo_server_new_multicast(group, port, err_h));
    return st;
}

lo_server_thread lo_server_thread_new_multicast_iface(const char *group, const char *port,
						      const char *iface, const char *ip,
						      lo_err_handler err_h)
{
    lo_server_thread st = alloc_server_thread(
        lo_server_new_multicast_iface(group, port, iface, ip, err_h));
    return st;
}

lo_server_thread lo_server_thread_new_with_proto(const char *port,
                                                 int proto,
                                                 lo_err_handler err_h)
{
    lo_server_thread st = alloc_server_thread(
        lo_server_new_with_proto(port, proto, err_h));
    return st;
}

lo_server_thread lo_server_thread_new_from_url(const char *url,
                                               lo_err_handler err_h)
{
    lo_server_thread st = alloc_server_thread(
        lo_server_new_from_url(url, err_h));
    return st;
}

void lo_server_thread_set_error_context(lo_server_thread st,
                                        void *user_data)
{
    lo_server_set_error_context(st->s, user_data);
}

void lo_server_thread_free(lo_server_thread st)
{
    if (st) {
        if (st->active) {
            lo_server_thread_stop(st);
        }
        lo_server_free(st->s);
    }
    free(st);
}

lo_method lo_server_thread_add_method(lo_server_thread st,
                                      const char *path,
                                      const char *typespec,
                                      lo_method_handler h,
                                      const void *user_data)
{
    return lo_server_add_method(st->s, path, typespec, h, user_data);
}

void lo_server_thread_del_method(lo_server_thread st, const char *path,
                                 const char *typespec)
{
    lo_server_del_method(st->s, path, typespec);
}

int lo_server_thread_del_lo_method(lo_server_thread st, lo_method m)
{
    return lo_server_del_lo_method(st->s, m);
}

void lo_server_thread_set_callbacks(lo_server_thread st,
                                    lo_server_thread_init_callback init,
                                    lo_server_thread_cleanup_callback cleanup,
                                    void *user_data)
{
    st->cb_init = init;
    st->cb_cleanup = cleanup;
    st->user_data = user_data;
}

int lo_server_thread_start(lo_server_thread st)
{
    if (!st->active) {
        st->active = 1;
        st->done = 0;

        // Create the server thread
#ifdef HAVE_LIBPTHREAD
        int result;
        result=pthread_create(&(st->thread), NULL, &thread_func, st);
        if (result)
        {
            fprintf (stderr,
                "Failed to create thread: pthread_create(), %s",
                strerror (result));
            return -result;
        }
#else
#ifdef HAVE_WIN32_THREADS
        st->thread = (HANDLE)_beginthreadex (NULL, 0, &thread_func, st, 0, NULL);

        if (st->thread == NULL)
        {
            fprintf (stderr,
                "Failed to create thread: Win _beginthreadex(), %s",
                strerror (errno));
            return -1;
        }
#else
#error "No threading implementation available."
#endif
#endif
    }
    return 0;
}

int lo_server_thread_stop(lo_server_thread st)
{
    int result;

    if (st->active) {
        // Signal thread to stop
        st->active = 0;

#ifdef HAVE_LIBPTHREAD
        // pthread_join waits for thread to terminate
        // and then releases the thread's resources
        result = pthread_join(st->thread, NULL);

        if (result) {
            fprintf(stderr, "Failed to stop thread: pthread_join(), %s",
                    strerror(result));
            return -result;
        }
#else
#ifdef HAVE_WIN32_THREADS
        result = WaitForSingleObject (st->thread, INFINITE);
        CloseHandle (st->thread);
        st->thread = NULL;

        if (result != 0)
        {
            fprintf (stderr, "Failed to join thread: waitForSingleObject(), %d",
                result);
            return -1;
        }
#else
#error "No threading implementation available."
#endif
#endif
    }

    return 0;
}

int lo_server_thread_get_port(lo_server_thread st)
{
    return lo_server_get_port(st->s);
}

char *lo_server_thread_get_url(lo_server_thread st)
{
    return lo_server_get_url(st->s);
}

lo_server lo_server_thread_get_server(lo_server_thread st)
{
    return st->s;
}

int lo_server_thread_events_pending(lo_server_thread st)
{
    return lo_server_events_pending(st->s);
}

#ifdef HAVE_WIN32_THREADS
static unsigned __stdcall thread_func(void *data)
#else
static void* thread_func(void *data)
#endif
{
    lo_server_thread st = (lo_server_thread) data;

    if (st->cb_init) {
        if ( (st->cb_init)(st, st->user_data) )
        {
            st->done = 1;
#ifdef HAVE_LIBPTHREAD
            pthread_exit (NULL);
#else
#ifdef HAVE_WIN32_THREADS
            _endthread ();
#else
#error "No threading implementation selected."
#endif
#endif
            return 0;
        }
    }

    while (st->active) {
        lo_server_recv_noblock(st->s, 10);
    }
    st->done = 1;

    if (st->cb_cleanup) {
        (st->cb_cleanup)(st, st->user_data);
    }

#ifdef HAVE_LIBPTHREAD
    pthread_exit(NULL);
#else
#ifdef HAVE_WIN32_THREADS
    _endthread ();
#else
#error "No threading implementation selected."
#endif
#endif
    return 0;
}

void lo_server_thread_pp(lo_server_thread st)
{
    lo_server_pp(st->s);
}

/* vi:set ts=8 sts=4 sw=4: */