sys.cpp

P2P应用 ： Peercast的源代码

// ------------------------------------------------
// File : sys.cpp
// Date: 4-apr-2002
// Author: giles
// Desc: 
//		Sys is a base class for all things systemy, like starting threads, creating sockets etc..
//		Lock is a very basic cross platform CriticalSection class		
//		SJIS-UTF8 conversion by ????
//
// (c) 2002 peercast.org
// ------------------------------------------------
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// ------------------------------------------------

#include "common.h"
#include "sys.h"
#include "socket.h"
#include "gnutella.h"
#include <stdlib.h>
#include <time.h>
#include "jis.h"

// -----------------------------------
#define isSJIS(a,b) ((a >= 0x81 && a <= 0x9f || a >= 0xe0 && a<=0xfc) && (b >= 0x40 && b <= 0x7e || b >= 0x80 && b<=0xfc))
#define isEUC(a) (a >= 0xa1 && a <= 0xfe)
#define isASCII(a) (a <= 0x7f) 
#define isPLAINASCII(a) (((a >= '0') && (a <= '9')) || ((a >= 'a') && (a <= 'z')) || ((a >= 'A') && (a <= 'Z')))
#define isUTF8(a,b) ((a & 0xc0) == 0xc0 && (b & 0x80) == 0x80 )
#define isESCAPE(a,b) ((a == '&') && (b == '#'))
#define isHTMLSPECIAL(a) ((a == '&') || (a == '\"') || (a == '\'') || (a == '<') || (a == '>'))



// -----------------------------------
const char *LogBuffer::logTypes[]=
{
	"",
	"DBUG",
	"EROR",
	"GNET",
	"CHAN",
};

// -----------------------------------
// base64 encode/decode taken from ices2 source.. 
static char base64table[64] = {
    'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
    'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
    'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
    'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/'
};
#if 0
// -----------------------------------
static char *util_base64_encode(char *data)
{
    int len = strlen(data);
    char *out = malloc(len*4/3 + 4);
    char *result = out;
    int chunk;

    while(len > 0) {
        chunk = (len >3)?3:len;
        *out++ = base64table[(*data & 0xFC)>>2];
        *out++ = base64table[((*data & 0x03)<<4) | ((*(data+1) & 0xF0) >> 4)];
        switch(chunk) {
            case 3:
                *out++ = base64table[((*(data+1) & 0x0F)<<2) | ((*(data+2) & 0xC0)>>6)];
                *out++ = base64table[(*(data+2)) & 0x3F];
                break;
            case 2:
                *out++ = base64table[((*(data+1) & 0x0F)<<2)];
                *out++ = '=';
                break;
            case 1:
                *out++ = '=';
                *out++ = '=';
                break;
        }
        data += chunk;
        len -= chunk;
    }

    return result;
}
#endif

// -----------------------------------
static int base64chartoval(char input)
{
    if(input >= 'A' && input <= 'Z')
        return input - 'A';
    else if(input >= 'a' && input <= 'z')
        return input - 'a' + 26;
    else if(input >= '0' && input <= '9')
        return input - '0' + 52;
    else if(input == '+')
        return 62;
    else if(input == '/')
        return 63;
    else if(input == '=')
        return -1;
    else
        return -2;
}

// -----------------------------------
static char *util_base64_decode(char *input)
{
	return NULL;
}





// ------------------------------------------
Sys::Sys()
{
	idleSleepTime = 10;
	logBuf = new LogBuffer(1000,100);
	numThreads=0;
}

// ------------------------------------------
void Sys::sleepIdle()
{
	sleep(idleSleepTime);
}

// ------------------------------------------
bool Host::isLocalhost()
{
	return loopbackIP() || (ip == ClientSocket::getIP(NULL)); 
}
// ------------------------------------------
void Host::fromStrName(const char *str, int p)
{
	if (!strlen(str))
	{
		port = 0;
		ip = 0;
		return;
	}

	char name[128];
	strncpy(name,str,sizeof(name)-1);
	port = p;
	char *pp = strstr(name,":");
	if (pp)
	{
		port = atoi(pp+1);
		pp[0] = 0;
	}

	ip = ClientSocket::getIP(name);
}
// ------------------------------------------
void Host::fromStrIP(const char *str, int p)
{
	unsigned int ipb[4];
	unsigned int ipp;


	if (strstr(str,":"))
	{
		if (sscanf(str,"%03d.%03d.%03d.%03d:%d",&ipb[0],&ipb[1],&ipb[2],&ipb[3],&ipp) == 5)
		{
			ip = ((ipb[0]&0xff) << 24) | ((ipb[1]&0xff) << 16) | ((ipb[2]&0xff) << 8) | ((ipb[3]&0xff));
			port = ipp;
		}else
		{
			ip = 0;
			port = 0;
		}
	}else{
		port = p;
		if (sscanf(str,"%03d.%03d.%03d.%03d",&ipb[0],&ipb[1],&ipb[2],&ipb[3]) == 4)
			ip = ((ipb[0]&0xff) << 24) | ((ipb[1]&0xff) << 16) | ((ipb[2]&0xff) << 8) | ((ipb[3]&0xff));
		else
			ip = 0;
	}
}
// -----------------------------------
bool Host::isMemberOf(Host &h)
{
	if (h.ip==0)
		return false;

    if( h.ip0() != 255 && ip0() != h.ip0() )
        return false;
    if( h.ip1() != 255 && ip1() != h.ip1() )
        return false;
    if( h.ip2() != 255 && ip2() != h.ip2() )
        return false;
    if( h.ip3() != 255 && ip3() != h.ip3() )
        return false;

/* removed for endieness compatibility
	for(int i=0; i<4; i++)
		if (h.ipByte[i] != 255)
			if (ipByte[i] != h.ipByte[i])
				return false;
*/
	return true;
}

// -----------------------------------
char *trimstr(char *s1)
{
	while (*s1)
	{
		if ((*s1 == ' ') || (*s1 == '\t'))
			s1++;
		else
			break;

	}

	char *s = s1;

	s1 = s1+strlen(s1);

	while (*--s1)
		if ((*s1 != ' ') && (*s1 != '\t'))
			break;

	s1[1] = 0;

	return s;
}

// -----------------------------------
char *stristr(const char *s1, const char *s2)
{
	while (*s1)
	{
		if (TOUPPER(*s1) == TOUPPER(*s2))
		{
			const char *c1 = s1;
			const char *c2 = s2;

			while (*c1 && *c2)
			{
				if (TOUPPER(*c1) != TOUPPER(*c2))
					break;
				c1++;
				c2++;
			}
			if (*c2==0)
				return (char *)s1;
		}

		s1++;
	}
	return NULL;
}
// -----------------------------------
bool String::isValidURL()
{
	return (strnicmp(data,"http://",7)==0) || (strnicmp(data,"mailto:",7)==0);
}

// -----------------------------------
void String::setFromTime(unsigned int t)
{
	char *p = ctime((time_t*)&t);
	if (p)
		strcpy(data,p);
	else
		strcpy(data,"-");
	type = T_ASCII;
}
// -----------------------------------
void String::setFromStopwatch(unsigned int t)
{
	unsigned int sec,min,hour,day;

	sec = t%60;
	min = (t/60)%60;
	hour = (t/3600)%24;
	day = (t/86400);

	if (day)
		sprintf(data,"%d day, %d hour",day,hour);
	else if (hour)
		sprintf(data,"%d hour, %d min",hour,min);
	else if (min)
		sprintf(data,"%d min, %d sec",min,sec);
	else if (sec)
		sprintf(data,"%d sec",sec);
	else
		sprintf(data,"-");

	type = T_ASCII;
}
// -----------------------------------
void String::setFromString(const char *str, TYPE t)
{
	int cnt=0;
	bool quote=false;
	while (*str)
	{
		bool add=true;
		if (*str == '\"')
		{
			if (quote) 
				break;
			else 
				quote = true;
			add = false;
		}else if (*str == ' ')
		{
			if (!quote)
			{
				if (cnt)
					break;
				else
					add = false;
			}
		}

		if (add)
		{
			data[cnt++] = *str++;
			if (cnt >= (MAX_LEN-1))
				break;
		}else
			str++;
	}
	data[cnt] = 0;
	type = t;
}

// -----------------------------------
int String::base64WordToChars(char *out,const char *input)
{
	char *start = out;
	signed char vals[4];

    vals[0] = base64chartoval(*input++);
    vals[1] = base64chartoval(*input++);
    vals[2] = base64chartoval(*input++);
    vals[3] = base64chartoval(*input++);

    if(vals[0] < 0 || vals[1] < 0 || vals[2] < -1 || vals[3] < -1) 
		return 0;

    *out++ = vals[0]<<2 | vals[1]>>4;
    if(vals[2] >= 0)
        *out++ = ((vals[1]&0x0F)<<4) | (vals[2]>>2);
    else
        *out++ = 0;

    if(vals[3] >= 0)
        *out++ = ((vals[2]&0x03)<<6) | (vals[3]);
    else
        *out++ = 0;

	return out-start;
}

// -----------------------------------
void String::BASE642ASCII(const char *input)
{
	char *out = data;
    int len = strlen(input);

    while(len >= 4) 
	{
		out += base64WordToChars(out,input);
		input += 4;
        len -= 4;
    }
    *out = 0;
}



// -----------------------------------
void String::UNKNOWN2UNICODE(const char *in,bool safe)
{
	MemoryStream utf8(data,MAX_LEN-1);

	unsigned char c;
	unsigned char d;

	while (c = *in++)
	{
		d = *in;

		if (isUTF8(c,d))		// utf8 encoded 
		{
			int numChars=0;
			int i;

			for(i=0; i<6; i++)
			{
				if (c & (0x80>>i))
					numChars++;
				else
					break;
			}

			utf8.writeChar(c);
			for(i=0; i<numChars-1; i++)
				utf8.writeChar(*in++);

		}
		else if(isSJIS(c,d))			// shift_jis
		{
			utf8.writeUTF8(JISConverter::sjisToUnicode((c<<8 | d)));
			in++;

		}
		else if(isEUC(c) && isEUC(d))		// euc-jp
		{
			utf8.writeUTF8(JISConverter::eucToUnicode((c<<8 | d)));
			in++;

		}
		else if (isESCAPE(c,d))		// html escape tags &#xx;
		{
			in++;
			char code[16];
			char *cp = code;
			while (c=*in++) 
			{
				if (c!=';')
					*cp++ = c;
				else
					break;
			}
			*cp = 0;

			utf8.writeUTF8(strtoul(code,NULL,10));

		}
		else if (isPLAINASCII(c))	// plain ascii : a-z 0-9 etc..
		{
			utf8.writeUTF8(c);

		}
		else if (isHTMLSPECIAL(c) && safe)			
		{
			const char *str = NULL;
			if (c == '&') str = "&amp;";
			else if (c == '\"') str = "&quot;";
			else if (c == '\'') str = "&#039;";
			else if (c == '<') str = "&lt;";
			else if (c == '>') str = "&gt;";
			else str = "?";

			utf8.writeString(str);
		}
		else
		{
			utf8.writeUTF8(c);
		}

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


	}

	utf8.writeChar(0);	// null terminate

}

// -----------------------------------
void String::ASCII2HTML(const char *in)
{
	char *op = data;
	char *oe = data+MAX_LEN-10;
	unsigned char c;
	const char *p = in;
	while (c = *p++)
	{
		
		if (((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')))
		{
			*op++ = c;
		}else
		{
			sprintf(op,"&#x%02X;",(int)c);
			op+=6;
		}
		if (op >= oe)
			break;
	}
	*op = 0;
}