def upcall(self, kind, upcallInfo):
if kind == pyccn.UPCALL_CONTENT or kind == pyccn.UPCALL_CONTENT_UNVERIFIED:
print 'G on data'
co = upcallInfo.ContentObject
device_prefix = co.content.strip(
' \t\n\r') + '/device/siemens/' + serial
#how to append serial
#register prefix device_name
print device_prefix
InterestBaseName = pyccn.Name(device_prefix).append('pubkey')
configclosure = ConfigClosure(device_prefix) ###################
handler0.setInterestFilter(InterestBaseName, configclosure)
m = hashlib.sha256()
m.update(symkey)
m.update(device_prefix)
#iv = Random.new().read(AES.block_size)
#cipher = AES.new(symkey, AES.MODE_CBC, iv)
#ciphertext = cipher.encrypt(pad(m.hexdigest()))
instname = pyccn.Name('/local/manager' + device_prefix).append(
m.hexdigest())
#configclosure1 = ConfigClosure()
handler0.expressInterest(instname, configclosure, interest_tmpl0)
elif kind == pyccn.UPCALL_INTEREST_TIMED_OUT:
print 'interest time out'
return pyccn.RESULT_REEXPRESS
return pyccn.RESULT_OK
def update_acl(self, index):
self.device[index]['acl_name'] = pyccn.Name(
self.device[index]['acl_name']).components
co_name = pyccn.Name(self.device[index]['acl_name']
[0:len(self.device[index]['acl_name']) -
1]).appendVersion()
print 'publish acl to repo'
print str(co_name)
self.device[index]['acl_name'] = str(co_name)
content = json.dumps({'acl': self.device[index]['acl']}) ##
co = pyccn.ContentObject(name=co_name,
content=content,
signed_info=pyccn.SignedInfo(
self.key.publicKeyID,
pyccn.KeyLocator(self.keyname)))
co.sign(self.key)
self.publisher.put(co)
if (self.device[index]['loc_name'] != None):
inst_name = pyccn.Name(
self.device[index]['loc_name']).append('acl')
aclclosure = ConfigClosure(self)
handler.expressInterest(inst_name, aclclosure, interest_tmpl)
print 'manager expressInterest'
print inst_name
def getLatestVersion(self, name):
try:
return self.m_keyCache[str(name)]
except:
pass
base_len = len(name)
excludeList = []
version = 0
co = None
while True:
interestName = pyccn.Name(name)
exclude1 = pyccn.ExclusionFilter()
exclude1.add_names([pyccn.Name().append(n) for n in excludeList])
interest_tmpl = pyccn.Interest(exclude=exclude1,
interestLifetime=self.args.timeout,
minSuffixComponents=1,
maxSuffixComponents=100,
scope=self.args.scope)
class Slurp(pyccn.Closure):
def __init__(self):
self.finished = False
self.done = False
def upcall(self, kind, upcallInfo):
if kind == pyccn.UPCALL_CONTENT or kind == pyccn.UPCALL_CONTENT_UNVERIFIED:
self.co = upcallInfo.ContentObject
if len(self.co.name) == base_len:
self.done = True
else:
excludeList.append(self.co.name[base_len])
elif kind == pyccn.UPCALL_INTEREST_TIMED_OUT:
self.done = True
self.finished = True
return pyccn.RESULT_OK
slurp = Slurp()
self.ccn.expressInterest(interestName, slurp, interest_tmpl)
while not slurp.finished:
# print slurp.finished
self.ccn.run(1)
if slurp.done:
# print "Done with %s" % interestName
break
try:
newversion = pyccn.Name.seg2num(slurp.co.name[len(name)])
if newversion > version:
version = newversion
co = slurp.co
except:
print "ERROR: Unversioned content object: %s" % interestName
return None
self.m_keyCache[str(name)] = co
return co
def upcall(self, kind, upcallInfo):
if kind == pyccn.UPCALL_CONTENT or kind == pyccn.UPCALL_CONTENT_UNVERIFIED:
co = upcallInfo.ContentObject
#how to decript
print 'G on data'
co_content = json.loads(co.content)
txt = co_content['ciphertxt']
#iv = encrypted_content[0:16]
#ciphertxt = encrypted_content[16:len(encrypted_content)]
#decipher = AES.new(symkey, AES.MODE_CBC, iv)
#txt = unpad(decipher.decrypt(ciphertxt))
m = hashlib.sha256()
m.update(symkey)
m.update(co_content['uncripted'])
if txt == m.hexdigest() and self.logger == None:
content = json.loads(co_content['uncripted'])
print 'content'
print content
aclname = pyccn.Name(str(content['acl_name']))
print aclname
self.logger = SensorDataLogger(1000, content['trust_anchor'],
content['prefix'])
aclclosure = AclClosure(self.logger, self.device_prefix)
handler0.expressInterest(aclname, aclclosure, interest_tmpl0)
InterestBaseName = pyccn.Name(self.device_prefix).append('acl')
print InterestBaseName
handler0.setInterestFilter(InterestBaseName, aclclosure)
elif kind == pyccn.UPCALL_INTEREST:
print 'G on interest'
interest = upcallInfo.Interest
print interest.name
pubkey = ksk.publicToDER()
#iv = Random.new().read(AES.block_size)
m = hashlib.sha256()
m.update(symkey)
m.update(pubkey)
digest = m.hexdigest()
#cipher = AES.new(symkey, AES.MODE_CBC, iv)
#cipherkey = cipher.encrypt(pad(digest))
print 'digest'
print digest
sendpubkey = pyccn.Key()
sendpubkey.fromDER(public=pubkey)
co = pyccn.ContentObject(
name=interest.name,
content=digest,
signed_info=pyccn.SignedInfo(
ksk.publicKeyID,
pyccn.KeyLocator(sendpubkey),
type=pyccn.CONTENT_KEY,
final_block=b'\x00')) ####################
co.sign(ksk)
handler0.put(co)
elif kind == pyccn.UPCALL_INTEREST_TIMED_OUT:
return pyccn.RESULT_REEXPRESS
return pyccn.RESULT_OK
def GenerateAcl(self):
j = 0
for device in self.device:
k = 3
name_t = pyccn.Name(device['prefix'])
while (k <= len(name_t.components)):
temp = str(pyccn.Name(name_t.components[0:k]))
if ((temp in self.acl_tree) == True):
for acl_t in self.acl_tree[temp]['acl']:
self.device[j]['acl'].append(acl_t)
k = k + 1
j = j + 1
def FormAclTree(self):
self.acl_tree = dict([('/ndn/ucla.edu/bms',{'acl':[],'child':['/ndn/ucla.edu/bms/melnitz','/ndn/ucla.edu/bms/boelter']}), \
('/ndn/ucla.edu/bms/melnitz',{'acl':[],'child':['/ndn/ucla.edu/bms/melnitz/1405']}), \
('/ndn/ucla.edu/bms/boelter',{'acl':[],'child':['/ndn/ucla.edu/bms/boelter/4805','/ndn/ucla.edu/bms/boelter/4809']}), \
('/ndn/ucla.edu/bms/melnitz/1405',{'acl':[],'child':[]}), \
('/ndn/ucla.edu/bms/boelter/4805',{'acl':[],'child':[]}), \
('/ndn/ucla.edu/bms/boelter/4809',{'acl':[],'child':[]})])
for usr in usrlist:
for prefix in usr['prefix']:
name_t = pyccn.Name(prefix)
if (len(name_t.components) > 5):
name_t = pyccn.Name(name_t.components[0:5])
if ((str(name_t) in self.acl_tree) == True):
self.acl_tree[str(name_t)]['acl'].append(usr['usrname'])
def build_interest(self, latest):
if self.start_with_latest:
latest = True
self.start_with_latest = False
excl = pyccn.ExclusionFilter()
excl.add_any()
excl.add_name(pyccn.Name([self.latest_version]))
# expected result should be between those two names
excl.add_name(pyccn.Name([self.last_version_marker]))
excl.add_any()
interest = pyccn.Interest(name = self.base_name, exclude = excl, \
minSuffixComponents = 3, maxSuffixComponents = 3)
interest.childSelector = 1 if latest else 0
return interest
def __init__(self, publisher, uri):
freshness = 30 * 60
self._chunk_size = 3900
self._segment = 0
self._caps = None
self.publisher = publisher
self._basename = pyccn.Name(uri)
self._name_segments = self._basename.append("segments")
self._name_frames = self._basename.append("index")
self._name_key = self._basename.append("key")
self._key = pyccn.CCN.getDefaultKey()
self._signed_info = pyccn.SignedInfo(self._key.publicKeyID,
pyccn.KeyLocator(self._name_key),
freshness=freshness)
self._signed_info_frames = pyccn.SignedInfo(self._key.publicKeyID,
pyccn.KeyLocator(
self._name_key),
freshness=freshness)
self._segmenter = DataSegmenter(self.send_data, self._chunk_size)
signed_info = pyccn.SignedInfo(self._key.publicKeyID,
pyccn.KeyLocator(self._key),
freshness=freshness)
co = pyccn.ContentObject(self._name_key, self._key.publicToDER(),
signed_info)
co.sign(self._key)
self.publisher.put(co)
def fetch_seek_query(self, ns):
index = self.ts2index_add_1(ns)
#debug(self, "Fetching segment number before %s" % index)
interest = pyccn.Interest(publisherPublicKeyDigest=self.publisher_id,
childSelector=1,
answerOriginKind=pyccn.AOK_NONE)
interest.exclude = pyccn.ExclusionFilter()
interest.exclude.add_name(pyccn.Name([index]))
interest.exclude.add_any()
#debug(self, "Sending interest to %s" % self._name_frames)
#debug(self, "Exclusion list %s" % interest.exclude)
while True:
co = self._get_handle.get(self._name_frames, interest)
if co:
break
debug(self, "Timeout while seeking %d, retrying ..." % (ns))
debug(self, "Got segment: %s" % co.content)
index = co.name[-1]
segment = int(co.content)
return (self.index2ts(index), segment)
def AddUser(self, user):
for prefix in user['prefix']:
name_t = pyccn.Name(str(prefix))
if (len(name_t.components) > 5):
name_t = pyccn.Name(name_t.components[0:5])
name_str = str(name_t)
if ((name_str in self.acl_tree) == True):
self.acl_tree[name_str]['acl'].append(user['usrname'])
#len_name = len(name_t.components)
self.node = []
self.find_device(name_str)
for device_name in self.node:
index = self.findbyprefix(device_name)
if (index != -1):
self.device[index]['acl'].append(user['usrname'])
self.update_acl(index)
def __init__(self, prefix, handle):
self.prefix = pyccn.Name(prefix)
self.handle = handle
self.content_objects = []
self.cleanup_time = 15 * 60 # keep responses for 15 min
handle.setInterestFilter(self.prefix, self)
def __init__(self, acl, key, timestamp, dsk, dsk_si, anchor, prefix):
self.kds_key = dsk
self.kds_si = dsk_si
self.prefix = pyccn.Name(prefix)
self.symkey = key
self.acl = acl
self.index = 0
self.timestamp = timestamp
self.publisher = RepoSocketPublisher(12345)
self.anchors = anchor
#self.acl = acl
print 'acl'
print acl
#[{'name':'/ndn/ucla.edu/bms/%C1.M.K%00%03a%27%95_%7C%1F%CD%C0E%2B54%00%87%AC%84r%DBg%83%07%5D%F9%03%02p%DB%A9%B8%06%B4','namespace': '/ndn/ucla.edu/bms', 'pubkey': \
# '0\x81\x9f0\r\x06\t*\x86H\x86\xf7\r\x01\x01\x01\x05\x00\x03\x81\x8d\x000\x81\x89\x02\x81\x81\x00\xd8\xe8\xa76\xbe|\x99\x1f\x0eO\x8e\xbel\xc1\xed\xfd-p\x8b>\xb1\x0f-\x1b\xf7z#j\xba\x9c\x0c\xa0\x9bh\x08\xfbg\xab\x89\xc7\xb5\xc5\xdb\xde\x90H\xee(F\x17\x86\xaf\xd6O\x12`\x00\xd2)n\x95\x14IV\x1e\xa6\xf4+\xa4\xed1z\x801\x1d\x7f\xbe\xcf3\xd3\xbc\xa7\x83\xda\xe6\x13~\x1e\xc3\xb6\x86\xae\xc96\x16\x8e":c\xa4eg\x11\x85\xa2\xff\xae\xa1\xe4\xc6s28W3\'S.\x87\xc5\x94\'\xf7\x90\xa9\x888c\x02\x03\x01\x00\x01' \
#}]
self.rules = [
#rule for 'users' sub-namespace
{
'key_pat':
re.compile("^(/ndn/ucla.edu/bms/users)/%C1.M.K[^/]+$"),
'key_pat_ext': 0,
'data_pat':
re.compile("^(/ndn/ucla.edu/bms/users(?:/[^/]+)*)$"),
'data_pat_ext': 0
}
]
self.stack = []
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 packet(name, data, key):
co = pyccn.ContentObject()
co.name = pyccn.Name(name)
co.content = data
co.signedInfo.publisherPublicKeyDigest = key.publicKeyID
co.signedInfo.keyLocator = pyccn.KeyLocator(key)
co.sign(key)
return co
def upcall(self, kind, upcallInfo):
if kind == pyccn.UPCALL_CONTENT or kind == pyccn.UPCALL_CONTENT_UNVERIFIED:
co = upcallInfo.ContentObject
root_key = pyccn.Key()
root_key.fromPEM(public=self.logger.anchor[0]['pubkey'])
flag = co.verify_signature(root_key)
if flag == True:
if co.name.components[len(co.name.components) - 1] == 'acl':
print 'getting acl name'
inst_name = pyccn.Name(str(co.content))
handler0.expressInterest(inst_name, self, interest_tmpl)
elif co.name.components[len(co.name.components) - 2] == 'acl':
print 'getting acl'
if self.logger.acl == None:
self.logger.acl = json.loads(co.content)['acl']
self.logger.start()
else:
#self.logger.lock.acquire()
self.logger.acl = json.loads(co.content)['acl']
#self.logger.lock.release()
kds_prefix = str(self.logger.prefix.append('kds'))
kds_thread = kds.KDSPublisher(
key, time_s, self.logger.kds_dsk,
self.logger.kds_si, self.logger.anchor,
self.logger.acl, kds_prefix) #,self.logger.lock)
kds_thread.start()
#I need to trigger the kds to fetch symkey########
#self.logger.join()
elif kind == pyccn.UPCALL_INTEREST:
interest = upcallInfo.Interest
content = 'received'
co = pyccn.ContentObject(name=interest.name,
content=content,
signed_info=pyccn.SignedInfo(
ksk.publicKeyID,
pyccn.KeyLocator(
self.logger.ksk_name)))
co.sign(ksk)
handler0.put(co)
inst_name = pyccn.Name('/local/manager' +
self.device_prefix).append('acl')
handler0.expressInterest(inst_name, self, interest_tmpl0)
elif kind == pyccn.UPCALL_INTEREST_TIMED_OUT:
return pyccn.RESULT_REEXPRESS
return pyccn.RESULT_OK
def make_content(name):
global key
co = pyccn.ContentObject()
co.name = pyccn.Name(name)
co.signedInfo.publisherPublicKeyDigest = key.publicKeyID
co.sign(key)
return co
def upcall(self, kind, upcallInfo):
if kind == pyccn.UPCALL_FINAL:
# any cleanup code here (so far I never had need for
# this call type)
return pyccn.RESULT_OK
if kind == pyccn.UPCALL_INTEREST_TIMED_OUT:
print("Got timeout!")
return pyccn.RESULT_OK
# make sure we're getting sane responses
if not kind in [
pyccn.UPCALL_CONTENT, pyccn.UPCALL_CONTENT_UNVERIFIED,
pyccn.UPCALL_CONTENT_BAD
]:
print("Received invalid kind type: %d" % kind)
sys.exit(100)
matched_comps = upcallInfo.matchedComps
response_name = upcallInfo.ContentObject.name
org_prefix = response_name[:matched_comps]
assert (org_prefix == self.root)
if matched_comps == len(response_name):
comp = pyccn.Name([upcallInfo.ContentObject.digest()])
disp_name = pyccn.Name(response_name)
else:
comp = response_name[matched_comps:matched_comps + 1]
disp_name = response_name[:matched_comps + 1]
if kind == pyccn.UPCALL_CONTENT_BAD:
print("*** VERIFICATION FAILURE *** %s" % response_name)
print("%s [%s]" % (disp_name, \
"verified" if kind == pyccn.UPCALL_CONTENT else "unverified"))
self.exclusions.add_name(comp)
self.express_my_interest()
# explore next level
if matched_comps + 1 < len(response_name):
new = Slurp(response_name[:matched_comps + 1], self.handle)
new.express_my_interest()
return pyccn.RESULT_OK
def check_duration(self):
interest = pyccn.Interest(childSelector=1)
if self._duration_last:
interest.exclude = pyccn.ExclusionFilter()
interest.exclude.add_any()
interest.exclude.add_name(pyccn.Name([self._duration_last]))
self._handle.expressInterest(self._name_frames,
self._duration_callback, interest)
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 put(self, content):
name = str(self._sequence)
self._sequence += 1
of = open(os.path.join(self.import_loc, name), "wb")
of.write(_pyccn.dump_charbuf(content.ccn_data))
of.close()
self.handle.expressInterest(pyccn.Name(self.name + name), self,
self.interest_tpl)
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 decoder(self, device_name, serial, code, test,
flag): #decoding using the symkey
k = 0
for info in self.device:
if (info['name'] == device_name and info['serial'] == serial):
#iv0 = code[0:16]
#print iv0
#decipher = AES.new(info['symkey'], AES.MODE_CBC, iv0)
#text = unpad(decipher.decrypt(code[16:len(code)]))
m = hashlib.sha256()
m.update(info['symkey'])
m.update(test)
digest = m.hexdigest()
if code == digest:
if flag == 'interest' and self.device[k][
'loc_name'] == None:
self.device[k]['loc_name'] = test
content = {
'acl_name':
info['acl_name'],
'prefix':
info['prefix'],
'trust_anchor': [{
'name':
str(self.keyname),
'namespace':
str(
pyccn.Name(self.keyname.components[
0:len(self.keyname.components) - 1])),
'pubkey':
str(self.key.publicToPEM())
}]
}
print content
txt = json.dumps(content)
#iv = Random.new().read(AES.block_size)
m = hashlib.sha256()
m.update(info['symkey'])
m.update(txt)
#cipher = AES.new(info['symkey'], AES.MODE_CBC, iv)
#ciphertxt = cipher.encrypt(pad(m.hexdigest()))
sendtxt = json.dumps({
'uncripted': txt,
'ciphertxt': m.hexdigest()
})
return sendtxt
elif flag == 'data' and self.device[k]['pubkey'] == None:
self.device[k]['pubkey'] = test
return info['prefix']
else:
print "decode failure"
return None
k = k + 1
return None
def __init__(self):
self.key = pyccn.Key()
self.key.fromPEM(filename='./keychain/keys/bms_root.pem')
self.keyname = pyccn.Name('/ndn/ucla.edu/bms').appendKeyID(self.key)
self.publisher = RepoSocketPublisher(12345)
self.device = device
self.usrlist = usrlist
self.acl_count = 1
self.acl_tree = None
self.FormAclTree()
self.GenerateAcl()
self.dsk = pyccn.Key()
self.dsk.fromPEM(filename='./keychain/keys/user_root.pem')
self.dskname = pyccn.Name('/ndn/ucla.edu/bms/users').appendKeyID(
self.dsk)
i = 0
while i < len(self.device): #add version
self.device[i]['acl_name'] = str(
pyccn.Name(self.device[i]['acl_name']).appendVersion())
i = i + 1
def authorizeKey(self, dataName, keyName):
if len(keyName) < 1:
return {
"authorized":
False,
"formattedName":
"%s%s: %s%s" %
(bcolors.FAIL, "Invalid key name", str(keyName), bcolors.ENDC)
}
if len(dataName) <= len(keyName) - 1:
return {
"authorized":
False,
"formattedName":
"%s%s: %s%s" %
(bcolors.FAIL, "Invalid key name", str(keyName), bcolors.ENDC)
}
keyBase = str(keyName[:-1])
dataBase = str(
dataName[0:len(keyName) - 1]
) # this has to be this way (it's keyName length, not dataName length)
if keyBase == dataBase:
return {
"authorized":
True,
"formattedName":
"%s[AUTH KEY]%s %s%s%s%s" %
(bcolors.OKBLUE, bcolors.ENDC, bcolors.OKGREEN, keyBase,
bcolors.ENDC, str(pyccn.Name().append(keyName[-1])))
}
else:
return {
"authorized":
False,
"formattedName":
"%s[WRONG KEY] %s%s%s" %
(bcolors.FAIL, keyBase, bcolors.ENDC,
str(pyccn.Name().append(keyName[-1])))
}
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, 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 __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 main(args):
gobject.threads_init()
if len(args) not in [3, 4]:
usage(args[0])
return 1
uri = pyccn.Name(args[1])
mode = []
mode += args[2]
pidfile = "publish.pid" if len(args) == 3 else args[3]
uri = uri.appendVersion()
video_pipe = """v4l2src device=%s ! video/x-raw-yuv,width=%d,height=%d ! aspectratiocrop aspect-ratio=4/3 !
deinterlace mode=1 method=4 fields=top ! videorate ! timeoverlay shaded-background=true valignment=bottom ! \
clockoverlay shaded-background=true halignment=right valignment=bottom !
x264enc byte-stream=true bitrate=%d qp-max=30 interlaced=true ! VideoSink location=%s"""
audio_pipe = "autoaudiosrc ! lamemp3enc bitrate=%d ! AudioSink location=%s"
pipes = {}
pipes['a'] = audio_pipe % (128, uri + "audio")
pipes['v'] = video_pipe % ("/dev/video0", 704, 480, 1024, uri + "video")
pipes['1'] = video_pipe % ("/dev/video1", 352, 240, 256, uri + "video1")
pipes['2'] = video_pipe % ("/dev/video2", 352, 240, 256, uri + "video2")
pipes['3'] = video_pipe % ("/dev/video3", 352, 240, 256, uri + "video3")
pipes['4'] = video_pipe % ("/dev/video4", 352, 240, 256, uri + "video4")
p = []
for m in mode:
p.append(pipes[m])
of = open(pidfile, "w")
of.write(str(os.getpid()))
of.close()
pipeline = gst.parse_launch(" ".join(p))
loop = gobject.MainLoop()
pipeline.set_state(gst.STATE_PLAYING)
try:
loop.run()
except KeyboardInterrupt:
print "Ctrl+C pressed; exiting"
pass
pipeline.set_state(gst.STATE_NULL)
pipeline.get_state(gst.CLOCK_TIME_NONE)
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")
