libgfanet/src/inet4s.cpp

#include "util.h"
#include "inet4s.h"

/////////////////////////////////////////////////////////////////////////////

bool ParseIfaceInet4sParam(const std::vector<std::string> &v, IFACE_INET_STATIC &is)
{
	auto vSize = v.size();

	if(vSize >= 2)
	{
		struct in_addr addr, mask;
		if(!v[0].compare("address"))
		{
			std::vector<std::string> va;
			SplitString(v[1], "[^\\/]+", va);

			if(va.size() == 1)
			{
				if(inet_aton(va[0].c_str(), &addr))
				{
					is.addr = addr;
					return true;
				}
			}
			else if(va.size() == 2)
			{
				if(inet_aton(va[0].c_str(), &addr))
				{
					if(IsDecimalInt(va[1].c_str()))
					{
						unsigned int nBits = (unsigned int)std::stoul(va[1], 0, 0);
						if(nBits <= 32)
							is.netprefix = nBits;
					}
					else if(inet_aton(va[1].c_str(), &mask) && IsValidNetmask(mask))
						is.netprefix = Mask2Prefix(mask);
					else
						return false;
					is.addr = addr;
					return true;
				}
			}
		}
		else if(!v[0].compare("gateway"))
		{
			if(inet_aton(v[1].c_str(), &addr))
			{
				is.gate = addr;
				return true;
			}
		}
		else if(!v[0].compare("broadcast"))
		{
			if(inet_aton(v[1].c_str(), &addr))
			{
				is.bcast = addr;
				return true;
			}
			else if(!v[1].compare("-"))
			{
				is.bcastOpt = -1;
				return true;
			}
		}
		else if(!v[0].compare("pointopoint"))
		{
			if(inet_aton(v[1].c_str(), &addr))
			{
				is.pointopoint = addr;
				return true;
			}
		}
		else if(!v[0].compare("netmask"))
		{
			if(IsDecimalInt(v[1].c_str()))
			{
				unsigned int nBits = (unsigned int)std::stoul(v[1], 0, 0);
				if(nBits <= 32)
				{
					is.netmask.s_addr = Prefix2Mask(nBits);
					return true;
				}
			}
			else if(inet_aton(v[1].c_str(), &mask))
			{
				if(IsValidNetmask(mask))
				{
					is.netmask = mask;
					return true;
				}
			}
		}
		else if(!v[0].compare("dns-nameservers"))
		{
			int bNs = 0;
			for(size_t i = 1, j = 0; i < vSize && j < _countof(is.namesvr); i++, j++)
			{
				if(inet_aton(v[i].c_str(), &addr))
				{
					is.namesvr[j] = addr;
					bNs++;
				}
			}
			return bNs > 0;
		}
		else if(!v[0].compare("dns-search"))
		{
			for(size_t i = 1; i < vSize; i++)
			{
				is.dnss.push_back(v[i]);
			}
			return true;
		}
		else if(!v[0].compare("hwaddress"))
		{
			is.hwaddr = v[1];
			strlcase(is.hwaddr);
			return true;
		}
		else if(!v[0].compare("metric") && IsDecimalInt(v[1].c_str()))
		{
			is.metric = (int)std::stol(v[1], 0, 0);
			return true;
		}
		else if(!v[0].compare("mtu") && IsDecimalInt(v[1].c_str()))
		{
			is.mtu = (int)std::stol(v[1], 0, 0);
			return true;
		}
		else if(!v[0].compare("scope"))
		{
			is.scope = v[1];
			return true;
		}
	}

	return false;
}

/////////////////////////////////////////////////////////////////////////////

bool WriteIfaceInet4sParam(FILE *pf, const IFACE_INET_STATIC &is)
{
	if(is.addr.s_addr != INADDR_ANY)
	{
		fprintf(pf, "\taddress %s", inet_ntoa(is.addr));
		if(is.netprefix)
			fprintf(pf, "/%u", is.netprefix);
		fputc('\n', pf);
	}
#if 0
	if(!is.netprefix && is.netmask.s_addr != INADDR_ANY)
	{
		fprintf(pf, "\tnetmask %s\n", inet_ntoa(is.netmask));
	}
#endif
	if(is.gate.s_addr != INADDR_ANY)
	{
		fprintf(pf, "\tgateway %s\n", inet_ntoa(is.gate));
	}

	if(is.bcastOpt == -1)
	{
		fprintf(pf, "\tbroadcast -\n");
	}
	else if(is.bcast.s_addr != INADDR_ANY)
	{
		fprintf(pf, "\tbroadcast %s\n", inet_ntoa(is.bcast));
	}

	if(is.pointopoint.s_addr != INADDR_ANY)
	{
		fprintf(pf, "\tpointopoint %s\n", inet_ntoa(is.pointopoint));
	}

	if(is.namesvr[0].s_addr != INADDR_ANY)
	{
		fputs("\tdns-nameservers", pf);
		for(size_t i = 0; i < _countof(is.namesvr); i++)
		{
			if(is.namesvr[i].s_addr != INADDR_ANY)
			{
				fputc(' ', pf);
				fputs(inet_ntoa(is.namesvr[i]), pf);
			}
		}
		fputc('\n', pf);
	}

	if(is.dnss.size() > 0)
	{
		fputs("\tdns-search", pf);
		for(auto it = is.dnss.begin(); it != is.dnss.end(); it++)
		{
			const std::string &ds = *it;
			fputc(' ', pf);
			fputs(ds.c_str(), pf);
		}
		fputc('\n', pf);
	}

	if(!is.hwaddr.empty())
	{
		fprintf(pf, "\thwaddress %s\n", is.hwaddr.c_str());
	}

	if(is.metric >= 0)
	{
		fprintf(pf, "\tmetric %d\n", is.metric);
	}

	if(is.mtu >= 0)
	{
		fprintf(pf, "\tmtu %d\n", is.mtu);
	}

	if(!is.scope.empty())
	{
		fprintf(pf, "\tscope %s\n", is.scope.c_str());
	}

	return true;
}