def get_nat_type():
parser = optparse.OptionParser(version=stun.__version__)
parser.add_option("-d", "--debug", dest="DEBUG", action="store_true",
default=False, help="Enable debug logging")
parser.add_option("-H", "--host", dest="stun_host", default=None,
help="STUN host to use")
parser.add_option("-P", "--host-port", dest="stun_port", type="int",
default=3478, help="STUN host port to use (default: "
"3478)")
parser.add_option("-i", "--interface", dest="source_ip", default="0.0.0.0",
help="network interface for client (default: 0.0.0.0)")
parser.add_option("-p", "--port", dest="source_port", type="int",
default=54320, help="port to listen on for client "
"(default: 54320)")
(options, args) = parser.parse_args()
if options.DEBUG:
stun.enable_logging()
kwargs = dict(source_ip=options.source_ip,
source_port=int(options.source_port),
stun_host=options.stun_host,
stun_port=options.stun_port)
nat_type, external_ip, external_port = stun.get_ip_info(**kwargs)
print "NAT Type:", nat_type
print "External IP:", external_ip
print "External Port:", external_port
return nat_type, external_ip, external_port
def get_NAT_status(stun_host=None):
"""
Given a server hostname, initiate a STUN request to it;
and return the response in the form of a dict.
"""
response = stun.get_ip_info(stun_host=stun_host, source_port=0)
return {'nat_type': response[0],
'external_ip': response[1],
'external_port': response[2]}
def test_stun():
"""Get external IP address from stun, and test the connection capabilities"""
log.info("STUN - Testing connection...")
src_port=randint(1025, 65535)
stun = get_ip_info(source_port=src_port)
log.debug(stun)
port_mapping = PRESERVES_PORT if stun[2] == src_port else None
seq_stun = None
if port_mapping != PRESERVES_PORT:
"""Test for sequential port mapping"""
seq_stun = get_ip_info(source_port=src_port+1)
log.debug(seq_stun)
port_mapping = SQUENTIAL_PORT if stun[2] + 1 == seq_stun[2] else RANDOM_PORT
log.debug("STUN - Port allocation: "+port_strings[port_mapping])
seq_stun = seq_stun or None
ret = (stun, seq_stun), port_mapping, src_port
return ret
def start_node(self, port):
self.dynamic_ip = stun.get_ip_info()[1]
try:
self.loadState(OBNodeStrings.knode_pickle)
except IOError:
print "knode.p does not exist, network has not been saved."
print "%s:\t%s" % (self.dynamic_ip, self.node.port,)
def run(self):
self._log("Getting external IP info")
nat_type, external_ip, external_port = stun.get_ip_info()
#nat_type, external_ip, external_port = None, "0.0.0.0", 12345
self._log("Public addr: %s:%s" % (external_ip, external_port))
self._log("Connecting to DHT")
self.dht = DHT("0.0.0.0", 52525)
self.public_contact = (external_ip, external_port)
for peer in self.core.config.get("peers", self._default_peers):
self.dht.bootstrap(peer["host"], peer["port"])
def lback_default_focused_agent():
ip_info =stun.get_ip_info()
public_ip = ip_info[1]
local_ip = "127.0.0.1"
## prefer local
agents = lback_agents()
for agent in agents:
if local_ip==agent.host:
return agent.id
if public_ip==agent.host:
return agent.id
raise Exception("No default focused agent available")
def update_loop(prefs, client):
while True:
nat_type, ip, port = get_ip_info()
for domain in prefs.get('domains'):
result = client.update_dns_record(domain['dns'], ip)
if result:
logger.info("Updated DNS Record")
else:
logger.info("DNS is already set.")
logger.info("Sleeping for %s seconds" % prefs.get('interval'))
sleep(prefs.get('interval'))
pass
def connectionSupport(self):
"""
This method provide reserve of external port on external router
or rewrite info about external port on Signal server.
"""
self.transport.write('[True, "something"]', ('10.0.16.24', 4444))
time.sleep(2)
if self.s_connect:
self.s_connect = False
self.connectionSupport()
else:
self.sendDatagram('[False, "Client 911", %s]' % str(stun.get_ip_info()[1:]))
self.connectionSupport()
def connect_to_server(self):
ch = raw_input("Choose how to setup a connection\n 1.m for private server\n 2.p for public server\n")
self.local_port = int(raw_input("enter port to listen: "))
if ch == 'p':
self.nat_type, self.my_ip, self.port = stun.get_ip_info('0.0.0.0', self.local_port)
if not self.my_ip:
log.warn('Stun request failed! switching to manual server')
else:
log.info('External address: %s:%s' % (self.my_ip, self.port))
self.listen_address = ('0.0.0.0', self.local_port)
log.info('Listening on address: %s:%s' % (self.listen_address[0], self.listen_address[1]))
self.linsocket.bind(self.listen_address)
def uiStunserver():
global PeerAddr
global PeerIp
global port
nat_type, Myip, port = stun.get_ip_info()
if Myip=="" or Myip=="none":
print "Stun request falied! switching to manual server"
uiMyserver()
else:
listenport=port
listenAddr=('0.0.0.0',listenport)
listensoc.bind(listenAddr)
print "your ip is: '"+Myip+ "' and your port is: '"+str(port)+"'"
def ReceiverTask(addr, port, bootstrap=None):
global t_recv_buffer
receiver = Receiver((addr, port))
addr, port = receiver.get_addr()
cache["addr"], cache["port"] = addr, port
port_map = [(port, "UDP"), (port + 1, "UDP")]
external_ip, lan_addr = do_UPNP_mapping(port_map)
#external_ip, lan_addr = "161.53.120.206", get_lan_addr()
if external_ip:
logging.info("[+] uPnP maps:{0}:{1} -> {2}:{3}".format(
lan_addr, port, external_ip, port))
cache["addr"], cache["port"] = lan_addr, port
#cache["addr"], cache["port"] = external_ip, port
else:
# Do STUN probe
logging.info("[-] external_ip unknown: sending STUN probe...")
import stun
nat_type, external_ip, external_port = stun.get_ip_info()
logging.info("[+] STUN probe: {0}:{1}, {2}".format(
external_ip, external_port, nat_type))
#cache["addr"], cache["port"] = external_ip, port #, external_port
# TODO: if nat_type == symmetric -> import turn
logging.info("cache['addr'] = {0}, cache['port'] = {1}".format(
cache["addr"], cache["port"]))
p = Process(target=tftp_server, args=(port + 1, "./tasks/"))
p.start()
if bootstrap:
yield NewTask(Bootstrap(bootstrap))
while True:
logging.info("Waiting for packets in ReceiverTask")
resp, addr, rpc_no, uuid = yield receiver.recv()
packet = {"resp": resp,
"addr": addr,
"rpc_no": rpc_no,
"uuid": uuid }
#logging.debug("Packet received {}".format(packet))
if not socket_observable.notify_one(packet):
logging.debug("Not observer for notify, sending response...")
sender = Sender(packet["addr"],
(cache["addr"], cache["port"]),
cache["uuid"])
yield sender.send_resp(packet["resp"], packet["rpc_no"])
def main():
try:
parser = make_argument_parser()
args = parser.parse_args()
if args.mode == CLIENT:
nat_type, host, port = stun.get_ip_info()
reactor.listenUDP(0, Client(host, port, args.message))
reactor.run()
elif args.mode == SERVER:
reactor.listenUDP(0, Server())
reactor.run()
else:
parser.print_help()
except KeyboardInterrupt:
sys.exit()
def setup_external_ip(self, hostname=None):
"""
Detects and change hostname if needed (not fully implemented so far)
:param hostname:the current hostname of the robot
"""
nat_type, current_external_ip, external_port = stun.get_ip_info()
log.info("Nat type %s, external IP %s, external port %s", nat_type, current_external_ip, external_port)
dns_registered_ip = dns.resolver.query(hostname)[0]
if str(current_external_ip) != str(dns_registered_ip):
log.info(
"DNS need change. Currently on DNS '%s', current external IP '%s'",
dns_registered_ip,
current_external_ip,
)
else:
log.info("DNS and current external IP ('%s') are the same, no DNS change needed", current_external_ip)
def main():
try:
options = make_argument_parser().parse_args()
if options.debug:
logging.basicConfig()
stun.log.setLevel(logging.DEBUG)
nat_type, external_ip, external_port = stun.get_ip_info(
source_ip=options.source_ip,
source_port=options.source_port,
stun_host=options.stun_host,
stun_port=options.stun_port
)
print('NAT Type:', nat_type)
print('External IP:', external_ip)
print('External Port:', external_port)
except KeyboardInterrupt:
sys.exit()
def main():
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.settimeout(10)
nat_type, external_ip, external_port = stun.get_ip_info()
other_client, other_client_nat = request_conn(s, addr2str((external_ip, external_port)))
connected = None
s.settimeout(2)
while True:
# discover procedure
while not connected:
for addr in [other_client, other_client_nat]:
print("Try to conn to addr: {}".format(addr))
s.sendto("discover", addr)
try:
data, addr = s.recvfrom(1024)
s.sendto("discover", addr)
except socket.timeout:
continue
connected = addr
print("Connected to: {}".format(addr))
s.sendto("hello i'm here", connected)
data, addr = s.recvfrom(1024)
print("Received from {}: {}".format(addr, data))
time.sleep(1)
def get_ip_info():
type_nat, ip, port = stun.get_ip_info()
return (ip, port)
def run(*args):
TESTNET = args[0]
# Create the database
db = Database(testnet=TESTNET)
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log", rotateLength=15000000, maxRotatedFiles=1)
log.addObserver(FileLogObserver(logFile, level="debug").emit)
log.addObserver(FileLogObserver(level="debug").emit)
logger = Logger(system="Httpseed")
# Load the keys
keychain = KeyChain(db)
if os.path.isfile(DATA_FOLDER + 'keys.pickle'):
keys = pickle.load(open(DATA_FOLDER + "keys.pickle", "r"))
signing_key_hex = keys["signing_privkey"]
signing_key = nacl.signing.SigningKey(signing_key_hex, encoder=nacl.encoding.HexEncoder)
else:
signing_key = nacl.signing.SigningKey.generate()
keys = {
'signing_privkey': signing_key.encode(encoder=nacl.encoding.HexEncoder),
'signing_pubkey': signing_key.verify_key.encode(encoder=nacl.encoding.HexEncoder)
}
pickle.dump(keys, open(DATA_FOLDER + "keys.pickle", "wb"))
# Stun
port = 18467 if not TESTNET else 28467
logger.info("Finding NAT Type...")
response = stun.get_ip_info(stun_host="stun.l.google.com", source_port=port, stun_port=19302)
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
ip_address = response[1]
port = response[2]
# Start the kademlia server
this_node = Node(keychain.guid, ip_address, port,
keychain.guid_signed_pubkey, None, objects.FULL_CONE, False)
protocol = OpenBazaarProtocol((ip_address, port), objects.FULL_CONE, testnet=TESTNET, relaying=True)
try:
kserver = Server.loadState('cache.pickle', ip_address, port, protocol, db, objects.FULL_CONE, None)
except Exception:
kserver = Server(this_node, db)
kserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(kserver.protocol)
kserver.saveStateRegularly('cache.pickle', 10)
reactor.listenUDP(port, protocol)
class WebResource(resource.Resource):
def __init__(self, kserver_r):
resource.Resource.__init__(self)
self.kserver = kserver_r
self.nodes = {}
for bucket in self.kserver.protocol.router.buckets:
for node in bucket.getNodes():
self.nodes[(node.ip, node.port)] = node
self.nodes[(this_node.ip, this_node.port)] = this_node
loopingCall = task.LoopingCall(self.crawl)
loopingCall.start(180, True)
def crawl(self):
def gather_results(result):
for proto in result:
n = objects.Node()
try:
n.ParseFromString(proto)
node = Node(n.guid, n.nodeAddress.ip, n.nodeAddress.port, n.signedPublicKey,
None if not n.HasField("relayAddress") else
(n.relayAddress.ip, n.relayAddress.port),
n.natType,
n.vendor)
self.nodes[(node.ip, node.port)] = node
except Exception:
pass
def start_crawl(results):
for node, result in results.items():
if not result[0]:
del self.nodes[(node.ip, node.port)]
node = Node(digest(random.getrandbits(255)))
nearest = self.kserver.protocol.router.findNeighbors(node)
spider = NodeSpiderCrawl(self.kserver.protocol, node, nearest, 100, 4)
spider.find().addCallback(gather_results)
ds = {}
for bucket in self.kserver.protocol.router.buckets:
for node in bucket.getNodes():
self.nodes[(node.ip, node.port)] = node
for node in self.nodes.values():
if node.id != this_node.id:
ds[node] = self.kserver.protocol.callPing(node)
deferredDict(ds).addCallback(start_crawl)
def getChild(self, child, request):
return self
def render_GET(self, request):
nodes = self.nodes.values()
shuffle(nodes)
logger.info("Received a request for nodes, responding...")
if "format" in request.args:
if request.args["format"][0] == "json":
json_list = []
if "type" in request.args and request.args["type"][0] == "vendors":
for node in nodes:
if node.vendor is True:
node_dic = {}
node_dic["ip"] = node.ip
node_dic["port"] = node.port
node_dic["guid"] = node.id.encode("hex")
json_list.append(node_dic)
sig = signing_key.sign(str(json_list))
resp = {"peers": json_list, "signature": hexlify(sig[:64])}
request.write(json.dumps(resp, indent=4))
else:
for node in nodes[:50]:
node_dic = {}
node_dic["ip"] = node.ip
node_dic["port"] = node.port
json_list.append(node_dic)
sig = signing_key.sign(str(json_list))
resp = {"peers": json_list, "signature": hexlify(sig[:64])}
request.write(json.dumps(resp, indent=4))
elif request.args["format"][0] == "protobuf":
proto = peers.PeerSeeds()
for node in nodes[:50]:
proto.serializedNode.append(node.getProto().SerializeToString())
sig = signing_key.sign("".join(proto.serializedNode))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
else:
proto = peers.PeerSeeds()
if "type" in request.args and request.args["type"][0] == "vendors":
for node in nodes:
if node.vendor is True:
proto.serializedNode.append(node.getProto().SerializeToString())
sig = signing_key.sign("".join(proto.serializedNode))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
else:
for node in nodes[:50]:
proto.serializedNode.append(node.getProto().SerializeToString())
sig = signing_key.sign("".join(proto.serializedNode))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
request.finish()
return server.NOT_DONE_YET
server_protocol = server.Site(WebResource(kserver))
reactor.listenTCP(8080, server_protocol)
reactor.run()
def get_public_ip():
nat_type, external_ip, external_port = stun.get_ip_info()
return str(external_ip)
def run(*args):
TESTNET = args[0]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
# TODO: prune this log file and prevent it from getting too large?
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(FileLogObserver(logFile, level=args[1]).emit)
log.addObserver(FileLogObserver(level=args[1]).emit)
logger = Logger(system="OpenBazaard")
# NAT traversal
port = args[2]
PortMapper().add_port_mapping(port, port, 'UDP')
logger.info("Finding NAT Type...")
while True:
try:
response = stun.get_ip_info(source_port=port)
break
except Exception:
pass
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
ip_address = response[1]
port = response[2]
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
logger.info("bootstrap complete, downloading outstanding messages...")
mlistener = MessageListenerImpl(ws_factory, db)
mserver.get_messages(mlistener)
mserver.protocol.add_listener(mlistener)
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
# TODO: ping seed node to establish connection if not full cone NAT
# TODO: after bootstrap run through any pending contracts and see if the bitcoin address
# has been funded, if not listen on the address and start the 10 minute delete timer.
protocol = OpenBazaarProtocol((ip_address, port), response[0], testnet=TESTNET)
# kademlia
node = Node(keys.guid, ip_address, port, signed_pubkey=keys.guid_signed_pubkey, vendor=Profile(db).get().vendor)
storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db,
on_bootstrap_complete, storage=storage)
except Exception:
kserver = Server(node, db, KSIZE, ALPHA, storage=storage)
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(
kserver.querySeed("seed.openbazaar.org:8080",
"5b44be5c18ced1bc9400fe5e79c8ab90204f06bebacc04dd9c70a95eaca6e117"))\
.addCallback(on_bootstrap_complete)
# TODO: load seeds from config file
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
# websockets api
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(9000, web, interface=args[4])
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
site = Site(api, timeout=None)
reactor.listenTCP(18469, site, interface=args[3])
# TODO: add optional SSL on rest and websocket servers
# blockchain
# TODO: listen on the libbitcoin heartbeat port instead fetching height
def height_fetched(ec, height):
# TODO: re-broadcast any unconfirmed txs in the db using height to find confirmation status
logger.info("Libbitcoin server online")
try:
timeout.cancel()
except Exception:
pass
def timeout(client):
logger.critical("Libbitcoin server offline")
client = None
if TESTNET:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER_TESTNET)
else:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER)
# TODO: load libbitcoin server url from config file
libbitcoin_client.fetch_last_height(height_fetched)
timeout = reactor.callLater(7, timeout, libbitcoin_client)
protocol.set_servers(ws_factory, libbitcoin_client)
reactor.run()
def start_server(keychain, first_startup=False):
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log", rotateLength=15000000, maxRotatedFiles=1)
log.addObserver(FileLogObserver(logFile, level="debug").emit)
log.addObserver(FileLogObserver(level="debug").emit)
logger = Logger(system="Httpseed")
if os.path.isfile(DATA_FOLDER + 'keys.pickle'):
keys = pickle.load(open(DATA_FOLDER + "keys.pickle", "r"))
signing_key_hex = keys["signing_privkey"]
signing_key = nacl.signing.SigningKey(signing_key_hex, encoder=nacl.encoding.HexEncoder)
else:
signing_key = nacl.signing.SigningKey.generate()
keys = {
'signing_privkey': signing_key.encode(encoder=nacl.encoding.HexEncoder),
'signing_pubkey': signing_key.verify_key.encode(encoder=nacl.encoding.HexEncoder)
}
pickle.dump(keys, open(DATA_FOLDER + "keys.pickle", "wb"))
# Stun
port = 18467 if not TESTNET else 28467
logger.info("Finding NAT Type...")
response = stun.get_ip_info(stun_host="stun.l.google.com", source_port=port, stun_port=19302)
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
ip_address = response[1]
port = response[2]
# Start the kademlia server
this_node = Node(keychain.guid, ip_address, port,
keychain.verify_key.encode(), None, objects.FULL_CONE, False)
protocol = OpenBazaarProtocol(db, (ip_address, port), objects.FULL_CONE, testnet=TESTNET, relaying=True)
try:
kserver = Server.loadState('cache.pickle', ip_address, port, protocol, db, objects.FULL_CONE, None)
except Exception:
kserver = Server(this_node, db, keychain.signing_key)
kserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(kserver.protocol)
kserver.saveStateRegularly('cache.pickle', 10)
reactor.listenUDP(port, protocol)
class WebResource(resource.Resource):
def __init__(self, kserver_r):
resource.Resource.__init__(self)
self.kserver = kserver_r
self.nodes = {}
for bucket in self.kserver.protocol.router.buckets:
for node in bucket.getNodes():
self.nodes[(node.ip, node.port)] = node
self.nodes[(this_node.ip, this_node.port)] = this_node
loopingCall = task.LoopingCall(self.crawl)
loopingCall.start(900, True)
def crawl(self):
def gather_results(result):
for proto in result:
n = objects.Node()
try:
n.ParseFromString(proto)
node = Node(n.guid, n.nodeAddress.ip, n.nodeAddress.port, n.signedPublicKey,
None if not n.HasField("relayAddress") else
(n.relayAddress.ip, n.relayAddress.port),
n.natType,
n.vendor)
self.nodes[(node.ip, node.port)] = node
except Exception:
pass
def start_crawl(results):
for node, result in results.items():
if not result[0]:
del self.nodes[(node.ip, node.port)]
node = Node(digest(random.getrandbits(255)))
nearest = self.kserver.protocol.router.findNeighbors(node)
spider = NodeSpiderCrawl(self.kserver.protocol, node, nearest, 100, 4)
spider.find().addCallback(gather_results)
ds = {}
for bucket in self.kserver.protocol.router.buckets:
for node in bucket.getNodes():
self.nodes[(node.ip, node.port)] = node
for node in self.nodes.values():
if node.id != this_node.id:
ds[node] = self.kserver.protocol.callPing(node)
deferredDict(ds).addCallback(start_crawl)
def getChild(self, child, request):
return self
def render_GET(self, request):
nodes = self.nodes.values()
shuffle(nodes)
logger.info("Received a request for nodes, responding...")
if "format" in request.args:
if request.args["format"][0] == "json":
json_list = []
if "type" in request.args and request.args["type"][0] == "vendors":
for node in nodes:
if node.vendor is True:
node_dic = {}
node_dic["ip"] = node.ip
node_dic["port"] = node.port
node_dic["guid"] = node.id.encode("hex")
json_list.append(node_dic)
sig = signing_key.sign(str(json_list))
resp = {"peers": json_list, "signature": hexlify(sig[:64])}
request.write(json.dumps(resp, indent=4))
else:
for node in nodes[:50]:
node_dic = {}
node_dic["ip"] = node.ip
node_dic["port"] = node.port
json_list.append(node_dic)
sig = signing_key.sign(str(json_list))
resp = {"peers": json_list, "signature": hexlify(sig[:64])}
request.write(json.dumps(resp, indent=4))
elif request.args["format"][0] == "protobuf":
proto = peers.PeerSeeds()
for node in nodes[:50]:
proto.serializedNode.append(node.getProto().SerializeToString())
sig = signing_key.sign("".join(proto.serializedNode))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
else:
proto = peers.PeerSeeds()
if "type" in request.args and request.args["type"][0] == "vendors":
for node in nodes:
if node.vendor is True:
proto.serializedNode.append(node.getProto().SerializeToString())
sig = signing_key.sign("".join(proto.serializedNode))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
else:
for node in nodes[:50]:
proto.serializedNode.append(node.getProto().SerializeToString())
sig = signing_key.sign("".join(proto.serializedNode))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
request.finish()
return server.NOT_DONE_YET
server_protocol = server.Site(WebResource(kserver))
reactor.listenTCP(HTTPPORT, server_protocol)
import stun nat_type, external_ip, external_port = stun.get_ip_info(stun_host='192.168.1.191',stun_port=8898) print(nat_type) print(external_ip) print(external_port)
from guidutils.guid import GUID
from dht.network import Server
from dht.node import Node
from wireprotocol import OpenBazaarProtocol
from constants import DATA_FOLDER
from market import network
from txjsonrpc.netstring import jsonrpc
from networkcli import RPCCalls
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(log.FileLogObserver(logFile).emit)
log.startLogging(sys.stdout)
# stun
response = stun.get_ip_info(stun_host="stun.l.google.com", source_port=0, stun_port=19302)
ip_address = response[1]
port = response[2]
# key generation
if os.path.isfile(DATA_FOLDER + 'keys.pickle'):
keys = pickle.load(open(DATA_FOLDER + "keys.pickle", "r"))
g = keys["guid"]
else:
print "Generating GUID, stand by..."
g = GUID()
keys = {'guid': g}
pickle.dump(keys, open(DATA_FOLDER + "keys.pickle", "wb"))
protocol = OpenBazaarProtocol((ip_address, port))
from constants import DATA_FOLDER, DATABASE
from txjsonrpc.netstring import jsonrpc
from networkcli import RPCCalls
from market import network
from market.listeners import MessageListenerImpl, NotificationListenerImpl
from ws import WSFactory, WSProtocol
from autobahn.twisted.websocket import listenWS
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(log.FileLogObserver(logFile).emit)
log.startLogging(sys.stdout)
# stun
print "Finding NAT Type.."
response = stun.get_ip_info(stun_host='seed.openbazaar.org', stun_port=3478, source_port=0)
print "%s on %s:%s" % (response[0], response[1], response[2])
ip_address = response[1]
port = response[2]
# database
if not os.path.isfile(DATABASE):
create_database()
# key generation
keys = KeyChain()
def on_bootstrap_complete(resp):
mlistener = MessageListenerImpl(ws_factory)
mserver.get_messages(mlistener)
mserver.protocol.add_listener(mlistener)
v_sig_host = 'XX.XX.XX.XX'
v_sig_port = XXXX
#id этого КЛИЕНТА, имя этого КЛИЕНТА, id искомого СЕРВЕРА
v_id_client = 'id_server_1002'
v_name_client = 'name_server_2'
v_id_server = 'none'
#IP и PORT этого КЛИЕНТА
v_ip_localhost = 'XX.XX.XX.XX'
v_port_localhost = XXXX
udp_socket = ''
try:
#Получаем текущий внешний IP и PORT при помощи утилиты STUN
nat_type, external_ip, external_port = stun.get_ip_info()
#Присваиваем переменным белый IP и PORT сигнального сервера для отправки запроса
host_sigserver = v_sig_host
port_sigserver = v_sig_port
addr_sigserv = (host_sigserver,port_sigserver)
#Заполняем словарь данными для отправки на СИГНАЛЬНЫЙ СЕРВЕР:
#текущий id + имя + текущий внешний IP и PORT,
#и id_dest - укажем 'none'
#В качестве id можно использовать хеш случайного числа + соль
data_out = v_id_client + ',' + v_name_client + ',' + external_ip + ',' + str(external_port) + ',' + v_id_server
#Создадим сокет с атрибутами:
#использовать пространство интернет адресов (AF_INET),
#передавать данные в виде отдельных сообщений
def run(*args):
TESTNET = args[0]
# Create the database
db = Database(testnet=TESTNET)
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(log.FileLogObserver(logFile).emit)
log.startLogging(sys.stdout)
# Load the keys
keychain = KeyChain(db)
if os.path.isfile(DATA_FOLDER + 'keys.pickle'):
keys = pickle.load(open(DATA_FOLDER + "keys.pickle", "r"))
signing_key_hex = keys["signing_privkey"]
signing_key = nacl.signing.SigningKey(signing_key_hex, encoder=nacl.encoding.HexEncoder)
else:
signing_key = nacl.signing.SigningKey.generate()
keys = {
'signing_privkey': signing_key.encode(encoder=nacl.encoding.HexEncoder),
'signing_pubkey': signing_key.verify_key.encode(encoder=nacl.encoding.HexEncoder)
}
pickle.dump(keys, open(DATA_FOLDER + "keys.pickle", "wb"))
# Stun
port = 18467 if not TESTNET else 28467
print "Finding NAT Type.."
response = stun.get_ip_info(stun_host="stun.l.google.com", source_port=port, stun_port=19302)
print "%s on %s:%s" % (response[0], response[1], response[2])
ip_address = response[1]
port = response[2]
# Start the kademlia server
this_node = Node(keychain.guid, ip_address, port, keychain.guid_signed_pubkey, vendor=Profile(db).get().vendor)
protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET)
try:
kserver = Server.loadState('cache.pickle', ip_address, port, protocol, db)
except Exception:
kserver = Server(this_node, db)
kserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(kserver.protocol)
kserver.saveStateRegularly('cache.pickle', 10)
# start the market server
mserver = network.Server(kserver, keychain.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
class WebResource(resource.Resource):
def __init__(self, kserver_r):
resource.Resource.__init__(self)
self.kserver = kserver_r
self.nodes = {}
for bucket in self.kserver.protocol.router.buckets:
for node in bucket.getNodes():
self.nodes[(node.ip, node.port)] = node
self.nodes[(this_node.ip, this_node.port)] = this_node
loopingCall = task.LoopingCall(self.crawl)
loopingCall.start(60, True)
def crawl(self):
def gather_results(result):
for proto in result:
n = objects.Node()
try:
n.ParseFromString(proto)
node = Node(n.guid, n.ip, n.port, n.signedPublicKey, n.vendor)
self.nodes[(node.ip, node.port)] = node
except Exception:
pass
def start_crawl(results):
for node, result in results.items():
if not result[0]:
del self.nodes[(node.ip, node.port)]
node = Node(digest(random.getrandbits(255)))
nearest = self.kserver.protocol.router.findNeighbors(node)
spider = NodeSpiderCrawl(self.kserver.protocol, node, nearest, 100, 4)
spider.find().addCallback(gather_results)
ds = {}
for bucket in self.kserver.protocol.router.buckets:
for node in bucket.getNodes():
self.nodes[(node.ip, node.port)] = node
for node in self.nodes.values():
if node.id != this_node.id:
ds[node] = self.kserver.protocol.callPing(node)
deferredDict(ds).addCallback(start_crawl)
def getChild(self, child, request):
return self
def render_GET(self, request):
nodes = self.nodes.values()
shuffle(nodes)
log.msg("Received a request for nodes, responding...")
if "format" in request.args:
if request.args["format"][0] == "json":
json_list = []
if "type" in request.args and request.args["type"][0] == "vendors":
print "getting list of vendors"
for node in nodes:
if node.vendor is True:
print "found vendor"
node_dic = {}
node_dic["ip"] = node.ip
node_dic["port"] = node.port
json_list.append(node_dic)
sig = signing_key.sign(str(json_list))
resp = {"peers": json_list, "signature": hexlify(sig[:64])}
request.write(json.dumps(resp, indent=4))
else:
for node in nodes[:50]:
node_dic = {}
node_dic["ip"] = node.ip
node_dic["port"] = node.port
json_list.append(node_dic)
sig = signing_key.sign(str(json_list))
resp = {"peers": json_list, "signature": hexlify(sig[:64])}
request.write(json.dumps(resp, indent=4))
elif request.args["format"][0] == "protobuf":
proto = peers.PeerSeeds()
for node in nodes[:50]:
peer = peers.PeerData()
peer.ip_address = node.ip
peer.port = node.port
peer.vendor = node.vendor
proto.peer_data.append(peer.SerializeToString())
sig = signing_key.sign("".join(proto.peer_data))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
else:
proto = peers.PeerSeeds()
if "type" in request.args and request.args["type"][0] == "vendors":
for node in nodes:
if node.vendor is True:
peer = peers.PeerData()
peer.ip_address = node.ip
peer.port = node.port
peer.vendor = node.vendor
proto.peer_data.append(peer.SerializeToString())
sig = signing_key.sign("".join(proto.peer_data))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
else:
for node in nodes[:50]:
peer = peers.PeerData()
peer.ip_address = node.ip
peer.port = node.port
peer.vendor = node.vendor
proto.peer_data.append(peer.SerializeToString())
sig = signing_key.sign("".join(proto.peer_data))[:64]
proto.signature = sig
uncompressed_data = proto.SerializeToString()
request.write(uncompressed_data.encode("zlib"))
request.finish()
return server.NOT_DONE_YET
server_protocol = server.Site(WebResource(kserver))
reactor.listenTCP(8080, server_protocol)
reactor.run()
def __init__(self, guid, port):
super(OBNode, self).__init__()
self.listen_on_here(port)
self.dynamic_ip = stun.get_ip_info()[1]
self.saveState()
def startProtocol(self):
"""
This method describe information for starting protocol.
"""
self.sendDatagram('[False, "Client 911", %s]' % str(stun.get_ip_info()[1:]))
reactor.callInThread(self.connectionSupport)
def run(*args):
TESTNET = args[0]
LOGLEVEL = args[1]
PORT = args[2]
ALLOWIP = args[3]
SSL = args[4]
RESTPORT = args[5]
WSPORT = args[6]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log",
rotateLength=15000000,
maxRotatedFiles=1)
log.addObserver(FileLogObserver(logFile, level=LOGLEVEL).emit)
log.addObserver(FileLogObserver(level=LOGLEVEL).emit)
logger = Logger(system="OpenBazaard")
# NAT traversal
p = PortMapper()
p.add_port_mapping(PORT, PORT, "UDP")
logger.info("Finding NAT Type...")
while True:
# sometimes the stun server returns a code the client
# doesn't understand so we have to try again
try:
response = stun.get_ip_info(source_port=PORT)
break
except Exception:
pass
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
ip_address = response[1]
port = response[2]
if response[0] == "Full Cone":
nat_type = FULL_CONE
elif response[0] == "Restric NAT":
nat_type = RESTRICTED
else:
nat_type = SYMMETRIC
def on_bootstrap_complete(resp):
logger.info("bootstrap complete")
mserver.get_messages(mlistener)
task.LoopingCall(check_unfunded_for_payment, db, libbitcoin_client,
nlistener, TESTNET).start(600)
protocol = OpenBazaarProtocol(
(ip_address, port),
nat_type,
testnet=TESTNET,
relaying=True if nat_type == FULL_CONE else False)
# kademlia
storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE)
relay_node = None
if nat_type != FULL_CONE:
for seed in SEEDS:
try:
relay_node = (socket.gethostbyname(seed[0].split(":")[0]),
28469 if TESTNET else 18469)
break
except socket.gaierror:
pass
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address,
port, protocol, db, nat_type, relay_node,
on_bootstrap_complete, storage)
except Exception:
node = Node(keys.guid, ip_address, port, keys.guid_signed_pubkey,
relay_node, nat_type,
Profile(db).get().vendor)
protocol.relay_node = node.relay_node
kserver = Server(node, db, KSIZE, ALPHA, storage=storage)
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(
kserver.querySeed(SEEDS)).addCallback(on_bootstrap_complete)
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
class OnlyIP(Site):
def __init__(self, resource, ip, timeout=60 * 60 * 1):
self.ip = ip
Site.__init__(self, resource, timeout=timeout)
def buildProtocol(self, addr):
if addr.host == self.ip:
return Site.buildProtocol(self, addr)
return None
# websockets api
if SSL:
ws_factory = WSFactory("wss://127.0.0.1:" + str(WSPORT),
mserver,
kserver,
only_ip=ALLOWIP)
contextFactory = ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT)
ws_factory.protocol = WSProtocol
listenWS(ws_factory, contextFactory)
else:
ws_factory = WSFactory("ws://127.0.0.1:" + str(WSPORT),
mserver,
kserver,
only_ip=ALLOWIP)
ws_factory.protocol = WSProtocol
listenWS(ws_factory)
if ALLOWIP != "127.0.0.1" and ALLOWIP != "0.0.0.0":
ws_interface = "0.0.0.0"
else:
ws_interface = ALLOWIP
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(WSPORT - 1, web, interface=ws_interface)
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
if ALLOWIP != "127.0.0.1" and ALLOWIP != "0.0.0.0":
rest_interface = "0.0.0.0"
site = OnlyIP(api, ALLOWIP, timeout=None)
else:
rest_interface = ALLOWIP
site = Site(api, timeout=None)
if SSL:
reactor.listenSSL(RESTPORT,
site,
ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT),
interface=rest_interface)
else:
reactor.listenTCP(RESTPORT, site, interface=rest_interface)
# blockchain
if TESTNET:
libbitcoin_client = LibbitcoinClient(
LIBBITCOIN_SERVER_TESTNET, log=Logger(service="LibbitcoinClient"))
else:
libbitcoin_client = LibbitcoinClient(
LIBBITCOIN_SERVER, log=Logger(service="LibbitcoinClient"))
# listeners
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
mlistener = MessageListenerImpl(ws_factory, db)
mserver.protocol.add_listener(mlistener)
blistener = BroadcastListenerImpl(ws_factory, db)
mserver.protocol.add_listener(blistener)
protocol.set_servers(ws_factory, libbitcoin_client)
logger.info("Startup took %s seconds" %
str(round(time.time() - args[7], 2)))
reactor.run()
def run(*args):
TESTNET = args[0]
LOGLEVEL = args[1]
PORT = args[2]
ALLOWIP = args[3]
SSL = args[4]
RESTPORT = args[5]
WSPORT = args[6]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log", rotateLength=15000000, maxRotatedFiles=1)
log.addObserver(FileLogObserver(logFile, level=LOGLEVEL).emit)
log.addObserver(FileLogObserver(level=LOGLEVEL).emit)
logger = Logger(system="OpenBazaard")
# NAT traversal
p = PortMapper()
threading.Thread(target=p.add_port_mapping, args=(PORT, PORT, "UDP")).start()
logger.info("Finding NAT Type...")
while True:
# sometimes the stun server returns a code the client
# doesn't understand so we have to try again
try:
response = stun.get_ip_info(source_port=PORT)
break
except Exception:
pass
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
nat_type = response[0]
ip_address = response[1]
port = response[2]
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
logger.info("bootstrap complete")
mserver.get_messages(mlistener)
task.LoopingCall(check_unfunded_for_payment, db, libbitcoin_client, nlistener, TESTNET).start(600)
protocol = OpenBazaarProtocol((ip_address, port), response[0], testnet=TESTNET)
# kademlia
node = Node(keys.guid, ip_address, port, signed_pubkey=keys.guid_signed_pubkey, vendor=Profile(db).get().vendor)
storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db,
on_bootstrap_complete, storage=storage)
except Exception:
kserver = Server(node, db, KSIZE, ALPHA, storage=storage)
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(kserver.querySeed(SEED)).addCallback(on_bootstrap_complete)
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
if nat_type != "Full Cone":
kserver.protocol.ping(SEED_NODE_TESTNET if TESTNET else SEED_NODE)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
class OnlyIP(Site):
def __init__(self, resource, ip, timeout=60 * 60 * 1):
self.ip = ip
Site.__init__(self, resource, timeout=timeout)
def buildProtocol(self, addr):
if addr.host == self.ip:
return Site.buildProtocol(self, addr)
return None
# websockets api
if SSL:
ws_factory = WSFactory("wss://127.0.0.1:" + str(WSPORT), mserver, kserver, only_ip=ALLOWIP)
contextFactory = ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT)
ws_factory.protocol = WSProtocol
listenWS(ws_factory, contextFactory)
else:
ws_factory = WSFactory("ws://127.0.0.1:" + str(WSPORT), mserver, kserver, only_ip=ALLOWIP)
ws_factory.protocol = WSProtocol
listenWS(ws_factory)
if ALLOWIP != "127.0.0.1" and ALLOWIP != "0.0.0.0":
ws_interface = "0.0.0.0"
else:
ws_interface = ALLOWIP
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(WSPORT - 1, web, interface=ws_interface)
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
if ALLOWIP != "127.0.0.1" and ALLOWIP != "0.0.0.0":
rest_interface = "0.0.0.0"
site = OnlyIP(api, ALLOWIP, timeout=None)
else:
rest_interface = ALLOWIP
site = Site(api, timeout=None)
if SSL:
reactor.listenSSL(RESTPORT, site, ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT), interface=rest_interface)
else:
reactor.listenTCP(RESTPORT, site, interface=rest_interface)
# blockchain
if TESTNET:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER_TESTNET, log=Logger(service="LibbitcoinClient"))
else:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER, log=Logger(service="LibbitcoinClient"))
# listeners
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
mlistener = MessageListenerImpl(ws_factory, db)
mserver.protocol.add_listener(mlistener)
blistener = BroadcastListenerImpl(ws_factory, db)
mserver.protocol.add_listener(blistener)
protocol.set_servers(ws_factory, libbitcoin_client)
logger.info("Startup took %s seconds" % str(round(time.time() - args[7], 2)))
reactor.run()
def run(*args):
TESTNET = args[0]
SSL = args[5]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log", rotateLength=15000000, maxRotatedFiles=1)
log.addObserver(FileLogObserver(logFile, level=args[1]).emit)
log.addObserver(FileLogObserver(level=args[1]).emit)
logger = Logger(system="OpenBazaard")
# NAT traversal
port = args[2]
PortMapper().add_port_mapping(port, port, 'UDP')
logger.info("Finding NAT Type...")
while True:
try:
response = stun.get_ip_info(source_port=port)
break
except Exception:
pass
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
ip_address = response[1]
port = response[2]
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
logger.info("bootstrap complete, downloading outstanding messages...")
mserver.get_messages(mlistener)
# TODO: ping seed node to establish connection if not full cone NAT
# TODO: after bootstrap run through any pending contracts and see if the bitcoin address
# has been funded, if not listen on the address and start the 10 minute delete timer.
protocol = OpenBazaarProtocol((ip_address, port), response[0], testnet=TESTNET)
# kademlia
node = Node(keys.guid, ip_address, port, signed_pubkey=keys.guid_signed_pubkey, vendor=Profile(db).get().vendor)
storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db,
on_bootstrap_complete, storage=storage)
except Exception:
kserver = Server(node, db, KSIZE, ALPHA, storage=storage)
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(kserver.querySeed(SEED)).addCallback(on_bootstrap_complete)
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
class OnlyIP(Site):
def __init__(self, resource, ip, timeout=60 * 60 * 1):
self.ip = ip
Site.__init__(self, resource, timeout=timeout)
def buildProtocol(self, addr):
if addr.host == self.ip:
return Site.buildProtocol(self, addr)
return None
# websockets api
if SSL:
ws_factory = WSFactory("wss://127.0.0.1:18466", mserver, kserver)
contextFactory = ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory, contextFactory)
else:
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
if args[4] != "127.0.0.1" and args[4] != "0.0.0.0":
ws_interface = "0.0.0.0"
web = OnlyIP(webdir, args[4])
else:
ws_interface = args[4]
web = Site(webdir)
reactor.listenTCP(18465, web, interface=ws_interface)
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
if args[3] != "127.0.0.1" and args[3] != "0.0.0.0":
rest_interface = "0.0.0.0"
site = OnlyIP(api, args[3], timeout=None)
else:
rest_interface = args[3]
site = Site(api, timeout=None)
if SSL:
reactor.listenSSL(18469, site, ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT), interface=rest_interface)
else:
reactor.listenTCP(18469, site, interface=rest_interface)
# blockchain
if TESTNET:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER_TESTNET)
else:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER)
def heartbeat():
f = HeartbeatFactory(libbitcoin_client)
if TESTNET:
reactor.connectTCP(LIBBITCOIN_SERVER_TESTNET[6: LIBBITCOIN_SERVER_TESTNET.index(":", 6)], 9092, f)
else:
reactor.connectTCP(LIBBITCOIN_SERVER[6: LIBBITCOIN_SERVER.index(":", 6)], 9092, f)
task.LoopingCall(heartbeat).start(300)
# listeners
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
mlistener = MessageListenerImpl(ws_factory, db)
mserver.protocol.add_listener(mlistener)
blistener = BroadcastListenerImpl(ws_factory, db)
mserver.protocol.add_listener(blistener)
protocol.set_servers(ws_factory, libbitcoin_client)
reactor.run()
def check_stun(host_ip):
return stun.get_ip_info(stun_host=host_ip)
def run(*args):
TESTNET = args[0]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
# TODO: prune this log file and prevent it from getting too large?
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(log.FileLogObserver(logFile).emit)
log.startLogging(sys.stdout)
# stun
# TODO: accept port from command line
port = 18467 if not TESTNET else 28467
print "Finding NAT Type.."
# TODO: maintain a list of backup STUN servers and try them if ours fails
response = stun.get_ip_info(stun_host="seed.openbazaar.org",
source_port=port)
print "%s on %s:%s" % (response[0], response[1], response[2])
ip_address = response[1]
port = response[2]
# TODO: try UPnP if restricted NAT
# TODO: maintain open connection to seed node if STUN/UPnP fail
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
mlistener = MessageListenerImpl(ws_factory, db)
mserver.get_messages(mlistener)
mserver.protocol.add_listener(mlistener)
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET)
# kademlia
node = Node(keys.guid,
ip_address,
port,
signed_pubkey=keys.guid_signed_pubkey)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle',
ip_address,
port,
protocol,
db,
on_bootstrap_complete,
storage=PersistentStorage(db.DATABASE))
except Exception:
kserver = Server(node,
db,
KSIZE,
ALPHA,
storage=PersistentStorage(db.DATABASE))
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(
kserver.querySeed("seed.openbazaar.org:8080",
"ddd862778e3ed71af06db0e3619a4c6269ec7468c745132dbb73982b319fc572"))\
.addCallback(on_bootstrap_complete)
# TODO: load seeds from config file
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
# websockets api
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(9000, web, interface="127.0.0.1")
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
site = Site(api, timeout=None)
reactor.listenTCP(18469, site, interface="127.0.0.1")
# TODO: add optional SSL on rest and websocket servers
# blockchain
# TODO: listen on the libbitcoin heartbeat port instead fetching height
def height_fetched(ec, height):
print "Libbitcoin server online"
try:
timeout.cancel()
except Exception:
pass
def timeout(client):
print "Libbitcoin server offline"
client = None
if TESTNET:
libbitcoin_client = obelisk.ObeliskOfLightClient(
"tcp://libbitcoin2.openbazaar.org:9091")
else:
libbitcoin_client = obelisk.ObeliskOfLightClient(
"tcp://libbitcoin1.openbazaar.org:9091")
# TODO: load libbitcoin server url from config file
libbitcoin_client.fetch_last_height(height_fetched)
timeout = reactor.callLater(5, timeout, libbitcoin_client)
protocol.set_servers(ws_factory, libbitcoin_client)
reactor.run()
def run(*args):
TESTNET = args[0]
LOGLEVEL = args[1]
PORT = args[2]
ALLOWIP = args[3]
SSL = args[4]
RESTPORT = args[5]
WSPORT = args[6]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log", rotateLength=15000000, maxRotatedFiles=1)
log.addObserver(FileLogObserver(logFile, level=LOGLEVEL).emit)
log.addObserver(FileLogObserver(level=LOGLEVEL).emit)
logger = Logger(system="OpenBazaard")
# NAT traversal
p = PortMapper()
p.add_port_mapping(PORT, PORT, "UDP")
logger.info("Finding NAT Type...")
while True:
# sometimes the stun server returns a code the client
# doesn't understand so we have to try again
try:
response = stun.get_ip_info(source_port=PORT)
break
except Exception:
pass
logger.info("%s on %s:%s" % (response[0], response[1], response[2]))
ip_address = response[1]
port = response[2]
if response[0] == "Full Cone":
nat_type = FULL_CONE
elif response[0] == "Restric NAT":
nat_type = RESTRICTED
else:
nat_type = SYMMETRIC
def on_bootstrap_complete(resp):
logger.info("bootstrap complete")
mserver.get_messages(mlistener)
task.LoopingCall(check_unfunded_for_payment, db, libbitcoin_client, nlistener, TESTNET).start(600)
protocol = OpenBazaarProtocol((ip_address, port), nat_type, testnet=TESTNET,
relaying=True if nat_type == FULL_CONE else False)
# kademlia
storage = ForgetfulStorage() if TESTNET else PersistentStorage(db.DATABASE)
relay_node = None
if nat_type != FULL_CONE:
for seed in SEEDS:
try:
relay_node = (socket.gethostbyname(seed[0].split(":")[0]),
28469 if TESTNET else 18469)
break
except socket.gaierror:
pass
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db,
nat_type, relay_node, on_bootstrap_complete, storage)
except Exception:
node = Node(keys.guid, ip_address, port, keys.guid_signed_pubkey,
relay_node, nat_type, Profile(db).get().vendor)
protocol.relay_node = node.relay_node
kserver = Server(node, db, KSIZE, ALPHA, storage=storage)
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(kserver.querySeed(SEEDS)).addCallback(on_bootstrap_complete)
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
interface = "0.0.0.0" if ALLOWIP not in ("127.0.0.1", "0.0.0.0") else ALLOWIP
# websockets api
ws_api = WSFactory(mserver, kserver, only_ip=ALLOWIP)
if SSL:
reactor.listenSSL(RESTPORT, WebSocketFactory(ws_api),
ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT), interface=interface)
else:
reactor.listenTCP(WSPORT, WebSocketFactory(ws_api), interface=interface)
# rest api
rest_api = RestAPI(mserver, kserver, protocol, only_ip=ALLOWIP)
if SSL:
reactor.listenSSL(RESTPORT, rest_api, ChainedOpenSSLContextFactory(SSL_KEY, SSL_CERT), interface=interface)
else:
reactor.listenTCP(RESTPORT, rest_api, interface=interface)
# blockchain
if TESTNET:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER_TESTNET, log=Logger(service="LibbitcoinClient"))
else:
libbitcoin_client = LibbitcoinClient(LIBBITCOIN_SERVER, log=Logger(service="LibbitcoinClient"))
# listeners
nlistener = NotificationListenerImpl(ws_api, db)
mserver.protocol.add_listener(nlistener)
mlistener = MessageListenerImpl(ws_api, db)
mserver.protocol.add_listener(mlistener)
blistener = BroadcastListenerImpl(ws_api, db)
mserver.protocol.add_listener(blistener)
protocol.set_servers(ws_api, libbitcoin_client)
logger.info("Startup took %s seconds" % str(round(time.time() - args[7], 2)))
reactor.run()
db.add("port_mappings", [(port, "UDP"), (port + 1, "UDP")])
try:
external_addr = u.external_addr()
except Exception, e:
logging.warning(
"Cannot fetch external address via uPnP: {0}".format(e))
except Exception, e:
logging.error("Cannot import UPNP class or port map is busy -> audit.")
## Do STUN probing - !
logging.info("Sending STUN probe...")
try:
import stun
nat_type, external_ip, external_port = stun.get_ip_info()
logging.info(
"""STUN probe results:\n
[+] NAT: {0}
[+] External IP: {1}:{2}
""".format(nat_type, external_ip, external_port))
db.add("nat_type", nat_type)
db.add("external_ip", external_ip)
db.add("external_port", port) ## audit for stun/turn port map
except Exception, e:
logging.error("STUN probing failed: {0}".format(e))
## start tftp receiver
p = Process(target=tftp_server, args=(port + 1, "./tasks"))
def get_network_adresses(self):
"""
:return: (internal ip, external ip)
"""
return self.upnpc.lanaddr, stun.get_ip_info()[1]
def run(*args):
TESTNET = args[0]
# database
db = Database(TESTNET)
# key generation
keys = KeyChain(db)
# logging
# TODO: prune this log file and prevent it from getting too large?
logFile = logfile.LogFile.fromFullPath(DATA_FOLDER + "debug.log")
log.addObserver(log.FileLogObserver(logFile).emit)
log.startLogging(sys.stdout)
# stun
# TODO: accept port from command line
port = 18467 if not TESTNET else 28467
print "Finding NAT Type.."
# TODO: maintain a list of backup STUN servers and try them if ours fails
response = stun.get_ip_info(stun_host="seed.openbazaar.org", source_port=port)
print "%s on %s:%s" % (response[0], response[1], response[2])
ip_address = response[1]
port = response[2]
# TODO: try UPnP if restricted NAT
# TODO: maintain open connection to seed node if STUN/UPnP fail
# TODO: use TURN if symmetric NAT
def on_bootstrap_complete(resp):
mlistener = MessageListenerImpl(ws_factory, db)
mserver.get_messages(mlistener)
mserver.protocol.add_listener(mlistener)
nlistener = NotificationListenerImpl(ws_factory, db)
mserver.protocol.add_listener(nlistener)
# TODO: after bootstrap run through any pending contracts and see if the bitcoin address
# has been funded, if not listen on the address and start the 10 minute delete timer.
protocol = OpenBazaarProtocol((ip_address, port), testnet=TESTNET)
# kademlia
node = Node(keys.guid, ip_address, port, signed_pubkey=keys.guid_signed_pubkey)
try:
kserver = Server.loadState(DATA_FOLDER + 'cache.pickle', ip_address, port, protocol, db,
on_bootstrap_complete, storage=PersistentStorage(db.DATABASE))
except Exception:
kserver = Server(node, db, KSIZE, ALPHA, storage=PersistentStorage(db.DATABASE))
kserver.protocol.connect_multiplexer(protocol)
kserver.bootstrap(
kserver.querySeed("seed.openbazaar.org:8080",
"5b44be5c18ced1bc9400fe5e79c8ab90204f06bebacc04dd9c70a95eaca6e117"))\
.addCallback(on_bootstrap_complete)
# TODO: load seeds from config file
kserver.saveStateRegularly(DATA_FOLDER + 'cache.pickle', 10)
protocol.register_processor(kserver.protocol)
# market
mserver = network.Server(kserver, keys.signing_key, db)
mserver.protocol.connect_multiplexer(protocol)
protocol.register_processor(mserver.protocol)
reactor.listenUDP(port, protocol)
# websockets api
ws_factory = WSFactory("ws://127.0.0.1:18466", mserver, kserver)
ws_factory.protocol = WSProtocol
ws_factory.setProtocolOptions(allowHixie76=True)
listenWS(ws_factory)
webdir = File(".")
web = Site(webdir)
reactor.listenTCP(9000, web, interface="127.0.0.1")
# rest api
api = OpenBazaarAPI(mserver, kserver, protocol)
site = Site(api, timeout=None)
reactor.listenTCP(18469, site, interface="127.0.0.1")
# TODO: add optional SSL on rest and websocket servers
# blockchain
# TODO: listen on the libbitcoin heartbeat port instead fetching height
def height_fetched(ec, height):
# TODO: re-broadcast any unconfirmed txs in the db using height to find confirmation status
print "Libbitcoin server online"
try:
timeout.cancel()
except Exception:
pass
def timeout(client):
print "Libbitcoin server offline"
client = None
if TESTNET:
libbitcoin_client = LibbitcoinClient("tcp://libbitcoin2.openbazaar.org:9091")
else:
libbitcoin_client = LibbitcoinClient("tcp://libbitcoin1.openbazaar.org:9091")
# TODO: load libbitcoin server url from config file
libbitcoin_client.fetch_last_height(height_fetched)
timeout = reactor.callLater(5, timeout, libbitcoin_client)
protocol.set_servers(ws_factory, libbitcoin_client)
reactor.run()
if check_transparent_proxy():
result |= TRANSPARENT | PROXY
else:
headers = external_headers()
for header in headers:
if 'via' in header.lower():
result |= PROXY
break
deip = dns_external_ip()
if deip:
result |= DIRECT_DNS
try:
nat, _, _ = stun.get_ip_info()
for bit, descr in STUN_NAT_DESCRIPTION.iteritems():
if descr == nat:
result |= bit
break
except Exception, e:
logger.debug('STUN Checks failed: %s', e)
result |= STUN_NAT_BLOCKED
try:
offset = ntp_time_diff()
result |= NTP
if offset > 32767:
offset = 32767
elif offset < -32768:
