ethernet_client.cpp

Go to the documentation of this file.

 
#include <net/ethernet_client.h>
 
namespace net {
 
int EthernetClient::connect(IPAddress ip, uint16_t port) { return hal_->connect(ip, port); }
 
// Returns INVALID_SERVER (-2) if DNS is disabled.
int EthernetClient::connect(const char *host, uint16_t port) { return hal_->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 EthernetClient::connectNoWait(const IPAddress &ip, uint16_t port) {
  return hal_->connectNoWait(ip, port);
}
 
// Returns INVALID_SERVER (-2) if DNS is disabled.
int EthernetClient::connectNoWait(const char *host, uint16_t port) {
  return hal_->connectNoWait(host, port);
}
 
uint8_t EthernetClient::connected() { return hal_->connected(); }
 
EthernetClient::operator bool() { return hal_->operator bool(); }
 
void EthernetClient::setConnectionTimeout(uint16_t timeout) {
  return hal_->setConnectionTimeout(timeout);
}
 
// Returns the current timeout value.
uint16_t EthernetClient::connectionTimeout() const { return hal_->connectionTimeout(); }
 
void EthernetClient::stop() { return hal_->stop(); }
 
// Closes the connection. This works the same as stop(), but without waiting
// for the connection to close.
void EthernetClient::close() { return hal_->close(); }
 
// Closes the sending side of this connection.
void EthernetClient::closeOutput() { return hal_->closeOutput(); }
 
// Kills the connection without going through the TCP close process.
void EthernetClient::abort() { return hal_->abort(); }
 
uint16_t EthernetClient::localPort() { return hal_->localPort(); }
 
IPAddress EthernetClient::remoteIP() { return hal_->remoteIP(); }
 
uint16_t EthernetClient::remotePort() { return hal_->remotePort(); }
 
// Returns the local IP address for this connection, or INADDR_NONE if this
// client is not connected.
IPAddress EthernetClient::localIP() { return hal_->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 EthernetClient::connectionId() { return hal_->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 EthernetClient::writeFully(uint8_t b) { return hal_->writeFully(b); }
 
size_t EthernetClient::writeFully(const char *s) { return hal_->writeFully(s); }
 
size_t EthernetClient::writeFully(const char *s, size_t size) { return hal_->writeFully(s, size); }
 
size_t EthernetClient::writeFully(const uint8_t *buf, size_t size) {
  return hal_->writeFully(buf, size);
}
 
size_t EthernetClient::write(uint8_t b) { return hal_->write(b); }
 
size_t EthernetClient::write(const uint8_t *buf, size_t size) { return hal_->write(buf, size); }
 
int EthernetClient::availableForWrite() { return hal_->availableForWrite(); }
 
void EthernetClient::flush() { return hal_->flush(); }
 
int EthernetClient::available() { return hal_->available(); }
 
int EthernetClient::read() { return hal_->read(); }
 
// A NULL buffer allows the caller to skip bytes without having to read into
// a buffer.
int EthernetClient::read(uint8_t *buf, size_t size) { return hal_->read(buf, size); }
 
int EthernetClient::peek() { return hal_->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 EthernetClient::setNoDelay(bool flag) { return hal_->setNoDelay(flag); }
 
// Returns the value of the TCP_NODELAY flag for the current connection. This
// returns false if not connected.
bool EthernetClient::isNoDelay() { return hal_->isNoDelay(); }
 
} // namespace net