Ejemplo n.º 1
0
def update():
    """
    A good way to check all things - load and sign again.
    """
    dhnio.init()
    settings.init()
    src = dhnio.ReadTextFile(settings.LocalIdentityFilename())
    misc.setLocalIdentity(identity(xmlsrc=src))
    misc.getLocalIdentity().sign()
    misc.saveLocalIdentity()
    print misc.getLocalIdentity().serialize()    
Ejemplo n.º 2
0
    def _stuned(ip):
        if stun.getUDPClient() is None:
            print 'UDP CLIENT IS NONE - EXIT'
            reactor.stop()
            return

        print '+++++ EXTERNAL UDP ADDRESS IS', stun.getUDPClient().externalAddress
        
        if sys.argv[1] == 'listen':
            print '+++++ START LISTENING'
            return
        
        if sys.argv[1] == 'connect':
            print '+++++ CONNECTING TO REMOTE MACHINE'
            _try2connect()
            return

        lid = misc.getLocalIdentity()
        udp_contact = 'udp://'+stun.getUDPClient().externalAddress[0]+':'+str(stun.getUDPClient().externalAddress[1])
        lid.setProtoContact('udp', udp_contact)
        lid.sign()
        misc.setLocalIdentity(lid)
        misc.saveLocalIdentity()
        
        print '+++++ UPDATE IDENTITY', str(lid.contacts)
        _send_servers().addBoth(_id_sent)
Ejemplo n.º 3
0
def dhn_stun_server_response(datagram, address):
    try:
        myipport, peeridurl, peeripport, deltatime = datagram.split(' ')
        if peeripport == '0':
            return
        myip, myport = myipport.split(':')
        myport = int(myport)
        peerip, peerport = peeripport.split(':')
        peerport = int(peerport)
    except:
        dhnio.DprintException()    
        return False
    myaddress = (myip, myport)
    peeraddress = (peerip, peerport)
    x, ip, port, x = misc.getLocalIdentity().getProtoParts('udp')
    # if ip and port and ip != myip and str(port) != str(myport):
        # network_address_changed(myaddress)
        # return
    mappedaddress = peeraddress
    if identitycache.HasLocalIP(peeridurl):
        mappedaddress = (identitycache.GetLocalIP(peeridurl), peeraddress[1]) 
    if mappedaddress != peeraddress:
        if not is_session_opened(mappedaddress):
            s = open_session(mappedaddress)
            dhnio.Dprint(6, 'transport_udp_session.dhn_stun_server_response made a new LOCAL session %s for user [%s], address=%s' % (s.name, nameurl.GetName(peeridurl), str(mappedaddress)))
            s.event('init', peeridurl)
            s.routed = True
    else:
        if not is_session_opened(peeraddress):
            s = open_session(peeraddress)
            dhnio.Dprint(6, 'transport_udp_session.dhn_stun_server_response made a new session %s for user [%s]' % (s.name, nameurl.GetName(peeridurl)))
            s.event('init', peeridurl)
            s.routed = True
Ejemplo n.º 4
0
def test1():
    """
    Some tests.
    """
    myidentity=misc.getLocalIdentity()
    print 'getIP =', myidentity.getIP()
    if myidentity.Valid():
        print "myidentity is Valid!!!!"
    else:
        print "myidentity is not Valid"
        misc.saveLocalIdentity()            # sign and save
        raise Exception("myidentity is not Valid")
    print "myidentity.contacts"
    print myidentity.contacts
    print "len myidentity.contacts "
    print len (myidentity.contacts)
    print "len myidentity.contacts[0] "
    print myidentity.contacts[0]
    con=myidentity.getContact()
    print "con:", con, type(con)
    protocol, machine, port, filename = nameurl.UrlParse(con)
    print protocol, machine, port, filename
    print "identity.main serialize:\n", myidentity.serialize()
    for index in range(myidentity.getContactsNumber()):
        proto, host, port, filename = myidentity.getContactParts(index)
        print '[%s] [%s] [%s] [%s]' % (proto, host, port, filename)
Ejemplo n.º 5
0
def main():
    """
    This should print a current identity or create a new one.
    """
    misc.loadLocalIdentity()
    if misc.isLocalIdentityReady():
        misc.getLocalIdentity().sign()
        print misc.getLocalIdentity().serialize()
        print 'Valid is: ', misc.getLocalIdentity().Valid()
    else:
        misc.setLocalIdentity(makeDefaultIdentity(sys.argv[1]))
        misc.saveLocalIdentity()
        print misc.getLocalIdentity().serialize()
        print 'Valid is: ', misc.getLocalIdentity().Valid()
        misc._LocalIdentity = None
        misc.loadLocalIdentity()
Ejemplo n.º 6
0
 def _send_servers():
     import tmpfile, misc, nameurl, settings, transport_tcp
     sendfile, sendfilename = tmpfile.make("propagate")
     os.close(sendfile)
     LocalIdentity = misc.getLocalIdentity()
     dhnio.WriteFile(sendfilename, LocalIdentity.serialize())
     dlist = []
     for idurl in LocalIdentity.sources:
         # sources for out identity are servers we need to send to
         protocol, host, port, filename = nameurl.UrlParse(idurl)
         port = settings.IdentityServerPort()
         d = Deferred()
         transport_tcp.sendsingle(sendfilename, host, port, do_status_report=False, result_defer=d, description='Identity')
         dlist.append(d) 
     dl = DeferredList(dlist, consumeErrors=True)
     print '+++++ IDENTITY SENT TO %s:%s' % (host, port)
     return dl
Ejemplo n.º 7
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