def test_sendto(self, tco):
pdu = nfc.llcp.pdu.UnnumberedInformation(1, 1, HEX('1122'))
assert tco.sendto(pdu.data, 1, flags=nfc.llcp.MSG_DONTWAIT) is True
assert tco.dequeue(10, 4) == pdu
assert tco.connect(2) is True
with pytest.raises(nfc.llcp.Error) as excinfo:
tco.sendto(pdu.data, 1, flags=nfc.llcp.MSG_DONTWAIT)
assert excinfo.value.errno == errno.EDESTADDRREQ
with pytest.raises(nfc.llcp.Error) as excinfo:
data = (tco.send_miu + 1) * HEX('11')
tco.sendto(data, 2, flags=nfc.llcp.MSG_DONTWAIT)
assert excinfo.value.errno == errno.EMSGSIZE
tco.close()
with pytest.raises(nfc.llcp.Error) as excinfo:
tco.sendto(pdu.data, 1, 0)
assert excinfo.value.errno == errno.ESHUTDOWN
python类EMSGSIZE的实例源码
def send(self, message, flags):
with self.send_token:
if not self.state.ESTABLISHED:
self.err("send() in socket state {0}".format(self.state))
if self.state.CLOSE_WAIT:
raise err.Error(errno.EPIPE)
raise err.Error(errno.ENOTCONN)
if len(message) > self.send_miu:
raise err.Error(errno.EMSGSIZE)
while self.send_window_slots == 0 and self.state.ESTABLISHED:
if flags & nfc.llcp.MSG_DONTWAIT:
raise err.Error(errno.EWOULDBLOCK)
self.log("waiting on busy send window")
self.send_token.wait()
self.log("send {0} byte on {1}".format(len(message), str(self)))
if self.state.ESTABLISHED:
send_pdu = pdu.Information(self.peer, self.addr, data=message)
send_pdu.ns = self.send_cnt
self.send_cnt = (self.send_cnt + 1) % 16
super(DataLinkConnection, self).send(send_pdu, flags)
return self.state.ESTABLISHED is True
def send(self, message):
with self.send_token:
if not self.state.ESTABLISHED:
self.err("send() in socket state {0}".format(self.state))
if self.state.CLOSE_WAIT:
raise Error(errno.EPIPE)
raise Error(errno.ENOTCONN)
if len(message) > self.send_miu:
raise Error(errno.EMSGSIZE)
while self.send_window_slots == 0 and self.state.ESTABLISHED:
self.log("waiting on busy send window")
self.send_token.wait()
self.log("send() {0}".format(str(self)))
if self.state.ESTABLISHED:
pdu = Information(self.peer, self.addr, sdu=message)
pdu.ns = self.send_cnt
self.send_cnt = (self.send_cnt + 1) % 16
super(DataLinkConnection, self).send(pdu)
return self.state.ESTABLISHED == True
def write(self, datagram, address):
"""Write a datagram."""
try:
return self.socket.sendto(datagram, address)
except socket.error as se:
no = se.args[0]
if no == EINTR:
return self.write(datagram, address)
elif no == EMSGSIZE:
raise error.MessageLengthError("message too long")
elif no == EAGAIN:
# oh, well, drop the data. The only difference from UDP
# is that UDP won't ever notice.
# TODO: add TCP-like buffering
pass
else:
raise
def write(self, data):
"""
Write a datagram.
"""
try:
return self.socket.send(data)
except socket.error as se:
no = se.args[0]
if no == EINTR:
return self.write(data)
elif no == EMSGSIZE:
raise error.MessageLengthError("message too long")
elif no == ECONNREFUSED:
self.protocol.connectionRefused()
elif no == EAGAIN:
# oh, well, drop the data. The only difference from UDP
# is that UDP won't ever notice.
# TODO: add TCP-like buffering
pass
else:
raise
def run(self):
self._establishConnection()
while self._alive:
try:
data, addr = self._server.recvfrom(self.bufferSize)
if self._acceptAddress(addr):
if data == BDTP_SIG['END']:
self._closeConnection()
else:
self._decode(data)
else:
self._client.sendto(BDTP_SIG['REJ'], addr)
except timeout:
continue
except error as e:
if e[0] == errno.EMSGSIZE:
continue
else:
raise e
except Exception as err:
raise err
def write(self, datagram, addr=None):
"""Write a datagram.
@param addr: should be a tuple (ip, port), can be None in connected mode.
"""
if self._connectedAddr:
assert addr in (None, self._connectedAddr)
try:
return self.socket.send(datagram)
except socket.error, se:
no = se.args[0]
if no == EINTR:
return self.write(datagram)
elif no == EMSGSIZE:
raise error.MessageLengthError, "message too long"
elif no == ECONNREFUSED:
self.protocol.connectionRefused()
else:
raise
else:
assert addr != None
if not addr[0].replace(".", "").isdigit():
warnings.warn("Please only pass IPs to write(), not hostnames", DeprecationWarning, stacklevel=2)
try:
return self.socket.sendto(datagram, addr)
except socket.error, se:
no = se.args[0]
if no == EINTR:
return self.write(datagram, addr)
elif no == EMSGSIZE:
raise error.MessageLengthError, "message too long"
elif no == ECONNREFUSED:
# in non-connected UDP ECONNREFUSED is platform dependent, I think
# and the info is not necessarily useful. Nevertheless maybe we
# should call connectionRefused? XXX
return
else:
raise
def write(self, data):
"""Write a datagram."""
try:
return self.socket.send(data)
except socket.error, se:
no = se.args[0]
if no == EINTR:
return self.write(data)
elif no == EMSGSIZE:
raise error.MessageLengthError, "message too long"
elif no == ECONNREFUSED:
self.protocol.connectionRefused()
else:
raise
def sendto(self, message, dest, flags):
if self.state.SHUTDOWN:
raise err.Error(errno.ESHUTDOWN)
if self.peer and dest != self.peer:
raise err.Error(errno.EDESTADDRREQ)
if len(message) > self.send_miu:
raise err.Error(errno.EMSGSIZE)
send_pdu = pdu.UnnumberedInformation(dest, self.addr, data=message)
super(LogicalDataLink, self).send(send_pdu, flags)
return self.state.ESTABLISHED is True
def write(self, datagram, addr=None):
"""Write a datagram.
@param addr: should be a tuple (ip, port), can be None in connected mode.
"""
if self._connectedAddr:
assert addr in (None, self._connectedAddr)
try:
return self.socket.send(datagram)
except socket.error, se:
no = se.args[0]
if no == EINTR:
return self.write(datagram)
elif no == EMSGSIZE:
raise error.MessageLengthError, "message too long"
elif no == ECONNREFUSED:
self.protocol.connectionRefused()
else:
raise
else:
assert addr != None
if not addr[0].replace(".", "").isdigit():
warnings.warn("Please only pass IPs to write(), not hostnames", DeprecationWarning, stacklevel=2)
try:
return self.socket.sendto(datagram, addr)
except socket.error, se:
no = se.args[0]
if no == EINTR:
return self.write(datagram, addr)
elif no == EMSGSIZE:
raise error.MessageLengthError, "message too long"
elif no == ECONNREFUSED:
# in non-connected UDP ECONNREFUSED is platform dependent, I think
# and the info is not necessarily useful. Nevertheless maybe we
# should call connectionRefused? XXX
return
else:
raise
def write(self, data):
"""Write a datagram."""
try:
return self.socket.send(data)
except socket.error, se:
no = se.args[0]
if no == EINTR:
return self.write(data)
elif no == EMSGSIZE:
raise error.MessageLengthError, "message too long"
elif no == ECONNREFUSED:
self.protocol.connectionRefused()
else:
raise
def sendto(self, message, dest):
if self.state.SHUTDOWN:
raise Error(errno.EBADF)
if self.peer and dest != self.peer:
raise Error(errno.EDESTADDRREQ)
if len(message) > self.send_miu:
raise Error(errno.EMSGSIZE)
pdu = UnnumberedInformation(dest, self.addr, sdu=message)
super(LogicalDataLink, self).send(pdu)
return self.state.ESTABLISHED == True
def write(self, datagram, addr=None):
"""
Write a datagram.
@type datagram: L{bytes}
@param datagram: The datagram to be sent.
@type addr: L{tuple} containing L{str} as first element and L{int} as
second element, or L{None}
@param addr: A tuple of (I{stringified IPv4 or IPv6 address},
I{integer port number}); can be L{None} in connected mode.
"""
if self._connectedAddr:
assert addr in (None, self._connectedAddr)
try:
return self.socket.send(datagram)
except socket.error as se:
no = se.args[0]
if no == EINTR:
return self.write(datagram)
elif no == EMSGSIZE:
raise error.MessageLengthError("message too long")
elif no == ECONNREFUSED:
self.protocol.connectionRefused()
else:
raise
else:
assert addr != None
if (not abstract.isIPAddress(addr[0])
and not abstract.isIPv6Address(addr[0])
and addr[0] != "<broadcast>"):
raise error.InvalidAddressError(
addr[0],
"write() only accepts IP addresses, not hostnames")
if ((abstract.isIPAddress(addr[0]) or addr[0] == "<broadcast>")
and self.addressFamily == socket.AF_INET6):
raise error.InvalidAddressError(
addr[0],
"IPv6 port write() called with IPv4 or broadcast address")
if (abstract.isIPv6Address(addr[0])
and self.addressFamily == socket.AF_INET):
raise error.InvalidAddressError(
addr[0], "IPv4 port write() called with IPv6 address")
try:
return self.socket.sendto(datagram, addr)
except socket.error as se:
no = se.args[0]
if no == EINTR:
return self.write(datagram, addr)
elif no == EMSGSIZE:
raise error.MessageLengthError("message too long")
elif no == ECONNREFUSED:
# in non-connected UDP ECONNREFUSED is platform dependent, I
# think and the info is not necessarily useful. Nevertheless
# maybe we should call connectionRefused? XXX
return
else:
raise
