Index: src/mlx/acars.py
===================================================================
--- src/mlx/acars.py	(revision 743)
+++ src/mlx/acars.py	(revision 298)
@@ -25,5 +25,5 @@
         self.state = state
         self.bookedFlight = gui.bookedFlight
-
+        
         self.blockTime = 0 if flight.blockTimeStart is None \
                          else aircraft.state.timestamp - flight.blockTimeStart
@@ -48,26 +48,4 @@
         else:
             return "Landed"
-
-    def _serialize(self):
-        """Serialize the ACARS object for JSON-RPC."""
-        bookedFlight = self.bookedFlight
-        state = self.state
-
-        attrs = {}
-        attrs["longitude"] = state.longitude
-        attrs["latitude"] = state.latitude
-        attrs["pilotName"] = self.pilotName
-        attrs["numPassengers"] = bookedFlight.numPassengers
-        attrs["blockTime"] = self.getBlockTimeText()
-        attrs["callsign"] = bookedFlight.callsign
-        attrs["aircraftTypeName"] = bookedFlight.aircraftTypeName
-        attrs["departureICAO"] = bookedFlight.departureICAO
-        attrs["arrivalICAO"] = bookedFlight.arrivalICAO
-        attrs["altitude"] = state.altitude
-        attrs["groundSpeed"] = state.groundSpeed
-        attrs["event"] = self.getEventText()
-        attrs["tailNumber"] = bookedFlight.tailNumber
-
-        return ([], attrs)
-
+        
 #------------------------------------------------------------------------------
Index: src/mlx/common.py
===================================================================
--- src/mlx/common.py	(revision 740)
+++ src/mlx/common.py	(revision 651)
@@ -15,8 +15,4 @@
 # used, which is the default on Windows or when the \c FORCE_PYGTK environment
 # variable is set.
-
-#---------------------------------------------------------------------------------------
-
-MAVA_BASE_URL = os.environ.get("MAVA_BASE_URL", "http://virtualairlines.hu")
 
 #-------------------------------------------------------------------------------
Index: src/mlx/config.py
===================================================================
--- src/mlx/config.py	(revision 738)
+++ src/mlx/config.py	(revision 733)
@@ -258,5 +258,4 @@
         if secondaryInstallation:
             self._updateURL += "/exp"
-        self._useRPC = True
 
         self._messageTypeLevels = {}
@@ -667,16 +666,4 @@
         if updateURL!=self._updateURL:
             self._updateURL = updateURL
-            self._modified = True
-
-    @property
-    def useRPC(self):
-        """Determine if RPC calls should be used."""
-        return self._useRPC
-
-    @useRPC.setter
-    def useRPC(self, useRPC):
-        """Set whether RPC calls should be used."""
-        if useRPC!=self._useRPC:
-            self._useRPC = useRPC
             self._modified = True
 
@@ -788,5 +775,4 @@
                                     Config.DEFAULT_UPDATE_URL +
                                     ("/exp" if secondaryInstallation else ""))
-        self._useRPC = self._getBoolean(config, "general", "useRPC", True)
 
         for aircraftType in const.aircraftTypes:
@@ -881,7 +867,4 @@
         config.set("update", "url", self._updateURL)
 
-        config.set("general", "useRPC",
-                   "yes" if self._useRPC else "no")
-
         config.add_section(Checklist.SECTION)
         config.add_section(ApproachCallouts.SECTION)
@@ -1018,5 +1001,4 @@
         print "  autoUpdate:", self._autoUpdate
         print "  updateURL:", self._updateURL
-        print "  useRPC:", self._useRPC
 
         print "  messageTypeLevels:"
Index: src/mlx/fsuipc.py
===================================================================
--- src/mlx/fsuipc.py	(revision 749)
+++ src/mlx/fsuipc.py	(revision 669)
@@ -1387,7 +1387,4 @@
         state.gearsDown = data[self._monidx_noseGear]==16383
 
-        if state.gearControlDown!=state.gearsDown:
-            print "gearControl:", data[self._monidx_gearControl], ", noseGear:", data[self._monidx_noseGear]
-
         state.spoilersArmed = data[self._monidx_spoilersArmed]!=0
 
Index: src/mlx/gui/acars.py
===================================================================
--- src/mlx/gui/acars.py	(revision 747)
+++ src/mlx/gui/acars.py	(revision 649)
@@ -13,5 +13,5 @@
 # The ACARS tab.
 #
-# This module implements to \ref ACARS class, which displays the MAVA ACARS in a
+# This module implements to \ref ACRS class, which displays the MAVA ACARS in a
 # browser window using CEF
 
@@ -21,5 +21,5 @@
     """The flight info tab."""
     # The URL of the ACARS map
-    URL = MAVA_BASE_URL + "/acars2/show.html"
+    URL = "http://virtualairlines.hu/acars2/show.html"
 
     def __init__(self, gui):
Index: src/mlx/gui/common.py
===================================================================
--- src/mlx/gui/common.py	(revision 741)
+++ src/mlx/gui/common.py	(revision 732)
@@ -279,119 +279,4 @@
                       else str(self._currentInteger))
         self._selfSetting = False
-
-#------------------------------------------------------------------------------
-
-class CredentialsDialog(gtk.Dialog):
-    """A dialog window to ask for a user name and a password."""
-    def __init__(self, gui, userName, password,
-                 titleLabel, cancelButtonLabel, okButtonLabel,
-                 userNameLabel, userNameTooltip,
-                 passwordLabel, passwordTooltip,
-                 infoText = None,
-                 rememberPassword = None,
-                 rememberLabel = None, rememberTooltip = None):
-        """Construct the dialog."""
-        super(CredentialsDialog, self).__init__(WINDOW_TITLE_BASE + " - " +
-                                                titleLabel,
-                                                gui.mainWindow,
-                                                DIALOG_MODAL)
-        self.add_button(cancelButtonLabel, RESPONSETYPE_CANCEL)
-        self.add_button(okButtonLabel, RESPONSETYPE_OK)
-
-        contentArea = self.get_content_area()
-
-        contentAlignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
-                                         xscale = 0.0, yscale = 0.0)
-        contentAlignment.set_padding(padding_top = 4, padding_bottom = 16,
-                                     padding_left = 8, padding_right = 8)
-
-        contentArea.pack_start(contentAlignment, False, False, 0)
-
-        contentVBox = gtk.VBox()
-        contentAlignment.add(contentVBox)
-
-        if infoText is not None:
-            label = gtk.Label(infoText)
-            label.set_alignment(0.0, 0.0)
-
-            contentVBox.pack_start(label, False, False, 0)
-
-        tableAlignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
-                                       xscale = 0.0, yscale = 0.0)
-        tableAlignment.set_padding(padding_top = 24, padding_bottom = 0,
-                                   padding_left = 0, padding_right = 0)
-
-        table = gtk.Table(3, 2)
-        table.set_row_spacings(4)
-        table.set_col_spacings(16)
-        table.set_homogeneous(False)
-
-        tableAlignment.add(table)
-        contentVBox.pack_start(tableAlignment, True, True, 0)
-
-        label = gtk.Label(userNameLabel)
-        label.set_use_underline(True)
-        label.set_alignment(0.0, 0.5)
-        table.attach(label, 0, 1, 0, 1)
-
-        self._userName = gtk.Entry()
-        self._userName.set_width_chars(16)
-        # FIXME: enabled the OK button only when there is something in thr
-        # user name and password fields
-        #self._userName.connect("changed",
-        #                       lambda button: self._updateForwardButton())
-        self._userName.set_tooltip_text(userNameTooltip)
-        self._userName.set_text(userName)
-        table.attach(self._userName, 1, 2, 0, 1)
-        label.set_mnemonic_widget(self._userName)
-
-        label = gtk.Label(passwordLabel)
-        label.set_use_underline(True)
-        label.set_alignment(0.0, 0.5)
-        table.attach(label, 0, 1, 1, 2)
-
-        self._password = gtk.Entry()
-        self._password.set_visibility(False)
-        #self._password.connect("changed",
-        #                       lambda button: self._updateForwardButton())
-        self._password.set_tooltip_text(passwordTooltip)
-        self._password.set_text(password)
-        table.attach(self._password, 1, 2, 1, 2)
-        label.set_mnemonic_widget(self._password)
-
-        if rememberPassword is not None:
-            self._rememberButton = gtk.CheckButton(rememberLabel)
-            self._rememberButton.set_use_underline(True)
-            self._rememberButton.set_tooltip_text(rememberTooltip)
-            self._rememberButton.set_active(rememberPassword)
-            table.attach(self._rememberButton, 1, 2, 2, 3, ypadding = 8)
-        else:
-            self._rememberButton = None
-
-    @property
-    def userName(self):
-        """Get the user name entered."""
-        return self._userName.get_text()
-
-    @property
-    def password(self):
-        """Get the password entered."""
-        return self._password.get_text()
-
-    @property
-    def rememberPassword(self):
-        """Get whether the password is to be remembered."""
-        return None if self._rememberButton is None \
-               else self._rememberButton.get_active()
-
-    def run(self):
-        """Run the dialog."""
-        self.show_all()
-
-        response = super(CredentialsDialog, self).run()
-
-        self.hide()
-
-        return response
 
 #------------------------------------------------------------------------------
Index: src/mlx/gui/flight.py
===================================================================
--- src/mlx/gui/flight.py	(revision 739)
+++ src/mlx/gui/flight.py	(revision 728)
@@ -4682,4 +4682,5 @@
         """Handle the login result."""
         self.gui.endBusy()
+        returned = True
         isReload = self._loginResult is not None
         if returned:
Index: src/mlx/gui/gui.py
===================================================================
--- src/mlx/gui/gui.py	(revision 746)
+++ src/mlx/gui/gui.py	(revision 733)
@@ -90,10 +90,5 @@
         self._sendBugReportCallback = None
 
-        self._credentialsCondition = threading.Condition()
-        self._credentialsAvailable = False
-        self._credentialsUserName = None
-        self._credentialsPassword = None
-
-        self.webHandler = web.Handler(config, self._getCredentialsCallback)
+        self.webHandler = web.Handler()
         self.webHandler.start()
 
@@ -1640,56 +1635,2 @@
         """Set the anti-ice on indicator."""
         self._wizard.landingAntiIceOn = value
-
-    def _getCredentialsCallback(self):
-        """Called when the web handler asks for the credentials."""
-        # FIXME: this is almost the same as
-        # SimBriefSetupPage._getCredentialsCallback
-        with self._credentialsCondition:
-            self._credentialsAvailable = False
-
-            gobject.idle_add(self._getCredentials)
-
-            while not self._credentialsAvailable:
-                self._credentialsCondition.wait()
-
-            return (self._credentialsUserName, self._credentialsPassword)
-
-    def _getCredentials(self):
-        """Get the credentials."""
-        # FIXME: this is almost the same as
-        # SimBriefSetupPage._getCredentials
-        with self._credentialsCondition:
-            config = self.config
-
-            dialog = CredentialsDialog(self, config.pilotID, config.password,
-                                       xstr("login_title"),
-                                       xstr("button_cancel"),
-                                       xstr("button_ok"),
-                                       xstr("label_pilotID"),
-                                       xstr("login_pilotID_tooltip"),
-                                       xstr("label_password"),
-                                       xstr("login_password_tooltip"),
-                                       xstr("login_info"),
-                                       config.rememberPassword,
-                                       xstr("remember_password"),
-                                       xstr("login_remember_tooltip"))
-            response = dialog.run()
-
-            if response==RESPONSETYPE_OK:
-                self._credentialsUserName = dialog.userName
-                self._credentialsPassword = dialog.password
-                rememberPassword = dialog.rememberPassword
-
-                config.pilotID = self._credentialsUserName
-
-                config.password = \
-                  self._credentialsPassword if rememberPassword else ""
-                config.rememberPassword = rememberPassword
-
-                config.save()
-            else:
-                self._credentialsUserName = None
-                self._credentialsPassword = None
-
-            self._credentialsAvailable = True
-            self._credentialsCondition.notify()
Index: src/mlx/gui/prefs.py
===================================================================
--- src/mlx/gui/prefs.py	(revision 738)
+++ src/mlx/gui/prefs.py	(revision 684)
@@ -276,6 +276,4 @@
 
         self._updateURL.set_text(config.updateURL)
-
-        self._useRPC.set_active(config.useRPC)
 
         self._settingFromConfig = False
@@ -322,5 +320,4 @@
         config.autoUpdate = self._autoUpdate.get_active()
         config.updateURL = self._updateURL.get_text()
-        config.useRPC = self._useRPC.get_active()
 
     def _buildGeneral(self):
@@ -817,10 +814,4 @@
         updateURLBox.pack_start(self._updateURL, True, True, 4)
 
-        self._useRPC = gtk.CheckButton(xstr("prefs_use_rpc"))
-        mainBox.pack_start(self._useRPC, False, False, 16)
-
-        self._useRPC.set_use_underline(True)
-        self._useRPC.set_tooltip_text(xstr("prefs_use_rpc_tooltip"))
-
         return mainAlignment
 
Index: src/mlx/pirep.py
===================================================================
--- src/mlx/pirep.py	(revision 743)
+++ src/mlx/pirep.py	(revision 437)
@@ -4,6 +4,4 @@
 import const
 import cPickle as pickle
-import datetime
-import time
 
 #------------------------------------------------------------------------------
@@ -21,9 +19,4 @@
 class PIREP(object):
     """A pilot's report of a flight."""
-    _flightTypes = { const.FLIGHTTYPE_SCHEDULED : "SCHEDULED",
-                     const.FLIGHTTYPE_OLDTIMER : "OT",
-                     const.FLIGHTTYPE_VIP : "VIP",
-                     const.FLIGHTTYPE_CHARTER : "CHARTER" }
-
     @staticmethod
     def _formatLine(timeStr, line):
@@ -31,9 +24,4 @@
         some other things."""
         return "[" + timeStr + "]-[" + line + "]"
-
-    @staticmethod
-    def formatTimestampForRPC(t):
-        """Format the given timestamp for RPC."""
-        return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(t))
 
     @staticmethod
@@ -103,29 +91,4 @@
         self.faultLineIndexes = logger.faultLineIndexes
 
-    @property
-    def flightTypeText(self):
-        """Get the text representation of the flight type."""
-        return PIREP._flightTypes[self.flightType]
-
-    @property
-    def blockTimeStartText(self):
-        """Get the beginning of the block time in string format."""
-        return PIREP.formatTimestampForRPC(self.blockTimeStart)
-
-    @property
-    def flightTimeStartText(self):
-        """Get the beginning of the flight time in string format."""
-        return PIREP.formatTimestampForRPC(self.flightTimeStart)
-
-    @property
-    def flightTimeEndText(self):
-        """Get the end of the flight time in string format."""
-        return PIREP.formatTimestampForRPC(self.flightTimeEnd)
-
-    @property
-    def blockTimeEndText(self):
-        """Get the end of the block time in string format."""
-        return PIREP.formatTimestampForRPC(self.blockTimeEnd)
-
     def getACARSText(self):
         """Get the ACARS text.
@@ -189,39 +152,2 @@
             print u"Failed saving PIREP to %s: %s" % (path, error)
             return error
-
-    def _serialize(self):
-        """Serialize the PIREP for JSON-RPC."""
-        attrs = {}
-        attrs["log"] = self.getACARSText()
-        attrs["numPassengers"] = self.numPassengers
-        attrs["numCrew"] = self.numCrew
-        attrs["cargoWeight"] = self.cargoWeight
-        attrs["bagWeight"] = self.bagWeight
-        attrs["mailWeight"] = self.mailWeight
-        attrs["flightType"] = self.flightTypeText
-        attrs["online"] = 1 if self.online else 0
-        attrs["blockTimeStart"] = self.blockTimeStartText
-        attrs["blockTimeEnd"] = self.blockTimeEndText
-        attrs["flightTimeStart"] = self.flightTimeStartText
-        attrs["flightTimeEnd"] = self.flightTimeEndText
-        attrs["timeComment"] = self.getTimeComment()
-        attrs["fuelUsed"] = self.fuelUsed
-        attrs["departureRunway"] = self.departureRunway
-        attrs["arrivalRunway"] = self.arrivalRunway
-        attrs["departureMETAR"] = self.departureMETAR
-        attrs["arrivalMETAR"] = self.arrivalMETAR
-        attrs["filedCruiseLevel"] = self.filedCruiseAltitude / 100.0
-        attrs["cruiseLevel"] = self.cruiseAltitude / 100.0
-        attrs["sid"] = self.sid
-        attrs["route"] = self.route
-        attrs["star"] = self.star
-        attrs["approachType"] = self.approachType
-        attrs["comments"] = self.comments
-        attrs["flightDefects"] = self.flightDefects
-        attrs["ratingText"] = self.getRatingText()
-        attrs["rating"] = max(0.0, self.rating)
-        attrs["flownDistance"] = self.flownDistance
-        # FIXME: it should be stored in the PIREP when it is sent later
-        attrs["flightDate"] = datetime.date.today().strftime("%Y-%m-%d")
-
-        return ([], attrs)
Index: src/mlx/rpc.py
===================================================================
--- src/mlx/rpc.py	(revision 745)
+++ 	(revision )
@@ -1,293 +1,0 @@
-import const
-import rpccommon
-
-from common import MAVA_BASE_URL
-
-import jsonrpclib
-import hashlib
-import datetime
-
-#---------------------------------------------------------------------------------------
-
-class RPCObject(object):
-    """Base class for objects read from RPC calls.
-
-    It is possible to construct it from a dictionary."""
-    def __init__(self, value, instructions = {}):
-        """Construct the object.
-
-        value is the dictionary returned by the call.
-
-        info is a mapping from names to 'instructions' on what to do with the
-        corresponding values. If the instruction is None, it will be ignored.
-        If the instruction is a function, the value will be passed to it and
-        the return value will be stored in the object.
-
-        For all other names, the value will be stored as the same-named
-        attribute."""
-        for (key, value) in value.iteritems():
-            if key in instructions:
-                instruction = instructions[key]
-                if instruction is None:
-                    continue
-
-                value = instruction(value)
-            setattr(self, key, value)
-
-#---------------------------------------------------------------------------------------
-
-class Reply(RPCObject):
-    """The generic reply structure."""
-
-#---------------------------------------------------------------------------------------
-
-class BookedFlight(RPCObject):
-    """A booked flight."""
-    # FIXME: copied from web.BookedFlight
-    TYPECODE2TYPE = { "736"  : const.AIRCRAFT_B736,
-                      "73G"  : const.AIRCRAFT_B737,
-                      "738"  : const.AIRCRAFT_B738,
-                      "73H"  : const.AIRCRAFT_B738C,
-                      "733"  : const.AIRCRAFT_B733,
-                      "734"  : const.AIRCRAFT_B734,
-                      "735"  : const.AIRCRAFT_B735,
-                      "DH4"  : const.AIRCRAFT_DH8D,
-                      "762"  : const.AIRCRAFT_B762,
-                      "763"  : const.AIRCRAFT_B763,
-                      "CR2"  : const.AIRCRAFT_CRJ2,
-                      "F70"  : const.AIRCRAFT_F70,
-                      "LI2"  : const.AIRCRAFT_DC3,
-                      "TU3"  : const.AIRCRAFT_T134,
-                      "TU5"  : const.AIRCRAFT_T154,
-                      "YK4"  : const.AIRCRAFT_YK40,
-                      "146"  : const.AIRCRAFT_B462 }
-
-    # FIXME: copied from web.BookedFlight
-    @staticmethod
-    def _decodeAircraftType(typeCode):
-        """Decode the aircraft type from the given typeCode."""
-        if typeCode in BookedFlight.TYPECODE2TYPE:
-            return BookedFlight.TYPECODE2TYPE[typeCode]
-        else:
-            raise Exception("Invalid aircraft type code: '" + typeCode + "'")
-
-    # FIXME: copied from web.BookedFlight
-    @staticmethod
-    def getDateTime(date, time):
-        """Get a datetime object from the given textual date and time."""
-        return datetime.datetime.strptime(date + " " + time,
-                                          "%Y-%m-%d %H:%M:%S")
-
-    # The instructions for the construction
-    _instructions = {
-        "numPassengers" : int,
-        "numCrew" : int,
-        "bagWeight" : int,
-        "cargoWeight" : int,
-        "mailWeight" : int,
-        "aircraftType" : lambda value: BookedFlight._decodeAircraftType(value)
-        }
-
-    def __init__(self, value):
-        """Construct the booked flight object from the given RPC result
-        value."""
-        super(BookedFlight, self).__init__(value, BookedFlight._instructions)
-        self.departureTime = \
-          BookedFlight.getDateTime(self.date, self.departureTime)
-        self.arrivalTime = \
-          BookedFlight.getDateTime(self.date, self.arrivalTime)
-        if self.arrivalTime<self.departureTime:
-            self.arrivalTime += datetime.timedelta(days = 1)
-
-#---------------------------------------------------------------------------------------
-
-class Plane(rpccommon.Plane, RPCObject):
-    """An airplane in the fleet."""
-    _instructions = {
-        "status" : lambda value: rpccommon.Plane.str2status(value),
-        "gateNumber" : lambda value: value if value else None
-        }
-
-    def __init__(self, value):
-        """Construct the plane."""
-        RPCObject.__init__(self, value, instructions = Plane._instructions)
-
-#---------------------------------------------------------------------------------------
-
-class Fleet(rpccommon.Fleet):
-    """The fleet."""
-    def __init__(self, value):
-        """Construct the fleet."""
-        super(Fleet, self).__init__()
-        for planeValue in value:
-            self._addPlane(Plane(planeValue))
-
-#---------------------------------------------------------------------------------------
-
-class RPCException(Exception):
-    """An exception thrown by RPC operations."""
-    def __init__(self, result, message = None):
-        """Construct the exception."""
-        self._result = result
-        if message is None:
-            message = "RPC call failed with result code: %d" % (result,)
-        super(RPCException, self).__init__(message)
-
-    @property
-    def result(self):
-        """Get the result code."""
-        return self._result
-
-#---------------------------------------------------------------------------------------
-
-class Client(object):
-    """The RPC client interface."""
-    # Result code: OK
-    RESULT_OK = 0
-
-    # Result code: the login has failed
-    RESULT_LOGIN_FAILED = 1
-
-    # Result code: the given session ID is unknown (it might have expired).
-    RESULT_SESSION_INVALID = 2
-
-    # Result code: some database error
-    RESULT_DATABASE_ERROR = 3
-
-    # Result code: the flight does not exist
-    RESULT_FLIGHT_NOT_EXISTS = 101
-
-    # Result code: the flight has already been reported.
-    RESULT_FLIGHT_ALREADY_REPORTED = 102
-
-    def __init__(self, getCredentialsFn):
-        """Construct the client."""
-        self._getCredentialsFn = getCredentialsFn
-
-        self._server = jsonrpclib.Server(MAVA_BASE_URL + "/jsonrpc.php")
-
-        self._userName = None
-        self._passwordHash = None
-        self._sessionID = None
-        self._loginCount = 0
-
-    @property
-    def valid(self):
-        """Determine if the client is valid, i.e. there is a session ID
-        stored."""
-        return self._sessionID is not None
-
-    def setCredentials(self, userName, password):
-        """Set the credentials for future logins."""
-
-        self._userName = userName
-
-        md5 = hashlib.md5()
-        md5.update(password)
-        self._passwordHash = md5.hexdigest()
-
-        self._sessionID = None
-
-    def login(self):
-        """Login using the given previously set credentials.
-
-        The session ID is stored in the object and used for later calls.
-
-        Returns a boolean indicating if login has succeeded."""
-        self._sessionID = None
-
-        reply = Reply(self._server.login(self._userName, self._passwordHash))
-        if reply.result == Client.RESULT_OK:
-            self._loginCount += 1
-            self._sessionID = reply.value["sessionID"]
-            return reply.value["name"]
-        else:
-            return None
-
-    def getFlights(self):
-        """Get the flights available for performing."""
-        flights = []
-
-        value = self._performCall(lambda sessionID:
-                                  self._server.getFlights(sessionID))
-        for flightData in value:
-            flights.append(BookedFlight(flightData))
-
-        flights.sort(cmp = lambda flight1, flight2:
-                     cmp(flight1.departureTime, flight2.departureTime))
-
-        return flights
-
-    def getFleet(self):
-        """Query and return the fleet."""
-        value = self._performCall(lambda sessionID:
-                                  self._server.getFleet(sessionID))
-
-        return Fleet(value)
-
-    def updatePlane(self, tailNumber, status, gateNumber):
-        """Update the state and position of the plane with the given tail
-        number."""
-        status = rpccommon.Plane.status2str(status)
-        self._performCall(lambda sessionID:
-                          self._server.updatePlane(sessionID, tailNumber,
-                                                   status, gateNumber))
-
-    def addPIREP(self, flightID, pirep):
-        """Add the PIREP for the given flight."""
-        (result, _value) = \
-          self._performCall(lambda sessionID:
-                            self._server.addPIREP(sessionID, flightID, pirep),
-                            acceptResults = [Client.RESULT_FLIGHT_ALREADY_REPORTED,
-                                             Client.RESULT_FLIGHT_NOT_EXISTS])
-        return result
-
-    def updateOnlineACARS(self, acars):
-        """Update the online ACARS from the given data."""
-        self._performCall(lambda sessionID:
-                          self._server.updateOnlineACARS(sessionID, acars))
-
-    def _performCall(self, callFn, acceptResults = []):
-        """Perform a call using the given call function.
-
-        acceptResults should be a list of result codes that should be accepted
-        besides RESULT_OK. If this list is not empty, the returned value is a
-        tuple of the result code and the corresponding value. Otherwise only
-        RESULT_OK is accepted, and the value is returned.
-
-        All other error codes are converted to exceptions."""
-        numAttempts = 0
-        while True:
-            reply = Reply(callFn(self._ensureSession()))
-            numAttempts += 1
-            result = reply.result
-            if result==Client.RESULT_SESSION_INVALID:
-                self._sessionID = None
-                if numAttempts==3:
-                    raise RPCException(result)
-            elif result!=Client.RESULT_OK and result not in acceptResults:
-                raise RPCException(result)
-            elif acceptResults:
-                return (result, reply.value)
-            else:
-                return reply.value
-
-    def _ensureSession(self):
-        """Ensure that there is a valid session ID."""
-        while self._sessionID is None:
-            if self._userName is not None and self._passwordHash is not None:
-                if not self.login():
-                    self._userName = self._passwordHash = None
-
-            if self._userName is None or self._passwordHash is None:
-                (self._userName, password) = self._getCredentialsFn()
-                if self._userName is None:
-                    raise RPCException(Client.RESULT_LOGIN_FAILED)
-
-                md5 = hashlib.md5()
-                md5.update(password)
-                self._passwordHash = md5.hexdigest()
-
-        return self._sessionID
-
-#---------------------------------------------------------------------------------------
Index: src/mlx/rpccommon.py
===================================================================
--- src/mlx/rpccommon.py	(revision 742)
+++ 	(revision )
@@ -1,93 +1,0 @@
-# Some common objects for RPC communication
-
-#------------------------------------------------------------------------------
-
-import const
-
-#------------------------------------------------------------------------------
-
-class Plane(object):
-    """Information about an airplane in the fleet."""
-    @staticmethod
-    def str2status(letter):
-        """Convert the given letter into a plane status."""
-        return const.PLANE_HOME if letter=="H" else \
-               const.PLANE_AWAY if letter=="A" else \
-               const.PLANE_PARKING if letter=="P" else \
-               const.PLANE_UNKNOWN
-
-    @staticmethod
-    def status2str(status):
-        """Convert the given status into the corresponding letter code."""
-        return "H" if status==const.PLANE_HOME else \
-               "A" if status==const.PLANE_AWAY else \
-               "P" if status==const.PLANE_PARKING else ""
-
-    def _setStatus(self, letter):
-        """Set the status from the given letter."""
-        self.status = Plane.str2status(letter)
-
-    def __repr__(self):
-        """Get the representation of the plane object."""
-        s = "<Plane: %s %s" % (self.tailNumber,
-                               "home" if self.status==const.PLANE_HOME else \
-                               "away" if self.status==const.PLANE_AWAY else \
-                               "parking" if self.status==const.PLANE_PARKING \
-                               else "unknown")
-        if self.gateNumber is not None:
-            s += " (gate " + self.gateNumber + ")"
-        s += ">"
-        return s
-
-#------------------------------------------------------------------------------
-
-class Fleet(object):
-    """Information about the whole fleet."""
-    def __init__(self):
-        """Construct the fleet information by reading the given file object."""
-        self._planes = {}
-
-    def isGateConflicting(self, plane):
-        """Check if the gate of the given plane conflicts with another plane's
-        position."""
-        for p in self._planes.itervalues():
-            if p.tailNumber!=plane.tailNumber and \
-               p.status==const.PLANE_HOME and \
-               p.gateNumber==plane.gateNumber:
-                return True
-
-        return False
-
-    def getOccupiedGateNumbers(self):
-        """Get a set containing the numbers of the gates occupied by planes."""
-        gateNumbers = set()
-        for p in self._planes.itervalues():
-            if p.status==const.PLANE_HOME and p.gateNumber:
-                gateNumbers.add(p.gateNumber)
-        return gateNumbers
-
-    def updatePlane(self, tailNumber, status, gateNumber = None):
-        """Update the status of the given plane."""
-        if tailNumber in self._planes:
-            plane = self._planes[tailNumber]
-            plane.status = status
-            plane.gateNumber = gateNumber
-
-    def _addPlane(self, plane):
-        """Add the given plane to the fleet."""
-        self._planes[plane.tailNumber] = plane
-
-    def __iter__(self):
-        """Get an iterator over the planes."""
-        for plane in self._planes.itervalues():
-            yield plane
-
-    def __getitem__(self, tailNumber):
-        """Get the plane with the given tail number.
-
-        If the plane is not in the fleet, None is returned."""
-        return self._planes[tailNumber] if tailNumber in self._planes else None
-
-    def __repr__(self):
-        """Get the representation of the fleet object."""
-        return self._planes.__repr__()
Index: src/mlx/web.py
===================================================================
--- src/mlx/web.py	(revision 746)
+++ src/mlx/web.py	(revision 570)
@@ -2,8 +2,4 @@
 import const
 import util
-import rpc
-import rpccommon
-
-from common import MAVA_BASE_URL
 
 import threading
@@ -259,5 +255,5 @@
 #------------------------------------------------------------------------------
 
-class Plane(rpccommon.Plane):
+class Plane(object):
     """Information about an airplane in the fleet."""
     def __init__(self, s):
@@ -267,6 +263,4 @@
         The first field is the tail number, the second field is the gate
         number, the third field is the plane's status as a character."""
-        super(Plane, self).__init__()
-
         try:
             words = s.split(" ")
@@ -275,5 +269,8 @@
 
             status = words[2] if len(words)>2 else None
-            self._setStatus(status)
+            self.status = const.PLANE_HOME if status=="H" else \
+                          const.PLANE_AWAY if status=="A" else \
+                          const.PLANE_PARKING if status=="P" else \
+                          const.PLANE_UNKNOWN
 
             gateNumber = words[1] if len(words)>1 else ""
@@ -284,12 +281,24 @@
             self.tailNumber = None
 
-#------------------------------------------------------------------------------
-
-class Fleet(rpccommon.Fleet):
+    def __repr__(self):
+        """Get the representation of the plane object."""
+        s = "<Plane: %s %s" % (self.tailNumber,
+                               "home" if self.status==const.PLANE_HOME else \
+                               "away" if self.status==const.PLANE_AWAY else \
+                               "parking" if self.status==const.PLANE_PARKING \
+                               else "unknown")
+        if self.gateNumber is not None:
+            s += " (gate " + self.gateNumber + ")"
+        s += ">"
+        return s
+
+
+#------------------------------------------------------------------------------
+
+class Fleet(object):
     """Information about the whole fleet."""
     def __init__(self, f):
         """Construct the fleet information by reading the given file object."""
-        super(Fleet, self).__init__()
-
+        self._planes = {}
         while True:
             line = readline(f)
@@ -297,5 +306,47 @@
 
             plane = Plane(line)
-            self._addPlane(plane)
+            if plane.tailNumber is not None:
+                self._planes[plane.tailNumber] = plane
+
+    def isGateConflicting(self, plane):
+        """Check if the gate of the given plane conflicts with another plane's
+        position."""
+        for p in self._planes.itervalues():
+            if p.tailNumber!=plane.tailNumber and \
+               p.status==const.PLANE_HOME and \
+               p.gateNumber==plane.gateNumber:
+                return True
+
+        return False
+
+    def getOccupiedGateNumbers(self):
+        """Get a set containing the numbers of the gates occupied by planes."""
+        gateNumbers = set()
+        for p in self._planes.itervalues():
+            if p.status==const.PLANE_HOME and p.gateNumber:
+                gateNumbers.add(p.gateNumber)
+        return gateNumbers
+
+    def updatePlane(self, tailNumber, status, gateNumber = None):
+        """Update the status of the given plane."""
+        if tailNumber in self._planes:
+            plane = self._planes[tailNumber]
+            plane.status = status
+            plane.gateNumber = gateNumber
+
+    def __iter__(self):
+        """Get an iterator over the planes."""
+        for plane in self._planes.itervalues():
+            yield plane
+
+    def __getitem__(self, tailNumber):
+        """Get the plane with the given tail number.
+
+        If the plane is not in the fleet, None is returned."""
+        return self._planes[tailNumber] if tailNumber in self._planes else None
+
+    def __repr__(self):
+        """Get the representation of the fleet object."""
+        return self._planes.__repr__()
 
 #------------------------------------------------------------------------------
@@ -612,15 +663,4 @@
 #------------------------------------------------------------------------------
 
-class RPCRequest(Request):
-    """Common base class for RPC requests.
-
-    It stores the RPC client received from the handler."""
-    def __init__(self, client, callback):
-        """Construct the request."""
-        super(RPCRequest, self).__init__(callback)
-        self._client = client
-
-#------------------------------------------------------------------------------
-
 class Login(Request):
     """A login request."""
@@ -647,8 +687,8 @@
 
         if self._entranceExam:
-            url = MAVA_BASE_URL + "/ellenorzo/getflightplan.php?pid=%s" % \
+            url = "http://www.virtualairlines.hu/ellenorzo/getflightplan.php?pid=%s" % \
                   (pilotID,)
         else:
-            url = MAVA_BASE_URL + "/leker2.php?pid=%s&psw=%s" % \
+            url = "http://www.virtualairlines.hu/leker2.php?pid=%s&psw=%s" % \
                   (pilotID, password)
 
@@ -696,34 +736,4 @@
 #------------------------------------------------------------------------------
 
-class LoginRPC(RPCRequest):
-    """An RPC-based login request."""
-    def __init__(self, client, callback, pilotID, password, entranceExam):
-        """Construct the login request with the given pilot ID and
-        password."""
-        super(LoginRPC, self).__init__(client, callback)
-
-        self._pilotID = pilotID
-        self._password = password
-        self._entranceExam = entranceExam
-
-    def run(self):
-        """Perform the login request."""
-        result = Result()
-        # FIXME: handle the entrance exam case
-        result.entranceExam = self._entranceExam
-
-        self._client.setCredentials(self._pilotID, self._password)
-        pilotName = self._client.login()
-        result.loggedIn = pilotName is not None
-        if result.loggedIn:
-            result.pilotID = self._pilotID
-            result.pilotName = pilotName
-            result.password = self._password
-            result.flights = self._client.getFlights()
-
-        return result
-
-#------------------------------------------------------------------------------
-
 class GetFleet(Request):
     """Request to get the fleet from the website."""
@@ -735,5 +745,5 @@
     def run(self):
         """Perform the login request."""
-        url = MAVA_BASE_URL + "/onlinegates_get.php"
+        url = "http://www.virtualairlines.hu/onlinegates_get.php"
 
         f = urllib2.urlopen(url, timeout = 10.0)
@@ -741,20 +751,4 @@
         result.fleet = Fleet(f)
         f.close()
-
-        return result
-
-#------------------------------------------------------------------------------
-
-class GetFleetRPC(RPCRequest):
-    """Request to get the fleet from the website using RPC."""
-    def __init__(self, client, callback):
-        """Construct the request with the given client and callback function."""
-        super(GetFleetRPC, self).__init__(client, callback)
-
-    def run(self):
-        """Perform the login request."""
-        result = Result()
-
-        result.fleet = self._client.getFleet()
 
         return result
@@ -773,7 +767,9 @@
     def run(self):
         """Perform the plane update."""
-        url = MAVA_BASE_URL + "/onlinegates_set.php"
-
-        status = Plane.status2str(self._status)
+        url = "http://www.virtualairlines.hu/onlinegates_set.php"
+
+        status = "H" if self._status==const.PLANE_HOME else \
+                 "A" if self._status==const.PLANE_AWAY else \
+                 "P" if self._status==const.PLANE_PARKING else ""
 
         gateNumber = self._gateNumber if self._gateNumber else ""
@@ -788,26 +784,4 @@
         result = Result()
         result.success = line == "OK"
-
-        return result
-
-#------------------------------------------------------------------------------
-
-class UpdatePlaneRPC(RPCRequest):
-    """RPC request to update the status and the position of a plane in the
-    fleet."""
-    def __init__(self, client, callback, tailNumber, status, gateNumber = None):
-        """Construct the request."""
-        super(UpdatePlaneRPC, self).__init__(client, callback)
-        self._tailNumber = tailNumber
-        self._status = status
-        self._gateNumber = gateNumber
-
-    def run(self):
-        """Perform the plane update."""
-        self._client.updatePlane(self._tailNumber, self._status, self._gateNumber)
-
-        # Otherwise an exception is thrown
-        result = Result()
-        result.success = True
 
         return result
@@ -924,4 +898,9 @@
 class SendPIREP(Request):
     """A request to send a PIREP to the MAVA website."""
+    _flightTypes = { const.FLIGHTTYPE_SCHEDULED : "SCHEDULED",
+                     const.FLIGHTTYPE_OLDTIMER : "OT",
+                     const.FLIGHTTYPE_VIP : "VIP",
+                     const.FLIGHTTYPE_CHARTER : "CHARTER" }
+
     _latin2Encoder = codecs.getencoder("iso-8859-2")
 
@@ -933,5 +912,6 @@
     def run(self):
         """Perform the sending of the PIREP."""
-        url = MAVA_BASE_URL + "/malevacars.php"
+        url = "http://www.virtualairlines.hu/malevacars.php"
+        #url = "http://localhost:15000"
 
         pirep = self._pirep
@@ -952,5 +932,5 @@
         data["mail"] = str(pirep.mailWeight)
 
-        data["flttype"] = pirep.flightTypeText
+        data["flttype"] = SendPIREP._flightTypes[pirep.flightType]
         data["onoff"] = "1" if pirep.online else "0"
         data["bt_dep"] = util.getTimestampString(pirep.blockTimeStart)
@@ -1000,26 +980,4 @@
 #------------------------------------------------------------------------------
 
-class SendPIREPRPC(RPCRequest):
-    """A request to send a PIREP to the MAVA website via the RPC interface."""
-
-    def __init__(self, client, callback, pirep):
-        """Construct the sending of the PIREP."""
-        super(SendPIREPRPC, self).__init__(client, callback)
-        self._pirep = pirep
-
-    def run(self):
-        """Perform the sending of the PIREP."""
-        pirep = self._pirep
-        resultCode = self._client.addPIREP(pirep.bookedFlight.id, pirep)
-
-        result = Result()
-        result.success = resultCode==rpc.Client.RESULT_OK
-        result.alreadyFlown = resultCode==rpc.Client.RESULT_FLIGHT_ALREADY_REPORTED
-        result.notAvailable = resultCode==rpc.Client.RESULT_FLIGHT_NOT_EXISTS
-
-        return result
-
-#------------------------------------------------------------------------------
-
 class SendACARS(Request):
     """A request to send an ACARS to the MAVA website."""
@@ -1035,5 +993,5 @@
         print "Sending the online ACARS"
 
-        url = MAVA_BASE_URL  + "/acars2/acarsonline.php"
+        url = "http://www.virtualairlines.hu/acars2/acarsonline.php"
 
         acars = self._acars
@@ -1069,20 +1027,4 @@
 #------------------------------------------------------------------------------
 
-class SendACARSRPC(RPCRequest):
-    """A request to send an ACARS to the MAVA website via JSON-RPC."""
-    def __init__(self, client, callback, acars):
-        """Construct the request for the given PIREP."""
-        super(SendACARSRPC, self).__init__(client, callback)
-        self._acars = acars
-
-    def run(self):
-        """Perform the sending of the ACARS."""
-        print "Sending the online ACARS via JSON-RPC"
-
-        self._client.updateOnlineACARS(self._acars)
-        return Result()
-
-#------------------------------------------------------------------------------
-
 class SendBugReport(Request):
     """A request to send a bug report to the project homepage."""
@@ -1121,5 +1063,5 @@
     It can process one request at a time. The results are passed to a callback
     function."""
-    def __init__(self, config, getCredentialsFn):
+    def __init__(self):
         """Construct the handler."""
         super(Handler, self).__init__()
@@ -1129,33 +1071,16 @@
 
         self.daemon = True
-        self._config = config
-        self._rpcClient = rpc.Client(getCredentialsFn)
-        if config.rememberPassword:
-            self._rpcClient.setCredentials(config.pilotID, config.password)
 
     def login(self, callback, pilotID, password, entranceExam = False):
         """Enqueue a login request."""
-        request = \
-          LoginRPC(self._rpcClient, callback, pilotID, password, entranceExam) \
-          if self._config.useRPC and not entranceExam \
-          else Login(callback, pilotID, password, entranceExam)
-
-        self._addRequest(request)
+        self._addRequest(Login(callback, pilotID, password, entranceExam))
 
     def getFleet(self, callback):
         """Enqueue a fleet retrieval request."""
-        request = \
-          GetFleetRPC(self._rpcClient, callback,) if self._config.useRPC \
-          else GetFleet(callback)
-        self._addRequest(request)
+        self._addRequest(GetFleet(callback))
 
     def updatePlane(self, callback, tailNumber, status, gateNumber = None):
         """Update the status of the given plane."""
-        request = \
-          UpdatePlaneRPC(self._rpcClient, callback,
-                         tailNumber, status, gateNumber) \
-          if self._config.useRPC \
-          else UpdatePlane(callback, tailNumber, status, gateNumber)
-        self._addRequest(request)
+        self._addRequest(UpdatePlane(callback, tailNumber, status, gateNumber))
 
     def getNOTAMs(self, callback, departureICAO, arrivalICAO):
@@ -1169,15 +1094,9 @@
     def sendPIREP(self, callback, pirep):
         """Send the given PIREP."""
-        request = \
-          SendPIREPRPC(self._rpcClient, callback, pirep) if self._config.useRPC \
-          else SendPIREP(callback, pirep)
-        self._addRequest(request)
+        self._addRequest(SendPIREP(callback, pirep))
 
     def sendACARS(self, callback, acars):
         """Send the given ACARS"""
-        request = \
-          SendACARSRPC(self._rpcClient, callback, acars) if self._config.useRPC \
-          else SendACARS(callback, acars)
-        self._addRequest(request)
+        self._addRequest(SendACARS(callback, acars))
 
     def sendBugReport(self, callback, summary, description, email):
