citadel/modules/xmpp/xmpp_xmacros.c

   1 #include <stdio.h>
   2 #include <expat.h>
   3 #include <libcitadel.h>
   4 #include "ctdl_module.h"
   5 #include "serv_xmpp.h"
   6
   7 void *GetToken_iq(void)
   8 {
   9         return &XMPP->IQ;
  10 }
  11 void *GetToken_piq(void)
  12 {
  13         return NULL;
  14 }
  15
  16 void *GetToken_message(void)
  17 {
  18         return &XMPP->Message;
  19 }
  20
  21 /// TODO
  22 #define CALLBACK(NAME);
  23
  24 #define STRPROP(STRUCTNAME, NAME)                                       \
  25         if (StrLength(pdata->NAME) > 0)                                 \
  26         {                                                               \
  27         XPut(#NAME, sizeof(#NAME) - 1);                                 \
  28         XPut("=\"", 2);                                                 \
  29         XPutProp(SKEY(pdata->NAME));                                    \
  30         XPut("\" ", 2);                                                 \
  31         }
  32
  33 #define PAYLOAD(STRUCTNAME, NAME)                                       \
  34         XPrint(#NAME, sizeof(#NAME) -1,                                 \
  35                XCLOSED,                                                 \
  36                TYPE_BODYSTR, SKEY(pdata->NAME),                         \
  37                TYPE_ARGEND);
  38
  39 #define THENAMESPACE(STRUCTNAME, NAME)                                  \
  40         XPut(#NAME, sizeof(#NAME) - 1);                                 \
  41         XPut("=\"", 2);                                                 \
  42         XPutProp(NAMESPACE_##STRUCTNAME,                                \
  43                  sizeof(NAMESPACE_##STRUCTNAME)-1);                     \
  44         XPut("\" ", 2);
  45
  46 #define TOKEN(NAME, STRUCT)                                             \
  47         void serialize_##NAME(TheToken_##NAME *pdata, int Close)        \
  48         {                                                               \
  49         XPUT("<");                                                      \
  50         XPut(#NAME, sizeof(#NAME));                                     \
  51         XPUT(" ");                                                      \
  52         STRUCT ;                                                        \
  53         XPUT(">");                                                      \
  54         if (Close)                                                      \
  55         {                                                               \
  56                 XPut("</", 2);                                          \
  57                 XPut(#NAME, sizeof(#NAME));                             \
  58                 XPut(">", 1);                                           \
  59         }                                                               \
  60         }
  61
  62 #define SUBTOKEN(NAME, NS, STOKEN, STRUCT)                              \
  63         void serialize_##NAME##NS##STOKEN(                              \
  64                 theSubToken_##NAME##NS##STOKEN *pdata, int Close)       \
  65         {                                                               \
  66         XPUT("<");                                                      \
  67         XPut(#NAME, sizeof(#NAME));                                     \
  68         XPUT(" ");                                                      \
  69         STRUCT ;                                                        \
  70         XPUT(">");                                                      \
  71         if (Close)                                                      \
  72         {                                                               \
  73                 XPut("</", 2);                                          \
  74                 XPut(#NAME, sizeof(#NAME));                             \
  75                 XPut(">", 1);                                           \
  76         }                                                               \
  77         }
  78
  79 #include "token.def"
  80 #undef STRPROP
  81 #undef PAYLOAD
  82 #undef TOKEN
  83 #undef SUBTOKEN
  84
  85 #define STRPROP(STRUCTNAME, NAME)                                       \
  86         FreeStrBuf(&pdata->NAME);
  87
  88 #define PAYLOAD(STRUCTNAME, NAME)                                       \
  89         FreeStrBuf(&pdata->NAME);
  90
  91 #define TOKEN(NAME, STRUCT)                                             \
  92         void free_buf_##NAME(TheToken_##NAME *pdata)                    \
  93         {                                                               \
  94                 STRUCT ;                                                \
  95         }
  96
  97 #define SUBTOKEN(NAME, NS, STOKEN, STRUCT) void free_buf__##NAME##NS##STOKEN \
  98         (theSubToken_##NAME##NS##STOKEN *pdata){                        \
  99                 STRUCT ;                                                \
 100         }
 101
 102 #include "token.def"
 103 #undef STRPROP
 104 #undef PAYLOAD
 105 #undef TOKEN
 106 #undef SUBTOKEN
 107
 108 #define TOKEN(NAME, STRUCT)                                             \
 109         void free_##NAME(TheToken_##NAME *pdata)                        \
 110         {                                                               \
 111                 free_buf_##NAME(pdata);                                 \
 112                 free(pdata);                                            \
 113         }
 114
 115 #define SUBTOKEN(NAME, NS, STOKEN, STRUCT) void free__##NAME##NS##STOKEN \
 116         (theSubToken_##NAME##NS##STOKEN *pdata)                         \
 117         {                                                               \
 118                 free_buf__##NAME##NS##STOKEN(pdata);                    \
 119                 free(pdata);                                            \
 120         }
 121
 122 #include "token.def"
 123 #undef STRPROP
 124 #undef TOKEN
 125 #undef SUBTOKEN
 126
 127
 128
 129 CTDL_MODULE_INIT(xmpp_xmacros)
 130 {
 131         if (!threading) {
 132 #define STRPROP(TOKENNAME, PROPERTYNAME)                                \
 133                 long offset##PROPERTYNAME =                             \
 134                         offsetof(TheToken_##TOKENNAME, PROPERTYNAME);   \
 135                 XMPP_RegisterTokenProperty(                             \
 136                         NAMESPACE_##TOKENNAME,                          \
 137                         sizeof(NAMESPACE_##TOKENNAME)-1,                \
 138                         #TOKENNAME, sizeof(#TOKENNAME)-1,               \
 139                         #PROPERTYNAME, sizeof(#PROPERTYNAME)-1,         \
 140                         GetToken_##TOKENNAME,                           \
 141                         offset##PROPERTYNAME);
 142 #define PAYLOAD(TOKENNAME, PROPERTYNAME)                                \
 143                 long offset##PROPERTYNAME =                             \
 144                         offsetof(TheToken_##TOKENNAME, PROPERTYNAME);   \
 145                 XMPP_RegisterTokenProperty(                             \
 146                         NAMESPACE_##TOKENNAME,                          \
 147                         sizeof(NAMESPACE_##TOKENNAME)-1,                \
 148                         #TOKENNAME, sizeof(#TOKENNAME)-1,               \
 149                         NULL, 0,                                        \
 150                         GetToken_##TOKENNAME,                           \
 151                         offset##PROPERTYNAME);
 152 #define TOKEN(NAME, STRUCT) STRUCT
 153 #define SUBTOKEN(NAME, NS, STOKEN, STRUCT) STRUCT
 154 #include "token.def"
 155 #undef STRPROP
 156 #undef TOKEN
 157         }
 158
 159         /* return our module name for the log */
 160         return "xmpp_xmacros";
 161 }