src/libesl/esl_oop.cpp

   1 #include <esl.h>
   2 #include <esl_oop.h>
   3
   4 #define connection_construct_common() memset(&handle, 0, sizeof(handle)); last_event_obj = NULL
   5 #define event_construct_common() event = NULL; serialized_string = NULL; mine = 0; hp = NULL
   6
   7 void eslSetLogLevel(int level)
   8 {
   9         esl_global_set_default_logger(level);
  10 }
  11
  12 ESLconnection::ESLconnection(const char *host, const char *port, const char *password)
  13 {
  14         connection_construct_common();
  15         int x_port = atoi(port);
  16
  17         esl_connect(&handle, host, x_port, password);
  18 }
  19
  20
  21 ESLconnection::ESLconnection(int socket)
  22 {
  23         connection_construct_common();
  24         memset(&handle, 0, sizeof(handle));
  25         esl_attach_handle(&handle, (esl_socket_t)socket, NULL);
  26 }
  27
  28 ESLconnection::~ESLconnection()
  29 {
  30         if (handle.connected) {
  31                 esl_disconnect(&handle);
  32         }
  33
  34 }
  35
  36 int ESLconnection::disconnect()
  37 {
  38         if (handle.connected) {
  39         return esl_disconnect(&handle);
  40     }
  41
  42         return 0;
  43 }
  44
  45 int ESLconnection::connected()
  46 {
  47         return handle.connected;
  48 }
  49
  50 int ESLconnection::send(const char *cmd)
  51 {
  52         return esl_send(&handle, cmd);
  53 }
  54
  55 ESLevent *ESLconnection::sendRecv(const char *cmd)
  56 {
  57         if (esl_send_recv(&handle, cmd) == ESL_SUCCESS) {
  58                 esl_event_t *event;
  59                 esl_event_dup(&event, handle.last_sr_event);
  60                 return new ESLevent(event, 1);
  61         }
  62
  63         return NULL;
  64 }
  65
  66 ESLevent *ESLconnection::api(const char *cmd, const char *arg)
  67 {
  68         size_t len;
  69         char *cmd_buf;
  70
  71         if (!cmd) {
  72                 return NULL;
  73         }
  74
  75         len = strlen(cmd) + (arg ? strlen(arg) : 0) + 10;
  76
  77         cmd_buf = (char *) malloc(len + 1);
  78         assert(cmd_buf);
  79
  80         snprintf(cmd_buf, len, "api %s %s", cmd, arg ? arg : "");
  81         *(cmd_buf + (len)) = '\0';
  82
  83
  84         if (esl_send_recv(&handle, cmd_buf) == ESL_SUCCESS) {
  85                 esl_event_t *event;
  86                 esl_event_dup(&event, handle.last_sr_event);
  87                 return new ESLevent(event, 1);
  88         }
  89
  90         free(cmd_buf);
  91
  92         return NULL;
  93 }
  94
  95 ESLevent *ESLconnection::bgapi(const char *cmd, const char *arg)
  96 {
  97         size_t len;
  98         char *cmd_buf;
  99
 100         if (!cmd) {
 101                 return NULL;
 102         }
 103
 104         len = strlen(cmd) + (arg ? strlen(arg) : 0) + 10;
 105
 106         cmd_buf = (char *) malloc(len + 1);
 107         assert(cmd_buf);
 108
 109         snprintf(cmd_buf, len, "bgapi %s %s", cmd, arg ? arg : "");
 110         *(cmd_buf + (len)) = '\0';
 111
 112         if (esl_send_recv(&handle, cmd_buf) == ESL_SUCCESS) {
 113                 esl_event_t *event;
 114                 esl_event_dup(&event, handle.last_sr_event);
 115                 return new ESLevent(event, 1);
 116         }
 117
 118         free(cmd_buf);
 119
 120         return NULL;
 121 }
 122
 123 ESLevent *ESLconnection::getInfo()
 124 {
 125         if (handle.connected && handle.info_event) {
 126                 esl_event_t *event;
 127                 esl_event_dup(&event, handle.info_event);
 128                 return new ESLevent(event, 1);
 129         }
 130
 131         return NULL;
 132 }
 133
 134 int ESLconnection::setAsyncExecute(const char *val)
 135 {
 136         if (val) {
 137                 handle.async_execute = esl_true(val);
 138         }
 139         return handle.async_execute;
 140 }
 141
 142 int ESLconnection::setEventLock(const char *val)
 143 {
 144         if (val) {
 145                 handle.event_lock = esl_true(val);
 146         }
 147         return handle.event_lock;
 148 }
 149
 150 int ESLconnection::execute(const char *app, const char *arg, const char *uuid)
 151 {
 152         return esl_execute(&handle, app, arg, uuid);
 153 }
 154
 155
 156 int ESLconnection::executeAsync(const char *app, const char *arg, const char *uuid)
 157 {
 158         int async = handle.async_execute;
 159         int r;
 160
 161         handle.async_execute = 1;
 162         r = esl_execute(&handle, app, arg, uuid);
 163         handle.async_execute = async;
 164
 165         return r;
 166 }
 167
 168 int ESLconnection::sendEvent(ESLevent *send_me)
 169 {
 170         return esl_sendevent(&handle, send_me->event);
 171 }
 172
 173 ESLevent *ESLconnection::recvEvent()
 174 {
 175         if (last_event_obj) {
 176                 delete last_event_obj;
 177         }
 178
 179         if (esl_recv_event(&handle, 1, NULL) == ESL_SUCCESS) {
 180                 esl_event_t *e = handle.last_ievent ? handle.last_ievent : handle.last_event;
 181                 if (e) {
 182                         esl_event_t *event;
 183                         esl_event_dup(&event, e);
 184                         last_event_obj = new ESLevent(event, 1);
 185                         return last_event_obj;
 186                 }
 187         }
 188
 189         last_event_obj = new ESLevent("server_disconnected");
 190
 191         return last_event_obj;
 192 }
 193
 194 ESLevent *ESLconnection::recvEventTimed(int ms)
 195 {
 196         if (last_event_obj) {
 197                 delete last_event_obj;
 198                 last_event_obj = NULL;
 199         }
 200
 201         if (esl_recv_event_timed(&handle, ms, 1, NULL) == ESL_SUCCESS) {
 202                 esl_event_t *e = handle.last_ievent ? handle.last_ievent : handle.last_event;
 203                 if (e) {
 204                         esl_event_t *event;
 205                         esl_event_dup(&event, e);
 206                         last_event_obj = new ESLevent(event, 1);
 207                         return last_event_obj;
 208                 }
 209     }
 210
 211         return NULL;
 212 }
 213
 214 ESLevent *ESLconnection::filter(const char *header, const char *value)
 215 {
 216         esl_status_t status = esl_filter(&handle, header, value);
 217
 218         if (status == ESL_SUCCESS && handle.last_sr_event) {
 219                 esl_event_t *event;
 220                 esl_event_dup(&event, handle.last_sr_event);
 221                 return new ESLevent(event, 1);
 222         }
 223
 224         return NULL;
 225
 226 }
 227
 228 int ESLconnection::events(const char *etype, const char *value)
 229 {
 230         esl_event_type_t type_id = ESL_EVENT_TYPE_PLAIN;
 231
 232         if (!strcmp(etype, "xml")) {
 233                 type_id = ESL_EVENT_TYPE_XML;
 234         }
 235
 236         return esl_events(&handle, type_id, value);
 237 }
 238
 239 // ESLevent
 240 ///////////////////////////////////////////////////////////////////////
 241
 242 ESLevent::ESLevent(const char *type, const char *subclass_name)
 243 {
 244         esl_event_types_t event_id;
 245
 246         event_construct_common();
 247
 248         if (esl_name_event(type, &event_id) != ESL_SUCCESS) {
 249                 event_id = ESL_EVENT_MESSAGE;
 250         }
 251
 252         if (!esl_strlen_zero(subclass_name) && event_id != ESL_EVENT_CUSTOM) {
 253                 esl_log(ESL_LOG_WARNING, "Changing event type to custom because you specified a subclass name!\n");
 254                 event_id = ESL_EVENT_CUSTOM;
 255         }
 256
 257         if (esl_event_create_subclass(&event, event_id, subclass_name) != ESL_SUCCESS) {
 258                 esl_log(ESL_LOG_ERROR, "Failed to create event!\n");
 259                 event = NULL;
 260         }
 261
 262         serialized_string = NULL;
 263         mine = 1;
 264 }
 265
 266 ESLevent::ESLevent(esl_event_t *wrap_me, int free_me)
 267 {
 268         event_construct_common();
 269         event = wrap_me;
 270         mine = free_me;
 271         serialized_string = NULL;
 272 }
 273
 274
 275 ESLevent::ESLevent(ESLevent *me)
 276 {
 277         /* workaround for silly php thing */
 278         event = me->event;
 279         mine = me->mine;
 280         serialized_string = NULL;
 281         me->event = NULL;
 282         me->mine = 0;
 283         esl_safe_free(me->serialized_string);
 284 }
 285
 286 ESLevent::~ESLevent()
 287 {
 288
 289         if (serialized_string) {
 290                 free(serialized_string);
 291         }
 292
 293         if (event && mine) {
 294                 esl_event_destroy(&event);
 295         }
 296 }
 297
 298 const char *ESLevent::nextHeader(void)
 299 {
 300         const char *name = NULL;
 301
 302         if (hp) {
 303                 name = hp->name;
 304                 hp = hp->next;
 305         }
 306
 307         return name;
 308 }
 309
 310 const char *ESLevent::firstHeader(void)
 311 {
 312         if (event) {
 313                 hp = event->headers;
 314         }
 315
 316         return nextHeader();
 317 }
 318
 319 const char *ESLevent::serialize(const char *format)
 320 {
 321         this_check("");
 322
 323         esl_safe_free(serialized_string);
 324
 325         if (!event) {
 326                 return "";
 327         }
 328
 329         if (esl_event_serialize(event, &serialized_string, ESL_TRUE) == ESL_SUCCESS) {
 330                 return serialized_string;
 331         }
 332
 333         return "";
 334
 335 }
 336
 337 bool ESLevent::setPriority(esl_priority_t priority)
 338 {
 339         this_check(false);
 340
 341         if (event) {
 342         esl_event_set_priority(event, priority);
 343                 return true;
 344         } else {
 345                 esl_log(ESL_LOG_ERROR, "Trying to setPriority an event that does not exist!\n");
 346     }
 347         return false;
 348 }
 349
 350 const char *ESLevent::getHeader(const char *header_name)
 351 {
 352         this_check("");
 353
 354         if (event) {
 355                 return esl_event_get_header(event, header_name);
 356         } else {
 357                 esl_log(ESL_LOG_ERROR, "Trying to getHeader an event that does not exist!\n");
 358         }
 359         return NULL;
 360 }
 361
 362 bool ESLevent::addHeader(const char *header_name, const char *value)
 363 {
 364         this_check(false);
 365
 366         if (event) {
 367                 return esl_event_add_header_string(event, ESL_STACK_BOTTOM, header_name, value) == ESL_SUCCESS ? true : false;
 368         } else {
 369                 esl_log(ESL_LOG_ERROR, "Trying to addHeader an event that does not exist!\n");
 370         }
 371
 372         return false;
 373 }
 374
 375 bool ESLevent::delHeader(const char *header_name)
 376 {
 377         this_check(false);
 378
 379         if (event) {
 380                 return esl_event_del_header(event, header_name) == ESL_SUCCESS ? true : false;
 381         } else {
 382                 esl_log(ESL_LOG_ERROR, "Trying to delHeader an event that does not exist!\n");
 383         }
 384
 385         return false;
 386 }
 387
 388
 389 bool ESLevent::addBody(const char *value)
 390 {
 391         this_check(false);
 392
 393         if (event) {
 394                 return esl_event_add_body(event, "%s", value) == ESL_SUCCESS ? true : false;
 395         } else {
 396                 esl_log(ESL_LOG_ERROR, "Trying to addBody an event that does not exist!\n");
 397         }
 398
 399         return false;
 400 }
 401
 402 char *ESLevent::getBody(void)
 403 {
 404
 405         this_check((char *)"");
 406
 407         if (event) {
 408                 return esl_event_get_body(event);
 409         } else {
 410                 esl_log(ESL_LOG_ERROR, "Trying to getBody an event that does not exist!\n");
 411         }
 412
 413         return NULL;
 414 }
 415
 416 const char *ESLevent::getType(void)
 417 {
 418         this_check("");
 419
 420         if (event) {
 421                 return esl_event_name(event->event_id);
 422         } else {
 423                 esl_log(ESL_LOG_ERROR, "Trying to getType an event that does not exist!\n");
 424         }
 425
 426         return (char *) "invalid";
 427 }