string.c

来自「ftam等标准协议服务器和客户端的源代码。」· C语言 代码 · 共 1,405 行 · 第 1/2 页

/* string.c - printable string handling */

#ifndef lint
 static char *rcsid = "$Header: /xtel/isode/isode/dsap/common/RCS/string.c,v 9.0 1992/06/16 12:12:39 isode Rel $";
#endif

/*
 * $Header: /xtel/isode/isode/dsap/common/RCS/string.c,v 9.0 1992/06/16 12:12:39 isode Rel $
 *
 *
 * $Log: string.c,v $
 * Revision 9.0  1992/06/16  12:12:39  isode
 * Release 8.0
 *
 */

/*
 *                                NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


/* LINTLIBRARY */

#include "quipu/util.h"
#include "quipu/ds_search.h"

   /* when/if tidy_string every gets removed from getline you can undef this */
#define TIDY_STRING
#define NICER_ESCAPES

extern LLog * log_dsap;
extern char * srealloc ();

static short exct = 0;
static short tel_sntx = 0;
static char char_failed;

int ch_set = 0;

extern int soundex_match ();


static unsigned char escapes[16][17] = {
	'A','C','E','I','N','O','U','Y', 
	'a','c','e','i','n','o','u','y', ' ',

/* Grave upper case */
	0xc0, '?', 0xc8, 0xcc, '?', 0xd2, 0xd9, '?',  
/* Grave lower case */
	0xe0, '?', 0xe8, 0xec, '?', 0xf2, 0xf9, '?', '`', 

/* Acute upper case */
	0xc1, '?', 0xc9, 0xcd, '?', 0xd3, 0xda, 0xdd,
/* Acute lower case */
	0xe1, '?', 0xe9, 0xed, '?', 0xf3, 0xfa, 0xfd, '\'',

/* Circumflex upper case */
	0xc2, '?', 0xca, 0xce, '?', 0xd4, 0xdb, '?', 
/* Circumflex lower case */
	0xe2, '?', 0xea, 0xee, '?', 0xf4, 0xfb, '?', '?',

/* Tilde upper case */
	0xc3, '?', 0xcb, 0xcf, 0xd1, 0xd5, 0xdc, '?', 
/* Tilde lower case */
	0xe3, '?', 0xeb, 0xef, 0xf1, 0xf5, 0xfc, '?', '?',

/* Macron upper case */
	'?', '?', '?', '?', '?', '?', '?', '?',   
/* Macron lower case */
	'?', '?', '?', '?', '?', '?', '?', '?',  '?', 

/* ? upper case */
	'?', '?', '?', '?', '?', '?', '?', '?', 
/* ? lower case */
	'?', '?', '?', '?', '?', '?', '?', '?',  '?',

/* Dot upper case */
	0xc5, '?', '?', '?', '?', '?', '?', '?',
/* Dot lower case */
	0xe5, '?', '?', '?', '?', '?', '?', '?', '?', 

/* Diaresis upper case */
        0xc4, '?', 0xcb, 0xcf, '?', 0xd6, 0xdc, 0x82,
/* Diaresis lower case */
        0xe4, '?', 0xeb, 0xef, '?', 0xf6, 0xfc, 0xff, '"',

/* Umlaut upper case */
        0xc4, '?', 0xcb, 0xcf, '?', 0xd6, 0xdc, 0x82,
/* Umlaut lower case */
        0xe4, '?', 0xeb, 0xef, '?', 0xf6, 0xfc, 0xff, '"',

/* Ring upper case */
	0xc5, '?', '?', '?', '?', '?', '?', '?', 
/* Ring lower case */
	0xe5, '?', '?', '?', '?', '?', '?', '?', '?',

/* Cedilla upper case */
	'?', 0xc7, '?', '?', '?', '?', '?', '?',
/* Cedilla lower case */
	'?', 0xe7, '?', '?', '?', '?', '?', '?',  '?', 

/* Underline upper case */
	'?', '?', '?', '?', '?', '?', '?', '?',
/* Underline lower case */
	'?', '?', '?', '?', '?', '?', '?', '?',  '_', 

/* Umlaut upper case */
        0xc4, '?', 0xcb, 0xcf, '?', 0xd6, 0xdc, 0x82,
/* Umlaut lower case */
        0xe4, '?', 0xeb, 0xef, '?', 0xf6, 0xfc, 0xff, '"',

/* Cedilla? upper case */
	'?', 0xc7, '?', '?', '?', '?', '?', '?',
/* Cedilla? lower case */
	'?', 0xe7, '?', '?', '?', '?', '?', '?',  '?', 

/* ? upper case */
	'?', '?', '?', '?', '?', '?', '?', '?',
/* ? lower case */
	'?', '?', '?', '?', '?', '?', '?', '?', '?'
};

static unsigned char trans[32] = {
	'?', 0xc6, 0xd0, '?', '?', '?', '?', 'L', 
	'L', 0xd8, '?', '?', 0xde, 'T', 'N', 'n',
	'K', 0xe6, 'd', 0xf0, 'h', 'i', '?', 'l',
	'l', 0xf8, '?', 0xdf, 0xfe, 't', 'N', '?'};

int iso8859print(ps, sstr)
PS ps;
char *sstr;
{
unsigned char *str;
int n;
static unsigned char *buff = (unsigned char *)0;
unsigned char *optr;

  if (buff == (unsigned char *)0)
	  buff = (unsigned char *) smalloc (BUFSIZ);

  optr = buff;

  str = (unsigned char *) sstr;
  while (*str != '\0')
  {
  if ((*str > 0x1f) && (*str < 0x80)) {
	*optr++ = *str++;}
  else if ((*str>0xa0) && (*str < 0xc0)) { 
	*optr++ = *str++;}
  else if (*str > 0xdf) {
	*optr++ = trans[((int)(*str++)) - 0xe0];}
  else if ((*str > 0xbf) && (*str < 0xd0)) {
	n = (int) (*str - (unsigned char) 0xc0);
	str++;
	if (*str == '\0')
		return;
	switch (*str) {
	   case 'A':
		*optr++ = escapes[n][0];
		break;
	   case 'C':
		*optr++ = escapes[n][1];
		break;
	   case 'E':
		*optr++ = escapes[n][2];
		break;
	   case 'I':
		*optr++ = escapes[n][3];
		break;
	   case 'N':
		*optr++ = escapes[n][4];
		break;
	   case 'O':
		*optr++ = escapes[n][5];
		break;
	   case 'U':
		*optr++ = escapes[n][6];
		break;
	   case 'Y':
		*optr++ = escapes[n][7];
		break;
	   case 'a':
		*optr++ = escapes[n][8];
		break;
	   case 'c':
		*optr++ = escapes[n][9];
		break;
	   case 'e':
		*optr++ = escapes[n][10];
		break;
	   case 'i':
		*optr++ = escapes[n][11];
		break;
	   case 'n':
		*optr++ = escapes[n][12];
		break;
	   case 'o':
		*optr++ = escapes[n][13];
		break;
	   case 'u':
		*optr++ = escapes[n][14];
		break;
	   case 'y':
		*optr++ = escapes[n][15];
		break;
	   case ' ':
		*optr++ = escapes[n][16];
		break;
	   default:
		*optr++ = '?';
	 };
	str++;
	}
	else str++;
  };
  *optr++ = '\0';
  ps_printf(ps, "%s", buff);
}

static PE ia5enc (x)
char *x;
{
	return (ia5s2prim(x,strlen(x)));
}

static PE nstrenc (x)
char *x;
{
	return (nums2prim(x,strlen(x)));
}


/*
 * Real octet strings encode (r_*)
 */
PE r_octenc (x)
struct qbuf *x;
{
	return (qb2prim(x,PE_CLASS_UNIV, PE_PRIM_OCTS));
}

static PE octenc (x)
char *x;
{
	return (oct2prim(x,strlen(x)));
}

static PE strenc (x)
char *x;
{
	if (*x == T61_MARK) {
		x++;
		return (t61s2prim(x,strlen(x)));
	} else
		return (prts2prim(x,strlen(x)));
}

static char * local_t61 (a)
char * a;
{
char * b;

	if (a == NULLCP)
		return (NULLCP);

	b = smalloc (strlen(a) +2);
	*b++ = T61_MARK;
	(void) strcpy (b,a);
	(void) free (a);
	return (--b);
}

static char * prtsdec (pe)
PE pe;
{
int z;
char * p, *ptr, val;

	if (PE_ID(pe->pe_class, pe->pe_id) ==
	    PE_ID(PE_CLASS_UNIV,PE_DEFN_PRTS)) {
		ptr = prim2str(pe,&z);
		val = *ptr;
		if (((p = TidyString2(ptr)) == NULLCP) || (*p == 0))
		    if (val == ' ') {
			    free (p);	
			    return strdup (" ");
		    } else
			    return NULLCP;

		if (check_print_string(p))
			return (p);
		free (p);
	}
	return (NULLCP);
}

#ifdef STRICT_X500
#include "iso3166.h"
#endif

int	check_3166 (a)
char   *a;
{
#ifdef STRICT_X500
    int    bitno;
#endif

    if (strlen (a) != 2)
	return 0;

    if (islower ((u_char) a[0]))
	a[0] = toupper (a[0]);
    if (islower ((u_char) a[1]))
	a[1] = toupper (a[1]);

#ifdef STRICT_X500
    return (isupper ((u_char) a[0]) && isupper ((u_char) a[1]) && is3166 (a));
#else
    return (isupper ((u_char) a[0]) && isupper ((u_char) a[1]));
#endif
}


static char * cntydec (pe)
PE pe;
{
char *a;
#ifdef STRICT_X500
int   bitno;
#endif

	if ((a = prtsdec(pe)) == NULLCP)
		return (NULLCP);

	if (strlen (a) != 2) {
		LLOG (log_dsap,LLOG_EXCEPTIONS,
		      ("Country code size wrong: \"%s\"", a));
losing: ;
		free (a);
		return (NULLCP);
	}


	if (islower ((u_char) a[0]))
	    a[0] = toupper (a[0]);
	if (islower ((u_char) a[1]))
	    a[1] = toupper (a[1]);

#ifdef STRICT_X500
	if (isupper ((u_char) a[0]) && isupper ((u_char) a[1]) && is3166 (a))
#else
	if (isupper ((u_char) a[0]) && isupper ((u_char) a[1]))
#endif
	    	return (a);

	LLOG (log_dsap, LLOG_EXCEPTIONS,
	      ("Invalid country code: \"%s\"", a));
	goto losing;
}

struct qbuf *
r_octsdec (pe)
PE pe;
{

	if (PE_ID(pe->pe_class, pe->pe_id) ==
	    PE_ID(PE_CLASS_UNIV,PE_PRIM_OCTS))
		return (prim2qb(pe));
	else
		return ((struct qbuf *)0);

}
static char * octsdec (pe)
PE pe;
{
int z;

	if (PE_ID(pe->pe_class, pe->pe_id) ==
	    PE_ID(PE_CLASS_UNIV,PE_PRIM_OCTS))
		return (TidyString2(prim2str(pe,&z)));
	else
		return (NULLCP);

}

static char * ia5sdec (pe)
PE pe;
{
int z;

	if (PE_ID(pe->pe_class, pe->pe_id) ==
	    PE_ID(PE_CLASS_UNIV,PE_DEFN_IA5S))
		return (TidyString2(prim2str(pe,&z)));
	else
		return (NULLCP);
}

static char * numsdec (pe)
PE pe;
{
int z;
	if ( PE_ID(pe->pe_class, pe->pe_id) ==
	    PE_ID(PE_CLASS_UNIV,PE_DEFN_NUMS))
		return (TidyString2(prim2str(pe,&z)));
	else
		return (NULLCP);
}


static char * t61dec (pe)
PE pe;
{
int z;
char * ptr, *p2, val;

	if (pe->pe_form != PE_FORM_PRIM) {
		LLOG (log_dsap,LLOG_EXCEPTIONS,("Primative string expected"));
		return NULLCP;
	}

	if ( PE_ID (pe -> pe_class, pe -> pe_id) == PE_ID (PE_CLASS_UNIV,PE_DEFN_T61S) ) {
		ptr = prim2str(pe,&z);
		val = *ptr;
		if (((p2 = TidyString2(ptr)) == NULLCP) || (*p2 == 0))
		    if (val == ' ') {
			    free (p2);	
			    p2 = strdup ("  ");
			    *p2 = T61_MARK;
			    return p2;
		    } else
			    return NULLCP;
		return (local_t61 (p2));
	} else 
		return (prtsdec(pe));
}

static char * quotechar (a,b)
register char a, *b;
{
#ifdef NICER_ESCAPES
#define CONT_CHAR	'\\'

    switch (a & 0xff) {
    case '\n':
	 *b++ = CONT_CHAR;
	 *b++ = 'n';
	 break;

     case '\t':
	 *b++ = CONT_CHAR;
	 *b++ = 't';
	 break;

     case '\r':
	 *b++ = CONT_CHAR;
	 *b++ = 'r';
	 break;

    case '\\':
        *b++ = CONT_CHAR;
        *b++ = CONT_CHAR;
	break;

#ifndef	TIDY_STRING
    case ' '
        *b++ = CONT_CHAR;
        *b++ = ' ';
        break;
#endif

    default:
	(void) sprintf (b,"\\%02x", a & 0xff);
	b += 3;
	break;
    }
    return (b);
#else
	(void) sprintf (b,"\\%02x", a & 0xff);
	b += 3;
	return (b);
#endif
}

static char * unquotechar (a,b)
register char *a, *b;
{
int val;

#ifdef NICER_ESCAPES

        switch (*a) {
        case '\\':
                *b = '\\';
                break;
        case 'n':
            *b = '\n';
            break;

        case 't':
            *b = '\t';

        case 'r':
            *b = '\r';
            break;

#ifndef	TIDY_STRING
       case ' '
           *b = ' ';
	   break;
#endif

        default:
            if (isxdigit((*a) & 0xff) && sscanf (a,"%2x", &val) == 1) {
                *b = val & 0xff;
                a++;
            } else
		parse_error ("Bad Quoted character",NULLCP);
	    break;

        }
#else
	if (*a == '\\') 
		*b = '\\';
	else {
		if (sscanf (a,"%2x", &val) == 1) {
			*b = val & 0xff;
			a++;
		} else
			parse_error ("Bad Quoted character",NULLCP);
	}
#endif
	return (a);
}


check_print_string (str)
register char * str;
{

    for (; *str != 0; str++) {
	if ((isascii((*str)& 0xff)) && (isalnum ((*str) & 0xff)))
		continue;

	switch (*str) {
		case 047:  /* ' */
		case '(':
		case ')':
		case '+':
		case '-':
		case '.':
		case ',':
		case '/':
		case ':':
		case '=':
		case '?':
		case ' ': continue;
		default:  LLOG (log_dsap,LLOG_NOTICE,("character '%c' not in printablestring",*str));
			  char_failed = *str;
			  return (0);
	}
    }
    return (1);
}

#define MINBUF		3
#define PARSE_INCR	240

struct qbuf * 
r_octparse (str)
register char * str;
{
    static char 	*buf;
    static int 		buflen = 0;
    register char	*ptr;
    int			left;
    int			curlen;

    left = buflen;
    ptr = buf;

    for (; *str != 0; str++) {
	if ( left <= MINBUF) {
            if (buflen <= 0) {
                left = buflen = PARSE_INCR;
                ptr = buf = smalloc(PARSE_INCR);
            } else {
                buflen += PARSE_INCR;
                left += PARSE_INCR;
		curlen = ptr - buf;
                buf = srealloc(buf, buflen);
                ptr = buf + curlen;
            }
        }

	if (*str != '\\')
	    *ptr++ = *str;
	else {
	    str++;
	    str = unquotechar (str,ptr);
	    ptr++;
	}
	left--;
    }

    *ptr = 0;	/* just for safety ? */
    return (str2qb(buf, ptr - buf, 1));
}

char * octparse (str)
register char * str;
{
char buffer [BUFSIZ];
register char * ptr=buffer;
register int i;

        for (i=0; *str != 0; str++,i++) {
                if (*str != '\\')
                        *ptr++ = *str;
                else {
			str++, i++;
                        str = unquotechar (str,ptr);
			ptr++;
		}
		if ( i >= BUFSIZ ) {
			parse_error ("String too long", NULLCP);	
			return NULLCP;
		}
	}
	*ptr = 0;
	return (strdup(buffer));
}


#define prtparse_aux(z)	(check_print_string(z) ? strdup(z) : NULLCP)

char * prtparse (str)
char * str;
{
char * ptr;

        if ((*str == '\\') && (*(str+1) == '2') 
	    && (*(str+2) == '0')
	    && (*(str+3) == 0))
		return strdup (" ");

	if ((ptr = prtparse_aux(str)) != NULLCP)
		return (ptr);
	else {
		parse_error ("character '%c' not in printablestring",(char *)char_failed);
		return (NULLCP);
	}
}

static char * cntyparse(str)
char * str;
{
char * a;

	if ((a=prtparse(str)) == NULLCP)
		return (NULLCP);

	if (check_3166 (a))
	    return a;

	parse_error ("invalid country code: \"%s\"", a);
	free (a);
	return (NULLCP);
}

static char * t61parse (str)
char * str;
{
extern char t61_flag;
char * res;

        if ((*str == '\\') && (*(str+1) == '2') 
	    && (*(str+2) == '0')
	    && (*(str+3) == 0))
		if (t61_flag) {
			t61_flag = FALSE;
			res = strdup ("  ");
			*res = T61_MARK;
			return res;
		} else 
			return strdup (" ");

	if (t61_flag) {
		t61_flag = FALSE;  /* recognised it !!! */
		return (local_t61(octparse (str)));   /* need t61 parser */
	} else if ((res=prtparse_aux(str)) == NULLCP) {
		LLOG (log_dsap,LLOG_NOTICE,("auto-convert to T.61 for '%s' ('%c' not allowed)",str,char_failed));
		return (local_t61(octparse (str)));
	} else
		return (res);
}