--- /dev/null
+
+Fabio Fiorina <Fabio.Fiorina@alcatel.it>
+
--- /dev/null
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+\f
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+\f
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+\f
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+\f
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+\f
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) 19yy <name of author>
+
+ 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.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) 19yy name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Library General
+Public License instead of this License.
--- /dev/null
+Basic Installation
+==================
+
+ These are generic installation instructions.
+
+ The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation. It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions. Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, a file
+`config.cache' that saves the results of its tests to speed up
+reconfiguring, and a file `config.log' containing compiler output
+(useful mainly for debugging `configure').
+
+ If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release. If at some point `config.cache'
+contains results you don't want to keep, you may remove or edit it.
+
+ The file `configure.in' is used to create `configure' by a program
+called `autoconf'. You only need `configure.in' if you want to change
+it or regenerate `configure' using a newer version of `autoconf'.
+
+The simplest way to compile this package is:
+
+ 1. `cd' to the directory containing the package's source code and type
+ `./configure' to configure the package for your system. If you're
+ using `csh' on an old version of System V, you might need to type
+ `sh ./configure' instead to prevent `csh' from trying to execute
+ `configure' itself.
+
+ Running `configure' takes awhile. While running, it prints some
+ messages telling which features it is checking for.
+
+ 2. Type `make' to compile the package.
+
+ 3. Optionally, type `make check' to run any self-tests that come with
+ the package.
+
+ 4. Type `make install' to install the programs and any data files and
+ documentation.
+
+ 5. You can remove the program binaries and object files from the
+ source code directory by typing `make clean'. To also remove the
+ files that `configure' created (so you can compile the package for
+ a different kind of computer), type `make distclean'. There is
+ also a `make maintainer-clean' target, but that is intended mainly
+ for the package's developers. If you use it, you may have to get
+ all sorts of other programs in order to regenerate files that came
+ with the distribution.
+
+Compilers and Options
+=====================
+
+ Some systems require unusual options for compilation or linking that
+the `configure' script does not know about. You can give `configure'
+initial values for variables by setting them in the environment. Using
+a Bourne-compatible shell, you can do that on the command line like
+this:
+ CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
+
+Or on systems that have the `env' program, you can do it like this:
+ env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
+
+Compiling For Multiple Architectures
+====================================
+
+ You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory. To do this, you must use a version of `make' that
+supports the `VPATH' variable, such as GNU `make'. `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script. `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.
+
+ If you have to use a `make' that does not supports the `VPATH'
+variable, you have to compile the package for one architecture at a time
+in the source code directory. After you have installed the package for
+one architecture, use `make distclean' before reconfiguring for another
+architecture.
+
+Installation Names
+==================
+
+ By default, `make install' will install the package's files in
+`/usr/local/bin', `/usr/local/man', etc. You can specify an
+installation prefix other than `/usr/local' by giving `configure' the
+option `--prefix=PATH'.
+
+ You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files. If you
+give `configure' the option `--exec-prefix=PATH', the package will use
+PATH as the prefix for installing programs and libraries.
+Documentation and other data files will still use the regular prefix.
+
+ In addition, if you use an unusual directory layout you can give
+options like `--bindir=PATH' to specify different values for particular
+kinds of files. Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.
+
+ If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+Optional Features
+=================
+
+ Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System). The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+ For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+Specifying the System Type
+==========================
+
+ There may be some features `configure' can not figure out
+automatically, but needs to determine by the type of host the package
+will run on. Usually `configure' can figure that out, but if it prints
+a message saying it can not guess the host type, give it the
+`--host=TYPE' option. TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name with three fields:
+ CPU-COMPANY-SYSTEM
+
+See the file `config.sub' for the possible values of each field. If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the host type.
+
+ If you are building compiler tools for cross-compiling, you can also
+use the `--target=TYPE' option to select the type of system they will
+produce code for and the `--build=TYPE' option to select the type of
+system on which you are compiling the package.
+
+Sharing Defaults
+================
+
+ If you want to set default values for `configure' scripts to share,
+you can create a site shell script called `config.site' that gives
+default values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists. Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Operation Controls
+==================
+
+ `configure' recognizes the following options to control how it
+operates.
+
+`--cache-file=FILE'
+ Use and save the results of the tests in FILE instead of
+ `./config.cache'. Set FILE to `/dev/null' to disable caching, for
+ debugging `configure'.
+
+`--help'
+ Print a summary of the options to `configure', and exit.
+
+`--quiet'
+`--silent'
+`-q'
+ Do not print messages saying which checks are being made. To
+ suppress all normal output, redirect it to `/dev/null' (any error
+ messages will still be shown).
+
+`--srcdir=DIR'
+ Look for the package's source code in directory DIR. Usually
+ `configure' can determine that directory automatically.
+
+`--version'
+ Print the version of Autoconf used to generate the `configure'
+ script, and exit.
+
+`configure' also accepts some other, not widely useful, options.
--- /dev/null
+## Process this file with automake to produce Makefile.in
+
+EXTRA_DIST = ChangeLog NEWS INSTALL README THANKS COPYING
+SUBDIRS = lib src doc
+
+ChangeLog:
+ cvs2cl --utc -U .cvsusers --fsf -t -S --prune
--- /dev/null
+Version 0.1.0
+- Initial release
--- /dev/null
+This is the ASN.1 library used in GNUTLS.
+More up to date information can be found at
+http://www.gnu.org/software/gnutls and http://www.gnutls.org
+
+* Documentation:
+ view the doc/ directory and the examples in the src/ directory.
+
--- /dev/null
+#undef PACKAGE
+#undef VERSION
+
+#undef T_CPU
+#undef T_VENDOR
+#undef T_OS
+
+#undef LT_CURRENT
+#undef LT_REVISION
+#undef LT_AGE
+
+#undef ASN1_VERSION
+
--- /dev/null
+
+dnl *-*wedit:notab*-* Please keep this as the last line.
--- /dev/null
+#! /bin/sh
+
+aclocal && \
+libtoolize -c --force --automake && \
+aclocal && \
+autoheader && \
+automake -a -c --gnu || automake -a -c --gnu
+autoconf
+
--- /dev/null
+dnl Process this file with autoconf to produce a configure script.
+AC_PREREQ(2.50)
+AC_INIT
+
+AC_PREFIX_DEFAULT(/usr/local)
+
+AC_CANONICAL_TARGET([])
+AC_DEFINE_UNQUOTED(T_CPU, "$target_cpu")
+AC_DEFINE_UNQUOTED(T_VENDOR, "$target_vendor")
+AC_DEFINE_UNQUOTED(T_OS, "$target_os")
+
+dnl libasn1 Version
+ASN1_MAJOR_VERSION=0
+ASN1_MINOR_VERSION=1
+ASN1_MICRO_VERSION=0
+ASN1_VERSION=$ASN1_MAJOR_VERSION.$ASN1_MINOR_VERSION.$ASN1_MICRO_VERSION
+
+AC_DEFINE_UNQUOTED(ASN1_VERSION, "$ASN1_VERSION")
+
+AM_INIT_AUTOMAKE(gnutls, $ASN1_VERSION)
+AM_CONFIG_HEADER(config.h)
+
+dnl This is the library version
+ASN1_MOST_RECENT_INTERFACE=0
+ASN1_CURRENT_INTERFACE_IMPLEMENTATION_NUMBER=$ASN1_MICRO_VERSION
+ASN1_OLDEST_INTERFACE=0
+
+
+AC_SUBST(ASN1_MAJOR_VERSION)
+AC_SUBST(ASN1_MINOR_VERSION)
+AC_SUBST(ASN1_MICRO_VERSION)
+AC_SUBST(ASN1_VERSION)
+
+AC_SUBST(ASN1_MOST_RECENT_INTERFACE)
+AC_SUBST(ASN1_CURRENT_INTERFACE_IMPLEMENTATION_NUMBER)
+AC_SUBST(ASN1_OLDEST_INTERFACE)
+
+LT_CURRENT=$ASN1_MOST_RECENT_INTERFACE
+LT_REVISION=$ASN1_CURRENT_INTERFACE_IMPLEMENTATION_NUMBER
+LT_AGE=`expr $ASN1_MOST_RECENT_INTERFACE - $ASN1_OLDEST_INTERFACE`
+AC_SUBST(LT_CURRENT)
+AC_SUBST(LT_REVISION)
+AC_SUBST(LT_AGE)
+
+AC_PROG_CC
+
+AC_PROG_YACC
+
+AC_PROG_LN_S
+
+
+dnl Checks for programs.
+AC_PROG_INSTALL
+
+
+AC_MSG_RESULT([***
+*** Detecting compiler options...
+])
+
+
+AC_C_CONST
+AC_C_INLINE
+
+
+if test $ac_cv_c_compiler_gnu != no; then
+
+ CFLAGS="${CFLAGS} -Wall -Wpointer-arith -Wstrict-prototypes"
+
+ AC_MSG_CHECKING([whether we have GNU assembler])
+
+ GAS=`as --version < /dev/null|grep GNU`
+ if test "$GAS"; then
+ CFLAGS="${CFLAGS} -pipe"
+ AC_MSG_RESULT(yes)
+ else
+ AC_MSG_RESULT(no)
+ fi
+fi
+
+
+AC_MSG_RESULT([***
+*** Detecting C library capabilities...
+])
+
+AC_HEADER_STDC
+AC_CHECK_HEADERS(unistd.h strings.h)
+AC_CHECK_FUNCS(bzero memset memmove bcopy,,)
+AC_FUNC_ALLOCA
+
+
+AC_MSG_RESULT([***
+*** Detecting system's parameters...
+])
+
+AC_CHECK_SIZEOF(unsigned long long, 8)
+AC_CHECK_SIZEOF(unsigned long int, 4)
+AC_CHECK_SIZEOF(unsigned int, 4)
+AC_CHECK_SIZEOF(unsigned short int, 2)
+AC_CHECK_SIZEOF(unsigned char, 1)
+
+
+
+AC_MSG_RESULT([***
+*** Detecting options for shared libraries...
+])
+AM_PROG_LIBTOOL
+
+AC_CONFIG_FILES([Makefile src/Makefile lib/Makefile \
+doc/Makefile doc/scripts/Makefile])
+AC_OUTPUT
+
--- /dev/null
+EXTRA_DIST = asn1.tex asn1.ps asn1.html fdl.tex TODO
+SUBDIRS = scripts
+
+
+TEX_OBJECTS = asn1.tex ../lib/asn1-api.tex
+
+asn1.ps: $(TEX_OBJECTS)
+ -$(LN_S) ../lib/asn1-api.tex .
+ -latex asn1.tex && latex asn1.tex && dvips asn1.dvi -o asn1.ps
+
+asn1.html: $(TEX_OBJECTS)
+ -latex2html asn1.tex -no_navigation -no_subdir 1 -split 0 -local_icons -html_version 3.2,math \
+ -info "" -white
+
+
+clean:
+ @-rm *.log *.aux *.toc
+ @-rm *.pl index.html asn1.dvi
+ @-rm WARNINGS asn1-api.tex
--- /dev/null
+\documentclass{book}
+\usepackage{html}
+\usepackage{fancyheadings}
+\usepackage{graphicx}
+
+\begin{document}
+
+\vspace*{\stretch{2}}
+
+\begin{center}
+\par
+Copyright \copyright\ 2001, 2002 Fabio Fiorina\\
+\setlength{\parskip}{4mm}
+\par
+Permission is granted to copy, distribute and/or modify this
+document under the terms of the GNU Free Documentation License,
+Version 1.1 or any later version published by the Free Software
+Foundation; with no Invariant Sections, no Front-Cover Texts and
+no Back-Cover Texts. A copy of the license is included in the
+chapter entitled "GNU Free Documentation License".
+\end{center}
+
+\setlength{\parindent}{2mm}
+
+\setlength{\parskip}{1mm}
+
+
+\chapter{ASN.1 structures handling}
+
+\section{Introduction}
+ This file describes the forth version of ASN.1 parser I
+developed.
+The main difference from the first version is the use of pointers and the
+possibility to save/get ASN1 definitions in/from a C vector.
+Other differences are:
+\begin{itemize}
+\item write\_value function for type ANY
+\item the introduction of ENUMERATED type,
+\item negative integer are allowed in ASN.1 syntax files,
+\item PKIX1Implicit88.txt instead of Certificate.txt for the Certificate description
+\item functions naming
+\item an easier way to set INTEGER and get OBJECT IDENTFIER
+\end{itemize}
+
+
+\section{ASN.1 syntax}
+The parser is case sensitive. The comments begin with "-- " and end at the end of line.
+An example is in "Certificate.txt" file.
+The ASN.1 declarations must have this form:
+
+\begin{verbatim}
+ object_name {<object definition>}
+
+ DEFINITIONS <EXPLICIT or IMPLICIT> TAGS ::=
+
+ BEGIN
+
+ <type and constants definitions>
+
+ END
+\end{verbatim}
+
+\par
+The token "::=" must be separate from others elements, so this is a wrong declaration:
+ Version ::=INTEGER
+the correct one is : Version ::= INTEGER
+Here is the list of types that the parser can manage:
+\begin{itemize}
+
+\item INTEGER
+\item ENUMERATED
+\item BOOLEAN
+\item OBJECT IDENTIFIER
+\item NULL
+\item BIT STRING
+\item OCTET STRING
+\item UTCTime
+\item GeneralizedTime
+\item SEQUENCE
+\item SEQUENCE OF
+\item SET
+\item SET OF
+\item CHOICE
+\item ANY
+\item ANY DEFINED BY
+\end{itemize}
+
+This version doesn't manage REAL type. It also not allow the use of
+"EXPORT" and "IMPORT" sections.
+
+The SIZE constraints are allowed but no check is done on them.
+
+
+
+\section{Naming}
+If you have this definitions:
+
+\begin{verbatim}
+ Example { 1 2 3 4 }
+
+ DEFINITIONS EXPLICIT TAGS ::=
+
+ BEGIN
+
+ Group ::= SEQUENCE {
+ id OBJECT IDENTIFIER,
+ value Value
+ }
+
+ Value ::= SEQUENCE {
+ value1 INTEGER,
+ value2 BOOLEAN
+ }
+
+ END
+\end{verbatim}
+
+to identify the type 'Group' you have to use the null terminated string "Example.Group".
+Others examples:
+Field 'id' in 'Group' type : "Example.Group.id"
+Field 'value1' in filed 'value' in type 'Group': "Example.Group.value.value1"
+These strings are used in functions that are described below.
+Elements of structured types that don't have a name, receve the name "?1","?2", and so on.
+The name "?LAST" indicates the last element of a SET\_OF or SEQUENCE\_OF.
+
+\section{Future developments}
+\begin{enumerate}
+\item type REAL
+\item improve the error signaling with strings that give you more details.
+ Examples: in case of ASN1 syntax error you will have the line number where the error is,
+ if creating a der encoding the result is ASN\_VALUE\_NOT\_FOUND you will have the
+ name of the element without the value.
+\item improve the 'visit\_tree' function and change the output from stdout to a null terminated
+ string.
+
+\end{enumerate}
+
+\input{asn1-api}
+
+\input{fdl.tex}
+
+\end{document}
--- /dev/null
+% fdl.tex
+% This file is a chapter. It must be included in a larger document to work
+% properly.
+
+\chapter{GNU Free Documentation License}
+
+Version 1.1, March 2000\\
+
+ Copyright \copyright\ 2000 Free Software Foundation, Inc.\\
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\\
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+\section*{Preamble}
+
+The purpose of this License is to make a manual, textbook, or other
+written document ``free'' in the sense of freedom: to assure everyone
+the effective freedom to copy and redistribute it, with or without
+modifying it, either commercially or noncommercially. Secondarily,
+this License preserves for the author and publisher a way to get
+credit for their work, while not being considered responsible for
+modifications made by others.
+
+This License is a kind of ``copyleft'', which means that derivative
+works of the document must themselves be free in the same sense. It
+complements the GNU General Public License, which is a copyleft
+license designed for free software.
+
+We have designed this License in order to use it for manuals for free
+software, because free software needs free documentation: a free
+program should come with manuals providing the same freedoms that the
+software does. But this License is not limited to software manuals;
+it can be used for any textual work, regardless of subject matter or
+whether it is published as a printed book. We recommend this License
+principally for works whose purpose is instruction or reference.
+
+\section{Applicability and Definitions}
+
+This License applies to any manual or other work that contains a
+notice placed by the copyright holder saying it can be distributed
+under the terms of this License. The ``Document'', below, refers to any
+such manual or work. Any member of the public is a licensee, and is
+addressed as ``you''.
+
+A ``Modified Version'' of the Document means any work containing the
+Document or a portion of it, either copied verbatim, or with
+modifications and/or translated into another language.
+
+A ``Secondary Section'' is a named appendix or a front-matter section of
+the Document that deals exclusively with the relationship of the
+publishers or authors of the Document to the Document's overall subject
+(or to related matters) and contains nothing that could fall directly
+within that overall subject. (For example, if the Document is in part a
+textbook of mathematics, a Secondary Section may not explain any
+mathematics.) The relationship could be a matter of historical
+connection with the subject or with related matters, or of legal,
+commercial, philosophical, ethical or political position regarding
+them.
+
+The ``Invariant Sections'' are certain Secondary Sections whose titles
+are designated, as being those of Invariant Sections, in the notice
+that says that the Document is released under this License.
+
+The ``Cover Texts'' are certain short passages of text that are listed,
+as Front-Cover Texts or Back-Cover Texts, in the notice that says that
+the Document is released under this License.
+
+A ``Transparent'' copy of the Document means a machine-readable copy,
+represented in a format whose specification is available to the
+general public, whose contents can be viewed and edited directly and
+straightforwardly with generic text editors or (for images composed of
+pixels) generic paint programs or (for drawings) some widely available
+drawing editor, and that is suitable for input to text formatters or
+for automatic translation to a variety of formats suitable for input
+to text formatters. A copy made in an otherwise Transparent file
+format whose markup has been designed to thwart or discourage
+subsequent modification by readers is not Transparent. A copy that is
+not ``Transparent'' is called ``Opaque''.
+
+Examples of suitable formats for Transparent copies include plain
+ASCII without markup, Texinfo input format, \LaTeX~input format, SGML
+or XML using a publicly available DTD, and standard-conforming simple
+HTML designed for human modification. Opaque formats include
+PostScript, PDF, proprietary formats that can be read and edited only
+by proprietary word processors, SGML or XML for which the DTD and/or
+processing tools are not generally available, and the
+machine-generated HTML produced by some word processors for output
+purposes only.
+
+The ``Title Page'' means, for a printed book, the title page itself,
+plus such following pages as are needed to hold, legibly, the material
+this License requires to appear in the title page. For works in
+formats which do not have any title page as such, ``Title Page'' means
+the text near the most prominent appearance of the work's title,
+preceding the beginning of the body of the text.
+
+
+\section{Verbatim Copying}
+
+You may copy and distribute the Document in any medium, either
+commercially or noncommercially, provided that this License, the
+copyright notices, and the license notice saying this License applies
+to the Document are reproduced in all copies, and that you add no other
+conditions whatsoever to those of this License. You may not use
+technical measures to obstruct or control the reading or further
+copying of the copies you make or distribute. However, you may accept
+compensation in exchange for copies. If you distribute a large enough
+number of copies you must also follow the conditions in section 3.
+
+You may also lend copies, under the same conditions stated above, and
+you may publicly display copies.
+
+
+\section{Copying in Quantity}
+
+If you publish printed copies of the Document numbering more than 100,
+and the Document's license notice requires Cover Texts, you must enclose
+the copies in covers that carry, clearly and legibly, all these Cover
+Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
+the back cover. Both covers must also clearly and legibly identify
+you as the publisher of these copies. The front cover must present
+the full title with all words of the title equally prominent and
+visible. You may add other material on the covers in addition.
+Copying with changes limited to the covers, as long as they preserve
+the title of the Document and satisfy these conditions, can be treated
+as verbatim copying in other respects.
+
+If the required texts for either cover are too voluminous to fit
+legibly, you should put the first ones listed (as many as fit
+reasonably) on the actual cover, and continue the rest onto adjacent
+pages.
+
+If you publish or distribute Opaque copies of the Document numbering
+more than 100, you must either include a machine-readable Transparent
+copy along with each Opaque copy, or state in or with each Opaque copy
+a publicly-accessible computer-network location containing a complete
+Transparent copy of the Document, free of added material, which the
+general network-using public has access to download anonymously at no
+charge using public-standard network protocols. If you use the latter
+option, you must take reasonably prudent steps, when you begin
+distribution of Opaque copies in quantity, to ensure that this
+Transparent copy will remain thus accessible at the stated location
+until at least one year after the last time you distribute an Opaque
+copy (directly or through your agents or retailers) of that edition to
+the public.
+
+It is requested, but not required, that you contact the authors of the
+Document well before redistributing any large number of copies, to give
+them a chance to provide you with an updated version of the Document.
+
+
+\section{Modifications}
+
+You may copy and distribute a Modified Version of the Document under
+the conditions of sections 2 and 3 above, provided that you release
+the Modified Version under precisely this License, with the Modified
+Version filling the role of the Document, thus licensing distribution
+and modification of the Modified Version to whoever possesses a copy
+of it. In addition, you must do these things in the Modified Version:
+
+\begin{itemize}
+
+\item Use in the Title Page (and on the covers, if any) a title distinct
+ from that of the Document, and from those of previous versions
+ (which should, if there were any, be listed in the History section
+ of the Document). You may use the same title as a previous version
+ if the original publisher of that version gives permission.
+\item List on the Title Page, as authors, one or more persons or entities
+ responsible for authorship of the modifications in the Modified
+ Version, together with at least five of the principal authors of the
+ Document (all of its principal authors, if it has less than five).
+\item State on the Title page the name of the publisher of the
+ Modified Version, as the publisher.
+\item Preserve all the copyright notices of the Document.
+\item Add an appropriate copyright notice for your modifications
+ adjacent to the other copyright notices.
+\item Include, immediately after the copyright notices, a license notice
+ giving the public permission to use the Modified Version under the
+ terms of this License, in the form shown in the Addendum below.
+\item Preserve in that license notice the full lists of Invariant Sections
+ and required Cover Texts given in the Document's license notice.
+\item Include an unaltered copy of this License.
+\item Preserve the section entitled ``History'', and its title, and add to
+ it an item stating at least the title, year, new authors, and
+ publisher of the Modified Version as given on the Title Page. If
+ there is no section entitled ``History'' in the Document, create one
+ stating the title, year, authors, and publisher of the Document as
+ given on its Title Page, then add an item describing the Modified
+ Version as stated in the previous sentence.
+\item Preserve the network location, if any, given in the Document for
+ public access to a Transparent copy of the Document, and likewise
+ the network locations given in the Document for previous versions
+ it was based on. These may be placed in the ``History'' section.
+ You may omit a network location for a work that was published at
+ least four years before the Document itself, or if the original
+ publisher of the version it refers to gives permission.
+\item In any section entitled ``Acknowledgements'' or ``Dedications'',
+ preserve the section's title, and preserve in the section all the
+ substance and tone of each of the contributor acknowledgements
+ and/or dedications given therein.
+\item Preserve all the Invariant Sections of the Document,
+ unaltered in their text and in their titles. Section numbers
+ or the equivalent are not considered part of the section titles.
+\item Delete any section entitled ``Endorsements''. Such a section
+ may not be included in the Modified Version.
+\item Do not retitle any existing section as ``Endorsements''
+ or to conflict in title with any Invariant Section.
+
+\end{itemize}
+
+If the Modified Version includes new front-matter sections or
+appendices that qualify as Secondary Sections and contain no material
+copied from the Document, you may at your option designate some or all
+of these sections as invariant. To do this, add their titles to the
+list of Invariant Sections in the Modified Version's license notice.
+These titles must be distinct from any other section titles.
+
+You may add a section entitled ``Endorsements'', provided it contains
+nothing but endorsements of your Modified Version by various
+parties -- for example, statements of peer review or that the text has
+been approved by an organization as the authoritative definition of a
+standard.
+
+You may add a passage of up to five words as a Front-Cover Text, and a
+passage of up to 25 words as a Back-Cover Text, to the end of the list
+of Cover Texts in the Modified Version. Only one passage of
+Front-Cover Text and one of Back-Cover Text may be added by (or
+through arrangements made by) any one entity. If the Document already
+includes a cover text for the same cover, previously added by you or
+by arrangement made by the same entity you are acting on behalf of,
+you may not add another; but you may replace the old one, on explicit
+permission from the previous publisher that added the old one.
+
+The author(s) and publisher(s) of the Document do not by this License
+give permission to use their names for publicity for or to assert or
+imply endorsement of any Modified Version.
+
+
+\section{Combining Documents}
+
+You may combine the Document with other documents released under this
+License, under the terms defined in section 4 above for modified
+versions, provided that you include in the combination all of the
+Invariant Sections of all of the original documents, unmodified, and
+list them all as Invariant Sections of your combined work in its
+license notice.
+
+The combined work need only contain one copy of this License, and
+multiple identical Invariant Sections may be replaced with a single
+copy. If there are multiple Invariant Sections with the same name but
+different contents, make the title of each such section unique by
+adding at the end of it, in parentheses, the name of the original
+author or publisher of that section if known, or else a unique number.
+Make the same adjustment to the section titles in the list of
+Invariant Sections in the license notice of the combined work.
+
+In the combination, you must combine any sections entitled ``History''
+in the various original documents, forming one section entitled
+``History''; likewise combine any sections entitled ``Acknowledgements'',
+and any sections entitled ``Dedications''. You must delete all sections
+entitled ``Endorsements.''
+
+
+\section{Collections of Documents}
+
+You may make a collection consisting of the Document and other documents
+released under this License, and replace the individual copies of this
+License in the various documents with a single copy that is included in
+the collection, provided that you follow the rules of this License for
+verbatim copying of each of the documents in all other respects.
+
+You may extract a single document from such a collection, and distribute
+it individually under this License, provided you insert a copy of this
+License into the extracted document, and follow this License in all
+other respects regarding verbatim copying of that document.
+
+
+
+\section{Aggregation With Independent Works}
+
+A compilation of the Document or its derivatives with other separate
+and independent documents or works, in or on a volume of a storage or
+distribution medium, does not as a whole count as a Modified Version
+of the Document, provided no compilation copyright is claimed for the
+compilation. Such a compilation is called an ``aggregate'', and this
+License does not apply to the other self-contained works thus compiled
+with the Document, on account of their being thus compiled, if they
+are not themselves derivative works of the Document.
+
+If the Cover Text requirement of section 3 is applicable to these
+copies of the Document, then if the Document is less than one quarter
+of the entire aggregate, the Document's Cover Texts may be placed on
+covers that surround only the Document within the aggregate.
+Otherwise they must appear on covers around the whole aggregate.
+
+
+\section{Translation}
+
+Translation is considered a kind of modification, so you may
+distribute translations of the Document under the terms of section 4.
+Replacing Invariant Sections with translations requires special
+permission from their copyright holders, but you may include
+translations of some or all Invariant Sections in addition to the
+original versions of these Invariant Sections. You may include a
+translation of this License provided that you also include the
+original English version of this License. In case of a disagreement
+between the translation and the original English version of this
+License, the original English version will prevail.
+
+
+\section{Termination}
+
+You may not copy, modify, sublicense, or distribute the Document except
+as expressly provided for under this License. Any other attempt to
+copy, modify, sublicense or distribute the Document is void, and will
+automatically terminate your rights under this License. However,
+parties who have received copies, or rights, from you under this
+License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+
+\section{Future Revisions of This License}
+
+The Free Software Foundation may publish new, revised versions
+of the GNU Free Documentation License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns. See
+http://www.gnu.org/copyleft/.
+
+Each version of the License is given a distinguishing version number.
+If the Document specifies that a particular numbered version of this
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that specified version or
+of any later version that has been published (not as a draft) by the
+Free Software Foundation. If the Document does not specify a version
+number of this License, you may choose any version ever published (not
+as a draft) by the Free Software Foundation.
+
+\section*{ADDENDUM: How to use this License for your documents}
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and
+license notices just after the title page:
+
+\begin{quote}
+
+ Copyright \copyright\ YEAR YOUR NAME.
+ Permission is granted to copy, distribute and/or modify this document
+ under the terms of the GNU Free Documentation License, Version 1.1
+ or any later version published by the Free Software Foundation;
+ with the Invariant Sections being LIST THEIR TITLES, with the
+ Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
+ A copy of the license is included in the section entitled ``GNU
+ Free Documentation License''.
+
+\end{quote}
+
+If you have no Invariant Sections, write ``with no Invariant Sections''
+instead of saying which ones are invariant. If you have no
+Front-Cover Texts, write ``no Front-Cover Texts'' instead of
+``Front-Cover Texts being LIST''; likewise for Back-Cover Texts.
+
+If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License,
+to permit their use in free software.
+
--- /dev/null
+EXTRA_DIST = gdoc
+
+
--- /dev/null
+#!/usr/bin/perl
+
+## Copyright (c) 1998 Michael Zucchi, All Rights Reserved ##
+## hacked to allow -tex option --nmav ##
+## ##
+## This software falls under the GNU Public License. Please read ##
+## the COPYING file for more information ##
+
+#
+# This will read a 'c' file and scan for embedded comments in the
+# style of gnome comments (+minor extensions - see below).
+#
+# This program is modified by Nikos Mavroyanopoulos, for the gnutls
+# project.
+
+# Note: This only supports 'c'.
+
+# usage:
+# gdoc [ -docbook | -html | -text | -man | -tex ]
+# [ -function funcname [ -function funcname ...] ] c file(s)s > outputfile
+#
+# Set output format using one of -docbook -html -text or -man. Default is man.
+#
+# -function funcname
+# If set, then only generate documentation for the given function(s). All
+# other functions are ignored.
+#
+# c files - list of 'c' files to process
+#
+# All output goes to stdout, with errors to stderr.
+
+#
+# format of comments.
+# In the following table, (...)? signifies optional structure.
+# (...)* signifies 0 or more structure elements
+# /**
+# * function_name(:)? (- short description)?
+# (* @parameterx: (description of parameter x)?)*
+# (* a blank line)?
+# * (Description:)? (Description of function)?
+# * (section header: (section description)? )*
+# (*)?*/
+#
+# So .. the trivial example would be:
+#
+# /**
+# * my_function
+# **/
+#
+# If the Description: header tag is ommitted, then there must be a blank line
+# after the last parameter specification.
+# e.g.
+# /**
+# * my_function - does my stuff
+# * @my_arg: its mine damnit
+# *
+# * Does my stuff explained.
+# */
+#
+# or, could also use:
+# /**
+# * my_function - does my stuff
+# * @my_arg: its mine damnit
+# * Description: Does my stuff explained.
+# */
+# etc.
+#
+# All descriptions can be multiline, apart from the short function description.
+#
+# All descriptive text is further processed, scanning for the following special
+# patterns, which are highlighted appropriately.
+#
+# 'funcname()' - function
+# '$ENVVAR' - environmental variable
+# '&struct_name' - name of a structure
+# '@parameter' - name of a parameter
+# '%CONST' - name of a constant.
+
+#
+# Extensions for LaTeX:
+#
+# 1. the symbol '->' will be replaced with a rightarrow
+# 2. x^y with ${x}^{y}$.
+# 3. xxx\: with xxx:
+
+
+# match expressions used to find embedded type information
+$type_constant = "\\\%(\\w+)";
+#$type_func = "(\\w+\\(\\))";
+$type_func = "(\\(w||\\\\)+\\(\\))";
+$type_param = "\\\@(\\w+)";
+$type_struct = "\\\&(\\w+)";
+$type_env = "(\\\$\\w+)";
+
+
+# Output conversion substitutions.
+# One for each output format
+
+# these work fairly well
+%highlights_html = ( $type_constant, "<i>\$1</i>",
+ $type_func, "<b>\$1</b>",
+ $type_struct, "<i>\$1</i>",
+ $type_param, "<tt><b>\$1</b></tt>" );
+$blankline_html = "<p>";
+
+%highlights_tex = ( $type_constant, "{\\\\it \$1}",
+ $type_func, "{\\\\bf \$1}",
+ $type_struct, "{\\\\it \$1}",
+ $type_param, "{\\\\bf \$1}" );
+$blankline_tex = "\\par";
+
+# sgml, docbook format
+%highlights_sgml = ( $type_constant, "<replaceable class=\"option\">\$1</replaceable>",
+ $type_func, "<function>\$1</function>",
+ $type_struct, "<structname>\$1</structname>",
+ $type_env, "<envar>\$1</envar>",
+ $type_param, "<parameter>\$1</parameter>" );
+$blankline_sgml = "</para><para>\n";
+
+# these are pretty rough
+%highlights_man = ( $type_constant, "\\n.I \\\"\$1\\\"\\n",
+ $type_func, "\\n.B \\\"\$1\\\"\\n",
+ $type_struct, "\\n.I \\\"\$1\\\"\\n",
+ $type_param."([\.\, ]*)\n?", "\\n.I \\\"\$1\$2\\\"\\n" );
+$blankline_man = "";
+
+# text-mode
+%highlights_text = ( $type_constant, "\$1",
+ $type_func, "\$1",
+ $type_struct, "\$1",
+ $type_param, "\$1" );
+$blankline_text = "";
+
+
+sub usage {
+ print "Usage: $0 [ -v ] [ -docbook | -html | -text | -man | -tex ]\n";
+ print " [ -function funcname [ -function funcname ...] ]\n";
+ print " c source file(s) > outputfile\n";
+ exit 1;
+}
+
+# read arguments
+if ($#ARGV==-1) {
+ usage();
+}
+
+$verbose = 0;
+$output_mode = "man";
+%highlights = %highlights_man;
+$blankline = $blankline_man;
+$modulename = "API Documentation";
+$function_only = 0;
+while ($ARGV[0] =~ m/^-(.*)/) {
+ $cmd = shift @ARGV;
+ if ($cmd eq "-html") {
+ $output_mode = "html";
+ %highlights = %highlights_html;
+ $blankline = $blankline_html;
+ } elsif ($cmd eq "-man") {
+ $output_mode = "man";
+ %highlights = %highlights_man;
+ $blankline = $blankline_man;
+ } elsif ($cmd eq "-tex") {
+ $output_mode = "tex";
+ %highlights = %highlights_tex;
+ $blankline = $blankline_tex;
+ } elsif ($cmd eq "-text") {
+ $output_mode = "text";
+ %highlights = %highlights_text;
+ $blankline = $blankline_text;
+ } elsif ($cmd eq "-docbook") {
+ $output_mode = "sgml";
+ %highlights = %highlights_sgml;
+ $blankline = $blankline_sgml;
+ } elsif ($cmd eq "-module") { # not needed for sgml, inherits from calling document
+ $modulename = shift @ARGV;
+ } elsif ($cmd eq "-function") { # to only output specific functions
+ $function_only = 1;
+ $function = shift @ARGV;
+ $function_table{$function} = 1;
+ } elsif ($cmd eq "-v") {
+ $verbose = 1;
+ } elsif (($cmd eq "-h") || ($cmd eq "--help")) {
+ usage();
+ }
+}
+
+
+# generate a sequence of code that will splice in highlighting information
+# using the s// operator.
+$dohighlight = "";
+foreach $pattern (keys %highlights) {
+# print "scanning pattern $pattern ($highlights{$pattern})\n";
+ $dohighlight .= "\$contents =~ s:$pattern:$highlights{$pattern}:gs;\n";
+}
+
+##
+# dumps section contents to arrays/hashes intended for that purpose.
+#
+sub dump_section {
+ my $name = shift @_;
+ my $contents = join "\n", @_;
+
+ if ($name =~ m/$type_constant/) {
+ $name = $1;
+# print STDERR "constant section '$1' = '$contents'\n";
+ $constants{$name} = $contents;
+ } elsif ($name =~ m/$type_param/) {
+# print STDERR "parameter def '$1' = '$contents'\n";
+ $name = $1;
+ $parameters{$name} = $contents;
+ } else {
+# print STDERR "other section '$name' = '$contents'\n";
+ $sections{$name} = $contents;
+ push @sectionlist, $name;
+ }
+}
+
+##
+# output function
+#
+# parameters, a hash.
+# function => "function name"
+# parameterlist => @list of parameters
+# parameters => %parameter descriptions
+# sectionlist => @list of sections
+# sections => %descriont descriptions
+#
+
+sub output_highlight {
+ my $contents = join "\n", @_;
+ my $line;
+
+ eval $dohighlight;
+ foreach $line (split "\n", $contents) {
+ if ($line eq ""){
+ print $lineprefix, $blankline;
+ } else {
+ print $lineprefix, $line;
+ }
+ print "\n";
+ }
+}
+
+
+# output in html
+sub output_html {
+ my %args = %{$_[0]};
+ my ($parameter, $section);
+ my $count;
+ print "\n\n<a name=\"". $args{'function'} . "\"> </a><h2>Function</h2>\n";
+
+ print "<i>".$args{'functiontype'}."</i>\n";
+ print "<b>".$args{'function'}."</b>\n";
+ print "(";
+ $count = 0;
+ foreach $parameter (@{$args{'parameterlist'}}) {
+ print "<i>".$args{'parametertypes'}{$parameter}."</i> <b>".$parameter."</b>\n";
+ if ($count != $#{$args{'parameterlist'}}) {
+ $count++;
+ print ", ";
+ }
+ }
+ print ")\n";
+
+ print "<h3>Arguments</h3>\n";
+ print "<dl>\n";
+ foreach $parameter (@{$args{'parameterlist'}}) {
+ print "<dt><i>".$args{'parametertypes'}{$parameter}."</i> <b>".$parameter."</b>\n";
+ print "<dd>";
+ output_highlight($args{'parameters'}{$parameter});
+ }
+ print "</dl>\n";
+ foreach $section (@{$args{'sectionlist'}}) {
+ print "<h3>$section</h3>\n";
+ print "<ul>\n";
+ output_highlight($args{'sections'}{$section});
+ print "</ul>\n";
+ }
+ print "<hr>\n";
+}
+
+# output in tex
+sub output_tex {
+ my %args = %{$_[0]};
+ my ($parameter, $section);
+ my $count;
+ my $func = $args{'function'};
+ my $param;
+ my $param2;
+ my $sec;
+ my $check;
+ my $type;
+
+ $func =~ s/_/\\_/g;
+
+ print "\n\n\\subsection{". $func . "}\n\\label{" . $args{'function'} . "}\n";
+
+ $type = $args{'functiontype'};
+ $type =~ s/_/\\_/g;
+
+ print "{\\it ".$type."}\n";
+ print "{\\bf ".$func."}\n";
+ print "(\n";
+ $count = 0;
+ foreach $parameter (@{$args{'parameterlist'}}) {
+ $param = $args{'parametertypes'}{$parameter};
+ $param2 = $parameter;
+ $param =~ s/_/\\_/g;
+ $param2 =~ s/_/\\_/g;
+
+ print "{\\it ".$param."} {\\bf ".$param2."}\n";
+ if ($count != $#{$args{'parameterlist'}}) {
+ $count++;
+ print ", ";
+ }
+ }
+ print ")\n";
+
+ print "\n{\\large{Arguments}}\n";
+
+ print "\\begin{itemize}\n";
+ $check=0;
+ foreach $parameter (@{$args{'parameterlist'}}) {
+ $param1 = $args{'parametertypes'}{$parameter};
+ $param1 =~ s/_/\\_/g;
+ $param2 = $parameter;
+ $param2 =~ s/_/\\_/g;
+
+ $check = 1;
+ print "\\item {\\it ".$param1."} {\\bf ".$param2."}: \n";
+# print "\n";
+
+ $param3 = $args{'parameters'}{$parameter};
+ $param3 =~ s/_/\\_/g;
+ $param3 =~ s/&([a-zA-Z\_]+)/{\\it \1}/g;
+
+ output_highlight($param3);
+ }
+ if ($check==0) {
+ print "\\item void\n";
+ }
+ print "\\end{itemize}\n";
+
+ foreach $section (@{$args{'sectionlist'}}) {
+ $sec = $section;
+ $sec =~ s/_/\\_/g;
+ $sec =~ s/&([a-zA-Z\_]+)/{\\it \1}/g;
+
+ print "\n\\par{\\large{$sec}}\\par\n";
+ print "\\begin{rmfamily}\n";
+
+ $sec = $args{'sections'}{$section};
+ $sec =~ s/_/\\_/g;
+ $sec =~ s/\\:/:/g;
+ $sec =~ s/&([a-zA-Z\_]+)/{\\it \1}/g;
+ $sec =~ s/->/\$\\rightarrow\$/g;
+ $sec =~ s/([0-9]+)\^([0-9]+)/\$\{\1\}\^\{\2\}\$/g;
+
+ output_highlight($sec);
+ print "\\end{rmfamily}\n";
+ }
+ print "\n";
+}
+
+
+# output in sgml DocBook
+sub output_sgml {
+ my %args = %{$_[0]};
+ my ($parameter, $section);
+ my $count;
+ my $id;
+
+ $id = $args{'module'}."-".$args{'function'};
+ $id =~ s/[^A-Za-z0-9]/-/g;
+
+ print "<refentry>\n";
+ print "<refmeta>\n";
+ print "<refentrytitle><phrase id=\"$id\">".$args{'function'}."</phrase></refentrytitle>\n";
+ print "</refmeta>\n";
+ print "<refnamediv>\n";
+ print " <refname>".$args{'function'}."</refname>\n";
+ print " <refpurpose>\n";
+ print " ".$args{'purpose'}."\n";
+ print " </refpurpose>\n";
+ print "</refnamediv>\n";
+
+ print "<refsynopsisdiv>\n";
+ print " <title>Synopsis</title>\n";
+ print " <funcsynopsis>\n";
+ print " <funcdef>".$args{'functiontype'}." ";
+ print "<function>".$args{'function'}." ";
+ print "</function></funcdef>\n";
+
+# print "<refsect1>\n";
+# print " <title>Synopsis</title>\n";
+# print " <funcsynopsis>\n";
+# print " <funcdef>".$args{'functiontype'}." ";
+# print "<function>".$args{'function'}." ";
+# print "</function></funcdef>\n";
+
+ $count = 0;
+ if ($#{$args{'parameterlist'}} >= 0) {
+ foreach $parameter (@{$args{'parameterlist'}}) {
+ print " <paramdef>".$args{'parametertypes'}{$parameter};
+ print " <parameter>$parameter</parameter></paramdef>\n";
+ }
+ } else {
+ print " <void>\n";
+ }
+ print " </funcsynopsis>\n";
+ print "</refsynopsisdiv>\n";
+# print "</refsect1>\n";
+
+ # print parameters
+ print "<refsect1>\n <title>Arguments</title>\n";
+# print "<para>\nArguments\n";
+ if ($#{$args{'parameterlist'}} >= 0) {
+ print " <variablelist>\n";
+ foreach $parameter (@{$args{'parameterlist'}}) {
+ print " <varlistentry>\n <term><parameter>$parameter</parameter></term>\n";
+ print " <listitem>\n <para>\n";
+ $lineprefix=" ";
+ output_highlight($args{'parameters'}{$parameter});
+ print " </para>\n </listitem>\n </varlistentry>\n";
+ }
+ print " </variablelist>\n";
+ } else {
+ print " <para>\n None\n </para>\n";
+ }
+ print "</refsect1>\n";
+
+ # print out each section
+ $lineprefix=" ";
+ foreach $section (@{$args{'sectionlist'}}) {
+ print "<refsect1>\n <title>$section</title>\n <para>\n";
+# print "<para>\n$section\n";
+ if ($section =~ m/EXAMPLE/i) {
+ print "<example><para>\n";
+ }
+ output_highlight($args{'sections'}{$section});
+# print "</para>";
+ if ($section =~ m/EXAMPLE/i) {
+ print "</para></example>\n";
+ }
+ print " </para>\n</refsect1>\n";
+ }
+
+ print "\n\n";
+}
+
+##
+# output in man
+sub output_man {
+ my %args = %{$_[0]};
+ my ($parameter, $section);
+ my $count;
+
+ print ".TH \"$args{'module'}\" \"$args{'function'}\" \"25 May 1998\" \"API Manual\" GNOME\n";
+
+ print ".SH Function\n";
+
+ print ".I \"".$args{'functiontype'}."\"\n";
+ print ".B \"".$args{'function'}."\"\n";
+ print "(\n";
+ $count = 0;
+ foreach $parameter (@{$args{'parameterlist'}}) {
+ print ".I \"".$args{'parametertypes'}{$parameter}."\"\n.B \"".$parameter."\"\n";
+ if ($count != $#{$args{'parameterlist'}}) {
+ $count++;
+ print ",\n";
+ }
+ }
+ print ")\n";
+
+ print ".SH Arguments\n";
+ foreach $parameter (@{$args{'parameterlist'}}) {
+ print ".IP \"".$args{'parametertypes'}{$parameter}." ".$parameter."\" 12\n";
+ output_highlight($args{'parameters'}{$parameter});
+ }
+ foreach $section (@{$args{'sectionlist'}}) {
+ print ".SH \"$section\"\n";
+ output_highlight($args{'sections'}{$section});
+ }
+}
+
+##
+# output in text
+sub output_text {
+ my %args = %{$_[0]};
+ my ($parameter, $section);
+
+ print "Function = ".$args{'function'}."\n";
+ print " return type: ".$args{'functiontype'}."\n\n";
+ foreach $parameter (@{$args{'parameterlist'}}) {
+ print " ".$args{'parametertypes'}{$parameter}." ".$parameter."\n";
+ print " -> ".$args{'parameters'}{$parameter}."\n";
+ }
+ foreach $section (@{$args{'sectionlist'}}) {
+ print " $section:\n";
+ print " -> ";
+ output_highlight($args{'sections'}{$section});
+ }
+}
+
+##
+# generic output function - calls the right one based
+# on current output mode.
+sub output_function {
+# output_html(@_);
+ eval "output_".$output_mode."(\@_);";
+}
+
+
+##
+# takes a function prototype and spits out all the details
+# stored in the global arrays/hsahes.
+sub dump_function {
+ my $prototype = shift @_;
+
+ if ($prototype =~ m/^()([a-zA-Z0-9_~:]+)\s*\(([^\)]*)\)/ ||
+ $prototype =~ m/^(\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\)]*)\)/ ||
+ $prototype =~ m/^(\w+\s*\*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\)]*)\)/ ||
+ $prototype =~ m/^(\w+\s+\w+)\s+([a-zA-Z0-9_~:]+)\s*\(([^\)]*)\)/ ||
+ $prototype =~ m/^(\w+\s+\w+\s*\*)\s*([a-zA-Z0-9_~:]+)\s*\(([^\)]*)\)/) {
+ $return_type = $1;
+ $function_name = $2;
+ $args = $3;
+
+# print STDERR "ARGS = '$args'\n";
+
+ foreach $arg (split ',', $args) {
+ # strip leading/trailing spaces
+ $arg =~ s/^\s*//;
+ $arg =~ s/\s*$//;
+# print STDERR "SCAN ARG: '$arg'\n";
+ @args = split('\s', $arg);
+
+# print STDERR " -> @args\n";
+ $param = pop @args;
+# print STDERR " -> @args\n";
+ if ($param =~ m/^(\*+)(.*)/) {
+ $param = $2;
+ push @args, $1;
+ }
+ $type = join " ", @args;
+
+ if ($parameters{$param} eq "" && $param != "void") {
+ $parameters{$param} = "-- undescribed --";
+ print STDERR "Warning($lineno): Function parameter '$param' not described in '$function_name'\n";
+ }
+
+ push @parameterlist, $param;
+ $parametertypes{$param} = $type;
+
+# print STDERR "param = '$param', type = '$type'\n";
+ }
+ } else {
+ print STDERR "Error($lineno): cannot understand prototype: '$prototype'\n";
+ return;
+ }
+
+ if ($function_only==0 || defined($function_table{$function_name})) {
+ output_function({'function' => $function_name,
+ 'module' => $modulename,
+ 'functiontype' => $return_type,
+ 'parameterlist' => \@parameterlist,
+ 'parameters' => \%parameters,
+ 'parametertypes' => \%parametertypes,
+ 'sectionlist' => \@sectionlist,
+ 'sections' => \%sections,
+ 'purpose' => $function_purpose
+ });
+ }
+}
+
+######################################################################
+# main
+# states
+# 0 - normal code
+# 1 - looking for function name
+# 2 - scanning field start.
+# 3 - scanning prototype.
+$state = 0;
+$section = "";
+
+$doc_special = "\@\%\$\&";
+
+$doc_start = "^/\\*\\*\$";
+$doc_end = "\\*/";
+$doc_com = "\\s*\\*\\s*";
+$doc_func = $doc_com."(\\w+):?";
+$doc_sect = $doc_com."([".$doc_special."]?[\\w ]+):(.*)";
+$doc_content = $doc_com."(.*)";
+
+%constants = ();
+%parameters = ();
+@parameterlist = ();
+%sections = ();
+@sectionlist = ();
+
+$contents = "";
+$section_default = "Description"; # default section
+$section = $section_default;
+
+$lineno = 0;
+foreach $file (@ARGV) {
+ if (!open(IN,"<$file")) {
+ print STDERR "Error: Cannot open file $file\n";
+ next;
+ }
+ while (<IN>) {
+ $lineno++;
+
+ if ($state == 0) {
+ if (/$doc_start/o) {
+ $state = 1; # next line is always the function name
+ }
+ } elsif ($state == 1) { # this line is the function name (always)
+ if (/$doc_func/o) {
+ $function = $1;
+ $state = 2;
+ if (/-(.*)/) {
+ $function_purpose = $1;
+ } else {
+ $function_purpose = "";
+ }
+ if ($verbose) {
+ print STDERR "Info($lineno): Scanning doc for $function\n";
+ }
+ } else {
+ print STDERR "WARN($lineno): Cannot understand $_ on line $lineno",
+ " - I thought it was a doc line\n";
+ $state = 0;
+ }
+ } elsif ($state == 2) { # look for head: lines, and include content
+ if (/$doc_sect/o) {
+ $newsection = $1;
+ $newcontents = $2;
+
+ if ($contents ne "") {
+ dump_section($section, $contents);
+ $section = $section_default;
+ }
+
+ $contents = $newcontents;
+ if ($contents ne "") {
+ $contents .= "\n";
+ }
+ $section = $newsection;
+ } elsif (/$doc_end/) {
+
+ if ($contents ne "") {
+ dump_section($section, $contents);
+ $section = $section_default;
+ $contents = "";
+ }
+
+# print STDERR "end of doc comment, looking for prototype\n";
+ $prototype = "";
+ $state = 3;
+ } elsif (/$doc_content/) {
+ # miguel-style comment kludge, look for blank lines after
+ # @parameter line to signify start of description
+ if ($1 eq "" && $section =~ m/^@/) {
+ dump_section($section, $contents);
+ $section = $section_default;
+ $contents = "";
+ } else {
+ $contents .= $1."\n";
+ }
+ } else {
+ # i dont know - bad line? ignore.
+ print STDERR "WARNING($lineno): bad line: $_";
+ }
+ } elsif ($state == 3) { # scanning for function { (end of prototype)
+ if (m#\s*/\*\s+MACDOC\s*#io) {
+ # do nothing
+ }
+ elsif (/([^\{]*)/) {
+ $prototype .= $1;
+ }
+ if (/\{/) {
+ $prototype =~ s@/\*.*?\*/@@gos; # strip comments.
+ $prototype =~ s@[\r\n]+@ @gos; # strip newlines/cr's.
+ $prototype =~ s@^ +@@gos; # strip leading spaces
+ dump_function($prototype);
+
+ $function = "";
+ %constants = ();
+ %parameters = ();
+ %parametertypes = ();
+ @parameterlist = ();
+ %sections = ();
+ @sectionlist = ();
+ $prototype = "";
+
+ $state = 0;
+ }
+ }
+ }
+}
+
--- /dev/null
+/* A Bison parser, made from ASN.y
+ by GNU bison 1.32. */
+
+#define YYBISON 1 /* Identify Bison output. */
+
+# define ASSIG 257
+# define NUM 258
+# define IDENTIFIER 259
+# define OPTIONAL 260
+# define INTEGER 261
+# define SIZE 262
+# define OCTET 263
+# define STRING 264
+# define SEQUENCE 265
+# define BIT 266
+# define UNIVERSAL 267
+# define PRIVATE 268
+# define APPLICATION 269
+# define DEFAULT 270
+# define CHOICE 271
+# define OF 272
+# define OBJECT 273
+# define STR_IDENTIFIER 274
+# define BOOLEAN 275
+# define TRUE 276
+# define FALSE 277
+# define TOKEN_NULL 278
+# define ANY 279
+# define DEFINED 280
+# define BY 281
+# define SET 282
+# define EXPLICIT 283
+# define IMPLICIT 284
+# define DEFINITIONS 285
+# define TAGS 286
+# define BEGIN 287
+# define END 288
+# define UTCTime 289
+# define GeneralizedTime 290
+# define FROM 291
+# define IMPORTS 292
+# define ENUMERATED 293
+
+#line 30 "ASN.y"
+
+#include <defines.h>
+#include <asn1.h>
+
+FILE *file_asn1; /* Pointer to file to parse */
+extern int parse_mode; /* PARSE_MODE_CHECK = only syntax check
+ PARSE_MODE_CREATE = structure creation */
+int result_parse; /* result of the parser algorithm */
+node_asn *p_tree; /* pointer to the root of the structure
+ created by the parser*/
+
+int yyerror (char *);
+int yylex(void);
+
+
+#line 47 "ASN.y"
+#ifndef YYSTYPE
+typedef union {
+ unsigned int constant;
+ char str[129];
+ node_asn* node;
+} yystype;
+# define YYSTYPE yystype
+#endif
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+
+
+#define YYFINAL 189
+#define YYFLAG -32768
+#define YYNTBASE 50
+
+/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
+#define YYTRANSLATE(x) ((unsigned)(x) <= 293 ? yytranslate[x] : 93)
+
+/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
+static const char yytranslate[] =
+{
+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 42, 43, 2, 40, 44, 41, 49, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 45, 2, 46, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 47, 2, 48, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 1, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39
+};
+
+#if YYDEBUG
+static const short yyprhs[] =
+{
+ 0, 0, 1, 4, 6, 9, 12, 14, 16, 18,
+ 20, 22, 24, 28, 33, 35, 39, 41, 44, 46,
+ 51, 53, 56, 58, 60, 62, 66, 71, 73, 76,
+ 79, 82, 85, 88, 90, 95, 103, 105, 107, 109,
+ 114, 122, 124, 128, 131, 135, 140, 142, 146, 149,
+ 155, 160, 163, 165, 168, 170, 172, 174, 176, 178,
+ 180, 182, 184, 186, 188, 190, 192, 194, 197, 199,
+ 202, 205, 208, 210, 214, 219, 223, 228, 233, 237,
+ 242, 247, 249, 254, 258, 266, 273, 278, 280, 282,
+ 284, 287, 292, 296, 297, 303, 305, 307
+};
+static const short yyrhs[] =
+{
+ -1, 50, 92, 0, 4, 0, 40, 4, 0, 41,
+ 4, 0, 51, 0, 52, 0, 4, 0, 5, 0,
+ 53, 0, 5, 0, 42, 53, 43, 0, 5, 42,
+ 53, 43, 0, 56, 0, 57, 44, 56, 0, 5,
+ 0, 58, 5, 0, 54, 0, 5, 42, 4, 43,
+ 0, 59, 0, 60, 59, 0, 13, 0, 14, 0,
+ 15, 0, 45, 4, 46, 0, 45, 61, 4, 46,
+ 0, 62, 0, 62, 29, 0, 62, 30, 0, 16,
+ 55, 0, 16, 22, 0, 16, 23, 0, 7, 0,
+ 7, 47, 57, 48, 0, 65, 42, 54, 49, 49,
+ 54, 43, 0, 21, 0, 35, 0, 36, 0, 8,
+ 42, 54, 43, 0, 8, 42, 54, 49, 49, 54,
+ 43, 0, 68, 0, 42, 68, 43, 0, 9, 10,
+ 0, 9, 10, 69, 0, 5, 42, 4, 43, 0,
+ 71, 0, 72, 44, 71, 0, 12, 10, 0, 12,
+ 10, 47, 72, 48, 0, 39, 47, 72, 48, 0,
+ 19, 20, 0, 5, 0, 5, 69, 0, 65, 0,
+ 74, 0, 66, 0, 67, 0, 70, 0, 73, 0,
+ 81, 0, 75, 0, 83, 0, 84, 0, 82, 0,
+ 24, 0, 76, 0, 63, 76, 0, 77, 0, 77,
+ 64, 0, 77, 6, 0, 5, 78, 0, 79, 0,
+ 80, 44, 79, 0, 11, 47, 80, 48, 0, 11,
+ 18, 76, 0, 11, 69, 18, 76, 0, 28, 47,
+ 80, 48, 0, 28, 18, 76, 0, 28, 69, 18,
+ 76, 0, 17, 47, 80, 48, 0, 25, 0, 25,
+ 26, 27, 5, 0, 5, 3, 77, 0, 5, 19,
+ 20, 3, 47, 60, 48, 0, 5, 5, 3, 47,
+ 60, 48, 0, 5, 7, 3, 4, 0, 85, 0,
+ 86, 0, 87, 0, 88, 87, 0, 5, 47, 60,
+ 48, 0, 5, 47, 48, 0, 0, 38, 58, 37,
+ 5, 60, 0, 29, 0, 30, 0, 89, 31, 91,
+ 32, 3, 33, 90, 88, 34, 0
+};
+
+#endif
+
+#if YYDEBUG
+/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
+static const short yyrline[] =
+{
+ 0, 106, 107, 110, 111, 114, 118, 119, 122, 123,
+ 126, 127, 130, 132, 137, 138, 142, 144, 150, 152,
+ 157, 158, 162, 163, 164, 167, 169, 173, 174, 175,
+ 178, 180, 181, 184, 185, 187, 194, 197, 198, 201,
+ 203, 209, 210, 213, 214, 218, 223, 224, 228, 229,
+ 234, 239, 242, 244, 247, 248, 249, 250, 251, 252,
+ 253, 254, 255, 256, 257, 258, 261, 262, 267, 268,
+ 271, 274, 277, 278, 282, 284, 286, 291, 293, 295,
+ 300, 304, 305, 310, 313, 317, 322, 328, 329, 332,
+ 333, 337, 340, 344, 345, 353, 354, 357
+};
+#endif
+
+
+#if (YYDEBUG) || defined YYERROR_VERBOSE
+
+/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
+static const char *const yytname[] =
+{
+ "$", "error", "$undefined.", "\"::=\"", "NUM", "IDENTIFIER", "OPTIONAL",
+ "INTEGER", "SIZE", "OCTET", "STRING", "SEQUENCE", "BIT", "UNIVERSAL",
+ "PRIVATE", "APPLICATION", "DEFAULT", "CHOICE", "OF", "OBJECT",
+ "STR_IDENTIFIER", "BOOLEAN", "TRUE", "FALSE", "TOKEN_NULL", "ANY",
+ "DEFINED", "BY", "SET", "EXPLICIT", "IMPLICIT", "DEFINITIONS", "TAGS",
+ "BEGIN", "END", "UTCTime", "GeneralizedTime", "FROM", "IMPORTS",
+ "ENUMERATED", "'+'", "'-'", "'('", "')'", "','", "'['", "']'", "'{'",
+ "'}'", "'.'", "input", "pos_num", "neg_num", "pos_neg_num",
+ "num_identifier", "pos_neg_identifier", "constant", "constant_list",
+ "identifier_list", "obj_constant", "obj_constant_list", "class",
+ "tag_type", "tag", "default", "integer_def", "boolean_def", "Time",
+ "size_def2", "size_def", "octet_string_def", "bit_element",
+ "bit_element_list", "bit_string_def", "enumerated_def", "object_def",
+ "type_assig_right", "type_assig_right_tag",
+ "type_assig_right_tag_default", "type_assig", "type_assig_list",
+ "sequence_def", "set_def", "choise_def", "any_def", "type_def",
+ "constant_def", "type_constant", "type_constant_list", "definitions_id",
+ "imports_def", "explicit_implicit", "definitions", NULL
+};
+#endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const short yyr1[] =
+{
+ 0, 50, 50, 51, 51, 52, 53, 53, 54, 54,
+ 55, 55, 56, 56, 57, 57, 58, 58, 59, 59,
+ 60, 60, 61, 61, 61, 62, 62, 63, 63, 63,
+ 64, 64, 64, 65, 65, 65, 66, 67, 67, 68,
+ 68, 69, 69, 70, 70, 71, 72, 72, 73, 73,
+ 74, 75, 76, 76, 76, 76, 76, 76, 76, 76,
+ 76, 76, 76, 76, 76, 76, 77, 77, 78, 78,
+ 78, 79, 80, 80, 81, 81, 81, 82, 82, 82,
+ 83, 84, 84, 85, 86, 86, 86, 87, 87, 88,
+ 88, 89, 89, 90, 90, 91, 91, 92
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
+static const short yyr2[] =
+{
+ 0, 0, 2, 1, 2, 2, 1, 1, 1, 1,
+ 1, 1, 3, 4, 1, 3, 1, 2, 1, 4,
+ 1, 2, 1, 1, 1, 3, 4, 1, 2, 2,
+ 2, 2, 2, 1, 4, 7, 1, 1, 1, 4,
+ 7, 1, 3, 2, 3, 4, 1, 3, 2, 5,
+ 4, 2, 1, 2, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 2, 1, 2,
+ 2, 2, 1, 3, 4, 3, 4, 4, 3, 4,
+ 4, 1, 4, 3, 7, 6, 4, 1, 1, 1,
+ 2, 4, 3, 0, 5, 1, 1, 9
+};
+
+/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
+ doesn't specify something else to do. Zero means the default is an
+ error. */
+static const short yydefact[] =
+{
+ 1, 0, 0, 0, 2, 0, 0, 8, 9, 92,
+ 18, 20, 0, 95, 96, 0, 0, 91, 21, 0,
+ 0, 0, 19, 93, 0, 0, 16, 0, 0, 87,
+ 88, 89, 0, 17, 0, 0, 0, 0, 0, 97,
+ 90, 0, 52, 33, 0, 0, 0, 0, 0, 36,
+ 65, 81, 0, 37, 38, 0, 0, 27, 0, 54,
+ 56, 57, 58, 59, 55, 61, 66, 83, 60, 64,
+ 62, 63, 0, 0, 0, 0, 0, 0, 41, 53,
+ 0, 43, 0, 0, 0, 48, 0, 51, 0, 0,
+ 0, 0, 0, 0, 22, 23, 24, 0, 28, 29,
+ 67, 0, 0, 86, 0, 0, 0, 0, 0, 14,
+ 0, 44, 75, 0, 72, 0, 0, 0, 0, 0,
+ 78, 0, 0, 0, 46, 0, 25, 0, 9, 0,
+ 0, 0, 0, 42, 0, 3, 0, 0, 6, 7,
+ 0, 0, 34, 68, 71, 0, 74, 76, 0, 80,
+ 82, 77, 79, 0, 0, 50, 26, 0, 85, 0,
+ 39, 0, 0, 4, 5, 12, 15, 70, 0, 69,
+ 73, 49, 0, 47, 0, 84, 0, 13, 11, 31,
+ 32, 10, 30, 45, 0, 0, 35, 40, 0, 0
+};
+
+static const short yydefgoto[] =
+{
+ 1, 138, 139, 140, 10, 182, 109, 110, 27, 11,
+ 12, 97, 57, 58, 169, 59, 60, 61, 78, 79,
+ 62, 124, 125, 63, 64, 65, 66, 67, 144, 114,
+ 115, 68, 69, 70, 71, 29, 30, 31, 32, 3,
+ 25, 15, 4
+};
+
+static const short yypact[] =
+{
+ -32768, 33, -7, 28,-32768, 0, -5,-32768, 22,-32768,
+ -32768,-32768, 3,-32768,-32768, 42, 62,-32768,-32768, 76,
+ 45, 60,-32768, 85, 109, 127,-32768, 8, 108,-32768,
+ -32768,-32768, 9,-32768, 128, 11, 131, 132, 116,-32768,
+ -32768, 67, 18, 90, 129, 23, 130, 91, 121,-32768,
+ -32768, 117, 34,-32768,-32768, 95, 106, 87, 73, 102,
+ -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+ -32768,-32768, 98, 142, 145, 67, 107, 143,-32768,-32768,
+ 12, 18, 73, 147, 135, 103, 147,-32768, 133, 73,
+ 147, 136, 150, 110,-32768,-32768,-32768, 153,-32768,-32768,
+ -32768, 126, 67,-32768, 111, 126, 118, 120, 17,-32768,
+ 51,-32768,-32768, 11,-32768, 52, 73, 150, 58, 154,
+ -32768, 59, 73, 122,-32768, 78,-32768, 119,-32768, 114,
+ 5, 67, 40,-32768, 17,-32768, 162, 163,-32768,-32768,
+ 125, 12,-32768, 13,-32768, 147,-32768,-32768, 80,-32768,
+ -32768,-32768,-32768, 165, 150,-32768,-32768, 123,-32768, 7,
+ -32768, 124, 134,-32768,-32768,-32768,-32768,-32768, 64,-32768,
+ -32768,-32768, 137,-32768, 126,-32768, 126,-32768,-32768,-32768,
+ -32768,-32768,-32768,-32768, 138, 139,-32768,-32768, 170,-32768
+};
+
+static const short yypgoto[] =
+{
+ -32768,-32768,-32768, -119, -99,-32768, 30,-32768,-32768, -12,
+ -40,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 97, -8,
+ -32768, 21, 61,-32768,-32768,-32768, -55, 63,-32768, 38,
+ 39,-32768,-32768,-32768,-32768,-32768,-32768, 152,-32768,-32768,
+ -32768,-32768,-32768
+};
+
+
+#define YYLAST 184
+
+
+static const short yytable[] =
+{
+ 18, 75, 129, 100, 7, 8, 132, 7, 8, 7,
+ 8, 7, 8, 33, 28, 162, 42, 107, 43, 167,
+ 44, 135, 45, 46, 13, 14, 76, 112, 47, 168,
+ 48, 76, 49, 188, 120, 50, 51, 84, 2, 52,
+ 5, 82, 76, 39, 91, 34, 53, 54, 9, 181,
+ 55, 17, 89, 158, 108, 175, 56, 136, 137, 6,
+ 77, 147, 130, 18, 16, 77, 20, 152, 135, 178,
+ 83, 7, 8, 111, 19, 184, 77, 185, 42, 21,
+ 43, 90, 44, 160, 45, 46, 179, 180, 22, 161,
+ 47, 159, 48, 23, 49, 141, 145, 50, 51, 142,
+ 146, 52, 145, 145, 136, 137, 149, 151, 53, 54,
+ 93, 35, 55, 36, 26, 37, 98, 99, 18, 94,
+ 95, 96, 154, 24, 154, 118, 155, 38, 171, 121,
+ 7, 128, 28, 41, 72, 73, 74, 80, 86, 81,
+ 85, 87, 92, 88, 101, 102, 103, 18, 104, 105,
+ 117, 76, 113, 116, 122, 123, 126, 127, 131, 150,
+ 119, 133, 134, 157, 153, 156, 163, 164, 165, 172,
+ 189, 166, 174, 176, 106, 173, 143, 177, 148, 0,
+ 183, 186, 187, 170, 40
+};
+
+static const short yycheck[] =
+{
+ 12, 41, 101, 58, 4, 5, 105, 4, 5, 4,
+ 5, 4, 5, 5, 5, 134, 5, 5, 7, 6,
+ 9, 4, 11, 12, 29, 30, 8, 82, 17, 16,
+ 19, 8, 21, 0, 89, 24, 25, 45, 5, 28,
+ 47, 18, 8, 34, 52, 37, 35, 36, 48, 168,
+ 39, 48, 18, 48, 42, 48, 45, 40, 41, 31,
+ 42, 116, 102, 75, 42, 42, 4, 122, 4, 5,
+ 47, 4, 5, 81, 32, 174, 42, 176, 5, 3,
+ 7, 47, 9, 43, 11, 12, 22, 23, 43, 49,
+ 17, 131, 19, 33, 21, 44, 44, 24, 25, 48,
+ 48, 28, 44, 44, 40, 41, 48, 48, 35, 36,
+ 4, 3, 39, 5, 5, 7, 29, 30, 130, 13,
+ 14, 15, 44, 38, 44, 86, 48, 19, 48, 90,
+ 4, 5, 5, 5, 3, 3, 20, 47, 47, 10,
+ 10, 20, 47, 26, 42, 47, 4, 159, 3, 42,
+ 47, 8, 5, 18, 18, 5, 46, 4, 47, 5,
+ 27, 43, 42, 49, 42, 46, 4, 4, 43, 4,
+ 0, 141, 49, 49, 77, 154, 113, 43, 117, -1,
+ 43, 43, 43, 145, 32
+};
+/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
+#line 3 "/usr/share/bison/bison.simple"
+
+/* Skeleton output parser for bison,
+ Copyright (C) 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc.
+
+ 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, 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.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+/* As a special exception, when this file is copied by Bison into a
+ Bison output file, you may use that output file without restriction.
+ This special exception was added by the Free Software Foundation
+ in version 1.24 of Bison. */
+
+/* This is the parser code that is written into each bison parser when
+ the %semantic_parser declaration is not specified in the grammar.
+ It was written by Richard Stallman by simplifying the hairy parser
+ used when %semantic_parser is specified. */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+ infringing on user name space. This should be done even for local
+ variables, as they might otherwise be expanded by user macros.
+ There are some unavoidable exceptions within include files to
+ define necessary library symbols; they are noted "INFRINGES ON
+ USER NAME SPACE" below. */
+
+#ifdef __cplusplus
+# define YYSTD(x) std::x
+#else
+# define YYSTD(x) x
+#endif
+
+#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# if YYSTACK_USE_ALLOCA
+# define YYSTACK_ALLOC alloca
+# define YYSIZE_T YYSTD (size_t)
+# else
+# ifndef YYSTACK_USE_ALLOCA
+# if defined (alloca) || defined (_ALLOCA_H)
+# define YYSTACK_ALLOC alloca
+# define YYSIZE_T YYSTD (size_t)
+# else
+# ifdef __GNUC__
+# define YYSTACK_ALLOC __builtin_alloca
+# endif
+# endif
+# endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's `empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# else
+# ifdef __cplusplus
+# include <cstdlib> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T std::size_t
+# else
+# ifdef __STDC__
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# endif
+# endif
+# define YYSTACK_ALLOC YYSTD (malloc)
+# define YYSTACK_FREE YYSTD (free)
+# endif
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ short yyss;
+ YYSTYPE yyvs;
+# if YYLSP_NEEDED
+ YYLTYPE yyls;
+# endif
+};
+
+/* The size of the maximum gap between one aligned stack and the next. */
+# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+ N elements. */
+# if YYLSP_NEEDED
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+ + 2 * YYSTACK_GAP_MAX)
+# else
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
+ + YYSTACK_GAP_MAX)
+# endif
+
+/* Relocate the TYPE STACK from its old location to the new one. The
+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
+ elements in the stack, and YYPTR gives the new location of the
+ stack. Advance YYPTR to a properly aligned location for the next
+ stack. */
+# define YYSTACK_RELOCATE(Type, Stack) \
+ do \
+ { \
+ YYSIZE_T yynewbytes; \
+ yymemcpy ((char *) yyptr, (char *) (Stack), \
+ yysize * (YYSIZE_T) sizeof (Type)); \
+ Stack = &yyptr->Stack; \
+ yynewbytes = yystacksize * sizeof (Type) + YYSTACK_GAP_MAX; \
+ yyptr += yynewbytes / sizeof (*yyptr); \
+ } \
+ while (0)
+
+#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
+
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
+#endif
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# ifdef __cplusplus
+# include <cstddef> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T std::size_t
+# else
+# ifdef __STDC__
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# endif
+# endif
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
+#endif
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY -2
+#define YYEOF 0
+#define YYACCEPT goto yyacceptlab
+#define YYABORT goto yyabortlab
+#define YYERROR goto yyerrlab1
+/* Like YYERROR except do call yyerror. This remains here temporarily
+ to ease the transition to the new meaning of YYERROR, for GCC.
+ Once GCC version 2 has supplanted version 1, this can go. */
+#define YYFAIL goto yyerrlab
+#define YYRECOVERING() (!!yyerrstatus)
+#define YYBACKUP(Token, Value) \
+do \
+ if (yychar == YYEMPTY && yylen == 1) \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
+ yychar1 = YYTRANSLATE (yychar); \
+ YYPOPSTACK; \
+ goto yybackup; \
+ } \
+ else \
+ { \
+ yyerror ("syntax error: cannot back up"); \
+ YYERROR; \
+ } \
+while (0)
+
+#define YYTERROR 1
+#define YYERRCODE 256
+
+
+/* YYLLOC_DEFAULT -- Compute the default location (before the actions
+ are run).
+
+ When YYLLOC_DEFAULT is run, CURRENT is set the location of the
+ first token. By default, to implement support for ranges, extend
+ its range to the last symbol. */
+
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N) \
+ Current.last_line = Rhs[N].last_line; \
+ Current.last_column = Rhs[N].last_column;
+#endif
+
+
+/* YYLEX -- calling `yylex' with the right arguments. */
+
+#if YYPURE
+# if YYLSP_NEEDED
+# ifdef YYLEX_PARAM
+# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
+# else
+# define YYLEX yylex (&yylval, &yylloc)
+# endif
+# else /* !YYLSP_NEEDED */
+# ifdef YYLEX_PARAM
+# define YYLEX yylex (&yylval, YYLEX_PARAM)
+# else
+# define YYLEX yylex (&yylval)
+# endif
+# endif /* !YYLSP_NEEDED */
+#else /* !YYPURE */
+# define YYLEX yylex ()
+#endif /* !YYPURE */
+
+
+/* Enable debugging if requested. */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+# ifdef __cplusplus
+# include <cstdio> /* INFRINGES ON USER NAME SPACE */
+# else
+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+# endif
+# define YYFPRINTF YYSTD (fprintf)
+# endif
+
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (0)
+/* Nonzero means print parse trace. [The following comment makes no
+ sense to me. Could someone clarify it? --akim] Since this is
+ uninitialized, it does not stop multiple parsers from coexisting.
+ */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+#endif /* !YYDEBUG */
+
+/* YYINITDEPTH -- initial size of the parser's stacks. */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+ if the built-in stack extension method is used).
+
+ Do not make this value too large; the results are undefined if
+ SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
+
+#if YYMAXDEPTH == 0
+# undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+\f
+#if ! defined (yyoverflow) && ! defined (yymemcpy)
+# if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
+# define yymemcpy __builtin_memcpy
+# else /* not GNU C or C++ */
+
+/* This is the most reliable way to avoid incompatibilities
+ in available built-in functions on various systems. */
+static void
+# if defined (__STDC__) || defined (__cplusplus)
+yymemcpy (char *yyto, const char *yyfrom, YYSIZE_T yycount)
+# else
+yymemcpy (yyto, yyfrom, yycount)
+ char *yyto;
+ const char *yyfrom;
+ YYSIZE_T yycount;
+# endif
+{
+ register const char *yyf = yyfrom;
+ register char *yyt = yyto;
+ register YYSIZE_T yyi = yycount;
+
+ while (yyi-- != 0)
+ *yyt++ = *yyf++;
+}
+# endif
+#endif
+
+#ifdef YYERROR_VERBOSE
+
+# ifndef yystrlen
+# if defined (__GLIBC__) && defined (_STRING_H)
+# define yystrlen strlen
+# else
+/* Return the length of YYSTR. */
+static YYSIZE_T
+# if defined (__STDC__) || defined (__cplusplus)
+yystrlen (const char *yystr)
+# else
+yystrlen (yystr)
+ const char *yystr;
+# endif
+{
+ register const char *yys = yystr;
+
+ while (*yys++ != '\0')
+ continue;
+
+ return yys - yystr - 1;
+}
+# endif
+# endif
+
+# ifndef yystpcpy
+# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+# define yystpcpy stpcpy
+# else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+ YYDEST. */
+static char *
+# if defined (__STDC__) || defined (__cplusplus)
+yystpcpy (char *yydest, const char *yysrc)
+# else
+yystpcpy (yydest, yysrc)
+ char *yydest;
+ const char *yysrc;
+# endif
+{
+ register char *yyd = yydest;
+ register const char *yys = yysrc;
+
+ while ((*yyd++ = *yys++) != '\0')
+ continue;
+
+ return yyd - 1;
+}
+# endif
+# endif
+#endif
+\f
+#line 341 "/usr/share/bison/bison.simple"
+
+
+/* The user can define YYPARSE_PARAM as the name of an argument to be passed
+ into yyparse. The argument should have type void *.
+ It should actually point to an object.
+ Grammar actions can access the variable by casting it
+ to the proper pointer type. */
+
+#ifdef YYPARSE_PARAM
+# ifdef __cplusplus
+# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+# define YYPARSE_PARAM_DECL
+# else /* !__cplusplus */
+# define YYPARSE_PARAM_ARG YYPARSE_PARAM
+# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+# endif /* !__cplusplus */
+#else /* !YYPARSE_PARAM */
+# define YYPARSE_PARAM_ARG
+# define YYPARSE_PARAM_DECL
+#endif /* !YYPARSE_PARAM */
+
+/* Prevent warning if -Wstrict-prototypes. */
+#ifdef __GNUC__
+# ifdef YYPARSE_PARAM
+int yyparse (void *);
+# else
+int yyparse (void);
+# endif
+#endif
+
+/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
+ variables are global, or local to YYPARSE. */
+
+#define YY_DECL_NON_LSP_VARIABLES \
+/* The lookahead symbol. */ \
+int yychar; \
+ \
+/* The semantic value of the lookahead symbol. */ \
+YYSTYPE yylval; \
+ \
+/* Number of parse errors so far. */ \
+int yynerrs;
+
+#if YYLSP_NEEDED
+# define YY_DECL_VARIABLES \
+YY_DECL_NON_LSP_VARIABLES \
+ \
+/* Location data for the lookahead symbol. */ \
+YYLTYPE yylloc;
+#else
+# define YY_DECL_VARIABLES \
+YY_DECL_NON_LSP_VARIABLES
+#endif
+
+
+/* If nonreentrant, generate the variables here. */
+
+#if !YYPURE
+YY_DECL_VARIABLES
+#endif /* !YYPURE */
+
+int
+yyparse (YYPARSE_PARAM_ARG)
+ YYPARSE_PARAM_DECL
+{
+ /* If reentrant, generate the variables here. */
+#if YYPURE
+ YY_DECL_VARIABLES
+#endif /* !YYPURE */
+
+ register int yystate;
+ register int yyn;
+ int yyresult;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
+ /* Lookahead token as an internal (translated) token number. */
+ int yychar1 = 0;
+
+ /* Three stacks and their tools:
+ `yyss': related to states,
+ `yyvs': related to semantic values,
+ `yyls': related to locations.
+
+ Refer to the stacks thru separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* The state stack. */
+ short yyssa[YYINITDEPTH];
+ short *yyss = yyssa;
+ register short *yyssp;
+
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs = yyvsa;
+ register YYSTYPE *yyvsp;
+
+#if YYLSP_NEEDED
+ /* The location stack. */
+ YYLTYPE yylsa[YYINITDEPTH];
+ YYLTYPE *yyls = yylsa;
+ YYLTYPE *yylsp;
+#endif
+
+#if YYLSP_NEEDED
+# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
+#else
+# define YYPOPSTACK (yyvsp--, yyssp--)
+#endif
+
+ YYSIZE_T yystacksize = YYINITDEPTH;
+
+
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+#if YYLSP_NEEDED
+ YYLTYPE yyloc;
+#endif
+
+ /* When reducing, the number of symbols on the RHS of the reduced
+ rule. */
+ int yylen;
+
+ YYDPRINTF ((stderr, "Starting parse\n"));
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yynerrs = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+
+ /* Initialize stack pointers.
+ Waste one element of value and location stack
+ so that they stay on the same level as the state stack.
+ The wasted elements are never initialized. */
+
+ yyssp = yyss;
+ yyvsp = yyvs;
+#if YYLSP_NEEDED
+ yylsp = yyls;
+#endif
+ goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate. |
+`------------------------------------------------------------*/
+ yynewstate:
+ /* In all cases, when you get here, the value and location stacks
+ have just been pushed. so pushing a state here evens the stacks.
+ */
+ yyssp++;
+
+ yysetstate:
+ *yyssp = yystate;
+
+ if (yyssp >= yyss + yystacksize - 1)
+ {
+ /* Get the current used size of the three stacks, in elements. */
+ YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+ {
+ /* Give user a chance to reallocate the stack. Use copies of
+ these so that the &'s don't force the real ones into
+ memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ short *yyss1 = yyss;
+
+ /* Each stack pointer address is followed by the size of the
+ data in use in that stack, in bytes. */
+# if YYLSP_NEEDED
+ YYLTYPE *yyls1 = yyls;
+ /* This used to be a conditional around just the two extra args,
+ but that might be undefined if yyoverflow is a macro. */
+ yyoverflow ("parser stack overflow",
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yyls1, yysize * sizeof (*yylsp),
+ &yystacksize);
+ yyls = yyls1;
+# else
+ yyoverflow ("parser stack overflow",
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yystacksize);
+# endif
+ yyss = yyss1;
+ yyvs = yyvs1;
+ }
+#else /* no yyoverflow */
+ /* Extend the stack our own way. */
+ if (yystacksize >= YYMAXDEPTH)
+ goto yyoverflowlab;
+ yystacksize *= 2;
+ if (yystacksize > YYMAXDEPTH)
+ yystacksize = YYMAXDEPTH;
+
+ {
+ short *yyss1 = yyss;
+ union yyalloc *yyptr =
+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+ if (! yyptr)
+ goto yyoverflowlab;
+ YYSTACK_RELOCATE (short, yyss);
+ YYSTACK_RELOCATE (YYSTYPE, yyvs);
+# if YYLSP_NEEDED
+ YYSTACK_RELOCATE (YYLTYPE, yyls);
+# endif
+# undef YYSTACK_RELOCATE
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
+ }
+#endif /* no yyoverflow */
+
+ yyssp = yyss + yysize - 1;
+ yyvsp = yyvs + yysize - 1;
+#if YYLSP_NEEDED
+ yylsp = yyls + yysize - 1;
+#endif
+
+ YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+ (unsigned long int) yystacksize));
+
+ if (yyssp >= yyss + yystacksize - 1)
+ YYABORT;
+ }
+
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+ goto yybackup;
+
+
+/*-----------.
+| yybackup. |
+`-----------*/
+yybackup:
+
+/* Do appropriate processing given the current state. */
+/* Read a lookahead token if we need one and don't already have one. */
+/* yyresume: */
+
+ /* First try to decide what to do without reference to lookahead token. */
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ goto yydefault;
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* yychar is either YYEMPTY or YYEOF
+ or a valid token in external form. */
+
+ if (yychar == YYEMPTY)
+ {
+ YYDPRINTF ((stderr, "Reading a token: "));
+ yychar = YYLEX;
+ }
+
+ /* Convert token to internal form (in yychar1) for indexing tables with */
+
+ if (yychar <= 0) /* This means end of input. */
+ {
+ yychar1 = 0;
+ yychar = YYEOF; /* Don't call YYLEX any more */
+
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
+ yychar1 = YYTRANSLATE (yychar);
+
+#if YYDEBUG
+ /* We have to keep this `#if YYDEBUG', since we use variables
+ which are defined only if `YYDEBUG' is set. */
+ if (yydebug)
+ {
+ YYFPRINTF (stderr, "Next token is %d (%s",
+ yychar, yytname[yychar1]);
+ /* Give the individual parser a way to print the precise
+ meaning of a token, for further debugging info. */
+# ifdef YYPRINT
+ YYPRINT (stderr, yychar, yylval);
+# endif
+ YYFPRINTF (stderr, ")\n");
+ }
+#endif
+ }
+
+ yyn += yychar1;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+ goto yydefault;
+
+ yyn = yytable[yyn];
+
+ /* yyn is what to do for this token type in this state.
+ Negative => reduce, -yyn is rule number.
+ Positive => shift, yyn is new state.
+ New state is final state => don't bother to shift,
+ just return success.
+ 0, or most negative number => error. */
+
+ if (yyn < 0)
+ {
+ if (yyn == YYFLAG)
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+ else if (yyn == 0)
+ goto yyerrlab;
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+ /* Shift the lookahead token. */
+ YYDPRINTF ((stderr, "Shifting token %d (%s), ",
+ yychar, yytname[yychar1]));
+
+ /* Discard the token being shifted unless it is eof. */
+ if (yychar != YYEOF)
+ yychar = YYEMPTY;
+
+ *++yyvsp = yylval;
+#if YYLSP_NEEDED
+ *++yylsp = yylloc;
+#endif
+
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
+
+ yystate = yyn;
+ goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
+yydefault:
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+ goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction. |
+`-----------------------------*/
+yyreduce:
+ /* yyn is the number of a rule to reduce with. */
+ yylen = yyr2[yyn];
+
+ /* If YYLEN is nonzero, implement the default value of the action:
+ `$$ = $1'.
+
+ Otherwise, the following line sets YYVAL to the semantic value of
+ the lookahead token. This behavior is undocumented and Bison
+ users should not rely upon it. Assigning to YYVAL
+ unconditionally makes the parser a bit smaller, and it avoids a
+ GCC warning that YYVAL may be used uninitialized. */
+ yyval = yyvsp[1-yylen];
+
+#if YYLSP_NEEDED
+ /* Similarly for the default location. Let the user run additional
+ commands if for instance locations are ranges. */
+ yyloc = yylsp[1-yylen];
+ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+#endif
+
+#if YYDEBUG
+ /* We have to keep this `#if YYDEBUG', since we use variables which
+ are defined only if `YYDEBUG' is set. */
+ if (yydebug)
+ {
+ int yyi;
+
+ YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
+ yyn, yyrline[yyn]);
+
+ /* Print the symbols being reduced, and their result. */
+ for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
+ YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
+ YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+ }
+#endif
+
+ switch (yyn) {
+
+case 3:
+#line 110 "ASN.y"
+{strcpy(yyval.str,yyvsp[0].str);}
+ break;
+case 4:
+#line 111 "ASN.y"
+{strcpy(yyval.str,yyvsp[0].str);}
+ break;
+case 5:
+#line 114 "ASN.y"
+{strcpy(yyval.str,"-");
+ strcat(yyval.str,yyvsp[0].str);}
+ break;
+case 6:
+#line 118 "ASN.y"
+{strcpy(yyval.str,yyvsp[0].str);}
+ break;
+case 7:
+#line 119 "ASN.y"
+{strcpy(yyval.str,yyvsp[0].str);}
+ break;
+case 8:
+#line 122 "ASN.y"
+{strcpy(yyval.str,yyvsp[0].str);}
+ break;
+case 9:
+#line 123 "ASN.y"
+{strcpy(yyval.str,yyvsp[0].str);}
+ break;
+case 10:
+#line 126 "ASN.y"
+{strcpy(yyval.str,yyvsp[0].str);}
+ break;
+case 11:
+#line 127 "ASN.y"
+{strcpy(yyval.str,yyvsp[0].str);}
+ break;
+case 12:
+#line 130 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_value(yyval.node,yyvsp[-1].str,strlen(yyvsp[-1].str)+1);}
+ break;
+case 13:
+#line 132 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_name(yyval.node,yyvsp[-3].str);
+ _asn1_set_value(yyval.node,yyvsp[-1].str,strlen(yyvsp[-1].str)+1);}
+ break;
+case 14:
+#line 137 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 15:
+#line 138 "ASN.y"
+{yyval.node=yyvsp[-2].node;
+ _asn1_set_right(_asn1_get_last_right(yyvsp[-2].node),yyvsp[0].node);}
+ break;
+case 16:
+#line 142 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_IDENTIFIER);
+ _asn1_set_name(yyval.node,yyvsp[0].str);}
+ break;
+case 17:
+#line 145 "ASN.y"
+{yyval.node=yyvsp[-1].node;
+ _asn1_set_right(_asn1_get_last_right(yyval.node),_asn1_add_node(TYPE_IDENTIFIER));
+ _asn1_set_name(_asn1_get_last_right(yyval.node),yyvsp[0].str);}
+ break;
+case 18:
+#line 150 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_value(yyval.node,yyvsp[0].str,strlen(yyvsp[0].str)+1);}
+ break;
+case 19:
+#line 152 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_name(yyval.node,yyvsp[-3].str);
+ _asn1_set_value(yyval.node,yyvsp[-1].str,strlen(yyvsp[-1].str)+1);}
+ break;
+case 20:
+#line 157 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 21:
+#line 158 "ASN.y"
+{yyval.node=yyvsp[-1].node;
+ _asn1_set_right(_asn1_get_last_right(yyvsp[-1].node),yyvsp[0].node);}
+ break;
+case 22:
+#line 162 "ASN.y"
+{yyval.constant=CONST_UNIVERSAL;}
+ break;
+case 23:
+#line 163 "ASN.y"
+{yyval.constant=CONST_PRIVATE;}
+ break;
+case 24:
+#line 164 "ASN.y"
+{yyval.constant=CONST_APPLICATION;}
+ break;
+case 25:
+#line 167 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_TAG);
+ _asn1_set_value(yyval.node,yyvsp[-1].str,strlen(yyvsp[-1].str)+1);}
+ break;
+case 26:
+#line 169 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_TAG | yyvsp[-2].constant);
+ _asn1_set_value(yyval.node,yyvsp[-1].str,strlen(yyvsp[-1].str)+1);}
+ break;
+case 27:
+#line 173 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 28:
+#line 174 "ASN.y"
+{yyval.node=_asn1_mod_type(yyvsp[-1].node,CONST_EXPLICIT);}
+ break;
+case 29:
+#line 175 "ASN.y"
+{yyval.node=_asn1_mod_type(yyvsp[-1].node,CONST_IMPLICIT);}
+ break;
+case 30:
+#line 178 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_DEFAULT);
+ _asn1_set_value(yyval.node,yyvsp[0].str,strlen(yyvsp[0].str)+1);}
+ break;
+case 31:
+#line 180 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_DEFAULT|CONST_TRUE);}
+ break;
+case 32:
+#line 181 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_DEFAULT|CONST_FALSE);}
+ break;
+case 33:
+#line 184 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_INTEGER);}
+ break;
+case 34:
+#line 185 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_INTEGER|CONST_LIST);
+ _asn1_set_down(yyval.node,yyvsp[-1].node);}
+ break;
+case 35:
+#line 188 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_INTEGER|CONST_MIN_MAX);
+ _asn1_set_down(yyval.node,_asn1_add_node(TYPE_SIZE));
+ _asn1_set_value(_asn1_get_down(yyval.node),yyvsp[-1].str,strlen(yyvsp[-1].str)+1);
+ _asn1_set_name(_asn1_get_down(yyval.node),yyvsp[-4].str);}
+ break;
+case 36:
+#line 194 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_BOOLEAN);}
+ break;
+case 37:
+#line 197 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_TIME|CONST_UTC);}
+ break;
+case 38:
+#line 198 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_TIME|CONST_GENERALIZED);}
+ break;
+case 39:
+#line 201 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_SIZE|CONST_1_PARAM);
+ _asn1_set_value(yyval.node,yyvsp[-1].str,strlen(yyvsp[-1].str)+1);}
+ break;
+case 40:
+#line 204 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_SIZE|CONST_MIN_MAX);
+ _asn1_set_value(yyval.node,yyvsp[-4].str,strlen(yyvsp[-4].str)+1);
+ _asn1_set_name(yyval.node,yyvsp[-1].str);}
+ break;
+case 41:
+#line 209 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 42:
+#line 210 "ASN.y"
+{yyval.node=yyvsp[-1].node;}
+ break;
+case 43:
+#line 213 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_OCTET_STRING);}
+ break;
+case 44:
+#line 214 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_OCTET_STRING|CONST_SIZE);
+ _asn1_set_down(yyval.node,yyvsp[0].node);}
+ break;
+case 45:
+#line 218 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_name(yyval.node,yyvsp[-3].str);
+ _asn1_set_value(yyval.node,yyvsp[-1].str,strlen(yyvsp[-1].str)+1);}
+ break;
+case 46:
+#line 223 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 47:
+#line 224 "ASN.y"
+{yyval.node=yyvsp[-2].node;
+ _asn1_set_right(_asn1_get_last_right(yyvsp[-2].node),yyvsp[0].node);}
+ break;
+case 48:
+#line 228 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_BIT_STRING);}
+ break;
+case 49:
+#line 230 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_BIT_STRING|CONST_LIST);
+ _asn1_set_down(yyval.node,yyvsp[-1].node);}
+ break;
+case 50:
+#line 235 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_ENUMERATED|CONST_LIST);
+ _asn1_set_down(yyval.node,yyvsp[-1].node);}
+ break;
+case 51:
+#line 239 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_OBJECT_ID);}
+ break;
+case 52:
+#line 242 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_IDENTIFIER);
+ _asn1_set_value(yyval.node,yyvsp[0].str,strlen(yyvsp[0].str)+1);}
+ break;
+case 53:
+#line 244 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_IDENTIFIER|CONST_SIZE);
+ _asn1_set_value(yyval.node,yyvsp[-1].str,strlen(yyvsp[-1].str)+1);
+ _asn1_set_down(yyval.node,yyvsp[0].node);}
+ break;
+case 54:
+#line 247 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 55:
+#line 248 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 56:
+#line 249 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 58:
+#line 251 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 59:
+#line 252 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 60:
+#line 253 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 61:
+#line 254 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 62:
+#line 255 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 63:
+#line 256 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 64:
+#line 257 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 65:
+#line 258 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_NULL);}
+ break;
+case 66:
+#line 261 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 67:
+#line 262 "ASN.y"
+{yyval.node=_asn1_mod_type(yyvsp[0].node,CONST_TAG);
+ _asn1_set_right(yyvsp[-1].node,_asn1_get_down(yyval.node));
+ _asn1_set_down(yyval.node,yyvsp[-1].node);}
+ break;
+case 68:
+#line 267 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 69:
+#line 268 "ASN.y"
+{yyval.node=_asn1_mod_type(yyvsp[-1].node,CONST_DEFAULT);
+ _asn1_set_right(yyvsp[0].node,_asn1_get_down(yyval.node));
+ _asn1_set_down(yyval.node,yyvsp[0].node);}
+ break;
+case 70:
+#line 271 "ASN.y"
+{yyval.node=_asn1_mod_type(yyvsp[-1].node,CONST_OPTION);}
+ break;
+case 71:
+#line 274 "ASN.y"
+{yyval.node=_asn1_set_name(yyvsp[0].node,yyvsp[-1].str);}
+ break;
+case 72:
+#line 277 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 73:
+#line 278 "ASN.y"
+{yyval.node=yyvsp[-2].node;
+ _asn1_set_right(_asn1_get_last_right(yyvsp[-2].node),yyvsp[0].node);}
+ break;
+case 74:
+#line 282 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_SEQUENCE);
+ _asn1_set_down(yyval.node,yyvsp[-1].node);}
+ break;
+case 75:
+#line 284 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_SEQUENCE_OF);
+ _asn1_set_down(yyval.node,yyvsp[0].node);}
+ break;
+case 76:
+#line 286 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_SEQUENCE_OF|CONST_SIZE);
+ _asn1_set_right(yyvsp[-2].node,yyvsp[0].node);
+ _asn1_set_down(yyval.node,yyvsp[-2].node);}
+ break;
+case 77:
+#line 291 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_SET);
+ _asn1_set_down(yyval.node,yyvsp[-1].node);}
+ break;
+case 78:
+#line 293 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_SET_OF);
+ _asn1_set_down(yyval.node,yyvsp[0].node);}
+ break;
+case 79:
+#line 295 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_SET_OF|CONST_SIZE);
+ _asn1_set_right(yyvsp[-2].node,yyvsp[0].node);
+ _asn1_set_down(yyval.node,yyvsp[-2].node);}
+ break;
+case 80:
+#line 300 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_CHOICE);
+ _asn1_set_down(yyval.node,yyvsp[-1].node);}
+ break;
+case 81:
+#line 304 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_ANY);}
+ break;
+case 82:
+#line 305 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_ANY|CONST_DEFINED_BY);
+ _asn1_set_down(yyval.node,_asn1_add_node(TYPE_CONSTANT));
+ _asn1_set_name(_asn1_get_down(yyval.node),yyvsp[0].str);}
+ break;
+case 83:
+#line 310 "ASN.y"
+{yyval.node=_asn1_set_name(yyvsp[0].node,yyvsp[-2].str);}
+ break;
+case 84:
+#line 314 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_OBJECT_ID|CONST_ASSIGN);
+ _asn1_set_name(yyval.node,yyvsp[-6].str);
+ _asn1_set_down(yyval.node,yyvsp[-1].node);}
+ break;
+case 85:
+#line 318 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_OBJECT_ID|CONST_ASSIGN|CONST_1_PARAM);
+ _asn1_set_name(yyval.node,yyvsp[-5].str);
+ _asn1_set_value(yyval.node,yyvsp[-4].str,strlen(yyvsp[-4].str)+1);
+ _asn1_set_down(yyval.node,yyvsp[-1].node);}
+ break;
+case 86:
+#line 323 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_INTEGER|CONST_ASSIGN);
+ _asn1_set_name(yyval.node,yyvsp[-3].str);
+ _asn1_set_value(yyval.node,yyvsp[0].str,strlen(yyvsp[0].str)+1);}
+ break;
+case 87:
+#line 328 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 88:
+#line 329 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 89:
+#line 332 "ASN.y"
+{yyval.node=yyvsp[0].node;}
+ break;
+case 90:
+#line 333 "ASN.y"
+{yyval.node=yyvsp[-1].node;
+ _asn1_set_right(_asn1_get_last_right(yyvsp[-1].node),yyvsp[0].node);}
+ break;
+case 91:
+#line 337 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_OBJECT_ID);
+ _asn1_set_down(yyval.node,yyvsp[-1].node);
+ _asn1_set_name(yyval.node,yyvsp[-3].str);}
+ break;
+case 92:
+#line 340 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_OBJECT_ID);
+ _asn1_set_name(yyval.node,yyvsp[-2].str);}
+ break;
+case 93:
+#line 344 "ASN.y"
+{yyval.node=NULL;}
+ break;
+case 94:
+#line 346 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_IMPORTS);
+ _asn1_set_down(yyval.node,_asn1_add_node(TYPE_OBJECT_ID));
+ _asn1_set_name(_asn1_get_down(yyval.node),yyvsp[-1].str);
+ _asn1_set_down(_asn1_get_down(yyval.node),yyvsp[0].node);
+ _asn1_set_right(yyval.node,yyvsp[-3].node);}
+ break;
+case 95:
+#line 353 "ASN.y"
+{yyval.constant=CONST_EXPLICIT;}
+ break;
+case 96:
+#line 354 "ASN.y"
+{yyval.constant=CONST_IMPLICIT;}
+ break;
+case 97:
+#line 360 "ASN.y"
+{yyval.node=_asn1_add_node(TYPE_DEFINITIONS|yyvsp[-6].constant|((yyvsp[-2].node==NULL)?0:CONST_IMPORTS));
+ _asn1_set_name(yyval.node,_asn1_get_name(yyvsp[-8].node));
+ _asn1_set_name(yyvsp[-8].node,"");
+ if(yyvsp[-2].node==NULL) _asn1_set_right(yyvsp[-8].node,yyvsp[-1].node);
+ else {_asn1_set_right(yyvsp[-2].node,yyvsp[-1].node);_asn1_set_right(yyvsp[-8].node,yyvsp[-2].node);}
+ _asn1_set_down(yyval.node,yyvsp[-8].node);
+ if(parse_mode==PARSE_MODE_CREATE){
+ _asn1_set_default_tag(yyval.node);
+ _asn1_type_set_config(yyval.node);
+ result_parse=_asn1_check_identifier(yyval.node);
+ if(result_parse==ASN_IDENTIFIER_NOT_FOUND)
+ asn1_delete_structure(yyval.node);
+ else p_tree=yyval.node;
+ }}
+ break;
+}
+
+#line 727 "/usr/share/bison/bison.simple"
+
+\f
+ yyvsp -= yylen;
+ yyssp -= yylen;
+#if YYLSP_NEEDED
+ yylsp -= yylen;
+#endif
+
+#if YYDEBUG
+ if (yydebug)
+ {
+ short *yyssp1 = yyss - 1;
+ YYFPRINTF (stderr, "state stack now");
+ while (yyssp1 != yyssp)
+ YYFPRINTF (stderr, " %d", *++yyssp1);
+ YYFPRINTF (stderr, "\n");
+ }
+#endif
+
+ *++yyvsp = yyval;
+#if YYLSP_NEEDED
+ *++yylsp = yyloc;
+#endif
+
+ /* Now `shift' the result of the reduction. Determine what state
+ that goes to, based on the state we popped back to and the rule
+ number reduced by. */
+
+ yyn = yyr1[yyn];
+
+ yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+ if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yytable[yystate];
+ else
+ yystate = yydefgoto[yyn - YYNTBASE];
+
+ goto yynewstate;
+
+
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+ /* If not already recovering from an error, report this error. */
+ if (!yyerrstatus)
+ {
+ ++yynerrs;
+
+#ifdef YYERROR_VERBOSE
+ yyn = yypact[yystate];
+
+ if (yyn > YYFLAG && yyn < YYLAST)
+ {
+ YYSIZE_T yysize = 0;
+ char *yymsg;
+ int yyx, yycount;
+
+ yycount = 0;
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. */
+ for (yyx = yyn < 0 ? -yyn : 0;
+ yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
+ if (yycheck[yyx + yyn] == yyx)
+ yysize += yystrlen (yytname[yyx]) + 15, yycount++;
+ yysize += yystrlen ("parse error, unexpected ") + 1;
+ yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
+ yymsg = (char *) YYSTACK_ALLOC (yysize);
+ if (yymsg != 0)
+ {
+ char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+ yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
+
+ if (yycount < 5)
+ {
+ yycount = 0;
+ for (yyx = yyn < 0 ? -yyn : 0;
+ yyx < (int) (sizeof (yytname) / sizeof (char *));
+ yyx++)
+ if (yycheck[yyx + yyn] == yyx)
+ {
+ const char *yyq = ! yycount ? ", expecting " : " or ";
+ yyp = yystpcpy (yyp, yyq);
+ yyp = yystpcpy (yyp, yytname[yyx]);
+ yycount++;
+ }
+ }
+ yyerror (yymsg);
+ YYSTACK_FREE (yymsg);
+ }
+ else
+ yyerror ("parse error; also virtual memory exhausted");
+ }
+ else
+#endif /* defined (YYERROR_VERBOSE) */
+ yyerror ("parse error");
+ }
+ goto yyerrlab1;
+
+
+/*--------------------------------------------------.
+| yyerrlab1 -- error raised explicitly by an action |
+`--------------------------------------------------*/
+yyerrlab1:
+ if (yyerrstatus == 3)
+ {
+ /* If just tried and failed to reuse lookahead token after an
+ error, discard it. */
+
+ /* return failure if at end of input */
+ if (yychar == YYEOF)
+ YYABORT;
+ YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
+ yychar, yytname[yychar1]));
+ yychar = YYEMPTY;
+ }
+
+ /* Else will try to reuse lookahead token after shifting the error
+ token. */
+
+ yyerrstatus = 3; /* Each real token shifted decrements this */
+
+ goto yyerrhandle;
+
+
+/*-------------------------------------------------------------------.
+| yyerrdefault -- current state does not do anything special for the |
+| error token. |
+`-------------------------------------------------------------------*/
+yyerrdefault:
+#if 0
+ /* This is wrong; only states that explicitly want error tokens
+ should shift them. */
+
+ /* If its default is to accept any token, ok. Otherwise pop it. */
+ yyn = yydefact[yystate];
+ if (yyn)
+ goto yydefault;
+#endif
+
+
+/*---------------------------------------------------------------.
+| yyerrpop -- pop the current state because it cannot handle the |
+| error token |
+`---------------------------------------------------------------*/
+yyerrpop:
+ if (yyssp == yyss)
+ YYABORT;
+ yyvsp--;
+ yystate = *--yyssp;
+#if YYLSP_NEEDED
+ yylsp--;
+#endif
+
+#if YYDEBUG
+ if (yydebug)
+ {
+ short *yyssp1 = yyss - 1;
+ YYFPRINTF (stderr, "Error: state stack now");
+ while (yyssp1 != yyssp)
+ YYFPRINTF (stderr, " %d", *++yyssp1);
+ YYFPRINTF (stderr, "\n");
+ }
+#endif
+
+/*--------------.
+| yyerrhandle. |
+`--------------*/
+yyerrhandle:
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ goto yyerrdefault;
+
+ yyn += YYTERROR;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+ goto yyerrdefault;
+
+ yyn = yytable[yyn];
+ if (yyn < 0)
+ {
+ if (yyn == YYFLAG)
+ goto yyerrpop;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+ else if (yyn == 0)
+ goto yyerrpop;
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+ YYDPRINTF ((stderr, "Shifting error token, "));
+
+ *++yyvsp = yylval;
+#if YYLSP_NEEDED
+ *++yylsp = yylloc;
+#endif
+
+ yystate = yyn;
+ goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here. |
+`-------------------------------------*/
+yyacceptlab:
+ yyresult = 0;
+ goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here. |
+`-----------------------------------*/
+yyabortlab:
+ yyresult = 1;
+ goto yyreturn;
+
+/*---------------------------------------------.
+| yyoverflowab -- parser overflow comes here. |
+`---------------------------------------------*/
+yyoverflowlab:
+ yyerror ("parser stack overflow");
+ yyresult = 2;
+ /* Fall through. */
+
+yyreturn:
+#ifndef yyoverflow
+ if (yyss != yyssa)
+ YYSTACK_FREE (yyss);
+#endif
+ return yyresult;
+}
+#line 376 "ASN.y"
+
+
+
+#include <ctype.h>
+#include <string.h>
+
+const char *key_word[]={"::=","OPTIONAL","INTEGER","SIZE","OCTET","STRING"
+ ,"SEQUENCE","BIT","UNIVERSAL","PRIVATE","OPTIONAL"
+ ,"DEFAULT","CHOICE","OF","OBJECT","IDENTIFIER"
+ ,"BOOLEAN","TRUE","FALSE","APPLICATION","ANY","DEFINED"
+ ,"SET","BY","EXPLICIT","IMPLICIT","DEFINITIONS","TAGS"
+ ,"BEGIN","END","UTCTime","GeneralizedTime","FROM"
+ ,"IMPORTS","NULL","ENUMERATED"};
+const int key_word_token[]={ASSIG,OPTIONAL,INTEGER,SIZE,OCTET,STRING
+ ,SEQUENCE,BIT,UNIVERSAL,PRIVATE,OPTIONAL
+ ,DEFAULT,CHOICE,OF,OBJECT,STR_IDENTIFIER
+ ,BOOLEAN,TRUE,FALSE,APPLICATION,ANY,DEFINED
+ ,SET,BY,EXPLICIT,IMPLICIT,DEFINITIONS,TAGS
+ ,BEGIN,END,UTCTime,GeneralizedTime,FROM
+ ,IMPORTS,TOKEN_NULL,ENUMERATED};
+
+/*************************************************************/
+/* Function: yylex */
+/* Description: looks for tokens in file_asn1 pointer file. */
+/* Return: int */
+/* Token identifier or ASCII code or 0(zero: End Of File) */
+/*************************************************************/
+int
+yylex()
+{
+ int c,counter=0,k;
+ char string[129]; /* will contain the next token */
+ while(1)
+ {
+ while((c=fgetc(file_asn1))==' ' || c=='\t' || c=='\n');
+ if(c==EOF) return 0;
+ if(c=='(' || c==')' || c=='[' || c==']' ||
+ c=='{' || c=='}' || c==',' || c=='.' ||
+ c=='+') return c;
+ if(c=='-'){ /* Maybe the first '-' of a comment */
+ if((c=fgetc(file_asn1))!='-'){
+ ungetc(c,file_asn1);
+ return '-';
+ }
+ else{ /* Comments */
+ counter=0;
+ /* A comment finishes at the end of line */
+ while((c=fgetc(file_asn1))!=EOF && c!='\n');
+ if(c==EOF) return 0;
+ else continue; /* next char, please! (repeat the search) */
+ }
+ }
+ string[counter++]=c;
+ /* Till the end of the token */
+ while(!((c=fgetc(file_asn1))==EOF || c==' '|| c=='\t' || c=='\n' ||
+ c=='(' || c==')' || c=='[' || c==']' ||
+ c=='{' || c=='}' || c==',' || c=='.'))
+ {
+ string[counter++]=c;
+ }
+ ungetc(c,file_asn1);
+ string[counter]=0;
+
+ /* Is STRING a number? */
+ for(k=0;k<counter;k++)
+ if(!isdigit(string[k])) break;
+ if(k>=counter)
+ {
+ strcpy(yylval.str,string);
+ return NUM; /* return the number */
+ }
+
+ /* Is STRING a keyword? */
+ for(k=0;k<(sizeof(key_word)/sizeof(char*));k++)
+ if(!strcmp(string,key_word[k])) return key_word_token[k];
+
+ /* STRING is an IDENTIFIER */
+ strcpy(yylval.str,string);
+ return IDENTIFIER;
+ }
+}
+
+
+/**
+ * asn1_parser_asn1 - function used to start the parse algorithm.
+ * @file_name: specify the path and the name of file that contains ASN.1 declarations.
+ * @pointer: return the pointer to the structure created from
+ * "file_name" ASN.1 declarations.
+ * Description:
+ *
+ * Creates the structures needed to manage the definitions included in *FILE_NAME file.
+ *
+ * Returns:
+ *
+ * ASN_OK\: the file has a correct syntax and every identifier is known.
+ *
+ * ASN_FILE_NOT_FOUND\: an error occured while opening FILE_NAME.
+ *
+ * ASN_SYNTAX_ERROR\: the syntax is not correct.
+ *
+ * ASN_IDENTIFIER_NOT_FOUND\: in the file there is an identifier that is not defined.
+ **/
+int asn1_parser_asn1(char *file_name,node_asn **pointer){
+ p_tree=NULL;
+ *pointer=NULL;
+
+ /* open the file to parse */
+ file_asn1=fopen(file_name,"r");
+ if(file_asn1==NULL) return ASN_FILE_NOT_FOUND;
+
+ result_parse=ASN_OK;
+
+ /* only syntax check */
+ parse_mode=PARSE_MODE_CHECK;
+ yyparse();
+
+ if(result_parse==ASN_OK){ /* syntax OK */
+ fclose(file_asn1);
+ file_asn1=fopen(file_name,"r");
+
+ /* structure creation */
+ parse_mode=PARSE_MODE_CREATE;
+ yyparse();
+
+ _asn1_change_integer_value(p_tree);
+ _asn1_expand_object_id(p_tree);
+ }
+
+ fclose(file_asn1);
+
+ parse_mode=PARSE_MODE_CREATE;
+
+ *pointer=p_tree;
+
+ return result_parse;
+}
+
+
+/**
+ * asn1_parser_asn1_file_c - function that generates a C structure from an ASN1 file
+ * @file_name: specify the path and the name of file that contains ASN.1 declarations.
+ * Description:
+ *
+ * Creates a file containing a C vector to use to manage the definitions included in
+ * *FILE_NAME file. If *FILE_NAME is "/aa/bb/xx.yy" the file created is "/aa/bb/xx_asn1_tab.c",
+ * and the vector is "xx_asn1_tab".
+ *
+ * Returns:
+ *
+ * ASN_OK\: the file has a correct syntax and every identifier is known.
+ *
+ * ASN_FILE_NOT_FOUND\: an error occured while opening FILE_NAME.
+ *
+ * ASN_SYNTAX_ERROR\: the syntax is not correct.
+ *
+ * ASN_IDENTIFIER_NOT_FOUND\: in the file there is an identifier that is not defined.
+ **/
+int asn1_parser_asn1_file_c(char *file_name){
+ int result;
+
+ p_tree=NULL;
+
+ /* open the file to parse */
+ file_asn1=fopen(file_name,"r");
+ if(file_asn1==NULL) return ASN_FILE_NOT_FOUND;
+
+ result_parse=ASN_OK;
+
+ /* syntax check */
+ parse_mode=PARSE_MODE_CHECK;
+ yyparse();
+
+ if(result_parse==ASN_OK){ /* syntax OK */
+ fclose(file_asn1);
+ file_asn1=fopen(file_name,"r");
+
+ /* structure creation */
+ parse_mode=PARSE_MODE_CREATE;
+ yyparse();
+
+ /* structure saved in a file */
+ result=_asn1_create_static_structure(p_tree,file_name,NULL);
+
+ /* delete structure in memory */
+ asn1_delete_structure(p_tree);
+ }
+
+ fclose(file_asn1);
+
+ parse_mode=PARSE_MODE_CREATE;
+
+ return result_parse;
+}
+
+
+/*************************************************************/
+/* Function: yyerror */
+/* Description: function called when there are syntax errors*/
+/* Parameters: */
+/* char *s : error description */
+/* Return: int */
+/* */
+/*************************************************************/
+int yyerror (char *s)
+{
+ /* Sends the error description to the std_out */
+ /* printf("%s\n",s); */
+ result_parse=ASN_SYNTAX_ERROR;
+ return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+/*
+ * Copyright (C) 2000,2001 Fabio Fiorina
+ *
+ * This file is part of GNUTLS.
+ *
+ * GNUTLS 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.
+ *
+ * GNUTLS 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+/*****************************************************/
+/* File: x509_ASN.y */
+/* Description: input file for 'bison' program. */
+/* The output file is a parser (in C language) for */
+/* ASN.1 syntax */
+/*****************************************************/
+
+
+%{
+#include <defines.h>
+#include <asn1.h>
+
+FILE *file_asn1; /* Pointer to file to parse */
+extern int parse_mode; /* PARSE_MODE_CHECK = only syntax check
+ PARSE_MODE_CREATE = structure creation */
+int result_parse; /* result of the parser algorithm */
+node_asn *p_tree; /* pointer to the root of the structure
+ created by the parser*/
+
+int yyerror (char *);
+int yylex(void);
+
+%}
+
+
+%union {
+ unsigned int constant;
+ char str[129];
+ node_asn* node;
+}
+
+
+%token ASSIG "::="
+%token <str> NUM
+%token <str> IDENTIFIER
+%token OPTIONAL
+%token INTEGER
+%token SIZE
+%token OCTET
+%token STRING
+%token SEQUENCE
+%token BIT
+%token UNIVERSAL
+%token PRIVATE
+%token APPLICATION
+%token OPTIONAL
+%token DEFAULT
+%token CHOICE
+%token OF
+%token OBJECT
+%token STR_IDENTIFIER
+%token BOOLEAN
+%token TRUE
+%token FALSE
+%token TOKEN_NULL
+%token ANY
+%token DEFINED
+%token BY
+%token SET
+%token EXPLICIT
+%token IMPLICIT
+%token DEFINITIONS
+%token TAGS
+%token BEGIN
+%token END
+%token UTCTime
+%token GeneralizedTime
+%token FROM
+%token IMPORTS
+%token ENUMERATED
+
+%type <node> octet_string_def constant constant_list type_assig_right
+%type <node> integer_def type_assig type_assig_list sequence_def type_def
+%type <node> bit_string_def default size_def choise_def object_def
+%type <node> boolean_def any_def size_def2 obj_constant obj_constant_list
+%type <node> constant_def type_constant type_constant_list definitions
+%type <node> definitions_id Time bit_element bit_element_list set_def
+%type <node> identifier_list imports_def tag_type tag type_assig_right_tag
+%type <node> type_assig_right_tag_default enumerated_def
+%type <str> pos_num neg_num pos_neg_num pos_neg_identifier num_identifier
+%type <constant> class explicit_implicit
+
+%%
+
+input: /* empty */
+ | input definitions
+;
+
+pos_num : NUM {strcpy($$,$1);}
+ | '+' NUM {strcpy($$,$2);}
+;
+
+neg_num : '-' NUM {strcpy($$,"-");
+ strcat($$,$2);}
+;
+
+pos_neg_num : pos_num {strcpy($$,$1);}
+ | neg_num {strcpy($$,$1);}
+;
+
+num_identifier : NUM {strcpy($$,$1);}
+ | IDENTIFIER {strcpy($$,$1);}
+;
+
+pos_neg_identifier : pos_neg_num {strcpy($$,$1);}
+ | IDENTIFIER {strcpy($$,$1);}
+;
+
+constant: '(' pos_neg_num ')' {$$=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_value($$,$2,strlen($2)+1);}
+ | IDENTIFIER'('pos_neg_num')' {$$=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_name($$,$1);
+ _asn1_set_value($$,$3,strlen($3)+1);}
+;
+
+constant_list: constant {$$=$1;}
+ | constant_list ',' constant {$$=$1;
+ _asn1_set_right(_asn1_get_last_right($1),$3);}
+;
+
+identifier_list : IDENTIFIER {$$=_asn1_add_node(TYPE_IDENTIFIER);
+ _asn1_set_name($$,$1);}
+ | identifier_list IDENTIFIER
+ {$$=$1;
+ _asn1_set_right(_asn1_get_last_right($$),_asn1_add_node(TYPE_IDENTIFIER));
+ _asn1_set_name(_asn1_get_last_right($$),$2);}
+;
+
+obj_constant: num_identifier {$$=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_value($$,$1,strlen($1)+1);}
+ | IDENTIFIER'('NUM')' {$$=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_name($$,$1);
+ _asn1_set_value($$,$3,strlen($3)+1);}
+;
+
+obj_constant_list: obj_constant {$$=$1;}
+ | obj_constant_list obj_constant {$$=$1;
+ _asn1_set_right(_asn1_get_last_right($1),$2);}
+;
+
+class : UNIVERSAL {$$=CONST_UNIVERSAL;}
+ | PRIVATE {$$=CONST_PRIVATE;}
+ | APPLICATION {$$=CONST_APPLICATION;}
+;
+
+tag_type : '[' NUM ']' {$$=_asn1_add_node(TYPE_TAG);
+ _asn1_set_value($$,$2,strlen($2)+1);}
+ | '[' class NUM ']' {$$=_asn1_add_node(TYPE_TAG | $2);
+ _asn1_set_value($$,$3,strlen($3)+1);}
+;
+
+tag : tag_type {$$=$1;}
+ | tag_type EXPLICIT {$$=_asn1_mod_type($1,CONST_EXPLICIT);}
+ | tag_type IMPLICIT {$$=_asn1_mod_type($1,CONST_IMPLICIT);}
+;
+
+default : DEFAULT pos_neg_identifier {$$=_asn1_add_node(TYPE_DEFAULT);
+ _asn1_set_value($$,$2,strlen($2)+1);}
+ | DEFAULT TRUE {$$=_asn1_add_node(TYPE_DEFAULT|CONST_TRUE);}
+ | DEFAULT FALSE {$$=_asn1_add_node(TYPE_DEFAULT|CONST_FALSE);}
+;
+
+integer_def: INTEGER {$$=_asn1_add_node(TYPE_INTEGER);}
+ | INTEGER'{'constant_list'}' {$$=_asn1_add_node(TYPE_INTEGER|CONST_LIST);
+ _asn1_set_down($$,$3);}
+ | integer_def'('num_identifier'.''.'num_identifier')'
+ {$$=_asn1_add_node(TYPE_INTEGER|CONST_MIN_MAX);
+ _asn1_set_down($$,_asn1_add_node(TYPE_SIZE));
+ _asn1_set_value(_asn1_get_down($$),$6,strlen($6)+1);
+ _asn1_set_name(_asn1_get_down($$),$3);}
+;
+
+boolean_def: BOOLEAN {$$=_asn1_add_node(TYPE_BOOLEAN);}
+;
+
+Time: UTCTime {$$=_asn1_add_node(TYPE_TIME|CONST_UTC);}
+ | GeneralizedTime {$$=_asn1_add_node(TYPE_TIME|CONST_GENERALIZED);}
+;
+
+size_def2: SIZE'('num_identifier')' {$$=_asn1_add_node(TYPE_SIZE|CONST_1_PARAM);
+ _asn1_set_value($$,$3,strlen($3)+1);}
+ | SIZE'('num_identifier'.''.'num_identifier')'
+ {$$=_asn1_add_node(TYPE_SIZE|CONST_MIN_MAX);
+ _asn1_set_value($$,$3,strlen($3)+1);
+ _asn1_set_name($$,$6);}
+;
+
+size_def: size_def2 {$$=$1;}
+ | '(' size_def2 ')' {$$=$2;}
+;
+
+octet_string_def : OCTET STRING {$$=_asn1_add_node(TYPE_OCTET_STRING);}
+ | OCTET STRING size_def {$$=_asn1_add_node(TYPE_OCTET_STRING|CONST_SIZE);
+ _asn1_set_down($$,$3);}
+;
+
+bit_element : IDENTIFIER'('NUM')' {$$=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_name($$,$1);
+ _asn1_set_value($$,$3,strlen($3)+1);}
+;
+
+bit_element_list : bit_element {$$=$1;}
+ | bit_element_list ',' bit_element {$$=$1;
+ _asn1_set_right(_asn1_get_last_right($1),$3);}
+;
+
+bit_string_def : BIT STRING {$$=_asn1_add_node(TYPE_BIT_STRING);}
+ | BIT STRING'{'bit_element_list'}'
+ {$$=_asn1_add_node(TYPE_BIT_STRING|CONST_LIST);
+ _asn1_set_down($$,$4);}
+;
+
+enumerated_def : ENUMERATED'{'bit_element_list'}'
+ {$$=_asn1_add_node(TYPE_ENUMERATED|CONST_LIST);
+ _asn1_set_down($$,$3);}
+;
+
+object_def : OBJECT STR_IDENTIFIER {$$=_asn1_add_node(TYPE_OBJECT_ID);}
+;
+
+type_assig_right: IDENTIFIER {$$=_asn1_add_node(TYPE_IDENTIFIER);
+ _asn1_set_value($$,$1,strlen($1)+1);}
+ | IDENTIFIER size_def {$$=_asn1_add_node(TYPE_IDENTIFIER|CONST_SIZE);
+ _asn1_set_value($$,$1,strlen($1)+1);
+ _asn1_set_down($$,$2);}
+ | integer_def {$$=$1;}
+ | enumerated_def {$$=$1;}
+ | boolean_def {$$=$1;}
+ | Time
+ | octet_string_def {$$=$1;}
+ | bit_string_def {$$=$1;}
+ | sequence_def {$$=$1;}
+ | object_def {$$=$1;}
+ | choise_def {$$=$1;}
+ | any_def {$$=$1;}
+ | set_def {$$=$1;}
+ | TOKEN_NULL {$$=_asn1_add_node(TYPE_NULL);}
+;
+
+type_assig_right_tag : type_assig_right {$$=$1;}
+ | tag type_assig_right {$$=_asn1_mod_type($2,CONST_TAG);
+ _asn1_set_right($1,_asn1_get_down($$));
+ _asn1_set_down($$,$1);}
+;
+
+type_assig_right_tag_default : type_assig_right_tag {$$=$1;}
+ | type_assig_right_tag default {$$=_asn1_mod_type($1,CONST_DEFAULT);
+ _asn1_set_right($2,_asn1_get_down($$));
+ _asn1_set_down($$,$2);}
+ | type_assig_right_tag OPTIONAL {$$=_asn1_mod_type($1,CONST_OPTION);}
+;
+
+type_assig : IDENTIFIER type_assig_right_tag_default {$$=_asn1_set_name($2,$1);}
+;
+
+type_assig_list : type_assig {$$=$1;}
+ | type_assig_list','type_assig {$$=$1;
+ _asn1_set_right(_asn1_get_last_right($1),$3);}
+;
+
+sequence_def : SEQUENCE'{'type_assig_list'}' {$$=_asn1_add_node(TYPE_SEQUENCE);
+ _asn1_set_down($$,$3);}
+ | SEQUENCE OF type_assig_right {$$=_asn1_add_node(TYPE_SEQUENCE_OF);
+ _asn1_set_down($$,$3);}
+ | SEQUENCE size_def OF type_assig_right {$$=_asn1_add_node(TYPE_SEQUENCE_OF|CONST_SIZE);
+ _asn1_set_right($2,$4);
+ _asn1_set_down($$,$2);}
+;
+
+set_def : SET'{'type_assig_list'}' {$$=_asn1_add_node(TYPE_SET);
+ _asn1_set_down($$,$3);}
+ | SET OF type_assig_right {$$=_asn1_add_node(TYPE_SET_OF);
+ _asn1_set_down($$,$3);}
+ | SET size_def OF type_assig_right {$$=_asn1_add_node(TYPE_SET_OF|CONST_SIZE);
+ _asn1_set_right($2,$4);
+ _asn1_set_down($$,$2);}
+;
+
+choise_def : CHOICE'{'type_assig_list'}' {$$=_asn1_add_node(TYPE_CHOICE);
+ _asn1_set_down($$,$3);}
+;
+
+any_def : ANY {$$=_asn1_add_node(TYPE_ANY);}
+ | ANY DEFINED BY IDENTIFIER {$$=_asn1_add_node(TYPE_ANY|CONST_DEFINED_BY);
+ _asn1_set_down($$,_asn1_add_node(TYPE_CONSTANT));
+ _asn1_set_name(_asn1_get_down($$),$4);}
+;
+
+type_def : IDENTIFIER "::=" type_assig_right_tag {$$=_asn1_set_name($3,$1);}
+;
+
+constant_def : IDENTIFIER OBJECT STR_IDENTIFIER "::=" '{'obj_constant_list'}'
+ {$$=_asn1_add_node(TYPE_OBJECT_ID|CONST_ASSIGN);
+ _asn1_set_name($$,$1);
+ _asn1_set_down($$,$6);}
+ | IDENTIFIER IDENTIFIER "::=" '{' obj_constant_list '}'
+ {$$=_asn1_add_node(TYPE_OBJECT_ID|CONST_ASSIGN|CONST_1_PARAM);
+ _asn1_set_name($$,$1);
+ _asn1_set_value($$,$2,strlen($2)+1);
+ _asn1_set_down($$,$5);}
+ | IDENTIFIER INTEGER "::=" NUM
+ {$$=_asn1_add_node(TYPE_INTEGER|CONST_ASSIGN);
+ _asn1_set_name($$,$1);
+ _asn1_set_value($$,$4,strlen($4)+1);}
+;
+
+type_constant: type_def {$$=$1;}
+ | constant_def {$$=$1;}
+;
+
+type_constant_list : type_constant {$$=$1;}
+ | type_constant_list type_constant {$$=$1;
+ _asn1_set_right(_asn1_get_last_right($1),$2);}
+;
+
+definitions_id : IDENTIFIER '{' obj_constant_list '}' {$$=_asn1_add_node(TYPE_OBJECT_ID);
+ _asn1_set_down($$,$3);
+ _asn1_set_name($$,$1);}
+ | IDENTIFIER '{' '}' {$$=_asn1_add_node(TYPE_OBJECT_ID);
+ _asn1_set_name($$,$1);}
+;
+
+imports_def : /* empty */ {$$=NULL;}
+ | IMPORTS identifier_list FROM IDENTIFIER obj_constant_list
+ {$$=_asn1_add_node(TYPE_IMPORTS);
+ _asn1_set_down($$,_asn1_add_node(TYPE_OBJECT_ID));
+ _asn1_set_name(_asn1_get_down($$),$4);
+ _asn1_set_down(_asn1_get_down($$),$5);
+ _asn1_set_right($$,$2);}
+;
+
+explicit_implicit : EXPLICIT {$$=CONST_EXPLICIT;}
+ | IMPLICIT {$$=CONST_IMPLICIT;}
+;
+
+definitions: definitions_id
+ DEFINITIONS explicit_implicit TAGS "::=" BEGIN imports_def
+ type_constant_list END
+ {$$=_asn1_add_node(TYPE_DEFINITIONS|$3|(($7==NULL)?0:CONST_IMPORTS));
+ _asn1_set_name($$,_asn1_get_name($1));
+ _asn1_set_name($1,"");
+ if($7==NULL) _asn1_set_right($1,$8);
+ else {_asn1_set_right($7,$8);_asn1_set_right($1,$7);}
+ _asn1_set_down($$,$1);
+ if(parse_mode==PARSE_MODE_CREATE){
+ _asn1_set_default_tag($$);
+ _asn1_type_set_config($$);
+ result_parse=_asn1_check_identifier($$);
+ if(result_parse==ASN_IDENTIFIER_NOT_FOUND)
+ asn1_delete_structure($$);
+ else p_tree=$$;
+ }}
+;
+
+%%
+
+
+#include <ctype.h>
+#include <string.h>
+
+const char *key_word[]={"::=","OPTIONAL","INTEGER","SIZE","OCTET","STRING"
+ ,"SEQUENCE","BIT","UNIVERSAL","PRIVATE","OPTIONAL"
+ ,"DEFAULT","CHOICE","OF","OBJECT","IDENTIFIER"
+ ,"BOOLEAN","TRUE","FALSE","APPLICATION","ANY","DEFINED"
+ ,"SET","BY","EXPLICIT","IMPLICIT","DEFINITIONS","TAGS"
+ ,"BEGIN","END","UTCTime","GeneralizedTime","FROM"
+ ,"IMPORTS","NULL","ENUMERATED"};
+const int key_word_token[]={ASSIG,OPTIONAL,INTEGER,SIZE,OCTET,STRING
+ ,SEQUENCE,BIT,UNIVERSAL,PRIVATE,OPTIONAL
+ ,DEFAULT,CHOICE,OF,OBJECT,STR_IDENTIFIER
+ ,BOOLEAN,TRUE,FALSE,APPLICATION,ANY,DEFINED
+ ,SET,BY,EXPLICIT,IMPLICIT,DEFINITIONS,TAGS
+ ,BEGIN,END,UTCTime,GeneralizedTime,FROM
+ ,IMPORTS,TOKEN_NULL,ENUMERATED};
+
+/*************************************************************/
+/* Function: yylex */
+/* Description: looks for tokens in file_asn1 pointer file. */
+/* Return: int */
+/* Token identifier or ASCII code or 0(zero: End Of File) */
+/*************************************************************/
+int
+yylex()
+{
+ int c,counter=0,k;
+ char string[129]; /* will contain the next token */
+ while(1)
+ {
+ while((c=fgetc(file_asn1))==' ' || c=='\t' || c=='\n');
+ if(c==EOF) return 0;
+ if(c=='(' || c==')' || c=='[' || c==']' ||
+ c=='{' || c=='}' || c==',' || c=='.' ||
+ c=='+') return c;
+ if(c=='-'){ /* Maybe the first '-' of a comment */
+ if((c=fgetc(file_asn1))!='-'){
+ ungetc(c,file_asn1);
+ return '-';
+ }
+ else{ /* Comments */
+ counter=0;
+ /* A comment finishes at the end of line */
+ while((c=fgetc(file_asn1))!=EOF && c!='\n');
+ if(c==EOF) return 0;
+ else continue; /* next char, please! (repeat the search) */
+ }
+ }
+ string[counter++]=c;
+ /* Till the end of the token */
+ while(!((c=fgetc(file_asn1))==EOF || c==' '|| c=='\t' || c=='\n' ||
+ c=='(' || c==')' || c=='[' || c==']' ||
+ c=='{' || c=='}' || c==',' || c=='.'))
+ {
+ string[counter++]=c;
+ }
+ ungetc(c,file_asn1);
+ string[counter]=0;
+
+ /* Is STRING a number? */
+ for(k=0;k<counter;k++)
+ if(!isdigit(string[k])) break;
+ if(k>=counter)
+ {
+ strcpy(yylval.str,string);
+ return NUM; /* return the number */
+ }
+
+ /* Is STRING a keyword? */
+ for(k=0;k<(sizeof(key_word)/sizeof(char*));k++)
+ if(!strcmp(string,key_word[k])) return key_word_token[k];
+
+ /* STRING is an IDENTIFIER */
+ strcpy(yylval.str,string);
+ return IDENTIFIER;
+ }
+}
+
+
+/**
+ * asn1_parser_asn1 - function used to start the parse algorithm.
+ * @file_name: specify the path and the name of file that contains ASN.1 declarations.
+ * @pointer: return the pointer to the structure created from
+ * "file_name" ASN.1 declarations.
+ * Description:
+ *
+ * Creates the structures needed to manage the definitions included in *FILE_NAME file.
+ *
+ * Returns:
+ *
+ * ASN_OK\: the file has a correct syntax and every identifier is known.
+ *
+ * ASN_FILE_NOT_FOUND\: an error occured while opening FILE_NAME.
+ *
+ * ASN_SYNTAX_ERROR\: the syntax is not correct.
+ *
+ * ASN_IDENTIFIER_NOT_FOUND\: in the file there is an identifier that is not defined.
+ **/
+int asn1_parser_asn1(char *file_name,node_asn **pointer){
+ p_tree=NULL;
+ *pointer=NULL;
+
+ /* open the file to parse */
+ file_asn1=fopen(file_name,"r");
+ if(file_asn1==NULL) return ASN_FILE_NOT_FOUND;
+
+ result_parse=ASN_OK;
+
+ /* only syntax check */
+ parse_mode=PARSE_MODE_CHECK;
+ yyparse();
+
+ if(result_parse==ASN_OK){ /* syntax OK */
+ fclose(file_asn1);
+ file_asn1=fopen(file_name,"r");
+
+ /* structure creation */
+ parse_mode=PARSE_MODE_CREATE;
+ yyparse();
+
+ _asn1_change_integer_value(p_tree);
+ _asn1_expand_object_id(p_tree);
+ }
+
+ fclose(file_asn1);
+
+ parse_mode=PARSE_MODE_CREATE;
+
+ *pointer=p_tree;
+
+ return result_parse;
+}
+
+
+/**
+ * asn1_parser_asn1_file_c - function that generates a C structure from an ASN1 file
+ * @file_name: specify the path and the name of file that contains ASN.1 declarations.
+ * Description:
+ *
+ * Creates a file containing a C vector to use to manage the definitions included in
+ * *FILE_NAME file. If *FILE_NAME is "/aa/bb/xx.yy" the file created is "/aa/bb/xx_asn1_tab.c",
+ * and the vector is "xx_asn1_tab".
+ *
+ * Returns:
+ *
+ * ASN_OK\: the file has a correct syntax and every identifier is known.
+ *
+ * ASN_FILE_NOT_FOUND\: an error occured while opening FILE_NAME.
+ *
+ * ASN_SYNTAX_ERROR\: the syntax is not correct.
+ *
+ * ASN_IDENTIFIER_NOT_FOUND\: in the file there is an identifier that is not defined.
+ **/
+int asn1_parser_asn1_file_c(char *file_name){
+ int result;
+
+ p_tree=NULL;
+
+ /* open the file to parse */
+ file_asn1=fopen(file_name,"r");
+ if(file_asn1==NULL) return ASN_FILE_NOT_FOUND;
+
+ result_parse=ASN_OK;
+
+ /* syntax check */
+ parse_mode=PARSE_MODE_CHECK;
+ yyparse();
+
+ if(result_parse==ASN_OK){ /* syntax OK */
+ fclose(file_asn1);
+ file_asn1=fopen(file_name,"r");
+
+ /* structure creation */
+ parse_mode=PARSE_MODE_CREATE;
+ yyparse();
+
+ /* structure saved in a file */
+ result=_asn1_create_static_structure(p_tree,file_name,NULL);
+
+ /* delete structure in memory */
+ asn1_delete_structure(p_tree);
+ }
+
+ fclose(file_asn1);
+
+ parse_mode=PARSE_MODE_CREATE;
+
+ return result_parse;
+}
+
+
+/*************************************************************/
+/* Function: yyerror */
+/* Description: function called when there are syntax errors*/
+/* Parameters: */
+/* char *s : error description */
+/* Return: int */
+/* */
+/*************************************************************/
+int yyerror (char *s)
+{
+ /* Sends the error description to the std_out */
+ /* printf("%s\n",s); */
+ result_parse=ASN_SYNTAX_ERROR;
+ return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+include_HEADERS = asn1.h
+
+EXTRA_DIST = asn1.h der.h asn1-api.tex mem.h gstr.h
+
+lib_LTLIBRARIES = libasn1.la
+
+# Separate so we can create the documentation
+COBJECTS = ASN.y asn1.c der.c gstr.c
+
+libasn1_la_SOURCES = $(COBJECTS)
+
+libasn1_la_LDFLAGS = -version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
+
+asn1-api.tex: $(COBJECTS)
+ @echo "\\newpage" > asn1-api.tex
+ @echo "\\section{ASN.1 parser function reference}" >> asn1-api.tex
+ @for i in $(COBJECTS); \
+ do echo -n "Creating documentation for file $$i... " && ../doc/scripts/gdoc -tex $$i >> asn1-api.tex \
+ && echo "ok"; \
+ done
+
+all-local: asn1-api.tex
--- /dev/null
+/*
+ * Copyright (C) 2000,2001 Fabio Fiorina
+ *
+ * This file is part of GNUTLS.
+ *
+ * GNUTLS 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.
+ *
+ * GNUTLS 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+/*****************************************************/
+/* File: x509_asn1.c */
+/* Description: Functions to manage ASN.1 DEFINITIONS*/
+/*****************************************************/
+
+
+#include <defines.h>
+#include "asn1.h"
+#include "der.h"
+#include <gstr.h>
+
+/* define used for visiting trees */
+#define UP 1
+#define RIGHT 2
+#define DOWN 3
+
+
+int parse_mode; /* PARSE_MODE_CHECK = only syntax check
+ PARSE_MODE_CREATE = structure creation */
+
+
+/******************************************************/
+/* Function : _asn1_add_node */
+/* Description: creates a new NODE_ASN element. */
+/* Parameters: */
+/* type: type of the new element (see TYPE_ */
+/* and CONST_ constants). */
+/* Return: pointer to the new element. */
+/******************************************************/
+node_asn *
+_asn1_add_node(unsigned int type)
+{
+ node_asn *punt;
+
+ if(parse_mode==PARSE_MODE_CHECK) return NULL;
+
+ punt=(node_asn *) _asn1_malloc(sizeof(node_asn));
+ if (punt==NULL) return NULL;
+
+ punt->left=NULL;
+ punt->name=NULL;
+ punt->type=type;
+ punt->value=NULL;
+ punt->down=NULL;
+ punt->right=NULL;
+
+ return punt;
+}
+
+/******************************************************************/
+/* Function : _asn1_set_value */
+/* Description: sets the field VALUE in a NODE_ASN element. The */
+/* previus value (if exist) will be lost */
+/* Parameters: */
+/* node: element pointer. */
+/* value: pointer to the value that you want to set. */
+/* len: character number of value. */
+/* Return: pointer to the NODE_ASN element. */
+/******************************************************************/
+node_asn *
+_asn1_set_value(node_asn *node,unsigned char *value,unsigned int len)
+{
+ if(parse_mode==PARSE_MODE_CHECK) return NULL;
+
+ if(node==NULL) return node;
+ if(node->value){
+ _asn1_free(node->value);
+ node->value=NULL;
+ }
+ if(!len) return node;
+ node->value=(unsigned char *) _asn1_malloc(len);
+ if (node->value==NULL) return NULL;
+
+ memcpy(node->value,value,len);
+ return node;
+}
+
+/******************************************************************/
+/* Function : _asn1_set_name */
+/* Description: sets the field NAME in a NODE_ASN element. The */
+/* previus value (if exist) will be lost */
+/* Parameters: */
+/* node: element pointer. */
+/* name: a null terminated string with the name that you want */
+/* to set. */
+/* Return: pointer to the NODE_ASN element. */
+/******************************************************************/
+node_asn *
+_asn1_set_name(node_asn *node,char *name)
+{
+ if(parse_mode==PARSE_MODE_CHECK) return NULL;
+
+ if(node==NULL) return node;
+
+ if(node->name){
+ _asn1_free(node->name);
+ node->name=NULL;
+ }
+
+ if(name==NULL) return node;
+
+ if(strlen(name))
+ {
+ node->name=(char *) _asn1_strdup( name);
+ if (node->name==NULL) return NULL;
+ }
+ else node->name=NULL;
+ return node;
+}
+
+/******************************************************************/
+/* Function : _asn1_set_right */
+/* Description: sets the field RIGHT in a NODE_ASN element. */
+/* Parameters: */
+/* node: element pointer. */
+/* right: pointer to a NODE_ASN element that you want be pointed*/
+/* by NODE. */
+/* Return: pointer to *NODE. */
+/******************************************************************/
+node_asn *
+_asn1_set_right(node_asn *node,node_asn *right)
+{
+ if(parse_mode==PARSE_MODE_CHECK) return NULL;
+
+ if(node==NULL) return node;
+ node->right=right;
+ if(right) right->left=node;
+ return node;
+}
+
+/******************************************************************/
+/* Function : _asn1_get_right */
+/* Description: returns the element pointed by the RIGHT field of */
+/* a NODE_ASN element. */
+/* Parameters: */
+/* node: NODE_ASN element pointer. */
+/* Return: field RIGHT of NODE. */
+/******************************************************************/
+node_asn *
+_asn1_get_right(node_asn *node)
+{
+ if(parse_mode==PARSE_MODE_CHECK) return NULL;
+
+ if(node==NULL) return NULL;
+ return node->right;
+}
+
+/******************************************************************/
+/* Function : _asn1_get_last_right */
+/* Description: return the last element along the right chain. */
+/* Parameters: */
+/* node: starting element pointer. */
+/* Return: pointer to the last element along the right chain. */
+/******************************************************************/
+node_asn *
+_asn1_get_last_right(node_asn *node)
+{
+ node_asn *p;
+
+ if(parse_mode==PARSE_MODE_CHECK) return NULL;
+ if(node==NULL) return NULL;
+ p=node;
+ while(p->right) p=p->right;
+ return p;
+}
+
+/******************************************************************/
+/* Function : _asn1_set_down */
+/* Description: sets the field DOWN in a NODE_ASN element. */
+/* Parameters: */
+/* node: element pointer. */
+/* down: pointer to a NODE_ASN element that you want be pointed */
+/* by NODE. */
+/* Return: pointer to *NODE. */
+/******************************************************************/
+node_asn *
+_asn1_set_down(node_asn *node,node_asn *down)
+{
+ if(parse_mode==PARSE_MODE_CHECK) return NULL;
+
+ if(node==NULL) return node;
+ node->down=down;
+ if(down) down->left=node;
+ return node;
+}
+
+/******************************************************************/
+/* Function : _asn1_get_down */
+/* Description: returns the element pointed by the DOWN field of */
+/* a NODE_ASN element. */
+/* Parameters: */
+/* node: NODE_ASN element pointer. */
+/* Return: field DOWN of NODE. */
+/******************************************************************/
+node_asn *
+_asn1_get_down(node_asn *node)
+{
+ if(parse_mode==PARSE_MODE_CHECK) return NULL;
+
+ if(node==NULL) return NULL;
+ return node->down;
+}
+
+/******************************************************************/
+/* Function : _asn1_get_name */
+/* Description: returns the name of a NODE_ASN element. */
+/* Parameters: */
+/* node: NODE_ASN element pointer. */
+/* Return: a null terminated string. */
+/******************************************************************/
+char *
+_asn1_get_name(node_asn *node)
+{
+ if(parse_mode==PARSE_MODE_CHECK) return NULL;
+
+ if(node==NULL) return NULL;
+ return node->name;
+}
+
+/******************************************************************/
+/* Function : _asn1_mod_type */
+/* Description: change the field TYPE of an NODE_ASN element. */
+/* The new value is the old one | (bitwise or) the */
+/* paramener VALUE. */
+/* Parameters: */
+/* node: NODE_ASN element pointer. */
+/* value: the integer value that must be or-ed with the current */
+/* value of field TYPE. */
+/* Return: NODE pointer. */
+/******************************************************************/
+node_asn *
+_asn1_mod_type(node_asn *node,unsigned int value)
+{
+ if(parse_mode==PARSE_MODE_CHECK) return NULL;
+
+ if(node==NULL) return node;
+ node->type|=value;
+ return node;
+}
+
+/******************************************************************/
+/* Function : _asn1_remove_node */
+/* Description: gets free the memory allocated for an NODE_ASN */
+/* element (not the elements pointed by it). */
+/* Parameters: */
+/* node: NODE_ASN element pointer. */
+/******************************************************************/
+void
+_asn1_remove_node(node_asn *node)
+{
+ if(node==NULL) return;
+
+ if (node->name!=NULL)
+ _asn1_free(node->name);
+ if (node->value!=NULL)
+ _asn1_free(node->value);
+ _asn1_free(node);
+}
+
+
+/******************************************************************/
+/* Function : _asn1_find_mode */
+/* Description: searches an element called NAME starting from */
+/* POINTER. The name is composed by differents */
+/* identifiers separated by dot.The first identifier */
+/* must be the name of *POINTER. */
+/* Parameters: */
+/* pointer: NODE_ASN element pointer. */
+/* name: null terminated string with the element's name to find.*/
+/* Return: the searching result. NULL if not find. */
+/******************************************************************/
+node_asn *
+_asn1_find_node(node_asn *pointer,char *name)
+{
+ node_asn *p;
+ char *n_start,*n_end,n[128];
+
+ if((name==NULL) || (name[0]==0)) return NULL;
+
+ n_start=name;
+ n_end=strchr(n_start,'.'); /* search the first dot */
+ if(n_end){
+ memcpy(n,n_start,n_end-n_start);
+ n[n_end-n_start]=0;
+ n_start=n_end;
+ n_start++;
+ }
+ else{
+ _asn1_str_cpy(n,sizeof(n),n_start);
+ n_start=NULL;
+ }
+
+ p=pointer;
+ while(p){
+ if((p->name) && (!strcmp(p->name,n))) break;
+ else p=p->right;
+ } /* while */
+
+ if(p==NULL) return NULL;
+
+ while(n_start){ /* Has the end of NAME been reached? */
+ n_end=strchr(n_start,'.'); /* search the next dot */
+ if(n_end){
+ memcpy(n,n_start,n_end-n_start);
+ n[n_end-n_start]=0;
+ n_start=n_end;
+ n_start++;
+ }
+ else{
+ _asn1_str_cpy(n,sizeof(n),n_start);
+ n_start=NULL;
+ }
+
+ if(p->down==NULL) return NULL;
+
+ p=p->down;
+
+ /* The identifier "?LAST" indicates the last element
+ in the right chain. */
+ if(!strcmp(n,"?LAST")){
+ if(p==NULL) return NULL;
+ while(p->right) p=p->right;
+ }
+ else{ /* no "?LAST" */
+ while(p){
+ if((p->name) && (!strcmp(p->name,n))) break;
+ else p=p->right;
+ }
+ if(p==NULL) return NULL;
+ }
+ } /* while */
+
+ return p;
+}
+
+/******************************************************************/
+/* Function : _asn1_find_left */
+/* Description: returns the NODE_ASN element with RIGHT field that*/
+/* points the element NODE. */
+/* Parameters: */
+/* node: NODE_ASN element pointer. */
+/* Return: NULL if not found. */
+/******************************************************************/
+node_asn *
+_asn1_find_left(node_asn *node)
+{
+ if((node==NULL) || (node->left==NULL) ||
+ (node->left->down==node)) return NULL;
+
+ return node->left;
+}
+
+/******************************************************************/
+/* Function : _asn1_find_up */
+/* Description: return the father of the NODE_ASN element. */
+/* Parameters: */
+/* node: NODE_ASN element pointer. */
+/* Return: Null if not found. */
+/******************************************************************/
+node_asn *
+_asn1_find_up(node_asn *node)
+{
+ node_asn *p;
+
+ if(node==NULL) return NULL;
+
+ p=node;
+
+ while((p->left!=NULL) && (p->left->right==p)) p=p->left;
+
+ return p->left;
+}
+
+/******************************************************************/
+/* Function : _asn1_convert_integer */
+/* Description: converts an integer from a null terminated string */
+/* to der decoding. The convertion from a null */
+/* terminated string to an integer is made with */
+/* the 'strtol' function. */
+/* Parameters: */
+/* value: null terminated string to convert. */
+/* value_out: convertion result (memory must be already */
+/* allocated). */
+/* value_out_size: number of bytes of value_out. */
+/* len: number of significant byte of value_out. */
+/* Return: ASN_MEM_ERROR or ASN_OK */
+/******************************************************************/
+int
+_asn1_convert_integer(char *value,unsigned char *value_out,int value_out_size, int *len)
+{
+ char negative;
+ unsigned char val[4],temp;
+ int k,k2;
+
+ *((long*)val)=strtol(value,NULL,10);
+ for(k=0;k<2;k++){
+ temp=val[k];
+ val[k]=val[3-k];
+ val[3-k]=temp;
+ }
+
+ if(val[0]&0x80) negative=1;
+ else negative=0;
+
+ for(k=0;k<3;k++){
+ if(negative && (val[k]!=0xFF)) break;
+ else if(!negative && val[k]) break;
+ }
+
+ if((negative && !(val[k]&0x80)) ||
+ (!negative && (val[k]&0x80))) k--;
+
+ for(k2=k;k2<4;k2++) {
+ if (k2-k > value_out_size-1) {
+ return ASN_MEM_ERROR;
+ }
+ /* VALUE_OUT is too short to contain the value convertion */
+ value_out[k2-k]=val[k2];
+ }
+ *len=4-k;
+
+ return ASN_OK;
+}
+
+/**
+ * asn1_create_tree - Creates the structures needed to manage the ASN1 definitions.
+ * @root: specify vector that contains ASN.1 declarations
+ * @pointer: return the pointer to the structure created by *ROOT ASN.1 declarations
+ * Description:
+ *
+ * Creates the structures needed to manage the ASN1 definitions. ROOT is a vector created by
+ * 'asn1_parser_asn1_file_c' function.
+ *
+ * Returns:
+ *
+ * ASN_OK\: structure created correctly.
+ *
+ * ASN_GENERIC_ERROR\: an error occured while structure creation
+ **/
+int
+asn1_create_tree(const static_asn *root,node_asn **pointer)
+{
+ node_asn *p,*p_last;
+ unsigned long k;
+ int move;
+
+ *pointer=NULL;
+ move=UP;
+
+ k=0;
+ while(root[k].value || root[k].type || root[k].name){
+ p=_asn1_add_node(root[k].type&(~CONST_DOWN));
+ if(root[k].name) _asn1_set_name(p,root[k].name);
+ if(root[k].value) _asn1_set_value(p,root[k].value,strlen(root[k].value)+1);
+
+ if(*pointer==NULL) *pointer=p;
+
+ if(move==DOWN) _asn1_set_down(p_last,p);
+ else if(move==RIGHT) _asn1_set_right(p_last,p);
+
+ p_last=p;
+
+ if(root[k].type&CONST_DOWN) move=DOWN;
+ else if(root[k].type&CONST_RIGHT) move=RIGHT;
+ else{
+ while(1){
+ if(p_last==*pointer) break;
+
+ p_last= _asn1_find_up(p_last);
+
+ if(p_last==NULL) break;
+
+ if(p_last->type&CONST_RIGHT){
+ p_last->type&=~CONST_RIGHT;
+ move=RIGHT;
+ break;
+ }
+ } /* while */
+ }
+ k++;
+ } /* while */
+
+ if(p_last==*pointer){
+ _asn1_change_integer_value(*pointer);
+ _asn1_expand_object_id(*pointer);
+ }
+ else asn1_delete_structure(*pointer);
+
+ return (p_last==*pointer)?ASN_OK:ASN_GENERIC_ERROR;
+}
+
+
+int
+_asn1_create_static_structure(node_asn *pointer,char *file_name, char* out_name)
+{
+ FILE *file;
+ node_asn *p;
+ unsigned long t;
+ char structure_name[128],file_out_name[128],*char_p,*slash_p,*dot_p;
+
+ char_p=file_name;
+ slash_p=file_name;
+ while((char_p=strchr(char_p,'/'))){
+ char_p++;
+ slash_p=char_p;
+ }
+
+ char_p=slash_p;
+ dot_p=file_name+strlen(file_name);
+
+ while((char_p=strchr(char_p,'.'))){
+ dot_p=char_p;
+ char_p++;
+ }
+
+ memcpy(structure_name,slash_p,dot_p-slash_p);
+ structure_name[dot_p-slash_p]=0;
+ _asn1_str_cat(structure_name, sizeof(structure_name),"_asn1_tab");
+
+ if (out_name==NULL) {
+ memcpy(file_out_name,file_name,dot_p-file_name);
+ file_out_name[dot_p-file_name]=0;
+ _asn1_str_cat(file_out_name, sizeof(file_out_name), "_asn1_tab.c");
+ } else {
+ _asn1_str_cpy( file_out_name, sizeof(file_out_name), out_name);
+ }
+ file=fopen( file_out_name,"w");
+
+ if(file==NULL) return ASN_FILE_NOT_FOUND;
+
+ fprintf(file,"\n#include \"asn1.h\"\n\n");
+ fprintf(file,"const static_asn %s[]={\n",structure_name);
+
+ p=pointer;
+
+ while(p){
+ fprintf(file," {");
+
+ if(p->name) fprintf(file,"\"%s\",",p->name);
+ else fprintf(file,"0,");
+
+ t=p->type;
+ if(p->down) t|=CONST_DOWN;
+ if(p->right) t|=CONST_RIGHT;
+
+ fprintf(file,"%lu,",t);
+
+ if(p->value) fprintf(file,"\"%s\"},\n",p->value);
+ else fprintf(file,"0},\n");
+
+ if(p->down){
+ p=p->down;
+ }
+ else if(p->right){
+ p=p->right;
+ }
+ else{
+ while(1){
+ p=_asn1_find_up(p);
+ if(p==pointer){
+ p=NULL;
+ break;
+ }
+ if(p->right){
+ p=p->right;
+ break;
+ }
+ }
+ }
+ }
+
+ fprintf(file," {0,0,0}\n};\n");
+
+ fclose(file);
+
+ return ASN_OK;
+}
+
+
+/**
+ * asn1_visit_tree - Prints on the standard output the structure's tree
+ * @pointer: pointer to the structure that you want to delete.
+ * @name: an element of the structure
+ *
+ * Prints on the standard output the structure's tree starting from the NAME element inside
+ * the structure *POINTER.
+ **/
+void
+asn1_visit_tree(node_asn *pointer,char *name)
+{
+ node_asn *p,*root;
+ int k,indent=0,len,len2,len3;
+
+ root=_asn1_find_node(pointer,name);
+
+ if(root==NULL) return;
+
+ p=root;
+ while(p){
+ for(k=0;k<indent;k++)printf(" ");
+
+ printf("name:");
+ if(p->name) printf("%s ",p->name);
+ else printf("NULL ");
+
+ printf("type:");
+ switch(type_field(p->type)){
+ case TYPE_NULL:
+ printf("NULL");
+ break;
+ case TYPE_CONSTANT:
+ printf("CONST");
+ if(p->value) printf(" value:%s",p->value);
+ break;
+ case TYPE_IDENTIFIER:
+ printf("IDENTIFIER");
+ if(p->value) printf(" value:%s",p->value);
+ break;
+ case TYPE_INTEGER:
+ printf("INTEGER");
+ if(p->value){
+ len2=-1;
+ len=_asn1_get_length_der(p->value,&len2);
+ printf(" value:0x");
+ for(k=0;k<len;k++) printf("%02x",(p->value)[k+len2]);
+ }
+ break;
+ case TYPE_ENUMERATED:
+ printf("ENUMERATED");
+ if(p->value){
+ len2=-1;
+ len=_asn1_get_length_der(p->value,&len2);
+ printf(" value:0x");
+ for(k=0;k<len;k++) printf("%02x",(p->value)[k+len2]);
+ }
+ break;
+ case TYPE_TIME:
+ printf("TIME");
+ if(p->value) printf(" value:%s",p->value);
+ break;
+ case TYPE_BOOLEAN:
+ printf("BOOLEAN");
+ if(p->value){
+ if(p->value[0]=='T') printf(" value:TRUE");
+ else if(p->value[0]=='F') printf(" value:FALSE");
+ }
+ break;
+ case TYPE_SEQUENCE:
+ printf("SEQUENCE");
+ break;
+ case TYPE_BIT_STRING:
+ printf("BIT_STR");
+ if(p->value){
+ len2=-1;
+ len=_asn1_get_length_der(p->value,&len2);
+ printf(" value(%i):",(len-1)*8-(p->value[len2]));
+ for(k=1;k<len;k++) printf("%02x",(p->value)[k+len2]);
+ }
+ break;
+ case TYPE_OCTET_STRING:
+ printf("OCT_STR");
+ if(p->value){
+ len2=-1;
+ len=_asn1_get_length_der(p->value,&len2);
+ printf(" value:");
+ for(k=0;k<len;k++) printf("%02x",(p->value)[k+len2]);
+ }
+ break;
+ case TYPE_TAG:
+ printf("TAG");
+ printf(" value:%s",p->value);
+ break;
+ case TYPE_DEFAULT:
+ printf("DEFAULT");
+ if(p->value) printf(" value:%s",p->value);
+ break;
+ case TYPE_SIZE:
+ printf("SIZE");
+ if(p->value) printf(" value:%s",p->value);
+ break;
+ case TYPE_SEQUENCE_OF:
+ printf("SEQ_OF");
+ break;
+ case TYPE_OBJECT_ID:
+ printf("OBJ_ID");
+ if(p->value) printf(" value:%s",p->value);
+ break;
+ case TYPE_ANY:
+ printf("ANY");
+ if(p->value){
+ len3=-1;
+ len2=_asn1_get_length_der(p->value,&len3);
+ printf(" value:");
+ for(k=0;k<len2;k++) printf("%02x",(p->value)[k+len3]);
+ }
+
+ break;
+ case TYPE_SET:
+ printf("SET");
+ break;
+ case TYPE_SET_OF:
+ printf("SET_OF");
+ break;
+ case TYPE_CHOICE:
+ printf("CHOICE");
+ break;
+ case TYPE_DEFINITIONS:
+ printf("DEFINITIONS");
+ break;
+ default:
+ printf("ERROR\n");
+ break;
+ }
+
+ if(p->type&0xFFFFFF00){
+ printf(" attr:");
+ if(p->type & CONST_UNIVERSAL) printf("UNIVERSAL,");
+ if(p->type & CONST_PRIVATE) printf("PRIVATE,");
+ if(p->type & CONST_APPLICATION) printf("APPLICATION,");
+ if(p->type & CONST_EXPLICIT) printf("EXPLICIT,");
+ if(p->type & CONST_IMPLICIT) printf("IMPLICIT,");
+ if(p->type & CONST_TAG) printf("TAG,");
+ if(p->type & CONST_DEFAULT) printf("DEFAULT,");
+ if(p->type & CONST_TRUE) printf("TRUE,");
+ if(p->type & CONST_FALSE) printf("FALSE,");
+ if(p->type & CONST_LIST) printf("LIST,");
+ if(p->type & CONST_MIN_MAX) printf("MIN_MAX,");
+ if(p->type & CONST_OPTION) printf("OPTION,");
+ if(p->type & CONST_1_PARAM) printf("1_PARAM,");
+ if(p->type & CONST_SIZE) printf("SIZE,");
+ if(p->type & CONST_DEFINED_BY) printf("DEF_BY,");
+ if(p->type & CONST_GENERALIZED) printf("GENERALIZED,");
+ if(p->type & CONST_UTC) printf("UTC,");
+ if(p->type & CONST_IMPORTS) printf("IMPORTS,");
+ if(p->type & CONST_SET) printf("SET,");
+ if(p->type & CONST_NOT_USED) printf("NOT_USED,");
+ if(p->type & CONST_ASSIGN) printf("ASSIGNEMENT,");
+ }
+
+ printf("\n");
+
+ if(p->down){
+ p=p->down;
+ indent+=2;
+ }
+ else if(p==root){
+ p=NULL;
+ break;
+ }
+ else if(p->right) p=p->right;
+ else{
+ while(1){
+ p=_asn1_find_up(p);
+ if(p==root){
+ p=NULL;
+ break;
+ }
+ indent-=2;
+ if(p->right){
+ p=p->right;
+ break;
+ }
+ }
+ }
+ }
+}
+
+
+/**
+ * asn1_delete_structure - Deletes the structure *POINTER.
+ * @root: pointer to the structure that you want to delete.
+ * Description:
+ *
+ * Deletes the structure *POINTER.
+ *
+ * Returns:
+ *
+ * ASN_OK\: everything OK
+ *
+ * ASN_ELEMENT_NOT_FOUND\: pointer==NULL.
+ *
+ **/
+int
+asn1_delete_structure(node_asn *root)
+{
+ node_asn *p,*p2,*p3;
+
+ if(root==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ p=root;
+ while(p){
+ if(p->down){
+ p=p->down;
+ }
+ else{ /* no down */
+ p2=p->right;
+ if(p!=root){
+ p3=_asn1_find_up(p);
+ _asn1_set_down(p3,p2);
+ _asn1_remove_node(p);
+ p=p3;
+ }
+ else{ /* p==root */
+ p3=_asn1_find_left(p);
+ if(!p3){
+ p3=_asn1_find_up(p);
+ if(p3) _asn1_set_down(p3,p2);
+ else{
+ if(p->right) p->right->left=NULL;
+ }
+ }
+ else _asn1_set_right(p3,p2);
+ _asn1_remove_node(p);
+ p=NULL;
+ }
+ }
+ }
+ return ASN_OK;
+}
+
+
+node_asn *
+_asn1_copy_structure3(node_asn *source_node)
+{
+ node_asn *dest_node,*p_s,*p_d,*p_d_prev;
+ int len,len2,move;
+
+ if(source_node==NULL) return NULL;
+
+ dest_node=_asn1_add_node(source_node->type);
+
+ p_s=source_node;
+ p_d=dest_node;
+
+ move=DOWN;
+
+ do{
+ if(move!=UP){
+ if(p_s->name) _asn1_set_name(p_d,p_s->name);
+ if(p_s->value){
+ switch(type_field(p_s->type)){
+ case TYPE_OCTET_STRING: case TYPE_BIT_STRING:
+ case TYPE_INTEGER: // case TYPE_DEFAULT:
+ len2=-1;
+ len=_asn1_get_length_der(p_s->value,&len2);
+ _asn1_set_value(p_d,p_s->value,len+len2);
+ break;
+ default:
+ _asn1_set_value(p_d,p_s->value,strlen(p_s->value)+1);
+ }
+ }
+ move=DOWN;
+ }
+ else move=RIGHT;
+
+ if(move==DOWN){
+ if(p_s->down){
+ p_s=p_s->down;
+ p_d_prev=p_d;
+ p_d=_asn1_add_node(p_s->type);
+ _asn1_set_down(p_d_prev,p_d);
+ }
+ else move=RIGHT;
+ }
+
+ if(p_s==source_node) break;
+
+ if(move==RIGHT){
+ if(p_s->right){
+ p_s=p_s->right;
+ p_d_prev=p_d;
+ p_d=_asn1_add_node(p_s->type);
+ _asn1_set_right(p_d_prev,p_d);
+ }
+ else move=UP;
+ }
+ if(move==UP){
+ p_s=_asn1_find_up(p_s);
+ p_d=_asn1_find_up(p_d);
+ }
+ }while(p_s!=source_node);
+
+ return dest_node;
+}
+
+
+node_asn *
+_asn1_copy_structure2(node_asn *root,char *source_name)
+{
+ node_asn *source_node;
+
+ source_node=_asn1_find_node(root,source_name);
+
+ return _asn1_copy_structure3(source_node);
+
+}
+
+
+/**
+ * asn1_create_structure - Creates a structure called DEST_NAME of type SOURCE_NAME.
+ * @root: pointer to the structure returned by "parser_asn1" function
+ * @source_name: the name of the type of the new structure (must be inside p_structure).
+ * @pointer: pointer to the structure created.
+ * @dest_name: the name of the new structure.
+ * Description:
+ *
+ * Creates a structure called DEST_NAME of type SOURCE_NAME.
+ *
+ * Returns:
+ *
+ * ASN_OK\: creation OK
+ *
+ * ASN_ELEMENT_NOT_FOUND\: SOURCE_NAME isn't known
+ *
+ * Example: using "pkix.asn"
+ * result=asn1_create_structure(cert_def,"PKIX1.Certificate",&cert,"certificate1");
+ **/
+int
+asn1_create_structure(node_asn *root,char *source_name,node_asn **pointer,char *dest_name)
+{
+ node_asn *dest_node;
+ int res;
+ char *end,n[129];
+
+ *pointer=NULL;
+
+ dest_node=_asn1_copy_structure2(root,source_name);
+
+ if(dest_node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ _asn1_set_name(dest_node,dest_name);
+
+ end=strchr(source_name,'.');
+ if(end){
+ memcpy(n,source_name,end-source_name);
+ n[end-source_name]=0;
+ }
+ else{
+ _asn1_str_cpy(n,sizeof(n),source_name);
+ }
+
+ res=_asn1_expand_identifier(&dest_node,root);
+ _asn1_type_choice_config(dest_node);
+
+ *pointer=dest_node;
+
+ return res;
+}
+
+
+int
+_asn1_append_sequence_set(node_asn *node)
+{
+ node_asn *p,*p2;
+ char temp[10];
+ long n;
+
+ if(!node || !(node->down)) return ASN_GENERIC_ERROR;
+
+ p=node->down;
+ while((type_field(p->type)==TYPE_TAG) || (type_field(p->type)==TYPE_SIZE)) p=p->right;
+ p2=_asn1_copy_structure3(p);
+ while(p->right) p=p->right;
+ _asn1_set_right(p,p2);
+
+ if(p->name==NULL) _asn1_str_cpy(temp,sizeof(temp),"?1");
+ else{
+ n=strtol(p->name+1,NULL,0);
+ n++;
+ temp[0]='?';
+ _asn1_ltostr(n,temp+1);
+ }
+ _asn1_set_name(p2,temp);
+
+ return ASN_OK;
+}
+
+
+/**
+ * asn1_write_value - Set the value of one element inside a structure.
+ * @node_root: pointer to a structure
+ * @name: the name of the element inside the structure that you want to set.
+ * @value: vector used to specify the value to set. If len is >0,
+ * VALUE must be a two's complement form integer.
+ * if len=0 *VALUE must be a null terminated string with an integer value.
+ * @len: number of bytes of *value to use to set the value: value[0]..value[len-1]
+ * or 0 if value is a null terminated string
+ * Description:
+ *
+ * Set the value of one element inside a structure.
+ *
+ * Returns:
+ *
+ * ASN_OK\: set value OK
+ *
+ * ASN_ELEMENT_NOT_FOUND\: NAME is not a valid element.
+ *
+ * ASN_VALUE_NOT_VALID\: VALUE has a wrong format.
+ *
+ * Examples:
+ * description for each type
+ * INTEGER: VALUE must contain a two's complement form integer.
+ * value[0]=0xFF , len=1 -> integer=-1
+ * value[0]=0xFF value[1]=0xFF , len=2 -> integer=-1
+ * value[0]=0x01 , len=1 -> integer= 1
+ * value[0]=0x00 value[1]=0x01 , len=2 -> integer= 1
+ * value="123" , len=0 -> integer= 123
+ * ENUMERATED: as INTEGER (but only with not negative numbers)
+ * BOOLEAN: VALUE must be the null terminated string "TRUE" or "FALSE" and LEN != 0
+ * value="TRUE" , len=1 -> boolean=TRUE
+ * value="FALSE" , len=1 -> boolean=FALSE
+ * OBJECT IDENTIFIER: VALUE must be a null terminated string with each number separated by
+ * a blank (e.g. "1 2 3 543 1").
+ * LEN != 0
+ * value="1 2 840 10040 4 3" , len=1 -> OID=dsa-with-sha
+ * UTCTime: VALUE must be a null terminated string in one of these formats:
+ * "YYMMDDhhmmssZ" "YYMMDDhhmmssZ" "YYMMDDhhmmss+hh'mm'" "YYMMDDhhmmss-hh'mm'"
+ * "YYMMDDhhmm+hh'mm'" "YYMMDDhhmm-hh'mm'".
+ * LEN != 0
+ * value="9801011200Z" , len=1 -> time=Jannuary 1st, 1998 at 12h 00m Greenwich Mean Time
+ * GeneralizedTime: VALUE must be in one of this format:
+ * "YYYYMMDDhhmmss.sZ" "YYYYMMDDhhmmss.sZ" "YYYYMMDDhhmmss.s+hh'mm'"
+ * "YYYYMMDDhhmmss.s-hh'mm'" "YYYYMMDDhhmm+hh'mm'" "YYYYMMDDhhmm-hh'mm'"
+ * where ss.s indicates the seconds with any precision like "10.1" or "01.02".
+ * LEN != 0
+ * value="2001010112001.12-0700" , len=1 -> time=Jannuary 1st, 2001 at 12h 00m 01.12s
+ * Pacific Daylight Time
+ * OCTET STRING: VALUE contains the octet string and LEN is the number of octet.
+ * value="$\backslash$x01$\backslash$x02$\backslash$x03" , len=3 -> three bytes octet string
+ * BIT STRING: VALUE contains the bit string organized by bytes and LEN is the number of bits.
+ * value="$\backslash$xCF" , len=6 -> bit string="110011" (six bits)
+ * CHOICE: if NAME indicates a choice type, VALUE must specify one of the alternatives with a
+ * null terminated string. LEN != 0
+ * Using "pkix.asn":
+ * result=asn1_write_value(cert,"certificate1.tbsCertificate.subject","rdnSequence",1);
+ * ANY: VALUE indicates the der encoding of a structure.
+ * LEN != 0
+ * SEQUENCE OF: VALUE must be the null terminated string "NEW" and LEN != 0. With this
+ * instruction another element is appended in the sequence. The name of this
+ * element will be "?1" if it's the first one, "?2" for the second and so on.
+ * Using "pkix.asn":
+ * result=asn1_write_value(cert,"certificate1.tbsCertificate.subject.rdnSequence","NEW",1);
+ * SET OF: the same as SEQUENCE OF.
+ * Using "pkix.asn":
+ * result=asn1_write_value(cert,"certificate1.tbsCertificate.subject.rdnSequence.?LAST","NEW",1);
+ *
+ * If an element is OPTIONAL and you want to delete it, you must use the value=NULL and len=0.
+ * Using "pkix.asn":
+ * result=asn1_write_value(cert,"certificate1.tbsCertificate.issuerUniqueID",NULL,0);
+ *
+ **/
+int
+asn1_write_value(node_asn *node_root,char *name,unsigned char *value,int len)
+{
+ node_asn *node,*p,*p2;
+ unsigned char *temp,*value_temp,*default_temp;
+ int len2,k,k2,negative;
+
+ node=_asn1_find_node(node_root,name);
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ if((node->type & CONST_OPTION) && (value==NULL) && (len==0)){
+ asn1_delete_structure(node);
+ return ASN_OK;
+ }
+
+ switch(type_field(node->type)){
+ case TYPE_BOOLEAN:
+ if(!strcmp(value,"TRUE")){
+ if(node->type&CONST_DEFAULT){
+ p=node->down;
+ while(type_field(p->type)!=TYPE_DEFAULT) p=p->right;
+ if(p->type&CONST_TRUE) _asn1_set_value(node,NULL,0);
+ else _asn1_set_value(node,"T",1);
+ }
+ else _asn1_set_value(node,"T",1);
+ }
+ else if(!strcmp(value,"FALSE")){
+ if(node->type&CONST_DEFAULT){
+ p=node->down;
+ while(type_field(p->type)!=TYPE_DEFAULT) p=p->right;
+ if(p->type&CONST_FALSE) _asn1_set_value(node,NULL,0);
+ else _asn1_set_value(node,"F",1);
+ }
+ else _asn1_set_value(node,"F",1);
+ }
+ else return ASN_VALUE_NOT_VALID;
+ break;
+ case TYPE_INTEGER: case TYPE_ENUMERATED:
+ if(len==0){
+ if(isdigit(value[0])){
+ value_temp=(unsigned char *)_asn1_alloca(4);
+ if (value_temp==NULL) return ASN_MEM_ERROR;
+
+ _asn1_convert_integer(value,value_temp,4, &len);
+ }
+ else{ /* is an identifier like v1 */
+ if(!(node->type&CONST_LIST)) return ASN_VALUE_NOT_VALID;
+ p=node->down;
+ while(p){
+ if(type_field(p->type)==TYPE_CONSTANT){
+ if((p->name) && (!strcmp(p->name,value))){
+ value_temp=(unsigned char *)_asn1_alloca(4);
+ if (value_temp==NULL) return ASN_MEM_ERROR;
+
+ _asn1_convert_integer(p->value,value_temp,4, &len);
+ break;
+ }
+ }
+ p=p->right;
+ }
+ if(p==NULL) return ASN_VALUE_NOT_VALID;
+ }
+ }
+ else{
+ value_temp=(unsigned char *)_asn1_alloca(len);
+ if (value_temp==NULL) return ASN_MEM_ERROR;
+ memcpy(value_temp,value,len);
+ }
+
+
+ if(value_temp[0]&0x80) negative=1;
+ else negative=0;
+
+ if(negative && (type_field(node->type)==TYPE_ENUMERATED))
+ {_asn1_afree(value_temp);return ASN_VALUE_NOT_VALID;}
+
+ for(k=0;k<len-1;k++)
+ if(negative && (value_temp[k]!=0xFF)) break;
+ else if(!negative && value_temp[k]) break;
+
+ if((negative && !(value_temp[k]&0x80)) ||
+ (!negative && (value_temp[k]&0x80))) k--;
+
+ _asn1_length_der(len-k,NULL,&len2);
+ temp=(unsigned char *)_asn1_alloca(len-k+len2);
+ if (temp==NULL) return ASN_MEM_ERROR;
+
+ _asn1_octet_der(value_temp+k,len-k,temp,&len2);
+ _asn1_set_value(node,temp,len2);
+
+ _asn1_afree(temp);
+
+ if(node->type&CONST_DEFAULT){
+ p=node->down;
+ while(type_field(p->type)!=TYPE_DEFAULT) p=p->right;
+ if(isdigit(p->value[0])){
+ default_temp=(unsigned char *)_asn1_alloca(4);
+ if (default_temp==NULL) return ASN_MEM_ERROR;
+
+ _asn1_convert_integer(p->value,default_temp,4,&len2);
+ }
+ else{ /* is an identifier like v1 */
+ if(!(node->type&CONST_LIST)) return ASN_VALUE_NOT_VALID;
+ p2=node->down;
+ while(p2){
+ if(type_field(p2->type)==TYPE_CONSTANT){
+ if((p2->name) && (!strcmp(p2->name,p->value))){
+ default_temp=(unsigned char *)_asn1_alloca(4);
+ if (default_temp==NULL) return ASN_MEM_ERROR;
+
+ _asn1_convert_integer(p2->value,default_temp,4,&len2);
+ break;
+ }
+ }
+ p2=p2->right;
+ }
+ if(p2==NULL) return ASN_VALUE_NOT_VALID;
+ }
+
+ if((len-k)==len2){
+ for(k2=0;k2<len2;k2++)
+ if(value_temp[k+k2]!=default_temp[k2]){
+ break;
+ }
+ if(k2==len2) _asn1_set_value(node,NULL,0);
+ }
+ _asn1_afree(default_temp);
+ }
+ _asn1_afree(value_temp);
+ break;
+ case TYPE_OBJECT_ID:
+ for(k=0;k<strlen(value);k++)
+ if((!isdigit(value[k])) && (value[k]!=' ') && (value[k]!='+'))
+ return ASN_VALUE_NOT_VALID;
+ _asn1_set_value(node,value,strlen(value)+1);
+ break;
+ case TYPE_TIME:
+ if(node->type&CONST_UTC){
+ if(strlen(value)<11) return ASN_VALUE_NOT_VALID;
+ for(k=0;k<10;k++)
+ if(!isdigit(value[k])) return ASN_VALUE_NOT_VALID;
+ switch(strlen(value)){
+ case 11:
+ if(value[10]!='Z') return ASN_VALUE_NOT_VALID;
+ break;
+ case 13:
+ if((!isdigit(value[10])) || (!isdigit(value[11])) ||
+ (value[12]!='Z')) return ASN_VALUE_NOT_VALID;
+ break;
+ case 15:
+ if((value[10]!='+') && (value[10]!='-')) return ASN_VALUE_NOT_VALID;
+ for(k=11;k<15;k++)
+ if(!isdigit(value[k])) return ASN_VALUE_NOT_VALID;
+ break;
+ case 17:
+ if((!isdigit(value[10])) || (!isdigit(value[11])))
+ return ASN_VALUE_NOT_VALID;
+ if((value[12]!='+') && (value[12]!='-')) return ASN_VALUE_NOT_VALID;
+ for(k=13;k<17;k++)
+ if(!isdigit(value[k])) return ASN_VALUE_NOT_VALID;
+ break;
+ default:
+ return ASN_VALUE_NOT_FOUND;
+ }
+ _asn1_set_value(node,value,strlen(value)+1);
+ }
+ else{ /* GENERALIZED TIME */
+ if(value) _asn1_set_value(node,value,strlen(value)+1);
+ }
+ break;
+ case TYPE_OCTET_STRING:
+ _asn1_length_der(len,NULL,&len2);
+ temp=(unsigned char *)_asn1_alloca(len+len2);
+ if (temp==NULL) return ASN_MEM_ERROR;
+
+ _asn1_octet_der(value,len,temp,&len2);
+ _asn1_set_value(node,temp,len2);
+ _asn1_afree(temp);
+ break;
+ case TYPE_BIT_STRING:
+ _asn1_length_der((len>>3)+2,NULL,&len2);
+ temp=(unsigned char *)_asn1_alloca((len>>3)+2+len2);
+ if (temp==NULL) return ASN_MEM_ERROR;
+
+ _asn1_bit_der(value,len,temp,&len2);
+ _asn1_set_value(node,temp,len2);
+ _asn1_afree(temp);
+ break;
+ case TYPE_CHOICE:
+ p=node->down;
+ while(p){
+ if(!strcmp(p->name,value)){
+ p2=node->down;
+ while(p2){
+ if(p2!=p){asn1_delete_structure(p2); p2=node->down;}
+ else p2=p2->right;
+ }
+ break;
+ }
+ p=p->right;
+ }
+ if(!p) return ASN_ELEMENT_NOT_FOUND;
+ break;
+ case TYPE_ANY:
+ _asn1_length_der(len,NULL,&len2);
+ temp=(unsigned char *)_asn1_alloca(len+len2);
+ if (temp==NULL) return ASN_MEM_ERROR;
+
+ _asn1_octet_der(value,len,temp,&len2);
+ _asn1_set_value(node,temp,len2);
+ _asn1_afree(temp);
+ break;
+ case TYPE_SEQUENCE_OF: case TYPE_SET_OF:
+ if(strcmp(value,"NEW")) return ASN_VALUE_NOT_VALID;
+ _asn1_append_sequence_set(node);
+ break;
+ default:
+ return ASN_ELEMENT_NOT_FOUND;
+ break;
+ }
+
+ return ASN_OK;
+}
+
+#define PUT_VALUE( ptr, ptr_size, data, data_size) \
+ *len = data_size; \
+ if (ptr_size < data_size) { \
+ return ASN_MEM_ERROR; \
+ } else { \
+ memcpy( ptr, data, data_size); \
+ }
+
+#define PUT_STR_VALUE( ptr, ptr_size, data) \
+ *len = strlen(data) + 1; \
+ if (ptr_size < *len) { \
+ return ASN_MEM_ERROR; \
+ } else { \
+ /* this strcpy is checked */ \
+ strcpy(ptr, data); \
+ }
+
+#define ADD_STR_VALUE( ptr, ptr_size, data) \
+ *len = strlen(data) + 1; \
+ if (ptr_size < strlen(ptr)+(*len)) { \
+ return ASN_MEM_ERROR; \
+ } else { \
+ /* this strcat is checked */ \
+ strcat(ptr, data); \
+ }
+
+/**
+ * asn1_read_value - Returns the value of one element inside a structure
+ * @root: pointer to a structure
+ * @name: the name of the element inside a structure that you want to read.
+ * @value: vector that will contain the element's content.
+ * VALUE must be a pointer to memory cells already allocated.
+ * @len: number of bytes of *value: value[0]..value[len-1]. Initialy holds the sizeof value.
+ *
+ * Description:
+ *
+ * Returns the value of one element inside a structure.
+ *
+ * Returns:
+ *
+ * ASN_OK\: set value OK
+ *
+ * ASN_ELEMENT_NOT_FOUND\: NAME is not a valid element.
+ *
+ * ASN_VALUE_NOT_FOUND\: there isn't any value for the element selected.
+ *
+ * Examples:
+ * a description for each type
+ * INTEGER: VALUE will contain a two's complement form integer.
+ * integer=-1 -> value[0]=0xFF , len=1
+ * integer=1 -> value[0]=0x01 , len=1
+ * ENUMERATED: as INTEGER (but only with not negative numbers)
+ * BOOLEAN: VALUE will be the null terminated string "TRUE" or "FALSE" and LEN=5 or LEN=6
+ * OBJECT IDENTIFIER: VALUE will be a null terminated string with each number separated by
+ * a blank (i.e. "1 2 3 543 1").
+ * LEN = strlen(VALUE)+1
+ * UTCTime: VALUE will be a null terminated string in one of these formats:
+ * "YYMMDDhhmmss+hh'mm'" or "YYMMDDhhmmss-hh'mm'"
+ * LEN=strlen(VALUE)+1
+ * GeneralizedTime: VALUE will be a null terminated string in the same format used to set
+ * the value
+ * OCTET STRING: VALUE will contain the octet string and LEN will be the number of octet.
+ * BIT STRING: VALUE will contain the bit string organized by bytes and LEN will be the
+ * number of bits.
+ * CHOICE: if NAME indicates a choice type, VALUE will specify the alternative selected
+ * ANY: if NAME indicates an any type, VALUE will indicate the DER encoding of the structure
+ * actually used.
+ *
+ * If an element is OPTIONAL and the function "read_value" returns ASN_ELEMENT_NOT_FOUND, it
+ * means that this element wasn't present in the der encoding that created the structure.
+ * The first element of a SEQUENCE_OF or SET_OF is named "?1". The second one "?2" and so on.
+ *
+ **/
+int
+asn1_read_value(node_asn *root,char *name,unsigned char *value, int *len)
+{
+ node_asn *node,*p;
+ int len2,len3;
+ int value_size = *len;
+
+ node=_asn1_find_node(root,name);
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ if((type_field(node->type)!=TYPE_NULL) &&
+ (type_field(node->type)!=TYPE_CHOICE) &&
+ !(node->type&CONST_DEFAULT) && !(node->type&CONST_ASSIGN) &&
+ (node->value==NULL))
+ return ASN_VALUE_NOT_FOUND;
+
+ switch(type_field(node->type)){
+ case TYPE_NULL:
+ PUT_STR_VALUE( value, value_size, "NULL");
+ break;
+ case TYPE_BOOLEAN:
+ if((node->type&CONST_DEFAULT) && (node->value==NULL)){
+ p=node->down;
+ while(type_field(p->type)!=TYPE_DEFAULT) p=p->right;
+ if(p->type&CONST_TRUE) {
+ PUT_STR_VALUE( value, value_size, "TRUE");
+ } else {
+ PUT_STR_VALUE(value, value_size, "FALSE");
+ }
+ }
+ else if(node->value[0]=='T') {
+ PUT_STR_VALUE(value, value_size, "TRUE");
+ }
+ else {
+ PUT_STR_VALUE(value, value_size, "FALSE");
+ }
+ break;
+ case TYPE_INTEGER: case TYPE_ENUMERATED:
+ if((node->type&CONST_DEFAULT) && (node->value==NULL)){
+ p=node->down;
+ while(type_field(p->type)!=TYPE_DEFAULT) p=p->right;
+ if (_asn1_convert_integer(p->value,value,value_size, len)!=ASN_OK) return ASN_MEM_ERROR;
+ }
+ else{
+ len2=-1;
+ if (_asn1_get_octet_der(node->value,&len2,value, value_size, len)!=ASN_OK) return ASN_MEM_ERROR;
+ }
+ break;
+ case TYPE_OBJECT_ID:
+ if(node->type&CONST_ASSIGN){
+ _asn1_str_cpy(value, *len, "");
+ p=node->down;
+ while(p){
+ if(type_field(p->type)==TYPE_CONSTANT){
+ ADD_STR_VALUE( value, value_size, p->value);
+ if(p->right) {
+ ADD_STR_VALUE( value, value_size, " ");
+ }
+ }
+ p=p->right;
+ }
+ } else {
+ PUT_STR_VALUE(value, value_size, node->value);
+ }
+ break;
+ case TYPE_TIME:
+ PUT_STR_VALUE( value, value_size, node->value);
+ break;
+ case TYPE_OCTET_STRING:
+ len2=-1;
+ if (_asn1_get_octet_der(node->value,&len2,value, value_size, len)!=ASN_OK) return ASN_MEM_ERROR;
+ break;
+ case TYPE_BIT_STRING:
+ len2=-1;
+ if (_asn1_get_bit_der(node->value,&len2,value,value_size,len)!=ASN_OK) return ASN_MEM_ERROR;
+ break;
+ case TYPE_CHOICE:
+ PUT_STR_VALUE( value, value_size, node->down->name);
+ break;
+ case TYPE_ANY:
+ len3=-1;
+ len2=_asn1_get_length_der(node->value,&len3);
+ PUT_VALUE( value, value_size, node->value+len3, len2);
+ break;
+ default:
+ return ASN_ELEMENT_NOT_FOUND;
+ break;
+ }
+ return ASN_OK;
+}
+
+/**
+ * asn1_number_of_elements - Counts the number of elements of a structure.
+ * @root: pointer to the root of an ASN1 structure.
+ * @name: the name of a sub-structure of ROOT.
+ * @num: pointer to an integer where the result will be stored
+ * Description:
+ *
+ * Counts the number of elements of a sub-structure called NAME with names equal to "?1","?2", ...
+ *
+ * Returns:
+ *
+ * ASN_OK: creation OK
+ * ASN_ELEMENT_NOT_FOUND: NAME isn't known
+ * ASN_GENERIC_ERROR: parameter num equal to NULL
+ *
+ **/
+int
+asn1_number_of_elements(node_asn *root,char *name,int *num)
+{
+ node_asn *node,*p;
+
+ if(num==NULL) return ASN_GENERIC_ERROR;
+
+ *num=0;
+
+ node=_asn1_find_node(root,name);
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ p=node->down;
+
+ while(p){
+ if((p->name) && (p->name[0]=='?')) (*num)++;
+ p=p->right;
+ }
+
+ return ASN_OK;
+}
+
+
+int
+_asn1_set_default_tag(node_asn *node)
+{
+ node_asn *p;
+
+ if((node==NULL) || (type_field(node->type)!=TYPE_DEFINITIONS))
+ return ASN_ELEMENT_NOT_FOUND;
+
+ p=node;
+ while(p){
+ if((type_field(p->type)==TYPE_TAG) &&
+ !(p->type&CONST_EXPLICIT) &&
+ !(p->type&CONST_IMPLICIT)){
+ if(node->type&CONST_EXPLICIT) p->type|=CONST_EXPLICIT;
+ else p->type|=CONST_IMPLICIT;
+ }
+
+ if(p->down){
+ p=p->down;
+ }
+ else if(p->right) p=p->right;
+ else{
+ while(1){
+ p=_asn1_find_up(p);
+ if(p==node){
+ p=NULL;
+ break;
+ }
+ if(p->right){
+ p=p->right;
+ break;
+ }
+ }
+ }
+ }
+
+ return ASN_OK;
+}
+
+
+int
+_asn1_check_identifier(node_asn *node)
+{
+ node_asn *p,*p2;
+ char name2[129];
+
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ p=node;
+ while(p){
+ if(type_field(p->type)==TYPE_IDENTIFIER){
+ _asn1_str_cpy(name2, sizeof(name2), node->name);
+ _asn1_str_cat(name2, sizeof(name2), ".");
+ _asn1_str_cat(name2, sizeof(name2), p->value);
+ p2=_asn1_find_node(node,name2);
+ if(p2==NULL){printf("%s\n",name2); return ASN_IDENTIFIER_NOT_FOUND;}
+ }
+ else if((type_field(p->type)==TYPE_OBJECT_ID) &&
+ (p->type&CONST_ASSIGN)){
+ p2=p->down;
+ if(p2 && (type_field(p2->type)==TYPE_CONSTANT)){
+ if(p2->value && !isdigit(p2->value[0])){
+ _asn1_str_cpy(name2, sizeof(name2), node->name);
+ _asn1_str_cat(name2, sizeof(name2), ".");
+ _asn1_str_cat(name2, sizeof(name2), p2->value);
+ p2=_asn1_find_node(node,name2);
+ if(!p2 || (type_field(p2->type)!=TYPE_OBJECT_ID) ||
+ !(p2->type&CONST_ASSIGN))
+ {printf("%s\n",name2); return ASN_IDENTIFIER_NOT_FOUND;}
+ }
+ }
+ }
+
+ if(p->down){
+ p=p->down;
+ }
+ else if(p->right) p=p->right;
+ else{
+ while(1){
+ p=_asn1_find_up(p);
+ if(p==node){
+ p=NULL;
+ break;
+ }
+ if(p->right){
+ p=p->right;
+ break;
+ }
+ }
+ }
+ }
+
+ return ASN_OK;
+}
+
+
+int
+_asn1_change_integer_value(node_asn *node)
+{
+ node_asn *p;
+ unsigned char val[4],val2[5];
+ int len;
+
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ p=node;
+ while(p){
+ if((type_field(p->type)==TYPE_INTEGER) && (p->type&CONST_ASSIGN)){
+ if(p->value){
+ _asn1_convert_integer(p->value,val,sizeof(val), &len);
+ _asn1_octet_der(val,len,val2,&len);
+ _asn1_set_value(p,val2,len);
+ }
+ }
+
+ if(p->down){
+ p=p->down;
+ }
+ else{
+ if(p==node) p=NULL;
+ else if(p->right) p=p->right;
+ else{
+ while(1){
+ p=_asn1_find_up(p);
+ if(p==node){
+ p=NULL;
+ break;
+ }
+ if(p->right){
+ p=p->right;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return ASN_OK;
+}
+
+
+int
+_asn1_delete_not_used(node_asn *node)
+{
+ node_asn *p,*p2;
+
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ p=node;
+ while(p){
+ if(p->type&CONST_NOT_USED){
+ p2=NULL;
+ if(p!=node){
+ p2=_asn1_find_left(p);
+ if(!p2) p2=_asn1_find_up(p);
+ }
+ asn1_delete_structure(p);
+ p=p2;
+ }
+
+ if(!p) break; /* reach node */
+
+ if(p->down){
+ p=p->down;
+ }
+ else{
+ if(p==node) p=NULL;
+ else if(p->right) p=p->right;
+ else{
+ while(1){
+ p=_asn1_find_up(p);
+ if(p==node){
+ p=NULL;
+ break;
+ }
+ if(p->right){
+ p=p->right;
+ break;
+ }
+ }
+ }
+ }
+ }
+ return ASN_OK;
+}
+
+
+
+int
+_asn1_expand_identifier(node_asn **node,node_asn *root)
+{
+ node_asn *p,*p2,*p3;
+ char name2[129];
+ int move;
+
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ p=*node;
+ move=DOWN;
+
+ while(!((p==*node) && (move==UP))){
+ if(move!=UP){
+ if(type_field(p->type)==TYPE_IDENTIFIER){
+ _asn1_str_cpy(name2, sizeof(name2), root->name);
+ _asn1_str_cat(name2, sizeof(name2), ".");
+ _asn1_str_cat(name2, sizeof(name2), p->value);
+ p2=_asn1_copy_structure2(root,name2);
+ if(p2==NULL) return ASN_IDENTIFIER_NOT_FOUND;
+ _asn1_set_name(p2,p->name);
+ p2->right=p->right;
+ p2->left=p->left;
+ if(p->right) p->right->left=p2;
+ p3=p->down;
+ if(p3){
+ while(p3->right) p3=p3->right;
+ _asn1_set_right(p3,p2->down);
+ _asn1_set_down(p2,p->down);
+ }
+
+ p3=_asn1_find_left(p);
+ if(p3) _asn1_set_right(p3,p2);
+ else{
+ p3=_asn1_find_up(p);
+ if(p3) _asn1_set_down(p3,p2);
+ else {
+ p2->left=NULL;
+ }
+ }
+
+ if(p->type & CONST_SIZE) p2->type|=CONST_SIZE;
+ if(p->type & CONST_TAG) p2->type|=CONST_TAG;
+ if(p->type & CONST_OPTION) p2->type|=CONST_OPTION;
+ if(p->type & CONST_DEFAULT) p2->type|=CONST_DEFAULT;
+ if(p->type & CONST_SET) p2->type|=CONST_SET;
+ if(p->type & CONST_NOT_USED) p2->type|=CONST_NOT_USED;
+
+ if(p==*node) *node=p2;
+ _asn1_remove_node(p);
+ p=p2;
+ move=DOWN;
+ continue;
+ }
+ move=DOWN;
+ }
+ else move=RIGHT;
+
+ if(move==DOWN){
+ if(p->down) p=p->down;
+ else move=RIGHT;
+ }
+
+ if(p==*node) {move=UP; continue;}
+
+ if(move==RIGHT){
+ if(p->right) p=p->right;
+ else move=UP;
+ }
+ if(move==UP) p=_asn1_find_up(p);
+ }
+
+ return ASN_OK;
+}
+
+
+
+int
+_asn1_type_choice_config(node_asn *node)
+{
+ node_asn *p,*p2,*p3,*p4;
+ int move;
+
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ p=node;
+ move=DOWN;
+
+ while(!((p==node) && (move==UP))){
+ if(move!=UP){
+ if((type_field(p->type)==TYPE_CHOICE) &&
+ (p->type&CONST_TAG)){
+ p2=p->down;
+ while(p2){
+ if(type_field(p2->type)!=TYPE_TAG){
+ p2->type|=CONST_TAG;
+ p3=_asn1_find_left(p2);
+ while(p3){
+ if(type_field(p3->type)==TYPE_TAG){
+ p4=_asn1_add_node(p3->type);
+ _asn1_set_value(p4,p3->value,strlen(p3->value)+1);
+ _asn1_set_right(p4,p2->down);
+ _asn1_set_down(p2,p4);
+ }
+ p3=_asn1_find_left(p3);
+ }
+ }
+ p2=p2->right;
+ }
+ p->type&=~(CONST_TAG);
+ p2=p->down;
+ while(p2){
+ p3=p2->right;
+ if(type_field(p2->type)==TYPE_TAG) asn1_delete_structure(p2);
+ p2=p3;
+ }
+ }
+ move=DOWN;
+ }
+ else move=RIGHT;
+
+ if(move==DOWN){
+ if(p->down) p=p->down;
+ else move=RIGHT;
+ }
+
+ if(p==node) {move=UP; continue;}
+
+ if(move==RIGHT){
+ if(p->right) p=p->right;
+ else move=UP;
+ }
+ if(move==UP) p=_asn1_find_up(p);
+ }
+
+ return ASN_OK;
+}
+
+
+int
+_asn1_type_set_config(node_asn *node)
+{
+ node_asn *p,*p2;
+ int move;
+
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ p=node;
+ move=DOWN;
+
+ while(!((p==node) && (move==UP))){
+ if(move!=UP){
+ if(type_field(p->type)==TYPE_SET){
+ p2=p->down;
+ while(p2){
+ if(type_field(p2->type)!=TYPE_TAG)
+ p2->type|=CONST_SET|CONST_NOT_USED;
+ p2=p2->right;
+ }
+ }
+ move=DOWN;
+ }
+ else move=RIGHT;
+
+ if(move==DOWN){
+ if(p->down) p=p->down;
+ else move=RIGHT;
+ }
+
+ if(p==node) {move=UP; continue;}
+
+ if(move==RIGHT){
+ if(p->right) p=p->right;
+ else move=UP;
+ }
+ if(move==UP) p=_asn1_find_up(p);
+ }
+
+ return ASN_OK;
+}
+
+
+int
+_asn1_expand_object_id(node_asn *node)
+{
+ node_asn *p,*p2,*p3,*p4,*p5;
+ char name_root[129],name2[129];
+ int move;
+
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ _asn1_str_cpy(name_root, sizeof(name_root), node->name);
+
+ p=node;
+ move=DOWN;
+
+ while(!((p==node) && (move==UP))){
+ if(move!=UP){
+ if((type_field(p->type)==TYPE_OBJECT_ID) && (p->type&CONST_ASSIGN)){
+ p2=p->down;
+ if(p2 && (type_field(p2->type)==TYPE_CONSTANT)){
+ if(p2->value && !isdigit(p2->value[0])){
+ _asn1_str_cpy(name2, sizeof(name2), name_root);
+ _asn1_str_cat(name2, sizeof(name2), ".");
+ _asn1_str_cat(name2, sizeof(name2), p2->value);
+ p3=_asn1_find_node(node,name2);
+ if(!p3 || (type_field(p3->type)!=TYPE_OBJECT_ID) ||
+ !(p3->type&CONST_ASSIGN)) return ASN_ELEMENT_NOT_FOUND;
+ _asn1_set_down(p,p2->right);
+ _asn1_remove_node(p2);
+ p2=p;
+ p4=p3->down;
+ while(p4){
+ if(type_field(p4->type)==TYPE_CONSTANT){
+ p5=_asn1_add_node(TYPE_CONSTANT);
+ _asn1_set_name(p5,p4->name);
+ _asn1_set_value(p5,p4->value,strlen(p4->value)+1);
+ if(p2==p){
+ _asn1_set_right(p5,p->down);
+ _asn1_set_down(p,p5);
+ }
+ else{
+ _asn1_set_right(p5,p2->right);
+ _asn1_set_right(p2,p5);
+ }
+ p2=p5;
+ }
+ p4=p4->right;
+ }
+ move=DOWN;
+ continue;
+ }
+ }
+ }
+ move=DOWN;
+ }
+ else move=RIGHT;
+
+ if(move==DOWN){
+ if(p->down) p=p->down;
+ else move=RIGHT;
+ }
+
+ if(p==node) {move=UP; continue;}
+
+ if(move==RIGHT){
+ if(p->right) p=p->right;
+ else move=UP;
+ }
+ if(move==UP) p=_asn1_find_up(p);
+ }
+
+ return ASN_OK;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+
+/*************************************************/
+/* File: x509_asn1.h */
+/* Description: list of exported object by */
+/* "x509_asn1.c" */
+/*************************************************/
+
+#ifndef _GNUTLS_ASN1_H
+#define _GNUTLS_ASN1_H
+
+#define PARSE_MODE_CHECK 1
+#define PARSE_MODE_CREATE 2
+
+/* List of constants for field type of typedef node_asn */
+#define TYPE_CONSTANT 1
+#define TYPE_IDENTIFIER 2
+#define TYPE_INTEGER 3
+#define TYPE_BOOLEAN 4
+#define TYPE_SEQUENCE 5
+#define TYPE_BIT_STRING 6
+#define TYPE_OCTET_STRING 7
+#define TYPE_TAG 8
+#define TYPE_DEFAULT 9
+#define TYPE_SIZE 10
+#define TYPE_SEQUENCE_OF 11
+#define TYPE_OBJECT_ID 12
+#define TYPE_ANY 13
+#define TYPE_SET 14
+#define TYPE_SET_OF 15
+#define TYPE_DEFINITIONS 16
+#define TYPE_TIME 17
+#define TYPE_CHOICE 18
+#define TYPE_IMPORTS 19
+#define TYPE_NULL 20
+#define TYPE_ENUMERATED 21
+
+
+/***********************************************************************/
+/* List of constants for specify better the type of typedef node_asn. */
+/***********************************************************************/
+/* Used with TYPE_TAG */
+#define CONST_UNIVERSAL (1<<8)
+#define CONST_PRIVATE (1<<9)
+#define CONST_APPLICATION (1<<10)
+#define CONST_EXPLICIT (1<<11)
+#define CONST_IMPLICIT (1<<12)
+
+#define CONST_TAG (1<<13) /* Used in ASN.1 assignement */
+#define CONST_OPTION (1<<14)
+#define CONST_DEFAULT (1<<15)
+#define CONST_TRUE (1<<16)
+#define CONST_FALSE (1<<17)
+
+#define CONST_LIST (1<<18) /* Used with TYPE_INTEGER and TYPE_BIT_STRING */
+#define CONST_MIN_MAX (1<<19)
+
+#define CONST_1_PARAM (1<<20)
+
+#define CONST_SIZE (1<<21)
+
+#define CONST_DEFINED_BY (1<<22)
+
+#define CONST_GENERALIZED (1<<23)
+#define CONST_UTC (1<<24)
+
+#define CONST_IMPORTS (1<<25)
+
+#define CONST_NOT_USED (1<<26)
+#define CONST_SET (1<<27)
+#define CONST_ASSIGN (1<<28)
+
+#define CONST_DOWN (1<<29)
+#define CONST_RIGHT (1<<30)
+
+
+#define ASN_OK 0
+#define ASN_FILE_NOT_FOUND 1
+#define ASN_ELEMENT_NOT_FOUND 2
+#define ASN_IDENTIFIER_NOT_FOUND 3
+#define ASN_DER_ERROR 4
+#define ASN_VALUE_NOT_FOUND 5
+#define ASN_GENERIC_ERROR 6
+#define ASN_VALUE_NOT_VALID 7
+#define ASN_TAG_ERROR 8
+#define ASN_TAG_IMPLICIT 9
+#define ASN_ERROR_TYPE_ANY 10
+#define ASN_SYNTAX_ERROR 11
+#define ASN_MEM_ERROR 12
+#define ASN_DER_OVERFLOW 13
+
+
+/******************************************************/
+/* Structure definition used for the node of the tree */
+/* that rappresent an ASN.1 DEFINITION. */
+/******************************************************/
+typedef struct node_asn_struct{
+ char *name; /* Node name */
+ unsigned int type; /* Node type */
+ unsigned char *value; /* Node value */
+ struct node_asn_struct *down; /* Pointer to the son node */
+ struct node_asn_struct *right; /* Pointer to the brother node */
+ struct node_asn_struct *left; /* Pointer to the next list element */
+} node_asn;
+
+
+
+typedef struct static_struct_asn{
+ char *name; /* Node name */
+ unsigned int type; /* Node type */
+ unsigned char *value; /* Node value */
+} static_asn;
+
+
+/****************************************/
+/* Returns the first 8 bits. */
+/* Used with the field type of node_asn */
+/****************************************/
+#define type_field(x) (x&0xFF)
+
+
+/***************************************/
+/* Functions used by ASN.1 parser */
+/***************************************/
+node_asn *
+_asn1_add_node(unsigned int type);
+
+node_asn *
+_asn1_set_value(node_asn *node,unsigned char *value,unsigned int len);
+
+node_asn *
+_asn1_set_name(node_asn *node,char *name);
+
+node_asn *
+_asn1_set_right(node_asn *node,node_asn *right);
+
+node_asn *
+_asn1_get_right(node_asn *node);
+
+node_asn *
+_asn1_get_last_right(node_asn *node);
+
+node_asn *
+_asn1_set_down(node_asn *node,node_asn *down);
+
+char *
+_asn1_get_name(node_asn *node);
+
+node_asn *
+_asn1_get_down(node_asn *node);
+
+node_asn *
+_asn1_mod_type(node_asn *node,unsigned int value);
+
+void
+_asn1_append_tree(node_asn *node);
+
+node_asn *
+_asn1_find_node(node_asn *pointer,char *name);
+
+node_asn *
+_asn1_find_up(node_asn *node);
+
+int
+_asn1_append_sequence_set(node_asn *node);
+
+int
+_asn1_delete_not_used(node_asn *node);
+
+int
+_asn1_set_default_tag(node_asn *node);
+
+/* prototypes - not defined elsewere */
+int _asn1_change_integer_value(node_asn *node);
+int _asn1_expand_object_id(node_asn *node);
+int _asn1_expand_identifier(node_asn **node,node_asn *root);
+int _asn1_type_choice_config(node_asn *node);
+int _asn1_type_set_config(node_asn *node);
+int _asn1_check_identifier(node_asn *node);
+int _asn1_create_static_structure(node_asn *pointer,char *file_name, char* out_name);
+
+int
+asn1_parser_asn1(char *file_name,node_asn **pointer);
+
+int
+asn1_create_structure(node_asn *root,char *source_name,node_asn **pointer,
+ char *dest_name);
+
+int
+asn1_delete_structure(node_asn *root);
+
+int
+asn1_write_value(node_asn *root,char *name,unsigned char *value,int len);
+
+int
+asn1_read_value(node_asn *root,char *name,unsigned char *value,int *len);
+
+int
+asn1_create_tree(const static_asn *root,node_asn **pointer);
+
+int
+asn1_number_of_elements(node_asn *root,char *name,int *num);
+
+#endif
+
--- /dev/null
+/*
+ * Copyright (C) 2000,2001,2002 Nikos Mavroyanopoulos
+ *
+ * This file is part of GNUTLS.
+ *
+ * GNUTLS 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.
+ *
+ * GNUTLS 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#ifndef DEFINES_H
+# define DEFINES_H
+
+#ifndef __GNUC__
+# if HAVE_ALLOCA_H
+# include <alloca.h>
+# else
+# ifdef _AIX
+#pragma alloca
+# else
+# ifndef alloca /* predefined by HP cc +Olibcalls */
+char *alloca();
+# endif
+# endif
+# endif
+#endif
+
+
+#include <config.h>
+
+#ifdef STDC_HEADERS
+# include <string.h>
+# include <stdlib.h>
+# include <stdio.h>
+# include <ctype.h>
+#endif
+
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+
+#if SIZEOF_UNSIGNED_LONG_INT == 4
+typedef unsigned long int uint32;
+typedef signed long int sint32;
+#elif SIZEOF_UNSIGNED_INT == 4
+typedef unsigned int uint32;
+typedef signed int sint32;
+#else
+# error "Cannot find a 32 bit integer in your system, sorry."
+#endif
+
+#if SIZEOF_UNSIGNED_INT == 2
+typedef unsigned int uint16;
+typedef signed int sint16;
+#elif SIZEOF_UNSIGNED_SHORT_INT == 2
+typedef unsigned short int uint16;
+typedef signed short int sint16;
+#else
+# error "Cannot find a 16 bit integer in your system, sorry."
+#endif
+
+#if SIZEOF_UNSIGNED_CHAR == 1
+typedef unsigned char uint8;
+typedef signed char int8;
+#else
+# error "Cannot find an 8 bit char in your system, sorry."
+#endif
+
+#ifndef HAVE_MEMMOVE
+# ifdef HAVE_BCOPY
+# define memmove(d, s, n) bcopy ((s), (d), (n))
+# else
+# error "Neither memmove nor bcopy exists on your system."
+# endif
+#endif
+
+#include <mem.h>
+
+#endif /* defines_h */
--- /dev/null
+/*
+ * Copyright (C) 2000,2001 Fabio Fiorina
+ *
+ * This file is part of GNUTLS.
+ *
+ * GNUTLS 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.
+ *
+ * GNUTLS 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+/*****************************************************/
+/* File: x509_der.c */
+/* Description: Functions to manage DER encoding */
+/*****************************************************/
+
+#include <defines.h>
+#include "der.h"
+#include "asn1.h"
+#include <gstr.h>
+
+#define TAG_BOOLEAN 0x01
+#define TAG_INTEGER 0x02
+#define TAG_SEQUENCE 0x10
+#define TAG_SET 0x11
+#define TAG_OCTET_STRING 0x04
+#define TAG_BIT_STRING 0x03
+#define TAG_UTCTime 0x17
+#define TAG_GENERALIZEDTime 0x18
+#define TAG_OBJECT_ID 0x06
+#define TAG_ENUMERATED 0x0A
+#define TAG_NULL 0x05
+
+
+char *
+_asn1_ltostr(long v,char *str)
+{
+ long d,r;
+ char temp[20];
+ int count,k,start;
+
+ if(v<0){
+ str[0]='-';
+ start=1;
+ v=-v;
+ }
+ else start=0;
+
+ count=0;
+ do{
+ d=v/10;
+ r=v-d*10;
+ temp[start+count]='0'+(char)r;
+ count++;
+ v=d;
+ }while(v);
+
+ for(k=0;k<count;k++) str[k+start]=temp[start+count-k-1];
+ str[count+start]=0;
+ return str;
+}
+
+
+void
+_asn1_length_der(unsigned long len,unsigned char *ans,int *ans_len)
+{
+ int k;
+ unsigned char temp[128];
+
+ if(len<128){
+ /* short form */
+ if(ans!=NULL) ans[0]=(unsigned char)len;
+ *ans_len=1;
+ }
+ else{
+ /* Long form */
+ k=0;
+ while(len){
+ temp[k++]=len&0xFF;
+ len=len>>8;
+ }
+ *ans_len=k+1;
+ if(ans!=NULL){
+ ans[0]=((unsigned char)k&0x7F)+128;
+ while(k--) ans[*ans_len-1-k]=temp[k];
+ }
+ }
+}
+
+
+unsigned long
+_asn1_get_length_der(unsigned char *der,int *len)
+{
+ unsigned long ans;
+ int k,punt;
+
+ if(!(der[0]&128)){
+ /* short form */
+ *len=1;
+ return der[0];
+ }
+ else{
+ /* Long form */
+ k=der[0]&0x7F;
+ punt=1;
+ ans=0;
+ while(punt<=k) ans=ans*256+der[punt++];
+
+ *len=punt;
+ return ans;
+ }
+}
+
+
+void
+_asn1_tag_der(unsigned char class,unsigned int tag_value,unsigned char *ans,int *ans_len)
+{
+ int k;
+ unsigned char temp[128];
+
+ if(tag_value<30){
+ /* short form */
+ ans[0]=(class&0xE0) + ((unsigned char)(tag_value&0x1F));
+ *ans_len=1;
+ }
+ else{
+ /* Long form */
+ ans[0]=(class&0xE0) + 31;
+ k=0;
+ while(tag_value){
+ temp[k++]=tag_value&0x7F;
+ tag_value=tag_value>>7;
+ }
+ *ans_len=k+1;
+ while(k--) ans[*ans_len-1-k]=temp[k]+128;
+ ans[*ans_len-1]-=128;
+ }
+}
+
+
+unsigned int
+_asn1_get_tag_der(unsigned char *der,unsigned char *class,int *len)
+{
+ int punt,ris;
+
+ *class=der[0]&0xE0;
+ if((der[0]&0x1F)!=0x1F){
+ /* short form */
+ *len=1;
+ ris=der[0]&0x1F;
+ }
+ else{
+ /* Long form */
+ punt=1;
+ ris=0;
+ while(der[punt]&128) ris=ris*128+(der[punt++]&0x7F);
+ ris=ris*128+(der[punt++]&0x7F);
+ *len=punt;
+ }
+ return ris;
+}
+
+
+void
+_asn1_octet_der(unsigned char *str,int str_len,unsigned char *der,int *der_len)
+{
+ int len_len;
+
+ if(der==NULL) return;
+ _asn1_length_der(str_len,der,&len_len);
+ memcpy(der+len_len,str,str_len);
+ *der_len=str_len+len_len;
+}
+
+
+int
+_asn1_get_octet_der(unsigned char *der,int *der_len,unsigned char *str,int str_size, int *str_len)
+{
+ int len_len;
+
+ if(str==NULL) return ASN_OK;
+ *str_len=_asn1_get_length_der(der,&len_len);
+ if ( str_size >= *str_len)
+ memcpy(str,der+len_len,*str_len);
+ else {
+ return ASN_MEM_ERROR;
+ }
+ *der_len=*str_len+len_len;
+
+ return ASN_OK;
+}
+
+
+void
+_asn1_time_der(unsigned char *str,unsigned char *der,int *der_len)
+{
+ int len_len;
+
+ if(der==NULL) return;
+ _asn1_length_der(strlen(str),der,&len_len);
+ memcpy(der+len_len,str,strlen(str));
+ *der_len=len_len+strlen(str);
+}
+
+
+/*
+void
+_asn1_get_utctime_der(unsigned char *der,int *der_len,unsigned char *str)
+{
+ int len_len,str_len;
+ char temp[20];
+
+ if(str==NULL) return;
+ str_len=_asn1_get_length_der(der,&len_len);
+ memcpy(temp,der+len_len,str_len);
+ *der_len=str_len+len_len;
+ switch(str_len){
+ case 11:
+ temp[10]=0;
+ strcat(temp,"00+0000");
+ break;
+ case 13:
+ temp[12]=0;
+ strcat(temp,"+0000");
+ break;
+ case 15:
+ temp[15]=0;
+ memmove(temp+12,temp+10,6);
+ temp[10]=temp[11]='0';
+ break;
+ case 17:
+ temp[17]=0;
+ break;
+ default:
+ return;
+ }
+ strcpy(str,temp);
+}
+*/
+
+
+void
+_asn1_get_time_der(unsigned char *der,int *der_len,unsigned char *str)
+{
+ int len_len,str_len;
+
+ if(str==NULL) return;
+ str_len=_asn1_get_length_der(der,&len_len);
+ memcpy(str,der+len_len,str_len);
+ str[str_len]=0;
+ *der_len=str_len+len_len;
+}
+
+void
+_asn1_objectid_der(unsigned char *str,unsigned char *der,int *der_len)
+{
+ int len_len,counter,k,first;
+ char temp[128],*n_end,*n_start;
+ unsigned char bit7;
+ unsigned long val,val1;
+
+ if(der==NULL) return;
+
+ _asn1_str_cpy(temp, sizeof(temp), str);
+ _asn1_str_cat(temp, sizeof(temp), " ");
+
+ counter=0;
+ n_start=temp;
+ while((n_end=strchr(n_start,' '))){
+ *n_end=0;
+ val=strtoul(n_start,NULL,10);
+ counter++;
+
+ if(counter==1) val1=val;
+ else if(counter==2){
+ der[0]=40*val1+val;
+ *der_len=1;
+ }
+ else{
+ first=0;
+ for(k=4;k>=0;k--){
+ bit7=(val>>(k*7))&0x7F;
+ if(bit7 || first || !k){
+ if(k) bit7|=0x80;
+ der[*der_len]=bit7;
+ (*der_len)++;
+ first=1;
+ }
+ }
+
+ }
+ n_start=n_end+1;
+ }
+
+ _asn1_length_der(*der_len,NULL,&len_len);
+ memmove(der+len_len,der,*der_len);
+ _asn1_length_der(*der_len,der,&len_len);
+ *der_len+=len_len;
+}
+
+
+void
+_asn1_get_objectid_der(unsigned char *der,int *der_len,unsigned char *str, int str_size)
+{
+ int len_len,len,k;
+ char temp[20];
+ unsigned long val,val1;
+
+ if(str==NULL) return;
+ len=_asn1_get_length_der(der,&len_len);
+
+ val1=der[len_len]/40;
+ val=der[len_len]-val1*40;
+
+ _asn1_str_cpy(str, str_size, _asn1_ltostr(val1,temp));
+ _asn1_str_cat(str, str_size, " ");
+ _asn1_str_cat(str, str_size, _asn1_ltostr(val,temp));
+
+ val=0;
+ for(k=1;k<len;k++){
+ val=val<<7;
+ val|=der[len_len+k]&0x7F;
+ if(!(der[len_len+k]&0x80)){
+ _asn1_str_cat(str, str_size," ");
+ _asn1_str_cat(str, str_size,_asn1_ltostr(val,temp));
+ val=0;
+ }
+ }
+ *der_len=len+len_len;
+}
+
+
+
+char bit_mask[]={0xFF,0xFE,0xFC,0xF8,0xF0,0xE0,0xC0,0x80};
+
+void
+_asn1_bit_der(unsigned char *str,int bit_len,unsigned char *der,int *der_len)
+{
+ int len_len,len_byte,len_pad;
+
+ if(der==NULL) return;
+ len_byte=bit_len>>3;
+ len_pad=8-(bit_len&7);
+ if(len_pad==8) len_pad=0;
+ else len_byte++;
+ _asn1_length_der(len_byte+1,der,&len_len);
+ der[len_len]=len_pad;
+ memcpy(der+len_len+1,str,len_byte);
+ der[len_len+len_byte]&=bit_mask[len_pad];
+ *der_len=len_byte+len_len+1;
+}
+
+
+int
+_asn1_get_bit_der(unsigned char *der,int *der_len,unsigned char *str, int str_size, int *bit_len)
+{
+ int len_len,len_byte;
+
+ if(str==NULL) return ASN_OK;
+ len_byte=_asn1_get_length_der(der,&len_len)-1;
+
+ if (str_size >= len_byte)
+ memcpy(str,der+len_len+1,len_byte);
+ else {
+ return ASN_MEM_ERROR;
+ }
+ *bit_len=len_byte*8-der[len_len];
+ *der_len=len_byte+len_len+1;
+
+ return ASN_OK;
+}
+
+
+
+
+#define UP 1
+#define DOWN 2
+#define RIGHT 3
+
+
+void
+_asn1_complete_explicit_tag(node_asn *node,unsigned char *der,int *counter)
+{
+ node_asn *p;
+ int is_tag_implicit,len2,len3;
+ unsigned char temp[10];
+
+ is_tag_implicit=0;
+
+ if(node->type&CONST_TAG){
+ p=node->down;
+ while(p){
+ if(type_field(p->type)==TYPE_TAG){
+ if(p->type&CONST_EXPLICIT){
+ len2=strtol(p->name,NULL,10);
+ _asn1_set_name(p,NULL);
+ _asn1_length_der(*counter-len2,temp,&len3);
+ memmove(der+len2+len3,der+len2,*counter-len2);
+ memcpy(der+len2,temp,len3);
+ *counter+=len3;
+ is_tag_implicit=0;
+ }
+ else{ /* CONST_IMPLICIT */
+ if(!is_tag_implicit){
+ is_tag_implicit=1;
+ }
+ }
+ }
+ p=p->right;
+ }
+ }
+}
+
+
+int
+_asn1_insert_tag_der(node_asn *node,unsigned char *der,int *counter)
+{
+ node_asn *p;
+ int tag_len,is_tag_implicit;
+ unsigned char class,class_implicit,temp[10];
+ unsigned long tag_implicit;
+
+ is_tag_implicit=0;
+
+ if(node->type&CONST_TAG){
+ p=node->down;
+ while(p){
+ if(type_field(p->type)==TYPE_TAG){
+ if(p->type&CONST_APPLICATION) class=APPLICATION;
+ else if(p->type&CONST_UNIVERSAL) class=UNIVERSAL;
+ else if(p->type&CONST_PRIVATE) class=PRIVATE;
+ else class=CONTEXT_SPECIFIC;
+
+ if(p->type&CONST_EXPLICIT){
+ if(is_tag_implicit)
+ _asn1_tag_der(class_implicit,tag_implicit,der+*counter,&tag_len);
+ else
+ _asn1_tag_der(class|STRUCTURED,strtoul(p->value,NULL,10),der+*counter,&tag_len);
+ *counter+=tag_len;
+ _asn1_ltostr(*counter,temp);
+ _asn1_set_name(p,temp);
+
+ is_tag_implicit=0;
+ }
+ else{ /* CONST_IMPLICIT */
+ if(!is_tag_implicit){
+ if((type_field(node->type)==TYPE_SEQUENCE) ||
+ (type_field(node->type)==TYPE_SEQUENCE_OF) ||
+ (type_field(node->type)==TYPE_SET) ||
+ (type_field(node->type)==TYPE_SET_OF)) class|=STRUCTURED;
+ class_implicit=class;
+ tag_implicit=strtoul(p->value,NULL,10);
+ is_tag_implicit=1;
+ }
+ }
+ }
+ p=p->right;
+ }
+ }
+
+ if(is_tag_implicit){
+ _asn1_tag_der(class_implicit,tag_implicit,der+*counter,&tag_len);
+ }
+ else{
+ switch(type_field(node->type)){
+ case TYPE_NULL:
+ _asn1_tag_der(UNIVERSAL,TAG_NULL,der+*counter,&tag_len);
+ break;
+ case TYPE_BOOLEAN:
+ _asn1_tag_der(UNIVERSAL,TAG_BOOLEAN,der+*counter,&tag_len);
+ break;
+ case TYPE_INTEGER:
+ _asn1_tag_der(UNIVERSAL,TAG_INTEGER,der+*counter,&tag_len);
+ break;
+ case TYPE_ENUMERATED:
+ _asn1_tag_der(UNIVERSAL,TAG_ENUMERATED,der+*counter,&tag_len);
+ break;
+ case TYPE_OBJECT_ID:
+ _asn1_tag_der(UNIVERSAL,TAG_OBJECT_ID,der+*counter,&tag_len);
+ break;
+ case TYPE_TIME:
+ if(node->type&CONST_UTC){
+ _asn1_tag_der(UNIVERSAL,TAG_UTCTime,der+*counter,&tag_len);
+ }
+ else _asn1_tag_der(UNIVERSAL,TAG_GENERALIZEDTime,der+*counter,&tag_len);
+ break;
+ case TYPE_OCTET_STRING:
+ _asn1_tag_der(UNIVERSAL,TAG_OCTET_STRING,der+*counter,&tag_len);
+ break;
+ case TYPE_BIT_STRING:
+ _asn1_tag_der(UNIVERSAL,TAG_BIT_STRING,der+*counter,&tag_len);
+ break;
+ case TYPE_SEQUENCE: case TYPE_SEQUENCE_OF:
+ _asn1_tag_der(UNIVERSAL|STRUCTURED,TAG_SEQUENCE,der+*counter,&tag_len);
+ break;
+ case TYPE_SET: case TYPE_SET_OF:
+ _asn1_tag_der(UNIVERSAL|STRUCTURED,TAG_SET,der+*counter,&tag_len);
+ break;
+ case TYPE_TAG:
+ tag_len=0;
+ break;
+ case TYPE_CHOICE:
+ tag_len=0;
+ break;
+ case TYPE_ANY:
+ tag_len=0;
+ break;
+ default:
+ return ASN_GENERIC_ERROR;
+ }
+ }
+
+ *counter+=tag_len;
+
+ return ASN_OK;
+}
+
+
+int
+_asn1_extract_tag_der(node_asn *node,unsigned char *der,int *der_len)
+{
+ node_asn *p;
+ int counter,len2,len3,is_tag_implicit;
+ unsigned long tag,tag_implicit;
+ unsigned char class,class2,class_implicit;
+
+ counter=is_tag_implicit=0;
+ if(node->type&CONST_TAG){
+ p=node->down;
+ while(p){
+ if(type_field(p->type)==TYPE_TAG){
+ if(p->type&CONST_APPLICATION) class2=APPLICATION;
+ else if(p->type&CONST_UNIVERSAL) class2=UNIVERSAL;
+ else if(p->type&CONST_PRIVATE) class2=PRIVATE;
+ else class2=CONTEXT_SPECIFIC;
+
+ if(p->type&CONST_EXPLICIT){
+ tag=_asn1_get_tag_der(der+counter,&class,&len2);
+ counter+=len2;
+ len3=_asn1_get_length_der(der+counter,&len2);
+ counter+=len2;
+ if(!is_tag_implicit){
+ if((class!=(class2|STRUCTURED)) || (tag!=strtoul(p->value,NULL,10)))
+ return ASN_TAG_ERROR;
+ }
+ else{ /* TAG_IMPLICIT */
+ if((class!=class_implicit) || (tag!=tag_implicit))
+ return ASN_TAG_ERROR;
+ }
+
+ is_tag_implicit=0;
+ }
+ else{ /* TAG_IMPLICIT */
+ if(!is_tag_implicit){
+ if((type_field(node->type)==TYPE_SEQUENCE) ||
+ (type_field(node->type)==TYPE_SEQUENCE_OF) ||
+ (type_field(node->type)==TYPE_SET) ||
+ (type_field(node->type)==TYPE_SET_OF)) class2|=STRUCTURED;
+ class_implicit=class2;
+ tag_implicit=strtoul(p->value,NULL,10);
+ is_tag_implicit=1;
+ }
+ }
+ }
+ p=p->right;
+ }
+ }
+
+ if(is_tag_implicit){
+ tag=_asn1_get_tag_der(der+counter,&class,&len2);
+ if((class!=class_implicit) || (tag!=tag_implicit)) return ASN_TAG_ERROR;
+ }
+ else{
+ if(type_field(node->type)==TYPE_TAG){
+ counter=0;
+ *der_len=counter;
+ return ASN_OK;
+ }
+
+ tag=_asn1_get_tag_der(der+counter,&class,&len2);
+ switch(type_field(node->type)){
+ case TYPE_NULL:
+ if((class!=UNIVERSAL) || (tag!=TAG_NULL)) return ASN_DER_ERROR;
+ break;
+ case TYPE_BOOLEAN:
+ if((class!=UNIVERSAL) || (tag!=TAG_BOOLEAN)) return ASN_DER_ERROR;
+ break;
+ case TYPE_INTEGER:
+ if((class!=UNIVERSAL) || (tag!=TAG_INTEGER)) return ASN_DER_ERROR;
+ break;
+ case TYPE_ENUMERATED:
+ if((class!=UNIVERSAL) || (tag!=TAG_ENUMERATED)) return ASN_DER_ERROR;
+ break;
+ case TYPE_OBJECT_ID:
+ if((class!=UNIVERSAL) || (tag!=TAG_OBJECT_ID)) return ASN_DER_ERROR;
+ break;
+ case TYPE_TIME:
+ if(node->type&CONST_UTC){
+ if((class!=UNIVERSAL) || (tag!=TAG_UTCTime)) return ASN_DER_ERROR;
+ }
+ else{
+ if((class!=UNIVERSAL) || (tag!=TAG_GENERALIZEDTime))
+ return ASN_DER_ERROR;
+ }
+ break;
+ case TYPE_OCTET_STRING:
+ if((class!=UNIVERSAL) || (tag!=TAG_OCTET_STRING)) return ASN_DER_ERROR;
+ break;
+ case TYPE_BIT_STRING:
+ if((class!=UNIVERSAL) || (tag!=TAG_BIT_STRING)) return ASN_DER_ERROR;
+ break;
+ case TYPE_SEQUENCE: case TYPE_SEQUENCE_OF:
+ if((class!=(UNIVERSAL|STRUCTURED)) || (tag!=TAG_SEQUENCE))
+ return ASN_DER_ERROR;
+ break;
+ case TYPE_SET: case TYPE_SET_OF:
+ if((class!=(UNIVERSAL|STRUCTURED)) || (tag!=TAG_SET))
+ return ASN_DER_ERROR;
+ break;
+ case TYPE_ANY:
+ counter-=len2;
+ break;
+ default:
+ return ASN_DER_ERROR;
+ break;
+ }
+ }
+
+ counter+=len2;
+ *der_len=counter;
+ return ASN_OK;
+}
+
+
+void
+_asn1_ordering_set(unsigned char *der,node_asn *node)
+{
+ struct vet{
+ int end;
+ unsigned long value;
+ struct vet *next,*prev;
+ };
+
+ int counter,len,len2;
+ struct vet *first,*last,*p_vet,*p2_vet;
+ node_asn *p;
+ unsigned char class,*temp;
+ unsigned long tag;
+
+ counter=0;
+
+ if(type_field(node->type)!=TYPE_SET) return;
+
+ p=node->down;
+ while((type_field(p->type)==TYPE_TAG) || (type_field(p->type)==TYPE_SIZE)) p=p->right;
+
+ if((p==NULL) || (p->right==NULL)) return;
+
+ first=last=NULL;
+ while(p){
+ p_vet=(struct vet *)_asn1_alloca( sizeof(struct vet));
+ if (p_vet==NULL) return;
+
+ p_vet->next=NULL;
+ p_vet->prev=last;
+ if(first==NULL) first=p_vet;
+ else last->next=p_vet;
+ last=p_vet;
+
+ /* tag value calculation */
+ tag=_asn1_get_tag_der(der+counter,&class,&len2);
+ p_vet->value=(class<<24)|tag;
+ counter+=len2;
+
+ /* extraction and length */
+ len2=_asn1_get_length_der(der+counter,&len);
+ counter+=len+len2;
+
+ p_vet->end=counter;
+ p=p->right;
+ }
+
+ p_vet=first;
+
+ while(p_vet){
+ p2_vet=p_vet->next;
+ counter=0;
+ while(p2_vet){
+ if(p_vet->value>p2_vet->value){
+ /* change position */
+ temp=(unsigned char *)_asn1_alloca( p_vet->end-counter);
+ if (temp==NULL) return;
+
+ memcpy(temp,der+counter,p_vet->end-counter);
+ memmove(der+counter,der+p_vet->end,p2_vet->end-p_vet->end);
+ memcpy(der+p_vet->end,temp,p_vet->end-counter);
+ _asn1_afree(temp);
+
+ tag=p_vet->value;
+ p_vet->value=p2_vet->value;
+ p2_vet->value=tag;
+
+ p_vet->end=counter+(p2_vet->end-p_vet->end);
+ }
+ counter=p_vet->end;
+
+ p2_vet=p2_vet->next;
+ p_vet=p_vet->next;
+ }
+
+ if(p_vet!=first) p_vet->prev->next=NULL;
+ else first=NULL;
+ _asn1_afree(p_vet);
+ p_vet=first;
+ }
+}
+
+
+void
+_asn1_ordering_set_of(unsigned char *der,node_asn *node)
+{
+ struct vet{
+ int end;
+ struct vet *next,*prev;
+ };
+
+ int counter,len,len2,change;
+ struct vet *first,*last,*p_vet,*p2_vet;
+ node_asn *p;
+ unsigned char *temp,class;
+ unsigned long k,max;
+
+ counter=0;
+
+ if(type_field(node->type)!=TYPE_SET_OF) return;
+
+ p=node->down;
+ while((type_field(p->type)==TYPE_TAG) || (type_field(p->type)==TYPE_SIZE)) p=p->right;
+ p=p->right;
+
+ if((p==NULL) || (p->right==NULL)) return;
+
+ first=last=NULL;
+ while(p){
+ p_vet=(struct vet *)_asn1_alloca(sizeof(struct vet));
+ if (p_vet==NULL) return;
+
+ p_vet->next=NULL;
+ p_vet->prev=last;
+ if(first==NULL) first=p_vet;
+ else last->next=p_vet;
+ last=p_vet;
+
+ /* extraction of tag and length */
+ _asn1_get_tag_der(der+counter,&class,&len);
+ counter+=len;
+ len2=_asn1_get_length_der(der+counter,&len);
+ counter+=len+len2;
+
+ p_vet->end=counter;
+ p=p->right;
+ }
+
+ p_vet=first;
+
+ while(p_vet){
+ p2_vet=p_vet->next;
+ counter=0;
+ while(p2_vet){
+ if((p_vet->end-counter)>(p2_vet->end-p_vet->end))
+ max=p_vet->end-counter;
+ else
+ max=p2_vet->end-p_vet->end;
+
+ change=-1;
+ for(k=0;k<max;k++)
+ if(der[counter+k]>der[p_vet->end+k]){change=1;break;}
+ else if(der[counter+k]<der[p_vet->end+k]){change=0;break;}
+
+ if((change==-1) && ((p_vet->end-counter)>(p2_vet->end-p_vet->end)))
+ change=1;
+
+ if(change==1){
+ /* change position */
+ temp=(unsigned char *)_asn1_alloca(p_vet->end-counter);
+ if (temp==NULL) return;
+
+ memcpy(temp,der+counter,p_vet->end-counter);
+ memmove(der+counter,der+p_vet->end,p2_vet->end-p_vet->end);
+ memcpy(der+p_vet->end,temp,p_vet->end-counter);
+ _asn1_afree(temp);
+
+ p_vet->end=counter+(p2_vet->end-p_vet->end);
+ }
+ counter=p_vet->end;
+
+ p2_vet=p2_vet->next;
+ p_vet=p_vet->next;
+ }
+
+ if(p_vet!=first) p_vet->prev->next=NULL;
+ else first=NULL;
+ _asn1_afree(p_vet);
+ p_vet=first;
+ }
+}
+
+/**
+ * asn1_create_der - Creates the DER encoding for the NAME structure
+ * @root: pointer to a structure
+ * @name: the name of the structure you want to encode (it must be inside *POINTER).
+ * @der: vector that will contain the DER encoding. DER must be a pointer to memory cells already allocated.
+ * @len: number of bytes of *der: der[0]..der[len-1]
+ * Description:
+ *
+ * Creates the DER encoding for the NAME structure (inside *POINTER structure).
+ *
+ * Returns:
+ *
+ * ASN_OK\: DER encoding OK
+ *
+ * ASN_ELEMENT_NOT_FOUND\: NAME is not a valid element.
+ *
+ * ASN_VALUE_NOT_FOUND\: there is an element without a value.
+ **/
+int
+asn1_create_der(node_asn *root,char *name,unsigned char *der,int *len)
+{
+ node_asn *node,*p;
+ char temp[20];
+ int counter,counter_old,len2,len3,move,ris;
+
+ node=_asn1_find_node(root,name);
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ counter=0;
+ move=DOWN;
+ p=node;
+ while(1){
+
+ counter_old=counter;
+ if(move!=UP) ris=_asn1_insert_tag_der(p,der,&counter);
+
+ switch(type_field(p->type)){
+ case TYPE_NULL:
+ der[counter]=0;
+ counter++;
+ move=RIGHT;
+ break;
+ case TYPE_BOOLEAN:
+ if((p->type&CONST_DEFAULT) && (p->value==NULL)) counter=counter_old;
+ else{
+ der[counter++]=1;
+ if(p->value[0]=='F') der[counter++]=0;
+ else der[counter++]=0xFF;
+ }
+ move=RIGHT;
+ break;
+ case TYPE_INTEGER: case TYPE_ENUMERATED:
+ if((p->type&CONST_DEFAULT) && (p->value==NULL)) counter=counter_old;
+ else{
+ len2=_asn1_get_length_der(p->value,&len3);
+ memcpy(der+counter,p->value,len3+len2);
+ counter+=len3+len2;
+ }
+ move=RIGHT;
+ break;
+ case TYPE_OBJECT_ID:
+ _asn1_objectid_der(p->value,der+counter,&len2);
+ counter+=len2;
+ move=RIGHT;
+ break;
+ case TYPE_TIME:
+ _asn1_time_der(p->value,der+counter,&len2);
+ counter+=len2;
+ move=RIGHT;
+ break;
+ case TYPE_OCTET_STRING:
+ len2=_asn1_get_length_der(p->value,&len3);
+ memcpy(der+counter,p->value,len3+len2);
+ counter+=len3+len2;
+ move=RIGHT;
+ break;
+ case TYPE_BIT_STRING:
+ len2=_asn1_get_length_der(p->value,&len3);
+ memcpy(der+counter,p->value,len3+len2);
+ counter+=len3+len2;
+ move=RIGHT;
+ break;
+ case TYPE_SEQUENCE: case TYPE_SET:
+ if(move!=UP){
+ _asn1_ltostr(counter,temp);
+ _asn1_set_value(p,temp,strlen(temp)+1);
+ move=DOWN;
+ }
+ else{ /* move==UP */
+ len2=strtol(p->value,NULL,10);
+ _asn1_set_value(p,NULL,0);
+ if(type_field(p->type)==TYPE_SET) _asn1_ordering_set(der+len2,p);
+ _asn1_length_der(counter-len2,temp,&len3);
+ memmove(der+len2+len3,der+len2,counter-len2);
+ memcpy(der+len2,temp,len3);
+ counter+=len3;
+ move=RIGHT;
+ }
+ break;
+ case TYPE_SEQUENCE_OF: case TYPE_SET_OF:
+ if(move!=UP){
+ _asn1_ltostr(counter,temp);
+ _asn1_set_value(p,temp,strlen(temp)+1);
+ p=p->down;
+ while((type_field(p->type)==TYPE_TAG) || (type_field(p->type)==TYPE_SIZE)) p=p->right;
+ if(p->right){
+ p=p->right;
+ move=RIGHT;
+ continue;
+ }
+ else p=_asn1_find_up(p);
+ move=UP;
+ }
+ if(move==UP){
+ len2=strtol(p->value,NULL,10);
+ _asn1_set_value(p,NULL,0);
+ if(type_field(p->type)==TYPE_SET_OF) _asn1_ordering_set_of(der+len2,p);
+ _asn1_length_der(counter-len2,temp,&len3);
+ memmove(der+len2+len3,der+len2,counter-len2);
+ memcpy(der+len2,temp,len3);
+ counter+=len3;
+ move=RIGHT;
+ }
+ break;
+ case TYPE_ANY:
+ len2=_asn1_get_length_der(p->value,&len3);
+ memcpy(der+counter,p->value+len3,len2);
+ counter+=len2;
+ move=RIGHT;
+ break;
+ default:
+ move=(move==UP)?RIGHT:DOWN;
+ break;
+ }
+
+ if((move!=DOWN) && (counter!=counter_old))
+ _asn1_complete_explicit_tag(p,der,&counter);
+
+ if(p==node && move!=DOWN) break;
+
+ if(move==DOWN){
+ if(p->down) p=p->down;
+ else move=RIGHT;
+ }
+ if(move==RIGHT){
+ if(p->right) p=p->right;
+ else move=UP;
+ }
+ if(move==UP) p=_asn1_find_up(p);
+ }
+
+ *len=counter;
+ return ASN_OK;
+}
+
+/**
+ * asn1_get_der - Fill the structure *POINTER with values of a DER encoding string.
+ * @root: pointer to a structure
+ * @der: vector that contains the DER encoding.
+ * @len: number of bytes of *der: der[0]..der[len-1]
+ * Description:
+ *
+ * Fill the structure *POINTER with values of a DER encoding string. The sructure must just be
+ * created with function 'create_stucture'.
+ *
+ * Returns:
+ *
+ * ASN_OK\: DER encoding OK
+ *
+ * ASN_ELEMENT_NOT_FOUND\: NAME is not a valid element.
+ *
+ * ASN_TAG_ERROR,ASN_DER_ERROR\: the der encoding doesn't match the structure NAME.
+ **/
+
+int
+asn1_get_der(node_asn *root,unsigned char *der,int len)
+{
+ node_asn *node,*p,*p2,*p3;
+ char temp[128];
+ int counter,len2,len3,len4,move,ris;
+ unsigned char class,*temp2;
+ unsigned int tag;
+
+ node=root;
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ if(node->type&CONST_OPTION) return ASN_GENERIC_ERROR;
+
+ counter=0;
+ move=DOWN;
+ p=node;
+ while(1){
+ ris=ASN_OK;
+
+ if(move!=UP){
+ if(p->type&CONST_SET){
+ p2=_asn1_find_up(p);
+ len2=strtol(p2->value,NULL,10);
+ if(counter==len2){
+ p=p2;
+ move=UP;
+ continue;
+ }
+ else if(counter>len2) return ASN_DER_ERROR;
+ p2=p2->down;
+ while(p2){
+ if((p2->type&CONST_SET) && (p2->type&CONST_NOT_USED)){ /* CONTROLLARE */
+ if(type_field(p2->type)!=TYPE_CHOICE)
+ ris=_asn1_extract_tag_der(p2,der+counter,&len2);
+ else{
+ p3=p2->down;
+ while(p3){
+ ris=_asn1_extract_tag_der(p3,der+counter,&len2);
+ if(ris==ASN_OK) break;
+ //if(ris==ASN_ERROR_TYPE_ANY) return ASN_ERROR_TYPE_ANY;
+ p3=p3->right;
+ }
+ }
+ if(ris==ASN_OK){
+ p2->type&=~CONST_NOT_USED;
+ p=p2;
+ break;
+ }
+ //else if(ris==ASN_ERROR_TYPE_ANY) return ASN_ERROR_TYPE_ANY;
+ }
+ p2=p2->right;
+ }
+ if(p2==NULL) return ASN_DER_ERROR;
+ }
+
+ if(type_field(p->type)==TYPE_CHOICE){
+ while(p->down){
+ ris=_asn1_extract_tag_der(p->down,der+counter,&len2);
+ if(ris==ASN_OK){
+ while(p->down->right) asn1_delete_structure(p->down->right);
+ break;
+ }
+ else if(ris==ASN_ERROR_TYPE_ANY) return ASN_ERROR_TYPE_ANY;
+ else asn1_delete_structure(p->down);
+ }
+ if(p->down==NULL) return ASN_DER_ERROR;
+ p=p->down;
+ }
+
+ if((p->type&CONST_OPTION) || (p->type&CONST_DEFAULT)){
+ p2=_asn1_find_up(p);
+ len2=strtol(p2->value,NULL,10);
+ if(counter>=len2) ris=ASN_TAG_ERROR;
+ }
+
+ if(ris==ASN_OK) ris=_asn1_extract_tag_der(p,der+counter,&len2);
+ if(ris!=ASN_OK){
+ //if(ris==ASN_ERROR_TYPE_ANY) return ASN_ERROR_TYPE_ANY;
+ if(p->type&CONST_OPTION){
+ p->type|=CONST_NOT_USED;
+ move=RIGHT;
+ }
+ else if(p->type&CONST_DEFAULT) {
+ _asn1_set_value(p,NULL,0);
+ move=RIGHT;
+ }
+ else {
+ //return (type_field(p->type)!=TYPE_ANY)?ASN_TAG_ERROR:ASN_ERROR_TYPE_ANY;
+ return ASN_TAG_ERROR;
+ }
+ }
+ else counter+=len2;
+ }
+
+ if(ris==ASN_OK){
+ switch(type_field(p->type)){
+ case TYPE_NULL:
+ if(der[counter]) return ASN_DER_ERROR;
+ counter++;
+ move=RIGHT;
+ break;
+ case TYPE_BOOLEAN:
+ if(der[counter++]!=1) return ASN_DER_ERROR;
+ if(der[counter++]==0) _asn1_set_value(p,"F",1);
+ else _asn1_set_value(p,"T",1);
+ move=RIGHT;
+ break;
+ case TYPE_INTEGER: case TYPE_ENUMERATED:
+ len2=_asn1_get_length_der(der+counter,&len3);
+ _asn1_set_value(p,der+counter,len3+len2);
+ counter+=len3+len2;
+ move=RIGHT;
+ break;
+ case TYPE_OBJECT_ID:
+ _asn1_get_objectid_der(der+counter,&len2, temp, sizeof(temp));
+ _asn1_set_value(p,temp,strlen(temp)+1);
+ counter+=len2;
+ move=RIGHT;
+ break;
+ case TYPE_TIME:
+ _asn1_get_time_der(der+counter,&len2,temp);
+ _asn1_set_value(p,temp,strlen(temp)+1);
+ counter+=len2;
+ move=RIGHT;
+ break;
+ case TYPE_OCTET_STRING:
+ len2=_asn1_get_length_der(der+counter,&len3);
+ _asn1_set_value(p,der+counter,len3+len2);
+ counter+=len3+len2;
+ move=RIGHT;
+ break;
+ case TYPE_BIT_STRING:
+ len2=_asn1_get_length_der(der+counter,&len3);
+ _asn1_set_value(p,der+counter,len3+len2);
+ counter+=len3+len2;
+ move=RIGHT;
+ break;
+ case TYPE_SEQUENCE: case TYPE_SET:;
+ if(move==UP){
+ len2=strtol(p->value,NULL,10);
+ _asn1_set_value(p,NULL,0);
+ if(len2!=counter) return ASN_DER_ERROR;
+ move=RIGHT;
+ }
+ else{ /* move==DOWN || move==RIGHT */
+ len3=_asn1_get_length_der(der+counter,&len2);
+ counter+=len2;
+ _asn1_ltostr(counter+len3,temp);
+ _asn1_set_value(p,temp,strlen(temp)+1);
+ move=DOWN;
+ }
+ break;
+ case TYPE_SEQUENCE_OF: case TYPE_SET_OF:
+ if(move==UP){
+ len2=strtol(p->value,NULL,10);
+ if(len2>counter){
+ _asn1_append_sequence_set(p);
+ p=p->down;
+ while(p->right) p=p->right;
+ move=RIGHT;
+ continue;
+ }
+ _asn1_set_value(p,NULL,0);
+ if(len2!=counter) return ASN_DER_ERROR;
+ }
+ else{ /* move==DOWN || move==RIGHT */
+ len3=_asn1_get_length_der(der+counter,&len2);
+ counter+=len2;
+ if(len3){
+ _asn1_ltostr(counter+len3,temp);
+ _asn1_set_value(p,temp,strlen(temp)+1);
+ p2=p->down;
+ while((type_field(p2->type)==TYPE_TAG) || (type_field(p2->type)==TYPE_SIZE)) p2=p2->right;
+ if(p2->right==NULL) _asn1_append_sequence_set(p);
+ p=p2;
+ }
+ }
+ move=RIGHT;
+ break;
+ case TYPE_ANY:
+ tag=_asn1_get_tag_der(der+counter,&class,&len2);
+ len2+=_asn1_get_length_der(der+counter+len2,&len3);
+ _asn1_length_der(len2+len3,NULL,&len4);
+ temp2=(unsigned char *)_asn1_alloca(len2+len3+len4);
+ if (temp2==NULL) return ASN_MEM_ERROR;
+
+ _asn1_octet_der(der+counter,len2+len3,temp2,&len4);
+ _asn1_set_value(p,temp2,len4);
+ _asn1_afree(temp2);
+ counter+=len2+len3;
+ move=RIGHT;
+ break;
+ default:
+ move=(move==UP)?RIGHT:DOWN;
+ break;
+ }
+ }
+
+ if(p==node && move!=DOWN) break;
+
+ if(move==DOWN){
+ if(p->down) p=p->down;
+ else move=RIGHT;
+ }
+ if((move==RIGHT) && !(p->type&CONST_SET)){
+ if(p->right) p=p->right;
+ else move=UP;
+ }
+ if(move==UP) p=_asn1_find_up(p);
+ }
+
+ _asn1_delete_not_used(root);
+
+ return (counter==len)?ASN_OK:ASN_DER_ERROR;
+}
+
+
+/**
+ * asn1_get_start_end_der - Find the start and end point of an element in a DER encoding string.
+ * @root: pointer to a structure
+ * @der: vector that contains the DER encoding.
+ * @len: number of bytes of *der: der[0]..der[len-1]
+ * @name_element: an element of NAME structure.
+ * @start: the position of the first byte of NAME_ELEMENT decoding (der[*start])
+ * @end: the position of the last byte of NAME_ELEMENT decoding (der[*end])
+ * Description:
+ *
+ * Find the start and end point of an element in a DER encoding string. I mean that if you
+ * have a der encoding and you have already used the function "get_der" to fill a structure, it may
+ * happen that you want to find the piece of string concerning an element of the structure.
+ *
+ * Example: the sequence "tbsCertificate" inside an X509 certificate.
+ *
+ * Returns:
+ *
+ * ASN_OK\: DER encoding OK
+ *
+ * ASN_ELEMENT_NOT_FOUND\: NAME or NAME_ELEMENT is not a valid element.
+ *
+ * ASN_TAG_ERROR,ASN_DER_ERROR\: the der encoding doesn't match the structure NAME.
+ *
+ **/
+int
+asn1_get_start_end_der(node_asn *root,unsigned char *der,int len,char *name_element,int *start, int *end)
+{
+ node_asn *node,*node_to_find,*p,*p2,*p3;
+ int counter,len2,len3,move,ris;
+ unsigned char class;
+ unsigned int tag;
+
+ node=root;
+ node_to_find=_asn1_find_node(root,name_element);
+
+ if(node_to_find==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ if(node_to_find==node){
+ *start=0;
+ *end=len-1;
+ return ASN_OK;
+ }
+
+ if(node==NULL) return ASN_ELEMENT_NOT_FOUND;
+
+ if(node->type&CONST_OPTION) return ASN_GENERIC_ERROR;
+
+ counter=0;
+ move=DOWN;
+ p=node;
+ while(1){
+ ris=ASN_OK;
+
+ if(move!=UP){
+ if(p->type&CONST_SET){
+ p2=_asn1_find_up(p);
+ len2=strtol(p2->value,NULL,10);
+ if(counter==len2){
+ p=p2;
+ move=UP;
+ continue;
+ }
+ else if(counter>len2) return ASN_DER_ERROR;
+ p2=p2->down;
+ while(p2){
+ if((p2->type&CONST_SET) && (p2->type&CONST_NOT_USED)){ /* CONTROLLARE */
+ if(type_field(p2->type)!=TYPE_CHOICE)
+ ris=_asn1_extract_tag_der(p2,der+counter,&len2);
+ else{
+ p3=p2->down;
+ ris=_asn1_extract_tag_der(p3,der+counter,&len2);
+ }
+ if(ris==ASN_OK){
+ p2->type&=~CONST_NOT_USED;
+ p=p2;
+ break;
+ }
+ }
+ p2=p2->right;
+ }
+ if(p2==NULL) return ASN_DER_ERROR;
+ }
+
+ if(p==node_to_find) *start=counter;
+
+ if(type_field(p->type)==TYPE_CHOICE){
+ p=p->down;
+ ris=_asn1_extract_tag_der(p,der+counter,&len2);
+ if(p==node_to_find) *start=counter;
+ }
+
+ if(ris==ASN_OK) ris=_asn1_extract_tag_der(p,der+counter,&len2);
+ if(ris!=ASN_OK){
+ if(p->type&CONST_OPTION){
+ p->type|=CONST_NOT_USED;
+ move=RIGHT;
+ }
+ else if(p->type&CONST_DEFAULT) {
+ move=RIGHT;
+ }
+ else {
+ return ASN_TAG_ERROR;
+ }
+ }
+ else counter+=len2;
+ }
+
+ if(ris==ASN_OK){
+ switch(type_field(p->type)){
+ case TYPE_NULL:
+ if(der[counter]) return ASN_DER_ERROR;
+ counter++;
+ move=RIGHT;
+ break;
+ case TYPE_BOOLEAN:
+ if(der[counter++]!=1) return ASN_DER_ERROR;
+ counter++;
+ move=RIGHT;
+ break;
+ case TYPE_INTEGER: case TYPE_ENUMERATED:
+ len2=_asn1_get_length_der(der+counter,&len3);
+ counter+=len3+len2;
+ move=RIGHT;
+ break;
+ case TYPE_OBJECT_ID:
+ len2=_asn1_get_length_der(der+counter,&len3);
+ counter+=len2+len3;
+ move=RIGHT;
+ break;
+ case TYPE_TIME:
+ len2=_asn1_get_length_der(der+counter,&len3);
+ counter+=len2+len3;
+ move=RIGHT;
+ break;
+ case TYPE_OCTET_STRING:
+ len2=_asn1_get_length_der(der+counter,&len3);
+ counter+=len3+len2;
+ move=RIGHT;
+ break;
+ case TYPE_BIT_STRING:
+ len2=_asn1_get_length_der(der+counter,&len3);
+ counter+=len3+len2;
+ move=RIGHT;
+ break;
+ case TYPE_SEQUENCE: case TYPE_SET:
+ if(move!=UP){
+ len3=_asn1_get_length_der(der+counter,&len2);
+ counter+=len2;
+ move=DOWN;
+ }
+ else move=RIGHT;
+ break;
+ case TYPE_SEQUENCE_OF: case TYPE_SET_OF:
+ if(move!=UP){
+ len3=_asn1_get_length_der(der+counter,&len2);
+ counter+=len2;
+ if(len3){
+ p2=p->down;
+ while((type_field(p2->type)==TYPE_TAG) ||
+ (type_field(p2->type)==TYPE_SIZE)) p2=p2->right;
+ p=p2;
+ }
+ }
+ move=RIGHT;
+ break;
+ case TYPE_ANY:
+ tag=_asn1_get_tag_der(der+counter,&class,&len2);
+ len2+=_asn1_get_length_der(der+counter+len2,&len3);
+ counter+=len3+len2;
+ move=RIGHT;
+ break;
+ default:
+ move=(move==UP)?RIGHT:DOWN;
+ break;
+ }
+ }
+
+ if((p==node_to_find) && (move==RIGHT)){
+ *end=counter-1;
+ return ASN_OK;
+ }
+
+ if(p==node && move!=DOWN) break;
+
+ if(move==DOWN){
+ if(p->down) p=p->down;
+ else move=RIGHT;
+ }
+ if((move==RIGHT) && !(p->type&CONST_SET)){
+ if(p->right) p=p->right;
+ else move=UP;
+ }
+ if(move==UP) p=_asn1_find_up(p);
+ }
+
+ return ASN_ELEMENT_NOT_FOUND;
+}
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+/*************************************************/
+/* File: x509_der.h */
+/* Description: list of exported object by */
+/* "x509_der.c" */
+/*************************************************/
+
+#ifndef _GNUTLS_DER_H
+#define _GNUTLS_DER_H
+
+#include "asn1.h"
+
+#define UNIVERSAL 0x00
+#define APPLICATION 0x40
+#define CONTEXT_SPECIFIC 0x80
+#define PRIVATE 0xC0
+#define STRUCTURED 0x20
+
+
+void
+_asn1_octet_der(unsigned char *str,int str_len,unsigned char *der,int *der_len);
+
+int
+_asn1_get_octet_der(unsigned char *der,int *der_len,unsigned char *str,int str_size, int *str_len);
+
+void
+_asn1_bit_der(unsigned char *str,int bit_len,unsigned char *der,int *der_len);
+
+int
+_asn1_get_bit_der(unsigned char *der,int *der_len,unsigned char *str, int str_size, int *bit_len);
+
+int
+asn1_create_der(node_asn *root,char *name,unsigned char *der,int *len);
+
+int
+asn1_get_der(node_asn *root,unsigned char *der,int len);
+
+int
+asn1_get_start_end_der(node_asn *root,unsigned char *der,int len,char *name_element,int *start, int *end);
+
+unsigned long
+_asn1_get_length_der(unsigned char *der,int *len);
+
+void
+_asn1_length_der(unsigned long len,unsigned char *ans,int *ans_len);
+
+char *
+_asn1_ltostr(long v,char *str);
+
+#endif
+
+
+
+
+
--- /dev/null
+/*
+ * Copyright (C) 2002 Nikos Mavroyanopoulos
+ *
+ * This file is part of GNUTLS.
+ *
+ * GNUTLS 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.
+ *
+ * GNUTLS 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <defines.h>
+
+/* These function are like strcat, strcpy. They only
+ * do bound checking (they shouldn't cause buffer overruns),
+ * and they always produce null terminated strings.
+ *
+ * They should be used only with null terminated strings.
+ */
+void _asn1_str_cat( char* dest, size_t dest_tot_size, const char* src) {
+size_t str_size = strlen(src);
+size_t dest_size = strlen(dest);
+
+ if ( dest_tot_size - dest_size > str_size) {
+ strcat( dest, src);
+ } else {
+ if ( dest_tot_size - dest_size > 0) {
+ strncat( dest, src, (dest_tot_size - dest_size) -1);
+ dest[dest_tot_size-1] = 0;
+ }
+ }
+}
+
+void _asn1_str_cpy( char* dest, size_t dest_tot_size, const char* src) {
+size_t str_size = strlen(src);
+
+ if ( dest_tot_size > str_size) {
+ strcpy( dest, src);
+ } else {
+ if ( dest_tot_size > 0) {
+ strncpy( dest, src, (dest_tot_size) -1);
+ dest[dest_tot_size-1] = 0;
+ }
+ }
+}
+
+void _asn1_mem_cpy( char* dest, size_t dest_tot_size, const char* src, size_t src_size)
+{
+
+ if ( dest_tot_size >= src_size) {
+ memcpy( dest, src, src_size);
+ } else {
+ if ( dest_tot_size > 0) {
+ memcpy( dest, src, dest_tot_size);
+ }
+ }
+}
--- /dev/null
+void _asn1_str_cpy( char* dest, size_t dest_tot_size, const char* src);
+void _asn1_mem_cpy( char* dest, size_t dest_tot_size, const char* src, size_t src_size);
+void _asn1_str_cat( char* dest, size_t dest_tot_size, const char* src);
--- /dev/null
+#ifndef MEM_H
+# define MEM_H
+
+/* Use _asn1_afree() when calling alloca, or
+ * memory leaks may occur in systems which do not
+ * support alloca.
+ */
+#ifdef HAVE_ALLOCA
+# define _asn1_alloca alloca
+# define _asn1_afree(x)
+#else
+# define _asn1_alloca _asn1_malloc
+# define _asn1_afree _asn1_free
+#endif /* HAVE_ALLOCA */
+
+#define _asn1_malloc malloc
+#define _asn1_free free
+#define _asn1_calloc calloc
+#define _asn1_realloc realloc
+#define _asn1_strdup strdup
+
+#endif /* MEM_H */
--- /dev/null
+/*
+ * Copyright (C) 2000,2001 Fabio Fiorina
+ *
+ * This file is part of GNUTLS.
+ *
+ * GNUTLS 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.
+ *
+ * GNUTLS 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+/*****************************************************/
+/* File: CertificateExample.c */
+/* Description: An example on how to use the ASN1 */
+/* parser with the Certificate.txt file */
+/*****************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include "../lib/asn1.h"
+#include "../lib/der.h"
+
+/******************************************************/
+/* Function : get_name_type */
+/* Description: analyze a structure of type Name */
+/* Parameters: */
+/* char *root: the structure identifier */
+/* char *answer: the string with elements like: */
+/* "C=US O=gov" */
+/******************************************************/
+void
+get_Name_type(node_asn *cert_def,node_asn *cert,char *root, char *answer)
+{
+ int k,k2,result,len;
+ char name[128],str[1024],str2[1024],name2[128],counter[5],name3[128];
+ node_asn *value;
+
+ answer[0]=0;
+ k=1;
+ do{
+ strcpy(name,root);
+ strcat(name,".rdnSequence.?");
+ _asn1_ltostr(k,counter);
+ strcat(name,counter);
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert,name,str,&len);
+ if(result==ASN_ELEMENT_NOT_FOUND) break;
+ k2=1;
+ do{
+ strcpy(name2,name);
+ strcat(name2,".?");
+ _asn1_ltostr(k2,counter);
+ strcat(name2,counter);
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert,name2,str,&len);
+ if(result==ASN_ELEMENT_NOT_FOUND) break;
+ strcpy(name3,name2);
+ strcat(name3,".type");
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert,name3,str,&len);
+ strcpy(name3,name2);
+ strcat(name3,".value");
+ if(result==ASN_OK){
+ len = sizeof(str2) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",
+ str2,&len);
+ if(!strcmp(str,str2)){
+ asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationName",
+ &value,"certificate2-subject-C");
+ len = sizeof(str) - 1;
+ asn1_read_value(cert,name3,str,&len);
+ asn1_get_der(value,str,len);
+ strcpy(name3,"certificate2-subject-C");
+ len = sizeof(str) - 1;
+ asn1_read_value(value,name3,str,&len); /* CHOICE */
+ strcat(name3,".");
+ strcat(name3,str);
+ len = sizeof(str) - 1;
+ asn1_read_value(value,name3,str,&len);
+ str[len]=0;
+ strcat(answer," C=");
+ strcat(answer,str);
+ asn1_delete_structure(value);
+ }
+ else{
+ len = sizeof(str2) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName"
+ ,str2,&len);
+ if(!strcmp(str,str2)){
+ asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationName"
+ ,&value,"certificate2-subject-O");
+ len = sizeof(str) - 1;
+ asn1_read_value(cert,name3,str,&len);
+ asn1_get_der(value,str,len);
+ strcpy(name3,"certificate2-subject-O");
+ len = sizeof(str) - 1;
+ asn1_read_value(value,name3,str,&len); /* CHOICE */
+ strcat(name3,".");
+ strcat(name3,str);
+ len = sizeof(str) - 1;
+ asn1_read_value(value,name3,str,&len);
+ str[len]=0;
+ strcat(answer," O=");
+ strcat(answer,str);
+ asn1_delete_structure(value);
+ }
+ else{
+ len = sizeof(str2) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",str2,&len);
+ if(!strcmp(str,str2)){
+ asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value,"certificate2-subject-OU");
+ len = sizeof(str) - 1;
+ asn1_read_value(cert,name3,str,&len);
+ asn1_get_der(value,str,len);
+ strcpy(name3,"certificate2-subject-OU");
+ len = sizeof(str) - 1;
+ asn1_read_value(value,name3,str,&len); /* CHOICE */
+ strcat(name3,".");
+ strcat(name3,str);
+ len = sizeof(str) - 1;
+ asn1_read_value(value,name3,str,&len);
+ str[len]=0;
+ strcat(answer," OU=");
+ strcat(answer,str);
+ asn1_delete_structure(value);
+ }
+ }
+ }
+ }
+ k2++;
+ }while(1);
+ k++;
+ }while(1);
+}
+
+
+/******************************************************/
+/* Function : create_certificate */
+/* Description: creates a certificate named */
+/* "certificate1". Values are the same */
+/* as in rfc2459 Appendix D.1 */
+/* Parameters: */
+/* unsigned char *der: contains the der encoding */
+/* int *der_len: number of bytes of der string */
+/******************************************************/
+void
+create_certificate(node_asn *cert_def,unsigned char *der,int *der_len)
+{
+ int result,k,len;
+ unsigned char str[1024],*str2;
+ node_asn *cert1,*value,*param,*constr;
+
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.Certificate",&cert1,"certificate1");
+
+ /* Use the next 3 lines to visit the empty certificate */
+ /* printf("-----------------\n");
+ asn1_visit_tree(cert1,"certificate1");
+ printf("-----------------\n"); */
+
+ /* version: v3(2) */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.version","v3",0);
+
+ /* serialNumber: 17 */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.serialNumber","17",0);
+
+ /* signature: dsa-with-sha1 */
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.signature.algorithm",
+ str,1);
+
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.signature.parameters",
+ NULL,0);
+
+
+ /* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer","rdnSequence",12);
+
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence","NEW",1);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
+ /* C */
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.X520countryName",
+ &value,"countryName");
+ result=asn1_write_value(value,"countryName","US",2);
+ result=asn1_create_der(value,"countryName",der,der_len);
+ asn1_delete_structure(value);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+
+
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence","NEW",1);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
+ /* O */
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationName",
+ &value,"OrgName");
+ result=asn1_write_value(value,"OrgName","printableString",1);
+ result=asn1_write_value(value,"OrgName.printableString","gov",3);
+ result=asn1_create_der(value,"OrgName",der,der_len);
+ asn1_delete_structure(value);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+
+
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence","NEW",1);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence.?LAST","NEW",1);
+
+ /* OU */
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
+ str,&len);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence.?LAST.?LAST.type",str,1);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value,"OrgUnitName");
+ result=asn1_write_value(value,"OrgUnitName","printableString",1);
+ result=asn1_write_value(value,"OrgUnitName.printableString","nist",4);
+ result=asn1_create_der(value,"OrgUnitName",der,der_len);
+ asn1_delete_structure(value);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+
+
+ /* validity */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.validity.notBefore","utcTime",1);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.validity.notBefore.utcTime","970630000000Z",1);
+
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.validity.notAfter","utcTime",1);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.validity.notAfter.utcTime","971231000000Z",1);
+
+
+
+ /* subject: Country="US" Organization="gov" OrganizationUnit="nist" */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject","rdnSequence",1);
+
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence","NEW",1);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence.?LAST","NEW",1);
+ /* C */
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.X520countryName",
+ &value,"countryName");
+ result=asn1_write_value(value,"countryName","US",2);
+ result=asn1_create_der(value,"countryName",der,der_len);
+ asn1_delete_structure(value);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
+
+
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence","NEW",4);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence.?LAST","NEW",4);
+ /* O */
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationName",
+ &value,"OrgName");
+ result=asn1_write_value(value,"OrgName","printableString",1);
+ result=asn1_write_value(value,"OrgName.printableString","gov",3);
+ result=asn1_create_der(value,"OrgName",der,der_len);
+ asn1_delete_structure(value);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
+
+
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence","NEW",4);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence.?LAST","NEW",4);
+ /* OU */
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
+ str,&len);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence.?LAST.?LAST.type",str,1);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value,"OrgUnitName");
+ result=asn1_write_value(value,"OrgUnitName","printableString",1);
+ result=asn1_write_value(value,"OrgUnitName.printableString","nist",4);
+ result=asn1_create_der(value,"OrgUnitName",der,der_len);
+ asn1_delete_structure(value);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subject.rdnSequence.?LAST.?LAST.value",der,*der_len);
+
+
+ /* subjectPublicKeyInfo: dsa with parameters=Dss-Parms */
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa",str,&len);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subjectPublicKeyInfo.algorithm.algorithm",str,1);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.Dss-Parms",¶m,"parameters");
+ str2="\xd4\x38"; /* only an example */
+ result=asn1_write_value(param,"parameters.p",str2,128);
+ str2="\xd4\x38"; /* only an example */
+ result=asn1_write_value(param,"parameters.q",str2,20);
+ str2="\xd4\x38"; /* only an example */
+ result=asn1_write_value(param,"parameters.g",str2,128);
+ result=asn1_create_der(param,"parameters",der,der_len);
+ asn1_delete_structure(param);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subjectPublicKeyInfo.algorithm.parameters",der,*der_len);
+
+
+ /* subjectPublicKey */
+ str2="\x02\x81"; /* only an example */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subjectPublicKeyInfo.subjectPublicKey",str2,1048);
+
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.issuerUniqueID",NULL,0); /* NO OPTION */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.subjectUniqueID",NULL,0); /* NO OPTION */
+
+ /* extensions */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.extensions","NEW",1);
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-basicConstraints",
+ str,&len);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.extensions.?LAST.extnID",str,1); /* basicConstraints */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.extensions.?LAST.critical","TRUE",1);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.BasicConstraints",&constr,
+ "basicConstraints1");
+ result=asn1_write_value(constr,"basicConstraints1.cA","TRUE",1);
+ result=asn1_write_value(constr,"basicConstraints1.pathLenConstraint",NULL,0);
+ result=asn1_create_der(constr,"basicConstraints1",der,der_len);
+ result=asn1_delete_structure(constr);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.extensions.?LAST.extnValue",der,*der_len);
+
+
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.extensions","NEW",1);
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-subjectKeyIdentifier",
+ str,&len);
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.extensions.?LAST.extnID",str,1); /* subjectKeyIdentifier */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.extensions.?LAST.critical","FALSE",1);
+ str2="\x04\x14\xe7\x26\xc5"; /* only an example */
+ result=asn1_write_value(cert1,"certificate1.tbsCertificate.extensions.?LAST.extnValue",str2,22);
+
+
+ /* signatureAlgorithm: dsa-with-sha */
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
+ result=asn1_write_value(cert1,"certificate1.signatureAlgorithm.algorithm",str,1);
+ result=asn1_write_value(cert1,"certificate1.signatureAlgorithm.parameters",NULL,0); /* NO OPTION */
+
+
+ /* signature */
+ result=asn1_create_der(cert1,"certificate1.tbsCertificate",der,der_len);
+ if(result!=ASN_OK){
+ printf("\n'tbsCertificate' encoding creation: ERROR\n");
+ // return;
+ }
+ /* add the lines for the signature on der[0]..der[der_len-1]: result in str2 */
+ result=asn1_write_value(cert1,"certificate1.signature",str2,368); /* dsa-with-sha */
+
+
+ /* Use the next 3 lines to visit the certificate */
+ /* printf("-----------------\n");
+ asn1_visit_tree(cert1,"certificate1");
+ printf("-----------------\n"); */
+
+
+ result=asn1_create_der(cert1,"certificate1",der,der_len);
+ if(result!=ASN_OK){
+ printf("\n'certificate1' encoding creation: ERROR\n");
+ return;
+ }
+
+ /* Print the 'Certificate1' DER encoding */
+ printf("-----------------\nCertificate1 Encoding:\nNumber of bytes=%i\n",*der_len);
+ for(k=0;k<*der_len;k++) printf("%02x ",der[k]);
+ printf("\n-----------------\n");
+
+ /* Clear the "certificate1" structure */
+ asn1_delete_structure(cert1);
+}
+
+
+
+/******************************************************/
+/* Function : get_certificate */
+/* Description: creates a certificate named */
+/* "certificate2" from a der encoding */
+/* string */
+/* Parameters: */
+/* unsigned char *der: the encoding string */
+/* int der_len: number of bytes of der string */
+/******************************************************/
+void
+get_certificate(node_asn *cert_def,unsigned char *der,int der_len)
+{
+ int result,len,start,end;
+ unsigned char str[1024],str2[1024];
+ node_asn *cert2;
+
+ asn1_create_structure(cert_def,"PKIX1Implicit88.Certificate",&cert2,"certificate2");
+
+ result=asn1_get_der(cert2,der,der_len);
+
+ if(result!=ASN_OK){
+ printf("Problems with DER encoding\n");
+ return;
+ }
+
+
+ /* issuer */
+ get_Name_type(cert_def,cert2,"certificate2.tbsCertificate.issuer",str);
+ printf("certificate2:\nissuer =%s\n",str);
+ /* subject */
+ get_Name_type(cert_def,cert2,"certificate2.tbsCertificate.subject",str);
+ printf("subject=%s\n",str);
+
+
+ /* Verify sign */
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert2,"certificate2.signatureAlgorithm.algorithm"
+ ,str,&len);
+
+ len = sizeof(str2) - 1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str2,&len);
+ if(!strcmp(str,str2)){ /* dsa-with-sha */
+
+ result=asn1_get_start_end_der(cert2,der,der_len,
+ "certificate2.tbsCertificate",&start,&end);
+
+ /* add the lines to calculate the sha on der[start]..der[end] */
+
+ len = sizeof(str) - 1;
+ result=asn1_read_value(cert2,"certificate2.signature",str,&len);
+
+ /* compare the previous value to signature ( with issuer public key) */
+ }
+
+ /* Use the next 3 lines to visit the certificate */
+ /* printf("-----------------\n");
+ asn1_visit_tree(cert2,"certificate2");
+ printf("-----------------\n"); */
+
+
+ /* Clear the "certificate2" structure */
+ asn1_delete_structure(cert2);
+}
+
+
+/********************************************************/
+/* Function : main */
+/* Description: reads the certificate description. */
+/* Creates a certificate and calculate */
+/* the der encoding. After that creates */
+/* another certificate from der string */
+/********************************************************/
+int
+main(int argc,char *argv[])
+{
+ int result,der_len;
+ unsigned char der[1024];
+ char file_name[128];
+ node_asn *PKIX1Implicit88;
+
+/* result=asn1_create_tree(pkix_asn1_tab,&PKIX1Implicit88); */
+
+ if(argc==2) strcpy(file_name,argv[1]);
+ else file_name[0]=0;
+
+ strcat(file_name,"pkix.asn");
+
+ result=asn1_parser_asn1(file_name,&PKIX1Implicit88);
+
+ if(result==ASN_FILE_NOT_FOUND){
+ printf("FILE NOT FOUND\n");
+ return;
+ }
+ else if(result==ASN_SYNTAX_ERROR){
+ printf("PARSE ERROR\n");
+ return;
+ }
+ else if(result==ASN_IDENTIFIER_NOT_FOUND){
+ printf("IDENTIFIER NOT FOUND\n");
+ return;
+ }
+
+
+ /* Use the following 3 lines to visit the PKIX1Implicit structures */
+ /* printf("-----------------\n");
+ asn1_visit_tree(PKIX1Implicit88,"PKIX1Implicit88");
+ printf("-----------------\n"); */
+
+
+ create_certificate(PKIX1Implicit88,der,&der_len);
+
+ get_certificate(PKIX1Implicit88,der,der_len);
+
+ /* Clear the "PKIX1Implicit88" structures */
+ asn1_delete_structure(PKIX1Implicit88);
+
+ return;
+}
+
+
+
+
+
+
+
+
+
--- /dev/null
+/*
+ * Copyright (C) 2000,2001 Fabio Fiorina
+ *
+ * This file is part of GNUTLS.
+ *
+ * GNUTLS 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.
+ *
+ * GNUTLS 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+/*****************************************************/
+/* File: CrlExample.c */
+/* Description: An example on how to use the ASN1 */
+/* parser with the Certificate.txt file */
+/*****************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include "../lib/asn1.h"
+#include "../lib/der.h"
+
+/******************************************************/
+/* Function : get_name_type */
+/* Description: analyze a structure of type Name */
+/* Parameters: */
+/* char *root: the structure identifier */
+/* char *answer: the string with elements like: */
+/* "C=US O=gov" */
+/******************************************************/
+void
+get_Name_type(node_asn *cert_def,node_asn *cert,char *root, char *answer)
+{
+ int k,k2,result,len;
+ char name[128],str[1024],str2[1024],name2[128],counter[5],name3[128];
+ node_asn *value;
+
+ answer[0]=0;
+ k=1;
+ do{
+ strcpy(name,root);
+ strcat(name,".rdnSequence.?");
+ _asn1_ltostr(k,counter);
+ strcat(name,counter);
+
+ len = sizeof(str)-1;
+ result=asn1_read_value(cert,name,str,&len);
+ if(result==ASN_ELEMENT_NOT_FOUND) break;
+ k2=1;
+ do{
+ strcpy(name2,name);
+ strcat(name2,".?");
+ _asn1_ltostr(k2,counter);
+ strcat(name2,counter);
+
+ len = sizeof(str)-1;
+ result=asn1_read_value(cert,name2,str,&len);
+ if(result==ASN_ELEMENT_NOT_FOUND) break;
+ strcpy(name3,name2);
+ strcat(name3,".type");
+
+ len = sizeof(str)-1;
+ result=asn1_read_value(cert,name3,str,&len);
+ strcpy(name3,name2);
+ strcat(name3,".value");
+ if(result==ASN_OK){
+ len = sizeof(str2);
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",
+ str2,&len);
+ if(!strcmp(str,str2)){
+ asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationName",
+ &value,"certificate2-subject-C");
+ len = sizeof(str)-1;
+ asn1_read_value(cert,name3,str,&len);
+ asn1_get_der(value,str,len);
+ strcpy(name3,"certificate2-subject-C");
+
+ len = sizeof(str)-1;
+ asn1_read_value(value,name3,str,&len); /* CHOICE */
+ strcat(name3,".");
+ strcat(name3,str);
+
+ len = sizeof(str)-1;
+ asn1_read_value(value,name3,str,&len);
+ str[len]=0;
+ strcat(answer," C=");
+ strcat(answer,str);
+ asn1_delete_structure(value);
+ }
+ else{
+ len = sizeof(str2);
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName"
+ ,str2,&len);
+ if(!strcmp(str,str2)){
+ asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationName"
+ ,&value,"certificate2-subject-O");
+
+ len = sizeof(str)-1;
+ asn1_read_value(cert,name3,str,&len);
+ asn1_get_der(value,str,len);
+ strcpy(name3,"certificate2-subject-O");
+ len = sizeof(str)-1;
+ asn1_read_value(value,name3,str,&len); /* CHOICE */
+ strcat(name3,".");
+ strcat(name3,str);
+ len = sizeof(str)-1;
+ asn1_read_value(value,name3,str,&len);
+ str[len]=0;
+ strcat(answer," O=");
+ strcat(answer,str);
+ asn1_delete_structure(value);
+ }
+ else{
+ len = sizeof(str2);
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",str2,&len);
+ if(!strcmp(str,str2)){
+ asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value,"certificate2-subject-OU");
+ len = sizeof(str)-1;
+ asn1_read_value(cert,name3,str,&len);
+ asn1_get_der(value,str,len);
+ strcpy(name3,"certificate2-subject-OU");
+ len = sizeof(str)-1;
+ asn1_read_value(value,name3,str,&len); /* CHOICE */
+ strcat(name3,".");
+ strcat(name3,str);
+ len = sizeof(str)-1;
+ asn1_read_value(value,name3,str,&len);
+ str[len]=0;
+ strcat(answer," OU=");
+ strcat(answer,str);
+ asn1_delete_structure(value);
+ }
+ }
+ }
+ }
+ k2++;
+ }while(1);
+ k++;
+ }while(1);
+}
+
+
+/******************************************************/
+/* Function : create_certificate */
+/* Description: creates a certificate named */
+/* "certificate1". Values are the same */
+/* as in rfc2459 Appendix D.1 */
+/* Parameters: */
+/* unsigned char *der: contains the der encoding */
+/* int *der_len: number of bytes of der string */
+/******************************************************/
+void
+create_CRL(node_asn *cert_def, unsigned char *der,int *der_len)
+{
+ int result,k,len;
+ unsigned char str[1024],*str2;
+ node_asn *crl,*value;
+
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.CertificateList",&crl,"crl1");
+
+ /* Use the next 3 lines to visit the empty certificate */
+ /* printf("-----------------\n");
+ asn1_visit_tree(crl,"crl1");
+ printf("-----------------\n"); */
+
+
+ /* version: v2(1) */
+ result=asn1_write_value(crl,"crl1.tbsCertList.version","v2",0);
+
+ /* signature: dsa-with-sha */
+ len = sizeof(str)-1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
+ result=asn1_write_value(crl,"crl1.tbsCertList.signature.algorithm",str,1);
+
+ result=asn1_write_value(crl,"crl1.tbsCertList.signature.parameters",NULL,0);
+
+
+ /* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer","rdnSequence",1);
+
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence","NEW",1);
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence.?LAST","NEW",1);
+ /* C */
+ len = sizeof(str)-1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-countryName",str,&len);
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,1);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.X520countryName",
+ &value,"countryName");
+ result=asn1_write_value(value,"countryName","US",2);
+ result=asn1_create_der(value,"countryName",der,der_len);
+ asn1_delete_structure(value);
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+
+
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence","NEW",4);
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence.?LAST","NEW",4);
+ /* O */
+ len = sizeof(str)-1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationName",str,&len);
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,8);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationName",
+ &value,"OrgName");
+ result=asn1_write_value(value,"OrgName","printableString",1);
+ result=asn1_write_value(value,"OrgName.printableString","gov",3);
+ result=asn1_create_der(value,"OrgName",der,der_len);
+ asn1_delete_structure(value);
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+
+
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence","NEW",1);
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence.?LAST","NEW",1);
+ /* OU */
+ len = sizeof(str)-1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-at-organizationalUnitName",
+ str,&len);
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",str,1);
+ result=asn1_create_structure(cert_def,"PKIX1Implicit88.X520OrganizationalUnitName",&value,"OrgUnitName");
+ result=asn1_write_value(value,"OrgUnitName","printableString",1);
+ result=asn1_write_value(value,"OrgUnitName.printableString","nist",4);
+ result=asn1_create_der(value,"OrgUnitName",der,der_len);
+ asn1_delete_structure(value);
+ result=asn1_write_value(crl,"crl1.tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",der,*der_len);
+
+
+ /* validity */
+ result=asn1_write_value(crl,"crl1.tbsCertList.thisUpdate","utcTime",1);
+ result=asn1_write_value(crl,"crl1.tbsCertList.thisUpdate.utcTime","970801000000Z",1);
+
+ result=asn1_write_value(crl,"crl1.tbsCertList.nextUpdate","utcTime",1);
+ result=asn1_write_value(crl,"crl1.tbsCertList.nextUpdate.utcTime","970808000000Z",1);
+
+
+ /* revokedCertificates */
+ result=asn1_write_value(crl,"crl1.tbsCertList.revokedCertificates","NEW",1);
+ str[0]=18;
+ result=asn1_write_value(crl,"crl1.tbsCertList.revokedCertificates.?LAST.userCertificate",str,1);
+ result=asn1_write_value(crl,"crl1.tbsCertList.revokedCertificates.?LAST.revocationDate","utcTime",1);
+ result=asn1_write_value(crl,"crl1.tbsCertList.revokedCertificates.?LAST.revocationDate.utcTime","970731000000Z",1);
+
+ result=asn1_write_value(crl,"crl1.tbsCertList.revokedCertificates.?LAST.crlEntryExtensions","NEW",1);
+ len = sizeof(str)-1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-ce-cRLReasons",
+ str,&len);
+ result=asn1_write_value(crl,"crl1.tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnID",str,1); /* reasonCode */
+ result=asn1_write_value(crl,"crl1.tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.critical","FALSE",1);
+ str2="\x0a\x01\x01";
+ result=asn1_write_value(crl,"crl1.tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnValue",str2,3);
+
+
+ /* crlExtensions */
+ result=asn1_write_value(crl,"crl1.tbsCertList.crlExtensions",NULL,0);
+
+
+ /* signatureAlgorithm: dsa-with-sha */
+ len = sizeof(str)-1;
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str,&len);
+ result=asn1_write_value(crl,"crl1.signatureAlgorithm.algorithm",str,1);
+ result=asn1_write_value(crl,"crl1.signatureAlgorithm.parameters",NULL,0); /* NO OPTION */
+
+ /* signature */
+ result=asn1_create_der(crl,"crl1.tbsCertList",der,der_len);
+ if(result!=ASN_OK){
+ printf("\n'tbsCertList' encoding creation: ERROR\n");
+ return;
+ }
+
+ /* add the lines for the signature on der[0]..der[der_len-1]: result in str2 */
+ result=asn1_write_value(crl,"crl1.signature",str2,46*8);
+
+
+ /* Use the next 3 lines to visit the certificate */
+ /* printf("-----------------\n");
+ asn1_visit_tree(crl,"crl1");
+ printf("-----------------\n"); */
+
+
+ result=asn1_create_der(crl,"crl1",der,der_len);
+ if(result!=ASN_OK){
+ printf("\n'crl1' encoding creation: ERROR\n");
+ return;
+ }
+
+ /* Print the 'Certificate1' DER encoding */
+ printf("-----------------\nCrl1 Encoding:\nNumber of bytes=%i\n",*der_len);
+ for(k=0;k<*der_len;k++) printf("%02x ",der[k]);
+ printf("\n-----------------\n");
+
+ /* Clear the "certificate1" structure */
+ asn1_delete_structure(crl);
+}
+
+
+
+/******************************************************/
+/* Function : get_certificate */
+/* Description: creates a certificate named */
+/* "certificate2" from a der encoding */
+/* string */
+/* Parameters: */
+/* unsigned char *der: the encoding string */
+/* int der_len: number of bytes of der string */
+/******************************************************/
+void
+get_CRL(node_asn *cert_def,unsigned char *der,int der_len)
+{
+ int result,len,start,end;
+ unsigned char str[1024],str2[1024];
+ node_asn *crl2;
+
+
+ asn1_create_structure(cert_def,"PKIX1Implicit88.CertificateList",&crl2,"crl2");
+
+ result=asn1_get_der(crl2,der,der_len);
+
+ if(result!=ASN_OK){
+ printf("Problems with DER encoding\n");
+ return;
+ }
+
+
+ /* issuer */
+ get_Name_type(cert_def,crl2,"crl2.tbsCertList.issuer",str);
+ printf("crl2:\nissuer =%s\n",str);
+
+
+ /* Verify sign */
+ len = sizeof(str)-1;
+ result=asn1_read_value(crl2,"crl2.signatureAlgorithm.algorithm",str,&len);
+
+ result=asn1_read_value(cert_def,"PKIX1Implicit88.id-dsa-with-sha1",str2,&len);
+ if(!strcmp(str,str2)){ /* dsa-with-sha */
+
+ result=asn1_get_start_end_der(crl2,der,der_len,
+ "crl2.tbsCertList",&start,&end);
+
+ /* add the lines to calculate the sha on der[start]..der[end] */
+
+ result=asn1_read_value(crl2,"crl2.signature",str,&len);
+
+ /* compare the previous value to signature ( with issuer public key) */
+ }
+
+ /* Use the next 3 lines to visit the certificate */
+ /* printf("-----------------\n");
+ asn1_visit_tree(crl2,"crl2");
+ printf("-----------------\n"); */
+
+
+ /* Clear the "crl2" structure */
+ asn1_delete_structure(crl2);
+}
+
+
+/********************************************************/
+/* Function : main */
+/* Description: reads the certificate description. */
+/* Creates a certificate and calculate */
+/* the der encoding. After that creates */
+/* another certificate from der string */
+/********************************************************/
+int
+main(int argc,char *argv[])
+{
+ int result,der_len;
+ unsigned char der[1024];
+ char file_name[128];
+ node_asn *PKIX1Implicit88;
+
+/* result=asn1_create_tree(pkix_asn1_tab,&PKIX1Implicit88);*/
+ if(argc==2) strcpy(file_name,argv[1]);
+ else file_name[0]=0;
+
+ strcat(file_name,"pkix.asn");
+ result=asn1_parser_asn1(file_name,&PKIX1Implicit88);
+
+ if(result==ASN_FILE_NOT_FOUND){
+ printf("FILE NOT FOUND\n");
+ return;
+ }
+ else if(result==ASN_SYNTAX_ERROR){
+ printf("PARSE ERROR\n");
+ return;
+ }
+ else if(result==ASN_IDENTIFIER_NOT_FOUND){
+ printf("IDENTIFIER NOT FOUND\n");
+ return;
+ }
+
+
+ /* Use the following 3 lines to visit the PKIX1Implicit structures */
+ /* printf("-----------------\n");
+ asn1_visit_tree(cert_def,"PKIX1Implicit88");
+ printf("-----------------\n"); */
+
+
+ create_CRL(PKIX1Implicit88,der,&der_len);
+
+ get_CRL(PKIX1Implicit88,der,der_len);
+
+ /* Clear the "PKIX1Implicit88" structures */
+ asn1_delete_structure(PKIX1Implicit88);
+
+ return;
+}
+
+
+
+
+
+
+
+
+
--- /dev/null
+INCLUDES = -I../lib
+
+EXTRA_DIST = pkix.asn
+
+noinst_PROGRAMS = asn1c CertificateExample CrlExample
+CertificateExample_SOURCES = CertificateExample.c
+CertificateExample_LDADD = ../lib/libasn1.la
+CrlExample_SOURCES = CrlExample.c
+CrlExample_LDADD = ../lib/libasn1.la
+asn1c_SOURCES = asn1c.c
+asn1c_LDADD = ../lib/libasn1.la
--- /dev/null
+/*
+ * Copyright (C) 2000,2001 Fabio Fiorina
+ *
+ * This file is part of GNUTLS.
+ *
+ * GNUTLS 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.
+ *
+ * GNUTLS 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+
+/*****************************************************/
+/* File: PkixTabExample.c */
+/* Description: An example on how to use the */
+/* 'asn1_parser_asn1_file_c' function. */
+/*****************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include "../lib/asn1.h"
+#include "../lib/der.h"
+
+int
+main(int argc,char *argv[])
+{
+ int result;
+ char* outfile;
+
+ if(argc<2||argc>3) {
+ fprintf(stderr, "Usage: %s: input.asn output.c\n", argv[0]);
+ exit(1);
+ }
+
+ if (argc==3) outfile=argv[2];
+ else outfile=NULL;
+
+ result=asn1_parser_asn1_file_c( argv[1], outfile);
+
+ if(result==ASN_SYNTAX_ERROR){
+ printf("PARSE ERROR\n");
+ return;
+ }
+ else if(result==ASN_IDENTIFIER_NOT_FOUND){
+ printf("IDENTIFIER NOT FOUND\n");
+ return;
+ }
+ else if(result==ASN_FILE_NOT_FOUND){
+ printf("FILE NOT FOUND\n");
+ return;
+ }
+
+ return;
+}
+
+
+
+
+
--- /dev/null
+
+PKIX1Implicit88 {iso(1) identified-organization(3) dod(6) internet(1)
+ security(5) mechanisms(5) pkix(7) id-mod(0) id-pkix1-implicit-88(2)}
+
+DEFINITIONS IMPLICIT TAGS ::=
+
+BEGIN
+
+
+-- ISO arc for standard certificate and CRL extensions
+
+id-ce OBJECT IDENTIFIER ::= {joint-iso-ccitt(2) ds(5) 29}
+
+
+-- authority key identifier OID and syntax
+
+id-ce-authorityKeyIdentifier OBJECT IDENTIFIER ::= { id-ce 35 }
+
+AuthorityKeyIdentifier ::= SEQUENCE {
+ keyIdentifier [0] KeyIdentifier OPTIONAL,
+ authorityCertIssuer [1] GeneralNames OPTIONAL,
+ authorityCertSerialNumber [2] CertificateSerialNumber OPTIONAL }
+ -- authorityCertIssuer and authorityCertSerialNumber shall both
+ -- be present or both be absgent
+
+KeyIdentifier ::= OCTET STRING
+
+-- subject key identifier OID and syntax
+
+id-ce-subjectKeyIdentifier OBJECT IDENTIFIER ::= { id-ce 14 }
+
+SubjectKeyIdentifier ::= KeyIdentifier
+
+-- key usage extension OID and syntax
+
+id-ce-keyUsage OBJECT IDENTIFIER ::= { id-ce 15 }
+
+KeyUsage ::= BIT STRING {
+ digitalSignature (0),
+ nonRepudiation (1),
+ keyEncipherment (2),
+ dataEncipherment (3),
+ keyAgreement (4),
+ keyCertSign (5),
+ cRLSign (6),
+ encipherOnly (7),
+ decipherOnly (8) }
+
+-- private key usage period extension OID and syntax
+
+id-ce-privateKeyUsagePeriod OBJECT IDENTIFIER ::= { id-ce 16 }
+
+PrivateKeyUsagePeriod ::= SEQUENCE {
+ notBefore [0] GeneralizedTime OPTIONAL,
+ notAfter [1] GeneralizedTime OPTIONAL }
+ -- either notBefore or notAfter shall be present
+
+-- certificate policies extension OID and syntax
+
+id-ce-certificatePolicies OBJECT IDENTIFIER ::= { id-ce 32 }
+
+CertificatePolicies ::= SEQUENCE SIZE (1..MAX) OF PolicyInformation
+
+PolicyInformation ::= SEQUENCE {
+ policyIdentifier CertPolicyId,
+ policyQualifiers SEQUENCE SIZE (1..MAX) OF
+ PolicyQualifierInfo OPTIONAL }
+
+CertPolicyId ::= OBJECT IDENTIFIER
+
+PolicyQualifierInfo ::= SEQUENCE {
+ policyQualifierId PolicyQualifierId,
+ qualifier ANY DEFINED BY policyQualifierId }
+
+-- Implementations that recognize additional policy qualifiers shall
+-- augment the following definition for PolicyQualifierId
+
+PolicyQualifierId ::=
+ OBJECT IDENTIFIER -- ( id-qt-cps | id-qt-unotice )
+
+-- CPS pointer qualifier
+
+CPSuri ::= IA5String
+
+-- user notice qualifier
+
+UserNotice ::= SEQUENCE {
+ noticeRef NoticeReference OPTIONAL,
+ explicitText DisplayText OPTIONAL}
+
+NoticeReference ::= SEQUENCE {
+ organization DisplayText,
+ noticeNumbers SEQUENCE OF INTEGER }
+
+DisplayText ::= CHOICE {
+ visibleString VisibleString (SIZE (1..200)),
+ bmpString BMPString (SIZE (1..200)),
+ utf8String UTF8String (SIZE (1..200)) }
+
+-- policy mapping extension OID and syntax
+
+id-ce-policyMappings OBJECT IDENTIFIER ::= { id-ce 33 }
+
+PolicyMappings ::= SEQUENCE SIZE (1..MAX) OF SEQUENCE {
+ issuerDomainPolicy CertPolicyId,
+ subjectDomainPolicy CertPolicyId }
+
+-- subject alternative name extension OID and syntax
+
+id-ce-subjectAltName OBJECT IDENTIFIER ::= { id-ce 17 }
+
+SubjectAltName ::= GeneralNames
+
+GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
+
+GeneralName ::= CHOICE {
+ otherName [0] AnotherName,
+ rfc822Name [1] IA5String,
+ dNSName [2] IA5String,
+ x400Address [3] ORAddress,
+ directoryName [4] Name,
+ ediPartyName [5] EDIPartyName,
+ uniformResourceIdentifier [6] IA5String,
+ iPAddress [7] OCTET STRING,
+ registeredID [8] OBJECT IDENTIFIER }
+
+-- AnotherName replaces OTHER-NAME ::= TYPE-IDENTIFIER, as
+-- TYPE-IDENTIFIER is not supported in the '88 ASN.1 syntax
+
+AnotherName ::= SEQUENCE {
+ type-id OBJECT IDENTIFIER,
+ value [0] EXPLICIT ANY DEFINED BY type-id }
+
+EDIPartyName ::= SEQUENCE {
+ nameAssigner [0] DirectoryString OPTIONAL,
+ partyName [1] DirectoryString }
+
+-- issuer alternative name extension OID and syntax
+
+id-ce-issuerAltName OBJECT IDENTIFIER ::= { id-ce 18 }
+
+IssuerAltName ::= GeneralNames
+
+id-ce-subjectDirectoryAttributes OBJECT IDENTIFIER ::= { id-ce 9 }
+
+SubjectDirectoryAttributes ::= SEQUENCE SIZE (1..MAX) OF Attribute
+
+-- basic constraints extension OID and syntax
+
+id-ce-basicConstraints OBJECT IDENTIFIER ::= { id-ce 19 }
+
+BasicConstraints ::= SEQUENCE {
+ cA BOOLEAN DEFAULT FALSE,
+ pathLenConstraint INTEGER (0..MAX) OPTIONAL }
+
+-- name constraints extension OID and syntax
+
+id-ce-nameConstraints OBJECT IDENTIFIER ::= { id-ce 30 }
+
+NameConstraints ::= SEQUENCE {
+ permittedSubtrees [0] GeneralSubtrees OPTIONAL,
+ excludedSubtrees [1] GeneralSubtrees OPTIONAL }
+
+GeneralSubtrees ::= SEQUENCE SIZE (1..MAX) OF GeneralSubtree
+
+GeneralSubtree ::= SEQUENCE {
+ base GeneralName,
+ minimum [0] BaseDistance DEFAULT 0,
+ maximum [1] BaseDistance OPTIONAL }
+
+BaseDistance ::= INTEGER (0..MAX)
+
+-- policy constraints extension OID and syntax
+
+id-ce-policyConstraints OBJECT IDENTIFIER ::= { id-ce 36 }
+
+PolicyConstraints ::= SEQUENCE {
+ requireExplicitPolicy [0] SkipCerts OPTIONAL,
+ inhibitPolicyMapping [1] SkipCerts OPTIONAL }
+
+SkipCerts ::= INTEGER (0..MAX)
+
+-- CRL distribution points extension OID and syntax
+
+id-ce-cRLDistributionPoints OBJECT IDENTIFIER ::= {id-ce 31}
+
+CRLDistPointsSyntax ::= SEQUENCE SIZE (1..MAX) OF DistributionPoint
+
+DistributionPoint ::= SEQUENCE {
+ distributionPoint [0] DistributionPointName OPTIONAL,
+ reasons [1] ReasonFlags OPTIONAL,
+ cRLIssuer [2] GeneralNames OPTIONAL }
+
+DistributionPointName ::= CHOICE {
+ fullName [0] GeneralNames,
+ nameRelativeToCRLIssuer [1] RelativeDistinguishedName }
+
+
+
+ReasonFlags ::= BIT STRING {
+ unused (0),
+ keyCompromise (1),
+ cACompromise (2),
+ affiliationChanged (3),
+ superseded (4),
+ cessationOfOperation (5),
+ certificateHold (6) }
+
+-- extended key usage extension OID and syntax
+
+id-ce-extKeyUsage OBJECT IDENTIFIER ::= {id-ce 37}
+
+ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId
+
+KeyPurposeId ::= OBJECT IDENTIFIER
+
+-- extended key purpose OIDs
+id-kp-serverAuth OBJECT IDENTIFIER ::= { id-kp 1 }
+id-kp-clientAuth OBJECT IDENTIFIER ::= { id-kp 2 }
+id-kp-codeSigning OBJECT IDENTIFIER ::= { id-kp 3 }
+id-kp-emailProtection OBJECT IDENTIFIER ::= { id-kp 4 }
+id-kp-ipsecEndSystem OBJECT IDENTIFIER ::= { id-kp 5 }
+id-kp-ipsecTunnel OBJECT IDENTIFIER ::= { id-kp 6 }
+id-kp-ipsecUser OBJECT IDENTIFIER ::= { id-kp 7 }
+id-kp-timeStamping OBJECT IDENTIFIER ::= { id-kp 8 }
+
+-- authority info access
+
+id-pe-authorityInfoAccess OBJECT IDENTIFIER ::= { id-pe 1 }
+
+AuthorityInfoAccessSyntax ::=
+ SEQUENCE SIZE (1..MAX) OF AccessDescription
+
+AccessDescription ::= SEQUENCE {
+ accessMethod OBJECT IDENTIFIER,
+ accessLocation GeneralName }
+
+-- CRL number extension OID and syntax
+
+id-ce-cRLNumber OBJECT IDENTIFIER ::= { id-ce 20 }
+
+CRLNumber ::= INTEGER (0..MAX)
+
+-- issuing distribution point extension OID and syntax
+
+id-ce-issuingDistributionPoint OBJECT IDENTIFIER ::= { id-ce 28 }
+
+IssuingDistributionPoint ::= SEQUENCE {
+ distributionPoint [0] DistributionPointName OPTIONAL,
+ onlyContainsUserCerts [1] BOOLEAN DEFAULT FALSE,
+ onlyContainsCACerts [2] BOOLEAN DEFAULT FALSE,
+ onlySomeReasons [3] ReasonFlags OPTIONAL,
+ indirectCRL [4] BOOLEAN DEFAULT FALSE }
+
+
+id-ce-deltaCRLIndicator OBJECT IDENTIFIER ::= { id-ce 27 }
+
+-- deltaCRLIndicator ::= BaseCRLNumber
+
+BaseCRLNumber ::= CRLNumber
+
+-- CRL reasons extension OID and syntax
+
+id-ce-cRLReasons OBJECT IDENTIFIER ::= { id-ce 21 }
+
+CRLReason ::= ENUMERATED {
+ unspecified (0),
+ keyCompromise (1),
+ cACompromise (2),
+ affiliationChanged (3),
+ superseded (4),
+ cessationOfOperation (5),
+ certificateHold (6),
+ removeFromCRL (8) }
+
+-- certificate issuer CRL entry extension OID and syntax
+
+id-ce-certificateIssuer OBJECT IDENTIFIER ::= { id-ce 29 }
+
+CertificateIssuer ::= GeneralNames
+
+-- hold instruction extension OID and syntax
+
+id-ce-holdInstructionCode OBJECT IDENTIFIER ::= { id-ce 23 }
+
+HoldInstructionCode ::= OBJECT IDENTIFIER
+
+-- ANSI x9 holdinstructions
+
+-- ANSI x9 arc holdinstruction arc
+holdInstruction OBJECT IDENTIFIER ::=
+ {joint-iso-itu-t(2) member-body(2) us(840) x9cm(10040) 2}
+
+-- ANSI X9 holdinstructions referenced by this standard
+id-holdinstruction-none OBJECT IDENTIFIER ::=
+ {holdInstruction 1} -- deprecated
+id-holdinstruction-callissuer OBJECT IDENTIFIER ::=
+ {holdInstruction 2}
+id-holdinstruction-reject OBJECT IDENTIFIER ::=
+ {holdInstruction 3}
+
+-- invalidity date CRL entry extension OID and syntax
+
+id-ce-invalidityDate OBJECT IDENTIFIER ::= { id-ce 24 }
+
+InvalidityDate ::= GeneralizedTime
+
+
+-- --------------------------------------
+-- EXPLICIT
+-- --------------------------------------
+
+-- UNIVERSAL Types defined in '93 and '98 ASN.1
+-- but required by this specification
+
+VisibleString ::= [UNIVERSAL 26] IMPLICIT OCTET STRING
+
+NumericString ::= [UNIVERSAL 18] IMPLICIT OCTET STRING
+
+IA5String ::= [UNIVERSAL 22] IMPLICIT OCTET STRING
+
+TeletexString ::= [UNIVERSAL 20] IMPLICIT OCTET STRING
+
+PrintableString ::= [UNIVERSAL 19] IMPLICIT OCTET STRING
+
+UniversalString ::= [UNIVERSAL 28] IMPLICIT OCTET STRING
+ -- UniversalString is defined in ASN.1:1993
+
+BMPString ::= [UNIVERSAL 30] IMPLICIT OCTET STRING
+ -- BMPString is the subtype of UniversalString and models
+ -- the Basic Multilingual Plane of ISO/IEC/ITU 10646-1
+
+UTF8String ::= [UNIVERSAL 12] IMPLICIT OCTET STRING
+ -- The content of this type conforms to RFC 2279.
+
+
+-- PKIX specific OIDs
+
+id-pkix OBJECT IDENTIFIER ::=
+ { iso(1) identified-organization(3) dod(6) internet(1)
+ security(5) mechanisms(5) pkix(7) }
+
+-- PKIX arcs
+
+id-pe OBJECT IDENTIFIER ::= { id-pkix 1 }
+ -- arc for private certificate extensions
+id-qt OBJECT IDENTIFIER ::= { id-pkix 2 }
+ -- arc for policy qualifier types
+id-kp OBJECT IDENTIFIER ::= { id-pkix 3 }
+ -- arc for extended key purpose OIDS
+id-ad OBJECT IDENTIFIER ::= { id-pkix 48 }
+ -- arc for access descriptors
+
+-- policyQualifierIds for Internet policy qualifiers
+
+id-qt-cps OBJECT IDENTIFIER ::= { id-qt 1 }
+ -- OID for CPS qualifier
+id-qt-unotice OBJECT IDENTIFIER ::= { id-qt 2 }
+ -- OID for user notice qualifier
+
+-- access descriptor definitions
+
+id-ad-ocsp OBJECT IDENTIFIER ::= { id-ad 1 }
+id-ad-caIssuers OBJECT IDENTIFIER ::= { id-ad 2 }
+
+-- attribute data types --
+
+Attribute ::= SEQUENCE {
+ type AttributeType,
+ values SET OF AttributeValue
+ -- at least one value is required --
+}
+
+AttributeType ::= OBJECT IDENTIFIER
+
+AttributeValue ::= ANY
+
+AttributeTypeAndValue ::= SEQUENCE {
+ type AttributeType,
+ value AttributeValue }
+
+-- suggested naming attributes: Definition of the following
+-- information object set may be augmented to meet local
+-- requirements. Note that deleting members of the set may
+-- prevent interoperability with conforming implementations.
+-- presented in pairs: the AttributeType followed by the
+-- type definition for the corresponding AttributeValue
+
+-- Arc for standard naming attributes
+id-at OBJECT IDENTIFIER ::= {joint-iso-ccitt(2) ds(5) 4}
+
+-- Attributes of type NameDirectoryString
+id-at-name AttributeType ::= {id-at 41}
+id-at-surname AttributeType ::= {id-at 4}
+id-at-givenName AttributeType ::= {id-at 42}
+id-at-initials AttributeType ::= {id-at 43}
+id-at-generationQualifier AttributeType ::= {id-at 44}
+
+X520name ::= CHOICE {
+ teletexString TeletexString (SIZE (1..ub-name)),
+ printableString PrintableString (SIZE (1..ub-name)),
+ universalString UniversalString (SIZE (1..ub-name)),
+ utf8String UTF8String (SIZE (1..ub-name)),
+ bmpString BMPString (SIZE(1..ub-name)) }
+
+--
+
+id-at-commonName AttributeType ::= {id-at 3}
+
+X520CommonName ::= CHOICE {
+ teletexString TeletexString (SIZE (1..ub-common-name)),
+ printableString PrintableString (SIZE (1..ub-common-name)),
+ universalString UniversalString (SIZE (1..ub-common-name)),
+ utf8String UTF8String (SIZE (1..ub-common-name)),
+ bmpString BMPString (SIZE(1..ub-common-name)) }
+
+--
+
+id-at-localityName AttributeType ::= {id-at 7}
+
+X520LocalityName ::= CHOICE {
+ teletexString TeletexString (SIZE (1..ub-locality-name)),
+ printableString PrintableString (SIZE (1..ub-locality-name)),
+ universalString UniversalString (SIZE (1..ub-locality-name)),
+ utf8String UTF8String (SIZE (1..ub-locality-name)),
+ bmpString BMPString (SIZE(1..ub-locality-name)) }
+
+--
+
+id-at-stateOrProvinceName AttributeType ::= {id-at 8}
+
+X520StateOrProvinceName ::= CHOICE {
+ teletexString TeletexString (SIZE (1..ub-state-name)),
+ printableString PrintableString (SIZE (1..ub-state-name)),
+ universalString UniversalString (SIZE (1..ub-state-name)),
+ utf8String UTF8String (SIZE (1..ub-state-name)),
+ bmpString BMPString (SIZE(1..ub-state-name)) }
+
+--
+
+id-at-organizationName AttributeType ::= {id-at 10}
+
+X520OrganizationName ::= CHOICE {
+ teletexString TeletexString (SIZE (1..ub-organization-name)),
+ printableString PrintableString (SIZE (1..ub-organization-name)),
+ universalString UniversalString (SIZE (1..ub-organization-name)),
+ utf8String UTF8String (SIZE (1..ub-organization-name)),
+ bmpString BMPString (SIZE(1..ub-organization-name)) }
+
+--
+
+id-at-organizationalUnitName AttributeType ::= {id-at 11}
+
+X520OrganizationalUnitName ::= CHOICE {
+ teletexString TeletexString (SIZE (1..ub-organizational-unit-name)),
+ printableString PrintableString
+ (SIZE (1..ub-organizational-unit-name)),
+ universalString UniversalString
+ (SIZE (1..ub-organizational-unit-name)),
+ utf8String UTF8String (SIZE (1..ub-organizational-unit-name)),
+ bmpString BMPString (SIZE(1..ub-organizational-unit-name)) }
+
+--
+
+id-at-title AttributeType ::= {id-at 12}
+
+X520Title ::= CHOICE {
+ teletexString TeletexString (SIZE (1..ub-title)),
+ printableString PrintableString (SIZE (1..ub-title)),
+ universalString UniversalString (SIZE (1..ub-title)),
+ utf8String UTF8String (SIZE (1..ub-title)),
+ bmpString BMPString (SIZE(1..ub-title)) }
+
+--
+
+id-at-dnQualifier AttributeType ::= {id-at 46}
+X520dnQualifier ::= PrintableString
+
+id-at-countryName AttributeType ::= {id-at 6}
+X520countryName ::= PrintableString (SIZE (2)) -- IS 3166 codes
+
+ -- Legacy attributes
+
+pkcs-9 OBJECT IDENTIFIER ::=
+ { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) 9 }
+
+emailAddress AttributeType ::= { pkcs-9 1 }
+
+Pkcs9email ::= IA5String (SIZE (1..ub-emailaddress-length))
+
+-- naming data types --
+
+Name ::= CHOICE { -- only one possibility for now --
+ rdnSequence RDNSequence }
+
+RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
+
+DistinguishedName ::= RDNSequence
+
+RelativeDistinguishedName ::=
+ SET SIZE (1 .. MAX) OF AttributeTypeAndValue
+
+-- Directory string type --
+
+DirectoryString ::= CHOICE {
+ teletexString TeletexString (SIZE (1..MAX)),
+ printableString PrintableString (SIZE (1..MAX)),
+ universalString UniversalString (SIZE (1..MAX)),
+ utf8String UTF8String (SIZE (1..MAX)),
+ bmpString BMPString (SIZE(1..MAX)) }
+
+
+-- --------------------------------------------------------
+-- certificate and CRL specific structures begin here
+-- --------------------------------------------------------
+
+Certificate ::= SEQUENCE {
+ tbsCertificate TBSCertificate,
+ signatureAlgorithm AlgorithmIdentifier,
+ signature BIT STRING }
+
+TBSCertificate ::= SEQUENCE {
+ version [0] EXPLICIT Version DEFAULT v1,
+ serialNumber CertificateSerialNumber,
+ signature AlgorithmIdentifier,
+ issuer Name,
+ validity Validity,
+ subject Name,
+ subjectPublicKeyInfo SubjectPublicKeyInfo,
+ issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
+ -- If present, version shall be v2 or v3
+ subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
+ -- If present, version shall be v2 or v3
+ extensions [3] EXPLICIT Extensions OPTIONAL
+ -- If present, version shall be v3 --
+}
+
+Version ::= INTEGER { v1(0), v2(1), v3(2) }
+
+CertificateSerialNumber ::= INTEGER
+
+Validity ::= SEQUENCE {
+ notBefore Time,
+ notAfter Time }
+
+Time ::= CHOICE {
+ utcTime UTCTime,
+ generalTime GeneralizedTime }
+
+UniqueIdentifier ::= BIT STRING
+
+SubjectPublicKeyInfo ::= SEQUENCE {
+ algorithm AlgorithmIdentifier,
+ subjectPublicKey BIT STRING }
+
+Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
+
+Extension ::= SEQUENCE {
+ extnID OBJECT IDENTIFIER,
+ critical BOOLEAN DEFAULT FALSE,
+ extnValue OCTET STRING }
+
+
+-- ------------------------------------------
+-- CRL structures
+-- ------------------------------------------
+
+CertificateList ::= SEQUENCE {
+ tbsCertList TBSCertList,
+ signatureAlgorithm AlgorithmIdentifier,
+ signature BIT STRING }
+
+TBSCertList ::= SEQUENCE {
+ version Version OPTIONAL,
+ -- if present, shall be v2
+ signature AlgorithmIdentifier,
+ issuer Name,
+ thisUpdate Time,
+ nextUpdate Time OPTIONAL,
+ revokedCertificates SEQUENCE OF SEQUENCE {
+ userCertificate CertificateSerialNumber,
+ revocationDate Time,
+ crlEntryExtensions Extensions OPTIONAL
+ -- if present, shall be v2
+ } OPTIONAL,
+ crlExtensions [0] EXPLICIT Extensions OPTIONAL
+ -- if present, shall be v2 --
+}
+
+-- Version, Time, CertificateSerialNumber, and Extensions were
+-- defined earlier for use in the certificate structure
+
+AlgorithmIdentifier ::= SEQUENCE {
+ algorithm OBJECT IDENTIFIER,
+ parameters ANY DEFINED BY algorithm OPTIONAL }
+ -- contains a value of the type
+ -- registered for use with the
+ -- algorithm object identifier value
+
+-- Algorithm OIDs and parameter structures
+
+pkcs-1 OBJECT IDENTIFIER ::= {
+ iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) 1 }
+
+rsaEncryption OBJECT IDENTIFIER ::= { pkcs-1 1 }
+
+md2WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 2 }
+
+md5WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 4 }
+
+sha1WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 5 }
+
+id-dsa-with-sha1 OBJECT IDENTIFIER ::= {
+ iso(1) member-body(2) us(840) x9-57 (10040) x9algorithm(4) 3 }
+
+Dss-Sig-Value ::= SEQUENCE {
+ r INTEGER,
+ s INTEGER }
+
+dhpublicnumber OBJECT IDENTIFIER ::= {
+ iso(1) member-body(2) us(840) ansi-x942(10046) number-type(2) 1 }
+
+DomainParameters ::= SEQUENCE {
+ p INTEGER, -- odd prime, p=jq +1
+ g INTEGER, -- generator, g
+ q INTEGER, -- factor of p-1
+ j INTEGER OPTIONAL, -- subgroup factor, j>= 2
+ validationParms ValidationParms OPTIONAL }
+
+ValidationParms ::= SEQUENCE {
+ seed BIT STRING,
+ pgenCounter INTEGER }
+
+id-dsa OBJECT IDENTIFIER ::= {
+ iso(1) member-body(2) us(840) x9-57(10040) x9algorithm(4) 1 }
+
+Dss-Parms ::= SEQUENCE {
+ p INTEGER,
+ q INTEGER,
+ g INTEGER }
+
+-- x400 address syntax starts here
+-- OR Names
+
+ORAddress ::= SEQUENCE {
+ built-in-standard-attributes BuiltInStandardAttributes,
+ built-in-domain-defined-attributes
+ BuiltInDomainDefinedAttributes OPTIONAL,
+ -- see also teletex-domain-defined-attributes
+ extension-attributes ExtensionAttributes OPTIONAL }
+-- The OR-address is semantically absent from the OR-name if the
+-- built-in-standard-attribute sequence is empty and the
+-- built-in-domain-defined-attributes and extension-attributes are
+-- both omitted.
+
+-- Built-in Standard Attributes
+
+BuiltInStandardAttributes ::= SEQUENCE {
+ country-name CountryName OPTIONAL,
+ administration-domain-name AdministrationDomainName OPTIONAL,
+ network-address [0] EXPLICIT NetworkAddress OPTIONAL,
+ -- see also extended-network-address
+ terminal-identifier [1] EXPLICIT TerminalIdentifier OPTIONAL,
+ private-domain-name [2] EXPLICIT PrivateDomainName OPTIONAL,
+ organization-name [3] EXPLICIT OrganizationName OPTIONAL,
+ -- see also teletex-organization-name
+ numeric-user-identifier [4] EXPLICIT NumericUserIdentifier OPTIONAL,
+ personal-name [5] EXPLICIT PersonalName OPTIONAL,
+ -- see also teletex-personal-name
+ organizational-unit-names [6] EXPLICIT OrganizationalUnitNames OPTIONAL
+ -- see also teletex-organizational-unit-names --
+}
+
+CountryName ::= [APPLICATION 1] CHOICE {
+ x121-dcc-code NumericString
+ (SIZE (ub-country-name-numeric-length)),
+ iso-3166-alpha2-code PrintableString
+ (SIZE (ub-country-name-alpha-length)) }
+
+AdministrationDomainName ::= [APPLICATION 2] EXPLICIT CHOICE {
+ numeric NumericString (SIZE (0..ub-domain-name-length)),
+ printable PrintableString (SIZE (0..ub-domain-name-length)) }
+
+NetworkAddress ::= X121Address -- see also extended-network-address
+
+X121Address ::= NumericString (SIZE (1..ub-x121-address-length))
+
+TerminalIdentifier ::= PrintableString (SIZE (1..ub-terminal-id-length))
+
+PrivateDomainName ::= CHOICE {
+ numeric NumericString (SIZE (1..ub-domain-name-length)),
+ printable PrintableString (SIZE (1..ub-domain-name-length)) }
+
+OrganizationName ::= PrintableString
+ (SIZE (1..ub-organization-name-length))
+-- see also teletex-organization-name
+
+NumericUserIdentifier ::= NumericString
+ (SIZE (1..ub-numeric-user-id-length))
+
+PersonalName ::= SET {
+ surname [0] PrintableString (SIZE (1..ub-surname-length)),
+ given-name [1] PrintableString
+ (SIZE (1..ub-given-name-length)) OPTIONAL,
+ initials [2] PrintableString (SIZE (1..ub-initials-length)) OPTIONAL,
+ generation-qualifier [3] PrintableString
+ (SIZE (1..ub-generation-qualifier-length)) OPTIONAL }
+-- see also teletex-personal-name
+
+OrganizationalUnitNames ::= SEQUENCE SIZE (1..ub-organizational-units)
+ OF OrganizationalUnitName
+-- see also teletex-organizational-unit-names
+
+OrganizationalUnitName ::= PrintableString (SIZE
+ (1..ub-organizational-unit-name-length))
+
+-- Built-in Domain-defined Attributes
+
+BuiltInDomainDefinedAttributes ::= SEQUENCE SIZE
+ (1..ub-domain-defined-attributes) OF
+ BuiltInDomainDefinedAttribute
+
+BuiltInDomainDefinedAttribute ::= SEQUENCE {
+ type PrintableString (SIZE
+ (1..ub-domain-defined-attribute-type-length)),
+ value PrintableString (SIZE
+ (1..ub-domain-defined-attribute-value-length))}
+
+-- Extension Attributes
+
+ExtensionAttributes ::= SET SIZE (1..ub-extension-attributes) OF
+ ExtensionAttribute
+
+ExtensionAttribute ::= SEQUENCE {
+ extension-attribute-type [0] EXPLICIT INTEGER (0..ub-extension-attributes),
+ extension-attribute-value [1] EXPLICIT
+ ANY DEFINED BY extension-attribute-type }
+
+-- Extension types and attribute values
+--
+
+common-name INTEGER ::= 1
+
+CommonName ::= PrintableString (SIZE (1..ub-common-name-length))
+
+teletex-common-name INTEGER ::= 2
+
+TeletexCommonName ::= TeletexString (SIZE (1..ub-common-name-length))
+
+teletex-organization-name INTEGER ::= 3
+
+TeletexOrganizationName ::=
+ TeletexString (SIZE (1..ub-organization-name-length))
+
+teletex-personal-name INTEGER ::= 4
+
+TeletexPersonalName ::= SET {
+ surname [0] EXPLICIT TeletexString (SIZE (1..ub-surname-length)),
+ given-name [1] EXPLICIT TeletexString
+ (SIZE (1..ub-given-name-length)) OPTIONAL,
+ initials [2] EXPLICIT TeletexString (SIZE (1..ub-initials-length)) OPTIONAL,
+ generation-qualifier [3] EXPLICIT TeletexString (SIZE
+ (1..ub-generation-qualifier-length)) OPTIONAL }
+
+teletex-organizational-unit-names INTEGER ::= 5
+
+TeletexOrganizationalUnitNames ::= SEQUENCE SIZE
+ (1..ub-organizational-units) OF TeletexOrganizationalUnitName
+
+TeletexOrganizationalUnitName ::= TeletexString
+ (SIZE (1..ub-organizational-unit-name-length))
+
+pds-name INTEGER ::= 7
+
+PDSName ::= PrintableString (SIZE (1..ub-pds-name-length))
+
+physical-delivery-country-name INTEGER ::= 8
+
+PhysicalDeliveryCountryName ::= CHOICE {
+ x121-dcc-code NumericString (SIZE (ub-country-name-numeric-length)),
+ iso-3166-alpha2-code PrintableString
+ (SIZE (ub-country-name-alpha-length)) }
+
+postal-code INTEGER ::= 9
+
+PostalCode ::= CHOICE {
+ numeric-code NumericString (SIZE (1..ub-postal-code-length)),
+ printable-code PrintableString (SIZE (1..ub-postal-code-length)) }
+
+physical-delivery-office-name INTEGER ::= 10
+
+PhysicalDeliveryOfficeName ::= PDSParameter
+
+physical-delivery-office-number INTEGER ::= 11
+
+PhysicalDeliveryOfficeNumber ::= PDSParameter
+
+extension-OR-address-components INTEGER ::= 12
+
+ExtensionORAddressComponents ::= PDSParameter
+
+physical-delivery-personal-name INTEGER ::= 13
+
+PhysicalDeliveryPersonalName ::= PDSParameter
+
+physical-delivery-organization-name INTEGER ::= 14
+
+PhysicalDeliveryOrganizationName ::= PDSParameter
+
+extension-physical-delivery-address-components INTEGER ::= 15
+
+ExtensionPhysicalDeliveryAddressComponents ::= PDSParameter
+
+unformatted-postal-address INTEGER ::= 16
+
+UnformattedPostalAddress ::= SET {
+ printable-address SEQUENCE SIZE (1..ub-pds-physical-address-lines) OF
+ PrintableString (SIZE (1..ub-pds-parameter-length)) OPTIONAL,
+ teletex-string TeletexString
+ (SIZE (1..ub-unformatted-address-length)) OPTIONAL }
+
+street-address INTEGER ::= 17
+
+StreetAddress ::= PDSParameter
+
+post-office-box-address INTEGER ::= 18
+
+PostOfficeBoxAddress ::= PDSParameter
+
+poste-restante-address INTEGER ::= 19
+
+PosteRestanteAddress ::= PDSParameter
+
+unique-postal-name INTEGER ::= 20
+
+UniquePostalName ::= PDSParameter
+
+local-postal-attributes INTEGER ::= 21
+
+LocalPostalAttributes ::= PDSParameter
+
+PDSParameter ::= SET {
+ printable-string PrintableString
+ (SIZE(1..ub-pds-parameter-length)) OPTIONAL,
+ teletex-string TeletexString
+ (SIZE(1..ub-pds-parameter-length)) OPTIONAL }
+
+extended-network-address INTEGER ::= 22
+
+ExtendedNetworkAddress ::= CHOICE {
+ e163-4-address SEQUENCE {
+ number [0] EXPLICIT NumericString (SIZE (1..ub-e163-4-number-length)),
+ sub-address [1] EXPLICIT NumericString
+ (SIZE (1..ub-e163-4-sub-address-length)) OPTIONAL },
+ psap-address [0] EXPLICIT PresentationAddress }
+
+PresentationAddress ::= SEQUENCE {
+ pSelector [0] EXPLICIT OCTET STRING OPTIONAL,
+ sSelector [1] EXPLICIT OCTET STRING OPTIONAL,
+ tSelector [2] EXPLICIT OCTET STRING OPTIONAL,
+ nAddresses [3] EXPLICIT SET SIZE (1..MAX) OF OCTET STRING }
+
+terminal-type INTEGER ::= 23
+
+TerminalType ::= INTEGER {
+ telex (3),
+ teletex (4),
+ g3-facsimile (5),
+ g4-facsimile (6),
+ ia5-terminal (7),
+ videotex (8) } (0..ub-integer-options)
+
+-- Extension Domain-defined Attributes
+
+teletex-domain-defined-attributes INTEGER ::= 6
+
+TeletexDomainDefinedAttributes ::= SEQUENCE SIZE
+ (1..ub-domain-defined-attributes) OF TeletexDomainDefinedAttribute
+
+TeletexDomainDefinedAttribute ::= SEQUENCE {
+ type TeletexString
+ (SIZE (1..ub-domain-defined-attribute-type-length)),
+ value TeletexString
+ (SIZE (1..ub-domain-defined-attribute-value-length)) }
+
+-- specifications of Upper Bounds shall be regarded as mandatory
+-- from Annex B of ITU-T X.411 Reference Definition of MTS Parameter
+-- Upper Bounds
+
+-- Upper Bounds
+ub-name INTEGER ::= 32768
+ub-common-name INTEGER ::= 64
+ub-locality-name INTEGER ::= 128
+ub-state-name INTEGER ::= 128
+ub-organization-name INTEGER ::= 64
+ub-organizational-unit-name INTEGER ::= 64
+ub-title INTEGER ::= 64
+ub-match INTEGER ::= 128
+
+ub-emailaddress-length INTEGER ::= 128
+
+ub-common-name-length INTEGER ::= 64
+ub-country-name-alpha-length INTEGER ::= 2
+ub-country-name-numeric-length INTEGER ::= 3
+ub-domain-defined-attributes INTEGER ::= 4
+ub-domain-defined-attribute-type-length INTEGER ::= 8
+ub-domain-defined-attribute-value-length INTEGER ::= 128
+ub-domain-name-length INTEGER ::= 16
+ub-extension-attributes INTEGER ::= 256
+ub-e163-4-number-length INTEGER ::= 15
+ub-e163-4-sub-address-length INTEGER ::= 40
+ub-generation-qualifier-length INTEGER ::= 3
+ub-given-name-length INTEGER ::= 16
+ub-initials-length INTEGER ::= 5
+ub-integer-options INTEGER ::= 256
+ub-numeric-user-id-length INTEGER ::= 32
+ub-organization-name-length INTEGER ::= 64
+ub-organizational-unit-name-length INTEGER ::= 32
+ub-organizational-units INTEGER ::= 4
+ub-pds-name-length INTEGER ::= 16
+ub-pds-parameter-length INTEGER ::= 30
+ub-pds-physical-address-lines INTEGER ::= 6
+ub-postal-code-length INTEGER ::= 16
+ub-surname-length INTEGER ::= 40
+ub-terminal-id-length INTEGER ::= 24
+ub-unformatted-address-length INTEGER ::= 180
+ub-x121-address-length INTEGER ::= 16
+
+-- Note - upper bounds on string types, such as TeletexString, are
+-- measured in characters. Excepting PrintableString or IA5String, a
+-- significantly greater number of octets will be required to hold
+-- such a value. As a minimum, 16 octets, or twice the specified upper
+-- bound, whichever is the larger, should be allowed for TeletexString.
+-- For UTF8String or UniversalString at least four times the upper
+-- bound should be allowed.
+
+
+
+END
+
+
+
+
+
+
+
+
+
projects / platform / upstream / libtasn1.git / commitdiff