clone.h

/*
 *  libdoclone - library for cloning GNU/Linux systems
 *  Copyright (C) 2013-2015 Joan Lledó <joanlluislledo@gmail.com>
 *
 *  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 3 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 _CLONE_H_
#define _CLONE_H_

#include <stdint.h>

/* Include this headers only in C++
 *
 * For C, libdoclone has another API defined bellow
 */
#ifdef __cplusplus

#include <doclone/DataTransfer.h>
#include <doclone/Logger.h>
#include <doclone/observer/AbstractObserver.h>
#include <doclone/Operation.h>
#include <doclone/exception/Exception.h>

#endif //__cplusplus

/*
 * C Wrapper API
 */

#ifdef __cplusplus
extern "C" {
#endif

typedef enum dcTransferEvent {
    TRANS_TOTAL_SIZE,
    TRANS_TRANSFERRED_BYTES
} dcTransferEvent;

typedef enum dcOperationEvent {
    OPER_ADD,
    OPER_MARK_COMPLETED
} dcOperationEvent;

typedef enum dcOperationType {
    OP_NONE,
    OP_READ_PARTITION_TABLE,
    OP_MAKE_DISKLABEL,
    OP_CREATE_PARTITION,
    OP_FORMAT_PARTITION,
    OP_WRITE_PARTITION_FLAGS,
    OP_WRITE_FS_LABEL,
    OP_WRITE_FS_UUID,
    OP_READ_DATA,
    OP_WRITE_DATA,
    OP_GRUB_INSTALL,
    OP_TRANSFER_DATA,
    OP_WAIT_SERVER,
    OP_WAIT_CLIENTS
} dcOperationType;

typedef enum dcEvent {
    EVT_CANCEL_EXECUTION,
    EVT_FINISH_EXECUTION,
    EVT_NEW_CONNECION
} dcEvent;

typedef void (*transferCallback) (dcTransferEvent event,
        uint64_t numBytes);

typedef void (*operationCallback) (dcOperationEvent event, dcOperationType type,
        const char *target);

typedef void (*generalCallback) (dcEvent event, const char *target);

typedef void (*notificationCallback) (const char *str);

typedef struct dc_doclone {
    char _image[512];
    char _device[512];
    char _address[20];
    char _interface[20];
    uint32_t _nodesNumber;
    uint8_t _empty;
    uint8_t _force;
    void * _observer;
} dc_doclone;


/*
 * AC_CHECK_LIB Macro compatibility
 */
int libdoclone_is_present();

/*
 * Memory management for the dc_doclone object
 */
dc_doclone *doclone_new();
void doclone_destroy(dc_doclone *dc_obj);

/*
 * Operations that can be performed
 */
int doclone_create(const dc_doclone *dc_obj);
int doclone_restore(const dc_doclone *dc_obj);
int doclone_send(const dc_doclone *dc_obj);
int doclone_receive(const dc_doclone *dc_obj);
int doclone_chain_origin(const dc_doclone *dc_obj);
int doclone_chain_link(const dc_doclone *dc_obj);

/*
 * Setters for the dc_doclone object
 */
void doclone_set_image(dc_doclone *dc_obj, const char *image);
void doclone_set_device(dc_doclone *dc_obj, const char *device);
void doclone_set_address(dc_doclone *dc_obj, const char *address);
void doclone_set_interface(dc_doclone *dc_obj, const char *interface);
void doclone_set_nodes_number(dc_doclone *dc_obj, unsigned int number);
void doclone_set_empty(dc_doclone *dc_obj, unsigned short empty);
void doclone_set_force(dc_doclone *dc_obj, unsigned short force);

/*
 * Functions for set the callbacks of libdoclone events
 */
void doclone_subscribe_to_tranfer_events(dc_doclone *dc_obj,
        transferCallback call);
void doclone_subscribe_to_operation_events(dc_doclone *dc_obj,
        operationCallback call);
void doclone_subscribe_to_general_events(dc_doclone *dc_obj,
        generalCallback call);
void doclone_subscribe_to_notifications(dc_doclone *dc_obj,
        notificationCallback call);

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus

class DefaultObserver : public Doclone::AbstractObserver {
public:
    DefaultObserver();

    void notify(Doclone::dcTransferEvent event, uint64_t numBytes);
    void notify(Doclone::dcOperationEvent event,
            Doclone::dcOperationType type, const std::string &target);
    void notify(Doclone::dcEvent event, const std::string &target);
    void notify(const std::string &str);

    void setTCallback(const transferCallback call);
    void setOCallback(const operationCallback call);
    void setGCallback(const generalCallback call);
    void setNCallback(const notificationCallback call);

private:
    transferCallback _tCallback;
    operationCallback _oCallback;
    generalCallback _gCallback;
    notificationCallback _nCallback;
};

#endif //__cplusplus

#endif /* _CLONE_H_ */