libjaylink-internal.h

Go to the documentation of this file.

/*
 * This file is part of the libjaylink project.
 *
 * Copyright (C) 2014-2016 Marc Schink <jaylink-dev@marcschink.de>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef LIBJAYLINK_LIBJAYLINK_INTERNAL_H
#define LIBJAYLINK_LIBJAYLINK_INTERNAL_H

#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdarg.h>
#include <sys/types.h>
#ifdef _WIN32
#include <ws2tcpip.h>
#else
#include <sys/socket.h>
#include <arpa/inet.h>
#endif

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

#ifdef HAVE_LIBUSB
#include <libusb.h>
#endif

#include "libjaylink.h"

#if defined(_WIN32) || defined(__MSYS__) || defined(__CYGWIN__)
#define JAYLINK_PRIV
#else
#define JAYLINK_PRIV __attribute__ ((visibility ("hidden")))
#endif

#define MIN(a, b) (((a) < (b)) ? (a) : (b))

struct jaylink_context {
#ifdef HAVE_LIBUSB

    struct libusb_context *usb_ctx;
#endif

    struct list *devs;
    struct list *discovered_devs;
    enum jaylink_log_level log_level;
    jaylink_log_callback log_callback;
    void *log_callback_data;
    char log_domain[JAYLINK_LOG_DOMAIN_MAX_LENGTH + 1];
};

struct jaylink_device {
    struct jaylink_context *ctx;
    size_t ref_count;
    enum jaylink_host_interface iface;
    uint32_t serial_number;
    bool has_serial_number;
#ifdef HAVE_LIBUSB

    struct libusb_device *usb_dev;
    enum jaylink_usb_address usb_address;
#endif

    char ipv4_address[INET_ADDRSTRLEN];
    uint8_t mac_address[JAYLINK_MAC_ADDRESS_LENGTH];
    bool has_mac_address;
    char product_name[JAYLINK_PRODUCT_NAME_MAX_LENGTH];
    bool has_product_name;
    char nickname[JAYLINK_NICKNAME_MAX_LENGTH];
    bool has_nickname;
    struct jaylink_hardware_version hw_version;
    bool has_hw_version;
};

struct jaylink_device_handle {
    struct jaylink_device *dev;
    uint8_t *buffer;
    size_t buffer_size;
    size_t read_length;
    size_t bytes_available;
    size_t read_pos;
    size_t write_length;
    size_t write_pos;
#ifdef HAVE_LIBUSB

    struct libusb_device_handle *usb_devh;
    uint8_t interface_number;
    uint8_t endpoint_in;
    uint8_t endpoint_out;
#endif

    int sock;
};

struct list {
    void *data;
    struct list *next;
};

typedef bool (*list_compare_callback)(const void *data, const void *user_data);

/*--- buffer.c --------------------------------------------------------------*/

JAYLINK_PRIV void buffer_set_u16(uint8_t *buffer, uint16_t value,
        size_t offset);
JAYLINK_PRIV uint16_t buffer_get_u16(const uint8_t *buffer, size_t offset);
JAYLINK_PRIV void buffer_set_u32(uint8_t *buffer, uint32_t value,
        size_t offset);
JAYLINK_PRIV uint32_t buffer_get_u32(const uint8_t *buffer, size_t offset);

/*--- device.c --------------------------------------------------------------*/

JAYLINK_PRIV struct jaylink_device *device_allocate(
        struct jaylink_context *ctx);

/*--- discovery_tcp.c -------------------------------------------------------*/

JAYLINK_PRIV int discovery_tcp_scan(struct jaylink_context *ctx);

/*--- discovery_usb.c -------------------------------------------------------*/

JAYLINK_PRIV int discovery_usb_scan(struct jaylink_context *ctx);

/*--- list.c ----------------------------------------------------------------*/

JAYLINK_PRIV struct list *list_prepend(struct list *list, void *data);
JAYLINK_PRIV struct list *list_remove(struct list *list, const void *data);
JAYLINK_PRIV struct list *list_find_custom(struct list *list,
        list_compare_callback callback, const void *user_data);
JAYLINK_PRIV size_t list_length(struct list *list);
JAYLINK_PRIV void list_free(struct list *list);

/*--- log.c -----------------------------------------------------------------*/

JAYLINK_PRIV int log_vprintf(const struct jaylink_context *ctx,
        enum jaylink_log_level level, const char *format, va_list args,
        void *user_data);
JAYLINK_PRIV void log_err(const struct jaylink_context *ctx,
        const char *format, ...);
JAYLINK_PRIV void log_warn(const struct jaylink_context *ctx,
        const char *format, ...);
JAYLINK_PRIV void log_info(const struct jaylink_context *ctx,
        const char *format, ...);
JAYLINK_PRIV void log_dbg(const struct jaylink_context *ctx,
        const char *format, ...);
JAYLINK_PRIV void log_dbgio(const struct jaylink_context *ctx,
        const char *format, ...);

/*--- socket.c --------------------------------------------------------------*/

JAYLINK_PRIV bool socket_close(int sock);
JAYLINK_PRIV bool socket_bind(int sock, const struct sockaddr *address,
        size_t length);
JAYLINK_PRIV bool socket_send(int sock, const void *buffer, size_t *length,
        int flags);
JAYLINK_PRIV bool socket_recv(int sock, void *buffer, size_t *length,
        int flags);
JAYLINK_PRIV bool socket_sendto(int sock, const void *buffer, size_t *length,
        int flags, const struct sockaddr *address,
        size_t address_length);
JAYLINK_PRIV bool socket_recvfrom(int sock, void *buffer, size_t *length,
        int flags, struct sockaddr *address, size_t *address_length);
JAYLINK_PRIV bool socket_set_option(int sock, int level, int option,
        const void *value, size_t length);

/*--- transport.c -----------------------------------------------------------*/

JAYLINK_PRIV int transport_open(struct jaylink_device_handle *devh);
JAYLINK_PRIV int transport_close(struct jaylink_device_handle *devh);
JAYLINK_PRIV int transport_start_write_read(struct jaylink_device_handle *devh,
        size_t write_length, size_t read_length, bool has_command);
JAYLINK_PRIV int transport_start_write(struct jaylink_device_handle *devh,
        size_t length, bool has_command);
JAYLINK_PRIV int transport_start_read(struct jaylink_device_handle *devh,
        size_t length);
JAYLINK_PRIV int transport_write(struct jaylink_device_handle *devh,
        const uint8_t *buffer, size_t length);
JAYLINK_PRIV int transport_read(struct jaylink_device_handle *devh,
        uint8_t *buffer, size_t length);

/*--- transport_usb.c -------------------------------------------------------*/

JAYLINK_PRIV int transport_usb_open(struct jaylink_device_handle *devh);
JAYLINK_PRIV int transport_usb_close(struct jaylink_device_handle *devh);
JAYLINK_PRIV int transport_usb_start_write_read(
        struct jaylink_device_handle *devh, size_t write_length,
        size_t read_length, bool has_command);
JAYLINK_PRIV int transport_usb_start_write(struct jaylink_device_handle *devh,
        size_t length, bool has_command);
JAYLINK_PRIV int transport_usb_start_read(struct jaylink_device_handle *devh,
        size_t length);
JAYLINK_PRIV int transport_usb_write(struct jaylink_device_handle *devh,
        const uint8_t *buffer, size_t length);
JAYLINK_PRIV int transport_usb_read(struct jaylink_device_handle *devh,
        uint8_t *buffer, size_t length);

/*--- transport_tcp.c -------------------------------------------------------*/

JAYLINK_PRIV int transport_tcp_open(struct jaylink_device_handle *devh);
JAYLINK_PRIV int transport_tcp_close(struct jaylink_device_handle *devh);
JAYLINK_PRIV int transport_tcp_start_write_read(
        struct jaylink_device_handle *devh, size_t write_length,
        size_t read_length, bool has_command);
JAYLINK_PRIV int transport_tcp_start_write(struct jaylink_device_handle *devh,
        size_t length, bool has_command);
JAYLINK_PRIV int transport_tcp_start_read(struct jaylink_device_handle *devh,
        size_t length);
JAYLINK_PRIV int transport_tcp_write(struct jaylink_device_handle *devh,
        const uint8_t *buffer, size_t length);
JAYLINK_PRIV int transport_tcp_read(struct jaylink_device_handle *devh,
        uint8_t *buffer, size_t length);

#endif /* LIBJAYLINK_LIBJAYLINK_INTERNAL_H */