Exemplo n.º 1
1
 def listen_push_port(self, port):
   port.sockets = []
   for port_url in port.port_urls:
     socket = self.context.socket(zmq.PUSH)
     socket.setsockopt(zmq.HWM, self.queue_size)
     socket.connect(port_url)
     port.sockets.append(socket)
Exemplo n.º 2
0
def main():
	host = ''
	port = 80

	socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

	try:
		socket.connect(host, port)

	except Exception as e:
		print ("Couldn't acquire port :", port,"\n")

		try:
			port = 8080
			socket.connect(host, port)

		except Exception as e:
			print ("Couldn't connect to port 80 ad 8080")

	print ("Success: client connected to host: ", host, "and port: ", port)


	while True:
		sys.stdout.write("Client ready to send request:")
		cmd = str(sys.argv)
		print ("Sending command to server: %s" % cmd)
		print ("Host name: %s" % str(sys.argv[1]))
		print ("Port: %s" % str(sys.argv[2]))
		print ("Filename: %s" % str(sys.argv[2]))
 
		socket.send(cmd)
		response = socket.recv(1024)
		if response:
			sys.stdout.write(response)
	socket.close()
Exemplo n.º 3
0
def get_replay(name, query, config, context=None):
    endpoint = config.get('replay_endpoints', {}).get(name, None)
    if not endpoint:
        raise IOError("No appropriate replay endpoint "
                      "found for {0}".format(name))

    if not context:
        context = zmq.Context(config['io_threads'])

    # A replay endpoint isn't PUB/SUB but REQ/REP, as it allows
    # for bidirectional communication
    socket = context.socket(zmq.REQ)
    try:
        socket.connect(endpoint)
    except zmq.ZMQError as e:
        raise IOError("Error when connecting to the "
                      "replay endpoint: '{0}'".format(str(e)))

    # REQ/REP dance
    socket.send(fedmsg.encoding.dumps(query))
    msgs = socket.recv_multipart()
    socket.close()

    for m in msgs:
        try:
            yield fedmsg.encoding.loads(m)
        except ValueError:
            # We assume that if it isn't JSON then it's an error message
            raise ValueError(m)
Exemplo n.º 4
0
  def send(self, message_type=None, message_type_args={}, request_id=None):
    if(not request_id):
      request_id = uuid.uuid4()
    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    socket.connect("tcp://{0}:{1}".format(self._ip, self._port))
    socket.poll(timeout=1)
    poller = zmq.Poller()
    poller.register(socket, zmq.POLLIN)
    lib.debug.info("Sending request {0} …".format(request_id))

    timestarted = time.time()
    hostdetails = simplejson.dumps({'hostname':lib.hostname_ip.hostname, 'ip':lib.hostname_ip.ip})
    send_msg = simplejson.dumps(self.process(message_type, message_type_args,hostdetails))
    socket.send_multipart([bytes(unicode(request_id)), bytes(unicode(hostdetails)), bytes(unicode(message_type)), bytes(unicode(send_msg))])
    while(True):
      sockets = dict(poller.poll(10000))
      if(sockets):
        for s in sockets.keys():
          if(sockets[s] == zmq.POLLIN):
            try:
              (recv_id, recv_hostdetails, recv_msg_type, recved_msg) = s.recv_multipart()
              recv_message = self.process(recv_msg_type, recved_msg,recv_hostdetails)
              lib.debug.info("Received reply %s : %s [ %s ]" % (recv_id, recv_message, time.time() - timestarted))
            except:
              lib.debug.info (sys.exc_info())
            break
        break
      lib.debug.info ("Reciever Timeout error : Check if the server is running")



    socket.close()
    context.term()
Exemplo n.º 5
0
def orca_producer(host, port=44666):
    """
    Pushes CMOS and base current records to a ZMQ Push/Pull socket
    to be parsed by other workers. CMOS rates and base currents are
    pushed to ports 5557 and 5558 respectively.
    See `zeromq.org <http://zeromq.org>`_ for more information.
    """
    socket = Socket()
    socket.connect(host, port)

    cmos_context = zmq.Context()
    cmos = cmos_context.socket(zmq.PUSH)
    cmos.bind('tcp://127.0.0.1:5557')

    base_context = zmq.Context()
    base = base_context.socket(zmq.PUSH)
    base.bind('tcp://127.0.0.1:5558')

    while True:
        id, rec = socket.recv_record()
        if id == CMOS_ID:
            cmos.send_pyobj((id,rec))

        if id == BASE_ID:
            base.send_pyobj((id,rec))
Exemplo n.º 6
0
def getFile(filename):
    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    socket.connect("tcp://localhost:1337")
    socket.send(filename)
    response = socket.recv_json()
    return response
Exemplo n.º 7
0
 def _socketRequest(self, scheme, host, port, payload):
     socket = self._getSocketForScheme(scheme)
     socket.connect((host, port))
     socket.sendall(payload)
     data = socket.recv(1024)
     socket.close()
     return data
Exemplo n.º 8
0
 def send(self, service_name, method, *args):
     socket = NetRPC()
     socket.connect(self.hostname, self.port)
     socket.mysend((service_name, method, )+args)
     result = socket.myreceive()
     socket.disconnect()
     return result
Exemplo n.º 9
0
def localization_client(ip,port):
    context = zmq.Context()
    #  Socket to talk to server
    print "Connecting to localization server ... "
    socket = context.socket(zmq.REQ)
    socket.connect(("tcp://localhost:%d" % port))

    #  Do 10 requests, waiting each time for a response
    while True:
        # print("Sending request %s ... " % request)
        socket.send(b"pose")

        #  Get the reply.
        result = json.loads(socket.recv(1024));

        # printing the result
        # print(result)
        
        # In order to access position : (result["pos"]["x"],result["pos"]["y"],result["pos"]["z"])
        # In order to access orientation : (result["orient"]["w"],result["orient"]["x"],result["orient"]["y"],result["orient"]["z"])
        print "Position    : " , (float(result["pos"]["x"]),float(result["pos"]["y"]),float(result["pos"]["z"]))
        print "Orientation : " , (float(result["orient"]["w"]),float(result["orient"]["x"]),float(result["orient"]["y"]),float(result["orient"]["z"]))

        # wait for a while
        time.sleep(0.050)
Exemplo n.º 10
0
def main(network, nick, chan, port):
    socket.connect((network, port))
    irc = ssl.wrap_socket(socket)
    irc.send(bytes("NICK %s\r\n" % nick, "UTF-8"))
    print(irc.recv(4096))
    irc.send(bytes("USER %s %s %s :My bot\r\n" % (nick, nick, nick), "UTF-8"))
    print(irc.recv(4096))
    irc.send(bytes("JOIN #%s\r\n" % chan, "UTF-8"))
    print(irc.recv(4096))

    while True:
        data = irc.recv(4096)
        print(data)
        user_in = input(":")
        if user_in.find("!s") != -1:
            user_in = user_in[3:]
            searchterm = user_in
            try:
                print_search(searchterm)
            except KeyError:
                print("No Result Found")
        print(user_in)
        data = data.decode("UTF-8")
        if data.find("PING") != -1:
            irc.send(bytes("PONG " + data.split()[1] + "\r\n", "UTF-8"))
        if user_in.find("!q") != -1:
            irc.send(bytes("QUIT\r\n", "UTF-8"))
            exit()
        if user_in.find("!d") != -1:  ##to check for xfer
            bot_name = "Dragonkeeper"
            pack_number = "1"
            # user_in = user_in[3:]   ## for option select  !d 1  will show as 1
            irc.send(bytes("PRIVMSG " + bot_name + " :xdcc send " + pack_number + "\r\n", "UTF-8"))
Exemplo n.º 11
0
  def _worker(self,worker_url, worker_id=uuid.uuid4()):
    if (sys.platform.lower().find("linux") >= 0):
      setproctitle.setproctitle("server-worker")
    lib.debug.info (worker_url)
    context = zmq.Context()
    # Socket to talk to dispatcher
    socket = context.socket(zmq.REP)
    socket.poll(timeout=1)
    socket.connect(worker_url)

    while True:
      (request_id_rep, state_name_rep, topic_rep, msg_rep) = socket.recv_multipart()
      rep_sock.send_multipart([request_id_rep, state_name, msg_rep])
      lib.debug.debug(msg_rep)
      try:
        msg_reved = simplejson.loads(msg_rep)
        if (msg_reved['status'] == "free"):
          hosts_recieved[msg_reved['hostid']] = msg_reved
          lib.debug.debug("sending state : " + state_name_rep + " : ")
        else:
          return (msg_reved['status'] + " : " + msg_reved['request_id'])
      except:
        lib.debug.error(str(state_name) + " : " + str(request_id) + " : " + str(sys.exc_info()))
        return (str(state_name) + " : " + str(request_id) + " : " + str(sys.exc_info()))

    while True:
      received = socket.recv_multipart()
      lib.debug.info("Received request: [ {0} ] -> [ {1} ]".format(str(worker_id),msg_type_args))
      reply = self.process(received)
      reply_to_send = simplejson.dumps(reply)
      socket.send_multipart([bytes(unicode(hostid)),bytes(unicode(request_id)),bytes(unicode(reply_to_send))])
      lib.debug.info("Replied to request: [ {0} ] -> [ {1} ]".format(str(worker_id), msg_type_args))
def InitResource(version):
	global database, resource, socket, listflie, tfidfmodel, tfidfdict, table_state_strategy
	if version is 'v1':
		listfile = 'cnn_qa_human_response_name.list'
	if version is 'v2':
		listfile = 'cnn_qa_human_response_name_high_app.list'
        if version is 'v2.5':
		listfile = 'cnn_qa_human_response_name_high_app.list'
                tfidfdict = corpora.Dictionary.load(tfidfname + '.dict')
                tfidfmodel = models.tfidfmodel.TfidfModel.load(tfidfname + '.tfidf')
        if version is 'v3':
                listfile = 'cnn_hr_v1_v2.list'
                tfidfdict = corpora.Dictionary.load(tfidfname + '.dict')
                tfidfmodel = models.tfidfmodel.TfidfModel.load(tfidfname + '.tfidf')
        if version is 'v4':
                listfile = 'cnn_hr_v1_v2_v4.list'
                tfidfdict = corpora.Dictionary.load(tfidfname + '.dict')
                tfidfmodel = models.tfidfmodel.TfidfModel.load(tfidfname + '.tfidf')

        datalist=[line.strip() for line in open(listfile)]
	database = Loader.LoadDataPair(datalist)
	resource = Loader.LoadLanguageResource()
	global TemplateLib, TopicLib, TreeState, Template,model
	TemplateLib = Loader.LoadTemplate(template_list)
	TopicLib = Loader.LoadTopic(topicfile)
	TreeState, Template = Control.Init()
        model = models.Doc2Vec.load('/tmp/word2vec_50')
        if wizard is 2:
		context= zmq.Context()
		socket = context.socket(zmq.REQ)
		socket.connect("tcp://localhost:5555")
        with open('table_state_strategy.pkl') as f:
            table_state_strategy = pickle.load(f)
Exemplo n.º 13
0
def myConnect(socket,host,port):
    while True: ## send message to log
        try:
            socket.connect(host,port)
            break
        except:
            continue
def obtainTaskSpecFromServer(ServerIP, ServerPort, TeamName):
    # context = zmq.Context()
    # connection_address = "tcp://" + ServerIP + ":" + ServerPort
    # print "Start connection to " + connection_address
    # # Socket to talk to server
    # print "Connecting to server..."
    # socket = context.socket(zmq.REQ)
    # socket.connect(connection_address)
    #
    # print "Sending request ..."
    # socket.send(TeamName)
    #
    # # Get the reply.
    # message = socket.recv()
    # socket.send("ACK")
    # socket.close()
    # print "Received message: ", message
    # return message
    while True:
        try:
           socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
           socket.connect((ServerIP, ServerPort))
           errorPrinted = False
        except socket.error, err:
           if not errorPrinted:
               rospy.loginfo("Connection to %s:%s not succsesfull: %s", ServerIP, ServerPort, err)
               rospy.loginfo("retrying ...")
               errorPrinted = True
           rospy.sleep(1.)
        else:
            socket.send(MESSAGE)
            return waitForData(socket)
        rospy.loginfo("Connected to %s : %s", ServerIP, ServerPort)
Exemplo n.º 15
0
def connectTo(peer):
	socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
	socket.settimeout(10)
	try:
		socket.connect(peer)
	except:
		return False
	return True
Exemplo n.º 16
0
	def connect(self, socket, channel):
		n = self.nickname
		socket.connect((self.ip, self.port))
		self.socket_send(socket, "USER "+n+" "+n+" "+n+" :Jestem bogiem irc")
		self.socket_send(socket, "NICK "+n)
		time.sleep(10) # otherwise, it tends to not join the channel

		self.functions.join_channel(self.channel)
Exemplo n.º 17
0
 def connection(socket,host,port):
     try:
         socket.connect((host,port))
         return socket
     except IOError, e:
         if e.errno == 101:
             time.sleep(5)
             connection(socket,host,port)
Exemplo n.º 18
0
 def create_socket(socktype, endpoints,flag):
     socket = zmq.Socket(zmq.Context.instance(), socktype)
     socket.setsockopt(zmq.LINGER, 0)
     for endpoint in endpoints:
         if flag==1:
             socket.bind(endpoint)
         else:
             socket.connect(endpoint)
     return socket
Exemplo n.º 19
0
 def connect(self, addr):
     self.connected = False
     self.connecting = True
     socket = self.socket
     socket.setblocking(1)
     socket.connect(addr)
     socket.setblocking(0)
     self.addr = addr
     self.handle_connect_event()
Exemplo n.º 20
0
 def run(self):
     for i in range(self.packets):
         try:
             bytes = random._urandom(self.size)
             socket.connect(self.ip, self.port)
             socket.setblocking(0)
             socket.sendto(bytes,(self.ip, self.port))
         except:
             pass
Exemplo n.º 21
0
def connectWithPlayer(clientSocket, serverSocket):
    try:
        socket.connect('127.0.0.1', 3000)
        print('Connected with player')
        return 1
    except:
        print('Waiting for players....')
        c, addr = serverSocket.accept()
        print('Connected with player')
 def connectToServer(self, ip, port):
     
     import socket
     
     socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     
     socket.connect((ip, port))
     
     return socket
Exemplo n.º 23
0
 def add_socket (self, socket):
     # get socket to connect
     socket.connect()
     if socket.sock is not None :
         fd = socket.sock.fileno()
         self.sockets[fd] = socket
         self.poller.register(socket.sock, select.POLLIN | select.POLLPRI | select.POLLHUP | select.POLLERR)
     else :
         self.logger.log ('unable to add socket to poller, sock==None')
Exemplo n.º 24
0
def CONNECTION():
    port=input("Enter FTP Port: ")
    
    if port == '':
         port = 21
    else: port = port
    
    socket.connect((input("Enter FTP Address: "),port))
    RECIEVE()
Exemplo n.º 25
0
def ban_swabber(ip):
    if not zmq:
        raise SystemExit("swabber engine enabled but zmq not available!")

    context = zmq.Context()
    socket = context.socket(zmq.PUB)
    socket.connect("tcp://127.0.0.1:22620")
    socket.send_multipart(("swabber_bans", ip))
    socket.close()
    return True
Exemplo n.º 26
0
 def run(socket):
     socket.bind((address, port))
     try:
         socket.connect((self.DEFAULT_SRC_ADDRESS,
                         self.DEFAULT_SRC_PORT))
         self.end_event.wait()
         socket.free()
     except Exception, e:
         traceback.print_exc(e)
         self.network.close()
Exemplo n.º 27
0
	def __init__(self):

		
		socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		try:
			socket.connect((configbone.FloatHOST, configbone.BoneSocket))
			while True:
				data = sensors()
				socket.send(data)
		except:
			sock.close()
Exemplo n.º 28
0
def _rpc(action, *args):
    _logger.debug("About to send rpc request %s with args %s", action, args)
    with sockets.context.socket(zmq.REQ) as socket:
        #
        # To avoid problems when restarting a beacon not long after it's been
        # closed, force the socket to shut down regardless about 1 second after 
        # it's been closed.
        #
        socket.connect("tcp://localhost:%s" % _Beacon.rpc_port)
        socket.send(_pack([action] + list(args)))
        return _unpack(socket.recv())
Exemplo n.º 29
0
def get_connection(socket, endpoint, ssh_server=None, ssh_keyfile=None):
    if ssh_server is None:
        socket.connect(endpoint)
    else:
        try:
            try:
                ssh.tunnel_connection(socket, endpoint, ssh_server, keyfile=ssh_keyfile)
            except ImportError:
                ssh.tunnel_connection(socket, endpoint, ssh_server, keyfile=ssh_keyfile, paramiko=True)
        except ImportError:
            raise ImportError("pexpect was not found, and failed to use " "Paramiko.  You need to install Paramiko")
Exemplo n.º 30
0
def tunnel_connection(socket, addr, server, keyfile=None, password=None, paramiko=None, timeout=60):
    """Connect a socket to an address via an ssh tunnel.

    This is a wrapper for socket.connect(addr), when addr is not accessible
    from the local machine.  It simply creates an ssh tunnel using the remaining args,
    and calls socket.connect('tcp://localhost:lport') where lport is the randomly
    selected local port of the tunnel.

    """
    new_url, tunnel = open_tunnel(addr, server, keyfile=keyfile, password=password, paramiko=paramiko, timeout=timeout)
    socket.connect(new_url)
    return tunnel
Exemplo n.º 31
0
Arquivo: resta.py Projeto: jorszs/C-S
def server():
    while True:
        # time.sleep(2)
        try:
            context_rep = zmq.Context()
            socket = context_rep.socket(zmq.REP)
            socket.bind("tcp://*:" + mi_port)
            try:
                print("servidor ejecutando...")
                message = socket.recv_string()
                print(message)
                l = message.split("_")
                # print(l)
                # print(type(l[0]))
                #print("cualquier cosa")

                if l[0] == "p":
                    if l[1] == yo:
                        # aqui se devuelve enviando el puerto del sevicio hasta llegar a cliente

                        print(l)

                        ruta = l[5]  # se extrae el diccionario_string ruta
                        # se convierte a diccionario
                        ruta_dic = json.loads(ruta)
                        # agrego mi servicio/nodo a la ruta
                        ruta_dic[yo] = {"ip": nombre_equipo, "puerto": mi_port}
                        keys = []  # se guardaran las keys del diccionario ruta
                        # se extraen todas las keys (para saber cuantos nodos hay en la ruta)
                        for key in ruta_dic:
                            keys.append(key)
                        # se agrega el dato ruta actualizado a la lista
                        #l[5] = json.dumps(ruta_dic)
                        print("llaves de ruta: ", keys)

                        # si estamos ubicados en el ultimo nodo mas cercano al cliente cambiamos el token que esta al inicio del mensaje
                        # lo sabemos si en ruta solo quedan dos nodos: el cliente y el que tiene el servicio

                        context_respuesta = zmq.Context()
                        socket_respuesta = context_respuesta.socket(zmq.REQ)

                        print(directorio)
                        # traer la seccion de ruta para analizar cual fue el ultimo nodo agregado
                        # enviar el puerto y el host al ultimo nodo
                        # eliminar el ultimo nodo de la ruta
                        #a = directorio.get(l[4])

                        a = ruta_dic.get(keys[-2])
                        # eliminar penultimo nodo de ruta (el ultimo contiene la direccion del servicio buscado)
                        if len(keys) > 2:
                            ruta_dic.pop(keys[-2])

                        l[5] = json.dumps(ruta_dic)
                        l[0] = "s"
                        nuevo_msm = '_'.join(l)
                        print("nuevo mensaje:", nuevo_msm)
                        socket_respuesta.connect("tcp://" + a['ip'] + ":" +
                                                 a['puerto'])
                        socket_respuesta.send_string(nuevo_msm)
                    else:

                        cliente = l[4]
                        ruta_str = l[5]  # string de ruta

                        ruta_dic = json.loads(ruta_str)  # diccionario de ruta
                        print(ruta_dic)

                        ruta_dic[yo] = {"ip": nombre_equipo, "puerto": mi_port}
                        ruta_str = json.dumps(ruta_dic)
                        l[5] = ruta_str

                        nuevo_msm = '_'.join(l)

                        keys = []  # se guardaran las keys del diccionario ruta
                        # se extraen todas las keys (para saber cuantos nodos hay en la ruta)
                        for key in ruta_dic:
                            keys.append(key)

                        # tenemos que verificar no replicar el mensaje a los nodos que ya estan dentro de ruta
                        for key in directorio:
                            if key != yo and key != cliente and key not in keys:
                                print("yolo")
                                info = directorio.get(key)
                                print(info)
                                context_replicar = zmq.Context()
                                socket_replicar = context_replicar.socket(
                                    zmq.REQ)
                                socket_replicar.connect("tcp://" + info['ip'] +
                                                        ":" + info['puerto'])
                                socket_replicar.send_string(nuevo_msm)
                elif l[0] == "r":

                    msm_c = l[1]  # operador
                    a = directorio.get(msm_c)
                    if a == None:
                        adicionar(l)
                        print("este es l", l)
                        print(directorio)
                    else:
                        pass
                # recibir mensaje de confirmacion (servicio encontrado)
                elif l[0] == "s":

                    # si queda un solo elemento en ruta: conectar directamente
                    # sino seguir pasando el mensaje al penultimo nodo de ruta
                    ruta_str = l[5]
                    ruta_dic = json.loads(ruta_str)
                    keys = []
                    for key in ruta_dic:
                        keys.append(key)

                    if len(keys) == 2:
                        print("entrooooooo", l)
                        # conectarse directamente
                        aux = ruta_dic.get(l[1])  # "-"
                        #print("entro correctamente felicitaciones !!!", aux)
                        host = aux["ip"]
                        port = aux["puerto"]

                        #print("ruta: ", ruta_dic)

                        ruta_dic.pop(l[1])
                        l[5] = json.dumps(ruta_dic)
                        nuevo_msm = '_'.join(l)

                        #print("este es el nuevo mensaje: ", nuevo_msm)
                        context_servicio = zmq.Context()
                        socket = context_servicio.socket(zmq.REQ)
                        socket.connect("tcp://" + host + ":" + port)

                        socket.send_string(nuevo_msm)

                    # el servidor recibe conexion directa de
                    elif len(keys) == 1:
                        print("respondiendo...")
                        print(l)
                        respuesta = int(l[2]) - int(l[3])
                        respuesta = "resultado"+"_" + \
                            l[1]+"_"+l[2]+"_"+l[3]+"_" + \
                            str(respuesta)  # "resultado_-_2_3_1"
                        print(respuesta)
                        aux = ruta_dic.get(l[4])  # "+"
                        print("este es el cliente", aux)
                        host = aux.get("ip")
                        port = aux.get("puerto")

                        context_servicio = zmq.Context()
                        socket = context_servicio.socket(zmq.REQ)
                        socket.connect("tcp://" + host + ":" + port)
                        socket.send_string(respuesta)
                    else:
                        aux = ruta_dic.get(keys[-2])  # [+,-,/]
                        host = aux["ip"]
                        port = aux["puerto"]
                        ruta_dic.pop(keys[-2])  # [+,/]
                        context_servicio = zmq.Context()
                        socket = context_servicio.socket(zmq.REQ)
                        socket.connect("tcp://" + host + ":" + port)
                        socket.send_string(mensaje)
                elif l[0] == "e":
                    print("entro a resultado")
                    # "resultado_-_2_3_1"
                    print(l)
                    print(str(l[2]) + str(l[1]) + str(l[3]) + ": " + str(l[4]))
                elif l[0] == "resultado":
                    # "resultado_-_2_3_1"
                    print(l[2] + l[1] + l[3] + ": " + l[4])
            except:
                pass
        except:
            pass  # print("ffffff")
Exemplo n.º 32
0
import socket

# Create socket and connect to the server
socket = socket.socket()
socket.connect(('localhost',5252))

# Buffer size
bufferSize = 8 * 1024

# Create a new empty file to receive the uploaded file 
file = open('fileReceived.png', 'wb')

# Receive the first bytes of the file
chunk = socket.recv(bufferSize)

# Stay in loop receiving the other parts of the file
while chunk:
    # Write the bytes received in the file
    file.write(chunk)
    # Await the sending of new bytes 
    chunk = socket.recv(bufferSize)

# Close file
file.close()

# Close socket
socket.close()
Exemplo n.º 33
0
import socket                   # Import socket module

A_host = socket.gethostname()                 # Get local machine name
A_port = 50001                        # Reserve a port for your service.

B_port = 50000                        # Reserve a port for your service.
B_host = '127.0.0.1'

socket = socket.socket()             # Create a socket object

filename='pingpong.jpg'
f = open(filename,'rb')

socket.connect((B_host, B_port))

l = f.read(1024)
while (l):
    socket.send(l)
    l = f.read(1024)
f.close()
socket.close()

with open('received_tcp.jpg', 'wb') as f:
    print ('file opened')
    
    #socket.bind((A_host, A_port))            # Bind to the port
    socket.listen(5)                                     # Now wait for client connection.

    while True:
        conn, addr = socket.accept()     # Establish connection with client.
        print ('Got connection from', addr)
Exemplo n.º 34
0
if host == "":
    host = "127.0.0.1"
elif host == "0":
    host = "192.168.1.140"
elif host == "gatien":
    host = "gatien-oudoire.ddns.net"

port, host = (6010, host)

decoVoulue = 0

try:
    print("Tentative de connexion sur -> " + host) 
    socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    socket.connect((host, port))
    print("La connexion a réussie \n")
    print("Il est conseillé de décliner son identité dans le premier message\n")
    while True:
        data = input("Entrez votre message :\n")
        print(data)
        if data == "sortir":
            data = "XPTDRTDECO"
            data = data.encode("utf8")
            socket.sendall(data)
            time.sleep(2.5)
            socket.close()
            decoVoulue = 1
            break
        if data != "":
            data = data.encode("utf8")
Exemplo n.º 35
0
import socket
import time

data = "data"
ADDRESS = '192.168.100.104'
PORT = 57214
with socket.socket() as socket:
    socket.connect((ADDRESS, PORT))
    while True:
        data = socket.recv(3)
        if not data:
            break
        print("image data {}".format(data.decode()))
        time.sleep(1)

print("end")
Exemplo n.º 36
0
import socket
import logging
import traceback
import projet

messegNum = 0
publicKey = ""

try:
    socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    ip = socket.connect(('localhost', 9090))

    # Debut de la session
    socket.send('hello')
    chunk = socket.recv(2048)
    messegNum = messegNum + 1
    if messegNum == 1:

        #recuperation de la cle publique du serveur
        publicKey = chunk
        # generation de la cle DES
        desKey = projet.generateDESKey(64)
        # chiffrement RSA de la cle DES avec la cle publique du serveur
        desKeyEncrypted = desKey.to01()
        # envoi de la cle DES chiffre
        socket.send(desKeyEncrypted)
    # rec
    print "Connection OK"

except Exception as e:
    print logging.error(traceback.format_exc())
Exemplo n.º 37
0
    print("Peer connected!")
    client.send("Peer connected!".encode())

    while True:
        server_msg = input('>>> ')
        if server_msg == '.exit':
            break
        client.send(server_msg[:100].encode())
        client_msg = client.recv(100).decode()
        print(client_msg)

    socket.close()

if MODE == 'client':
    socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    socket.connect(('localhost', 42069))

    print("Waiting for peer to connect")
    server_msg = socket.recv(100).decode()
    print(server_msg)

    while True:
        client_msg = input('>>> ')
        if client_msg == '.exit':
            break
        socket.send(client_msg[:100].encode())
        server_msg = socket.recv(100).decode()
        print(server_msg)

    socket.close()
Exemplo n.º 38
0
###
### Start sending the payloads
###

payload = generate_bytes()

start_time = int(time.time())
window_start_time = int(time.time())
rate_current_second = int(time.time())

socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
address = os.environ["IP_ADDRESS"]
port = 9000
print(f"Connecting to address {address}, port {port}")
socket.connect((address, port))

print(f"Sending {range(payloads_to_send)} payloads...")

for i in range(payloads_to_send):

    # Check for rate being exceeded, i.e. we are sending data too quickly
    while rate_exceeded:

        # Sleep for 10 msec
        time.sleep(0.01)

        # Check the current time
        current_time = int(time.time())

        # Remove rate limiting if we are in a new second
 def test_connect_DefaultAttemptsFail_Exception(self):
     socket = ControllerSocket('badhost')
     with self.assertRaises(SocketConnectionException):
         socket.connect()
Exemplo n.º 40
0

def unbox_recvd_message(resp_data):
    dict_data = json.loads(resp_data.decode('utf-8'))
    return dict_data


if __name__ == "__main__":
    parser = sys_arg_parser()
    args = parser.parse_args()
    setup_log_config()
    logging.info(f'Starting client')

    try:
        socket = socket.socket()
        socket.connect((args.addr, int(args.port)))
        print('Connected to ', args.addr, args.port)
        logging.info(f'Connected to ", {args.addr}, {args.port}')
    except Exception as err:
        logging.error(
            f'Unnable to connect to server {args.addr}, port {args.port}')
        socket.close()

    try:
        message = make_presence()
        send_message(message)
        logging.info(f'Message sent: {message}')
    except Exception as err:
        logging.error(f'Unnable to send message {message}!')
        socket.close()
Exemplo n.º 41
0
import socket
import argparse

parser = argparse.ArgumentParser("This script connects to a server and sends bgp messages read from a file.")
parser.add_argument("dst_ip", type=str, help="Server IP")
parser.add_argument("port", type=int, help="Port")
parser.add_argument("infile", type=str, help="Infile")
args = parser.parse_args()
dst = args.dst_ip
port = args.port
infile = args.infile

socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connect((dst, port))
print 'Connected to ',dst,' port ',port

with open(infile, 'r') as fd:
    for line in fd.readlines():
        if line[0] != '#':
            #print line
            linetab = line.split('|')
            linetab[2] = '10000'
            line = '|'.join(linetab)

            socket.send(line)

socket.close()
Exemplo n.º 42
0
import socket
import AlphaBot
server = ('', 7500)
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connect(server)

while True:
    alphabot = AlphaBot.AlphaBot()
    percorso = socket.recv(4096)
    steps = (percorso.decode).split(',')
    alphabot.setMotor()
    while True:
        if steps[1][1] == 'f':
            alphabot.forward(steps[1][1:])
            steps.remove(1)
        elif steps[1][1] == 'b':
            alphabot.backward(steps[1][1:])
            steps.remove(1)
        elif steps[1][1] == 'l':
            alphabot.left(steps[1][1:])
            steps.remove(1)
        else:
            alphabot.right(steps[1][1:])
            steps.remove(1)
Exemplo n.º 43
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-


from devinclude import *
from bustime.models import *
import socket
import zmq
import cPickle as pickle
import time
import base64

context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect("tcp://127.0.0.1:15556")
#socket.connect("ipc://bustime_out")
#socket.connect("ipc://bustime_in")
#socket.setsockopt_string(zmq.SUBSCRIBE, u"")
socket.setsockopt(zmq.SUBSCRIBE, "")
#socket.setsockopt(zmq.SUBSCRIBE, "bdata_mode0")
#socket.setsockopt_string(zmq.SUBSCRIBE, u"busamounts_4")

while 1:
    sr = socket.recv()
    what, p = sr.split(' ', 1)
    p = pickle.loads(p)
    #p = pickle.loads(base64.b64decode(p))
    print what
    #print p
    print ""
import socket

# definisikan IP server tujuan file akan diupload
ip_server = "192.168.43.149"

# definisikan port number proses di server
port_server = 8080

# definisikan ukuran buffer untuk mengirim
buffer_size = 1024

# buat socket (apakah bertipe UDP atau TCP?)
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# lakukan koneksi ke server
socket.connect((ip_server, port_server))

# buka file bernama "hasil_download.txt bertipe byte
# masih hard code, file harus ada dalam folder yang sama dengan script python
file_download = open("hasil_download.txt", "wb")

# loop forever
while 1:
    # terima pesan dari client
    data = socket.recv(buffer_size)
    print("Now Download")
    # tulis pesan yang diterima dari client ke file kita (result.txt)
    while (data):
        file_download.write(data)
        data = socket.recv(buffer_size)
Exemplo n.º 45
0
if __name__ == '__main__':
    if len(sys.argv) != 3:
        print(f'python {sys.argv[0]} -p <port>')
        sys.exit()
    try:
        port = int(sys.argv[2])
    except:
        print('Invalid port')
        sys.exit()
    if not 1025 <= port <= 65535:
        print('Invalid port')
        sys.exit()

    socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        socket.connect(('localhost', port))
    except ConnectionRefusedError:
         print('Connection refused, check host is running')
         sys.exit()

    player = Player()
    game_map = GameMap(player)
    goals = Goals(game_map)
    while True:
        data = receive_socket_data(socket)
        if not data:
            socket.close()
            sys.exit()
        #print_view(data)
        game_map.update_map(data)
        #game_map.print_map()
Exemplo n.º 46
0
  <edit-config>
    <target>
      <candidate/>
    </target>
    <config>
      <configuration>
        <system>
          <host-name>{0}</host-name>
        </system>   
      </configuration>
    </config>
  </edit-config>
</rpc>"""

socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connect((ROUTER_IP, 22))

trans = paramiko.Transport(socket)
trans.connect(username=USERNAME, password=PASSWORD)

#CREATE CHANNEL FOR DATA COMM
ch = trans.open_session()
name = ch.set_name('netconf')

#Invoke NETCONF
ch.invoke_subsystem('netconf')

print "\n[IPSpace NCClient Demo] Opened NETCONF subchannel"

NEW_HOSTNAME = "MX03"
HOSTNAME_NC_STRING = SET_HOSTNAME.format(NEW_HOSTNAME)
Exemplo n.º 47
0
def timeout(sock, user, secs=600):
    """
    Time out a user for a set period of time.
    Keyword arguments:
    sock -- the socket over which to send the timeout command
    user -- the user to be timed out
    secs -- the length of the timeout in seconds (default 600)
    """
    chat(sock, ".timeout {}".format(user, secs))


#network functions

socket = socket.socket()
socket.connect((cfg.HOST, cfg.PORT))
socket.send("PASS {}\r\n".format(cfg.PASS).encode("utf-8"))
socket.send("NICK {}\r\n".format(cfg.NICK).encode("utf-8"))
socket.send("JOIN {}\r\n".format(cfg.CHAN).encode("utf-8"))

#maintain the chat in the infinite loop, handle the ping
hello = False
while True:
    response = socket.recv(1024).decode("utf-8")
    if response == "PING :tmi.twitch.tv\r\n":
        socket.send("PONG :tmi.twitch.tv\r\n".encode("utf-8"))
    else:

        CHAT_MSG = re.compile(r"^:\w+!\w+@\w+\.tmi\.twitch\.tv PRIVMSG #\w+ :")
        username = re.search(r"\w+",
                             response).group(0)  # return the entire match
Exemplo n.º 48
0
import socket

socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# socket.bind(('127.0.0.1', 9090))

socket.connect(('127.0.0.1', 9090))

socket.send("good morning.\n".encode('utf-8'))

socket.close()

Exemplo n.º 49
0
import socket
import time

socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connect(("100.64.12.40", 8867))

while 1:
    socket.send("hello".encode())
    print("sent")
    time.sleep(1)
Exemplo n.º 50
0
def run_peer(queue, win_size, nb_withdrawals_burst_start, \
nb_withdrawals_burst_end, min_bpa_burst_size, burst_outdir, socket_rib_name, \
nb_withdraws_per_cycle=100, p_w=1, r_w=1, bpa_algo=False, nb_bits_aspath=33, \
run_encoding_threshold=1000000, global_rib_enabled=True, silent=False):

    global peer_logger

    import socket

    try:
        os.nice(-20)
    except OSError:
        peer_logger.info('Cannot change the nice.')

    # Create the topologies for this peer
    G = ASTopology(1, silent)  # Main topology
    G_W = ASTopology(
        nb_withdrawals_burst_start,
        silent)  # Subset of the topology with the withdraws in the queue

    # Current burst (if any)
    current_burst = None

    # Last time the peer wrote the rib and queue size in the log file
    last_log_write = 0

    # Socket connected to the global RIB
    socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

    # Exit properly when receiving SIGINT
    def signal_handler(signal, frame):
        if current_burst is not None:
            current_burst.stop(bgp_msg.time)

        socket.close()

        peer_logger.info('Received SIGTERM. Exiting.')

        sys.exit(0)

    signal.signal(signal.SIGTERM, signal_handler)

    peer_id = None
    peer_as = None

    # Create the RIB for this peer
    rib = RIBPeer()

    encoding = None

    # This function create and initialize the encoding
    def init_encoding():
        encoding = Encoding(peer_id,
                            G,
                            'encoding',
                            nb_bits_aspath,
                            5,
                            output=True)
        encoding.compute_encoding()
        peer_logger.info(
            str(int(bgp_msg.time)) + '\t' + str(len(rib)) + '\t' +
            str(len(W_queue)) + '\t' + 'Encoding computed!')

        if global_rib_enabled:
            for p in rib.rib:
                send_fake_update(p, peer_ip, bgp_msg.time, rib, encoding,
                                 socket)

        return encoding

    #A_queue = BGPMessagesQueue(win_size) # Queue of Updates
    W_queue = BGPMessagesQueue(win_size)  # Queue of Withdraws

    last_ts = 0

    while True:

        while True:
            bgp_msg = queue.get()

            if bgp_msg is not None:
                if peer_id is None:
                    peer_id = bgp_msg.peer_id
                    peer_as = bgp_msg.peer_as
                    peer_as_set = set()
                    last_ts = bgp_msg.time
                    peer_ip = peer_id.split('-')[-1]

                    peer_handler = logging.handlers.RotatingFileHandler(
                        log_dir + '/peer_' + str(peer_id),
                        maxBytes=200000000000000,
                        backupCount=5)
                    peer_handler.setFormatter(formatter)
                    peer_logger.removeHandler(handler)
                    peer_logger.addHandler(peer_handler)

                    peer_logger.info('Peer_' + str(peer_id) + '_(AS' +
                                     str(str(peer_as)) + ')_started.')

                    if bgp_msg.as_path is not None and len(
                            bgp_msg.as_path) > 0:
                        if peer_as != bgp_msg.as_path[0]:
                            peer_logger.warning(
                                'Peer AS ' + str(peer_as) + ' and first AS ' +
                                str(bgp_msg.as_path[0]) +
                                ' in AS path does not match. Setting first AS as peer AS.'
                            )
                            peer_as = bgp_msg.as_path[0]

                    # Make the connection with the global RIB
                    rib_global_socket_address = '/tmp/' + socket_rib_name
                    socket.connect(rib_global_socket_address)
                    peer_logger.info('Peer_' + str(peer_id) + '_(AS' +
                                     str(str(peer_as)) +
                                     ') connected with the global RIB.')

                if peer_id != bgp_msg.peer_id:
                    peer_logger.critical(
                        'Received a bgp_message with peer_id: ' +
                        str(bgp_msg.peer_id))

                if bgp_msg.mtype == 'A':
                    # Update the set set of peer_as (useful when doing the naive solution)
                    if len(bgp_msg.as_path) > 0:
                        peer_as_set.add(bgp_msg.as_path[0])

                    # Update the RIB for this peer
                    old_as_path = rib.update(bgp_msg)

                    # Remove the old as-path in the main graph for this prefix
                    G.remove(old_as_path, bgp_msg.prefix)

                    # Add the new as-path in both the main graph and the graph of advertisments
                    G.add(bgp_msg.as_path, bgp_msg.prefix)

                    # Update the encoding, and send the fake advertisement to the global RIB
                    if encoding is not None:
                        encoding.advertisement(old_as_path, bgp_msg.as_path)
                        if global_rib_enabled:
                            send_fake_update(bgp_msg.prefix, peer_ip,
                                             bgp_msg.time, rib, encoding,
                                             socket)
                    elif len(rib.rib) > run_encoding_threshold:
                        encoding = init_encoding()

                elif bgp_msg.mtype == 'W':
                    # Create the encoding if not done yet
                    if encoding is None:
                        encoding = init_encoding()

                    # Update the RIB for this peer
                    bgp_msg.as_path = rib.withdraw(bgp_msg)

                    # Remove the old as-path in the main graph for this prefix
                    G.remove(bgp_msg.as_path, bgp_msg.prefix)

                    # Add the withdrawn as-path in the graph of withdraws
                    G_W.add(bgp_msg.as_path)

                    # Update the queue of withdraws
                    if bgp_msg.as_path != []:
                        W_queue.append(bgp_msg)

                    # Update the encoding
                    encoding.withdraw(bgp_msg.as_path)

                    # Send the withdrawal to the global RIB
                    if global_rib_enabled:
                        send_fake_update(bgp_msg.prefix, peer_ip, bgp_msg.time,
                                         None, None, socket)

                elif bgp_msg.mtype == 'CLOSE':

                    # CLOSE this peer. Clear all the topologies, ribs, queues, bursts, etc
                    if current_burst is not None:
                        best_edge_set, best_fm_score, best_TP, best_FP, best_FN = burst_prediction(
                            current_burst, G, G_W, W_queue, p_w, r_w, bpa_algo,
                            peer_as_set)
                        current_burst.fd_predicted.write(
                            'PREDICTION_END_CLOSE|' + bpa_algo + '|' +
                            str(len(current_burst)) + '|' +
                            str(best_fm_score) + '|' + str(best_TP) + '|' +
                            str(best_FN) + '|' + str(best_FP) + '\n')
                        current_burst.fd_predicted.write(
                            'PREDICTION_END_EDGE|')
                        res = ''
                        depth = 9999999999
                        for e in best_edge_set:
                            depth = min(G_W.get_depth(e[0], e[1]), depth)
                            res += str(e[0]) + '-' + str(e[1]) + ','

                        current_burst.fd_predicted.write(res[:len(res) - 1] +
                                                         '|' + str(depth) +
                                                         '\n')

                        #G_W.draw_graph(peer_as)

                        current_burst.stop(bgp_msg.time)
                        current_burst = None

                    # Withdraw all the routes advertised by this peer
                    if global_rib_enabled:
                        for p in rib.rib:
                            send_fake_update(p, peer_ip, -1, None, None,
                                             socket)

                    peer_logger.info('Received CLOSE. CLEANING the peer.')

                    # Stop this peer
                    os.kill(os.getpid(), signal.SIGTERM)
                else:
                    peer_logger.info(bgp_msg)

                # Make sure to compute start en end time of burst with a second granularity (only if ther is a burst)
                if current_burst is not None:
                    while (last_ts != bgp_msg.time):
                        last_ts += 1

                        # Update the graph of withdraws
                        for w in W_queue.refresh_iter(last_ts):
                            current_burst.deleted_from_W_queue.append(w)

                        # Remove the current burst (if any) if it the size of the withdraws is lower than w_threshold (meaning it has finished)
                        if len(
                                W_queue
                        ) < nb_withdrawals_burst_end:  #current_burst.is_expired(bgp_msg.time):
                            # Execute BPA at the end of the burst if the burst is large enough
                            best_edge_set, best_fm_score, best_TP, best_FN, best_FP = burst_prediction(
                                current_burst, G, G_W, W_queue, p_w, r_w,
                                bpa_algo, peer_as_set)
                            current_burst.fd_predicted.write(
                                'PREDICTION_END|' + bpa_algo + '|' +
                                str(len(current_burst)) + '|' +
                                str(best_fm_score) + '|' + str(best_TP) + '|' +
                                str(best_FN) + '|' + str(best_FP) + '\n')
                            current_burst.fd_predicted.write(
                                'PREDICTION_END_EDGE|')

                            # Print some information about the prediction on the prediction file
                            res = ''
                            depth = 9999999999
                            for e in best_edge_set:
                                res += str(e[0]) + '-' + str(e[1]) + ','
                                depth = min(G_W.get_depth(e[0], e[1]), depth)
                            current_burst.fd_predicted.write(res[:len(res) -
                                                                 1] + '|' +
                                                             str(depth) + '\n')

                            #G_W.draw_graph(peer_as, G, current_burst, outfile='as_graph_'+str(current_burst.start_time)+'.dot', threshold=500)

                            # Update the graph of withdrawals
                            for w in current_burst.deleted_from_W_queue:
                                G_W.remove(w.as_path)

                            current_burst.stop(bgp_msg.time)
                            current_burst = None
                            break
                        else:
                            current_burst.last_ts = last_ts

                # Update the graph of withdraws.
                if current_burst is None:
                    for w in W_queue.refresh_iter(bgp_msg.time):
                        G_W.remove(w.as_path)

                # Update the last timestamp seen
                last_ts = bgp_msg.time

                # Add the updates in the real prefixes set of the burst, if any
                if current_burst is not None:  #and not silent:
                    if bgp_msg.as_path != []:
                        old_as_path = bgp_msg.as_path if bgp_msg.mtype == 'W' else old_as_path
                        current_burst.add_real_prefix(bgp_msg.time,
                                                      bgp_msg.prefix,
                                                      bgp_msg.mtype,
                                                      old_as_path)

                # If we are not in the burst yet, we create the burst
                if current_burst is None and len(
                        W_queue) >= nb_withdrawals_burst_start:
                    current_burst = Burst(peer_id, bgp_msg.time, win_size,
                                          burst_outdir, encoding, W_queue,
                                          silent)
                    next_bpa_execution = min_bpa_burst_size

                # Print some log ...
                if (bgp_msg.time > last_log_write
                    ) or bgp_msg.time - last_log_write >= 3600:
                    peer_logger.info(
                        str(int(bgp_msg.time)) + '\t' + str(len(rib)) + '\t' +
                        str(len(W_queue)))
                    last_log_write = bgp_msg.time

                # Execute BPA if there is a burst and
                # i) the current burst is greater than the minimum required
                # ii) we have wait the number of withdrawals required per cycle or the queue is empty
                if current_burst is not None:
                    total_current_burst_size = len(
                        current_burst) + nb_withdrawals_burst_start
                    if total_current_burst_size >= min_bpa_burst_size and total_current_burst_size > next_bpa_execution:  #\
                        if nb_withdraws_per_cycle > 0 and total_current_burst_size < 12505:
                            next_bpa_execution += nb_withdraws_per_cycle
                        else:
                            next_bpa_execution = 999999999999
                        break

        #print ('Queue size: '+str(len(rib))+'\t'+str(len(W_queue))+'\t'+str(len(current_burst)+nb_withdrawals_burst_start))

        if current_burst is not None:

            # Compute the set of edges with the highest FM score
            best_edge_set, best_fm_score, best_TP, best_FP, best_FN = burst_prediction(
                current_burst, G, G_W, W_queue, p_w, r_w, bpa_algo,
                peer_as_set)
            # Load that set in the burst
            if not silent:
                burst_add_edge(current_burst, rib, encoding, bgp_msg.time,
                               best_edge_set, G, G_W, W_queue, silent)

            # Inform the global RIB about the set of failed links
            for e in best_edge_set:
                depth_set = set()
                if G_W.has_edge(e[0], e[1]):
                    depth_set = depth_set.union(
                        G_W[e[0]][e[1]]['depth'].keys())
                if G.has_edge(e[0], e[1]):
                    depth_set = depth_set.union(G[e[0]][e[1]]['depth'].keys())

                for d in depth_set:
                    if encoding.is_encoded(d, e[0], e[1]):

                        vmac_partial = ''
                        bitmask_partial = ''

                        for i in range(2, encoding.max_depth + 2):
                            if i == d:
                                vmac_partial += encoding.mapping[
                                    i].get_mapping_string(e[0])
                                bitmask_partial += '1' * encoding.mapping[
                                    i].nb_bytes
                            elif i == d + 1:
                                vmac_partial += encoding.mapping[
                                    i].get_mapping_string(e[1])
                                bitmask_partial += '1' * encoding.mapping[
                                    i].nb_bytes
                            else:
                                if i in encoding.mapping:
                                    vmac_partial += '0' * encoding.mapping[
                                        i].nb_bytes
                                    bitmask_partial += '0' * encoding.mapping[
                                        i].nb_bytes

                        if global_rib_enabled:
                            socket.send('FR|' + peer_ip + '|' + vmac_partial +
                                        '|' + bitmask_partial + '|' + str(d) +
                                        '|' + str(last_ts) + '\n')

            # Print information about the perdiction in the predicted file
            current_burst.fd_predicted.write('PREDICTION|' + bpa_algo + '|' +
                                             str(len(current_burst)) + '|' +
                                             str(best_fm_score) + '|' +
                                             str(best_TP) + '|' +
                                             str(best_FP) + '|' +
                                             str(best_FN) + '\n')
            current_burst.fd_predicted.write('PREDICTION_EDGE|')
            res = ''
            depth = 9999999999
            for e in best_edge_set:
                depth = min(G_W.get_depth(e[0], e[1]), depth)
                res += str(e[0]) + '-' + str(e[1]) + ','
            current_burst.fd_predicted.write(res[:len(res) - 1] + '|' +
                                             str(depth) + '\n')
Exemplo n.º 51
0
def connect_timeout(socket, host_port):
    return socket.connect(host_port)
Exemplo n.º 52
0
if len(sys.argv) < 3:
    print "usage: ./client.py port input_file"
else:
    port = sys.argv[1]
    inputFile = sys.argv[2]

    try:
        with open(inputFile) as file:
            #Parse file into lines
            content = file.readlines()
            #Remove unnecessary characters
            content = [x.strip() for x in content]

        #Create socket and connect to server
        socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        socket.connect(('127.0.0.1', int(port)))

        #Send data to server one line at a time
        for line in content:
            socket.send(line)
            #Wait for server to respond before sending another line
            st = socket.recv(100)

        #Receive terminating message from server

        #Close socket
        socket.close()
        exit(0)
    except Exception as e:
        print e
        exit(1)
Exemplo n.º 53
0
def banner():
    socket = socket.socket()
    socket.connect((ip, int(port)))
    print(socket.recv(1024))
Exemplo n.º 54
0
    if len(sys.argv) < 2:
        print('you need to pass the name of the plot!')

    plotName = sys.argv[1]
    setupDict = yaml.load(open('smalldata_plot.yml', 'r'))
    i0var = setupDict[plotName]['i0var']
    sigvar = setupDict[plotName]['sigvar']
    binWidth = setupDict[plotName]['binWidth']
    binEntries = setupDict[plotName]['binEntries']
    FilterVar = setupDict[plotName]['FilterVar']
    FilterVarMin = setupDict[plotName]['FilterVarMin']
    FilterVarMax = setupDict[plotName]['FilterVarMax']

    context = zmq.Context()
    socket = context.socket(zmq.SUB)
    socket.connect("tcp://%s:%d" % ('daq-xpp-mon05', 5000))
    socket.setsockopt(zmq.SUBSCRIBE, b"")

    #if socket.poll(timeout=0):
    nrep = 1
    while nrep > 0:
        socket.send_string("Request_for test")
        nowStr = time.strftime("%b %d %Y %H:%M:%S", time.localtime())
        print("test requested data at %s " % (nowStr))
        data_dict = socket.recv_pyobj()
        print("got data")

        data = {'scanSteps': []}
        data['scanValues_on'] = []

        scanVarName = 'delay'
Exemplo n.º 55
0
import random
import socket, string, time, ssl
import urllib, re
import time
from random import shuffle
import random

socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server = ""  # Server
channel = ""  # Channel
keys = ""  # Keys
botnick = "homestuckbot"  # Your bots nick
adminname = ""  #IRC nickname
exitcode = "begone " + botnick

socket.connect(
    (server, 9999))  # Here we connect to the server using the port 6667

ircsock = ssl.wrap_socket(socket)

ircsock.send(
    bytes(
        "USER " + botnick + " " + botnick + " " + botnick + " " + botnick +
        "\n", "UTF-8")
)  #We are basically filling out a form with this line and saying to set all the fields to the bot nickname.
ircsock.send(bytes("NICK " + botnick + "\n",
                   "UTF-8"))  # assign the nick to the bot


def joinchan(chan):  # join channel(s).

    ircsock.send(bytes("JOIN " + chan + keys + "\r\n", "UTF-8"))
    return job, job2


if __name__ == '__main__':

    parser = argparse.ArgumentParser()
    parser.add_argument("encrypted_message",
                        type=str,
                        help="The message you want to decrypt")
    parser.add_argument("key_length", type=int, help="length of the key")
    args = parser.parse_args()

    # fetch IP address of the client
    socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    socket.connect(("8.8.8.8", 80))

    cluster = dispy.JobCluster(delegate,
                               ip_addr="192.168.0.142",
                               nodes="192.168.0.*",
                               depends=[
                                   'quadgram_analysis.py', QuadgramAnalyzer,
                                   "cipher.py", cipher.decrypt,
                                   cipher.decrypt_unknown_key
                               ])
    import time
    start_time = time.time()
    run_jobs()
    print(f"--- {time.time() - start_time} seconds ---")

    cluster.print_status()
# -*- coding: utf-8 -*-
import socket


def send_data(socket, data):
    total = 0
    while total < len(data):
        sent = socket.send(data[total:])
        total += sent
    print "Sent %d bytes" % total


socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connect(("localhost", 8888))

viesti = u"шкм" * 1000

data = viesti.encode("utf-8")

send_data(socket, data)
socket.close()
Exemplo n.º 58
0
                pass
            print(server_response)
            mess = input(">>> ")

        self.socket.send(mess.encode())

        server_response = self.socket.recv(1024)
        print(server_response.decode())

    def close(self):
        print("Close")
        self.socket.close()



if __name__ == '__main__':
    hote = "localhost"
    port = 15555
    socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    socket.connect((hote, port))
    print("Connection on {}".format(port))

    response = ""
    while not response:
        socket.send('Hello world'.encode())
        response = socket.recv(1024)
        print("<"+response.decode())

    print("Close connexion")
    socket.close()
Exemplo n.º 59
0
import socket

# 'argparse' is a very useful library for building python tools that are easy
# to use from the command line.  It greatly simplifies the input validation
# and "usage" prompts which really help when trying to debug your own code.
parser = argparse.ArgumentParser(
    description="Solver for 'All Your Base' challenge")
parser.add_argument("ip", help="IP (or hostname) of remote instance")
parser.add_argument("port", type=int, help="port for remote instance")
args = parser.parse_args()

# This tells the computer that we want a new TCP "socket"
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# This says we want to connect to the given IP and port
socket.connect((args.ip, args.port))

# This gives us a file-like view of the connection which makes reading data
# easier since it handles the buffering of lines for you.
f = socket.makefile()

while True:
    line = f.readline().strip()
    print(line)
    # This iterates over data from the server a line at a time.  This can cause
    # some unexpected behavior like not seeing "prompts" until after you've sent
    # a reply for it (for example, you won't see "answer:" for this problem).
    # However, you can still send data and it will be handled correctly.

    # Handle the information from the server to extact the problem and build
    # the answer string.
Exemplo n.º 60
0
 def ActConn(self,socket,port,cport):
     socket.bind(("",port))
     socket.connect((caddr,cport))