Example #1
0
    def ping(idurl, host, port):
        lg.out(14,
               'http_node.receive.ping     %s (%s:%s)' % (idurl, host, port))
        url = 'http://' + str(host) + ':' + str(port)

        if dhnnet.proxy_is_on():
            f = TransportHTTPProxyClientFactory(
                url,
                method='POST',
                headers={
                    'User-Agent': 'DataHaven.NET transport_http',
                    'idurl': misc.getLocalID(),
                })
            conn = reactor.connectTCP(dhnnet.get_proxy_host(),
                                      int(dhnnet.get_proxy_port()), f)
        else:
            f = TransportHTTPClientFactory(url,
                                           method='POST',
                                           headers={
                                               'User-Agent':
                                               'DataHaven.NET transport_http',
                                               'idurl': misc.getLocalID(),
                                           })
            conn = reactor.connectTCP(host, int(port), f)


#        f = HTTPClientFactory(url, method='POST', headers={
#            'User-Agent': 'DataHaven.NET transport_http',
#            'idurl': misc.getLocalID(), } )
#        conn = reactor.connectTCP(host, int(port), f)

        f.deferred.addCallback(success, idurl, host, port, conn)
        f.deferred.addErrback(fail, idurl, host, port, conn)
        return conn
Example #2
0
def getRemoteContacts():
    """
    Return ID's list of all known peers. 
    """
    allcontacts = getContactsAndCorrespondents()
    if misc.getLocalID() in allcontacts:
        allcontacts.remove(misc.getLocalID())
    return allcontacts
Example #3
0
def update_contacts():
    lg.out(10, 'http_node.update_contacts ')
    global _Contacts
    _Contacts.clear()

    def update_contact(x, idurl):
        add_contact(idurl)

    def failed(x, idurl):
        lg.out(10, 'http_node.update_contacts.failed   NETERROR ' + idurl)

    contacts_list = contacts.getContactIDs()
    contacts_list.append(settings.CentralID())
    contacts_list.append(settings.MoneyServerID())
    contacts_list.append(settings.MarketServerID())
    for idurl in contacts_list:
        lg.out(10, 'http_node.update_contacts want ' + idurl)
        if idurl == misc.getLocalID():
            continue
        ident = contacts.getContact(idurl)
        if ident is None:
            d = identitycache.immediatelyCaching(idurl)
            d.addCallback(update_contact, idurl)
            d.addErrback(failed, idurl)
            continue

        update_contact('', idurl)
Example #4
0
def update_contacts():
    dhnio.Dprint(10, 'transport_http.update_contacts ')
    global _Contacts
    _Contacts.clear()

    def update_contact(x, idurl):
        add_contact(idurl)

    def failed(x, idurl):
        dhnio.Dprint(10, 'transport_http.update_contacts.failed   NETERROR ' + idurl)

    contacts_list = contacts.getContactIDs()
    contacts_list.append(settings.CentralID())
    contacts_list.append(settings.MoneyServerID())
    contacts_list.append(settings.MarketServerID())
    for idurl in contacts_list:
        dhnio.Dprint(10, 'transport_http.update_contacts want ' + idurl)
        if idurl == misc.getLocalID():
            continue
        ident = contacts.getContact(idurl)
        if ident is None:
            d = identitycache.immediatelyCaching(idurl)
            d.addCallback(update_contact, idurl)
            d.addErrback(failed, idurl)
            continue

        update_contact('', idurl)
Example #5
0
 def doRemoveOldUDPSession(self, arg):
     for idurl in arg[0]:
         if idurl == misc.getLocalID():
             continue
         if idurl not in arg[1]:
             ident = contacts.getContact(idurl)
             if ident is None:
                 continue
             address = ident.getProtoContact('udp')
             if address is None:
                 continue
             try:
                 ip, port = address[6:].split(':')
                 address = (ip, int(port))
             except:
                 dhnio.DprintException()
                 continue
             if transport_udp_session.is_session_opened(address):
                 dhnio.Dprint(8, 'transport_udp.doRemoveOldUDPSession shutdown %s with [%s]' % (str(address), nameurl.GetName(idurl)))
                 reactor.callLater(0, transport_udp_session.A, address, 'shutdown')
             address_local = self.remapAddress(address)
             if address_local != address:
                 if transport_udp_session.is_session_opened(address_local):
                     dhnio.Dprint(8, 'transport_udp.doRemoveOldUDPSession shutdown %s with local peer [%s]' % (str(address_local), nameurl.GetName(idurl)))
                     self.eraseRedirection(address_local)
                     reactor.callLater(0, transport_udp_session.A, address_local, 'shutdown')
             self.eraseRedirection(address)
             self.eraseRedirection(address_local)
 def doPing(self, arg):
     self.sendDatagram(COMMANDS['PING'])
     if not self.routed:
         if dhn_stun_servers_enabled():
             if self.remote_idurl:
                 request = DHN_STUN_COMMANDS['ROUTE']+('%s %s' % (misc.getLocalID(), self.remote_idurl))
                 dhn_stun_servers_request(parent().client.transport, request)
Example #7
0
def update_db():
    idlist = set()
    idlist.add(misc.getLocalID())
    idlist.add(settings.CentralID())
    #Not sure we need this:
    #idlist.add(settings.MoneyServerID())
    idlist = idlist.union(contacts.getContactsAndCorrespondents())

    add_identity2db(idlist)
Example #8
0
    def ping(idurl, host, port):
        dhnio.Dprint(14, 'transport_http.receive.ping     %s (%s:%s)' % (idurl, host, port))
        url = 'http://' + str(host) + ':' + str(port)

        if dhnnet.proxy_is_on():
            f = TransportHTTPProxyClientFactory(url, method='POST', headers={
                'User-Agent': 'DataHaven.NET transport_http', 'idurl': misc.getLocalID(), } )
            conn = reactor.connectTCP(dhnnet.get_proxy_host(), int(dhnnet.get_proxy_port()), f)
        else:
            f = TransportHTTPClientFactory(url, method='POST', headers={
                'User-Agent': 'DataHaven.NET transport_http', 'idurl': misc.getLocalID(), } )
            conn = reactor.connectTCP(host, int(port), f)

#        f = HTTPClientFactory(url, method='POST', headers={
#            'User-Agent': 'DataHaven.NET transport_http',
#            'idurl': misc.getLocalID(), } )
#        conn = reactor.connectTCP(host, int(port), f)

        f.deferred.addCallback(success, idurl, host, port, conn)
        f.deferred.addErrback(fail, idurl, host, port, conn)
        return conn
Example #9
0
 def doRequestRemoteID(self, arg):
     if isinstance(arg, str): 
         idurl = arg
         identitycache.immediatelyCaching(idurl).addCallbacks(
             lambda src: self.automat('remote-id-received', idurl),
             lambda x: self.automat('remote-id-failed', x))
     else:
         for idurl in arg[1]:
             if idurl == misc.getLocalID():
                 continue
             if idurl not in arg[0]:
                 identitycache.immediatelyCaching(idurl).addCallbacks(
                     lambda src: self.automat('remote-id-received', idurl),
                     lambda x: self.automat('remote-id-failed', x))
Example #10
0
def INfile(filename, newpacket, proto, host, status):
    """
    Count incoming file from `proto`://`host`, `newpacket` is already Unserialized.
    """
    if status != "finished":
        return
    try:
        sz = os.path.getsize(filename)
    except:
        dhnio.DprintException()
        return
    packet_from = newpacket.OwnerID
    if newpacket.OwnerID == misc.getLocalID() and newpacket.Command == commands.Data():
        packet_from = newpacket.RemoteID
    IN(packet_from, sz)
Example #11
0
def getContact(idurl):
    """
    The Main Method Here - return identity object for given ID or None if not found. 
    Only valid contacts for dhnpackets will be signed by local identity, suppliers, customers
    and eventually dhn central command.
    """
    #    global _RequestFailsDict
    if idurl is None:
        return None
    if idurl == misc.getLocalID():
        return misc.getLocalIdentity()
    if idurl == settings.CentralID():
        return identitycache.FromCache(idurl)
    if idurl == settings.MoneyServerID():
        return identitycache.FromCache(idurl)
    if idurl == settings.MarketServerID():
        return identitycache.FromCache(idurl)
    if contactsdb.is_supplier(idurl):
        return identitycache.FromCache(idurl)
    if contactsdb.is_customer(idurl):
        return identitycache.FromCache(idurl)
    if contactsdb.is_correspondent(idurl):
        return identitycache.FromCache(idurl)
    if identitycache.HasKey(idurl):
        # dhnio.Dprint(2, "contacts.getContact WARNING who is %s ?" % nameurl.GetName(idurl))
        return identitycache.FromCache(idurl)
    if misc.getLocalID() == settings.MarketServerID():
        return None
    dhnio.Dprint(2, "contacts.getContact WARNING %s not found!" % nameurl.GetName(idurl))
    #    if not _RequestFailsDict.has_key(idurl):
    #        _RequestFailsDict[idurl] = 0
    #    _RequestFailsDict[idurl] += 1
    # TODO
    # this is not correct: 
    # need to check if other contacts is fine - if internet is turned off we can get lots fails ...  
    return None
Example #12
0
 def doCreateNewUDPSession(self, arg):
     for idurl in arg[1]:
         if idurl == misc.getLocalID():
             continue
         if idurl not in arg[0]:
             ident = contacts.getContact(idurl)
             if ident is None:
                 continue
             address = ident.getProtoContact('udp')
             if address is None:
                 continue
             try:
                 proto, ip, port, filename = nameurl.UrlParse(address)
                 address = (ip, int(port))
             except:
                 dhnio.DprintException()
                 continue
             address = self.remapAddress(address)
             sess = transport_udp_session.open_session(address)
             dhnio.Dprint(8, 'transport_udp.doCreateNewUDPSession %s with [%s]' % (sess.name, nameurl.GetName(idurl)))
             sess.automat('init', idurl)
 def doReceiveData(self, arg):
     global _ReceiveControlFunc
     try:
         datagram, addr = arg
     except:
         return
     io = cStringIO.StringIO(datagram)
     code = io.read(2)
     cmd = CODES.get(code, None)
     if cmd is None:
         # dhnio.Dprint(2, 'transport_udp_session.doReceiveData WARNING incorrect data from %s: [%s]' % (self.remote_address, code))
         return
     if _ReceiveControlFunc:
         seconds_pause = _ReceiveControlFunc(len(datagram))
         if seconds_pause > 0:
             # transport_udp.A().client.transport.pauseProducing()
             parent().client.client.transport.pauseProducing()
             # self.client.transport.pauseProducing()
             # reactor.callLater(seconds_pause, transport_udp.A().client.transport.resumeProducing)
             reactor.callLater(seconds_pause, parent().client.transport.resumeProducing)
     # dhnio.Dprint(8, '                                UDP:[%s] from %s' % (cmd, self.remote_address))
     self.last_alive_packet_time = time.time()
     #--- DATA
     if cmd == 'DATA':
         try:
             file_id = struct.unpack('i', io.read(4))[0]
             block_id = struct.unpack('i', io.read(4))[0]
             num_blocks = struct.unpack('i', io.read(4))[0]
             data_size = struct.unpack('i', io.read(4))[0]
         except:
             dhnio.DprintException()
             return
         if not self.incommingFiles.has_key(file_id):
             if self.receivedFiles.has_key(file_id):
                 if time.time() - self.receivedFiles[file_id] > 10:
                     # we receive the file, but 10 seconds since that we still receive the acks
                     # definitely something wrong - drop session 
                     self.automat('shutdown')
                     return 
                 self.sendDatagram(COMMANDS['REPORT'] + struct.pack('i', file_id) + struct.pack('i', block_id))
                 return
             if len(self.incommingFiles) >= 2 * self.maxOutgoingFiles:
                 # too many incoming files - drop session
                 self.automat('shutdown') 
                 return
             self.incommingFiles[file_id] = InboxFile(self, file_id, num_blocks)
         inp_data = io.read()
         if len(inp_data) != data_size:
             dhnio.Dprint(2, 'transport_udp_session.doReceiveData WARNING incorrect datagram received from %s, not full data' % str(self.remote_address))
             return
         self.incommingFiles[file_id].input_block(block_id, inp_data) 
         self.sendDatagram(COMMANDS['REPORT'] + struct.pack('i', file_id) + struct.pack('i', block_id))
         # dhnio.Dprint(12, 'transport_udp_session.doReceiveData [%d] (%d/%d) from %s, state=%s' % (file_id, block_id, num_blocks, self.remote_address, self.state))
         if len(self.incommingFiles[file_id].blocks) == num_blocks:
             # dhnio.Dprint(12, 'transport_udp_session.doReceiveData new file [%d] (%d/%d) from %s' % (file_id, block_id, num_blocks, self.remote_address))
             self.incommingFiles[file_id].build()
             file_received(self.incommingFiles[file_id].filename, 'finished', 'udp', self.remote_address)
             self.incommingFiles[file_id].close()   
             del self.incommingFiles[file_id]   
             self.receivedFiles[file_id] = time.time()
             self.eraseOldFileIDs()
     #--- REPORT
     elif cmd == 'REPORT':
         try:
             file_id = struct.unpack('i', io.read(4))[0]
         except:
             dhnio.DprintException()
             return
         if not self.outgoingFiles.has_key(file_id):
             # if not self.receivedFiles.has_key(file_id):
             #     dhnio.Dprint(8, 'transport_udp_session.doReceiveData WARNING unknown file_id in REPORT packet received from %s: [%d]' % (self.remote_address, file_id))
             return
         try:
             block_id = struct.unpack('i', io.read(4))[0]
         except:
             dhnio.DprintException()
             return
         self.outgoingFiles[file_id].report_block(block_id)
         self.sliding_window.pop((file_id, block_id), None)
         self.sliding_window_size += 1
         if self.sliding_window_size > MAX_WINDOW_SIZE:
             self.sliding_window_size = MAX_WINDOW_SIZE
         if len(self.outgoingFiles[file_id].blocks) == 0:
             self.reportSentDone(file_id)
             self.closeOutboxFile(file_id)
         # dhnio.Dprint(8, 'transport_udp_session.doReceiveData REPORT on [%d,%d] received, blocks=%d, window=%d' % (file_id, block_id, len(self.outgoingFiles[file_id]), self.sliding_window_size))
     #--- GREETING
     elif cmd == 'GREETING':
         greeting_idurl = io.read()
         dhnio.Dprint(12, 'transport_udp_session.doReceiveData GREETING "%s" from %s, remote_idurl=%s, remote_address=%s, state=%s' % (
             greeting_idurl[:120], str(addr), self.remote_idurl, self.remote_address, self.state))
         if greeting_idurl:
             if nameurl.UrlMake(parts=nameurl.UrlParse(greeting_idurl)) != greeting_idurl:
                 dhnio.Dprint(2, 'transport_udp_session.doReceiveData WARNING incorrect idurl=%s in GREETING packet from %s' % (greeting_idurl, self.name))
                 self.sendDatagram(COMMANDS['PING'])
             else:
                 if self.remote_idurl is None:
                     self.remote_idurl = greeting_idurl
                     self.remote_name = nameurl.GetName(self.remote_idurl)
                     dhnio.Dprint(6, 'transport_udp_session.doReceiveData got idurl=%s in GREETING packet from %s' % (greeting_idurl, self.name))
                     parent().automat('recognize-remote-id', (self.index, self.remote_idurl))
                 else:
                     if self.remote_idurl != greeting_idurl:
                         dhnio.Dprint(2, 'transport_udp_session.doReceiveData WARNING wrong idurl=%s in GREETING packet from %s' % (greeting_idurl, self.name))
                 ident = contacts.getContact(greeting_idurl)
                 if ident:
                     udpip = ident.getIP('udp')
                     if udpip:
                         if udpip != addr[0]:
                             parent().automat('detect-remote-ip', (self.index, self.remote_idurl))
                 self.sendDatagram(COMMANDS['ALIVE'])
         else:
             dhnio.Dprint(2, 'transport_udp_session.doReceiveData WARNING did not found idurl in GREETING packet from %s, send PING again' % self.name)
             self.sendDatagram(COMMANDS['PING'])
     #--- PING
     elif cmd == 'PING':
         self.sendDatagram(COMMANDS['GREETING']+misc.getLocalID())
     #--- ALIVE            
     elif cmd == 'ALIVE':
         pass
 def doGreeting(self, arg):
     self.sendDatagram(COMMANDS['GREETING']+misc.getLocalID())
 def datagram_received(self, cmd, io):
     self.last_alive_packet_time = time.time()
     #---DATA---
     if cmd == 'DATA':
         try:
             file_id = struct.unpack('i', io.read(4))[0]
             block_id = struct.unpack('i', io.read(4))[0]
             num_blocks = struct.unpack('i', io.read(4))[0]
             data_size = struct.unpack('i', io.read(4))[0]
         except:
             dhnio.DprintException()
             return
         if not self.incommingFiles.has_key(file_id):
             if self.receivedFiles.has_key(file_id):
                 self.transport.sendDatagram(COMMANDS['REPORT'] + struct.pack('i', file_id) + struct.pack('i', block_id), self.remote_address)
                 return
             self.incommingFiles[file_id] = InboxFile(self, file_id, num_blocks)
         inp_data = io.read()
         if len(inp_data) < data_size:
             # dhnio.Dprint(2, 'transport_udp_server.UDPPeer.datagram_received WARNING not full data from [%s]' % (str(self.remote_address)))
             return
         self.incommingFiles[file_id].input_block(block_id, inp_data) 
         self.transport.sendDatagram(COMMANDS['REPORT'] + struct.pack('i', file_id) + struct.pack('i', block_id), self.remote_address)            # dhnio.Dprint(10, 'transport_udp_server.UDPPeer.datagram_received DATA [%d,%d/%d] from %s' % (file_id, block_id, num_blocks, self.remote_address))
         if len(self.incommingFiles[file_id].blocks) == num_blocks:
             self.incommingFiles[file_id].build()
             file_received(self.incommingFiles[file_id].filename, 'finished', 'udp', self.remote_address)              
             self.incommingFiles[file_id].close()
             del self.incommingFiles[file_id]
             self.receivedFiles[file_id] = time.time()
             self.erase_old_file_ids()
     #---REPORT---        
     elif cmd == 'REPORT':
         try:
             file_id = struct.unpack('i', io.read(4))[0]
         except:
             dhnio.DprintException()
             return
         if not self.outgoingFiles.has_key(file_id):
             return
         try:
             block_id = struct.unpack('i', io.read(4))[0]
         except:
             dhnio.DprintException()
             return
         if not self.outgoingFiles[file_id].blocks.has_key(block_id):
             # dhnio.Dprint(2, 'transport_udp_server.UDPPeer.datagram_received WARNING unknown block_id in REPORT packet received: [%d]' % block_id)
             return
         # dhnio.Dprint(8, 'transport_udp_server.UDPPeer.datagram_received REPORT for [%d,%d] from %s, window=%d' % (file_id, block_id, self.remote_address, len(self.sliding_window)))
         self.outgoingFiles[file_id].report_block(block_id)
         self.sliding_window.pop((file_id, block_id), None)
         self.sliding_window_size += 1
         if self.sliding_window_size > MAX_WINDOW_SIZE:
             self.sliding_window_size = MAX_WINDOW_SIZE
         if len(self.outgoingFiles[file_id].blocks) == 0:
             file_sent(self.remote_address, self.outgoingFiles[file_id].filename, 'finished', 'udp')
             self.outgoingFiles[file_id].close()
             del self.outgoingFiles[file_id]
             self.block_size_level += 1
             if self.block_size_level > MAX_BLOCK_SIZE_LEVEL:
                 self.block_size_level = MAX_BLOCK_SIZE_LEVEL
             # dhnio.Dprint(8, 'transport_udp_server.UDPPeer.datagram_received [%s] sending finished to %s' % (os.path.basename(filename), self.remote_address))
     #---PING---    
     elif cmd == 'PING':
         self.transport.sendDatagram(COMMANDS['GREETING']+misc.getLocalID(), self.remote_address)
     #---GREETING---
     elif cmd == 'GREETING':
         self.transport.sendDatagram(COMMANDS['ALIVE'], self.remote_address)
     #---ALIVE---
     elif cmd == 'ALIVE':
         pass