Beispiel #1
0
 def state_changed(self, oldstate, newstate, event, *args, **kwargs):
     """
     Method to catch the moment when proxy_receiver() state were changed.
     """
     if settings.enablePROXYsending():
         from transport.proxy import proxy_sender
         proxy_sender.A('proxy_receiver.state', newstate)
 def state_changed(self, oldstate, newstate, event, arg):
     """
     Method to catch the moment when proxy_receiver() state were changed.
     """
     if settings.enablePROXYsending():
         from transport.proxy import proxy_sender
         proxy_sender.A('proxy_receiver.state', newstate)
Beispiel #3
0
 def connect(self, options):
     """
     """
     if _Debug:
         lg.out(4, 'proxy_interface.connect %s' % str(options))
     from transport.proxy import proxy_receiver
     from transport.proxy import proxy_sender
     if settings.enablePROXYreceiving():
         proxy_receiver.A('start', options)
     else:
         lg.warn('proxy transport receiving is disabled')
         interface_receiving_failed()
         return False
     if settings.enablePROXYsending():
         proxy_sender.A('start', options)
     return succeed(True)
    def connect(self, options):
        """
        
        """
        if _Debug:
            lg.out(4, "proxy_interface.connect %s" % str(options))
        from transport.proxy import proxy_receiver
        from transport.proxy import proxy_sender

        if settings.enablePROXYreceiving():
            proxy_receiver.A("start", options)
        else:
            lg.warn("proxy transport receiving is disabled")
            interface_receiving_failed()
            return False
        if settings.enablePROXYsending():
            proxy_sender.A("start", options)
        return succeed(True)
Beispiel #5
0
 def _push(self):
     from transport import gateway
     if self.route:
         # if this packet is routed - send directly to route host
         gateway.send_file(
             strng.to_bin(self.route['remoteid']),
             strng.to_text(self.route['proto']),
             strng.to_bin(self.route['host']),
             self.filename,
             self.description,
             self,
         )
         self.items.append(
             WorkItem(strng.to_text(self.route['proto']),
                      strng.to_bin(self.route['host']), self.filesize))
         self.automat('items-sent')
         return
     # get info about his local IP
     localIP = identitycache.GetLocalIP(self.remote_idurl)
     workitem_sent = False
     if self.wide:
         # send to all his contacts
         for contactmethod in self.remote_identity.getContacts():
             proto, host = nameurl.IdContactSplit(contactmethod)
             if host.strip() and \
                     settings.transportIsEnabled(proto) and \
                     settings.transportSendingIsEnabled(proto) and \
                     gateway.can_send(proto) and \
                     gateway.is_installed(proto):
                 if proto == 'tcp' and localIP:
                     host = localIP
                 gateway.send_file(
                     strng.to_bin(self.remote_idurl),
                     strng.to_text(proto),
                     strng.to_bin(host),
                     self.filename,
                     self.description,
                     self,
                 )
                 self.items.append(
                     WorkItem(strng.to_text(proto), strng.to_bin(host),
                              self.filesize))
                 workitem_sent = True
         if not workitem_sent:
             self.automat('nothing-to-send')
             lg.warn('(wide) no supported protocols with %s' %
                     self.remote_idurl)
         else:
             self.automat('items-sent')
         return
     # send to one of his contacts,
     # now need to decide which transport to use
     # let's prepare his contacts first
     byproto = self.remote_identity.getContactsByProto()
     tcp_contact = None
     if settings.enableTCP() and settings.enableTCPsending():
         tcp_contact = byproto.get('tcp', None)
     udp_contact = None
     if settings.enableUDP() and settings.enableUDPsending():
         udp_contact = byproto.get('udp', None)
     http_contact = None
     if settings.enableHTTP() and settings.enableHTTPsending():
         http_contact = byproto.get('http', None)
     proxy_contact = None
     if settings.enablePROXY() and settings.enablePROXYsending():
         proxy_contact = byproto.get('proxy', None)
     working_protos = p2p_stats.peers_protos().get(self.remote_idurl, set())
     # tcp seems to be the most stable proto
     # now let's check if we know his local IP and
     # he enabled tcp in his settings to be able to receive packets from others
     # try to send to his local IP first, not external
     if tcp_contact and localIP:
         if gateway.is_installed('tcp') and gateway.can_send(proto):
             proto, host, port, fn = nameurl.UrlParse(tcp_contact)
             if port:
                 host = localIP + ':' + str(port)
             gateway.send_file(strng.to_bin(self.remote_idurl),
                               strng.to_text(proto), strng.to_bin(host),
                               self.filename, self.description, self)
             self.items.append(
                 WorkItem(strng.to_text(proto), strng.to_bin(host),
                          self.filesize))
             self.automat('items-sent')
             return
     # tcp is the best proto - if it is working - this is the best case!!!
     if tcp_contact and 'tcp' in working_protos:
         proto, host, port, fn = nameurl.UrlParse(tcp_contact)
         if host.strip() and gateway.is_installed(
                 proto) and gateway.can_send(proto):
             if port:
                 host = host + ':' + str(port)
             gateway.send_file(strng.to_bin(self.remote_idurl),
                               strng.to_text(proto), strng.to_bin(host),
                               self.filename, self.description)
             self.items.append(
                 WorkItem(strng.to_text(proto), strng.to_bin(host),
                          self.filesize))
             self.automat('items-sent')
             return
     # udp contact
     if udp_contact and 'udp' in working_protos:
         proto, host = nameurl.IdContactSplit(udp_contact)
         if host.strip() and gateway.is_installed(
                 'udp') and gateway.can_send(proto):
             gateway.send_file(strng.to_bin(self.remote_idurl),
                               strng.to_text(proto), strng.to_bin(host),
                               self.filename, self.description, self)
             self.items.append(
                 WorkItem(strng.to_text(proto), strng.to_bin(host),
                          self.filesize))
             self.automat('items-sent')
             return
     # http contact
     if http_contact and 'http' in working_protos:
         proto, host, port, _ = nameurl.UrlParse(http_contact)
         if host.strip() and gateway.is_installed(
                 proto) and gateway.can_send(proto):
             if port:
                 host = host + ':' + str(port)
             gateway.send_file(strng.to_bin(self.remote_idurl),
                               strng.to_text(proto), strng.to_bin(host),
                               self.filename, self.description, self)
             self.items.append(
                 WorkItem(strng.to_text(proto), strng.to_bin(host),
                          self.filesize))
             self.automat('items-sent')
             return
     # proxy contact - he may use other node to receive and send packets
     if proxy_contact and 'proxy' in working_protos:
         proto, host = nameurl.IdContactSplit(proxy_contact)
         if host.strip() and gateway.is_installed(
                 'proxy') and gateway.can_send(proto):
             gateway.send_file(strng.to_bin(self.remote_idurl),
                               strng.to_text(proto), strng.to_bin(host),
                               self.filename, self.description, self)
             self.items.append(
                 WorkItem(strng.to_text(proto), strng.to_bin(host),
                          self.filesize))
             self.automat('items-sent')
             return
     # finally use the first proto we supported if we can not find the best preferable method
     for contactmethod in self.remote_identity.getContacts():
         proto, host, port, fn = nameurl.UrlParse(contactmethod)
         if port:
             host = host + ':' + str(port)
         # if method exist but empty - don't use it
         if host.strip():
             # try sending with tcp even if it is switched off in the settings
             if gateway.is_installed(proto) and gateway.can_send(proto):
                 if settings.enableTransport(
                         proto) and settings.transportSendingIsEnabled(
                             proto):
                     gateway.send_file(strng.to_bin(self.remote_idurl),
                                       strng.to_text(proto),
                                       strng.to_bin(host), self.filename,
                                       self.description, self)
                     self.items.append(
                         WorkItem(strng.to_text(proto), strng.to_bin(host),
                                  self.filesize))
                     self.automat('items-sent')
                     return
     self.automat('nothing-to-send')
     lg.warn('no supported protocols with %s : %s %s %s, byproto:%s' %
             (self.remote_idurl, tcp_contact, udp_contact, working_protos,
              str(byproto)))
 def init(self, **kwargs):
     global _PacketLogFileEnabled
     _PacketLogFileEnabled = config.conf().getBool('logs/packet-enabled')
     self._sending_enabled = settings.enablePROXYsending()
Beispiel #7
0
 def _push(self):
     if self.route:
         # if this packet is routed - send directly to route host
         gateway.send_file(
             self.route["remoteid"], self.route["proto"], self.route["host"], self.filename, self.description
         )
         self.items.append(WorkItem(self.route["proto"], self.route["host"], self.filesize))
         self.automat("items-sent")
         return
     # get info about his local IP
     localIP = identitycache.GetLocalIP(self.remote_idurl)
     workitem_sent = False
     if self.wide:
         # send to all his contacts
         for contactmethod in self.remote_identity.getContacts():
             proto, host = nameurl.IdContactSplit(contactmethod)
             if (
                 host.strip()
                 and settings.transportIsEnabled(proto)
                 and settings.transportSendingIsEnabled(proto)
                 and gateway.can_send(proto)
                 and gateway.is_installed(proto)
             ):
                 if proto == "tcp" and localIP:
                     host = localIP
                 gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
                 self.items.append(WorkItem(proto, host, self.filesize))
                 workitem_sent = True
         if not workitem_sent:
             self.automat("nothing-to-send")
             lg.warn("(wide) no supported protocols with %s" % self.remote_idurl)
         else:
             self.automat("items-sent")
         return
     # send to one of his contacts,
     # now need to decide which transport to use
     # let's prepare his contacts first
     byproto = self.remote_identity.getContactsByProto()
     tcp_contact = None
     if settings.enableTCP() and settings.enableTCPsending():
         tcp_contact = byproto.get("tcp", None)
     udp_contact = None
     if settings.enableUDP() and settings.enableUDPsending():
         udp_contact = byproto.get("udp", None)
     proxy_contact = None
     if settings.enablePROXY() and settings.enablePROXYsending():
         proxy_contact = byproto.get("proxy", None)
     working_protos = stats.peers_protos().get(self.remote_idurl, set())
     # tcp seems to be the most stable proto
     # now let's check if we know his local IP and
     # he enabled tcp in his settings to be able to receive packets from others
     # try to send to his local IP first, not external
     if tcp_contact and localIP:
         if gateway.is_installed("tcp") and gateway.can_send(proto):
             proto, host, port, fn = nameurl.UrlParse(tcp_contact)
             if port:
                 host = localIP + ":" + str(port)
             gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
             self.items.append(WorkItem(proto, host, self.filesize))
             self.automat("items-sent")
             return
     # tcp is the best proto - if it is working - this is the best case!!!
     if tcp_contact and "tcp" in working_protos:
         proto, host, port, fn = nameurl.UrlParse(tcp_contact)
         if host.strip() and gateway.is_installed(proto) and gateway.can_send(proto):
             if port:
                 host = host + ":" + str(port)
             gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
             self.items.append(WorkItem(proto, host, self.filesize))
             self.automat("items-sent")
             return
     # udp contact
     if udp_contact and "udp" in working_protos:
         proto, host = nameurl.IdContactSplit(udp_contact)
         if host.strip() and gateway.is_installed("udp") and gateway.can_send(proto):
             gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
             self.items.append(WorkItem(proto, host, self.filesize))
             self.automat("items-sent")
             return
     # proxy contact - he may use other node to receive and send packets
     if proxy_contact and "proxy" in working_protos:
         proto, host = nameurl.IdContactSplit(proxy_contact)
         if host.strip() and gateway.is_installed("proxy") and gateway.can_send(proto):
             gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
             self.items.append(WorkItem(proto, host, self.filesize))
             self.automat("items-sent")
             return
     # finally use the first proto we supported if we can not find the best preferable method
     for contactmethod in self.remote_identity.getContacts():
         proto, host, port, fn = nameurl.UrlParse(contactmethod)
         if port:
             host = host + ":" + str(port)
         # if method exist but empty - don't use it
         if host.strip():
             # try sending with tcp even if it is switched off in the settings
             if gateway.is_installed(proto) and gateway.can_send(proto):
                 if settings.enableTransport(proto) and settings.transportSendingIsEnabled(proto):
                     gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
                     self.items.append(WorkItem(proto, host, self.filesize))
                     self.automat("items-sent")
                     return
     self.automat("nothing-to-send")
     lg.warn(
         "no supported protocols with %s : %s %s %s, byproto:%s"
         % (self.remote_idurl, tcp_contact, udp_contact, working_protos, str(byproto))
     )
Beispiel #8
0
 def isSendingEnabled(self, *args, **kwargs):
     """
     Condition method.
     """
     return settings.enablePROXYsending()