nescaprint.cc

/*
 * Copyright (c) 2024, oldteam. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "include/nescaprint.h"
#include "include/nescadata.h"
#include "include/nescaengine.h"
#include "libncsnet/ncsnet/ip4addr.h"
#include "libncsnet/ncsnet/ip6addr.h"
#include "libncsnet/ncsnet/mac.h"
#include "libncsnet/ncsnet/ncsnet.h"

#include <cstdint>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <string>
#include <sys/types.h>
#include <iomanip>

std::string NESCASTATUS="";	/* nesca status bar */

u8 strmethod(int m)
{
	switch (m) {
		case M_ICMP_PING_ECHO:
			return 'e';
		case M_ICMP_PING_INFO:
			return 'i';
		case M_ICMP_PING_TIME:
			return 't';
		case M_TCP_PING_SYN:
			return 's';
		case M_TCP_PING_ACK:
			return 'a';
		case M_TCP_SYN_SCAN:
			return 'S';
		case M_TCP_XMAS_SCAN:
			return 'x';
		case M_TCP_FIN_SCAN:
			return 'f';
		case M_TCP_NULL_SCAN:
			return 'n';
		case M_TCP_ACK_SCAN:
			return 'A';
		case M_TCP_WINDOW_SCAN:
			return 'w';
		case M_TCP_MAIMON_SCAN:
			return 'm';
		case M_TCP_PSH_SCAN:
			return 'p';
		case M_SCTP_INIT_SCAN:
			return 'I';
		case M_SCTP_COOKIE_SCAN:
			return 'C';
		case M_SCTP_INIT_PING:
			return 'N';
		case M_UDP_PING:
			return 'u';
		case M_UDP_SCAN:
			return 'U';
		case M_ARP_PING:
			return 'r';
	}
	return '?';
}


std::string is_service(NESCAPORT *port)
{
	std::string	line, name, portproto, fproto;
	size_t		sp, fport;

	std::ifstream f(DEFAULT_SERVICES_PATH);
	if (!f.is_open())
		return "???";

	while (std::getline(f, line)) {
		std::istringstream iss(line);
		if (iss>>name>>portproto) {
			sp=portproto.find('/');
			if (sp==std::string::npos)
				continue;
			fport=std::stoi(portproto.substr(0, sp));
			fproto=portproto.substr(sp + 1);
			if ((int)fport==port->port&&fproto==
					((port->proto==6)?"tcp"
					:(port->proto==17)?"udp"
					:"sctp"))
				break;
		}

	}

	f.close();
	return name;
}


std::string portblock(NESCAPORT *port, bool onlyok)
{
	std::string	res, p, s, m,
			srv, num;
	res="";
	if (onlyok)
		if (!isokport(port))
			return "";
	res+='\'';
	switch (port->proto) {
		case PR_TCP:
			p="tcp";
			break;
		case PR_UDP:
			p="udp";
			break;
		case PR_SCTP:
			p="sctp";
			break;
		default:
			p="???";
			break;
	}
	switch (port->state) {
		case PORT_OPEN:
			s="open";
			break;
		case PORT_CLOSED:
			s= "closed";
			break;
		case PORT_FILTER:
			s="filtered";
			break;
		case PORT_ERROR:
			s="error";
			break;
		case PORT_OPEN_OR_FILTER:
			s="open|filtered";
			break;
		case PORT_NO_FILTER:
			s="unfiltered";
			break;
		default:
			s="???";
			break;
	}
	switch (port->method) {
		case M_TCP_SYN_SCAN:
			m="syn";
			break;
		case M_TCP_XMAS_SCAN:
			m="xmas";
			break;
		case M_TCP_FIN_SCAN:
			m="fin";
			break;
		case M_TCP_ACK_SCAN:
			m="ack";
			break;
		case M_TCP_WINDOW_SCAN:
			m="window";
			break;
		case M_TCP_NULL_SCAN:
			m="null";
			break;
		case M_TCP_MAIMON_SCAN:
			m="maimon";
			break;
		case M_TCP_PSH_SCAN:
			m="psh";
			break;
		case M_SCTP_INIT_SCAN:
			m="init";
			break;
		case M_SCTP_COOKIE_SCAN:
			m="cookie";
			break;
		case M_UDP_SCAN:
			m="udp";
			break;
		default:
			m="???";
			break;
	}

	num=(port->num>1)?"/"+std::to_string(port->num):"";
	srv=is_service(port);
	res+=std::to_string(port->port)+"/";
	res+=p+"/";
	res+=s+"/";
	res+=srv+"(";
	res+=m+")";
	res+=num;
	res+='\'';

	return res;
}


static std::string cutinfo(const std::string &input, bool yes)
{
	std::string res;

	if (input.length()<40||yes)
		return input;

	res=input;
	res=res.substr(0,40);
	res+="...";

	return res;
}


/*
 * Print results, print class NESCATARGET
 */
void NESCAPRINT::nescatarget(NESCATARGET *target, bool onlyok, bool cut)
{
	std::string	methodstr, block;
	size_t		i, j;

	if (onlyok&&!target->isok())
		return;
	methodstr="'.";
	if (target->get_num_time()>0)
		for (i=0;i<target->get_num_time();i++)
			methodstr+=strmethod(target->get_type_time(i));
	if (target->get_num_port()>0)
		for (i=0;i<target->get_num_port();i++)
			methodstr+=strmethod(target->get_port(i).method);
	methodstr.erase(std::unique(methodstr.begin(),
		methodstr.end()), methodstr.end());
	methodstr+="'";
	std::cout << "Report nesca4 for ";

	/* ipv4 */
	if (!target->get_mainip().empty())
		std::cout << target->get_mainip();
	else
		std::cout << "???";

	/* dns results */
	std::cout << " (";
	if (target->get_num_dns()>0) {
		for (i=0;i<target->get_num_dns();i++) {
			std::cout << target->get_dns(i);
			if (i!=target->get_num_dns()-1)
				std::cout << " ";
		}
	}
	else
		std::cout << "???";
	std::cout << ") ";

	/* mac result */
	if (!target->get_mac().empty())
		std::cout << "[" << target->get_mac() << "] ";

	/* methods */
	std::cout << methodstr << " ";

	/* rtt result */
	if (target->get_num_time()>0) {
		for (i=0;i<target->get_num_time();i++) {
			std::cout << util_timediff(target->get_time(i).tstamp1,
				target->get_time(i).tstamp2);
			if (i!=target->get_num_time()-1)
				putchar(' ');
		}
	}
	putchar('\n');

	/* ports result */
	if (target->get_num_port()>0) {
		if (((onlyok&&target->openports())||!onlyok))
			putchar('\n');
	}
	else if (target->check_service()||target->get_num_dbres()>0)
		putchar('\n');
	if (target->get_num_port()>0) {
		target->removedublports();
		if (onlyok&&!target->openports())
			return;
		for (i=0;i<target->get_num_port();i++) {
			NESCAPORT p=target->get_port(i);
			if (onlyok&&!isokport(&p))
				continue;
			block+=portblock(&p, onlyok);
			block+=',';
		}
		block.pop_back();
		if (!block.empty()) {
			std::cout << "  ports  ";
			std::cout << block;
		}
		putchar('\n');
	}

	/* services result */
	if (target->check_service()) {
		for (j=0;j<S_NUM;j++) {
			for (i=0;i<target->get_num_port();i++) {
				NESCASERVICE tmp=target->get_service(target->get_real_port(i), j);
				if (!tmp.init)
					continue;
				for (const auto&s:tmp.info) {
					std::cout<<"  "<<
						((tmp.service==S_FTP)?"ftp":
						 (tmp.service==S_HTTP)?"http":
						 "???")
						<< "(" << s.type << ")"
						<< "  ";
					std::cout << cutinfo(s.info, cut);
					putchar('\n');
				}
			}
		}
	}

	/* database result */
	if (target->get_num_dbres()>0) {
		for (j=0;j<target->get_num_dbres();j++) {
			NESCADBRES tmp=target->get_dbres(j);
			std::cout << "  db(" << tmp.find << ")  " <<
				tmp.info << std::endl;;
		}
	}
}


void NESCAPRINT::PRINTTARGETS(NESCADATA *ncsdata)
{
	if (ncsdata->opts.check_stats_flag())
		std::cout << "NESCAPRINT for "<<
			ncsdata->targets.size() << " targets\n";

	for (const auto&t:ncsdata->targets) {
		if (ncsdata->opts.check_onlyopen_flag()&&!t->openports())
			continue;
		this->nescatarget(t, 1, ncsdata->opts.check_detal_flag());
		if (t->openports())
			putchar('\n');
		ncsdata->tmplast=(t->openports())?0:1;
		if (t->isok()) ncsdata->ok++;
	}
}


static void print_u128(u128 value)
{
	u64 high=value>>64;
	u64 low=static_cast<u64>(value);

	if (high>0) {
		std::cout << std::hex << high << std::setfill('0') << std::setw(16);
		std::cout << low << std::dec;
	}
	else
		std::cout << low << std::dec;
}


void NESCAPRINT::nescastats(size_t grouplen, __uint128_t total, __uint128_t i)
{
	u128	complete;
	int	dots;

	if (total==0)
		return;

	complete=(i*100)/total;
	dots=(static_cast<uint64_t>(complete)*10)/100;

	std::cout << "\n -> completed ";
	print_u128(complete);
	std::cout << "% targets";
	std::cout << "\n -> remaining ";
	print_u128(100-complete);
	std::cout << "% [";
	for (;dots+1;dots--)
		putchar('.');
	std::cout << "]\n\n";
}


void NESCAPRINT::finish(NESCADATA *ncsdata)
{
	if (!ncsdata->ok)
		std::cout << "All scanned targets were unavailable, try another ping method.\n\n";
	if (ncsdata->tmplast)
		putchar('\n');
	std::cout << "NESCA4 finished ";
	print_u128(ncsdata->ok);
	std::cout << " up IPs (success) in ";
	std::cout << util_timediff(ncsdata->tstamp_s, ncsdata->tstamp_e) << "\n";
}


void nescastatus(const std::string &status) {
	NESCASTATUS=status;
}


static std::string uint128_to_string(__uint128_t value)
{
	std::string res;

	if (value==0)
		return "0";

	while (value > 0) {
		res.insert(res.begin(),'0'+(value%10));
		value/=10;
	}

	return res;
}


static std::string firstline(const std::string& path)
{
	std::ifstream	file(path);
	std::string	line;

	if (!file.is_open())
		return "";
	if (std::getline(file, line))
		return line;

	return "";
}


static size_t ccalc(size_t *a, size_t *b, short issize_t)
{
	if (*b>=*a)
		return *b-*a;
	else {
		if (*a>sizeof(u32)||*b>sizeof(u32)
				||issize_t==1)
			return SIZE_MAX-*a+*b;
		else
			return sizeof(u32)-*a+*b;
	}
}


static std::string getstatsdevice(NESCADEVICE *ncsdev)
{
	static size_t	startrx=SIZE_MAX, starttx=SIZE_MAX;
	size_t		tmprx, tmptx, rx, tx;
	std::string	prepath, res;

	prepath="/sys/class/net/"+ncsdev->get_device()+"/statistics/";
	tmprx=atoll(firstline((prepath+"rx_bytes")).c_str());
	tmptx=atoll(firstline((prepath+"tx_bytes")).c_str());

	if (startrx==SIZE_MAX&&starttx==SIZE_MAX) {
		startrx=tmprx;
		starttx=tmptx;
	}

	rx=ccalc(&startrx, &tmprx, 1);
	tx=ccalc(&starttx, &tmptx, 1);

	startrx=tmprx;
	starttx=tmptx;

	res=(util_bytesconv(rx)+"  "+util_bytesconv(tx));
	return res;
}


void nescawatting(std::atomic<bool> &running, __uint128_t i,
		NESCADEVICE *ncsdev)
{
	std::string	symbols[]={"-", "|", "/"}, line;
	size_t		ident;

	ident=0;
	for (;running;) {
		std::ostringstream oss;
		oss << symbols[ident] << " PASSED " <<
			uint128_to_string(i) << "    " <<
			NESCASTATUS << "    " <<
			getstatsdevice(ncsdev);

		line=oss.str();
		std::cout << "\r" << line << std::flush;
		std::this_thread::sleep_for(std::chrono::milliseconds(200));
		std::cout << "\r" << std::string(line.size(), ' ') << "\r" << std::flush;
		ident=(ident+1)%3;
	}

	std::cout << "\r" << std::string((line.size()), ' ') << "\r" << std::flush;
}


/*
 * Print class NESCADEVICE
 */
void NESCAPRINT::nescadevice(NESCADEVICE *device)
{
	mac_t	mac,dstmac;
	ip4_t	ip4,ip4_g;
	ip6_t	ip6,ip6_g;

	mac=device->get_srcmac();
	dstmac=device->get_dstmac();
	ip4=device->get_srcip4();
	ip6=device->get_srcip6();
	ip4_g=device->get_gateway4();
	ip6_g=device->get_gateway6();

	std::cout << "note: device " << device->get_device() <<
		((device->check_ipv6())?" [support ip6]":" [not support ip6]") <<
		((device->check_ipv4())?" [support ip4]":" [not support ip4]") <<
		": mac(" << mact_ntop_c(&mac) <<
		") ip4(" << ip4t_ntop_c(&ip4) <<
		") ip6(" << ip6t_ntop_c(&ip6) << ") gateway4(";

	std::cout << ip4t_ntop_c(&ip4_g) <<") gateway6(" <<
		ip6t_ntop_c(&ip6_g) << ") dstmac(" << mact_ntop_c(&dstmac)
		<< ")\n";
}


/*
 * print usage (help menu)
 */
void NESCAPRINT::usage(int argc, char **argv)
{
	printf("Usage %s [flags] <targets>\n", argv[0]);
	std::cout << R"(
 -import <filepath> - import target(s) from file
 -random-ip <numips> - choose random ip4 target(s)
 -dev <ifr.if_name> - specify your interface
 -dst, -src <mac> - set your source/dest mac address
 -ip4, -ip6 <ip4/6> - set your source ip4 or ip6
 -maxfds <numfds> - set your max open fds
 -pps <pps> - set max packet per second for send
 -gplus <num> - set plus target group size
 -gmax <num> - set max target group size
 -gmin <num> - set min target group size
 -stats - display engine statistics after exec
 -dlen <length> - append random data to packets
 -dhex <hexseq> - append a custom data to packet
 -dstr <str> - append a custom ASCII data to packets
 -ttl <num> - set Time To Live, (TTL)
 -win <num> - set your TCP window size, default 1024
 -ackn <num> - set TCP acknowledgment number
 -off <flag1[/flag2]...,> - set fragmentation OFFset: df,mf,rf
 -ipopt <hex> - set ip options to packet
 -badsum - send packets with bodus checksum
 -adler32 - use adler32 checksum for all SCTP packets
 -ps, -pa, -py, -pu <ports> - use SYN/ACK/UDP/SCTP ping
 -pr, -pe, -pi, -pm - use ARP/ICMP ping ECHO/INFO/TIMESTAMP
 -all-ping - use all ping methods
 -wait-ping <time> - set your wait time for ping (timeout)
 -num-ping <num> - set count ping probes
 -n-ping - skip ping scan, disable ping
 -xmas, -fin, -psh, -null - use one of these scanning methods
 -syn, -ack, -window, -maimon - use other TCP methods port scan
 -init, -cookie, -udp - use init, cookie SCTP, or UDP port scan method
 -all-scan - using all scan port methods
 -wait-scan <time> - set your max wait time for scan (timeout)
 -num-scan <num> - set count scan probes
 -mtpl-scan <multiplier> - set your multiplier for calc scan timeout
	 Nb: <rtt> * <mult> = timeout
 -p <ports> - set ports for scan
	 Ex: -p 80; -p 80,443; -p S:40-50,U:3,T:33,10-15
 -sn, -n-scan - skip port scan, disable port scan
 -s <ports> - set ports for service, ex: -s http:80-81,ftp:21,21
 -detal - do not abbreviate service information
 -dbpath <path> - set your nesca database path
 -n-db - skip or off nesca database scanning
 -login <path> - set your logins passwd list
 -pass <path> - set your pass passwd list
 -wait-brute <time> - set your max wait time (timeout)
 -threads-brute <num> - set your number threads
 -delay-brute <time> - set your special delay
 -n-brute - skip or off nesca bruteforcing
 -onlyopen - output information only if there are open ports
 -v - display all verbose information
 -html <filepath> - save output in html format
 -n - no resolv, skip resolution dns names
 -cfg <path> - set your config file for opts
 -help - display this menu and exit

 ./nesca4 google.com -p 80,443 -syn -pe -v
 ./nesca4 -random-ip 1000 google.com -p 80,443 -all-ping -syn -v
 ./nesca4 _gateway -pr -p 0-500 -syn -v -maxfds 5
)";
	putchar(0xa);
	exit(0);
}


/*
 * print run string
 */
void NESCAPRINT::run(void)
{
	char formatted_date[11];
	get_current_date(formatted_date, sizeof(formatted_date));
	printf("Running NESCA4 (v%s) time %s at %s\n",
			PACKAGE_VERSION, get_time(), formatted_date);
}


/*
 * print error string
 */
void NESCAPRINT::error(const std::string &err)
{
	std::cout << "err: " << err << std::endl;
	exit(0);
}

void NESCAPRINT::warning(const std::string &warn)
{
	std::cout << "warn: " << warn << std::endl;
}

void NESCAPRINT::note(const std::string &note)
{
	std::cout << "note: " << note << std::endl;
}

void NESCAHTML::nh_addtobuf(const std::string &txt)
{
	std::ofstream file(this->path, std::ios::app);
	if (file.is_open())
		 file<<txt<<std::endl;
	total++;
}

std::string NESCAHTML::nh_fmtdate(const std::string &fmt)
{
	std::time_t	t;
	std::tm		*now;
	char		date[100];

	t=std::time(NULL);
	now=std::localtime(&t);

	std::strftime(date, sizeof(date),
		fmt.c_str(), now);

	return std::string(date);
}

void NESCAHTML::nh_style(const std::string &filepath)
{
	std::string respath,line;

	respath=(filepath.empty())?
		DEFAULT_STYLE_PATH:filepath;

	std::ifstream f(respath);
	while (std::getline(f, line))
		nh_addtobuf(line);

	f.close();
}

void NESCAHTML::nh_headeropen(void)
{
	nh_addtobuf("<!DOCTYPE html>");
	nh_addtobuf("<html lang=\"en\">");
	nh_addtobuf("	<head>");
	nh_addtobuf("		<meta charset=\"UTF-8\">");
	nh_addtobuf("		<title>"+nh_fmtdate("Results of %b %d %Y")+"</title>");
	nh_style("");
	nh_addtobuf("	</head>");
}

void NESCAHTML::nh_bodyopen(NESCADATA *ncsdata)
{
	nh_addtobuf("	<body>");
	nh_addtobuf("		<center><span>"+ncsdata->opts.runcmd+"</span></center>");
	nh_addtobuf("		<div class=\"title\">");
	nh_addtobuf("			<center><h5>"+nh_fmtdate("%a %b %d %H:%M:%S %Y")+"</h5></center>");
	nh_addtobuf("			<hr>");
	nh_addtobuf("			<center><a href=\"	\">.Automatically generated by NESCA4.</a></center>");
	nh_addtobuf("		</div>");
	nh_addtobuf("		<br>");
}

static void remline(const std::string &filename, size_t num)
{
	std::string	line="";
	size_t		cur=0;

	std::ifstream infile(filename);
	if (!infile.is_open())
		return;

	std::ofstream temp_file("resources/tmp.txt");
	if (!temp_file.is_open()) {
		infile.close();
		return;
	}

	while (std::getline(infile, line)) {
		if (cur!=num)
			temp_file<<line<<'\n';
		++cur;
	}

	infile.close();
	temp_file.close();
	std::remove(filename.c_str());
	std::rename("resources/tmp.txt", filename.c_str());
}

void NESCAHTML::nh_bodyclose(void)
{
	if (this->bodyclose_pos>0&&this->bodyclose_pos<=total)
		remline(this->path, bodyclose_pos);
	nh_addtobuf("	</body>");
	this->bodyclose_pos=total-1;
}

void NESCAHTML::nh_headerclose(void)
{
	if (this->headerclose_pos>0&&this->headerclose_pos<=total)
		remline(this->path, headerclose_pos-1);
	nh_addtobuf("</html>");
	this->headerclose_pos=total-1;
}

#include <filesystem>

void NESCAHTML::NH_OPEN(NESCADATA *ncsdata)
{
	this->open=1;
	nh_headeropen();
	nh_bodyopen(ncsdata);
}

void NESCAHTML::NH_ADD(NESCATARGET *target, NESCADATA *ncsdata, bool onlyok, bool cut)
{
	std::string	block, methodstr;
	size_t		i, j;
	bool		details;

	details=0;
	if (onlyok&&!target->isok())
		return;

	methodstr="'.";
	if (target->get_num_time()>0)
		for (i=0;i<target->get_num_time();i++)
			methodstr+=strmethod(target->get_type_time(i));
	if (target->get_num_port()>0)
		for (i=0;i<target->get_num_port();i++)
			methodstr+=strmethod(target->get_port(i).method);
	methodstr.erase(std::unique(methodstr.begin(),
		methodstr.end()), methodstr.end());
	methodstr+="'";

	nh_addtobuf("");
	nh_addtobuf("		<div class=\"log-entry\">");
	nh_addtobuf("			"+nh_fmtdate("[%a %b %d %H:%M:%S %Y]"));
	nh_addtobuf("			<a href=\"http://"+target->get_mainip()+"\">"+target->get_mainip()+"</a>");
	nh_addtobuf("			mtdh=<span class=\"info_1\">"+methodstr+"</span>;");

	if (target->get_num_dns()>0) {
		block="";
		for (i=0;i<target->get_num_dns();i++) {
			block+=target->get_dns(i);
			if (i!=target->get_num_dns()-1)
				block+=", ";
		}
		if (!block.empty())
			nh_addtobuf("			rdns=<span class=\"info\">"+block+"</span>;");
	}

	if (target->get_num_time()>0) {
		block="";
		for (i=0;i<target->get_num_time();i++) {
			block+=util_timediff(target->get_time(i).tstamp1,
				target->get_time(i).tstamp2);
			if (i!=target->get_num_time()-1)
				block+=", ";
		}
		if (!block.empty())
			nh_addtobuf("			rtt=<span class=\"info_2\">"+block+"</span>;");
	}

	if (onlyok&&(target->openports()||target->check_service()))
		details=1;

	if (details) {
		nh_addtobuf("		<details><summary>detail</summary>");
		nh_addtobuf("		<pre>");
		nh_addtobuf("");
	}
	if (target->get_num_port()>0) {
		block="";
		if (onlyok&&!target->openports())
			goto skip;
		for (i=0;i<target->get_num_port();i++) {
			NESCAPORT p=target->get_port(i);
			if (onlyok&&!isokport(&p))
				continue;
			block+=portblock(&p, onlyok);
			block+=", ";
		}
		block.pop_back();
		block.pop_back();
		if (!block.empty())
			nh_addtobuf("	Ports: <span class=\"info\">"+
				block+"</span>;");
	}
skip:
	if (target->check_service()) {
		for (j=0;j<S_NUM;j++) {
			for (i=0;i<target->get_num_port();i++) {
				NESCASERVICE tmp=target->get_service(target->get_real_port(i), j);
				if (!tmp.init)
					continue;
				for (const auto&s:tmp.info) {
					block="";
					block+=
					std::string(((tmp.service==S_FTP)?"ftp":(tmp.service==S_HTTP)?
						"http": "???")) + "(" + s.type + ")" + "	";
					nh_addtobuf("	"+block+"<span class=\"info\">"+
						cutinfo(s.info, cut)+"</span>;");
				}
			}
		}
	}
	if (target->get_num_dbres()>0) {
		for (j=0;j<target->get_num_dbres();j++) {
			NESCADBRES tmp=target->get_dbres(j);
			block="";
			block+="db("+tmp.find+")	";
			nh_addtobuf("	"+block+"<span class=\"info\">"+
				cutinfo(tmp.info, cut)+"</span>;");
		}
	}
	if (details) {
		nh_addtobuf("		</pre>");
		nh_addtobuf("		</details>");
	}
	nh_addtobuf("		</div>");
	NH_CLOSE();
}

void NESCAHTML::NH_CLOSE(void)
{
	nh_bodyclose();
	nh_headerclose();
	total-=2;
}

void NESCAHTML::NHTARGETS(NESCADATA *ncsdata)
{
	bool onlyoktmp=1;

	if (!ncsdata->opts.check_html_flag())
		return;

	if (!this->open) {
		nh_setpath(ncsdata->opts.get_html_param());
		NH_OPEN(ncsdata);
	}
	for (const auto&t:ncsdata->targets) {
		if (ncsdata->opts.check_onlyopen_flag()
			&&!t->openports())
			continue;
		NH_ADD(t, ncsdata, onlyoktmp,
			ncsdata->opts.check_detal_flag());
	}
}

void NESCAHTML::nh_setpath(const std::string &path) {
	this->path=path;
}