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()