#include "parser.h"

using namespace nmap;
using namespace std;
//just helper functions
inline string _toStr(const char * inStr){
	if(inStr==NULL){
		return "";
	}
	return inStr;
}
inline string _makeLower(string &str){
	transform(str.begin(),str.end(),str.begin(),static_cast<int (*)(int)>(tolower));
	return str;
}
inline string _makeLower(const char *str){
	if(str==NULL){
		return "";
	}
	string tmpStr = str;
	_makeLower(tmpStr);
	return tmpStr;
}
inline unsigned int _makeInt(const string &str){
	if(str==""){
		return 0;
	}
	std::istringstream iss(str);
	int i;
	iss >> i;
	return i;
}
inline unsigned int _makeInt(const unsigned char * str){
	if(str==NULL){
		return 0;
	}
	std::istringstream iss((const char*)str);
	unsigned int i;
	iss >> i;
	return i;
}
const bool nService::operator==(nService value){
	if(this->_version!=value._version){
		return false;
	}
	if(this->_name!=value._name){
		return false;
	}
	if(this->_product!=value._product){
		return false;
	}
	if(this->_method!=value._method){
		return false;
	}
	return true;
}


const string nHost::hostname() {
	if(!_hostnames.empty()){
		return _hostnames[0];
	}else{
		return "";
	}
}
const string nHost::hostname(unsigned int index){
	if(_hostnames.size()<=index){
		if(!_hostnames.empty()){
			return _hostnames[_hostnames.size()-1];
		}else{
			return "";
		}
	}else{
		return _hostnames[index];
	}
}

nHost::nHost(){
	_distance=-1;
	_status="unknown";
	_ipv4="";
	_ipv6="";
	_mac="";
	_vendor="";
	_uptime_str="";
	_uptime_sec=0;
	_start_time=0;
	_end_time=0;
}

bool nHost::operator ==(nHost value){
	if(this->protocols() != value.protocols()){
		return false;
	}
	//iterate over tcp, upd, ipproto, or whatever the hoses were scanned with
	set<string> protos = this->protocols();
	for(set<string>::iterator po=protos.begin();
		po!=protos.end();
		po++){
			if((*this).port_count(*po)!=value.port_count(*po)){
				return false;
			}
			vector<unsigned int> portListA=this->ports(*po);
			vector<unsigned int> portListB=value.ports(*po);
			//todo: service check
			for(int i=value.port_count(*po)-1;i>=0;i--){
				//are they the same port?
				string stateA =this->port_state(*po, portListA[i]);
				string stateB =value.port_state(*po, portListB[i]);
				if(portListA[i]!=portListB[i]){
					return false;
				//do they have the same state?
				}else if(this->port_state(*po, portListA[i]) != value.port_state(*po, portListB[i])){
					return false;
				}else if(!(this->service(*po, portListA[i]) == value.service(*po, portListB[i]))){
					return false;
				}
			}
	}
	return true;
}
const vector<nHost> parser::all_hosts(string status){
	_makeLower(status);
	return _State_Hosts[status];
}
const vector<unsigned int> nHost::ports(string proto) {
	_makeLower(proto);
	return _ports[proto]; }
const vector<unsigned int> nHost::ports(string proto, string states) { 
	_makeLower(states);
	_makeLower(proto);
	return _state_ports[proto][states];
}

void parser::parse_nmaprun(XMLNode &pointer){
	//<nmaprun scanner="nmap" args="nmap -sS -p80" start="1000000000"
	//startstr="Mon Jun 10 00:00:00 2000" version="4.68" xmloutputversion="1.02">

	Session._ARGS = _toStr(pointer.getAttribute("args",0));
	Session._START_TIME = _makeInt(pointer.getAttribute("start",0));
	Session._START_TIME_ASC = _toStr(pointer.getAttribute("startstr",0));
	Session._XML_OUT_VER = _toStr(pointer.getAttribute("xmloutputversion",0));
	Session._VERSION = _toStr(pointer.getAttribute("version",0));
	Session._SCANNER = _toStr(pointer.getAttribute("scanner",0));
}

void parser::parse_host_state(const XMLNode &pointer, nHost &tmpHost){
	//<status state="up" reason="arp-response"/>
	//TODO: parse reason too?
	tmpHost._status = _toStr(pointer.getAttribute("state",0));
}

void parser::parse_host_address(const XMLNode &pointer, nHost &tmpHost){
	//<address addr="10.0.0.1" addrtype="ipv4" />
	//<address addr="00:DE:AD:BE:EF:00" addrtype="mac" vendor="vendor name" />
	string addr,addrtype,vendor;

	addrtype=_toStr(pointer.getAttribute("addrtype",0));
	addr=_toStr(pointer.getAttribute("addr",0));
	vendor=_toStr(pointer.getAttribute("vendor",0));
	if(addrtype=="ipv4"){
		tmpHost._ipv4=addr;
	}else if(addrtype=="ipv6"){
		tmpHost._ipv6=addr;
	}else if(addrtype=="mac"){
		tmpHost._mac=addr;
		tmpHost._vendor=vendor;
	}

}
void parser::parse_host_names(const XMLNode &pointer, nHost &tmpHost){
	//<hostnames><hostname name="cbc1.ca" type="PTR" /><hostname name="cbc5.ca" type="PTR" /></hostnames>
	int num_names=pointer.nChildNode("hostname");
	if(num_names>0){
		int iterator=0;
		for(int i=0;i<num_names;i++){
			tmpHost._hostnames.push_back(pointer.getChildNode("hostname",&iterator).getAttribute("name",0));
		}
	}
}

int parser::parse_host_ports_service(const XMLNode &pointer, nService &serv){
	//<service name="vmware-auth" product="VMware Authentication Daemon" version="1.10"
	//extrainfo="Uses VNC" tunnel="ssl" method="probed" conf="10" />
	serv._name=_toStr(pointer.getAttribute("name"));
	serv._product=_toStr(pointer.getAttribute("product"));
	serv._version=_toStr(pointer.getAttribute("version"));
	serv._extrainfo=_toStr(pointer.getAttribute("extrainfo"));
	serv._tunnel=_toStr(pointer.getAttribute("tunnel"));
	serv._method=_toStr(pointer.getAttribute("method"));
	serv._conf=_makeInt(pointer.getAttribute("conf"));
	serv._ostype=_toStr(pointer.getAttribute("ostype"));
	serv._fingerprint=_toStr(pointer.getAttribute("fingerprint"));
	return true;
}
int parser::parse_host_ports_chidren(const XMLNode &pointer, string &pstate, nService &serv){
	int state=false;
	//dont overwrite pstate if it the state element doesnt exist
	//that way the host will be reported as "unknown"
	if(pointer.nChildNode("state")!=0){
		pstate=pointer.getChildNode("state").getAttribute("state");
	}
	if(pointer.nChildNode("service")!=0){
		state = parse_host_ports_service(pointer.getChildNode("service"),serv);
	}

	//this tells the caler if we want to store the service information in memory
	//which we only want to do if the service element exists and is valid
	return state;
}
void parser::parse_host_ports(const XMLNode &pointer, nHost &tmpHost){
	nService service;
	string proto, pstate;
	unsigned int port;
	int contServ=false;
	int num_ports=pointer.nChildNode("port");
	int iterator=0;
	for(int i=0;i<num_ports;i++){
		XMLNode tmpPort=pointer.getChildNode("port", iterator);
		proto=_makeLower(tmpPort.getAttribute("protocol"));
		port=_makeInt(tmpPort.getAttribute("portid"));

		contServ = parse_host_ports_chidren(tmpPort,pstate,service);

		tmpHost._state_ports[proto][pstate].push_back(port);
		tmpHost._port_state[proto][port]=pstate;
		tmpHost._ports[proto].push_back(port);
		tmpHost._protocols.insert(proto);
		tmpHost._states.insert(pstate);
		if(contServ){
			service._port=port;
			service._proto=proto;
			tmpHost._port_service[proto][port]=service;
		}
	}
}
void parser::parse_host(const XMLNode& pointer){
	nHost tmpHost;

	tmpHost._start_time = _makeInt(pointer.getAttribute("starttime"));
	tmpHost._end_time =  _makeInt(pointer.getAttribute("endtime"));

	//outsource all the parsing to other functions
	//its probably ineffecient to do it like this but
	//thats just how xmlParser is designed
	parse_host_state(pointer.getChildNode("status"),tmpHost);
	int num_addr=pointer.nChildNode("address");
	int iterator=0;
	for(int i=0; i<num_addr;i++){
		parse_host_address(pointer.getChildNode("address",&iterator),tmpHost);
	}
	iterator=0;

	parse_host_names(pointer.getChildNode("hostnames"),tmpHost);

	iterator=0;
	int num_children=pointer.nChildNode("ports");
	for(int i=0; i<num_children;i++){
		parse_host_ports(pointer.getChildNode("ports",&iterator),tmpHost);
	}
	if(tmpHost._ipv6=="" && tmpHost._ipv4=="" && tmpHost._mac==""){
		return;
	}

	//save our freshly created tmpHost :)
	_Hosts.push_back(tmpHost);
	string addr=tmpHost._ipv4==""?tmpHost._ipv6:tmpHost._ipv4;
	_IP_Host[addr]=_Hosts.back();
	_State_IPs[tmpHost._status].push_back(addr);
	_State_Hosts[tmpHost._status].push_back(_Hosts.back());
}
void parser::parse(){
	//get the start times, run commands, version and etc
	parse_nmaprun(r_xmlNode);

	//I may want to parse the scaninfo some time in the future
	//... or may not, I dont need any of the information it gives me currently

	//parse hosts
	//how many hosts?
	int h_count = r_xmlNode.nChildNode("host");
	int iterator=0;
	for(int i=0; i<h_count;i++){
		parse_host(r_xmlNode.getChildNode("host",&iterator));
	}

	//I may want to parse the runstats for end time in the future
}
parser::parser(string filename){
	setfile(filename);
}

void parser::setfile(string filename){
	purge();
	r_xmlNode =XMLNode::openFileHelper(filename.c_str(),"nmaprun");
	//TODO: right now xmlparser dosnt handle errors gracefully, 
	parse();
}
parser::~parser(){
	purge();
}
//Deallocs all dynamic variables.
void parser::purge(){
	//TODO: clear r_xmlNode somehow
	_IP_Host.clear();
	_State_Hosts.clear();
	_State_IPs.clear();
	_Hosts.clear();
	//the session variables
}

nHost* parser::get_host(string ip_addr){
	if(_IP_Host.count(ip_addr)==0)
		return NULL;
	return &_IP_Host[ip_addr];
}

const vector<nHost> parser::all_hosts(){
	return _Hosts;
}

const set<string> parser::status(){
	return _states;
}

const vector<string> parser::get_ips(){
	vector<string> ips;
	for(map<string,vector<string> >::iterator it= _State_IPs.begin();
		it!=_State_IPs.end();
		++it){
			ips.insert(ips.end(),(*it).second.begin(),(*it).second.end());
	}
	return ips;
}

const vector<string> parser::get_ips(string status){
	return _State_IPs[status];
}