int
main(int argc, char **argv)
{
#ifdef LESSTIF_VERSION
Widget toplevel;
XtAppContext app;
XmFontList fontlist;
XmString xmstr1 = XmStringCreate("Here is a ", "MY_FONT1");
XmString xmstr2 = XmStringCreate("different font", "MY_FONT");
char buf[] = { 0xdf, 0x80, 0x06, 0x00, 0x01, 0x00 };
XmStringContext context;
char *text;
XmStringCharSet cs;
XmStringDirection dir;
Boolean sep;
XmString xmstr = XmStringConcat(xmstr1, xmstr2);
XtSetLanguageProc(NULL, NULL, NULL);
toplevel = XtVaAppInitialize(&app, "Label", NULL, 0, &argc, argv, NULL, NULL);
fontlist = XmFontListAppendEntry(NULL,
XmFontListEntryCreate("MY_FONT",
XmFONT_IS_FONT,
XLoadQueryFont(XtDisplay(toplevel),
"-adobe-helvetica-bold-o-normal--17-0-75-75-p-*-iso8859-1")));
fontlist = XmFontListAppendEntry(fontlist,
XmFontListEntryCreate("MY_FONT1",
XmFONT_IS_FONT,
XLoadQueryFont(XtDisplay(toplevel),
"-adobe-helvetica-bold-r-normal--17-0-75-75-p-*-iso8859-1")));
asn1_dump((unsigned char *)xmstr);
printf("SINGLE SEGMENT\n");
text = NULL;
cs = "-adobe-helvetica-bold-r-normal--17-0-75-75-p-*-iso8859-1";
_XmStringSingleSegment(xmstr, &text, &cs);
printf("text: %s cs: %s\n", text ? text : "(empty)", cs ? cs : "(empty)");
if (_XmStringIsXmString((XmString)buf))
printf("IS STRING\n");
else
printf("ISN'T STRING\n");
asn1_dump((unsigned char *)buf);
XmStringInitContext(&context, xmstr);
while (XmStringGetNextSegment(context, &text, &cs, &dir, &sep)) {
printf("%s %s %d %d\n", text ? text : "(null)", cs ? cs : "(null)",
dir, sep);
}
XmStringFreeContext(context);
printf("current charset: %s\n", _XmStringGetCurrentCharset());
#endif
exit(0);
}
int main(int argc, char **argv)
{
int opt, ret, i;
SilcAsn1 asn1;
SilcBufferStruct buf;
unsigned char *data, *tmp;
SilcUInt32 data_len;
if (argc < 2) {
usage();
return 1;
}
while ((opt = getopt(argc, argv, "hxbai")) != EOF) {
switch (opt) {
case 'h':
usage();
return 1;
break;
case 'x':
hexdump = TRUE;
break;
case 'b':
dec_base64 = TRUE;
break;
case 'i':
ignore_header = TRUE;
break;
case 'a':
parse_all = TRUE;
break;
default:
usage();
return 1;
}
}
data = tmp = silc_file_readfile(argv[argc - 1], &data_len, NULL);
if (!data) {
fprintf(stderr, "Error: Cannot read file '%s': %s\n", argv[argc - 1],
silc_errno_string(silc_errno));
return 1;
}
silc_buffer_set(&buf, data, data_len);
if (ignore_header) {
SilcBool header = FALSE;
for (i = 0; i < data_len; i++) {
if (data_len > i + 4 &&
data[i ] == '-' && data[i + 1] == '-' &&
data[i + 2] == '-' && data[i + 3] == '-') {
if (data_len > i + 5 && (data[i + 4] == '\r' ||
tmp[i + 4] == '\n')) {
/* End of line, header */
if (data_len > i + 6 && data[i + 4] == '\r' &&
data[i + 5] == '\n')
i++;
i += 5;
silc_buffer_pull(&buf, i);
header = TRUE;
} else if (i > 0 && data_len > i + 5 && data[i + 4] != '-' &&
header) {
/* Start of line, footer */
silc_buffer_push_tail(&buf, silc_buffer_truelen(&buf) - i);
break;
}
}
}
}
if (dec_base64) {
data = silc_base64_decode(NULL, silc_buffer_data(&buf),
silc_buffer_len(&buf), &data_len);
if (!data) {
fprintf(stderr, "Error: Cannot decode Base64 encoding\n");
return 1;
}
silc_buffer_set(&buf, data, data_len);
silc_free(tmp);
}
asn1 = silc_asn1_alloc(NULL);
ret = asn1_dump(asn1, &buf, 0);
silc_asn1_free(asn1);
silc_free(data);
return ret;
}
int asn1_dump(SilcAsn1 asn1, SilcBuffer src, int depth)
{
SilcBool ret = FALSE;
SilcBerEncoding renc;
SilcUInt32 rtag;
const unsigned char *rdata;
SilcBufferStruct buf;
SilcBerClass rclass;
SilcUInt32 rdata_len, len = 0;
SilcBool rindef;
char indent[256];
memset(indent, 0, sizeof(indent));
while (silc_buffer_len(src)) {
/* Decode the BER block */
ret = silc_ber_decode(src, &rclass, &renc, &rtag, &rdata,
&rdata_len, &rindef, &len);
if (!ret) {
fprintf(stderr, "Error: Cannot parse BER block, malformed ASN.1 data\n");
return -1;
}
/* If class is 0, encoding 0, tag 0 and data length 0 ignore them
as they are zero bytes, unless user wants to see them */
if (rclass == 0 && renc == 0 && rtag == 0 && rdata_len == 0 &&
!parse_all) {
if (len && silc_buffer_len(src) >= len)
silc_buffer_pull(src, len);
continue;
}
if (depth)
memset(indent, 32, depth);
fprintf(stdout, "%04d: %s%s [%d] %s %s %s", depth, indent,
asn1_tag_name(rtag), (int)rtag,
rclass == SILC_BER_CLASS_UNIVERSAL ? "univ" :
rclass == SILC_BER_CLASS_APPLICATION ? "appl" :
rclass == SILC_BER_CLASS_CONTEXT ? "cont" : "priv",
renc == SILC_BER_ENC_PRIMITIVE ? "primit" : "constr",
rindef ? "indef" : "defin");
if (rtag != SILC_ASN1_TAG_SEQUENCE &&
rtag != SILC_ASN1_TAG_SET &&
rtag != SILC_ASN1_TAG_SEQUENCE_OF) {
if (hexdump) {
fprintf(stdout, " [len %lu]\n", rdata_len);
silc_hexdump(rdata, rdata_len, stdout);
} else {
fprintf(stdout, "\n");
}
} else {
fprintf(stdout, "\n");
}
if (renc == SILC_BER_ENC_PRIMITIVE)
len = len + rdata_len;
else
len = len;
if (len && silc_buffer_len(src) >= len)
silc_buffer_pull(src, len);
/* Decode sequences and sets recursively */
if ((rtag == SILC_ASN1_TAG_SEQUENCE ||
rtag == SILC_ASN1_TAG_SET ||
rtag == SILC_ASN1_TAG_SEQUENCE_OF) &&
depth + 1 < sizeof(indent) - 1) {
silc_buffer_set(&buf, (unsigned char *)rdata, rdata_len);
if (silc_buffer_len(src) >= rdata_len)
silc_buffer_pull(src, rdata_len);
if (asn1_dump(asn1, &buf, depth + 1) < 0)
return -1;
if (silc_buffer_len(src) == 0)
return 0;
}
}
return 0;
}
int
asn1_dump(unsigned char *string) {
unsigned length, i, nlen;
struct __XmStringRec *str = (struct __XmStringRec *)string;
unsigned char *next;
printf("STRING: TAG: %02x LEN: %02x\n", str->tag, str->len);
length = 0;
/* indefinite length ? */
if (str->len != ASN_LENGTH_MODIFIER) {
if (str->len > ASN_LENGTH_MODIFIER) {
for (i = 0; i < (str->len & ~ASN_LENGTH_MODIFIER); i++) {
length <<= 8;
length |= str->data[i];
if (i > sizeof(unsigned)) {
fprintf(stderr, "Invalid XmString\n");
exit (0);
}
}
}
else {
i = 0;
length = str->len & ~ASN_LENGTH_MODIFIER;
}
next = &str->data[i];
/* primitive type -- doesn't recurse */
switch (str->tag) {
case XmSTRING_COMPONENT_UNKNOWN:
printf("UNKNOWN COMPONENT: length %d\n", length);
return length + i + 2;
case XmSTRING_COMPONENT_CHARSET:
printf("CHARSET:\n");
for (nlen = 0; nlen < length; nlen++)
putchar(str->data[i + nlen]);
putchar('\n');
return length + i + 2;
case XmSTRING_COMPONENT_TEXT:
printf("TEXT: %d\n", length);
for (nlen = 0; nlen < length; nlen++)
putchar(str->data[i + nlen]);
putchar('\n');
return length + i + 2;
case XmSTRING_COMPONENT_DIRECTION:
printf("DIRECTION: %d\n", length);
for (nlen = 0; nlen < length; nlen++)
printf("%d ", str->data[i + nlen]);
putchar('\n');
return length + i + 2;
case XmSTRING_COMPONENT_SEPARATOR:
printf("SEPARATOR: %d\n", length);
for (nlen = 0; nlen < length; nlen++)
printf("%d ", str->data[i + nlen]);
putchar('\n');
return length + i + 2;
case XmSTRING_COMPONENT_LOCALE_TEXT:
printf("LOCALE TEXT: %d\n", length);
for (nlen = 0; nlen < length; nlen++)
putchar(str->data[i + nlen]);
putchar('\n');
return length + i + 2;
case (XmSTRING_COMPONENT_LOCALE_TEXT+1):
i += length + 2;
for (;;) {
nlen = asn1_dump(next);
next += nlen;
length -= nlen;
if (length <= 0)
return 0;
}
default:
printf("invalid tag: %02x\n", str->tag);
return 1;
}
}
else { /* it's indefinite */
next = str->data;
str = (struct __XmStringRec *)next;
while (str->tag != 0 && str->len != 0) {
nlen = asn1_dump(next);
if (nlen == 0)
break;
next += nlen;
str = (struct __XmStringRec *)next;
}
}
return 0;
}
