#ifndef _IP65_H
#define _IP65_H

// Error codes
//
#define IP65_ERROR_PORT_IN_USE                   0x80
#define IP65_ERROR_TIMEOUT_ON_RECEIVE            0x81
#define IP65_ERROR_TRANSMIT_FAILED               0x82
#define IP65_ERROR_TRANSMISSION_REJECTED_BY_PEER 0x83
#define IP65_ERROR_INPUT_TOO_LARGE               0x84
#define IP65_ERROR_DEVICE_FAILURE                0x85
#define IP65_ERROR_ABORTED_BY_USER               0x86
#define IP65_ERROR_LISTENER_NOT_AVAILABLE        0x87
#define IP65_ERROR_CONNECTION_RESET_BY_PEER      0x89
#define IP65_ERROR_CONNECTION_CLOSED             0x8A
#define IP65_ERROR_FILE_ACCESS_FAILURE           0x90
#define IP65_ERROR_MALFORMED_URL                 0xA0
#define IP65_ERROR_DNS_LOOKUP_FAILED             0xA1

// Last error code
//
extern unsigned char ip65_error;

// MAC address of local machine (will be overwritten if ip65_init is called)
//
extern unsigned char cfg_mac[6];

// IP address of local machine (will be overwritten if dhcp_init is called)
//
extern unsigned long cfg_ip;

// Netmask of local network (will be overwritten if dhcp_init is called)
//
extern unsigned long cfg_netmask;

// IP address of router on local network (will be overwritten if dhcp_init is called)
//
extern unsigned long cfg_gateway;

// IP address of dns server to use (will be overwritten if dhcp_init is called)
//
extern unsigned long cfg_dns;

// Will be set to address of DHCP server that configuration was obtained from
//
extern unsigned long dhcp_server;

// Initialise the IP stack
//
// This calls the individual protocol & driver initialisations, so this is
// the only *_init routine that must be called by a user application,
// except for dhcp_init which must also be called if the application
// is using DHCP rather than hardcoded IP configuration.
//
// Inputs: None
// Output: 1 if there was an error, 0 otherwise
//
unsigned char ip65_init(void);

// Main IP polling loop
//
// This routine should be periodically called by an application at any time
// that an inbound packet needs to be handled.
// It is 'non-blocking', i.e. it will return if there is no packet waiting to be
// handled. Any inbound packet will be handed off to the appropriate handler.
//
// Inputs: None
// Output: 1 if no packet was waiting or packet handling caused error, 0 otherwise
//
unsigned char ip65_process(void);

// Generate a 'random' 16 bit word
//
// Entropy comes from the last ethernet frame, counters, and timer.
//
// Inputs: None
// Output: Pseudo-random 16 bit number
//
unsigned int ip65_random_word(void);

// Convert 4 octets (IP address, netmask) into a string representing a dotted quad
//
// The string is returned in a statically allocated buffer, which subsequent calls
// will overwrite.
//
// Inputs: quad: IP address
// Output: Null terminated string containing dotted quad (e.g. "192.168.1.0")
//
char* __fastcall__ dotted_quad(unsigned long quad);

// Convert a string representing a dotted quad (IP address, netmask) into 4 octets
//
// Inputs: quad: Null terminated string containing dotted quad (e.g. "192.168.1.0"),
//               to simplify URL parsing, a ':' or '/' can also terminate the string.
// Output: IP address, 0 on error
//
unsigned long __fastcall__ parse_dotted_quad(char* quad);

// Minimal DHCP client implementation
//
// IP addresses are requested from a DHCP server (aka 'leased') but are not renewed
// or released. Although this is not correct behaviour according to  the DHCP RFC,
// this works fine in practice in a typical home network environment.
//
// Inputs: None (although ip65_init should be called first)
// Output: 0 if IP config has been sucesfully obtained and cfg_ip, cfg_netmask,
//           cfg_gateway and cfg_dns will be set per response from dhcp server.
//           dhcp_server will be set to address of server that provided configuration.
//         1 if there was an error
//
unsigned char dhcp_init(void);

// Resolve a string containing a hostname (or a dotted quad) to an IP address
//
// Inputs: hostname: pointer to null terminated string that contains either
//                   a DNS hostname (e.g. "host.example.com") or an address
//                   in "dotted quad" format (e.g. "192.168.1.0").
// Output: IP address of the hostname, 0 on error
//
unsigned long __fastcall__ dns_resolve(const char* hostname);

// Send a ping (ICMP echo request) to a remote host, and wait for a response
//
// Inputs: dest: Destination IP address
// Output: 0 if no response, otherwise time (in miliseconds) for host to respond
//
unsigned int __fastcall__ icmp_ping(unsigned long dest);

// Add a UDP listener
//
// Inputs: port:     UDP port to listen on
//         callback: Vector to call when UDP packet arrives on specified port
// Output: 1 if too may listeners already installed, 0 otherwise
//
unsigned char __fastcall__ udp_add_listener(unsigned int port, void (*callback)(void));

// Remove a UDP listener
//
// Inputs: port: UDP port to stop listening on
// Output: 0 if handler found and removed,
//         1 if handler for specified port not found
//
unsigned char __fastcall__ udp_remove_listener(unsigned int port);

// Access to received UDP packet
//
// Access to the four items below is only valid in the context of a callback
// added with udp_add_listener.
//
extern unsigned char udp_recv_buf[1476];        // Buffer with data received
       unsigned int  udp_recv_len(void);        // Length of data received
       unsigned long udp_recv_src(void);        // Source IP address
       unsigned int  udp_recv_src_port(void);   // Source port

// Send a UDP packet
//
// If the correct MAC address can't be found in the ARP cache then
// an ARP request is sent - and the UDP packet is NOT sent. The caller
// should wait a while calling ip65_process (to allow time for an ARP
// response to arrive) and then call upd_send again. This behavior
// makes sense as a UDP packet may get lost in transit at any time
// so the caller should to be prepared to resend it after a while
// anyway.
//
// Inputs: buf:       Pointer to buffer containing data to be sent
//         len:       Length of data to send (exclusive of any headers)
//         dest:      Destination IP address
//         dest_port: Destination port
//         src_port:  Source port
// Output: 1 if an error occured, 0 otherwise
//
unsigned char __fastcall__ udp_send(const unsigned char* buf, unsigned int len,
                                    unsigned long dest, unsigned int dest_port,
                                    unsigned int src_port);

// Listen for an inbound TCP connection
//
// This is a 'blocking' call, i.e. it will not return until a connection has been made.
//
// Inputs: port:     TCP port to listen on
//         callback: Vector to call when data arrives on this connection
//                   buf: Pointer to buffer with data received
//                   len: -1 on close, otherwise length of data received
// Output: IP address of the connected client, 0 on error
//
unsigned long __fastcall__ tcp_listen(unsigned int port,
                                      void (*callback)(const unsigned char* buf, int len));

// Make outbound TCP connection
//
// Inputs: dest:      Destination IP address
//         dest_port: Destination port
//         callback:  Vector to call when data arrives on this connection
//                    buf: Pointer to buffer with data received
//                    len: -1 on close, otherwise length of data received
// Output: 1 if an error occured, 0 otherwise
//
unsigned char __fastcall__ tcp_connect(unsigned long dest, unsigned int dest_port,
                                       void (*callback)(const unsigned char* buf, int len));

// Close the current TCP connection
//
// Inputs: None
// Output: 1 if an error occured, 0 otherwise
//
unsigned char tcp_close(void);

// Send data on the current TCP connection
//
// Inputs: buf: Pointer to buffer containing data to be sent
//         len: Length of data to send (exclusive of any headers)
// Output: 1 if an error occured, 0 otherwise
//
unsigned char __fastcall__ tcp_send(const unsigned char* buf, unsigned int len);

// Send an empty ACK packet on the current TCP connection
//
// Inputs: None
// Output: 1 if an error occured, 0 otherwise
//
unsigned char tcp_send_keep_alive(void);

// Query an SNTP server for current UTC time
//
// Inputs: SNTP server IP address
// Output: The number of seconds since 00:00 on Jan 1, 1900 (UTC)
//
unsigned long sntp_get_time(unsigned long server);

// Get number of milliseconds since initialization
//
// Inputs: None
// Output: Current number of milliseconds
//
unsigned int timer_read(void);

// Check if specified period of time has passed yet
//
// Inputs: time: Number of milliseconds we are willing to wait for
// Output: 1 if timeout occured, 0 otherwise
//
unsigned char __fastcall__ timer_timeout(unsigned int time);

// User abort control
//
// Control if the user can abort blocking functions with the abort key
// (making them return IP65_ERROR_ABORTED_BY_USER). Initially the abort
// key is enabled.
//
// Inputs: enable: 0 to disable the key, 1 to enable the key
// Output: None
//
void __fastcall__ abort_key(unsigned char enable);

#endif