#include	"nntp.h"
#include	"nntp_lib.h"

typedef	struct	{char *name; int value;} TABLE;
#define HOUR(x) (x*60)

static TABLE    tzone_table[] = {
    { "gmt",HOUR( 0) },  /* Greenwich Mean */
    { "ut", HOUR( 0) },  /* Universal */
    { "utc",HOUR( 0) },  /* Universal Coordinated */
    { "cut",HOUR( 0) },  /* Coordinated Universal */
    { "z",  HOUR( 0) },  /* Greenwich Mean */
    { "wet",HOUR( 0) },  /* Western European */
    { "bst",HOUR( 0) },  /* British Summer */
    { "nst",HOUR(3)+30 },/* Newfoundland Standard */
    { "ndt",HOUR(3)+30 },/* Newfoundland Daylight */
    { "ast",HOUR( 4) },  /* Atlantic Standard */
    { "adt",HOUR( 4) },  /* Atlantic Daylight */
    { "est",HOUR( 5) },  /* Eastern Standard */
    { "edt",HOUR( 5) },  /* Eastern Daylight */
    { "cst",HOUR( 6) },  /* Central Standard */
    { "cdt",HOUR( 6) },  /* Central Daylight */
    { "mst",HOUR( 7) },  /* Mountain Standard */
    { "mdt",HOUR( 7) },  /* Mountain Daylight */
    { "pst",HOUR( 8) },  /* Pacific Standard */
    { "pdt",HOUR( 8) },  /* Pacific Daylight */
    { "yst",HOUR( 9) },  /* Yukon Standard */
    { "ydt",HOUR( 9) },  /* Yukon Daylight */
    { "akst",HOUR( 9) }, /* Alaska Standard */
    { "akdt",HOUR( 9) }, /* Alaska Daylight */
    { "hst",HOUR(10) },  /* Hawaii Standard */
    { "hast",HOUR(10) }, /* Hawaii-Aleutian Standard */
    { "hadt",HOUR(10) }, /* Hawaii-Aleutian Daylight */
    { "ces",-HOUR(1) },  /* Central European Summer */
    { "cest",-HOUR(1) }, /* Central European Summer */
    { "mez",-HOUR(1) },  /* Middle European */
    { "mezt",-HOUR(1) }, /* Middle European Summer */
    { "cet",-HOUR(1) },  /* Central European */
    { "met",-HOUR(1) },  /* Middle European */
    { "eet",-HOUR(2) },  /* Eastern Europe */
    { "msk",-HOUR(3) },  /* Moscow Winter */
    { "msd",-HOUR(3) },  /* Moscow Summer */
    { "wast",-HOUR(8) }, /* West Australian Standard */
    { "wadt",-HOUR(8) }, /* West Australian Daylight */
    { "hkt",-HOUR(8) },  /* Hong Kong */
    { "cct",-HOUR(8) },  /* China Coast */
    { "jst",-HOUR(9) },  /* Japan Standard */
    { "kst",-HOUR(9) },  /* Korean Standard */
    { "kdt",-HOUR(9) },  /* Korean Daylight */
    { "cast",-(HOUR(9)+30) }, /* Central Australian Standard */
    { "cadt",-(HOUR(9)+30) }, /* Central Australian Daylight */
    { "east",-HOUR(10) }, /* Eastern Australian Standard */
    { "eadt",-HOUR(10) }, /* Eastern Australian Daylight */
    { "nzst",-HOUR(12) }, /* New Zealand Standard */
    { "nzdt",-HOUR(12) }, /* New Zealand Daylight */
    { NULL,   0 }  /* End of table */
};

static	char    *Mont = {"JanFebMarAprMayJunJulAugSepOctNovDec"};
static	char    *Wdyt = {"SunMonTueWedThuFriSat"};

int	cvt_tz_to_min	(char *tz)
{
int	i;
char	tzl [ 16 ];
char	s,h[3],m[3];


        strcpy (tzl,tz);
	strlwr (tzl);

	if ( !(tzl[1]) ) 
		{
		/* Military time zones, could have sign wrong*/
                if (*tzl>='a' && *tzl<='m') return -(*tzl-'a'+1)*60;
                if (*tzl>='n' && *tzl<='y') return (*tzl-'n'+1)*60;
                return 0;
		}

	for (i=0; tzone_table[i].name!=NULL; i++)
		if (strcmp(tzl,tzone_table[i].name)==0)
			return tzone_table[i].value;

	i = 0;
	s = '+';

	if ( tzl[0] == '-' )
		{s = '-';i++;}
	if ( tzl[0] == '+' )
		{s = '+';i++;}
		
	h[0] = tzl[i++];
	h[1] = tzl[i++];
	h[2] = 0;

	m[0] = tzl[i++];
	m[1] = tzl[i++];
	m[2] = 0;

	i = 60*atoi (h);
	i+= atoi (m);
	
	if (s == '+')
		return i;

	return -i;
}
/*
 *
 */
time_t  cvt_rfc_to_vms  (char *msgt)
{
time_t          t;
struct  tm      ta;

char    Wdy[4];
int     DD;
char    Mon[4];
int     YY;
int     HH;
int     MM;
int     SS;
char    *cp;
char    c;
char	TZ [ 16 ];
int	tzi;


/*msgt =           "Tue, 12 Nov 1996 21:50:04 GMT"
  msgt =           "Tue, 12 Nov 1996 21:50:04 MSK"
  msgt =           "Tue, 12 Nov   96 21:50:04 +0300"
  msgt =           "Tue, 12 Nov 1996 21:50:04 0300"

  msgt =           "18 Nov 1996 22:37:31 +1100"
  msgt =           "18 Nov 1996 22:37:31 MSK"
  msgt =           "18 Nov 1996 22:37:31 EET"
*/
	if ( strchr(msgt,',') )
	        sscanf(msgt,"%3s%c %d %3s %d %2d%c%2d%c%2d %s",
                     &Wdy,&c,  &DD,  &Mon, &YY,  &HH,&c,&MM,&c, &SS, &TZ);
	else	sscanf(msgt,"%d %3s %d %2d%c%2d%c%2d %s",
                     &DD,  &Mon , &YY,  &HH,&c,&MM,&c,&SS,&TZ);


        if ( cp = strstr(Wdyt,Wdy) )
                ta.tm_wday = (cp-Wdyt)/3;

        ta.tm_mday = DD;

        if ( cp = strstr(Mont,Mon) )
                ta.tm_mon =  (cp-Mont)/3;

        if (YY < 1900)  ta.tm_year = YY;
        else            ta.tm_year = YY - 1900;


	tzi = cvt_tz_to_min(TZ);
        ta.tm_hour = HH+(tzi/60);
        ta.tm_min  = MM+(tzi%60);
        ta.tm_sec  = SS;

        return (mktime(&ta));
}
/*
 *
 */
char	*cvt_vms_to_rfc  (time_t t,char *msgt,char *LocalTZ)
{
struct  tm      ta;

        ta = *localtime(&t);


        sprintf(msgt,"%3.3s, %2.2d %3.3s %2.2d %02.2d%:%02.2d%:%02.2d %s",
                     (Wdyt+ta.tm_wday*3),
                        ta.tm_mday,
                     (Mont+ta.tm_mon*3),
                        ta.tm_year,
                        ta.tm_hour,
                        ta.tm_min,
                        ta.tm_sec,
			LocalTZ);

	return	msgt;
}
/*
 *
 */
char	*strlwr	(char *s)
{
char	*ss=s;

        for (;*s!=0;s++) *s = tolower(*s);
        return ss;
}
/*
 *
 */
int	strnlen	(char *s,int maxl)
{
int	l;

        for (l = 0;(l < maxl) && (*s) ;l++) s++;

	return	l;
}

/*
 *
 */
int     strincmp	(char *s1,char *s2,int n)
{
int     s;
        for(s = 0; n > 0;n--,s1++,s2++)
                {
                if ( s = tolower(*s1) - tolower(*s2) )
                        break;
                if ( !(*s1) || !(*s2) )
                        break;
                }


        return s;
}
/*
 *
 */
void	strstrip	(char *src,char *strip_set,char *term_set)
{
char	*cp = src;

	while ( (!strchr(term_set,*src)) && (*src) )
         	{
		if ( !strchr (strip_set,*src) )
			{
			*cp = *src;
			 cp++;
			}
		src++;
		}
	*(cp) = 0;
}
/*
 *
 */
int     stricmp		(char *s1,char *s2)
{
int     s;

        while ( !(s = tolower(*s1) - tolower(*s2)) )     
                {                                                                   
                if ( !(*(s1++)) || !(*(s2++)) )                  
                        break;                           
		}
        return s;
}

/*
 *	"YYMMDD HHMMSS [GMT]" -> time_t
 */
time_t	cvt_nntp_to_vms	(char *date_time)
{
time_t  t;
struct  tm      ta;
int	tzi,i;
char	GMT	[8];

	memset(&ta,0,sizeof(ta));

	if ( 6 > (i = sscanf(date_time,"%2d%2d%2d %2d%2d%2d %5s",
		&ta.tm_year,&ta.tm_mon,&ta.tm_mday,
		&ta.tm_hour,&ta.tm_min,&ta.tm_sec, &GMT)) )
		return 0;

	ta.tm_mon--;

	if ( (i = 7) && (tzi = cvt_tz_to_min(GMT)) )
		{
		ta.tm_hour += (tzi/60);
		ta.tm_min  += (tzi%60);
		}

	return (mktime(&ta));
}
/*
 *
 */

#define TRUE                    1
#define FALSE                   0
#define ABORT                   -1
#define NEGATE_CLASS            '^'

int	domatch(char *text, char *p)
{
int	last,matched,reverse;

    for ( ; *p; text++, p++) {
        if (*text == '\0' && *p != '*')
            return ABORT;
        switch (*p) {
        case '\\':
            /* Literal match with following character. */
            p++;
            /* FALLTHROUGH */
        default:
            if (*text != *p)
                return FALSE;
            continue;
        case '?':
            /* Match anything. */
            continue;
        case '*':
            while (*++p == '*')
                /* Consecutive stars act just like one. */
                continue;
            if (*p == '\0')
                /* Trailing star matches everything. */
                return TRUE;
            while (*text)
                if ((matched = domatch(text++, p)) != FALSE)
                    return matched;
            return ABORT;
        case '[':
            reverse = p[1] == NEGATE_CLASS ? TRUE : FALSE;            
	if (reverse)
                /* Inverted character class. */
                p++;
            matched = FALSE;
            if (p[1] == ']' || p[1] == '-')
                if (*++p == *text)
                    matched = TRUE;
            for (last = *p; *++p && *p != ']'; last = *p)
                if (*p == '-' && p[1] != ']'
                    ? *text <= *++p && *text >= last : *text == *p)
                    matched = TRUE;
            if (matched == reverse)
                return FALSE;
            continue;
        }
    }
    return *text == '\0';
}


int	match_wild(char *p,char *text)
{
	if (p[0] == '*' && p[1] == '\0')
		return TRUE;
	return domatch(text, p) == TRUE;
}

int	match_in_list	(char *wild, char *grp)
{
char	bf[600];
int	m = TRUE, lastm = FALSE;
char	*s;

        strncpy (bf,wild,500);

        s = strtok(bf," ,");

	for (;s!=NULL;)
		{
                m = TRUE;
                if (*s=='!') 
			{
                        s++;
                        m = FALSE;
                	}
		if (match_wild(s,grp))	lastm = m;

                s = strtok(NULL," ,");
	        }

        return lastm;
}

char	*strtok_val	(	char	*src,
				char	*dst,
				char	*tag,
				char	*sep,
				int	 sz
			)
{
char	*cp0,*cp1;

	*dst = 0;

	if ( NULL == (cp0 = strstr (src,tag)) )
		return NULL;

	cp0	+= strlen(tag);

	for(;*cp0 == ' ';cp0++);

	if ( NULL == (cp1 = strpbrk (cp0,sep)) )
		{
		strncpy(dst,cp0,sz);
		*(dst+sz) = 0;
		}
	else	{
		strncpy(dst,cp0,min (cp1-cp0,sz));
		*(dst+min (cp1-cp0,sz)) = 0;
		}
	
	return	dst;
}