XmlRpcInterface.h

Go to the documentation of this file.

//
// Copyright (C) 2007 Institut fuer Telematik, Universitaet Karlsruhe (TH)
//
// 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.
//

#ifndef _XMLRPCINTERFACE_H__
#define _XMLRPCINTERFACE_H__

#include <tunoutscheduler.h>
#include <realtimescheduler.h>
#include <omnetpp.h>
#include <CommonMessages_m.h>
#include <DHTMessage_m.h>
#include <BaseOverlay.h>
#include <BaseApp.h>
#include <XmlRpc.h>

class P2pns;

const int XMLRPC_TIMEOUT=30;


class XmlRpcInterface : public BaseApp, public XmlRpc::XmlRpcServer
{
protected:
    unsigned int mtu;

    cMessage* packetNotification; // used by TunOutScheduler to notify about new packets
    PacketBuffer packetBuffer; // received packets are stored here
    RealtimeScheduler* scheduler;

    bool readHeader(char *buf, uint32_t length);

    bool readRequest(char *buf, uint32_t length);

    bool writeResponse();

    enum ServerConnectionState { READ_HEADER, READ_REQUEST, EXECUTE_REQUEST,
                             WRITE_RESPONSE };

    struct XmlRpcConnectionState {
        ServerConnectionState _connectionState;

        std::string _header;

        int _contentLength;

        std::string _request;

        std::string _response;

        int _bytesWritten;

        bool _keepAlive;

        SOCKET appFd;

        bool localhost;

        uint32_t pendingRpc;
    };

    std::map<int, XmlRpcConnectionState> state;
    SOCKET curAppFd;
    bool limitAccess;

    XmlRpc::XmlRpcServerMethod* _localLookup;
    XmlRpc::XmlRpcServerMethod* _lookup;
    XmlRpc::XmlRpcServerMethod* _register;
    XmlRpc::XmlRpcServerMethod* _resolve;
    XmlRpc::XmlRpcServerMethod* _put;
    XmlRpc::XmlRpcServerMethod* _get;
    XmlRpc::XmlRpcServerMethod* _dumpDht;
    XmlRpc::XmlRpcServerMethod* _joinOverlay;

    // SODESSON interface
    XmlRpc::XmlRpcServerMethod* _addContact;
    XmlRpc::XmlRpcServerMethod* _removeContact;
    XmlRpc::XmlRpcServerMethod* _getContacts;
    XmlRpc::XmlRpcServerMethod* _getUserId;
    XmlRpc::XmlRpcServerMethod* _searchContact;
    XmlRpc::XmlRpcServerMethod* _publish;
    XmlRpc::XmlRpcServerMethod* _pull_notification;
    XmlRpc::XmlRpcServerMethod* _subscribe;

    bool isPrivileged();

    void handleAppTunPacket(char *buf, uint32_t len);
    void handleRealworldPacket(char *buf, uint32_t len);
    void handleCommonAPIPacket(cMessage *msg);
    void handleRpcResponse(BaseResponseMessage* msg,
                           cPolymorphic* context,
                           int rpcId,
                           simtime_t rtt);
    void resetConnectionState();

    void closeConnection();
    void sendInternalRpcWithTimeout(CompType destComp, BaseCallMessage *call);
    virtual void handleReadyMessage(CompReadyMessage* msg);

    SOCKET appTunFd; 
    P2pns* p2pns; 
public:
    XmlRpcInterface();
    ~XmlRpcInterface();

    virtual void initializeApp(int stage);

    virtual void handleMessage(cMessage *msg);

    // see BaseRpc.cc
    void handleRpcTimeout(BaseCallMessage* msg,
                          const TransportAddress& dest,
                          cPolymorphic* context, int rpcId,
                          const OverlayKey&);

    void deliverTunneledMessage(const BinaryValue& payload);

    void localLookup(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);
    void lookup(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);
    void p2pnsRegister(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);
    void p2pnsResolve(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);
    void put(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);
    void get(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);
    void dumpDht(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);
    void joinOverlay(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);

};

#endif