#include <XnodeBaseNetwork.h>

const char pmNetworkChipBoot[] PROGMEM = "Init eth0";
const char pmNetworkChipError[] PROGMEM = "ERR: No chip";
const char pmNetworkLinkError[] PROGMEM = "ERR: No link";
const char pmNetworkStaticBoot[] PROGMEM = "Static IP";
const char pmNetworkDhcpBoot[] PROGMEM = "Request dhcp";
const char pmNetworkDhcpDone[] PROGMEM = "dhcp done";
const char pmNetworkDhcpError[] PROGMEM = "ERR: dhcp failed";
const char pmNetworkDnsLookup[] PROGMEM = "Lookup dns";
const char pmNetworkResultError[] PROGMEM = "# Invalid result:0x";
const char pmNetworkResultPing[] PROGMEM = "Server replied";

const char pmNetworkUsePrefix[] PROGMEM = "eth0_";
const char pmNetworkConfigInfo[] PROGMEM = "net_info";
const char pmNetworkConfigInfoEth0[] PROGMEM = "net_info_eth0";
const char pmNetworkConfigMac[] PROGMEM = "net_mac";
const char pmNetworkConfigIp[] PROGMEM = "net_ip";
const char pmNetworkConfigMask[] PROGMEM = "net_mask";
const char pmNetworkConfigGate[] PROGMEM = "net_gate";
const char pmNetworkConfigDns[] PROGMEM = "net_dns";
const char pmNetworkConfigKey[] PROGMEM = "net_key";
const char pmNetworkConfigId[] PROGMEM = "net_id";

const char pmNetworkServerHost[] PROGMEM = "net_srv_host";
const char pmNetworkServerIp[] PROGMEM = "net_srv_ip";
const char pmNetworkServerLookup[] PROGMEM = "net_srv_lup";

const char pmNetworkServer[] PROGMEM = NET_XNODE_HOST;
const char pmNetworkUrlPost[] PROGMEM = NET_URL_POST;
const char pmNetworkUrlParaPostType[] PROGMEM = NET_URL_PARA_POST_TYPE;
const char pmNetworkUrlParaReqCnt[] PROGMEM = NET_URL_PARA_REQ_CNT;
const char pmNetworkUrlParaNetId[] PROGMEM = NET_URL_PARA_NET_ID;
const char pmNetworkUrlParaNodeData[] PROGMEM = NET_URL_PARA_NODE_DATA;
const char pmNetworkUrlParaNodeNumber[] PROGMEM = NET_URL_PARA_NODE_NUMBER;

const char pmNetworkInfoTXOpen[] PROGMEM = "net_tx_open";
const char pmNetworkInfoTX[] PROGMEM = "net_tx";
const char pmNetworkInfoRX[] PROGMEM = "net_rx";

const char pmNetworkPing[] PROGMEM = "net_ping";

unsigned long net_ping_boot_timer = ZERO;
unsigned long net_ping_host_timer = ZERO;
unsigned long net_dhcp_retry_timer = ZERO;
unsigned long net_dns_lookup_timer = ZERO;
uint8_t net_status_eth = ZERO;
uint8_t net_status_ip = ZERO;
uint8_t net_status_dns = ZERO;
uint8_t net_status_data = ZERO;
uint8_t net_status_ping = ZERO;
uint8_t net_status_reply = ZERO;

uint8_t net_tx_open = ZERO;
unsigned long net_tx = ZERO;
unsigned long net_rx = ZERO;

char line_buf[128];
#define ETH_BUFFER_SIZE 450
byte Ethernet::buffer[ETH_BUFFER_SIZE];
Stash stash;
byte stashStart;
byte stashSession;
XnodeBaseNetwork XBNetwork;

void XnodeBaseNetwork::begin() {
	XBHardware.changeLed(SYS_LED_NETWORK, SYS_LED_STATUS_ON);
	setupChip();
	setupIp();
	XSerial.printCommentLineP(pmNetworkDnsLookup);
	XSerial.executeCommandP(pmNetworkServerLookup);
	XSerial.executeCommandP(pmNetworkConfigInfo);
	XSerial.executeCommandP(pmNetworkConfigInfoEth0);
	unsigned long time = millis();
	net_dhcp_retry_timer = time + (unsigned long) NET_DHCP_RETRY_TIME;
	net_dns_lookup_timer = time + (unsigned long) NET_DNS_LOOKUP_TIME;
	net_ping_boot_timer  = time + (unsigned long) NET_PING_BOOT_TIME;
	net_ping_host_timer  = time + (unsigned long) NET_PING_HOST_TIME;
	XBHardware.changeLed(SYS_LED_NETWORK, SYS_LED_STATUS_OFF);
}

void XnodeBaseNetwork::loop() {
	if (net_status_eth != ZERO) {
		return; // no chip
	}
	loopAutoSetup(); // auto dhcp and dns refresh
	if (net_status_ip != ZERO || net_status_dns != ZERO) {
		return; // no ip or dns
	}
	ether.packetLoop(ether.packetReceive());
	loopDataRX(); // rx first so that on tx-req packetLoop is runned first before RX code.
	loopDataTX();
	loopPingBoot();
	loopPingHost();
}

// prev version needed about ~32 requests before network is working, now it works direct but we keep ping.
void XnodeBaseNetwork::loopPingBoot() {
	if (net_status_ping == ONE) {
		return;
	}
	unsigned long time = millis();
	if (time < net_ping_boot_timer) {
		return; // wait
	}
	net_ping_boot_timer = time + (unsigned long) NET_PING_BOOT_TIME;
	if (net_status_reply == ZERO) {
		line_buf[ZERO] = ZERO;
		sendPing(); // keep sending ping requests.
		return;
	}
	if (net_status_ping == ZERO) {
		XSerial.print(CHAR_NEWLINE);// new line bacause the dot progress bar
		XSerial.printCommentLineP(pmNetworkResultPing); // let user know network is up.
		XSerial.printPromt();
		net_tx_open = ZERO; // reset open request counter
	}
	net_status_ping = ONE+ONE; // print once
	if (XBHardware.config.net_key.u8[ZERO] == ZERO) {
		sendInit(); // send init request.
		net_ping_boot_timer += (unsigned long) NET_PING_BOOT_TIME; // add extra wait time
		return;
	}
	net_status_ping = ONE; // never run this function again.
}

void XnodeBaseNetwork::loopPingHost() {
	if (millis() < net_ping_host_timer) {
		return; // wait
	}
	sendPing();
	net_ping_host_timer = millis() + (unsigned long) NET_PING_HOST_TIME;
}

void XnodeBaseNetwork::xxteaEncrypt(unsigned long v[2]) {
	unsigned int i;
	unsigned long v0=v[0], v1=v[1], sum=0, delta=0x9E3779B9;
	for (i=0; i < XXTEA_NUM_ROUNDS; i++) {
		v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + XBHardware.config.net_key.u32[sum & 3]);
		sum += delta;
		v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + XBHardware.config.net_key.u32[(sum>>11) & 3]);
	}
	v[0]=v0; v[1]=v1;
}

void XnodeBaseNetwork::xxteaDecrypt(unsigned long v[2]) {
	unsigned int i;
	uint32_t v0=v[0], v1=v[1], delta=0x9E3779B9, sum=delta*XXTEA_NUM_ROUNDS;
	for (i=0; i < XXTEA_NUM_ROUNDS; i++) {
		v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + XBHardware.config.net_key.u32[(sum>>11) & 3]);
		sum -= delta;
		v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + XBHardware.config.net_key.u32[sum & 3]);
	}
	v[0]=v0; v[1]=v1;
}

int XnodeBaseNetwork::parseReplyData(word off) {
	memset(line_buf, NULL, sizeof(line_buf));
	if (off != 0) {
		uint16_t pos = off;
		int line_pos = 0;
		
		// Skip over header until data part is found
		while (Ethernet::buffer[pos]) {
			if (Ethernet::buffer[pos - 1] == '\n' && Ethernet::buffer[pos] == '\r') {
				break;
			}
			pos++;
		}
		pos += 2;
		while (Ethernet::buffer[pos]) {
			if (line_pos < 49) {
				line_buf[line_pos] = Ethernet::buffer[pos];
				line_pos++;
			} else {
				break;
			}
			pos++;
		}
		line_buf[line_pos] = '\0';
		return line_pos;
	}
	return 0;
}

void XnodeBaseNetwork::sendStart(char postType) {
	if (stashSession != ZERO) {
		int maxWait = 100;
		while (stashSession != ZERO) {
			loop();
			maxWait--;
			if (maxWait == ZERO) {
				break;
			}
		} 
		
#ifdef DEBUG_NETWORK
		if (stashSession != ZERO) {
			Serial.println(F("#D kill prev tcp req"));
		}
#endif	
		//return; // data is already sending (TODO: move ??)
	}
	
	stashStart = stash.create();
	stash.print(XUtil.UNPSTR(pmNetworkUrlParaPostType));
	stash.print(postType);
	stash.print(XUtil.UNPSTR(pmNetworkUrlParaReqCnt));
	stash.print(net_tx++);
	stash.print(XUtil.UNPSTR(pmNetworkUrlParaNetId));
	for (byte i = ZERO; i < NET_BYTE_NET_ID_SIZE; ++i) {
		byte data = XBHardware.config.net_id[i];
		if (data<0xF) {
			stash.print(ZERO); // extra zero to have fixed length hex string
		}
		stash.print(data, HEX);
	}
}

void XnodeBaseNetwork::sendPing() {
	sendStart(NET_URL_PT_PING);
	net_status_data = NET_URL_PT_PING;
}

void XnodeBaseNetwork::sendInit() {
#ifdef DEBUG_NETWORK
	Serial.println(F("#D req init"));
#endif
	sendStart(NET_URL_PT_INIT);
	net_status_data = NET_URL_PT_INIT;
}

NetKey x_data;

void XnodeBaseNetwork::sendNodeData(byte senderId, char* data) {
	sendStart(NET_URL_PT_DATA);
	stash.print(XUtil.UNPSTR(pmNetworkUrlParaNodeNumber));
	stash.print((int) senderId);
	stash.print(XUtil.UNPSTR(pmNetworkUrlParaNodeData));

	char* dstring = data;
	while (*dstring != 0) {
		char value = *dstring;
		dstring++;
		stash.print(value);
	}
	
	/*
	byte i = 0;
	char* dstring = data;
	while (*dstring != 0) {
		x_data.u8[i] = *dstring;
		dstring++;
		i++;
		if (i==8) {
			i = 0;
			xxteaEncrypt(x_data.u32);
			for (byte i = 0; i < 8; ++i) {
				char value = x_data.u8[i];
				if (value == 0) {
					stash.print('00');
					continue;
				}
				if (value <= 0xF) {
					stash.print('0');
				}
				stash.print(value,HEX);
			}
		}
	}
	while(i < 8) {
		x_data.u8[i] = 0;
		i++;
	}
	xxteaEncrypt(x_data.u32);
	for (byte i = 0; i < 8; ++i) {
		char value = x_data.u8[i];
		if (value == 0) {
			stash.print('00');
			continue;
		}
		if (value <= 0xF) {
			stash.print('0');
		}
		stash.print(value,HEX);
	}
	*/
	net_status_data = NET_URL_PT_DATA;
}

void XnodeBaseNetwork::loopDataTX() {
	if (net_status_data == ZERO) {
		return; // no data to send
	}
	if (!ether.isLinkUp()) {
		if (net_status_ip == ZERO) {
			XSerial.printCommentLineP(pmNetworkLinkError);
		}
		net_status_ip = ONE;
		return; // link down; request new ip when link gets up.
	}
	
	XBHardware.changeLed(SYS_LED_NETWORK, SYS_LED_STATUS_ON);
	
#ifdef DEBUG_NETWORK
	Serial.print(F("#D sendHttp pt="));
	Serial.print((char)net_status_data);
	Serial.print(F(" size="));
	Serial.println((char)stash.size(),DEC);
#endif
	
	stash.save();
	Stash::prepare(PSTR("POST http://$F/$F HTTP/1.1" "\r\n"
			"Host: $F" "\r\n"
			"Cache-Control: no-cache" "\r\n"
			"Content-type: application/x-www-form-urlencoded;\r\n"
			"Accept: application/xhtml+xml" "\r\n"
			"Content-Length: $D" "\r\n"
			"\r\n"
			"$H"), pmNetworkServer, pmNetworkUrlPost, pmNetworkServer, stash.size(), stashStart);
	net_tx_open++;
	net_status_data = ZERO;
	stashSession = ether.tcpSend(); // releases also stash buf
	//stash.release();
}

void XnodeBaseNetwork::loopDataRX() {
	if (stashSession == ZERO) {
		return; // no reply to search for
	}
	const char* msgStart = ether.tcpReply(stashSession);
	if (msgStart == ZERO) {
#ifdef DEBUG_NETWORK
		Serial.println(F("#D wait tcpReply"));
#endif
		delay(100);
		return; // no reply yet
	}
	
	net_rx++;
	stashSession = ZERO;
	parseReplyData((int) *msgStart);
	handleServerResult();
	XBHardware.changeLed(SYS_LED_NETWORK, SYS_LED_STATUS_OFF);
}

void XnodeBaseNetwork::handleServerResult() {
	if (line_buf[ZERO] != NET_URL_RESULT_OK) {
		XSerial.printCharP(pmNetworkResultError);
		Serial.print(line_buf[ZERO], HEX); // TODO: check
#ifdef DEBUG_NETWORK
		Serial.print(CHAR_SPACE);
		for (int i=0;i<10;i++) {
			if (line_buf[i] != ZERO) {
				Serial.print(line_buf[i]);
			}
		}
#endif
		XSerial.print(CHAR_NEWLINE);
		return;
	}
	net_tx_open--; // valid result
	net_status_reply = ONE; // we have reply
	
	if (line_buf[ONE] == ZERO) {
		return; // Only X returns so nop.
	}
	
	if (line_buf[ONE] == NET_URL_PT_INIT) {
		XSystem.executeCommand(line_buf + ONE + ONE,true); // skip Xi chars
		loop();     // Else we miss most of the time the second init request.
		loop(); // an other extra to be sure we done miss the second request.
		sendInit(); // request next init command
		return;
	}
	if (line_buf[ONE] == NET_URL_RESULT_OK) {
		XSystem.executeCommand(line_buf + ONE + ONE,true); // skip XX chars
		loop();
		loop();
		sendNodeData(RF_BASE_NODE_ID,XSystem.replyBuffer); // send reply as
	}
}

bool XnodeBaseNetwork::isUp() {
	return ZERO == (net_status_eth + net_status_ip + net_status_dns);
}

void XnodeBaseNetwork::loopAutoSetup() {
	unsigned long time = millis();
	// auto dhcp
	if (net_status_ip == ONE) {
		if (time < net_dhcp_retry_timer) {
			return; // wait
		}
		net_dhcp_retry_timer = millis() + (unsigned long) NET_DHCP_RETRY_TIME;
		setupIp();
		if (net_status_ip == ONE) {
			return; // failed dhcp
		}
		net_status_dns = ONE;       // when link plugs in later
		net_dns_lookup_timer = ONE; // then do direct dns lookup
	}
	// auto dns
	if (net_status_dns == ONE) {
		if (time < net_dns_lookup_timer) {
			return; // wait
		}
		net_dns_lookup_timer = time + (unsigned long) NET_DNS_LOOKUP_TIME;
		XSerial.executeCommandP(pmNetworkServerLookup);
	}
	// auto dns refresh
	if (net_status_dns == ZERO && time > net_dns_lookup_timer) {
		net_status_dns = ONE;
	}
}

// FIXME: without chip it takes 3 watchdog reboots before no chip result ?? (prev lib version)
void XnodeBaseNetwork::setupChip() {
	XSerial.printCommentLineP(pmNetworkChipBoot);
	if (ether.begin(sizeof Ethernet::buffer, XBHardware.config.net_mac,	HW_PIN_SPI_ETH0_CS) == ZERO) {
		XSerial.printCommentLineP(pmNetworkChipError);
		XBHardware.changeLed(SYS_LED_ERROR, SYS_LED_STATUS_BLINK);
		net_status_eth = ONE;
		return;
	}
	ether.disableBroadcast();
	ether.disableMulticast();
	delay(100); // needed for link isLinkUp to return valid value.
}

void XnodeBaseNetwork::setupIp() {
	net_status_ip = ZERO;
	if (net_status_eth != ZERO) {
		return; // no chip
	}
	if (!ether.isLinkUp()) {
		net_status_ip = ONE; // do again
		XSerial.printCommentLineP(pmNetworkLinkError);
		return;
	}
	
	// Setup static if ip is given.
	if (XBHardware.config.net_ip[ZERO] != ZERO) {
		XSerial.printCommentLineP(pmNetworkStaticBoot);
		ether.staticSetup(XBHardware.config.net_ip, XBHardware.config.net_gate, XBHardware.config.net_dns);
		ether.copyIp(ether.netmask, XBHardware.config.net_mask);
		return;
	}
	XSerial.printCommentLineP(pmNetworkDhcpBoot);
	wdt_disable();
	if (!ether.dhcpSetup()) {
		net_status_ip = ONE; // do again
		XSerial.printCommentLineP(pmNetworkDhcpError);
		XBHardware.changeLed(SYS_LED_ERROR, SYS_LED_STATUS_ON); // TODO: fix led blinking on timer int.
	} else {
		XSerial.printCommentLineP(pmNetworkDhcpDone);
		XBHardware.changeLed(SYS_LED_ERROR, SYS_LED_STATUS_OFF); // set led off after recovery
	}
	wdt_enable(WDT_TIMEOUT); // no link or no dhcp will take long timeout ~30s
	
#ifdef DEBUG_NET_GATE
	if (net_status_ip == ZERO) {
		byte debug_gate[NET_BYTE_IP_SIZE] = DEBUG_NET_GATE; // transparent http proxy network config.
		ether.copyIp(ether.gwip, debug_gate);
		Serial.println(F("#D Used debug gate ip"));
	}
#endif
}

void XnodeBaseNetwork::cmdDnsLookup() {
	net_status_dns = ZERO;
	if (net_status_eth != ZERO) {
		return; // no chip
	}
	if (net_status_ip != ZERO) {
		net_status_dns = ONE;
		return; // no ip
	}
	
#ifdef DEBUG_NET_HISIP
	byte debug_hisip[NET_BYTE_IP_SIZE] = DEBUG_NET_HISIP;
	ether.copyIp(ether.hisip, debug_hisip);
	Serial.println(F("#D Used debug dns ip"));
	return;
#endif
	
	wdt_disable();
	if (!ether.dnsLookup(pmNetworkServer)) {
		net_status_dns = ONE;
		XSystem.buildReplyPValue(pmNetworkServerLookup,ZERO);
		XBHardware.changeLed(SYS_LED_ERROR, SYS_LED_STATUS_BLINK);
	} else {
		XSystem.buildReplyPValue(pmNetworkServerLookup,ONE);
		XBHardware.changeLed(SYS_LED_ERROR, SYS_LED_STATUS_OFF);
	}
	wdt_enable (WDT_TIMEOUT);
}

void XnodeBaseNetwork::cmdInfoEth0() {
	// Print currently used config
	XSystem.buildReplyCharP(pmNetworkUsePrefix);
	XSystem.buildReplyPValueIP(pmNetworkConfigIp, ether.myip);
	XSystem.buildReplyCharP(pmNetworkUsePrefix);
	XSystem.buildReplyPValueIP(pmNetworkConfigMask, ether.netmask);
	XSystem.buildReplyCharP(pmNetworkUsePrefix);
	XSystem.buildReplyPValueIP(pmNetworkConfigGate, ether.gwip);
	XSystem.buildReplyCharP(pmNetworkUsePrefix);
	XSystem.buildReplyPValueIP(pmNetworkConfigDns, ether.dnsip);
	XSystem.buildReplyCharP(pmNetworkUsePrefix);
	XSystem.buildReplyPValueByteA(pmNetworkConfigMac,ether.mymac, NET_BYTE_MAC_SIZE);
}

void XnodeBaseNetwork::cmdInfo() {
	// Print server value and lookup
	XSystem.buildReplyPValueP(pmNetworkServerHost,pmNetworkServer);
	XSystem.buildReplyPValueIP(pmNetworkServerIp, ether.hisip);
	
	// Print config
	XSystem.buildReplyPValueByteA(pmNetworkConfigMac,XBHardware.config.net_mac, NET_BYTE_MAC_SIZE);
	XSystem.buildReplyPValueIP(pmNetworkConfigIp, XBHardware.config.net_ip);
	XSystem.buildReplyPValueIP(pmNetworkConfigMask, XBHardware.config.net_mask);
	XSystem.buildReplyPValueIP(pmNetworkConfigGate, XBHardware.config.net_gate);
	XSystem.buildReplyPValueIP(pmNetworkConfigDns, XBHardware.config.net_dns);
	XSystem.buildReplyPValueByteA(pmNetworkConfigKey,XBHardware.config.net_key.u8, NET_BYTE_NET_KEY_SIZE);
	XSystem.buildReplyPValueByteA(pmNetworkConfigId,XBHardware.config.net_id, NET_BYTE_NET_ID_SIZE);
	
	XSystem.buildReplyPValue(pmNetworkInfoTXOpen, (int) net_tx_open);
	XSystem.buildReplyPValue(pmNetworkInfoTX, net_tx);
	XSystem.buildReplyPValue(pmNetworkInfoRX, net_rx);
}

void XnodeBaseNetwork::parseCommandIp(const char* pmName, char** args, byte* ip_conf) {
	ether.parseIp(ip_conf, args[ZERO]);
	XSystem.buildReplyPValueIP(pmName, ip_conf);
	XSystem.configSave(); // auto save on change
}

void XnodeBaseNetwork::systemModuleCommandList() {
	XSystem.buildReplyCommandListP(pmNetworkConfigInfo);
	XSystem.buildReplyCommandListP(pmNetworkConfigInfoEth0);
	XSystem.buildReplyCommandListP(pmNetworkConfigMac);
	XSystem.buildReplyCommandListP(pmNetworkConfigIp);
	XSystem.buildReplyCommandListP(pmNetworkConfigMask);
	XSystem.buildReplyCommandListP(pmNetworkConfigGate);
	XSystem.buildReplyCommandListP(pmNetworkConfigDns);
	XSystem.buildReplyCommandListP(pmNetworkPing);
	XSystem.buildReplyCommandListP(pmNetworkServerLookup);
#ifdef DEBUG_NETWORK
	XSystem.buildReplyCommandListP(pmNetworkConfigId);  // keep secret that these cmd work
	XSystem.buildReplyCommandListP(pmNetworkConfigKey); // for init over network with this.
#endif
}

bool XnodeBaseNetwork::systemModuleCommandExecute(char* cmd, char** args) {
	if (XUtil.strcmpP(cmd, pmNetworkConfigInfo) == ZERO) {
		cmdInfo();
		return true;
		
	} else if (XUtil.strcmpP(cmd, pmNetworkConfigInfoEth0) == ZERO) {
		cmdInfoEth0();
		return true;
		
	} else if (XUtil.strcmpP(cmd, pmNetworkConfigId) == ZERO) {
		if (XSystem.buildReplyCommandArgumentError(cmd, args)) {
			return true;
		}
		XUtil.charsToByteA(args[ZERO],XBHardware.config.net_id, NET_BYTE_NET_ID_SIZE);
		XSystem.buildReplyPValueByteA(pmNetworkConfigId,XBHardware.config.net_id,NET_BYTE_NET_ID_SIZE);
		XSystem.configSave();
		return true;
		
	} else if (XUtil.strcmpP(cmd, pmNetworkConfigKey) == ZERO) {
		if (XSystem.buildReplyCommandArgumentError(cmd, args)) {
			return true;
		}
		XUtil.charsToByteA(args[ZERO],XBHardware.config.net_key.u8, NET_BYTE_NET_KEY_SIZE);
		XSystem.buildReplyPValueByteA(pmNetworkConfigKey,XBHardware.config.net_key.u8,NET_BYTE_NET_KEY_SIZE);
		XSystem.configSave();
		return true;
		
	} else if (XUtil.strcmpP(cmd, pmNetworkConfigMac) == ZERO) {
		if (XSystem.buildReplyCommandArgumentError(cmd, args)) {
			return true;
		}
		XUtil.charsToByteA(args[ZERO],XBHardware.config.net_mac, NET_BYTE_MAC_SIZE);
		XSystem.buildReplyPValueByteA(pmNetworkConfigMac,XBHardware.config.net_mac, NET_BYTE_MAC_SIZE);
		XSystem.configSave();
		return true;
		
	} else if (XUtil.strcmpP(cmd, pmNetworkConfigIp) == ZERO) {
		if (XSystem.buildReplyCommandArgumentError(cmd, args)) {
			return true;
		}
		parseCommandIp(pmNetworkConfigIp, args, XBHardware.config.net_ip);
		return true;
		
	} else if (XUtil.strcmpP(cmd, pmNetworkConfigMask) == ZERO) {
		if (XSystem.buildReplyCommandArgumentError(cmd, args)) {
			return true;
		}
		parseCommandIp(pmNetworkConfigMask, args, XBHardware.config.net_mask);
		return true;
		
	} else if (XUtil.strcmpP(cmd, pmNetworkConfigGate) == ZERO) {
		if (XSystem.buildReplyCommandArgumentError(cmd, args)) {
			return true;
		}
		parseCommandIp(pmNetworkConfigGate, args, XBHardware.config.net_gate);
		return true;
		
	} else if (XUtil.strcmpP(cmd, pmNetworkConfigDns) == ZERO) {
		if (XSystem.buildReplyCommandArgumentError(cmd, args)) {
			return true;
		}
		parseCommandIp(pmNetworkConfigDns, args, XBHardware.config.net_dns);
		return true;
	} else if (XUtil.strcmpP(cmd, pmNetworkPing) == ZERO) {
		sendPing();
		return true;
	} else if (XUtil.strcmpP(cmd, pmNetworkServerLookup) == ZERO) {
		cmdDnsLookup();
		return true;
	}
	return false;
}