tristan/ZealOS
1
0
Fork 0
mirror of https://github.com/Zeal-Operating-System/ZealOS.git synced 2025-06-07 08:14:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fixed 4 million context swap/second Networking bug.

Browse Source 
Revamped NetHandlerTask into interrupt-based NetHandler.
Created NetLog to output Network info to, instead of outputting to zenith_task.
Updated NetStart.CC and Test files some.
Changed UDPSocketReceiveFrom behaviour to NetWarn instead of Debug when hits timeout and sees AF_UNSPEC.
This commit is contained in:
TomAwezome 2021-01-20 19:33:03 -05:00
parent ca24a0ab32
commit de1878c1f7
22 changed files with 279 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Zenith-latest-2021-01-18-23_29_01.iso → Zenith-latest-2021-01-20-19_26_38.iso
View File

Binary file not shown.

24
src/Home/Net/ARP.CC
View File

@ -91,7 +91,7 @@ CARPHash *ARPCacheFindByIP(U32 ip_address)
if (entry == NULL) if (entry == NULL)
{ {
ZenithWarn("ARP CACHE FIND BY IP: Could not find an IP in ARP cache.\n"); NetWarn("ARP CACHE FIND BY IP: Could not find an IP in ARP cache.");
} }
Free(ip_string); Free(ip_string);
@ -101,15 +101,15 @@ CARPHash *ARPCacheFindByIP(U32 ip_address)
CARPHash *ARPCachePut(U32 ip_address, U8 *mac_address) CARPHash *ARPCachePut(U32 ip_address, U8 *mac_address)
{ {
CARPHash *entry = ARPCacheFindByIP(ip_address); CARPHash *entry = ARPCacheFindByIP(ip_address);
ZenithLog("ARP CACHE PUT: Attempting to look for entry in ARP Cache.\n"); NetLog("ARP CACHE PUT: Attempting to look for entry in ARP Cache.");
//Free(entry); // something seems wrong about this... //Free(entry); // something seems wrong about this...
if (!entry) if (!entry)
{ {
entry = CAlloc(sizeof(CARPHash)); entry = CAlloc(sizeof(CARPHash));
ZenithLog("ARP CACHE PUT: Attempting add to cache: addr, mac: \n"); NetLog("ARP CACHE PUT: Attempting add to cache: addr, mac:");
ZenithLog(" 0x%0X, 0x%0X 0x%0X 0x%0X 0x%0X 0x%0X 0x%0X\n", NetLog(" 0x%0X, 0x%0X 0x%0X 0x%0X 0x%0X 0x%0X 0x%0X",
ip_address, mac_address[0], mac_address[1], mac_address[2], mac_address[3], mac_address[4], mac_address[5]); ip_address, mac_address[0], mac_address[1], mac_address[2], mac_address[3], mac_address[4], mac_address[5]);
entry->str = MStrPrint("%X", ip_address); entry->str = MStrPrint("%X", ip_address);
entry->type = HTT_ARP; entry->type = HTT_ARP;
@ -118,7 +118,7 @@ CARPHash *ARPCachePut(U32 ip_address, U8 *mac_address)
HashAdd(entry, arp_cache); HashAdd(entry, arp_cache);
} }
else else
ZenithWarn("ARP CACHE Put: Entry was already found in Cache. TODO: overwrite?\n"); NetWarn("ARP CACHE Put: Entry was already found in Cache. TODO: overwrite?");
return entry; return entry;
} }
@ -152,18 +152,18 @@ I64 ARPHandler(CEthernetFrame *ethernet_frame)
CARPHeader *header; CARPHeader *header;
U16 operation; U16 operation;
ZenithLog("ARP HANDLER: Entering ARP Handler.\n"); NetLog("ARP HANDLER: Entering ARP Handler.");
// shrine checks if frame ethertype is ARP and ensures length is not less than CARPHeader // shrine checks if frame ethertype is ARP and ensures length is not less than CARPHeader
// since revising Shrine implement, will do same checks for now .. // since revising Shrine implement, will do same checks for now ..
if (ethernet_frame->ethertype != ETHERTYPE_ARP) if (ethernet_frame->ethertype != ETHERTYPE_ARP)
{ {
ZenithErr("ARP HANDLER: Caught wrong frame ethertype.\n"); NetErr("ARP HANDLER: Caught wrong frame ethertype.");
return -1; // External use of ARPHandler must account for -1 error codes return -1; // External use of ARPHandler must account for -1 error codes
} }
if (ethernet_frame->length < sizeof(CARPHeader)) if (ethernet_frame->length < sizeof(CARPHeader))
{ {
ZenithErr("ARP HANDLER: Caught wrong frame length.\n"); NetErr("ARP HANDLER: Caught wrong frame length.");
return -1; // External use of ARPHandler must account for -1 error codes return -1; // External use of ARPHandler must account for -1 error codes
} }
@ -176,22 +176,22 @@ I64 ARPHandler(CEthernetFrame *ethernet_frame)
// hlen(?) != 6(?), and that plen(?) == 4 (?) // hlen(?) != 6(?), and that plen(?) == 4 (?)
if (EndianU16(header->hardware_type) != HTYPE_ETHERNET) if (EndianU16(header->hardware_type) != HTYPE_ETHERNET)
{ {
ZenithErr("ARP HANDLER: Caught wrong frame hardware type.\n"); NetErr("ARP HANDLER: Caught wrong frame hardware type.");
return -1; // External use of ARPHandler must account for -1 error codes return -1; // External use of ARPHandler must account for -1 error codes
} }
if (EndianU16(header->protocol_type) != ETHERTYPE_IPV4) if (EndianU16(header->protocol_type) != ETHERTYPE_IPV4)
{ {
ZenithErr("ARP HANDLER: Caught wrong frame protocol type.\n"); NetErr("ARP HANDLER: Caught wrong frame protocol type.");
return -1; // External use of ARPHandler must account for -1 error codes return -1; // External use of ARPHandler must account for -1 error codes
} }
if (header->hardware_addr_len != HLEN_ETHERNET) if (header->hardware_addr_len != HLEN_ETHERNET)
{ {
ZenithErr("ARP HANDLER: Caught wrong frame hardware address length.\n"); NetErr("ARP HANDLER: Caught wrong frame hardware address length.");
return -1; // External use of ARPHandler must account for -1 error codes return -1; // External use of ARPHandler must account for -1 error codes
} }
if (header->protocol_addr_len != PLEN_IPV4) if (header->protocol_addr_len != PLEN_IPV4)
{ {
ZenithErr("ARP HANDLER: Caught wrong frame protocol address length.\n"); NetErr("ARP HANDLER: Caught wrong frame protocol address length.");
return -1; // External use of ARPHandler must account for -1 error codes return -1; // External use of ARPHandler must account for -1 error codes
} }

72
src/Home/Net/DHCP.CC
View File

@ -95,7 +95,7 @@ I64 DHCPSendDiscover(U32 xid)
sizeof(CDHCPHeader) + sizeof(CDHCPDiscoverOptions)); sizeof(CDHCPHeader) + sizeof(CDHCPDiscoverOptions));
if (de_index < 0) if (de_index < 0)
{ {
ZenithErr("DHCP SEND DISCOVER: Failed, UDP Packet Allocate error.\n"); NetErr("DHCP SEND DISCOVER: Failed, UDP Packet Allocate error.");
return de_index; return de_index;
} }
@ -151,7 +151,7 @@ I64 DHCPSendRequest(U32 xid, U32 requested_ip, U32 server_ip)
sizeof(CDHCPHeader) + sizeof(CDHCPRequestOptions)); sizeof(CDHCPHeader) + sizeof(CDHCPRequestOptions));
if (de_index < 0) if (de_index < 0)
{ {
ZenithErr("DHCP SEND REQUEST: Failed, UDP Packet Allocate error.\n"); NetErr("DHCP SEND REQUEST: Failed, UDP Packet Allocate error.");
} }
dhcp = ethernet_frame; dhcp = ethernet_frame;
@ -197,7 +197,7 @@ I64 DHCPParseBegin(U8 **data_inout, I64 *length_inout, CDHCPHeader **header_out)
if (length < sizeof(CDHCPHeader) + 4) // + 4? if (length < sizeof(CDHCPHeader) + 4) // + 4?
{ {
ZenithErr("DHCP PARSE BEGIN: Failed, length too short.\n"); NetErr("DHCP PARSE BEGIN: Failed, length too short.");
return -1; return -1;
} }
@ -205,7 +205,7 @@ I64 DHCPParseBegin(U8 **data_inout, I64 *length_inout, CDHCPHeader **header_out)
if (EndianU32(*cookie) != DHCP_COOKIE) if (EndianU32(*cookie) != DHCP_COOKIE)
{ {
ZenithErr("DHCP PARSE BEGIN: Failed, cookie doesn't match DHCP-cookie.\n"); NetErr("DHCP PARSE BEGIN: Failed, cookie doesn't match DHCP-cookie.");
return -1; return -1;
} }
@ -223,13 +223,13 @@ I64 DHCPParseOption(U8 **data_inout, I64 *length_inout, U8 *type_out, U8 *value_
if (length < 2 || length < 2 + data[1]) // ??? what is the 1 if (length < 2 || length < 2 + data[1]) // ??? what is the 1
{ {
ZenithErr("DHCP PARSE OPTION: Failed, length too short.\n"); NetErr("DHCP PARSE OPTION: Failed, length too short.");
return -1; return -1;
} }
if (data[0] == 0xFF) // ahead, data[0] is type_out, so data[0] is perhaps usually type? if (data[0] == 0xFF) // ahead, data[0] is type_out, so data[0] is perhaps usually type?
{ {
ZenithLog("DHCP PARSE OPTION: Saw 0xFF, returning 0.\n"); NetLog("DHCP PARSE OPTION: Saw 0xFF, returning 0.");
return 0; return 0;
} }
@ -262,7 +262,7 @@ I64 DHCPParseOffer(U32 xid, U8 *data, I64 length,
if (EndianU32(header->xid) != xid) if (EndianU32(header->xid) != xid)
{ {
ZenithErr("DHCP PARSE OFFER: Failed, parsed and parameter Transaction IDs do not match.\n"); NetErr("DHCP PARSE OFFER: Failed, parsed and parameter Transaction IDs do not match.");
return -1; return -1;
} }
@ -272,7 +272,7 @@ I64 DHCPParseOffer(U32 xid, U8 *data, I64 length,
if (error < 0) if (error < 0)
{ {
ZenithErr("DHCP PARSE OFFER: Failed at DHCP Parse Option.\n"); NetErr("DHCP PARSE OFFER: Failed at DHCP Parse Option.");
return error; return error;
} }
if (error == 0) if (error == 0)
@ -283,13 +283,13 @@ I64 DHCPParseOffer(U32 xid, U8 *data, I64 length,
switch (type) switch (type)
{ {
case DHCP_OPTION_MESSAGETYPE: case DHCP_OPTION_MESSAGETYPE:
ZenithLog("DHCP PARSE OFFER: Parsed Option, Type MESSAGETYPE.\n"); NetLog("DHCP PARSE OFFER: Parsed Option, Type MESSAGETYPE.");
if (value_length == 1 && value[0] == DHCP_MESSAGETYPE_OFFER) if (value_length == 1 && value[0] == DHCP_MESSAGETYPE_OFFER)
have_type = TRUE; have_type = TRUE;
break; break;
case DHCP_OPTION_DNS: case DHCP_OPTION_DNS:
ZenithLog("DHCP PARSE OFFER: Parsed Option, Type DNS.\n"); NetLog("DHCP PARSE OFFER: Parsed Option, Type DNS.");
if (value_length == 4) if (value_length == 4)
{ {
*dns_ip_out = EndianU32(*(value(U32 *))); // TODO: this syntax used on last 3 cases is gross, alter it *dns_ip_out = EndianU32(*(value(U32 *))); // TODO: this syntax used on last 3 cases is gross, alter it
@ -298,7 +298,7 @@ I64 DHCPParseOffer(U32 xid, U8 *data, I64 length,
break; break;
case DHCP_OPTION_ROUTER: case DHCP_OPTION_ROUTER:
ZenithLog("DHCP PARSE OFFER: Parsed Option, Type ROUTER.\n"); NetLog("DHCP PARSE OFFER: Parsed Option, Type ROUTER.");
if (value_length == 4) if (value_length == 4)
{ {
*router_ip_out = EndianU32(*(value(U32 *))); // *router_ip_out = EndianU32(*(value(U32 *))); //
@ -307,7 +307,7 @@ I64 DHCPParseOffer(U32 xid, U8 *data, I64 length,
break; break;
case DHCP_OPTION_SUBNET_MASK: case DHCP_OPTION_SUBNET_MASK:
ZenithLog("DHCP PARSE OFFER: Parsed Option, Type SUBNET MASK.\n"); NetLog("DHCP PARSE OFFER: Parsed Option, Type SUBNET MASK.");
if (value_length == 4) if (value_length == 4)
{ {
*subnet_mask_out = EndianU32(*(value(U32 *))); // *subnet_mask_out = EndianU32(*(value(U32 *))); //
@ -320,16 +320,16 @@ I64 DHCPParseOffer(U32 xid, U8 *data, I64 length,
if (have_type && have_dns && have_subnet && have_router) if (have_type && have_dns && have_subnet && have_router)
{ {
*your_ip_out = EndianU32(header->your_ip); *your_ip_out = EndianU32(header->your_ip);
ZenithLog("DHCP PARSE OFFER: Success, got your-ip from DHCP Header.\n"); NetLog("DHCP PARSE OFFER: Success, got your-ip from DHCP Header.");
return 0; return 0;
} }
else else
{ {
ZenithErr("DHCP PARSE OFFER: Failed, did not have needed Options.\n"); NetErr("DHCP PARSE OFFER: Failed, did not have needed Options.");
ZenithErr(" have_type: %Z\n", have_type, "ST_FALSE_TRUE"); NetErr(" have_type: %Z", have_type, "ST_FALSE_TRUE");
ZenithErr(" have_dns: %Z\n", have_dns, "ST_FALSE_TRUE"); NetErr(" have_dns: %Z", have_dns, "ST_FALSE_TRUE");
ZenithErr(" have_router: %Z\n", have_router, "ST_FALSE_TRUE"); NetErr(" have_router: %Z", have_router, "ST_FALSE_TRUE");
ZenithErr(" have_subnet: %Z\n", have_subnet, "ST_FALSE_TRUE"); NetErr(" have_subnet: %Z", have_subnet, "ST_FALSE_TRUE");
return -1; return -1;
} }
} }
@ -344,7 +344,7 @@ I64 DHCPParseAck(U32 xid, U8 *data, I64 length)
if (EndianU32(header->xid) != xid) if (EndianU32(header->xid) != xid)
{ {
ZenithErr("DHCP PARSE ACK: Failed, parsed and parameter Transaction IDs do not match.\n"); NetErr("DHCP PARSE ACK: Failed, parsed and parameter Transaction IDs do not match.");
return -1; return -1;
} }
@ -354,7 +354,7 @@ I64 DHCPParseAck(U32 xid, U8 *data, I64 length)
if (error < 0) if (error < 0)
{ {
ZenithErr("DHCP PARSE ACK: Failed at DHCP Parse Option.\n"); NetErr("DHCP PARSE ACK: Failed at DHCP Parse Option.");
return error; return error;
} }
if (error == 0) if (error == 0)
@ -371,7 +371,7 @@ I64 DHCPParseAck(U32 xid, U8 *data, I64 length)
} }
} }
ZenithErr("DHCP PARSE ACK: Failed.\n"); NetErr("DHCP PARSE ACK: Failed.");
return -1; return -1;
} }
@ -402,7 +402,7 @@ I64 DHCPConfigureInner(CUDPSocket *udp_socket,
if (UDPSocketBind(udp_socket, &ipv4_addr) < 0) if (UDPSocketBind(udp_socket, &ipv4_addr) < 0)
{ {
ZenithErr("DHCP CONFIGURE INNER: Failed to Bind UDP Socket.\n"); NetErr("DHCP CONFIGURE INNER: Failed to Bind UDP Socket.");
return -1; return -1;
} }
@ -419,11 +419,11 @@ I64 DHCPConfigureInner(CUDPSocket *udp_socket,
break; break;
case DHCP_STATE_CLIENT_DISCOVER: case DHCP_STATE_CLIENT_DISCOVER:
ZenithLog("DHCP CONFIGURE INNER: Trying Discover.\n"); NetLog("DHCP CONFIGURE INNER: Trying Discover.");
error = DHCPSendDiscover(xid); error = DHCPSendDiscover(xid);
if (error < 0) if (error < 0)
{ {
ZenithErr("DHCP CONFIGURE INNER: Failed, DHCP Send Discover error.\n"); NetErr("DHCP CONFIGURE INNER: Failed, DHCP Send Discover error.");
return error; return error;
} }
@ -431,11 +431,11 @@ I64 DHCPConfigureInner(CUDPSocket *udp_socket,
if (count > 0) if (count > 0)
{ // 'Try a parse offer' { // 'Try a parse offer'
ZenithLog("DHCP CONFIGURE INNER: Trying Parse Offer.\n"); NetLog("DHCP CONFIGURE INNER: Trying Parse Offer.");
error = DHCPParseOffer(xid, buffer, count, your_ip_out, dns_ip_out, router_ip_out, subnet_mask_out); error = DHCPParseOffer(xid, buffer, count, your_ip_out, dns_ip_out, router_ip_out, subnet_mask_out);
if (error < 0) if (error < 0)
ZenithWarn("DHCP CONFIGURE INNER: Unsuccessful DHCP Parse Offer.\n"); NetWarn("DHCP CONFIGURE INNER: Unsuccessful DHCP Parse Offer.");
} }
if (count > 0 && error >= 0) // TODO: >= ? can DHCPSendDiscover or DHCPParseOffer return greater than zero? if (count > 0 && error >= 0) // TODO: >= ? can DHCPSendDiscover or DHCPParseOffer return greater than zero?
@ -446,19 +446,19 @@ I64 DHCPConfigureInner(CUDPSocket *udp_socket,
} }
else if (++retries == DHCP_MAX_RETRIES) else if (++retries == DHCP_MAX_RETRIES)
{ {
ZenithErr("DHCP CONFIGURE INNER: Failed, hit max retries in DHCP DISCOVER state.\n"); NetErr("DHCP CONFIGURE INNER: Failed, hit max retries in DHCP DISCOVER state.");
return -1; return -1;
} }
break; break;
case DHCP_STATE_CLIENT_REQUEST: case DHCP_STATE_CLIENT_REQUEST:
ZenithLog("DHCP CONFIGURE INNER: Trying Send Request.\n"); NetLog("DHCP CONFIGURE INNER: Trying Send Request.");
error = DHCPSendRequest(xid, *your_ip_out, dhcp_addr); error = DHCPSendRequest(xid, *your_ip_out, dhcp_addr);
if (error < 0) if (error < 0)
{ {
ZenithErr("DHCP CONFIGURE INNER: Failed, unsuccessful DHCP Send Request.\n"); NetErr("DHCP CONFIGURE INNER: Failed, unsuccessful DHCP Send Request.");
return error; return error;
} }
@ -469,7 +469,7 @@ I64 DHCPConfigureInner(CUDPSocket *udp_socket,
error = DHCPParseAck(xid, buffer, count); error = DHCPParseAck(xid, buffer, count);
if (error < 0) if (error < 0)
ZenithWarn("DHCP CONFIGURE INNER: Unsuccessful DHCP Parse Ack.\n"); NetWarn("DHCP CONFIGURE INNER: Unsuccessful DHCP Parse Ack.");
} }
if (count > 0 && error >= 0) // see above TODO if (count > 0 && error >= 0) // see above TODO
@ -479,7 +479,7 @@ I64 DHCPConfigureInner(CUDPSocket *udp_socket,
} }
else if (++retries == DHCP_MAX_RETRIES) else if (++retries == DHCP_MAX_RETRIES)
{ {
ZenithErr("DHCP CONFIGURE INNER: Failed, hit max retries in DHCP REQUEST state.\n"); NetErr("DHCP CONFIGURE INNER: Failed, hit max retries in DHCP REQUEST state.");
return -1; return -1;
} }
@ -505,7 +505,7 @@ I64 DHCPConfigure()
if (state == DHCP_STATE_CLIENT_REQ_ACCEPTED) if (state == DHCP_STATE_CLIENT_REQ_ACCEPTED)
{ {
address.address = EndianU32(your_ip); address.address = EndianU32(your_ip);
ZenithLog("$$FG,2$$DHCP CONFIGURE: Obtained IPV4 Address! : %s $$FG$$\n", NetworkToPresentation(AF_INET, &address)); NetLog("$$BG,2$$$$FG,15$$DHCP CONFIGURE: Obtained IPV4 Address! : %s $$BG$$$$FG$$", NetworkToPresentation(AF_INET, &address));
IPV4SetAddress(your_ip); IPV4SetAddress(your_ip);
IPV4SetSubnet(router_ip, subnet_mask); IPV4SetSubnet(router_ip, subnet_mask);
@ -514,7 +514,7 @@ I64 DHCPConfigure()
} }
else else
{ {
ZenithErr("$$FG,4$$DHCP CONFIGURE: Failed, incorrect state.$$FG$$\n"); NetErr("$$BG,4$$DHCP CONFIGURE: Failed, incorrect state.$$BG$$");
return -1; return -1;
} }
} }
@ -524,11 +524,11 @@ U0 NetConfigure()
{ {
I64 error; I64 error;
ZenithLog("==== Configuring Network. ====\n"); NetLog("==== Configuring Network. ====");
error = DHCPConfigure(); error = DHCPConfigure();
if (error < 0) if (error < 0)
ZenithLog("$$FG,4$$==== Network Configure Failed ====$$FG$$\n"); NetErr("==== Network Configure Failed ====");
else else
ZenithLog("$$FG,2$$==== Network Configure Success ====$$FG$$\n"); NetLog("$$BG,2$$$$FG,15$$==== Network Configure Success ====$$FG$$$$BG$$");
} }

42
src/Home/Net/DNS.CC
View File

@ -16,9 +16,9 @@
#define DNS_CLASS_IN 1 #define DNS_CLASS_IN 1
#define DNS_TIMEOUT 1000 #define DNS_TIMEOUT 5000
#define DNS_MAX_RETRIES 20 // Shrine has 3, why not 5? :^) #define DNS_MAX_RETRIES 5
class CDNSHash:CHash class CDNSHash:CHash
{ // store U8 *hostname as CHash->str U8 * { // store U8 *hostname as CHash->str U8 *
@ -85,14 +85,14 @@ CDNSHash *DNSCacheFind(U8 *hostname)
CDNSHash *entry = HashFind(hostname, dns_cache, HTT_DNS); CDNSHash *entry = HashFind(hostname, dns_cache, HTT_DNS);
if (entry == NULL) if (entry == NULL)
ZenithWarn("DNS CACHE FIND: Could not find a hostname in the DNS Cache.\n"); NetWarn("DNS CACHE FIND: Could not find a hostname in the DNS Cache.");
return entry; return entry;
} }
CDNSHash *DNSCachePut(U8 *hostname, CAddressInfo *info) CDNSHash *DNSCachePut(U8 *hostname, CAddressInfo *info)
{ {
ZenithLog("DNS CACHE PUT: Attempting Find DNS Entry in Cache: hostname: %s\n", hostname); NetLog("DNS CACHE PUT: Attempting Find DNS Entry in Cache: hostname: %s", hostname);
CDNSHash *entry = DNSCacheFind(hostname); CDNSHash *entry = DNSCacheFind(hostname);
if (!entry) if (!entry)
@ -106,7 +106,7 @@ CDNSHash *DNSCachePut(U8 *hostname, CAddressInfo *info)
HashAdd(entry, dns_cache); HashAdd(entry, dns_cache);
} }
else else
ZenithWarn("DNS CACHE PUT: Entry was already found in Cache. TODO: overwrite?"); NetWarn("DNS CACHE PUT: Entry was already found in Cache. TODO: overwrite?");
return entry; return entry;
} }
@ -156,11 +156,11 @@ I64 DNSSendQuestion(U16 id, U16 local_port, CDNSQuestion *q)
switch (dns_globals.addr_family) switch (dns_globals.addr_family)
{ {
case AF_UNSPEC: // 0, global dns ip not set case AF_UNSPEC: // 0, global dns ip not set
ZenithErr("DNS SEND QUESTION: Failed, global dns addr family was AF_UNSPEC.\n"); NetErr("DNS SEND QUESTION: Failed, global dns addr family was AF_UNSPEC.");
return -1; return -1;
case AF_INET6: case AF_INET6:
ZenithErr("DNS SEND QUESTION: Failed, IPV6 not supported yet in DNS.\n"); NetErr("DNS SEND QUESTION: Failed, IPV6 not supported yet in DNS.");
throw('DNS'); throw('DNS');
case AF_INET: case AF_INET:
@ -168,7 +168,7 @@ I64 DNSSendQuestion(U16 id, U16 local_port, CDNSQuestion *q)
if (!*ipv4_addr) if (!*ipv4_addr)
{ {
ZenithErr("DNS SEND QUESTION: Failed, ipv4_addr had no value set.\n"); NetErr("DNS SEND QUESTION: Failed, ipv4_addr had no value set.");
return -1; return -1;
} }
} }
@ -182,7 +182,7 @@ I64 DNSSendQuestion(U16 id, U16 local_port, CDNSQuestion *q)
sizeof(CDNSHeader) + DNSCalculateQuestionSize(q)); sizeof(CDNSHeader) + DNSCalculateQuestionSize(q));
if (de_index < 0) if (de_index < 0)
{ {
ZenithErr("DNS SEND QUESTION: Failed, UDPPacketAllocate returned error.\n"); NetErr("DNS SEND QUESTION: Failed, UDPPacketAllocate returned error.");
return de_index; return de_index;
} }
@ -215,7 +215,7 @@ I64 DNSParseDomainName(U8 *packet_data, I64 packet_length, U8 **data_inout, I64
if (length < 1) if (length < 1)
{ {
ZenithErr("DNS PARSE DOMAIN NAME: Length less than one.\n"); NetErr("DNS PARSE DOMAIN NAME: Length less than one.");
return -1; return -1;
} }
@ -241,7 +241,7 @@ I64 DNSParseDomainName(U8 *packet_data, I64 packet_length, U8 **data_inout, I64
*data_inout = data + 1; *data_inout = data + 1;
*length_inout = length - 1; *length_inout = length - 1;
jump_taken = TRUE; jump_taken = TRUE;
ZenithLog("DNS PARSE DOMAIN NAME: Jump taken\n"); NetLog("DNS PARSE DOMAIN NAME: Jump taken");
} }
data = packet_data + ((label_len << 8) | *data); data = packet_data + ((label_len << 8) | *data);
@ -341,7 +341,7 @@ I64 DNSParseResponse(U16 id, U8 *data, I64 length, CDNSHeader **header_out, CDNS
if (length < sizeof(CDNSHeader)) if (length < sizeof(CDNSHeader))
{ {
ZenithErr("DNS PARSE RESPONSE: Length too short.\n"); NetErr("DNS PARSE RESPONSE: Length too short.");
return -1; return -1;
} }
@ -350,7 +350,7 @@ I64 DNSParseResponse(U16 id, U8 *data, I64 length, CDNSHeader **header_out, CDNS
if (id != 0 && EndianU16(header->id) != id) if (id != 0 && EndianU16(header->id) != id)
{ {
ZenithErr("DNS PARSE RESPONSE: Header ID mismatch.\n"); NetErr("DNS PARSE RESPONSE: Header ID mismatch.");
return -1; return -1;
} }
@ -477,7 +477,7 @@ I64 DNSRunQuery(CUDPSocket *udp_socket, U8 *name, U16 port, CAddressInfo **resul
// UDPSocketBind will be attempted on the udp_socket param, method expects a UDPSocket() result to be made already // UDPSocketBind will be attempted on the udp_socket param, method expects a UDPSocket() result to be made already
if (UDPSocketBind(udp_socket, &ipv4_addr)) // expected return value is 0 if (UDPSocketBind(udp_socket, &ipv4_addr)) // expected return value is 0
{ {
ZenithErr("DNS RUN QUERY: Failed to bind UDP socket.\n"); NetErr("DNS RUN QUERY: Failed to bind UDP socket.");
return -1; return -1;
} }
@ -488,7 +488,7 @@ I64 DNSRunQuery(CUDPSocket *udp_socket, U8 *name, U16 port, CAddressInfo **resul
error = DNSSendQuestion(id, local_port, &q); error = DNSSendQuestion(id, local_port, &q);
if (error < 0) if (error < 0)
{ {
ZenithErr("DNS RUN QUERY: Failed to Send Question.\n"); NetErr("DNS RUN QUERY: Failed to Send Question.");
return -1; return -1;
} }
@ -496,7 +496,7 @@ I64 DNSRunQuery(CUDPSocket *udp_socket, U8 *name, U16 port, CAddressInfo **resul
if (count > 0) if (count > 0)
{ {
ZenithLog("DNS RUN QUERY: Trying Parse Response.\n"); NetLog("DNS RUN QUERY: Trying Parse Response.");
header = NULL; header = NULL;
questions = NULL; questions = NULL;
@ -554,18 +554,18 @@ I64 DNSRunQuery(CUDPSocket *udp_socket, U8 *name, U16 port, CAddressInfo **resul
// Shrine comment: 'at this point, we could try iterative resolution, // Shrine comment: 'at this point, we could try iterative resolution,
// but all end-user DNS servers would have tried that already' // but all end-user DNS servers would have tried that already'
ZenithErr("DNS RUN QUERY: Failed to find suitable answer in reply.\n"); NetErr("DNS RUN QUERY: Failed to find suitable answer in reply.");
error = -1; error = -1;
} }
else else
{ {
ZenithErr("DNS RUN QUERY: Failed a DNS Parse Response.\n"); NetErr("DNS RUN QUERY: Failed a DNS Parse Response.");
} }
} }
if (++retries == DNS_MAX_RETRIES) if (++retries == DNS_MAX_RETRIES)
{ {
ZenithErr("DNS RUN QUERY: Failed, max retries reached.\n"); NetErr("DNS RUN QUERY: Failed, max retries reached.");
error = -1; error = -1;
break; break;
} }
@ -602,7 +602,7 @@ I64 DNSGetAddressInfo(U8 *node_name, U16 port, CAddressInfo **result)
} }
else else
{ {
ZenithErr("DNS GET ADDRESS INFO: Failed to make UDP Socket.\n"); NetErr("DNS GET ADDRESS INFO: Failed to make UDP Socket.");
error = -1; error = -1;
} }
@ -626,7 +626,7 @@ U0 Host(U8 *hostname)
if (error < 0) if (error < 0)
{ {
ZenithErr("HOST(): Failed at DNS Get Address Info.\n"); NetErr("HOST(): Failed at DNS Get Address Info.");
} }
else else
{ {

BIN
src/Home/Net/Docs/ZenithStackNotes.DD
View File

Binary file not shown.

2
src/Home/Net/Ethernet.CC
View File

@ -36,7 +36,7 @@ U0 EthernetFrameParse(CEthernetFrame *frame_out, U8 *frame, U16 length)
//of the current system should be done with less extra allocation //of the current system should be done with less extra allocation
//altogether, more passing. //altogether, more passing.
ZenithLog("ETHERNET FRAME PARSE: Parsing frame, copying out to frame_out param.\n"); NetLog("ETHERNET FRAME PARSE: Parsing frame, copying out to frame_out param.");
MemCopy(frame_out->destination_address, frame, MAC_ADDRESS_LENGTH); MemCopy(frame_out->destination_address, frame, MAC_ADDRESS_LENGTH);

4
src/Home/Net/ICMP.CC
View File

@ -32,7 +32,7 @@ I64 ICMPSendReply(U32 destination_ip_address,
sizeof(CICMPHeader) + length); sizeof(CICMPHeader) + length);
if (de_index < 0) if (de_index < 0)
{ {
ZenithErr("ICMP SEND REPLY: Failed to allocate IPV4 packet.\n"); NetErr("ICMP SEND REPLY: Failed to allocate IPV4 packet.");
return de_index; return de_index;
} }
@ -57,7 +57,7 @@ I64 ICMPHandler(CIPV4Packet *packet)
if (packet->length < sizeof(CICMPHeader)) if (packet->length < sizeof(CICMPHeader))
{ {
ZenithErr("ICMP HANDLER: Caught wrong IPV4 length.\n"); NetErr("ICMP HANDLER: Caught wrong IPV4 length.");
return -1; return -1;
} }

14
src/Home/Net/IPV4.CC
View File

@ -98,12 +98,12 @@ I64 GetMACAddressForIP(U32 ip_address, U8 **mac_out)
if (ip_address == 0) if (ip_address == 0)
{ {
ZenithErr("GET MAC FOR IP: Failed. Address = 0\n"); NetErr("GET MAC FOR IP: Failed. Address = 0");
return IPV4_ERR_ADDR_INVALID; return IPV4_ERR_ADDR_INVALID;
} }
if (ip_address == 0xFFFFFFFF) if (ip_address == 0xFFFFFFFF)
{ {
ZenithLog("GET MAC FOR IP: Returning ethernet broadcast\n"); NetLog("GET MAC FOR IP: Returning ethernet broadcast");
*mac_out = ethernet_globals.ethernet_broadcast; *mac_out = ethernet_globals.ethernet_broadcast;
return 0; return 0;
@ -113,12 +113,12 @@ I64 GetMACAddressForIP(U32 ip_address, U8 **mac_out)
if ((ip_address & ipv4_globals.ipv4_subnet_mask) != (ipv4_globals.local_ip & ipv4_globals.ipv4_subnet_mask)) if ((ip_address & ipv4_globals.ipv4_subnet_mask) != (ipv4_globals.local_ip & ipv4_globals.ipv4_subnet_mask))
{ {
// TODO: Shrine recurses here... and says FIXME infinite loop if mis-configured... // TODO: Shrine recurses here... and says FIXME infinite loop if mis-configured...
ZenithWarn("GET MAC FOR IP: TODO: Doing GetMACAddressForIP recursion, could infinite loop and overflow stack."); NetWarn("GET MAC FOR IP: TODO: Doing GetMACAddressForIP recursion, could infinite loop and overflow stack.");
return GetMACAddressForIP(ipv4_globals.ipv4_router_address, mac_out); return GetMACAddressForIP(ipv4_globals.ipv4_router_address, mac_out);
} }
else // "local network" else // "local network"
{ {
ZenithLog("GET MAC FOR IP: Attempting ARP Find by IP for address: %d.\n", ip_address); NetLog("GET MAC FOR IP: Attempting ARP Find by IP for address: %d.", ip_address);
entry = ARPCacheFindByIP(ip_address); entry = ARPCacheFindByIP(ip_address);
if (entry) if (entry)
@ -158,7 +158,7 @@ I64 GetMACAddressForIP(U32 ip_address, U8 **mac_out)
} }
//Shrine does some in_addr mess to log error //Shrine does some in_addr mess to log error
ZenithErr("GET MAC FOR IP: Failed to resolve address %d\n", ip_address); NetErr("GET MAC FOR IP: Failed to resolve address %d", ip_address);
return IPV4_ERR_HOST_UNREACHABLE; return IPV4_ERR_HOST_UNREACHABLE;
} }
} }
@ -180,7 +180,7 @@ I64 IPV4PacketAllocate(U8 **frame_out,
if (error < 0) if (error < 0)
{ {
ZenithLog("IPV4 PACKET ALLOCATE: Failed to get MAC for destination.\n"); NetLog("IPV4 PACKET ALLOCATE: Failed to get MAC for destination.");
return error; return error;
} }
@ -191,7 +191,7 @@ I64 IPV4PacketAllocate(U8 **frame_out,
sizeof(CIPV4Header) + length); sizeof(CIPV4Header) + length);
if (de_index < 0) if (de_index < 0)
{ {
ZenithLog("IPV4 PACKET ALLOCATE: Ethernet Frame Allocate failed.\n"); NetLog("IPV4 PACKET ALLOCATE: Ethernet Frame Allocate failed.");
return de_index; return de_index;
} }

30
src/Home/Net/NetHandlerTask.CC → src/Home/Net/NetHandler.CC
View File

@ -9,7 +9,7 @@ U0 IPV4Handler(CEthernetFrame *ethernet_frame)
switch (packet.protocol) switch (packet.protocol)
{ {
case IP_PROTOCOL_ICMP: case IP_PROTOCOL_ICMP:
ZenithLog("IPV4 HANDLER: ICMP.\n"); NetLog("IPV4 HANDLER: ICMP.");
ICMPHandler(&packet); ICMPHandler(&packet);
break; break;
@ -17,7 +17,7 @@ U0 IPV4Handler(CEthernetFrame *ethernet_frame)
break; break;
case IP_PROTOCOL_UDP: case IP_PROTOCOL_UDP:
ZenithLog("IPV4 HANDLER: UDP.\n"); NetLog("IPV4 HANDLER: UDP.");
UDPHandler(&packet); UDPHandler(&packet);
break; break;
} }
@ -32,37 +32,33 @@ U0 HandleNetQueueEntry(CNetQueueEntry *entry)
switch (ethernet_frame.ethertype) switch (ethernet_frame.ethertype)
{ {
case ETHERTYPE_ARP: case ETHERTYPE_ARP:
ZenithLog("HANDLE NETQUEUE ENTRY: ARP.\n"); NetLog("HANDLE NETQUEUE ENTRY: ARP.");
ARPHandler(&ethernet_frame); ARPHandler(&ethernet_frame);
break; break;
case ETHERTYPE_IPV4: case ETHERTYPE_IPV4:
ZenithLog("HANDLE NETQUEUE ENTRY: IPV4.\n"); NetLog("HANDLE NETQUEUE ENTRY: IPV4.");
IPV4Handler(&ethernet_frame); IPV4Handler(&ethernet_frame);
break; break;
} }
} }
U0 NetHandlerTask(I64) interrupt U0 NetHandler()
{
while (TRUE)
{ {
CNetQueueEntry *entry = NetQueuePull(); CNetQueueEntry *entry = NetQueuePull();
if (entry) if (entry)
{ {
ZenithLog("NET HANDLER TASK: Caught NetQueue Entry, handling.\n"); NetLog("NET HANDLER TASK: Caught NetQueue Entry, handling.");
HandleNetQueueEntry(entry); HandleNetQueueEntry(entry);
} }
else
*(dev.uncached_alias + LAPIC_EOI)(U32*) = 0;
}
U0 NetHandlerInit()
{ {
LBts(&Fs->task_flags, TASKf_IDLE); IntEntrySet(I_NETHANDLER, &NetHandler);
//ZenithLog("IDLE: NetHandler\n");
Yield;
} }
} NetHandlerInit;
ZenithErr("Net Handler Task exit! Debug!\n"); // shouldn't ever reach this
}
net_handler_task = Spawn(&NetHandlerTask, NULL, "NetQueueHandler");

48
src/Home/Net/NetLog.CC Executable file
View File

@ -0,0 +1,48 @@
CTask *net_log_task = NULL;
U0 NetLogTask(I64)
{
while (TRUE)
{
Refresh;
}
}
U0 NetLogInit()
{
net_log_task = Spawn(&ServerCmdLine, NULL, "Network Log");
TaskWait(net_log_task);
WinTileHorz;
WinFocus;
}
U0 NetLog(U8 *format, ...)
{ // Output text to NetLogTask as Log.
U8 *buf = StrPrintJoin(NULL, format, argc, argv);
DocBottom(net_log_task->put_doc);
DocPrint(net_log_task->put_doc, "$$LTGRAY$$%s$$FG$$\n", buf);
}
U0 NetWarn(U8 *format, ...)
{ // Output text to NetLogTask as Warning.
U8 *buf = StrPrintJoin(NULL, format, argc, argv);
DocBottom(net_log_task->put_doc);
DocPrint(net_log_task->put_doc, "$$BG,BROWN$$$$WHITE$$%s$$BG$$$$FG$$\n", buf);
}
U0 NetErr(U8 *format, ...)
{ // Output text to NetLogTask as Error.
U8 *buf = StrPrintJoin(NULL, format, argc, argv);
DocBottom(net_log_task->put_doc);
DocPrint(net_log_task->put_doc, "$$BG,RED$$$$WHITE$$%s$$BG$$$$FG$$\n", buf);
}
NetLogInit;

22
src/Home/Net/NetQueue.CC
View File

@ -23,12 +23,17 @@ class CNetQueueEntry:CQueue
CQueue *net_queue; // no QueueRemove the Head! only Entries! CQueue *net_queue; // no QueueRemove the Head! only Entries!
/* Net Handler Task is set idle and active depending /* PCNet reroutes PCI interrupts to software. See $LK,"PCNet",A="FF:C:/Home/Net/PCNet.CC,I_PCNET0"$.
on if entries in Net Queue. See $LK,"NetHandlerTask",A="FF:C:/Home/Net/NetHandlerTask.CC,net_handler_task"$ */ Net Handler interrupt is generated whenever an entry is
pushed to the NetQueue. See $LK,"NetHandler",A="FF:C:/Home/Net/NetHandler.CC,I_NETHANDLER"$ */
CTask *net_handler_task = NULL;
#define I_PCNET0 I_USER + 0
#define I_PCNET1 I_USER + 1
#define I_PCNET2 I_USER + 2
#define I_PCNET3 I_USER + 3
#define I_NETHANDLER I_USER + 4
#define INT_DEST_CPU 0
U0 NetQueueInit() U0 NetQueueInit()
{ {
@ -46,7 +51,7 @@ CNetQueueEntry *NetQueuePull()
{ {
entry = net_queue->next; entry = net_queue->next;
ZenithLog("NETQUEUE PULL: Removing entry from queue.\n"); NetLog("NETQUEUE PULL: Removing entry from queue.");
QueueRemove(entry); QueueRemove(entry);
} }
else // Queue is empty if head->next is head itself. else // Queue is empty if head->next is head itself.
@ -71,10 +76,9 @@ U0 NetQueuePushCopy(U8 *data, I64 length)
QueueInsert(entry, net_queue->last); QueueInsert(entry, net_queue->last);
//Set Net Handler Task active. // Generate Net Handler interrupt.
ZenithLog("NETQUEUE PUSH COPY: Setting NetHandler ACTIVE.\n"); NetLog("NETQUEUE PUSH COPY: Generating NetHandler interrupt.");
if (net_handler_task) MPInt(I_NETHANDLER, INT_DEST_CPU);
LBtr(&net_handler_task->task_flags, TASKf_IDLE);
} }

28
src/Home/Net/NetStart.CC
View File

@ -1,16 +1,7 @@
if (Fs != zenith_task)
{
WinVert(2, zenith_task->win_bottom + zenith_task->win_bottom / 3, zenith_task);
WinVert(zenith_task->win_bottom + 3, TEXT_ROWS - 2);
}
else
{
WinVert(2, zenith_task->win_bottom + zenith_task->win_bottom / 3, zenith_task);
WinVert(zenith_task->win_bottom + 3, TEXT_ROWS - 2, zenith_task->next_task);
}
#include "C:/Home/Net/Net.HH" #include "C:/Home/Net/Net.HH"
#include "C:/Home/Net/NetLog"
#include "C:/Home/Net/NetQueue" #include "C:/Home/Net/NetQueue"
#include "C:/Home/Net/PCNet" #include "C:/Home/Net/PCNet"
#include "C:/Home/Net/Ethernet" #include "C:/Home/Net/Ethernet"
@ -26,15 +17,26 @@ else
#include "C:/Home/Net/DNS" #include "C:/Home/Net/DNS"
#include "C:/Home/Net/DHCP" #include "C:/Home/Net/DHCP"
#include "C:/Home/Net/NetHandlerTask" // needs IPV4, UDP, ICMP #include "C:/Home/Net/NetHandler" // needs IPV4, UDP, ICMP
if (Fs != zenith_task) if (Fs != zenith_task)
{ {
NetConfigure; NetConfigure;
"\nNow run one of the $MA,"Tests",LM="Cd(\"C:/Home/Net/Tests\");Dir;\n"$.\n\n"; if (ipv4_globals.local_ip != 0) // is set if NetConfigure is successful
{
"\nNow run one of the $MA,"Tests",LM="Cd(\"C:/Home/Net/Tests\");Dir;\n"$.\n";
"\nIf a test crashes to Debug, try typing $FG,0$G2;$FG$\n\n";
}
else
{
"\nNetConfigure unsuccessful. See Network Log for details.\n\n";
}
} }
else else
{ {
XTalkStr(zenith_task->next_task, "NetConfigure;\n"); XTalkStr(zenith_task->next_task, "NetConfigure;\n");
} }

74
src/Home/Net/PCNet.CC
View File

@ -78,8 +78,6 @@
#define PCNET_DESCRIPTORf_OWN 31 // AMD PCNet datasheet p.1-992, 1-994 #define PCNET_DESCRIPTORf_OWN 31 // AMD PCNet datasheet p.1-992, 1-994
//#define PCNET_DESCRIPTORF_OWN (1 << PCNET_DESCRIPTORf_OWN) //#define PCNET_DESCRIPTORF_OWN (1 << PCNET_DESCRIPTORf_OWN)
#define INT_DEST_CPU 0
class CPCNet class CPCNet
{ {
CPCIDev *pci; CPCIDev *pci;
@ -217,14 +215,12 @@ U0 PCNetGetMAC()
APROM accessible at first 16 bytes of PCI IO space. */ APROM accessible at first 16 bytes of PCI IO space. */
I64 i; I64 i;
ZenithLog("PCNET GET MAC: Getting VM MAC.\n"); NetLog("PCNET GET MAC: Getting VM MAC.");
ZenithLog(" ");
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++)
{ {
pcnet.mac_address[i] = InU8(PCNetGetIOBase() + i); pcnet.mac_address[i] = InU8(PCNetGetIOBase() + i);
ZenithLog(" %02X", pcnet.mac_address[i]); NetLog(" %02X", pcnet.mac_address[i]);
} }
ZenithLog("\n");
} }
U0 PCNetInitDescriptorEntry(CPCNetDescriptorEntry *entry, U32 buffer_address, I64 is_rx) U0 PCNetInitDescriptorEntry(CPCNetDescriptorEntry *entry, U32 buffer_address, I64 is_rx)
@ -322,11 +318,11 @@ U0 PCNetDirectInit()
The OR and bit-shift of 8 allows writing The OR and bit-shift of 8 allows writing
separate U8 values in the correct locations separate U8 values in the correct locations
of the CSR. */ of the CSR. */
ZenithLog("PCNetDirectInit: Write MAC to CSR: 0x%X \n", pcnet.mac_address[0] | (pcnet.mac_address[1] << 8)); NetLog("PCNetDirectInit: Write MAC to CSR: 0x%X ", pcnet.mac_address[0] | (pcnet.mac_address[1] << 8));
PCNetWriteCSR(PCNET_CSR_PADR0, pcnet.mac_address[0] | (pcnet.mac_address[1] << 8)); PCNetWriteCSR(PCNET_CSR_PADR0, pcnet.mac_address[0] | (pcnet.mac_address[1] << 8));
ZenithLog("PCNetDirectInit: Write MAC to CSR: 0x%X \n", pcnet.mac_address[2] | (pcnet.mac_address[3] << 8)); NetLog("PCNetDirectInit: Write MAC to CSR: 0x%X ", pcnet.mac_address[2] | (pcnet.mac_address[3] << 8));
PCNetWriteCSR(PCNET_CSR_PADR1, pcnet.mac_address[2] | (pcnet.mac_address[3] << 8)); PCNetWriteCSR(PCNET_CSR_PADR1, pcnet.mac_address[2] | (pcnet.mac_address[3] << 8));
ZenithLog("PCNetDirectInit: Write MAC to CSR: 0x%X \n", pcnet.mac_address[4] | (pcnet.mac_address[5] << 8)); NetLog("PCNetDirectInit: Write MAC to CSR: 0x%X ", pcnet.mac_address[4] | (pcnet.mac_address[5] << 8));
PCNetWriteCSR(PCNET_CSR_PADR2, pcnet.mac_address[4] | (pcnet.mac_address[5] << 8)); PCNetWriteCSR(PCNET_CSR_PADR2, pcnet.mac_address[4] | (pcnet.mac_address[5] << 8));
/* AMD PCNet datasheet p.1-961, 1-962, 1-963 /* AMD PCNet datasheet p.1-961, 1-962, 1-963
@ -466,7 +462,7 @@ I64 PCNetAllocateTransmitPacket(U8 **packet_buffer_out, I64 length)
if (length > 0xFFF) if (length > 0xFFF)
{ // Max packet length must fit into BCNT 12-bit register. { // Max packet length must fit into BCNT 12-bit register.
ZenithErr("PCNET ALLOCATE TX PACKET: Invalid TX Packet Length\n"); NetErr("PCNET ALLOCATE TX PACKET: Invalid TX Packet Length");
throw('PCNet'); throw('PCNet');
} }
@ -474,12 +470,12 @@ I64 PCNetAllocateTransmitPacket(U8 **packet_buffer_out, I64 length)
if (!PCNetDriverOwns(entry)) if (!PCNetDriverOwns(entry))
{ {
ZenithErr("PCNET ALLOCATE TX PACKET: TX FIFO Full\n"); NetErr("PCNET ALLOCATE TX PACKET: TX FIFO Full");
return -1; // Positive value expected. Functions calling this must factor this in. return -1; // Positive value expected. Functions calling this must factor this in.
} }
else else
{ {
ZenithLog("PCNET ALLOCATE TX PACKET: Driver owns TX DE at index %d.\n", de_index); NetLog("PCNET ALLOCATE TX PACKET: Driver owns TX DE at index %d.", de_index);
} }
Bts(&entry->status1, PCNET_DESCRIPTORf_STP); Bts(&entry->status1, PCNET_DESCRIPTORf_STP);
@ -505,7 +501,7 @@ I64 PCNetAllocateTransmitPacket(U8 **packet_buffer_out, I64 length)
MemSet(*packet_buffer_out, 0, ETHERNET_FRAME_SIZE); // Clear buffer contents in advance. MemSet(*packet_buffer_out, 0, ETHERNET_FRAME_SIZE); // Clear buffer contents in advance.
ZenithLog("PCNET ALLOCATE TX PACKET: de_index: %X.\n", de_index); NetLog("PCNET ALLOCATE TX PACKET: de_index: %X.", de_index);
return de_index; return de_index;
} }
@ -516,7 +512,7 @@ U0 PCNetFinishTransmitPacket(I64 de_index)
CPCNetDescriptorEntry *entry = &pcnet.tx_de_buffer[de_index * sizeof(CPCNetDescriptorEntry)]; CPCNetDescriptorEntry *entry = &pcnet.tx_de_buffer[de_index * sizeof(CPCNetDescriptorEntry)];
Bts(&entry->status1, PCNET_DESCRIPTORf_OWN); Bts(&entry->status1, PCNET_DESCRIPTORf_OWN);
ZenithLog("PCNet FINISH TX PACKET: TX DE index: %X, OWN bit of entry at entry: %b.\n", NetLog("PCNet FINISH TX PACKET: TX DE index: %X, OWN bit of entry at entry: %b.",
de_index, Bt(&entry->status1, PCNET_DESCRIPTORf_OWN)); de_index, Bt(&entry->status1, PCNET_DESCRIPTORf_OWN));
} }
@ -539,7 +535,7 @@ I64 PCNetReceivePacket(U8 **packet_buffer_out, U16 *packet_length_out)
I64 de_index = pcnet.current_rx_de_index; I64 de_index = pcnet.current_rx_de_index;
U16 packet_length; U16 packet_length;
ZenithLog("PCNET RECEIVE PACKET: PCNet received packet. %X , %X \n", packet_buffer_out, packet_length_out); NetLog("PCNET RECEIVE PACKET: PCNet received packet. %X , %X ", packet_buffer_out, packet_length_out);
CPCNetDescriptorEntry *entry = &pcnet.rx_de_buffer[de_index * sizeof(CPCNetDescriptorEntry)]; CPCNetDescriptorEntry *entry = &pcnet.rx_de_buffer[de_index * sizeof(CPCNetDescriptorEntry)];
@ -576,13 +572,13 @@ interrupt U0 PCNetIRQ()
while (PCNetDriverOwns(&entry[pcnet.current_rx_de_index])) while (PCNetDriverOwns(&entry[pcnet.current_rx_de_index]))
{ {
ZenithLog("PCNET IRQ: Saw owned RX DE index %d.\n", pcnet.current_rx_de_index); NetLog("PCNET IRQ: Saw owned RX DE index %d.", pcnet.current_rx_de_index);
de_index = PCNetReceivePacket(&packet_buffer, &packet_length); de_index = PCNetReceivePacket(&packet_buffer, &packet_length);
if (de_index >= 0) // necessary? check increment logic in PCNetReceivePacket. if (de_index >= 0) // necessary? check increment logic in PCNetReceivePacket.
{ {
ZenithLog("PCNET IRQ: Pushing copy into Net Queue, Releasing Receive Packet\n"); NetLog("PCNET IRQ: Pushing copy into Net Queue, Releasing Receive Packet");
NetQueuePushCopy(packet_buffer, packet_length); NetQueuePushCopy(packet_buffer, packet_length);
PCNetReleaseReceivePacket(de_index); PCNetReleaseReceivePacket(de_index);
} }
@ -612,11 +608,11 @@ U0 PCIRerouteInterrupts(I64 base)
U0 PCNetSetupInterrupts() U0 PCNetSetupInterrupts()
{ // todo: comments explaining process { // todo: comments explaining process
IntEntrySet(I_USER + 0, &PCNetIRQ, IDTET_IRQ); IntEntrySet(I_PCNET0, &PCNetIRQ);
IntEntrySet(I_USER + 1, &PCNetIRQ, IDTET_IRQ); IntEntrySet(I_PCNET1, &PCNetIRQ);
IntEntrySet(I_USER + 2, &PCNetIRQ, IDTET_IRQ); IntEntrySet(I_PCNET2, &PCNetIRQ);
IntEntrySet(I_USER + 3, &PCNetIRQ, IDTET_IRQ); IntEntrySet(I_PCNET3, &PCNetIRQ);
PCIRerouteInterrupts(I_USER); PCIRerouteInterrupts(I_PCNET0);
} }
U0 PCNetInit() U0 PCNetInit()
@ -643,10 +639,10 @@ U0 PCNetInit()
PCNetEnter32BitMode; PCNetEnter32BitMode;
U32 csr = PCNetReadCSR(PCNET_CSR_CTRLSTATUS); U32 csr = PCNetReadCSR(PCNET_CSR_CTRLSTATUS);
ZenithLog("PCNET INIT START: what is INIT ?: %d\n", Bt(&csr, PCNET_CTRL_INIT)); NetLog("PCNET INIT START: what is INIT ?: %d", Bt(&csr, PCNET_CTRL_INIT));
ZenithLog("PCNET INIT START: what is STRT ?: %d\n", Bt(&csr, PCNET_CTRL_STRT)); NetLog("PCNET INIT START: what is STRT ?: %d", Bt(&csr, PCNET_CTRL_STRT));
ZenithLog("PCNET INIT START: what is STOP ?: %d\n", Bt(&csr, PCNET_CTRL_STOP)); NetLog("PCNET INIT START: what is STOP ?: %d", Bt(&csr, PCNET_CTRL_STOP));
ZenithLog("PCNET INIT START: what is RINT ?: %d\n", Bt(&csr, PCNET_CTRL_RINT)); NetLog("PCNET INIT START: what is RINT ?: %d", Bt(&csr, PCNET_CTRL_RINT));
PCNetSetSWStyle; PCNetSetSWStyle;
@ -666,10 +662,10 @@ U0 PCNetInit()
PCNetWriteCSR(0, PCNetReadCSR(0) | 1 | (1<<6)); PCNetWriteCSR(0, PCNetReadCSR(0) | 1 | (1<<6));
csr = PCNetReadCSR(PCNET_CSR_CTRLSTATUS); csr = PCNetReadCSR(PCNET_CSR_CTRLSTATUS);
ZenithLog("PCNET INIT UPLOAD: what is INIT ?: %d\n", Bt(&csr, PCNET_CTRL_INIT)); NetLog("PCNET INIT UPLOAD: what is INIT ?: %d", Bt(&csr, PCNET_CTRL_INIT));
ZenithLog("PCNET INIT UPLOAD: what is STRT ?: %d\n", Bt(&csr, PCNET_CTRL_STRT)); NetLog("PCNET INIT UPLOAD: what is STRT ?: %d", Bt(&csr, PCNET_CTRL_STRT));
ZenithLog("PCNET INIT UPLOAD: what is STOP ?: %d\n", Bt(&csr, PCNET_CTRL_STOP)); NetLog("PCNET INIT UPLOAD: what is STOP ?: %d", Bt(&csr, PCNET_CTRL_STOP));
ZenithLog("PCNET INIT UPLOAD: what is RINT ?: %d\n", Bt(&csr, PCNET_CTRL_RINT)); NetLog("PCNET INIT UPLOAD: what is RINT ?: %d", Bt(&csr, PCNET_CTRL_RINT));
while (!(PCNetReadCSR(0) & (1<<8))) while (!(PCNetReadCSR(0) & (1<<8)))
Yield; Yield;
@ -688,15 +684,15 @@ U0 PCNetInit()
"pcnet->rx_de_buffer_phys: %X\n", pcnet.tx_de_buffer_phys; "pcnet->rx_de_buffer_phys: %X\n", pcnet.tx_de_buffer_phys;
*/ */
csr = PCNetReadCSR(PCNET_CSR_CTRLSTATUS); csr = PCNetReadCSR(PCNET_CSR_CTRLSTATUS);
ZenithLog("PCNET INIT END: what is INIT ?: %d\n", Bt(&csr, PCNET_CTRL_INIT)); NetLog("PCNET INIT END: what is INIT ?: %d", Bt(&csr, PCNET_CTRL_INIT));
ZenithLog("PCNET INIT END: what is STRT ?: %d\n", Bt(&csr, PCNET_CTRL_STRT)); NetLog("PCNET INIT END: what is STRT ?: %d", Bt(&csr, PCNET_CTRL_STRT));
ZenithLog("PCNET INIT END: what is STOP ?: %d\n", Bt(&csr, PCNET_CTRL_STOP)); NetLog("PCNET INIT END: what is STOP ?: %d", Bt(&csr, PCNET_CTRL_STOP));
ZenithLog("PCNET INIT END: what is RINT ?: %d\n", Bt(&csr, PCNET_CTRL_RINT)); NetLog("PCNET INIT END: what is RINT ?: %d", Bt(&csr, PCNET_CTRL_RINT));
ZenithLog("PCNET INIT END: what is TXON ?: %d\n", Bt(&csr, 4)); NetLog("PCNET INIT END: what is TXON ?: %d", Bt(&csr, 4));
ZenithLog("PCNET INIT END: what is RXON ?: %d\n", Bt(&csr, 5)); NetLog("PCNET INIT END: what is RXON ?: %d", Bt(&csr, 5));
csr = PCNetReadCSR(PCNET_CSR_POLLINT); csr = PCNetReadCSR(PCNET_CSR_POLLINT);
ZenithLog("PCNET INIT END: what is POLLINT ?: %d\n", Bt(&csr, PCNET_CTRL_RINT)); NetLog("PCNET INIT END: what is POLLINT ?: %d", Bt(&csr, PCNET_CTRL_RINT));
Free(setup); Free(setup);
} }
@ -719,7 +715,7 @@ I64 EthernetFrameAllocate(U8 **packet_buffer_out,
//need to see if 3 years later VirtualBox supports APAD_XMT! //need to see if 3 years later VirtualBox supports APAD_XMT!
if (packet_length < ETHERNET_MIN_FRAME_SIZE) if (packet_length < ETHERNET_MIN_FRAME_SIZE)
{ {
ZenithWarn("ETHERNET FRAME ALLOCATE: PCNET APAD XMT TRUNCATE ? ...\n"); NetWarn("ETHERNET FRAME ALLOCATE: PCNET APAD XMT TRUNCATE ? ...");
packet_length = ETHERNET_MIN_FRAME_SIZE; packet_length = ETHERNET_MIN_FRAME_SIZE;
} }
@ -727,7 +723,7 @@ I64 EthernetFrameAllocate(U8 **packet_buffer_out,
if (de_index < 0) if (de_index < 0)
{ {
ZenithErr("ETHERNET FRAME ALLOCATE: Failure\n"); NetErr("ETHERNET FRAME ALLOCATE: Failure");
return -1; // Positive value expected. Functions calling this must factor this in. return -1; // Positive value expected. Functions calling this must factor this in.
} }

18
src/Home/Net/Sockets.CC
View File

@ -178,12 +178,12 @@ Bool IPV4AddressParse(U8 *string, U32 *destination)
case TK_I64: case TK_I64:
if (cc->cur_i64 > 255 || cc->cur_i64 < 0) if (cc->cur_i64 > 255 || cc->cur_i64 < 0)
{ {
ZenithErr("IPV4 ADDRESS PARSE: Invalid value, must be 0 - 255.\n"); NetErr("IPV4 ADDRESS PARSE: Invalid value, must be 0 - 255.");
return FALSE; return FALSE;
} }
if (current_section > 3) if (current_section > 3)
{ {
ZenithErr("IPV4 ADDRESS PARSE: IP Address can only have 4 sections.\n"); NetErr("IPV4 ADDRESS PARSE: IP Address can only have 4 sections.");
return FALSE; return FALSE;
} }
@ -195,7 +195,7 @@ Bool IPV4AddressParse(U8 *string, U32 *destination)
break; break;
default: default:
ZenithErr("IPV4 ADDRESS PARSE: Expected decimal. \n"); NetErr("IPV4 ADDRESS PARSE: Expected decimal. ");
return FALSE; return FALSE;
} }
break; break;
@ -208,7 +208,7 @@ Bool IPV4AddressParse(U8 *string, U32 *destination)
break; break;
default: default:
ZenithErr("IPV4 ADDRESS PARSE: Expected dot. \n"); NetErr("IPV4 ADDRESS PARSE: Expected dot. ");
return FALSE; return FALSE;
} }
break; break;
@ -245,7 +245,7 @@ I64 PresentationToNetwork(I64 address_family, U8 *string, CIPAddressStorage *des
case AF_INET: case AF_INET:
if (string_length > INET_ADDRSTRLEN || string_length < INET_MIN_ADDRSTRLEN) if (string_length > INET_ADDRSTRLEN || string_length < INET_MIN_ADDRSTRLEN)
{ {
ZenithErr("IP to Socket Address failed: Invalid Input String Size.\n"); NetErr("IP to Socket Address failed: Invalid Input String Size.");
return -1; return -1;
} }
ipv4_address = destination; ipv4_address = destination;
@ -257,7 +257,7 @@ I64 PresentationToNetwork(I64 address_family, U8 *string, CIPAddressStorage *des
case AF_INET6: case AF_INET6:
if (string_length > INET6_ADDRSTRLEN || string_length < INET6_MIN_ADDRSTRLEN) if (string_length > INET6_ADDRSTRLEN || string_length < INET6_MIN_ADDRSTRLEN)
{ {
ZenithErr("IP to Socket Address failed: Invalid Input String Size.\n"); NetErr("IP to Socket Address failed: Invalid Input String Size.");
return -1; return -1;
} }
ipv6_address = destination; ipv6_address = destination;
@ -269,7 +269,7 @@ I64 PresentationToNetwork(I64 address_family, U8 *string, CIPAddressStorage *des
break; break;
default: default:
ZenithErr("IP to Socket Address failed: Invalid Address Family.\n"); NetErr("IP to Socket Address failed: Invalid Address Family.");
return -1; return -1;
} }
@ -314,7 +314,7 @@ U8 *NetworkToPresentation(I64 address_family, CIPAddressStorage *source)
break; break;
default: default:
ZenithErr("Socket Address to IP failed: Invalid Address Family.\n"); NetErr("Socket Address to IP failed: Invalid Address Family.");
break; break;
} }
@ -367,7 +367,7 @@ U0 SocketStateErr(U8 *request, U8 state)
state_string = StrNew("CLOSED"); state_string = StrNew("CLOSED");
break; break;
} }
ZenithErr("Socket attempted %s while in %s state.\n", request, state_string); NetErr("Socket attempted %s while in %s state.", request, state_string);
} }
U0 SocketAccept(CSocket *socket) U0 SocketAccept(CSocket *socket)

5
src/Home/Net/Tests/DHCPSendTrash1.CC
View File

@ -3,19 +3,20 @@ U8 dst_mac[6] = {0xF0, 0x0D, 0xBE, 0xAD, 0xDE, 0xAF};
U32 dst_ip = 0x01020304; U32 dst_ip = 0x01020304;
U0 DHCPSendTrash() U0 DHCPSendTrash()
{ // DHCPConfigure, then send UDP trash. { // DHCPConfigure (if not already configured), then send UDP trash.
U8 *udp_payload; U8 *udp_payload;
I64 de_index; I64 de_index;
ARPCachePut(dst_ip, dst_mac); // Force entry into ARP Cache so IPV4 can match it with GetMACAddressForIP ARPCachePut(dst_ip, dst_mac); // Force entry into ARP Cache so IPV4 can match it with GetMACAddressForIP
if (ipv4_globals.local_ip == 0)
DHCPConfigure; DHCPConfigure;
while (TRUE) while (TRUE)
{ {
de_index = UDPPacketAllocate(&udp_payload, arp_globals.local_ipv4, 0xDEAD, dst_ip, 0xBEEF, 8); de_index = UDPPacketAllocate(&udp_payload, ipv4_globals.local_ip, 0xDEAD, dst_ip, 0xBEEF, 8);
*(udp_payload(U64 *)) = EndianU64(0xDEADBEEFC0DEFADE); *(udp_payload(U64 *)) = EndianU64(0xDEADBEEFC0DEFADE);

6
src/Home/Net/Tests/DHCPSendTrash2.CC
View File

@ -11,6 +11,12 @@ U0 DHCPSendTrash()
U8 *packet_buffer; U8 *packet_buffer;
I64 de_index; I64 de_index;
if (ipv4_globals.local_ip != 0)
{
"\nThis test will only work on unconfigured network.\n";
"To force for testing, comment out $FG,0$NetConfigure;$FG$ in $LK,"NetStart",A="FF:C:/Home/Net/NetStart.CC,NetConfigure"$.\n\n";
return;
}
DHCPConfigureInner(udp_socket, &your_ip, &dns_ip, &router_ip, &subnet_mask); DHCPConfigureInner(udp_socket, &your_ip, &dns_ip, &router_ip, &subnet_mask);

3
src/Home/Net/Tests/DNSSendTrash.CC
View File

@ -9,8 +9,11 @@ U0 DNSSendTrash()
U8 **l = labels; U8 **l = labels;
CDNSQuestion *q = CAlloc(sizeof(CDNSQuestion)); CDNSQuestion *q = CAlloc(sizeof(CDNSQuestion));
if (dns_globals.addr_family == AF_UNSPEC)
{
ARPCachePut(dns_ip, dns_mac); // Force entry into ARP Cache so IPV4 can match it with GetMACAddressForIP ARPCachePut(dns_ip, dns_mac); // Force entry into ARP Cache so IPV4 can match it with GetMACAddressForIP
DNSSetResolverIPV4(dns_ip); // Forcing so DNSSendQuestion succeeds DNSSetResolverIPV4(dns_ip); // Forcing so DNSSendQuestion succeeds
}
q->q_name.labels = labels; q->q_name.labels = labels;
q->q_name.num_labels = 4; q->q_name.num_labels = 4;

5
src/Home/Net/Tests/HostTest1.CC
View File

@ -4,12 +4,13 @@ U32 dns_ip = 0x51525354;
U0 HostTest() U0 HostTest()
{
if (dns_globals.addr_family == AF_UNSPEC)
{ {
ARPCachePut(dns_ip, dns_mac); // Force entry into ARP Cache so IPV4 can match it with GetMACAddressForIP ARPCachePut(dns_ip, dns_mac); // Force entry into ARP Cache so IPV4 can match it with GetMACAddressForIP
DNSSetResolverIPV4(dns_ip); // Forcing so DNSSendQuestion succeeds DNSSetResolverIPV4(dns_ip); // Forcing so DNSSendQuestion succeeds
}
"\n$BG,8$Type $FG,0$G2;$FG$ if it crashes$BG$\n\n";
Host("zenithos.org"); Host("zenithos.org");
} }

8
src/Home/Net/Tests/Old/Test.CC
View File

@ -48,7 +48,7 @@ I64 IPV4AddressParse(U8 *string, U32 destination)
break; break;
default: default:
ZenithErr("IPV4 Parse Failure: Unexpected char.\n"); NetErr("IPV4 Parse Failure: Unexpected char.\n");
parse_state = IP_PARSE_STATE_ERROR; parse_state = IP_PARSE_STATE_ERROR;
break; break;
@ -59,7 +59,7 @@ I64 IPV4AddressParse(U8 *string, U32 destination)
"%s, %X\n", digit_buffer, Str2I64(digit_buffer); "%s, %X\n", digit_buffer, Str2I64(digit_buffer);
if (Str2I64(digit_buffer) > 255) if (Str2I64(digit_buffer) > 255)
{ {
ZenithErr("IPV4 Parse Failure: Chunk exceeds 0 - 255 range.\n"); NetErr("IPV4 Parse Failure: Chunk exceeds 0 - 255 range.\n");
parse_state = IP_PARSE_STATE_ERROR; parse_state = IP_PARSE_STATE_ERROR;
break; break;
} }
@ -73,7 +73,7 @@ I64 IPV4AddressParse(U8 *string, U32 destination)
current_chunk_index++; current_chunk_index++;
if (current_chunk_index > 3) if (current_chunk_index > 3)
{ {
ZenithErr("IPV4 Parse Failure: Too many dots in address string.\n"); NetErr("IPV4 Parse Failure: Too many dots in address string.\n");
parse_state = IP_PARSE_STATE_ERROR; parse_state = IP_PARSE_STATE_ERROR;
break; break;
} }
@ -83,7 +83,7 @@ I64 IPV4AddressParse(U8 *string, U32 destination)
break; break;
case IP_PARSE_STATE_ERROR: case IP_PARSE_STATE_ERROR:
ZenithErr("IPV4 Parse Failure: Invalid Address String.\n"); NetErr("IPV4 Parse Failure: Invalid Address String.\n");
return -1; // error state! return -1; // error state!
} }
} }

16
src/Home/Net/Tests/Old/Test2.CC
View File

@ -70,12 +70,12 @@ Bool IPV4AddressParse(U8 *string, U32* destination)
case TK_I64: case TK_I64:
if (cc->cur_i64 > 255 || cc->cur_i64 < 0) if (cc->cur_i64 > 255 || cc->cur_i64 < 0)
{ {
ZenithErr("Invalid value, must be 0 - 255.\n"); NetErr("Invalid value, must be 0 - 255.\n");
return FALSE; return FALSE;
} }
if (current_section > 3) if (current_section > 3)
{ {
ZenithErr("IP Address can only have 4 sections.\n"); NetErr("IP Address can only have 4 sections.\n");
return FALSE; return FALSE;
} }
@ -87,7 +87,7 @@ Bool IPV4AddressParse(U8 *string, U32* destination)
break; break;
default: default:
ZenithErr("Expected decimal. \n"); NetErr("Expected decimal. \n");
return FALSE; return FALSE;
} }
break; break;
@ -100,7 +100,7 @@ Bool IPV4AddressParse(U8 *string, U32* destination)
break; break;
default: default:
ZenithErr("Expected dot. \n"); NetErr("Expected dot. \n");
return FALSE; return FALSE;
} }
break; break;
@ -174,7 +174,7 @@ I64 IPV4AddressParseOOOOOOOOOOPS(U8 *string, U32 destination)
break; break;
default: default:
ZenithErr("IPV4 Parse Failure: Unexpected char.\n"); NetErr("IPV4 Parse Failure: Unexpected char.\n");
parse_state = IP_PARSE_STATE_ERROR; parse_state = IP_PARSE_STATE_ERROR;
break; break;
@ -185,7 +185,7 @@ I64 IPV4AddressParseOOOOOOOOOOPS(U8 *string, U32 destination)
"%s, %X\n", digit_buffer, Str2I64(digit_buffer); "%s, %X\n", digit_buffer, Str2I64(digit_buffer);
if (Str2I64(digit_buffer) > 255) if (Str2I64(digit_buffer) > 255)
{ {
ZenithErr("IPV4 Parse Failure: Chunk exceeds 0 - 255 range.\n"); NetErr("IPV4 Parse Failure: Chunk exceeds 0 - 255 range.\n");
parse_state = IP_PARSE_STATE_ERROR; parse_state = IP_PARSE_STATE_ERROR;
break; break;
} }
@ -199,7 +199,7 @@ I64 IPV4AddressParseOOOOOOOOOOPS(U8 *string, U32 destination)
current_chunk_index++; current_chunk_index++;
if (current_chunk_index > 3) if (current_chunk_index > 3)
{ {
ZenithErr("IPV4 Parse Failure: Too many dots in address string.\n"); NetErr("IPV4 Parse Failure: Too many dots in address string.\n");
parse_state = IP_PARSE_STATE_ERROR; parse_state = IP_PARSE_STATE_ERROR;
break; break;
} }
@ -209,7 +209,7 @@ I64 IPV4AddressParseOOOOOOOOOOPS(U8 *string, U32 destination)
break; break;
case IP_PARSE_STATE_ERROR: case IP_PARSE_STATE_ERROR:
ZenithErr("IPV4 Parse Failure: Invalid Address String.\n"); NetErr("IPV4 Parse Failure: Invalid Address String.\n");
return -1; // error state! return -1; // error state!
} }
} }

2
src/Home/Net/Tests/UDPSendTrash1.CC
View File

@ -13,7 +13,7 @@ U0 UDPSendTrash()
error = DNSGetAddressInfo("zenithos.org", NULL, &result); error = DNSGetAddressInfo("zenithos.org", NULL, &result);
if (error < 0) if (error < 0)
{ {
ZenithErr("failed at DNS Get Address Info.\n"); NetErr("failed at DNS Get Address Info.");
} }
else else
{ {

56
src/Home/Net/UDP.CC
View File

@ -254,12 +254,12 @@ CUDPTreeQueue *UDPTreeNodeQueueIPV4Find(U32 address, CUDPTreeNode *node)
if (temp_queue->socket->receive_address.family == AF_INET) if (temp_queue->socket->receive_address.family == AF_INET)
{ {
temp_ip = &temp_queue->socket->receive_address; temp_ip = &temp_queue->socket->receive_address;
ZenithLog("UDPTreeNodeQueueIPV4Find: addr, nodequeue addr: %08X, %08X\n", NetLog("UDPTreeNodeQueueIPV4Find: addr, nodequeue addr: %08X, %08X",
address, temp_ip->address.address); address, temp_ip->address.address);
if (temp_ip->address.address == address || temp_ip->address.address == INADDR_ANY) if (temp_ip->address.address == address || temp_ip->address.address == INADDR_ANY)
{ {
ZenithLog("UDPTreeNodeQueueIPV4Find: Address match: addr, nodequeue: %08X, %08X \n", NetLog("UDPTreeNodeQueueIPV4Find: Address match: addr, nodequeue: %08X, %08X ",
address, temp_ip->address.address); address, temp_ip->address.address);
return temp_queue; return temp_queue;
} }
@ -348,7 +348,7 @@ I64 UDPPacketAllocate(U8 **frame_out,
sizeof(CUDPHeader) + length); sizeof(CUDPHeader) + length);
if (de_index < 0) if (de_index < 0)
{ {
ZenithLog("UDP PACKET ALLOCATE: Ethernet Frame Allocate failed.\n"); NetLog("UDP PACKET ALLOCATE: Ethernet Frame Allocate failed.");
return de_index; return de_index;
} }
@ -421,13 +421,13 @@ I64 UDPSocketBind(CUDPSocket *udp_socket, CSocketAddressStorage *address_source)
break; break;
default: default:
ZenithErr("UDP SOCKET BIND: Failed, Socket state-machine must be in READY state.\n"); NetErr("UDP SOCKET BIND: Failed, Socket state-machine must be in READY state.");
return -1; return -1;
} }
if (udp_socket->bound_to) if (udp_socket->bound_to)
{ {
ZenithErr("UDP SOCKET BIND: UDP Socket currently Bound.\n"); NetErr("UDP SOCKET BIND: UDP Socket currently Bound.");
return -1; return -1;
} }
@ -437,7 +437,7 @@ I64 UDPSocketBind(CUDPSocket *udp_socket, CSocketAddressStorage *address_source)
if (udp_socket->receive_address.family == AF_INET6) if (udp_socket->receive_address.family == AF_INET6)
{ {
ZenithErr("UDP SOCKET BIND: Incompatible Address type.\n"); NetErr("UDP SOCKET BIND: Incompatible Address type.");
return -1; return -1;
} }
@ -455,7 +455,7 @@ I64 UDPSocketBind(CUDPSocket *udp_socket, CSocketAddressStorage *address_source)
if (udp_socket->receive_address.family == AF_INET) if (udp_socket->receive_address.family == AF_INET)
{ {
ZenithErr("UDP SOCKET BIND: Incompatible Address type.\n"); NetErr("UDP SOCKET BIND: Incompatible Address type.");
return -1; return -1;
} }
@ -491,7 +491,7 @@ I64 UDPSocketBind(CUDPSocket *udp_socket, CSocketAddressStorage *address_source)
// TODO: will any INADDR_ANY sockets bound at the port break this? // TODO: will any INADDR_ANY sockets bound at the port break this?
if (UDPTreeNodeQueueIPV4Find(ipv4_receive->address.address, temp_node)) if (UDPTreeNodeQueueIPV4Find(ipv4_receive->address.address, temp_node))
{ {
ZenithErr("UDP SOCKET BIND: Address already in Bound Socket Tree !\n"); NetErr("UDP SOCKET BIND: Address already in Bound Socket Tree !");
return -1; return -1;
} }
else else
@ -532,7 +532,7 @@ I64 UDPSocketBind(CUDPSocket *udp_socket, CSocketAddressStorage *address_source)
break; break;
default: default:
ZenithErr("UDP SOCKET BIND: Failed, Misconfigured Socket state-machine.\n"); NetErr("UDP SOCKET BIND: Failed, Misconfigured Socket state-machine.");
return -1; return -1;
} }
@ -593,7 +593,7 @@ I64 UDPSocketReceiveFrom(CUDPSocket *udp_socket, U8 *buffer, I64 len, CSocketAdd
break; break;
default: default:
ZenithErr("UDP SOCKET RECEIVE FROM: Socket state-machine must be in OPEN or BOUND state.\n"); NetErr("UDP SOCKET RECEIVE FROM: Socket state-machine must be in OPEN or BOUND state.");
return -1; return -1;
} }
@ -603,13 +603,13 @@ I64 UDPSocketReceiveFrom(CUDPSocket *udp_socket, U8 *buffer, I64 len, CSocketAdd
if (udp_socket->receive_timeout_ms != 0) if (udp_socket->receive_timeout_ms != 0)
udp_socket->receive_max_timeout = counts.jiffies + udp_socket->receive_timeout_ms * JIFFY_FREQ / 1000; udp_socket->receive_max_timeout = counts.jiffies + udp_socket->receive_timeout_ms * JIFFY_FREQ / 1000;
ZenithLog("UDP SOCKET RECEIVE FROM: udp_socket->receive_buffer: 0x%0X.\n", udp_socket->receive_buffer); NetLog("UDP SOCKET RECEIVE FROM: udp_socket->receive_buffer: 0x%0X.", udp_socket->receive_buffer);
while (udp_socket->receive_buffer != NULL) while (udp_socket->receive_buffer != NULL)
{ // 'Check for timeout' { // 'Check for timeout'
if (udp_socket->receive_timeout_ms != 0 && counts.jiffies > udp_socket->receive_max_timeout) if (udp_socket->receive_timeout_ms != 0 && counts.jiffies > udp_socket->receive_max_timeout)
{ // Shrine has TODO: 'seterror(EWOULDBLOCK)' investigate this { // Shrine has TODO: 'seterror(EWOULDBLOCK)' investigate this
udp_socket->receive_len = -1; // ? udp_socket->receive_len = -1; // ?
ZenithErr("UDP SOCKET RECEIVE FROM: Timed out.\n"); NetErr("UDP SOCKET RECEIVE FROM: Timed out.");
break; break;
} }
@ -632,7 +632,7 @@ I64 UDPSocketReceiveFrom(CUDPSocket *udp_socket, U8 *buffer, I64 len, CSocketAdd
MemCopy(ipv6_socket_addr, &udp_socket->from_address, sizeof(CSocketAddressIPV6)); MemCopy(ipv6_socket_addr, &udp_socket->from_address, sizeof(CSocketAddressIPV6));
break; break;
case AF_UNSPEC: case AF_UNSPEC:
Debug("TODO: UDP Receive From Error AF_UNSPEC UDPSocket Address Family\n"); NetWarn("UDP Receive From AF_UNSPEC UDPSocket Address Family\n");
break; break;
} }
} }
@ -658,13 +658,13 @@ I64 UDPSocketSendTo(CUDPSocket *udp_socket, U8 *buffer, I64 len, CSocketAddressS
break; // and use stored address as send address. break; // and use stored address as send address.
case SOCKET_STATE_READY: // If socket state is initial, attempt to bind it to destination. case SOCKET_STATE_READY: // If socket state is initial, attempt to bind it to destination.
ZenithLog("UDP SOCKET SEND TO: Socket unbound. Attempting Bind at address parameter.\n"); NetLog("UDP SOCKET SEND TO: Socket unbound. Attempting Bind at address parameter.");
UDPSocketBind(udp_socket, destination_addr); UDPSocketBind(udp_socket, destination_addr);
dest = destination_addr; dest = destination_addr;
break; break;
default: default:
ZenithErr("UDP SOCKET SEND TO: Socket state-machine must be in OPEN, BOUND or READY state.\n"); NetErr("UDP SOCKET SEND TO: Socket state-machine must be in OPEN, BOUND or READY state.");
return -1; return -1;
} }
@ -712,13 +712,13 @@ I64 UDPHandler(CIPV4Packet *packet)
CSocketAddressIPV4 *ipv4_addr; CSocketAddressIPV4 *ipv4_addr;
I64 num_receive; I64 num_receive;
ZenithLog("UDP HANDLER: Beginning handling UDP Packet.\n"); NetLog("UDP HANDLER: Beginning handling UDP Packet.");
I64 error = UDPParsePacket(&source_port, &destination_port, &data, &length, packet); I64 error = UDPParsePacket(&source_port, &destination_port, &data, &length, packet);
if (error < 0) if (error < 0)
{ {
ZenithErr("UDP HANDLER: Packet Parse Error.\n"); NetErr("UDP HANDLER: Packet Parse Error.");
return error; return error;
} }
@ -731,38 +731,38 @@ I64 UDPHandler(CIPV4Packet *packet)
if (queue) if (queue)
{ {
udp_socket = queue->socket; udp_socket = queue->socket;
ZenithLog("UDP HANDLER: Port and Address are in bound tree.\n"); NetLog("UDP HANDLER: Port and Address are in bound tree.");
} }
else else
{ {
ZenithWarn("UDP HANDLER: Found node for port, but address is not in node queue.\n"); NetWarn("UDP HANDLER: Found node for port, but address is not in node queue.");
ZenithWarn(" UDP packet dest ip: 0x%0X.\n", packet->destination_ip_address); NetWarn(" UDP packet dest ip: 0x%0X.", packet->destination_ip_address);
return -1; return -1;
} }
} }
else else
{ {
ZenithWarn("UDP HANDLER: Node for Port is not in tree.\n"); NetWarn("UDP HANDLER: Node for Port is not in tree.");
return -1; return -1;
} }
} }
else else
{ {
ZenithWarn("UDP HANDLER: Socket tree is currently empty.\n"); NetWarn("UDP HANDLER: Socket tree is currently empty.");
return -1; return -1;
} }
ZenithLog("UDP HANDLER: Checking if UDP Socket's Receive-Buffer exists. UDPSocket at: 0x%0X \n", udp_socket); NetLog("UDP HANDLER: Checking if UDP Socket's Receive-Buffer exists. UDPSocket at: 0x%0X ", udp_socket);
ZenithLog(" It probably exists, wtf going on ? udp_socket->receive_buffer: 0x%0X.\n", udp_socket->receive_buffer); NetLog(" It probably exists, wtf going on ? udp_socket->receive_buffer: 0x%0X.", udp_socket->receive_buffer);
// at this point, udp_socket is set, otherwise has already returned -1. // at this point, udp_socket is set, otherwise has already returned -1.
if (udp_socket->receive_buffer) if (udp_socket->receive_buffer)
{ {
ZenithLog("UDP HANDLER: Saw UDP Socket receive buffer exists, about to copy data into it.\n"); NetLog("UDP HANDLER: Saw UDP Socket receive buffer exists, about to copy data into it.");
num_receive = udp_socket->receive_len; num_receive = udp_socket->receive_len;
if (num_receive > length) if (num_receive > length)
{ {
ZenithWarn("UDP HANDLER: Truncating UDP socket receive length. num_receive , len : %d, %d\n", NetWarn("UDP HANDLER: Truncating UDP socket receive length. num_receive , len : %d, %d",
num_receive, length); num_receive, length);
num_receive = length; num_receive = length;
} }
@ -783,14 +783,14 @@ I64 UDPHandler(CIPV4Packet *packet)
ipv4_addr->family = AF_INET; ipv4_addr->family = AF_INET;
ipv4_addr->port = EndianU16(source_port); ipv4_addr->port = EndianU16(source_port);
ipv4_addr->address.address = EndianU32(packet->source_ip_address); ipv4_addr->address.address = EndianU32(packet->source_ip_address);
ZenithLog("UDP HANDLER: Copying packet source IP (BE) to FROM_ADDRESS of UDP Socket: %08X \n", ipv4_addr->address.address); NetLog("UDP HANDLER: Copying packet source IP (BE) to FROM_ADDRESS of UDP Socket: %08X ", ipv4_addr->address.address);
} }
return error; return error;
} }
// the socket functions just act on the socket state machine. // the socket functions just act on the socket state machine.
// ZenithErr and return fail vals if socket FSM improperly used. // NetErr and return fail vals if socket FSM improperly used.
// Careful with Free()'s. // Careful with Free()'s.
UDPGlobalsInit; UDPGlobalsInit;