def pack(self, packer: Packer) -> None:
self.data_name.pack(packer)
if self.data_value is None:
packer.pack_uint(0)
else:
packer.pack_uint(1)
self.data_value.pack(packer)
def pack(self, packer: Packer) -> None:
self.num_sponsored.pack(packer)
self.num_sponsoring.pack(packer)
packer.pack_uint(len(self.signer_sponsoring_i_ds))
for signer_sponsoring_i_d in self.signer_sponsoring_i_ds:
signer_sponsoring_i_d.pack(packer)
self.ext.pack(packer)
def pack(self, packer: Packer) -> None:
self.tx_set_hash.pack(packer)
self.close_time.pack(packer)
packer.pack_uint(len(self.upgrades))
for upgrade in self.upgrades:
upgrade.pack(packer)
self.ext.pack(packer)
def pack(self, packer: Packer) -> None:
if self.source_account is None:
packer.pack_uint(0)
else:
packer.pack_uint(1)
self.source_account.pack(packer)
self.body.pack(packer)
def pack(self, values):
metric = {
'hostname': '',
'spoof': 0,
'units': '',
'slope': 'both',
'tmax': 60,
'dmax': 0
}
metric.update(values)
if metric.get('spoof', False):
metric['spoof'] = 1
else:
metric['spoof'] = 0
metric['slope'] = SLOPE[metric['slope']]
for key in ('name', 'value', 'type'):
if key not in metric:
raise KeyError("Missing {0}".format(key))
if metric['type'] not in ('string', 'int8', 'uint8', 'int16', 'uint16',
'int32', 'uint32', 'float', 'double'):
raise TypeError("Invalid metric type")
convert = lambda v: v.encode() if isinstance(v, str) else v
metric = {key: convert(value) for key, value in metric.items()}
# Metadata
meta = Packer()
meta.pack_int(128)
meta.pack_string(metric['hostname'])
meta.pack_string(metric['name'])
meta.pack_int(int(metric['spoof']))
meta.pack_string(metric['type'])
meta.pack_string(metric['name'])
meta.pack_string(metric['units'])
meta.pack_int(metric['slope'])
meta.pack_uint(int(metric['tmax']))
meta.pack_uint(int(metric['dmax']))
# Group support
if 'group' in metric:
meta.pack_int(1)
meta.pack_string(b"GROUP")
meta.pack_string(metric['group'])
else:
meta.pack_int(0)
# Data
data = Packer()
data.pack_int(128 + 5)
data.pack_string(metric['hostname'])
data.pack_string(metric['name'])
data.pack_int(int(metric['spoof']))
data.pack_string(b"%s")
data.pack_string(bytes(metric['value']))
return meta.get_buffer(), data.get_buffer()
def secure_data(self, cred, data):
log_gss.debug("secure_data(%r)" % cred)
cred = cred.body
if cred.service == rpc_gss_svc_none or \
cred.gss_proc in (RPCSEC_GSS_INIT, RPCSEC_GSS_CONTINUE_INIT):
return data
p = Packer()
context = self._get_context(cred.handle)
try:
if cred.service == rpc_gss_svc_integrity:
# data = opaque[gss_seq_num+data] + opaque[checksum]
p.pack_uint(cred.seq_num)
data = p.get_buffer() + data
token = context.getMIC(data) # XXX BUG set qop
p.reset()
p.pack_opaque(data)
p.pack_opaque(token)
data = p.get_buffer()
elif cred.service == rpc_gss_svc_privacy:
# data = opaque[wrap([gss_seq_num+data])]
p.pack_uint(cred.seq_num)
data = p.get_buffer() + data
token = context.wrap(data) # XXX BUG set qop
p.reset()
p.pack_opaque(token)
data = p.get_buffer()
else:
# Can't get here, but doesn't hurt
log_gss.error("Unknown service %i for RPCSEC_GSS" % cred.service)
except gssapi.Error as e:
# XXX What now?
log_gss.warn("secure_data: gssapi call returned %s" % e.name)
raise
return data
def pack(self, packer: Packer) -> None:
if not self.fixed:
size = len(self.value)
packer.pack_uint(size)
else:
size = self.size
packer.pack_fopaque(size, self.value)
def secure_data(self, cred, data):
log_gss.debug("secure_data(%r)" % cred)
cred = cred.body
if cred.service == rpc_gss_svc_none or \
cred.gss_proc in (RPCSEC_GSS_INIT, RPCSEC_GSS_CONTINUE_INIT):
return data
p = Packer()
context = self._get_context(cred.handle)
try:
if cred.service == rpc_gss_svc_integrity:
# data = opaque[gss_seq_num+data] + opaque[checksum]
p.pack_uint(cred.seq_num)
data = p.get_buffer() + data
token = context.getMIC(data) # XXX BUG set qop
p.reset()
p.pack_opaque(data)
p.pack_opaque(token)
data = p.get_buffer()
elif cred.service == rpc_gss_svc_privacy:
# data = opaque[wrap([gss_seq_num+data])]
p.pack_uint(cred.seq_num)
data = p.get_buffer() + data
token = context.wrap(data) # XXX BUG set qop
p.reset()
p.pack_opaque(token)
data = p.get_buffer()
else:
# Can't get here, but doesn't hurt
log_gss.error("Unknown service %i for RPCSEC_GSS" %
cred.service)
except gssapi.Error as e:
# XXX What now?
log_gss.warn("secure_data: gssapi call returned %s" % e.name)
raise
return data
def pack(self, values):
metric = {
'hostname': '',
'spoof': 0,
'units': '',
'slope': 'both',
'tmax': 60,
'dmax': 0
}
metric.update(values)
if metric.get('spoof', False):
metric['spoof'] = 1
else:
metric['spoof'] = 0
metric['slope'] = SLOPE[metric['slope']]
for key in ('name', 'value', 'type'):
if key not in metric:
raise KeyError("Missing {0}".format(key))
if metric['type'] not in ('string', 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'float', 'double'):
raise TypeError("Invalid metric type")
convert = lambda v: v.encode() if isinstance(v, str) else v
metric = {key: convert(value) for key, value in metric.items()}
# Metadata
meta = Packer()
meta.pack_int(128)
meta.pack_string(metric['hostname'])
meta.pack_string(metric['name'])
meta.pack_int(int(metric['spoof']))
meta.pack_string(metric['type'])
meta.pack_string(metric['name'])
meta.pack_string(metric['units'])
meta.pack_int(metric['slope'])
meta.pack_uint(int(metric['tmax']))
meta.pack_uint(int(metric['dmax']))
# Group support
if 'group' in metric:
meta.pack_int(1)
meta.pack_string(b"GROUP")
meta.pack_string(metric['group'])
else:
meta.pack_int(0)
# Data
data = Packer()
data.pack_int(128 + 5)
data.pack_string(metric['hostname'])
data.pack_string(metric['name'])
data.pack_int(int(metric['spoof']))
data.pack_string(b"%s")
data.pack_string(bytes(metric['value']))
return meta.get_buffer(), data.get_buffer()
def pack(self, packer: Packer) -> None:
self.balance_id.pack(packer)
packer.pack_uint(len(self.claimants))
for claimant in self.claimants:
claimant.pack(packer)
self.asset.pack(packer)
self.amount.pack(packer)
self.ext.pack(packer)
def pack(self, packer: Packer) -> None:
self.quorum_set_hash.pack(packer)
packer.pack_uint(len(self.votes))
for vote in self.votes:
vote.pack(packer)
packer.pack_uint(len(self.accepted))
for accepted in self.accepted:
accepted.pack(packer)
def pack(self, packer: Packer) -> None:
self.threshold.pack(packer)
packer.pack_uint(len(self.validators))
for validator in self.validators:
validator.pack(packer)
packer.pack_uint(len(self.inner_sets))
for inner_set in self.inner_sets:
inner_set.pack(packer)
def pack(self, packer: Packer) -> None:
self.code.pack(packer)
if self.code == InflationResultCode.INFLATION_SUCCESS:
if self.payouts is None:
raise ValueError("payouts should not be None.")
packer.pack_uint(len(self.payouts))
for payout in self.payouts:
payout.pack(packer)
return
def pack(self, packer: Packer) -> None:
self.send_asset.pack(packer)
self.send_max.pack(packer)
self.destination.pack(packer)
self.dest_asset.pack(packer)
self.dest_amount.pack(packer)
packer.pack_uint(len(self.path))
for path in self.path:
path.pack(packer)
def send(self):
''' packs the Header vars into a buffer '''
unp = Packer()
unp.pack_uint(self.magic)
unp.pack_uint(self.version)
unp.pack_uint(self.msgid)
unp.pack_uint(self.msglen)
unp.pack_uint(0) # reply_addr y reply_port
unp.pack_uint(0) # reply_addr y reply_port
unp.pack_fstring(8, self.callsign.encode())
return unp.get_buffer()
def gmetric_write(NAME, VAL, TYPE, UNITS, SLOPE, TMAX, DMAX):
"""
Arguments are in all upper-case to match XML
"""
packer = Packer()
packer.pack_int(0) # type gmetric
packer.pack_string(TYPE)
packer.pack_string(NAME)
packer.pack_string(str(VAL))
packer.pack_string(UNITS)
packer.pack_int(slope_str2int[SLOPE]) # map slope string to int
packer.pack_uint(int(TMAX))
packer.pack_uint(int(DMAX))
return packer.get_buffer()
def _bytes_from_length(len, closing):
"""
The RPC standard calls for the length of a message to be sent as the least
significant 31 bits of an XDR encoded unsigned integer. The most
significant bit encodes a True/False bit which indicates that this message
will be the last.
"""
assert 0 <= len < 2**31
from xdrlib import Packer
if closing:
len += 2**31
packer = Packer()
packer.pack_uint(len)
return packer.get_buffer()
def __init__(self, stamp, machinename, uid, gid, gids):
if len(machinename) > 255:
raise SecError("machinename %s is too long" % machinename)
if len(gids) > 16:
raise SecError("gid array too long: %s" % str(gids))
try:
p = Packer()
p.pack_int(stamp)
p.pack_string(machinename)
p.pack_uint(uid)
p.pack_uint(gid)
p.pack_array(gids, p.pack_uint)
self.cred = p.get_buffer()
except Error, e:
raise SecError("Packing error: %s", str(e))
def __init__(self, stamp, machinename, uid, gid, gids):
if len(machinename) > 255:
raise SecError("machinename %s is too long" % machinename)
if len(gids) > 16:
raise SecError("gid array too long: %s" % str(gids))
try:
p = Packer()
p.pack_int(stamp)
p.pack_string(machinename)
p.pack_uint(uid)
p.pack_uint(gid)
p.pack_array(gids, p.pack_uint)
self.cred = p.get_buffer()
except Error, e:
raise SecError("Packing error: %s", str(e))
def sendV2Data(self, sock, address, value):
packer = Packer()
packer.pack_enum(0) # metric_user_defined
packer.pack_string(self.type)
packer.pack_string(self.name)
packer.pack_string(str(value))
packer.pack_string(self.units)
if self.slope == 'zero':
slope = 0
else:
slope = 3 # both
packer.pack_uint(slope)
packer.pack_uint(self.tmax)
packer.pack_uint(self.dmax)
sock.sendto(packer.get_buffer(), address)
def pack(self, packer: Packer) -> None:
self.code.pack(packer)
if (self.code == TransactionResultCode.txFEE_BUMP_INNER_SUCCESS
or self.code == TransactionResultCode.txFEE_BUMP_INNER_FAILED):
if self.inner_result_pair is None:
raise ValueError("inner_result_pair should not be None.")
self.inner_result_pair.pack(packer)
return
if (self.code == TransactionResultCode.txSUCCESS
or self.code == TransactionResultCode.txFAILED):
if self.results is None:
raise ValueError("results should not be None.")
packer.pack_uint(len(self.results))
for result in self.results:
result.pack(packer)
return
raise ValueError("Invalid code.")
def gmetric_write(NAME, VAL, TYPE, UNITS, SLOPE, TMAX, DMAX, GROUP, SPOOF):
"""
Arguments are in all upper-case to match XML
"""
packer = Packer()
HOSTNAME = "test"
if SPOOF == "":
SPOOFENABLED = 0
else:
SPOOFENABLED = 1
# Meta data about a metric
packer.pack_int(128)
if SPOOFENABLED == 1:
packer.pack_string(SPOOF)
else:
packer.pack_string(HOSTNAME)
packer.pack_string(NAME)
packer.pack_int(SPOOFENABLED)
packer.pack_string(TYPE)
packer.pack_string(NAME)
packer.pack_string(UNITS)
packer.pack_int(slope_str2int[SLOPE]) # map slope string to int
packer.pack_uint(int(TMAX))
packer.pack_uint(int(DMAX))
# Magic number. Indicates number of entries to follow. Put in 1 for GROUP
if GROUP == "":
packer.pack_int(0)
else:
packer.pack_int(1)
packer.pack_string("GROUP")
packer.pack_string(GROUP)
# Actual data sent in a separate packet
data = Packer()
data.pack_int(128 + 5)
if SPOOFENABLED == 1:
data.pack_string(SPOOF)
else:
data.pack_string(HOSTNAME)
data.pack_string(NAME)
data.pack_int(SPOOFENABLED)
data.pack_string("%s")
data.pack_string(str(VAL))
return (packer.get_buffer(), data.get_buffer())
def gmetric_write(NAME, VAL, TYPE, UNITS, SLOPE, TMAX, DMAX, GROUP, SPOOF):
"""
Arguments are in all upper-case to match XML
"""
packer = Packer()
HOSTNAME="test"
if SPOOF == "":
SPOOFENABLED=0
else :
SPOOFENABLED=1
# Meta data about a metric
packer.pack_int(128)
if SPOOFENABLED == 1:
packer.pack_string(SPOOF)
else:
packer.pack_string(HOSTNAME)
packer.pack_string(NAME)
packer.pack_int(SPOOFENABLED)
packer.pack_string(TYPE)
packer.pack_string(NAME)
packer.pack_string(UNITS)
packer.pack_int(slope_str2int[SLOPE]) # map slope string to int
packer.pack_uint(int(TMAX))
packer.pack_uint(int(DMAX))
# Magic number. Indicates number of entries to follow. Put in 1 for GROUP
if GROUP == "":
packer.pack_int(0)
else:
packer.pack_int(1)
packer.pack_string("GROUP")
packer.pack_string(GROUP)
# Actual data sent in a separate packet
data = Packer()
data.pack_int(128+5)
if SPOOFENABLED == 1:
data.pack_string(SPOOF)
else:
data.pack_string(HOSTNAME)
data.pack_string(NAME)
data.pack_int(SPOOFENABLED)
data.pack_string("%s")
data.pack_string(str(VAL))
return ( packer.get_buffer() , data.get_buffer() )
def make_reply_verf(self, cred, stat):
log_gss.debug("CALL:make_reply_verf(%r, %i)" % (cred, stat))
cred = cred.body
if stat:
# Return trivial verf on error
# NOTE this relies on GSS_S_COMPLETE == rpc.SUCCESS == 0
return rpclib.NULL_CRED
elif cred.gss_proc in (RPCSEC_GSS_INIT, RPCSEC_GSS_CONTINUE_INIT):
# init requires getMIC(seq_window)
i = WINDOWSIZE
else:
# Else return getMIC(cred.seq_num)
i = cred.seq_num
p = Packer()
p.pack_uint(i)
# XXX BUG - need to set qop
token = self._get_context(cred.handle).getMIC(p.get_buffer())
return opaque_auth(RPCSEC_GSS, token)
def make_reply_verf(self, cred, stat):
log_gss.debug("CALL:make_reply_verf(%r, %i)" % (cred, stat))
cred = cred.body
if stat:
# Return trivial verf on error
# NOTE this relies on GSS_S_COMPLETE == rpc.SUCCESS == 0
return rpclib.NULL_CRED
elif cred.gss_proc in (RPCSEC_GSS_INIT, RPCSEC_GSS_CONTINUE_INIT):
# init requires getMIC(seq_window)
i = WINDOWSIZE
else:
# Else return getMIC(cred.seq_num)
i = cred.seq_num
p = Packer()
p.pack_uint(i)
# XXX BUG - need to set qop
token = self._get_context(cred.handle).getMIC(p.get_buffer())
return opaque_auth(RPCSEC_GSS, token)
def pack(self, packer: Packer) -> None:
self.ledger_version.pack(packer)
self.previous_ledger_hash.pack(packer)
self.scp_value.pack(packer)
self.tx_set_result_hash.pack(packer)
self.bucket_list_hash.pack(packer)
self.ledger_seq.pack(packer)
self.total_coins.pack(packer)
self.fee_pool.pack(packer)
self.inflation_seq.pack(packer)
self.id_pool.pack(packer)
self.base_fee.pack(packer)
self.base_reserve.pack(packer)
self.max_tx_set_size.pack(packer)
packer.pack_uint(4)
for skip_list in self.skip_list:
skip_list.pack(packer)
self.ext.pack(packer)
def pack(self, packer: Packer) -> None:
Integer(self.v).pack(packer)
if self.v == 0:
if self.operations is None:
raise ValueError("operations should not be None.")
packer.pack_uint(len(self.operations))
for operation in self.operations:
operation.pack(packer)
return
if self.v == 1:
if self.v1 is None:
raise ValueError("v1 should not be None.")
self.v1.pack(packer)
return
if self.v == 2:
if self.v2 is None:
raise ValueError("v2 should not be None.")
self.v2.pack(packer)
return
def __init__(self, stamp=0, machinename='', uid=0, gid=0, gids=[]):
if len(machinename) > 255:
raise SecError("machinename %s is too long" % machinename)
if len(gids) > 16:
raise SecError("gid array too long: %s" % str(gids))
try:
p = Packer()
p.pack_int(stamp)
try: # for python2
p.pack_string(machinename)
except: # for python3
p.pack_string(bytes(machinename, 'utf-8'))
p.pack_uint(uid)
p.pack_uint(gid)
p.pack_array(gids, p.pack_uint)
self.cred = p.get_buffer()
except Error as e:
raise SecError("Packing error: %s", str(e))
self.uid = uid
self.gid = gid
def gmetric_meta(NAME, TYPE, UNITS, SLOPE, TMAX, DMAX, EXTRAS=None):
"""
Arguments are in all upper-case to match XML
"""
packer = Packer()
packer.pack_int(128) # "gmetadata_full"
packer.pack_string('nickg-macbook.local')
packer.pack_string(NAME)
packer.pack_bool(False)
packer.pack_string(TYPE)
packer.pack_string(NAME)
packer.pack_string(UNITS)
packer.pack_int(slope_str2int[SLOPE]) # map slope string to int
packer.pack_uint(int(TMAX))
packer.pack_uint(int(DMAX))
if EXTRAS is None:
packer.pack_uint(0)
else:
packer.pack_uint(len(EXTRAS))
for k,v in EXTRAS.iteritems():
packer.pack_string(k)
packer.pack_string(v)
return packer.get_buffer()
def gmetric_write(NAME, VAL, TYPE, UNITS, SLOPE, TMAX, DMAX, GROUP, SPOOF):
"""
Arguments are in all upper-case to match XML
"""
packer = Packer()
HOSTNAME = 'test'
if SPOOF == '':
SPOOFENABLED = 0
else:
SPOOFENABLED = 1
packer.pack_int(128)
if SPOOFENABLED == 1:
packer.pack_string(SPOOF)
else:
packer.pack_string(HOSTNAME)
packer.pack_string(NAME)
packer.pack_int(SPOOFENABLED)
packer.pack_string(TYPE)
packer.pack_string(NAME)
packer.pack_string(UNITS)
packer.pack_int(slope_str2int[SLOPE])
packer.pack_uint(int(TMAX))
packer.pack_uint(int(DMAX))
if GROUP == '':
packer.pack_int(0)
else:
packer.pack_int(1)
packer.pack_string('GROUP')
packer.pack_string(GROUP)
data = Packer()
data.pack_int(133)
if SPOOFENABLED == 1:
data.pack_string(SPOOF)
else:
data.pack_string(HOSTNAME)
data.pack_string(NAME)
data.pack_int(SPOOFENABLED)
data.pack_string('%s')
data.pack_string(str(VAL))
return (packer.get_buffer(), data.get_buffer())
def gmetric_meta(NAME, TYPE, UNITS, SLOPE, TMAX, DMAX, EXTRAS=None):
"""
Arguments are in all upper-case to match XML
"""
packer = Packer()
packer.pack_int(128) # "gmetadata_full"
packer.pack_string('nickg-macbook.local')
packer.pack_string(NAME)
packer.pack_bool(False)
packer.pack_string(TYPE)
packer.pack_string(NAME)
packer.pack_string(UNITS)
packer.pack_int(slope_str2int[SLOPE]) # map slope string to int
packer.pack_uint(int(TMAX))
packer.pack_uint(int(DMAX))
if EXTRAS is None:
packer.pack_uint(0)
else:
packer.pack_uint(len(EXTRAS))
for k, v in EXTRAS.iteritems():
packer.pack_string(k)
packer.pack_string(v)
return packer.get_buffer()
def pack(self, packer: Packer) -> None:
self.quorum_set_hash.pack(packer)
self.ballot.pack(packer)
if self.prepared is None:
packer.pack_uint(0)
else:
packer.pack_uint(1)
self.prepared.pack(packer)
if self.prepared_prime is None:
packer.pack_uint(0)
else:
packer.pack_uint(1)
self.prepared_prime.pack(packer)
self.n_c.pack(packer)
self.n_h.pack(packer)
def pack(self, packer: Packer) -> None:
self.code.pack(packer)
if (self.code == TransactionResultCode.txSUCCESS
or self.code == TransactionResultCode.txFAILED):
if self.results is None:
raise ValueError("results should not be None.")
packer.pack_uint(len(self.results))
for result in self.results:
result.pack(packer)
return
if (self.code == TransactionResultCode.txTOO_EARLY
or self.code == TransactionResultCode.txTOO_LATE
or self.code == TransactionResultCode.txMISSING_OPERATION
or self.code == TransactionResultCode.txBAD_SEQ
or self.code == TransactionResultCode.txBAD_AUTH
or self.code == TransactionResultCode.txINSUFFICIENT_BALANCE
or self.code == TransactionResultCode.txNO_ACCOUNT
or self.code == TransactionResultCode.txINSUFFICIENT_FEE
or self.code == TransactionResultCode.txBAD_AUTH_EXTRA
or self.code == TransactionResultCode.txINTERNAL_ERROR
or self.code == TransactionResultCode.txNOT_SUPPORTED
or self.code == TransactionResultCode.txBAD_SPONSORSHIP):
return
def gmetric_write(NAME, VAL, TYPE, UNITS, SLOPE, TMAX, DMAX, GROUP, SPOOF):
packer = Packer()
HOSTNAME = 'test'
if SPOOF == '':
SPOOFENABLED = 0
else:
SPOOFENABLED = 1
packer.pack_int(128)
if SPOOFENABLED == 1:
packer.pack_string(SPOOF)
else:
packer.pack_string(HOSTNAME)
packer.pack_string(NAME)
packer.pack_int(SPOOFENABLED)
packer.pack_string(TYPE)
packer.pack_string(NAME)
packer.pack_string(UNITS)
packer.pack_int(slope_str2int[SLOPE])
packer.pack_uint(int(TMAX))
packer.pack_uint(int(DMAX))
if GROUP == '':
packer.pack_int(0)
else:
packer.pack_int(1)
packer.pack_string('GROUP')
packer.pack_string(GROUP)
data = Packer()
data.pack_int(133)
if SPOOFENABLED == 1:
data.pack_string(SPOOF)
else:
data.pack_string(HOSTNAME)
data.pack_string(NAME)
data.pack_int(SPOOFENABLED)
data.pack_string('%s')
data.pack_string(str(VAL))
return (packer.get_buffer(), data.get_buffer())
def send(self):
try:
unp = Packer()
unp.pack_fstring(96, self.model.encode())
unp.pack_double(self.time)
unp.pack_double(self.lag)
unp.pack_farray(3, self.position, unp.pack_double)
unp.pack_farray(3, self.orientation, unp.pack_float)
unp.pack_farray(3, self.linear_vel, unp.pack_float)
unp.pack_farray(3, self.angular_vel, unp.pack_float)
unp.pack_farray(3, self.linear_accel, unp.pack_float)
unp.pack_farray(3, self.angular_accel, unp.pack_float)
unp.pack_uint(0)
self.properties.send(unp)
msgbuf = unp.get_buffer()
headbuf = self.header.send()
self.header.msglen = len(headbuf + msgbuf)
#print("setting len=",self.header.msglen, len(headbuf + msgbuf))
headbuf = self.header.send()
#print("len2=",self.header.msglen, len(headbuf+msgbuf))
return headbuf + msgbuf
except:
llogger.exception("ERROR creating msg")
print(self.model)
def pack(self, packer: Packer) -> None:
self.ledger_header.pack(packer)
self.tx_set.pack(packer)
packer.pack_uint(len(self.tx_processing))
for tx_processing in self.tx_processing:
tx_processing.pack(packer)
packer.pack_uint(len(self.upgrades_processing))
for upgrades_processing in self.upgrades_processing:
upgrades_processing.pack(packer)
packer.pack_uint(len(self.scp_info))
for scp_info in self.scp_info:
scp_info.pack(packer)
def pack(self, packer: Packer) -> None:
self.source_account_ed25519.pack(packer)
self.fee.pack(packer)
self.seq_num.pack(packer)
if self.time_bounds is None:
packer.pack_uint(0)
else:
packer.pack_uint(1)
self.time_bounds.pack(packer)
self.memo.pack(packer)
packer.pack_uint(len(self.operations))
for operation in self.operations:
operation.pack(packer)
self.ext.pack(packer)
def pack(self, packer: Packer) -> None:
self.type.pack(packer)
if self.type == ClaimPredicateType.CLAIM_PREDICATE_UNCONDITIONAL:
return
if self.type == ClaimPredicateType.CLAIM_PREDICATE_AND:
if self.and_predicates is None:
raise ValueError("and_predicates should not be None.")
packer.pack_uint(len(self.and_predicates))
for and_predicate in self.and_predicates:
and_predicate.pack(packer)
return
if self.type == ClaimPredicateType.CLAIM_PREDICATE_OR:
if self.or_predicates is None:
raise ValueError("or_predicates should not be None.")
packer.pack_uint(len(self.or_predicates))
for or_predicate in self.or_predicates:
or_predicate.pack(packer)
return
if self.type == ClaimPredicateType.CLAIM_PREDICATE_NOT:
if self.not_predicate is None:
packer.pack_uint(0)
return
packer.pack_uint(1)
if self.not_predicate is None:
raise ValueError("not_predicate should not be None.")
self.not_predicate.pack(packer)
return
if self.type == ClaimPredicateType.CLAIM_PREDICATE_BEFORE_ABSOLUTE_TIME:
if self.abs_before is None:
raise ValueError("abs_before should not be None.")
self.abs_before.pack(packer)
return
if self.type == ClaimPredicateType.CLAIM_PREDICATE_BEFORE_RELATIVE_TIME:
if self.rel_before is None:
raise ValueError("rel_before should not be None.")
self.rel_before.pack(packer)
return
raise ValueError("Invalid type.")
def pack(self, packer: Packer) -> None:
self.account_id.pack(packer)
self.balance.pack(packer)
self.seq_num.pack(packer)
self.num_sub_entries.pack(packer)
if self.inflation_dest is None:
packer.pack_uint(0)
else:
packer.pack_uint(1)
self.inflation_dest.pack(packer)
self.flags.pack(packer)
self.home_domain.pack(packer)
self.thresholds.pack(packer)
packer.pack_uint(len(self.signers))
for signer in self.signers:
signer.pack(packer)
self.ext.pack(packer)
def sendMetadata(self, sock, address):
self.lastMetadataSendTime = time.time()
packer = Packer()
packer.pack_enum(self.formatIDs['full'])
packer.pack_string(self.hostname)
packer.pack_string(self.name)
packer.pack_bool(False) # spoof = false
packer.pack_string(self.type)
packer.pack_string(self.name)
packer.pack_string(self.units)
if self.slope == 'zero':
slope = 0
else:
slope = 3
packer.pack_uint(slope)
packer.pack_uint(self.tmax)
packer.pack_uint(self.dmax)
packer.pack_uint(len(self.meta)) # array length
for name, value in self.meta.items():
packer.pack_string(name)
packer.pack_string(value)
sock.sendto(packer.get_buffer(), address)
def compute_tlv(tag, message):
packer = Packer()
packer.pack_uint(tag)
packer.pack_string(message)
return packer.get_buffer()
def pack(self, packer: Packer) -> None:
self.tx.pack(packer)
packer.pack_uint(len(self.signatures))
for signature in self.signatures:
signature.pack(packer)
def handle_message(self, opaque_bytes, client_id):
"""
Handles a message, start to finish.
Takes the opaque bytes representing the XDR encoded RPC message.
Produces an RPC reply, also encoded as opaque bytes.
"""
from xdrlib import Unpacker, Packer
unpacker = Unpacker(opaque_bytes)
msg = rpc_msg.unpack(unpacker)
print(msg.body.mtype.value)
if msg.body.mtype != msg_type.CALL:
print("No reply!")
return None # do not reply to such a bad message.
#response = self.handle_message(msg,
# opaque_bytes[unpacker.get_position():])
print("Well-formed message!")
print("rpc version: %d" % msg.body.cbody.rpcvers)
print("program id: %d" % msg.body.cbody.prog)
print("version id: %d" % msg.body.cbody.vers)
print("procedure id: %d" % msg.body.cbody.proc)
print("cred flavor: %d" % msg.body.cbody.cred.flavor)
print("verf flavor: %d" % msg.body.cbody.verf.flavor)
print("remaining bytes: %s" % opaque_bytes[unpacker.get_position():])
if msg.body.cbody.cred.flavor == auth_flavor.AUTH_SYS:
print("using system auth")
unpacker2 = Unpacker(msg.body.cbody.cred.body.bytes)
params = authsys_parms.unpack(unpacker2)
print(params)
id = self.next_short_id
self.next_short_id += 1
self.system_auth[id] = params
packer = Packer()
packer.pack_uint(id)
verf = opaque_auth(flavor=auth_flavor.AUTH_SHORT,
body=packer.get_buffer())
else:
verf = opaque_auth.NONE()
def _pack(reply):
packer = Packer()
reply.pack(packer)
return packer.get_buffer()
_body = rpc_msg.body
_rbody = reply_body
_rreply = rejected_reply
_areply = accepted_reply
_rdata = accepted_reply.reply_data
if msg.body.cbody.rpcvers != 2:
reply = rpc_msg(xid=msg.xid,
body=_body(mtype=msg_type.REPLY,
rbody=_rbody(stat=reply_stat.MSG_DENIED,
rreply=_rreply(stat=reject_stat.RPC_MISMATCH,
mismatch_info=mismatch_info(low=2, high=2)))))
return _pack(reply)
if msg.body.cbody.prog not in self.programs:
print("no such program!")
reply = rpc_msg(xid=msg.xid,
body=_body(mtype=msg_type.REPLY,
rbody=_rbody(stat=reply_stat.MSG_ACCEPTED,
areply=_areply(verf=verf,
reply_data=_rdata(stat=accept_stat.PROG_UNAVAIL)))))
return _pack(reply)
program = self.programs[msg.body.cbody.prog]
print("program: %s" % str(program))
version = program.get_version_impl(msg.body.cbody.vers)
print("version: %s" % str(version))
procedure = version.get_procedure_by_id(msg.body.cbody.proc)
print("procedure: %s" % str(procedure))
print("procedure.arg_type: %s" % str(procedure.argument_type))
args = procedure.argument_type.unpack(unpacker)
print("args: %s" % str(args))
response = procedure(version, msg, args)
print("response: %s" % str(response))
reply = rpc_msg(xid=msg.xid,
body=_body(mtype=msg_type.REPLY,
rbody=_rbody(stat=reply_stat.MSG_ACCEPTED,
areply=_areply(verf=verf,
reply_data=_rdata(stat=accept_stat.SUCCESS)))))
print("reply: %s" % str(reply))
packer = Packer()
reply.pack(packer)
response.pack(packer)
print("bytes: %s" % str(packer.get_buffer()))
return packer.get_buffer()
def _gmetric(self, name, val, metric_type, units, slope, tmax, dmax, group, title, description, spoof):
meta = Packer()
HOSTNAME = socket.gethostname()
if spoof:
SPOOF_ENABLED = 1
else:
SPOOF_ENABLED = 0
# Meta data about a metric
packet_type = 128
meta.pack_int(packet_type)
if SPOOF_ENABLED == 1:
meta.pack_string(spoof)
else:
meta.pack_string(HOSTNAME)
meta.pack_string(name)
meta.pack_int(SPOOF_ENABLED)
meta.pack_string(metric_type)
meta.pack_string(name)
meta.pack_string(units)
meta.pack_int(METRIC_SLOPES[slope]) # map slope string to int
meta.pack_uint(int(tmax))
meta.pack_uint(int(dmax))
extra_data = 0
if group:
extra_data += 1
if title:
extra_data += 1
if description:
extra_data += 1
meta.pack_int(extra_data)
if group:
for g in group.split(','):
meta.pack_string("GROUP")
meta.pack_string(g)
if title:
meta.pack_string("TITLE")
meta.pack_string(title)
if description:
meta.pack_string("DESC")
meta.pack_string(description)
# Actual data sent in a separate packet
data = Packer()
packet_type = METRIC_TYPES[metric_type]
data.pack_int(packet_type)
if SPOOF_ENABLED == 1:
data.pack_string(spoof)
else:
data.pack_string(HOSTNAME)
data.pack_string(name)
data.pack_int(SPOOF_ENABLED)
if metric_type in ['int8', 'uint8', 'int16', 'uint16', 'int32']:
data.pack_string("%d")
data.pack_int(int(val))
if metric_type == 'uint32':
data.pack_string("%u")
data.pack_uint(long(val))
if metric_type == 'string':
data.pack_string("%s")
data.pack_string(str(val))
if metric_type == 'float':
data.pack_string("%f")
data.pack_float(float(val))
if metric_type == 'double':
data.pack_string("%f")
data.pack_double(float(val)) # XXX - double or float?
return meta.get_buffer(), data.get_buffer()
def _rpcPacket(): #Build RPC portmap call
data = Packer()
data.pack_uint(int(random() * 0xffffffff)) # Transaction Identifier (xid)
data.pack_enum(CALL) # Message Type
data.pack_uint(2) # RPC version
data.pack_enum(PORTMAP) # Program
data.pack_uint(2) # Program Version
data.pack_enum(GETPORT) # Process
data.pack_enum(AUTH_NULL) # Credentials
data.pack_uint(0) # Credentials length
data.pack_enum(AUTH_NULL) # Verifier
data.pack_uint(0) # Verifier Length
data.pack_enum(VXI11_CORE) # Called Program
data.pack_uint(1) # Program Version
data.pack_enum(TCP) # Program Protocol
data.pack_uint(0) # Port
return data.get_buffer()
def _gmetric(self, name, val, type, units, slope, tmax, dmax, group, title, description, spoof):
"""
Arguments are in all upper-case to match XML
"""
meta = Packer()
HOSTNAME=socket.gethostname()
if spoof == "":
SPOOFENABLED=0
else :
SPOOFENABLED=1
# Meta data about a metric
packet_type = 128
meta.pack_int(packet_type)
if SPOOFENABLED == 1:
meta.pack_string(spoof)
else:
meta.pack_string(HOSTNAME)
meta.pack_string(name)
meta.pack_int(SPOOFENABLED)
meta.pack_string(type)
meta.pack_string(name)
meta.pack_string(units)
meta.pack_int(SLOPES[slope]) # map slope string to int
meta.pack_uint(int(tmax))
meta.pack_uint(int(dmax))
extra_data = 0
if group != "":
extra_data += 1
if title != "":
extra_data += 1
if description != "":
extra_data += 1
meta.pack_int(extra_data)
if group != "":
meta.pack_string("GROUP")
meta.pack_string(group)
if title != "":
meta.pack_string("TITLE")
meta.pack_string(title)
if description != "":
meta.pack_string("DESC")
meta.pack_string(description)
# Actual data sent in a separate packet
data = Packer()
packet_type = TYPES[type]
data.pack_int(packet_type)
if SPOOFENABLED == 1:
data.pack_string(spoof)
else:
data.pack_string(HOSTNAME)
data.pack_string(name)
data.pack_int(SPOOFENABLED)
if type in ['int8','uint8','int16','uint16','int32']:
data.pack_string("%d")
data.pack_int(int(val))
if type == 'uint32':
data.pack_string("%u")
data.pack_uint(long(val))
if type == 'string':
data.pack_string("%s")
data.pack_string(str(val))
if type == 'float':
data.pack_string("%f")
data.pack_float(float(val))
if type == 'double':
data.pack_string("%f")
data.pack_double(float(val)) # XXX - double or float?
return (meta.get_buffer(), data.get_buffer())
