def mytest(ip, port, username, password):
    domain = ""
    width = 1024
    height = 800
    fullscreen = False
    optimized = False
    recodedPath = None
    keyboardLayout = 'en'
    app = QtGui.QApplication(sys.argv)

    #add qt4 reactor
    import qt4reactor
    qt4reactor.install()

    if fullscreen:
        width = QtGui.QDesktopWidget().screenGeometry().width()
        height = QtGui.QDesktopWidget().screenGeometry().height()

    log.info("keyboard layout set to %s"%keyboardLayout)

    from twisted.internet import reactor
    ret = {"connected": False}
    mytimer = TimerThread(app, reactor, ret)
    mytimer.start()

    reactor.connectTCP(ip, int(port), RDPClientQtFactory(width, height, username, password, domain, fullscreen, keyboardLayout, optimized, "nego", recodedPath, mytimer))
    reactor.runReturn()
    app.exec_()
    return ret["connected"]

 def onReady(self):
     """
     @summary: callback use when RDP stack is connected (just before received bitmap)
     """
     log.info("connected %s"%addr)
     width, height = self._controller.getScreen()
     self._buffer = QtGui.QImage(width, height, QtGui.QImage.Format_RGB32)

    def sendWheelEvent(self, x, y, step, isNegative = False, isHorizontal = False):
        """
        @summary: Send a mouse wheel event
        @param x: x position of pointer
        @param y: y position of pointer
        @param step: number of step rolled
        @param isHorizontal: horizontal wheel (default is vertical)
        @param isNegative: is upper (default down)
        """
        if not self._isReady:
            return

        try:
            event = pdu.data.PointerEvent()
            if isHorizontal:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_HWHEEL
            else:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_WHEEL
                
            if isNegative:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_WHEEL_NEGATIVE
                
            event.pointerFlags.value |= (step & pdu.data.PointerFlag.WheelRotationMask)
            
            #position
            event.xPos.value = x
            event.yPos.value = y
            
            #send proper event
            self._pduLayer.sendInputEvents([event])
            
        except InvalidValue:
            log.info("try send wheel event with incorrect position")

 def onReady(self):
     """
     @summary:  Event use to inform state of server stack
                 First time this event is called is when human client is connected
                 Second time is after color depth nego, because color depth nego
                 restart a connection sequence
     @see: rdp.RDPServerObserver.onReady
     """
     if self._rssFile is None:
         #compute which RSS file to keep
         width, height = self._controller.getScreen()
         size = width * height
         rssFilePath = sorted(self._rssFileSizeList, key = lambda x: abs(x[0][0] * x[0][1] - size))[0][1]
         log.info("select file (%s, %s) -> %s"%(width, height, rssFilePath))
         self._rssFile = rss.createReader(rssFilePath)
     
     domain, username, password = self._controller.getCredentials()
     hostname = self._controller.getHostname()
     log.info("""Credentials:
     \tdomain : %s
     \tusername : %s
     \tpassword : %s
     \thostname : %s
     """%(domain, username, password, hostname));
     self.start()

    def sendPointerEvent(self, x, y, button, isPressed):
        """
        @summary: send pointer events
        @param x: x position of pointer
        @param y: y position of pointer
        @param button: 1 or 2 or 3
        @param isPressed: true if button is pressed or false if it's released
        """
        if not self._isReady:
            return

        try:
            event = pdu.data.PointerEvent()
            if isPressed:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_DOWN
            
            if button == 1:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_BUTTON1
            elif button == 2:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_BUTTON2
            elif button == 3:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_BUTTON3
            else:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_MOVE
            
            #position
            event.xPos.value = x
            event.yPos.value = y
            
            #send proper event
            self._pduLayer.sendInputEvents([event])
            
        except InvalidValue:
            log.info("try send pointer event with incorrect position")

    def recvData(self, data):
        """
        @summary: Main receive method
        @param data: {Stream} 
        """
        opcode = UInt8()
        data.readType(opcode)
        
        if self.readMCSPDUHeader(opcode.value, DomainMCSPDU.DISCONNECT_PROVIDER_ULTIMATUM):
            log.info("MCS DISCONNECT_PROVIDER_ULTIMATUM")
            self._transport.close()
            return
        
        #client case
        elif not self.readMCSPDUHeader(opcode.value, self._receiveOpcode):
            raise InvalidExpectedDataException("Invalid expected MCS opcode receive data")
        
        #server user id
        per.readInteger16(data, Channel.MCS_USERCHANNEL_BASE)
        
        channelId = per.readInteger16(data)
        
        per.readEnumerates(data)       
        per.readLength(data)
        
        #channel id doesn't match a requested layer
        if not self._channels.has_key(channelId):
            log.error("receive data for an unconnected layer")
            return

        self._channels[channelId].recv(data) 

 def clientConnectionFailed(self, connector, reason):
     """
     @summary: Connection failed event
     @param connector: twisted connector use for rdp connection (use reconnect to restart connection)
     @param reason: str use to advertise reason of lost connection
     """
     self._mytimer.conn_fail()
     log.info("Connection failed : %s"%reason)

 def buildObserver(self, controller, addr):
     """
     @param controller: {rdp.RDPServerController}
     @param addr: destination address
     @see: rdp.ServerFactory.buildObserver
     """
     log.info("Connection from %s:%s"%(addr.host, addr.port))
     return HoneyPotServer(controller, self._rssFileSizeList)

 def clientConnectionFailed(self, connector, reason):
     """
     @summary: Connection failed event
     @param connector: twisted connector use for rdp connection (use reconnect to restart connection)
     @param reason: str use to advertise reason of lost connection
     """
     log.info("Connection failed : %s"%reason)
     reactor.stop()
     app.exit()

 def onKeyEventUnicode(self, code, isPressed):
     """
     @summary: Event call when a keyboard event is catch in unicode format
     @param code: unicode of key
     @param isPressed: True if key is down
     @see: rdp.RDPServerObserver.onKeyEventUnicode
     """
     if not isPressed:
         k.type_string(chr(code))
         log.info("KeyEventUnicode: " + chr(code))

 def onClose(self):
     """
     @summary: callback use when RDP stack is closed
     """
     log.info("save screenshot into %s" % self._path)
     if self._complete:
         if self._dbm:
             self._dbm.open_connection()
             self._dbm.update_vnc_rdp_object(self._obj)
             self._dbm.close()
         self._buffer.save(self._path)

 def clientConnectionFailed(self, connector, reason):
     """
     @summary: Connection failed event
     @param connector: twisted connector use for rfb connection (use reconnect to restart connection)
     @param reason: str use to advertise reason of lost connection
     """
     log.info("connection failed : %s"%reason)
     RFBScreenShotFactory.__INSTANCE__ -= 1
     if(RFBScreenShotFactory.__INSTANCE__ == 0):
         reactor.stop()
         app.exit()

 def clientConnectionFailed(self, connector, reason):
     """
     @summary: Connection failed event
     @param connector: twisted connector use for rdp connection (use reconnect to restart connection)
     @param reason: str use to advertise reason of lost connection
     """
     log.info("connection failed : %s"%reason)
     RDPScreenShotFactory.__STATE__.append((connector.host, connector.port, reason))
     RDPScreenShotFactory.__INSTANCE__ -= 1
     if(RDPScreenShotFactory.__INSTANCE__ == 0):
         self._reactor.stop()
         self._app.exit()

 def recvSecurityResult(self, data):
     """
     Read security result packet
     Use by server to inform connection status of client
     @param data: Stream that contain well formed packet 
     """
     result = UInt32Be()
     data.readType(result)
     if result == UInt32Be(1):
         log.info("Authentification failed")
         if self._version.value == ProtocolVersion.RFB003008:
             self.expectWithHeader(4, self.recvSecurityFailed)
     else:
         log.debug("Authentification OK")
         self.sendClientInit()

 def onPointerEvent(self, x, y, button, isPressed):
     """
     @summary: Event call on mouse event
     @param x: x position
     @param y: y position
     @param button: 1, 2 or 3 button
     @param isPressed: True if mouse button is pressed
     @see: rdp.RDPServerObserver.onPointerEvent
     """
     if isPressed:
         m.press(x, y, button)
         time.sleep(0.05)
         m.release(x, y)
     else:
         m.move(x, y)
     log.info("PointerEvent: " + str(x) + " " + str(y) + " @" + datetime.now().strftime("%Y-%m-%d %H:%M:%S"))

 def recvServerName(self, data):
     """
     @summary: Read server name
     @param data: Stream that contains well formed packet
     """
     data.readType(self._serverName)
     log.info("Server name %s"%str(self._serverName))
     #end of handshake
     #send pixel format
     self.sendPixelFormat(self._pixelFormat)
     #write encoding
     self.sendSetEncoding()
     #request entire zone
     self.sendFramebufferUpdateRequest(False, 0, 0, self._serverInit.width.value, self._serverInit.height.value)
     #now i'm ready to send event
     self._clientListener.onReady()
     self.expect(1, self.recvServerOrder)

 def sendKeyEvent(self, isDown, key):
     """
     @summary: Send a key event throw RFB protocol
     @param isDown: boolean notify if key is pressed or not (True if key is pressed)
     @param key: ASCII code of key
     """
     if not self._isReady:
         log.info("Try to send key event on non ready layer")
         return
     try:
         event = KeyEvent()
         event.downFlag.value = isDown
         event.key.value = key
     
         self._rfbLayer.sendKeyEvent(event)
     except InvalidValue:
         log.debug("Try to send an invalid key event")

    def clientConnectionLost(self, connector, reason):
        """
        @summary: Connection lost event
        @param connector: twisted connector use for rdp connection (use reconnect to restart connection)
        @param reason: str use to advertise reason of lost connection
        """
        #try reconnect with basic RDP security
        if reason.type == RDPSecurityNegoFail and self._nego:
            #stop nego
            log.info("due to security nego error back to standard RDP security layer")
            self._nego = False
            self._security = rdp.SecurityLevel.RDP_LEVEL_RDP
            self._client._widget.hide()
            connector.connect()
            return

        self._mytimer.conn_fail()
        log.info("Lost connection : %s"%reason)

 def clientConnectionLost(self, connector, reason):
     """
     @summary: Connection lost event
     @param connector: twisted connector use for rdp connection (use reconnect to restart connection)
     @param reason: str use to advertise reason of lost connection
     """
     if reason.type == RDPSecurityNegoFail and self._security != "rdp":
         log.info("due to RDPSecurityNegoFail try standard security layer")
         self._security = rdp.SecurityLevel.RDP_LEVEL_RDP
         connector.connect()
         return
     
     log.info("connection lost : %s"%reason)
     RDPScreenShotFactory.__STATE__.append((connector.host, connector.port, reason))
     RDPScreenShotFactory.__INSTANCE__ -= 1
     if(RDPScreenShotFactory.__INSTANCE__ == 0):
         self._reactor.stop()
         self._app.exit()

 def sendPointerEvent(self, mask, x, y):
     """
     @summary: Send a pointer event throw RFB protocol
     @param mask: mask of button if button 1 and 3 are pressed then mask is 00000101
     @param x: x coordinate of mouse pointer
     @param y: y pointer of mouse pointer
     """
     if not self._isReady:
         log.info("Try to send pointer event on non ready layer")
         return
     try:
         event = PointerEvent()
         event.mask.value = mask
         event.x.value = x
         event.y.value = y
         
         self._rfbLayer.sendPointerEvent(event)
     except InvalidValue:
         log.debug("Try to send an invalid pointer event")