def test_05(self, llc):
"""Undeliverable resource"""
payload = bytearray(range(122 - 29))
records = [ndef.Record("application/octet-stream", "1", payload)]
ndef_message_sent = b''.join(ndef.message_encoder(records))
max_ndef_msg_recv_size = len(ndef_message_sent) - 1
snep = nfc.snep.SnepClient(llc, max_ndef_msg_recv_size)
try:
info("connect to {0}".format(validation_server))
snep.connect(validation_server)
except nfc.llcp.ConnectRefused:
raise cli.TestFail("could not connect to validation server")
try:
info("put {0} octets ndef message".format(len(ndef_message_sent)))
snep.put_octets(ndef_message_sent)
info(
"request ndef message with max acceptable lenght of {} octets".
format(max_ndef_msg_recv_size))
identifier = ndef.Record("application/octet-stream", "1")
identifier = b''.join(ndef.message_encoder([identifier]))
try:
snep.get_octets(identifier)
except nfc.snep.SnepError as e:
if e.errno != nfc.snep.ExcessData:
raise cli.TestFail("received unexpected response code")
info("received 'excess data' response as expected")
else:
raise cli.TestFail("received unexpected message from server")
finally:
info("disconnect from {0}".format(validation_server))
snep.close()
def test_07(self, llc):
"""Default server limits"""
payload = bytearray(x % 256 for x in range(1024 - 32))
records = [ndef.Record("application/octet-stream", "1", payload)]
ndef_message = b''.join(ndef.message_encoder(records))
snep = nfc.snep.SnepClient(llc)
try:
info("connect to {0}".format("urn:nfc:sn:snep"))
snep.connect("urn:nfc:sn:snep")
except nfc.llcp.ConnectRefused:
raise cli.TestFail("could not connect to default server")
try:
info("put {0} octets ndef message".format(len(ndef_message)))
snep.put_octets(ndef_message)
identifier = ndef.Record("application/octet-stream", "1")
info("request ndef message {}".format(identifier))
identifier = b''.join(ndef.message_encoder([identifier]))
try:
ndef_message = snep.get_octets(identifier)
except nfc.snep.SnepError as e:
if e.errno != nfc.snep.NotImplemented:
raise cli.TestFail("received unexpected response code")
info("received 'not implemented' response as expected")
else:
raise cli.TestFail("received unexpected message from server")
finally:
info("disconnect from server")
snep.close()
def test_04(self, llc):
"""Multiple ndef messages"""
ndef_message_sent = list()
ndef_message_rcvd = list()
payload = bytearray(range(50))
records = [ndef.Record("application/octet-stream", "1", payload)]
ndef_message_sent.append(b''.join(ndef.message_encoder(records)))
records = [ndef.Record("application/octet-stream", "2", payload)]
ndef_message_sent.append(b''.join(ndef.message_encoder(records)))
snep = nfc.snep.SnepClient(llc, max_ndef_msg_recv_size=10000)
try:
info("connect to {0}".format(validation_server))
snep.connect(validation_server)
except nfc.llcp.ConnectRefused:
raise cli.TestFail("could not connect to validation server")
try:
info("put 1st ndef message")
snep.put_octets(ndef_message_sent[0])
info("put 2nd ndef message")
snep.put_octets(ndef_message_sent[1])
info("get 1st ndef message")
identifier = ndef.Record("application/octet-stream", "1")
identifier = b''.join(ndef.message_encoder([identifier]))
ndef_message = snep.get_octets(identifier)
ndef_message_rcvd.append(ndef_message)
info("get 2nd ndef message")
identifier = ndef.Record("application/octet-stream", "2")
identifier = b''.join(ndef.message_encoder([identifier]))
ndef_message = snep.get_octets(identifier)
ndef_message_rcvd.append(ndef_message)
for i in range(len(ndef_message_sent)):
if not ndef_message_rcvd == ndef_message_sent:
info("rcvd ndef message {0} differs".format(i))
raise cli.TestFail("rcvd message {0} differs".format(i))
else:
info("rcvd message {0} is correct".format(i))
except Exception as e:
raise cli.TestFail("exception " + str(e))
finally:
info("disconnect from {0}".format(validation_server))
snep.close()
def test_handover_initiate_record_attributes():
record = HandoverInitiateRecord()
record.add_alternative_carrier('active', 'wifi', 'a1', 'a2')
record.add_alternative_carrier('inactive', 'bt31', 'a3')
record.unknown_records.append(Record('text/plain', 'txt', 'Hello'))
octets = b''.join(message_encoder([record]))
record = list(message_decoder(octets))[0]
assert isinstance(record, HandoverInitiateRecord)
assert record.type == 'urn:nfc:wkt:Hi'
assert record.name == ''
assert record.hexversion == 0x13
assert record.version_info == (1, 3)
assert record.version_string == "1.3"
assert len(record.alternative_carriers) == 2
assert len(record.alternative_carriers[0].auxiliary_data_reference) == 2
assert len(record.alternative_carriers[1].auxiliary_data_reference) == 1
assert record.alternative_carriers[0].carrier_power_state == 'active'
assert record.alternative_carriers[0].carrier_data_reference == 'wifi'
assert record.alternative_carriers[0].auxiliary_data_reference[0] == 'a1'
assert record.alternative_carriers[0].auxiliary_data_reference[1] == 'a2'
assert record.alternative_carriers[1].carrier_power_state == 'inactive'
assert record.alternative_carriers[1].carrier_data_reference == 'bt31'
assert record.alternative_carriers[1].auxiliary_data_reference[0] == 'a3'
assert len(record.unknown_records) == 1
assert record.unknown_records[0].type == 'text/plain'
assert record.unknown_records[0].name == 'txt'
assert record.unknown_records[0].data == b'Hello'
def encode_message(data):
"""creates an ndef encoding to write to the card, needs a data of a certain type to encode it to ndef format"""
print(f"trying to encode {data}")
# encode characters to bytes
databin = data.encode('utf-8')
# print(databin)
# ndeflib example
## check when encoding for data type
# if isinstance(data, str):
# record = ndef.new_message(data)
# elif isinstance:
record = ndef.new_message(data)
# no clue yet why below works as it does. the last line actually returns / yields the record from the previous line
encoder = ndef.message_encoder()
encoder.send(None)
encoder.send(record)
payload = encoder.send(None)
# payload = ndef.message_encoder(record)
# print(f"encoded paylorecord = ndef.new_message(data)ad = {payload}")
return payload
def test_06(self, llc):
"""Unavailable resource"""
snep = nfc.snep.SnepClient(llc)
try:
info("connect to {0}".format(validation_server))
snep.connect(validation_server)
except nfc.llcp.ConnectRefused:
raise cli.TestFail("could not connect to validation server")
try:
identifier = ndef.Record("application/octet-stream", "na")
info("request ndef message {}".format(identifier))
identifier = b''.join(ndef.message_encoder([identifier]))
try:
snep.get_octets(identifier)
except nfc.snep.SnepError as e:
if e.errno != nfc.snep.NotFound:
raise cli.TestFail("received unexpected response code")
info("received 'not found' response as expected")
else:
raise cli.TestFail("received unexpected message from server")
finally:
info("disconnect from {0}".format(validation_server))
snep.close()
def test_message_encoder_with_record_send(encoded, message):
stream = BytesIO()
octets = bytes(bytearray.fromhex(encoded))
encoder = ndef.message_encoder(stream=stream)
encoder.send(None)
for record in message:
encoder.send(record)
encoder.send(None)
assert stream.getvalue() == octets
def send_records(self, records):
"""Send handover request message records to the remote server."""
log.debug("sending '{0}' message".format(records[0].type))
try:
octets = b''.join(ndef.message_encoder(records))
except ndef.EncodeError as error:
log.error(repr(error))
else:
return self.send_octets(octets)
def create_ndef(message,encoding):
record = ndef.Record('urn:nfc:ext:ln','invoice', bytes(message,encoding))
print("Record: {}".format(record))
encoder = ndef.message_encoder()
encoder.send(None)
encoder.send(record)
# A none message must be sent for the last
message = encoder.send(None)
return message
def send_message(args, llc, message):
t0 = time.time() if args.timeit else None
if not nfc.snep.SnepClient(llc).put_records(message):
log.error("failed to send message")
if t0 is not None:
transfer_time = time.time() - t0
message_size = len(b''.join(ndef.message_encoder(message)))
print("message sent in {0:.3f} seconds ({1} byte @ {2:.0f} byte/sec)".
format(transfer_time, message_size,
message_size / transfer_time))
def put_records(self, records, timeout=1.0):
"""Send NDEF message records to a SNEP Server.
.. versionadded:: 0.13
The :class:`ndef.Record` list given by *records* is encoded
and then send via :meth:`put_octets`. Same as::
import ndef
octets = ndef.message_encoder(records)
snep_client.put_octets(octets, timeout)
"""
octets = b''.join(ndef.message_encoder(records))
return self.put_octets(octets, timeout)
def _process_request_data(self, octets):
log.debug("<<< %s", binascii.hexlify(octets).decode())
try:
records = list(ndef.message_decoder(octets, 'relax'))
except ndef.DecodeError as error:
log.error(repr(error))
return b''
if records[0].type == 'urn:nfc:wkt:Hr':
records = self.process_handover_request_message(records)
else:
log.error("received unknown request message")
records = []
octets = b''.join(ndef.message_encoder(records))
log.debug(">>> %s", binascii.hexlify(octets).decode())
return octets
def get_records(self, records=None, timeout=1.0):
"""Get NDEF message records from a SNEP Server.
.. versionadded:: 0.13
The :class:`ndef.Record` list given by *records* is encoded as
the request message octets input to :meth:`get_octets`. The
return value is an :class:`ndef.Record` list decoded from the
response message octets returned by :meth:`get_octets`. Same
as::
import ndef
send_octets = ndef.message_encoder(records)
rcvd_octets = snep_client.get_octets(send_octets, timeout)
records = list(ndef.message_decoder(rcvd_octets))
"""
octets = b''.join(ndef.message_encoder(records)) if records else None
octets = self.get_octets(octets, timeout)
if octets and len(octets) >= 3:
return list(ndef.message_decoder(octets))
def encode_message_text(array_of_strings):
"""
Receives an array of strings and returns a message that contains these in a bytearray that can be transferred to a NFC tag.
"""
print(f"Array of strings send: {array_of_strings}")
# create list of ndef records
message = []
for string in array_of_strings:
message += [ndef.TextRecord(string)]
print(f"NDEF Records created: {message}")
# create ndef encoder generator
encoder = ndef.message_encoder(message)
# convert ndef encoder to payload octets
payload = b''.join(encoder)
print(f"NDEF payload created: {payload}")
return payload
def process_snep_request(self, request_data):
assert isinstance(request_data, bytearray)
log.debug("<<< %s", binascii.hexlify(request_data).decode())
try:
if request_data[1] == 1 and len(request_data) >= 10:
acceptable_length = struct.unpack(">L", request_data[6:10])[0]
octets = request_data[10:]
records = list(ndef.message_decoder(octets, known_types={}))
response = self.process_get_request(records)
if isinstance(response, int):
response_code = response
response_data = b''
else:
response_code = 0x81 # nfc.snep.Success
response_data = b''.join(ndef.message_encoder(response))
if len(response_data) > acceptable_length:
response_code = 0xC1 # nfc.snep.ExcessData
response_data = b''
elif request_data[1] == 2:
octets = request_data[6:]
records = list(ndef.message_decoder(octets, known_types={}))
response_code = self.process_put_request(records)
response_data = b''
else:
log.debug("bad request (0x{:02x})".format(request_data[1]))
response_code = 0xC2 # nfc.snep.BadRequest
response_data = b''
except ndef.DecodeError as error:
log.error(repr(error))
response_code = 0xC2 # nfc.snep.BadRequest
response_data = b''
except ndef.EncodeError as error:
log.error(repr(error))
response_code = 0xC0 # nfc.snep.NotFound
response_data = b''
header = struct.pack(">BBL", 0x10, response_code, len(response_data))
response_data = header + response_data
log.debug(">>> %s", binascii.hexlify(response_data).decode())
return response_data
def cmd(ctx, message, **kwargs):
"""The *payload* command either changes the current last record's
data (NDEF Record PAYLOAD) or, if the current message does
not have any records, creates a record with the given record
data. The changed record is verified to successfully encode and
decode unless disabled with -x.
The data string may contain hexadecimal bytes using '\\xNN'
notation where each N is a nibble from [0-F].
\b
Examples:
ndeftool payload 'Hello World' typename 'text/plain' print
ndeftool payload '\\x02enHello World' typename 'urn:nfc:wkt:T' print -l
"""
dmsg(__name__ + ' ' + str(kwargs))
dmsg(repr(kwargs['data']))
if not message:
message = [ndef.Record('unknown')]
record_type = message[-1].type
record_name = message[-1].name
record_data = eval(repr(kwargs['data'].encode()).replace('\\\\', '\\'))
record = ndef.Record(record_type, record_name, record_data)
if not kwargs['no_check']:
octets = b''.join(ndef.message_encoder([record]))
errors = ctx.meta['decode-errors']
try:
record = next(ndef.message_decoder(octets, errors))
except ndef.DecodeError as error:
raise click.ClickException(str(error))
message[-1] = record
return message
def cmd(ctx, message, **kwargs):
"""The *typename* command either changes the current last record's
type (NDEF Record TNF and TYPE) or, if the current message does
not have any records, creates a record with the given record
type. The changed record is verified to successfully encode and
decode unless disabled with -x.
\b
Examples:
ndeftool typename 'text/plain' print
ndeftool typename 'text/plain' payload 'Hello World' print
"""
dmsg(__name__ + ' ' + str(kwargs))
if not message:
message = [ndef.Record()]
record_type = kwargs['type'].encode('latin', 'replace')
record_name = message[-1].name
record_data = message[-1].data
try:
record = ndef.Record(record_type, record_name, record_data)
except ValueError as error:
raise click.ClickException(str(error))
if not kwargs['no_check']:
octets = b''.join(ndef.message_encoder([record]))
errors = ctx.meta['decode-errors']
try:
record = next(ndef.message_decoder(octets, errors))
except ndef.DecodeError as error:
raise click.ClickException(str(error))
message[-1] = record
return message
def run_recv_save_action(args, llc, message):
log.info('save ndef message {}'.format(message[0].type))
args.file.write(b''.join(ndef.message_encoder(message)))
def test_message_encoder_stop_iteration():
encoder = ndef.message_encoder()
encoder.send(None)
encoder.send(None)
with pytest.raises(StopIteration):
encoder.send(None)
def test_message_encoder_with_bytes_output(encoded, message):
octets = bytes(bytearray.fromhex(encoded))
assert b''.join(list(ndef.message_encoder(message))) == octets
def test_message_encode(encoded, message):
octets = bytes(bytearray.fromhex(encoded))
print(list(ndef.message_encoder(message)))
assert b''.join(list(ndef.message_encoder(message))) == octets
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('first_name')
parser.add_argument('last_name')
parser.add_argument('phone_number')
parser.add_argument('phone_personal')
parser.add_argument('email_address')
parser.add_argument('email_personal')
parser.add_argument('organization')
parser.add_argument('position')
parser.add_argument('policy')
args = parser.parse_args()
print(str(args))
vcard = vobject.vCard()
if args['first_name'] and args['last_name']:
vcard.add('n')
vcard.add('fn')
vcard.n.value = vobject.vcard.Name(family=args['last_name'],
given=args['first_name'])
vcard.fn.value = ' '.join([args['first_name'], args['last_name']])
elif args['first_name']:
vcard.add('n')
vcard.add('fn')
vcard.n.value = vobject.vcard.Name(given=args['first_name'])
vcard.fn.value = args['first_name']
elif args['last_name']:
vcard.add('n')
vcard.add('fn')
vcard.n.value = vobject.vcard.Name(family=args['last_name'])
vcard.fn.value = args['last_name']
if args['phone_number']:
vcard.add('tel')
#vcard.tel.value = ''.join(['+7', args['phone_number']])
vcard.tel.value = args['phone_number']
if args['phone_personal']:
vcard.tel.type_param = 'CELL'
else:
vcard.tel.type_param = 'WORK'
if args['email_address']:
vcard.add('email')
vcard.email.value = args['email_address']
if args['email_personal']:
vcard.email.type_param = 'HOME'
else:
vcard.email.type_param = 'WORK'
if args['organization']:
vcard.add('org')
vcard.org.value[0] = args['organization']
if args['position']:
vcard.add('title')
vcard.title.value = args['position']
vcard_newlines = '\n'.join(vcard.serialize().splitlines())
if args['policy']:
with open('/usr/src/app/vcards/' + str(uuid.uuid4()) + '.vcf',
'w') as f:
f.write(vcard_newlines)
vcard_bytes = bytes(vcard_newlines, 'utf-8')
ndf_record = ndef.Record(type='text/vcard', name='', data=vcard_bytes)
ndef_data = b''.join(ndef.message_encoder([ndf_record]))
device = NTAGWriter()
try:
device.write_ndef_message(ndef_data)
except NTAGWriterError as e:
return e, 500
return 'Written', 201
def test_message_encode(encoded, message):
octets = bytes(bytearray.fromhex(encoded))
print(list(ndef.message_encoder(message)))
assert b''.join(list(ndef.message_encoder(message))) == octets
def test_message_encoder_with_stream_output(encoded, message):
stream = BytesIO()
octets = bytes(bytearray.fromhex(encoded))
assert sum(ndef.message_encoder(message, stream)) == len(octets)
assert stream.getvalue() == octets
def cmd(ctx, message, **kwargs):
"""The *save* command writes the current records to disk. The records
to write can be restricted to the subset selected with '--skip',
'--count', '--head' and '--tail' applied in that order. The
default mode is to save all selected records as one NDEF message
into a single file given by PATH. In '--burst' mode each record is
written as one NDEF message into a separate file under the
directory given by PATH. The file names are three digit numbers
created from the record index. In '--unpack' mode the payload of
each record is written to a separate file under directory PATH
with the file name set to the record name (NDEF Record ID).
Records without name are not written unless '--unpack' and
'--burst' are both set.
The *save* command does not replace existing files or directories
unless this is requested with '--force'.
The *save* command consumes records from the internal message
pipe. This can be prevented with '--keep', all records are then
forwarded to the next command or written to standard output. When
*save* is the first command it creates the pipe by reading from
standard input.
\b
Examples:
ndeftool text 'Hello World' save text.ndef
ndeftool text 'Hello World' | ndeftool save text.ndef
ndeftool text 'One' save one.ndef text 'Two' save two.ndef
"""
dmsg(__name__ + ' ' + str(kwargs))
path = kwargs['path']
if os.path.exists(path) and not kwargs['force']:
errmsg = "path '%s' exists. Use '--force' to replace."
raise click.ClickException(errmsg % path)
if message is None:
info("Reading data from standard input")
octets = click.get_binary_stream('stdin').read()
errors = ctx.meta['decode-errors']
try:
message = list(ndef.message_decoder(octets, errors))
except ndef.DecodeError as error:
raise click.ClickException(str(error))
first = min(kwargs['skip'], len(message))
count = min(kwargs['count'] or len(message), len(message))
head = min(kwargs['head'] or count, count)
tail = min(kwargs['tail'] or count, count)
dmsg("first=%d count=%d head=%d tail=%d" % (first, count, head, tail))
count = min(head, tail, len(message) - first)
first = first + head - min(head, tail)
dmsg("first=%d count=%d head=%d tail=%d" % (first, count, head, tail))
if kwargs['burst'] or kwargs['unpack']:
path = os.path.normpath(path)
try:
if os.path.isdir(path):
shutil.rmtree(path)
os.mkdir(path)
except (OSError, IOError) as error:
raise click.ClickException(str(error))
for index, record in enumerate(message[first:first + count]):
name = None
if kwargs['unpack'] and record.name:
name = record.name
if kwargs['burst'] and not name:
name = '%03d.ndef' % index
if name:
with click.open_file('%s/%s' % (path, name), 'wb') as f:
info("Saving 1 record to {}.".format(f.name))
if kwargs['unpack']:
f.write(record.data)
else:
f.write(b''.join(ndef.message_encoder([record])))
else:
warn("Skipping 1 record without name")
else:
with click.open_file(path, 'wb') as f:
filename = f.name if f.name != '-' else '<stdout>'
info("Saving {num} record{s} to {path}.".format(
num=count, path=filename, s=('', 's')[count > 1]))
f.write(b''.join(ndef.message_encoder(message[first:first +
count])))
if not kwargs['keep']:
del message[first:first + count]
return message
def ndef_octets(self):
uri = 'http://www.abcdefghijklmnopqrstuvwxyzabcdefg.com'
return b''.join(ndef.message_encoder([ndef.UriRecord(uri)]))
def ndef_octets(self):
uri = "http://www." + 17 * "abcdefghijklmnopqrstuvwxyz" + "abcdefg.com"
return b''.join(ndef.message_encoder([ndef.UriRecord(uri)]))
def test_fail_message_encoder_invalid_types(argument, errmsg):
with pytest.raises(TypeError) as excinfo:
list(ndef.message_encoder(argument))
assert errmsg == str(excinfo.value)
def records(self, value):
self.octets = b''.join(message_encoder(value))
def records(self, value):
self.octets = b''.join(message_encoder(value))
def process_commands(processors, **kwargs):
message = None
for processor in processors:
message = processor(message)
dmsg('records = ' + str(message))
echo(b''.join(ndef.message_encoder(message)), nl=False)
