def start(self):
"""
Starts the server to route messages
"""
# Creates new socket to listen to
s = socket(AF_INET, SOCK_STREAM)
s.bind((self.host, self.port))
s.listen(1)
print "Listening for message.. "
# Process a new message
new_socket, address = s.accept()
data = new_socket.recv(512)
new_msg = self.parse_msg(data)
if data:
new_socket.send("Recieved Message")
s.close()
s = socket(AF_INET, SOCK_STREAM)
s.connect((new_msg[Message.RECIPIENT_KEY], self.port))
new_msg = self.package_msg(new_msg)
s.send(new_msg)
s.close()
def test_socket():
s1 = socket(AF_INET, SOCK_DGRAM)
s2 = socket(AF_INET, SOCK_DGRAM)
s1.bind(('', INADDR_ANY))
s2.bind(('', INADDR_ANY))
s1.connect(s2.getsockname())
s2.connect(s1.getsockname())
lst = []
def g1():
lst.append(0)
x = recv(s1, 5)
assert x == 'hello'
lst.append(3)
sendall(s1, 'world')
lst.append(4)
return 1
def g2():
lst.append(1)
sendall(s2, 'hello')
lst.append(2)
y = recv(s2, 5)
assert y == 'world'
lst.append(5)
return 2
one, two = allof(g1, g2)
assert lst == [0, 1, 2, 3, 4, 5]
assert one == 1
assert two == 2
def __init__(self):
#Variabler
#HOST = '130.236.216.128'
self.HOST = '130.236.189.14'
self.HOST2 = '130.236.189.14'
self.PORT = 2011
self.PORT2 = 2012
if(len(sys.argv) > 1):
self.PORT = int(sys.argv[1])
#self.BUFF = 1024
self.MYPORT = 2361
self.ADDR = ('127.0.0.1')
self.ADDR2 = ('127.0.0.1')
self.contactList = list()
self.primary = False
self.online = False
self.osso_c = osso.Context("client", "0.0.1", False)
self.osso_rpc = osso.Rpc(self.osso_c)
self.osso_rpc.set_rpc_callback("thor.client","/thor/client","thor.client",self.send)
#Aktivera clientsocket
self.clientSocket = socket(AF_INET, SOCK_STREAM)
self.clientSocket2 = socket(AF_INET, SOCK_STREAM)
self.clientSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.clientSocket2.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.q = Queue()
def callback(self, widget, data):
print "%s was pressed" % data
socket_out = socket(AF_INET,SOCK_STREAM) # create a new socket object (serv)
socket_out.bind((ADDR_OUT)) # bind socket to address with new tuple
socket_out.listen(5) # maximum number of queued connections
while data == "START":
print "listening..." # need method to break loop on STOP
conn,addr = socket_out.accept() # accept the connection
print '...connected!'
HEADER = "TYPE"
PAYLOAD = "DATA"
msg = json.dumps({'HEADER':HEADER, 'PAYLOAD':PAYLOAD}) # dump to string
conn.send(msg)
conn.close()
# RECEIVE
socket_in = socket(AF_INET,SOCK_STREAM) # tmp socket
socket_in.connect((ADDR_IN))
msg = socket_in.recv(BUFSIZE) # get message as string
jmsg = json.loads(msg) # re-encode message as json
HEADER = jmsg["HEADER"] # parse header
PAYLOAD = jmsg["PAYLOAD"] # parse payload
print HEADER
print PAYLOAD
socket_in.close()
def send():
address = Entryid.get()
print "the average globaltime is: " + (str)(get_average_global_time())
send_data = make_led_track(10,20)
UDPSock = socket(AF_INET6,SOCK_DGRAM)
UDPSock.connect((address,1234))
UDPSock.send(send_data)
send_data = make_audio_track(10,20)
UDPSock = socket(AF_INET6,SOCK_DGRAM)
UDPSock.connect((address,1234))
UDPSock.send(send_data)
# broadcast
if(address == "ffff"):
for currentid in IDS:
time.sleep(.05)
UDPSock = socket(AF_INET6,SOCK_DGRAM)
UDPSock.connect((currentid,1234))
UDPSock.send(send_data)
# specific mote
else:
"""
UDPSock = socket(AF_INET6,SOCK_DGRAM)
UDPSock.connect((address,1234))
UDPSock.send(send_data)
"""
send_data = 0
def relay(self):
"""
Redirect packet
:return: None (Demon)
"""
rs = socket(AF_PACKET, SOCK_RAW, htons(0x0003)) # receive_socket
ss = socket(AF_PACKET, SOCK_RAW, SOCK_RAW) # send socket
ss.bind((self.name, SOCK_RAW))
while True:
packet = rs.recvfrom(4096)
eh_hex, ah_hex = ARP.get_headers(packet)
# analyzed ip info
ip_header = ARP.analysis_header(ah_hex)
# 내가 날리는 ARP 패킷이면 SKIP
if eh_hex[2] == ARP_TYPE_ETHERNET_PROTOCOL:
continue
# 만약 dst_ip 가 Gateway ip 이면서
# dst_mac 이 공격자 MAC 일 경우
# ---> 오염된 피해자의 패킷일 경우
if ip_header['dst_ip'] == self.gateway_ip and ip_header['dst_mac'] == self.mac:
edited_packet = self.edit_packet(packet)
ss.send(edited_packet) # Redirect!
"""
def run(self): self.load_data_file() s = socket(AF_INET, SOCK_STREAM) host = "" port = 1337 backlog = 5 size = 1024 s = socket(AF_INET, SOCK_STREAM) s.bind((host, port)) s.listen(backlog) while True: for p in self.data: print p client, address = s.accept() data = client.recv(size) if data: msg = str(data) client.send(msg) print "Recieved:", str(msg) cmd = msg.split() if cmd[0] == "kill": self.kill(*cmd[1:]) self.save_data_file() client.close()
def setUp(self):
super(SocketOptions, self).setUp()
self.host = '127.0.0.1'
self.connect_timeout = 3
self.socket = MockSocket()
fcntl_ctx = patch('fcntl.fcntl')
fcntl_ctx.start()
self.addCleanup(fcntl_ctx.stop)
socket_ctx = patch('socket.socket')
socket = socket_ctx.start()
self.addCleanup(socket_ctx.stop)
socket().getsockopt = self.socket.getsockopt
socket().setsockopt = self.socket.setsockopt
self.tcp_keepidle = 20
self.tcp_keepintvl = 30
self.tcp_keepcnt = 40
self.socket.setsockopt(
socket.SOL_TCP, socket.TCP_NODELAY, 1,
)
self.socket.setsockopt(
socket.SOL_TCP, TCP_KEEPIDLE, self.tcp_keepidle,
)
self.socket.setsockopt(
socket.SOL_TCP, TCP_KEEPINTVL, self.tcp_keepintvl,
)
self.socket.setsockopt(
socket.SOL_TCP, TCP_KEEPCNT, self.tcp_keepcnt,
)
# We don't need an actual connection so we mock a bunch of stuff
transport.TCPTransport._write = Mock()
transport.TCPTransport._setup_transport = Mock()
transport.SSLTransport._write = Mock()
transport.SSLTransport._setup_transport = Mock()
def multiserv(port1, port2):
control = socket(AF_INET, SOCK_STREAM)
control.bind(('', port1))
control.listen(1)
trans = socket(AF_INET, SOCK_STREAM)
trans.bind(('', port2))
trans.listen(1)
while(1):
cclient, caddr = control.accept()
print "[*] Connected: ", caddr
cclient.send("220 Welcome: Evil Secure FTPD 1.666\r\n")
while(1):
r0 = cclient.recv(1024)
print "[>] Input: %s" % (r0)
r1 = parser(r0)
if r1 == None:
r1 = "502 Command not implemented.\r\n"
cclient.send(r1)
print "[<] Output: %s" % (r1)
if r1 == res[4]:
print "[*] Data mode\n"
tclient, taddr = trans.accept()
print "[*] Connected: ", taddr
if r1 == res[5]:
print "[*] b00mb!"
tclient.send(heapb0f)
print "[*] done"
break
break
def setUp(self):
super(SocketOptions, self).setUp()
self.host = '127.0.0.1'
self.connect_timeout = 3
self.socket = MockSocket()
try:
import fcntl
except ImportError:
fcntl = None
if fcntl is not None:
self.patch('fcntl.fcntl')
socket = self.patch('socket.socket')
socket().getsockopt = self.socket.getsockopt
socket().setsockopt = self.socket.setsockopt
self.tcp_keepidle = 20
self.tcp_keepintvl = 30
self.tcp_keepcnt = 40
self.socket.setsockopt(
socket.SOL_TCP, socket.TCP_NODELAY, 1,
)
self.socket.setsockopt(
socket.SOL_TCP, TCP_KEEPIDLE, self.tcp_keepidle,
)
self.socket.setsockopt(
socket.SOL_TCP, TCP_KEEPINTVL, self.tcp_keepintvl,
)
self.socket.setsockopt(
socket.SOL_TCP, TCP_KEEPCNT, self.tcp_keepcnt,
)
self.patch('amqp.transport.TCPTransport._write')
self.patch('amqp.transport.TCPTransport._setup_transport')
self.patch('amqp.transport.SSLTransport._write')
self.patch('amqp.transport.SSLTransport._setup_transport')
def __init__(self, port, robot, mode=0):
self.robot = robot
self.port = port
self.sock = socket(AF_INET, SOCK_STREAM)
self.udpsock = socket(AF_INET, SOCK_DGRAM)
self.connected = False
self.udp_connected = False
self.tcp_connected = False
if (mode == 0):
self.sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.sock.bind(tuple(["127.0.0.1", port]))
self.sock.listen(1)
self.sock.setblocking(False)
self.test_for_incoming_tcp()
self.udpsock.bind(tuple(["127.0.0.1", port]))
self.udpsock.setblocking(False)
self.robot.set_display_text(1, "localhost ready 12.5V")
self.robot.set_display_text(2, "127.0.0.1")
else:
res = -1
while (res != 0):
time.sleep(1)
#print("connecting...")
self.sock = socket(AF_INET, SOCK_STREAM)
res = self.sock.connect_ex(("127.0.0.1", port))
#print("res = ", res)
#print("connected to port", port)
self.fd = self.sock
self.fd.setblocking(False)
self.connected = True
self.tcp_connected = True
def open_connection(self):
from socket import socket, AF_INET, SOCK_DGRAM
self.udpPort = 34268
self.ssock = socket(AF_INET, SOCK_DGRAM)
self.rsock = socket(AF_INET, SOCK_DGRAM)
self.rsock.bind(("", self.udpPort))
self.rsock.settimeout(100.0)
def checkPort(address, port):
# create a raw socket and bind it to the public interface
s = socket(AF_INET, SOCK_RAW, IPPROTO_IP)
s.bind((address, 0))
# Include IP headers
s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1)
# receive all packages
s.ioctl(SIO_RCVALL, RCVALL_ON)
# receive a package
try:
print s.recvfrom(21)
except:
pass
# disabled promiscuous mode
s.ioctl(SIO_RCVALL, RCVALL_OFF)
if 0:
s = socket(AF_INET, SOCK_STREAM)
s.settimeout(5)
result = s.connect_ex((address, i))
if(result == 0):
print 'Port %d: OPEN' % (i,)
print "send result", s.send("test")
return True
s.close()
return False
return False
def socketpair():
"""Wraps socketpair() to support Windows using local ephemeral ports
This is a mix of python 3.5 socketpair on windows with a goal of making
selectable communication cross platform"""
try:
return socket.socketpair(FAMILY, TYPE, PROTO)
except:
host = LOCALHOST
# creates new socket on connect
listensock = socket(FAMILY, TYPE, PROTO)
listensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
listensock.bind((host, 0))
listensock.listen()
addr, port = listensock.getsockname()
csock = socket(FAMILY, TYPE, PROTO)
try:
csock.setblocking(False)
csock.connect((addr, port))
csock.setblocking(True)
ssock, _ = listensock.accept()
except:
csock.close()
raise
finally:
listensock.close()
return (ssock, csock)
def __init__(self, id = '000000000000', ip = '127.0.0.1', port = 44445, receive_timeout = 0.1, retrysend_delay = 5, loghost = '0.0.0.0', logport=514): # delays in seconds
#from droidcontroller.connstate import ConnState
from droidcontroller.statekeeper import StateKeeper
self.sk = StateKeeper(off_tout=300, on_tout=0) # conn state with up/down times.
# do hard reboot via 0xFEED when changed to down.
# what to do if never up? keep hard rebooting?
try:
from droidcontroller.gpio_led import GPIOLED
self.led = GPIOLED() # led alarm and conn
except:
log.warning('GPIOLED not imported')
self.host_id = id
self.ip = ip
self.port = port
self.loghost = loghost
self.logport = logport
self.logaddr = (self.loghost,self.logport) # tuple
self.traffic = [0,0] # UDP bytes in, out
self.UDPSock = socket(AF_INET,SOCK_DGRAM)
self.UDPSock.settimeout(receive_timeout)
self.retrysend_delay = retrysend_delay
self.inum = 0 # sent message counter
self.UDPlogSock = socket(AF_INET,SOCK_DGRAM)
self.UDPlogSock.settimeout(None) # for syslog
self.UDPlogSock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1) # broadcast allowed
print('init: created uniscada and syslog connections to '+ip+':'+str(port)+' and '+loghost+':'+str(logport))
self.table = 'buff2server' # can be anything, not accessible to other objects WHY? would be useful to know the queue length...
self.Initialize()
def scan_ports(host, start_port, end_port, protocol):
#setup
print "Scanning: " +host +" From port: " +str(start_port) +" To Port: " +str(end_port)
#Create Socket
try:
#Create a TCP or UDP socket depending on protocol
if (protocol == 'TCP'):
serverSocket = socket(AF_INET, SOCK_STREAM)
else:
serverSocket = socket(AF_INET, DGRAM)
except:
#handle the error
print("ERROR: Connection could not be made")
#Set the IP
remote_ip=host
#Scan Ports
end_port +=1
#loop over the range of ports
for(start_Port; start_port < end_port; start_port++):
# If protocol is TCP
if (protocol == 'TCP'):
#try TCP port detect if open
# else:
else:
def sendFile(path, content):
sock = socket(AF_INET, SOCK_DGRAM)
sock.settimeout(16)
sock.bind( ('0.0.0.0', 56662) )
fName = path.split('/')[-1]
fSize = os.path.getsize(path)
header = '{"name": "%s", "size": %s, "content": "%s"}' % (fName, fSize, content)
print('Trying to connect, header: %s' % header)
sock.sendto( header, udpAddr )
try:
data, addr = sock.recvfrom(64)
except:
print('Connection timed out')
return
if data == '{"response": 200}':
with open( path, 'r' ) as rBuffer:
try:
strmSock = socket(AF_INET, SOCK_STREAM)
strmSock.connect( tcpAddr )
rBuffer.seek(0)
while not False:
data = rBuffer.read(2048)
if not data:
break
strmSock.send(data)
finally:
strmSock.close()
def __init__(self,proj,listenIP,broadCastIP,createPort,beaglePort,artagPort,sonarPort,buffer):
# Communication parameters
self.listenerIP = listenIP
self.createPort = createPort
self.beaglePort = beaglePort
self.artagPort = artagPort
self.sonarPort = sonarPort
self.broadcastIP = broadCastIP
self.buffer = buffer
# Communication parameters
self.beagleAddr = (self.broadcastIP,self.beaglePort)
self.createAddr = (self.broadcastIP,self.createPort)
self.beagleSock = socket(AF_INET,SOCK_STREAM)
self.createSock = socket(AF_INET,SOCK_STREAM)
# Communication threads
self.listener = _RobotListener(self.listenerIP,self.artagPort,self.buffer)
self.broadcaster = _RobotBroadcaster(proj,self.broadcastIP,self.beagleSock,self.createSock,self.beagleAddr,self.createAddr,self.buffer)
self.viconMarkerListener = _ViconMarkerListener(20.0,"0.0.0.0",7500)# just use the default
self.targetMarker = None
self.viconMarkers = []
self.arrived = False
self.pickUpAttempt = 0
def proxy_server(): threading.Thread(target = target_server).start() s = socket(AF_INET, SOCK_STREAM) s_proxy = socket(AF_INET, SOCK_STREAM) s_proxy.connect((proxy_target_host, proxy_target_port)) s.bind((host, port)) print host, port s.listen(1) conn, addr = s.accept() while 1: data = conn.recv(1024) if not data: break try : s_proxy.sendall(data) target_data = s_proxy.recv(1024) if not target_data: print "target close the connect" break except: print "proxy failed to connect to target" conn.sendall(target_data) print "send to client: ", target_data
def synchrinize(self):
tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(self.addr)
#send command to get preview photo
data = struct.pack('i', 2)
tcpCliSock.send(data)
filelist = glob.glob1("local", "*.jpg")
data = struct.pack('i', len(filelist))
tcpCliSock.send(data)
tcpCliSock.close()
for each in filelist:
tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(self.synchronizeAddr)
filename = "local/" + each
filenameNoExt = each.split(".")[0]
hs = (filenameNoExt + "_" + self.hashing(filename)).encode()
tcpCliSock.send(hs)
tf = tcpCliSock.recv(256)
if tf == b'1':
tcpCliSock.close()
continue
th = Thread(target=self.sendData, args=(tcpCliSock, filename, ))
th.start()
def run():
host = ''
backlog = 5
sock_GCS = None
addr_udp = None
# create tcp socket
tcp = socket(AF_INET, SOCK_STREAM)
tcp.bind(('',DEFAULT_PORT))
tcp.listen(backlog)
# create udp socket
udp = socket(AF_INET, SOCK_DGRAM)
udp.bind(('',DEFAULT_PORT))
input = [tcp,udp]
while True:
inputready,outputready,exceptready = select(input,[],[])
for s in inputready:
if s == tcp:
sock_GCS, addr = s.accept()
input.append(sock_GCS)
elif s == udp:
data, addr_udp = s.recvfrom(MAVLINK_LENGTH)
if sock_GCS is not None and data is not None:
sock_GCS.send(data)
else:
data = sock_GCS.recv(MAVLINK_LENGTH)
if addr_udp is not None and data is not None:
udp.sendto( data, addr_udp )
def __init__(self, port=5678):
self.host = ""
self.port = port
self.addr = (self.host, self.port)
self.buf = 1024
self.udpsock = socket(AF_INET, SOCK_DGRAM)
self.tcpsock = socket(AF_INET, SOCK_STREAM)
def run_test(n):
print('Sending', NMESSAGES, 'messages')
if args.mpr:
n //= args.mpr
if unix:
sock = socket(AF_UNIX, SOCK_STREAM)
else:
sock = socket(AF_INET, SOCK_STREAM)
try:
sock.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
except (OSError, NameError):
pass
sock.connect(addr)
while n > 0:
sock.sendall(msg)
nrecv = 0
while nrecv < REQSIZE:
resp = sock.recv(REQSIZE)
if not resp:
raise SystemExit()
nrecv += len(resp)
n -= 1
def feeder(id,diagMsg):
currentTime = str(time.time())
# 1. Send Keep Alive to Watchdog Server
s = socket(AF_INET, SOCK_STREAM)
s.settimeout(.5)
try:
s.connect(('localhost', 8080))
toSend = id+","+currentTime
s.send(toSend.encode())
s.close()
print("Keep Alive Message = "+toSend)
except error:
print("No Watchdog Server available")
# 2. Send Diagnostic Message to Diagnostic Server (192.168.1.248)
time.sleep(1)
s = socket(AF_INET, SOCK_STREAM)
s.settimeout(.5)
try:
s.connect(('192.168.1.248', 8081))
toSend = id+","+currentTime+","+diagMsg+"\n"
s.send(toSend.encode())
s.close()
#print("Diagnostic Message = "+toSend)
except error:
print("No Diagnostic Server available")
def start_proxy(ipaddr, port):
try: #create sockets
s = socket(AF_INET, SOCK_STREAM) #for listening and receiving data
s1 = socket(AF_INET, SOCK_STREAM) #for connecting and sending data
s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
except socket.error:
print("Failed to create socket.")
s.bind((ipaddr, port)) #bind socket to (ipaddr,port)
s.listen(1) #start listening through socket, s
client, addr = s.accept() #connection found
print("applying proxy for ",addr)
time.sleep(1)
#receiving destination IP address from source client
destip = client.recv(16).decode('utf8')
time.sleep(1)
#receiving destination port from source client
destport = client.recv(4).decode('utf8')
#connect to destination client through socket, s1
s1.connect((str(destip),int(destport)))
while(True):
data = client.recv(1024).decode('utf8') #receive from source client
if not data:
break
print("Message received : ",data)
print("Sending data to destination")
s1.send(data.encode('utf8')) #send to destination client
client.close() #closing sockets
s.close()
s1.close()
def run(self):
resock = socket(AF_INET, SOCK_STREAM)
print('trying to connect to '+self.contact+'\n')
try:
resock.connect((self.address, 4321))
except:
print ('could not connect to '+self.contact)
resock.send('start conference')
print ('sent conf request to'+self.contact+'\n')
resock.send(self.confid)
#resock.send(self.data)
#print('sent '+self.data+' to '+self.contact)
while 1:
print ('waiting for reply from '+self.contact)
indata = resock.recv(1024)
if indata == 'yes':
print(self.contact+' accepted conf starting data sock')
datasocket = socket(AF_INET, SOCK_STREAM)
datasocket.connect((self.address, 4321))
datasocket.send('start conference')
datasocket.send(self.confid)
#wx.CallAfter(self.confwin.newcon, self.contact, self.address)
wx.CallAfter(self.confwin.contacton, self.contact, self.address, resock, datasocket)
break
else:
print (self.contact+' refused the conference request')
break
def hopSpecificTTL(my_dest_ip, my_ttl, attempts):
send_socket = socket(AF_INET, SOCK_DGRAM, getprotobyname('udp'))
recv_socket = socket(AF_INET, SOCK_RAW, getprotobyname('icmp'))
send_socket.setsockopt(SOL_IP, IP_TTL, my_ttl)
recv_socket.settimeout(1)
recv_socket.bind(("", 33434))
# joes packet signifies my message
send_socket.sendto("joespacket", (my_dest_ip, 33434))
current_address = None
try:
data, current_address = recv_socket.recvfrom(5120)
current_address = current_address[0]
if current_address == None:
if attempts > 5:
# print ("***")
return "***"
else:
hopSpecificTTL(my_dest_ip, my_ttl, attempts+1)
except error:
if attempts > 5:
# print "***"
return "***"
else:
hopSpecificTTL(my_dest_ip, my_ttl, attempts+1)
finally:
send_socket.close()
recv_socket.close()
# if (current_address != None):
# print ("ttl: {} , current_address: {}".format(my_ttl, current_address))
return current_address
def distribute_data(self):
whole_data = cStringIO.StringIO()
for i in self.result:
for csio in self.result[i]:
d = string.strip(csio.getvalue())
if len(d) == 0:
continue
whole_data.write(d)
whole_data.write("\n")
del csio
if self.distinct or self.limit != -1:
data_list = whole_data.getvalue().split(self.db_row_sep)
del whole_data
if self.distinct:
data_list = set(data_list)
if self.limit != -1:
data_list = data_list[:self.limit]
data = cStringIO.StringIO()
data.write(self.db_row_sep.join(str(s) for s in data_list))
del data_list
else:
data = whole_data
if self.dest == conf.DATA_TO_ONE_CLIENT:
# send data to a random client
random_num = random.randint(0, len(self.client_sock) - 1)
addr = self.client_sock[random_num]
sock = socket(AF_INET, SOCK_STREAM)
sock.connect(addr)
data_s = data.getvalue()
sock.send("%10s%s" % (len(data_s), data_s))
re = sock.recv(10)
assert re == "OK"
sock.close()
elif self.dest == conf.DATA_TO_DB:
self.data = data
col_sep = self.db_col_sep
row_sep = self.db_row_sep
master = (self.master_name, self.master_port)
ParaLiteLog.debug("Load data start:")
# send request to the master
t_size = len(data.getvalue())
sep = conf.SEP_IN_MSG
tag = conf.LOAD_FROM_API
if row_sep is None or row_sep == "\n":
temp_sep = "NULL"
else:
temp_sep = row_sep
msg = sep.join(
str(s) for s in [conf.REQ, self.cqid, gethostname(),
self.my_port, self.dest_db, self.dest_table,
t_size, tag, self.fashion, temp_sep, "0"])
so_master = socket(AF_INET, SOCK_STREAM)
so_master.connect(master)
so_master.send("%10s%s" % (len(msg),msg))
so_master.close()
def __init__(self, target, time_out):
self.target_addr = getaddrinfo(target, 'http', AF_INET, SOCK_DGRAM, IPPROTO_UDP)[0][4][0]
self.timeout = time_out
self.port = 33434
self.recv_sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)
self.send_sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)
self.recv_sock.bind(('0.0.0.0', 0))
def getAllPhoto(self):
tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(self.addr)
#send command to get preview photo
data = struct.pack('i', 1)
tcpCliSock.send(data)
#receive number of files
data = tcpCliSock.recv(1024)
count = struct.unpack('i', data)[0]
tcpCliSock.close()
#each connections receive a file
for each in range(count):
tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(self.recvAllPhotoAddr)
filename = tcpCliSock.recv(256).decode()
filename = 'temp/' + filename
th = Thread(target=self.receiveData, args=(tcpCliSock, filename, ))
th.start()
# On Windows, the best timer is time.clock()
default_timer = time.clock
else:
# On most other platforms the best timer is time.time()
default_timer = time.time
# ICMP parameters
ICMP_ECHOREPLY = 0 # Echo reply (per RFC792)
ICMP_ECHO = 8 # Echo request (per RFC792)
ICMP_MAX_RECV = 2048 # Max size of incoming buffer
MAX_SLEEP = 1000
TIME_PORT = 37133
MONI_PORT = 33844
if __name__ == '__main__':
#time synchronization
if len(sys.argv) == 3:
HOST = argv[2]
else:
print "Error: "
sys.exit()
soc = socket(AF_INET)
soc.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
print("[*] connecting to %s:%s" % (HOST, TIME_PORT))
soc.connect((HOST, MONI_PORT))
# FIXME: Add a real CLI
print("[*] connecting to %s:%s" % (HOST, MONI_PORT))
# verbose_ping(sys.argv[1])
soc.sendall(' ' + "\n")
# Import socket module
from socket import *
import sys # In order to terminate the program
# Create a TCP server socket
#(AF_INET is used for IPv4 protocols)
#(SOCK_STREAM is used for TCP)
serverSocket = socket(AF_INET, SOCK_STREAM)
# Assign a port number
serverPort = 6789
# Bind the socket to server address and server port
serverSocket.bind(('', serverPort))
# Listen to at most 1 connection at a time
serverSocket.listen(1)
# Server should be up and running and listening to the incoming connections
while True:
print('The server is ready to receive')
# Set up a new connection from the client
connectionSocket, addr = serverSocket.accept()
# If an exception occurs during the execution of try clause
# the rest of the clause is skipped
# If the exception type matches the word after except
# the except clause is executed
def Stable_Server(cls, port, func=None, address='', backlog=3, buffer=4096, listener=1, stop_keyword='Server --kill'):
if backlog == 0 or backlog > 200:
return False
try:
NO_USE = subprocess.run('chcp 65001', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
except:
pass
_LISTENER = int(listener)
_BUFFER = int(buffer)
_BACKLOG = int(backlog)
_HOST = str(address)
_FUNC = func
_PORT = int(port)
try:
socket_server = socket()
socket_server.bind((_HOST,_PORT))
socket_server.listen(_LISTENER)
except error as sk_error:
cls.Stable_Server(_PORT, backlog=(_BACKLOG-1))
try:
while True:
CONNECTION, (client_IP, client_PORT) = socket_server.accept()
try:
while True:
try:
_recieveData = CONNECTION.recv(_BUFFER).decode()
if _recieveData.lower() == stop_keyword:
return None
if func:
response = _FUNC(str(_recieveData))
else:
response = cls.Server_RESPONSE_NULL(str(_recieveData))
response = str(response)
response = response.encode()
CONNECTION.send(response)
except:
CONNECTION.send('Flag Error :: Server-Failed-Queue'.encode())
except:
pass
finally:
CONNECTION.close()
finally:
socket_server.close()
return None
import time
import datetime
import re
import base64
import ssl
# 写文件函数，保存发送信息：发送时间，发送方，发送信息，接收方
def save_to_file(where_file, contents):
save_file = open(where_file, 'w')
save_file.write(contents)
save_file.close()
# 开始server端的socket
s = socket()
if (s):
print("server端socket对象创建成功")
else:
print("创建对象失败。。。")
s.close()
sys.exit(0)
# 本地主机名和端口
host = "127.0.0.1"
# port = 465
port = 25
# 绑定端口号
s.bind((host, port))
# 设置等待监听连接数
del clients[client]
broadcast(bytes("%s has left the chat."% name, "utf8"))
break
def broadcast (msg, prefix = ""): #prefix is for name identification -- prefixo é para identificar quem fala
#""" Broadcasts a message to all the clients -- Enviar uma mensagem em broadcast para todos """"
for sock in clients:
sock.send(bytes(prefix, "utf8")+ msg)
clients = {}
addresses = {}
HOST = ''
PORT = 33000
BUFFSIZE = 1024
ADDR = (HOST, PORT)
SERVER = socket(AF_INET, SOCK_STREAM)
SERVER.bind(ADDR)
if __name__ == "__main__":
SERVER.listen(5) #Listen for 5 conections at max -- permita no m[aximo 5 conexões
print("Waiting for connection...")
ACCEPT_THREAD = Thread(target = accept_incoming_connections)
ACCEPT_THREAD.start() #Start the infinite loop -- iniciando o loop infinito
ACCEPT_THREAD.join()
SERVER.close()
def __init__(self, skt=None):
if skt is None:
self.sock = socket(AF_INET, SOCK_STREAM)
else:
self.sock = skt
from socket import *
HOST = '127.0.0.1'
PORT = 21561
BUFSIZ = 1024
ADDR = (HOST, PORT)
udpCliSock = socket(AF_INET, SOCK_DGRAM)
while True:
data = input('> ')
if not data:
break
udpCliSock.sendto(bytes(data, 'utf-8'), ADDR)
data, addr = udpCliSock.recvfrom(BUFSIZ)
if not data:
break
print(data.decode('utf-8'))
udpCliSock.close()
from socket import *
from time import sleep
host = '10.0.0.41'
port = 12000
clientSocket = socket(AF_INET, SOCK_DGRAM)
clientSocket.sendto('plex', (host, port))
message, address = clientSocket.recvfrom(1024)
print message
clientSocket.close()
def runServer():
s = socket(AF_INET, SOCK_DGRAM)
s.bind((HOST, PORT))
while True:
last_type = DATA
message = ""
print '\n\n============ START NEW MESSAGE ============'
while last_type == DATA:
msg = s.recvfrom(PACKET_SIZE)
client = msg[1]
r_type, r_chksum, r_len, r_payload = struct.unpack(
PACKET_FMT, msg[0])
if r_type == TERM:
print "Server received TERM. Exiting..."
exit(0)
elif r_type not in [DATA, LAST_DATA]:
print "Server received invalid packet type while receiving message! \
Exiting..."
exit(1)
if random() < DROP_RATE:
print 'ERROR IN CHECKSUM OCCURRING...',
r_chksum += 13
ret_type = ACK if r_chksum == checksum(r_payload) else NACK
print "Received: '" + r_payload + "'...",
r_payload = r_payload.strip('\0x00')
r_payload = r_payload[0:r_len]
message += r_payload if ret_type == ACK else ""
print "Sending ACK" if ret_type == ACK else "Sending NACK"
last_type = LAST_DATA if r_type == LAST_DATA and ret_type == ACK else DATA
s.sendto(struct.pack(PACKET_FMT, ret_type, 0, 0, ''), client)
print "Received LAST_DATA successfully. Sending back message to client"
essagemay = piglatinize(message)
essagemay = essagemay.strip()
packets = packetize(essagemay)
print "\nOriginal message: " + message
print "Response: '" + essagemay + "'\n"
i = 0
while (i < len(packets)):
curr_pkt = packets[i][:]
if random() < DROP_RATE:
print 'ERROR IN CHECKSUM OCCURRING...',
curr_pkt[1] += 13
print "Sending packet #" + str(i) + "... " + str(curr_pkt) + ".",
s.sendto(
struct.pack(PACKET_FMT, curr_pkt[0], curr_pkt[1], curr_pkt[2],
curr_pkt[3]), client)
msg = s.recvfrom(PACKET_SIZE)
r_type, r_chksum, r_len, r_payload = struct.unpack(
PACKET_FMT, msg[0])
if r_type == TERM:
print "Server received TERM. Exiting..."
exit(0)
elif r_type != ACK and r_type != NACK:
print "Server received invalid packet type while sending message! \
Exiting..."
exit(1)
i += 1 if r_type == ACK else 0
print 'Received ACK' if r_type == ACK else 'Received NACK'
return
# UNIVERSIDADE FEDERAL DO RIO GRANDE DO NORTE
# DEPARTAMENTO DE ENGENHARIA DE COMPUTACAO E AUTOMACAO
# DISCIPLINA REDES DE COMPUTADORES (DCA0113)
# AUTORES: Francisco Kennedi
# Lara Beatriz
# SCRIPT: Chat com servidor (Cliente)
#
# importacao das bibliotecas
from socket import *
import threading
# definicao das variaveis
serverName = 'localhost' # ip do servidor
serverPort = 65000 # porta a se conectar
clientSocket = socket(AF_INET,SOCK_STREAM) # criacao do socket TCP
clientSocket.connect((serverName, serverPort)) # conecta o socket ao servidor
message = ''
nickname = input('Digite o seu nome: ')
clientSocket.send(nickname.encode('utf-8'))
print('Bem vindo, pode começar a conversar!\n')
def print_messages(message):
while message != 'quit':
received_messages = clientSocket.recv(1024)
print(received_messages.decode('utf-8'))
return 0
while message != 'quit':
import sys, os
from socket import *
# Establece el nombre y el puerto del servidor (serán dos parámetros
# pasados por la línea de comandos).
if (len(sys.argv) > 2):
server_name = sys.argv[1]
server_port = int(sys.argv[2])
else:
print("Uso: python cliente_basico server_name server_port")
sys.exit(1)
# Obtiene la dirección IP correspondiente al servidor.
server_address = gethostbyname(server_name)
# Crea un socket.
connection_socket = socket(AF_INET, SOCK_STREAM)
# Conecta el socket al servidor.
connection_socket.connect((server_address, server_port))
# Crea los ficheros asociados con el socket. Permite leer y escribir del
# socket como si de un fichero se tratase.
incoming_stream = connection_socket.makefile("r")
outgoing_stream = connection_socket.makefile("w")
# Ahora el cliente puede comunicarse con el servidor.
# Lee la hora y la imprime en la salida estándar (monitor).
print(incoming_stream.read())
# Cierra la conexión y termina
incoming_stream.close()
outgoing_stream.close()
connection_socket.close()
from socket import *
from time import ctime
import time
import psycopg2
import psycopg2.extras
import pprint
import datetime
##HOST = '127.0.0.1'
HOST = '59.78.35.20' # 主机
PORT = 8002 # 端口号，可以随意选择
BUFSIZ = 1024
ADDR = (HOST, PORT) #主机端口号组成一个套接字地址
tcpSerSock = socket(AF_INET, SOCK_STREAM) #创建一个套接字对象，是AF_INET族的tcp套接字
tcpSerSock.bind(ADDR) #这个函数用于绑定地址到套接字
tcpSerSock.listen(5) # 服务器开始监听连接，参数表示最多允许同时有几个连接进来
threads = []
##全部输出
##conn_string = "host='localhost' dbname='CNCXYZ' user='******' password='******'"
##conn = psycopg2.connect(conn_string)
##cursor = conn.cursor()
##cursor.execute("SELECT * FROM linear_position")
##records = cursor.fetchall()
##pprint.pprint(records)
##分行输出
##conn_string = "host='localhost' dbname='CNCXYZ' user='******' password='******'"
##conn = psycopg2.connect(conn_string)
##cursor = conn.cursor('name', cursor_factory=psycopg2.extras.DictCursor)
##cursor.execute('SELECT * From linear_position LIMIT 10000')
##
}
def check_response(response):
if response[RESPONSE] == 200:
return 200
else:
print(' >> BZZ! response not "200"\n')
return 400
if __name__ == '__main__':
print('начинаем соединение с сервером... пи-пи-пи')
# соединяемся с сервером, получаем текущее время
with socket(
AF_INET,
SOCK_STREAM) as sock: # Создаем сокет TCP в менеджере контекста
sock.connect((option.address, option.port)) # Соединиться с сервером
print('соединение установлено... ')
# принимаем текущее время
# tm = sock.recv(4096)
# print("Текущее время: %s" % tm.decode('ascii'))
''' формируем json данные приветствия и посылаем их серверу '''
presence[USER][ACCOUNT_NAME] = option.user
send_msg(sock, presence)
print('послали данные приветствия... ')
''' принимаем данные (подтверждение) от сервера '''
response = get_msg(sock)
#print('приняли ответ от сервера')
if response:
"""
tcp客户端 循环示例1
重点代码 ！！！
"""
from socket import *
# 服务器地址
ADDR = ("127.0.0.1", 8889)
# 默认就是tcp
tcp_socket = socket()
# 连接服务器
tcp_socket.connect(ADDR)
# 先发送再接收
while True:
msg = input(">>")
# 不通知服务端直接退出
if not msg:
break
tcp_socket.send(msg.encode())
# 结束退出
# if msg == "##":
# break
data = tcp_socket.recv(1024)
print("From server:", data.decode())
# 关闭
tcp_socket.close()
# 客户端ping程序服务器端
import random
from socket import *
serverSocket = socket(AF_INET, SOCK_DGRAM)
serverSocket.bind(('', 12000))
print("The server is ready to receive")
while True:
rand = random.randint(0, 10)
message, address = serverSocket.recvfrom(1024)
message = message.upper()
if rand < 4:
continue
serverSocket.sendto(message, address)
from socket import *
socketfd = socket()
socketfd.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
socketfd.bind(('127.0.0.1', 8887))
socketfd.listen(5)
while True:
print('wait for `````accept')
conn, addr = socketfd.accept()
print('accept!')
print(addr)
while True:
data = conn.recv(1024)
if not data:
break
print(data.decode())
a = open('pow.txt', 'rt')
print(a)
b = a.read()
print(b, end='')
send1 = conn.send(b.encode())
print('send:', send1)
a.close()
conn.close()
socketfd.close()
from socket import *
serverName = 'localhost'
serverPort = 12000
clientSocket = socket(AF_INET, SOCK_STREAM)
clientSocket.connect((serverName, serverPort))
sentence = input('Input lowercase sentence:')
clientSocket.send(sentence.encode())
modifiedSentence = clientSocket.recv(1024)
print('From Server:', modifiedSentence.decode())
message = modifiedSentence.decode()
clientSocket.close()
import os
from menu import menu
from socket import *
serverHost = 'localhost'
serverPort = 30801
sockObj = socket(AF_INET, SOCK_STREAM)
sockObj.connect((serverHost, serverPort))
sockObj.send(menu().encode('utf-8'))
titulo = sockObj.recv(1024).decode('utf-8')
with open('{}.mp3'.format(titulo), 'wb') as f:
l = sockObj.recv(10240)
while l:
f.write(l)
l = sockObj.recv(10240)
path = os.path.dirname(os.path.realpath(__file__))
print('Salvo em: {}'.format(path))
sockObj.close()
# import RPi.GPIO as GPIO
import time
# from functions import rc_time, ForwardStep, BackwardStep, Right90, Left90
from socket import *
import pickle
listener_address = ('localhost', 6000 )
listener_socket = socket()
listener_socket.connect(listener_address)
print listener_socket, 'connected'
main_address = ('localhost', 9000 )
main_socket = socket()
main_socket.connect(main_address)
print main_socket, 'connected'
def ds_process():
ds_threshold = 10 # to be caliberated
while True:
msg = False
ds_reading = int(raw_input('ds reading: '))
listener_socket.send('ds_reading:' + str(ds_reading))
if ds_reading < ds_threshold:
msg = True
main_socket.send('ds status:' + str(msg))
if __name__ == "__main__":
try:
ds_process()
except KeyboardInterrupt:
pass
from socket import *
import sys
if len(sys.argv) <= 1:
print(
'Usage : "python ProxyServer.py server_ip"\n[server_ip : It is the IP Address Of Proxy Server'
)
sys.exit(2)
# Create a server socket, bind it to a port and start listening
tcpSerSock = socket(AF_INET, SOCK_STREAM)
# Fill in start
tcpSerSock.bind(('127.0.0.1', 12001))
tcpSerSock.listen(1)
# Fill in end
while 1:
# Strat receiving data from the client
print('Ready to serve...')
tcpCliSock, addr = tcpSerSock.accept()
print('Received a connection from:', addr)
# Fill in start
message = tcpCliSock.recv(1024)
# Fill in End
print(message)
# Extract the filename from the given message
print(message.split()[1])
filename = message.decode().split()[1].partition("/")[2]
print(filename)
fileExist = "false"
filetouse = "/" + filename
def __Connect__(TargetIPAddressAfter, TargetPortAfter):
soc = socket(AF_INET, SOCK_STREAM)
soc.connect((TargetIPAddressAfter, TargetPortAfter))
reply = soc.recv(1024)
return reply
from geometry_msgs.msg import Twist
zTwist = 0.0000
xTwist = 0.0000
forward = 0.0
left = 0.0
Max_Forward = 0.8
Max_Side = 0.9
# This segment contains some preliminary items needed so that the socket can listen to anyone who would access its port
host = "" # So that IP doesn't matter
port = 2362 # Remember, this is the port that you MUST connect to on ARC
buf = 1024 # Buffer size
addr = (host, port)
UDPSock = socket(AF_INET, SOCK_DGRAM)
UDPSock.bind(addr)
print "Waiting to receive messages..." # This is a printout that tells us that our server is ready
while True: # Our server will continue receiving messages forever until you press the SELECT key on ARC
pub = rospy.Publisher('/RosAria/cmd_vel', Twist)
pub2 = rospy.Publisher('/cmd_vel', Twist)
rospy.init_node('p3dx_mover')
twist = Twist()
(data, addr) = UDPSock.recvfrom(buf) # Socket is listening for messages
buttonPressed=str(data)
if buttonPressed == "button select 1": # By pressing the SELECT button, you're shutting down connection between the ARC and GAZEBO
print "Closing Socket..."
break
def __init__(self, port):
Thread.__init__(self)
self.listeClient = []
self.s = socket(AF_INET, SOCK_STREAM)
self.s.bind(('', port))
BROADCAST_TO_PORT = 6969
SLEEP_SEC = 600 #skal være 600(10 minutter) men test ved 5-15 sec
from datetime import datetime
from sense_hat import SenseHat
sense = SenseHat()
now = datetime.now()
import json
import time
from socket import *
#sets the Ip locally
ip = "127.0.0.1"
s = socket(AF_INET, SOCK_DGRAM)
s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
while True:
# Take readings from all three sensors
t = sense.get_temperature_from_humidity()
p = sense.get_pressure()
h = sense.get_humidity()
# Round the values to one decimal place
t = round(t, 1)
p = round(p, 1)
h = round(h, 1)
#define the sensor data
data = "Pressure: " + str(t) + " Temperature: " + str(
t) + " Humidity: " + str(h) + " Time: " + str(datetime.now())
#broadcast the defined data
#!/usr/bin/python
from socket import *
from time import ctime
HOST = '192.168.1.3'
PORT = 8888
BUFSIZE = 1024
ADDR = (HOST, PORT)
sockfd = socket(AF_INET, SOCK_STREAM)
sockfd.bind(ADDR)
sockfd.listen(5)
while True:
print "waiting for connection....."
connfd, addr = sockfd.accept()
print "connected from :", addr
while True:
data = connfd.recv(BUFSIZE)
if not data:
break
connfd.send("[%s] : %s" % (ctime(), data))
sockfd.close()
connfd.close()
from socket import *
import sys
import pickle
# Taking the arguments from Command line input
server_name = str(sys.argv[1])
server_port = int(sys.argv[2])
# Create socket Server
socket_client = socket(AF_INET, SOCK_DGRAM)
socket_client.settimeout(1) # Connection timeout set to 1 second
for ping_seq in range(1, 2):
# keeps listening for user input until quit is typed in the command
print("Client is Running. ")
while 1:
message = input("Input your command: \n")
# If quit is typed, then both the server and client will quit
if message == 'quit':
try:
socket_client.sendto(message.encode(),
(server_name, server_port))
received_message, server_address = socket_client.recvfrom(
2048) # Received msg from Server
deserialized_message = pickle.loads(received_message)
print(deserialized_message)
except timeout: # Timer set to 1 second
print('Request Timed Out.')
print("User Requested to Quit. Quitting CLient ")
exit()
# For any other commands, it will be forwarded to server and processed there.
from socket import *
s = socket()
print("socket created")
s.bind(('localhost', 9999))
s.listen(3)
print("wait for connection")
while True:
c, addr = s.accept()
print("connected with", addr)
c.send(bytes('welcome to newchart', 'utf-8'))
while True:
#r=input('enter the "r" to recive message to send message enter "c"')
#if r=='r':
print(c.recv(1024).decode())
#elif r=='c':
chat = input("enter the chat: ")
c.send(bytes(chat, 'utf-8'))
if chat == 'end':
break
c.close()
break
"""
基于 select 方法的 IO多路复用网络并发
重点代码 !!!
"""
from socket import *
from select import select
# 创建好监听套接字
sockfd = socket()
sockfd.bind(('0.0.0.0',8888))
sockfd.listen(5)
# 与非阻塞IO配合防止传输过程阻塞
sockfd.setblocking(False)
# 准备IO进行监控
rlist = [sockfd]
wlist = []
xlist = []
# 循环监控IO发生
while True:
# 开始监控IO
rs,ws,xs = select(rlist,wlist,xlist)
# 伴随监控的IO的增多,就绪的IO情况也会复杂
# 分类讨论 分两类 sockfd（监听套接字，客户端链接了就能触发监听套接字） -- connfd（客户端链接套接字）
for r in rs:
# 有客户端连接
if r is sockfd:
connfd,addr = r.accept()
print("Connect from",addr)
#!/usr/bin/env python
import RPi.GPIO as GPIO
import video_dir
import car_dir
import motor
from socket import *
from time import ctime # Import necessary modules
HOST = '' # The variable of HOST is null, so the function bind( ) can be bound to all valid addresses.
PORT = 21567
BUFSIZ = 1024 # Size of the buffer
ADDR = (HOST, PORT)
tcpSerSock = socket(AF_INET, SOCK_STREAM) # Create a socket.
tcpSerSock.bind(ADDR) # Bind the IP address and port number of the server.
tcpSerSock.listen(
5
) # The parameter of listen() defines the number of connections permitted at one time. Once the
# connections are full, others will be rejected.
busnum = 1 # Edit busnum to 0, if you uses Raspberry Pi 1 or 0
def setup():
global offset_x, offset_y, offset, forward0, forward1
offset_x = 0
offset_y = 0
offset = 0
forward0 = 'True'
forward1 = 'False'
try:
from socket import *
serverip='127.0.0.1'
serverport=12000
socket_client=socket(AF_INET,SOCK_STREAM)
socket_client.connect((serverip,serverport))
sentence=raw_input("enter a lower case sentence-")
socket_client.send(sentence)
modified_sentence=socket_client.recv(1024)
print modified_sentence
print socket_client
socket_client.close()
