sys.cpp

P2P应用 ： Peercast的源代码

// -----------------------------------
void String::ASCII2ESC(const char *in, bool safe)
{
	char *op = data;
	char *oe = data+MAX_LEN-10;
	const char *p = in;
	unsigned char c;
	while (c = *p++)
	{
		if (((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')))
			*op++ = c;
		else
		{
			*op++ = '%';
			if (safe)
				*op++ = '%';
			*op=0;
			sprintf(op,"%02X",(int)c);
			op+=2;
		}
		if (op >= oe)
			break;
	}
	*op=0;
}
// -----------------------------------
void String::HTML2ASCII(const char *in)
{
	unsigned char c;
	char *o = data;
	char *oe = data+MAX_LEN-10;
	const char *p = in;
	while (c = *p++)
	{
		if ((c == '&') && (p[0] == '#'))
		{
			p++;
			char code[8];
			char *cp = code;
			char ec = *p++;		// hex/dec
			while (c=*p++) 
			{
				if (c!=';')
					*cp++ = c;
				else
					break;
			}
			*cp = 0;
			c = (unsigned char)strtoul(code,NULL,ec=='x'?16:10);
		}
		*o++ = c;
		if (o >= oe)
			break;
	}

	*o=0;
}
// -----------------------------------
void String::HTML2UNICODE(const char *in)
{
	MemoryStream utf8(data,MAX_LEN-1);

	unsigned char c;
	while (c = *in++)
	{
		if ((c == '&') && (*in == '#'))
		{
			in++;
			char code[16];
			char *cp = code;
			char ec = *in++;		// hex/dec
			while (c=*in++) 
			{
				if (c!=';')
					*cp++ = c;
				else
					break;
			}
			*cp = 0;
			utf8.writeUTF8(strtoul(code,NULL,ec=='x'?16:10));
		}else
			utf8.writeUTF8(c);

		if (utf8.pos >= (MAX_LEN-10))
			break;
	}

	utf8.writeUTF8(0);
}

// -----------------------------------
void String::ESC2ASCII(const char *in)
{
	unsigned char c;
	char *o = data;
	char *oe = data+MAX_LEN-10;
	const char *p = in;
	while (c = *p++)
	{
		if (c == '+')
			c = ' ';
		else if (c == '%')
		{
			if (p[0] == '%')
				p++;

			char hi = TOUPPER(p[0]);
			char lo = TOUPPER(p[1]);
			c = (TONIBBLE(hi)<<4) | TONIBBLE(lo);
			p+=2;
		}
		*o++ = c;
		if (o >= oe)
			break;
	}

	*o=0;
}
// -----------------------------------
void String::ASCII2META(const char *in, bool safe)
{
	char *op = data;
	char *oe = data+MAX_LEN-10;
	const char *p = in;
	unsigned char c;
	while (c = *p++)
	{
		switch (c)
		{
			case '%':
				if (safe)
					*op++='%';
				break;
			case ';':
				c = ':';
				break;
		}

		*op++=c;
		if (op >= oe)
			break;
	}
	*op=0;
}
// -----------------------------------
void String::convertTo(TYPE t)
{
	if (t != type)
	{
		String tmp = *this;

		// convert to ASCII
		switch (type)
		{
			case T_UNKNOWN:
			case T_ASCII:
				break;
			case T_HTML:
				tmp.HTML2ASCII(data);
				break;
			case T_ESC:
			case T_ESCSAFE:
				tmp.ESC2ASCII(data);
				break;
			case T_META:
			case T_METASAFE:
				break;
			case T_BASE64:
				tmp.BASE642ASCII(data);
				break;
		}

		// convert to new format
		switch (t)
		{
			case T_UNKNOWN:
			case T_ASCII:
				strcpy(data,tmp.data);
				break;
			case T_UNICODE:
				UNKNOWN2UNICODE(tmp.data,false);
				break;
			case T_UNICODESAFE:
				UNKNOWN2UNICODE(tmp.data,true);
				break;
			case T_HTML:
				ASCII2HTML(tmp.data);
				break;
			case T_ESC:
				ASCII2ESC(tmp.data,false);
				break;
			case T_ESCSAFE:
				ASCII2ESC(tmp.data,true);
				break;
			case T_META:
				ASCII2META(tmp.data,false);
				break;
			case T_METASAFE:
				ASCII2META(tmp.data,true);
				break;
		}

		type = t;
	}
}
// -----------------------------------
void LogBuffer::write(const char *str, TYPE t)
{
	lock.on();

	unsigned int len = strlen(str);
	int cnt=0;
	while (len)
	{
		unsigned int rlen = len;
		if (rlen > (lineLen-1))
			rlen = lineLen-1;

		int i = currLine % maxLines;
		int bp = i*lineLen;
		strncpy(&buf[bp],str,rlen);
		buf[bp+rlen] = 0;
		if (cnt==0)
		{
			times[i] = sys->getTime();
			types[i] = t;
		}else
		{
			times[i] = 0;
			types[i] = T_NONE;
		}
		currLine++;

		str += rlen;
		len -= rlen;
		cnt++;
	}

	lock.off();
}

// -----------------------------------
char *getCGIarg(const char *str, const char *arg)
{
	if (!str)
		return NULL;

	char *s = strstr(str,arg);

	if (!s)
		return NULL;

	s += strlen(arg);

	return s;
}

// -----------------------------------
bool cmpCGIarg(char *str, char *arg, char *value)
{
	if ((!str) || (!strlen(value)))
		return false;

	if (strnicmp(str,arg,strlen(arg)) == 0)
	{

		str += strlen(arg);

		return strncmp(str,value,strlen(value))==0;
	}else
		return false;
}
// -----------------------------------
bool hasCGIarg(char *str, char *arg)
{
	if (!str)
		return false;

	char *s = strstr(str,arg);

	if (!s)
		return false;

	return true;
}


// ---------------------------
void GnuID::encode(Host *h, const char *salt1, const char *salt2, unsigned char salt3)
{
	int s1=0,s2=0;
	for(int i=0; i<16; i++)
	{
		unsigned char ipb = id[i];

		// encode with IP address 
		if (h)
			ipb ^= ((unsigned char *)&h->ip)[i&3];

		// add a bit of salt 
		if (salt1)
		{
			if (salt1[s1])
				ipb ^= salt1[s1++];
			else
				s1=0;
		}

		// and some more
		if (salt2)
		{
			if (salt2[s2])
				ipb ^= salt2[s2++];
			else
				s2=0;
		}

		// plus some pepper
		ipb ^= salt3;

		id[i] = ipb;
	}

}
// ---------------------------
void GnuID::toStr(char *str)
{

	str[0] = 0;
	for(int i=0; i<16; i++)
	{
		char tmp[8];
		unsigned char ipb = id[i];

		sprintf(tmp,"%02X",ipb);
		strcat(str,tmp);
	}

}
// ---------------------------
void GnuID::fromStr(const char *str)
{
	clear();

	if (strlen(str) < 32)
		return;

	char buf[8];

	buf[2] = 0;

	for(int i=0; i<16; i++)
	{
		buf[0] = str[i*2];
		buf[1] = str[i*2+1];
		id[i] = (unsigned char)strtoul(buf,NULL,16);
	}

}

// ---------------------------
void GnuID::generate(unsigned char flags)
{
	clear();

	for(int i=0; i<16; i++)
		id[i] = sys->rnd();

	id[0] = flags;
}

// ---------------------------
unsigned char GnuID::getFlags()
{
	return id[0];
}

// ---------------------------
GnuIDList::GnuIDList(int max)
:ids(new GnuID[max])
{
	maxID = max;
	for(int i=0; i<maxID; i++)
		ids[i].clear();
}
// ---------------------------
GnuIDList::~GnuIDList()
{
	delete [] ids;
}
// ---------------------------
bool GnuIDList::contains(GnuID &id)
{
	for(int i=0; i<maxID; i++)
		if (ids[i].isSame(id))
			return true;
	return false;
}
// ---------------------------
int GnuIDList::numUsed()
{
	int cnt=0;
	for(int i=0; i<maxID; i++)
		if (ids[i].storeTime)
			cnt++;
	return cnt;
}
// ---------------------------
unsigned int GnuIDList::getOldest()
{
	unsigned int t=(unsigned int)-1;
	for(int i=0; i<maxID; i++)
		if (ids[i].storeTime)
			if (ids[i].storeTime < t)
				t = ids[i].storeTime;
	return t;
}
// ---------------------------
void GnuIDList::add(GnuID &id)
{
	unsigned int minTime = (unsigned int) -1;
	int minIndex = 0;

	// find same or oldest
	for(int i=0; i<maxID; i++)
	{
		if (ids[i].isSame(id))
		{
			ids[i].storeTime = sys->getTime();
			return;
		}
		if (ids[i].storeTime <= minTime)
		{
			minTime = ids[i].storeTime;
			minIndex = i;
		}
	}

	ids[minIndex] = id;
	ids[minIndex].storeTime = sys->getTime();
}
// ---------------------------
void GnuIDList::clear()
{
	for(int i=0; i<maxID; i++)
		ids[i].clear();
}
	
// ---------------------------
void LogBuffer::dumpHTML(Stream &out)
{
	lock.on();

	unsigned int nl = currLine;
	unsigned int sp = 0;
	if (nl > maxLines)
	{
		nl = maxLines-1;
		sp = (currLine+1)%maxLines;
	}

	String tim,str;
	if (nl)
	{
		for(unsigned int i=0; i<nl; i++)
		{
			unsigned int bp = sp*lineLen;

			if (types[sp])
			{
				tim.setFromTime(times[sp]);

				out.writeString(tim.cstr());
				out.writeString(" <b>[");
				out.writeString(getTypeStr(types[sp]));
				out.writeString("]</b> ");
			}
			str.set(&buf[bp]);
			str.convertTo(String::T_HTML);

			out.writeString(str.cstr());
			out.writeString("<br>");

			sp++;
			sp %= maxLines;
		}
	}

	lock.off();

}

// ---------------------------
void	ThreadInfo::shutdown()
{
	active = false;
	//sys->waitThread(this);
}