kopete/protocols/groupwise/libgroupwise/eventprotocol.cpp

   1 /*
   2     Kopete Groupwise Protocol
   3     eventprotocol.cpp - reads the protocol used by GroupWise for signalling Events
   4
   5     Copyright (c) 2004      SUSE Linux AG                http://www.suse.com
   6
   7     Kopete (c) 2002-2004 by the Kopete developers <kopete-devel@kde.org>
   8
   9     *************************************************************************
  10     *                                                                       *
  11     * This library is free software; you can redistribute it and/or         *
  12     * modify it under the terms of the GNU Lesser General Public            *
  13     * License as published by the Free Software Foundation; either          *
  14     * version 2 of the License, or (at your option) any later version.      *
  15     *                                                                       *
  16     *************************************************************************
  17 */
  18
  19 #include <qbuffer.h>
  20
  21 #include "gwerror.h"
  22
  23 #include "eventtransfer.h"
  24 #include "eventprotocol.h"
  25
  26 using namespace GroupWise;
  27
  28 EventProtocol::EventProtocol(QObject *parent)
  29  : InputProtocolBase(parent)
  30 {
  31 }
  32
  33 EventProtocol::~EventProtocol()
  34 {
  35 }
  36
  37 Transfer * EventProtocol::parse( QByteArray & wire, uint& bytes )
  38 {
  39         m_bytes = 0;
  40         //m_din = new QDataStream( wire, QIODevice::ReadOnly );
  41         QBuffer inBuf( &wire );
  42         inBuf.open( QIODevice::ReadOnly);
  43         m_din.setDevice( &inBuf );
  44         m_din.setByteOrder( QDataStream::LittleEndian );
  45         quint32 type;
  46
  47         if ( !okToProceed() )
  48         {
  49                 m_din.unsetDevice();
  50                 return 0;
  51         }
  52         // read the event type
  53         m_din >> type;
  54         m_bytes += sizeof( quint32 );
  55
  56         debug( QString( "EventProtocol::parse() Reading event of type %1" ).arg( type ) );
  57         if ( type > Stop )
  58         {
  59                 debug( QString ( "EventProtocol::parse() - found unexpected event type %1 - assuming out of sync" ).arg( type ) );
  60                 m_state = OutOfSync;
  61                 return 0;
  62         }
  63
  64         // read the event source
  65         QString source;
  66         if ( !readString( source ) )
  67         {
  68                 m_din.unsetDevice();
  69                 return 0;
  70         }
  71
  72         // now create an event object
  73         //HACK: lowercased DN
  74         EventTransfer * tentative = new EventTransfer( type, source.toLower(), QDateTime::currentDateTime() );
  75
  76         // add any additional data depending on the type of event
  77         // Note: if there are any errors in the way the data is read below, we will soon be OutOfSync
  78         QString statusText;
  79         QString guid;
  80         quint16 status;
  81         quint32 flags;
  82         QString message;
  83
  84         switch ( type )
  85         {
  86                 case StatusChange: //103 - STATUS + STATUSTEXT
  87                         if ( !okToProceed() )
  88                         {
  89                                 m_din.unsetDevice();
  90                                 return 0;
  91                         }
  92                         m_din >> status;
  93                         m_bytes += sizeof( quint16 );
  94                         if ( !readString( statusText ) )
  95                         {
  96                                 m_din.unsetDevice();
  97                                 return 0;
  98                         }
  99                         debug( QString( "got status: %1").arg( status ) );
 100                         tentative->setStatus( status );
 101                         debug( QString( "tentative status: %1").arg( tentative->status() ) );
 102                         tentative->setStatusText( statusText );
 103                         break;
 104                 case ConferenceJoined:          // 106 - GUID + FLAGS
 105                 case ConferenceLeft:            // 107
 106                         if ( !readString( guid ) )
 107                         {
 108                                 m_din.unsetDevice();
 109                                 return 0;
 110                         }
 111                         tentative->setGuid( guid );
 112                         if ( !readFlags( flags ) )
 113                         {
 114                                 m_din.unsetDevice();
 115                                 return 0;
 116                         }
 117                         tentative->setFlags( flags );
 118                         break;
 119                 case UndeliverableStatus:       //102 - GUID
 120                 case ConferenceClosed:          //105
 121                 case ConferenceInviteNotify://118
 122                 case ConferenceReject:          //119
 123                 case UserTyping:                        //112
 124                 case UserNotTyping:                     //113
 125                         if ( !readString( guid ) )
 126                         {
 127                                 m_din.unsetDevice();
 128                                 return 0;
 129                         }
 130                         tentative->setGuid( guid );
 131                         break;
 132                 case ReceiveAutoReply:          //121 - GUID + FLAGS + MESSAGE
 133                 case ReceiveMessage:            //108
 134                         // guid
 135                         if ( !readString( guid ) )
 136                         {
 137                                 m_din.unsetDevice();
 138                                 return 0;
 139                         }
 140                         tentative->setGuid( guid );
 141                         // flags
 142                         if ( !readFlags( flags ) )
 143                         {
 144                                 m_din.unsetDevice();
 145                                 return 0;
 146                         }
 147                         tentative->setFlags( flags );
 148                         // message
 149                         if ( !readString( message ) )
 150                         {
 151                                 m_din.unsetDevice();
 152                                 return 0;
 153                         }
 154                         tentative->setMessage( message );
 155                         break;
 156                 case ConferenceInvite:          //117 GUID + MESSAGE
 157                         // guid
 158                         if ( !readString( guid ) )
 159                         {
 160                                 m_din.unsetDevice();
 161                                 return 0;
 162                         }
 163                         tentative->setGuid( guid );
 164                         // message
 165                         if ( !readString( message ) )
 166                         {
 167                                 m_din.unsetDevice();
 168                                 return 0;
 169                         }
 170                         tentative->setMessage( message );
 171                         break;
 172                 case UserDisconnect:            //114 (NOTHING)
 173                 case ServerDisconnect:          //115
 174                         // nothing else to read
 175                         break;
 176                 case InvalidRecipient:          //101
 177                 case ContactAdd:                        //104
 178                 case ReceiveFile:                       //109
 179                 case ConferenceRename:          //116
 180                         // unhandled because unhandled in Gaim
 181                         break;
 182                 /* GW7 */
 183                 case ReceivedBroadcast:         //122
 184                 case ReceivedSystemBroadcast: //123
 185                         // message
 186                         if ( !readString( message ) )
 187                         {
 188                                 m_din.unsetDevice();
 189                                 return 0;
 190                         }
 191                         tentative->setMessage( message );
 192                         break;
 193                 default:
 194                         debug( QString( "EventProtocol::parse() - found unexpected event type %1" ).arg( type ) );
 195                         break;
 196         }
 197         // if we got this far, the parse succeeded, return the Transfer
 198         m_state = Success;
 199         //delete m_din;
 200         bytes = m_bytes;
 201         m_din.unsetDevice();
 202         return tentative;
 203 }
 204
 205 bool EventProtocol::readFlags( quint32 &flags)
 206 {
 207         if ( okToProceed() )
 208         {
 209                 m_din >> flags;
 210                 m_bytes += sizeof( quint32 );
 211                 return true;
 212         }
 213         return false;
 214 }
 215
 216 #include "eventprotocol.moc"