src/gras/gras_private.h

   1 /* $Id$ */
   2
   3 /* gras_private.h - GRAS private definitions                                */
   4
   5 /* Authors: Martin Quinson                                                  */
   6 /* Copyright (C) 2003 the OURAGAN project.                                  */
   7
   8 /* This program is free software; you can redistribute it and/or modify it
   9    under the terms of the license (GNU LGPL) which comes with this package. */
  10
  11 #ifndef GRAS_PRIVATE_H
  12 #define GRAS_PRIVATE_H
  13
  14 #include <unistd.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18
  19 /* Oli's macro */
  20 #ifndef GS_FAILURE_CONTEXT
  21 #  define GS_FAILURE_CONTEXT
  22 #endif /* FAILURE_CONTEXT */
  23
  24 #define GS_FAILURE(str) \
  25      (fprintf(stderr, "FAILURE: %s(%s:%d)" GS_FAILURE_CONTEXT "%s\n", __func__, __FILE__, __LINE__, (str)), \
  26       abort())
  27
  28 #define aligned(v, a) (((v) + (a - 1)) & ~(a - 1))
  29 #define max(a, b) (((a) > (b))?(a):(b))
  30 #define min(a, b) (((a) < (b))?(a):(b))
  31
  32 /* end of Oli's cruft */
  33
  34 #include "gras_config.h"
  35
  36 #include "gras/error.h"
  37 #include "gras/log.h"
  38 #include "gras/dynar.h"
  39 #include "gras/dict.h"
  40 #include "gras/config.h"
  41
  42 #include "gras/data_description.h"
  43 #include "gras/dd_type_bag.h"
  44
  45 #include "gras/core.h"
  46 #include "gras/datadesc.h"
  47 #include "gras/socket.h"
  48 #include "gras/messages.h"
  49
  50 #define TRUE  1
  51 #define FALSE 0
  52
  53 #define ASSERT(cond,msg) do {if (!(cond)) { fprintf(stderr,msg); abort(); }} while(0)
  54
  55 /* **************************************************************************
  56  * Locking system
  57  ****************************************************************************/
  58 /**
  59  * gras_lock:
  60  * @Returns: 1 if succesfull 0 otherwise.
  61  *
  62  * Get the GRAS lock.
  63  */
  64 int
  65 gras_lock(void);
  66
  67 /**
  68  * gras_unlock:
  69  * @Returns: 1 if succesfull 0 otherwise.
  70  *
  71  * release the GRAS general lock.
  72  */
  73 int
  74 gras_unlock(void);
  75
  76 /* **************************************************************************
  77  * Messaging stuff
  78  * **************************************************************************/
  79
  80 /**
  81  * gras_cblist_t:
  82  *
  83  * The list of callbacks for a given message type on a given host
  84  */
  85 typedef struct {
  86   gras_msgid_t id;     /** identificator of this message */
  87
  88   int cbCount;         /** number of registered callbacks */
  89   gras_cb_t *cb;       /** callbacks */
  90   int *cbTTL;          /** TTL of each callback (in number of use)*/
  91 } gras_cblist_t;
  92
  93 /**
  94  * gras_msgentry_t:
  95  *
  96  * An entry in the registered message list.
  97  */
  98
  99 struct gras_msgentry_s {
 100   gras_msgid_t id;     /** identificator of this message */
 101   char *name;               /** printable name of this message */
 102
 103   int seqCount;             /** number of sequence for this message */
 104   DataDescriptor **dd;      /** list of datadescriptor for each sequence */
 105   size_t *ddCount;          /** list of datadescriptor for each sequence */
 106   unsigned int *networkSize;/** network size of one element in each sequence */
 107   unsigned int *hostSize;   /** host size of one element in each sequence */
 108 };
 109 /* **************************************************************************
 110  * GRAS globals
 111  * **************************************************************************/
 112
 113 /**
 114  * gras_hostglobal_t:
 115  *
 116  * Globals for a given host.
 117  */
 118 typedef struct {
 119   gras_cblist_t *grasCbList; /** callbacks for registered messages */
 120   unsigned int grasCbListCount;      /** length of previous array */
 121 } gras_hostglobal_t;
 122
 123 /**
 124  * gras_msgheader_t:
 125  *
 126  * A header sent with messages.  #version# is the NWS version and is presently
 127  * ignored, but it could be used for compatibility.  #message# is the actual
 128  * message. #seqCount# is the number of sequence accompagning this message.
 129  */
 130 struct gras_msgheader_s {
 131   char          version[10];
 132   gras_msgid_t  message;
 133   unsigned int  dataSize;
 134   unsigned int  seqCount;
 135 };
 136
 137 /**
 138  * grasProcessData_t:
 139  *
 140  * Data for each process
 141  */
 142 typedef struct {
 143   /* queue of messages which where received but not wanted in msgWait, and therefore
 144      temporarly queued until the next msgHandle */
 145   int grasMsgQueueLen;
 146   gras_msg_t **grasMsgQueue;
 147
 148   /* registered callbacks for each message */
 149   int grasCblListLen;
 150   gras_cblist_t *grasCblList;
 151
 152   /* The channel we are listening to in SG for formated messages */
 153   int chan;
 154   /* The channel we are listening to in SG for raw send/recv */
 155   int rawChan;
 156
 157   /* globals of the process */
 158   void *userdata;
 159 } grasProcessData_t;
 160
 161
 162 /*@unused@*/static const DataDescriptor headerDescriptor[] =
 163   {SIMPLE_MEMBER(CHAR_TYPE, 10, offsetof(gras_msgheader_t, version)),
 164    SIMPLE_MEMBER(UNSIGNED_INT_TYPE, 1, offsetof(gras_msgheader_t, message)),
 165    SIMPLE_MEMBER(UNSIGNED_INT_TYPE, 1, offsetof(gras_msgheader_t, dataSize)),
 166    SIMPLE_MEMBER(UNSIGNED_INT_TYPE, 1, offsetof(gras_msgheader_t, seqCount))};
 167 #define headerDescriptorCount 4
 168
 169 /*@unused@*/static const DataDescriptor countDescriptor[] =
 170   {SIMPLE_DATA(UNSIGNED_INT_TYPE,1)};
 171 #define countDescriptorCount 1
 172
 173 /**
 174  * GRASVERSION
 175  *
 176  * This string is sent in each message to identify the version of the
 177  * communication protocol used. This may be paranoid, but I feel so right now.
 178  */
 179 #define GRASVERSION "0.0.020504"
 180
 181 /**
 182  * grasMsgEntryGet:
 183  * @id: msg id to look for
 184  * @Returns: the entry if found, NULL otherwise
 185  *
 186  * Get the entry corresponding to this message id;
 187  */ /*@observer@*/
 188 gras_msgentry_t * grasMsgEntryGet(gras_msgid_t id);
 189
 190 /**
 191  * grasProcessDataGet:
 192  *
 193  * Get the GRAS globals for this host
 194  */ /*@observer@*/
 195 grasProcessData_t *grasProcessDataGet(void);
 196
 197 /**
 198  * gras_cb_get:
 199  * @id: msg id to look for
 200  *
 201  * Get the callback list corresponding to this message id;
 202  */ /*@observer@*/
 203 gras_cblist_t * gras_cb_get(gras_msgid_t id);
 204
 205 /**
 206  * gras_cb_create:
 207  * @id: the id of the new msg
 208  *
 209  * Create a new callback list for a new message id.
 210  */
 211 gras_error_t gras_cb_create(gras_msgid_t message);
 212
 213 /**
 214  * grasMsgHeaderNew:
 215  * @msgId:
 216  * @dataSize: total size in network format, including headers and seqcount
 217  * @seqCount: Number of sequences in this message (to check that everything goes well)
 218  * @Returns: the created header
 219  *
 220  * Create a new header containing the passed values.
 221  */
 222 gras_msgheader_t *grasMsgHeaderNew(gras_msgid_t msgId,
 223                                   unsigned int dataSize,
 224                                   unsigned int seqCount);
 225
 226 /**
 227  * grasMsgRecv:
 228  *
 229  * Receive the next message arriving within the given timeout
 230  */
 231 gras_error_t grasMsgRecv(gras_msg_t **msg, double timeout);
 232
 233 /**
 234  * gras_sock_new:
 235  *
 236  * Create an empty socket
 237  */
 238 gras_sock_t *gras_sock_new(void);
 239
 240 /**
 241  * grasSockFree:
 242  *
 243  * Frees an old socket
 244  */
 245 void grasSockFree(gras_sock_t *s);
 246
 247
 248
 249 /* **************************************************************************
 250  * Handling DataDescriptors
 251  * **************************************************************************/
 252 typedef enum {HOST_FORMAT, NETWORK_FORMAT} FormatTypes;
 253 size_t DataSize(const DataDescriptor *description,
 254                 size_t length,
 255                 FormatTypes format);
 256 void *gras_datadesc_copy_data(const DataDescriptor *dd, unsigned int c, void *data);
 257 int gras_datadesc_cmp(/*@null@*/const DataDescriptor *dd1, unsigned int c1,
 258                       /*@null@*/const DataDescriptor *dd2, unsigned int c2);
 259 void gras_datadesc_dump(/*@null@*/const DataDescriptor *dd, unsigned int c);
 260
 261 #endif /* GRAS_PRIVATE_H */