---

frdi_struct.h

Go to the documentation of this file.

#ifndef _FRDI_STRUCT_H
#define _FRDI_STRUCT_H

#include "frdi_defines.h"


// ############################################################
//
// Original
//
// ############################################################


/*
struct frdi__timestamp
{
        char *id;
        time_t *time;
};

typedef struct frdi__timestamp frdi_timestamp;


struct frdi__client
{
        char *id;
        char *description;
        int instance;
};

typedef struct frdi__client frdi_client;


struct frdi__server
{
        char *id;
        char *description;
        int instance;
        frdi_client *client;
};

typedef struct frdi__server frdi_server;



struct frdi__game
{
        char *id;
        char *description;
        int instance;
        frdi_server *server;
};

typedef struct frdi__game frdi_game;


struct frdi__event
{
        char *id;
        frdi_timestamp *timestamp;
        frdi_game *game;
};

typedef struct frdi__event frdi_event;
*/

// ############################################################
//
// SHUFFLE DECK
//
// ############################################################


struct card_struct
{
        char suit;
        char pips;
};

typedef struct card_struct card;

struct deck_struct
{
        card cards[FRDI_STANDARD_DECK_SIZE];
};

typedef struct deck_struct deck;

typedef mpz_t frdi_bigint;


// We want to avoid having gmp specifics in too many places,
// so we wrap it in a structure
struct frdi__seed
{
        gmp_randstate_t state;
};

typedef struct frdi__seed frdi_seed;


// ############################################################
//
// THREADING
//
// ############################################################

typedef void *(*frdi_thread_function)(void *);



// ############################################################
//
// UTILS
//
// ############################################################

struct frdi__handler
{
        void *(*handler_function)(void *);
        char *name;
        char *arg_type;
        char *ret_type;
};

typedef struct frdi__handler frdi_handler;


struct frdi__log
{
        FILE *log_file;
        int   flag_time;
        int   flag_app;
        int   flag_link;
        int   flag_text;
        int   flag_byte;
        int   flag_thread;
        int   verbose;
        pthread_mutex_t log_file_m;
};

typedef struct frdi__log frdi_log;


struct frdi__exception
{
        jmp_buf location;
        int err_num;
        char *message;
        struct frdi__exception *parent;
        frdi_handler *handler;
        frdi_log *log;
};

typedef struct frdi__exception frdi_exception;


// ############################################################
//
// LIST
//
// ############################################################

struct frdi__list_node
{
        void *value;
        int size;
        struct frdi__list_node *last;
        struct frdi__list_node *next;
        frdi_handler *string;
        frdi_handler *free;
};

typedef struct frdi__list_node frdi_list_node;


struct frdi__list
{
        int size;
        frdi_exception *eh;
        frdi_list_node *start;
        frdi_list_node *finish;
        frdi_handler *string;
        frdi_handler *free;
};

typedef struct frdi__list frdi_list;



// ############################################################
//
// DICT
//
// ############################################################

struct frdi__dict
{
        int size;
        frdi_exception *eh;
        frdi_list *keys;
        frdi_list *values;
        frdi_handler *key_string;
        frdi_handler *key_free;
        frdi_handler *value_string;
        frdi_handler *value_free;
};

typedef struct frdi__dict frdi_dict;


// ############################################################
//
// CONFIG
//
// ############################################################

struct frdi__config
{
        char *id;
        char *timestamp; // or should it be frdi_timestamp ??
        char *version; // against, should also be an object
        char *client;
        char *server;
        int   userport;
        int   clientport;
        int   serverport;
        int   hostport;
        int   verbose; // 1 if verbose, 0 if brief
        char *name;
        char *description;
        char *logdir;
        char *logstem;
        int   scenario;
        int   flag_time;
        int   flag_app;
        int   flag_link;
        int   flag_text;
        int   flag_byte;
        int   flag_thread;
        int   flag_outcome;
};


typedef struct frdi__config frdi_config;


struct frdi__app
{
        frdi_config *config;
        frdi_log *log;
        frdi_exception *eh;
        frdi_seed *seed;
        void *self; // Will be one of: client, host, user, server
        pthread_mutex_t log_m;
};

typedef struct frdi__app frdi_app;


// ############################################################
//
// NETWORK
//
// ############################################################

struct frdi__application
{
        char *machine_name;// eg "localhost", "casino.harry.net"
        char *machine_num; // as string in "123.123.123.123" form
        int port_number;
};

typedef struct frdi__application frdi_application;


struct frdi__listener
{
        frdi_handler *spawner;
        int port_number;
        int socket_descriptor;
        pthread_t thread;
        int is_accepting;
        frdi_app *self; // Will be one of: client, host, user, server
        frdi_exception *eh;
};

typedef struct frdi__listener frdi_listener;


struct frdi__link
{
        int authentication_mode;
        int encryption_mode;
        int encoding_mode;
        frdi_dict *authentication_data;
        frdi_dict *encryption_data;
        frdi_dict *encoding_data;
};

typedef struct frdi__link frdi_link;


struct frdi__connection
{
        frdi_handler *receiver;
        frdi_application *remote;
        frdi_listener *listener; // NULL if none
        int socket_descriptor;
        pthread_t sender_thread;
        pthread_t receiver_thread;
        char send_buffer[FRDI_MESSAGE_TOTAL_SIZE];
        char receive_buffer[FRDI_MESSAGE_TOTAL_SIZE];
        int total_bytes_sent;
        int total_bytes_received;
        frdi_exception *eh_send; // one error handler per thread
        frdi_exception *eh_receive; // one error handler per thread
        int is_receiving;
        int is_disconnected;
        frdi_app *self;
        frdi_link *link;
};

typedef struct frdi__connection frdi_connection;


struct frdi__message
{
        frdi_connection *connection;
        int size;
        void *data;
};

typedef struct frdi__message frdi_message;

#ifdef NOT_NEEDED
/*
struct xfrdi__game_output
{
        frdi_bigint *result;
};

typedef struct xfrdi__game_output xfrdi_game_output;


struct xfrdi__game_input
{
        char *plaintext;
        frdi_bigint *numvalue;
};

typedef struct xfrdi__game_input xfrdi_game_input;


struct xfrdi__game
{
        int num_players;
        frdi_bigint *num_range; // equal distribution between 0..num_range inclusive
};

typedef struct xfrdi__game xfrdi_game;
*/
#endif /* NOT_NEEDED */

// ######################################################
//
//    frdi_game_*
//
// ######################################################

struct frdi__game_modulo
{
        frdi_bigint *num;
        char *text;
};

typedef struct frdi__game_modulo frdi_game_modulo;


struct frdi__game_usertext
{
        frdi_bigint *num;
        char *text;
};

typedef struct frdi__game_usertext frdi_game_usertext;


struct frdi__game_sharedtext
{
        char *text;
        char *hostid;
        char *gameid;
        char *timeid;
        char *padding;
};

typedef struct frdi__game_sharedtext frdi_game_sharedtext;


struct frdi__game_digest
{
        frdi_bigint *num;
        char *text;
};

typedef struct frdi__game_digest frdi_game_digest;


struct frdi__game_plaintext
{
        char *text;
        frdi_game_sharedtext *sharedtext;
        frdi_game_usertext *usertext;
        frdi_game_digest *digest;
};

typedef struct frdi__game_plaintext frdi_game_plaintext;


struct frdi__game_properties
{
        int size; // number of inputs
        frdi_game_modulo *modulo;
        frdi_game_sharedtext *sharedtext;
};

typedef struct frdi__game_properties frdi_game_properties;


struct frdi__game_input
{
        frdi_bigint *num;
        char *text;
};

typedef struct frdi__game_input frdi_game_input;


struct frdi__game_output
{
        frdi_bigint *num;
        char *text;
};

typedef struct frdi__game_output frdi_game_output;


#endif /* _FRDI_STRUCT_H */

/* End of File */

---