def __init__(self, uri):
self._handle = pyccn.CCN()
self._get_handle = pyccn.CCN()
self._uri = pyccn.Name(uri)
self._name_segments = self._uri.append('segments')
self._name_frames = self._uri.append('frames')
self._pipeline = utils.PipelineFetch(100, self.issue_interest,
self.handle_data)
def __init__(self, uri, window=None, retries=None):
# size of the pipeline
window = window or 1
# how many times to retry request
self.interest_retries = retries or 1
# maximum number of buffers we can hold in memory waiting to be processed
self.queue = Queue.Queue(window * 2)
# duration of the stream (in nanoseconds)
self.duration_ns = None
# interest timeout
self.interest_lifetime = None
# whether fetching thread is running
self._running = False
# caps of the stream
self._caps = None
# timestamp of the remote machine
self._start_time = None
self._seek_segment = None
self._duration_last = None
self._cmd_q = Queue.Queue(2)
self._handle = pyccn.CCN()
self._get_handle = pyccn.CCN()
self._uri = pyccn.Name(uri)
self._name_segments = self._uri + 'segments'
self._name_frames = self._uri + 'index'
self._pipeline = utils.PipelineFetch(window, self.issue_interest,
self.process_response)
self._segmenter = DataSegmenter(self.push_data)
self._stats = {
'srtt': 0.05,
'rttvar': 0.01 \
}
self._stats_retries = 0
self._stats_drops = 0
self._timing_clock_diff = None
self._timing_pause_diff = 0
self._tmp_retry_requests = {}
DurationChecker = type('DurationChecker', (pyccn.Closure, ),
dict(upcall=self.duration_process_result))
self._duration_callback = DurationChecker()
def get_latest_version(name):
n = pyccn.Name(name)
i = pyccn.Interest(childSelector=1, answerOriginKind=pyccn.AOK_NONE)
handle = pyccn.CCN()
co = handle.get(n, i)
if co is None:
return None
return co.name[:len(n) + 1]
def __init__(self, uri, sink):
self._sink = sink
self._handle = pyccn.CCN()
self._basename = pyccn.Name(uri)
self._name_segments = self._basename.append("segments")
self._name_frames = self._basename.append("frames")
self._key = self._handle.getDefaultKey()
self._flow_controller = utils.FlowController(self._basename, self._handle)
self._signed_info = pyccn.SignedInfo(self._key.publicKeyID, pyccn.KeyLocator(self._key))
self._signed_info_frames = pyccn.SignedInfo(self._key.publicKeyID, pyccn.KeyLocator(self._key))
def get_latest_version(name, publisher_id):
n = pyccn.Name(name)
i = pyccn.Interest(publisherPublicKeyDigest=publisher_id,
childSelector=1,
answerOriginKind=pyccn.AOK_NONE)
handle = pyccn.CCN()
co = handle.get(n, i)
if co is None:
return None, None
return co.name[:len(n) + 1], co.signedInfo.publisherPublicKeyDigest
def __init__(self, repo_port=None):
if not repo_port:
if not os.environ.has_key('CCNR_STATUS_PORT'):
raise Exception(
"CCNR_STATUS_PORT not defined and no repo port specified")
repo_port = os.environ['CCNR_STATUS_PORT']
self.repo_dest = ('127.0.0.1', int(repo_port))
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect(self.repo_dest)
self.handle = pyccn.CCN()
def __init__(self, prefix, callback):
self.gui_callback = callback
self.friendly_names = {}
self.handle = pyccn.CCN()
self.chat_uri = pyccn.Name(prefix)
self.members_uri = self.chat_uri + "members"
self.net_pull = VersionedPull(self.chat_uri, None, handle=self.handle)
self.default_key = self.handle.getDefaultKey()
digest = fix_digest(self.default_key.publicKeyID)
self.friendly_names[digest] = getpass.getuser()
def __init__(self, prefix, nick=getpass.getuser()):
self.handle = pyccn.CCN()
self.flow = FlowController(prefix, self.handle)
#XXX: temporary, until we allow fetching key from key storage
self.key = self.handle.getDefaultKey()
self.keylocator = pyccn.KeyLocator(self.key)
self.prefix = pyccn.Name(prefix)
self.members_uri = self.prefix + "members"
member_name = self.members_uri.appendKeyID(
fix_digest(self.key.publicKeyID))
self.member_message = self.publish(member_name, nick)
self.flow.put(self.member_message)
def __init__(self, uri, sink):
self._sink = sink
self._handle = pyccn.CCN()
self._basename = pyccn.Name(uri)
self._name_segments = self._basename.append("segments")
self._name_frames = self._basename.append("frames")
self._key = self._handle.getDefaultKey()
self._signed_info = pyccn.SignedInfo(self._key.publicKeyID,
pyccn.KeyLocator(self._key))
self._signed_info_frames = pyccn.SignedInfo(
self._key.publicKeyID, pyccn.KeyLocator(self._key))
self._flow_controller = RepoPublisher(self._handle,
"/home/takeda/ccnx/repo")
def main(args):
if len(sys.argv) != 2:
usage()
name = pyccn.Name(sys.argv[1])
data = ccnb_enumerate(generate_names())
key = pyccn.CCN.getDefaultKey()
name = name.append('\xc1.E.be').appendKeyID(key).appendVersion()
wrapper = Wrapper(name, key)
sgmtr = segmenter(data, wrapper)
handle = pyccn.CCN()
for seg in sgmtr:
handle.put(seg)
return 0
def __init__(self,
base_name,
callback,
handle=None,
version=None,
latest=True):
handle = handle or pyccn.CCN()
# some constants
self.version_marker = '\xfd'
self.first_version_marker = self.version_marker
self.last_version_marker = '\xfe\x00\x00\x00\x00\x00\x00'
self.base_name = pyccn.Name(base_name)
self.callback = callback
self.handle = handle
self.latest_version = version or self.first_version_marker
self.start_with_latest = latest
import random
import kds
from pyccn import _pyccn
import binascii
from Crypto.Cipher import AES
from Crypto import Random
from device_info import device
from pyccn import AOK_NONE
import hashlib
from user_list import usrlist
BS = 16
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
unpad = lambda s: s[0:-ord(s[-1])]
handler = pyccn.CCN()
interest_tmpl = pyccn.Interest(scope=2, answerOriginKind=AOK_NONE)
class RepoSocketPublisher(pyccn.Closure):
def __init__(self, repo_port):
self.repo_dest = ('127.0.0.1', int(repo_port))
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect(self.repo_dest)
def put(self, content):
self.sock.send(_pyccn.dump_charbuf(content.ccn_data))
class ConfigManager():
def __init__(self, name, content):
self.handle = pyccn.CCN()
self.name = pyccn.Name(name)
self.content = self.prepareContent(content,
self.handle.getDefaultKey())
import struct
import random
import kds
from pyccn import _pyccn
import binascii
from Crypto.Cipher import AES
from Crypto import Random
from pyccn import AOK_NONE
import hashlib
interest_tmpl = pyccn.Interest(scope=2,
childSelector=1,
answerOriginKind=AOK_NONE,
interestLifetime=1000.0)
interest_tmpl0 = pyccn.Interest(scope=2)
handler0 = pyccn.CCN()
flag_terminate0 = 0
BS = 16
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
unpad = lambda s: s[0:-ord(s[-1])]
keyFile = "./keychain/keys/boelter4809.pem"
key = binascii.unhexlify(
'14fe923dd3ac6e8945ea02e892db6b3192f2081cbab26b44147d308af58f5609')
time_s = None
ksk = pyccn.Key()
ksk.generateRSA(1024)
serial = '002'
help=
'''Maximum timeout for each fetching operation/Interest lifetime (default: 0.1s)'''
)
aparser.add_argument(
'-M',
'--no-meta',
dest='check_meta',
action='store_false',
default=True,
help='''Disable checking meta data (e.g., certificate expiration)''')
args = aparser.parse_args()
seq_num = 1
kv = verify.key_verifier(args)
ccn = pyccn.CCN()
while (seq_num > 0):
raw_input("Press Enter to send an Interest")
#interestName = pyccn.Name (args.c + "/" + repr(seq_num))
interestName = pyccn.Name(args.c)
interest_tmpl = pyccn.Interest(exclude=None,
interestLifetime=4.0,
minSuffixComponents=1,
maxSuffixComponents=100,
scope=args.scope)
class Slurp(pyccn.Closure):
def __init__(self):
self.finished = False
# SignedInfo
si = pyccn.SignedInfo()
si.type = pyccn.CONTENT_DATA
si.finalBlockID = pyccn.Name.num2seg(0)
si.publisherPublicKeyDigest = key.publicKeyID
si.keyLocator = keylocator
# ContentObject
co = pyccn.ContentObject()
co.content = content
co.name = co_name
co.signedInfo = si
co.sign(key)
return co
def callback(kind, info):
print(info.ContentObject.content)
fc = FlowController("/test", pyccn.CCN())
fc.put(publish('/test/1', 'one'))
fc.put(publish('/test/2', 'two'))
fc.put(publish('/test/3', 'three'))
vp = VersionedPull("/chat", callback)
el = pyccn.EventLoop(fc.handle, vp.handle)
while True:
vp.requestNext()
el.run_once()
time.sleep(1)
def __init__(self, args):
self.ccn = pyccn.CCN()
self.args = args
self.m_keyCache = {}
return bytes(x)
class sendMessage(threading.Thread):
def run(self):
po = Popen(['ccnput', '-x', '5', '-t', 'ENCR', 'ccnx:/messages/hello'],
stdin=PIPE)
po.communicate(arrgh("Hello everyone"))
# po.stdin.close()
po.wait()
thread = sendMessage()
name = pyccn.Name("ccnx:/messages/hello")
handle = pyccn.CCN()
thread.start()
co = handle.get(name)
thread.join()
print(co)
print(co.content)
print(type(co.content))
assert co.content == bytearray(b"Hello everyone")
print(co.name)
assert str(co.name) == "/messages/hello"
signedinfo = co.signedInfo
assert signedinfo.type == pyccn.CONTENT_ENCR
def __init__(self, root, handle=None):
self.root = pyccn.Name(root)
self.exclusions = pyccn.ExclusionFilter()
self.handle = handle or pyccn.CCN()
