flom_handle.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013-2020, Christian Ferrari <tiian@users.sourceforge.net>
 * All rights reserved.
 *
 * This file is part of FLoM, Free Lock Manager
 *
 * FLoM is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2.0 as
 * published by the Free Software Foundation.
 *
 * FLoM 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 FLoM.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef FLOM_HANDLE_H
# define FLOM_HANDLE_H



#include <stdlib.h>



#include "flom_errors.h"
#include "flom_types.h"



typedef enum flom_handle_state_e {
    FLOM_HANDLE_STATE_INIT = 22,
    FLOM_HANDLE_STATE_CONNECTED,
    FLOM_HANDLE_STATE_LOCKED,
    FLOM_HANDLE_STATE_DISCONNECTED,
    FLOM_HANDLE_STATE_CLEANED
} flom_handle_state_t;



typedef struct flom_handle_s {
    flom_handle_state_t   state;
    void                 *conn;
    void                 *config;
    char                 *locked_element;
} flom_handle_t;



#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */



    int flom_handle_init(flom_handle_t *handle);
    


    int flom_handle_clean(flom_handle_t *handle);
    


    flom_handle_t *flom_handle_new(void);


    
    void flom_handle_delete(flom_handle_t *handle);


    
    int flom_handle_lock(flom_handle_t *handle);



    int flom_handle_unlock(flom_handle_t *handle);



    int flom_handle_unlock_rollback(flom_handle_t *handle);



    const char *flom_handle_get_locked_element(const flom_handle_t *handle) {
        return handle->locked_element;
    }


    
    int flom_handle_get_discovery_attempts(const flom_handle_t *handle);

    
    
    int flom_handle_set_discovery_attempts(flom_handle_t *handle, int value);



    int flom_handle_get_discovery_timeout(const flom_handle_t *handle);

    
    
    int flom_handle_set_discovery_timeout(flom_handle_t *handle, int value);



    int flom_handle_get_discovery_ttl(const flom_handle_t *handle);

    
    
    int flom_handle_set_discovery_ttl(flom_handle_t *handle, int value);



    flom_lock_mode_t flom_handle_get_lock_mode(const flom_handle_t *handle);



    int flom_handle_set_lock_mode(flom_handle_t *handle,
                                  flom_lock_mode_t value);



    const char *flom_handle_get_multicast_address(const flom_handle_t *handle);



    int flom_handle_set_multicast_address(flom_handle_t *handle,
                                          const char *value);


    
    int flom_handle_get_multicast_port(const flom_handle_t *handle);



    int flom_handle_set_multicast_port(flom_handle_t *handle, int value);



    const char *flom_handle_get_network_interface(const flom_handle_t *handle);



    int flom_handle_set_network_interface(flom_handle_t *handle,
                                          const char *value);


    
    int flom_handle_get_resource_create(const flom_handle_t *handle);


    
    int flom_handle_set_resource_create(flom_handle_t *handle, int value);



    int flom_handle_get_resource_idle_lifespan(const flom_handle_t *handle);


    
    int flom_handle_set_resource_idle_lifespan(flom_handle_t *handle,
                                               int value);



    const char *flom_handle_get_resource_name(const flom_handle_t *handle);


    
    int flom_handle_set_resource_name(flom_handle_t *handle,
                                      const char *value);


    
    int flom_handle_get_resource_quantity(const flom_handle_t *handle);

    

    int flom_handle_set_resource_quantity(flom_handle_t *handle, int value);


    
    int flom_handle_get_resource_timeout(const flom_handle_t *handle);


    
    int flom_handle_set_resource_timeout(flom_handle_t *handle, int value);



    const char *flom_handle_get_socket_name(const flom_handle_t *handle);

    

    int flom_handle_set_socket_name(flom_handle_t *handle,
                                    const char *value);


    
    const char *flom_handle_get_trace_filename(const flom_handle_t *handle);


    
    int flom_handle_set_trace_filename(flom_handle_t *handle,
                                       const char *value);



    const char *flom_handle_get_unicast_address(const flom_handle_t *handle);



    int flom_handle_set_unicast_address(flom_handle_t *handle,
                                        const char *value);


    
    int flom_handle_get_unicast_port(const flom_handle_t *handle);


    
    int flom_handle_set_unicast_port(flom_handle_t *handle, int value);



    const char *flom_handle_get_tls_certificate(const flom_handle_t *handle);



    int flom_handle_set_tls_certificate(flom_handle_t *handle,
                                        const char *value);


    
    const char *flom_handle_get_tls_private_key(const flom_handle_t *handle);



    int flom_handle_set_tls_private_key(flom_handle_t *handle,
                                        const char *value);


    
    const char *flom_handle_get_tls_ca_certificate(
        const flom_handle_t *handle);



    int flom_handle_set_tls_ca_certificate(flom_handle_t *handle,
                                           const char *value);


    
    int flom_handle_get_tls_check_peer_id(const flom_handle_t *handle);


    
    int flom_handle_set_tls_check_peer_id(flom_handle_t *handle, int value);



#ifdef __cplusplus
}
#endif /* __cplusplus */



#endif /* FLOM_HANDLE_H */