libpurple/protocols/novell/nmevent.c

   1 /*
   2  * nmevent.c
   3  *
   4  * Copyright (c) 2004 Novell, Inc. All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA        02111-1301      USA
  18  *
  19  */
  20
  21 #include <glib.h>
  22 #include <string.h>
  23 #include <time.h>
  24 #include "nmevent.h"
  25 #include "nmfield.h"
  26 #include "nmconn.h"
  27 #include "nmuserrecord.h"
  28 #include "nmrtf.h"
  29
  30 #define MAX_UINT32 0xFFFFFFFF
  31
  32 struct _NMEvent
  33 {
  34
  35         /* Event type */
  36         int type;
  37
  38         /* The DN of the event source */
  39         char *source;
  40
  41         /* Timestamp of the event */
  42         guint32 gmt;
  43
  44         /* Conference to associate with the event */
  45         NMConference *conference;
  46
  47         /* User record to associate with the event */
  48         NMUserRecord *user_record;
  49
  50         /* Text associated with the event */
  51         char *text;
  52
  53         /* Reference count for event structure */
  54         int ref_count;
  55
  56 };
  57
  58 /* Handle getdetails response and set the new user record into the event */
  59 static void
  60 _got_user_for_event(NMUser * user, NMERR_T ret_val,
  61                                         gpointer resp_data, gpointer user_data)
  62 {
  63         NMUserRecord *user_record;
  64         NMEvent *event;
  65         nm_event_cb cb;
  66
  67         if (user == NULL)
  68                 return;
  69
  70         user_record = resp_data;
  71         event = user_data;
  72
  73         if (ret_val == NM_OK) {
  74                 if (event && user_record) {
  75
  76                         /* Add the user record to the event structure
  77                          * and make the callback.
  78                          */
  79                         nm_event_set_user_record(event, user_record);
  80                         if ((cb = nm_user_get_event_callback(user))) {
  81                                 cb(user, event);
  82                         }
  83                 }
  84
  85         } else {
  86                 /* Cleanup resp_data */
  87
  88         }
  89
  90         /* Clean up */
  91         if (event)
  92                 nm_release_event(event);
  93
  94 }
  95
  96 /* Handle getdetails response, set the new user record into the event
  97  * and add the user record as a participant in the conference
  98  */
  99 static void
 100 _got_user_for_conference(NMUser * user, NMERR_T ret_val,
 101                                                  gpointer resp_data, gpointer user_data)
 102 {
 103         NMUserRecord *user_record = resp_data;
 104         NMEvent *event = user_data;
 105         NMConference *conference;
 106         nm_event_cb cb;
 107
 108         if (user == NULL)
 109                 return;
 110
 111         if (event && user_record) {
 112
 113                 conference = nm_event_get_conference(event);
 114                 if (conference) {
 115
 116                         /* Add source of event as recip of the conference */
 117                         nm_conference_add_participant(conference, user_record);
 118
 119                         /* Add the user record to the event structure
 120                          * and make the callback.
 121                          */
 122                         nm_event_set_user_record(event, user_record);
 123                         if ((cb = nm_user_get_event_callback(user))) {
 124                                 cb(user, event);
 125                         }
 126                 }
 127         }
 128
 129         if (event)
 130                 nm_release_event(event);
 131 }
 132
 133 /* Read the receive message event, set up the event object, and
 134  * get details for the event source if we don't have them yet.
 135  */
 136 static NMERR_T
 137 handle_receive_message(NMUser * user, NMEvent * event, gboolean autoreply)
 138 {
 139         NMConference *conference;
 140         NMUserRecord *user_record;
 141         NMConn *conn;
 142         NMERR_T rc = NM_OK;
 143         guint32 size = 0, flags = 0;
 144         char *msg = NULL;
 145         char *nortf = NULL;
 146         char *guid = NULL;
 147
 148         conn = nm_user_get_conn(user);
 149
 150         /* Read the conference guid */
 151         rc = nm_read_uint32(conn, &size);
 152         if (size > 1000)        return NMERR_PROTOCOL;
 153
 154         if (rc == NM_OK) {
 155                 guid = g_new0(char, size + 1);
 156                 rc = nm_read_all(conn, guid, size);
 157         }
 158
 159         /* Read the conference flags */
 160         if (rc == NM_OK) {
 161                 rc = nm_read_uint32(conn, &flags);
 162         }
 163
 164         /* Read the message text */
 165         if (rc == NM_OK) {
 166                 rc = nm_read_uint32(conn, &size);
 167                 if (size > 100000)      return NMERR_PROTOCOL;
 168
 169                 if (rc == NM_OK) {
 170                         msg = g_new0(char, size + 1);
 171                         rc = nm_read_all(conn, msg, size);
 172
 173                         purple_debug(PURPLE_DEBUG_INFO, "novell", "Message is %s\n", msg);
 174
 175                         /* Auto replies are not in RTF format! */
 176                         if (!autoreply) {
 177                                 NMRtfContext *ctx;
 178
 179                                 ctx = nm_rtf_init();
 180                                 nortf = nm_rtf_strip_formatting(ctx, msg);
 181                                 nm_rtf_deinit(ctx);
 182
 183                                 purple_debug(PURPLE_DEBUG_INFO, "novell",
 184                                                    "Message without RTF is %s\n", nortf);
 185
 186                                 /* Store the event data */
 187                                 nm_event_set_text(event, nortf);
 188
 189                         } else {
 190
 191                                 /* Store the event data */
 192                                 nm_event_set_text(event, msg);
 193                         }
 194                 }
 195         }
 196
 197         /* Check to see if we already know about the conference */
 198         conference = nm_conference_list_find(user, guid);
 199         if (conference) {
 200
 201                 nm_conference_set_flags(conference, flags);
 202                 nm_event_set_conference(event, conference);
 203
 204                 /* Add a reference to the user record in our event object */
 205                 user_record = nm_find_user_record(user, nm_event_get_source(event));
 206                 if (user_record) {
 207                         nm_event_set_user_record(event, user_record);
 208                 }
 209
 210         } else {
 211
 212                 /* This is a new conference, so create one and add it to our list */
 213                 conference = nm_create_conference(guid);
 214                 nm_conference_set_flags(conference, flags);
 215
 216                 /* Add a reference to the conference in the event */
 217                 nm_event_set_conference(event, conference);
 218
 219                 /* Add new conference to the conference list */
 220                 nm_conference_list_add(user, conference);
 221
 222                 /* Check to see if we have details for the event source yet */
 223                 user_record = nm_find_user_record(user, nm_event_get_source(event));
 224                 if (user_record) {
 225
 226                         /* We do so add the user record as a recipient of the conference */
 227                         nm_conference_add_participant(conference, user_record);
 228
 229                         /* Add a reference to the user record in our event object */
 230                         nm_event_set_user_record(event, user_record);
 231
 232                 } else {
 233
 234                         /* Need to go to the server to get details for the user */
 235                         rc = nm_send_get_details(user, nm_event_get_source(event),
 236                                                                          _got_user_for_conference, event);
 237                         if (rc == NM_OK)
 238                                 rc = -1;                /* Not done processing the event yet! */
 239                 }
 240
 241                 nm_release_conference(conference);
 242         }
 243
 244         g_free(msg);
 245         g_free(nortf);
 246         g_free(guid);
 247
 248         return rc;
 249 }
 250
 251 /* Read the invite event, set up the event object, and
 252  * get details for the event source if we don't have them yet.
 253  */
 254 static NMERR_T
 255 handle_conference_invite(NMUser * user, NMEvent * event)
 256 {
 257         NMERR_T rc = NM_OK;
 258         guint32 size = 0;
 259         char *guid = NULL;
 260         char *msg = NULL;
 261         NMConn *conn;
 262         NMUserRecord *user_record;
 263
 264         conn = nm_user_get_conn(user);
 265
 266         /* Read the conference guid */
 267         rc = nm_read_uint32(conn, &size);
 268         if (size > 1000)        return NMERR_PROTOCOL;
 269
 270         if (rc == NM_OK) {
 271                 guid = g_new0(char, size + 1);
 272                 rc = nm_read_all(conn, guid, size);
 273         }
 274
 275         /* Read the the message */
 276         if (rc == NM_OK) {
 277                 rc = nm_read_uint32(conn, &size);
 278                 if (size > 100000)      return NMERR_PROTOCOL;
 279
 280                 if (rc == NM_OK) {
 281                         msg = g_new0(char, size + 1);
 282                         rc = nm_read_all(conn, msg, size);
 283                 }
 284         }
 285
 286         /* Store the event data */
 287         if (rc == NM_OK) {
 288                 NMConference *conference;
 289
 290                 nm_event_set_text(event, msg);
 291
 292                 conference = nm_conference_list_find(user, guid);
 293                 if (conference == NULL) {
 294                         conference = nm_create_conference(guid);
 295
 296                         /* Add new conference to the list and the event */
 297                         nm_conference_list_add(user, conference);
 298                         nm_event_set_conference(event, conference);
 299
 300                         /* Check to see if we have details for the event source yet */
 301                         user_record = nm_find_user_record(user, nm_event_get_source(event));
 302                         if (user_record) {
 303
 304                                 /* Add a reference to the user record in our event object */
 305                                 nm_event_set_user_record(event, user_record);
 306
 307                         } else {
 308
 309                                 /* Need to go to the server to get details for the user */
 310                                 rc = nm_send_get_details(user, nm_event_get_source(event),
 311                                                                                  _got_user_for_event, event);
 312                                 if (rc == NM_OK)
 313                                         rc = -1;        /* Not done processing the event yet! */
 314                         }
 315
 316                         nm_release_conference(conference);
 317
 318                 }
 319         }
 320
 321         g_free(msg);
 322         g_free(guid);
 323
 324         return rc;
 325 }
 326
 327 /* Read the invite notify event, set up the event object, and
 328  * get details for the event source if we don't have them yet.
 329  */
 330 static NMERR_T
 331 handle_conference_invite_notify(NMUser * user, NMEvent * event)
 332 {
 333         NMERR_T rc = NM_OK;
 334         guint32 size = 0;
 335         char *guid = NULL;
 336         NMConn *conn;
 337         NMConference *conference;
 338         NMUserRecord *user_record;
 339
 340         conn = nm_user_get_conn(user);
 341
 342         /* Read the conference guid */
 343         rc = nm_read_uint32(conn, &size);
 344         if (size > 1000)        return NMERR_PROTOCOL;
 345
 346         if (rc == NM_OK) {
 347                 guid = g_new0(char, size + 1);
 348                 rc = nm_read_all(conn, guid, size);
 349         }
 350
 351         conference = nm_conference_list_find(user, guid);
 352         if (conference) {
 353                 nm_event_set_conference(event, conference);
 354
 355                 /* Check to see if we have details for the event source yet */
 356                 user_record = nm_find_user_record(user, nm_event_get_source(event));
 357                 if (user_record) {
 358
 359                         /* Add a reference to the user record in our event object */
 360                         nm_event_set_user_record(event, user_record);
 361
 362                 } else {
 363
 364                         /* Need to go to the server to get details for the user */
 365                         rc = nm_send_get_details(user, nm_event_get_source(event),
 366                                                                          _got_user_for_event, event);
 367                         if (rc == NM_OK)
 368                                 rc = -1;                /* Not done processing the event yet! */
 369                 }
 370
 371         } else {
 372                 rc = NMERR_CONFERENCE_NOT_FOUND;
 373         }
 374
 375
 376         g_free(guid);
 377
 378         return rc;
 379 }
 380
 381 /* Read the conference reject event and set up the event object */
 382 static NMERR_T
 383 handle_conference_reject(NMUser * user, NMEvent * event)
 384 {
 385         NMERR_T rc = NM_OK;
 386         guint32 size = 0;
 387         char *guid = NULL;
 388         NMConn *conn;
 389         NMConference *conference;
 390
 391         conn = nm_user_get_conn(user);
 392
 393         /* Read the conference guid */
 394         rc = nm_read_uint32(conn, &size);
 395         if (size > 1000)        return NMERR_PROTOCOL;
 396
 397         if (rc == NM_OK) {
 398                 guid = g_new0(char, size + 1);
 399                 rc = nm_read_all(conn, guid, size);
 400         }
 401
 402         if (rc == NM_OK) {
 403                 conference = nm_conference_list_find(user, guid);
 404                 if (conference) {
 405                         nm_event_set_conference(event, conference);
 406                 } else {
 407                         rc = NMERR_CONFERENCE_NOT_FOUND;
 408                 }
 409         }
 410
 411         g_free(guid);
 412
 413         return rc;
 414 }
 415
 416 /* Read the conference left event, set up the event object, and
 417  * remove the conference from the list if there are no more
 418  * participants
 419  */
 420 static NMERR_T
 421 handle_conference_left(NMUser * user, NMEvent * event)
 422 {
 423         NMERR_T rc = NM_OK;
 424         guint32 size = 0, flags = 0;
 425         char *guid = NULL;
 426         NMConference *conference;
 427         NMConn *conn;
 428
 429         conn = nm_user_get_conn(user);
 430
 431         /* Read the conference guid */
 432         rc = nm_read_uint32(conn, &size);
 433         if (size > 1000)        return NMERR_PROTOCOL;
 434
 435         if (rc == NM_OK) {
 436                 guid = g_new0(char, size + 1);
 437                 rc = nm_read_all(conn, guid, size);
 438         }
 439
 440         /* Read the conference flags */
 441         if (rc == NM_OK) {
 442                 rc = nm_read_uint32(conn, &flags);
 443         }
 444
 445         if (rc == NM_OK) {
 446                 conference = nm_conference_list_find(user, guid);
 447                 if (conference) {
 448                         nm_event_set_conference(event, conference);
 449                         nm_conference_set_flags(conference, flags);
 450
 451                         nm_conference_remove_participant(conference, nm_event_get_source(event));
 452                         if (nm_conference_get_participant_count(conference) == 0) {
 453                                 nm_conference_list_remove(user, conference);
 454                         }
 455
 456                 } else {
 457                         rc = NMERR_CONFERENCE_NOT_FOUND;
 458                 }
 459         }
 460
 461         g_free(guid);
 462
 463         return rc;
 464 }
 465
 466 /* Read the conference closed, set up the event object, and
 467  * remove the conference from the list
 468  */
 469 static NMERR_T
 470 handle_conference_closed(NMUser * user, NMEvent * event)
 471 {
 472         NMERR_T rc = NM_OK;
 473         guint32 size = 0;
 474         char *guid = NULL;
 475         NMConference *conference;
 476         NMConn *conn;
 477
 478         conn = nm_user_get_conn(user);
 479
 480         /* Read the conference guid */
 481         rc = nm_read_uint32(conn, &size);
 482         if (size > 1000)        return NMERR_PROTOCOL;
 483
 484         if (rc == NM_OK) {
 485                 guid = g_new0(char, size + 1);
 486                 rc = nm_read_all(conn, guid, size);
 487         }
 488
 489         if (rc == NM_OK) {
 490                 conference = nm_conference_list_find(user, guid);
 491                 if (conference) {
 492                         nm_event_set_conference(event, conference);
 493                         nm_conference_list_remove(user, conference);
 494                 } else {
 495                         rc = NMERR_CONFERENCE_NOT_FOUND;
 496                 }
 497         }
 498
 499         g_free(guid);
 500
 501         return rc;
 502 }
 503
 504 /* Read the conference joined event, set up the event object, and
 505  * get details for the event source if we don't have them yet.
 506  */
 507 static NMERR_T
 508 handle_conference_joined(NMUser * user, NMEvent * event)
 509 {
 510         NMERR_T rc = NM_OK;
 511         guint32 size = 0, flags = 0;
 512         char *guid = NULL;
 513         NMConn *conn;
 514         NMConference *conference;
 515         NMUserRecord *user_record;
 516
 517         conn = nm_user_get_conn(user);
 518
 519         /* Read the conference guid */
 520         rc = nm_read_uint32(conn, &size);
 521         if (size > 1000)        return NMERR_PROTOCOL;
 522
 523         if (rc == NM_OK) {
 524                 guid = g_new0(char, size + 1);
 525                 rc = nm_read_all(conn, guid, size);
 526         }
 527
 528         /* Read the conference flags */
 529         if (rc == NM_OK) {
 530                 rc = nm_read_uint32(conn, &flags);
 531         }
 532
 533         if (rc == NM_OK) {
 534                 conference = nm_conference_list_find(user, guid);
 535                 if (conference) {
 536                         nm_conference_set_flags(conference, flags);
 537
 538                         nm_event_set_conference(event, conference);
 539
 540                         /* Add the new user to the participants list */
 541                         user_record = nm_find_user_record(user, nm_event_get_source(event));
 542                         if (user_record) {
 543                                 nm_conference_remove_participant(conference,
 544                                                                                                  nm_user_record_get_dn(user_record));
 545                                 nm_conference_add_participant(conference, user_record);
 546                         } else {
 547
 548                                 /* Need to go to the server to get details for the user */
 549                                 rc = nm_send_get_details(user, nm_event_get_source(event),
 550                                                                                  _got_user_for_conference, event);
 551                                 if (rc == NM_OK)
 552                                         rc = -1;                /* Not done processing the event yet! */
 553                         }
 554
 555                 } else {
 556                         rc = NMERR_CONFERENCE_NOT_FOUND;
 557                 }
 558         }
 559
 560         g_free(guid);
 561
 562         return rc;
 563 }
 564
 565 /* Read the typing event and set up the event object */
 566 static NMERR_T
 567 handle_typing(NMUser * user, NMEvent * event)
 568 {
 569         NMERR_T rc = NM_OK;
 570         guint32 size = 0;
 571         char *guid = NULL;
 572         NMConference *conference;
 573         NMConn *conn;
 574
 575         conn = nm_user_get_conn(user);
 576
 577         /* Read the conference guid */
 578         rc = nm_read_uint32(conn, &size);
 579         if (size > 1000)        return NMERR_PROTOCOL;
 580
 581         if (rc == NM_OK) {
 582                 guid = g_new0(char, size + 1);
 583                 rc = nm_read_all(conn, guid, size);
 584         }
 585
 586         if (rc == NM_OK) {
 587                 conference = nm_conference_list_find(user, guid);
 588                 if (conference) {
 589                         nm_event_set_conference(event, conference);
 590                 } else {
 591                         rc = NMERR_CONFERENCE_NOT_FOUND;
 592                 }
 593         }
 594
 595         g_free(guid);
 596
 597         return rc;
 598 }
 599
 600 /* Read the event, set up the event object, and update
 601  * the status in the user record (for the event source)
 602  */
 603 static NMERR_T
 604 handle_status_change(NMUser * user, NMEvent * event)
 605 {
 606         NMERR_T rc = NM_OK;
 607         guint16 status;
 608         guint32 size;
 609         char *text = NULL;
 610         NMUserRecord *user_record;
 611         NMConn *conn;
 612
 613         conn = nm_user_get_conn(user);
 614
 615         /* Read new status */
 616         rc = nm_read_uint16(conn, &status);
 617         if (rc == NM_OK) {
 618
 619                 /* Read the status text */
 620                 rc = nm_read_uint32(conn, &size);
 621                 if (size > 10000)       return NMERR_PROTOCOL;
 622
 623                 if (rc == NM_OK) {
 624                         text = g_new0(char, size + 1);
 625                         rc = nm_read_all(conn, text, size);
 626                 }
 627         }
 628
 629         if (rc == NM_OK) {
 630                 nm_event_set_text(event, text);
 631
 632                 /* Get a reference to the user record and store the new status */
 633                 user_record = nm_find_user_record(user, nm_event_get_source(event));
 634                 if (user_record) {
 635                         nm_event_set_user_record(event, user_record);
 636                         nm_user_record_set_status(user_record, status, text);
 637                 }
 638         }
 639
 640         g_free(text);
 641
 642         return rc;
 643 }
 644
 645 /* Read the undeliverable event */
 646 static NMERR_T
 647 handle_undeliverable_status(NMUser * user, NMEvent * event)
 648 {
 649         NMERR_T rc = NM_OK;
 650         guint32 size = 0;
 651         char *guid = NULL;
 652         NMConn *conn;
 653
 654         conn = nm_user_get_conn(user);
 655
 656         /* Read the conference guid */
 657         rc = nm_read_uint32(conn, &size);
 658         if (size > 1000)        return NMERR_PROTOCOL;
 659
 660         if (rc == NM_OK) {
 661                 guid = g_new0(char, size + 1);
 662                 rc = nm_read_all(conn, guid, size);
 663         }
 664
 665         g_free(guid);
 666
 667         return rc;
 668 }
 669
 670 /*******************************************************************************
 671  * Event API -- see header file for comments
 672  ******************************************************************************/
 673
 674 NMEvent *
 675 nm_create_event(int type, const char *source, guint32 gmt)
 676 {
 677         NMEvent *event = g_new0(NMEvent, 1);
 678
 679         event->type = type;
 680         event->gmt = gmt;
 681
 682         if (source)
 683                 event->source = g_strdup(source);
 684
 685         event->ref_count = 1;
 686
 687         return event;
 688 }
 689
 690 void
 691 nm_release_event(NMEvent * event)
 692 {
 693         if (event == NULL) {
 694                 return;
 695         }
 696
 697         if (--(event->ref_count) == 0) {
 698
 699                 g_free(event->source);
 700
 701                 if (event->conference)
 702                         nm_release_conference(event->conference);
 703
 704                 if (event->user_record)
 705                         nm_release_user_record(event->user_record);
 706
 707                 g_free(event->text);
 708
 709                 g_free(event);
 710         }
 711 }
 712
 713
 714 NMConference *
 715 nm_event_get_conference(NMEvent * event)
 716 {
 717         if (event)
 718                 return event->conference;
 719         else
 720                 return NULL;
 721 }
 722
 723 void
 724 nm_event_set_conference(NMEvent * event, NMConference * conference)
 725 {
 726         if (event && conference) {
 727                 nm_conference_add_ref(conference);
 728                 event->conference = conference;
 729         }
 730 }
 731
 732 NMUserRecord *
 733 nm_event_get_user_record(NMEvent * event)
 734 {
 735         if (event)
 736                 return event->user_record;
 737         else
 738                 return NULL;
 739 }
 740
 741 void
 742 nm_event_set_user_record(NMEvent * event, NMUserRecord * user_record)
 743 {
 744         if (event && user_record) {
 745                 nm_user_record_add_ref(user_record);
 746                 event->user_record = user_record;
 747         }
 748 }
 749
 750 const char *
 751 nm_event_get_text(NMEvent * event)
 752 {
 753         if (event)
 754                 return event->text;
 755         else
 756                 return NULL;
 757 }
 758
 759 void
 760 nm_event_set_text(NMEvent * event, const char *text)
 761 {
 762         if (event) {
 763                 if (text)
 764                         event->text = g_strdup(text);
 765                 else
 766                         event->text = NULL;
 767         }
 768 }
 769
 770 const char *
 771 nm_event_get_source(NMEvent * event)
 772 {
 773         if (event)
 774                 return event->source;
 775         else
 776                 return NULL;
 777 }
 778
 779 int
 780 nm_event_get_type(NMEvent * event)
 781 {
 782         if (event)
 783                 return event->type;
 784         else
 785                 return -1;
 786 }
 787
 788 time_t
 789 nm_event_get_gmt(NMEvent * event)
 790 {
 791         if (event)
 792                 return event->gmt;
 793         else
 794                 return (time_t)-1;
 795 }
 796
 797 NMERR_T
 798 nm_process_event(NMUser * user, int type)
 799 {
 800         NMERR_T rc = NM_OK;
 801         guint32 size = 0;
 802         NMEvent *event = NULL;
 803         char *source = NULL;
 804         nm_event_cb cb;
 805         NMConn *conn;
 806
 807         if (user == NULL)
 808                 return NMERR_BAD_PARM;
 809
 810         if (type < NMEVT_START || type > NMEVT_STOP)
 811                 return NMERR_PROTOCOL;
 812
 813         conn = nm_user_get_conn(user);
 814
 815         /* Read the event source */
 816         rc = nm_read_uint32(conn, &size);
 817         if (rc == NM_OK) {
 818                 if (size > 1000000) {
 819                         /* Size is larger than our 1MB sanity check. Ignore it. */
 820                         rc = NMERR_PROTOCOL;
 821                 } else {
 822                         source = g_new0(char, size);
 823
 824                         rc = nm_read_all(conn, source, size);
 825                 }
 826         }
 827
 828         /* Read the event data */
 829         if (rc == NM_OK) {
 830                 event = nm_create_event(type, source, time(0));
 831
 832                 if (event) {
 833
 834                         switch (type) {
 835                         case NMEVT_STATUS_CHANGE:
 836                                 rc = handle_status_change(user, event);
 837                                 break;
 838
 839                         case NMEVT_RECEIVE_MESSAGE:
 840                                 rc = handle_receive_message(user, event, FALSE);
 841                                 break;
 842
 843                         case NMEVT_RECEIVE_AUTOREPLY:
 844                                 rc = handle_receive_message(user, event, TRUE);
 845                                 break;
 846
 847                         case NMEVT_USER_TYPING:
 848                         case NMEVT_USER_NOT_TYPING:
 849                                 rc = handle_typing(user, event);
 850                                 break;
 851
 852                         case NMEVT_CONFERENCE_LEFT:
 853                                 rc = handle_conference_left(user, event);
 854                                 break;
 855
 856                         case NMEVT_CONFERENCE_CLOSED:
 857                                 rc = handle_conference_closed(user, event);
 858                                 break;
 859
 860                         case NMEVT_CONFERENCE_JOINED:
 861                                 rc = handle_conference_joined(user, event);
 862                                 break;
 863
 864                         case NMEVT_CONFERENCE_INVITE:
 865                                 rc = handle_conference_invite(user, event);
 866                                 break;
 867
 868                         case NMEVT_CONFERENCE_REJECT:
 869                                 rc = handle_conference_reject(user, event);
 870                                 break;
 871
 872                         case NMEVT_CONFERENCE_INVITE_NOTIFY:
 873                                 rc = handle_conference_invite_notify(user, event);
 874                                 break;
 875
 876                         case NMEVT_UNDELIVERABLE_STATUS:
 877                                 rc = handle_undeliverable_status(user, event);
 878                                 break;
 879
 880                         case NMEVT_INVALID_RECIPIENT:
 881                                 /* Nothing else to read, just callback */
 882                                 break;
 883
 884                         case NMEVT_USER_DISCONNECT:
 885                                 /* Nothing else to read, just callback */
 886                                 break;
 887
 888                         case NMEVT_SERVER_DISCONNECT:
 889                                 /* Nothing else to read, just callback */
 890                                 break;
 891
 892                         case NMEVT_RECEIVE_FILE:
 893                         case NMEVT_CONTACT_ADD:
 894                                 /* Safely ignored for now */
 895                                 break;
 896
 897                         default:
 898                                 purple_debug(PURPLE_DEBUG_INFO, "novell",
 899                                                    "Unknown event %d received.\n", type);
 900                                 rc = NMERR_PROTOCOL;
 901                                 break;
 902                         }
 903                 }
 904         }
 905
 906         if (rc == (NMERR_T)-1) {
 907                 /* -1 means that we are not ready to callback yet. */
 908                 rc = NM_OK;
 909         } else if (rc == NM_OK && (cb = nm_user_get_event_callback(user))) {
 910
 911                 cb(user, event);
 912
 913                 if (event)
 914                         nm_release_event(event);
 915         } else {
 916                 if (event)
 917                         nm_release_event(event);
 918         }
 919
 920         /* Cleanup */
 921         g_free(source);
 922
 923         return rc;
 924 }