def start(self):
if self.port:
self.stop()
if config.setting["browser_integration_localhost_only"]:
self.host_address = QtNetwork.QHostAddress(QtNetwork.QHostAddress.LocalHost)
else:
self.host_address = QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any)
for port in range(config.setting["browser_integration_port"], 65535):
if self.listen(self.host_address, port):
log.debug("Starting the browser integration (%s:%d)", self.host_address.toString(), port)
self.port = port
self.tagger.listen_port_changed.emit(self.port)
break
def sendSDP(self, flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3,
bArray):
"""
You know, the detail experiment with sendSDP() see mySDPinger.py
the bArray can be constructed simply by using type casting. Ex:
elements = [0, 200, 50, 25, 10, 255]
bArray = bytearray(elements) # byte must be in range(0, 256)
Something wrong with bArray -> try to use list instead
"""
da = (dax << 8) + day
dpc = (dp << 5) + dc
sa = 0
spc = 255
pad = struct.pack('2B', 0, 0)
hdr = struct.pack('4B2H', flags, tag, dpc, spc, da, sa)
scp = struct.pack('2H3I', cmd, seq, arg1, arg2, arg3)
sdp = pad + hdr + scp
"""
if bArray is not None:
sdp = pad + hdr + scp + bArray
else:
sdp = pad + hdr + scp
"""
if bArray is not None:
for b in bArray:
sdp += struct.pack('<B', b)
#sdp += b
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST),
DEF_SEND_PORT)
time.sleep(DEF_SDP_TIMEOUT)
return sdp
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.blockSize = 0
self.tcpSocket = QtNetwork.QTcpSocket(self)
self.tcpSocket.readyRead.connect(self.readSig)
self.tcpSocket.connectToHost(QtNetwork.QHostAddress('127.0.0.1'), 5000)
def __init__(self, argv):
QtGui.QApplication.__init__(self, argv)
settings = utils.Settings()
# Prepare socket for sending notifications
self.socketTo = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socketTo.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.socketTo.connect(('255.255.255.255', settings.notificationPort))
# Prepare socket for receiving notifications
self.socketFrom = QtNetwork.QUdpSocket()
anyAddress = QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any)
self.socketFrom.bind(anyAddress, settings.notificationPort)
self.connect(self.socketFrom, SIGNAL("readyRead()"),
self.onNotification)
# Prepare the ping agent
self.pingAgent = PingAgent(self, settings.dbHost)
# Run the timer which checks the connection periodically
self.connectionTimer = QTimer(self)
self.connect(self.connectionTimer, SIGNAL("timeout()"),
self.checkConnection)
# Check the connection every 16 seconds if the connection is lost
# or every 5 minutes if the connection is here
self.connectionTimer.start(16 * 1000)
# Check it at the very beginning
QtCore.QTimer.singleShot(1000, self.checkConnection)
def Do_DownloadData(strFile, isFin=False):
strData = 'GET /userRpm/' + strFile + ' HTTP/1.1\r\n' \
'Cookie: ' + conf__strCookie + '\r\n' \
'Referer: ' + conf__strLinkPrefix + 'MenuRpm.htm\r\n\r\n'
print strData
cachedData = []
def on_ready_read():
if client.bytesAvailable():
print '-' * 50
print 'on_ready_read()'
print client.bytesAvailable(), 'read.'
data = str(client.readAll())
cachedData.append(data)
print len(data), client.bytesAvailable()
#print data
def on_connected():
client.writeData(strData)
print 'connected.'
def on_disconnect():
print '-' * 50
print 'on_disconnect()'
print len(cachedData)
print ''.join(cachedData)
if isFin: exit(0)
client = QtNetwork.QTcpSocket()
client.readyRead.connect(on_ready_read)
client.connected.connect(on_connected)
client.disconnected.connect(on_disconnect)
client.connectToHost(QtNetwork.QHostAddress('192.168.1.1'), 80)
def send_server_invite_option(self, invite_client_ids, channel_id):
# for each client_id find the socket on which to send the
# server_invite option
for invite_client_id in invite_client_ids:
for _, client_sockets in self.channels.items():
for (client_id, socket) in client_sockets:
if invite_client_id == client_id:
#Hier kann es auch sein, dass nur eine Id gebraucht
#wird und nicht eine Liste...
option_data = Container(channel_id=channel_id,
client_id=invite_client_ids)
option = Container(option_id="SERVER_INVITE_OPTION",
option_data=option_data)
pdu = Container(id=self.id, option=[option])
ip_to_invite = QtNetwork.QHostAddress(
socket.peerAddress())
udpSocket_for_invites = QtNetwork.QUdpSocket(self)
udpSocket_for_invites.bind(
ip_to_invite, broadcast_port,
QtNetwork.QUdpSocket.ShareAddress)
udpSocket_for_invites.writeDatagram(
InstantSoupData.peer_pdu.build(pdu), ip_to_invite,
broadcast_port)
log.debug('PDU: SERVER_INVITE_OPTION - id: %i - SENT' %
self.pdu_number)
def __init__(self, parent):
QtCore.QObject.__init__(self, parent)
self.host2ip = {}
self.ip2host = {}
self.last_calc = time.time()
self.pilotsHistory = {}
self.timer = QtCore.QTimer(self)
self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.on_timer)
self.dnsLookupThread = DnsLookupThread(self)
self.connect(self.dnsLookupThread, QtCore.SIGNAL("domain_found"),
self.on_domain_found)
#def run(self):
self.dnsLookupThread.start()
self.timer.start(1000)
self.telnetString = {}
self.telnetTimer = {}
self.telnetSocket = {}
self.lastUpdate = None
self.server = QtNetwork.QTcpServer(self)
self.connect(self.server, QtCore.SIGNAL("newConnection()"),
self.on_websocket_connection)
self.server.listen(QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any),
5050)
self.clientSockets = {}
self.increment = 0
def __init__(self, send_port, targetIP, parent=None):
super(UDP_sendStatus, self).__init__(parent)
self.sendPort = num(send_port)
self.target_IP = QtNetwork.QHostAddress(targetIP)
try:
self.ss = QtNetwork.QUdpSocket(self)
except:
print "Trouble opening UDP on socket %d" % (self.sendPort)
def start(self):
if self.port:
self.stop()
for port in range(config.setting["browser_integration_port"], 65535):
if self.listen(QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any),
port):
log.debug("Starting the browser integration (port %d)", port)
self.port = port
self.tagger.listen_port_changed.emit(self.port)
break
def start(self):
self.port = 8000
while self.port < 65535:
self.log.debug("Starting the browser integration (port %d)",
self.port)
if self.listen(QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any),
self.port):
self.tagger.emit(QtCore.SIGNAL("listen_port_changed"),
self.port)
break
self.port += 1
def start(self):
self.messageEmited.emit("NGQ Manager", "Initialization" + "...",
QtGui.QSystemTrayIcon.Information, 100)
self.tcpServer = QtNetwork.QTcpServer()
self.tcpServer.listen(QtNetwork.QHostAddress(self.__host), self.__port)
self.tcpServer.newConnection.connect(self.__newConnectionHandle)
self.configure()
self.ngqListChanged.connect(self.__chooseWaitingTasksForProject)
self.__putToWaitingTasks(partial(self.executeArgs, self.__argString),
None, self.__initializationTime)
def start(self):
self.startButton.setEnabled(False)
QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
self.bytesWritten = 0
self.bytesReceived = 0
self.clientStatusLabel.setText("Connecting")
self.tcpClient.connectToHost(
QtNetwork.QHostAddress(QtNetwork.QHostAddress.LocalHost), 9112)
def sendImgInfo(self, cmd, data_type):
dpc = (SDP_RECV_JPG_INFO_PORT <<
5) + SDP_RECV_CORE_ID #destination port and core
pad = struct.pack('2B', 0, 0)
hdr = struct.pack('4B2H', 7, 0, dpc, 255, 0, 0)
scp = struct.pack('2H3I', cmd, data_type, self.szImgFile, 0, 0)
sdp = pad + hdr + scp
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(self.spinn),
SPINN_PORT)
CmdSock.flush()
# then give a break, otherwise spinnaker will collapse
self.delay()
def sendChunk(ch_port, ba):
da = 0
dpc = (ch_port << 5) + 1
sa = 0
spc = 255
pad = struct.pack('<2B', 0, 0)
hdr = struct.pack('<4B2H', 7, 0, dpc, spc, da, sa)
sdp = pad + hdr + ba
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST), DEF_SEND_PORT)
CmdSock.flush()
def sendImgInfo(self):
dpc = (SDP_RECV_RAW_INFO_PORT <<
5) + SDP_RECV_CORE_ID # destination port and core
pad = struct.pack('2B', 0, 0)
hdr = struct.pack('4B2H', 7, 0, dpc, 255, 0, 0)
scp = struct.pack('2H3I', SDP_CMD_INIT_SIZE, 0, len(self.orgImg),
self.wImg, self.hImg)
sdp = pad + hdr + scp
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(self.spinn),
SPINN_PORT)
CmdSock.flush()
# then give a break, otherwise spinnaker might collapse
self.delay()
def __init__(self,
port=9500,
server_name = "default",
address = QtNetwork.QHostAddress(QtNetwork.QHostAddress.LocalHost),
parent = None,
verbose = False):
QtCore.QObject.__init__(self)
# Initialize internal attributes
self.address = address
self.port = port
self.server_name = server_name
self.socket = None
self.verbose = verbose
def sendImgPerChip(self, chipIdx, nChip):
"""
Send image data to a specific chip, where chipIdx = 0,1,2,3 for spin3.
This function assume rmap0, gmap0, and bmap0 are ready!
"""
# first, send image configuration
# for spin3:
x = spin3[chipIdx][0]
y = spin3[chipIdx][1]
da = (x << 8) + y
# send image information through SDP_PORT_CONFIG
dpcc = (sdpImgConfigPort << 5) + sdpCore
hdrc = struct.pack('4B2H', 0x07, 1, dpcc, 255, da, 0)
cmd = SDP_CMD_CONFIG
if self.isGray is True:
isGray = 1
else:
isGray = 0
if self.cbMode.currentIndex(
) == 0 and self.cbFilter.isChecked() is False:
opt = 1
elif self.cbMode.currentIndex(
) == 0 and self.cbFilter.isChecked() is True:
opt = 2
elif self.cbMode.currentIndex(
) == 1 and self.cbFilter.isChecked() is False:
opt = 3
else:
opt = 4
seq = (isGray << 8) + opt
arg1 = (self.w << 16) + self.h
arg2 = (chipIdx <<
16) + nChip # arg2.high = nodeBlockID, arg2.low = maxBlock
arg3 = ASK_BLOCK_REPORT
scp = struct.pack('2H3I', cmd, seq, arg1, arg2,
arg3) # arg3 is not used
sdp = pad + hdrc + scp
self.sdpSender.writeDatagram(sdp,
QtNetwork.QHostAddress(self.DEF_HOST),
DEF_SEND_PORT)
# this time, no need for reply
time.sleep(1) # wait a second
print "Sending image..."
self.sendImg(x, y)
def sendChunk(ch_port, core, seq, ba):
da = 0
dpc = (ch_port << 5) + core
sa = seq
spc = 255
pad = struct.pack('<2B',0,0)
hdr = struct.pack('<4B2H',7,0,dpc,spc,da,sa)
if ba is not None:
sdp = pad + hdr + ba
else:
sdp = pad + hdr
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST), DEF_SEND_PORT)
CmdSock.flush()
def __init__(self, parent):
QtCore.QObject.__init__(self, parent)
self.connections = []
self.threads = []
self.count = 0
self.server = QtNetwork.QTcpServer(self)
#FIXME
#tcp_address = QtNetwork.QHostAddress.Any
tcp_address = QtNetwork.QHostAddress("192.168.0.146")
tcp_port = 1137
self.connect(self.server, QtCore.SIGNAL("newConnection()"),
self.socket_connected)
self.server.listen(tcp_address, tcp_port)
parent.txtSocket.setPlainText(
"RiiFS Python Server is now ready for connections on 1137")
def sendSDP(flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray):
da = (dax << 8) + day
dpc = (dp << 5) + dc
sa = 0
spc = 255
pad = struct.pack('<2B', 0, 0)
hdr = struct.pack('<4B2H', flags, tag, dpc, spc, da, sa)
scp = struct.pack('<2H3I', cmd, seq, arg1, arg2, arg3)
if bArray is not None:
sdp = pad + hdr + scp + bArray
else:
sdp = pad + hdr + scp
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST), DEF_SEND_PORT)
CmdSock.flush()
return sdp
def __init__(self,
parent=None,
port=9500,
server_name="default",
address=QtNetwork.QHostAddress(
QtNetwork.QHostAddress.LocalHost),
verbose=False):
tcpCommunications.TCPCommunications.__init__(self,
parent=parent,
port=port,
server_name=server_name,
address=address,
verbose=verbose)
# Create instance of TCP socket
self.socket = QtNetwork.QTcpSocket()
self.socket.disconnected.connect(self.handleDisconnect)
self.socket.readyRead.connect(self.handleReadyRead)
def sendChunk(self, chunk):
# based on sendSDP()
# will be sent to chip <0,0>, no SCP
dpc = (SDP_RECV_RAW_DATA_PORT <<
5) + SDP_RECV_CORE_ID # destination port and core
pad = struct.pack('2B', 0, 0)
hdr = struct.pack('4B2H', 7, 0, dpc, 255, 0, 0)
if chunk is not None:
sdp = pad + hdr + chunk
else:
# empty sdp means end of image transmission
sdp = pad + hdr
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(self.spinn),
SPINN_PORT)
CmdSock.flush()
# then give a break, otherwise spinnaker will collapse
self.delay()
def func_connect(self):
retStatus = False
if self.listen(QtNetwork.QHostAddress(self.host), self.port):
if __package__ == None:
print 'server is awake :: %s:%s' % (str(
self.host), str(self.port))
else:
try:
self.messageSignal.emit(
u'TCP/IP 서버를 열었습니다. :: %s:%s' %
(str(self.host), str(self.serverPort())), self.id)
except:
pass
retStatus = True
else:
if __package__ == None: print "server couldn't wake up"
else:
try:
def configureNetwork(self):
#self.blockSize = 0
self.socket = QtNetwork.QTcpServer()
self.socket.name = 'ThinkGear Server'
if self.DEBUG:
print "<---- [%s] Initializing server on %s:%i" % \
(self.socket.name, self.server_interface, self.server_port)
if ((self.server_interface == '') or \
(self.server_interface == '*')):
address = QtNetwork.QHostAddress.Any
else:
#address=self.server_interface
address = QtNetwork.QHostAddress(self.server_interface)
result = self.socket.listen(address, self.server_port)
if not result:
try:
QtGui.QMessageBox.information( \
self.parent, \
self.socket.name, \
"Unable to start the server on %s:%i" % \
(self.server_interface, self.server_port))
except:
pass
if self.DEBUG:
print "ERROR [%s] Unable to start the server:" % self.socket.name,
print self.socket.errorString()
#self.parent.stopThinkGearConnectServer()
#self.parent.pushButtonThinkGearConnect.nextCheckState()
#self.parent.pushButtonThinkGearConnect.toggle()
#self.parent.pushButtonThinkGearConnect.test.emit(QtCore.SIGNAL("clicked()"))
self.socket.close()
return
self.socket.newConnection.connect(self.processConnection)
def sendFreqReq(self, freq, dax, day):
#def sendFreqReq(self,flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray):
"""
The detail experiment with sendSDP() see mySDPinger.py
"""
da = (dax << 8) + day
dpc = (DEF.SDP_PORT << 5) + DEF.SDP_CORE
sa = 0
spc = 255
pad = struct.pack('2B', 0, 0)
hdr = struct.pack('4B2H', DEF.NO_REPLY, DEF.SEND_IPTAG, dpc, spc, da,
sa)
scp = struct.pack('2H3I', DEF.HOST_SET_FREQ_VALUE, freq, 0, 0, 0)
sdp = pad + hdr + scp
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF.HOST),
DEF.SEND_PORT)
return sdp
def ctrlServer(self):
if not self._running:
self._server = Server(self)
#FIXME
#if not self._server.listen(QtNetwork.QHostAddress.Any, self.specPort.text().toInt()[0]):
if not self._server.listen(QtNetwork.QHostAddress(self.specAddr.text()), self.specPort.text().toInt()[0]):
print "Listen ERROR!"
self.close()
return
else:
print "Server Running"
self.serverCtrl.setText('Stop Server')
self._running=True
else:
for thread in self._server.threadList:
thread.exit()
self._server.close()
self.close()
def sendSDP(self,flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray):
"""
The detail experiment with sendSDP() see mySDPinger.py
"""
da = (dax << 8) + day
dpc = (dp << 5) + dc
sa = 0
spc = 255
pad = struct.pack('2B',0,0)
hdr = struct.pack('4B2H',flags,tag,dpc,spc,da,sa)
scp = struct.pack('2H3I',cmd,seq,arg1,arg2,arg3)
if bArray is not None:
sdp = pad + hdr + scp + bArray
else:
sdp = pad + hdr + scp
CmdSock = QtNetwork.QUdpSocket()
CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF.HOST), DEF.SEND_PORT)
return sdp
def __init__(self,
port=9500,
server_name="default",
address=QtNetwork.QHostAddress(
QtNetwork.QHostAddress.LocalHost),
parent=None,
verbose=False):
QtNetwork.QTcpServer.__init__(self, parent)
tcpCommunications.TCPCommunications.__init__(self,
parent=parent,
port=port,
server_name=server_name,
address=address,
verbose=verbose)
# Connect new connection signal
self.newConnection.connect(self.handleClientConnection)
# Listen for new connections
self.connectToNewClients()
def configureNetwork(self):
#self.blockSize = 0
self.socket = QtNetwork.QTcpSocket()
self.socket.name = 'ThinkGear Client'
if self.server_host == '*':
self.server_host = '127.0.0.1'
self.server_host = QtNetwork.QHostAddress(self.server_host)
self.socket.readyRead.connect(self.printReply)
self.socket.error.connect(self.displayError)
# Perform ThinkGear authorization if enabled
if ENABLE_THINKGEAR_AUTHORIZATION:
self.sendCommand(AUTHORIZATION_REQUEST)
self.socket.waitForReadyRead()
self.socket.disconnectFromHost()
self.sendCommand(THINKGEAR_CONFIGURATION_PARAMETERS)
def Do_DownloadData(strFile):
print 'strFile=', strFile
strData = 'GET /userRpm/' + strFile + ' HTTP/1.1\r\n' \
'Cookie: ' + conf__strCookie + '\r\n' \
'Referer: ' + conf__strLinkPrefix + 'MenuRpm.htm\r\n\r\n'
print strData
client = QtNetwork.QTcpSocket()
client.connectToHost(QtNetwork.QHostAddress('192.168.1.1'), 80)
client.writeData(strData)
cachedData = []
while True:
client.waitForReadyRead(30000)
nBytesAvailable = client.bytesAvailable()
if nBytesAvailable == 0: break
print nBytesAvailable, 'read.'
print '-' * 60
cachedData.append(str(client.readAll()))
client.close()
return ''.join(cachedData)
