示例#1
0
	def main(self):
		(self.options, args) = self.parser.parse_args()
		#print("===================================")
		#print(self.options, args)
		#self.usage()
		#print(self.config)
		#print("===================================")
		protocol = Protocol()
		
		if self.options.id2ip :
			print(protocol.id2ip(int(self.options.cai), int(self.options.id2ip)))
		elif self.options.ip2id :
			print(protocol.ip2id(str(self.options.ip2id)))
		elif self.options.tms :
			tms = TMS()
			tms.sendtoid(int(self.options.cai), int(self.options.tms), args[0])
		elif self.options.route :
                        print("Please add the following route:")
                        print("route add %s.0.0.0 mask 255.0.0.0 192.168.11.1" % self.options.cai)
		elif self.options.ping :
                        os.system("ping %s" % self.options.ping)
		elif self.options.online :
                        os.system("ping %s" % protocol.id2ip(int(self.options.cai), int(self.options.online))) 
		else:
			self.usage()
示例#2
0
 def btn_6_delete(self):
     data = []
     id_line = {}
     row_count = self.tableWidget_6_delete.rowCount()
     for i in range(row_count):
         id = self.tableWidget_6_delete.item(i, 0).text()
         # 不需要发送其他信息,因为服务器只用id检索条目进行删除
         if not id:
             id = "$"
         name = "$"
         sex = "$"
         age = "$"
         #name = self.tableWidget_6_delete.item(i, 1).text()
         #sex = self.tableWidget_6_delete.item(i, 2).text()
         #age = self.tableWidget_6_delete.item(i, 3).text()
         if not re.match(r"\b\d{6}\b", id):
             self.tableWidget_6_delete.setItem(i, 4, QtWidgets.QTableWidgetItem("Error"))
             continue
         item_str = Protocol.item_pack(id, name, sex, age)
         id_line[id] = i
         data.append(item_str)
     # 发送信息
     header = Protocol.gen_default_header()
     smsg = Protocol.msg_pack("DELETE", header, data)
     sock.send(smsg.encode("unicode_escape"))
     # 接收服务器发回的信息
     rmsg = sock.recv(1024).decode("unicode_escape")
     print(rmsg)
     rst = Protocol.msg_unpack(rmsg)
     rhear_line = rst[0]
     rheader = rst[1]
     rdata = rst[2]
     for id in id_line:
         self.tableWidget_6_delete.setItem(id_line[id], 4, QtWidgets.QTableWidgetItem(rheader[id]))
示例#3
0
  def setSpeed(self, pluginAction, dev):
    try:
      newValue = int(pluginAction.props.get(u"speed", 100))
    except ValueError:
      # The int() cast above might fail if the user didn't enter a number:
      indigo.server.log(u"set speed to device \"%s\" -- invalid value" % (dev.name), isError=True)
      return

    m = Magiccolor()
    m.connect()
    p = Protocol()
    p.keyNum=p.MODE_SPEED
    p.keyValue=newValue
    m.sendMsg(p)

    sendSuccess = True    # Set to False if it failed.

    if sendSuccess:
      # If success then log that the command was successfully sent.
      indigo.server.log(u"sent \"%s\" %s to %d" % (dev.name, "set speed", newValue))

      # And then tell the Indigo Server to update the state:
      dev.updateStateOnServer("programNumber", newValue)
    else:
      # Else log failure but do NOT update state on Indigo Server.
      indigo.server.log(u"send \"%s\" %s to %d failed" % (dev.name, "set speed", newValue), isError=True)
def get_value_4(Window, entry1, entry2, entry3, entry4, protocole,
                ProtoWindow):
    """
    This program gets 4 values from a label.
    
    Entry:
        Window(Frame): the protocol window
        entry1(Label variable): the first value to get
        entry2(Label variable): the second value to get
        entry3(Label variable): the third value to get
        entry4(Label variable): the fourth value to get
        protocole(list): the list of the protocole
        ProtoWindow(Frame): the protocol frame
    """
    pos = protocole.index(['position'])
    protocole[pos - 1] = [
        protocole[pos - 1][0],
        entry1.get(),
        entry2.get(),
        entry3.get(),
        entry4.get()
    ]
    Prot.EcrireProtocoleFichier(protocole, 'temp.txt')
    Prot.AfficherProtocol(ProtoWindow, protocole)
    Window.destroy()
    def __handle_existing_connections(self):
        # IF no_errors then:
		
        # Gets the player's move (who's turn is up)
        num, msg = Protocol.recv_all(self.players_sockets[self.turn])
        if num == Protocol.NetworkErrorCodes.DISCONNECTED:
            Protocol.send_all(self.players_sockets[1 - self.turn], 'EXIT')
            self.shut_down_server()
        # Sends the move to his opponent
        if num != Protocol.NetworkErrorCodes.FAILURE:
			eNum, eMsg = Protocol.send_all(self.players_sockets[1 - self.turn], msg)
			if eNum == Protocol.NetworkErrorCodes.FAILURE:
				Protocol.send_all(self.players_sockets[self.turn], 'EXIT')
				self.shut_down_server()
			# Receives the opponent's response
			num, msg = Protocol.recv_all(self.players_sockets[1- self.turn])
			if num == Protocol.NetworkErrorCodes.FAILURE:
				print msg
				self.shut_down_server()
			if num == Protocol.NetworkErrorCodes.DISCONNECTED:
				Protocol.send_all(self.players_sockets[self.turn], 'EXIT')
				self.shut_down_server()
			# Sends the response back to the player who's turn is up
			eNum, eMsg = Protocol.send_all(self.players_sockets[self.turn], msg)
			if eNum:
				print eMsg
				self.close_client()
示例#6
0
  def setPause(self, pluginAction, dev):
    newValue = pluginAction.props.get(u"pauseRun", False)

    m = Magiccolor()
    m.connect()
    p = Protocol()
    p.keyNum=p.MODE_PAUSE

    indigo.server.log("%d" % newValue)

    if newValue:
      p.keyValue=1
    else:
      p.keyValue=0

    m.sendMsg(p)
    sendSuccess = True    # Set to False if it failed.

    if sendSuccess:
      # If success then log that the command was successfully sent.
      indigo.server.log(u"sent \"%s\" %s to %d" % (dev.name, "pause", newValue))

      # And then tell the Indigo Server to update the state:
      dev.updateStateOnServer("pauseRun", newValue)
    else:
      # Else log failure but do NOT update state on Indigo Server.
      indigo.server.log(u"send \"%s\" %s to %d failed" % (dev.name, "set pause", newValue), isError=True)
示例#7
0
    def btn_4_search(self):
        id = self.lineEdit_4_old_id.text()
        if not id:
            id = "$"
        name = "$"
        sex = "$"
        age = "$"
        data = []
        item_str = Protocol.item_pack(id, name, sex, age)
        data.append(item_str)
        header = Protocol.gen_default_header()
        smsg = Protocol.msg_pack("SEARCH", header, data)
        #print(smsg, end="")
        sock.send(smsg.encode("unicode_escape"))

        rmsg = sock.recv(1024).decode("unicode_escape")
        print(rmsg)
        rst = Protocol.msg_unpack(rmsg)
        rhead_line = rst[0]
        rheader = rst[1]
        rdata = rst[2]
        #item_str = rdata[0]

        if len(rdata)>0:
            item_str = rdata[0]
            item = item_str.split()
            self.lineEdit_4_old_id.setText(item[0])
            self.lineEdit_4_old_name.setText(item[1])
            self.lineEdit_4_old_sex.setText(item[2])
            self.lineEdit_4_old_age.setText(item[3])
            self.lineEdit_4_new_id.setText(item[0])
            self.lineEdit_4_new_name.setText(item[1])
            self.lineEdit_4_new_sex.setText(item[2])
            self.lineEdit_4_new_age.setText(item[3])
    def __handle_new_connection(self):
        
        connection, client_address = self.l_socket.accept()

        # Request from new client to send his name
        eNum, eMsg = Protocol.send_all(connection, "ok_name")
        if eNum:
            sys.stderr.write(eMsg)
            self.shut_down_server()
        
        ################################################
        
        
        # Receive new client's name
        num, msg = Protocol.recv_all(connection)
        if num == Protocol.NetworkErrorCodes.FAILURE:
            sys.stderr.write(msg)
            self.shut_down_server()

        if num == Protocol.NetworkErrorCodes.DISCONNECTED:

            sys.stderr.write(msg)
            self.shut_down_server()
        
        self.players_names.append(msg)

        self.players_sockets.append(connection)
        self.all_sockets.append(connection)
        print "New client named '%s' has connected at address %s." % (msg,client_address[0])

        if len(self.players_sockets) == 2:  # we can start the game
            self.__set_start_game(0) 
            self.__set_start_game(1)
示例#9
0
def multiblock_encryption(c, key_id, versus, data, block_size, working_key_mode, working_key = ''):
        """
        TODO.
    
        """
	start = False
	chaining_data = ''
	result = ''
	while data != '':
		if len(data) <= block_size and not start:
			buff = data
			data = ''
			flag = 0x03
			start = True
		else:
			if len(data) > block_size:
				buff = data[:block_size]
				data = data[block_size:]
				flag = 0x00 # body
			else:
				buff = data 
				data = ''
				flag = 0x02 # end
			if not start:
				flag = 0x01 # start
				start = True
		Protocol.send_multiblock_encryption(c, key_id, flag, versus, buff, chaining_data, working_key_mode, working_key)
		ack = Protocol.recv_multiblock_encryption(c, 4)
		if ack['ack_code'] == 0x00:
			chaining_data = ack['chaining_data']
			result += ack['data']
		else: break
	return ack['ack_code'], result
示例#10
0
 def btn_4_update(self):
     # 获取文本框内容
     id = self.lineEdit_4_new_id.text()
     if not id:
         id = "$"
     name = self.lineEdit_4_new_name.text()
     if not name:
         name = "$"
     sex = self.lineEdit_4_new_sex.text()
     if not sex:
         sex = "$"
     age = self.lineEdit_4_new_age.text()
     if not age:
         age = "$"
     # 检查数据是否符合规范
     if self.check_item([id, name, sex, age, ""]):
         # 发送更新的条目信息
         data = []
         item_str = Protocol.item_pack(id, name, sex, age)
         data.append(item_str)
         header = Protocol.gen_default_header()
         smsg = Protocol.msg_pack("UPDATE", header, data)
         #print(smsg, end="")
         sock.send(smsg.encode("unicode_escape"))
         # 接收服务器发回的信息
         rmsg = sock.recv(1024).decode("unicode_escape")
         print(rmsg)
         rst = Protocol.msg_unpack(rmsg)
         rhead_line = rst[0]
         rheader = rst[1]
         rdata = rst[2]
         self.lineEdit_4_state.setText(rheader[id])
     else:
         self.lineEdit_4_state.setText("Error")
示例#11
0
    def start(self, serverSocket, addr):
        print("Client connected: ", addr)
        try:

            while True:
                dataRec = serverSocket.recv(1024)
                header, msg = Protocol.decodeMessage(dataRec.decode())
                print("Header: ", header)
                print("Message: ", msg)

                if (header == Protocol.HEAD_REQUEST):
                    self.sendFileList(serverSocket)
                    break
                elif (header == Protocol.HEAD_FILE):
                    self.sendFile(serverSocket,
                                  self.conf.serverSharePath + "/" + msg)
                    break
                elif (header == Protocol.HEAD_UPLOAD):
                    self.receiveFile(serverSocket,
                                     self.conf.serverDownloadPath + "/" + msg)
                    break
                else:
                    serverSocket.send(
                        Protocol.prepareMessage(Protocol.HEAD_ERROR, ""))
                    break
        except Exception as e:
            print("Error: ", e)

        print("Client disconnected: ", addr)
        serverSocket.close()
示例#12
0
 def getStatus(self, strIDs, timeout):
     # convert str to list
     ids = strIDs.split()
     # peek jobs
     tmpWrapper = _TimedMethod(self.taskBuffer.peekJobs, timeout)
     tmpWrapper.run(ids, False, True, True, False)
     # make response
     if tmpWrapper.result == Protocol.TimeOutToken:
         # timeout
         response = Protocol.Response(Protocol.SC_TimeOut)
     else:
         if isinstance(tmpWrapper.result, types.ListType):
             # succeed
             response = Protocol.Response(Protocol.SC_Success)
             # make return
             retStr = ''
             attStr = ''
             for job in tmpWrapper.result:
                 if job == None:
                     retStr += '%s+' % 'notfound'
                     attStr += '0+'
                 else:
                     retStr += '%s+' % job.jobStatus
                     attStr += '%s+' % job.attemptNr
             response.appendNode('status', retStr[:-1])
             response.appendNode('attemptNr', attStr[:-1])
         else:
             # failed
             response = Protocol.Response(Protocol.SC_Failed)
     _logger.debug("getStatus : %s ret -> %s" % (strIDs, response.encode()))
     return response.encode()
示例#13
0
	def configureEEG(self):
		
		if not self.emulate_headset_data:
			
			self.serial_device = \
				serial_interface.SerialDevice( \
					self.log, \
					device_address=self.device_address, \
					DEBUG=self.DEBUG, \
					parent=self)
			
			self.serial_device.start()
		
		else:
			self.serial_device = None
		
		
		self.protocol = \
			serial_interface.ProtocolHandler( \
				self.log, \
				self.serial_device, \
				device_id=self.device_id, \
				device_model=self.device_model, \
				DEBUG=self.DEBUG, \
				parent=self)
		
		self.protocol.start()
示例#14
0
def launch(name):
    # Game
    game = Game.Game()
    
    # Try to connect 
    socket = Network.connect("192.168.0.3", 8080)
    Protocol.setName(socket, name)
    
    # Thread for inputs
    q = queue.Queue()
    t = None
    startThread(t, q)
    
        
    # Main event loop
    data = bytes()
    while True:
        # Send commands
        try:  
            line = q.get_nowait()
            interpretCommand(line, socket)
        except queue.Empty:
            pass
        
        # Get order
        order = Network.getOrder(socket)
        
        try:
            if order is not None:
                Protocol.manageOrder(socket, order, game)
        except Protocol.ByeException:
            break    
    
    socket.close()
示例#15
0
文件: Room.py 项目: ArildF/rogie
    def join( self, sock ):
        """Join a room using the given socket"""
        login = Protocol.getProtocol().getInitJoinPacket( self.nick )
        login.send( sock )
        
        time.sleep( 2 )

        login = Protocol.getProtocol().getJoinPacket( self.nick, self.roomName )
        login.send( sock )
示例#16
0
def sketch_loop():
   global sketchQueue
   global sketchRun
   global proxyCmdBuffer
   global proxyRxBuffer

   toSend = []
   rxBytes = []

   target = 1
   temperature = 80
   rssi = -60
   timestamp = 0

   WRITE = 2
   SREG_TARGET = 7
   SREG_PING = 11
   PING = 1

   while sketchRun:
      for target in range(2,6):
         # set target
         toSend = Protocol.form_packet(cmd=WRITE, addr=SREG_TARGET, data=target)
         for b in toSend:
            proxyCmdBuffer.write(b)

         #get response
         rxBytes = []
         rxBytes.append(ord(proxyRxBuffer.read()))
         rxBytes.append(ord(proxyRxBuffer.read()))

         for i in range(rxBytes[-1]):
            rxBytes.append(ord(proxyRxBuffer.read()))
         rxBytes.append(ord(proxyRxBuffer.read()))      

############## get data
         toSend = Protocol.form_packet(cmd=WRITE, addr=SREG_PING, data=PING)
         for b in toSend:
            proxyCmdBuffer.write(b)

         #get response
         rxBytes = []
         rxBytes.append(ord(proxyRxBuffer.read()))
         rxBytes.append(ord(proxyRxBuffer.read()))

         for i in range(rxBytes[-1]):
            rxBytes.append(ord(proxyRxBuffer.read()))
         rxBytes.append(ord(proxyRxBuffer.read()))         

         rssi = -((rxBytes[3]^0xff)+1)
         temperature = rxBytes[4]
         timestamp = time.time()
         sketchQueue.put({'timestamp':timestamp, 'id':target, 'network':'BP', 'data':{'temp':temperature, 'rssi':rssi} })
         time.sleep(0.1)
示例#17
0
    def test_v1_functionality(self):

        vehicle_id = 1
        lon = 16.1784483
        lat = 51.1826638
        action_id = 5

        data = (vehicle_id, lat, lon, action_id)
        packet = Protocol.encode(data)

        assert data == Protocol.decode(packet)
示例#18
0
 def finish_request(self, request, client_address):
     data, _ = request
     ipacket = Protocol.Packet ( data )
     if ipacket.opcode == Protocol.Packet.RRQ:
         if not self.handle_RRQ (ipacket, client_address):
             Protocol.Send_ERROR (client_address, 2)
     elif ipacket.opcode == Protocol.Packet.WRQ:
         self.handle_WRQ (ipacket, client_address)
     else:
         self.report_error ( "Message from %s, opcode %s, does not belong to a known session." %
                             (client_address, ipacket.opcode) )
示例#19
0
 def getKeyPair(self, realDN, publicKeyName, privateKeyName):
     tmpMsg = "getKeyPair {0}/{1} : ".format(publicKeyName, privateKeyName)
     if realDN == None:
         # cannot extract DN
         tmpMsg += "failed since DN cannot be extracted"
         _logger.debug(tmpMsg)
         response = Protocol.Response(
             Protocol.SC_Perms, 'Cannot extract DN from proxy. not HTTPS?')
     else:
         # get compact DN
         compactDN = self.taskBuffer.cleanUserID(realDN)
         # check permission
         self.specialDispatchParams.update()
         if not 'allowKey' in self.specialDispatchParams:
             allowKey = []
         else:
             allowKey = self.specialDispatchParams['allowKey']
         if not compactDN in allowKey:
             # permission denied
             tmpMsg += "failed since '{0}' not in the authorized user list who have 'k' in {1}.USERS.GRIDPREF".format(
                 compactDN, panda_config.schemaMETA)
             _logger.debug(tmpMsg)
             response = Protocol.Response(Protocol.SC_Perms, tmpMsg)
         else:
             # look for key pair
             if not 'keyPair' in self.specialDispatchParams:
                 keyPair = {}
             else:
                 keyPair = self.specialDispatchParams['keyPair']
             notFound = False
             if not publicKeyName in keyPair:
                 # public key is missing
                 notFound = True
                 tmpMsg += "failed for '{2}' since {0} is missing on {1}".format(
                     publicKeyName, socket.getfqdn(), compactDN)
             elif not privateKeyName in keyPair:
                 # private key is missing
                 notFound = True
                 tmpMsg += "failed for '{2}' since {0} is missing on {1}".format(
                     privateKeyName, socket.getfqdn(), compactDN)
             if notFound:
                 # private or public key is missing
                 _logger.debug(tmpMsg)
                 response = Protocol.Response(Protocol.SC_MissKey, tmpMsg)
             else:
                 # key pair is available
                 response = Protocol.Response(Protocol.SC_Success)
                 response.appendNode('publicKey', keyPair[publicKeyName])
                 response.appendNode('privateKey', keyPair[privateKeyName])
                 tmpMsg += "sent key-pair to '{0}'".format(compactDN)
                 _logger.debug(tmpMsg)
     # return
     return response.encode()
示例#20
0
    def _dispatch_packet(self, head=Protocol.NET_HEAD(), packet_data=""):
        header = packet_data
        url = Protocol.get_url(header)
        if not url:
            return
        params = Protocol.urlparams2dict(url)
        try:
            service = url[0:8]
            if service != "/chelun?":
                #logger.error("Recv|not chelun service:%s|header:%s",url,header)
                return
            query = params["query"]
            cityid = params["cityid"]
            if not query:
                logger.error("Recv|invalid query:%s", url)
                return

            citykey = DataSource.get_weather_citykey(cityid)
            if not citykey:
                logger.error("Recv|invalid cityid:%s", url)
                return

#logger.debug("Recv|Url:%s",url)
            task = Protocol.REQUEST_PACKET()
            task.request_type = head.request_type
            task.request_key = citykey
            task.request_tick = Utils.gettickcount()

            if query in ["weather", "weather2"]:
                weather_data = KvCache.get_data_from_cache(k=citykey)
                if not weather_data:
                    logger.debug(
                        "Recv|get_data_from_cache failed;then ask worker;%s",
                        url)
                    MsgPipe.MsgPipe.push(fileno=self.client_socket.fileno(),
                                         sessionid=self.client_session_id,
                                         msgdata=task)
                    return
                logger.debug("Recv|get_data_from_cache succ;%s", url)
                self.send_data_bychunked(weather_data)
                return
            elif query == "weather3":
                task.request_type = "TEST"
                logger.debug("Recv|Test;%s", url)
                MsgPipe.MsgPipe.push(fileno=self.client_socket.fileno(),
                                     sessionid=self.client_session_id,
                                     msgdata=task)
                return
            pass

        except:
            pass
        pass
示例#21
0
 def __init__(self, main_server_address=None, user_data=None):
     if (main_server_address):
         self.main_server_address = main_server_address
     else:
         self.main_server_address = ('localhost', 56789)
     self.dtp_server_address = None
     self.logger = Protocol.Logger()
     self.parser = Protocol.Parser(module=Protocol)
     self.user_data = None
     self.sock = None
     self.data_sock = None
     self.book_data = None
示例#22
0
def preopt_image(myconnection, head_line, header, data):
    id = header["Image"]
    file_name = header["FileName"]
    file_size = header["FileSize"]
    path = os.getcwd() + "/" + id + "_" + file_name
    fp = open(path, "wb")
    fp.close()
    sheader = Protocol.gen_default_header()
    info = "Image_" + id
    sheader.update({info: "READY", "Path": path})
    smsg = Protocol.msg_pack("300", sheader, [])
    myconnection.send(smsg.encode("unicode_escape"))
    return path
示例#23
0
def basicUnitTest():
    client = Protocol.ForgotPasswordClientProtocol()
    server = Protocol.ForgotPasswordServerProtocol()
    cTransport, sTransport = MockTransportToProtocol.CreateTransportPair(
        client, server)

    server.connection_made(sTransport)
    client.connection_made(cTransport)
    # client.send_initial_message()

    packet1 = Packets.RequestForgotPasswordPacket()
    packet1.userId = 'ehsia1'
    packet1Bytes = packet1.__serialize__()
    sResponse1 = server.data_received(packet1Bytes)
    assert isinstance(sResponse1, Packets.SecurityQuestionPacket)
    packet2 = Packets.SecurityQuestionPacket()
    packet2.securityQuestion = 'What was your hometown?'
    packet2Bytes = packet2.__serialize__()
    cResponse1 = client.data_received(packet2Bytes)
    cResponse1 = PacketType.Deserialize(cResponse1)
    assert isinstance(cResponse1, Packets.SecurityAnswerPacket)
    packet3 = Packets.SecurityAnswerPacket()
    packet3.securityAnswer = 'Windsor, CT'
    packet3Bytes = packet3.__serialize__()
    sResponse2 = server.data_received(packet3Bytes)
    assert isinstance(sResponse2, Packets.ForgotPasswordTokenPacket)
    packet3.securityAnswer = 'Windsor'
    packet3Bytes = packet3.__serialize__()
    sResponse2 = server.data_received(packet3Bytes)
    assert sResponse2 == "Invalid"
    packet4 = Packets.ForgotPasswordTokenPacket()
    packet4.token = 'asdf2313241SqwerXq'
    packet4Bytes = packet4.__serialize__()
    cResponse2 = client.data_received(packet4Bytes)
    cResponse2 = PacketType.Deserialize(cResponse2)
    assert isinstance(cResponse2, Packets.ResetPasswordInputPacket)
    packet5 = Packets.ResetPasswordInputPacket()
    packet5.newPassword = '******'
    packet5.passwordConfirmation = 'gronkgronkgronk'
    packet5Bytes = packet5.__serialize__()
    sResponse3 = server.data_received(packet5Bytes)
    assert isinstance(sResponse3, Packets.PasswordResetPacket)
    assert sResponse3.verification == True
    packet5.newPassword = '******'
    packet5.passwordConfirmation = 'gronkgronkgronk'
    packet5Bytes = packet5.__serialize__()
    sResponse3 = server.data_received(packet5Bytes)
    assert isinstance(sResponse3, Packets.PasswordResetPacket)
    assert sResponse3.verification == False

    print("Protocol completed! All tests passed!")
		def ConnectedCallback(_socket):
			if _socket is not None:
				self._ConnectingConfirm(socket_id, _socket)
				confirm_message = Protocol.PackMapCtrlMsg('link_confirm', socket_id)
				self._SelfSendData(confirm_message)
				self._Log(logging.DEBUG, 'Sending confirm message to remote, ID: [%d]', socket_id)
			else:
				try:
					refuse_message = Protocol.PackMapCtrlMsg('link_refuse', socket_id)
					self._SelfSendData(refuse_message)
					self._DelConnectingInfo(socket_id)
					self._Log(logging.DEBUG, 'Sending refuse message to remote, ID: [%d]', socket_id)
				except socket.error:
					pass
示例#25
0
    def uploadFile(self, uploadFileName):
        mySocket = self.connect()
        request = Protocol.prepareMessage(Protocol.HEAD_UPLOAD, uploadFileName)
        mySocket.send(request)

        header, msg = Protocol.decodeMessage(mySocket.recv(1024).decode())

        if (header == Protocol.HEAD_READY):
            f = open(self.conf.clientSharePath + "/" + uploadFileName, 'rb')
            l = f.read(1024)
            while (l):
                mySocket.send(l)
                l = f.read(1024)
        else:
            print("Upload Failed: \nHeader: ", header, " \nMessage: ", msg)
示例#26
0
    def getDownloadFileList(self):
        mySocket = self.connect()

        request = Protocol.prepareMessage(Protocol.HEAD_REQUEST, "")
        mySocket.send(request)

        header, msg = Protocol.decodeMessage(mySocket.recv(1024).decode())

        mySocket.close()

        if (header == Protocol.HEAD_REQUEST):
            files = msg.split(",")
            self.downloadFileList = []
            for f in files:
                self.downloadFileList.append(f)
示例#27
0
def protocolController():
    loop = asyncio.get_event_loop()
    loop.set_debug(enabled=True)
    client = Protocol.ForgotPasswordClientProtocol()
    server = Protocol.ForgotPasswordServerProtocol()
    serv = playground.getConnector().create_playground_server(
        lambda: server, 8080)
    s = loop.run_until_complete(serv)
    print("Echo server running at {}".format(s.sockets[0].gethostname()))
    cli = playground.getConnector().create_playground_connection(
        lambda: client, "20174.1.1.1", 8080)
    transport, protocol = loop.run_until_complete(cli)
    print("Echo client running with t:{}. p:{}".format(transport, protocol))
    loop.run_forever()
    loop.close()
示例#28
0
    def returnBook(self):
        # return book to libaray server
        # send memo xml file to data server
        try:
            sock = socket.create_connection(self.server_address)
            content = ''
            logging.debug(self.book_title)
            with open(here("clientdata/" + self.book_title + ".xml"),
                      "r") as xmlfd:
                for r in xmlfd:
                    content += r
            f = sock.makefile("rwb", 0)
            data = Protocol.ReturnRequest(book_title=self.book_title,
                                          memo_content=content,
                                          user_id=self.user_data.userId)
            f.write(data.serialize())
            rdata = sock.recv(1024)
            recv_data = Protocol.ReturnRequest.parse(rdata)

            logging.debug("return " + bytes.decode(recv_data.memo_content))
            os.remove(here("clientdata/" + self.book_title + ".pdf"))
            self.setParent(None)
        except IOError as e:
            logging.debug(e)
        except Exception as e:
            logging.debug(e)
        else:
            f.close()
            sock.close()
        pass
示例#29
0
文件: SimNode.py 项目: nvt/procnet
 def start(self):
     logging.info("Starting node {}".format(self.node_id))
     child_read_fd, self.write_fd = os.pipe()
     self.read_fd, child_write_fd = os.pipe()
     self.pid = os.fork()
     sys.stderr.flush()
     sys.stdout.flush()
     if self.pid != 0:
         # In the parent process.
         os.close(child_read_fd)
         os.close(child_write_fd)
         self.proto = Protocol.Protocol(self)
     else:
         # In the child process.
         os.dup2(child_read_fd, 0)
         os.dup2(child_write_fd, 1)
         os.dup2(child_write_fd, 2)
         argv = self.node_type.args.split()
         argv.insert(0, self.node_type.path)
         env = os.environ
         env['PROCNET_URI'] = "tcp://localhost:14395"
         env['PROCNET_AUTH_TOKEN'] = self.token
         try:
             os.execvpe(self.node_type.path, argv, env)
         except FileNotFoundError:
             os._exit(1)
示例#30
0
    def send_defend(self, result):
        msg = 'client:defending:' + result

        eNum, eMsg = Protocol.send_all(self.socket_to_server, msg)
        if eNum:
            sys.stderr.write(eMsg)
            self.close_client(1)
    def run(self):
        from app import APP
        APP.Functions.set_process_name ( "0@TFTPD_DATA" )
        logger = APP.LoggingClient ( name = "TFTPD%05d" % self.pid )
        queue_errors = 0
        while 1:
            try:
                (client_address, initiating_packet, filename, filesize) = self.rfQueue.get()
            except:
                queue_errors += 1
                if queue_errors > 2:
                    logger ("Too many errors reading rfqueue")
                    break
                time.sleep(queue_errors)
            
            queue_errors = 0
            if client_address is None: break
            logger ("Sending %s to %s" % (filename, client_address))
            try:
                with open(filename, 'r') as source:
                    try:
                        (bytes, dt, speed) = Protocol.Handle_RRQ (initiating_packet, client_address, source)
                        logger ( "Sent %d bytes to %s at %.1f kB/s" % (bytes, client_address, speed/ 1024) )
                    except Protocol.TFTPProtocolError as e:
                        logger ( "TFTP Protocol Error: %s" %  e )
            except:
                info = sys.exc_info()[:2]
                logger ( "TFTP error: %s, %s" % (info[0], info[1]))                

        logger ( "EXIT" )
示例#32
0
    def launch_protocol(self):
        #self.thread_onoff = False
        print('nb proie = ', self.nb_prey.get(), 'nb chasseur = ',
              self.nb_hunter.get())
        print('largeur = ', self.width_grid.get(), 'hauteur = ',
              self.height_grid.get())
        print('ratio = ', self.ratio_grid.get())

        self.protocols.append(
            Protocol(nb_hunter=self.nb_hunter.get(),
                     nb_prey=self.nb_prey.get(),
                     ratio=self.ratio_grid.get(),
                     time_limit=self.time_limit.get(),
                     width_grid=self.width_grid.get(),
                     height_grid=self.height_grid.get(),
                     wall=self.wall.get(),
                     id_protocol=self.nb_protocol,
                     experience=self,
                     detection_range_prey=self.detection_range_prey.get(),
                     detection_range_hunter=self.detection_range_hunter.get()))
        self.nb_protocol += 1
        for p in self.protocols:
            print(p.grid.map)
            print(p.agents)
            print("Id ", p.id_protocol, " : ", p.run)
示例#33
0
 def findServos(self, comm):
     """Retrieves and processes the list of available (responsive) servos
     attached to the arm's Arduino controller. Returns a dictionary mapping
     from servo functions to Servo() objects, or None if no matching servo
     was found for a particular function"""
     servos = {
         'swing': None,
         'actuator': None,
         'shoulder': None,
         'wrist_x': None,
         'wrist_y': None
     }
     # Mapping of IDs->functions
     v1_IDs = {
         0 : 'swing',
         1 : 'actuator',
         2 : 'shoulder'
     }
     v2_IDs = {
         1 : 'wrist_x',
         0 : 'wrist_y'
     }
     # Servos retrieved from Arduino
     found = Protocol.findServos(comm)
     i = 0
     for v1servo in found['v1']:
         servos[v1_IDs[i]] = v1servo
         i += 1
     j = 0
     for v2servo in found['v2']:
         servos[v2_IDs[j]] = v2servo
         j += 1
     # Return our output servo dictionary
     return servos
示例#34
0
    def __init__(self):

        self.Protocol = Protocol.Protocol()
        self.FieldManager = FieldManager.FieldManager()
        self.ConstructManager = ConstructManager.ConstructManager()
        self.StartNode = StartNode.StartNode("Name", "Protocol Desciption", "Dependent Protocol Name", "Dependency Pattern")
        self.EndNode = EndNode.EndNode()
示例#35
0
 def updateEventRanges(self, eventRanges, timeout, acceptJson, version):
     # peek jobs
     tmpWrapper = _TimedMethod(self.taskBuffer.updateEventRanges, timeout)
     tmpWrapper.run(eventRanges, version)
     # make response
     if tmpWrapper.result == Protocol.TimeOutToken:
         # timeout
         response = Protocol.Response(Protocol.SC_TimeOut)
     else:
         # succeed
         response = Protocol.Response(Protocol.SC_Success)
         # make return
         response.appendNode('Returns', tmpWrapper.result[0])
         response.appendNode('Command', tmpWrapper.result[1])
     _logger.debug("updateEventRanges : ret -> %s" %
                   (response.encode(acceptJson)))
     return response.encode(acceptJson)
示例#36
0
def init_File_server():
    host, port = Protocol.get_host(_config['nameserver'])
    with closing(HTTPConnection(host, port)) as conn:
        data = 'srv=%s&dirs=%s' % (
            _config['srv'],
            '\n'.join(_config['directories']),
        )
        conn.request('POST', '/', data)
示例#37
0
def MAC_verification(connection, KeyId, Versus = None, Data = None, MACData = None):
        """
        Keyboard and Security, MAC verification (0x40, 0x07).
    
        :Parameters:
            -*connection* (PupySPOT): Object managing spot connection.
            - *KeyId* (integer): Slot ID of Master Key.
            - *Versus* (Enums.Versus):  Operation required.
            - *Data* (bytes array): Data block on which the operation is performed.
            - *MACData* (bytes array): MAC data buffer to verify.
        
        :Returns: Ack-Code indicating successful of the operation.  
    
        """
	Protocol.send_mac_verification(connection, key_id = KeyId, versus = Versus, data = Data, mac = MACData)
	ack = Protocol.recv_send_mac_verification(connection, timeout = 120)
	return ack['ack_code'] 
    def __set_start_game(self, player_num):

        welcome_msg = "start|turn|" + self.players_names[1] if not player_num else "start|not_turn|" + self.players_names[0]
        
        eNum, eMsg = Protocol.send_all(self.players_sockets[player_num], welcome_msg)
        if eNum:
            sys.stderr.write(eMsg)
            self.shut_down_server()
def get_values_matrix(Window, x, y, temp_file, ProtoWindow):
    """
    This program gets 2 positions from a matrix of labels (it is called 2 times each to add one position).
    
    Entry:
        Window(Frame): the protocol window
        x: the first value to get
        y(Label variable): the second value to get
        temp_file(string): the name of the file
        ProtoWindow(Frame): the protocol frame
    """
    protocole = Prot.ReadProtocolFile(temp_file)
    pos = protocole.index(['position'])
    protocole[pos - 1] = protocole[pos - 1] + [x, y]
    Prot.EcrireProtocoleFichier(protocole, 'temp.txt')
    if len(protocole[pos - 1]) == 5:
        Prot.AfficherProtocol(ProtoWindow, protocole)
        Window.destroy()
示例#40
0
def get_tests(config={}):
    tests = []
    import Cipher; tests += Cipher.get_tests(config=config)
    import Hash;   tests += Hash.get_tests(config=config)
    import Protocol; tests += Protocol.get_tests(config=config)
    import PublicKey; tests += PublicKey.get_tests(config=config)
    import Random; tests += Random.get_tests(config=config)
    import Util;   tests += Util.get_tests(config=config)
    return tests
示例#41
0
def data_encryption(connection, KeyId, Versus=None, Data=None, WorkingKey=''):
        """
        Keyboard and Security, Data encryption (0x40, 0x03).
    
       :Parameters:
            -*connection* (PupySPOT): Object managing spot connection.
            - *KeyId* (integer): Slot ID of Master Key.
            - *Versus* (Enums.Versus):  Operation required.
            - *Data* (bytes array): Data block on which the operation is performed.
            - *WorkingKey* (bytes array): Working Key value encrypted with Master Key.
        
        :Returns: Ack-Code indicating successful of the operation.      
        
        """
	Protocol.send_data_encryption(connection, keyid = KeyId, versus = Versus, data = Data, mode = 0x00 if WorkingKey == '' else 0x01, working_key = WorkingKey)
	ack = Protocol.recv_data_encryption(connection, timeout = 120)
	if ack['ack_code'] != 0x00: ack['Data'] = None
	return ack['ack_code'], ack['Data'] 
示例#42
0
    def doExecute( self, sock, words ):
        if self.room.getAcl().hasPermission( self.nick, Acl.SHUTDOWN ):
            number = random.randrange( 0, len(LAST_WORDS) )
            self.sendMessage( sock, LAST_WORDS[ number ] )
            time.sleep( 2 )

            #send the leave message
            leavePacket = Protocol.getProtocol().getLeavePacket( self.room.getNick() )
            leavePacket.send( sock )
            self.room.shutdown()
 def __handle_standard_input(self):
     msg = sys.stdin.readline().strip().upper()
     if msg == 'EXIT':  # user wants to quit
         eNum, eMsg = Protocol.send_all(self.socket_to_server, "PLAYER_QUIT_EXIT")
         if eNum:
             print eMsg
             self.close_client()
         self.close_client()
     else:
         return msg
示例#44
0
    def send_attack(self, place):
	"""
	sends my attack to other (incommiiiiiing!)
	"""
        msg = 'client:attacking:' + place

        eNum, eMsg = Protocol.send_all(self.socket_to_server, msg)
        if eNum:
            sys.stderr.write(eMsg)
            self.close_client(1)
示例#45
0
def multiblock_MAC_verification(connection, KeyId, WorkingKeyMode = None, WorkingKey = None, Versus = None, Data = None, IV = None, BlockSize = 16, MACData = None):
	"""
	MultiBlock Encryption, MAC verification: Keyboard and Security  (0x40,0x16).    
	
	:Parameters:
	    -*connection* (PupySPOT): Object managing spot connection.
        - *KeyId* (integer): Slot ID of Master Key.
        - *WorkingKeyMode* (Enums.WKMode):  Working Key format. 
        - *WorkingKey* (bytes array): Working Key value encrypted with Master Key.
        - *Versus* (Enums.Versus):  Operation required.
        - *Data* (bytes array): Data block on which the operation is performed.
        - *IV* (bytes array): Initial vector IV. 
        - *BlockSize* (integer): Length of each block.
        - *MACData* (bytes array): MAC data buffer to verify.
       
         :Returns: Ack-Code indicating successful of the operation.      
        
	"""
	blkcount = 0
	data = Data
	cblock = IV
	macData = None

	# block split
	while True:
		block = data[:BlockSize]
		data = data[BlockSize:]
		#send
		if len(block) > 0 and len(data) > 0:
			flags = Enums.Flags.START_DATA_BLOCK if blkcount == 0 else Enums.Flags.INTERMEDIATE_DATA_BLOCK
		else:	
			flags = Enums.Flags.FIRSTANDLAST_DATA_BLOCK if blkcount == 0 else Enums.Flags.END_DATA_BLOCK
			macData = MACData
		Protocol.send_multiblock_verification(connection, KeyId = KeyId, WorkingKeyMode = Enums.WKMode[WorkingKeyMode], WorkingKey = WorkingKey, Flags = flags, Versus = Enums.Versus[Versus], Data = block, ChainingData = cblock, MACData = macData)
		#receive
		ack = Protocol.recv_multiblock_verification(connection, 120)
		if ack['ACKcode'] == 0x00:
			cblock = ack['ChainingData']
			if flags == Enums.Flags.FIRSTANDLAST_DATA_BLOCK or flags == Enums.Flags.END_DATA_BLOCK: break
		else: break
		blkcount += 1
	return ack['ACKcode']
示例#46
0
    def connect_to_server(self):

        # Create a TCP/IP socket_to_server
        try:
            self.socket_to_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        except socket.error as msg:

            self.socket_to_server = None
            sys.stderr.write(repr(msg) + '\n')
            exit(EXIT_ERROR)

        server_address = (self.server_name, int(self.server_port))
        try:
            self.socket_to_server.connect(server_address)
            self.all_sockets.append(
                self.socket_to_server)  # this will allow us to use Select System-call

        except socket.error as msg:
            self.socket_to_server.close()
            self.socket_to_server = None
            sys.stderr.write(repr(msg) + '\n')
            exit(EXIT_ERROR)

        # we wait to get ok from server to know we can send our name
        num, msg = Protocol.recv_all(self.socket_to_server)
        if num == Protocol.NetworkErrorCodes.FAILURE:
            sys.stderr.write(msg)
            self.close_client(1)

        if num == Protocol.NetworkErrorCodes.DISCONNECTED:
            self.bye('disconnected')

        # send our name to server
        eNum, eMsg = Protocol.send_all(self.socket_to_server, sys.argv[3])
        if eNum:
            sys.stderr.write(eMsg)
            self.close_client(1)

        print "*** Connected to server on %s ***" % server_address[0]
        print
        print "Waiting for an opponent..."
        print
示例#47
0
def get_platform(connection):
        """
        Gets the platform type.
    
        :Parameters:
            -*connection* (PupySPOT): Object managing spot connection.
            
        :Returns: A string containing the platform type.  
    
        """
	Protocol.send_hardware_configuration(connection, [0x01, 0x42])
	hw_conf_ack = Protocol.recv_hardware_configuration(connection, 0)
	connection.platform = None
	if hw_conf_ack['Entry'][str(int(0x42))].startswith('MCF532x'):
		connection.platform = 'M3'
	elif hw_conf_ack['Entry'][str(int(0x42))].startswith('OMAP35xx'):
		connection.platform = 'NGP'
	elif hw_conf_ack['Entry'][str(int(0x42))].startswith('UPMxxxxx'):
		connection.platform = 'VGD'
	return connection.platform
示例#48
0
文件: Client.py 项目: orensam/pythonw
    def send_to_server(self, msg):

        err_num, err_msg = Protocol.send_all(self.socket_to_server, msg)

        if err_num == Protocol.NetworkErrorCodes.FAILURE:
            print err_msg
            self.close_client(EXIT_ERROR)

        if err_num == Protocol.NetworkErrorCodes.DISCONNECTED:
            print "Server has closed connection."
            self.close_client(EXIT_OK)
示例#49
0
文件: main.py 项目: Brustar/RPGame
	def callback(self,data):
		self.logger.info('recv from server : %s' % binascii.b2a_hex(data))
		pro = Protocol.decode(data)

		if (pro.head != 0xEC or pro.tail != 0xEA):
			return
		# 服务器认证
		if (pro.cmd == MASTER_AUTHOR):
			ip = "%d.%d.%d.%d" % (pro.state, pro.R, pro.G, pro.B)
			port = pro.deviceID
			self.client = RBClient(ip, port)
			protocol = Protocol(SUB_AUTHOR, pro.masterID)
			self.client.sendData(protocol.command())
			self.client.recvData(self.callback)
		# 控制设备
		if (pro.cmd == 0x03):
			light = C4Light()
			if pro.state:
				light.powerOn(pro.deviceID)
			else:
				light.powerOff(pro.deviceID)
示例#50
0
    def __handle_server_request(self):
	"""
	handles all massages got from server
	"""

        num, msg = Protocol.recv_all(self.socket_to_server)
        if num == Protocol.NetworkErrorCodes.FAILURE:
            sys.stderr.write(msg)
            self.close_client(1)

		# the connection disconnected
        if num == Protocol.NetworkErrorCodes.DISCONNECTED:
            self.bye('disconnected')

        if "start" in msg:
            self.__start_game(msg)


        elif msg:
            (who, what, data) = msg.split(':')

			# the othe side left
            if data == 'EXIT' :
                self.bye('other '+ data)

			# a respond to my former attack or attacking me.
            if who == 'client':
                result = {'attacking': self.defend,
                          'defending': self.update_result,
                          }.get(what)(data.upper())

				# result is the outcome from the other's attack.
				#(if he didnt attacked in this message will be none)
                if result:

                    self.send_defend(result)
                    self.my_turn = True
                    print self.opponent_name + ' plays: ' + data
                    self.print_board()

					# iv'e lost ):
                    if result == 'LOST':
                        self.bye(result)
                    else:
                        print "It's your turn..."
                    
                else:
                    self.print_board()
            # the other tells us he lost the game... I guess we won.       
            if data ==  'LOST':
                self.bye('other '+ data)
                self.print_board()
示例#51
0
def get_bundle_version(connection, platform, login_answer):
        """
        Gets the bundle version.
    
        :Parameters:
            -*connection* (PupySPOT): Object managing spot connection.
            -*platform* (string): Platform type.
            -*login_answer* (string): TODO.
            
        :Returns: A string containing the bundle version.
          
        """
	version = None
	if platform == 'M3':
		Protocol.send_software_configuration(connection, [])
		ack = Protocol.recv_software_configuration(connection, 0)
		version = ack['Entry']['15'].split('\n')[0].split(' ')[1]
	elif platform == 'NGP':
		version = '|'.join([str(e['app_id']) + '=' + e['app_ascii'].strip('\x00') for e in login_answer['entries']])
	elif platform == 'VGD':
		version = '|'.join([str(e['app_id']) + '=' + e['app_ascii'].strip('\x00') for e in login_answer['entries']])
	return version
    def __handle_server_request(self):
        num, msg = Protocol.recv_all(self.socket_to_server)
        if num == Protocol.NetworkErrorCodes.FAILURE:
            sys.stderr.write(msg)
            self.close_client()

        if num == Protocol.NetworkErrorCodes.DISCONNECTED:
            print "Server has closed connection."
            self.close_client()
            
        if "EXIT" in msg:
            print "Your opponent has disconnected. You win!"
            self.close_client()

        if "start" in msg:
            self.__start_game(msg)
        
        else:
            msg_type = Client.server_msg_type(msg)  # Analyzing massage type
            #print "msg = " + msg				# ----------blllaaaaaaaaaaaaaaaaaaaaaa - ERASE
            if msg_type == OPPONENT_ANSWER:
                win = self.player.update_opponent_board(msg, self.latest_move[0], self.latest_move[1])
                self.print_board()
                if win:
                    #game ended - send massage
                    print "You won!"
                    self.close_client()
               
            else:	# A move was sent from the other client
                result = self.player.check_move(msg)
                Protocol.send_all(self.socket_to_server, result)    # Sends the response to the server
                print self.opponent_name + " plays: " + msg
                self.print_board()
                if "ALL" in result:
                    print "You lost :("
                    self.close_client()
                else:
                    print "It's your turn..."
示例#53
0
文件: Command.py 项目: ArildF/rogie
    def sendMessage( self, sock, msg ):
        #break up msg in appropriate chunks
        idxStart = 0
        idxEnd = MAX_PACKET_SIZE
        msgList = []
        while idxEnd < len( msg ):
            #make sure we break on a space
            while not msg[ idxEnd - 1 ] == " " and idxEnd > ( idxStart + MAX_PACKET_SIZE - 40 ):
                idxEnd = idxEnd - 1
            msgList.append( msg[ idxStart : idxEnd ] )
            idxStart = idxEnd
            idxEnd = idxStart + MAX_PACKET_SIZE

        msgList.append( msg[ idxStart : idxEnd ] )

        for message in msgList:
            if self.isPm:
                packet = Protocol.getProtocol().getPmPacket( self.room.getNick(), self.nick, message )
            else:
                packet = Protocol.getProtocol().getSpeechPacket( self.room.getNick() \
                    ,self.room.getRoomName(), message )
            packet.send( sock )
            time.sleep( 3 )
    def run_client(self):
        while True:
            r_sockets = select.select(self.all_sockets, [], [])[0]  # We won't use writable and exceptional sockets

            if sys.stdin in r_sockets:
                move = self.__handle_standard_input()
                eNum, eMsg = Protocol.send_all(self.socket_to_server, move)
                if eNum:
                    print eMsg
                    self.close_client()
                self.latest_move = Client.parse_msg(move)

            elif self.socket_to_server in r_sockets:
                self.__handle_server_request()
示例#55
0
 def run( self ):
     sleepMax = Config.getConfig().getInt( "quotes", "sleep_max" )
     sleepMin = Config.getConfig().getInt( "quotes", "sleep_min" )
     quoteDb = Config.getConfig().getString( "quotes", "quotefile" )
     store = SqliteQuoteStore.SqliteQuoteStore( quoteDb )
     
     while not self.finished:
         interval = random.randrange( sleepMin, sleepMax ) 
         time.sleep( interval * 60 )
         
         msg =  QuoteCommand.formatQuote( store.getRandomQuote() )
         packet = Protocol.getProtocol().getSpeechPacket( self.room.getNick(), self.room.getRoomName(),
                                   msg.strip() )
         packet.send( self.sock )
示例#56
0
def get_card_reader_type(connection):
        """
        Gets the card reader type.
    
        :Parameters:
            -*connection* (PupySPOT): Object managing spot connection.
            
        :Returns: A string containing the card reader type.  
        """
	Protocol.send_hardware_configuration(connection, [0x34])
	hw_conf_ack = Protocol.recv_hardware_configuration(connection, 0)
	connection.cr_type = None
	if hw_conf_ack['Entry']['52'].startswith('ZU-'):
		connection.cr_type = 'PANASONIC'
	elif hw_conf_ack['Entry']['52'].startswith('MAGTEK-HCR'):
		connection.cr_type = 'HCR2'
	elif hw_conf_ack['Entry']['52'].startswith('Sankyo'):
		connection.cr_type = 'SANKYO'
	elif hw_conf_ack['Entry']['52'].startswith('SANKYO-HCR2'):
		connection.cr_type = 'SANKYO-HCR2'
	elif hw_conf_ack['Entry']['52'].startswith('Omron'):
		connection.cr_type = 'OMRON'
	return connection.cr_type
示例#57
0
文件: Client.py 项目: orensam/pythonw
    def rcv_from_server(self):

        err_num, msg = Protocol.recv_all(self.socket_to_server)

        if err_num == Protocol.NetworkErrorCodes.FAILURE:
            sys.stderr.write(msg)
            self.close_client(EXIT_ERROR)

        elif err_num == Protocol.NetworkErrorCodes.DISCONNECTED:
            print "Server has closed connection."
            self.close_client(EXIT_OK)

        else:
            return msg