teensy_ethernet_client.cpp

Go to the documentation of this file.

 
#include <net/ethernet_client.h>
 
#include "teensy_ethernet_client.h"
 
namespace net {
 
TeensyEthernetClientHAL::TeensyEthernetClientHAL(qn::EthernetClient impl) : impl_(impl) {}
 
int TeensyEthernetClientHAL::connect(IPAddress ip, uint16_t port) { return impl_.connect(ip, port); }
 
// Returns INVALID_SERVER (-2) if DNS is disabled.
int TeensyEthernetClientHAL::connect(const char *host, uint16_t port) {
  return impl_.connect(host, port);
}
 
// These functions start the connection process but don't wait for the
// connection to be complete. Note that DNS lookup might still take some time.
// Neither of these will return TIMED_OUT (-1).
int TeensyEthernetClientHAL::connectNoWait(const IPAddress &ip, uint16_t port) {
  return impl_.connectNoWait(ip, port);
}
 
// Returns INVALID_SERVER (-2) if DNS is disabled.
int TeensyEthernetClientHAL::connectNoWait(const char *host, uint16_t port) {
  return impl_.connectNoWait(host, port);
}
 
uint8_t TeensyEthernetClientHAL::connected() { return impl_.connected(); }
 
TeensyEthernetClientHAL::operator bool() { return impl_.operator bool(); }
 
void TeensyEthernetClientHAL::setConnectionTimeout(uint16_t timeout) {
  return impl_.setConnectionTimeout(timeout);
}
 
// Returns the current timeout value.
uint16_t TeensyEthernetClientHAL::connectionTimeout() const { return impl_.connectionTimeout(); }
 
void TeensyEthernetClientHAL::stop() { impl_.stop(); }
 
// Closes the connection. This works the same as stop(), but without waiting
// for the connection to close.
void TeensyEthernetClientHAL::close() { impl_.close(); }
 
// Closes the sending side of this connection.
void TeensyEthernetClientHAL::closeOutput() { impl_.closeOutput(); }
 
// Kills the connection without going through the TCP close process.
void TeensyEthernetClientHAL::abort() { impl_.abort(); }
 
uint16_t TeensyEthernetClientHAL::localPort() { return impl_.localPort(); }
 
IPAddress TeensyEthernetClientHAL::remoteIP() { return impl_.remoteIP(); }
 
uint16_t TeensyEthernetClientHAL::remotePort() { return impl_.remotePort(); }
 
// Returns the local IP address for this connection, or INADDR_NONE if this
// client is not connected.
IPAddress TeensyEthernetClientHAL::localIP() { return impl_.localIP(); }
 
// Returns an ID for the connection to which this client refers. It will
// return non-zero if connected and zero if not connected.
//
// This is useful because of the way EthernetClient objects can be passed
// around, copied, and moved, etc. Just taking an address of the object won't
// work because more than one object could refer to the same connection.
//
// Note that while multiple active connections won't share the same ID, it's
// possible for new connections to reuse IDs that aren't currently in use. In
// other words, there is a one-to-one correspondence between the set of
// connection IDs and currently active connections.
uintptr_t TeensyEthernetClientHAL::connectionId() { return impl_.connectionId(); }
 
// Functions that loop until all bytes are written. If the connection is
// closed before all bytes are sent then these break early and return the
// actual number of bytes sent. In other words, these only return a value less
// than the specified size if the connection was closed.
size_t TeensyEthernetClientHAL::writeFully(uint8_t b) { return impl_.writeFully(b); }
 
size_t TeensyEthernetClientHAL::writeFully(const char *s) { return impl_.writeFully(s); }
 
size_t TeensyEthernetClientHAL::writeFully(const char *s, size_t size) {
  return impl_.writeFully(s, size);
}
 
size_t TeensyEthernetClientHAL::writeFully(const uint8_t *buf, size_t size) {
  return impl_.writeFully(buf, size);
}
 
size_t TeensyEthernetClientHAL::write(uint8_t b) { return impl_.write(b); }
 
size_t TeensyEthernetClientHAL::write(const uint8_t *buf, size_t size) {
  return impl_.write(buf, size);
}
 
int TeensyEthernetClientHAL::availableForWrite() { return impl_.availableForWrite(); }
 
void TeensyEthernetClientHAL::flush() { impl_.flush(); }
 
int TeensyEthernetClientHAL::available() { return impl_.available(); }
 
int TeensyEthernetClientHAL::read() { return impl_.read(); }
 
// A NULL buffer allows the caller to skip bytes without having to read into
// a buffer.
int TeensyEthernetClientHAL::read(uint8_t *buf, size_t size) { return impl_.read(buf, size); }
 
int TeensyEthernetClientHAL::peek() { return impl_.peek(); }
 
// ----------------
//  Socket Options
// ----------------
 
// Disables or enables Nagle's algorithm. This sets or clears the TCP_NODELAY
// flag. If the flag is set then Nagle's algorithm is disabled, otherwise it
// is enabled. Note that this option must be set for each new connection.
void TeensyEthernetClientHAL::setNoDelay(bool flag) { return impl_.setNoDelay(flag); }
 
// Returns the value of the TCP_NODELAY flag for the current connection. This
// returns false if not connected.
bool TeensyEthernetClientHAL::isNoDelay() { return impl_.isNoDelay(); }
 
} // namespace net