Chat-O-Matic/libs/libmsn/notificationserver.h

550 lines
21 KiB
C
Raw Normal View History

#ifndef __msn_notificationserver_h__
#define __msn_notificationserver_h__
/*
* notificationserver.h
* libmsn
*
* Created by Mark Rowe on Mon Mar 22 2004.
* Refactored by Tiago Salem Herrmann on 08/2007.
* Copyright (c) 2004 Mark Rowe. All rights reserved.
* Copyright (c) 2007 Tiago Salem Herrmann. All rights reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "connection.h"
#include "authdata.h"
#include "errorcodes.h"
#include "buddy.h"
#include "passport.h"
#include <stdexcept>
#include "externals.h"
#include "msnobject.h"
#include "soap.h"
#include <cassert>
#include <sys/types.h>
#include "libmsn_export.h"
#ifdef _WIN32
typedef unsigned uint;
#endif
namespace MSN
{
class SwitchboardServerConnection;
/** Contains information about synchronising the contact list with the server.
*/
class LIBMSN_EXPORT ListSyncInfo
{
public:
/** Constants specifying the status of the list synchronisation.
*/
enum SyncProgress
{
LST_AB = 1, /**< Address book has been received. */
LST_AL = 2, /**< Allow list has been received. */
LST_BL = 4, /**< Block list has been received. */
LST_RL = 8, /**< Reverse list has been received. */
LST_PL = 16, /**< Pending list has been received. */
COMPLETE_BLP = 32 /**< @c BLP has been received. */
};
/** Treat unknown users as if appearing on this list when they attempt
* to initiate a switchboard session.
*/
enum PrivacySetting
{
ALLOW = 'A', /**< Any user can see our status, except those in Block List. */
BLOCK = 'B' /**< Nobody can see our status, except those in Allow List. */
};
/** Action to take when a new user appears on our reverse list.
*/
enum NewReverseListEntryAction
{
PROMPT = 'A',
DONT_PROMPT = 'N'
};
/** A list of people who's statuses we are wish to be notified about.
*/
std::map<std::string, Buddy *> contactList;
std::string myDisplayName;
std::map<std::string, Group> groups;
/** The progress of the sync operation.
*/
unsigned int progress;
unsigned int usersRemaining, groupsRemaining;
/** Last change on Address Book and lists timestamp
*/
std::string lastChange;
/** Specifies the default list for non-buddies to be treated as
* appearing in when attempting to invite you into a switchboard setting.
*
* This corresponds to the @c BLP command in the MSN protocol.
*/
char privacySetting;
/** Specifies whether the user should be prompted when a new buddy
* appears on their reverse list.
*
* This corresponds to the @c GTC command in the MSN protocol.
*/
char reverseListPrompting;
ListSyncInfo(std::string lastChange_) :
progress(0), lastChange(lastChange_),
privacySetting(ListSyncInfo::ALLOW), reverseListPrompting(ListSyncInfo::PROMPT) {};
};
// Intermediate steps in connection:
class LIBMSN_EXPORT connectinfo
{
public:
Passport username;
std::string password;
std::string cookie;
connectinfo(const Passport & username_, const std::string & password_) : username(username_), password(password_), cookie("") {};
};
/** Represents a connection to a MSN notification server.
*
* The MSN notification server is responsible for dealing with the contact
* list, online status, and dispatching message requests or invitations to
* or from switchboard servers.
*/
class LIBMSN_EXPORT NotificationServerConnection : public Connection
{
private:
typedef void (NotificationServerConnection::*NotificationServerCallback)(std::vector<std::string> & args, int trid, void *);
std::string token;
class AuthData : public ::MSN::AuthData
{
public:
std::string password;
AuthData(const Passport & passport_,
const std::string & password_) :
::MSN::AuthData(passport_), password(password_) {} ;
};
NotificationServerConnection::AuthData auth;
int synctrid;
public:
MSNObject msnobj;
/** Create a NotificationServerConnection with the specified @a username and
* @a password.
*/
NotificationServerConnection(Passport username, std::string password, Callbacks & cb);
virtual ~NotificationServerConnection();
virtual void dispatchCommand(std::vector<std::string> & args);
/** Return a list of SwitchboardServerConnection's that have been started
* from this NotificationServerConnection.
*/
const std::vector<SwitchboardServerConnection *> & switchboardConnections();
/* Add a SwitchboardServerConnection to the list of connections that have
* been started from this connection.
*/
void addSwitchboardConnection(SwitchboardServerConnection *);
/* Add the @p Soap object to the list of connections that have
* been started from this connection.
*/
void addSoapConnection(Soap *);
/* Remove a SwitchboardServerConnection from the list of connections that have
* been started from this connection.
*/
void removeSwitchboardConnection(SwitchboardServerConnection *);
/* Remove the @p Soap object from the list of connections that have
* been started from this connection.
*/
void removeSoapConnection(Soap *);
/** Return a connection that is associated with @a fd.
*
* If @a fd is equal to @p sock, @c this is returned. Otherwise
* connectionWithSocket is sent to each SwitchboardServerConnection
* or Soap connections until a match is found.
*
* @return The matching connection, if found. Otherwise, @c NULL.
*/
Connection *connectionWithSocket(void *sock);
/** Return a SwitchboardServerConnection that has exactly one user whose
* username is @a username.
*
* @return The matching SwitchboardServerConnection, or @c NULL.
*/
SwitchboardServerConnection *switchboardWithOnlyUser(Passport username);
/** @name Action Methods
*
* These methods all perform actions on the notification server.
*/
/** @{ */
/** Set our capabilities. This is the sum of MSNClientInformationFields enum fields
*/
void setCapabilities(uint m_clientId);
void disconnectNS();
/** Set our online state to @a state and our capabilites to @a clientID.
*/
void setState(BuddyStatus state, uint clientID);
/** Set Black List policy
*/
void setBLP(char setting);
/** It must be called to complete the connection. Add all your contacts
* to allContacts, (both Forward, allow and block lists). The integer value
* of allContacts is the sum of all lists this contact is present. For example:
* If the contact is both on your allow and forward list, the number must be
* 3 (2+1).
*/
void completeConnection(std::map<std::string,int > & allContacts, void *data);
/** Set our friendly name to @a friendlyName.
*
* @param friendlyName Maximum allowed length is 387 characters after URL-encoding.
*/
void setFriendlyName(std::string friendlyName, bool updateServer = false) throw (std::runtime_error);
/** Points to our display picture. It must be a png file, size: 96x96.
* @param filename Path to the PNG file to be sent as avatar of this contact
*/
bool change_DisplayPicture(std::string filename);
/** Sets our personal info. Current media, personal message...
*/
void setPersonalStatus(personalInfo pInfo);
/** Add buddy named @a buddyName to the list named @a list.
*/
void addToList(MSN::ContactList list, Passport buddyName);
/** Remove buddy named @a buddyName from the list named @a list.
*/
void removeFromList(MSN::ContactList list, Passport buddyName);
/** Add contact @a buddyName to address book with @a displayName
* Automatically adds to allow list too.
*/
void addToAddressBook(Passport buddyName, std::string displayName);
/** Delete contact @a passport with @a contactId from address book.
*/
void delFromAddressBook(std::string contactId, std::string passport);
/** Enable a contact on address book. You will use it when you have disabled
* a contact before. This contact is still on your Address Book, but it is not
* a messenger contact. This function will turn this contact into a messenger
* contact again.
*/
void enableContactOnAddressBook(std::string contactId, std::string passport);
/** Do not delete the contact, just disable it.
*/
void disableContactOnAddressBook(std::string contactId, std::string passport);
/** Block a contact. This user won't be able to see your status anymore.
*/
void blockContact(Passport buddyName);
/** Unblock a contact. This user will be able to see your status again.
*/
void unblockContact(Passport buddyName);
/** Add a contact @a contactId to the group @a groupId .
*/
void addToGroup(std::string groupId, std::string contactId);
/** Remove a contact from a group.
*/
void removeFromGroup(std::string groupId, std::string contactId);
/** Add a new group.
*/
void addGroup(std::string groupName);
/** Remove a group.
*/
void removeGroup(std::string groupId);
/** Rename a group.
*/
void renameGroup(std::string groupId, std::string newGroupName);
/** Request the server side buddy list.
*
* @param lastChange if @a version is specified the server will respond with
* the changes necessary to update the list to the latest
* version. Otherwise the entire list will be sent.
*/
void synchronizeContactList(std::string lastChange="0");
/** Send a 'keep-alive' ping to the server.
*/
void sendPing();
/** Request a switchboard connection.
*/
void requestSwitchboardConnection(const void *tag);
/** Retrieve the Offline Instant Message identified by id
*/
void get_oim(std::string id, bool markAsRead);
/** Erase the Offline Instant Message identified by id
*/
void delete_oim(std::string id);
/** Send an Offline Instant Message
*/
void send_oim(Soap::OIM oim);
void getInboxUrl();
/* when we have to send more than 1 ADL command, we need to keep this here to track */
std::list<std::string> adl_packets;
/* Our current Display Name */
std::string myDisplayName;
/* Our passport */
std::string myPassport;
/* Sum of capabilities of the user */
uint m_clientId;
char bplSetting;
/* Our IP number reported by notification server */
std::string server_reported_ip;
/* Our TCP source port reported by notification server */
std::string server_reported_port;
std::string login_time;
std::string MSPAuth;
std::string sid;
std::string kv;
/* 1 if our email is verified, 0 if not */
std::string server_email_verified;
/* Says if we are direct connected based on server's report */
bool direct_connection;
virtual void connect(const std::string & hostname, unsigned int port);
virtual void connect(const std::string & hostname, unsigned int port,
const Passport & username,
const std::string & password);
virtual void disconnect();
virtual void addCallback(NotificationServerCallback cb, int trid, void *data);
virtual void removeCallback(int trid);
virtual void socketConnectionCompleted();
enum NotificationServerState
{
NS_DISCONNECTED,
NS_CONNECTING,
NS_CONNECTED,
NS_SYNCHRONISING,
NS_ONLINE
};
connectinfo *info;
NotificationServerState connectionState() const { return this->_connectionState; };
Callbacks & externalCallbacks;
virtual NotificationServerConnection *myNotificationServer() { return this; };
void gotTickets(Soap & soapConnection, std::vector<MSN::Soap::sitesToAuth> sitesToAuthList);
void gotLists(Soap &soapConnection);
void gotAddressBook(Soap &soapConnection);
void gotOIM(Soap & soapConnection, bool success, std::string id, std::string message);
void gotOIMLockkey(Soap & soapConnection, std::string lockkey);
void gotOIMSendConfirmation(Soap & soapConnection, int id, bool sent);
void gotOIMDeleteConfirmation(Soap & soapConnection, std::string id, bool deleted);
void gotSoapMailData(Soap & soapConnection, std::string maildata);
void gotChangeDisplayNameConfirmation(Soap & soapConnection, std::string displayName, bool changed);
void gotDelContactFromGroupConfirmation(Soap & soapConnection,
bool deleted,
std::string newVersion,
std::string groupId,
std::string contactId);
void gotAddContactToGroupConfirmation(Soap & soapConnection,
bool added,
std::string newVersion,
std::string groupId,
std::string contactId);
void gotAddGroupConfirmation(Soap & soapConnection,
bool added,
std::string newVersion,
std::string groupName,
std::string groupId);
void gotDelGroupConfirmation(Soap & soapConnection,
bool removed,
std::string newVersion,
std::string groupId);
void gotRenameGroupConfirmation(Soap & soapConnection,
bool renamed,
std::string newVersion,
std::string newGroupName,
std::string groupId);
void gotAddContactToAddressBookConfirmation(Soap & soapConnection,
bool added,
std::string newVersion,
std::string passport,
std::string displayName,
std::string guid);
void gotDelContactFromAddressBookConfirmation(Soap & soapConnection,
bool removed,
std::string newVersion,
std::string contactId,
std::string passport);
void gotEnableContactOnAddressBookConfirmation(Soap & soapConnection,
bool enabled,
std::string newVersion,
std::string contactId,
std::string passport);
void gotDisableContactOnAddressBookConfirmation(Soap & soapConnection,
bool disabled,
std::string newVersion,
std::string contactId,
std::string passport);
void gotAddContactToListConfirmation(Soap & soapConnection,
bool added,
std::string newVersion,
std::string passport,
MSN::ContactList list);
void gotDelContactFromListConfirmation(Soap & soapConnection,
bool deleted,
std::string newVersion,
std::string passport,
MSN::ContactList list);
protected:
virtual void handleIncomingData();
NotificationServerState _connectionState;
void setConnectionState(NotificationServerState s) { this->_connectionState = s; };
void assertConnectionStateIs(NotificationServerState s) { assert(this->_connectionState == s); };
void assertConnectionStateIsNot(NotificationServerState s) { assert(this->_connectionState != s); };
void assertConnectionStateIsAtLeast(NotificationServerState s) { assert(this->_connectionState >= s); };
private:
std::vector<SwitchboardServerConnection *> _switchboardConnections;
std::vector<Soap *> _SoapConnections;
std::map<int, std::pair<NotificationServerCallback, void *> > callbacks;
ListSyncInfo *listInfo;
std::vector<MSN::Soap::sitesToAuth> sitesToAuthList;
std::vector<MSN::Soap::OIM> SentQueuedOIMs;
std::vector<std::string> DeletedQueuedOIMs;
std::string lockkey;
bool generatingLockkey;
bool removingOIM;
void sendQueuedOIMs();
// mdi value got by tweener
std::string mdi;
virtual void disconnectForTransfer();
static std::map<std::string, void (NotificationServerConnection::*)(std::vector<std::string> &)> commandHandlers;
static std::map<std::string, void (NotificationServerConnection::*)(std::vector<std::string> &, std::string, std::string)> messageHandlers;
void registerHandlers();
void handle_OUT(std::vector<std::string> & args);
void handle_RML(std::vector<std::string> & args);
void handle_BLP(std::vector<std::string> & args);
void handle_CHG(std::vector<std::string> & args);
void handle_CHL(std::vector<std::string> & args);
void handle_ILN(std::vector<std::string> & args);
void handle_NLN(std::vector<std::string> & args);
void handle_FLN(std::vector<std::string> & args);
void handle_MSG(std::vector<std::string> & args);
void handle_RNG(std::vector<std::string> & args);
void handle_PRP(std::vector<std::string> & args);
void handle_UBX(std::vector<std::string> & args);
void handle_GCF(std::vector<std::string> & args);
void handle_ADL(std::vector<std::string> & args);
void handle_UBN(std::vector<std::string> & args);
void handle_FQY(std::vector<std::string> & args);
void callback_NegotiateCVR(std::vector<std::string> & args, int trid, void *data);
void callback_TransferToSwitchboard(std::vector<std::string> & args, int trid, void *data);
void callback_RequestUSR(std::vector<std::string> & args, int trid, void *data);
void callback_PassportAuthentication(std::vector<std::string> & args, int trid, void * data);
void callback_AuthenticationComplete(std::vector<std::string> & args, int trid, void * data);
void callback_initialBPL(std::vector<std::string> & args, int trid, void *data);
void callback_URL(std::vector<std::string> & args, int trid, void *data);
void message_initial_email_notification(std::vector<std::string> & args, std::string mime, std::string body);
void message_email_notification(std::vector<std::string> & args, std::string mime, std::string body);
void message_msmsgsprofile(std::vector<std::string> & args, std::string mime, std::string body);
void message_initialmdatanotification(std::vector<std::string> & args, std::string mime, std::string body);
void message_oimnotification(std::vector<std::string> & args, std::string mime, std::string body);
void gotMailData(std::string maildata);
};
}
#endif