Add files using upload-large-folder tool

miniconda3/envs/active_proaction/include/ncursesw/cursesapp.h

@@ -0,0 +1,191 @@
+// * This makes emacs happy -*-Mode: C++;-*-
+/****************************************************************************
+ * Copyright 2019-2020,2021 Thomas E. Dickey                                *
+ * Copyright 1998-2005,2011 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer, 1997                                          *
+ ****************************************************************************/
+
+// $Id: cursesapp.h,v 1.18 2021/06/17 21:26:02 tom Exp $
+
+#ifndef NCURSES_CURSESAPP_H_incl
+#define NCURSES_CURSESAPP_H_incl
+
+#include <ncursesw/cursslk.h>
+
+#if (defined(_WIN32) || defined(_WIN64))
+# define NCURSES_CXX_MAIN_NAME cursespp_main
+# define NCURSES_CXX_MAIN \
+  int main(int argc, char *argv[]) { \
+  	return NCURSES_CXX_MAIN_NAME(argc, argv); \
+  }
+#else
+# define NCURSES_CXX_MAIN_NAME main
+#endif
+NCURSES_CXX_IMPEXP int NCURSES_CXX_MAIN_NAME(int argc, char *argv[]);
+
+class NCURSES_CXX_IMPEXP NCursesApplication {
+public:
+  typedef struct _slk_link {          // This structure is used to maintain
+    struct _slk_link* prev;           // a stack of SLKs
+    Soft_Label_Key_Set* SLKs;
+  } SLK_Link;
+private:
+  static int rinit(NCursesWindow& w); // Internal Init function for title
+  static NCursesApplication* theApp;  // Global ref. to the application
+
+  static SLK_Link* slk_stack;
+
+protected:
+  static NCursesWindow* titleWindow;  // The Title Window (if any)
+
+  bool b_Colors;                      // Is this a color application?
+  NCursesWindow* Root_Window;         // This is the stdscr equiv.
+
+  // Initialization of attributes;
+  // Rewrite this in your derived class if you prefer other settings
+  virtual void init(bool bColors);
+
+  // The number of lines for the title window. Default is no title window
+  // You may rewrite this in your derived class
+  virtual int titlesize() const {
+    return 0;
+  }
+
+  // This method is called to put something into the title window initially
+  // You may rewrite this in your derived class
+  virtual void title() {
+  }
+
+  // The layout used for the Soft Label Keys. Default is to have no SLKs.
+  // You may rewrite this in your derived class
+  virtual Soft_Label_Key_Set::Label_Layout useSLKs() const {
+    return Soft_Label_Key_Set::None;
+  }
+
+  // This method is called to initialize the SLKs. Default is nothing.
+  // You may rewrite this in your derived class
+  virtual void init_labels(Soft_Label_Key_Set& S) const {
+    (void) S;
+  }
+
+  // Your derived class must implement this method. The return value must
+  // be the exit value of your application.
+  virtual int run() = 0;
+
+  // The constructor is protected, so you may use it in your derived
+  // class constructor. The argument tells whether or not you want colors.
+  NCursesApplication(bool wantColors = FALSE);
+
+  NCursesApplication& operator=(const NCursesApplication& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+    }
+    return *this;
+  }
+
+  NCursesApplication(const NCursesApplication& rhs)
+    : b_Colors(rhs.b_Colors),
+      Root_Window(rhs.Root_Window)
+  {
+  }
+
+  static NCursesWindow *&getTitleWindow();
+
+public:
+  virtual ~NCursesApplication() THROWS(NCursesException);
+
+  // Get a pointer to the current application object
+  static NCursesApplication* getApplication();
+
+  // This method runs the application and returns its exit value
+  int operator()(void);
+
+  // Process the commandline arguments. The default implementation simply
+  // ignores them. Your derived class may rewrite this.
+  virtual void handleArgs(int argc, char* argv[]) {
+    (void) argc;
+    (void) argv;
+  }
+
+  // Does this application use colors?
+  inline bool useColors() const {
+    return b_Colors;
+  }
+
+  // Push the Key Set S onto the SLK Stack. S then becomes the current set
+  // of Soft Labelled Keys.
+  void push(Soft_Label_Key_Set& S);
+
+  // Throw away the current set of SLKs and make the previous one the
+  // new current set.
+  bool pop();
+
+  // Retrieve the current set of Soft Labelled Keys.
+  Soft_Label_Key_Set* top() const;
+
+  // Attributes to use for menu and forms foregrounds
+  virtual chtype foregrounds() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(1)) : A_BOLD;
+  }
+
+  // Attributes to use for menu and forms backgrounds
+  virtual chtype backgrounds() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(2)) : A_NORMAL;
+  }
+
+  // Attributes to use for inactive (menu) elements
+  virtual chtype inactives() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(3)|A_DIM) : A_DIM;
+  }
+
+  // Attributes to use for (form) labels and SLKs
+  virtual chtype labels() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(4)) : A_NORMAL;
+  }
+
+  // Attributes to use for form backgrounds
+  virtual chtype dialog_backgrounds() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(4)) : A_NORMAL;
+  }
+
+  // Attributes to use as default for (form) window backgrounds
+  virtual chtype window_backgrounds() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(5)) : A_NORMAL;
+  }
+
+  // Attributes to use for the title window
+  virtual chtype screen_titles() const {
+    return b_Colors ? static_cast<chtype>(COLOR_PAIR(6)) : A_BOLD;
+  }
+
+};
+
+#endif /* NCURSES_CURSESAPP_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/cursesf.h

@@ -0,0 +1,968 @@
+// * This makes emacs happy -*-Mode: C++;-*-
+// vile:cppmode
+/****************************************************************************
+ * Copyright 2019-2021,2022 Thomas E. Dickey                                *
+ * Copyright 1998-2012,2014 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer, 1997                                          *
+ ****************************************************************************/
+
+// $Id: cursesf.h,v 1.39 2022/08/20 20:52:15 tom Exp $
+
+#ifndef NCURSES_CURSESF_H_incl
+#define NCURSES_CURSESF_H_incl 1
+
+#include <ncursesw/cursesp.h>
+
+#ifndef __EXT_QNX
+#include <string.h>
+#endif
+
+extern "C" {
+#  include <ncursesw/form.h>
+}
+//
+// -------------------------------------------------------------------------
+// The abstract base class for builtin and user defined Fieldtypes.
+// -------------------------------------------------------------------------
+//
+class NCURSES_CXX_IMPEXP NCursesFormField; // forward declaration
+
+// Class to represent builtin field types as well as C++ written new
+// fieldtypes (see classes UserDefineFieldType...
+class NCURSES_CXX_IMPEXP NCursesFieldType
+{
+  friend class NCursesFormField;
+
+protected:
+  FIELDTYPE* fieldtype;
+
+  inline void OnError(int err) const THROW2(NCursesException const, NCursesFormException) {
+    if (err!=E_OK)
+      THROW(new NCursesFormException (err));
+  }
+
+  NCursesFieldType(FIELDTYPE *f) : fieldtype(f) {
+  }
+
+  virtual ~NCursesFieldType() {}
+
+  // Set the fields f fieldtype to this one.
+  virtual void set(NCursesFormField& f) = 0;
+
+public:
+  NCursesFieldType()
+    : fieldtype(STATIC_CAST(FIELDTYPE*)(0))
+  {
+  }
+
+  NCursesFieldType& operator=(const NCursesFieldType& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+    }
+    return *this;
+  }
+
+  NCursesFieldType(const NCursesFieldType& rhs)
+    : fieldtype(rhs.fieldtype)
+  {
+  }
+
+};
+
+//
+// -------------------------------------------------------------------------
+// The class representing a forms field, wrapping the lowlevel FIELD struct
+// -------------------------------------------------------------------------
+//
+class NCURSES_CXX_IMPEXP NCursesFormField
+{
+  friend class NCursesForm;
+
+protected:
+  FIELD *field;		     // lowlevel structure
+  NCursesFieldType* ftype;   // Associated field type
+
+  // Error handler
+  inline void OnError (int err) const THROW2(NCursesException const, NCursesFormException) {
+    if (err != E_OK)
+      THROW(new NCursesFormException (err));
+  }
+
+public:
+  // Create a 'Null' field. Can be used to delimit a field list
+  NCursesFormField()
+    : field(STATIC_CAST(FIELD*)(0)),
+      ftype(STATIC_CAST(NCursesFieldType*)(0))
+  {
+  }
+
+  // Create a new field
+  NCursesFormField (int rows,
+		    int ncols,
+		    int first_row = 0,
+		    int first_col = 0,
+		    int offscreen_rows = 0,
+		    int additional_buffers = 0)
+    : field(0),
+      ftype(STATIC_CAST(NCursesFieldType*)(0))
+  {
+      field = ::new_field(rows, ncols, first_row, first_col,
+			  offscreen_rows, additional_buffers);
+      if (!field)
+	OnError(errno);
+  }
+
+  NCursesFormField& operator=(const NCursesFormField& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+    }
+    return *this;
+  }
+
+  NCursesFormField(const NCursesFormField& rhs)
+    : field(rhs.field), ftype(rhs.ftype)
+  {
+  }
+
+  virtual ~NCursesFormField () THROWS(NCursesException);
+
+  // Duplicate the field at a new position
+  inline NCursesFormField* dup(int first_row, int first_col)
+  {
+    NCursesFormField* f = new NCursesFormField();
+    if (!f)
+      OnError(E_SYSTEM_ERROR);
+    else {
+      f->ftype = ftype;
+      f->field = ::dup_field(field,first_row,first_col);
+      if (!f->field)
+	OnError(errno);
+    }
+    return f;
+  }
+
+  // Link the field to a new location
+  inline NCursesFormField* link(int first_row, int first_col) {
+    NCursesFormField* f = new NCursesFormField();
+    if (!f)
+      OnError(E_SYSTEM_ERROR);
+    else {
+      f->ftype = ftype;
+      f->field = ::link_field(field,first_row,first_col);
+      if (!f->field)
+	OnError(errno);
+    }
+    return f;
+  }
+
+  // Get the lowlevel field representation
+  inline FIELD* get_field() const {
+    return field;
+  }
+
+  // Retrieve info about the field
+  inline void info(int& rows, int& ncols,
+		   int& first_row, int& first_col,
+		   int& offscreen_rows, int& additional_buffers) const {
+    OnError(::field_info(field, &rows, &ncols,
+			 &first_row, &first_col,
+			 &offscreen_rows, &additional_buffers));
+  }
+
+  // Retrieve info about the fields dynamic properties.
+  inline void dynamic_info(int& dynamic_rows, int& dynamic_cols,
+			   int& max_growth) const {
+    OnError(::dynamic_field_info(field, &dynamic_rows, &dynamic_cols,
+				 &max_growth));
+  }
+
+  // For a dynamic field you may set the maximum growth limit.
+  // A zero means unlimited growth.
+  inline void set_maximum_growth(int growth = 0) {
+    OnError(::set_max_field(field,growth));
+  }
+
+  // Move the field to a new position
+  inline void move(int row, int col) {
+    OnError(::move_field(field,row,col));
+  }
+
+  // Mark the field to start a new page
+  inline void new_page(bool pageFlag = FALSE) {
+    OnError(::set_new_page(field,pageFlag));
+  }
+
+  // Retrieve whether or not the field starts a new page.
+  inline bool is_new_page() const {
+    return ::new_page(field);
+  }
+
+  // Set the justification for the field
+  inline void set_justification(int just) {
+    OnError(::set_field_just(field,just));
+  }
+
+  // Retrieve the fields justification
+  inline int justification() const {
+    return ::field_just(field);
+  }
+  // Set the foreground attribute for the field
+  inline void set_foreground(chtype foreground) {
+    OnError(::set_field_fore(field,foreground));
+  }
+
+  // Retrieve the fields foreground attribute
+  inline chtype fore() const {
+    return ::field_fore(field);
+  }
+
+  // Set the background attribute for the field
+  inline void set_background(chtype background) {
+    OnError(::set_field_back(field,background));
+  }
+
+  // Retrieve the fields background attribute
+  inline chtype back() const {
+    return ::field_back(field);
+  }
+
+  // Set the padding character for the field
+  inline void set_pad_character(int padding) {
+    OnError(::set_field_pad(field, padding));
+  }
+
+  // Retrieve the fields padding character
+  inline int pad() const {
+    return ::field_pad(field);
+  }
+
+  // Switch on the fields options
+  inline void options_on (Field_Options opts) {
+    OnError (::field_opts_on (field, opts));
+  }
+
+  // Switch off the fields options
+  inline void options_off (Field_Options opts) {
+    OnError (::field_opts_off (field, opts));
+  }
+
+  // Retrieve the fields options
+  inline Field_Options options () const {
+    return ::field_opts (field);
+  }
+
+  // Set the fields options
+  inline void set_options (Field_Options opts) {
+    OnError (::set_field_opts (field, opts));
+  }
+
+  // Mark the field as changed
+  inline void set_changed(bool changeFlag = TRUE) {
+    OnError(::set_field_status(field,changeFlag));
+  }
+
+  // Test whether or not the field is marked as changed
+  inline bool changed() const {
+    return ::field_status(field);
+  }
+
+  // Return the index of the field in the field array of a form
+  // or -1 if the field is not associated to a form
+  inline int (index)() const {
+    return ::field_index(field);
+  }
+
+  // Store a value in a fields buffer. The default buffer is nr. 0
+  inline void set_value(const char *val, int buffer = 0) {
+    OnError(::set_field_buffer(field,buffer,val));
+  }
+
+  // Retrieve the value of a fields buffer. The default buffer is nr. 0
+  inline char* value(int buffer = 0) const {
+    return ::field_buffer(field,buffer);
+  }
+
+  // Set the validation type of the field.
+  inline void set_fieldtype(NCursesFieldType& f) {
+    ftype = &f;
+    f.set(*this); // A good friend may do that...
+  }
+
+  // Retrieve the validation type of the field.
+  inline NCursesFieldType* fieldtype() const {
+    return ftype;
+  }
+
+};
+
+  // This are the built-in hook functions in this C++ binding. In C++ we use
+  // virtual member functions (see below On_..._Init and On_..._Termination)
+  // to provide this functionality in an object oriented manner.
+extern "C" {
+  void _nc_xx_frm_init(FORM *);
+  void _nc_xx_frm_term(FORM *);
+  void _nc_xx_fld_init(FORM *);
+  void _nc_xx_fld_term(FORM *);
+}
+
+//
+// -------------------------------------------------------------------------
+// The class representing a form, wrapping the lowlevel FORM struct
+// -------------------------------------------------------------------------
+//
+class NCURSES_CXX_IMPEXP NCursesForm : public NCursesPanel
+{
+protected:
+  FORM* form;  // the lowlevel structure
+
+private:
+  NCursesWindow* sub;   // the subwindow object
+  bool b_sub_owner;     // is this our own subwindow?
+  bool b_framed;	// has the form a border?
+  bool b_autoDelete;    // Delete fields when deleting form?
+
+  NCursesFormField** my_fields; // The array of fields for this form
+
+  // This structure is used for the form's user data field to link the
+  // FORM* to the C++ object and to provide extra space for a user pointer.
+  typedef struct {
+    void*	       m_user;	    // the pointer for the user's data
+    const NCursesForm* m_back;      // backward pointer to C++ object
+    const FORM*	       m_owner;
+  } UserHook;
+
+  // Get the backward pointer to the C++ object from a FORM
+  static inline NCursesForm* getHook(const FORM *f) {
+    UserHook* hook = reinterpret_cast<UserHook*>(::form_userptr(f));
+    assert(hook != 0 && hook->m_owner==f);
+    return const_cast<NCursesForm*>(hook->m_back);
+  }
+
+  friend void _nc_xx_frm_init(FORM *);
+  friend void _nc_xx_frm_term(FORM *);
+  friend void _nc_xx_fld_init(FORM *);
+  friend void _nc_xx_fld_term(FORM *);
+
+  // Calculate FIELD* array for the menu
+  FIELD** mapFields(NCursesFormField* nfields[]);
+
+protected:
+  // internal routines
+  inline void set_user(void *user) {
+    UserHook* uptr = reinterpret_cast<UserHook*>(::form_userptr (form));
+    assert (uptr != 0 && uptr->m_back==this && uptr->m_owner==form);
+    uptr->m_user = user;
+  }
+
+  inline void *get_user() {
+    UserHook* uptr = reinterpret_cast<UserHook*>(::form_userptr (form));
+    assert (uptr != 0 && uptr->m_back==this && uptr->m_owner==form);
+    return uptr->m_user;
+  }
+
+  void InitForm (NCursesFormField* Fields[],
+		 bool with_frame,
+		 bool autoDeleteFields);
+
+  inline void OnError (int err) const THROW2(NCursesException const, NCursesFormException) {
+    if (err != E_OK)
+      THROW(new NCursesFormException (err));
+  }
+
+  // this wraps the form_driver call.
+  virtual int driver (int c) ;
+
+  // 'Internal' constructor, builds an object without association to a
+  // field array.
+  NCursesForm( int  nlines,
+	       int  ncols,
+	       int  begin_y = 0,
+	       int  begin_x = 0)
+    : NCursesPanel(nlines, ncols, begin_y, begin_x),
+      form (STATIC_CAST(FORM*)(0)),
+      sub(0),
+      b_sub_owner(0),
+      b_framed(0),
+      b_autoDelete(0),
+      my_fields(0)
+  {
+  }
+
+public:
+  // Create form for the default panel.
+  NCursesForm (NCursesFormField* Fields[],
+	       bool with_frame=FALSE,	      // reserve space for a frame?
+	       bool autoDelete_Fields=FALSE)  // do automatic cleanup?
+    : NCursesPanel(),
+      form(0),
+      sub(0),
+      b_sub_owner(0),
+      b_framed(0),
+      b_autoDelete(0),
+      my_fields(0)
+  {
+    InitForm(Fields, with_frame, autoDelete_Fields);
+  }
+
+  // Create a form in a panel with the given position and size.
+  NCursesForm (NCursesFormField* Fields[],
+	       int  nlines,
+	       int  ncols,
+	       int  begin_y,
+	       int  begin_x,
+	       bool with_frame=FALSE,	     // reserve space for a frame?
+	       bool autoDelete_Fields=FALSE) // do automatic cleanup?
+    : NCursesPanel(nlines, ncols, begin_y, begin_x),
+      form(0),
+      sub(0),
+      b_sub_owner(0),
+      b_framed(0),
+      b_autoDelete(0),
+      my_fields(0)
+  {
+      InitForm(Fields, with_frame, autoDelete_Fields);
+  }
+
+  NCursesForm& operator=(const NCursesForm& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+      NCursesPanel::operator=(rhs);
+    }
+    return *this;
+  }
+
+  NCursesForm(const NCursesForm& rhs)
+    : NCursesPanel(rhs),
+      form(rhs.form),
+      sub(rhs.sub),
+      b_sub_owner(rhs.b_sub_owner),
+      b_framed(rhs.b_framed),
+      b_autoDelete(rhs.b_autoDelete),
+      my_fields(rhs.my_fields)
+  {
+  }
+
+  virtual ~NCursesForm() THROWS(NCursesException);
+
+  // Set the default attributes for the form
+  virtual void setDefaultAttributes();
+
+  // Retrieve current field of the form.
+  inline NCursesFormField* current_field() const {
+    return my_fields[::field_index(::current_field(form))];
+  }
+
+  // Set the forms subwindow
+  void setSubWindow(NCursesWindow& sub);
+
+  // Set these fields for the form
+  inline void setFields(NCursesFormField* Fields[]) {
+    OnError(::set_form_fields(form,mapFields(Fields)));
+  }
+
+  // Remove the form from the screen
+  inline void unpost (void) {
+    OnError (::unpost_form (form));
+  }
+
+  // Post the form to the screen if flag is true, unpost it otherwise
+  inline void post(bool flag = TRUE) {
+    OnError (flag ? ::post_form(form) : ::unpost_form (form));
+  }
+
+  // Decorations
+  inline void frame(const char *title=NULL, const char* btitle=NULL) NCURSES_OVERRIDE {
+    if (b_framed)
+      NCursesPanel::frame(title,btitle);
+    else
+      OnError(E_SYSTEM_ERROR);
+  }
+
+  inline void boldframe(const char *title=NULL, const char* btitle=NULL) NCURSES_OVERRIDE {
+    if (b_framed)
+      NCursesPanel::boldframe(title,btitle);
+    else
+      OnError(E_SYSTEM_ERROR);
+  }
+
+  inline void label(const char *topLabel, const char *bottomLabel) NCURSES_OVERRIDE {
+    if (b_framed)
+      NCursesPanel::label(topLabel,bottomLabel);
+    else
+      OnError(E_SYSTEM_ERROR);
+  }
+
+  // -----
+  // Hooks
+  // -----
+
+  // Called after the form gets repositioned in its window.
+  // This is especially true if the form is posted.
+  virtual void On_Form_Init();
+
+  // Called before the form gets repositioned in its window.
+  // This is especially true if the form is unposted.
+  virtual void On_Form_Termination();
+
+  // Called after the field became the current field
+  virtual void On_Field_Init(NCursesFormField& field);
+
+  // Called before this field is left as current field.
+  virtual void On_Field_Termination(NCursesFormField& field);
+
+  // Calculate required window size for the form.
+  void scale(int& rows, int& ncols) const {
+    OnError(::scale_form(form,&rows,&ncols));
+  }
+
+  // Retrieve number of fields in the form.
+  int count() const {
+    return ::field_count(form);
+  }
+
+  // Make the page the current page of the form.
+  void set_page(int pageNum) {
+    OnError(::set_form_page(form, pageNum));
+  }
+
+  // Retrieve current page number
+  int page() const {
+    return ::form_page(form);
+  }
+
+  // Switch on the forms options
+  inline void options_on (Form_Options opts) {
+    OnError (::form_opts_on (form, opts));
+  }
+
+  // Switch off the forms options
+  inline void options_off (Form_Options opts) {
+    OnError (::form_opts_off (form, opts));
+  }
+
+  // Retrieve the forms options
+  inline Form_Options options () const {
+    return ::form_opts (form);
+  }
+
+  // Set the forms options
+  inline void set_options (Form_Options opts) {
+    OnError (::set_form_opts (form, opts));
+  }
+
+  // Are there more data in the current field after the data shown
+  inline bool data_ahead() const {
+    return ::data_ahead(form);
+  }
+
+  // Are there more data in the current field before the data shown
+  inline bool data_behind() const {
+    return ::data_behind(form);
+  }
+
+  // Position the cursor to the current field
+  inline void position_cursor () {
+    OnError (::pos_form_cursor (form));
+  }
+  // Set the current field
+  inline void set_current(NCursesFormField& F) {
+    OnError (::set_current_field(form, F.field));
+  }
+
+  // Provide a default key virtualization. Translate the keyboard
+  // code c into a form request code.
+  // The default implementation provides a hopefully straightforward
+  // mapping for the most common keystrokes and form requests.
+  virtual int virtualize(int c);
+
+  // Operators
+  inline NCursesFormField* operator[](int i) const {
+    if ( (i < 0) || (i >= ::field_count (form)) )
+      OnError (E_BAD_ARGUMENT);
+    return my_fields[i];
+  }
+
+  // Perform the menu's operation
+  // Return the field where you left the form.
+  virtual NCursesFormField* operator()(void);
+
+  // Exception handlers. The default is a Beep.
+  virtual void On_Request_Denied(int c) const;
+  virtual void On_Invalid_Field(int c) const;
+  virtual void On_Unknown_Command(int c) const;
+
+};
+
+//
+// -------------------------------------------------------------------------
+// This is the typical C++ typesafe way to allow to attach
+// user data to a field of a form. Its assumed that the user
+// data belongs to some class T. Use T as template argument
+// to create a UserField.
+// -------------------------------------------------------------------------
+template<class T> class NCURSES_CXX_IMPEXP NCursesUserField : public NCursesFormField
+{
+public:
+  NCursesUserField (int rows,
+		    int ncols,
+		    int first_row = 0,
+		    int first_col = 0,
+		    const T* p_UserData = STATIC_CAST(T*)(0),
+		    int offscreen_rows = 0,
+		    int additional_buffers = 0)
+    : NCursesFormField (rows, ncols,
+			first_row, first_col,
+			offscreen_rows, additional_buffers) {
+      if (field)
+	OnError(::set_field_userptr(field, STATIC_CAST(void *)(p_UserData)));
+  }
+
+  virtual ~NCursesUserField() THROWS(NCursesException) {};
+
+  inline const T* UserData (void) const {
+    return reinterpret_cast<const T*>(::field_userptr (field));
+  }
+
+  inline virtual void setUserData(const T* p_UserData) {
+    if (field)
+      OnError (::set_field_userptr (field, STATIC_CAST(void *)(p_UserData)));
+  }
+};
+//
+// -------------------------------------------------------------------------
+// The same mechanism is used to attach user data to a form
+// -------------------------------------------------------------------------
+//
+template<class T> class NCURSES_CXX_IMPEXP NCursesUserForm : public NCursesForm
+{
+protected:
+  // 'Internal' constructor, builds an object without association to a
+  // field array.
+  NCursesUserForm( int  nlines,
+		   int  ncols,
+		   int  begin_y = 0,
+		   int  begin_x = 0,
+		   const T* p_UserData = STATIC_CAST(T*)(0))
+    : NCursesForm(nlines,ncols,begin_y,begin_x) {
+      if (form)
+	set_user (const_cast<void *>(reinterpret_cast<const void*>
+				     (p_UserData)));
+  }
+
+public:
+  NCursesUserForm (NCursesFormField* Fields[],
+		   const T* p_UserData = STATIC_CAST(T*)(0),
+		   bool with_frame=FALSE,
+		   bool autoDelete_Fields=FALSE)
+    : NCursesForm (&Fields, with_frame, autoDelete_Fields) {
+      if (form)
+	set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  };
+
+  NCursesUserForm (NCursesFormField* Fields[],
+		   int nlines,
+		   int ncols,
+		   int begin_y = 0,
+		   int begin_x = 0,
+		   const T* p_UserData = STATIC_CAST(T*)(0),
+		   bool with_frame=FALSE,
+		   bool autoDelete_Fields=FALSE)
+    : NCursesForm (&Fields, nlines, ncols, begin_y, begin_x,
+		   with_frame, autoDelete_Fields) {
+      if (form)
+	set_user (const_cast<void *>(reinterpret_cast<const void*>
+				     (p_UserData)));
+  };
+
+  virtual ~NCursesUserForm() THROWS(NCursesException) {
+  };
+
+  inline T* UserData (void) {
+    return reinterpret_cast<T*>(get_user ());
+  };
+
+  inline virtual void setUserData (const T* p_UserData) {
+    if (form)
+      set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  }
+
+};
+//
+// -------------------------------------------------------------------------
+// Builtin Fieldtypes
+// -------------------------------------------------------------------------
+//
+class NCURSES_CXX_IMPEXP Alpha_Field : public NCursesFieldType
+{
+private:
+  int min_field_width;
+
+  void set(NCursesFormField& f) NCURSES_OVERRIDE {
+    OnError(::set_field_type(f.get_field(),fieldtype,min_field_width));
+  }
+
+public:
+  explicit Alpha_Field(int width)
+    : NCursesFieldType(TYPE_ALPHA),
+      min_field_width(width) {
+  }
+};
+
+class NCURSES_CXX_IMPEXP Alphanumeric_Field : public NCursesFieldType
+{
+private:
+  int min_field_width;
+
+  void set(NCursesFormField& f) NCURSES_OVERRIDE {
+    OnError(::set_field_type(f.get_field(),fieldtype,min_field_width));
+  }
+
+public:
+  explicit Alphanumeric_Field(int width)
+    : NCursesFieldType(TYPE_ALNUM),
+      min_field_width(width) {
+  }
+};
+
+class NCURSES_CXX_IMPEXP Integer_Field : public NCursesFieldType
+{
+private:
+  int precision;
+  long lower_limit, upper_limit;
+
+  void set(NCursesFormField& f) NCURSES_OVERRIDE {
+    OnError(::set_field_type(f.get_field(),fieldtype,
+			     precision,lower_limit,upper_limit));
+  }
+
+public:
+  Integer_Field(int prec, long low=0L, long high=0L)
+    : NCursesFieldType(TYPE_INTEGER),
+      precision(prec), lower_limit(low), upper_limit(high) {
+  }
+};
+
+class NCURSES_CXX_IMPEXP Numeric_Field : public NCursesFieldType
+{
+private:
+  int precision;
+  double lower_limit, upper_limit;
+
+  void set(NCursesFormField& f) NCURSES_OVERRIDE {
+    OnError(::set_field_type(f.get_field(),fieldtype,
+			     precision,lower_limit,upper_limit));
+  }
+
+public:
+  Numeric_Field(int prec, double low=0.0, double high=0.0)
+    : NCursesFieldType(TYPE_NUMERIC),
+      precision(prec), lower_limit(low), upper_limit(high) {
+  }
+};
+
+class NCURSES_CXX_IMPEXP Regular_Expression_Field : public NCursesFieldType
+{
+private:
+  char* regex;
+
+  void set(NCursesFormField& f) NCURSES_OVERRIDE {
+    OnError(::set_field_type(f.get_field(),fieldtype,regex));
+  }
+
+  void copy_regex(const char *source)
+  {
+    regex = new char[1 + ::strlen(source)];
+    (::strcpy)(regex, source);
+  }
+
+public:
+  explicit Regular_Expression_Field(const char *expr)
+    : NCursesFieldType(TYPE_REGEXP),
+      regex(NULL)
+  {
+    copy_regex(expr);
+  }
+
+  Regular_Expression_Field& operator=(const Regular_Expression_Field& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+      copy_regex(rhs.regex);
+      NCursesFieldType::operator=(rhs);
+    }
+    return *this;
+  }
+
+  Regular_Expression_Field(const Regular_Expression_Field& rhs)
+    : NCursesFieldType(rhs),
+      regex(NULL)
+  {
+    copy_regex(rhs.regex);
+  }
+
+  ~Regular_Expression_Field() {
+    delete[] regex;
+  }
+};
+
+class NCURSES_CXX_IMPEXP Enumeration_Field : public NCursesFieldType
+{
+private:
+  const char** list;
+  int case_sensitive;
+  int non_unique_matches;
+
+  void set(NCursesFormField& f) NCURSES_OVERRIDE {
+    OnError(::set_field_type(f.get_field(),fieldtype,
+			     list,case_sensitive,non_unique_matches));
+  }
+public:
+  Enumeration_Field(const char* enums[],
+		    bool case_sens=FALSE,
+		    bool non_unique=FALSE)
+    : NCursesFieldType(TYPE_ENUM),
+      list(enums),
+      case_sensitive(case_sens ? -1 : 0),
+      non_unique_matches(non_unique ? -1 : 0) {
+  }
+
+  Enumeration_Field& operator=(const Enumeration_Field& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+      NCursesFieldType::operator=(rhs);
+    }
+    return *this;
+  }
+
+  Enumeration_Field(const Enumeration_Field& rhs)
+    : NCursesFieldType(rhs),
+      list(rhs.list),
+      case_sensitive(rhs.case_sensitive),
+      non_unique_matches(rhs.non_unique_matches)
+  {
+  }
+};
+
+class NCURSES_CXX_IMPEXP IPV4_Address_Field : public NCursesFieldType
+{
+private:
+  void set(NCursesFormField& f) NCURSES_OVERRIDE {
+    OnError(::set_field_type(f.get_field(),fieldtype));
+  }
+
+public:
+  IPV4_Address_Field() : NCursesFieldType(TYPE_IPV4) {
+  }
+};
+
+extern "C" {
+  bool _nc_xx_fld_fcheck(FIELD *, const void*);
+  bool _nc_xx_fld_ccheck(int c, const void *);
+  void* _nc_xx_fld_makearg(va_list*);
+}
+
+//
+// -------------------------------------------------------------------------
+// Abstract base class for User-Defined Fieldtypes
+// -------------------------------------------------------------------------
+//
+class NCURSES_CXX_IMPEXP UserDefinedFieldType : public NCursesFieldType
+{
+  friend class UDF_Init; // Internal helper to set up statics
+private:
+  // For all C++ defined fieldtypes we need only one generic lowlevel
+  // FIELDTYPE* element.
+  static FIELDTYPE* generic_fieldtype;
+
+protected:
+  // This are the functions required by the low level libforms functions
+  // to construct a fieldtype.
+  friend bool _nc_xx_fld_fcheck(FIELD *, const void*);
+  friend bool _nc_xx_fld_ccheck(int c, const void *);
+  friend void* _nc_xx_fld_makearg(va_list*);
+
+  void set(NCursesFormField& f) NCURSES_OVERRIDE {
+    OnError(::set_field_type(f.get_field(),fieldtype,&f));
+  }
+
+protected:
+  // Redefine this function to do a field validation. The argument
+  // is a reference to the field you should validate.
+  virtual bool field_check(NCursesFormField& f) = 0;
+
+  // Redefine this function to do a character validation. The argument
+  // is the character to be validated.
+  virtual bool char_check (int c) = 0;
+
+public:
+  UserDefinedFieldType();
+};
+
+extern "C" {
+  bool _nc_xx_next_choice(FIELD*, const void *);
+  bool _nc_xx_prev_choice(FIELD*, const void *);
+}
+
+//
+// -------------------------------------------------------------------------
+// Abstract base class for User-Defined Fieldtypes with Choice functions
+// -------------------------------------------------------------------------
+//
+class NCURSES_CXX_IMPEXP UserDefinedFieldType_With_Choice : public UserDefinedFieldType
+{
+  friend class UDF_Init; // Internal helper to set up statics
+private:
+  // For all C++ defined fieldtypes with choice functions we need only one
+  // generic lowlevel FIELDTYPE* element.
+  static FIELDTYPE* generic_fieldtype_with_choice;
+
+  // This are the functions required by the low level libforms functions
+  // to construct a fieldtype with choice functions.
+  friend bool _nc_xx_next_choice(FIELD*, const void *);
+  friend bool _nc_xx_prev_choice(FIELD*, const void *);
+
+protected:
+  // Redefine this function to do the retrieval of the next choice value.
+  // The argument is a reference to the field tobe examined.
+  virtual bool next    (NCursesFormField& f) = 0;
+
+  // Redefine this function to do the retrieval of the previous choice value.
+  // The argument is a reference to the field tobe examined.
+  virtual bool previous(NCursesFormField& f) = 0;
+
+public:
+  UserDefinedFieldType_With_Choice();
+};
+
+#endif /* NCURSES_CURSESF_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/cursesm.h

@@ -0,0 +1,674 @@
+// * This makes emacs happy -*-Mode: C++;-*-
+/****************************************************************************
+ * Copyright 2019-2020,2022 Thomas E. Dickey                                *
+ * Copyright 1998-2012,2014 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer, 1997                                          *
+ ****************************************************************************/
+
+// $Id: cursesm.h,v 1.35 2022/08/20 20:52:15 tom Exp $
+
+#ifndef NCURSES_CURSESM_H_incl
+#define NCURSES_CURSESM_H_incl 1
+
+#include <ncursesw/cursesp.h>
+
+extern "C" {
+#  include <ncursesw/menu.h>
+}
+//
+// -------------------------------------------------------------------------
+// This wraps the ITEM type of <ncursesw/menu.h>
+// -------------------------------------------------------------------------
+//
+class NCURSES_CXX_IMPEXP NCursesMenuItem
+{
+  friend class NCursesMenu;
+
+protected:
+  ITEM *item;
+
+  inline void OnError (int err) const THROW2(NCursesException const, NCursesMenuException) {
+    if (err != E_OK)
+      THROW(new NCursesMenuException (err));
+  }
+
+public:
+  NCursesMenuItem (const char* p_name     = NULL,
+		   const char* p_descript = NULL)
+    : item(0)
+  {
+    item = p_name ? ::new_item (p_name, p_descript) : STATIC_CAST(ITEM*)(0);
+    if (p_name && !item)
+      OnError (E_SYSTEM_ERROR);
+  }
+  // Create an item. If you pass both parameters as NULL, a delimiting
+  // item is constructed which can be used to terminate a list of
+  // NCursesMenu objects.
+
+  NCursesMenuItem& operator=(const NCursesMenuItem& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+    }
+    return *this;
+  }
+
+  NCursesMenuItem(const NCursesMenuItem& rhs)
+    : item(0)
+  {
+    (void) rhs;
+  }
+
+  virtual ~NCursesMenuItem () THROWS(NCursesException);
+  // Release the items memory
+
+  inline const char* name () const {
+    return ::item_name (item);
+  }
+  // Name of the item
+
+  inline const char* description () const {
+    return ::item_description (item);
+  }
+  // Description of the item
+
+  inline int (index) (void) const {
+    return ::item_index (item);
+  }
+  // Index of the item in an item array (or -1)
+
+  inline void options_on (Item_Options opts) {
+    OnError (::item_opts_on (item, opts));
+  }
+  // Switch on the items options
+
+  inline void options_off (Item_Options opts) {
+    OnError (::item_opts_off (item, opts));
+  }
+  // Switch off the item's option
+
+  inline Item_Options options () const {
+    return ::item_opts (item);
+  }
+  // Retrieve the items options
+
+  inline void set_options (Item_Options opts) {
+    OnError (::set_item_opts (item, opts));
+  }
+  // Set the items options
+
+  inline void set_value (bool f) {
+    OnError (::set_item_value (item,f));
+  }
+  // Set/Reset the items selection state
+
+  inline bool value () const {
+    return ::item_value (item);
+  }
+  // Retrieve the items selection state
+
+  inline bool visible () const {
+    return ::item_visible (item);
+  }
+  // Retrieve visibility of the item
+
+  virtual bool action();
+  // Perform an action associated with this item; you may use this in an
+  // user supplied driver for a menu; you may derive from this class and
+  // overload action() to supply items with different actions.
+  // If an action returns true, the menu will be exited. The default action
+  // is to do nothing.
+};
+
+// Prototype for an items callback function.
+typedef bool ITEMCALLBACK(NCursesMenuItem&);
+
+// If you don't like to create a child class for individual items to
+// overload action(), you may use this class and provide a callback
+// function pointer for items.
+class NCURSES_CXX_IMPEXP NCursesMenuCallbackItem : public NCursesMenuItem
+{
+private:
+  ITEMCALLBACK* p_fct;
+
+public:
+  NCursesMenuCallbackItem(ITEMCALLBACK* fct       = NULL,
+			  const char* p_name      = NULL,
+			  const char* p_descript  = NULL )
+    : NCursesMenuItem (p_name, p_descript),
+      p_fct (fct) {
+  }
+
+  NCursesMenuCallbackItem& operator=(const NCursesMenuCallbackItem& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+    }
+    return *this;
+  }
+
+  NCursesMenuCallbackItem(const NCursesMenuCallbackItem& rhs)
+    : NCursesMenuItem(rhs),
+      p_fct(0)
+  {
+  }
+
+  virtual ~NCursesMenuCallbackItem() THROWS(NCursesException);
+
+  bool action() NCURSES_OVERRIDE;
+};
+
+  // This are the built-in hook functions in this C++ binding. In C++ we use
+  // virtual member functions (see below On_..._Init and On_..._Termination)
+  // to provide this functionality in an object oriented manner.
+extern "C" {
+  void _nc_xx_mnu_init(MENU *);
+  void _nc_xx_mnu_term(MENU *);
+  void _nc_xx_itm_init(MENU *);
+  void _nc_xx_itm_term(MENU *);
+}
+
+//
+// -------------------------------------------------------------------------
+// This wraps the MENU type of <ncursesw/menu.h>
+// -------------------------------------------------------------------------
+//
+class NCURSES_CXX_IMPEXP NCursesMenu : public NCursesPanel
+{
+protected:
+  MENU *menu;
+
+private:
+  NCursesWindow* sub;   // the subwindow object
+  bool b_sub_owner;     // is this our own subwindow?
+  bool b_framed;        // has the menu a border?
+  bool b_autoDelete;    // Delete items when deleting menu?
+
+  NCursesMenuItem** my_items; // The array of items for this menu
+
+  // This structure is used for the menu's user data field to link the
+  // MENU* to the C++ object and to provide extra space for a user pointer.
+  typedef struct {
+    void*              m_user;      // the pointer for the user's data
+    const NCursesMenu* m_back;      // backward pointer to C++ object
+    const MENU*        m_owner;
+  } UserHook;
+
+  // Get the backward pointer to the C++ object from a MENU
+  static inline NCursesMenu* getHook(const MENU *m) {
+    UserHook* hook = STATIC_CAST(UserHook*)(::menu_userptr(m));
+    assert(hook != 0 && hook->m_owner==m);
+    return const_cast<NCursesMenu*>(hook->m_back);
+  }
+
+  friend void _nc_xx_mnu_init(MENU *);
+  friend void _nc_xx_mnu_term(MENU *);
+  friend void _nc_xx_itm_init(MENU *);
+  friend void _nc_xx_itm_term(MENU *);
+
+  // Calculate ITEM* array for the menu
+  ITEM** mapItems(NCursesMenuItem* nitems[]);
+
+protected:
+  // internal routines
+  inline void set_user(void *user) {
+    UserHook* uptr = STATIC_CAST(UserHook*)(::menu_userptr (menu));
+    assert (uptr != 0 && uptr->m_back==this && uptr->m_owner==menu);
+    uptr->m_user = user;
+  }
+
+  inline void *get_user() {
+    UserHook* uptr = STATIC_CAST(UserHook*)(::menu_userptr (menu));
+    assert (uptr != 0 && uptr->m_back==this && uptr->m_owner==menu);
+    return uptr->m_user;
+  }
+
+  void InitMenu (NCursesMenuItem* menu[],
+		 bool with_frame,
+		 bool autoDeleteItems);
+
+  inline void OnError (int err) const THROW2(NCursesException const, NCursesMenuException) {
+    if (err != E_OK)
+      THROW(new NCursesMenuException (this, err));
+  }
+
+  // this wraps the menu_driver call.
+  virtual int driver (int c) ;
+
+  // 'Internal' constructor to create a menu without association to
+  // an array of items.
+  NCursesMenu( int  nlines,
+	       int  ncols,
+	       int  begin_y = 0,
+	       int  begin_x = 0)
+    : NCursesPanel(nlines,ncols,begin_y,begin_x),
+      menu (STATIC_CAST(MENU*)(0)),
+      sub(0),
+      b_sub_owner(0),
+      b_framed(0),
+      b_autoDelete(0),
+      my_items(0)
+  {
+  }
+
+public:
+  // Make a full window size menu
+  NCursesMenu (NCursesMenuItem* Items[],
+	       bool with_frame=FALSE,        // Reserve space for a frame?
+	       bool autoDelete_Items=FALSE)  // Autocleanup of Items?
+    : NCursesPanel(),
+      menu(0),
+      sub(0),
+      b_sub_owner(0),
+      b_framed(0),
+      b_autoDelete(0),
+      my_items(0)
+  {
+      InitMenu(Items, with_frame, autoDelete_Items);
+  }
+
+  // Make a menu with a window of this size.
+  NCursesMenu (NCursesMenuItem* Items[],
+	       int  nlines,
+	       int  ncols,
+	       int  begin_y = 0,
+	       int  begin_x = 0,
+	       bool with_frame=FALSE,        // Reserve space for a frame?
+	       bool autoDelete_Items=FALSE)  // Autocleanup of Items?
+    : NCursesPanel(nlines, ncols, begin_y, begin_x),
+      menu(0),
+      sub(0),
+      b_sub_owner(0),
+      b_framed(0),
+      b_autoDelete(0),
+      my_items(0)
+  {
+      InitMenu(Items, with_frame, autoDelete_Items);
+  }
+
+  NCursesMenu& operator=(const NCursesMenu& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+      NCursesPanel::operator=(rhs);
+    }
+    return *this;
+  }
+
+  NCursesMenu(const NCursesMenu& rhs)
+    : NCursesPanel(rhs),
+      menu(rhs.menu),
+      sub(rhs.sub),
+      b_sub_owner(rhs.b_sub_owner),
+      b_framed(rhs.b_framed),
+      b_autoDelete(rhs.b_autoDelete),
+      my_items(rhs.my_items)
+  {
+  }
+
+  virtual ~NCursesMenu () THROWS(NCursesException);
+
+  // Retrieve the menus subwindow
+  inline NCursesWindow& subWindow() const {
+    assert(sub!=NULL);
+    return *sub;
+  }
+
+  // Set the menus subwindow
+  void setSubWindow(NCursesWindow& sub);
+
+  // Set these items for the menu
+  inline void setItems(NCursesMenuItem* Items[]) {
+    OnError(::set_menu_items(menu,mapItems(Items)));
+  }
+
+  // Remove the menu from the screen
+  inline void unpost (void) {
+    OnError (::unpost_menu (menu));
+  }
+
+  // Post the menu to the screen if flag is true, unpost it otherwise
+  inline void post(bool flag = TRUE) {
+    flag ? OnError (::post_menu(menu)) : OnError (::unpost_menu (menu));
+  }
+
+  // Get the number of rows and columns for this menu
+  inline void scale (int& mrows, int& mcols) const  {
+    OnError (::scale_menu (menu, &mrows, &mcols));
+  }
+
+  // Set the format of this menu
+  inline void set_format(int mrows, int mcols) {
+    OnError (::set_menu_format(menu, mrows, mcols));
+  }
+
+  // Get the format of this menu
+  inline void menu_format(int& rows,int& ncols) {
+    ::menu_format(menu,&rows,&ncols);
+  }
+
+  // Items of the menu
+  inline NCursesMenuItem* items() const {
+    return *my_items;
+  }
+
+  // Get the number of items in this menu
+  inline int count() const {
+    return ::item_count(menu);
+  }
+
+  // Get the current item (i.e. the one the cursor is located)
+  inline NCursesMenuItem* current_item() const {
+    return my_items[::item_index(::current_item(menu))];
+  }
+
+  // Get the marker string
+  inline const char* mark() const {
+    return ::menu_mark(menu);
+  }
+
+  // Set the marker string
+  inline void set_mark(const char *marker) {
+    OnError (::set_menu_mark (menu, marker));
+  }
+
+  // Get the name of the request code c
+  inline static const char* request_name(int c) {
+    return ::menu_request_name(c);
+  }
+
+  // Get the current pattern
+  inline char* pattern() const {
+    return ::menu_pattern(menu);
+  }
+
+  // true if there is a pattern match, false otherwise.
+  bool set_pattern (const char *pat);
+
+  // set the default attributes for the menu
+  // i.e. set fore, back and grey attribute
+  virtual void setDefaultAttributes();
+
+  // Get the menus background attributes
+  inline chtype back() const {
+    return ::menu_back(menu);
+  }
+
+  // Get the menus foreground attributes
+  inline chtype fore() const {
+    return ::menu_fore(menu);
+  }
+
+  // Get the menus grey attributes (used for unselectable items)
+  inline chtype grey() const {
+    return ::menu_grey(menu);
+  }
+
+  // Set the menus background attributes
+  inline chtype set_background(chtype a) {
+    return ::set_menu_back(menu,a);
+  }
+
+  // Set the menus foreground attributes
+  inline chtype set_foreground(chtype a) {
+    return ::set_menu_fore(menu,a);
+  }
+
+  // Set the menus grey attributes (used for unselectable items)
+  inline chtype set_grey(chtype a) {
+    return ::set_menu_grey(menu,a);
+  }
+
+  inline void options_on (Menu_Options opts) {
+    OnError (::menu_opts_on (menu,opts));
+  }
+
+  inline void options_off(Menu_Options opts) {
+    OnError (::menu_opts_off(menu,opts));
+  }
+
+  inline Menu_Options options() const {
+    return ::menu_opts(menu);
+  }
+
+  inline void set_options (Menu_Options opts) {
+    OnError (::set_menu_opts (menu,opts));
+  }
+
+  inline int pad() const {
+    return ::menu_pad(menu);
+  }
+
+  inline void set_pad (int padch) {
+    OnError (::set_menu_pad (menu, padch));
+  }
+
+  // Position the cursor to the current item
+  inline void position_cursor () const {
+    OnError (::pos_menu_cursor (menu));
+  }
+
+  // Set the current item
+  inline void set_current(NCursesMenuItem& I) {
+    OnError (::set_current_item(menu, I.item));
+  }
+
+  // Get the current top row of the menu
+  inline int top_row (void) const {
+    return ::top_row (menu);
+  }
+
+  // Set the current top row of the menu
+  inline void set_top_row (int row) {
+    OnError (::set_top_row (menu, row));
+  }
+
+  // spacing control
+  // Set the spacing for the menu
+  inline void setSpacing(int spc_description,
+			 int spc_rows,
+			 int spc_columns) {
+    OnError(::set_menu_spacing(menu,
+			       spc_description,
+			       spc_rows,
+			       spc_columns));
+  }
+
+  // Get the spacing info for the menu
+  inline void Spacing(int& spc_description,
+		      int& spc_rows,
+		      int& spc_columns) const {
+    OnError(::menu_spacing(menu,
+			   &spc_description,
+			   &spc_rows,
+			   &spc_columns));
+  }
+
+  // Decorations
+  inline void frame(const char *title=NULL, const char* btitle=NULL) NCURSES_OVERRIDE {
+    if (b_framed)
+      NCursesPanel::frame(title,btitle);
+    else
+      OnError(E_SYSTEM_ERROR);
+  }
+
+  inline void boldframe(const char *title=NULL, const char* btitle=NULL) NCURSES_OVERRIDE {
+    if (b_framed)
+      NCursesPanel::boldframe(title,btitle);
+    else
+      OnError(E_SYSTEM_ERROR);
+  }
+
+  inline void label(const char *topLabel, const char *bottomLabel) NCURSES_OVERRIDE {
+    if (b_framed)
+      NCursesPanel::label(topLabel,bottomLabel);
+    else
+      OnError(E_SYSTEM_ERROR);
+  }
+
+  // -----
+  // Hooks
+  // -----
+
+  // Called after the menu gets repositioned in its window.
+  // This is especially true if the menu is posted.
+  virtual void On_Menu_Init();
+
+  // Called before the menu gets repositioned in its window.
+  // This is especially true if the menu is unposted.
+  virtual void On_Menu_Termination();
+
+  // Called after the item became the current item
+  virtual void On_Item_Init(NCursesMenuItem& item);
+
+  // Called before this item is left as current item.
+  virtual void On_Item_Termination(NCursesMenuItem& item);
+
+  // Provide a default key virtualization. Translate the keyboard
+  // code c into a menu request code.
+  // The default implementation provides a hopefully straightforward
+  // mapping for the most common keystrokes and menu requests.
+  virtual int virtualize(int c);
+
+
+  // Operators
+  inline NCursesMenuItem* operator[](int i) const {
+    if ( (i < 0) || (i >= ::item_count (menu)) )
+      OnError (E_BAD_ARGUMENT);
+    return (my_items[i]);
+  }
+
+  // Perform the menu's operation
+  // Return the item where you left the selection mark for a single
+  // selection menu, or NULL for a multivalued menu.
+  virtual NCursesMenuItem* operator()(void);
+
+  // --------------------
+  // Exception handlers
+  // Called by operator()
+  // --------------------
+
+  // Called if the request is denied
+  virtual void On_Request_Denied(int c) const;
+
+  // Called if the item is not selectable
+  virtual void On_Not_Selectable(int c) const;
+
+  // Called if pattern doesn't match
+  virtual void On_No_Match(int c) const;
+
+  // Called if the command is unknown
+  virtual void On_Unknown_Command(int c) const;
+
+};
+//
+// -------------------------------------------------------------------------
+// This is the typical C++ typesafe way to allow to attach
+// user data to an item of a menu. Its assumed that the user
+// data belongs to some class T. Use T as template argument
+// to create a UserItem.
+// -------------------------------------------------------------------------
+//
+template<class T> class NCURSES_CXX_IMPEXP NCursesUserItem : public NCursesMenuItem
+{
+public:
+  NCursesUserItem (const char* p_name,
+		   const char* p_descript = NULL,
+		   const T* p_UserData    = STATIC_CAST(T*)(0))
+    : NCursesMenuItem (p_name, p_descript) {
+      if (item)
+	OnError (::set_item_userptr (item, const_cast<void *>(reinterpret_cast<const void*>(p_UserData))));
+  }
+
+  virtual ~NCursesUserItem() THROWS(NCursesException) {}
+
+  inline const T* UserData (void) const {
+    return reinterpret_cast<const T*>(::item_userptr (item));
+  };
+
+  inline virtual void setUserData(const T* p_UserData) {
+    if (item)
+      OnError (::set_item_userptr (item, const_cast<void *>(reinterpret_cast<const void *>(p_UserData))));
+  }
+};
+//
+// -------------------------------------------------------------------------
+// The same mechanism is used to attach user data to a menu
+// -------------------------------------------------------------------------
+//
+template<class T> class NCURSES_CXX_IMPEXP NCursesUserMenu : public NCursesMenu
+{
+protected:
+  NCursesUserMenu( int  nlines,
+		   int  ncols,
+		   int  begin_y = 0,
+		   int  begin_x = 0,
+		   const T* p_UserData = STATIC_CAST(T*)(0))
+    : NCursesMenu(nlines,ncols,begin_y,begin_x) {
+      if (menu)
+	set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  }
+
+public:
+  NCursesUserMenu (NCursesMenuItem* Items[],
+		   const T* p_UserData = STATIC_CAST(T*)(0),
+		   bool with_frame=FALSE,
+		   bool autoDelete_Items=FALSE)
+    : NCursesMenu (&Items, with_frame, autoDelete_Items) {
+      if (menu)
+	set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  };
+
+  NCursesUserMenu (NCursesMenuItem* Items[],
+		   int nlines,
+		   int ncols,
+		   int begin_y = 0,
+		   int begin_x = 0,
+		   const T* p_UserData = STATIC_CAST(T*)(0),
+		   bool with_frame=FALSE)
+    : NCursesMenu (&Items, nlines, ncols, begin_y, begin_x, with_frame) {
+      if (menu)
+	set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  };
+
+  virtual ~NCursesUserMenu() THROWS(NCursesException) {
+  };
+
+  inline T* UserData (void) {
+    return reinterpret_cast<T*>(get_user ());
+  };
+
+  inline virtual void setUserData (const T* p_UserData) {
+    if (menu)
+      set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  }
+};
+
+#endif /* NCURSES_CURSESM_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/cursesp.h

@@ -0,0 +1,271 @@
+// * This makes emacs happy -*-Mode: C++;-*-
+// vile:cppmode
+/****************************************************************************
+ * Copyright 2019-2021,2022 Thomas E. Dickey                                *
+ * Copyright 1998-2012,2014 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer, 1997                                          *
+ ****************************************************************************/
+
+#ifndef NCURSES_CURSESP_H_incl
+#define NCURSES_CURSESP_H_incl 1
+
+// $Id: cursesp.h,v 1.36 2022/08/20 20:52:15 tom Exp $
+
+#include <ncursesw/cursesw.h>
+
+extern "C" {
+#  include <ncursesw/panel.h>
+}
+
+class NCURSES_CXX_IMPEXP NCursesPanel
+  : public NCursesWindow
+{
+protected:
+  PANEL *p;
+  static NCursesPanel *dummy;
+
+private:
+  // This structure is used for the panel's user data field to link the
+  // PANEL* to the C++ object and to provide extra space for a user pointer.
+  typedef struct {
+    void*               m_user;      // the pointer for the user's data
+    const NCursesPanel* m_back;      // backward pointer to C++ object
+    const PANEL*        m_owner;     // the panel itself
+  } UserHook;
+
+  inline UserHook *UserPointer()
+  {
+    UserHook* uptr = reinterpret_cast<UserHook*>(
+                           const_cast<void *>(::panel_userptr (p)));
+    return uptr;
+  }
+
+  void init();                       // Initialize the panel object
+
+protected:
+  void set_user(void *user)
+  {
+    UserHook* uptr = UserPointer();
+    if (uptr != 0 && uptr->m_back==this && uptr->m_owner==p) {
+      uptr->m_user = user;
+    }
+  }
+  // Set the user pointer of the panel.
+
+  void *get_user()
+  {
+    UserHook* uptr = UserPointer();
+    void *result = 0;
+    if (uptr != 0 && uptr->m_back==this && uptr->m_owner==p)
+      result = uptr->m_user;
+    return result;
+  }
+
+  void OnError (int err) const THROW2(NCursesException const, NCursesPanelException)
+  {
+    if (err==ERR)
+      THROW(new NCursesPanelException (this, err));
+  }
+  // If err is equal to the curses error indicator ERR, an error handler
+  // is called.
+
+  // Get a keystroke. Default implementation calls getch()
+  virtual int getKey(void);
+
+public:
+  NCursesPanel(int nlines,
+	       int ncols,
+	       int begin_y = 0,
+	       int begin_x = 0)
+    : NCursesWindow(nlines,ncols,begin_y,begin_x), p(0)
+  {
+    init();
+  }
+  // Create a panel with this size starting at the requested position.
+
+  NCursesPanel()
+    : NCursesWindow(::stdscr), p(0)
+  {
+    init();
+  }
+  // This constructor creates the default Panel associated with the
+  // ::stdscr window
+
+  NCursesPanel& operator=(const NCursesPanel& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+      NCursesWindow::operator=(rhs);
+    }
+    return *this;
+  }
+
+  NCursesPanel(const NCursesPanel& rhs)
+    : NCursesWindow(rhs),
+      p(rhs.p)
+  {
+  }
+
+  virtual ~NCursesPanel() THROWS(NCursesException);
+
+  // basic manipulation
+  inline void hide()
+  {
+    OnError (::hide_panel(p));
+  }
+  // Hide the panel. It stays in the stack but becomes invisible.
+
+  inline void show()
+  {
+    OnError (::show_panel(p));
+  }
+  // Show the panel, i.e. make it visible.
+
+  inline void top()
+  {
+    OnError (::top_panel(p));
+  }
+  // Make this panel the top panel in the stack.
+
+  inline void bottom()
+  {
+    OnError (::bottom_panel(p));
+  }
+  // Make this panel the bottom panel in the stack.
+  // N.B.: The panel associated with ::stdscr is always on the bottom. So
+  // actually bottom() makes the panel the first above ::stdscr.
+
+  virtual int mvwin(int y, int x) NCURSES_OVERRIDE
+  {
+    OnError(::move_panel(p, y, x));
+    return OK;
+  }
+
+  inline bool hidden() const
+  {
+    return (::panel_hidden (p) ? TRUE : FALSE);
+  }
+  // Return TRUE if the panel is hidden, FALSE otherwise.
+
+/* The functions panel_above() and panel_below() are not reflected in
+   the NCursesPanel class. The reason for this is, that we cannot
+   assume that a panel retrieved by those operations is one wrapped
+   by a C++ class. Although this situation might be handled, we also
+   need a reverse mapping from PANEL to NCursesPanel which needs some
+   redesign of the low level stuff. At the moment, we define them in the
+   interface but they will always produce an error. */
+  inline NCursesPanel& above() const
+  {
+    OnError(ERR);
+    return *dummy;
+  }
+
+  inline NCursesPanel& below() const
+  {
+    OnError(ERR);
+    return *dummy;
+  }
+
+  // Those two are rewrites of the corresponding virtual members of
+  // NCursesWindow
+  virtual int refresh() NCURSES_OVERRIDE;
+  // Propagate all panel changes to the virtual screen and update the
+  // physical screen.
+
+  virtual int noutrefresh() NCURSES_OVERRIDE;
+  // Propagate all panel changes to the virtual screen.
+
+  static void redraw();
+  // Redraw all panels.
+
+  // decorations
+  virtual void frame(const char* title=NULL,
+		     const char* btitle=NULL);
+  // Put a frame around the panel and put the title centered in the top line
+  // and btitle in the bottom line.
+
+  virtual void boldframe(const char* title=NULL,
+			 const char* btitle=NULL);
+  // Same as frame(), but use highlighted attributes.
+
+  virtual void label(const char* topLabel,
+		     const char* bottomLabel);
+  // Put the title centered in the top line and btitle in the bottom line.
+
+  virtual void centertext(int row,const char* label);
+  // Put the label text centered in the specified row.
+};
+
+/* We use templates to provide a typesafe mechanism to associate
+ * user data with a panel. A NCursesUserPanel<T> is a panel
+ * associated with some user data of type T.
+ */
+template<class T> class NCursesUserPanel : public NCursesPanel
+{
+public:
+  NCursesUserPanel (int nlines,
+		    int ncols,
+		    int begin_y = 0,
+		    int begin_x = 0,
+		    const T* p_UserData = STATIC_CAST(T*)(0))
+    : NCursesPanel (nlines, ncols, begin_y, begin_x)
+  {
+      if (p)
+	set_user (const_cast<void *>(reinterpret_cast<const void*>
+				     (p_UserData)));
+  };
+  // This creates an user panel of the requested size with associated
+  // user data pointed to by p_UserData.
+
+  explicit NCursesUserPanel(const T* p_UserData = STATIC_CAST(T*)(0)) : NCursesPanel()
+  {
+    if (p)
+      set_user(const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  };
+  // This creates an user panel associated with the ::stdscr and user data
+  // pointed to by p_UserData.
+
+  virtual ~NCursesUserPanel() THROWS(NCursesException) {};
+
+  T* UserData (void)
+  {
+    return reinterpret_cast<T*>(get_user ());
+  };
+  // Retrieve the user data associated with the panel.
+
+  virtual void setUserData (const T* p_UserData)
+  {
+    if (p)
+      set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  }
+  // Associate the user panel with the user data pointed to by p_UserData.
+};
+
+#endif /* NCURSES_CURSESP_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/cursesw.h

@@ -0,0 +1,1581 @@
+// * This makes emacs happy -*-Mode: C++;-*-
+// vile:cppmode
+/****************************************************************************
+ * Copyright 2019-2021,2022 Thomas E. Dickey                                *
+ * Copyright 1998-2014,2017 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+#ifndef NCURSES_CURSESW_H_incl
+#define NCURSES_CURSESW_H_incl 1
+
+// $Id: cursesw.h,v 1.59 2022/08/20 20:52:15 tom Exp $
+
+extern "C" {
+#  include   <ncursesw/curses.h>
+}
+
+#if defined(BUILDING_NCURSES_CXX)
+# define NCURSES_CXX_IMPEXP NCURSES_EXPORT_GENERAL_EXPORT
+#else
+# define NCURSES_CXX_IMPEXP NCURSES_EXPORT_GENERAL_IMPORT
+#endif
+
+#define NCURSES_CXX_WRAPPED_VAR(type,name) extern NCURSES_CXX_IMPEXP type NCURSES_PUBLIC_VAR(name)(void)
+
+#define NCURSES_CXX_EXPORT(type) NCURSES_CXX_IMPEXP type NCURSES_API
+#define NCURSES_CXX_EXPORT_VAR(type) NCURSES_CXX_IMPEXP type
+
+#include <ncursesw/etip.h>
+
+/* SCO 3.2v4 curses.h includes term.h, which defines lines as a macro.
+   Undefine it here, because NCursesWindow uses lines as a method.  */
+#undef lines
+
+/* "Convert" macros to inlines. We'll define it as another symbol to avoid
+ * conflict with library symbols.
+ */
+#undef UNDEF
+#define UNDEF(name) CUR_ ##name
+
+#ifdef addch
+inline int UNDEF(addch)(chtype ch)  { return addch(ch); }
+#undef addch
+#define addch UNDEF(addch)
+#endif
+
+#ifdef addchstr
+inline int UNDEF(addchstr)(chtype *at) { return addchstr(at); }
+#undef addchstr
+#define addchstr UNDEF(addchstr)
+#endif
+
+#ifdef addnstr
+inline int UNDEF(addnstr)(const char *str, int n)
+{ return addnstr(str, n); }
+#undef addnstr
+#define addnstr UNDEF(addnstr)
+#endif
+
+#ifdef addstr
+inline int UNDEF(addstr)(const char * str)  { return addstr(str); }
+#undef addstr
+#define addstr UNDEF(addstr)
+#endif
+
+#ifdef attroff
+inline int UNDEF(attroff)(chtype at) { return attroff(at); }
+#undef attroff
+#define attroff UNDEF(attroff)
+#endif
+
+#ifdef attron
+inline int UNDEF(attron)(chtype at) { return attron(at); }
+#undef attron
+#define attron UNDEF(attron)
+#endif
+
+#ifdef attrset
+inline chtype UNDEF(attrset)(chtype at) { return attrset(at); }
+#undef attrset
+#define attrset UNDEF(attrset)
+#endif
+
+#ifdef bkgd
+inline int UNDEF(bkgd)(chtype ch) { return bkgd(ch); }
+#undef bkgd
+#define bkgd UNDEF(bkgd)
+#endif
+
+#ifdef bkgdset
+inline void UNDEF(bkgdset)(chtype ch) { bkgdset(ch); }
+#undef bkgdset
+#define bkgdset UNDEF(bkgdset)
+#endif
+
+#ifdef border
+inline int UNDEF(border)(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br)
+{ return border(ls, rs, ts, bs, tl, tr, bl, br); }
+#undef border
+#define border UNDEF(border)
+#endif
+
+#ifdef box
+inline int UNDEF(box)(WINDOW *win, int v, int h) { return box(win, v, h); }
+#undef box
+#define box UNDEF(box)
+#endif
+
+#ifdef chgat
+inline int UNDEF(chgat)(int n, attr_t attr, NCURSES_PAIRS_T color, const void *opts) {
+  return chgat(n, attr, color, opts); }
+#undef chgat
+#define chgat UNDEF(chgat)
+#endif
+
+#ifdef clear
+inline int UNDEF(clear)()  { return clear(); }
+#undef clear
+#define clear UNDEF(clear)
+#endif
+
+#ifdef clearok
+inline int UNDEF(clearok)(WINDOW* win, bool bf)  { return clearok(win, bf); }
+#undef clearok
+#define clearok UNDEF(clearok)
+#else
+extern "C" NCURSES_IMPEXP int NCURSES_API clearok(WINDOW*, bool);
+#endif
+
+#ifdef clrtobot
+inline int UNDEF(clrtobot)()  { return clrtobot(); }
+#undef clrtobot
+#define clrtobot UNDEF(clrtobot)
+#endif
+
+#ifdef clrtoeol
+inline int UNDEF(clrtoeol)()  { return clrtoeol(); }
+#undef clrtoeol
+#define clrtoeol UNDEF(clrtoeol)
+#endif
+
+#ifdef color_set
+inline chtype UNDEF(color_set)(NCURSES_PAIRS_T p, void* opts) { return color_set(p, opts); }
+#undef color_set
+#define color_set UNDEF(color_set)
+#endif
+
+#ifdef crmode
+inline int UNDEF(crmode)(void) { return crmode(); }
+#undef crmode
+#define crmode UNDEF(crmode)
+#endif
+
+#ifdef delch
+inline int UNDEF(delch)()  { return delch(); }
+#undef delch
+#define delch UNDEF(delch)
+#endif
+
+#ifdef deleteln
+inline int UNDEF(deleteln)()  { return deleteln(); }
+#undef deleteln
+#define deleteln UNDEF(deleteln)
+#endif
+
+#ifdef echochar
+inline int UNDEF(echochar)(chtype ch)  { return echochar(ch); }
+#undef echochar
+#define echochar UNDEF(echochar)
+#endif
+
+#ifdef erase
+inline int UNDEF(erase)()  { return erase(); }
+#undef erase
+#define erase UNDEF(erase)
+#endif
+
+#ifdef fixterm
+inline int UNDEF(fixterm)(void) { return fixterm(); }
+#undef fixterm
+#define fixterm UNDEF(fixterm)
+#endif
+
+#ifdef flushok
+inline int UNDEF(flushok)(WINDOW* _win, bool _bf)  {
+  return flushok(_win, _bf); }
+#undef flushok
+#define flushok UNDEF(flushok)
+#else
+#define _no_flushok
+#endif
+
+#ifdef getattrs
+inline int UNDEF(getattrs)(WINDOW *win) { return getattrs(win); }
+#undef getattrs
+#define getattrs UNDEF(getattrs)
+#endif
+
+#ifdef getbegyx
+inline void UNDEF(getbegyx)(WINDOW* win, int& y, int& x) { getbegyx(win, y, x); }
+#undef getbegyx
+#define getbegyx UNDEF(getbegyx)
+#endif
+
+#ifdef getbkgd
+inline chtype UNDEF(getbkgd)(const WINDOW *win) { return getbkgd(win); }
+#undef getbkgd
+#define getbkgd UNDEF(getbkgd)
+#endif
+
+#ifdef getch
+inline int UNDEF(getch)()  { return getch(); }
+#undef getch
+#define getch UNDEF(getch)
+#endif
+
+#ifdef getmaxyx
+inline void UNDEF(getmaxyx)(WINDOW* win, int& y, int& x) { getmaxyx(win, y, x); }
+#undef getmaxyx
+#define getmaxyx UNDEF(getmaxyx)
+#endif
+
+#ifdef getnstr
+inline int UNDEF(getnstr)(char *_str, int n)  { return getnstr(_str, n); }
+#undef getnstr
+#define getnstr UNDEF(getnstr)
+#endif
+
+#ifdef getparyx
+inline void UNDEF(getparyx)(WINDOW* win, int& y, int& x) { getparyx(win, y, x); }
+#undef getparyx
+#define getparyx UNDEF(getparyx)
+#endif
+
+#ifdef getstr
+inline int UNDEF(getstr)(char *_str)  { return getstr(_str); }
+#undef getstr
+#define getstr UNDEF(getstr)
+#endif
+
+#ifdef getyx
+inline void UNDEF(getyx)(const WINDOW* win, int& y, int& x) {
+  getyx(win, y, x); }
+#undef getyx
+#define getyx UNDEF(getyx)
+#endif
+
+#ifdef hline
+inline int UNDEF(hline)(chtype ch, int n) { return hline(ch, n); }
+#undef hline
+#define hline UNDEF(hline)
+#endif
+
+#ifdef inch
+inline chtype UNDEF(inch)()  { return inch(); }
+#undef inch
+#define inch UNDEF(inch)
+#endif
+
+#ifdef inchstr
+inline int UNDEF(inchstr)(chtype *str)  { return inchstr(str); }
+#undef inchstr
+#define inchstr UNDEF(inchstr)
+#endif
+
+#ifdef innstr
+inline int UNDEF(innstr)(char *_str, int n)  { return innstr(_str, n); }
+#undef innstr
+#define innstr UNDEF(innstr)
+#endif
+
+#ifdef insch
+inline int UNDEF(insch)(chtype c)  { return insch(c); }
+#undef insch
+#define insch UNDEF(insch)
+#endif
+
+#ifdef insdelln
+inline int UNDEF(insdelln)(int n)  { return insdelln(n); }
+#undef insdelln
+#define insdelln UNDEF(insdelln)
+#endif
+
+#ifdef insertln
+inline int UNDEF(insertln)()  { return insertln(); }
+#undef insertln
+#define insertln UNDEF(insertln)
+#endif
+
+#ifdef insnstr
+inline int UNDEF(insnstr)(const char *_str, int n)  {
+  return insnstr(_str, n); }
+#undef insnstr
+#define insnstr UNDEF(insnstr)
+#endif
+
+#ifdef insstr
+inline int UNDEF(insstr)(const char *_str)  {
+  return insstr(_str); }
+#undef insstr
+#define insstr UNDEF(insstr)
+#endif
+
+#ifdef instr
+inline int UNDEF(instr)(char *_str)  { return instr(_str); }
+#undef instr
+#define instr UNDEF(instr)
+#endif
+
+#ifdef intrflush
+inline void UNDEF(intrflush)(WINDOW *win, bool bf) { intrflush(); }
+#undef intrflush
+#define intrflush UNDEF(intrflush)
+#endif
+
+#ifdef is_linetouched
+inline int UNDEF(is_linetouched)(WINDOW *w, int l)  { return is_linetouched(w,l); }
+#undef is_linetouched
+#define is_linetouched UNDEF(is_linetouched)
+#endif
+
+#ifdef leaveok
+inline int UNDEF(leaveok)(WINDOW* win, bool bf)  { return leaveok(win, bf); }
+#undef leaveok
+#define leaveok UNDEF(leaveok)
+#else
+extern "C" NCURSES_IMPEXP int NCURSES_API leaveok(WINDOW* win, bool bf);
+#endif
+
+#ifdef move
+inline int UNDEF(move)(int x, int y)  { return move(x, y); }
+#undef move
+#define move UNDEF(move)
+#endif
+
+#ifdef mvaddch
+inline int UNDEF(mvaddch)(int y, int x, chtype ch)
+{ return mvaddch(y, x, ch); }
+#undef mvaddch
+#define mvaddch UNDEF(mvaddch)
+#endif
+
+#ifdef mvaddnstr
+inline int UNDEF(mvaddnstr)(int y, int x, const char *str, int n)
+{ return mvaddnstr(y, x, str, n); }
+#undef mvaddnstr
+#define mvaddnstr UNDEF(mvaddnstr)
+#endif
+
+#ifdef mvaddstr
+inline int UNDEF(mvaddstr)(int y, int x, const char * str)
+{ return mvaddstr(y, x, str); }
+#undef mvaddstr
+#define mvaddstr UNDEF(mvaddstr)
+#endif
+
+#ifdef mvchgat
+inline int UNDEF(mvchgat)(int y, int x, int n,
+			  attr_t attr, NCURSES_PAIRS_T color, const void *opts) {
+  return mvchgat(y, x, n, attr, color, opts); }
+#undef mvchgat
+#define mvchgat UNDEF(mvchgat)
+#endif
+
+#ifdef mvdelch
+inline int UNDEF(mvdelch)(int y, int x) { return mvdelch(y, x);}
+#undef mvdelch
+#define mvdelch UNDEF(mvdelch)
+#endif
+
+#ifdef mvgetch
+inline int UNDEF(mvgetch)(int y, int x) { return mvgetch(y, x);}
+#undef mvgetch
+#define mvgetch UNDEF(mvgetch)
+#endif
+
+#ifdef mvgetnstr
+inline int UNDEF(mvgetnstr)(int y, int x, char *str, int n) {
+  return mvgetnstr(y, x, str, n);}
+#undef mvgetnstr
+#define mvgetnstr UNDEF(mvgetnstr)
+#endif
+
+#ifdef mvgetstr
+inline int UNDEF(mvgetstr)(int y, int x, char *str) {return mvgetstr(y, x, str);}
+#undef mvgetstr
+#define mvgetstr UNDEF(mvgetstr)
+#endif
+
+#ifdef mvinch
+inline chtype UNDEF(mvinch)(int y, int x) { return mvinch(y, x);}
+#undef mvinch
+#define mvinch UNDEF(mvinch)
+#endif
+
+#ifdef mvinnstr
+inline int UNDEF(mvinnstr)(int y, int x, char *_str, int n) {
+  return mvinnstr(y, x, _str, n); }
+#undef mvinnstr
+#define mvinnstr UNDEF(mvinnstr)
+#endif
+
+#ifdef mvinsch
+inline int UNDEF(mvinsch)(int y, int x, chtype c)
+{ return mvinsch(y, x, c); }
+#undef mvinsch
+#define mvinsch UNDEF(mvinsch)
+#endif
+
+#ifdef mvinsnstr
+inline int UNDEF(mvinsnstr)(int y, int x, const char *_str, int n) {
+  return mvinsnstr(y, x, _str, n); }
+#undef mvinsnstr
+#define mvinsnstr UNDEF(mvinsnstr)
+#endif
+
+#ifdef mvinsstr
+inline int UNDEF(mvinsstr)(int y, int x, const char *_str)  {
+  return mvinsstr(y, x, _str); }
+#undef mvinsstr
+#define mvinsstr UNDEF(mvinsstr)
+#endif
+
+#ifdef mvwaddch
+inline int UNDEF(mvwaddch)(WINDOW *win, int y, int x, const chtype ch)
+{ return mvwaddch(win, y, x, ch); }
+#undef mvwaddch
+#define mvwaddch UNDEF(mvwaddch)
+#endif
+
+#ifdef mvwaddchnstr
+inline int UNDEF(mvwaddchnstr)(WINDOW *win, int y, int x, const chtype *str, int n)
+{ return mvwaddchnstr(win, y, x, str, n); }
+#undef mvwaddchnstr
+#define mvwaddchnstr UNDEF(mvwaddchnstr)
+#endif
+
+#ifdef mvwaddchstr
+inline int UNDEF(mvwaddchstr)(WINDOW *win, int y, int x, const chtype *str)
+{ return mvwaddchstr(win, y, x, str); }
+#undef mvwaddchstr
+#define mvwaddchstr UNDEF(mvwaddchstr)
+#endif
+
+#ifdef mvwaddnstr
+inline int UNDEF(mvwaddnstr)(WINDOW *win, int y, int x, const char *str, int n)
+{ return mvwaddnstr(win, y, x, str, n); }
+#undef mvwaddnstr
+#define mvwaddnstr UNDEF(mvwaddnstr)
+#endif
+
+#ifdef mvwaddstr
+inline int UNDEF(mvwaddstr)(WINDOW *win, int y, int x, const char * str)
+{ return mvwaddstr(win, y, x, str); }
+#undef mvwaddstr
+#define mvwaddstr UNDEF(mvwaddstr)
+#endif
+
+#ifdef mvwchgat
+inline int UNDEF(mvwchgat)(WINDOW *win, int y, int x, int n,
+			   attr_t attr, NCURSES_PAIRS_T color, const void *opts) {
+  return mvwchgat(win, y, x, n, attr, color, opts); }
+#undef mvwchgat
+#define mvwchgat UNDEF(mvwchgat)
+#endif
+
+#ifdef mvwdelch
+inline int UNDEF(mvwdelch)(WINDOW *win, int y, int x)
+{ return mvwdelch(win, y, x); }
+#undef mvwdelch
+#define mvwdelch UNDEF(mvwdelch)
+#endif
+
+#ifdef mvwgetch
+inline int UNDEF(mvwgetch)(WINDOW *win, int y, int x) { return mvwgetch(win, y, x);}
+#undef mvwgetch
+#define mvwgetch UNDEF(mvwgetch)
+#endif
+
+#ifdef mvwgetnstr
+inline int UNDEF(mvwgetnstr)(WINDOW *win, int y, int x, char *str, int n)
+{return mvwgetnstr(win, y, x, str, n);}
+#undef mvwgetnstr
+#define mvwgetnstr UNDEF(mvwgetnstr)
+#endif
+
+#ifdef mvwgetstr
+inline int UNDEF(mvwgetstr)(WINDOW *win, int y, int x, char *str)
+{return mvwgetstr(win, y, x, str);}
+#undef mvwgetstr
+#define mvwgetstr UNDEF(mvwgetstr)
+#endif
+
+#ifdef mvwhline
+inline int UNDEF(mvwhline)(WINDOW *win, int y, int x, chtype c, int n) {
+  return mvwhline(win, y, x, c, n); }
+#undef mvwhline
+#define mvwhline UNDEF(mvwhline)
+#endif
+
+#ifdef mvwinch
+inline chtype UNDEF(mvwinch)(WINDOW *win, int y, int x) {
+  return mvwinch(win, y, x);}
+#undef mvwinch
+#define mvwinch UNDEF(mvwinch)
+#endif
+
+#ifdef mvwinchnstr
+inline int UNDEF(mvwinchnstr)(WINDOW *win, int y, int x, chtype *str, int n)  { return mvwinchnstr(win, y, x, str, n); }
+#undef mvwinchnstr
+#define mvwinchnstr UNDEF(mvwinchnstr)
+#endif
+
+#ifdef mvwinchstr
+inline int UNDEF(mvwinchstr)(WINDOW *win, int y, int x, chtype *str)  { return mvwinchstr(win, y, x, str); }
+#undef mvwinchstr
+#define mvwinchstr UNDEF(mvwinchstr)
+#endif
+
+#ifdef mvwinnstr
+inline int UNDEF(mvwinnstr)(WINDOW *win, int y, int x, char *_str, int n) {
+  return mvwinnstr(win, y, x, _str, n); }
+#undef mvwinnstr
+#define mvwinnstr UNDEF(mvwinnstr)
+#endif
+
+#ifdef mvwinsch
+inline int UNDEF(mvwinsch)(WINDOW *win, int y, int x, chtype c)
+{ return mvwinsch(win, y, x, c); }
+#undef mvwinsch
+#define mvwinsch UNDEF(mvwinsch)
+#endif
+
+#ifdef mvwinsnstr
+inline int UNDEF(mvwinsnstr)(WINDOW *w, int y, int x, const char *_str, int n) {
+  return mvwinsnstr(w, y, x, _str, n); }
+#undef mvwinsnstr
+#define mvwinsnstr UNDEF(mvwinsnstr)
+#endif
+
+#ifdef mvwinsstr
+inline int UNDEF(mvwinsstr)(WINDOW *w, int y, int x,  const char *_str)  {
+  return mvwinsstr(w, y, x, _str); }
+#undef mvwinsstr
+#define mvwinsstr UNDEF(mvwinsstr)
+#endif
+
+#ifdef mvwvline
+inline int UNDEF(mvwvline)(WINDOW *win, int y, int x, chtype c, int n) {
+  return mvwvline(win, y, x, c, n); }
+#undef mvwvline
+#define mvwvline UNDEF(mvwvline)
+#endif
+
+#ifdef napms
+inline void UNDEF(napms)(unsigned long x) { napms(x); }
+#undef napms
+#define napms UNDEF(napms)
+#endif
+
+#ifdef nocrmode
+inline int UNDEF(nocrmode)(void) { return nocrmode(); }
+#undef nocrmode
+#define nocrmode UNDEF(nocrmode)
+#endif
+
+#ifdef nodelay
+inline void UNDEF(nodelay)() { nodelay(); }
+#undef nodelay
+#define nodelay UNDEF(nodelay)
+#endif
+
+#ifdef redrawwin
+inline int UNDEF(redrawwin)(WINDOW *win)  { return redrawwin(win); }
+#undef redrawwin
+#define redrawwin UNDEF(redrawwin)
+#endif
+
+#ifdef refresh
+inline int UNDEF(refresh)()  { return refresh(); }
+#undef refresh
+#define refresh UNDEF(refresh)
+#endif
+
+#ifdef resetterm
+inline int UNDEF(resetterm)(void) { return resetterm(); }
+#undef resetterm
+#define resetterm UNDEF(resetterm)
+#endif
+
+#ifdef saveterm
+inline int UNDEF(saveterm)(void) { return saveterm(); }
+#undef saveterm
+#define saveterm UNDEF(saveterm)
+#endif
+
+#ifdef scrl
+inline int UNDEF(scrl)(int l) { return scrl(l); }
+#undef scrl
+#define scrl UNDEF(scrl)
+#endif
+
+#ifdef scroll
+inline int UNDEF(scroll)(WINDOW *win) { return scroll(win); }
+#undef scroll
+#define scroll UNDEF(scroll)
+#endif
+
+#ifdef scrollok
+inline int UNDEF(scrollok)(WINDOW* win, bool bf)  { return scrollok(win, bf); }
+#undef scrollok
+#define scrollok UNDEF(scrollok)
+#else
+#if	defined(__NCURSES_H)
+extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, bool);
+#else
+extern "C" NCURSES_IMPEXP int NCURSES_API scrollok(WINDOW*, char);
+#endif
+#endif
+
+#ifdef setscrreg
+inline int UNDEF(setscrreg)(int t, int b) { return setscrreg(t, b); }
+#undef setscrreg
+#define setscrreg UNDEF(setscrreg)
+#endif
+
+#ifdef standend
+inline int UNDEF(standend)()  { return standend(); }
+#undef standend
+#define standend UNDEF(standend)
+#endif
+
+#ifdef standout
+inline int UNDEF(standout)()  { return standout(); }
+#undef standout
+#define standout UNDEF(standout)
+#endif
+
+#ifdef subpad
+inline WINDOW *UNDEF(subpad)(WINDOW *p, int l, int c, int y, int x)
+{ return derwin(p, l, c, y, x); }
+#undef subpad
+#define subpad UNDEF(subpad)
+#endif
+
+#ifdef timeout
+inline void UNDEF(timeout)(int delay) { timeout(delay); }
+#undef timeout
+#define timeout UNDEF(timeout)
+#endif
+
+#ifdef touchline
+inline int UNDEF(touchline)(WINDOW *win, int s, int c)
+{ return touchline(win, s, c); }
+#undef touchline
+#define touchline UNDEF(touchline)
+#endif
+
+#ifdef touchwin
+inline int UNDEF(touchwin)(WINDOW *win) { return touchwin(win); }
+#undef touchwin
+#define touchwin UNDEF(touchwin)
+#endif
+
+#ifdef untouchwin
+inline int UNDEF(untouchwin)(WINDOW *win) { return untouchwin(win); }
+#undef untouchwin
+#define untouchwin UNDEF(untouchwin)
+#endif
+
+#ifdef vline
+inline int UNDEF(vline)(chtype ch, int n) { return vline(ch, n); }
+#undef vline
+#define vline UNDEF(vline)
+#endif
+
+#ifdef waddchstr
+inline int UNDEF(waddchstr)(WINDOW *win, chtype *at) { return waddchstr(win, at); }
+#undef waddchstr
+#define waddchstr UNDEF(waddchstr)
+#endif
+
+#ifdef waddstr
+inline int UNDEF(waddstr)(WINDOW *win, char *str) { return waddstr(win, str); }
+#undef waddstr
+#define waddstr UNDEF(waddstr)
+#endif
+
+#ifdef wattroff
+inline int UNDEF(wattroff)(WINDOW *win, int att) { return wattroff(win, att); }
+#undef wattroff
+#define wattroff UNDEF(wattroff)
+#endif
+
+#ifdef wattrset
+inline int UNDEF(wattrset)(WINDOW *win, int att) { return wattrset(win, att); }
+#undef wattrset
+#define wattrset UNDEF(wattrset)
+#endif
+
+#ifdef winch
+inline chtype UNDEF(winch)(const WINDOW* win) { return winch(win); }
+#undef winch
+#define winch UNDEF(winch)
+#endif
+
+#ifdef winchnstr
+inline int UNDEF(winchnstr)(WINDOW *win, chtype *str, int n)  { return winchnstr(win, str, n); }
+#undef winchnstr
+#define winchnstr UNDEF(winchnstr)
+#endif
+
+#ifdef winchstr
+inline int UNDEF(winchstr)(WINDOW *win, chtype *str)  { return winchstr(win, str); }
+#undef winchstr
+#define winchstr UNDEF(winchstr)
+#endif
+
+#ifdef winsstr
+inline int UNDEF(winsstr)(WINDOW *w, const char *_str)  {
+  return winsstr(w, _str); }
+#undef winsstr
+#define winsstr UNDEF(winsstr)
+#endif
+
+#ifdef wstandend
+inline int UNDEF(wstandend)(WINDOW *win)  { return wstandend(win); }
+#undef wstandend
+#define wstandend UNDEF(wstandend)
+#endif
+
+#ifdef wstandout
+inline int UNDEF(wstandout)(WINDOW *win)  { return wstandout(win); }
+#undef wstandout
+#define wstandout UNDEF(wstandout)
+#endif
+
+/*
+ *
+ * C++ class for windows.
+ *
+ */
+
+extern "C" int     _nc_ripoffline(int, int (*init)(WINDOW*, int));
+extern "C" int     _nc_xx_ripoff_init(WINDOW *, int);
+extern "C" int     _nc_has_mouse(void);
+
+class NCURSES_CXX_IMPEXP NCursesWindow
+{
+  friend class NCursesMenu;
+  friend class NCursesForm;
+
+private:
+  static bool    b_initialized;
+  static void    initialize();
+  void           constructing();
+  friend int     _nc_xx_ripoff_init(WINDOW *, int);
+
+  void           set_keyboard();
+
+  NCURSES_COLOR_T getcolor(int getback) const;
+  NCURSES_PAIRS_T getPair() const;
+
+  static int     setpalette(NCURSES_COLOR_T fore, NCURSES_COLOR_T back, NCURSES_PAIRS_T pair);
+  static int     colorInitialized;
+
+  // This private constructor is only used during the initialization
+  // of windows generated by ripoffline() calls.
+  NCursesWindow(WINDOW* win, int ncols);
+
+protected:
+  virtual void   err_handler(const char *) const THROWS(NCursesException);
+  // Signal an error with the given message text.
+
+  static long count;        // count of all active windows:
+  //   We rely on the c++ promise that
+  //   all otherwise uninitialized
+  //   static class vars are set to 0
+
+  WINDOW*        w;                // the curses WINDOW
+
+  bool           alloced;          // TRUE if we own the WINDOW
+
+  NCursesWindow* par;              // parent, if subwindow
+  NCursesWindow* subwins;          // head of subwindows list
+  NCursesWindow* sib;              // next subwindow of parent
+
+  void           kill_subwindows(); // disable all subwindows
+  // Destroy all subwindows.
+
+  /* Only for use by derived classes. They are then in charge to
+     fill the member variables correctly. */
+  NCursesWindow();
+
+public:
+  explicit NCursesWindow(WINDOW* window);   // useful only for stdscr
+
+  NCursesWindow(int nlines,        // number of lines
+		int ncols,         // number of columns
+		int begin_y,       // line origin
+		int begin_x);      // col origin
+
+  NCursesWindow(NCursesWindow& par,// parent window
+		int nlines,        // number of lines
+		int ncols,         // number of columns
+		int begin_y,       // absolute or relative
+		int begin_x,       //   origins:
+		char absrel = 'a');// if `a', begin_y & begin_x are
+  // absolute screen pos, else if `r', they are relative to par origin
+
+  NCursesWindow(NCursesWindow& par,// parent window
+		bool do_box = TRUE);
+  // this is the very common case that we want to create the subwindow that
+  // is two lines and two columns smaller and begins at (1,1).
+  // We may automatically request the box around it.
+
+  NCursesWindow& operator=(const NCursesWindow& rhs)
+  {
+    if (this != &rhs)
+      *this = rhs;
+    return *this;
+  }
+
+  NCursesWindow(const NCursesWindow& rhs)
+    : w(rhs.w), alloced(rhs.alloced), par(rhs.par), subwins(rhs.subwins), sib(rhs.sib)
+  {
+  }
+
+  virtual ~NCursesWindow() THROWS(NCursesException);
+
+  NCursesWindow Clone();
+  // Make an exact copy of the window.
+
+  // Initialization.
+  static void    useColors(void);
+  // Call this routine very early if you want to have colors.
+
+  static int ripoffline(int ripoff_lines,
+			int (*init)(NCursesWindow& win));
+  // This function is used to generate a window of ripped-of lines.
+  // If the argument is positive, lines are removed from the top, if it
+  // is negative lines are removed from the bottom. This enhances the
+  // lowlevel ripoffline() function because it uses the internal
+  // implementation that allows to remove more than just a single line.
+  // This function must be called before any other ncurses function. The
+  // creation of the window is deferred until ncurses gets initialized.
+  // The initialization function is then called.
+
+  // -------------------------------------------------------------------------
+  // terminal status
+  // -------------------------------------------------------------------------
+  int            lines() const { initialize(); return LINES; }
+  // Number of lines on terminal, *not* window
+
+  int            cols() const { initialize(); return COLS; }
+  // Number of cols  on terminal, *not* window
+
+  int            tabsize() const { initialize(); return TABSIZE; }
+  // Size of a tab on terminal, *not* window
+
+  static int     NumberOfColors();
+  // Number of available colors
+
+  int            colors() const { return NumberOfColors(); }
+  // Number of available colors
+
+  // -------------------------------------------------------------------------
+  // window status
+  // -------------------------------------------------------------------------
+  int            height() const { return maxy() + 1; }
+  // Number of lines in this window
+
+  int            width() const { return maxx() + 1; }
+  // Number of columns in this window
+
+  int            begx() const { return getbegx(w); }
+  // Column of top left corner relative to stdscr
+
+  int            begy() const { return getbegy(w); }
+  // Line of top left corner relative to stdscr
+
+  int            curx() const { return getcurx(w); }
+  // Column of top left corner relative to stdscr
+
+  int            cury() const { return getcury(w); }
+  // Line of top left corner relative to stdscr
+
+  int            maxx() const { return getmaxx(w) == ERR ? ERR : getmaxx(w)-1; }
+  // Largest x coord in window
+
+  int            maxy() const { return getmaxy(w) == ERR ? ERR : getmaxy(w)-1; }
+  // Largest y coord in window
+
+  NCURSES_PAIRS_T getcolor() const;
+  // Actual color pair
+
+  NCURSES_COLOR_T foreground() const { return getcolor(0); }
+  // Actual foreground color
+
+  NCURSES_COLOR_T background() const { return getcolor(1); }
+  // Actual background color
+
+  int            setpalette(NCURSES_COLOR_T fore, NCURSES_COLOR_T back);
+  // Set color palette entry
+
+  int            setcolor(NCURSES_PAIRS_T pair);
+  // Set actually used palette entry
+
+  // -------------------------------------------------------------------------
+  // window positioning
+  // -------------------------------------------------------------------------
+  virtual int    mvwin(int begin_y, int begin_x) {
+    return ::mvwin(w, begin_y, begin_x); }
+  // Move window to new position with the new position as top left corner.
+  // This is virtual because it is redefined in NCursesPanel.
+
+  // -------------------------------------------------------------------------
+  // coordinate positioning
+  // -------------------------------------------------------------------------
+  int            move(int y, int x) { return ::wmove(w, y, x); }
+  // Move cursor the this position
+
+  void           getyx(int& y, int& x) const { ::getyx(w, y, x); }
+  // Get current position of the cursor
+
+  void           getbegyx(int& y, int& x) const { ::getbegyx(w, y, x); }
+  // Get beginning of the window
+
+  void           getmaxyx(int& y, int& x) const { ::getmaxyx(w, y, x); }
+  // Get size of the window
+
+  void           getparyx(int& y, int& x) const { ::getparyx(w, y, x); }
+  // Get parent's beginning of the window
+
+  int            mvcur(int oldrow, int oldcol, int newrow, int newcol) const {
+    return ::mvcur(oldrow, oldcol, newrow, newcol); }
+  // Perform lowlevel cursor motion that takes effect immediately.
+
+  // -------------------------------------------------------------------------
+  // input
+  // -------------------------------------------------------------------------
+  int            getch() { return ::wgetch(w); }
+  // Get a keystroke from the window.
+
+  int            getch(int y, int x) { return ::mvwgetch(w, y, x); }
+  // Move cursor to position and get a keystroke from the window
+
+  int            getstr(char* str, int n=-1) {
+    return ::wgetnstr(w, str, n); }
+  // Read a series of characters into str until a newline or carriage return
+  // is received. Read at most n characters. If n is negative, the limit is
+  // ignored.
+
+  int            getstr(int y, int x, char* str, int n=-1) {
+    return ::mvwgetnstr(w, y, x, str, n); }
+  // Move the cursor to the requested position and then perform the getstr()
+  // as described above.
+
+  int            instr(char *s, int n=-1) { return ::winnstr(w, s, n); }
+  // Get a string of characters from the window into the buffer s. Retrieve
+  // at most n characters, if n is negative retrieve all characters up to the
+  // end of the current line. Attributes are stripped from the characters.
+
+  int            instr(int y, int x, char *s, int n=-1) {
+    return ::mvwinnstr(w, y, x, s, n); }
+  // Move the cursor to the requested position and then perform the instr()
+  // as described above.
+
+  int            scanw(const char* fmt, ...)
+    // Perform a scanw function from the window.
+#if __GNUG__ >= 2
+    __attribute__ ((format (scanf, 2, 3)));
+#else
+  ;
+#endif
+
+  int            scanw(const char*, va_list);
+    // Perform a scanw function from the window.
+
+  int            scanw(int y, int x, const char* fmt, ...)
+    // Move the cursor to the requested position and then perform a scanw
+    // from the window.
+#if __GNUG__ >= 2
+    __attribute__ ((format (scanf, 4, 5)));
+#else
+  ;
+#endif
+
+  int            scanw(int y, int x, const char* fmt, va_list);
+    // Move the cursor to the requested position and then perform a scanw
+    // from the window.
+
+  // -------------------------------------------------------------------------
+  // output
+  // -------------------------------------------------------------------------
+  int            addch(const chtype ch) { return ::waddch(w, ch); }
+  // Put attributed character to the window.
+
+  int            addch(int y, int x, const chtype ch) {
+    return ::mvwaddch(w, y, x, ch); }
+  // Move cursor to the requested position and then put attributed character
+  // to the window.
+
+  int            echochar(const chtype ch) { return ::wechochar(w, ch); }
+  // Put attributed character to the window and refresh it immediately.
+
+  int            addstr(const char* str, int n=-1) {
+    return ::waddnstr(w, str, n); }
+  // Write the string str to the window, stop writing if the terminating
+  // NUL or the limit n is reached. If n is negative, it is ignored.
+
+  int            addstr(int y, int x, const char * str, int n=-1) {
+    return ::mvwaddnstr(w, y, x, str, n); }
+  // Move the cursor to the requested position and then perform the addchstr
+  // as described above.
+
+  int            addchstr(const chtype* str, int n=-1) {
+    return ::waddchnstr(w, str, n); }
+  // Write the string str to the window, stop writing if the terminating
+  // NUL or the limit n is reached. If n is negative, it is ignored.
+
+  int            addchstr(int y, int x, const chtype * str, int n=-1) {
+    return ::mvwaddchnstr(w, y, x, str, n); }
+  // Move the cursor to the requested position and then perform the addchstr
+  // as described above.
+
+  int            printw(const char* fmt, ...)
+    // Do a formatted print to the window.
+#if (__GNUG__ >= 2) && !defined(printf)
+    __attribute__ ((format (printf, 2, 3)));
+#else
+  ;
+#endif
+
+  int            printw(int y, int x, const char * fmt, ...)
+    // Move the cursor and then do a formatted print to the window.
+#if (__GNUG__ >= 2) && !defined(printf)
+    __attribute__ ((format (printf, 4, 5)));
+#else
+  ;
+#endif
+
+  int            printw(const char* fmt, va_list args);
+    // Do a formatted print to the window.
+
+  int            printw(int y, int x, const char * fmt, va_list args);
+    // Move the cursor and then do a formatted print to the window.
+
+  chtype         inch() const { return ::winch(w); }
+  // Retrieve attributed character under the current cursor position.
+
+  chtype         inch(int y, int x) { return ::mvwinch(w, y, x); }
+  // Move cursor to requested position and then retrieve attributed character
+  // at this position.
+
+  int            inchstr(chtype* str, int n=-1) {
+    return ::winchnstr(w, str, n); }
+  // Read the string str from the window, stop reading if the terminating
+  // NUL or the limit n is reached. If n is negative, it is ignored.
+
+  int            inchstr(int y, int x, chtype * str, int n=-1) {
+    return ::mvwinchnstr(w, y, x, str, n); }
+  // Move the cursor to the requested position and then perform the inchstr
+  // as described above.
+
+  int            insch(chtype ch) { return ::winsch(w, ch); }
+  // Insert attributed character into the window before current cursor
+  // position.
+
+  int            insch(int y, int x, chtype ch) {
+    return ::mvwinsch(w, y, x, ch); }
+  // Move cursor to requested position and then insert the attributed
+  // character before that position.
+
+  int            insertln() { return ::winsdelln(w, 1); }
+  // Insert an empty line above the current line.
+
+  int            insdelln(int n=1) { return ::winsdelln(w, n); }
+  // If n>0 insert that many lines above the current line. If n<0 delete
+  // that many lines beginning with the current line.
+
+  int            insstr(const char *s, int n=-1) {
+    return ::winsnstr(w, s, n); }
+  // Insert the string into the window before the current cursor position.
+  // Insert stops at end of string or when the limit n is reached. If n is
+  // negative, it is ignored.
+
+  int            insstr(int y, int x, const char *s, int n=-1) {
+    return ::mvwinsnstr(w, y, x, s, n); }
+  // Move the cursor to the requested position and then perform the insstr()
+  // as described above.
+
+  int            attron (chtype at) { return ::wattron (w, at); }
+  // Switch on the window attributes;
+
+  int            attroff(chtype at) { return ::wattroff(w, static_cast<int>(at)); }
+  // Switch off the window attributes;
+
+  int            attrset(chtype at) { return ::wattrset(w, static_cast<int>(at)); }
+  // Set the window attributes;
+
+  chtype         attrget() { return ::getattrs(w); }
+  // Get the window attributes;
+
+  int            color_set(NCURSES_PAIRS_T color_pair_number, void* opts=NULL) {
+    return ::wcolor_set(w, color_pair_number, opts); }
+  // Set the window color attribute;
+
+  int            chgat(int n, attr_t attr, NCURSES_PAIRS_T color, const void *opts=NULL) {
+    return ::wchgat(w, n, attr, color, opts); }
+  // Change the attributes of the next n characters in the current line. If
+  // n is negative or greater than the number of remaining characters in the
+  // line, the attributes will be changed up to the end of the line.
+
+  int            chgat(int y, int x,
+		       int n, attr_t attr, NCURSES_PAIRS_T color, const void *opts=NULL) {
+    return ::mvwchgat(w, y, x, n, attr, color, opts); }
+  // Move the cursor to the requested position and then perform chgat() as
+  // described above.
+
+  // -------------------------------------------------------------------------
+  // background
+  // -------------------------------------------------------------------------
+  chtype         getbkgd() const { return ::getbkgd(w); }
+  // Get current background setting.
+
+  int            bkgd(const chtype ch) { return ::wbkgd(w, ch); }
+  // Set the background property and apply it to the window.
+
+  void           bkgdset(chtype ch) { ::wbkgdset(w, ch); }
+  // Set the background property.
+
+  // -------------------------------------------------------------------------
+  // borders
+  // -------------------------------------------------------------------------
+  int            box(chtype vert=0, chtype  hor=0) {
+    return ::wborder(w, vert, vert, hor, hor, 0, 0, 0, 0); }
+  // Draw a box around the window with the given vertical and horizontal
+  // drawing characters. If you specify a zero as character, curses will try
+  // to find a "nice" character.
+
+  int            border(chtype left=0, chtype right=0,
+			chtype top =0, chtype bottom=0,
+			chtype top_left =0, chtype top_right=0,
+			chtype bottom_left =0, chtype bottom_right=0) {
+    return ::wborder(w, left, right, top, bottom, top_left, top_right,
+		     bottom_left, bottom_right); }
+  // Draw a border around the window with the given characters for the
+  // various parts of the border. If you pass zero for a character, curses
+  // will try to find "nice" characters.
+
+  // -------------------------------------------------------------------------
+  // lines and boxes
+  // -------------------------------------------------------------------------
+  int            hline(int len, chtype ch=0) { return ::whline(w, ch, len); }
+  // Draw a horizontal line of len characters with the given character. If
+  // you pass zero for the character, curses will try to find a "nice" one.
+
+  int            hline(int y, int x, int len, chtype ch=0) {
+    return ::mvwhline(w, y, x, ch, len); }
+  // Move the cursor to the requested position and then draw a horizontal line.
+
+  int            vline(int len, chtype ch=0) { return ::wvline(w, ch, len); }
+  // Draw a vertical line of len characters with the given character. If
+  // you pass zero for the character, curses will try to find a "nice" one.
+
+  int            vline(int y, int x, int len, chtype ch=0) {
+    return ::mvwvline(w, y, x, ch, len); }
+  // Move the cursor to the requested position and then draw a vertical line.
+
+  // -------------------------------------------------------------------------
+  // erasure
+  // -------------------------------------------------------------------------
+  int            erase() { return ::werase(w); }
+  // Erase the window.
+
+  int            clear() { return ::wclear(w); }
+  // Clear the window.
+
+  int            clearok(bool bf) { return ::clearok(w, bf); }
+  // Set/Reset the clear flag. If set, the next refresh() will clear the
+  // screen.
+
+  int            clrtobot() { return ::wclrtobot(w); }
+  // Clear to the end of the window.
+
+  int            clrtoeol() { return ::wclrtoeol(w); }
+  // Clear to the end of the line.
+
+  int            delch() { return ::wdelch(w); }
+  // Delete character under the cursor.
+
+  int            delch(int y, int x) { return ::mvwdelch(w, y, x); }
+  // Move cursor to requested position and delete the character under the
+  // cursor.
+
+  int            deleteln() { return ::winsdelln(w, -1); }
+  // Delete the current line.
+
+  // -------------------------------------------------------------------------
+  // screen control
+  // -------------------------------------------------------------------------
+  int            scroll(int amount=1) { return ::wscrl(w, amount); }
+  // Scroll amount lines. If amount is positive, scroll up, otherwise
+  // scroll down.
+
+  int            scrollok(bool bf) { return ::scrollok(w, bf); }
+  // If bf is TRUE, window scrolls if cursor is moved off the bottom
+  // edge of the window or a scrolling region, otherwise the cursor is left
+  // at the bottom line.
+
+  int            setscrreg(int from, int to) {
+    return ::wsetscrreg(w, from, to); }
+  // Define a soft scrolling region.
+
+  int            idlok(bool bf) { return ::idlok(w, bf); }
+  // If bf is TRUE, use insert/delete line hardware support if possible.
+  // Otherwise do it in software.
+
+  void           idcok(bool bf) { ::idcok(w, bf); }
+  // If bf is TRUE, use insert/delete character hardware support if possible.
+  // Otherwise do it in software.
+
+  int            touchline(int s, int c) { return ::touchline(w, s, c); }
+  // Mark the given lines as modified.
+
+  int            touchwin()   { return ::wtouchln(w, 0, height(), 1); }
+  // Mark the whole window as modified.
+
+  int            untouchwin() { return ::wtouchln(w, 0, height(), 0); }
+  // Mark the whole window as unmodified.
+
+  int            touchln(int s, int cnt, bool changed=TRUE) {
+    return ::wtouchln(w, s, cnt, static_cast<int>(changed ? 1 : 0)); }
+  // Mark cnt lines beginning from line s as changed or unchanged, depending
+  // on the value of the changed flag.
+
+  bool           is_linetouched(int line) const {
+    return (::is_linetouched(w, line) == TRUE ? TRUE:FALSE); }
+  // Return TRUE if line is marked as changed, FALSE otherwise
+
+  bool           is_wintouched() const {
+    return (::is_wintouched(w) ? TRUE:FALSE); }
+  // Return TRUE if window is marked as changed, FALSE otherwise
+
+  int            leaveok(bool bf) { return ::leaveok(w, bf); }
+  // If bf is TRUE, curses will leave the cursor after an update wherever
+  // it is after the update.
+
+  int            redrawln(int from, int n) { return ::wredrawln(w, from, n); }
+  // Redraw n lines starting from the requested line
+
+  int            redrawwin() { return ::wredrawln(w, 0, height()); }
+  // Redraw the whole window
+
+  int            doupdate()  { return ::doupdate(); }
+  // Do all outputs to make the physical screen looking like the virtual one
+
+  void           syncdown()  { ::wsyncdown(w); }
+  // Propagate the changes down to all descendant windows
+
+  void           syncup()    { ::wsyncup(w); }
+  // Propagate the changes up in the hierarchy
+
+  void           cursyncup() { ::wcursyncup(w); }
+  // Position the cursor in all ancestor windows corresponding to our setting
+
+  int            syncok(bool bf) { return ::syncok(w, bf); }
+  // If called with bf=TRUE, syncup() is called whenever the window is changed
+
+#ifndef _no_flushok
+  int            flushok(bool bf) { return ::flushok(w, bf); }
+#endif
+
+  void           immedok(bool bf) { ::immedok(w, bf); }
+  // If called with bf=TRUE, any change in the window will cause an
+  // automatic immediate refresh()
+
+  int            intrflush(bool bf) { return ::intrflush(w, bf); }
+
+  int            keypad(bool bf) { return ::keypad(w, bf); }
+  // If called with bf=TRUE, the application will interpret function keys.
+
+  int            nodelay(bool bf) { return ::nodelay(w, bf); }
+
+  int            meta(bool bf) { return ::meta(w, bf); }
+  // If called with bf=TRUE, keys may generate 8-Bit characters. Otherwise
+  // 7-Bit characters are generated.
+
+  int            standout() { return ::wstandout(w); }
+  // Enable "standout" attributes
+
+  int            standend() { return ::wstandend(w); }
+  // Disable "standout" attributes
+
+  // -------------------------------------------------------------------------
+  // The next two are virtual, because we redefine them in the
+  // NCursesPanel class.
+  // -------------------------------------------------------------------------
+  virtual int    refresh() { return ::wrefresh(w); }
+  // Propagate the changes in this window to the virtual screen and call
+  // doupdate(). This is redefined in NCursesPanel.
+
+  virtual int    noutrefresh() { return ::wnoutrefresh(w); }
+  // Propagate the changes in this window to the virtual screen. This is
+  // redefined in NCursesPanel.
+
+  // -------------------------------------------------------------------------
+  // multiple window control
+  // -------------------------------------------------------------------------
+  int            overlay(NCursesWindow& win) {
+    return ::overlay(w, win.w); }
+  // Overlay this window over win.
+
+  int            overwrite(NCursesWindow& win) {
+    return ::overwrite(w, win.w); }
+  // Overwrite win with this window.
+
+  int            copywin(NCursesWindow& win,
+			 int sminrow, int smincol,
+			 int dminrow, int dmincol,
+			 int dmaxrow, int dmaxcol, bool overlaywin=TRUE) {
+    return ::copywin(w, win.w, sminrow, smincol, dminrow, dmincol,
+		     dmaxrow, dmaxcol, static_cast<int>(overlaywin ? 1 : 0)); }
+  // Overlay or overwrite the rectangle in win given by dminrow,dmincol,
+  // dmaxrow,dmaxcol with the rectangle in this window beginning at
+  // sminrow,smincol.
+
+  // -------------------------------------------------------------------------
+  // Extended functions
+  // -------------------------------------------------------------------------
+#if defined(NCURSES_EXT_FUNCS) && (NCURSES_EXT_FUNCS != 0)
+  int            wresize(int newLines, int newColumns) {
+    return ::wresize(w, newLines, newColumns); }
+#endif
+
+  // -------------------------------------------------------------------------
+  // Mouse related
+  // -------------------------------------------------------------------------
+  bool has_mouse() const;
+  // Return TRUE if terminal supports a mouse, FALSE otherwise
+
+  // -------------------------------------------------------------------------
+  // traversal support
+  // -------------------------------------------------------------------------
+  NCursesWindow*  child() { return subwins; }
+  // Get the first child window.
+
+  NCursesWindow*  sibling() { return sib; }
+  // Get the next child of my parent.
+
+  NCursesWindow*  parent() { return par; }
+  // Get my parent.
+
+  bool isDescendant(NCursesWindow& win);
+  // Return TRUE if win is a descendant of this.
+};
+
+// -------------------------------------------------------------------------
+// We leave this here for compatibility reasons.
+// -------------------------------------------------------------------------
+class NCURSES_CXX_IMPEXP NCursesColorWindow : public NCursesWindow
+{
+public:
+  explicit NCursesColorWindow(WINDOW* &window)   // useful only for stdscr
+    : NCursesWindow(window) {
+      useColors(); }
+
+  NCursesColorWindow(int nlines,        // number of lines
+		     int ncols,         // number of columns
+		     int begin_y,       // line origin
+		     int begin_x)       // col origin
+    : NCursesWindow(nlines, ncols, begin_y, begin_x) {
+      useColors(); }
+
+  NCursesColorWindow(NCursesWindow& parentWin,// parent window
+		     int nlines,        // number of lines
+		     int ncols,         // number of columns
+		     int begin_y,       // absolute or relative
+		     int begin_x,       //   origins:
+		     char absrel = 'a') // if `a', by & bx are
+    : NCursesWindow(parentWin,
+		    nlines, ncols,	// absolute screen pos,
+		    begin_y, begin_x,   // else if `r', they are
+		    absrel ) {          // relative to par origin
+      useColors(); }
+};
+
+// These enum definitions really belong inside the NCursesPad class, but only
+// recent compilers support that feature.
+
+  typedef enum {
+    REQ_PAD_REFRESH = KEY_MAX + 1,
+    REQ_PAD_UP,
+    REQ_PAD_DOWN,
+    REQ_PAD_LEFT,
+    REQ_PAD_RIGHT,
+    REQ_PAD_EXIT
+  } Pad_Request;
+
+  const Pad_Request PAD_LOW  = REQ_PAD_REFRESH;   // lowest  op-code
+  const Pad_Request PAD_HIGH = REQ_PAD_EXIT;      // highest op-code
+
+// -------------------------------------------------------------------------
+// Pad Support. We allow an association of a pad with a "real" window
+// through which the pad may be viewed.
+// -------------------------------------------------------------------------
+class NCURSES_CXX_IMPEXP NCursesPad : public NCursesWindow
+{
+private:
+  NCursesWindow* viewWin;       // the "viewport" window
+  NCursesWindow* viewSub;       // the "viewport" subwindow
+
+  int h_gridsize, v_gridsize;
+
+protected:
+  int min_row, min_col;         // top left row/col of the pads display area
+
+  NCursesWindow* Win(void) const {
+    // Get the window into which the pad should be copied (if any)
+    return (viewSub?viewSub:(viewWin?viewWin:0));
+  }
+
+  NCursesWindow* getWindow(void) const {
+    return viewWin;
+  }
+
+  NCursesWindow* getSubWindow(void) const {
+    return viewSub;
+  }
+
+  virtual int driver (int key);      // Virtualize keystroke key
+  // The driver translates the keystroke c into an Pad_Request
+
+  virtual void OnUnknownOperation(int pad_req) {
+    (void) pad_req;
+    ::beep();
+  }
+  // This is called if the driver returns an unknown op-code
+
+  virtual void OnNavigationError(int pad_req) {
+    (void) pad_req;
+    ::beep();
+  }
+  // This is called if a navigation request couldn't be satisfied
+
+  virtual void OnOperation(int pad_req) {
+    (void) pad_req;
+  };
+  // OnOperation is called if a Pad_Operation was executed and just before
+  // the refresh() operation is done.
+
+public:
+  NCursesPad(int nlines, int ncols);
+  // create a pad with the given size
+
+  NCursesPad& operator=(const NCursesPad& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+      NCursesWindow::operator=(rhs);
+    }
+    return *this;
+  }
+
+  NCursesPad(const NCursesPad& rhs)
+    : NCursesWindow(rhs),
+      viewWin(rhs.viewWin),
+      viewSub(rhs.viewSub),
+      h_gridsize(rhs.h_gridsize),
+      v_gridsize(rhs.v_gridsize),
+      min_row(rhs.min_row),
+      min_col(rhs.min_col)
+  {
+  }
+
+  virtual ~NCursesPad() THROWS(NCursesException) {}
+
+  int echochar(const chtype ch) { return ::pechochar(w, ch); }
+  // Put the attributed character onto the pad and immediately do a
+  // prefresh().
+
+  int refresh() NCURSES_OVERRIDE;
+  // If a viewport is defined the pad is displayed in this window, otherwise
+  // this is a noop.
+
+  int refresh(int pminrow, int pmincol,
+	      int sminrow, int smincol,
+	      int smaxrow, int smaxcol) {
+    return ::prefresh(w, pminrow, pmincol,
+		      sminrow, smincol, smaxrow, smaxcol);
+  }
+  // The coordinates sminrow,smincol,smaxrow,smaxcol describe a rectangle
+  // on the screen. <b>refresh</b> copies a rectangle of this size beginning
+  // with top left corner pminrow,pmincol onto the screen and calls doupdate().
+
+  int noutrefresh() NCURSES_OVERRIDE;
+  // If a viewport is defined the pad is displayed in this window, otherwise
+  // this is a noop.
+
+  int noutrefresh(int pminrow, int pmincol,
+		  int sminrow, int smincol,
+		  int smaxrow, int smaxcol) {
+    return ::pnoutrefresh(w, pminrow, pmincol,
+			  sminrow, smincol, smaxrow, smaxcol);
+  }
+  // Does the same as refresh() but without calling doupdate().
+
+  virtual void setWindow(NCursesWindow& view, int v_grid = 1, int h_grid = 1);
+  // Add the window "view" as viewing window to the pad.
+
+  virtual void setSubWindow(NCursesWindow& sub);
+  // Use the subwindow "sub" of the viewport window for the actual viewing.
+  // The full viewport window is usually used to provide some decorations
+  // like frames, titles etc.
+
+  virtual void operator() (void);
+  // Perform Pad's operation
+};
+
+// A FramedPad is constructed always with a viewport window. This viewport
+// will be framed (by a box() command) and the interior of the box is the
+// viewport subwindow. On the frame we display scrollbar sliders.
+class NCURSES_CXX_IMPEXP NCursesFramedPad : public NCursesPad
+{
+protected:
+  virtual void OnOperation(int pad_req) NCURSES_OVERRIDE;
+
+public:
+  NCursesFramedPad(NCursesWindow& win, int nlines, int ncols,
+		   int v_grid = 1, int h_grid = 1)
+    : NCursesPad(nlines, ncols) {
+    NCursesPad::setWindow(win, v_grid, h_grid);
+    NCursesPad::setSubWindow(*(new NCursesWindow(win)));
+  }
+  // Construct the FramedPad with the given Window win as viewport.
+
+  virtual ~NCursesFramedPad() THROWS(NCursesException) {
+    delete getSubWindow();
+  }
+
+  void setWindow(NCursesWindow& view, int v_grid = 1, int h_grid = 1) NCURSES_OVERRIDE {
+    (void) view;
+    (void) v_grid;
+    (void) h_grid;
+    err_handler("Operation not allowed");
+  }
+  // Disable this call; the viewport is already defined
+
+  void setSubWindow(NCursesWindow& sub) NCURSES_OVERRIDE {
+    (void) sub;
+    err_handler("Operation not allowed");
+  }
+  // Disable this call; the viewport subwindow is already defined
+
+};
+
+#endif /* NCURSES_CURSESW_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/cursslk.h

@@ -0,0 +1,240 @@
+// * this is for making emacs happy: -*-Mode: C++;-*-
+// vile:cppmode
+/****************************************************************************
+ * Copyright 2019-2020,2021 Thomas E. Dickey                                *
+ * Copyright 1998-2003,2005 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer, 1997                                          *
+ ****************************************************************************/
+
+// $Id: cursslk.h,v 1.19 2021/04/17 18:11:08 tom Exp $
+
+#ifndef NCURSES_CURSSLK_H_incl
+#define NCURSES_CURSSLK_H_incl
+
+#include <ncursesw/cursesw.h>
+
+class NCURSES_CXX_IMPEXP Soft_Label_Key_Set {
+public:
+  // This inner class represents the attributes of a Soft Label Key (SLK)
+  class NCURSES_CXX_IMPEXP Soft_Label_Key {
+    friend class Soft_Label_Key_Set;
+  public:
+    typedef enum { Left=0, Center=1, Right=2 } Justification;
+
+  private:
+    char *label;           // The Text of the Label
+    Justification format;  // The Justification
+    int num;               // The number of the Label
+
+    Soft_Label_Key() : label(NULL), format(Left), num(-1) {
+    }
+
+    virtual ~Soft_Label_Key() {
+      delete[] label;
+    };
+
+  public:
+    // Set the text of the Label
+    Soft_Label_Key& operator=(char *text);
+
+    // Set the Justification of the Label
+    Soft_Label_Key& operator=(Justification just) {
+      format = just;
+      return *this;
+    }
+
+    // Retrieve the text of the label
+    inline char* operator()(void) const {
+      return label;
+    }
+
+    Soft_Label_Key& operator=(const Soft_Label_Key& rhs)
+    {
+      if (this != &rhs) {
+        *this = rhs;
+      }
+      return *this;
+    }
+
+    Soft_Label_Key(const Soft_Label_Key& rhs)
+      : label(NULL),
+        format(rhs.format),
+        num(rhs.num)
+    {
+      *this = rhs.label;
+    }
+  };
+
+public:
+  typedef enum {
+    None                = -1,
+    Three_Two_Three     = 0,
+    Four_Four           = 1,
+    PC_Style            = 2,
+    PC_Style_With_Index = 3
+  } Label_Layout;
+
+private:
+  static long count;               // Number of Key Sets
+  static Label_Layout  format;     // Layout of the Key Sets
+  static int  num_labels;          // Number Of Labels in Key Sets
+  bool b_attrInit;                 // Are attributes initialized
+
+  Soft_Label_Key *slk_array;       // The array of SLK's
+
+  // Init the Key Set
+  void init();
+
+  // Activate or Deactivate Label# i, Label counting starts with 1!
+  void activate_label(int i, bool bf=TRUE);
+
+  // Activate of Deactivate all Labels
+  void activate_labels(bool bf);
+
+protected:
+  inline void Error (const char* msg) const THROWS(NCursesException) {
+    THROW(new NCursesException (msg));
+  }
+
+  // Remove SLK's from screen
+  void clear() {
+    if (ERR==::slk_clear())
+      Error("slk_clear");
+  }
+
+  // Restore them
+  void restore() {
+    if (ERR==::slk_restore())
+      Error("slk_restore");
+  }
+
+public:
+
+  // Construct a Key Set, use the most comfortable layout as default.
+  // You must create a Soft_Label_Key_Set before you create any object of
+  // the NCursesWindow, NCursesPanel or derived classes. (Actually before
+  // ::initscr() is called).
+  explicit Soft_Label_Key_Set(Label_Layout fmt);
+
+  // This constructor assumes, that you already constructed a Key Set
+  // with a layout by the constructor above. This layout will be reused.
+  Soft_Label_Key_Set();
+
+  Soft_Label_Key_Set& operator=(const Soft_Label_Key_Set& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+      init();		// allocate a new slk_array[]
+    }
+    return *this;
+  }
+
+  Soft_Label_Key_Set(const Soft_Label_Key_Set& rhs)
+    : b_attrInit(rhs.b_attrInit),
+      slk_array(NULL)
+  {
+    init();		// allocate a new slk_array[]
+  }
+
+  virtual ~Soft_Label_Key_Set() THROWS(NCursesException);
+
+  // Get Label# i. Label counting starts with 1!
+  Soft_Label_Key& operator[](int i);
+
+  // Retrieve number of Labels
+  int labels() const;
+
+  // Refresh the SLK portion of the screen
+  inline void refresh() {
+    if (ERR==::slk_refresh())
+      Error("slk_refresh");
+  }
+
+  // Mark the SLK portion of the screen for refresh, defer actual refresh
+  // until next update call.
+  inline void noutrefresh() {
+    if (ERR==::slk_noutrefresh())
+      Error("slk_noutrefresh");
+  }
+
+  // Mark the whole SLK portion of the screen as modified
+  inline void touch() {
+    if (ERR==::slk_touch())
+      Error("slk_touch");
+  }
+
+  // Activate Label# i
+  inline void show(int i) {
+    activate_label(i,FALSE);
+    activate_label(i,TRUE);
+  }
+
+  // Hide Label# i
+  inline void hide(int i) {
+    activate_label(i,FALSE);
+  }
+
+  // Show all Labels
+  inline void show() {
+    activate_labels(FALSE);
+    activate_labels(TRUE);
+  }
+
+  // Hide all Labels
+  inline void hide() {
+    activate_labels(FALSE);
+  }
+
+  inline void attron(attr_t attrs) {
+    if (ERR==::slk_attron(attrs))
+      Error("slk_attron");
+  }
+
+  inline void attroff(attr_t attrs) {
+    if (ERR==::slk_attroff(attrs))
+      Error("slk_attroff");
+  }
+
+  inline void attrset(attr_t attrs) {
+    if (ERR==::slk_attrset(attrs))
+      Error("slk_attrset");
+  }
+
+  inline void color(short color_pair_number) {
+    if (ERR==::slk_color(color_pair_number))
+      Error("slk_color");
+  }
+
+  inline attr_t attr() const {
+    return ::slk_attr();
+  }
+};
+
+#endif /* NCURSES_CURSSLK_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/eti.h

@@ -0,0 +1,55 @@
+/****************************************************************************
+ * Copyright 2020 Thomas E. Dickey                                          *
+ * Copyright 1998-2002,2003 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author:  Juergen Pfeifer, 1995,1997                                    *
+ ****************************************************************************/
+
+/* $Id: eti.h,v 1.9 2020/02/02 23:34:34 tom Exp $ */
+
+#ifndef NCURSES_ETI_H_incl
+#define NCURSES_ETI_H_incl 1
+
+#define	E_OK			(0)
+#define	E_SYSTEM_ERROR	 	(-1)
+#define	E_BAD_ARGUMENT	 	(-2)
+#define	E_POSTED	 	(-3)
+#define	E_CONNECTED	 	(-4)
+#define	E_BAD_STATE	 	(-5)
+#define	E_NO_ROOM	 	(-6)
+#define	E_NOT_POSTED		(-7)
+#define	E_UNKNOWN_COMMAND	(-8)
+#define	E_NO_MATCH		(-9)
+#define	E_NOT_SELECTABLE	(-10)
+#define	E_NOT_CONNECTED	        (-11)
+#define	E_REQUEST_DENIED	(-12)
+#define	E_INVALID_FIELD	        (-13)
+#define	E_CURRENT		(-14)
+
+#endif

miniconda3/envs/active_proaction/include/ncursesw/etip.h

@@ -0,0 +1,406 @@
+// * This makes emacs happy -*-Mode: C++;-*-
+/****************************************************************************
+ * Copyright 2018-2021,2022 Thomas E. Dickey                                *
+ * Copyright 1998-2012,2017 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer, 1997                                          *
+ ****************************************************************************/
+
+// $Id: etip.h.in,v 1.50 2022/08/20 20:50:00 tom Exp $
+
+#ifndef NCURSES_ETIP_H_incl
+#define NCURSES_ETIP_H_incl 1
+
+// These are substituted at configure/build time
+#ifndef HAVE_BUILTIN_H
+#define HAVE_BUILTIN_H 0
+#endif
+
+#ifndef HAVE_GXX_BUILTIN_H
+#define HAVE_GXX_BUILTIN_H 0
+#endif
+
+#ifndef HAVE_GPP_BUILTIN_H
+#define HAVE_GPP_BUILTIN_H 0
+#endif
+
+#ifndef HAVE_IOSTREAM
+#define HAVE_IOSTREAM 1
+#endif
+
+#ifndef HAVE_TYPEINFO
+#define HAVE_TYPEINFO 1
+#endif
+
+#ifndef HAVE_VALUES_H
+#define HAVE_VALUES_H 0
+#endif
+
+#ifndef ETIP_NEEDS_MATH_H
+#define ETIP_NEEDS_MATH_H 0
+#endif
+
+#ifndef ETIP_NEEDS_MATH_EXCEPTION
+#define ETIP_NEEDS_MATH_EXCEPTION 0
+#endif
+
+#ifndef CPP_HAS_OVERRIDE
+#define CPP_HAS_OVERRIDE 0
+#endif
+
+#ifndef CPP_HAS_PARAM_INIT
+#define CPP_HAS_PARAM_INIT 0
+#endif
+
+#ifndef CPP_HAS_STATIC_CAST
+#define CPP_HAS_STATIC_CAST 1
+#endif
+
+#ifndef IOSTREAM_NAMESPACE
+#define IOSTREAM_NAMESPACE 1
+#endif
+
+#ifdef __GNUG__
+#  if ((__GNUG__ <= 2) && (__GNUC_MINOR__ < 8))
+#    if HAVE_TYPEINFO
+#      include <typeinfo>
+#    endif
+#  endif
+#endif
+
+#if defined(__GNUG__)
+#  if HAVE_BUILTIN_H || HAVE_GXX_BUILTIN_H || HAVE_GPP_BUILTIN_H
+#    if ETIP_NEEDS_MATH_H
+#      if ETIP_NEEDS_MATH_EXCEPTION
+#        undef exception
+#        define exception math_exception
+#      endif
+#      include <math.h>
+#    endif
+#    undef exception
+#    define exception builtin_exception
+#    if HAVE_GPP_BUILTIN_H
+#     include <gpp/builtin.h>
+#    elif HAVE_GXX_BUILTIN_H
+#     include <g++/builtin.h>
+#    else
+#     include <builtin.h>
+#    endif
+#    undef exception
+#  endif
+#elif defined (__SUNPRO_CC)
+#  include <generic.h>
+#endif
+
+#include <ncursesw/curses.h>
+
+extern "C" {
+#if HAVE_VALUES_H
+#  include <values.h>
+#endif
+
+#include <assert.h>
+#include <ncursesw/eti.h>
+#include <errno.h>
+}
+
+// Language features
+#if CPP_HAS_OVERRIDE
+#define NCURSES_OVERRIDE override
+#else
+#define NCURSES_OVERRIDE /*nothing*/
+#endif
+
+#if CPP_HAS_PARAM_INIT
+#define NCURSES_PARAM_INIT(value) = value
+#else
+#define NCURSES_PARAM_INIT(value) /*nothing*/
+#endif
+
+#if CPP_HAS_STATIC_CAST
+#define STATIC_CAST(s) static_cast<s>
+#else
+#define STATIC_CAST(s) (s)
+#endif
+
+#ifndef NCURSES_CXX_IMPEXP
+#define NCURSES_CXX_IMPEXP  /* nothing */
+#endif
+
+// Forward Declarations
+class NCURSES_CXX_IMPEXP NCursesPanel;
+class NCURSES_CXX_IMPEXP NCursesMenu;
+class NCURSES_CXX_IMPEXP NCursesForm;
+
+class NCURSES_CXX_IMPEXP NCursesException
+{
+public:
+  const char *message;
+  int errorno;
+
+  NCursesException (const char* msg, int err)
+    : message(msg), errorno (err)
+    {};
+
+  explicit NCursesException (const char* msg)
+    : message(msg), errorno (E_SYSTEM_ERROR)
+    {};
+
+  NCursesException& operator=(const NCursesException& rhs)
+  {
+    message = rhs.message;
+    errorno = rhs.errorno;
+    return *this;
+  }
+
+  NCursesException(const NCursesException& rhs)
+    : message(rhs.message), errorno(rhs.errorno)
+  {
+  }
+
+  virtual const char *classname() const {
+    return "NCursesWindow";
+  }
+
+  virtual ~NCursesException()
+  {
+  }
+};
+
+class NCURSES_CXX_IMPEXP NCursesPanelException : public NCursesException
+{
+public:
+  const NCursesPanel* p;
+
+  NCursesPanelException (const char *msg, int err) :
+    NCursesException (msg, err),
+    p (0)
+    {};
+
+  NCursesPanelException (const NCursesPanel* panel,
+			 const char *msg,
+			 int err) :
+    NCursesException (msg, err),
+    p (panel)
+    {};
+
+  explicit NCursesPanelException (int err) :
+    NCursesException ("panel library error", err),
+    p (0)
+    {};
+
+  NCursesPanelException (const NCursesPanel* panel,
+			 int err) :
+    NCursesException ("panel library error", err),
+    p (panel)
+    {};
+
+  NCursesPanelException& operator=(const NCursesPanelException& rhs)
+  {
+    if (this != &rhs) {
+      NCursesException::operator=(rhs);
+      p = rhs.p;
+    }
+    return *this;
+  }
+
+  NCursesPanelException(const NCursesPanelException& rhs)
+    : NCursesException(rhs), p(rhs.p)
+  {
+  }
+
+  virtual const char *classname() const NCURSES_OVERRIDE {
+    return "NCursesPanel";
+  }
+
+  virtual ~NCursesPanelException()
+  {
+  }
+};
+
+class NCURSES_CXX_IMPEXP NCursesMenuException : public NCursesException
+{
+public:
+  const NCursesMenu* m;
+
+  NCursesMenuException (const char *msg, int err) :
+    NCursesException (msg, err),
+    m (0)
+    {};
+
+  NCursesMenuException (const NCursesMenu* menu,
+			const char *msg,
+			int err) :
+    NCursesException (msg, err),
+    m (menu)
+    {};
+
+  explicit NCursesMenuException (int err) :
+    NCursesException ("menu library error", err),
+    m (0)
+    {};
+
+  NCursesMenuException (const NCursesMenu* menu,
+			int err) :
+    NCursesException ("menu library error", err),
+    m (menu)
+    {};
+
+  NCursesMenuException& operator=(const NCursesMenuException& rhs)
+  {
+    if (this != &rhs) {
+      NCursesException::operator=(rhs);
+      m = rhs.m;
+    }
+    return *this;
+  }
+
+  NCursesMenuException(const NCursesMenuException& rhs)
+    : NCursesException(rhs), m(rhs.m)
+  {
+  }
+
+  virtual const char *classname() const NCURSES_OVERRIDE {
+    return "NCursesMenu";
+  }
+
+  virtual ~NCursesMenuException()
+  {
+  }
+};
+
+class NCURSES_CXX_IMPEXP NCursesFormException : public NCursesException
+{
+public:
+  const NCursesForm* f;
+
+  NCursesFormException (const char *msg, int err) :
+    NCursesException (msg, err),
+    f (0)
+    {};
+
+  NCursesFormException (const NCursesForm* form,
+			const char *msg,
+			int err) :
+    NCursesException (msg, err),
+    f (form)
+    {};
+
+  explicit NCursesFormException (int err) :
+    NCursesException ("form library error", err),
+    f (0)
+    {};
+
+  NCursesFormException (const NCursesForm* form,
+			int err) :
+    NCursesException ("form library error", err),
+    f (form)
+    {};
+
+  NCursesFormException& operator=(const NCursesFormException& rhs)
+  {
+    if (this != &rhs) {
+      NCursesException::operator=(rhs);
+      f = rhs.f;
+    }
+    return *this;
+  }
+
+  NCursesFormException(const NCursesFormException& rhs)
+    : NCursesException(rhs), f(rhs.f)
+  {
+  }
+
+  virtual const char *classname() const NCURSES_OVERRIDE {
+    return "NCursesForm";
+  }
+
+  virtual ~NCursesFormException()
+  {
+  }
+};
+
+#if !((defined(__GNUG__) && defined(__EXCEPTIONS) && (__GNUG__ < 7)) || defined(__SUNPRO_CC))
+#  if HAVE_IOSTREAM
+#     include <iostream>
+#     if IOSTREAM_NAMESPACE
+using std::cerr;
+using std::endl;
+#     endif
+#  else
+#     include <iostream.h>
+#  endif
+#endif
+
+inline void THROW(const NCursesException *e) {
+#if defined(__GNUG__) && defined(__EXCEPTIONS)
+#  if ((__GNUG__ <= 2) && (__GNUC_MINOR__ < 8))
+      (*lib_error_handler)(e ? e->classname() : "", e ? e->message : "");
+#  elif (__GNUG__ >= 7)
+     // g++ 7.0 warns about deprecation, but lacks the predefined symbols
+      ::endwin();
+      std::cerr << "Found a problem - goodbye" << std::endl;
+      exit(EXIT_FAILURE);
+#  else
+#    define CPP_HAS_TRY_CATCH 1
+#  endif
+#elif defined(__SUNPRO_CC)
+#  if !defined(__SUNPRO_CC_COMPAT) || (__SUNPRO_CC_COMPAT < 5)
+  genericerror(1, ((e != 0) ? (char *)(e->message) : ""));
+#  else
+#    define CPP_HAS_TRY_CATCH 1
+#  endif
+#else
+  if (e)
+    cerr << e->message << endl;
+  exit(0);
+#endif
+
+#ifndef CPP_HAS_TRY_CATCH
+#define CPP_HAS_TRY_CATCH 0
+#define NCURSES_CPP_TRY		/* nothing */
+#define NCURSES_CPP_CATCH(e)	if (false)
+#define THROWS(s)		/* nothing */
+#define THROW2(s,t)		/* nothing */
+#elif CPP_HAS_TRY_CATCH
+  throw *e;
+#define NCURSES_CPP_TRY		try
+#define NCURSES_CPP_CATCH(e)	catch(e)
+#if defined(__cpp_noexcept_function_type) && (__cpp_noexcept_function_type >= 201510)
+// C++17 deprecates the usage of throw().
+#define THROWS(s)		/* nothing */
+#define THROW2(s,t)		/* nothing */
+#else
+#define THROWS(s)		throw(s)
+#define THROW2(s,t)		throw(s,t)
+#endif
+#endif
+}
+
+#endif /* NCURSES_ETIP_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/form.h

@@ -0,0 +1,460 @@
+/****************************************************************************
+ * Copyright 2018-2019-2020,2021 Thomas E. Dickey                           *
+ * Copyright 1998-2016,2017 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author:  Juergen Pfeifer, 1995,1997                                    *
+ ****************************************************************************/
+
+/* $Id: form.h,v 0.32 2021/06/17 21:26:02 tom Exp $ */
+
+#ifndef FORM_H
+#define FORM_H
+/* *INDENT-OFF*/
+
+#include <ncursesw/curses.h>
+#include <ncursesw/eti.h>
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+#if defined(BUILDING_FORM)
+# define FORM_IMPEXP NCURSES_EXPORT_GENERAL_EXPORT
+#else
+# define FORM_IMPEXP NCURSES_EXPORT_GENERAL_IMPORT
+#endif
+
+#define FORM_WRAPPED_VAR(type,name) extern FORM_IMPEXP type NCURSES_PUBLIC_VAR(name)(void)
+
+#define FORM_EXPORT(type) FORM_IMPEXP type NCURSES_API
+#define FORM_EXPORT_VAR(type) FORM_IMPEXP type
+
+#ifndef FORM_PRIV_H
+typedef void *FIELD_CELL;
+#endif
+
+#ifndef NCURSES_FIELD_INTERNALS
+#define NCURSES_FIELD_INTERNALS /* nothing */
+#endif
+
+typedef int Form_Options;
+typedef int Field_Options;
+
+	/**********
+	*  _PAGE  *
+	**********/
+
+typedef struct pagenode
+#if !NCURSES_OPAQUE_FORM
+{
+  short pmin;		/* index of first field on page			*/
+  short pmax;		/* index of last field on page			*/
+  short smin;		/* index of top leftmost field on page		*/
+  short smax;		/* index of bottom rightmost field on page	*/
+}
+#endif /* !NCURSES_OPAQUE_FORM */
+_PAGE;
+
+	/**********
+	*  FIELD  *
+	**********/
+
+typedef struct fieldnode
+#if 1			/* not yet: !NCURSES_OPAQUE_FORM */
+{
+  unsigned short	status;		/* flags			*/
+  short			rows;		/* size in rows			*/
+  short			cols;		/* size in cols			*/
+  short			frow;		/* first row			*/
+  short			fcol;		/* first col			*/
+  int			drows;		/* dynamic rows			*/
+  int			dcols;		/* dynamic cols			*/
+  int			maxgrow;	/* maximum field growth		*/
+  int			nrow;		/* off-screen rows		*/
+  short			nbuf;		/* additional buffers		*/
+  short			just;		/* justification		*/
+  short			page;		/* page on form			*/
+  short			index;		/* into form -> field		*/
+  int			pad;		/* pad character		*/
+  chtype		fore;		/* foreground attribute		*/
+  chtype		back;		/* background attribute		*/
+  Field_Options		opts;		/* options			*/
+  struct fieldnode *	snext;		/* sorted order pointer		*/
+  struct fieldnode *	sprev;		/* sorted order pointer		*/
+  struct fieldnode *	link;		/* linked field chain		*/
+  struct formnode *	form;		/* containing form		*/
+  struct typenode *	type;		/* field type			*/
+  void *		arg;		/* argument for type		*/
+  FIELD_CELL *		buf;		/* field buffers		*/
+  void *		usrptr;		/* user pointer			*/
+  /*
+   * The wide-character configuration requires extra information.  Because
+   * there are existing applications that manipulate the members of FIELD
+   * directly, we cannot make the struct opaque, except by changing the ABI.
+   * Offsets of members up to this point are the same in the narrow- and
+   * wide-character configuration.  But note that the type of buf depends on
+   * the configuration, and is made opaque for that reason.
+   */
+  NCURSES_FIELD_INTERNALS
+}
+#endif /* NCURSES_OPAQUE_FORM */
+FIELD;
+
+
+	/*********
+	*  FORM  *
+	*********/
+
+typedef struct formnode
+#if 1			/* not yet: !NCURSES_OPAQUE_FORM */
+{
+  unsigned short	status;	  	/* flags			*/
+  short			rows;		/* size in rows			*/
+  short			cols;		/* size in cols			*/
+  int			currow;		/* current row in field window	*/
+  int			curcol;		/* current col in field window	*/
+  int			toprow;		/* in scrollable field window	*/
+  int			begincol;	/* in horiz. scrollable field	*/
+  short			maxfield;	/* number of fields		*/
+  short			maxpage;	/* number of pages		*/
+  short			curpage;	/* index into page		*/
+  Form_Options		opts;		/* options			*/
+  WINDOW *		win;		/* window			*/
+  WINDOW *		sub;		/* subwindow			*/
+  WINDOW *		w;		/* window for current field	*/
+  FIELD **		field;		/* field [maxfield]		*/
+  FIELD *		current;	/* current field		*/
+  _PAGE *		page;		/* page [maxpage]		*/
+  void *		usrptr;		/* user pointer			*/
+
+  void			(*forminit)(struct formnode *);
+  void			(*formterm)(struct formnode *);
+  void			(*fieldinit)(struct formnode *);
+  void			(*fieldterm)(struct formnode *);
+
+}
+#endif /* !NCURSES_OPAQUE_FORM */
+FORM;
+
+
+	/**************
+	*  FIELDTYPE  *
+	**************/
+
+typedef struct typenode
+#if !NCURSES_OPAQUE_FORM
+{
+  unsigned short	status;			/* flags		    */
+  long			ref;			/* reference count	    */
+  struct typenode *	left;			/* ptr to operand for |     */
+  struct typenode *	right;			/* ptr to operand for |     */
+
+  void* (*makearg)(va_list *);			/* make fieldtype arg	    */
+  void* (*copyarg)(const void *);		/* copy fieldtype arg 	    */
+  void	(*freearg)(void *);			/* free fieldtype arg	    */
+
+#if NCURSES_INTEROP_FUNCS
+  union {
+    bool (*ofcheck)(FIELD *,const void *);	/* field validation	    */
+    bool (*gfcheck)(FORM*,FIELD *,const void*);	/* generic field validation */
+  } fieldcheck;
+  union {
+    bool (*occheck)(int,const void *);		/* character validation     */
+    bool (*gccheck)(int,FORM*,
+		    FIELD*,const void*);        /* generic char validation  */
+  } charcheck;
+  union {
+    bool (*onext)(FIELD *,const void *);        /* enumerate next value     */
+    bool (*gnext)(FORM*,FIELD*,const void*);    /* generic enumerate next   */
+  } enum_next;
+  union {
+    bool (*oprev)(FIELD *,const void *);	/* enumerate prev value     */
+    bool (*gprev)(FORM*,FIELD*,const void*);    /* generic enumerate prev   */
+  } enum_prev;
+  void* (*genericarg)(void*);                   /* Alternate Arg method     */
+#else
+  bool	(*fcheck)(FIELD *,const void *);	/* field validation	*/
+  bool	(*ccheck)(int,const void *);		/* character validation */
+
+  bool	(*next)(FIELD *,const void *);		/* enumerate next value */
+  bool	(*prev)(FIELD *,const void *);		/* enumerate prev value */
+#endif
+}
+#endif /* !NCURSES_OPAQUE_FORM */
+FIELDTYPE;
+
+typedef void (*Form_Hook)(FORM *);
+
+	/***************************
+	*  miscellaneous #defines  *
+	***************************/
+
+/* field justification */
+#define NO_JUSTIFICATION	(0)
+#define JUSTIFY_LEFT		(1)
+#define JUSTIFY_CENTER		(2)
+#define JUSTIFY_RIGHT		(3)
+
+/* field options */
+#define O_VISIBLE		(0x0001U)
+#define O_ACTIVE		(0x0002U)
+#define O_PUBLIC		(0x0004U)
+#define O_EDIT			(0x0008U)
+#define O_WRAP			(0x0010U)
+#define O_BLANK			(0x0020U)
+#define O_AUTOSKIP		(0x0040U)
+#define O_NULLOK		(0x0080U)
+#define O_PASSOK		(0x0100U)
+#define O_STATIC		(0x0200U)
+#define O_DYNAMIC_JUSTIFY	(0x0400U)	/* ncurses extension	*/
+#define O_NO_LEFT_STRIP		(0x0800U)	/* ncurses extension	*/
+#define O_EDGE_INSERT_STAY      (0x1000U)	/* ncurses extension	*/
+#define O_INPUT_LIMIT           (0x2000U)	/* ncurses extension	*/
+
+/* form options */
+#define O_NL_OVERLOAD		(0x0001U)
+#define O_BS_OVERLOAD		(0x0002U)
+
+/* form driver commands */
+#define REQ_NEXT_PAGE	 (KEY_MAX + 1)	/* move to next page		*/
+#define REQ_PREV_PAGE	 (KEY_MAX + 2)	/* move to previous page	*/
+#define REQ_FIRST_PAGE	 (KEY_MAX + 3)	/* move to first page		*/
+#define REQ_LAST_PAGE	 (KEY_MAX + 4)	/* move to last page		*/
+
+#define REQ_NEXT_FIELD	 (KEY_MAX + 5)	/* move to next field		*/
+#define REQ_PREV_FIELD	 (KEY_MAX + 6)	/* move to previous field	*/
+#define REQ_FIRST_FIELD	 (KEY_MAX + 7)	/* move to first field		*/
+#define REQ_LAST_FIELD	 (KEY_MAX + 8)	/* move to last field		*/
+#define REQ_SNEXT_FIELD	 (KEY_MAX + 9)	/* move to sorted next field	*/
+#define REQ_SPREV_FIELD	 (KEY_MAX + 10)	/* move to sorted prev field	*/
+#define REQ_SFIRST_FIELD (KEY_MAX + 11)	/* move to sorted first field	*/
+#define REQ_SLAST_FIELD	 (KEY_MAX + 12)	/* move to sorted last field	*/
+#define REQ_LEFT_FIELD	 (KEY_MAX + 13)	/* move to left to field	*/
+#define REQ_RIGHT_FIELD	 (KEY_MAX + 14)	/* move to right to field	*/
+#define REQ_UP_FIELD	 (KEY_MAX + 15)	/* move to up to field		*/
+#define REQ_DOWN_FIELD	 (KEY_MAX + 16)	/* move to down to field	*/
+
+#define REQ_NEXT_CHAR	 (KEY_MAX + 17)	/* move to next char in field	*/
+#define REQ_PREV_CHAR	 (KEY_MAX + 18)	/* move to prev char in field	*/
+#define REQ_NEXT_LINE	 (KEY_MAX + 19)	/* move to next line in field	*/
+#define REQ_PREV_LINE	 (KEY_MAX + 20)	/* move to prev line in field	*/
+#define REQ_NEXT_WORD	 (KEY_MAX + 21)	/* move to next word in field	*/
+#define REQ_PREV_WORD	 (KEY_MAX + 22)	/* move to prev word in field	*/
+#define REQ_BEG_FIELD	 (KEY_MAX + 23)	/* move to first char in field	*/
+#define REQ_END_FIELD	 (KEY_MAX + 24)	/* move after last char in fld	*/
+#define REQ_BEG_LINE	 (KEY_MAX + 25)	/* move to beginning of line	*/
+#define REQ_END_LINE	 (KEY_MAX + 26)	/* move after last char in line	*/
+#define REQ_LEFT_CHAR	 (KEY_MAX + 27)	/* move left in field		*/
+#define REQ_RIGHT_CHAR	 (KEY_MAX + 28)	/* move right in field		*/
+#define REQ_UP_CHAR	 (KEY_MAX + 29)	/* move up in field		*/
+#define REQ_DOWN_CHAR	 (KEY_MAX + 30)	/* move down in field		*/
+
+#define REQ_NEW_LINE	 (KEY_MAX + 31)	/* insert/overlay new line	*/
+#define REQ_INS_CHAR	 (KEY_MAX + 32)	/* insert blank char at cursor	*/
+#define REQ_INS_LINE	 (KEY_MAX + 33)	/* insert blank line at cursor	*/
+#define REQ_DEL_CHAR	 (KEY_MAX + 34)	/* delete char at cursor	*/
+#define REQ_DEL_PREV	 (KEY_MAX + 35)	/* delete char before cursor	*/
+#define REQ_DEL_LINE	 (KEY_MAX + 36)	/* delete line at cursor	*/
+#define REQ_DEL_WORD	 (KEY_MAX + 37)	/* delete word at cursor	*/
+#define REQ_CLR_EOL	 (KEY_MAX + 38)	/* clear to end of line		*/
+#define REQ_CLR_EOF	 (KEY_MAX + 39)	/* clear to end of field	*/
+#define REQ_CLR_FIELD	 (KEY_MAX + 40)	/* clear entire field		*/
+#define REQ_OVL_MODE	 (KEY_MAX + 41)	/* begin overlay mode		*/
+#define REQ_INS_MODE	 (KEY_MAX + 42)	/* begin insert mode		*/
+#define REQ_SCR_FLINE	 (KEY_MAX + 43)	/* scroll field forward a line	*/
+#define REQ_SCR_BLINE	 (KEY_MAX + 44)	/* scroll field backward a line	*/
+#define REQ_SCR_FPAGE	 (KEY_MAX + 45)	/* scroll field forward a page	*/
+#define REQ_SCR_BPAGE	 (KEY_MAX + 46)	/* scroll field backward a page	*/
+#define REQ_SCR_FHPAGE	 (KEY_MAX + 47) /* scroll field forward	 half page */
+#define REQ_SCR_BHPAGE	 (KEY_MAX + 48) /* scroll field backward half page */
+#define REQ_SCR_FCHAR	 (KEY_MAX + 49) /* horizontal scroll char	*/
+#define REQ_SCR_BCHAR	 (KEY_MAX + 50) /* horizontal scroll char	*/
+#define REQ_SCR_HFLINE	 (KEY_MAX + 51) /* horizontal scroll line	*/
+#define REQ_SCR_HBLINE	 (KEY_MAX + 52) /* horizontal scroll line	*/
+#define REQ_SCR_HFHALF	 (KEY_MAX + 53) /* horizontal scroll half line	*/
+#define REQ_SCR_HBHALF	 (KEY_MAX + 54) /* horizontal scroll half line	*/
+
+#define REQ_VALIDATION	 (KEY_MAX + 55)	/* validate field		*/
+#define REQ_NEXT_CHOICE	 (KEY_MAX + 56)	/* display next field choice	*/
+#define REQ_PREV_CHOICE	 (KEY_MAX + 57)	/* display prev field choice	*/
+
+#define MIN_FORM_COMMAND (KEY_MAX + 1)	/* used by form_driver		*/
+#define MAX_FORM_COMMAND (KEY_MAX + 57)	/* used by form_driver		*/
+
+#if defined(MAX_COMMAND)
+#  if (MAX_FORM_COMMAND > MAX_COMMAND)
+#    error Something is wrong -- MAX_FORM_COMMAND is greater than MAX_COMMAND
+#  elif (MAX_COMMAND != (KEY_MAX + 128))
+#    error Something is wrong -- MAX_COMMAND is already inconsistently defined.
+#  endif
+#else
+#  define MAX_COMMAND (KEY_MAX + 128)
+#endif
+
+	/*************************
+	*  standard field types  *
+	*************************/
+extern FORM_EXPORT_VAR(FIELDTYPE *) TYPE_ALPHA;
+extern FORM_EXPORT_VAR(FIELDTYPE *) TYPE_ALNUM;
+extern FORM_EXPORT_VAR(FIELDTYPE *) TYPE_ENUM;
+extern FORM_EXPORT_VAR(FIELDTYPE *) TYPE_INTEGER;
+extern FORM_EXPORT_VAR(FIELDTYPE *) TYPE_NUMERIC;
+extern FORM_EXPORT_VAR(FIELDTYPE *) TYPE_REGEXP;
+
+	/************************************
+	*  built-in additional field types  *
+	*  They are not defined in SVr4     *
+	************************************/
+extern FORM_EXPORT_VAR(FIELDTYPE *) TYPE_IPV4;      /* Internet IP Version 4 address */
+
+	/***********************
+	*  FIELDTYPE routines  *
+	***********************/
+extern FORM_EXPORT(FIELDTYPE *) new_fieldtype (
+		    bool (* const field_check)(FIELD *,const void *),
+		    bool (* const char_check)(int,const void *));
+extern FORM_EXPORT(FIELDTYPE *) link_fieldtype(
+		    FIELDTYPE *, FIELDTYPE *);
+
+extern FORM_EXPORT(int)	free_fieldtype (FIELDTYPE *);
+extern FORM_EXPORT(int)	set_fieldtype_arg (FIELDTYPE *,
+		    void * (* const make_arg)(va_list *),
+		    void * (* const copy_arg)(const void *),
+		    void (* const free_arg)(void *));
+extern FORM_EXPORT(int)	 set_fieldtype_choice (FIELDTYPE *,
+		    bool (* const next_choice)(FIELD *,const void *),
+	      	    bool (* const prev_choice)(FIELD *,const void *));
+
+	/*******************
+	*  FIELD routines  *
+	*******************/
+extern FORM_EXPORT(FIELD *)	new_field (int,int,int,int,int,int);
+extern FORM_EXPORT(FIELD *)	dup_field (FIELD *,int,int);
+extern FORM_EXPORT(FIELD *)	link_field (FIELD *,int,int);
+
+extern FORM_EXPORT(int)	free_field (FIELD *);
+extern FORM_EXPORT(int)	field_info (const FIELD *,int *,int *,int *,int *,int *,int *);
+extern FORM_EXPORT(int)	dynamic_field_info (const FIELD *,int *,int *,int *);
+extern FORM_EXPORT(int)	set_max_field ( FIELD *,int);
+extern FORM_EXPORT(int)	move_field (FIELD *,int,int);
+extern FORM_EXPORT(int)	set_field_type (FIELD *,FIELDTYPE *,...);
+extern FORM_EXPORT(int)	set_new_page (FIELD *,bool);
+extern FORM_EXPORT(int)	set_field_just (FIELD *,int);
+extern FORM_EXPORT(int)	field_just (const FIELD *);
+extern FORM_EXPORT(int)	set_field_fore (FIELD *,chtype);
+extern FORM_EXPORT(int)	set_field_back (FIELD *,chtype);
+extern FORM_EXPORT(int)	set_field_pad (FIELD *,int);
+extern FORM_EXPORT(int)	field_pad (const FIELD *);
+extern FORM_EXPORT(int)	set_field_buffer (FIELD *,int,const char *);
+extern FORM_EXPORT(int)	set_field_status (FIELD *,bool);
+extern FORM_EXPORT(int)	set_field_userptr (FIELD *, void *);
+extern FORM_EXPORT(int)	set_field_opts (FIELD *,Field_Options);
+extern FORM_EXPORT(int)	field_opts_on (FIELD *,Field_Options);
+extern FORM_EXPORT(int)	field_opts_off (FIELD *,Field_Options);
+
+extern FORM_EXPORT(chtype)	field_fore (const FIELD *);
+extern FORM_EXPORT(chtype)	field_back (const FIELD *);
+
+extern FORM_EXPORT(bool)	new_page (const FIELD *);
+extern FORM_EXPORT(bool)	field_status (const FIELD *);
+
+extern FORM_EXPORT(void *)	field_arg (const FIELD *);
+
+extern FORM_EXPORT(void *)	field_userptr (const FIELD *);
+
+extern FORM_EXPORT(FIELDTYPE *)	field_type (const FIELD *);
+
+extern FORM_EXPORT(char *)	field_buffer (const FIELD *,int);
+
+extern FORM_EXPORT(Field_Options)	field_opts (const FIELD *);
+
+	/******************
+	*  FORM routines  *
+	******************/
+
+extern FORM_EXPORT(FORM *)	new_form (FIELD **);
+
+extern FORM_EXPORT(FIELD **)	form_fields (const FORM *);
+extern FORM_EXPORT(FIELD *)	current_field (const FORM *);
+
+extern FORM_EXPORT(WINDOW *)	form_win (const FORM *);
+extern FORM_EXPORT(WINDOW *)	form_sub (const FORM *);
+
+extern FORM_EXPORT(Form_Hook)	form_init (const FORM *);
+extern FORM_EXPORT(Form_Hook)	form_term (const FORM *);
+extern FORM_EXPORT(Form_Hook)	field_init (const FORM *);
+extern FORM_EXPORT(Form_Hook)	field_term (const FORM *);
+
+extern FORM_EXPORT(int)	free_form (FORM *);
+extern FORM_EXPORT(int)	set_form_fields (FORM *,FIELD **);
+extern FORM_EXPORT(int)	field_count (const FORM *);
+extern FORM_EXPORT(int)	set_form_win (FORM *,WINDOW *);
+extern FORM_EXPORT(int)	set_form_sub (FORM *,WINDOW *);
+extern FORM_EXPORT(int)	set_current_field (FORM *,FIELD *);
+extern FORM_EXPORT(int)	unfocus_current_field (FORM *);
+extern FORM_EXPORT(int)	field_index (const FIELD *);
+extern FORM_EXPORT(int)	set_form_page (FORM *,int);
+extern FORM_EXPORT(int)	form_page (const FORM *);
+extern FORM_EXPORT(int)	scale_form (const FORM *,int *,int *);
+extern FORM_EXPORT(int)	set_form_init (FORM *,Form_Hook);
+extern FORM_EXPORT(int)	set_form_term (FORM *,Form_Hook);
+extern FORM_EXPORT(int)	set_field_init (FORM *,Form_Hook);
+extern FORM_EXPORT(int)	set_field_term (FORM *,Form_Hook);
+extern FORM_EXPORT(int)	post_form (FORM *);
+extern FORM_EXPORT(int)	unpost_form (FORM *);
+extern FORM_EXPORT(int)	pos_form_cursor (FORM *);
+extern FORM_EXPORT(int)	form_driver (FORM *,int);
+# if NCURSES_WIDECHAR
+extern FORM_EXPORT(int)	form_driver_w (FORM *,int,wchar_t);
+# endif
+extern FORM_EXPORT(int)	set_form_userptr (FORM *,void *);
+extern FORM_EXPORT(int)	set_form_opts (FORM *,Form_Options);
+extern FORM_EXPORT(int)	form_opts_on (FORM *,Form_Options);
+extern FORM_EXPORT(int)	form_opts_off (FORM *,Form_Options);
+extern FORM_EXPORT(int)	form_request_by_name (const char *);
+
+extern FORM_EXPORT(const char *)	form_request_name (int);
+
+extern FORM_EXPORT(void *)	form_userptr (const FORM *);
+
+extern FORM_EXPORT(Form_Options)	form_opts (const FORM *);
+
+extern FORM_EXPORT(bool)	data_ahead (const FORM *);
+extern FORM_EXPORT(bool)	data_behind (const FORM *);
+
+#if NCURSES_SP_FUNCS
+extern FORM_EXPORT(FORM *)	NCURSES_SP_NAME(new_form) (SCREEN*, FIELD **);
+#endif
+
+#ifdef __cplusplus
+  }
+#endif
+/* *INDENT-ON*/
+
+#endif /* FORM_H */

miniconda3/envs/active_proaction/include/ncursesw/menu.h

@@ -0,0 +1,281 @@
+/****************************************************************************
+ * Copyright 2020 Thomas E. Dickey                                          *
+ * Copyright 1998-2016,2017 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author:  Juergen Pfeifer, 1995,1997                                    *
+ ****************************************************************************/
+
+/* $Id: menu.h,v 1.26 2020/12/12 00:38:02 tom Exp $ */
+
+#ifndef ETI_MENU
+#define ETI_MENU
+
+#ifdef AMIGA
+#define TEXT TEXT_ncurses
+#endif
+
+#include <ncursesw/curses.h>
+#include <ncursesw/eti.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if defined(BUILDING_MENU)
+# define MENU_IMPEXP NCURSES_EXPORT_GENERAL_EXPORT
+#else
+# define MENU_IMPEXP NCURSES_EXPORT_GENERAL_IMPORT
+#endif
+
+#define MENU_WRAPPED_VAR(type,name) extern MENU_IMPEXP type NCURSES_PUBLIC_VAR(name)(void)
+
+#define MENU_EXPORT(type) MENU_IMPEXP type NCURSES_API
+#define MENU_EXPORT_VAR(type) MENU_IMPEXP type
+
+  typedef int Menu_Options;
+  typedef int Item_Options;
+
+/* Menu options: */
+#define O_ONEVALUE      (0x01)
+#define O_SHOWDESC      (0x02)
+#define O_ROWMAJOR      (0x04)
+#define O_IGNORECASE    (0x08)
+#define O_SHOWMATCH     (0x10)
+#define O_NONCYCLIC     (0x20)
+#define O_MOUSE_MENU    (0x40)
+
+/* Item options: */
+#define O_SELECTABLE    (0x01)
+
+#if !NCURSES_OPAQUE_MENU
+  typedef struct
+    {
+      const char *str;
+      unsigned short length;
+    }
+  TEXT;
+#endif				/* !NCURSES_OPAQUE_MENU */
+
+  struct tagMENU;
+
+  typedef struct tagITEM
+#if !NCURSES_OPAQUE_MENU
+    {
+      TEXT name;		/* name of menu item                         */
+      TEXT description;		/* description of item, optional in display  */
+      struct tagMENU *imenu;	/* Pointer to parent menu                    */
+      void *userptr;		/* Pointer to user defined per item data     */
+      Item_Options opt;		/* Item options                              */
+      short index;		/* Item number if connected to a menu        */
+      short y;			/* y and x location of item in menu          */
+      short x;
+      bool value;		/* Selection value                           */
+
+      struct tagITEM *left;	/* neighbor items                            */
+      struct tagITEM *right;
+      struct tagITEM *up;
+      struct tagITEM *down;
+
+    }
+#endif				/* !NCURSES_OPAQUE_MENU */
+  ITEM;
+
+  typedef void (*Menu_Hook) (struct tagMENU *);
+
+  typedef struct tagMENU
+#if 1				/* not yet: !NCURSES_OPAQUE_MENU   */
+    {
+      short height;		/* Nr. of chars high               */
+      short width;		/* Nr. of chars wide               */
+      short rows;		/* Nr. of items high               */
+      short cols;		/* Nr. of items wide               */
+      short frows;		/* Nr. of formatted items high     */
+      short fcols;		/* Nr. of formatted items wide     */
+      short arows;		/* Nr. of items high (actual)      */
+      short namelen;		/* Max. name length                */
+      short desclen;		/* Max. description length         */
+      short marklen;		/* Length of mark, if any          */
+      short itemlen;		/* Length of one item              */
+      short spc_desc;		/* Spacing for descriptor          */
+      short spc_cols;		/* Spacing for columns             */
+      short spc_rows;		/* Spacing for rows                */
+      char *pattern;		/* Buffer to store match chars     */
+      short pindex;		/* Index into pattern buffer       */
+      WINDOW *win;		/* Window containing menu          */
+      WINDOW *sub;		/* Subwindow for menu display      */
+      WINDOW *userwin;		/* User's window                   */
+      WINDOW *usersub;		/* User's subwindow                */
+      ITEM **items;		/* array of items                  */
+      short nitems;		/* Nr. of items in menu            */
+      ITEM *curitem;		/* Current item                    */
+      short toprow;		/* Top row of menu                 */
+      chtype fore;		/* Selection attribute             */
+      chtype back;		/* Nonselection attribute          */
+      chtype grey;		/* Inactive attribute              */
+      unsigned char pad;	/* Pad character                   */
+
+      Menu_Hook menuinit;	/* User hooks                      */
+      Menu_Hook menuterm;
+      Menu_Hook iteminit;
+      Menu_Hook itemterm;
+
+      void *userptr;		/* Pointer to menus user data      */
+      char *mark;		/* Pointer to marker string        */
+
+      Menu_Options opt;		/* Menu options                    */
+      unsigned short status;	/* Internal state of menu          */
+    }
+#endif				/* !NCURSES_OPAQUE_MENU */
+  MENU;
+
+/* Define keys */
+
+#define REQ_LEFT_ITEM           (KEY_MAX + 1)
+#define REQ_RIGHT_ITEM          (KEY_MAX + 2)
+#define REQ_UP_ITEM             (KEY_MAX + 3)
+#define REQ_DOWN_ITEM           (KEY_MAX + 4)
+#define REQ_SCR_ULINE           (KEY_MAX + 5)
+#define REQ_SCR_DLINE           (KEY_MAX + 6)
+#define REQ_SCR_DPAGE           (KEY_MAX + 7)
+#define REQ_SCR_UPAGE           (KEY_MAX + 8)
+#define REQ_FIRST_ITEM          (KEY_MAX + 9)
+#define REQ_LAST_ITEM           (KEY_MAX + 10)
+#define REQ_NEXT_ITEM           (KEY_MAX + 11)
+#define REQ_PREV_ITEM           (KEY_MAX + 12)
+#define REQ_TOGGLE_ITEM         (KEY_MAX + 13)
+#define REQ_CLEAR_PATTERN       (KEY_MAX + 14)
+#define REQ_BACK_PATTERN        (KEY_MAX + 15)
+#define REQ_NEXT_MATCH          (KEY_MAX + 16)
+#define REQ_PREV_MATCH          (KEY_MAX + 17)
+
+#define MIN_MENU_COMMAND        (KEY_MAX + 1)
+#define MAX_MENU_COMMAND        (KEY_MAX + 17)
+
+/*
+ * Some AT&T code expects MAX_COMMAND to be out-of-band not
+ * just for menu commands but for forms ones as well.
+ */
+#if defined(MAX_COMMAND)
+#  if (MAX_MENU_COMMAND > MAX_COMMAND)
+#    error Something is wrong -- MAX_MENU_COMMAND is greater than MAX_COMMAND
+#  elif (MAX_COMMAND != (KEY_MAX + 128))
+#    error Something is wrong -- MAX_COMMAND is already inconsistently defined.
+#  endif
+#else
+#  define MAX_COMMAND (KEY_MAX + 128)
+#endif
+
+/* --------- prototypes for libmenu functions ----------------------------- */
+
+  extern MENU_EXPORT(ITEM **) menu_items(const MENU *);
+  extern MENU_EXPORT(ITEM *) current_item(const MENU *);
+  extern MENU_EXPORT(ITEM *) new_item(const char *, const char *);
+
+  extern MENU_EXPORT(MENU *) new_menu(ITEM **);
+
+  extern MENU_EXPORT(Item_Options) item_opts(const ITEM *);
+  extern MENU_EXPORT(Menu_Options) menu_opts(const MENU *);
+
+  extern MENU_EXPORT(Menu_Hook) item_init(const MENU *);
+  extern MENU_EXPORT(Menu_Hook) item_term(const MENU *);
+  extern MENU_EXPORT(Menu_Hook) menu_init(const MENU *);
+  extern MENU_EXPORT(Menu_Hook) menu_term(const MENU *);
+
+  extern MENU_EXPORT(WINDOW *) menu_sub(const MENU *);
+  extern MENU_EXPORT(WINDOW *) menu_win(const MENU *);
+
+  extern MENU_EXPORT(const char *) item_description(const ITEM *);
+  extern MENU_EXPORT(const char *) item_name(const ITEM *);
+  extern MENU_EXPORT(const char *) menu_mark(const MENU *);
+  extern MENU_EXPORT(const char *) menu_request_name(int);
+
+  extern MENU_EXPORT(char *) menu_pattern(const MENU *);
+
+  extern MENU_EXPORT(void *) menu_userptr(const MENU *);
+  extern MENU_EXPORT(void *) item_userptr(const ITEM *);
+
+  extern MENU_EXPORT(chtype) menu_back(const MENU *);
+  extern MENU_EXPORT(chtype) menu_fore(const MENU *);
+  extern MENU_EXPORT(chtype) menu_grey(const MENU *);
+
+  extern MENU_EXPORT(int) free_item(ITEM *);
+  extern MENU_EXPORT(int) free_menu(MENU *);
+  extern MENU_EXPORT(int) item_count(const MENU *);
+  extern MENU_EXPORT(int) item_index(const ITEM *);
+  extern MENU_EXPORT(int) item_opts_off(ITEM *, Item_Options);
+  extern MENU_EXPORT(int) item_opts_on(ITEM *, Item_Options);
+  extern MENU_EXPORT(int) menu_driver(MENU *, int);
+  extern MENU_EXPORT(int) menu_opts_off(MENU *, Menu_Options);
+  extern MENU_EXPORT(int) menu_opts_on(MENU *, Menu_Options);
+  extern MENU_EXPORT(int) menu_pad(const MENU *);
+  extern MENU_EXPORT(int) pos_menu_cursor(const MENU *);
+  extern MENU_EXPORT(int) post_menu(MENU *);
+  extern MENU_EXPORT(int) scale_menu(const MENU *, int *, int *);
+  extern MENU_EXPORT(int) set_current_item(MENU *menu, ITEM *item);
+  extern MENU_EXPORT(int) set_item_init(MENU *, Menu_Hook);
+  extern MENU_EXPORT(int) set_item_opts(ITEM *, Item_Options);
+  extern MENU_EXPORT(int) set_item_term(MENU *, Menu_Hook);
+  extern MENU_EXPORT(int) set_item_userptr(ITEM *, void *);
+  extern MENU_EXPORT(int) set_item_value(ITEM *, bool);
+  extern MENU_EXPORT(int) set_menu_back(MENU *, chtype);
+  extern MENU_EXPORT(int) set_menu_fore(MENU *, chtype);
+  extern MENU_EXPORT(int) set_menu_format(MENU *, int, int);
+  extern MENU_EXPORT(int) set_menu_grey(MENU *, chtype);
+  extern MENU_EXPORT(int) set_menu_init(MENU *, Menu_Hook);
+  extern MENU_EXPORT(int) set_menu_items(MENU *, ITEM **);
+  extern MENU_EXPORT(int) set_menu_mark(MENU *, const char *);
+  extern MENU_EXPORT(int) set_menu_opts(MENU *, Menu_Options);
+  extern MENU_EXPORT(int) set_menu_pad(MENU *, int);
+  extern MENU_EXPORT(int) set_menu_pattern(MENU *, const char *);
+  extern MENU_EXPORT(int) set_menu_sub(MENU *, WINDOW *);
+  extern MENU_EXPORT(int) set_menu_term(MENU *, Menu_Hook);
+  extern MENU_EXPORT(int) set_menu_userptr(MENU *, void *);
+  extern MENU_EXPORT(int) set_menu_win(MENU *, WINDOW *);
+  extern MENU_EXPORT(int) set_top_row(MENU *, int);
+  extern MENU_EXPORT(int) top_row(const MENU *);
+  extern MENU_EXPORT(int) unpost_menu(MENU *);
+  extern MENU_EXPORT(int) menu_request_by_name(const char *);
+  extern MENU_EXPORT(int) set_menu_spacing(MENU *, int, int, int);
+  extern MENU_EXPORT(int) menu_spacing(const MENU *, int *, int *, int *);
+
+  extern MENU_EXPORT(bool) item_value(const ITEM *);
+  extern MENU_EXPORT(bool) item_visible(const ITEM *);
+
+  extern MENU_EXPORT(void) menu_format(const MENU *, int *, int *);
+
+#if NCURSES_SP_FUNCS
+  extern MENU_EXPORT(MENU *) NCURSES_SP_NAME(new_menu) (SCREEN *, ITEM **);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif				/* ETI_MENU */

miniconda3/envs/active_proaction/include/ncursesw/ncurses_dll.h

@@ -0,0 +1,103 @@
+/****************************************************************************
+ * Copyright 2018-2020,2023 Thomas E. Dickey                                *
+ * Copyright 2009,2014 Free Software Foundation, Inc.                       *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+/* $Id: ncurses_dll.h.in,v 1.18 2023/05/06 20:12:43 tom Exp $ */
+
+#ifndef NCURSES_DLL_H_incl
+#define NCURSES_DLL_H_incl 1
+
+/*
+ * MinGW gcc (unlike MSYS2 and Cygwin) should define _WIN32 and possibly _WIN64.
+ */
+#if defined(__MINGW64__)
+
+#ifndef _WIN64
+#define _WIN64 1
+#endif
+
+#elif defined(__MINGW32__)
+
+#ifndef _WIN32
+#define _WIN32 1
+#endif
+
+/* 2014-08-02 workaround for broken MinGW compiler.
+ * Oddly, only TRACE is mapped to trace - the other -D's are okay.
+ * suggest TDM as an alternative.
+ */
+#if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8)
+
+#ifdef trace
+#undef trace
+#define TRACE
+#endif
+
+#endif	/* broken compiler */
+
+#endif	/* MingW */
+
+/*
+ * For reentrant code, we map the various global variables into SCREEN by
+ * using functions to access them.
+ */
+#define NCURSES_PUBLIC_VAR(name) _nc_##name
+
+#if defined(BUILDING_NCURSES)
+# define NCURSES_IMPEXP NCURSES_EXPORT_GENERAL_EXPORT
+#else
+# define NCURSES_IMPEXP NCURSES_EXPORT_GENERAL_IMPORT
+#endif
+
+#define NCURSES_WRAPPED_VAR(type,name) extern NCURSES_IMPEXP type NCURSES_PUBLIC_VAR(name)(void)
+
+#define NCURSES_EXPORT(type) NCURSES_IMPEXP type NCURSES_API
+#define NCURSES_EXPORT_VAR(type) NCURSES_IMPEXP type
+
+/*
+ * These symbols hide dllimport/dllexport, for compilers which care about it.
+ */
+#if defined(__CYGWIN__) || (defined(_WIN32) || defined(_WIN64))
+# if defined(NCURSES_STATIC)	/* "static" here only implies "not-a-DLL" */
+#   define NCURSES_EXPORT_GENERAL_IMPORT
+#   define NCURSES_EXPORT_GENERAL_EXPORT
+# else
+#   define NCURSES_EXPORT_GENERAL_IMPORT __declspec(dllimport)
+#   define NCURSES_EXPORT_GENERAL_EXPORT __declspec(dllexport)
+# endif
+# define NCURSES_API __cdecl
+#else
+# define NCURSES_EXPORT_GENERAL_IMPORT
+# if (__GNUC__ >= 4) && !defined(__cplusplus)
+#   define NCURSES_EXPORT_GENERAL_EXPORT __attribute__((visibility ("default")))
+# else
+#   define NCURSES_EXPORT_GENERAL_EXPORT
+# endif
+# define NCURSES_API /* FIXME: __attribute__ ((cdecl)) is only available on x86 */
+#endif
+
+#endif /* NCURSES_DLL_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/panel.h

@@ -0,0 +1,100 @@
+/****************************************************************************
+ * Copyright 2020 Thomas E. Dickey                                          *
+ * Copyright 1998-2009,2017 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1995                    *
+ *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
+ *     and: Juergen Pfeifer                         1996-1999,2008          *
+ ****************************************************************************/
+
+/* $Id: panel.h,v 1.14 2020/07/04 20:38:43 tom Exp $ */
+
+/* panel.h -- interface file for panels library */
+
+#ifndef NCURSES_PANEL_H_incl
+#define NCURSES_PANEL_H_incl 1
+
+#include <ncursesw/curses.h>
+
+typedef struct panel
+#if !NCURSES_OPAQUE_PANEL
+{
+  WINDOW *win;
+  struct panel *below;
+  struct panel *above;
+  NCURSES_CONST void *user;
+}
+#endif /* !NCURSES_OPAQUE_PANEL */
+PANEL;
+
+#if	defined(__cplusplus)
+extern "C" {
+#endif
+
+#if defined(BUILDING_PANEL)
+# define PANEL_IMPEXP NCURSES_EXPORT_GENERAL_EXPORT
+#else
+# define PANEL_IMPEXP NCURSES_EXPORT_GENERAL_IMPORT
+#endif
+
+#define PANEL_WRAPPED_VAR(type,name) extern PANEL_IMPEXP type NCURSES_PUBLIC_VAR(name)(void)
+
+#define PANEL_EXPORT(type) PANEL_IMPEXP type NCURSES_API
+#define PANEL_EXPORT_VAR(type) PANEL_IMPEXP type
+
+extern PANEL_EXPORT(WINDOW*) panel_window (const PANEL *);
+extern PANEL_EXPORT(void)    update_panels (void);
+extern PANEL_EXPORT(int)     hide_panel (PANEL *);
+extern PANEL_EXPORT(int)     show_panel (PANEL *);
+extern PANEL_EXPORT(int)     del_panel (PANEL *);
+extern PANEL_EXPORT(int)     top_panel (PANEL *);
+extern PANEL_EXPORT(int)     bottom_panel (PANEL *);
+extern PANEL_EXPORT(PANEL*)  new_panel (WINDOW *);
+extern PANEL_EXPORT(PANEL*)  panel_above (const PANEL *);
+extern PANEL_EXPORT(PANEL*)  panel_below (const PANEL *);
+extern PANEL_EXPORT(int)     set_panel_userptr (PANEL *, NCURSES_CONST void *);
+extern PANEL_EXPORT(NCURSES_CONST void*) panel_userptr (const PANEL *);
+extern PANEL_EXPORT(int)     move_panel (PANEL *, int, int);
+extern PANEL_EXPORT(int)     replace_panel (PANEL *,WINDOW *);
+extern PANEL_EXPORT(int)     panel_hidden (const PANEL *);
+
+#if NCURSES_SP_FUNCS
+extern PANEL_EXPORT(PANEL *) ground_panel(SCREEN *);
+extern PANEL_EXPORT(PANEL *) ceiling_panel(SCREEN *);
+
+extern PANEL_EXPORT(void)    NCURSES_SP_NAME(update_panels) (SCREEN*);
+#endif
+
+#if	defined(__cplusplus)
+}
+#endif
+
+#endif /* NCURSES_PANEL_H_incl */
+
+/* end of panel.h */

miniconda3/envs/active_proaction/include/ncursesw/term.h

@@ -0,0 +1,890 @@
+/****************************************************************************
+ * Copyright 2018-2021,2023 Thomas E. Dickey                                *
+ * Copyright 1998-2013,2017 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************/
+/* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995                */
+/*    and: Eric S. Raymond <esr@snark.thyrsus.com>                          */
+/*    and: Thomas E. Dickey                        1995-on                  */
+/****************************************************************************/
+
+/* $Id: MKterm.h.awk.in,v 1.85 2023/04/23 19:15:36 tom Exp $ */
+
+/*
+**	term.h -- Definition of struct term
+*/
+
+#ifndef NCURSES_TERM_H_incl
+#define NCURSES_TERM_H_incl 1
+
+#undef  NCURSES_VERSION
+#define NCURSES_VERSION "6.5"
+
+#include <ncursesw/ncurses_dll.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Make this file self-contained by providing defaults for the HAVE_TERMIO[S]_H
+ * definition (based on the system for which this was configured).
+ */
+
+#ifndef __NCURSES_H
+
+typedef struct screen  SCREEN;
+
+#if 1
+#undef  NCURSES_SP_FUNCS
+#define NCURSES_SP_FUNCS 20240427
+#undef  NCURSES_SP_NAME
+#define NCURSES_SP_NAME(name) name##_sp
+
+/* Define the sp-funcs helper function */
+#undef  NCURSES_SP_OUTC
+#define NCURSES_SP_OUTC NCURSES_SP_NAME(NCURSES_OUTC)
+typedef int (*NCURSES_SP_OUTC)(SCREEN*, int);
+#endif
+
+#endif /* __NCURSES_H */
+
+#undef  NCURSES_CONST
+#define NCURSES_CONST const
+
+#undef  NCURSES_SBOOL
+#define NCURSES_SBOOL char
+
+#undef  NCURSES_USE_DATABASE
+#define NCURSES_USE_DATABASE 1
+
+#undef  NCURSES_USE_TERMCAP
+#define NCURSES_USE_TERMCAP 1
+
+#undef  NCURSES_XNAMES
+#define NCURSES_XNAMES 1
+
+/* We will use these symbols to hide differences between
+ * termios/termio/sgttyb interfaces.
+ */
+#undef  TTY
+#undef  SET_TTY
+#undef  GET_TTY
+
+/* Assume POSIX termio if we have the header and function */
+/* #if HAVE_TERMIOS_H && HAVE_TCGETATTR */
+#if 1 && 1
+
+#undef  TERMIOS
+#define TERMIOS 1
+
+#include <termios.h>
+#define TTY struct termios
+
+#else /* !HAVE_TERMIOS_H */
+
+/* #if HAVE_TERMIO_H */
+#if 1
+
+#undef  TERMIOS
+#define TERMIOS 1
+
+#include <termio.h>
+#define TTY struct termio
+
+#else /* !HAVE_TERMIO_H */
+
+#if (defined(_WIN32) || defined(_WIN64))
+#if 0
+#include <ncursesw/win32_curses.h>
+#define TTY struct winconmode
+#else
+#include <ncursesw/ncurses_mingw.h>
+#define TTY struct termios
+#endif
+#else
+#undef TERMIOS
+#include <sgtty.h>
+#include <sys/ioctl.h>
+#define TTY struct sgttyb
+#endif /* MINGW32 */
+#endif /* HAVE_TERMIO_H */
+
+#endif /* HAVE_TERMIOS_H */
+
+#ifdef TERMIOS
+#define GET_TTY(fd, buf) tcgetattr(fd, buf)
+#define SET_TTY(fd, buf) tcsetattr(fd, TCSADRAIN, buf)
+#elif 0 && (defined(_WIN32) || defined(_WIN64))
+#define GET_TTY(fd, buf) _nc_console_getmode(_nc_console_fd2handle(fd),buf)
+#define SET_TTY(fd, buf) _nc_console_setmode(_nc_console_fd2handle(fd),buf)
+#else
+#define GET_TTY(fd, buf) gtty(fd, buf)
+#define SET_TTY(fd, buf) stty(fd, buf)
+#endif
+
+#ifndef	GCC_NORETURN
+#define	GCC_NORETURN /* nothing */
+#endif
+
+#define NAMESIZE 256
+
+/* The cast works because TERMTYPE is the first data in TERMINAL */
+#define CUR ((TERMTYPE *)(cur_term))->
+
+#define auto_left_margin               CUR Booleans[0]
+#define auto_right_margin              CUR Booleans[1]
+#define no_esc_ctlc                    CUR Booleans[2]
+#define ceol_standout_glitch           CUR Booleans[3]
+#define eat_newline_glitch             CUR Booleans[4]
+#define erase_overstrike               CUR Booleans[5]
+#define generic_type                   CUR Booleans[6]
+#define hard_copy                      CUR Booleans[7]
+#define has_meta_key                   CUR Booleans[8]
+#define has_status_line                CUR Booleans[9]
+#define insert_null_glitch             CUR Booleans[10]
+#define memory_above                   CUR Booleans[11]
+#define memory_below                   CUR Booleans[12]
+#define move_insert_mode               CUR Booleans[13]
+#define move_standout_mode             CUR Booleans[14]
+#define over_strike                    CUR Booleans[15]
+#define status_line_esc_ok             CUR Booleans[16]
+#define dest_tabs_magic_smso           CUR Booleans[17]
+#define tilde_glitch                   CUR Booleans[18]
+#define transparent_underline          CUR Booleans[19]
+#define xon_xoff                       CUR Booleans[20]
+#define needs_xon_xoff                 CUR Booleans[21]
+#define prtr_silent                    CUR Booleans[22]
+#define hard_cursor                    CUR Booleans[23]
+#define non_rev_rmcup                  CUR Booleans[24]
+#define no_pad_char                    CUR Booleans[25]
+#define non_dest_scroll_region         CUR Booleans[26]
+#define can_change                     CUR Booleans[27]
+#define back_color_erase               CUR Booleans[28]
+#define hue_lightness_saturation       CUR Booleans[29]
+#define col_addr_glitch                CUR Booleans[30]
+#define cr_cancels_micro_mode          CUR Booleans[31]
+#define has_print_wheel                CUR Booleans[32]
+#define row_addr_glitch                CUR Booleans[33]
+#define semi_auto_right_margin         CUR Booleans[34]
+#define cpi_changes_res                CUR Booleans[35]
+#define lpi_changes_res                CUR Booleans[36]
+#define columns                        CUR Numbers[0]
+#define init_tabs                      CUR Numbers[1]
+#define lines                          CUR Numbers[2]
+#define lines_of_memory                CUR Numbers[3]
+#define magic_cookie_glitch            CUR Numbers[4]
+#define padding_baud_rate              CUR Numbers[5]
+#define virtual_terminal               CUR Numbers[6]
+#define width_status_line              CUR Numbers[7]
+#define num_labels                     CUR Numbers[8]
+#define label_height                   CUR Numbers[9]
+#define label_width                    CUR Numbers[10]
+#define max_attributes                 CUR Numbers[11]
+#define maximum_windows                CUR Numbers[12]
+#define max_colors                     CUR Numbers[13]
+#define max_pairs                      CUR Numbers[14]
+#define no_color_video                 CUR Numbers[15]
+#define buffer_capacity                CUR Numbers[16]
+#define dot_vert_spacing               CUR Numbers[17]
+#define dot_horz_spacing               CUR Numbers[18]
+#define max_micro_address              CUR Numbers[19]
+#define max_micro_jump                 CUR Numbers[20]
+#define micro_col_size                 CUR Numbers[21]
+#define micro_line_size                CUR Numbers[22]
+#define number_of_pins                 CUR Numbers[23]
+#define output_res_char                CUR Numbers[24]
+#define output_res_line                CUR Numbers[25]
+#define output_res_horz_inch           CUR Numbers[26]
+#define output_res_vert_inch           CUR Numbers[27]
+#define print_rate                     CUR Numbers[28]
+#define wide_char_size                 CUR Numbers[29]
+#define buttons                        CUR Numbers[30]
+#define bit_image_entwining            CUR Numbers[31]
+#define bit_image_type                 CUR Numbers[32]
+#define back_tab                       CUR Strings[0]
+#define bell                           CUR Strings[1]
+#define carriage_return                CUR Strings[2]
+#define change_scroll_region           CUR Strings[3]
+#define clear_all_tabs                 CUR Strings[4]
+#define clear_screen                   CUR Strings[5]
+#define clr_eol                        CUR Strings[6]
+#define clr_eos                        CUR Strings[7]
+#define column_address                 CUR Strings[8]
+#define command_character              CUR Strings[9]
+#define cursor_address                 CUR Strings[10]
+#define cursor_down                    CUR Strings[11]
+#define cursor_home                    CUR Strings[12]
+#define cursor_invisible               CUR Strings[13]
+#define cursor_left                    CUR Strings[14]
+#define cursor_mem_address             CUR Strings[15]
+#define cursor_normal                  CUR Strings[16]
+#define cursor_right                   CUR Strings[17]
+#define cursor_to_ll                   CUR Strings[18]
+#define cursor_up                      CUR Strings[19]
+#define cursor_visible                 CUR Strings[20]
+#define delete_character               CUR Strings[21]
+#define delete_line                    CUR Strings[22]
+#define dis_status_line                CUR Strings[23]
+#define down_half_line                 CUR Strings[24]
+#define enter_alt_charset_mode         CUR Strings[25]
+#define enter_blink_mode               CUR Strings[26]
+#define enter_bold_mode                CUR Strings[27]
+#define enter_ca_mode                  CUR Strings[28]
+#define enter_delete_mode              CUR Strings[29]
+#define enter_dim_mode                 CUR Strings[30]
+#define enter_insert_mode              CUR Strings[31]
+#define enter_secure_mode              CUR Strings[32]
+#define enter_protected_mode           CUR Strings[33]
+#define enter_reverse_mode             CUR Strings[34]
+#define enter_standout_mode            CUR Strings[35]
+#define enter_underline_mode           CUR Strings[36]
+#define erase_chars                    CUR Strings[37]
+#define exit_alt_charset_mode          CUR Strings[38]
+#define exit_attribute_mode            CUR Strings[39]
+#define exit_ca_mode                   CUR Strings[40]
+#define exit_delete_mode               CUR Strings[41]
+#define exit_insert_mode               CUR Strings[42]
+#define exit_standout_mode             CUR Strings[43]
+#define exit_underline_mode            CUR Strings[44]
+#define flash_screen                   CUR Strings[45]
+#define form_feed                      CUR Strings[46]
+#define from_status_line               CUR Strings[47]
+#define init_1string                   CUR Strings[48]
+#define init_2string                   CUR Strings[49]
+#define init_3string                   CUR Strings[50]
+#define init_file                      CUR Strings[51]
+#define insert_character               CUR Strings[52]
+#define insert_line                    CUR Strings[53]
+#define insert_padding                 CUR Strings[54]
+#define key_backspace                  CUR Strings[55]
+#define key_catab                      CUR Strings[56]
+#define key_clear                      CUR Strings[57]
+#define key_ctab                       CUR Strings[58]
+#define key_dc                         CUR Strings[59]
+#define key_dl                         CUR Strings[60]
+#define key_down                       CUR Strings[61]
+#define key_eic                        CUR Strings[62]
+#define key_eol                        CUR Strings[63]
+#define key_eos                        CUR Strings[64]
+#define key_f0                         CUR Strings[65]
+#define key_f1                         CUR Strings[66]
+#define key_f10                        CUR Strings[67]
+#define key_f2                         CUR Strings[68]
+#define key_f3                         CUR Strings[69]
+#define key_f4                         CUR Strings[70]
+#define key_f5                         CUR Strings[71]
+#define key_f6                         CUR Strings[72]
+#define key_f7                         CUR Strings[73]
+#define key_f8                         CUR Strings[74]
+#define key_f9                         CUR Strings[75]
+#define key_home                       CUR Strings[76]
+#define key_ic                         CUR Strings[77]
+#define key_il                         CUR Strings[78]
+#define key_left                       CUR Strings[79]
+#define key_ll                         CUR Strings[80]
+#define key_npage                      CUR Strings[81]
+#define key_ppage                      CUR Strings[82]
+#define key_right                      CUR Strings[83]
+#define key_sf                         CUR Strings[84]
+#define key_sr                         CUR Strings[85]
+#define key_stab                       CUR Strings[86]
+#define key_up                         CUR Strings[87]
+#define keypad_local                   CUR Strings[88]
+#define keypad_xmit                    CUR Strings[89]
+#define lab_f0                         CUR Strings[90]
+#define lab_f1                         CUR Strings[91]
+#define lab_f10                        CUR Strings[92]
+#define lab_f2                         CUR Strings[93]
+#define lab_f3                         CUR Strings[94]
+#define lab_f4                         CUR Strings[95]
+#define lab_f5                         CUR Strings[96]
+#define lab_f6                         CUR Strings[97]
+#define lab_f7                         CUR Strings[98]
+#define lab_f8                         CUR Strings[99]
+#define lab_f9                         CUR Strings[100]
+#define meta_off                       CUR Strings[101]
+#define meta_on                        CUR Strings[102]
+#define newline                        CUR Strings[103]
+#define pad_char                       CUR Strings[104]
+#define parm_dch                       CUR Strings[105]
+#define parm_delete_line               CUR Strings[106]
+#define parm_down_cursor               CUR Strings[107]
+#define parm_ich                       CUR Strings[108]
+#define parm_index                     CUR Strings[109]
+#define parm_insert_line               CUR Strings[110]
+#define parm_left_cursor               CUR Strings[111]
+#define parm_right_cursor              CUR Strings[112]
+#define parm_rindex                    CUR Strings[113]
+#define parm_up_cursor                 CUR Strings[114]
+#define pkey_key                       CUR Strings[115]
+#define pkey_local                     CUR Strings[116]
+#define pkey_xmit                      CUR Strings[117]
+#define print_screen                   CUR Strings[118]
+#define prtr_off                       CUR Strings[119]
+#define prtr_on                        CUR Strings[120]
+#define repeat_char                    CUR Strings[121]
+#define reset_1string                  CUR Strings[122]
+#define reset_2string                  CUR Strings[123]
+#define reset_3string                  CUR Strings[124]
+#define reset_file                     CUR Strings[125]
+#define restore_cursor                 CUR Strings[126]
+#define row_address                    CUR Strings[127]
+#define save_cursor                    CUR Strings[128]
+#define scroll_forward                 CUR Strings[129]
+#define scroll_reverse                 CUR Strings[130]
+#define set_attributes                 CUR Strings[131]
+#define set_tab                        CUR Strings[132]
+#define set_window                     CUR Strings[133]
+#define tab                            CUR Strings[134]
+#define to_status_line                 CUR Strings[135]
+#define underline_char                 CUR Strings[136]
+#define up_half_line                   CUR Strings[137]
+#define init_prog                      CUR Strings[138]
+#define key_a1                         CUR Strings[139]
+#define key_a3                         CUR Strings[140]
+#define key_b2                         CUR Strings[141]
+#define key_c1                         CUR Strings[142]
+#define key_c3                         CUR Strings[143]
+#define prtr_non                       CUR Strings[144]
+#define char_padding                   CUR Strings[145]
+#define acs_chars                      CUR Strings[146]
+#define plab_norm                      CUR Strings[147]
+#define key_btab                       CUR Strings[148]
+#define enter_xon_mode                 CUR Strings[149]
+#define exit_xon_mode                  CUR Strings[150]
+#define enter_am_mode                  CUR Strings[151]
+#define exit_am_mode                   CUR Strings[152]
+#define xon_character                  CUR Strings[153]
+#define xoff_character                 CUR Strings[154]
+#define ena_acs                        CUR Strings[155]
+#define label_on                       CUR Strings[156]
+#define label_off                      CUR Strings[157]
+#define key_beg                        CUR Strings[158]
+#define key_cancel                     CUR Strings[159]
+#define key_close                      CUR Strings[160]
+#define key_command                    CUR Strings[161]
+#define key_copy                       CUR Strings[162]
+#define key_create                     CUR Strings[163]
+#define key_end                        CUR Strings[164]
+#define key_enter                      CUR Strings[165]
+#define key_exit                       CUR Strings[166]
+#define key_find                       CUR Strings[167]
+#define key_help                       CUR Strings[168]
+#define key_mark                       CUR Strings[169]
+#define key_message                    CUR Strings[170]
+#define key_move                       CUR Strings[171]
+#define key_next                       CUR Strings[172]
+#define key_open                       CUR Strings[173]
+#define key_options                    CUR Strings[174]
+#define key_previous                   CUR Strings[175]
+#define key_print                      CUR Strings[176]
+#define key_redo                       CUR Strings[177]
+#define key_reference                  CUR Strings[178]
+#define key_refresh                    CUR Strings[179]
+#define key_replace                    CUR Strings[180]
+#define key_restart                    CUR Strings[181]
+#define key_resume                     CUR Strings[182]
+#define key_save                       CUR Strings[183]
+#define key_suspend                    CUR Strings[184]
+#define key_undo                       CUR Strings[185]
+#define key_sbeg                       CUR Strings[186]
+#define key_scancel                    CUR Strings[187]
+#define key_scommand                   CUR Strings[188]
+#define key_scopy                      CUR Strings[189]
+#define key_screate                    CUR Strings[190]
+#define key_sdc                        CUR Strings[191]
+#define key_sdl                        CUR Strings[192]
+#define key_select                     CUR Strings[193]
+#define key_send                       CUR Strings[194]
+#define key_seol                       CUR Strings[195]
+#define key_sexit                      CUR Strings[196]
+#define key_sfind                      CUR Strings[197]
+#define key_shelp                      CUR Strings[198]
+#define key_shome                      CUR Strings[199]
+#define key_sic                        CUR Strings[200]
+#define key_sleft                      CUR Strings[201]
+#define key_smessage                   CUR Strings[202]
+#define key_smove                      CUR Strings[203]
+#define key_snext                      CUR Strings[204]
+#define key_soptions                   CUR Strings[205]
+#define key_sprevious                  CUR Strings[206]
+#define key_sprint                     CUR Strings[207]
+#define key_sredo                      CUR Strings[208]
+#define key_sreplace                   CUR Strings[209]
+#define key_sright                     CUR Strings[210]
+#define key_srsume                     CUR Strings[211]
+#define key_ssave                      CUR Strings[212]
+#define key_ssuspend                   CUR Strings[213]
+#define key_sundo                      CUR Strings[214]
+#define req_for_input                  CUR Strings[215]
+#define key_f11                        CUR Strings[216]
+#define key_f12                        CUR Strings[217]
+#define key_f13                        CUR Strings[218]
+#define key_f14                        CUR Strings[219]
+#define key_f15                        CUR Strings[220]
+#define key_f16                        CUR Strings[221]
+#define key_f17                        CUR Strings[222]
+#define key_f18                        CUR Strings[223]
+#define key_f19                        CUR Strings[224]
+#define key_f20                        CUR Strings[225]
+#define key_f21                        CUR Strings[226]
+#define key_f22                        CUR Strings[227]
+#define key_f23                        CUR Strings[228]
+#define key_f24                        CUR Strings[229]
+#define key_f25                        CUR Strings[230]
+#define key_f26                        CUR Strings[231]
+#define key_f27                        CUR Strings[232]
+#define key_f28                        CUR Strings[233]
+#define key_f29                        CUR Strings[234]
+#define key_f30                        CUR Strings[235]
+#define key_f31                        CUR Strings[236]
+#define key_f32                        CUR Strings[237]
+#define key_f33                        CUR Strings[238]
+#define key_f34                        CUR Strings[239]
+#define key_f35                        CUR Strings[240]
+#define key_f36                        CUR Strings[241]
+#define key_f37                        CUR Strings[242]
+#define key_f38                        CUR Strings[243]
+#define key_f39                        CUR Strings[244]
+#define key_f40                        CUR Strings[245]
+#define key_f41                        CUR Strings[246]
+#define key_f42                        CUR Strings[247]
+#define key_f43                        CUR Strings[248]
+#define key_f44                        CUR Strings[249]
+#define key_f45                        CUR Strings[250]
+#define key_f46                        CUR Strings[251]
+#define key_f47                        CUR Strings[252]
+#define key_f48                        CUR Strings[253]
+#define key_f49                        CUR Strings[254]
+#define key_f50                        CUR Strings[255]
+#define key_f51                        CUR Strings[256]
+#define key_f52                        CUR Strings[257]
+#define key_f53                        CUR Strings[258]
+#define key_f54                        CUR Strings[259]
+#define key_f55                        CUR Strings[260]
+#define key_f56                        CUR Strings[261]
+#define key_f57                        CUR Strings[262]
+#define key_f58                        CUR Strings[263]
+#define key_f59                        CUR Strings[264]
+#define key_f60                        CUR Strings[265]
+#define key_f61                        CUR Strings[266]
+#define key_f62                        CUR Strings[267]
+#define key_f63                        CUR Strings[268]
+#define clr_bol                        CUR Strings[269]
+#define clear_margins                  CUR Strings[270]
+#define set_left_margin                CUR Strings[271]
+#define set_right_margin               CUR Strings[272]
+#define label_format                   CUR Strings[273]
+#define set_clock                      CUR Strings[274]
+#define display_clock                  CUR Strings[275]
+#define remove_clock                   CUR Strings[276]
+#define create_window                  CUR Strings[277]
+#define goto_window                    CUR Strings[278]
+#define hangup                         CUR Strings[279]
+#define dial_phone                     CUR Strings[280]
+#define quick_dial                     CUR Strings[281]
+#define tone                           CUR Strings[282]
+#define pulse                          CUR Strings[283]
+#define flash_hook                     CUR Strings[284]
+#define fixed_pause                    CUR Strings[285]
+#define wait_tone                      CUR Strings[286]
+#define user0                          CUR Strings[287]
+#define user1                          CUR Strings[288]
+#define user2                          CUR Strings[289]
+#define user3                          CUR Strings[290]
+#define user4                          CUR Strings[291]
+#define user5                          CUR Strings[292]
+#define user6                          CUR Strings[293]
+#define user7                          CUR Strings[294]
+#define user8                          CUR Strings[295]
+#define user9                          CUR Strings[296]
+#define orig_pair                      CUR Strings[297]
+#define orig_colors                    CUR Strings[298]
+#define initialize_color               CUR Strings[299]
+#define initialize_pair                CUR Strings[300]
+#define set_color_pair                 CUR Strings[301]
+#define set_foreground                 CUR Strings[302]
+#define set_background                 CUR Strings[303]
+#define change_char_pitch              CUR Strings[304]
+#define change_line_pitch              CUR Strings[305]
+#define change_res_horz                CUR Strings[306]
+#define change_res_vert                CUR Strings[307]
+#define define_char                    CUR Strings[308]
+#define enter_doublewide_mode          CUR Strings[309]
+#define enter_draft_quality            CUR Strings[310]
+#define enter_italics_mode             CUR Strings[311]
+#define enter_leftward_mode            CUR Strings[312]
+#define enter_micro_mode               CUR Strings[313]
+#define enter_near_letter_quality      CUR Strings[314]
+#define enter_normal_quality           CUR Strings[315]
+#define enter_shadow_mode              CUR Strings[316]
+#define enter_subscript_mode           CUR Strings[317]
+#define enter_superscript_mode         CUR Strings[318]
+#define enter_upward_mode              CUR Strings[319]
+#define exit_doublewide_mode           CUR Strings[320]
+#define exit_italics_mode              CUR Strings[321]
+#define exit_leftward_mode             CUR Strings[322]
+#define exit_micro_mode                CUR Strings[323]
+#define exit_shadow_mode               CUR Strings[324]
+#define exit_subscript_mode            CUR Strings[325]
+#define exit_superscript_mode          CUR Strings[326]
+#define exit_upward_mode               CUR Strings[327]
+#define micro_column_address           CUR Strings[328]
+#define micro_down                     CUR Strings[329]
+#define micro_left                     CUR Strings[330]
+#define micro_right                    CUR Strings[331]
+#define micro_row_address              CUR Strings[332]
+#define micro_up                       CUR Strings[333]
+#define order_of_pins                  CUR Strings[334]
+#define parm_down_micro                CUR Strings[335]
+#define parm_left_micro                CUR Strings[336]
+#define parm_right_micro               CUR Strings[337]
+#define parm_up_micro                  CUR Strings[338]
+#define select_char_set                CUR Strings[339]
+#define set_bottom_margin              CUR Strings[340]
+#define set_bottom_margin_parm         CUR Strings[341]
+#define set_left_margin_parm           CUR Strings[342]
+#define set_right_margin_parm          CUR Strings[343]
+#define set_top_margin                 CUR Strings[344]
+#define set_top_margin_parm            CUR Strings[345]
+#define start_bit_image                CUR Strings[346]
+#define start_char_set_def             CUR Strings[347]
+#define stop_bit_image                 CUR Strings[348]
+#define stop_char_set_def              CUR Strings[349]
+#define subscript_characters           CUR Strings[350]
+#define superscript_characters         CUR Strings[351]
+#define these_cause_cr                 CUR Strings[352]
+#define zero_motion                    CUR Strings[353]
+#define char_set_names                 CUR Strings[354]
+#define key_mouse                      CUR Strings[355]
+#define mouse_info                     CUR Strings[356]
+#define req_mouse_pos                  CUR Strings[357]
+#define get_mouse                      CUR Strings[358]
+#define set_a_foreground               CUR Strings[359]
+#define set_a_background               CUR Strings[360]
+#define pkey_plab                      CUR Strings[361]
+#define device_type                    CUR Strings[362]
+#define code_set_init                  CUR Strings[363]
+#define set0_des_seq                   CUR Strings[364]
+#define set1_des_seq                   CUR Strings[365]
+#define set2_des_seq                   CUR Strings[366]
+#define set3_des_seq                   CUR Strings[367]
+#define set_lr_margin                  CUR Strings[368]
+#define set_tb_margin                  CUR Strings[369]
+#define bit_image_repeat               CUR Strings[370]
+#define bit_image_newline              CUR Strings[371]
+#define bit_image_carriage_return      CUR Strings[372]
+#define color_names                    CUR Strings[373]
+#define define_bit_image_region        CUR Strings[374]
+#define end_bit_image_region           CUR Strings[375]
+#define set_color_band                 CUR Strings[376]
+#define set_page_length                CUR Strings[377]
+#define display_pc_char                CUR Strings[378]
+#define enter_pc_charset_mode          CUR Strings[379]
+#define exit_pc_charset_mode           CUR Strings[380]
+#define enter_scancode_mode            CUR Strings[381]
+#define exit_scancode_mode             CUR Strings[382]
+#define pc_term_options                CUR Strings[383]
+#define scancode_escape                CUR Strings[384]
+#define alt_scancode_esc               CUR Strings[385]
+#define enter_horizontal_hl_mode       CUR Strings[386]
+#define enter_left_hl_mode             CUR Strings[387]
+#define enter_low_hl_mode              CUR Strings[388]
+#define enter_right_hl_mode            CUR Strings[389]
+#define enter_top_hl_mode              CUR Strings[390]
+#define enter_vertical_hl_mode         CUR Strings[391]
+#define set_a_attributes               CUR Strings[392]
+#define set_pglen_inch                 CUR Strings[393]
+
+#define BOOLWRITE 37
+#define NUMWRITE  33
+#define STRWRITE  394
+
+/* older synonyms for some capabilities */
+#define beehive_glitch	no_esc_ctlc
+#define teleray_glitch	dest_tabs_magic_smso
+
+/* HPUX-11 uses this name rather than the standard one */
+#ifndef micro_char_size
+#define micro_char_size micro_col_size
+#endif
+
+#ifdef __INTERNAL_CAPS_VISIBLE
+#define termcap_init2                  CUR Strings[394]
+#define termcap_reset                  CUR Strings[395]
+#define magic_cookie_glitch_ul         CUR Numbers[33]
+#define backspaces_with_bs             CUR Booleans[37]
+#define crt_no_scrolling               CUR Booleans[38]
+#define no_correctly_working_cr        CUR Booleans[39]
+#define carriage_return_delay          CUR Numbers[34]
+#define new_line_delay                 CUR Numbers[35]
+#define linefeed_if_not_lf             CUR Strings[396]
+#define backspace_if_not_bs            CUR Strings[397]
+#define gnu_has_meta_key               CUR Booleans[40]
+#define linefeed_is_newline            CUR Booleans[41]
+#define backspace_delay                CUR Numbers[36]
+#define horizontal_tab_delay           CUR Numbers[37]
+#define number_of_function_keys        CUR Numbers[38]
+#define other_non_function_keys        CUR Strings[398]
+#define arrow_key_map                  CUR Strings[399]
+#define has_hardware_tabs              CUR Booleans[42]
+#define return_does_clr_eol            CUR Booleans[43]
+#define acs_ulcorner                   CUR Strings[400]
+#define acs_llcorner                   CUR Strings[401]
+#define acs_urcorner                   CUR Strings[402]
+#define acs_lrcorner                   CUR Strings[403]
+#define acs_ltee                       CUR Strings[404]
+#define acs_rtee                       CUR Strings[405]
+#define acs_btee                       CUR Strings[406]
+#define acs_ttee                       CUR Strings[407]
+#define acs_hline                      CUR Strings[408]
+#define acs_vline                      CUR Strings[409]
+#define acs_plus                       CUR Strings[410]
+#define memory_lock                    CUR Strings[411]
+#define memory_unlock                  CUR Strings[412]
+#define box_chars_1                    CUR Strings[413]
+#endif /* __INTERNAL_CAPS_VISIBLE */
+
+
+/*
+ * Predefined terminfo array sizes
+ */
+#define BOOLCOUNT 44
+#define NUMCOUNT  39
+#define STRCOUNT  414
+
+/* used by code for comparing entries */
+#define acs_chars_index	 146
+
+typedef struct termtype {	/* in-core form of terminfo data */
+    char  *term_names;		/* str_table offset of term names */
+    char  *str_table;		/* pointer to string table */
+    NCURSES_SBOOL  *Booleans;	/* array of boolean values */
+    short *Numbers;		/* array of integer values */
+    char  **Strings;		/* array of string offsets */
+
+#if NCURSES_XNAMES
+    char  *ext_str_table;	/* pointer to extended string table */
+    char  **ext_Names;		/* corresponding names */
+
+    unsigned short num_Booleans;/* count total Booleans */
+    unsigned short num_Numbers;	/* count total Numbers */
+    unsigned short num_Strings;	/* count total Strings */
+
+    unsigned short ext_Booleans;/* count extensions to Booleans */
+    unsigned short ext_Numbers;	/* count extensions to Numbers */
+    unsigned short ext_Strings;	/* count extensions to Strings */
+#endif /* NCURSES_XNAMES */
+
+} TERMTYPE;
+
+/*
+ * The only reason these structures are visible is for read-only use.
+ * Programs which modify the data are not, never were, portable across
+ * curses implementations.
+ *
+ * The first field in TERMINAL is used in macros.
+ * The remaining fields are private.
+ */
+#ifdef NCURSES_INTERNALS
+
+#undef TERMINAL
+#define TERMINAL struct term
+TERMINAL;
+
+typedef struct termtype2 {	/* in-core form of terminfo data */
+    char  *term_names;		/* str_table offset of term names */
+    char  *str_table;		/* pointer to string table */
+    NCURSES_SBOOL  *Booleans;	/* array of boolean values */
+    int   *Numbers;		/* array of integer values */
+    char  **Strings;		/* array of string offsets */
+
+#if NCURSES_XNAMES
+    char  *ext_str_table;	/* pointer to extended string table */
+    char  **ext_Names;		/* corresponding names */
+
+    unsigned short num_Booleans;/* count total Booleans */
+    unsigned short num_Numbers;	/* count total Numbers */
+    unsigned short num_Strings;	/* count total Strings */
+
+    unsigned short ext_Booleans;/* count extensions to Booleans */
+    unsigned short ext_Numbers;	/* count extensions to Numbers */
+    unsigned short ext_Strings;	/* count extensions to Strings */
+#endif /* NCURSES_XNAMES */
+
+} TERMTYPE2;
+#else
+
+typedef struct term {		/* describe an actual terminal */
+    TERMTYPE	type;		/* terminal type description */
+} TERMINAL;
+
+#endif /* NCURSES_INTERNALS */
+
+
+#if 0 && !0
+extern NCURSES_EXPORT_VAR(TERMINAL *) cur_term;
+#elif 0
+NCURSES_WRAPPED_VAR(TERMINAL *, cur_term);
+#define cur_term   NCURSES_PUBLIC_VAR(cur_term())
+#else
+extern NCURSES_EXPORT_VAR(TERMINAL *) cur_term;
+#endif
+
+#if 0 || 0
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, boolnames);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, boolcodes);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, boolfnames);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, numnames);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, numcodes);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, numfnames);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, strnames);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, strcodes);
+NCURSES_WRAPPED_VAR(NCURSES_CONST char * const *, strfnames);
+
+#define boolnames  NCURSES_PUBLIC_VAR(boolnames())
+#define boolcodes  NCURSES_PUBLIC_VAR(boolcodes())
+#define boolfnames NCURSES_PUBLIC_VAR(boolfnames())
+#define numnames   NCURSES_PUBLIC_VAR(numnames())
+#define numcodes   NCURSES_PUBLIC_VAR(numcodes())
+#define numfnames  NCURSES_PUBLIC_VAR(numfnames())
+#define strnames   NCURSES_PUBLIC_VAR(strnames())
+#define strcodes   NCURSES_PUBLIC_VAR(strcodes())
+#define strfnames  NCURSES_PUBLIC_VAR(strfnames())
+
+#else
+
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolnames[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolcodes[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) boolfnames[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numnames[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numcodes[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) numfnames[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strnames[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strcodes[];
+extern NCURSES_EXPORT_VAR(NCURSES_CONST char * const ) strfnames[];
+
+#endif
+
+/*
+ * These entrypoints are used only by the ncurses utilities such as tic.
+ */
+#ifdef NCURSES_INTERNALS
+
+extern NCURSES_EXPORT(int) _nc_set_tty_mode (TTY *buf);
+extern NCURSES_EXPORT(int) _nc_read_entry2 (const char * const, char * const, TERMTYPE2 *const);
+extern NCURSES_EXPORT(int) _nc_read_file_entry (const char *const, TERMTYPE2 *);
+extern NCURSES_EXPORT(int) _nc_read_termtype (TERMTYPE2 *, char *, int);
+extern NCURSES_EXPORT(char *) _nc_first_name (const char *const);
+extern NCURSES_EXPORT(int) _nc_name_match (const char *const, const char *const, const char *const);
+extern NCURSES_EXPORT(char *) _nc_tiparm(int, const char *, ...);
+extern NCURSES_EXPORT(const TERMTYPE *) _nc_fallback (const char *);
+extern NCURSES_EXPORT(int) _nc_read_entry (const char * const, char * const, TERMTYPE *const);
+
+#endif /* NCURSES_INTERNALS */
+
+/*
+ * Normal entry points
+ */
+extern NCURSES_EXPORT(TERMINAL *) set_curterm (TERMINAL *);
+extern NCURSES_EXPORT(int) del_curterm (TERMINAL *);
+
+/* miscellaneous entry points */
+extern NCURSES_EXPORT(int) restartterm (NCURSES_CONST char *, int, int *);
+extern NCURSES_EXPORT(int) setupterm (const char *,int,int *);
+
+/* terminfo entry points, also declared in curses.h */
+#if !defined(__NCURSES_H)
+extern NCURSES_EXPORT(char *) tigetstr (const char *);
+extern NCURSES_EXPORT_VAR(char) ttytype[];
+extern NCURSES_EXPORT(int) putp (const char *);
+extern NCURSES_EXPORT(int) tigetflag (const char *);
+extern NCURSES_EXPORT(int) tigetnum (const char *);
+
+#if 1 /* NCURSES_TPARM_VARARGS */
+extern NCURSES_EXPORT(char *) tparm (const char *, ...);	/* special */
+#else
+extern NCURSES_EXPORT(char *) tparm (const char *, long,long,long,long,long,long,long,long,long);	/* special */
+#endif
+
+extern NCURSES_EXPORT(char *) tiparm (const char *, ...);		/* special */
+extern NCURSES_EXPORT(char *) tiparm_s (int, int, const char *, ...);	/* special */
+extern NCURSES_EXPORT(int) tiscan_s (int *, int *, const char *);	/* special */
+
+#endif /* __NCURSES_H */
+
+/* termcap database emulation (XPG4 uses const only for 2nd param of tgetent) */
+#if !defined(NCURSES_TERMCAP_H_incl)
+extern NCURSES_EXPORT(char *) tgetstr (const char *, char **);
+extern NCURSES_EXPORT(char *) tgoto (const char *, int, int);
+extern NCURSES_EXPORT(int) tgetent (char *, const char *);
+extern NCURSES_EXPORT(int) tgetflag (const char *);
+extern NCURSES_EXPORT(int) tgetnum (const char *);
+extern NCURSES_EXPORT(int) tputs (const char *, int, int (*)(int));
+#endif /* NCURSES_TERMCAP_H_incl */
+
+/*
+ * Include curses.h before term.h to enable these extensions.
+ */
+#if defined(NCURSES_SP_FUNCS) && (NCURSES_SP_FUNCS != 0)
+
+extern NCURSES_EXPORT(char *)  NCURSES_SP_NAME(tigetstr) (SCREEN*, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(putp) (SCREEN*, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tigetflag) (SCREEN*, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tigetnum) (SCREEN*, const char *);
+
+#if 1 /* NCURSES_TPARM_VARARGS */
+extern NCURSES_EXPORT(char *)  NCURSES_SP_NAME(tparm) (SCREEN*, const char *, ...);	/* special */
+#else
+extern NCURSES_EXPORT(char *)  NCURSES_SP_NAME(tparm) (SCREEN*, const char *, long,long,long,long,long,long,long,long,long);	/* special */
+#endif
+
+/* termcap database emulation (XPG4 uses const only for 2nd param of tgetent) */
+extern NCURSES_EXPORT(char *)  NCURSES_SP_NAME(tgetstr) (SCREEN*, const char *, char **);
+extern NCURSES_EXPORT(char *)  NCURSES_SP_NAME(tgoto) (SCREEN*, const char *, int, int);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tgetent) (SCREEN*, char *, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tgetflag) (SCREEN*, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tgetnum) (SCREEN*, const char *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(tputs) (SCREEN*, const char *, int, NCURSES_SP_OUTC);
+
+extern NCURSES_EXPORT(TERMINAL *) NCURSES_SP_NAME(set_curterm) (SCREEN*, TERMINAL *);
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(del_curterm) (SCREEN*, TERMINAL *);
+
+extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(restartterm) (SCREEN*, NCURSES_CONST char *, int, int *);
+#endif /* NCURSES_SP_FUNCS */
+
+/*
+ * Debugging features.
+ */
+extern GCC_NORETURN NCURSES_EXPORT(void)    exit_terminfo(int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NCURSES_TERM_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/term_entry.h

@@ -0,0 +1,220 @@
+/****************************************************************************
+ * Copyright 2018-2022,2023 Thomas E. Dickey                                *
+ * Copyright 1998-2015,2017 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
+ *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
+ *     and: Thomas E. Dickey                        1998-on                 *
+ ****************************************************************************/
+
+/* $Id: term_entry.h,v 1.64 2023/04/22 13:37:14 tom Exp $ */
+
+/*
+ *	term_entry.h -- interface to entry-manipulation code
+ */
+
+#ifndef NCURSES_TERM_ENTRY_H_incl
+#define NCURSES_TERM_ENTRY_H_incl 1
+/* *INDENT-OFF* */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <ncursesw/curses.h>
+#include <ncursesw/term.h>
+
+/*
+ * These macros may be used by programs that know about TERMTYPE:
+ */
+#if NCURSES_XNAMES
+#define NUM_BOOLEANS(tp) (tp)->num_Booleans
+#define NUM_NUMBERS(tp)  (tp)->num_Numbers
+#define NUM_STRINGS(tp)  (tp)->num_Strings
+#define EXT_NAMES(tp,i,limit,index,table) (i >= limit) ? tp->ext_Names[index] : table[i]
+#else
+#define NUM_BOOLEANS(tp) BOOLCOUNT
+#define NUM_NUMBERS(tp)  NUMCOUNT
+#define NUM_STRINGS(tp)  STRCOUNT
+#define EXT_NAMES(tp,i,limit,index,table) table[i]
+#endif
+
+#define NUM_EXT_NAMES(tp) (unsigned) ((tp)->ext_Booleans + (tp)->ext_Numbers + (tp)->ext_Strings)
+
+#define for_each_boolean(n,tp) for(n = 0; n < NUM_BOOLEANS(tp); n++)
+#define for_each_number(n,tp)  for(n = 0; n < NUM_NUMBERS(tp);  n++)
+#define for_each_string(n,tp)  for(n = 0; n < NUM_STRINGS(tp);  n++)
+
+#if NCURSES_XNAMES
+#define for_each_ext_boolean(n,tp) for(n = BOOLCOUNT; (int) n < (int) NUM_BOOLEANS(tp); n++)
+#define for_each_ext_number(n,tp)  for(n = NUMCOUNT; (int) n < (int) NUM_NUMBERS(tp);  n++)
+#define for_each_ext_string(n,tp)  for(n = STRCOUNT; (int) n < (int) NUM_STRINGS(tp);  n++)
+#endif
+
+#define ExtBoolname(tp,i,names) EXT_NAMES(tp, i, BOOLCOUNT, (i - (tp->num_Booleans - tp->ext_Booleans)), names)
+#define ExtNumname(tp,i,names)  EXT_NAMES(tp, i, NUMCOUNT, (i - (tp->num_Numbers - tp->ext_Numbers)) + tp->ext_Booleans, names)
+#define ExtStrname(tp,i,names)  EXT_NAMES(tp, i, STRCOUNT, (i - (tp->num_Strings - tp->ext_Strings)) + (tp->ext_Numbers + tp->ext_Booleans), names)
+
+/*
+ * The remaining type-definitions and macros are used only internally by the
+ * ncurses utilities.
+ */
+#ifdef NCURSES_INTERNALS
+
+/*
+ * see db_iterator.c - this enumeration lists the places searched for a
+ * terminal description and defines the order in which they are searched.
+ */
+typedef enum {
+	dbdTIC = 0,		/* special, used by tic when writing entry */
+#if NCURSES_USE_DATABASE
+	dbdEnvOnce,		/* the $TERMINFO environment variable */
+	dbdHome,		/* $HOME/.terminfo */
+	dbdEnvList,		/* the $TERMINFO_DIRS environment variable */
+	dbdCfgList,		/* the compiled-in TERMINFO_DIRS value */
+	dbdCfgOnce,		/* the compiled-in TERMINFO value */
+#endif
+#if NCURSES_USE_TERMCAP
+	dbdEnvOnce2,		/* the $TERMCAP environment variable */
+	dbdEnvList2,		/* the $TERMPATH environment variable */
+	dbdCfgList2,		/* the compiled-in TERMPATH */
+#endif
+	dbdLAST
+} DBDIRS;
+
+#define MAX_USES	32
+#define MAX_CROSSLINKS	16
+
+typedef struct entry ENTRY;
+
+typedef struct {
+	char *name;
+	ENTRY *link;
+	long line;
+} ENTRY_USES;
+
+struct entry {
+	TERMTYPE2 tterm;
+	unsigned nuses;
+	ENTRY_USES uses[MAX_USES];
+	int ncrosslinks;
+	ENTRY *crosslinks[MAX_CROSSLINKS];
+	long cstart;
+	long cend;
+	long startline;
+	ENTRY *next;
+	ENTRY *last;
+};
+
+extern NCURSES_EXPORT_VAR(ENTRY *) _nc_head;
+extern NCURSES_EXPORT_VAR(ENTRY *) _nc_tail;
+#define for_entry_list(qp)	for (qp = _nc_head; qp; qp = qp->next)
+#define for_entry_list2(qp,q0)	for (qp = q0; qp; qp = qp->next)
+
+#define MAX_LINE	132
+
+#define NULLHOOK        (bool(*)(ENTRY *))0
+
+/*
+ * Note that WANTED and PRESENT are not simple inverses!  If a capability
+ * has been explicitly cancelled, it is not considered WANTED.
+ */
+#define WANTED(s)	((s) == ABSENT_STRING)
+#define PRESENT(s)	(((s) != ABSENT_STRING) && ((s) != CANCELLED_STRING))
+
+#define ANDMISSING(p,q) \
+		{ \
+		if (PRESENT(p) && !PRESENT(q)) \
+			_nc_warning(#p " but no " #q); \
+		}
+
+#define PAIRED(p,q) \
+		{ \
+		if (PRESENT(q) && !PRESENT(p)) \
+			_nc_warning(#q " but no " #p); \
+		if (PRESENT(p) && !PRESENT(q)) \
+			_nc_warning(#p " but no " #q); \
+		}
+
+/*
+ * These entrypoints are used only by the ncurses utilities such as tic.
+ */
+
+/* alloc_entry.c: elementary allocation code */
+extern NCURSES_EXPORT(ENTRY *) _nc_copy_entry (ENTRY *oldp);
+extern NCURSES_EXPORT(char *) _nc_save_str (const char *const);
+extern NCURSES_EXPORT(void) _nc_init_entry (ENTRY *const);
+extern NCURSES_EXPORT(void) _nc_merge_entry (ENTRY *const, ENTRY *const);
+extern NCURSES_EXPORT(void) _nc_wrap_entry (ENTRY *const, bool);
+
+/* alloc_ttype.c: elementary allocation code */
+extern NCURSES_EXPORT(void) _nc_align_termtype (TERMTYPE2 *, TERMTYPE2 *);
+
+/* free_ttype.c: elementary allocation code */
+extern NCURSES_EXPORT(void) _nc_free_termtype (TERMTYPE *);
+extern NCURSES_EXPORT(void) _nc_free_termtype1 (TERMTYPE *);
+extern NCURSES_EXPORT(void) _nc_free_termtype2 (TERMTYPE2 *);
+
+/* lib_termcap.c: trim sgr0 string for termcap users */
+extern NCURSES_EXPORT(char *) _nc_trim_sgr0 (TERMTYPE2 *);
+
+/* parse_entry.c: entry-parsing code */
+#if NCURSES_XNAMES
+extern NCURSES_EXPORT_VAR(bool) _nc_user_definable;
+extern NCURSES_EXPORT_VAR(bool) _nc_disable_period;
+#endif
+extern NCURSES_EXPORT(int) _nc_parse_entry (ENTRY *, int, bool);
+extern NCURSES_EXPORT(int) _nc_capcmp (const char *, const char *);
+
+/* write_entry.c: writing an entry to the file system */
+extern NCURSES_EXPORT(void) _nc_set_writedir (const char *);
+extern NCURSES_EXPORT(void) _nc_write_entry (TERMTYPE2 *const);
+extern NCURSES_EXPORT(int) _nc_write_object (TERMTYPE2 *, char *, unsigned *, unsigned);
+
+/* comp_parse.c: entry list handling */
+extern NCURSES_EXPORT(void) _nc_read_entry_source (FILE*, char*, int, bool, bool (*)(ENTRY*));
+extern NCURSES_EXPORT(bool) _nc_entry_match (char *, char *);
+extern NCURSES_EXPORT(int) _nc_resolve_uses (bool); /* obs 20040705 */
+extern NCURSES_EXPORT(int) _nc_resolve_uses2 (bool, bool);
+extern NCURSES_EXPORT(void) _nc_free_entries (ENTRY *);
+extern NCURSES_IMPEXP void (NCURSES_API *_nc_check_termtype)(TERMTYPE *); /* obs 20040705 */
+extern NCURSES_IMPEXP void (NCURSES_API *_nc_check_termtype2)(TERMTYPE2 *, bool);
+
+/* trace_xnames.c */
+extern NCURSES_EXPORT(void) _nc_trace_xnames (TERMTYPE *);
+
+#endif /* NCURSES_INTERNALS */
+
+#ifdef __cplusplus
+}
+#endif
+
+/* *INDENT-ON* */
+
+#endif /* NCURSES_TERM_ENTRY_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/termcap.h

@@ -0,0 +1,73 @@
+/****************************************************************************
+ * Copyright 2018-2020,2021 Thomas E. Dickey                                *
+ * Copyright 1998-2000,2001 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
+ *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
+ ****************************************************************************/
+
+/* $Id: termcap.h.in,v 1.20 2021/06/17 21:26:02 tom Exp $ */
+
+#ifndef NCURSES_TERMCAP_H_incl
+#define NCURSES_TERMCAP_H_incl	1
+
+#undef  NCURSES_VERSION
+#define NCURSES_VERSION "6.5"
+
+#include <ncursesw/ncurses_dll.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+#include <sys/types.h>
+
+#undef  NCURSES_OSPEED
+#define NCURSES_OSPEED short
+
+extern NCURSES_EXPORT_VAR(char) PC;
+extern NCURSES_EXPORT_VAR(char *) UP;
+extern NCURSES_EXPORT_VAR(char *) BC;
+extern NCURSES_EXPORT_VAR(NCURSES_OSPEED) ospeed;
+
+#if !defined(NCURSES_TERM_H_incl)
+extern NCURSES_EXPORT(char *) tgetstr (const char *, char **);
+extern NCURSES_EXPORT(char *) tgoto (const char *, int, int);
+extern NCURSES_EXPORT(int) tgetent (char *, const char *);
+extern NCURSES_EXPORT(int) tgetflag (const char *);
+extern NCURSES_EXPORT(int) tgetnum (const char *);
+extern NCURSES_EXPORT(int) tputs (const char *, int, int (*)(int));
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NCURSES_TERMCAP_H_incl */

miniconda3/envs/active_proaction/include/ncursesw/unctrl.h

@@ -0,0 +1,68 @@
+/****************************************************************************
+ * Copyright 2020 Thomas E. Dickey                                          *
+ * Copyright 1998-2001,2009 Free Software Foundation, Inc.                  *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
+ *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
+ ****************************************************************************/
+
+/*
+ * unctrl.h
+ *
+ * Display a printable version of a control character.
+ * Control characters are displayed in caret notation (^x), DELETE is displayed
+ * as ^?. Printable characters are displayed as is.
+ */
+
+/* $Id: unctrl.h.in,v 1.12 2020/02/02 23:34:34 tom Exp $ */
+
+#ifndef NCURSES_UNCTRL_H_incl
+#define NCURSES_UNCTRL_H_incl	1
+
+#undef  NCURSES_VERSION
+#define NCURSES_VERSION "6.5"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <ncursesw/curses.h>
+
+#undef unctrl
+NCURSES_EXPORT(NCURSES_CONST char *) unctrl (chtype);
+
+#if 1
+NCURSES_EXPORT(NCURSES_CONST char *) NCURSES_SP_NAME(unctrl) (SCREEN*, chtype);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NCURSES_UNCTRL_H_incl */

miniconda3/envs/active_proaction/include/openssl/aes.h

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2002-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_AES_H
+#define OPENSSL_AES_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_AES_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define AES_BLOCK_SIZE 16
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#define AES_ENCRYPT 1
+#define AES_DECRYPT 0
+
+#define AES_MAXNR 14
+
+/* This should be a hidden type, but EVP requires that the size be known */
+struct aes_key_st {
+#ifdef AES_LONG
+    unsigned long rd_key[4 * (AES_MAXNR + 1)];
+#else
+    unsigned int rd_key[4 * (AES_MAXNR + 1)];
+#endif
+    int rounds;
+};
+typedef struct aes_key_st AES_KEY;
+
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *AES_options(void);
+OSSL_DEPRECATEDIN_3_0
+int AES_set_encrypt_key(const unsigned char *userKey, const int bits,
+    AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+int AES_set_decrypt_key(const unsigned char *userKey, const int bits,
+    AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void AES_encrypt(const unsigned char *in, unsigned char *out,
+    const AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void AES_decrypt(const unsigned char *in, unsigned char *out,
+    const AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void AES_ecb_encrypt(const unsigned char *in, unsigned char *out,
+    const AES_KEY *key, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
+    size_t length, const AES_KEY *key,
+    unsigned char *ivec, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cfb128_encrypt(const unsigned char *in, unsigned char *out,
+    size_t length, const AES_KEY *key,
+    unsigned char *ivec, int *num, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cfb1_encrypt(const unsigned char *in, unsigned char *out,
+    size_t length, const AES_KEY *key,
+    unsigned char *ivec, int *num, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cfb8_encrypt(const unsigned char *in, unsigned char *out,
+    size_t length, const AES_KEY *key,
+    unsigned char *ivec, int *num, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_ofb128_encrypt(const unsigned char *in, unsigned char *out,
+    size_t length, const AES_KEY *key,
+    unsigned char *ivec, int *num);
+
+/* NB: the IV is _two_ blocks long */
+OSSL_DEPRECATEDIN_3_0
+void AES_ige_encrypt(const unsigned char *in, unsigned char *out,
+    size_t length, const AES_KEY *key,
+    unsigned char *ivec, const int enc);
+/* NB: the IV is _four_ blocks long */
+OSSL_DEPRECATEDIN_3_0
+void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out,
+    size_t length, const AES_KEY *key, const AES_KEY *key2,
+    const unsigned char *ivec, const int enc);
+OSSL_DEPRECATEDIN_3_0
+int AES_wrap_key(AES_KEY *key, const unsigned char *iv,
+    unsigned char *out, const unsigned char *in,
+    unsigned int inlen);
+OSSL_DEPRECATEDIN_3_0
+int AES_unwrap_key(AES_KEY *key, const unsigned char *iv,
+    unsigned char *out, const unsigned char *in,
+    unsigned int inlen);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

miniconda3/envs/active_proaction/include/openssl/asn1.h

@@ -0,0 +1,1125 @@
+/*
+ * WARNING: do not edit!
+ * Generated by Makefile from include/openssl/asn1.h.in
+ *
+ * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/* clang-format off */
+
+/* clang-format on */
+
+#ifndef OPENSSL_ASN1_H
+#define OPENSSL_ASN1_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_ASN1_H
+#endif
+
+#ifndef OPENSSL_NO_STDIO
+#include <stdio.h>
+#endif
+#include <time.h>
+#include <openssl/e_os2.h>
+#include <openssl/opensslconf.h>
+#include <openssl/bio.h>
+#include <openssl/safestack.h>
+#include <openssl/asn1err.h>
+#include <openssl/symhacks.h>
+
+#include <openssl/types.h>
+#include <openssl/bn.h>
+
+#ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#undef OPENSSL_EXTERN
+#define OPENSSL_EXTERN OPENSSL_EXPORT
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define V_ASN1_UNIVERSAL 0x00
+#define V_ASN1_APPLICATION 0x40
+#define V_ASN1_CONTEXT_SPECIFIC 0x80
+#define V_ASN1_PRIVATE 0xc0
+
+#define V_ASN1_CONSTRUCTED 0x20
+#define V_ASN1_PRIMITIVE_TAG 0x1f
+#define V_ASN1_PRIMATIVE_TAG /*compat*/ V_ASN1_PRIMITIVE_TAG
+
+#define V_ASN1_APP_CHOOSE -2 /* let the recipient choose */
+#define V_ASN1_OTHER -3 /* used in ASN1_TYPE */
+#define V_ASN1_ANY -4 /* used in ASN1 template code */
+
+#define V_ASN1_UNDEF -1
+/* ASN.1 tag values */
+#define V_ASN1_EOC 0
+#define V_ASN1_BOOLEAN 1
+#define V_ASN1_INTEGER 2
+#define V_ASN1_BIT_STRING 3
+#define V_ASN1_OCTET_STRING 4
+#define V_ASN1_NULL 5
+#define V_ASN1_OBJECT 6
+#define V_ASN1_OBJECT_DESCRIPTOR 7
+#define V_ASN1_EXTERNAL 8
+#define V_ASN1_REAL 9
+#define V_ASN1_ENUMERATED 10
+#define V_ASN1_UTF8STRING 12
+#define V_ASN1_SEQUENCE 16
+#define V_ASN1_SET 17
+#define V_ASN1_NUMERICSTRING 18
+#define V_ASN1_PRINTABLESTRING 19
+#define V_ASN1_T61STRING 20
+#define V_ASN1_TELETEXSTRING 20 /* alias */
+#define V_ASN1_VIDEOTEXSTRING 21
+#define V_ASN1_IA5STRING 22
+#define V_ASN1_UTCTIME 23
+#define V_ASN1_GENERALIZEDTIME 24
+#define V_ASN1_GRAPHICSTRING 25
+#define V_ASN1_ISO64STRING 26
+#define V_ASN1_VISIBLESTRING 26 /* alias */
+#define V_ASN1_GENERALSTRING 27
+#define V_ASN1_UNIVERSALSTRING 28
+#define V_ASN1_BMPSTRING 30
+
+/*
+ * NB the constants below are used internally by ASN1_INTEGER
+ * and ASN1_ENUMERATED to indicate the sign. They are *not* on
+ * the wire tag values.
+ */
+
+#define V_ASN1_NEG 0x100
+#define V_ASN1_NEG_INTEGER (2 | V_ASN1_NEG)
+#define V_ASN1_NEG_ENUMERATED (10 | V_ASN1_NEG)
+
+/* For use with d2i_ASN1_type_bytes() */
+#define B_ASN1_NUMERICSTRING 0x0001
+#define B_ASN1_PRINTABLESTRING 0x0002
+#define B_ASN1_T61STRING 0x0004
+#define B_ASN1_TELETEXSTRING 0x0004
+#define B_ASN1_VIDEOTEXSTRING 0x0008
+#define B_ASN1_IA5STRING 0x0010
+#define B_ASN1_GRAPHICSTRING 0x0020
+#define B_ASN1_ISO64STRING 0x0040
+#define B_ASN1_VISIBLESTRING 0x0040
+#define B_ASN1_GENERALSTRING 0x0080
+#define B_ASN1_UNIVERSALSTRING 0x0100
+#define B_ASN1_OCTET_STRING 0x0200
+#define B_ASN1_BIT_STRING 0x0400
+#define B_ASN1_BMPSTRING 0x0800
+#define B_ASN1_UNKNOWN 0x1000
+#define B_ASN1_UTF8STRING 0x2000
+#define B_ASN1_UTCTIME 0x4000
+#define B_ASN1_GENERALIZEDTIME 0x8000
+#define B_ASN1_SEQUENCE 0x10000
+/* For use with ASN1_mbstring_copy() */
+#define MBSTRING_FLAG 0x1000
+#define MBSTRING_UTF8 (MBSTRING_FLAG)
+#define MBSTRING_ASC (MBSTRING_FLAG | 1)
+#define MBSTRING_BMP (MBSTRING_FLAG | 2)
+#define MBSTRING_UNIV (MBSTRING_FLAG | 4)
+#define SMIME_OLDMIME 0x400
+#define SMIME_CRLFEOL 0x800
+#define SMIME_STREAM 0x1000
+
+/* Stacks for types not otherwise defined in this header */
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(X509_ALGOR, X509_ALGOR, X509_ALGOR)
+#define sk_X509_ALGOR_num(sk) OPENSSL_sk_num(ossl_check_const_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_value(sk, idx) ((X509_ALGOR *)OPENSSL_sk_value(ossl_check_const_X509_ALGOR_sk_type(sk), (idx)))
+#define sk_X509_ALGOR_new(cmp) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new(ossl_check_X509_ALGOR_compfunc_type(cmp)))
+#define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new_null())
+#define sk_X509_ALGOR_new_reserve(cmp, n) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new_reserve(ossl_check_X509_ALGOR_compfunc_type(cmp), (n)))
+#define sk_X509_ALGOR_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_ALGOR_sk_type(sk), (n))
+#define sk_X509_ALGOR_free(sk) OPENSSL_sk_free(ossl_check_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_zero(sk) OPENSSL_sk_zero(ossl_check_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_delete(sk, i) ((X509_ALGOR *)OPENSSL_sk_delete(ossl_check_X509_ALGOR_sk_type(sk), (i)))
+#define sk_X509_ALGOR_delete_ptr(sk, ptr) ((X509_ALGOR *)OPENSSL_sk_delete_ptr(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr)))
+#define sk_X509_ALGOR_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_pop(sk) ((X509_ALGOR *)OPENSSL_sk_pop(ossl_check_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_shift(sk) ((X509_ALGOR *)OPENSSL_sk_shift(ossl_check_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_ALGOR_sk_type(sk),ossl_check_X509_ALGOR_freefunc_type(freefunc))
+#define sk_X509_ALGOR_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr), (idx))
+#define sk_X509_ALGOR_set(sk, idx, ptr) ((X509_ALGOR *)OPENSSL_sk_set(ossl_check_X509_ALGOR_sk_type(sk), (idx), ossl_check_X509_ALGOR_type(ptr)))
+#define sk_X509_ALGOR_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr), pnum)
+#define sk_X509_ALGOR_sort(sk) OPENSSL_sk_sort(ossl_check_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_dup(sk) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_dup(ossl_check_const_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_copyfunc_type(copyfunc), ossl_check_X509_ALGOR_freefunc_type(freefunc)))
+#define sk_X509_ALGOR_set_cmp_func(sk, cmp) ((sk_X509_ALGOR_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_compfunc_type(cmp)))
+
+/* clang-format on */
+
+#define ASN1_STRING_FLAG_BITS_LEFT 0x08 /* Set if 0x07 has bits left value */
+/*
+ * This indicates that the ASN1_STRING is not a real value but just a place
+ * holder for the location where indefinite length constructed data should be
+ * inserted in the memory buffer
+ */
+#define ASN1_STRING_FLAG_NDEF 0x010
+
+/*
+ * This flag is used by the CMS code to indicate that a string is not
+ * complete and is a place holder for content when it had all been accessed.
+ * The flag will be reset when content has been written to it.
+ */
+
+#define ASN1_STRING_FLAG_CONT 0x020
+/*
+ * This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING
+ * type.
+ */
+#define ASN1_STRING_FLAG_MSTRING 0x040
+/* String is embedded and only content should be freed */
+#define ASN1_STRING_FLAG_EMBED 0x080
+/* String should be parsed in RFC 5280's time format */
+#define ASN1_STRING_FLAG_X509_TIME 0x100
+/* This is the base type that holds just about everything :-) */
+struct asn1_string_st {
+    int length;
+    int type;
+    unsigned char *data;
+    /*
+     * The value of the following field depends on the type being held.  It
+     * is mostly being used for BIT_STRING so if the input data has a
+     * non-zero 'unused bits' value, it will be handled correctly
+     */
+    long flags;
+};
+
+/*
+ * ASN1_ENCODING structure: this is used to save the received encoding of an
+ * ASN1 type. This is useful to get round problems with invalid encodings
+ * which can break signatures.
+ */
+
+typedef struct ASN1_ENCODING_st {
+    unsigned char *enc; /* DER encoding */
+    long len; /* Length of encoding */
+    int modified; /* set to 1 if 'enc' is invalid */
+} ASN1_ENCODING;
+
+/* Used with ASN1 LONG type: if a long is set to this it is omitted */
+#define ASN1_LONG_UNDEF 0x7fffffffL
+
+#define STABLE_FLAGS_MALLOC 0x01
+/*
+ * A zero passed to ASN1_STRING_TABLE_new_add for the flags is interpreted
+ * as "don't change" and STABLE_FLAGS_MALLOC is always set. By setting
+ * STABLE_FLAGS_MALLOC only we can clear the existing value. Use the alias
+ * STABLE_FLAGS_CLEAR to reflect this.
+ */
+#define STABLE_FLAGS_CLEAR STABLE_FLAGS_MALLOC
+#define STABLE_NO_MASK 0x02
+#define DIRSTRING_TYPE \
+    (B_ASN1_PRINTABLESTRING | B_ASN1_T61STRING | B_ASN1_BMPSTRING | B_ASN1_UTF8STRING)
+#define PKCS9STRING_TYPE (DIRSTRING_TYPE | B_ASN1_IA5STRING)
+
+struct asn1_string_table_st {
+    int nid;
+    long minsize;
+    long maxsize;
+    unsigned long mask;
+    unsigned long flags;
+};
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_STRING_TABLE, ASN1_STRING_TABLE, ASN1_STRING_TABLE)
+#define sk_ASN1_STRING_TABLE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_value(sk, idx) ((ASN1_STRING_TABLE *)OPENSSL_sk_value(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), (idx)))
+#define sk_ASN1_STRING_TABLE_new(cmp) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))
+#define sk_ASN1_STRING_TABLE_new_null() ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new_null())
+#define sk_ASN1_STRING_TABLE_new_reserve(cmp, n) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp), (n)))
+#define sk_ASN1_STRING_TABLE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (n))
+#define sk_ASN1_STRING_TABLE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_delete(sk, i) ((ASN1_STRING_TABLE *)OPENSSL_sk_delete(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (i)))
+#define sk_ASN1_STRING_TABLE_delete_ptr(sk, ptr) ((ASN1_STRING_TABLE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr)))
+#define sk_ASN1_STRING_TABLE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_pop(sk) ((ASN1_STRING_TABLE *)OPENSSL_sk_pop(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_shift(sk) ((ASN1_STRING_TABLE *)OPENSSL_sk_shift(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk),ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc))
+#define sk_ASN1_STRING_TABLE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr), (idx))
+#define sk_ASN1_STRING_TABLE_set(sk, idx, ptr) ((ASN1_STRING_TABLE *)OPENSSL_sk_set(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (idx), ossl_check_ASN1_STRING_TABLE_type(ptr)))
+#define sk_ASN1_STRING_TABLE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr), pnum)
+#define sk_ASN1_STRING_TABLE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_dup(sk) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_copyfunc_type(copyfunc), ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc)))
+#define sk_ASN1_STRING_TABLE_set_cmp_func(sk, cmp) ((sk_ASN1_STRING_TABLE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))
+
+/* clang-format on */
+
+/* size limits: this stuff is taken straight from RFC2459 */
+
+#define ub_name 32768
+#define ub_common_name 64
+#define ub_locality_name 128
+#define ub_state_name 128
+#define ub_organization_name 64
+#define ub_organization_unit_name 64
+#define ub_title 64
+#define ub_email_address 128
+
+/*
+ * Declarations for template structures: for full definitions see asn1t.h
+ */
+typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE;
+typedef struct ASN1_TLC_st ASN1_TLC;
+/* This is just an opaque pointer */
+typedef struct ASN1_VALUE_st ASN1_VALUE;
+
+/* Declare ASN1 functions: the implement macro is in asn1t.h */
+
+/*
+ * The mysterious 'extern' that's passed to some macros is innocuous,
+ * and is there to quiet pre-C99 compilers that may complain about empty
+ * arguments in macro calls.
+ */
+
+#define DECLARE_ASN1_FUNCTIONS_attr(attr, type) \
+    DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, type)
+#define DECLARE_ASN1_FUNCTIONS(type) \
+    DECLARE_ASN1_FUNCTIONS_attr(extern, type)
+
+#define DECLARE_ASN1_ALLOC_FUNCTIONS_attr(attr, type) \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, type)
+#define DECLARE_ASN1_ALLOC_FUNCTIONS(type) \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_attr(extern, type)
+
+#define DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, name)   \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name)
+#define DECLARE_ASN1_FUNCTIONS_name(type, name) \
+    DECLARE_ASN1_FUNCTIONS_name_attr(extern, type, name)
+
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, itname, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)        \
+    DECLARE_ASN1_ITEM_attr(attr, itname)
+#define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_attr(extern, type, itname, name)
+
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, name, name)
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_name(type, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(extern, type, name)
+
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)        \
+    attr type *d2i_##name(type **a, const unsigned char **in, long len); \
+    attr int i2d_##name(const type *a, unsigned char **out);
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_only(type, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(extern, type, name)
+
+#define DECLARE_ASN1_NDEF_FUNCTION_attr(attr, name) \
+    attr int i2d_##name##_NDEF(const name *a, unsigned char **out);
+#define DECLARE_ASN1_NDEF_FUNCTION(name) \
+    DECLARE_ASN1_NDEF_FUNCTION_attr(extern, name)
+
+#define DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name) \
+    attr type *name##_new(void);                                 \
+    attr void name##_free(type *a);
+#define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(extern, type, name)
+
+#define DECLARE_ASN1_DUP_FUNCTION_attr(attr, type) \
+    DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, type)
+#define DECLARE_ASN1_DUP_FUNCTION(type) \
+    DECLARE_ASN1_DUP_FUNCTION_attr(extern, type)
+
+#define DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, name) \
+    attr type *name##_dup(const type *a);
+#define DECLARE_ASN1_DUP_FUNCTION_name(type, name) \
+    DECLARE_ASN1_DUP_FUNCTION_name_attr(extern, type, name)
+
+#define DECLARE_ASN1_PRINT_FUNCTION_attr(attr, stname) \
+    DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, stname)
+#define DECLARE_ASN1_PRINT_FUNCTION(stname) \
+    DECLARE_ASN1_PRINT_FUNCTION_attr(extern, stname)
+
+#define DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, fname)   \
+    attr int fname##_print_ctx(BIO *out, const stname *x, int indent, \
+        const ASN1_PCTX *pctx);
+#define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname) \
+    DECLARE_ASN1_PRINT_FUNCTION_fname_attr(extern, stname, fname)
+
+#define D2I_OF(type) type *(*)(type **, const unsigned char **, long)
+#define I2D_OF(type) int (*)(const type *, unsigned char **)
+
+#define CHECKED_D2I_OF(type, d2i) \
+    ((d2i_of_void *)(1 ? d2i : ((D2I_OF(type))0)))
+#define CHECKED_I2D_OF(type, i2d) \
+    ((i2d_of_void *)(1 ? i2d : ((I2D_OF(type))0)))
+#define CHECKED_NEW_OF(type, xnew) \
+    ((void *(*)(void))(1 ? xnew : ((type * (*)(void))0)))
+#define CHECKED_PTR_OF(type, p) \
+    ((void *)(1 ? p : (type *)0))
+#define CHECKED_PPTR_OF(type, p) \
+    ((void **)(1 ? p : (type **)0))
+
+#define TYPEDEF_D2I_OF(type) typedef type *d2i_of_##type(type **, const unsigned char **, long)
+#define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(const type *, unsigned char **)
+#define TYPEDEF_D2I2D_OF(type) \
+    TYPEDEF_D2I_OF(type);      \
+    TYPEDEF_I2D_OF(type)
+
+typedef void *d2i_of_void(void **, const unsigned char **, long);
+typedef int i2d_of_void(const void *, unsigned char **);
+typedef int OSSL_i2d_of_void_ctx(const void *, unsigned char **, void *vctx);
+
+/*-
+ * The following macros and typedefs allow an ASN1_ITEM
+ * to be embedded in a structure and referenced. Since
+ * the ASN1_ITEM pointers need to be globally accessible
+ * (possibly from shared libraries) they may exist in
+ * different forms. On platforms that support it the
+ * ASN1_ITEM structure itself will be globally exported.
+ * Other platforms will export a function that returns
+ * an ASN1_ITEM pointer.
+ *
+ * To handle both cases transparently the macros below
+ * should be used instead of hard coding an ASN1_ITEM
+ * pointer in a structure.
+ *
+ * The structure will look like this:
+ *
+ * typedef struct SOMETHING_st {
+ *      ...
+ *      ASN1_ITEM_EXP *iptr;
+ *      ...
+ * } SOMETHING;
+ *
+ * It would be initialised as e.g.:
+ *
+ * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...};
+ *
+ * and the actual pointer extracted with:
+ *
+ * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr);
+ *
+ * Finally an ASN1_ITEM pointer can be extracted from an
+ * appropriate reference with: ASN1_ITEM_rptr(X509). This
+ * would be used when a function takes an ASN1_ITEM * argument.
+ *
+ */
+
+/*
+ * Platforms that can't easily handle shared global variables are declared as
+ * functions returning ASN1_ITEM pointers.
+ */
+
+/* ASN1_ITEM pointer exported type */
+typedef const ASN1_ITEM *ASN1_ITEM_EXP(void);
+
+/* Macro to obtain ASN1_ITEM pointer from exported type */
+#define ASN1_ITEM_ptr(iptr) (iptr())
+
+/* Macro to include ASN1_ITEM pointer from base type */
+#define ASN1_ITEM_ref(iptr) (iptr##_it)
+
+#define ASN1_ITEM_rptr(ref) (ref##_it())
+
+#define DECLARE_ASN1_ITEM_attr(attr, name) \
+    attr const ASN1_ITEM *name##_it(void);
+#define DECLARE_ASN1_ITEM(name) \
+    DECLARE_ASN1_ITEM_attr(extern, name)
+
+/* Parameters used by ASN1_STRING_print_ex() */
+
+/*
+ * These determine which characters to escape: RFC2253 special characters,
+ * control characters and MSB set characters
+ */
+
+#define ASN1_STRFLGS_ESC_2253 1
+#define ASN1_STRFLGS_ESC_CTRL 2
+#define ASN1_STRFLGS_ESC_MSB 4
+
+/* Lower 8 bits are reserved as an output type specifier */
+#define ASN1_DTFLGS_TYPE_MASK 0x0FUL
+#define ASN1_DTFLGS_RFC822 0x00UL
+#define ASN1_DTFLGS_ISO8601 0x01UL
+
+/*
+ * This flag determines how we do escaping: normally RC2253 backslash only,
+ * set this to use backslash and quote.
+ */
+
+#define ASN1_STRFLGS_ESC_QUOTE 8
+
+/* These three flags are internal use only. */
+
+/* Character is a valid PrintableString character */
+#define CHARTYPE_PRINTABLESTRING 0x10
+/* Character needs escaping if it is the first character */
+#define CHARTYPE_FIRST_ESC_2253 0x20
+/* Character needs escaping if it is the last character */
+#define CHARTYPE_LAST_ESC_2253 0x40
+
+/*
+ * NB the internal flags are safely reused below by flags handled at the top
+ * level.
+ */
+
+/*
+ * If this is set we convert all character strings to UTF8 first
+ */
+
+#define ASN1_STRFLGS_UTF8_CONVERT 0x10
+
+/*
+ * If this is set we don't attempt to interpret content: just assume all
+ * strings are 1 byte per character. This will produce some pretty odd
+ * looking output!
+ */
+
+#define ASN1_STRFLGS_IGNORE_TYPE 0x20
+
+/* If this is set we include the string type in the output */
+#define ASN1_STRFLGS_SHOW_TYPE 0x40
+
+/*
+ * This determines which strings to display and which to 'dump' (hex dump of
+ * content octets or DER encoding). We can only dump non character strings or
+ * everything. If we don't dump 'unknown' they are interpreted as character
+ * strings with 1 octet per character and are subject to the usual escaping
+ * options.
+ */
+
+#define ASN1_STRFLGS_DUMP_ALL 0x80
+#define ASN1_STRFLGS_DUMP_UNKNOWN 0x100
+
+/*
+ * These determine what 'dumping' does, we can dump the content octets or the
+ * DER encoding: both use the RFC2253 #XXXXX notation.
+ */
+
+#define ASN1_STRFLGS_DUMP_DER 0x200
+
+/*
+ * This flag specifies that RC2254 escaping shall be performed.
+ */
+#define ASN1_STRFLGS_ESC_2254 0x400
+
+/*
+ * All the string flags consistent with RFC2253, escaping control characters
+ * isn't essential in RFC2253 but it is advisable anyway.
+ */
+
+#define ASN1_STRFLGS_RFC2253 (ASN1_STRFLGS_ESC_2253 | ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | ASN1_STRFLGS_UTF8_CONVERT | ASN1_STRFLGS_DUMP_UNKNOWN | ASN1_STRFLGS_DUMP_DER)
+
+struct asn1_type_st {
+    int type;
+    union {
+        char *ptr;
+        ASN1_BOOLEAN boolean;
+        ASN1_STRING *asn1_string;
+        ASN1_OBJECT *object;
+        ASN1_INTEGER *integer;
+        ASN1_ENUMERATED *enumerated;
+        ASN1_BIT_STRING *bit_string;
+        ASN1_OCTET_STRING *octet_string;
+        ASN1_PRINTABLESTRING *printablestring;
+        ASN1_T61STRING *t61string;
+        ASN1_IA5STRING *ia5string;
+        ASN1_GENERALSTRING *generalstring;
+        ASN1_BMPSTRING *bmpstring;
+        ASN1_UNIVERSALSTRING *universalstring;
+        ASN1_UTCTIME *utctime;
+        ASN1_GENERALIZEDTIME *generalizedtime;
+        ASN1_VISIBLESTRING *visiblestring;
+        ASN1_UTF8STRING *utf8string;
+        /*
+         * set and sequence are left complete and still contain the set or
+         * sequence bytes
+         */
+        ASN1_STRING *set;
+        ASN1_STRING *sequence;
+        ASN1_VALUE *asn1_value;
+    } value;
+};
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_TYPE, ASN1_TYPE, ASN1_TYPE)
+#define sk_ASN1_TYPE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_value(sk, idx) ((ASN1_TYPE *)OPENSSL_sk_value(ossl_check_const_ASN1_TYPE_sk_type(sk), (idx)))
+#define sk_ASN1_TYPE_new(cmp) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new(ossl_check_ASN1_TYPE_compfunc_type(cmp)))
+#define sk_ASN1_TYPE_new_null() ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new_null())
+#define sk_ASN1_TYPE_new_reserve(cmp, n) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_TYPE_compfunc_type(cmp), (n)))
+#define sk_ASN1_TYPE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_TYPE_sk_type(sk), (n))
+#define sk_ASN1_TYPE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_delete(sk, i) ((ASN1_TYPE *)OPENSSL_sk_delete(ossl_check_ASN1_TYPE_sk_type(sk), (i)))
+#define sk_ASN1_TYPE_delete_ptr(sk, ptr) ((ASN1_TYPE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr)))
+#define sk_ASN1_TYPE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_pop(sk) ((ASN1_TYPE *)OPENSSL_sk_pop(ossl_check_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_shift(sk) ((ASN1_TYPE *)OPENSSL_sk_shift(ossl_check_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_TYPE_sk_type(sk),ossl_check_ASN1_TYPE_freefunc_type(freefunc))
+#define sk_ASN1_TYPE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr), (idx))
+#define sk_ASN1_TYPE_set(sk, idx, ptr) ((ASN1_TYPE *)OPENSSL_sk_set(ossl_check_ASN1_TYPE_sk_type(sk), (idx), ossl_check_ASN1_TYPE_type(ptr)))
+#define sk_ASN1_TYPE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr), pnum)
+#define sk_ASN1_TYPE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_dup(sk) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_copyfunc_type(copyfunc), ossl_check_ASN1_TYPE_freefunc_type(freefunc)))
+#define sk_ASN1_TYPE_set_cmp_func(sk, cmp) ((sk_ASN1_TYPE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_compfunc_type(cmp)))
+
+/* clang-format on */
+
+typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY;
+
+DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY)
+DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SET_ANY)
+
+/* This is used to contain a list of bit names */
+typedef struct BIT_STRING_BITNAME_st {
+    int bitnum;
+    const char *lname;
+    const char *sname;
+} BIT_STRING_BITNAME;
+
+#define B_ASN1_TIME \
+    B_ASN1_UTCTIME | B_ASN1_GENERALIZEDTIME
+
+#define B_ASN1_PRINTABLE \
+    B_ASN1_NUMERICSTRING | B_ASN1_PRINTABLESTRING | B_ASN1_T61STRING | B_ASN1_IA5STRING | B_ASN1_BIT_STRING | B_ASN1_UNIVERSALSTRING | B_ASN1_BMPSTRING | B_ASN1_UTF8STRING | B_ASN1_SEQUENCE | B_ASN1_UNKNOWN
+
+#define B_ASN1_DIRECTORYSTRING \
+    B_ASN1_PRINTABLESTRING | B_ASN1_TELETEXSTRING | B_ASN1_BMPSTRING | B_ASN1_UNIVERSALSTRING | B_ASN1_UTF8STRING
+
+#define B_ASN1_DISPLAYTEXT \
+    B_ASN1_IA5STRING | B_ASN1_VISIBLESTRING | B_ASN1_BMPSTRING | B_ASN1_UTF8STRING
+
+DECLARE_ASN1_ALLOC_FUNCTIONS_name(ASN1_TYPE, ASN1_TYPE)
+DECLARE_ASN1_ENCODE_FUNCTIONS(ASN1_TYPE, ASN1_ANY, ASN1_TYPE)
+
+int ASN1_TYPE_get(const ASN1_TYPE *a);
+void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value);
+int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value);
+int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b);
+
+ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t);
+void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t);
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_OBJECT, ASN1_OBJECT, ASN1_OBJECT)
+#define sk_ASN1_OBJECT_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_value(sk, idx) ((ASN1_OBJECT *)OPENSSL_sk_value(ossl_check_const_ASN1_OBJECT_sk_type(sk), (idx)))
+#define sk_ASN1_OBJECT_new(cmp) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new(ossl_check_ASN1_OBJECT_compfunc_type(cmp)))
+#define sk_ASN1_OBJECT_new_null() ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new_null())
+#define sk_ASN1_OBJECT_new_reserve(cmp, n) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_OBJECT_compfunc_type(cmp), (n)))
+#define sk_ASN1_OBJECT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_OBJECT_sk_type(sk), (n))
+#define sk_ASN1_OBJECT_free(sk) OPENSSL_sk_free(ossl_check_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_delete(sk, i) ((ASN1_OBJECT *)OPENSSL_sk_delete(ossl_check_ASN1_OBJECT_sk_type(sk), (i)))
+#define sk_ASN1_OBJECT_delete_ptr(sk, ptr) ((ASN1_OBJECT *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr)))
+#define sk_ASN1_OBJECT_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_pop(sk) ((ASN1_OBJECT *)OPENSSL_sk_pop(ossl_check_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_shift(sk) ((ASN1_OBJECT *)OPENSSL_sk_shift(ossl_check_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_OBJECT_sk_type(sk),ossl_check_ASN1_OBJECT_freefunc_type(freefunc))
+#define sk_ASN1_OBJECT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr), (idx))
+#define sk_ASN1_OBJECT_set(sk, idx, ptr) ((ASN1_OBJECT *)OPENSSL_sk_set(ossl_check_ASN1_OBJECT_sk_type(sk), (idx), ossl_check_ASN1_OBJECT_type(ptr)))
+#define sk_ASN1_OBJECT_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr), pnum)
+#define sk_ASN1_OBJECT_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_dup(sk) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_dup(ossl_check_const_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_copyfunc_type(copyfunc), ossl_check_ASN1_OBJECT_freefunc_type(freefunc)))
+#define sk_ASN1_OBJECT_set_cmp_func(sk, cmp) ((sk_ASN1_OBJECT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_compfunc_type(cmp)))
+
+/* clang-format on */
+
+DECLARE_ASN1_FUNCTIONS(ASN1_OBJECT)
+
+ASN1_STRING *ASN1_STRING_new(void);
+void ASN1_STRING_free(ASN1_STRING *a);
+void ASN1_STRING_clear_free(ASN1_STRING *a);
+int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str);
+DECLARE_ASN1_DUP_FUNCTION(ASN1_STRING)
+ASN1_STRING *ASN1_STRING_type_new(int type);
+int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b);
+/*
+ * Since this is used to store all sorts of things, via macros, for now,
+ * make its data void *
+ */
+int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len);
+void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len);
+int ASN1_STRING_length(const ASN1_STRING *x);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void ASN1_STRING_length_set(ASN1_STRING *x, int n);
+#endif
+int ASN1_STRING_type(const ASN1_STRING *x);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 unsigned char *ASN1_STRING_data(ASN1_STRING *x);
+#endif
+const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x);
+
+DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING)
+int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length);
+int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value);
+int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n);
+int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a,
+    const unsigned char *flags, int flags_len);
+
+int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs,
+    BIT_STRING_BITNAME *tbl, int indent);
+int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl);
+int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value,
+    BIT_STRING_BITNAME *tbl);
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_INTEGER, ASN1_INTEGER, ASN1_INTEGER)
+#define sk_ASN1_INTEGER_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_value(sk, idx) ((ASN1_INTEGER *)OPENSSL_sk_value(ossl_check_const_ASN1_INTEGER_sk_type(sk), (idx)))
+#define sk_ASN1_INTEGER_new(cmp) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new(ossl_check_ASN1_INTEGER_compfunc_type(cmp)))
+#define sk_ASN1_INTEGER_new_null() ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new_null())
+#define sk_ASN1_INTEGER_new_reserve(cmp, n) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_INTEGER_compfunc_type(cmp), (n)))
+#define sk_ASN1_INTEGER_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_INTEGER_sk_type(sk), (n))
+#define sk_ASN1_INTEGER_free(sk) OPENSSL_sk_free(ossl_check_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_delete(sk, i) ((ASN1_INTEGER *)OPENSSL_sk_delete(ossl_check_ASN1_INTEGER_sk_type(sk), (i)))
+#define sk_ASN1_INTEGER_delete_ptr(sk, ptr) ((ASN1_INTEGER *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr)))
+#define sk_ASN1_INTEGER_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_pop(sk) ((ASN1_INTEGER *)OPENSSL_sk_pop(ossl_check_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_shift(sk) ((ASN1_INTEGER *)OPENSSL_sk_shift(ossl_check_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_INTEGER_sk_type(sk),ossl_check_ASN1_INTEGER_freefunc_type(freefunc))
+#define sk_ASN1_INTEGER_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr), (idx))
+#define sk_ASN1_INTEGER_set(sk, idx, ptr) ((ASN1_INTEGER *)OPENSSL_sk_set(ossl_check_ASN1_INTEGER_sk_type(sk), (idx), ossl_check_ASN1_INTEGER_type(ptr)))
+#define sk_ASN1_INTEGER_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr), pnum)
+#define sk_ASN1_INTEGER_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_dup(sk) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_dup(ossl_check_const_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_copyfunc_type(copyfunc), ossl_check_ASN1_INTEGER_freefunc_type(freefunc)))
+#define sk_ASN1_INTEGER_set_cmp_func(sk, cmp) ((sk_ASN1_INTEGER_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_compfunc_type(cmp)))
+
+/* clang-format on */
+
+DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER)
+ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
+    long length);
+DECLARE_ASN1_DUP_FUNCTION(ASN1_INTEGER)
+int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y);
+
+DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED)
+
+int ASN1_UTCTIME_check(const ASN1_UTCTIME *a);
+ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t);
+ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
+    int offset_day, long offset_sec);
+int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str);
+int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t);
+
+int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a);
+ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
+    time_t t);
+ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
+    time_t t, int offset_day,
+    long offset_sec);
+int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str);
+
+int ASN1_TIME_diff(int *pday, int *psec,
+    const ASN1_TIME *from, const ASN1_TIME *to);
+
+DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING)
+DECLARE_ASN1_DUP_FUNCTION(ASN1_OCTET_STRING)
+int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a,
+    const ASN1_OCTET_STRING *b);
+int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data,
+    int len);
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_UTF8STRING, ASN1_UTF8STRING, ASN1_UTF8STRING)
+#define sk_ASN1_UTF8STRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_value(sk, idx) ((ASN1_UTF8STRING *)OPENSSL_sk_value(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), (idx)))
+#define sk_ASN1_UTF8STRING_new(cmp) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))
+#define sk_ASN1_UTF8STRING_new_null() ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new_null())
+#define sk_ASN1_UTF8STRING_new_reserve(cmp, n) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_UTF8STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_UTF8STRING_sk_type(sk), (n))
+#define sk_ASN1_UTF8STRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_delete(sk, i) ((ASN1_UTF8STRING *)OPENSSL_sk_delete(ossl_check_ASN1_UTF8STRING_sk_type(sk), (i)))
+#define sk_ASN1_UTF8STRING_delete_ptr(sk, ptr) ((ASN1_UTF8STRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr)))
+#define sk_ASN1_UTF8STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_pop(sk) ((ASN1_UTF8STRING *)OPENSSL_sk_pop(ossl_check_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_shift(sk) ((ASN1_UTF8STRING *)OPENSSL_sk_shift(ossl_check_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_UTF8STRING_sk_type(sk),ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc))
+#define sk_ASN1_UTF8STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr), (idx))
+#define sk_ASN1_UTF8STRING_set(sk, idx, ptr) ((ASN1_UTF8STRING *)OPENSSL_sk_set(ossl_check_ASN1_UTF8STRING_sk_type(sk), (idx), ossl_check_ASN1_UTF8STRING_type(ptr)))
+#define sk_ASN1_UTF8STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr), pnum)
+#define sk_ASN1_UTF8STRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_dup(sk) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_copyfunc_type(copyfunc), ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc)))
+#define sk_ASN1_UTF8STRING_set_cmp_func(sk, cmp) ((sk_ASN1_UTF8STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))
+
+/* clang-format on */
+
+DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_NULL)
+DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING)
+
+int UTF8_getc(const unsigned char *str, int len, unsigned long *val);
+int UTF8_putc(unsigned char *str, int len, unsigned long value);
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_GENERALSTRING, ASN1_GENERALSTRING, ASN1_GENERALSTRING)
+#define sk_ASN1_GENERALSTRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_value(sk, idx) ((ASN1_GENERALSTRING *)OPENSSL_sk_value(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), (idx)))
+#define sk_ASN1_GENERALSTRING_new(cmp) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))
+#define sk_ASN1_GENERALSTRING_new_null() ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new_null())
+#define sk_ASN1_GENERALSTRING_new_reserve(cmp, n) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_GENERALSTRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (n))
+#define sk_ASN1_GENERALSTRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_delete(sk, i) ((ASN1_GENERALSTRING *)OPENSSL_sk_delete(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (i)))
+#define sk_ASN1_GENERALSTRING_delete_ptr(sk, ptr) ((ASN1_GENERALSTRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr)))
+#define sk_ASN1_GENERALSTRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_pop(sk) ((ASN1_GENERALSTRING *)OPENSSL_sk_pop(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_shift(sk) ((ASN1_GENERALSTRING *)OPENSSL_sk_shift(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk),ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc))
+#define sk_ASN1_GENERALSTRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr), (idx))
+#define sk_ASN1_GENERALSTRING_set(sk, idx, ptr) ((ASN1_GENERALSTRING *)OPENSSL_sk_set(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (idx), ossl_check_ASN1_GENERALSTRING_type(ptr)))
+#define sk_ASN1_GENERALSTRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr), pnum)
+#define sk_ASN1_GENERALSTRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_dup(sk) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_copyfunc_type(copyfunc), ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc)))
+#define sk_ASN1_GENERALSTRING_set_cmp_func(sk, cmp) ((sk_ASN1_GENERALSTRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))
+
+/* clang-format on */
+
+DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE)
+
+DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING)
+DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT)
+DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME)
+DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME)
+DECLARE_ASN1_FUNCTIONS(ASN1_TIME)
+
+DECLARE_ASN1_DUP_FUNCTION(ASN1_TIME)
+DECLARE_ASN1_DUP_FUNCTION(ASN1_UTCTIME)
+DECLARE_ASN1_DUP_FUNCTION(ASN1_GENERALIZEDTIME)
+
+DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF)
+
+ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t);
+ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t,
+    int offset_day, long offset_sec);
+int ASN1_TIME_check(const ASN1_TIME *t);
+ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t,
+    ASN1_GENERALIZEDTIME **out);
+int ASN1_TIME_set_string(ASN1_TIME *s, const char *str);
+int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str);
+int ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm);
+int ASN1_TIME_normalize(ASN1_TIME *s);
+int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t);
+int ASN1_TIME_compare(const ASN1_TIME *a, const ASN1_TIME *b);
+
+int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a);
+int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size);
+int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a);
+int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size);
+int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a);
+int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size);
+int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type);
+int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a);
+
+int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num);
+ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
+    const char *sn, const char *ln);
+
+int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a);
+int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r);
+int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a);
+int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r);
+
+int ASN1_INTEGER_set(ASN1_INTEGER *a, long v);
+long ASN1_INTEGER_get(const ASN1_INTEGER *a);
+ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai);
+BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn);
+
+int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a);
+int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r);
+
+int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v);
+long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a);
+ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai);
+BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn);
+
+/* General */
+/* given a string, return the correct type, max is the maximum length */
+int ASN1_PRINTABLE_type(const unsigned char *s, int max);
+
+unsigned long ASN1_tag2bit(int tag);
+
+/* SPECIALS */
+int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
+    int *pclass, long omax);
+int ASN1_check_infinite_end(unsigned char **p, long len);
+int ASN1_const_check_infinite_end(const unsigned char **p, long len);
+void ASN1_put_object(unsigned char **pp, int constructed, int length,
+    int tag, int xclass);
+int ASN1_put_eoc(unsigned char **pp);
+int ASN1_object_size(int constructed, int length, int tag);
+
+/* Used to implement other functions */
+void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, const void *x);
+
+#define ASN1_dup_of(type, i2d, d2i, x)           \
+    ((type *)ASN1_dup(CHECKED_I2D_OF(type, i2d), \
+        CHECKED_D2I_OF(type, d2i),               \
+        CHECKED_PTR_OF(const type, x)))
+
+void *ASN1_item_dup(const ASN1_ITEM *it, const void *x);
+int ASN1_item_sign_ex(const ASN1_ITEM *it, X509_ALGOR *algor1,
+    X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
+    const void *data, const ASN1_OCTET_STRING *id,
+    EVP_PKEY *pkey, const EVP_MD *md, OSSL_LIB_CTX *libctx,
+    const char *propq);
+int ASN1_item_verify_ex(const ASN1_ITEM *it, const X509_ALGOR *alg,
+    const ASN1_BIT_STRING *signature, const void *data,
+    const ASN1_OCTET_STRING *id, EVP_PKEY *pkey,
+    OSSL_LIB_CTX *libctx, const char *propq);
+
+/* ASN1 alloc/free macros for when a type is only used internally */
+
+#define M_ASN1_new_of(type) (type *)ASN1_item_new(ASN1_ITEM_rptr(type))
+#define M_ASN1_free_of(x, type) \
+    ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type))
+
+#ifndef OPENSSL_NO_STDIO
+void *ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x);
+
+#define ASN1_d2i_fp_of(type, xnew, d2i, in, x)       \
+    ((type *)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), \
+        CHECKED_D2I_OF(type, d2i),                   \
+        in,                                          \
+        CHECKED_PPTR_OF(type, x)))
+
+void *ASN1_item_d2i_fp_ex(const ASN1_ITEM *it, FILE *in, void *x,
+    OSSL_LIB_CTX *libctx, const char *propq);
+void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x);
+int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, const void *x);
+
+#define ASN1_i2d_fp_of(type, i2d, out, x)   \
+    (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), \
+        out,                                \
+        CHECKED_PTR_OF(const type, x)))
+
+int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, const void *x);
+int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags);
+#endif
+
+int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in);
+
+void *ASN1_d2i_bio(void *(*xnew)(void), d2i_of_void *d2i, BIO *in, void **x);
+
+#define ASN1_d2i_bio_of(type, xnew, d2i, in, x)       \
+    ((type *)ASN1_d2i_bio(CHECKED_NEW_OF(type, xnew), \
+        CHECKED_D2I_OF(type, d2i),                    \
+        in,                                           \
+        CHECKED_PPTR_OF(type, x)))
+
+void *ASN1_item_d2i_bio_ex(const ASN1_ITEM *it, BIO *in, void *pval,
+    OSSL_LIB_CTX *libctx, const char *propq);
+void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *pval);
+int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, const void *x);
+
+#define ASN1_i2d_bio_of(type, i2d, out, x)   \
+    (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), \
+        out,                                 \
+        CHECKED_PTR_OF(const type, x)))
+
+int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, const void *x);
+BIO *ASN1_item_i2d_mem_bio(const ASN1_ITEM *it, const ASN1_VALUE *val);
+int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a);
+int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a);
+int ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm);
+int ASN1_TIME_print_ex(BIO *bp, const ASN1_TIME *tm, unsigned long flags);
+int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v);
+int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags);
+int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off);
+int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num,
+    unsigned char *buf, int off);
+int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent);
+int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent,
+    int dump);
+const char *ASN1_tag2str(int tag);
+
+/* Used to load and write Netscape format cert */
+
+int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s);
+
+int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len);
+int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len);
+int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num,
+    unsigned char *data, int len);
+int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num,
+    unsigned char *data, int max_len);
+
+void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it);
+void *ASN1_item_unpack_ex(const ASN1_STRING *oct, const ASN1_ITEM *it,
+    OSSL_LIB_CTX *libctx, const char *propq);
+
+ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it,
+    ASN1_OCTET_STRING **oct);
+
+void ASN1_STRING_set_default_mask(unsigned long mask);
+int ASN1_STRING_set_default_mask_asc(const char *p);
+unsigned long ASN1_STRING_get_default_mask(void);
+int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
+    int inform, unsigned long mask);
+int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
+    int inform, unsigned long mask,
+    long minsize, long maxsize);
+
+ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out,
+    const unsigned char *in, int inlen,
+    int inform, int nid);
+ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid);
+int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long);
+void ASN1_STRING_TABLE_cleanup(void);
+
+/* ASN1 template functions */
+
+/* Old API compatible functions */
+ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it);
+ASN1_VALUE *ASN1_item_new_ex(const ASN1_ITEM *it, OSSL_LIB_CTX *libctx,
+    const char *propq);
+void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it);
+ASN1_VALUE *ASN1_item_d2i_ex(ASN1_VALUE **val, const unsigned char **in,
+    long len, const ASN1_ITEM *it,
+    OSSL_LIB_CTX *libctx, const char *propq);
+ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in,
+    long len, const ASN1_ITEM *it);
+int ASN1_item_i2d(const ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);
+int ASN1_item_ndef_i2d(const ASN1_VALUE *val, unsigned char **out,
+    const ASN1_ITEM *it);
+
+void ASN1_add_oid_module(void);
+void ASN1_add_stable_module(void);
+
+ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf);
+ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf);
+int ASN1_str2mask(const char *str, unsigned long *pmask);
+
+/* ASN1 Print flags */
+
+/* Indicate missing OPTIONAL fields */
+#define ASN1_PCTX_FLAGS_SHOW_ABSENT 0x001
+/* Mark start and end of SEQUENCE */
+#define ASN1_PCTX_FLAGS_SHOW_SEQUENCE 0x002
+/* Mark start and end of SEQUENCE/SET OF */
+#define ASN1_PCTX_FLAGS_SHOW_SSOF 0x004
+/* Show the ASN1 type of primitives */
+#define ASN1_PCTX_FLAGS_SHOW_TYPE 0x008
+/* Don't show ASN1 type of ANY */
+#define ASN1_PCTX_FLAGS_NO_ANY_TYPE 0x010
+/* Don't show ASN1 type of MSTRINGs */
+#define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE 0x020
+/* Don't show field names in SEQUENCE */
+#define ASN1_PCTX_FLAGS_NO_FIELD_NAME 0x040
+/* Show structure names of each SEQUENCE field */
+#define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME 0x080
+/* Don't show structure name even at top level */
+#define ASN1_PCTX_FLAGS_NO_STRUCT_NAME 0x100
+
+int ASN1_item_print(BIO *out, const ASN1_VALUE *ifld, int indent,
+    const ASN1_ITEM *it, const ASN1_PCTX *pctx);
+ASN1_PCTX *ASN1_PCTX_new(void);
+void ASN1_PCTX_free(ASN1_PCTX *p);
+unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags);
+
+ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb)(ASN1_SCTX *ctx));
+void ASN1_SCTX_free(ASN1_SCTX *p);
+const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p);
+const ASN1_TEMPLATE *ASN1_SCTX_get_template(ASN1_SCTX *p);
+unsigned long ASN1_SCTX_get_flags(ASN1_SCTX *p);
+void ASN1_SCTX_set_app_data(ASN1_SCTX *p, void *data);
+void *ASN1_SCTX_get_app_data(ASN1_SCTX *p);
+
+const BIO_METHOD *BIO_f_asn1(void);
+
+/* cannot constify val because of CMS_stream() */
+BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it);
+
+int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
+    const ASN1_ITEM *it);
+int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
+    const char *hdr, const ASN1_ITEM *it);
+/* cannot constify val because of CMS_dataFinal() */
+int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
+    int ctype_nid, int econt_nid,
+    STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it);
+int SMIME_write_ASN1_ex(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
+    int ctype_nid, int econt_nid,
+    STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it,
+    OSSL_LIB_CTX *libctx, const char *propq);
+ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it);
+ASN1_VALUE *SMIME_read_ASN1_ex(BIO *bio, int flags, BIO **bcont,
+    const ASN1_ITEM *it, ASN1_VALUE **x,
+    OSSL_LIB_CTX *libctx, const char *propq);
+int SMIME_crlf_copy(BIO *in, BIO *out, int flags);
+int SMIME_text(BIO *in, BIO *out);
+
+const ASN1_ITEM *ASN1_ITEM_lookup(const char *name);
+const ASN1_ITEM *ASN1_ITEM_get(size_t i);
+
+/* Legacy compatibility */
+#define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name)        \
+    DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)
+#define DECLARE_ASN1_FUNCTIONS_const(type) DECLARE_ASN1_FUNCTIONS(type)
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS(type, name)
+#define I2D_OF_const(type) I2D_OF(type)
+#define ASN1_dup_of_const(type, i2d, d2i, x) ASN1_dup_of(type, i2d, d2i, x)
+#define ASN1_i2d_fp_of_const(type, i2d, out, x) ASN1_i2d_fp_of(type, i2d, out, x)
+#define ASN1_i2d_bio_of_const(type, i2d, out, x) ASN1_i2d_bio_of(type, i2d, out, x)
+
+#ifdef __cplusplus
+}
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/asn1err.h

@@ -0,0 +1,140 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ASN1ERR_H
+#define OPENSSL_ASN1ERR_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
+
+/*
+ * ASN1 reason codes.
+ */
+#define ASN1_R_ADDING_OBJECT 171
+#define ASN1_R_ASN1_PARSE_ERROR 203
+#define ASN1_R_ASN1_SIG_PARSE_ERROR 204
+#define ASN1_R_AUX_ERROR 100
+#define ASN1_R_BAD_OBJECT_HEADER 102
+#define ASN1_R_BAD_TEMPLATE 230
+#define ASN1_R_BMPSTRING_IS_WRONG_LENGTH 214
+#define ASN1_R_BN_LIB 105
+#define ASN1_R_BOOLEAN_IS_WRONG_LENGTH 106
+#define ASN1_R_BUFFER_TOO_SMALL 107
+#define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 108
+#define ASN1_R_CONTEXT_NOT_INITIALISED 217
+#define ASN1_R_DATA_IS_WRONG 109
+#define ASN1_R_DECODE_ERROR 110
+#define ASN1_R_DEPTH_EXCEEDED 174
+#define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED 198
+#define ASN1_R_ENCODE_ERROR 112
+#define ASN1_R_ERROR_GETTING_TIME 173
+#define ASN1_R_ERROR_LOADING_SECTION 172
+#define ASN1_R_ERROR_SETTING_CIPHER_PARAMS 114
+#define ASN1_R_EXPECTING_AN_INTEGER 115
+#define ASN1_R_EXPECTING_AN_OBJECT 116
+#define ASN1_R_EXPLICIT_LENGTH_MISMATCH 119
+#define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED 120
+#define ASN1_R_FIELD_MISSING 121
+#define ASN1_R_FIRST_NUM_TOO_LARGE 122
+#define ASN1_R_GENERALIZEDTIME_IS_TOO_SHORT 232
+#define ASN1_R_HEADER_TOO_LONG 123
+#define ASN1_R_ILLEGAL_BITSTRING_FORMAT 175
+#define ASN1_R_ILLEGAL_BOOLEAN 176
+#define ASN1_R_ILLEGAL_CHARACTERS 124
+#define ASN1_R_ILLEGAL_FORMAT 177
+#define ASN1_R_ILLEGAL_HEX 178
+#define ASN1_R_ILLEGAL_IMPLICIT_TAG 179
+#define ASN1_R_ILLEGAL_INTEGER 180
+#define ASN1_R_ILLEGAL_NEGATIVE_VALUE 226
+#define ASN1_R_ILLEGAL_NESTED_TAGGING 181
+#define ASN1_R_ILLEGAL_NULL 125
+#define ASN1_R_ILLEGAL_NULL_VALUE 182
+#define ASN1_R_ILLEGAL_OBJECT 183
+#define ASN1_R_ILLEGAL_OPTIONAL_ANY 126
+#define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE 170
+#define ASN1_R_ILLEGAL_PADDING 221
+#define ASN1_R_ILLEGAL_TAGGED_ANY 127
+#define ASN1_R_ILLEGAL_TIME_VALUE 184
+#define ASN1_R_ILLEGAL_ZERO_CONTENT 222
+#define ASN1_R_INTEGER_NOT_ASCII_FORMAT 185
+#define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG 128
+#define ASN1_R_INVALID_BIT_STRING_BITS_LEFT 220
+#define ASN1_R_INVALID_BMPSTRING_LENGTH 129
+#define ASN1_R_INVALID_DIGIT 130
+#define ASN1_R_INVALID_MIME_TYPE 205
+#define ASN1_R_INVALID_MODIFIER 186
+#define ASN1_R_INVALID_NUMBER 187
+#define ASN1_R_INVALID_OBJECT_ENCODING 216
+#define ASN1_R_INVALID_SCRYPT_PARAMETERS 227
+#define ASN1_R_INVALID_SEPARATOR 131
+#define ASN1_R_INVALID_STRING_TABLE_VALUE 218
+#define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH 133
+#define ASN1_R_INVALID_UTF8STRING 134
+#define ASN1_R_INVALID_VALUE 219
+#define ASN1_R_LENGTH_TOO_LONG 231
+#define ASN1_R_LIST_ERROR 188
+#define ASN1_R_MIME_NO_CONTENT_TYPE 206
+#define ASN1_R_MIME_PARSE_ERROR 207
+#define ASN1_R_MIME_SIG_PARSE_ERROR 208
+#define ASN1_R_MISSING_EOC 137
+#define ASN1_R_MISSING_SECOND_NUMBER 138
+#define ASN1_R_MISSING_VALUE 189
+#define ASN1_R_MSTRING_NOT_UNIVERSAL 139
+#define ASN1_R_MSTRING_WRONG_TAG 140
+#define ASN1_R_NESTED_ASN1_STRING 197
+#define ASN1_R_NESTED_TOO_DEEP 201
+#define ASN1_R_NON_HEX_CHARACTERS 141
+#define ASN1_R_NOT_ASCII_FORMAT 190
+#define ASN1_R_NOT_ENOUGH_DATA 142
+#define ASN1_R_NO_CONTENT_TYPE 209
+#define ASN1_R_NO_MATCHING_CHOICE_TYPE 143
+#define ASN1_R_NO_MULTIPART_BODY_FAILURE 210
+#define ASN1_R_NO_MULTIPART_BOUNDARY 211
+#define ASN1_R_NO_SIG_CONTENT_TYPE 212
+#define ASN1_R_NULL_IS_WRONG_LENGTH 144
+#define ASN1_R_OBJECT_NOT_ASCII_FORMAT 191
+#define ASN1_R_ODD_NUMBER_OF_CHARS 145
+#define ASN1_R_SECOND_NUMBER_TOO_LARGE 147
+#define ASN1_R_SEQUENCE_LENGTH_MISMATCH 148
+#define ASN1_R_SEQUENCE_NOT_CONSTRUCTED 149
+#define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG 192
+#define ASN1_R_SHORT_LINE 150
+#define ASN1_R_SIG_INVALID_MIME_TYPE 213
+#define ASN1_R_STREAMING_NOT_SUPPORTED 202
+#define ASN1_R_STRING_TOO_LONG 151
+#define ASN1_R_STRING_TOO_SHORT 152
+#define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154
+#define ASN1_R_TIME_NOT_ASCII_FORMAT 193
+#define ASN1_R_TOO_LARGE 223
+#define ASN1_R_TOO_LONG 155
+#define ASN1_R_TOO_SMALL 224
+#define ASN1_R_TYPE_NOT_CONSTRUCTED 156
+#define ASN1_R_TYPE_NOT_PRIMITIVE 195
+#define ASN1_R_UNEXPECTED_EOC 159
+#define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH 215
+#define ASN1_R_UNKNOWN_DIGEST 229
+#define ASN1_R_UNKNOWN_FORMAT 160
+#define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM 161
+#define ASN1_R_UNKNOWN_OBJECT_TYPE 162
+#define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE 163
+#define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM 199
+#define ASN1_R_UNKNOWN_TAG 194
+#define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE 164
+#define ASN1_R_UNSUPPORTED_CIPHER 228
+#define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE 167
+#define ASN1_R_UNSUPPORTED_TYPE 196
+#define ASN1_R_UTCTIME_IS_TOO_SHORT 233
+#define ASN1_R_WRONG_INTEGER_TYPE 225
+#define ASN1_R_WRONG_PUBLIC_KEY_TYPE 200
+#define ASN1_R_WRONG_TAG 168
+
+#endif

miniconda3/envs/active_proaction/include/openssl/asn1t.h

@@ -0,0 +1,935 @@
+/*
+ * WARNING: do not edit!
+ * Generated by Makefile from include/openssl/asn1t.h.in
+ *
+ * Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/* clang-format off */
+
+/* clang-format on */
+
+#ifndef OPENSSL_ASN1T_H
+#define OPENSSL_ASN1T_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_ASN1T_H
+#endif
+
+#include <stddef.h>
+#include <openssl/e_os2.h>
+#include <openssl/asn1.h>
+
+#ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#undef OPENSSL_EXTERN
+#define OPENSSL_EXTERN OPENSSL_EXPORT
+#endif
+
+/* ASN1 template defines, structures and functions */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*-
+ * These are the possible values for the itype field of the
+ * ASN1_ITEM structure and determine how it is interpreted.
+ *
+ * For PRIMITIVE types the underlying type
+ * determines the behaviour if items is NULL.
+ *
+ * Otherwise templates must contain a single
+ * template and the type is treated in the
+ * same way as the type specified in the template.
+ *
+ * For SEQUENCE types the templates field points
+ * to the members, the size field is the
+ * structure size.
+ *
+ * For CHOICE types the templates field points
+ * to each possible member (typically a union)
+ * and the 'size' field is the offset of the
+ * selector.
+ *
+ * The 'funcs' field is used for application-specific
+ * data and functions.
+ *
+ * The EXTERN type uses a new style d2i/i2d.
+ * The new style should be used where possible
+ * because it avoids things like the d2i IMPLICIT
+ * hack.
+ *
+ * MSTRING is a multiple string type, it is used
+ * for a CHOICE of character strings where the
+ * actual strings all occupy an ASN1_STRING
+ * structure. In this case the 'utype' field
+ * has a special meaning, it is used as a mask
+ * of acceptable types using the B_ASN1 constants.
+ *
+ * NDEF_SEQUENCE is the same as SEQUENCE except
+ * that it will use indefinite length constructed
+ * encoding if requested.
+ *
+ */
+
+#define ASN1_ITYPE_PRIMITIVE 0x0
+#define ASN1_ITYPE_SEQUENCE 0x1
+#define ASN1_ITYPE_CHOICE 0x2
+/* unused value                          0x3 */
+#define ASN1_ITYPE_EXTERN 0x4
+#define ASN1_ITYPE_MSTRING 0x5
+#define ASN1_ITYPE_NDEF_SEQUENCE 0x6
+
+/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */
+#define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)((iptr)()))
+
+/* Macros for start and end of ASN1_ITEM definition */
+
+#define ASN1_ITEM_start(itname)        \
+    const ASN1_ITEM *itname##_it(void) \
+    {                                  \
+        static const ASN1_ITEM local_it = {
+
+#define static_ASN1_ITEM_start(itname) \
+    static ASN1_ITEM_start(itname)
+
+#define ASN1_ITEM_end(itname) \
+    }                         \
+    ;                         \
+    return &local_it;         \
+    }
+
+/* Macros to aid ASN1 template writing */
+
+#define ASN1_ITEM_TEMPLATE(tname) \
+    static const ASN1_TEMPLATE tname##_item_tt
+
+#define ASN1_ITEM_TEMPLATE_END(tname) \
+    ;                                 \
+    ASN1_ITEM_start(tname)            \
+        ASN1_ITYPE_PRIMITIVE,         \
+        -1,                           \
+        &tname##_item_tt,             \
+        0,                            \
+        NULL,                         \
+        0,                            \
+        #tname ASN1_ITEM_end(tname)
+#define static_ASN1_ITEM_TEMPLATE_END(tname) \
+    ;                                        \
+    static_ASN1_ITEM_start(tname)            \
+        ASN1_ITYPE_PRIMITIVE,                \
+        -1,                                  \
+        &tname##_item_tt,                    \
+        0,                                   \
+        NULL,                                \
+        0,                                   \
+        #tname ASN1_ITEM_end(tname)
+
+/* This is a ASN1 type which just embeds a template */
+
+/*-
+ * This pair helps declare a SEQUENCE. We can do:
+ *
+ *      ASN1_SEQUENCE(stname) = {
+ *              ... SEQUENCE components ...
+ *      } ASN1_SEQUENCE_END(stname)
+ *
+ *      This will produce an ASN1_ITEM called stname_it
+ *      for a structure called stname.
+ *
+ *      If you want the same structure but a different
+ *      name then use:
+ *
+ *      ASN1_SEQUENCE(itname) = {
+ *              ... SEQUENCE components ...
+ *      } ASN1_SEQUENCE_END_name(stname, itname)
+ *
+ *      This will create an item called itname_it using
+ *      a structure called stname.
+ */
+
+#define ASN1_SEQUENCE(tname) \
+    static const ASN1_TEMPLATE tname##_seq_tt[]
+
+#define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname)
+
+#define static_ASN1_SEQUENCE_END(stname) static_ASN1_SEQUENCE_END_name(stname, stname)
+
+#define ASN1_SEQUENCE_END_name(stname, tname)           \
+    ;                                                   \
+    ASN1_ITEM_start(tname)                              \
+        ASN1_ITYPE_SEQUENCE,                            \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        NULL,                                           \
+        sizeof(stname),                                 \
+        #tname ASN1_ITEM_end(tname)
+
+#define static_ASN1_SEQUENCE_END_name(stname, tname)    \
+    ;                                                   \
+    static_ASN1_ITEM_start(tname)                       \
+        ASN1_ITYPE_SEQUENCE,                            \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        NULL,                                           \
+        sizeof(stname),                                 \
+        #stname ASN1_ITEM_end(tname)
+
+#define ASN1_NDEF_SEQUENCE(tname) \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_NDEF_SEQUENCE_cb(tname, cb) \
+    ASN1_SEQUENCE_cb(tname, cb)
+
+#define ASN1_SEQUENCE_cb(tname, cb)                                     \
+    static const ASN1_AUX tname##_aux = { NULL, 0, 0, 0, cb, 0, NULL }; \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_SEQUENCE_const_cb(tname, const_cb)                                                \
+    static const ASN1_AUX tname##_aux = { NULL, ASN1_AFLG_CONST_CB, 0, 0, NULL, 0, const_cb }; \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_SEQUENCE_cb_const_cb(tname, cb, const_cb)                                       \
+    static const ASN1_AUX tname##_aux = { NULL, ASN1_AFLG_CONST_CB, 0, 0, cb, 0, const_cb }; \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_SEQUENCE_ref(tname, cb)                                                                                                   \
+    static const ASN1_AUX tname##_aux = { NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), offsetof(tname, lock), cb, 0, NULL }; \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_SEQUENCE_enc(tname, enc, cb)                                                                   \
+    static const ASN1_AUX tname##_aux = { NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc), NULL }; \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_NDEF_SEQUENCE_END(tname)                   \
+    ;                                                   \
+    ASN1_ITEM_start(tname)                              \
+        ASN1_ITYPE_NDEF_SEQUENCE,                       \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        NULL,                                           \
+        sizeof(tname),                                  \
+        #tname ASN1_ITEM_end(tname)
+#define static_ASN1_NDEF_SEQUENCE_END(tname)            \
+    ;                                                   \
+    static_ASN1_ITEM_start(tname)                       \
+        ASN1_ITYPE_NDEF_SEQUENCE,                       \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        NULL,                                           \
+        sizeof(tname),                                  \
+        #tname ASN1_ITEM_end(tname)
+
+#define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
+
+#define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
+#define static_ASN1_SEQUENCE_END_cb(stname, tname) static_ASN1_SEQUENCE_END_ref(stname, tname)
+
+#define ASN1_SEQUENCE_END_ref(stname, tname)            \
+    ;                                                   \
+    ASN1_ITEM_start(tname)                              \
+        ASN1_ITYPE_SEQUENCE,                            \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        &tname##_aux,                                   \
+        sizeof(stname),                                 \
+        #tname ASN1_ITEM_end(tname)
+#define static_ASN1_SEQUENCE_END_ref(stname, tname)     \
+    ;                                                   \
+    static_ASN1_ITEM_start(tname)                       \
+        ASN1_ITYPE_SEQUENCE,                            \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        &tname##_aux,                                   \
+        sizeof(stname),                                 \
+        #stname ASN1_ITEM_end(tname)
+
+#define ASN1_NDEF_SEQUENCE_END_cb(stname, tname)        \
+    ;                                                   \
+    ASN1_ITEM_start(tname)                              \
+        ASN1_ITYPE_NDEF_SEQUENCE,                       \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        &tname##_aux,                                   \
+        sizeof(stname),                                 \
+        #stname ASN1_ITEM_end(tname)
+
+/*-
+ * This pair helps declare a CHOICE type. We can do:
+ *
+ *      ASN1_CHOICE(chname) = {
+ *              ... CHOICE options ...
+ *      ASN1_CHOICE_END(chname)
+ *
+ *      This will produce an ASN1_ITEM called chname_it
+ *      for a structure called chname. The structure
+ *      definition must look like this:
+ *      typedef struct {
+ *              int type;
+ *              union {
+ *                      ASN1_SOMETHING *opt1;
+ *                      ASN1_SOMEOTHER *opt2;
+ *              } value;
+ *      } chname;
+ *
+ *      the name of the selector must be 'type'.
+ *      to use an alternative selector name use the
+ *      ASN1_CHOICE_END_selector() version.
+ */
+
+#define ASN1_CHOICE(tname) \
+    static const ASN1_TEMPLATE tname##_ch_tt[]
+
+#define ASN1_CHOICE_cb(tname, cb)                                       \
+    static const ASN1_AUX tname##_aux = { NULL, 0, 0, 0, cb, 0, NULL }; \
+    ASN1_CHOICE(tname)
+
+#define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname)
+
+#define static_ASN1_CHOICE_END(stname) static_ASN1_CHOICE_END_name(stname, stname)
+
+#define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type)
+
+#define static_ASN1_CHOICE_END_name(stname, tname) static_ASN1_CHOICE_END_selector(stname, tname, type)
+
+#define ASN1_CHOICE_END_selector(stname, tname, selname) \
+    ;                                                    \
+    ASN1_ITEM_start(tname)                               \
+        ASN1_ITYPE_CHOICE,                               \
+        offsetof(stname, selname),                       \
+        tname##_ch_tt,                                   \
+        sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),   \
+        NULL,                                            \
+        sizeof(stname),                                  \
+        #stname ASN1_ITEM_end(tname)
+
+#define static_ASN1_CHOICE_END_selector(stname, tname, selname) \
+    ;                                                           \
+    static_ASN1_ITEM_start(tname)                               \
+        ASN1_ITYPE_CHOICE,                                      \
+        offsetof(stname, selname),                              \
+        tname##_ch_tt,                                          \
+        sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),          \
+        NULL,                                                   \
+        sizeof(stname),                                         \
+        #stname ASN1_ITEM_end(tname)
+
+#define ASN1_CHOICE_END_cb(stname, tname, selname)     \
+    ;                                                  \
+    ASN1_ITEM_start(tname)                             \
+        ASN1_ITYPE_CHOICE,                             \
+        offsetof(stname, selname),                     \
+        tname##_ch_tt,                                 \
+        sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE), \
+        &tname##_aux,                                  \
+        sizeof(stname),                                \
+        #stname ASN1_ITEM_end(tname)
+
+/* This helps with the template wrapper form of ASN1_ITEM */
+
+#define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \
+    (flags), (tag), 0,                                  \
+    #name, ASN1_ITEM_ref(type)                          \
+}
+
+/* These help with SEQUENCE or CHOICE components */
+
+/* used to declare other types */
+
+#define ASN1_EX_TYPE(flags, tag, stname, field, type) { \
+    (flags), (tag), offsetof(stname, field),            \
+    #field, ASN1_ITEM_ref(type)                         \
+}
+
+/* implicit and explicit helper macros */
+
+#define ASN1_IMP_EX(stname, field, type, tag, ex) \
+    ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | (ex), tag, stname, field, type)
+
+#define ASN1_EXP_EX(stname, field, type, tag, ex) \
+    ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | (ex), tag, stname, field, type)
+
+/* Any defined by macros: the field used is in the table itself */
+
+#define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb }
+#define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb }
+
+/* Plain simple type */
+#define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0, 0, stname, field, type)
+/* Embedded simple type */
+#define ASN1_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_EMBED, 0, stname, field, type)
+
+/* OPTIONAL simple type */
+#define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+#define ASN1_OPT_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL | ASN1_TFLG_EMBED, 0, stname, field, type)
+
+/* IMPLICIT tagged simple type */
+#define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0)
+#define ASN1_IMP_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_EMBED)
+
+/* IMPLICIT tagged OPTIONAL simple type */
+#define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
+#define ASN1_IMP_OPT_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL | ASN1_TFLG_EMBED)
+
+/* Same as above but EXPLICIT */
+
+#define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0)
+#define ASN1_EXP_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_EMBED)
+#define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
+#define ASN1_EXP_OPT_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL | ASN1_TFLG_EMBED)
+
+/* SEQUENCE OF type */
+#define ASN1_SEQUENCE_OF(stname, field, type) \
+    ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type)
+
+/* OPTIONAL SEQUENCE OF */
+#define ASN1_SEQUENCE_OF_OPT(stname, field, type) \
+    ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+
+/* Same as above but for SET OF */
+
+#define ASN1_SET_OF(stname, field, type) \
+    ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type)
+
+#define ASN1_SET_OF_OPT(stname, field, type) \
+    ASN1_EX_TYPE(ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+
+/* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */
+
+#define ASN1_IMP_SET_OF(stname, field, type, tag) \
+    ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
+
+#define ASN1_EXP_SET_OF(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
+
+#define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \
+    ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL)
+
+#define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL)
+
+#define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \
+    ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
+
+#define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \
+    ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL)
+
+#define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
+
+#define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL)
+
+/* EXPLICIT using indefinite length constructed form */
+#define ASN1_NDEF_EXP(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF)
+
+/* EXPLICIT OPTIONAL using indefinite length constructed form */
+#define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL | ASN1_TFLG_NDEF)
+
+/* Macros for the ASN1_ADB structure */
+
+#define ASN1_ADB(name) \
+    static const ASN1_ADB_TABLE name##_adbtbl[]
+
+#define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \
+    ;                                                       \
+    static const ASN1_ITEM *name##_adb(void)                \
+    {                                                       \
+        static const ASN1_ADB internal_adb = {              \
+            flags,                                          \
+            offsetof(name, field),                          \
+            adb_cb,                                         \
+            name##_adbtbl,                                  \
+            sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE), \
+            def,                                            \
+            none                                            \
+        };                                                  \
+        return (const ASN1_ITEM *)&internal_adb;            \
+    }                                                       \
+    void dummy_function(void)
+
+#define ADB_ENTRY(val, template) { val, template }
+
+#define ASN1_ADB_TEMPLATE(name) \
+    static const ASN1_TEMPLATE name##_tt
+
+/*
+ * This is the ASN1 template structure that defines a wrapper round the
+ * actual type. It determines the actual position of the field in the value
+ * structure, various flags such as OPTIONAL and the field name.
+ */
+
+struct ASN1_TEMPLATE_st {
+    unsigned long flags; /* Various flags */
+    long tag; /* tag, not used if no tagging */
+    unsigned long offset; /* Offset of this field in structure */
+    const char *field_name; /* Field name */
+    ASN1_ITEM_EXP *item; /* Relevant ASN1_ITEM or ASN1_ADB */
+};
+
+/* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */
+
+#define ASN1_TEMPLATE_item(t) (t->item_ptr)
+#define ASN1_TEMPLATE_adb(t) (t->item_ptr)
+
+typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE;
+typedef struct ASN1_ADB_st ASN1_ADB;
+
+struct ASN1_ADB_st {
+    unsigned long flags; /* Various flags */
+    unsigned long offset; /* Offset of selector field */
+    int (*adb_cb)(long *psel); /* Application callback */
+    const ASN1_ADB_TABLE *tbl; /* Table of possible types */
+    long tblcount; /* Number of entries in tbl */
+    const ASN1_TEMPLATE *default_tt; /* Type to use if no match */
+    const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */
+};
+
+struct ASN1_ADB_TABLE_st {
+    long value; /* NID for an object or value for an int */
+    const ASN1_TEMPLATE tt; /* item for this value */
+};
+
+/* template flags */
+
+/* Field is optional */
+#define ASN1_TFLG_OPTIONAL (0x1)
+
+/* Field is a SET OF */
+#define ASN1_TFLG_SET_OF (0x1 << 1)
+
+/* Field is a SEQUENCE OF */
+#define ASN1_TFLG_SEQUENCE_OF (0x2 << 1)
+
+/*
+ * Special case: this refers to a SET OF that will be sorted into DER order
+ * when encoded *and* the corresponding STACK will be modified to match the
+ * new order.
+ */
+#define ASN1_TFLG_SET_ORDER (0x3 << 1)
+
+/* Mask for SET OF or SEQUENCE OF */
+#define ASN1_TFLG_SK_MASK (0x3 << 1)
+
+/*
+ * These flags mean the tag should be taken from the tag field. If EXPLICIT
+ * then the underlying type is used for the inner tag.
+ */
+
+/* IMPLICIT tagging */
+#define ASN1_TFLG_IMPTAG (0x1 << 3)
+
+/* EXPLICIT tagging, inner tag from underlying type */
+#define ASN1_TFLG_EXPTAG (0x2 << 3)
+
+#define ASN1_TFLG_TAG_MASK (0x3 << 3)
+
+/* context specific IMPLICIT */
+#define ASN1_TFLG_IMPLICIT (ASN1_TFLG_IMPTAG | ASN1_TFLG_CONTEXT)
+
+/* context specific EXPLICIT */
+#define ASN1_TFLG_EXPLICIT (ASN1_TFLG_EXPTAG | ASN1_TFLG_CONTEXT)
+
+/*
+ * If tagging is in force these determine the type of tag to use. Otherwise
+ * the tag is determined by the underlying type. These values reflect the
+ * actual octet format.
+ */
+
+/* Universal tag */
+#define ASN1_TFLG_UNIVERSAL (0x0 << 6)
+/* Application tag */
+#define ASN1_TFLG_APPLICATION (0x1 << 6)
+/* Context specific tag */
+#define ASN1_TFLG_CONTEXT (0x2 << 6)
+/* Private tag */
+#define ASN1_TFLG_PRIVATE (0x3 << 6)
+
+#define ASN1_TFLG_TAG_CLASS (0x3 << 6)
+
+/*
+ * These are for ANY DEFINED BY type. In this case the 'item' field points to
+ * an ASN1_ADB structure which contains a table of values to decode the
+ * relevant type
+ */
+
+#define ASN1_TFLG_ADB_MASK (0x3 << 8)
+
+#define ASN1_TFLG_ADB_OID (0x1 << 8)
+
+#define ASN1_TFLG_ADB_INT (0x1 << 9)
+
+/*
+ * This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes
+ * indefinite length constructed encoding to be used if required.
+ */
+
+#define ASN1_TFLG_NDEF (0x1 << 11)
+
+/* Field is embedded and not a pointer */
+#define ASN1_TFLG_EMBED (0x1 << 12)
+
+/* This is the actual ASN1 item itself */
+
+struct ASN1_ITEM_st {
+    char itype; /* The item type, primitive, SEQUENCE, CHOICE
+                 * or extern */
+    long utype; /* underlying type */
+    const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains
+                                     * the contents */
+    long tcount; /* Number of templates if SEQUENCE or CHOICE */
+    const void *funcs; /* further data and type-specific functions */
+    /* funcs can be ASN1_PRIMITIVE_FUNCS*, ASN1_EXTERN_FUNCS*, or ASN1_AUX* */
+    long size; /* Structure size (usually) */
+    const char *sname; /* Structure name */
+};
+
+/*
+ * Cache for ASN1 tag and length, so we don't keep re-reading it for things
+ * like CHOICE
+ */
+
+struct ASN1_TLC_st {
+    char valid; /* Values below are valid */
+    int ret; /* return value */
+    long plen; /* length */
+    int ptag; /* class value */
+    int pclass; /* class value */
+    int hdrlen; /* header length */
+};
+
+/* Typedefs for ASN1 function pointers */
+typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
+    const ASN1_ITEM *it, int tag, int aclass, char opt,
+    ASN1_TLC *ctx);
+
+typedef int ASN1_ex_d2i_ex(ASN1_VALUE **pval, const unsigned char **in, long len,
+    const ASN1_ITEM *it, int tag, int aclass, char opt,
+    ASN1_TLC *ctx, OSSL_LIB_CTX *libctx,
+    const char *propq);
+typedef int ASN1_ex_i2d(const ASN1_VALUE **pval, unsigned char **out,
+    const ASN1_ITEM *it, int tag, int aclass);
+typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
+typedef int ASN1_ex_new_ex_func(ASN1_VALUE **pval, const ASN1_ITEM *it,
+    OSSL_LIB_CTX *libctx, const char *propq);
+typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
+
+typedef int ASN1_ex_print_func(BIO *out, const ASN1_VALUE **pval,
+    int indent, const char *fname,
+    const ASN1_PCTX *pctx);
+
+typedef int ASN1_primitive_i2c(const ASN1_VALUE **pval, unsigned char *cont,
+    int *putype, const ASN1_ITEM *it);
+typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont,
+    int len, int utype, char *free_cont,
+    const ASN1_ITEM *it);
+typedef int ASN1_primitive_print(BIO *out, const ASN1_VALUE **pval,
+    const ASN1_ITEM *it, int indent,
+    const ASN1_PCTX *pctx);
+
+typedef struct ASN1_EXTERN_FUNCS_st {
+    void *app_data;
+    ASN1_ex_new_func *asn1_ex_new;
+    ASN1_ex_free_func *asn1_ex_free;
+    ASN1_ex_free_func *asn1_ex_clear;
+    ASN1_ex_d2i *asn1_ex_d2i;
+    ASN1_ex_i2d *asn1_ex_i2d;
+    ASN1_ex_print_func *asn1_ex_print;
+    ASN1_ex_new_ex_func *asn1_ex_new_ex;
+    ASN1_ex_d2i_ex *asn1_ex_d2i_ex;
+} ASN1_EXTERN_FUNCS;
+
+typedef struct ASN1_PRIMITIVE_FUNCS_st {
+    void *app_data;
+    unsigned long flags;
+    ASN1_ex_new_func *prim_new;
+    ASN1_ex_free_func *prim_free;
+    ASN1_ex_free_func *prim_clear;
+    ASN1_primitive_c2i *prim_c2i;
+    ASN1_primitive_i2c *prim_i2c;
+    ASN1_primitive_print *prim_print;
+} ASN1_PRIMITIVE_FUNCS;
+
+/*
+ * This is the ASN1_AUX structure: it handles various miscellaneous
+ * requirements. For example the use of reference counts and an informational
+ * callback. The "informational callback" is called at various points during
+ * the ASN1 encoding and decoding. It can be used to provide minor
+ * customisation of the structures used. This is most useful where the
+ * supplied routines *almost* do the right thing but need some extra help at
+ * a few points. If the callback returns zero then it is assumed a fatal
+ * error has occurred and the main operation should be abandoned. If major
+ * changes in the default behaviour are required then an external type is
+ * more appropriate.
+ * For the operations ASN1_OP_I2D_PRE, ASN1_OP_I2D_POST, ASN1_OP_PRINT_PRE, and
+ * ASN1_OP_PRINT_POST, meanwhile a variant of the callback with const parameter
+ * 'in' is provided to make clear statically that its input is not modified. If
+ * and only if this variant is in use the flag ASN1_AFLG_CONST_CB must be set.
+ */
+
+typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it,
+    void *exarg);
+typedef int ASN1_aux_const_cb(int operation, const ASN1_VALUE **in,
+    const ASN1_ITEM *it, void *exarg);
+
+typedef struct ASN1_AUX_st {
+    void *app_data;
+    int flags;
+    int ref_offset; /* Offset of reference value */
+    int ref_lock; /* Offset of lock value */
+    ASN1_aux_cb *asn1_cb;
+    int enc_offset; /* Offset of ASN1_ENCODING structure */
+    ASN1_aux_const_cb *asn1_const_cb; /* for ASN1_OP_I2D_ and ASN1_OP_PRINT_ */
+} ASN1_AUX;
+
+/* For print related callbacks exarg points to this structure */
+typedef struct ASN1_PRINT_ARG_st {
+    BIO *out;
+    int indent;
+    const ASN1_PCTX *pctx;
+} ASN1_PRINT_ARG;
+
+/* For streaming related callbacks exarg points to this structure */
+typedef struct ASN1_STREAM_ARG_st {
+    /* BIO to stream through */
+    BIO *out;
+    /* BIO with filters appended */
+    BIO *ndef_bio;
+    /* Streaming I/O boundary */
+    unsigned char **boundary;
+} ASN1_STREAM_ARG;
+
+/* Flags in ASN1_AUX */
+
+/* Use a reference count */
+#define ASN1_AFLG_REFCOUNT 1
+/* Save the encoding of structure (useful for signatures) */
+#define ASN1_AFLG_ENCODING 2
+/* The Sequence length is invalid */
+#define ASN1_AFLG_BROKEN 4
+/* Use the new asn1_const_cb */
+#define ASN1_AFLG_CONST_CB 8
+
+/* operation values for asn1_cb */
+
+#define ASN1_OP_NEW_PRE 0
+#define ASN1_OP_NEW_POST 1
+#define ASN1_OP_FREE_PRE 2
+#define ASN1_OP_FREE_POST 3
+#define ASN1_OP_D2I_PRE 4
+#define ASN1_OP_D2I_POST 5
+#define ASN1_OP_I2D_PRE 6
+#define ASN1_OP_I2D_POST 7
+#define ASN1_OP_PRINT_PRE 8
+#define ASN1_OP_PRINT_POST 9
+#define ASN1_OP_STREAM_PRE 10
+#define ASN1_OP_STREAM_POST 11
+#define ASN1_OP_DETACHED_PRE 12
+#define ASN1_OP_DETACHED_POST 13
+#define ASN1_OP_DUP_PRE 14
+#define ASN1_OP_DUP_POST 15
+#define ASN1_OP_GET0_LIBCTX 16
+#define ASN1_OP_GET0_PROPQ 17
+
+/* Macro to implement a primitive type */
+#define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0)
+#define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \
+    ASN1_ITEM_start(itname)                       \
+        ASN1_ITYPE_PRIMITIVE,                     \
+        V_##vname, NULL, 0, NULL, ex, #itname ASN1_ITEM_end(itname)
+
+/* Macro to implement a multi string type */
+#define IMPLEMENT_ASN1_MSTRING(itname, mask) \
+    ASN1_ITEM_start(itname)                  \
+        ASN1_ITYPE_MSTRING,                  \
+        mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname ASN1_ITEM_end(itname)
+
+#define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \
+    ASN1_ITEM_start(sname)                       \
+        ASN1_ITYPE_EXTERN,                       \
+        tag,                                     \
+        NULL,                                    \
+        0,                                       \
+        &fptrs,                                  \
+        0,                                       \
+        #sname ASN1_ITEM_end(sname)
+
+/* Macro to implement standard functions in terms of ASN1_ITEM structures */
+
+#define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname)
+
+#define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname)
+
+#define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \
+    IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname)
+
+#define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \
+    IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname)
+
+#define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \
+    IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname)
+
+#define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \
+    pre stname *fname##_new(void)                                         \
+    {                                                                     \
+        return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname));           \
+    }                                                                     \
+    pre void fname##_free(stname *a)                                      \
+    {                                                                     \
+        ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname));          \
+    }
+
+#define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
+    stname *fname##_new(void)                                       \
+    {                                                               \
+        return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname));     \
+    }                                                               \
+    void fname##_free(stname *a)                                    \
+    {                                                               \
+        ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname));    \
+    }
+
+#define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname)    \
+    IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
+    IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
+
+#define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname)                       \
+    stname *d2i_##fname(stname **a, const unsigned char **in, long len)                    \
+    {                                                                                      \
+        return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname)); \
+    }                                                                                      \
+    int i2d_##fname(const stname *a, unsigned char **out)                                  \
+    {                                                                                      \
+        return ASN1_item_i2d((const ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));          \
+    }
+
+#define IMPLEMENT_ASN1_NDEF_FUNCTION(stname)                                           \
+    int i2d_##stname##_NDEF(const stname *a, unsigned char **out)                      \
+    {                                                                                  \
+        return ASN1_item_ndef_i2d((const ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname)); \
+    }
+
+#define IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(stname)            \
+    static stname *d2i_##stname(stname **a,                       \
+        const unsigned char **in, long len)                       \
+    {                                                             \
+        return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, \
+            ASN1_ITEM_rptr(stname));                              \
+    }                                                             \
+    static int i2d_##stname(const stname *a, unsigned char **out) \
+    {                                                             \
+        return ASN1_item_i2d((const ASN1_VALUE *)a, out,          \
+            ASN1_ITEM_rptr(stname));                              \
+    }
+
+#define IMPLEMENT_ASN1_DUP_FUNCTION(stname)              \
+    stname *stname##_dup(const stname *x)                \
+    {                                                    \
+        return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \
+    }
+
+#define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \
+    IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname)
+
+#define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \
+    int fname##_print_ctx(BIO *out, const stname *x, int indent,   \
+        const ASN1_PCTX *pctx)                                     \
+    {                                                              \
+        return ASN1_item_print(out, (const ASN1_VALUE *)x, indent, \
+            ASN1_ITEM_rptr(itname), pctx);                         \
+    }
+
+/* external definitions for primitive types */
+
+DECLARE_ASN1_ITEM(ASN1_BOOLEAN)
+DECLARE_ASN1_ITEM(ASN1_TBOOLEAN)
+DECLARE_ASN1_ITEM(ASN1_FBOOLEAN)
+DECLARE_ASN1_ITEM(ASN1_SEQUENCE)
+DECLARE_ASN1_ITEM(CBIGNUM)
+DECLARE_ASN1_ITEM(BIGNUM)
+DECLARE_ASN1_ITEM(INT32)
+DECLARE_ASN1_ITEM(ZINT32)
+DECLARE_ASN1_ITEM(UINT32)
+DECLARE_ASN1_ITEM(ZUINT32)
+DECLARE_ASN1_ITEM(INT64)
+DECLARE_ASN1_ITEM(ZINT64)
+DECLARE_ASN1_ITEM(UINT64)
+DECLARE_ASN1_ITEM(ZUINT64)
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * LONG and ZLONG are strongly discouraged for use as stored data, as the
+ * underlying C type (long) differs in size depending on the architecture.
+ * They are designed with 32-bit longs in mind.
+ */
+DECLARE_ASN1_ITEM(LONG)
+DECLARE_ASN1_ITEM(ZLONG)
+#endif
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_VALUE, ASN1_VALUE, ASN1_VALUE)
+#define sk_ASN1_VALUE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_value(sk, idx) ((ASN1_VALUE *)OPENSSL_sk_value(ossl_check_const_ASN1_VALUE_sk_type(sk), (idx)))
+#define sk_ASN1_VALUE_new(cmp) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new(ossl_check_ASN1_VALUE_compfunc_type(cmp)))
+#define sk_ASN1_VALUE_new_null() ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new_null())
+#define sk_ASN1_VALUE_new_reserve(cmp, n) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_VALUE_compfunc_type(cmp), (n)))
+#define sk_ASN1_VALUE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_VALUE_sk_type(sk), (n))
+#define sk_ASN1_VALUE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_delete(sk, i) ((ASN1_VALUE *)OPENSSL_sk_delete(ossl_check_ASN1_VALUE_sk_type(sk), (i)))
+#define sk_ASN1_VALUE_delete_ptr(sk, ptr) ((ASN1_VALUE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr)))
+#define sk_ASN1_VALUE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_pop(sk) ((ASN1_VALUE *)OPENSSL_sk_pop(ossl_check_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_shift(sk) ((ASN1_VALUE *)OPENSSL_sk_shift(ossl_check_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_VALUE_sk_type(sk),ossl_check_ASN1_VALUE_freefunc_type(freefunc))
+#define sk_ASN1_VALUE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr), (idx))
+#define sk_ASN1_VALUE_set(sk, idx, ptr) ((ASN1_VALUE *)OPENSSL_sk_set(ossl_check_ASN1_VALUE_sk_type(sk), (idx), ossl_check_ASN1_VALUE_type(ptr)))
+#define sk_ASN1_VALUE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr), pnum)
+#define sk_ASN1_VALUE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_dup(sk) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_copyfunc_type(copyfunc), ossl_check_ASN1_VALUE_freefunc_type(freefunc)))
+#define sk_ASN1_VALUE_set_cmp_func(sk, cmp) ((sk_ASN1_VALUE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_compfunc_type(cmp)))
+
+/* clang-format on */
+
+/* Functions used internally by the ASN1 code */
+
+int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
+void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
+
+int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
+    const ASN1_ITEM *it, int tag, int aclass, char opt,
+    ASN1_TLC *ctx);
+
+int ASN1_item_ex_i2d(const ASN1_VALUE **pval, unsigned char **out,
+    const ASN1_ITEM *it, int tag, int aclass);
+
+/* Legacy compatibility */
+#define IMPLEMENT_ASN1_FUNCTIONS_const(name) IMPLEMENT_ASN1_FUNCTIONS(name)
+#define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
+    IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname)
+
+#ifdef __cplusplus
+}
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/async.h

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2015-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <stdlib.h>
+
+#ifndef OPENSSL_ASYNC_H
+#define OPENSSL_ASYNC_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_ASYNC_H
+#endif
+
+#if defined(_WIN32)
+#if defined(BASETYPES) || defined(_WINDEF_H)
+/* application has to include <windows.h> to use this */
+#define OSSL_ASYNC_FD HANDLE
+#define OSSL_BAD_ASYNC_FD INVALID_HANDLE_VALUE
+#endif
+#else
+#define OSSL_ASYNC_FD int
+#define OSSL_BAD_ASYNC_FD -1
+#endif
+#include <openssl/asyncerr.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct async_job_st ASYNC_JOB;
+typedef struct async_wait_ctx_st ASYNC_WAIT_CTX;
+typedef int (*ASYNC_callback_fn)(void *arg);
+
+#define ASYNC_ERR 0
+#define ASYNC_NO_JOBS 1
+#define ASYNC_PAUSE 2
+#define ASYNC_FINISH 3
+
+#define ASYNC_STATUS_UNSUPPORTED 0
+#define ASYNC_STATUS_ERR 1
+#define ASYNC_STATUS_OK 2
+#define ASYNC_STATUS_EAGAIN 3
+
+int ASYNC_init_thread(size_t max_size, size_t init_size);
+void ASYNC_cleanup_thread(void);
+
+#ifdef OSSL_ASYNC_FD
+ASYNC_WAIT_CTX *ASYNC_WAIT_CTX_new(void);
+void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX *ctx);
+int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX *ctx, const void *key,
+    OSSL_ASYNC_FD fd,
+    void *custom_data,
+    void (*cleanup)(ASYNC_WAIT_CTX *, const void *,
+        OSSL_ASYNC_FD, void *));
+int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX *ctx, const void *key,
+    OSSL_ASYNC_FD *fd, void **custom_data);
+int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *fd,
+    size_t *numfds);
+int ASYNC_WAIT_CTX_get_callback(ASYNC_WAIT_CTX *ctx,
+    ASYNC_callback_fn *callback,
+    void **callback_arg);
+int ASYNC_WAIT_CTX_set_callback(ASYNC_WAIT_CTX *ctx,
+    ASYNC_callback_fn callback,
+    void *callback_arg);
+int ASYNC_WAIT_CTX_set_status(ASYNC_WAIT_CTX *ctx, int status);
+int ASYNC_WAIT_CTX_get_status(ASYNC_WAIT_CTX *ctx);
+int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *addfd,
+    size_t *numaddfds, OSSL_ASYNC_FD *delfd,
+    size_t *numdelfds);
+int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX *ctx, const void *key);
+#endif
+
+int ASYNC_is_capable(void);
+
+typedef void *(*ASYNC_stack_alloc_fn)(size_t *num);
+typedef void (*ASYNC_stack_free_fn)(void *addr);
+
+int ASYNC_set_mem_functions(ASYNC_stack_alloc_fn alloc_fn,
+    ASYNC_stack_free_fn free_fn);
+void ASYNC_get_mem_functions(ASYNC_stack_alloc_fn *alloc_fn,
+    ASYNC_stack_free_fn *free_fn);
+
+int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *ctx, int *ret,
+    int (*func)(void *), void *args, size_t size);
+int ASYNC_pause_job(void);
+
+ASYNC_JOB *ASYNC_get_current_job(void);
+ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job);
+void ASYNC_block_pause(void);
+void ASYNC_unblock_pause(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/asyncerr.h

@@ -0,0 +1,27 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ASYNCERR_H
+#define OPENSSL_ASYNCERR_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
+
+/*
+ * ASYNC reason codes.
+ */
+#define ASYNC_R_FAILED_TO_SET_POOL 101
+#define ASYNC_R_FAILED_TO_SWAP_CONTEXT 102
+#define ASYNC_R_INIT_FAILED 105
+#define ASYNC_R_INVALID_POOL_SIZE 103
+
+#endif

miniconda3/envs/active_proaction/include/openssl/bio.h

@@ -0,0 +1,1028 @@
+/*
+ * WARNING: do not edit!
+ * Generated by Makefile from include/openssl/bio.h.in
+ *
+ * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+/* clang-format off */
+
+/* clang-format on */
+
+#ifndef OPENSSL_BIO_H
+#define OPENSSL_BIO_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_BIO_H
+#endif
+
+#include <openssl/e_os2.h>
+
+#ifndef OPENSSL_NO_STDIO
+#include <stdio.h>
+#endif
+#include <stdarg.h>
+
+#include <openssl/crypto.h>
+#include <openssl/bioerr.h>
+#include <openssl/core.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* There are the classes of BIOs */
+#define BIO_TYPE_DESCRIPTOR 0x0100 /* socket, fd, connect or accept */
+#define BIO_TYPE_FILTER 0x0200
+#define BIO_TYPE_SOURCE_SINK 0x0400
+
+/* These are the 'types' of BIOs */
+#define BIO_TYPE_NONE 0
+#define BIO_TYPE_MEM (1 | BIO_TYPE_SOURCE_SINK)
+#define BIO_TYPE_FILE (2 | BIO_TYPE_SOURCE_SINK)
+
+#define BIO_TYPE_FD (4 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+#define BIO_TYPE_SOCKET (5 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+#define BIO_TYPE_NULL (6 | BIO_TYPE_SOURCE_SINK)
+#define BIO_TYPE_SSL (7 | BIO_TYPE_FILTER)
+#define BIO_TYPE_MD (8 | BIO_TYPE_FILTER)
+#define BIO_TYPE_BUFFER (9 | BIO_TYPE_FILTER)
+#define BIO_TYPE_CIPHER (10 | BIO_TYPE_FILTER)
+#define BIO_TYPE_BASE64 (11 | BIO_TYPE_FILTER)
+#define BIO_TYPE_CONNECT (12 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+#define BIO_TYPE_ACCEPT (13 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+
+#define BIO_TYPE_NBIO_TEST (16 | BIO_TYPE_FILTER) /* server proxy BIO */
+#define BIO_TYPE_NULL_FILTER (17 | BIO_TYPE_FILTER)
+#define BIO_TYPE_BIO (19 | BIO_TYPE_SOURCE_SINK) /* half a BIO pair */
+#define BIO_TYPE_LINEBUFFER (20 | BIO_TYPE_FILTER)
+#define BIO_TYPE_DGRAM (21 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+#define BIO_TYPE_ASN1 (22 | BIO_TYPE_FILTER)
+#define BIO_TYPE_COMP (23 | BIO_TYPE_FILTER)
+#ifndef OPENSSL_NO_SCTP
+#define BIO_TYPE_DGRAM_SCTP (24 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+#endif
+#define BIO_TYPE_CORE_TO_PROV (25 | BIO_TYPE_SOURCE_SINK)
+#define BIO_TYPE_DGRAM_PAIR (26 | BIO_TYPE_SOURCE_SINK)
+#define BIO_TYPE_DGRAM_MEM (27 | BIO_TYPE_SOURCE_SINK)
+
+/* Custom type starting index returned by BIO_get_new_index() */
+#define BIO_TYPE_START 128
+/* Custom type maximum index that can be returned by BIO_get_new_index() */
+#define BIO_TYPE_MASK 0xFF
+
+/*
+ * BIO_FILENAME_READ|BIO_CLOSE to open or close on free.
+ * BIO_set_fp(in,stdin,BIO_NOCLOSE);
+ */
+#define BIO_NOCLOSE 0x00
+#define BIO_CLOSE 0x01
+
+/*
+ * These are used in the following macros and are passed to BIO_ctrl()
+ */
+#define BIO_CTRL_RESET 1 /* opt - rewind/zero etc */
+#define BIO_CTRL_EOF 2 /* opt - are we at the eof */
+#define BIO_CTRL_INFO 3 /* opt - extra tit-bits */
+#define BIO_CTRL_SET 4 /* man - set the 'IO' type */
+#define BIO_CTRL_GET 5 /* man - get the 'IO' type */
+#define BIO_CTRL_PUSH 6 /* opt - internal, used to signify change */
+#define BIO_CTRL_POP 7 /* opt - internal, used to signify change */
+#define BIO_CTRL_GET_CLOSE 8 /* man - set the 'close' on free */
+#define BIO_CTRL_SET_CLOSE 9 /* man - set the 'close' on free */
+#define BIO_CTRL_PENDING 10 /* opt - is their more data buffered */
+#define BIO_CTRL_FLUSH 11 /* opt - 'flush' buffered output */
+#define BIO_CTRL_DUP 12 /* man - extra stuff for 'duped' BIO */
+#define BIO_CTRL_WPENDING 13 /* opt - number of bytes still to write */
+#define BIO_CTRL_SET_CALLBACK 14 /* opt - set callback function */
+#define BIO_CTRL_GET_CALLBACK 15 /* opt - set callback function */
+
+#define BIO_CTRL_PEEK 29 /* BIO_f_buffer special */
+#define BIO_CTRL_SET_FILENAME 30 /* BIO_s_file special */
+
+/* dgram BIO stuff */
+#define BIO_CTRL_DGRAM_CONNECT 31 /* BIO dgram special */
+#define BIO_CTRL_DGRAM_SET_CONNECTED 32 /* allow for an externally connected \
+                                         * socket to be passed in */
+#define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33 /* setsockopt, essentially */
+#define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34 /* getsockopt, essentially */
+#define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35 /* setsockopt, essentially */
+#define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36 /* getsockopt, essentially */
+
+#define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37 /* flag whether the last */
+#define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38 /* I/O operation timed out */
+
+/* #ifdef IP_MTU_DISCOVER */
+#define BIO_CTRL_DGRAM_MTU_DISCOVER 39 /* set DF bit on egress packets */
+/* #endif */
+
+#define BIO_CTRL_DGRAM_QUERY_MTU 40 /* as kernel for current MTU */
+#define BIO_CTRL_DGRAM_GET_FALLBACK_MTU 47
+#define BIO_CTRL_DGRAM_GET_MTU 41 /* get cached value for MTU */
+#define BIO_CTRL_DGRAM_SET_MTU 42 /* set cached value for MTU.  \
+                                   * want to use this if asking \
+                                   * the kernel fails */
+
+#define BIO_CTRL_DGRAM_MTU_EXCEEDED 43 /* check whether the MTU was    \
+                                        * exceed in the previous write \
+                                        * operation */
+
+#define BIO_CTRL_DGRAM_GET_PEER 46
+#define BIO_CTRL_DGRAM_SET_PEER 44 /* Destination for the data */
+
+#define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT 45 /* Next DTLS handshake timeout \
+                                            * to adjust socket timeouts */
+#define BIO_CTRL_DGRAM_SET_DONT_FRAG 48
+
+#define BIO_CTRL_DGRAM_GET_MTU_OVERHEAD 49
+
+/* Deliberately outside of OPENSSL_NO_SCTP - used in bss_dgram.c */
+#define BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE 50
+#ifndef OPENSSL_NO_SCTP
+/* SCTP stuff */
+#define BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY 51
+#define BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY 52
+#define BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD 53
+#define BIO_CTRL_DGRAM_SCTP_GET_SNDINFO 60
+#define BIO_CTRL_DGRAM_SCTP_SET_SNDINFO 61
+#define BIO_CTRL_DGRAM_SCTP_GET_RCVINFO 62
+#define BIO_CTRL_DGRAM_SCTP_SET_RCVINFO 63
+#define BIO_CTRL_DGRAM_SCTP_GET_PRINFO 64
+#define BIO_CTRL_DGRAM_SCTP_SET_PRINFO 65
+#define BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN 70
+#endif
+
+#define BIO_CTRL_DGRAM_SET_PEEK_MODE 71
+
+/*
+ * internal BIO:
+ * # define BIO_CTRL_SET_KTLS_SEND                 72
+ * # define BIO_CTRL_SET_KTLS_SEND_CTRL_MSG        74
+ * # define BIO_CTRL_CLEAR_KTLS_CTRL_MSG           75
+ */
+
+#define BIO_CTRL_GET_KTLS_SEND 73
+#define BIO_CTRL_GET_KTLS_RECV 76
+
+#define BIO_CTRL_DGRAM_SCTP_WAIT_FOR_DRY 77
+#define BIO_CTRL_DGRAM_SCTP_MSG_WAITING 78
+
+/* BIO_f_prefix controls */
+#define BIO_CTRL_SET_PREFIX 79
+#define BIO_CTRL_SET_INDENT 80
+#define BIO_CTRL_GET_INDENT 81
+
+#define BIO_CTRL_DGRAM_GET_LOCAL_ADDR_CAP 82
+#define BIO_CTRL_DGRAM_GET_LOCAL_ADDR_ENABLE 83
+#define BIO_CTRL_DGRAM_SET_LOCAL_ADDR_ENABLE 84
+#define BIO_CTRL_DGRAM_GET_EFFECTIVE_CAPS 85
+#define BIO_CTRL_DGRAM_GET_CAPS 86
+#define BIO_CTRL_DGRAM_SET_CAPS 87
+#define BIO_CTRL_DGRAM_GET_NO_TRUNC 88
+#define BIO_CTRL_DGRAM_SET_NO_TRUNC 89
+
+/*
+ * internal BIO:
+ * # define BIO_CTRL_SET_KTLS_TX_ZEROCOPY_SENDFILE 90
+ */
+
+#define BIO_CTRL_GET_RPOLL_DESCRIPTOR 91
+#define BIO_CTRL_GET_WPOLL_DESCRIPTOR 92
+#define BIO_CTRL_DGRAM_DETECT_PEER_ADDR 93
+#define BIO_CTRL_DGRAM_SET0_LOCAL_ADDR 94
+
+#define BIO_DGRAM_CAP_NONE 0U
+#define BIO_DGRAM_CAP_HANDLES_SRC_ADDR (1U << 0)
+#define BIO_DGRAM_CAP_HANDLES_DST_ADDR (1U << 1)
+#define BIO_DGRAM_CAP_PROVIDES_SRC_ADDR (1U << 2)
+#define BIO_DGRAM_CAP_PROVIDES_DST_ADDR (1U << 3)
+
+#ifndef OPENSSL_NO_KTLS
+#define BIO_get_ktls_send(b) \
+    (BIO_ctrl(b, BIO_CTRL_GET_KTLS_SEND, 0, NULL) > 0)
+#define BIO_get_ktls_recv(b) \
+    (BIO_ctrl(b, BIO_CTRL_GET_KTLS_RECV, 0, NULL) > 0)
+#else
+#define BIO_get_ktls_send(b) (0)
+#define BIO_get_ktls_recv(b) (0)
+#endif
+
+/* modifiers */
+#define BIO_FP_READ 0x02
+#define BIO_FP_WRITE 0x04
+#define BIO_FP_APPEND 0x08
+#define BIO_FP_TEXT 0x10
+
+#define BIO_FLAGS_READ 0x01
+#define BIO_FLAGS_WRITE 0x02
+#define BIO_FLAGS_IO_SPECIAL 0x04
+#define BIO_FLAGS_RWS (BIO_FLAGS_READ | BIO_FLAGS_WRITE | BIO_FLAGS_IO_SPECIAL)
+#define BIO_FLAGS_SHOULD_RETRY 0x08
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+/* This #define was replaced by an internal constant and should not be used. */
+#define BIO_FLAGS_UPLINK 0
+#endif
+
+#define BIO_FLAGS_BASE64_NO_NL 0x100
+
+/*
+ * This is used with memory BIOs:
+ * BIO_FLAGS_MEM_RDONLY means we shouldn't free up or change the data in any way;
+ * BIO_FLAGS_NONCLEAR_RST means we shouldn't clear data on reset.
+ */
+#define BIO_FLAGS_MEM_RDONLY 0x200
+#define BIO_FLAGS_NONCLEAR_RST 0x400
+#define BIO_FLAGS_IN_EOF 0x800
+
+/* the BIO FLAGS values 0x1000 to 0x8000 are reserved for internal KTLS flags */
+
+typedef union bio_addr_st BIO_ADDR;
+typedef struct bio_addrinfo_st BIO_ADDRINFO;
+
+int BIO_get_new_index(void);
+void BIO_set_flags(BIO *b, int flags);
+int BIO_test_flags(const BIO *b, int flags);
+void BIO_clear_flags(BIO *b, int flags);
+
+#define BIO_get_flags(b) BIO_test_flags(b, ~(0x0))
+#define BIO_set_retry_special(b) \
+    BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY))
+#define BIO_set_retry_read(b) \
+    BIO_set_flags(b, (BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY))
+#define BIO_set_retry_write(b) \
+    BIO_set_flags(b, (BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY))
+
+/* These are normally used internally in BIOs */
+#define BIO_clear_retry_flags(b) \
+    BIO_clear_flags(b, (BIO_FLAGS_RWS | BIO_FLAGS_SHOULD_RETRY))
+#define BIO_get_retry_flags(b) \
+    BIO_test_flags(b, (BIO_FLAGS_RWS | BIO_FLAGS_SHOULD_RETRY))
+
+/* These should be used by the application to tell why we should retry */
+#define BIO_should_read(a) BIO_test_flags(a, BIO_FLAGS_READ)
+#define BIO_should_write(a) BIO_test_flags(a, BIO_FLAGS_WRITE)
+#define BIO_should_io_special(a) BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL)
+#define BIO_retry_type(a) BIO_test_flags(a, BIO_FLAGS_RWS)
+#define BIO_should_retry(a) BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY)
+
+/*
+ * The next three are used in conjunction with the BIO_should_io_special()
+ * condition.  After this returns true, BIO *BIO_get_retry_BIO(BIO *bio, int
+ * *reason); will walk the BIO stack and return the 'reason' for the special
+ * and the offending BIO. Given a BIO, BIO_get_retry_reason(bio) will return
+ * the code.
+ */
+/*
+ * Returned from the SSL bio when the certificate retrieval code had an error
+ */
+#define BIO_RR_SSL_X509_LOOKUP 0x01
+/* Returned from the connect BIO when a connect would have blocked */
+#define BIO_RR_CONNECT 0x02
+/* Returned from the accept BIO when an accept would have blocked */
+#define BIO_RR_ACCEPT 0x03
+
+/* These are passed by the BIO callback */
+#define BIO_CB_FREE 0x01
+#define BIO_CB_READ 0x02
+#define BIO_CB_WRITE 0x03
+#define BIO_CB_PUTS 0x04
+#define BIO_CB_GETS 0x05
+#define BIO_CB_CTRL 0x06
+#define BIO_CB_RECVMMSG 0x07
+#define BIO_CB_SENDMMSG 0x08
+
+/*
+ * The callback is called before and after the underling operation, The
+ * BIO_CB_RETURN flag indicates if it is after the call
+ */
+#define BIO_CB_RETURN 0x80
+#define BIO_CB_return(a) ((a) | BIO_CB_RETURN)
+#define BIO_cb_pre(a) (!((a) & BIO_CB_RETURN))
+#define BIO_cb_post(a) ((a) & BIO_CB_RETURN)
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef long (*BIO_callback_fn)(BIO *b, int oper, const char *argp, int argi,
+    long argl, long ret);
+OSSL_DEPRECATEDIN_3_0 BIO_callback_fn BIO_get_callback(const BIO *b);
+OSSL_DEPRECATEDIN_3_0 void BIO_set_callback(BIO *b, BIO_callback_fn callback);
+OSSL_DEPRECATEDIN_3_0 long BIO_debug_callback(BIO *bio, int cmd,
+    const char *argp, int argi,
+    long argl, long ret);
+#endif
+
+typedef long (*BIO_callback_fn_ex)(BIO *b, int oper, const char *argp,
+    size_t len, int argi,
+    long argl, int ret, size_t *processed);
+BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b);
+void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex callback);
+long BIO_debug_callback_ex(BIO *bio, int oper, const char *argp, size_t len,
+    int argi, long argl, int ret, size_t *processed);
+
+char *BIO_get_callback_arg(const BIO *b);
+void BIO_set_callback_arg(BIO *b, char *arg);
+
+typedef struct bio_method_st BIO_METHOD;
+
+const char *BIO_method_name(const BIO *b);
+int BIO_method_type(const BIO *b);
+
+typedef int BIO_info_cb(BIO *, int, int);
+typedef BIO_info_cb bio_info_cb; /* backward compatibility */
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(BIO, BIO, BIO)
+#define sk_BIO_num(sk) OPENSSL_sk_num(ossl_check_const_BIO_sk_type(sk))
+#define sk_BIO_value(sk, idx) ((BIO *)OPENSSL_sk_value(ossl_check_const_BIO_sk_type(sk), (idx)))
+#define sk_BIO_new(cmp) ((STACK_OF(BIO) *)OPENSSL_sk_new(ossl_check_BIO_compfunc_type(cmp)))
+#define sk_BIO_new_null() ((STACK_OF(BIO) *)OPENSSL_sk_new_null())
+#define sk_BIO_new_reserve(cmp, n) ((STACK_OF(BIO) *)OPENSSL_sk_new_reserve(ossl_check_BIO_compfunc_type(cmp), (n)))
+#define sk_BIO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_BIO_sk_type(sk), (n))
+#define sk_BIO_free(sk) OPENSSL_sk_free(ossl_check_BIO_sk_type(sk))
+#define sk_BIO_zero(sk) OPENSSL_sk_zero(ossl_check_BIO_sk_type(sk))
+#define sk_BIO_delete(sk, i) ((BIO *)OPENSSL_sk_delete(ossl_check_BIO_sk_type(sk), (i)))
+#define sk_BIO_delete_ptr(sk, ptr) ((BIO *)OPENSSL_sk_delete_ptr(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr)))
+#define sk_BIO_push(sk, ptr) OPENSSL_sk_push(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_pop(sk) ((BIO *)OPENSSL_sk_pop(ossl_check_BIO_sk_type(sk)))
+#define sk_BIO_shift(sk) ((BIO *)OPENSSL_sk_shift(ossl_check_BIO_sk_type(sk)))
+#define sk_BIO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_BIO_sk_type(sk),ossl_check_BIO_freefunc_type(freefunc))
+#define sk_BIO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr), (idx))
+#define sk_BIO_set(sk, idx, ptr) ((BIO *)OPENSSL_sk_set(ossl_check_BIO_sk_type(sk), (idx), ossl_check_BIO_type(ptr)))
+#define sk_BIO_find(sk, ptr) OPENSSL_sk_find(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr), pnum)
+#define sk_BIO_sort(sk) OPENSSL_sk_sort(ossl_check_BIO_sk_type(sk))
+#define sk_BIO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_BIO_sk_type(sk))
+#define sk_BIO_dup(sk) ((STACK_OF(BIO) *)OPENSSL_sk_dup(ossl_check_const_BIO_sk_type(sk)))
+#define sk_BIO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(BIO) *)OPENSSL_sk_deep_copy(ossl_check_const_BIO_sk_type(sk), ossl_check_BIO_copyfunc_type(copyfunc), ossl_check_BIO_freefunc_type(freefunc)))
+#define sk_BIO_set_cmp_func(sk, cmp) ((sk_BIO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_BIO_sk_type(sk), ossl_check_BIO_compfunc_type(cmp)))
+
+/* clang-format on */
+
+/* Prefix and suffix callback in ASN1 BIO */
+typedef int asn1_ps_func(BIO *b, unsigned char **pbuf, int *plen,
+    void *parg);
+
+typedef void (*BIO_dgram_sctp_notification_handler_fn)(BIO *b,
+    void *context,
+    void *buf);
+#ifndef OPENSSL_NO_SCTP
+/* SCTP parameter structs */
+struct bio_dgram_sctp_sndinfo {
+    uint16_t snd_sid;
+    uint16_t snd_flags;
+    uint32_t snd_ppid;
+    uint32_t snd_context;
+};
+
+struct bio_dgram_sctp_rcvinfo {
+    uint16_t rcv_sid;
+    uint16_t rcv_ssn;
+    uint16_t rcv_flags;
+    uint32_t rcv_ppid;
+    uint32_t rcv_tsn;
+    uint32_t rcv_cumtsn;
+    uint32_t rcv_context;
+};
+
+struct bio_dgram_sctp_prinfo {
+    uint16_t pr_policy;
+    uint32_t pr_value;
+};
+#endif
+
+/* BIO_sendmmsg/BIO_recvmmsg-related definitions */
+typedef struct bio_msg_st {
+    void *data;
+    size_t data_len;
+    BIO_ADDR *peer, *local;
+    uint64_t flags;
+} BIO_MSG;
+
+typedef struct bio_mmsg_cb_args_st {
+    BIO_MSG *msg;
+    size_t stride, num_msg;
+    uint64_t flags;
+    size_t *msgs_processed;
+} BIO_MMSG_CB_ARGS;
+
+#define BIO_POLL_DESCRIPTOR_TYPE_NONE 0
+#define BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD 1
+#define BIO_POLL_DESCRIPTOR_TYPE_SSL 2
+#define BIO_POLL_DESCRIPTOR_CUSTOM_START 8192
+
+typedef struct bio_poll_descriptor_st {
+    uint32_t type;
+    union {
+        int fd;
+        void *custom;
+        uintptr_t custom_ui;
+        SSL *ssl;
+    } value;
+} BIO_POLL_DESCRIPTOR;
+
+/*
+ * #define BIO_CONN_get_param_hostname BIO_ctrl
+ */
+
+#define BIO_C_SET_CONNECT 100
+#define BIO_C_DO_STATE_MACHINE 101
+#define BIO_C_SET_NBIO 102
+/* # define BIO_C_SET_PROXY_PARAM                   103 */
+#define BIO_C_SET_FD 104
+#define BIO_C_GET_FD 105
+#define BIO_C_SET_FILE_PTR 106
+#define BIO_C_GET_FILE_PTR 107
+#define BIO_C_SET_FILENAME 108
+#define BIO_C_SET_SSL 109
+#define BIO_C_GET_SSL 110
+#define BIO_C_SET_MD 111
+#define BIO_C_GET_MD 112
+#define BIO_C_GET_CIPHER_STATUS 113
+#define BIO_C_SET_BUF_MEM 114
+#define BIO_C_GET_BUF_MEM_PTR 115
+#define BIO_C_GET_BUFF_NUM_LINES 116
+#define BIO_C_SET_BUFF_SIZE 117
+#define BIO_C_SET_ACCEPT 118
+#define BIO_C_SSL_MODE 119
+#define BIO_C_GET_MD_CTX 120
+/* # define BIO_C_GET_PROXY_PARAM                   121 */
+#define BIO_C_SET_BUFF_READ_DATA 122 /* data to read first */
+#define BIO_C_GET_CONNECT 123
+#define BIO_C_GET_ACCEPT 124
+#define BIO_C_SET_SSL_RENEGOTIATE_BYTES 125
+#define BIO_C_GET_SSL_NUM_RENEGOTIATES 126
+#define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT 127
+#define BIO_C_FILE_SEEK 128
+#define BIO_C_GET_CIPHER_CTX 129
+#define BIO_C_SET_BUF_MEM_EOF_RETURN 130 /* return end of input \
+                                          * value */
+#define BIO_C_SET_BIND_MODE 131
+#define BIO_C_GET_BIND_MODE 132
+#define BIO_C_FILE_TELL 133
+#define BIO_C_GET_SOCKS 134
+#define BIO_C_SET_SOCKS 135
+
+#define BIO_C_SET_WRITE_BUF_SIZE 136 /* for BIO_s_bio */
+#define BIO_C_GET_WRITE_BUF_SIZE 137
+#define BIO_C_MAKE_BIO_PAIR 138
+#define BIO_C_DESTROY_BIO_PAIR 139
+#define BIO_C_GET_WRITE_GUARANTEE 140
+#define BIO_C_GET_READ_REQUEST 141
+#define BIO_C_SHUTDOWN_WR 142
+#define BIO_C_NREAD0 143
+#define BIO_C_NREAD 144
+#define BIO_C_NWRITE0 145
+#define BIO_C_NWRITE 146
+#define BIO_C_RESET_READ_REQUEST 147
+#define BIO_C_SET_MD_CTX 148
+
+#define BIO_C_SET_PREFIX 149
+#define BIO_C_GET_PREFIX 150
+#define BIO_C_SET_SUFFIX 151
+#define BIO_C_GET_SUFFIX 152
+
+#define BIO_C_SET_EX_ARG 153
+#define BIO_C_GET_EX_ARG 154
+
+#define BIO_C_SET_CONNECT_MODE 155
+
+#define BIO_C_SET_TFO 156 /* like BIO_C_SET_NBIO */
+
+#define BIO_C_SET_SOCK_TYPE 157
+#define BIO_C_GET_SOCK_TYPE 158
+#define BIO_C_GET_DGRAM_BIO 159
+
+#define BIO_set_app_data(s, arg) BIO_set_ex_data(s, 0, arg)
+#define BIO_get_app_data(s) BIO_get_ex_data(s, 0)
+
+#define BIO_set_nbio(b, n) BIO_ctrl(b, BIO_C_SET_NBIO, (n), NULL)
+#define BIO_set_tfo(b, n) BIO_ctrl(b, BIO_C_SET_TFO, (n), NULL)
+
+#ifndef OPENSSL_NO_SOCK
+/* IP families we support, for BIO_s_connect() and BIO_s_accept() */
+/* Note: the underlying operating system may not support some of them */
+#define BIO_FAMILY_IPV4 4
+#define BIO_FAMILY_IPV6 6
+#define BIO_FAMILY_IPANY 256
+
+/* BIO_s_connect() */
+#define BIO_set_conn_hostname(b, name) BIO_ctrl(b, BIO_C_SET_CONNECT, 0, \
+    (char *)(name))
+#define BIO_set_conn_port(b, port) BIO_ctrl(b, BIO_C_SET_CONNECT, 1, \
+    (char *)(port))
+#define BIO_set_conn_address(b, addr) BIO_ctrl(b, BIO_C_SET_CONNECT, 2, \
+    (char *)(addr))
+#define BIO_set_conn_ip_family(b, f) BIO_int_ctrl(b, BIO_C_SET_CONNECT, 3, f)
+#define BIO_get_conn_hostname(b) ((const char *)BIO_ptr_ctrl(b, BIO_C_GET_CONNECT, 0))
+#define BIO_get_conn_port(b) ((const char *)BIO_ptr_ctrl(b, BIO_C_GET_CONNECT, 1))
+#define BIO_get_conn_address(b) ((const BIO_ADDR *)BIO_ptr_ctrl(b, BIO_C_GET_CONNECT, 2))
+#define BIO_get_conn_ip_family(b) BIO_ctrl(b, BIO_C_GET_CONNECT, 3, NULL)
+#define BIO_get_conn_mode(b) BIO_ctrl(b, BIO_C_GET_CONNECT, 4, NULL)
+#define BIO_set_conn_mode(b, n) BIO_ctrl(b, BIO_C_SET_CONNECT_MODE, (n), NULL)
+#define BIO_set_sock_type(b, t) BIO_ctrl(b, BIO_C_SET_SOCK_TYPE, (t), NULL)
+#define BIO_get_sock_type(b) BIO_ctrl(b, BIO_C_GET_SOCK_TYPE, 0, NULL)
+#define BIO_get0_dgram_bio(b, p) BIO_ctrl(b, BIO_C_GET_DGRAM_BIO, 0, (void *)(BIO **)(p))
+
+/* BIO_s_accept() */
+#define BIO_set_accept_name(b, name) BIO_ctrl(b, BIO_C_SET_ACCEPT, 0, \
+    (char *)(name))
+#define BIO_set_accept_port(b, port) BIO_ctrl(b, BIO_C_SET_ACCEPT, 1, \
+    (char *)(port))
+#define BIO_get_accept_name(b) ((const char *)BIO_ptr_ctrl(b, BIO_C_GET_ACCEPT, 0))
+#define BIO_get_accept_port(b) ((const char *)BIO_ptr_ctrl(b, BIO_C_GET_ACCEPT, 1))
+#define BIO_get_peer_name(b) ((const char *)BIO_ptr_ctrl(b, BIO_C_GET_ACCEPT, 2))
+#define BIO_get_peer_port(b) ((const char *)BIO_ptr_ctrl(b, BIO_C_GET_ACCEPT, 3))
+/* #define BIO_set_nbio(b,n)    BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */
+#define BIO_set_nbio_accept(b, n) BIO_ctrl(b, BIO_C_SET_ACCEPT, 2, (n) ? (void *)"a" : NULL)
+#define BIO_set_accept_bios(b, bio) BIO_ctrl(b, BIO_C_SET_ACCEPT, 3, \
+    (char *)(bio))
+#define BIO_set_accept_ip_family(b, f) BIO_int_ctrl(b, BIO_C_SET_ACCEPT, 4, f)
+#define BIO_get_accept_ip_family(b) BIO_ctrl(b, BIO_C_GET_ACCEPT, 4, NULL)
+#define BIO_set_tfo_accept(b, n) BIO_ctrl(b, BIO_C_SET_ACCEPT, 5, (n) ? (void *)"a" : NULL)
+
+/* Aliases kept for backward compatibility */
+#define BIO_BIND_NORMAL 0
+#define BIO_BIND_REUSEADDR BIO_SOCK_REUSEADDR
+#define BIO_BIND_REUSEADDR_IF_UNUSED BIO_SOCK_REUSEADDR
+#define BIO_set_bind_mode(b, mode) BIO_ctrl(b, BIO_C_SET_BIND_MODE, mode, NULL)
+#define BIO_get_bind_mode(b) BIO_ctrl(b, BIO_C_GET_BIND_MODE, 0, NULL)
+#endif /* OPENSSL_NO_SOCK */
+
+#define BIO_do_connect(b) BIO_do_handshake(b)
+#define BIO_do_accept(b) BIO_do_handshake(b)
+
+#define BIO_do_handshake(b) BIO_ctrl(b, BIO_C_DO_STATE_MACHINE, 0, NULL)
+
+/* BIO_s_datagram(), BIO_s_fd(), BIO_s_socket(), BIO_s_accept() and BIO_s_connect() */
+#define BIO_set_fd(b, fd, c) BIO_int_ctrl(b, BIO_C_SET_FD, c, fd)
+#define BIO_get_fd(b, c) BIO_ctrl(b, BIO_C_GET_FD, 0, (char *)(c))
+
+/* BIO_s_file() */
+#define BIO_set_fp(b, fp, c) BIO_ctrl(b, BIO_C_SET_FILE_PTR, c, (char *)(fp))
+#define BIO_get_fp(b, fpp) BIO_ctrl(b, BIO_C_GET_FILE_PTR, 0, (char *)(fpp))
+
+/* BIO_s_fd() and BIO_s_file() */
+#define BIO_seek(b, ofs) (int)BIO_ctrl(b, BIO_C_FILE_SEEK, ofs, NULL)
+#define BIO_tell(b) (int)BIO_ctrl(b, BIO_C_FILE_TELL, 0, NULL)
+
+/*
+ * name is cast to lose const, but might be better to route through a
+ * function so we can do it safely
+ */
+#ifdef CONST_STRICT
+/*
+ * If you are wondering why this isn't defined, its because CONST_STRICT is
+ * purely a compile-time kludge to allow const to be checked.
+ */
+int BIO_read_filename(BIO *b, const char *name);
+#else
+#define BIO_read_filename(b, name) (int)BIO_ctrl(b, BIO_C_SET_FILENAME, \
+    BIO_CLOSE | BIO_FP_READ, (char *)(name))
+#endif
+#define BIO_write_filename(b, name) (int)BIO_ctrl(b, BIO_C_SET_FILENAME, \
+    BIO_CLOSE | BIO_FP_WRITE, name)
+#define BIO_append_filename(b, name) (int)BIO_ctrl(b, BIO_C_SET_FILENAME, \
+    BIO_CLOSE | BIO_FP_APPEND, name)
+#define BIO_rw_filename(b, name) (int)BIO_ctrl(b, BIO_C_SET_FILENAME, \
+    BIO_CLOSE | BIO_FP_READ | BIO_FP_WRITE, name)
+
+/*
+ * WARNING WARNING, this ups the reference count on the read bio of the SSL
+ * structure.  This is because the ssl read BIO is now pointed to by the
+ * next_bio field in the bio.  So when you free the BIO, make sure you are
+ * doing a BIO_free_all() to catch the underlying BIO.
+ */
+#define BIO_set_ssl(b, ssl, c) BIO_ctrl(b, BIO_C_SET_SSL, c, (char *)(ssl))
+#define BIO_get_ssl(b, sslp) BIO_ctrl(b, BIO_C_GET_SSL, 0, (char *)(sslp))
+#define BIO_set_ssl_mode(b, client) BIO_ctrl(b, BIO_C_SSL_MODE, client, NULL)
+#define BIO_set_ssl_renegotiate_bytes(b, num) \
+    BIO_ctrl(b, BIO_C_SET_SSL_RENEGOTIATE_BYTES, num, NULL)
+#define BIO_get_num_renegotiates(b) \
+    BIO_ctrl(b, BIO_C_GET_SSL_NUM_RENEGOTIATES, 0, NULL)
+#define BIO_set_ssl_renegotiate_timeout(b, seconds) \
+    BIO_ctrl(b, BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT, seconds, NULL)
+
+/* defined in evp.h */
+/* #define BIO_set_md(b,md)     BIO_ctrl(b,BIO_C_SET_MD,1,(char *)(md)) */
+
+#define BIO_get_mem_data(b, pp) BIO_ctrl(b, BIO_CTRL_INFO, 0, (char *)(pp))
+#define BIO_set_mem_buf(b, bm, c) BIO_ctrl(b, BIO_C_SET_BUF_MEM, c, (char *)(bm))
+#define BIO_get_mem_ptr(b, pp) BIO_ctrl(b, BIO_C_GET_BUF_MEM_PTR, 0, \
+    (char *)(pp))
+#define BIO_set_mem_eof_return(b, v) \
+    BIO_ctrl(b, BIO_C_SET_BUF_MEM_EOF_RETURN, v, NULL)
+
+/* For the BIO_f_buffer() type */
+#define BIO_get_buffer_num_lines(b) BIO_ctrl(b, BIO_C_GET_BUFF_NUM_LINES, 0, NULL)
+#define BIO_set_buffer_size(b, size) BIO_ctrl(b, BIO_C_SET_BUFF_SIZE, size, NULL)
+#define BIO_set_read_buffer_size(b, size) BIO_int_ctrl(b, BIO_C_SET_BUFF_SIZE, size, 0)
+#define BIO_set_write_buffer_size(b, size) BIO_int_ctrl(b, BIO_C_SET_BUFF_SIZE, size, 1)
+#define BIO_set_buffer_read_data(b, buf, num) BIO_ctrl(b, BIO_C_SET_BUFF_READ_DATA, num, buf)
+
+/* Don't use the next one unless you know what you are doing :-) */
+#define BIO_dup_state(b, ret) BIO_ctrl(b, BIO_CTRL_DUP, 0, (char *)(ret))
+
+#define BIO_reset(b) (int)BIO_ctrl(b, BIO_CTRL_RESET, 0, NULL)
+#define BIO_eof(b) (int)BIO_ctrl(b, BIO_CTRL_EOF, 0, NULL)
+#define BIO_set_close(b, c) (int)BIO_ctrl(b, BIO_CTRL_SET_CLOSE, (c), NULL)
+#define BIO_get_close(b) (int)BIO_ctrl(b, BIO_CTRL_GET_CLOSE, 0, NULL)
+#define BIO_pending(b) (int)BIO_ctrl(b, BIO_CTRL_PENDING, 0, NULL)
+#define BIO_wpending(b) (int)BIO_ctrl(b, BIO_CTRL_WPENDING, 0, NULL)
+/* ...pending macros have inappropriate return type */
+size_t BIO_ctrl_pending(BIO *b);
+size_t BIO_ctrl_wpending(BIO *b);
+#define BIO_flush(b) (int)BIO_ctrl(b, BIO_CTRL_FLUSH, 0, NULL)
+#define BIO_get_info_callback(b, cbp) (int)BIO_ctrl(b, BIO_CTRL_GET_CALLBACK, 0, \
+    cbp)
+#define BIO_set_info_callback(b, cb) (int)BIO_callback_ctrl(b, BIO_CTRL_SET_CALLBACK, cb)
+
+/* For the BIO_f_buffer() type */
+#define BIO_buffer_get_num_lines(b) BIO_ctrl(b, BIO_CTRL_GET, 0, NULL)
+#define BIO_buffer_peek(b, s, l) BIO_ctrl(b, BIO_CTRL_PEEK, (l), (s))
+
+/* For BIO_s_bio() */
+#define BIO_set_write_buf_size(b, size) (int)BIO_ctrl(b, BIO_C_SET_WRITE_BUF_SIZE, size, NULL)
+#define BIO_get_write_buf_size(b, size) (size_t)BIO_ctrl(b, BIO_C_GET_WRITE_BUF_SIZE, size, NULL)
+#define BIO_make_bio_pair(b1, b2) (int)BIO_ctrl(b1, BIO_C_MAKE_BIO_PAIR, 0, b2)
+#define BIO_destroy_bio_pair(b) (int)BIO_ctrl(b, BIO_C_DESTROY_BIO_PAIR, 0, NULL)
+#define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL)
+/* macros with inappropriate type -- but ...pending macros use int too: */
+#define BIO_get_write_guarantee(b) (int)BIO_ctrl(b, BIO_C_GET_WRITE_GUARANTEE, 0, NULL)
+#define BIO_get_read_request(b) (int)BIO_ctrl(b, BIO_C_GET_READ_REQUEST, 0, NULL)
+size_t BIO_ctrl_get_write_guarantee(BIO *b);
+size_t BIO_ctrl_get_read_request(BIO *b);
+int BIO_ctrl_reset_read_request(BIO *b);
+
+/* ctrl macros for dgram */
+#define BIO_ctrl_dgram_connect(b, peer) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_CONNECT, 0, (char *)(peer))
+#define BIO_ctrl_set_connected(b, peer) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, 0, (char *)(peer))
+#define BIO_dgram_recv_timedout(b) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL)
+#define BIO_dgram_send_timedout(b) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL)
+#define BIO_dgram_get_peer(b, peer) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char *)(peer))
+#define BIO_dgram_set_peer(b, peer) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)(peer))
+#define BIO_dgram_detect_peer_addr(b, peer) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_DETECT_PEER_ADDR, 0, (char *)(peer))
+#define BIO_dgram_get_mtu_overhead(b) \
+    (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU_OVERHEAD, 0, NULL)
+#define BIO_dgram_get_local_addr_cap(b) \
+    (int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_LOCAL_ADDR_CAP, 0, NULL)
+#define BIO_dgram_get_local_addr_enable(b, penable) \
+    (int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_LOCAL_ADDR_ENABLE, 0, (char *)(penable))
+#define BIO_dgram_set_local_addr_enable(b, enable) \
+    (int)BIO_ctrl((b), BIO_CTRL_DGRAM_SET_LOCAL_ADDR_ENABLE, (enable), NULL)
+#define BIO_dgram_get_effective_caps(b) \
+    (uint32_t)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_EFFECTIVE_CAPS, 0, NULL)
+#define BIO_dgram_get_caps(b) \
+    (uint32_t)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_CAPS, 0, NULL)
+#define BIO_dgram_set_caps(b, caps) \
+    (int)BIO_ctrl((b), BIO_CTRL_DGRAM_SET_CAPS, (long)(caps), NULL)
+#define BIO_dgram_get_no_trunc(b) \
+    (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_NO_TRUNC, 0, NULL)
+#define BIO_dgram_set_no_trunc(b, enable) \
+    (int)BIO_ctrl((b), BIO_CTRL_DGRAM_SET_NO_TRUNC, (enable), NULL)
+#define BIO_dgram_get_mtu(b) \
+    (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU, 0, NULL)
+#define BIO_dgram_set_mtu(b, mtu) \
+    (int)BIO_ctrl((b), BIO_CTRL_DGRAM_SET_MTU, (mtu), NULL)
+#define BIO_dgram_set0_local_addr(b, addr) \
+    (int)BIO_ctrl((b), BIO_CTRL_DGRAM_SET0_LOCAL_ADDR, 0, (addr))
+
+/* ctrl macros for BIO_f_prefix */
+#define BIO_set_prefix(b, p) BIO_ctrl((b), BIO_CTRL_SET_PREFIX, 0, (void *)(p))
+#define BIO_set_indent(b, i) BIO_ctrl((b), BIO_CTRL_SET_INDENT, (i), NULL)
+#define BIO_get_indent(b) BIO_ctrl((b), BIO_CTRL_GET_INDENT, 0, NULL)
+
+#define BIO_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, l, p, newf, dupf, freef)
+int BIO_set_ex_data(BIO *bio, int idx, void *data);
+void *BIO_get_ex_data(const BIO *bio, int idx);
+uint64_t BIO_number_read(BIO *bio);
+uint64_t BIO_number_written(BIO *bio);
+
+/* For BIO_f_asn1() */
+int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
+    asn1_ps_func *prefix_free);
+int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
+    asn1_ps_func **pprefix_free);
+int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
+    asn1_ps_func *suffix_free);
+int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
+    asn1_ps_func **psuffix_free);
+
+const BIO_METHOD *BIO_s_file(void);
+BIO *BIO_new_file(const char *filename, const char *mode);
+BIO *BIO_new_from_core_bio(OSSL_LIB_CTX *libctx, OSSL_CORE_BIO *corebio);
+#ifndef OPENSSL_NO_STDIO
+BIO *BIO_new_fp(FILE *stream, int close_flag);
+#endif
+BIO *BIO_new_ex(OSSL_LIB_CTX *libctx, const BIO_METHOD *method);
+BIO *BIO_new(const BIO_METHOD *type);
+int BIO_free(BIO *a);
+void BIO_set_data(BIO *a, void *ptr);
+void *BIO_get_data(BIO *a);
+void BIO_set_init(BIO *a, int init);
+int BIO_get_init(BIO *a);
+void BIO_set_shutdown(BIO *a, int shut);
+int BIO_get_shutdown(BIO *a);
+void BIO_vfree(BIO *a);
+int BIO_up_ref(BIO *a);
+int BIO_read(BIO *b, void *data, int dlen);
+int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes);
+__owur int BIO_recvmmsg(BIO *b, BIO_MSG *msg,
+    size_t stride, size_t num_msg, uint64_t flags,
+    size_t *msgs_processed);
+int BIO_gets(BIO *bp, char *buf, int size);
+int BIO_get_line(BIO *bio, char *buf, int size);
+int BIO_write(BIO *b, const void *data, int dlen);
+int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written);
+__owur int BIO_sendmmsg(BIO *b, BIO_MSG *msg,
+    size_t stride, size_t num_msg, uint64_t flags,
+    size_t *msgs_processed);
+__owur int BIO_get_rpoll_descriptor(BIO *b, BIO_POLL_DESCRIPTOR *desc);
+__owur int BIO_get_wpoll_descriptor(BIO *b, BIO_POLL_DESCRIPTOR *desc);
+int BIO_puts(BIO *bp, const char *buf);
+int BIO_indent(BIO *b, int indent, int max);
+long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg);
+long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp);
+void *BIO_ptr_ctrl(BIO *bp, int cmd, long larg);
+long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg);
+BIO *BIO_push(BIO *b, BIO *append);
+BIO *BIO_pop(BIO *b);
+void BIO_free_all(BIO *a);
+BIO *BIO_find_type(BIO *b, int bio_type);
+BIO *BIO_next(BIO *b);
+void BIO_set_next(BIO *b, BIO *next);
+BIO *BIO_get_retry_BIO(BIO *bio, int *reason);
+int BIO_get_retry_reason(BIO *bio);
+void BIO_set_retry_reason(BIO *bio, int reason);
+BIO *BIO_dup_chain(BIO *in);
+
+int BIO_nread0(BIO *bio, char **buf);
+int BIO_nread(BIO *bio, char **buf, int num);
+int BIO_nwrite0(BIO *bio, char **buf);
+int BIO_nwrite(BIO *bio, char **buf, int num);
+
+const BIO_METHOD *BIO_s_mem(void);
+#ifndef OPENSSL_NO_DGRAM
+const BIO_METHOD *BIO_s_dgram_mem(void);
+#endif
+const BIO_METHOD *BIO_s_secmem(void);
+BIO *BIO_new_mem_buf(const void *buf, int len);
+#ifndef OPENSSL_NO_SOCK
+const BIO_METHOD *BIO_s_socket(void);
+const BIO_METHOD *BIO_s_connect(void);
+const BIO_METHOD *BIO_s_accept(void);
+#endif
+const BIO_METHOD *BIO_s_fd(void);
+const BIO_METHOD *BIO_s_log(void);
+const BIO_METHOD *BIO_s_bio(void);
+const BIO_METHOD *BIO_s_null(void);
+const BIO_METHOD *BIO_f_null(void);
+const BIO_METHOD *BIO_f_buffer(void);
+const BIO_METHOD *BIO_f_readbuffer(void);
+const BIO_METHOD *BIO_f_linebuffer(void);
+const BIO_METHOD *BIO_f_nbio_test(void);
+const BIO_METHOD *BIO_f_prefix(void);
+const BIO_METHOD *BIO_s_core(void);
+#ifndef OPENSSL_NO_DGRAM
+const BIO_METHOD *BIO_s_dgram_pair(void);
+const BIO_METHOD *BIO_s_datagram(void);
+int BIO_dgram_non_fatal_error(int error);
+BIO *BIO_new_dgram(int fd, int close_flag);
+#ifndef OPENSSL_NO_SCTP
+const BIO_METHOD *BIO_s_datagram_sctp(void);
+BIO *BIO_new_dgram_sctp(int fd, int close_flag);
+int BIO_dgram_is_sctp(BIO *bio);
+int BIO_dgram_sctp_notification_cb(BIO *b,
+    BIO_dgram_sctp_notification_handler_fn handle_notifications,
+    void *context);
+int BIO_dgram_sctp_wait_for_dry(BIO *b);
+int BIO_dgram_sctp_msg_waiting(BIO *b);
+#endif
+#endif
+
+#ifndef OPENSSL_NO_SOCK
+int BIO_sock_should_retry(int i);
+int BIO_sock_non_fatal_error(int error);
+int BIO_err_is_non_fatal(unsigned int errcode);
+int BIO_socket_wait(int fd, int for_read, time_t max_time);
+#endif
+int BIO_wait(BIO *bio, time_t max_time, unsigned int nap_milliseconds);
+int BIO_do_connect_retry(BIO *bio, int timeout, int nap_milliseconds);
+
+int BIO_fd_should_retry(int i);
+int BIO_fd_non_fatal_error(int error);
+int BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u),
+    void *u, const void *s, int len);
+int BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u),
+    void *u, const void *s, int len, int indent);
+int BIO_dump(BIO *b, const void *bytes, int len);
+int BIO_dump_indent(BIO *b, const void *bytes, int len, int indent);
+#ifndef OPENSSL_NO_STDIO
+int BIO_dump_fp(FILE *fp, const void *s, int len);
+int BIO_dump_indent_fp(FILE *fp, const void *s, int len, int indent);
+#endif
+int BIO_hex_string(BIO *out, int indent, int width, const void *data,
+    int datalen);
+
+#ifndef OPENSSL_NO_SOCK
+BIO_ADDR *BIO_ADDR_new(void);
+int BIO_ADDR_copy(BIO_ADDR *dst, const BIO_ADDR *src);
+BIO_ADDR *BIO_ADDR_dup(const BIO_ADDR *ap);
+int BIO_ADDR_rawmake(BIO_ADDR *ap, int family,
+    const void *where, size_t wherelen, unsigned short port);
+void BIO_ADDR_free(BIO_ADDR *);
+void BIO_ADDR_clear(BIO_ADDR *ap);
+int BIO_ADDR_family(const BIO_ADDR *ap);
+int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l);
+unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap);
+char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric);
+char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric);
+char *BIO_ADDR_path_string(const BIO_ADDR *ap);
+
+const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai);
+int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai);
+int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai);
+int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai);
+const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai);
+void BIO_ADDRINFO_free(BIO_ADDRINFO *bai);
+
+enum BIO_hostserv_priorities {
+    BIO_PARSE_PRIO_HOST,
+    BIO_PARSE_PRIO_SERV
+};
+int BIO_parse_hostserv(const char *hostserv, char **host, char **service,
+    enum BIO_hostserv_priorities hostserv_prio);
+enum BIO_lookup_type {
+    BIO_LOOKUP_CLIENT,
+    BIO_LOOKUP_SERVER
+};
+int BIO_lookup(const char *host, const char *service,
+    enum BIO_lookup_type lookup_type,
+    int family, int socktype, BIO_ADDRINFO **res);
+int BIO_lookup_ex(const char *host, const char *service,
+    int lookup_type, int family, int socktype, int protocol,
+    BIO_ADDRINFO **res);
+int BIO_sock_error(int sock);
+int BIO_socket_ioctl(int fd, long type, void *arg);
+int BIO_socket_nbio(int fd, int mode);
+int BIO_sock_init(void);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define BIO_sock_cleanup() \
+    while (0)              \
+    continue
+#endif
+int BIO_set_tcp_ndelay(int sock, int turn_on);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 struct hostent *BIO_gethostbyname(const char *name);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_get_port(const char *str, unsigned short *port_ptr);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_get_host_ip(const char *str, unsigned char *ip);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_get_accept_socket(char *host_port, int mode);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_accept(int sock, char **ip_port);
+#endif
+
+union BIO_sock_info_u {
+    BIO_ADDR *addr;
+};
+enum BIO_sock_info_type {
+    BIO_SOCK_INFO_ADDRESS
+};
+int BIO_sock_info(int sock,
+    enum BIO_sock_info_type type, union BIO_sock_info_u *info);
+
+#define BIO_SOCK_REUSEADDR 0x01
+#define BIO_SOCK_V6_ONLY 0x02
+#define BIO_SOCK_KEEPALIVE 0x04
+#define BIO_SOCK_NONBLOCK 0x08
+#define BIO_SOCK_NODELAY 0x10
+#define BIO_SOCK_TFO 0x20
+
+int BIO_socket(int domain, int socktype, int protocol, int options);
+int BIO_connect(int sock, const BIO_ADDR *addr, int options);
+int BIO_bind(int sock, const BIO_ADDR *addr, int options);
+int BIO_listen(int sock, const BIO_ADDR *addr, int options);
+int BIO_accept_ex(int accept_sock, BIO_ADDR *addr, int options);
+int BIO_closesocket(int sock);
+
+BIO *BIO_new_socket(int sock, int close_flag);
+BIO *BIO_new_connect(const char *host_port);
+BIO *BIO_new_accept(const char *host_port);
+#endif /* OPENSSL_NO_SOCK*/
+
+BIO *BIO_new_fd(int fd, int close_flag);
+
+int BIO_new_bio_pair(BIO **bio1, size_t writebuf1,
+    BIO **bio2, size_t writebuf2);
+#ifndef OPENSSL_NO_DGRAM
+int BIO_new_bio_dgram_pair(BIO **bio1, size_t writebuf1,
+    BIO **bio2, size_t writebuf2);
+#endif
+
+/*
+ * If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints.
+ * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. Size 0 uses default
+ * value.
+ */
+
+void BIO_copy_next_retry(BIO *b);
+
+/*
+ * long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);
+ */
+
+#define ossl_bio__attr__(x)
+#if defined(__GNUC__) && defined(__STDC_VERSION__)    \
+    && !defined(__MINGW32__) && !defined(__MINGW64__) \
+    && !defined(__APPLE__)
+/*
+ * Because we support the 'z' modifier, which made its appearance in C99,
+ * we can't use __attribute__ with pre C99 dialects.
+ */
+#if __STDC_VERSION__ >= 199901L
+#undef ossl_bio__attr__
+#define ossl_bio__attr__ __attribute__
+#if __GNUC__ * 10 + __GNUC_MINOR__ >= 44
+#define ossl_bio__printf__ __gnu_printf__
+#else
+#define ossl_bio__printf__ __printf__
+#endif
+#endif
+#endif
+int BIO_printf(BIO *bio, const char *format, ...)
+    ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 3)));
+int BIO_vprintf(BIO *bio, const char *format, va_list args)
+    ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 0)));
+int BIO_snprintf(char *buf, size_t n, const char *format, ...)
+    ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 4)));
+int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
+    ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 0)));
+#undef ossl_bio__attr__
+#undef ossl_bio__printf__
+
+BIO_METHOD *BIO_meth_new(int type, const char *name);
+void BIO_meth_free(BIO_METHOD *biom);
+int BIO_meth_set_write(BIO_METHOD *biom,
+    int (*write)(BIO *, const char *, int));
+int BIO_meth_set_write_ex(BIO_METHOD *biom,
+    int (*bwrite)(BIO *, const char *, size_t, size_t *));
+int BIO_meth_set_sendmmsg(BIO_METHOD *biom,
+    int (*f)(BIO *, BIO_MSG *, size_t, size_t,
+        uint64_t, size_t *));
+int BIO_meth_set_read(BIO_METHOD *biom,
+    int (*read)(BIO *, char *, int));
+int BIO_meth_set_read_ex(BIO_METHOD *biom,
+    int (*bread)(BIO *, char *, size_t, size_t *));
+int BIO_meth_set_recvmmsg(BIO_METHOD *biom,
+    int (*f)(BIO *, BIO_MSG *, size_t, size_t,
+        uint64_t, size_t *));
+int BIO_meth_set_puts(BIO_METHOD *biom,
+    int (*puts)(BIO *, const char *));
+int BIO_meth_set_gets(BIO_METHOD *biom,
+    int (*ossl_gets)(BIO *, char *, int));
+int BIO_meth_set_ctrl(BIO_METHOD *biom,
+    long (*ctrl)(BIO *, int, long, void *));
+int BIO_meth_set_create(BIO_METHOD *biom, int (*create)(BIO *));
+int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy)(BIO *));
+int BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
+    long (*callback_ctrl)(BIO *, int,
+        BIO_info_cb *));
+#ifndef OPENSSL_NO_DEPRECATED_3_5
+OSSL_DEPRECATEDIN_3_5 int (*BIO_meth_get_write(const BIO_METHOD *biom))(BIO *, const char *,
+    int);
+OSSL_DEPRECATEDIN_3_5 int (*BIO_meth_get_write_ex(const BIO_METHOD *biom))(BIO *, const char *,
+    size_t, size_t *);
+OSSL_DEPRECATEDIN_3_5 int (*BIO_meth_get_sendmmsg(const BIO_METHOD *biom))(BIO *, BIO_MSG *,
+    size_t, size_t,
+    uint64_t, size_t *);
+OSSL_DEPRECATEDIN_3_5 int (*BIO_meth_get_read(const BIO_METHOD *biom))(BIO *, char *, int);
+OSSL_DEPRECATEDIN_3_5 int (*BIO_meth_get_read_ex(const BIO_METHOD *biom))(BIO *, char *,
+    size_t, size_t *);
+OSSL_DEPRECATEDIN_3_5 int (*BIO_meth_get_recvmmsg(const BIO_METHOD *biom))(BIO *, BIO_MSG *,
+    size_t, size_t,
+    uint64_t, size_t *);
+OSSL_DEPRECATEDIN_3_5 int (*BIO_meth_get_puts(const BIO_METHOD *biom))(BIO *, const char *);
+OSSL_DEPRECATEDIN_3_5 int (*BIO_meth_get_gets(const BIO_METHOD *biom))(BIO *, char *, int);
+OSSL_DEPRECATEDIN_3_5 long (*BIO_meth_get_ctrl(const BIO_METHOD *biom))(BIO *, int,
+    long, void *);
+OSSL_DEPRECATEDIN_3_5 int (*BIO_meth_get_create(const BIO_METHOD *bion))(BIO *);
+OSSL_DEPRECATEDIN_3_5 int (*BIO_meth_get_destroy(const BIO_METHOD *biom))(BIO *);
+OSSL_DEPRECATEDIN_3_5 long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom))(BIO *, int,
+    BIO_info_cb *);
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/bioerr.h

@@ -0,0 +1,70 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BIOERR_H
+#define OPENSSL_BIOERR_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
+
+/*
+ * BIO reason codes.
+ */
+#define BIO_R_ACCEPT_ERROR 100
+#define BIO_R_ADDRINFO_ADDR_IS_NOT_AF_INET 141
+#define BIO_R_AMBIGUOUS_HOST_OR_SERVICE 129
+#define BIO_R_BAD_FOPEN_MODE 101
+#define BIO_R_BROKEN_PIPE 124
+#define BIO_R_CONNECT_ERROR 103
+#define BIO_R_CONNECT_TIMEOUT 147
+#define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET 107
+#define BIO_R_GETSOCKNAME_ERROR 132
+#define BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS 133
+#define BIO_R_GETTING_SOCKTYPE 134
+#define BIO_R_INVALID_ARGUMENT 125
+#define BIO_R_INVALID_SOCKET 135
+#define BIO_R_IN_USE 123
+#define BIO_R_LENGTH_TOO_LONG 102
+#define BIO_R_LISTEN_V6_ONLY 136
+#define BIO_R_LOCAL_ADDR_NOT_AVAILABLE 111
+#define BIO_R_LOOKUP_RETURNED_NOTHING 142
+#define BIO_R_MALFORMED_HOST_OR_SERVICE 130
+#define BIO_R_NBIO_CONNECT_ERROR 110
+#define BIO_R_NON_FATAL 112
+#define BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED 143
+#define BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED 144
+#define BIO_R_NO_PORT_DEFINED 113
+#define BIO_R_NO_SUCH_FILE 128
+#define BIO_R_NULL_PARAMETER 115 /* unused */
+#define BIO_R_TFO_DISABLED 106
+#define BIO_R_TFO_NO_KERNEL_SUPPORT 108
+#define BIO_R_TRANSFER_ERROR 104
+#define BIO_R_TRANSFER_TIMEOUT 105
+#define BIO_R_UNABLE_TO_BIND_SOCKET 117
+#define BIO_R_UNABLE_TO_CREATE_SOCKET 118
+#define BIO_R_UNABLE_TO_KEEPALIVE 137
+#define BIO_R_UNABLE_TO_LISTEN_SOCKET 119
+#define BIO_R_UNABLE_TO_NODELAY 138
+#define BIO_R_UNABLE_TO_REUSEADDR 139
+#define BIO_R_UNABLE_TO_TFO 109
+#define BIO_R_UNAVAILABLE_IP_FAMILY 145
+#define BIO_R_UNINITIALIZED 120
+#define BIO_R_UNKNOWN_INFO_TYPE 140
+#define BIO_R_UNSUPPORTED_IP_FAMILY 146
+#define BIO_R_UNSUPPORTED_METHOD 121
+#define BIO_R_UNSUPPORTED_PROTOCOL_FAMILY 131
+#define BIO_R_WRITE_TO_READ_ONLY_BIO 126
+#define BIO_R_WSASTARTUP 122
+#define BIO_R_PORT_MISMATCH 150
+#define BIO_R_PEER_ADDR_NOT_AVAILABLE 151
+
+#endif

miniconda3/envs/active_proaction/include/openssl/blowfish.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BLOWFISH_H
+#define OPENSSL_BLOWFISH_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_BLOWFISH_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_BF
+#include <openssl/e_os2.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define BF_BLOCK 8
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#define BF_ENCRYPT 1
+#define BF_DECRYPT 0
+
+/*-
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * ! BF_LONG has to be at least 32 bits wide.                     !
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+#define BF_LONG unsigned int
+
+#define BF_ROUNDS 16
+
+typedef struct bf_key_st {
+    BF_LONG P[BF_ROUNDS + 2];
+    BF_LONG S[4 * 256];
+} BF_KEY;
+
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void BF_set_key(BF_KEY *key, int len,
+    const unsigned char *data);
+OSSL_DEPRECATEDIN_3_0 void BF_encrypt(BF_LONG *data, const BF_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void BF_decrypt(BF_LONG *data, const BF_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void BF_ecb_encrypt(const unsigned char *in,
+    unsigned char *out, const BF_KEY *key,
+    int enc);
+OSSL_DEPRECATEDIN_3_0 void BF_cbc_encrypt(const unsigned char *in,
+    unsigned char *out, long length,
+    const BF_KEY *schedule,
+    unsigned char *ivec, int enc);
+OSSL_DEPRECATEDIN_3_0 void BF_cfb64_encrypt(const unsigned char *in,
+    unsigned char *out,
+    long length, const BF_KEY *schedule,
+    unsigned char *ivec, int *num,
+    int enc);
+OSSL_DEPRECATEDIN_3_0 void BF_ofb64_encrypt(const unsigned char *in,
+    unsigned char *out,
+    long length, const BF_KEY *schedule,
+    unsigned char *ivec, int *num);
+OSSL_DEPRECATEDIN_3_0 const char *BF_options(void);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#endif

miniconda3/envs/active_proaction/include/openssl/bn.h

@@ -0,0 +1,588 @@
+/*
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BN_H
+#define OPENSSL_BN_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_BN_H
+#endif
+
+#include <openssl/e_os2.h>
+#ifndef OPENSSL_NO_STDIO
+#include <stdio.h>
+#endif
+#include <openssl/opensslconf.h>
+#include <openssl/types.h>
+#include <openssl/crypto.h>
+#include <openssl/bnerr.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * 64-bit processor with LP64 ABI
+ */
+#ifdef SIXTY_FOUR_BIT_LONG
+#define BN_ULONG unsigned long
+#define BN_BYTES 8
+#endif
+
+/*
+ * 64-bit processor other than LP64 ABI
+ */
+#ifdef SIXTY_FOUR_BIT
+#define BN_ULONG unsigned long long
+#define BN_BYTES 8
+#endif
+
+#ifdef THIRTY_TWO_BIT
+#define BN_ULONG unsigned int
+#define BN_BYTES 4
+#endif
+
+#define BN_BITS2 (BN_BYTES * 8)
+#define BN_BITS (BN_BITS2 * 2)
+#define BN_TBIT ((BN_ULONG)1 << (BN_BITS2 - 1))
+
+#define BN_FLG_MALLOCED 0x01
+#define BN_FLG_STATIC_DATA 0x02
+
+/*
+ * avoid leaking exponent information through timing,
+ * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime,
+ * BN_div() will call BN_div_no_branch,
+ * BN_mod_inverse() will call bn_mod_inverse_no_branch.
+ */
+#define BN_FLG_CONSTTIME 0x04
+#define BN_FLG_SECURE 0x08
+
+#ifndef OPENSSL_NO_DEPRECATED_0_9_8
+/* deprecated name for the flag */
+#define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME
+#define BN_FLG_FREE 0x8000 /* used for debugging */
+#endif
+
+void BN_set_flags(BIGNUM *b, int n);
+int BN_get_flags(const BIGNUM *b, int n);
+
+/* Values for |top| in BN_rand() */
+#define BN_RAND_TOP_ANY -1
+#define BN_RAND_TOP_ONE 0
+#define BN_RAND_TOP_TWO 1
+
+/* Values for |bottom| in BN_rand() */
+#define BN_RAND_BOTTOM_ANY 0
+#define BN_RAND_BOTTOM_ODD 1
+
+/*
+ * get a clone of a BIGNUM with changed flags, for *temporary* use only (the
+ * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The
+ * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that
+ * has not been otherwise initialised or used.
+ */
+void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags);
+
+/* Wrapper function to make using BN_GENCB easier */
+int BN_GENCB_call(BN_GENCB *cb, int a, int b);
+
+BN_GENCB *BN_GENCB_new(void);
+void BN_GENCB_free(BN_GENCB *cb);
+
+/* Populate a BN_GENCB structure with an "old"-style callback */
+void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback)(int, int, void *),
+    void *cb_arg);
+
+/* Populate a BN_GENCB structure with a "new"-style callback */
+void BN_GENCB_set(BN_GENCB *gencb, int (*callback)(int, int, BN_GENCB *),
+    void *cb_arg);
+
+void *BN_GENCB_get_arg(BN_GENCB *cb);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define BN_prime_checks 0 /* default: select number of iterations based \
+                           * on the size of the number */
+
+/*
+ * BN_prime_checks_for_size() returns the number of Miller-Rabin iterations
+ * that will be done for checking that a random number is probably prime. The
+ * error rate for accepting a composite number as prime depends on the size of
+ * the prime |b|. The error rates used are for calculating an RSA key with 2 primes,
+ * and so the level is what you would expect for a key of double the size of the
+ * prime.
+ *
+ * This table is generated using the algorithm of FIPS PUB 186-4
+ * Digital Signature Standard (DSS), section F.1, page 117.
+ * (https://dx.doi.org/10.6028/NIST.FIPS.186-4)
+ *
+ * The following magma script was used to generate the output:
+ * securitybits:=125;
+ * k:=1024;
+ * for t:=1 to 65 do
+ *   for M:=3 to Floor(2*Sqrt(k-1)-1) do
+ *     S:=0;
+ *     // Sum over m
+ *     for m:=3 to M do
+ *       s:=0;
+ *       // Sum over j
+ *       for j:=2 to m do
+ *         s+:=(RealField(32)!2)^-(j+(k-1)/j);
+ *       end for;
+ *       S+:=2^(m-(m-1)*t)*s;
+ *     end for;
+ *     A:=2^(k-2-M*t);
+ *     B:=8*(Pi(RealField(32))^2-6)/3*2^(k-2)*S;
+ *     pkt:=2.00743*Log(2)*k*2^-k*(A+B);
+ *     seclevel:=Floor(-Log(2,pkt));
+ *     if seclevel ge securitybits then
+ *       printf "k: %5o, security: %o bits  (t: %o, M: %o)\n",k,seclevel,t,M;
+ *       break;
+ *     end if;
+ *   end for;
+ *   if seclevel ge securitybits then break; end if;
+ * end for;
+ *
+ * It can be run online at:
+ * http://magma.maths.usyd.edu.au/calc
+ *
+ * And will output:
+ * k:  1024, security: 129 bits  (t: 6, M: 23)
+ *
+ * k is the number of bits of the prime, securitybits is the level we want to
+ * reach.
+ *
+ * prime length | RSA key size | # MR tests | security level
+ * -------------+--------------|------------+---------------
+ *  (b) >= 6394 |     >= 12788 |          3 |        256 bit
+ *  (b) >= 3747 |     >=  7494 |          3 |        192 bit
+ *  (b) >= 1345 |     >=  2690 |          4 |        128 bit
+ *  (b) >= 1080 |     >=  2160 |          5 |        128 bit
+ *  (b) >=  852 |     >=  1704 |          5 |        112 bit
+ *  (b) >=  476 |     >=   952 |          5 |         80 bit
+ *  (b) >=  400 |     >=   800 |          6 |         80 bit
+ *  (b) >=  347 |     >=   694 |          7 |         80 bit
+ *  (b) >=  308 |     >=   616 |          8 |         80 bit
+ *  (b) >=   55 |     >=   110 |         27 |         64 bit
+ *  (b) >=    6 |     >=    12 |         34 |         64 bit
+ */
+
+#define BN_prime_checks_for_size(b) ((b) >= 3747 ? 3 : (b) >= 1345 ? 4  \
+        : (b) >= 476                                               ? 5  \
+        : (b) >= 400                                               ? 6  \
+        : (b) >= 347                                               ? 7  \
+        : (b) >= 308                                               ? 8  \
+        : (b) >= 55                                                ? 27 \
+                                                                   : /* b >= 6 */ 34)
+#endif
+
+#define BN_num_bytes(a) ((BN_num_bits(a) + 7) / 8)
+
+int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w);
+int BN_is_zero(const BIGNUM *a);
+int BN_is_one(const BIGNUM *a);
+int BN_is_word(const BIGNUM *a, const BN_ULONG w);
+int BN_is_odd(const BIGNUM *a);
+
+#define BN_one(a) (BN_set_word((a), 1))
+
+void BN_zero_ex(BIGNUM *a);
+
+#if OPENSSL_API_LEVEL > 908
+#define BN_zero(a) BN_zero_ex(a)
+#else
+#define BN_zero(a) (BN_set_word((a), 0))
+#endif
+
+const BIGNUM *BN_value_one(void);
+char *BN_options(void);
+BN_CTX *BN_CTX_new_ex(OSSL_LIB_CTX *ctx);
+BN_CTX *BN_CTX_new(void);
+BN_CTX *BN_CTX_secure_new_ex(OSSL_LIB_CTX *ctx);
+BN_CTX *BN_CTX_secure_new(void);
+void BN_CTX_free(BN_CTX *c);
+void BN_CTX_start(BN_CTX *ctx);
+BIGNUM *BN_CTX_get(BN_CTX *ctx);
+void BN_CTX_end(BN_CTX *ctx);
+int BN_rand_ex(BIGNUM *rnd, int bits, int top, int bottom,
+    unsigned int strength, BN_CTX *ctx);
+int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);
+int BN_priv_rand_ex(BIGNUM *rnd, int bits, int top, int bottom,
+    unsigned int strength, BN_CTX *ctx);
+int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom);
+int BN_rand_range_ex(BIGNUM *r, const BIGNUM *range, unsigned int strength,
+    BN_CTX *ctx);
+int BN_rand_range(BIGNUM *rnd, const BIGNUM *range);
+int BN_priv_rand_range_ex(BIGNUM *r, const BIGNUM *range,
+    unsigned int strength, BN_CTX *ctx);
+int BN_priv_rand_range(BIGNUM *rnd, const BIGNUM *range);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);
+OSSL_DEPRECATEDIN_3_0
+int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range);
+#endif
+int BN_num_bits(const BIGNUM *a);
+int BN_num_bits_word(BN_ULONG l);
+int BN_security_bits(int L, int N);
+BIGNUM *BN_new(void);
+BIGNUM *BN_secure_new(void);
+void BN_clear_free(BIGNUM *a);
+BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
+void BN_swap(BIGNUM *a, BIGNUM *b);
+BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
+BIGNUM *BN_signed_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2bin(const BIGNUM *a, unsigned char *to);
+int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
+int BN_signed_bn2bin(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
+BIGNUM *BN_signed_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
+int BN_signed_bn2lebin(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_native2bn(const unsigned char *s, int len, BIGNUM *ret);
+BIGNUM *BN_signed_native2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2nativepad(const BIGNUM *a, unsigned char *to, int tolen);
+int BN_signed_bn2native(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
+int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);
+/** BN_set_negative sets sign of a BIGNUM
+ * \param  b  pointer to the BIGNUM object
+ * \param  n  0 if the BIGNUM b should be positive and a value != 0 otherwise
+ */
+void BN_set_negative(BIGNUM *b, int n);
+/** BN_is_negative returns 1 if the BIGNUM is negative
+ * \param  b  pointer to the BIGNUM object
+ * \return 1 if a < 0 and 0 otherwise
+ */
+int BN_is_negative(const BIGNUM *b);
+
+int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
+    BN_CTX *ctx);
+#define BN_mod(rem, m, d, ctx) BN_div(NULL, (rem), (m), (d), (ctx))
+int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
+int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
+    BN_CTX *ctx);
+int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+    const BIGNUM *m);
+int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
+    BN_CTX *ctx);
+int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+    const BIGNUM *m);
+int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
+    BN_CTX *ctx);
+int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);
+int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
+    BN_CTX *ctx);
+int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);
+
+BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);
+BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);
+int BN_mul_word(BIGNUM *a, BN_ULONG w);
+int BN_add_word(BIGNUM *a, BN_ULONG w);
+int BN_sub_word(BIGNUM *a, BN_ULONG w);
+int BN_set_word(BIGNUM *a, BN_ULONG w);
+BN_ULONG BN_get_word(const BIGNUM *a);
+
+int BN_cmp(const BIGNUM *a, const BIGNUM *b);
+void BN_free(BIGNUM *a);
+int BN_is_bit_set(const BIGNUM *a, int n);
+int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
+int BN_lshift1(BIGNUM *r, const BIGNUM *a);
+int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+
+int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+    const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
+    const BIGNUM *m, BN_CTX *ctx,
+    BN_MONT_CTX *in_mont);
+int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p,
+    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,
+    const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
+    BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+    const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_exp_mont_consttime_x2(BIGNUM *rr1, const BIGNUM *a1, const BIGNUM *p1,
+    const BIGNUM *m1, BN_MONT_CTX *in_mont1,
+    BIGNUM *rr2, const BIGNUM *a2, const BIGNUM *p2,
+    const BIGNUM *m2, BN_MONT_CTX *in_mont2,
+    BN_CTX *ctx);
+
+int BN_mask_bits(BIGNUM *a, int n);
+#ifndef OPENSSL_NO_STDIO
+int BN_print_fp(FILE *fp, const BIGNUM *a);
+#endif
+int BN_print(BIO *bio, const BIGNUM *a);
+int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
+int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
+int BN_rshift1(BIGNUM *r, const BIGNUM *a);
+void BN_clear(BIGNUM *a);
+BIGNUM *BN_dup(const BIGNUM *a);
+int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
+int BN_set_bit(BIGNUM *a, int n);
+int BN_clear_bit(BIGNUM *a, int n);
+char *BN_bn2hex(const BIGNUM *a);
+char *BN_bn2dec(const BIGNUM *a);
+int BN_hex2bn(BIGNUM **a, const char *str);
+int BN_dec2bn(BIGNUM **a, const char *str);
+int BN_asc2bn(BIGNUM **a, const char *str);
+int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns
+                                                                  * -2 for
+                                                                  * error */
+int BN_are_coprime(BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+BIGNUM *BN_mod_inverse(BIGNUM *ret,
+    const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
+BIGNUM *BN_mod_sqrt(BIGNUM *ret,
+    const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
+
+void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords);
+
+/* Deprecated versions */
+#ifndef OPENSSL_NO_DEPRECATED_0_9_8
+OSSL_DEPRECATEDIN_0_9_8
+BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe,
+    const BIGNUM *add, const BIGNUM *rem,
+    void (*callback)(int, int, void *),
+    void *cb_arg);
+OSSL_DEPRECATEDIN_0_9_8
+int BN_is_prime(const BIGNUM *p, int nchecks,
+    void (*callback)(int, int, void *),
+    BN_CTX *ctx, void *cb_arg);
+OSSL_DEPRECATEDIN_0_9_8
+int BN_is_prime_fasttest(const BIGNUM *p, int nchecks,
+    void (*callback)(int, int, void *),
+    BN_CTX *ctx, void *cb_arg,
+    int do_trial_division);
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0
+int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx,
+    int do_trial_division, BN_GENCB *cb);
+#endif
+/* Newer versions */
+int BN_generate_prime_ex2(BIGNUM *ret, int bits, int safe,
+    const BIGNUM *add, const BIGNUM *rem, BN_GENCB *cb,
+    BN_CTX *ctx);
+int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add,
+    const BIGNUM *rem, BN_GENCB *cb);
+int BN_check_prime(const BIGNUM *p, BN_CTX *ctx, BN_GENCB *cb);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx);
+
+OSSL_DEPRECATEDIN_3_0
+int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
+    const BIGNUM *Xp, const BIGNUM *Xp1,
+    const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,
+    BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0
+int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1,
+    BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e,
+    BN_CTX *ctx, BN_GENCB *cb);
+#endif
+
+BN_MONT_CTX *BN_MONT_CTX_new(void);
+int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+    BN_MONT_CTX *mont, BN_CTX *ctx);
+int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
+    BN_CTX *ctx);
+int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
+    BN_CTX *ctx);
+void BN_MONT_CTX_free(BN_MONT_CTX *mont);
+int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx);
+BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);
+BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock,
+    const BIGNUM *mod, BN_CTX *ctx);
+
+/* BN_BLINDING flags */
+#define BN_BLINDING_NO_UPDATE 0x00000001
+#define BN_BLINDING_NO_RECREATE 0x00000002
+
+BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
+void BN_BLINDING_free(BN_BLINDING *b);
+int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx);
+int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
+int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
+int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
+int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
+    BN_CTX *);
+
+int BN_BLINDING_is_current_thread(BN_BLINDING *b);
+void BN_BLINDING_set_current_thread(BN_BLINDING *b);
+int BN_BLINDING_lock(BN_BLINDING *b);
+int BN_BLINDING_unlock(BN_BLINDING *b);
+
+unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
+void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
+BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
+    const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
+    int (*bn_mod_exp)(BIGNUM *r,
+        const BIGNUM *a,
+        const BIGNUM *p,
+        const BIGNUM *m,
+        BN_CTX *ctx,
+        BN_MONT_CTX *m_ctx),
+    BN_MONT_CTX *m_ctx);
+#ifndef OPENSSL_NO_DEPRECATED_0_9_8
+OSSL_DEPRECATEDIN_0_9_8
+void BN_set_params(int mul, int high, int low, int mont);
+OSSL_DEPRECATEDIN_0_9_8
+int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */
+#endif
+
+BN_RECP_CTX *BN_RECP_CTX_new(void);
+void BN_RECP_CTX_free(BN_RECP_CTX *recp);
+int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx);
+int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
+    BN_RECP_CTX *recp, BN_CTX *ctx);
+int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+    const BIGNUM *m, BN_CTX *ctx);
+int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
+    BN_RECP_CTX *recp, BN_CTX *ctx);
+
+#ifndef OPENSSL_NO_EC2M
+
+/*
+ * Functions for arithmetic over binary polynomials represented by BIGNUMs.
+ * The BIGNUM::neg property of BIGNUMs representing binary polynomials is
+ * ignored. Note that input arguments are not const so that their bit arrays
+ * can be expanded to the appropriate size if needed.
+ */
+
+/*
+ * r = a + b
+ */
+int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+#define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b)
+/*
+ * r=a mod p
+ */
+int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p);
+/* r = (a * b) mod p */
+int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+    const BIGNUM *p, BN_CTX *ctx);
+/* r = (a * a) mod p */
+int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+/* r = (1 / b) mod p */
+int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx);
+/* r = (a / b) mod p */
+int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+    const BIGNUM *p, BN_CTX *ctx);
+/* r = (a ^ b) mod p */
+int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+    const BIGNUM *p, BN_CTX *ctx);
+/* r = sqrt(a) mod p */
+int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+    BN_CTX *ctx);
+/* r^2 + r = a mod p */
+int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+    BN_CTX *ctx);
+#define BN_GF2m_cmp(a, b) BN_ucmp((a), (b))
+/*-
+ * Some functions allow for representation of the irreducible polynomials
+ * as an unsigned int[], say p.  The irreducible f(t) is then of the form:
+ *     t^p[0] + t^p[1] + ... + t^p[k]
+ * where m = p[0] > p[1] > ... > p[k] = 0.
+ */
+/* r = a mod p */
+int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]);
+/* r = (a * b) mod p */
+int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+    const int p[], BN_CTX *ctx);
+/* r = (a * a) mod p */
+int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[],
+    BN_CTX *ctx);
+/* r = (1 / b) mod p */
+int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[],
+    BN_CTX *ctx);
+/* r = (a / b) mod p */
+int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+    const int p[], BN_CTX *ctx);
+/* r = (a ^ b) mod p */
+int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+    const int p[], BN_CTX *ctx);
+/* r = sqrt(a) mod p */
+int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a,
+    const int p[], BN_CTX *ctx);
+/* r^2 + r = a mod p */
+int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a,
+    const int p[], BN_CTX *ctx);
+int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max);
+int BN_GF2m_arr2poly(const int p[], BIGNUM *a);
+
+#endif
+
+/*
+ * faster mod functions for the 'NIST primes' 0 <= a < p^2
+ */
+int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+
+const BIGNUM *BN_get0_nist_prime_192(void);
+const BIGNUM *BN_get0_nist_prime_224(void);
+const BIGNUM *BN_get0_nist_prime_256(void);
+const BIGNUM *BN_get0_nist_prime_384(void);
+const BIGNUM *BN_get0_nist_prime_521(void);
+
+int (*BN_nist_mod_func(const BIGNUM *p))(BIGNUM *r, const BIGNUM *a,
+    const BIGNUM *field, BN_CTX *ctx);
+
+int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range,
+    const BIGNUM *priv, const unsigned char *message,
+    size_t message_len, BN_CTX *ctx);
+
+/* Primes from RFC 2409 */
+BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn);
+BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn);
+
+/* Primes from RFC 3526 */
+BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define get_rfc2409_prime_768 BN_get_rfc2409_prime_768
+#define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024
+#define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536
+#define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048
+#define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072
+#define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096
+#define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144
+#define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192
+#endif
+
+int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/bnerr.h

@@ -0,0 +1,45 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BNERR_H
+#define OPENSSL_BNERR_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
+
+/*
+ * BN reason codes.
+ */
+#define BN_R_ARG2_LT_ARG3 100
+#define BN_R_BAD_RECIPROCAL 101
+#define BN_R_BIGNUM_TOO_LONG 114
+#define BN_R_BITS_TOO_SMALL 118
+#define BN_R_CALLED_WITH_EVEN_MODULUS 102
+#define BN_R_DIV_BY_ZERO 103
+#define BN_R_ENCODING_ERROR 104
+#define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105
+#define BN_R_INPUT_NOT_REDUCED 110
+#define BN_R_INVALID_LENGTH 106
+#define BN_R_INVALID_RANGE 115
+#define BN_R_INVALID_SHIFT 119
+#define BN_R_NOT_A_SQUARE 111
+#define BN_R_NOT_INITIALIZED 107
+#define BN_R_NO_INVERSE 108
+#define BN_R_NO_PRIME_CANDIDATE 121
+#define BN_R_NO_SOLUTION 116
+#define BN_R_NO_SUITABLE_DIGEST 120
+#define BN_R_PRIVATE_KEY_TOO_LARGE 117
+#define BN_R_P_IS_NOT_PRIME 112
+#define BN_R_TOO_MANY_ITERATIONS 113
+#define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109
+
+#endif

miniconda3/envs/active_proaction/include/openssl/buffer.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BUFFER_H
+#define OPENSSL_BUFFER_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_BUFFER_H
+#endif
+
+#include <openssl/types.h>
+#ifndef OPENSSL_CRYPTO_H
+#include <openssl/crypto.h>
+#endif
+#include <openssl/buffererr.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <sys/types.h>
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define BUF_strdup(s) OPENSSL_strdup(s)
+#define BUF_strndup(s, size) OPENSSL_strndup(s, size)
+#define BUF_memdup(data, size) OPENSSL_memdup(data, size)
+#define BUF_strlcpy(dst, src, size) OPENSSL_strlcpy(dst, src, size)
+#define BUF_strlcat(dst, src, size) OPENSSL_strlcat(dst, src, size)
+#define BUF_strnlen(str, maxlen) OPENSSL_strnlen(str, maxlen)
+#endif
+
+struct buf_mem_st {
+    size_t length; /* current number of bytes */
+    char *data;
+    size_t max; /* size of buffer */
+    unsigned long flags;
+};
+
+#define BUF_MEM_FLAG_SECURE 0x01
+
+BUF_MEM *BUF_MEM_new(void);
+BUF_MEM *BUF_MEM_new_ex(unsigned long flags);
+void BUF_MEM_free(BUF_MEM *a);
+size_t BUF_MEM_grow(BUF_MEM *str, size_t len);
+size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len);
+void BUF_reverse(unsigned char *out, const unsigned char *in, size_t siz);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/buffererr.h

@@ -0,0 +1,23 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BUFFERERR_H
+#define OPENSSL_BUFFERERR_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
+
+/*
+ * BUF reason codes.
+ */
+
+#endif

miniconda3/envs/active_proaction/include/openssl/byteorder.h

@@ -0,0 +1,339 @@
+/*
+ * Copyright 2025 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BYTEORDER_H
+#define OPENSSL_BYTEORDER_H
+#pragma once
+
+#include <openssl/e_os2.h>
+#include <string.h>
+
+/*
+ * "Modern" compilers do a decent job of optimising these functions to just a
+ * couple of instruction ([swap +] store, or load [+ swap]) when either no
+ * swapping is required, or a suitable swap instruction is available.
+ */
+
+#if defined(_MSC_VER) && _MSC_VER >= 1300
+#include <stdlib.h>
+#pragma intrinsic(_byteswap_ushort)
+#pragma intrinsic(_byteswap_ulong)
+#pragma intrinsic(_byteswap_uint64)
+#define OSSL_HTOBE16(x) _byteswap_ushort(x)
+#define OSSL_HTOBE32(x) _byteswap_ulong(x)
+#define OSSL_HTOBE64(x) _byteswap_uint64(x)
+#define OSSL_BE16TOH(x) _byteswap_ushort(x)
+#define OSSL_BE32TOH(x) _byteswap_ulong(x)
+#define OSSL_BE64TOH(x) _byteswap_uint64(x)
+#define OSSL_HTOLE16(x) (x)
+#define OSSL_HTOLE32(x) (x)
+#define OSSL_HTOLE64(x) (x)
+#define OSSL_LE16TOH(x) (x)
+#define OSSL_LE32TOH(x) (x)
+#define OSSL_LE64TOH(x) (x)
+
+#elif defined(__GLIBC__) && defined(__GLIBC_PREREQ)
+#if (__GLIBC_PREREQ(2, 19)) && defined(_DEFAULT_SOURCE)
+#include <endian.h>
+#define OSSL_HTOBE16(x) htobe16(x)
+#define OSSL_HTOBE32(x) htobe32(x)
+#define OSSL_HTOBE64(x) htobe64(x)
+#define OSSL_BE16TOH(x) be16toh(x)
+#define OSSL_BE32TOH(x) be32toh(x)
+#define OSSL_BE64TOH(x) be64toh(x)
+#define OSSL_HTOLE16(x) htole16(x)
+#define OSSL_HTOLE32(x) htole32(x)
+#define OSSL_HTOLE64(x) htole64(x)
+#define OSSL_LE16TOH(x) le16toh(x)
+#define OSSL_LE32TOH(x) le32toh(x)
+#define OSSL_LE64TOH(x) le64toh(x)
+#endif
+
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#if defined(__OpenBSD__)
+#include <sys/types.h>
+#else
+#include <sys/endian.h>
+#endif
+#define OSSL_HTOBE16(x) htobe16(x)
+#define OSSL_HTOBE32(x) htobe32(x)
+#define OSSL_HTOBE64(x) htobe64(x)
+#define OSSL_BE16TOH(x) be16toh(x)
+#define OSSL_BE32TOH(x) be32toh(x)
+#define OSSL_BE64TOH(x) be64toh(x)
+#define OSSL_HTOLE16(x) htole16(x)
+#define OSSL_HTOLE32(x) htole32(x)
+#define OSSL_HTOLE64(x) htole64(x)
+#define OSSL_LE16TOH(x) le16toh(x)
+#define OSSL_LE32TOH(x) le32toh(x)
+#define OSSL_LE64TOH(x) le64toh(x)
+
+#elif defined(__APPLE__)
+#include <libkern/OSByteOrder.h>
+#define OSSL_HTOBE16(x) OSSwapHostToBigInt16(x)
+#define OSSL_HTOBE32(x) OSSwapHostToBigInt32(x)
+#define OSSL_HTOBE64(x) OSSwapHostToBigInt64(x)
+#define OSSL_BE16TOH(x) OSSwapBigToHostInt16(x)
+#define OSSL_BE32TOH(x) OSSwapBigToHostInt32(x)
+#define OSSL_BE64TOH(x) OSSwapBigToHostInt64(x)
+#define OSSL_HTOLE16(x) OSSwapHostToLittleInt16(x)
+#define OSSL_HTOLE32(x) OSSwapHostToLittleInt32(x)
+#define OSSL_HTOLE64(x) OSSwapHostToLittleInt64(x)
+#define OSSL_LE16TOH(x) OSSwapLittleToHostInt16(x)
+#define OSSL_LE32TOH(x) OSSwapLittleToHostInt32(x)
+#define OSSL_LE64TOH(x) OSSwapLittleToHostInt64(x)
+
+#endif
+
+static ossl_inline ossl_unused unsigned char *
+OPENSSL_store_u16_le(unsigned char *out, uint16_t val)
+{
+#ifdef OSSL_HTOLE16
+    uint16_t t = OSSL_HTOLE16(val);
+
+    memcpy(out, (unsigned char *)&t, 2);
+    return out + 2;
+#else
+    *out++ = (val & 0xff);
+    *out++ = (val >> 8) & 0xff;
+    return out;
+#endif
+}
+
+static ossl_inline ossl_unused unsigned char *
+OPENSSL_store_u16_be(unsigned char *out, uint16_t val)
+{
+#ifdef OSSL_HTOBE16
+    uint16_t t = OSSL_HTOBE16(val);
+
+    memcpy(out, (unsigned char *)&t, 2);
+    return out + 2;
+#else
+    *out++ = (val >> 8) & 0xff;
+    *out++ = (val & 0xff);
+    return out;
+#endif
+}
+
+static ossl_inline ossl_unused unsigned char *
+OPENSSL_store_u32_le(unsigned char *out, uint32_t val)
+{
+#ifdef OSSL_HTOLE32
+    uint32_t t = OSSL_HTOLE32(val);
+
+    memcpy(out, (unsigned char *)&t, 4);
+    return out + 4;
+#else
+    *out++ = (val & 0xff);
+    *out++ = (val >> 8) & 0xff;
+    *out++ = (val >> 16) & 0xff;
+    *out++ = (val >> 24) & 0xff;
+    return out;
+#endif
+}
+
+static ossl_inline ossl_unused unsigned char *
+OPENSSL_store_u32_be(unsigned char *out, uint32_t val)
+{
+#ifdef OSSL_HTOBE32
+    uint32_t t = OSSL_HTOBE32(val);
+
+    memcpy(out, (unsigned char *)&t, 4);
+    return out + 4;
+#else
+    *out++ = (val >> 24) & 0xff;
+    *out++ = (val >> 16) & 0xff;
+    *out++ = (val >> 8) & 0xff;
+    *out++ = (val & 0xff);
+    return out;
+#endif
+}
+
+static ossl_inline ossl_unused unsigned char *
+OPENSSL_store_u64_le(unsigned char *out, uint64_t val)
+{
+#ifdef OSSL_HTOLE64
+    uint64_t t = OSSL_HTOLE64(val);
+
+    memcpy(out, (unsigned char *)&t, 8);
+    return out + 8;
+#else
+    *out++ = (val & 0xff);
+    *out++ = (val >> 8) & 0xff;
+    *out++ = (val >> 16) & 0xff;
+    *out++ = (val >> 24) & 0xff;
+    *out++ = (val >> 32) & 0xff;
+    *out++ = (val >> 40) & 0xff;
+    *out++ = (val >> 48) & 0xff;
+    *out++ = (val >> 56) & 0xff;
+    return out;
+#endif
+}
+
+static ossl_inline ossl_unused unsigned char *
+OPENSSL_store_u64_be(unsigned char *out, uint64_t val)
+{
+#ifdef OSSL_HTOLE64
+    uint64_t t = OSSL_HTOBE64(val);
+
+    memcpy(out, (unsigned char *)&t, 8);
+    return out + 8;
+#else
+    *out++ = (val >> 56) & 0xff;
+    *out++ = (val >> 48) & 0xff;
+    *out++ = (val >> 40) & 0xff;
+    *out++ = (val >> 32) & 0xff;
+    *out++ = (val >> 24) & 0xff;
+    *out++ = (val >> 16) & 0xff;
+    *out++ = (val >> 8) & 0xff;
+    *out++ = (val & 0xff);
+    return out;
+#endif
+}
+
+static ossl_inline ossl_unused const unsigned char *
+OPENSSL_load_u16_le(uint16_t *val, const unsigned char *in)
+{
+#ifdef OSSL_LE16TOH
+    uint16_t t;
+
+    memcpy((unsigned char *)&t, in, 2);
+    *val = OSSL_LE16TOH(t);
+    return in + 2;
+#else
+    uint16_t b0 = *in++;
+    uint16_t b1 = *in++;
+
+    *val = b0 | (b1 << 8);
+    return in;
+#endif
+}
+
+static ossl_inline ossl_unused const unsigned char *
+OPENSSL_load_u16_be(uint16_t *val, const unsigned char *in)
+{
+#ifdef OSSL_LE16TOH
+    uint16_t t;
+
+    memcpy((unsigned char *)&t, in, 2);
+    *val = OSSL_BE16TOH(t);
+    return in + 2;
+#else
+    uint16_t b1 = *in++;
+    uint16_t b0 = *in++;
+
+    *val = b0 | (b1 << 8);
+    return in;
+#endif
+}
+
+static ossl_inline ossl_unused const unsigned char *
+OPENSSL_load_u32_le(uint32_t *val, const unsigned char *in)
+{
+#ifdef OSSL_LE32TOH
+    uint32_t t;
+
+    memcpy((unsigned char *)&t, in, 4);
+    *val = OSSL_LE32TOH(t);
+    return in + 4;
+#else
+    uint32_t b0 = *in++;
+    uint32_t b1 = *in++;
+    uint32_t b2 = *in++;
+    uint32_t b3 = *in++;
+
+    *val = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
+    return in;
+#endif
+}
+
+static ossl_inline ossl_unused const unsigned char *
+OPENSSL_load_u32_be(uint32_t *val, const unsigned char *in)
+{
+#ifdef OSSL_LE32TOH
+    uint32_t t;
+
+    memcpy((unsigned char *)&t, in, 4);
+    *val = OSSL_BE32TOH(t);
+    return in + 4;
+#else
+    uint32_t b3 = *in++;
+    uint32_t b2 = *in++;
+    uint32_t b1 = *in++;
+    uint32_t b0 = *in++;
+
+    *val = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
+    return in;
+#endif
+}
+
+static ossl_inline ossl_unused const unsigned char *
+OPENSSL_load_u64_le(uint64_t *val, const unsigned char *in)
+{
+#ifdef OSSL_LE64TOH
+    uint64_t t;
+
+    memcpy((unsigned char *)&t, in, 8);
+    *val = OSSL_LE64TOH(t);
+    return in + 8;
+#else
+    uint64_t b0 = *in++;
+    uint64_t b1 = *in++;
+    uint64_t b2 = *in++;
+    uint64_t b3 = *in++;
+    uint64_t b4 = *in++;
+    uint64_t b5 = *in++;
+    uint64_t b6 = *in++;
+    uint64_t b7 = *in++;
+
+    *val = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24)
+        | (b4 << 32) | (b5 << 40) | (b6 << 48) | (b7 << 56);
+    return in;
+#endif
+}
+
+static ossl_inline ossl_unused const unsigned char *
+OPENSSL_load_u64_be(uint64_t *val, const unsigned char *in)
+{
+#ifdef OSSL_LE64TOH
+    uint64_t t;
+
+    memcpy((unsigned char *)&t, in, 8);
+    *val = OSSL_BE64TOH(t);
+    return in + 8;
+#else
+    uint64_t b7 = *in++;
+    uint64_t b6 = *in++;
+    uint64_t b5 = *in++;
+    uint64_t b4 = *in++;
+    uint64_t b3 = *in++;
+    uint64_t b2 = *in++;
+    uint64_t b1 = *in++;
+    uint64_t b0 = *in++;
+
+    *val = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24)
+        | (b4 << 32) | (b5 << 40) | (b6 << 48) | (b7 << 56);
+    return in;
+#endif
+}
+
+#undef OSSL_HTOBE16
+#undef OSSL_HTOBE32
+#undef OSSL_HTOBE64
+#undef OSSL_BE16TOH
+#undef OSSL_BE32TOH
+#undef OSSL_BE64TOH
+#undef OSSL_HTOLE16
+#undef OSSL_HTOLE32
+#undef OSSL_HTOLE64
+#undef OSSL_LE16TOH
+#undef OSSL_LE32TOH
+#undef OSSL_LE64TOH
+
+#endif

miniconda3/envs/active_proaction/include/openssl/camellia.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2006-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CAMELLIA_H
+#define OPENSSL_CAMELLIA_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CAMELLIA_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_CAMELLIA
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CAMELLIA_BLOCK_SIZE 16
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#define CAMELLIA_ENCRYPT 1
+#define CAMELLIA_DECRYPT 0
+
+/*
+ * Because array size can't be a const in C, the following two are macros.
+ * Both sizes are in bytes.
+ */
+
+/* This should be a hidden type, but EVP requires that the size be known */
+
+#define CAMELLIA_TABLE_BYTE_LEN 272
+#define CAMELLIA_TABLE_WORD_LEN (CAMELLIA_TABLE_BYTE_LEN / 4)
+
+typedef unsigned int KEY_TABLE_TYPE[CAMELLIA_TABLE_WORD_LEN]; /* to match
+                                                               * with WORD */
+
+struct camellia_key_st {
+    union {
+        double d; /* ensures 64-bit align */
+        KEY_TABLE_TYPE rd_key;
+    } u;
+    int grand_rounds;
+};
+typedef struct camellia_key_st CAMELLIA_KEY;
+
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int Camellia_set_key(const unsigned char *userKey,
+    const int bits,
+    CAMELLIA_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void Camellia_encrypt(const unsigned char *in,
+    unsigned char *out,
+    const CAMELLIA_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void Camellia_decrypt(const unsigned char *in,
+    unsigned char *out,
+    const CAMELLIA_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void Camellia_ecb_encrypt(const unsigned char *in,
+    unsigned char *out,
+    const CAMELLIA_KEY *key,
+    const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cbc_encrypt(const unsigned char *in,
+    unsigned char *out,
+    size_t length,
+    const CAMELLIA_KEY *key,
+    unsigned char *ivec,
+    const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cfb128_encrypt(const unsigned char *in,
+    unsigned char *out,
+    size_t length,
+    const CAMELLIA_KEY *key,
+    unsigned char *ivec,
+    int *num,
+    const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cfb1_encrypt(const unsigned char *in,
+    unsigned char *out,
+    size_t length,
+    const CAMELLIA_KEY *key,
+    unsigned char *ivec,
+    int *num,
+    const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cfb8_encrypt(const unsigned char *in,
+    unsigned char *out,
+    size_t length,
+    const CAMELLIA_KEY *key,
+    unsigned char *ivec,
+    int *num,
+    const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_ofb128_encrypt(const unsigned char *in,
+    unsigned char *out,
+    size_t length,
+    const CAMELLIA_KEY *key,
+    unsigned char *ivec,
+    int *num);
+OSSL_DEPRECATEDIN_3_0
+void Camellia_ctr128_encrypt(const unsigned char *in, unsigned char *out,
+    size_t length, const CAMELLIA_KEY *key,
+    unsigned char ivec[CAMELLIA_BLOCK_SIZE],
+    unsigned char ecount_buf[CAMELLIA_BLOCK_SIZE],
+    unsigned int *num);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#endif

miniconda3/envs/active_proaction/include/openssl/cast.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CAST_H
+#define OPENSSL_CAST_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CAST_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_CAST
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CAST_BLOCK 8
+#define CAST_KEY_LENGTH 16
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#define CAST_ENCRYPT 1
+#define CAST_DECRYPT 0
+
+#define CAST_LONG unsigned int
+
+typedef struct cast_key_st {
+    CAST_LONG data[32];
+    int short_key; /* Use reduced rounds for short key */
+} CAST_KEY;
+
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data);
+OSSL_DEPRECATEDIN_3_0
+void CAST_ecb_encrypt(const unsigned char *in, unsigned char *out,
+    const CAST_KEY *key, int enc);
+OSSL_DEPRECATEDIN_3_0
+void CAST_encrypt(CAST_LONG *data, const CAST_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void CAST_decrypt(CAST_LONG *data, const CAST_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void CAST_cbc_encrypt(const unsigned char *in, unsigned char *out,
+    long length, const CAST_KEY *ks, unsigned char *iv,
+    int enc);
+OSSL_DEPRECATEDIN_3_0
+void CAST_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+    long length, const CAST_KEY *schedule,
+    unsigned char *ivec, int *num, int enc);
+OSSL_DEPRECATEDIN_3_0
+void CAST_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+    long length, const CAST_KEY *schedule,
+    unsigned char *ivec, int *num);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#endif

miniconda3/envs/active_proaction/include/openssl/cmac.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMAC_H
+#define OPENSSL_CMAC_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CMAC_H
+#endif
+
+#ifndef OPENSSL_NO_CMAC
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <openssl/evp.h>
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+/* Opaque */
+typedef struct CMAC_CTX_st CMAC_CTX;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 CMAC_CTX *CMAC_CTX_new(void);
+OSSL_DEPRECATEDIN_3_0 void CMAC_CTX_cleanup(CMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 void CMAC_CTX_free(CMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 EVP_CIPHER_CTX *CMAC_CTX_get0_cipher_ctx(CMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 int CMAC_CTX_copy(CMAC_CTX *out, const CMAC_CTX *in);
+OSSL_DEPRECATEDIN_3_0 int CMAC_Init(CMAC_CTX *ctx,
+    const void *key, size_t keylen,
+    const EVP_CIPHER *cipher, ENGINE *impl);
+OSSL_DEPRECATEDIN_3_0 int CMAC_Update(CMAC_CTX *ctx,
+    const void *data, size_t dlen);
+OSSL_DEPRECATEDIN_3_0 int CMAC_Final(CMAC_CTX *ctx,
+    unsigned char *out, size_t *poutlen);
+OSSL_DEPRECATEDIN_3_0 int CMAC_resume(CMAC_CTX *ctx);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/cmp.h

@@ -0,0 +1,739 @@
+/*
+ * WARNING: do not edit!
+ * Generated by Makefile from include/openssl/cmp.h.in
+ *
+ * Copyright 2007-2024 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright Nokia 2007-2019
+ * Copyright Siemens AG 2015-2019
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/* clang-format off */
+
+/* clang-format on */
+
+#ifndef OPENSSL_CMP_H
+#define OPENSSL_CMP_H
+
+#include <openssl/opensslconf.h>
+#ifndef OPENSSL_NO_CMP
+
+#include <openssl/crmf.h>
+#include <openssl/cmperr.h>
+#include <openssl/cmp_util.h>
+#include <openssl/http.h>
+
+/* explicit #includes not strictly needed since implied by the above: */
+#include <openssl/types.h>
+#include <openssl/safestack.h>
+#include <openssl/x509.h>
+#include <openssl/x509v3.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OSSL_CMP_PVNO_2 2
+#define OSSL_CMP_PVNO_3 3
+#define OSSL_CMP_PVNO OSSL_CMP_PVNO_2 /* v2 is the default */
+
+/*-
+ *   PKIFailureInfo ::= BIT STRING {
+ *   -- since we can fail in more than one way!
+ *   -- More codes may be added in the future if/when required.
+ *       badAlg              (0),
+ *       -- unrecognized or unsupported Algorithm Identifier
+ *       badMessageCheck     (1),
+ *       -- integrity check failed (e.g., signature did not verify)
+ *       badRequest          (2),
+ *       -- transaction not permitted or supported
+ *       badTime             (3),
+ *       -- messageTime was not sufficiently close to the system time,
+ *       -- as defined by local policy
+ *       badCertId           (4),
+ *       -- no certificate could be found matching the provided criteria
+ *       badDataFormat       (5),
+ *       -- the data submitted has the wrong format
+ *       wrongAuthority      (6),
+ *       -- the authority indicated in the request is different from the
+ *       -- one creating the response token
+ *       incorrectData       (7),
+ *       -- the requester's data is incorrect (for notary services)
+ *       missingTimeStamp    (8),
+ *       -- when the timestamp is missing but should be there
+ *       -- (by policy)
+ *       badPOP              (9),
+ *       -- the proof-of-possession failed
+ *       certRevoked         (10),
+ *          -- the certificate has already been revoked
+ *       certConfirmed       (11),
+ *          -- the certificate has already been confirmed
+ *       wrongIntegrity      (12),
+ *          -- invalid integrity, password based instead of signature or
+ *          -- vice versa
+ *       badRecipientNonce   (13),
+ *          -- invalid recipient nonce, either missing or wrong value
+ *       timeNotAvailable    (14),
+ *          -- the TSA's time source is not available
+ *       unacceptedPolicy    (15),
+ *          -- the requested TSA policy is not supported by the TSA.
+ *       unacceptedExtension (16),
+ *          -- the requested extension is not supported by the TSA.
+ *       addInfoNotAvailable (17),
+ *          -- the additional information requested could not be
+ *          -- understood or is not available
+ *       badSenderNonce      (18),
+ *          -- invalid sender nonce, either missing or wrong size
+ *       badCertTemplate     (19),
+ *          -- invalid cert. template or missing mandatory information
+ *       signerNotTrusted    (20),
+ *          -- signer of the message unknown or not trusted
+ *       transactionIdInUse  (21),
+ *          -- the transaction identifier is already in use
+ *       unsupportedVersion  (22),
+ *          -- the version of the message is not supported
+ *       notAuthorized       (23),
+ *          -- the sender was not authorized to make the preceding
+ *          -- request or perform the preceding action
+ *       systemUnavail       (24),
+ *       -- the request cannot be handled due to system unavailability
+ *       systemFailure       (25),
+ *       -- the request cannot be handled due to system failure
+ *       duplicateCertReq    (26)
+ *       -- certificate cannot be issued because a duplicate
+ *       -- certificate already exists
+ *   }
+ */
+#define OSSL_CMP_PKIFAILUREINFO_badAlg 0
+#define OSSL_CMP_PKIFAILUREINFO_badMessageCheck 1
+#define OSSL_CMP_PKIFAILUREINFO_badRequest 2
+#define OSSL_CMP_PKIFAILUREINFO_badTime 3
+#define OSSL_CMP_PKIFAILUREINFO_badCertId 4
+#define OSSL_CMP_PKIFAILUREINFO_badDataFormat 5
+#define OSSL_CMP_PKIFAILUREINFO_wrongAuthority 6
+#define OSSL_CMP_PKIFAILUREINFO_incorrectData 7
+#define OSSL_CMP_PKIFAILUREINFO_missingTimeStamp 8
+#define OSSL_CMP_PKIFAILUREINFO_badPOP 9
+#define OSSL_CMP_PKIFAILUREINFO_certRevoked 10
+#define OSSL_CMP_PKIFAILUREINFO_certConfirmed 11
+#define OSSL_CMP_PKIFAILUREINFO_wrongIntegrity 12
+#define OSSL_CMP_PKIFAILUREINFO_badRecipientNonce 13
+#define OSSL_CMP_PKIFAILUREINFO_timeNotAvailable 14
+#define OSSL_CMP_PKIFAILUREINFO_unacceptedPolicy 15
+#define OSSL_CMP_PKIFAILUREINFO_unacceptedExtension 16
+#define OSSL_CMP_PKIFAILUREINFO_addInfoNotAvailable 17
+#define OSSL_CMP_PKIFAILUREINFO_badSenderNonce 18
+#define OSSL_CMP_PKIFAILUREINFO_badCertTemplate 19
+#define OSSL_CMP_PKIFAILUREINFO_signerNotTrusted 20
+#define OSSL_CMP_PKIFAILUREINFO_transactionIdInUse 21
+#define OSSL_CMP_PKIFAILUREINFO_unsupportedVersion 22
+#define OSSL_CMP_PKIFAILUREINFO_notAuthorized 23
+#define OSSL_CMP_PKIFAILUREINFO_systemUnavail 24
+#define OSSL_CMP_PKIFAILUREINFO_systemFailure 25
+#define OSSL_CMP_PKIFAILUREINFO_duplicateCertReq 26
+#define OSSL_CMP_PKIFAILUREINFO_MAX 26
+#define OSSL_CMP_PKIFAILUREINFO_MAX_BIT_PATTERN \
+    ((1 << (OSSL_CMP_PKIFAILUREINFO_MAX + 1)) - 1)
+#if OSSL_CMP_PKIFAILUREINFO_MAX_BIT_PATTERN > INT_MAX
+#error CMP_PKIFAILUREINFO_MAX bit pattern does not fit in type int
+#endif
+typedef ASN1_BIT_STRING OSSL_CMP_PKIFAILUREINFO;
+
+#define OSSL_CMP_CTX_FAILINFO_badAlg (1 << 0)
+#define OSSL_CMP_CTX_FAILINFO_badMessageCheck (1 << 1)
+#define OSSL_CMP_CTX_FAILINFO_badRequest (1 << 2)
+#define OSSL_CMP_CTX_FAILINFO_badTime (1 << 3)
+#define OSSL_CMP_CTX_FAILINFO_badCertId (1 << 4)
+#define OSSL_CMP_CTX_FAILINFO_badDataFormat (1 << 5)
+#define OSSL_CMP_CTX_FAILINFO_wrongAuthority (1 << 6)
+#define OSSL_CMP_CTX_FAILINFO_incorrectData (1 << 7)
+#define OSSL_CMP_CTX_FAILINFO_missingTimeStamp (1 << 8)
+#define OSSL_CMP_CTX_FAILINFO_badPOP (1 << 9)
+#define OSSL_CMP_CTX_FAILINFO_certRevoked (1 << 10)
+#define OSSL_CMP_CTX_FAILINFO_certConfirmed (1 << 11)
+#define OSSL_CMP_CTX_FAILINFO_wrongIntegrity (1 << 12)
+#define OSSL_CMP_CTX_FAILINFO_badRecipientNonce (1 << 13)
+#define OSSL_CMP_CTX_FAILINFO_timeNotAvailable (1 << 14)
+#define OSSL_CMP_CTX_FAILINFO_unacceptedPolicy (1 << 15)
+#define OSSL_CMP_CTX_FAILINFO_unacceptedExtension (1 << 16)
+#define OSSL_CMP_CTX_FAILINFO_addInfoNotAvailable (1 << 17)
+#define OSSL_CMP_CTX_FAILINFO_badSenderNonce (1 << 18)
+#define OSSL_CMP_CTX_FAILINFO_badCertTemplate (1 << 19)
+#define OSSL_CMP_CTX_FAILINFO_signerNotTrusted (1 << 20)
+#define OSSL_CMP_CTX_FAILINFO_transactionIdInUse (1 << 21)
+#define OSSL_CMP_CTX_FAILINFO_unsupportedVersion (1 << 22)
+#define OSSL_CMP_CTX_FAILINFO_notAuthorized (1 << 23)
+#define OSSL_CMP_CTX_FAILINFO_systemUnavail (1 << 24)
+#define OSSL_CMP_CTX_FAILINFO_systemFailure (1 << 25)
+#define OSSL_CMP_CTX_FAILINFO_duplicateCertReq (1 << 26)
+
+/*-
+ *   PKIStatus ::= INTEGER {
+ *       accepted                (0),
+ *       -- you got exactly what you asked for
+ *       grantedWithMods        (1),
+ *       -- you got something like what you asked for; the
+ *       -- requester is responsible for ascertaining the differences
+ *       rejection              (2),
+ *       -- you don't get it, more information elsewhere in the message
+ *       waiting                (3),
+ *       -- the request body part has not yet been processed; expect to
+ *       -- hear more later (note: proper handling of this status
+ *       -- response MAY use the polling req/rep PKIMessages specified
+ *       -- in Section 5.3.22; alternatively, polling in the underlying
+ *       -- transport layer MAY have some utility in this regard)
+ *       revocationWarning      (4),
+ *       -- this message contains a warning that a revocation is
+ *       -- imminent
+ *       revocationNotification (5),
+ *       -- notification that a revocation has occurred
+ *       keyUpdateWarning       (6)
+ *       -- update already done for the oldCertId specified in
+ *       -- CertReqMsg
+ *   }
+ */
+#define OSSL_CMP_PKISTATUS_request -3
+#define OSSL_CMP_PKISTATUS_trans -2
+#define OSSL_CMP_PKISTATUS_unspecified -1
+#define OSSL_CMP_PKISTATUS_accepted 0
+#define OSSL_CMP_PKISTATUS_grantedWithMods 1
+#define OSSL_CMP_PKISTATUS_rejection 2
+#define OSSL_CMP_PKISTATUS_waiting 3
+#define OSSL_CMP_PKISTATUS_revocationWarning 4
+#define OSSL_CMP_PKISTATUS_revocationNotification 5
+#define OSSL_CMP_PKISTATUS_keyUpdateWarning 6
+typedef ASN1_INTEGER OSSL_CMP_PKISTATUS;
+
+DECLARE_ASN1_ITEM(OSSL_CMP_PKISTATUS)
+
+#define OSSL_CMP_CERTORENCCERT_CERTIFICATE 0
+#define OSSL_CMP_CERTORENCCERT_ENCRYPTEDCERT 1
+
+/* data type declarations */
+typedef struct ossl_cmp_ctx_st OSSL_CMP_CTX;
+typedef struct ossl_cmp_pkiheader_st OSSL_CMP_PKIHEADER;
+DECLARE_ASN1_FUNCTIONS(OSSL_CMP_PKIHEADER)
+typedef struct ossl_cmp_msg_st OSSL_CMP_MSG;
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_MSG)
+DECLARE_ASN1_ENCODE_FUNCTIONS(OSSL_CMP_MSG, OSSL_CMP_MSG, OSSL_CMP_MSG)
+typedef struct ossl_cmp_certstatus_st OSSL_CMP_CERTSTATUS;
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTSTATUS, OSSL_CMP_CERTSTATUS, OSSL_CMP_CERTSTATUS)
+#define sk_OSSL_CMP_CERTSTATUS_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_value(sk, idx) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTSTATUS_new(cmp) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTSTATUS_new_null() ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTSTATUS_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTSTATUS_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (n))
+#define sk_OSSL_CMP_CERTSTATUS_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_delete(sk, i) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTSTATUS_delete_ptr(sk, ptr) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr)))
+#define sk_OSSL_CMP_CERTSTATUS_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_pop(sk) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_shift(sk) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk),ossl_check_OSSL_CMP_CERTSTATUS_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTSTATUS_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr), (idx))
+#define sk_OSSL_CMP_CERTSTATUS_set(sk, idx, ptr) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr)))
+#define sk_OSSL_CMP_CERTSTATUS_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr), pnum)
+#define sk_OSSL_CMP_CERTSTATUS_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_dup(sk) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTSTATUS_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTSTATUS_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTSTATUS_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp)))
+
+/* clang-format on */
+typedef struct ossl_cmp_itav_st OSSL_CMP_ITAV;
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_ITAV)
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_ITAV, OSSL_CMP_ITAV, OSSL_CMP_ITAV)
+#define sk_OSSL_CMP_ITAV_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_value(sk, idx) ((OSSL_CMP_ITAV *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_ITAV_new(cmp) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp)))
+#define sk_OSSL_CMP_ITAV_new_null() ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_ITAV_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_ITAV_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (n))
+#define sk_OSSL_CMP_ITAV_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_delete(sk, i) ((OSSL_CMP_ITAV *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (i)))
+#define sk_OSSL_CMP_ITAV_delete_ptr(sk, ptr) ((OSSL_CMP_ITAV *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr)))
+#define sk_OSSL_CMP_ITAV_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_pop(sk) ((OSSL_CMP_ITAV *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_shift(sk) ((OSSL_CMP_ITAV *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_ITAV_sk_type(sk),ossl_check_OSSL_CMP_ITAV_freefunc_type(freefunc))
+#define sk_OSSL_CMP_ITAV_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr), (idx))
+#define sk_OSSL_CMP_ITAV_set(sk, idx, ptr) ((OSSL_CMP_ITAV *)OPENSSL_sk_set(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (idx), ossl_check_OSSL_CMP_ITAV_type(ptr)))
+#define sk_OSSL_CMP_ITAV_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr), pnum)
+#define sk_OSSL_CMP_ITAV_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_dup(sk) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_ITAV_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_ITAV_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_ITAV_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp)))
+
+/* clang-format on */
+
+typedef struct ossl_cmp_crlstatus_st OSSL_CMP_CRLSTATUS;
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CRLSTATUS, OSSL_CMP_CRLSTATUS, OSSL_CMP_CRLSTATUS)
+#define sk_OSSL_CMP_CRLSTATUS_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CRLSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CRLSTATUS_value(sk, idx) ((OSSL_CMP_CRLSTATUS *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CRLSTATUS_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CRLSTATUS_new(cmp) ((STACK_OF(OSSL_CMP_CRLSTATUS) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CRLSTATUS_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CRLSTATUS_new_null() ((STACK_OF(OSSL_CMP_CRLSTATUS) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CRLSTATUS_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CRLSTATUS) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CRLSTATUS_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CRLSTATUS_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), (n))
+#define sk_OSSL_CMP_CRLSTATUS_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CRLSTATUS_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CRLSTATUS_delete(sk, i) ((OSSL_CMP_CRLSTATUS *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CRLSTATUS_delete_ptr(sk, ptr) ((OSSL_CMP_CRLSTATUS *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CRLSTATUS_type(ptr)))
+#define sk_OSSL_CMP_CRLSTATUS_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CRLSTATUS_type(ptr))
+#define sk_OSSL_CMP_CRLSTATUS_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CRLSTATUS_type(ptr))
+#define sk_OSSL_CMP_CRLSTATUS_pop(sk) ((OSSL_CMP_CRLSTATUS *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CRLSTATUS_shift(sk) ((OSSL_CMP_CRLSTATUS *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CRLSTATUS_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk),ossl_check_OSSL_CMP_CRLSTATUS_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CRLSTATUS_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CRLSTATUS_type(ptr), (idx))
+#define sk_OSSL_CMP_CRLSTATUS_set(sk, idx, ptr) ((OSSL_CMP_CRLSTATUS *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), (idx), ossl_check_OSSL_CMP_CRLSTATUS_type(ptr)))
+#define sk_OSSL_CMP_CRLSTATUS_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CRLSTATUS_type(ptr))
+#define sk_OSSL_CMP_CRLSTATUS_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CRLSTATUS_type(ptr))
+#define sk_OSSL_CMP_CRLSTATUS_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CRLSTATUS_type(ptr), pnum)
+#define sk_OSSL_CMP_CRLSTATUS_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CRLSTATUS_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CRLSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CRLSTATUS_dup(sk) ((STACK_OF(OSSL_CMP_CRLSTATUS) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CRLSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CRLSTATUS_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CRLSTATUS) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CRLSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CRLSTATUS_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CRLSTATUS_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CRLSTATUS_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CRLSTATUS_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CRLSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CRLSTATUS_compfunc_type(cmp)))
+
+/* clang-format on */
+
+typedef OSSL_CRMF_ATTRIBUTETYPEANDVALUE OSSL_CMP_ATAV;
+#define OSSL_CMP_ATAV_free OSSL_CRMF_ATTRIBUTETYPEANDVALUE_free
+typedef STACK_OF(OSSL_CRMF_ATTRIBUTETYPEANDVALUE) OSSL_CMP_ATAVS;
+DECLARE_ASN1_FUNCTIONS(OSSL_CMP_ATAVS)
+#define stack_st_OSSL_CMP_ATAV stack_st_OSSL_CRMF_ATTRIBUTETYPEANDVALUE
+#define sk_OSSL_CMP_ATAV_num sk_OSSL_CRMF_ATTRIBUTETYPEANDVALUE_num
+#define sk_OSSL_CMP_ATAV_value sk_OSSL_CRMF_ATTRIBUTETYPEANDVALUE_value
+#define sk_OSSL_CMP_ATAV_push sk_OSSL_CRMF_ATTRIBUTETYPEANDVALUE_push
+#define sk_OSSL_CMP_ATAV_pop_free sk_OSSL_CRMF_ATTRIBUTETYPEANDVALUE_pop_free
+
+typedef struct ossl_cmp_revrepcontent_st OSSL_CMP_REVREPCONTENT;
+typedef struct ossl_cmp_pkisi_st OSSL_CMP_PKISI;
+DECLARE_ASN1_FUNCTIONS(OSSL_CMP_PKISI)
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_PKISI)
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_PKISI, OSSL_CMP_PKISI, OSSL_CMP_PKISI)
+#define sk_OSSL_CMP_PKISI_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_value(sk, idx) ((OSSL_CMP_PKISI *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_PKISI_new(cmp) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp)))
+#define sk_OSSL_CMP_PKISI_new_null() ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_PKISI_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_PKISI_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (n))
+#define sk_OSSL_CMP_PKISI_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_delete(sk, i) ((OSSL_CMP_PKISI *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (i)))
+#define sk_OSSL_CMP_PKISI_delete_ptr(sk, ptr) ((OSSL_CMP_PKISI *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr)))
+#define sk_OSSL_CMP_PKISI_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_pop(sk) ((OSSL_CMP_PKISI *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_shift(sk) ((OSSL_CMP_PKISI *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_PKISI_sk_type(sk),ossl_check_OSSL_CMP_PKISI_freefunc_type(freefunc))
+#define sk_OSSL_CMP_PKISI_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr), (idx))
+#define sk_OSSL_CMP_PKISI_set(sk, idx, ptr) ((OSSL_CMP_PKISI *)OPENSSL_sk_set(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (idx), ossl_check_OSSL_CMP_PKISI_type(ptr)))
+#define sk_OSSL_CMP_PKISI_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr), pnum)
+#define sk_OSSL_CMP_PKISI_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_dup(sk) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_PKISI_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_PKISI_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_PKISI_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp)))
+
+/* clang-format on */
+typedef struct ossl_cmp_certrepmessage_st OSSL_CMP_CERTREPMESSAGE;
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTREPMESSAGE, OSSL_CMP_CERTREPMESSAGE, OSSL_CMP_CERTREPMESSAGE)
+#define sk_OSSL_CMP_CERTREPMESSAGE_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_value(sk, idx) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_new(cmp) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_new_null() ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTREPMESSAGE_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (n))
+#define sk_OSSL_CMP_CERTREPMESSAGE_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_delete(sk, i) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_delete_ptr(sk, ptr) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_pop(sk) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_shift(sk) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk),ossl_check_OSSL_CMP_CERTREPMESSAGE_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTREPMESSAGE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr), (idx))
+#define sk_OSSL_CMP_CERTREPMESSAGE_set(sk, idx, ptr) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr), pnum)
+#define sk_OSSL_CMP_CERTREPMESSAGE_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_dup(sk) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTREPMESSAGE_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTREPMESSAGE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp)))
+
+/* clang-format on */
+typedef struct ossl_cmp_pollrep_st OSSL_CMP_POLLREP;
+typedef STACK_OF(OSSL_CMP_POLLREP) OSSL_CMP_POLLREPCONTENT;
+typedef struct ossl_cmp_certresponse_st OSSL_CMP_CERTRESPONSE;
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTRESPONSE, OSSL_CMP_CERTRESPONSE, OSSL_CMP_CERTRESPONSE)
+#define sk_OSSL_CMP_CERTRESPONSE_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_value(sk, idx) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTRESPONSE_new(cmp) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTRESPONSE_new_null() ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTRESPONSE_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTRESPONSE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (n))
+#define sk_OSSL_CMP_CERTRESPONSE_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_delete(sk, i) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTRESPONSE_delete_ptr(sk, ptr) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr)))
+#define sk_OSSL_CMP_CERTRESPONSE_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_pop(sk) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_shift(sk) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk),ossl_check_OSSL_CMP_CERTRESPONSE_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTRESPONSE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr), (idx))
+#define sk_OSSL_CMP_CERTRESPONSE_set(sk, idx, ptr) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr)))
+#define sk_OSSL_CMP_CERTRESPONSE_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr), pnum)
+#define sk_OSSL_CMP_CERTRESPONSE_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_dup(sk) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTRESPONSE_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTRESPONSE_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTRESPONSE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp)))
+
+/* clang-format on */
+typedef STACK_OF(ASN1_UTF8STRING) OSSL_CMP_PKIFREETEXT;
+
+/*
+ * function DECLARATIONS
+ */
+
+/* from cmp_asn.c */
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_create(ASN1_OBJECT *type, ASN1_TYPE *value);
+void OSSL_CMP_ITAV_set0(OSSL_CMP_ITAV *itav, ASN1_OBJECT *type,
+    ASN1_TYPE *value);
+ASN1_OBJECT *OSSL_CMP_ITAV_get0_type(const OSSL_CMP_ITAV *itav);
+ASN1_TYPE *OSSL_CMP_ITAV_get0_value(const OSSL_CMP_ITAV *itav);
+int OSSL_CMP_ITAV_push0_stack_item(STACK_OF(OSSL_CMP_ITAV) **sk_p,
+    OSSL_CMP_ITAV *itav);
+void OSSL_CMP_ITAV_free(OSSL_CMP_ITAV *itav);
+
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_new0_certProfile(STACK_OF(ASN1_UTF8STRING)
+        *certProfile);
+int OSSL_CMP_ITAV_get0_certProfile(const OSSL_CMP_ITAV *itav,
+    STACK_OF(ASN1_UTF8STRING) **out);
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_new_caCerts(const STACK_OF(X509) *caCerts);
+int OSSL_CMP_ITAV_get0_caCerts(const OSSL_CMP_ITAV *itav, STACK_OF(X509) **out);
+
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_new_rootCaCert(const X509 *rootCaCert);
+int OSSL_CMP_ITAV_get0_rootCaCert(const OSSL_CMP_ITAV *itav, X509 **out);
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_new_rootCaKeyUpdate(const X509 *newWithNew,
+    const X509 *newWithOld,
+    const X509 *oldWithNew);
+int OSSL_CMP_ITAV_get0_rootCaKeyUpdate(const OSSL_CMP_ITAV *itav,
+    X509 **newWithNew,
+    X509 **newWithOld,
+    X509 **oldWithNew);
+
+OSSL_CMP_CRLSTATUS *OSSL_CMP_CRLSTATUS_create(const X509_CRL *crl,
+    const X509 *cert, int only_DN);
+OSSL_CMP_CRLSTATUS *OSSL_CMP_CRLSTATUS_new1(const DIST_POINT_NAME *dpn,
+    const GENERAL_NAMES *issuer,
+    const ASN1_TIME *thisUpdate);
+int OSSL_CMP_CRLSTATUS_get0(const OSSL_CMP_CRLSTATUS *crlstatus,
+    DIST_POINT_NAME **dpn, GENERAL_NAMES **issuer,
+    ASN1_TIME **thisUpdate);
+void OSSL_CMP_CRLSTATUS_free(OSSL_CMP_CRLSTATUS *crlstatus);
+OSSL_CMP_ITAV
+*OSSL_CMP_ITAV_new0_crlStatusList(STACK_OF(OSSL_CMP_CRLSTATUS) *crlStatusList);
+int OSSL_CMP_ITAV_get0_crlStatusList(const OSSL_CMP_ITAV *itav,
+    STACK_OF(OSSL_CMP_CRLSTATUS) **out);
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_new_crls(const X509_CRL *crls);
+int OSSL_CMP_ITAV_get0_crls(const OSSL_CMP_ITAV *it, STACK_OF(X509_CRL) **out);
+OSSL_CMP_ITAV
+*OSSL_CMP_ITAV_new0_certReqTemplate(OSSL_CRMF_CERTTEMPLATE *certTemplate,
+    OSSL_CMP_ATAVS *keySpec);
+int OSSL_CMP_ITAV_get1_certReqTemplate(const OSSL_CMP_ITAV *itav,
+    OSSL_CRMF_CERTTEMPLATE **certTemplate,
+    OSSL_CMP_ATAVS **keySpec);
+
+OSSL_CMP_ATAV *OSSL_CMP_ATAV_create(ASN1_OBJECT *type, ASN1_TYPE *value);
+void OSSL_CMP_ATAV_set0(OSSL_CMP_ATAV *itav, ASN1_OBJECT *type,
+    ASN1_TYPE *value);
+ASN1_OBJECT *OSSL_CMP_ATAV_get0_type(const OSSL_CMP_ATAV *itav);
+ASN1_TYPE *OSSL_CMP_ATAV_get0_value(const OSSL_CMP_ATAV *itav);
+OSSL_CMP_ATAV *OSSL_CMP_ATAV_new_algId(const X509_ALGOR *alg);
+X509_ALGOR *OSSL_CMP_ATAV_get0_algId(const OSSL_CMP_ATAV *atav);
+OSSL_CMP_ATAV *OSSL_CMP_ATAV_new_rsaKeyLen(int len);
+int OSSL_CMP_ATAV_get_rsaKeyLen(const OSSL_CMP_ATAV *atav);
+int OSSL_CMP_ATAV_push1(OSSL_CMP_ATAVS **sk_p, const OSSL_CMP_ATAV *atav);
+
+void OSSL_CMP_MSG_free(OSSL_CMP_MSG *msg);
+
+/* from cmp_ctx.c */
+OSSL_CMP_CTX *OSSL_CMP_CTX_new(OSSL_LIB_CTX *libctx, const char *propq);
+void OSSL_CMP_CTX_free(OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_reinit(OSSL_CMP_CTX *ctx);
+OSSL_LIB_CTX *OSSL_CMP_CTX_get0_libctx(const OSSL_CMP_CTX *ctx);
+const char *OSSL_CMP_CTX_get0_propq(const OSSL_CMP_CTX *ctx);
+/* CMP general options: */
+#define OSSL_CMP_OPT_LOG_VERBOSITY 0
+/* CMP transfer options: */
+#define OSSL_CMP_OPT_KEEP_ALIVE 10
+#define OSSL_CMP_OPT_MSG_TIMEOUT 11
+#define OSSL_CMP_OPT_TOTAL_TIMEOUT 12
+#define OSSL_CMP_OPT_USE_TLS 13
+/* CMP request options: */
+#define OSSL_CMP_OPT_VALIDITY_DAYS 20
+#define OSSL_CMP_OPT_SUBJECTALTNAME_NODEFAULT 21
+#define OSSL_CMP_OPT_SUBJECTALTNAME_CRITICAL 22
+#define OSSL_CMP_OPT_POLICIES_CRITICAL 23
+#define OSSL_CMP_OPT_POPO_METHOD 24
+#define OSSL_CMP_OPT_IMPLICIT_CONFIRM 25
+#define OSSL_CMP_OPT_DISABLE_CONFIRM 26
+#define OSSL_CMP_OPT_REVOCATION_REASON 27
+/* CMP protection options: */
+#define OSSL_CMP_OPT_UNPROTECTED_SEND 30
+#define OSSL_CMP_OPT_UNPROTECTED_ERRORS 31
+#define OSSL_CMP_OPT_OWF_ALGNID 32
+#define OSSL_CMP_OPT_MAC_ALGNID 33
+#define OSSL_CMP_OPT_DIGEST_ALGNID 34
+#define OSSL_CMP_OPT_IGNORE_KEYUSAGE 35
+#define OSSL_CMP_OPT_PERMIT_TA_IN_EXTRACERTS_FOR_IR 36
+#define OSSL_CMP_OPT_NO_CACHE_EXTRACERTS 37
+int OSSL_CMP_CTX_set_option(OSSL_CMP_CTX *ctx, int opt, int val);
+int OSSL_CMP_CTX_get_option(const OSSL_CMP_CTX *ctx, int opt);
+/* CMP-specific callback for logging and outputting the error queue: */
+int OSSL_CMP_CTX_set_log_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_log_cb_t cb);
+#define OSSL_CMP_CTX_set_log_verbosity(ctx, level) \
+    OSSL_CMP_CTX_set_option(ctx, OSSL_CMP_OPT_LOG_VERBOSITY, level)
+void OSSL_CMP_CTX_print_errors(const OSSL_CMP_CTX *ctx);
+/* message transfer: */
+int OSSL_CMP_CTX_set1_serverPath(OSSL_CMP_CTX *ctx, const char *path);
+int OSSL_CMP_CTX_set1_server(OSSL_CMP_CTX *ctx, const char *address);
+int OSSL_CMP_CTX_set_serverPort(OSSL_CMP_CTX *ctx, int port);
+int OSSL_CMP_CTX_set1_proxy(OSSL_CMP_CTX *ctx, const char *name);
+int OSSL_CMP_CTX_set1_no_proxy(OSSL_CMP_CTX *ctx, const char *names);
+#ifndef OPENSSL_NO_HTTP
+int OSSL_CMP_CTX_set_http_cb(OSSL_CMP_CTX *ctx, OSSL_HTTP_bio_cb_t cb);
+int OSSL_CMP_CTX_set_http_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
+void *OSSL_CMP_CTX_get_http_cb_arg(const OSSL_CMP_CTX *ctx);
+#endif
+typedef OSSL_CMP_MSG *(*OSSL_CMP_transfer_cb_t)(OSSL_CMP_CTX *ctx,
+    const OSSL_CMP_MSG *req);
+int OSSL_CMP_CTX_set_transfer_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_transfer_cb_t cb);
+int OSSL_CMP_CTX_set_transfer_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
+void *OSSL_CMP_CTX_get_transfer_cb_arg(const OSSL_CMP_CTX *ctx);
+/* server authentication: */
+int OSSL_CMP_CTX_set1_srvCert(OSSL_CMP_CTX *ctx, X509 *cert);
+int OSSL_CMP_CTX_set1_expected_sender(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_set0_trustedStore(OSSL_CMP_CTX *ctx, X509_STORE *store);
+#define OSSL_CMP_CTX_set0_trusted OSSL_CMP_CTX_set0_trustedStore
+X509_STORE *OSSL_CMP_CTX_get0_trustedStore(const OSSL_CMP_CTX *ctx);
+#define OSSL_CMP_CTX_get0_trusted OSSL_CMP_CTX_get0_trustedStore
+int OSSL_CMP_CTX_set1_untrusted(OSSL_CMP_CTX *ctx, STACK_OF(X509) *certs);
+STACK_OF(X509) *OSSL_CMP_CTX_get0_untrusted(const OSSL_CMP_CTX *ctx);
+/* client authentication: */
+int OSSL_CMP_CTX_set1_cert(OSSL_CMP_CTX *ctx, X509 *cert);
+int OSSL_CMP_CTX_build_cert_chain(OSSL_CMP_CTX *ctx, X509_STORE *own_trusted,
+    STACK_OF(X509) *candidates);
+int OSSL_CMP_CTX_set1_pkey(OSSL_CMP_CTX *ctx, EVP_PKEY *pkey);
+int OSSL_CMP_CTX_set1_referenceValue(OSSL_CMP_CTX *ctx,
+    const unsigned char *ref, int len);
+int OSSL_CMP_CTX_set1_secretValue(OSSL_CMP_CTX *ctx,
+    const unsigned char *sec, int len);
+/* CMP message header and extra certificates: */
+int OSSL_CMP_CTX_set1_recipient(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_push0_geninfo_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav);
+int OSSL_CMP_CTX_reset_geninfo_ITAVs(OSSL_CMP_CTX *ctx);
+STACK_OF(OSSL_CMP_ITAV)
+*OSSL_CMP_CTX_get0_geninfo_ITAVs(const OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_set1_extraCertsOut(OSSL_CMP_CTX *ctx,
+    STACK_OF(X509) *extraCertsOut);
+/* certificate template: */
+int OSSL_CMP_CTX_set0_newPkey(OSSL_CMP_CTX *ctx, int priv, EVP_PKEY *pkey);
+EVP_PKEY *OSSL_CMP_CTX_get0_newPkey(const OSSL_CMP_CTX *ctx, int priv);
+int OSSL_CMP_CTX_set1_issuer(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_set1_serialNumber(OSSL_CMP_CTX *ctx, const ASN1_INTEGER *sn);
+int OSSL_CMP_CTX_set1_subjectName(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_push1_subjectAltName(OSSL_CMP_CTX *ctx,
+    const GENERAL_NAME *name);
+int OSSL_CMP_CTX_set0_reqExtensions(OSSL_CMP_CTX *ctx, X509_EXTENSIONS *exts);
+int OSSL_CMP_CTX_reqExtensions_have_SAN(OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_push0_policy(OSSL_CMP_CTX *ctx, POLICYINFO *pinfo);
+int OSSL_CMP_CTX_set1_oldCert(OSSL_CMP_CTX *ctx, X509 *cert);
+int OSSL_CMP_CTX_set1_p10CSR(OSSL_CMP_CTX *ctx, const X509_REQ *csr);
+/* misc body contents: */
+int OSSL_CMP_CTX_push0_genm_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav);
+/* certificate confirmation: */
+typedef int (*OSSL_CMP_certConf_cb_t)(OSSL_CMP_CTX *ctx, X509 *cert,
+    int fail_info, const char **txt);
+int OSSL_CMP_certConf_cb(OSSL_CMP_CTX *ctx, X509 *cert, int fail_info,
+    const char **text);
+int OSSL_CMP_CTX_set_certConf_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_certConf_cb_t cb);
+int OSSL_CMP_CTX_set_certConf_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
+void *OSSL_CMP_CTX_get_certConf_cb_arg(const OSSL_CMP_CTX *ctx);
+/* result fetching: */
+int OSSL_CMP_CTX_get_status(const OSSL_CMP_CTX *ctx);
+OSSL_CMP_PKIFREETEXT *OSSL_CMP_CTX_get0_statusString(const OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_get_failInfoCode(const OSSL_CMP_CTX *ctx);
+#define OSSL_CMP_PKISI_BUFLEN 1024
+X509 *OSSL_CMP_CTX_get0_validatedSrvCert(const OSSL_CMP_CTX *ctx);
+X509 *OSSL_CMP_CTX_get0_newCert(const OSSL_CMP_CTX *ctx);
+STACK_OF(X509) *OSSL_CMP_CTX_get1_newChain(const OSSL_CMP_CTX *ctx);
+STACK_OF(X509) *OSSL_CMP_CTX_get1_caPubs(const OSSL_CMP_CTX *ctx);
+STACK_OF(X509) *OSSL_CMP_CTX_get1_extraCertsIn(const OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_set1_transactionID(OSSL_CMP_CTX *ctx,
+    const ASN1_OCTET_STRING *id);
+int OSSL_CMP_CTX_set1_senderNonce(OSSL_CMP_CTX *ctx,
+    const ASN1_OCTET_STRING *nonce);
+
+/* from cmp_status.c */
+char *OSSL_CMP_CTX_snprint_PKIStatus(const OSSL_CMP_CTX *ctx, char *buf,
+    size_t bufsize);
+char *OSSL_CMP_snprint_PKIStatusInfo(const OSSL_CMP_PKISI *statusInfo,
+    char *buf, size_t bufsize);
+OSSL_CMP_PKISI *
+OSSL_CMP_STATUSINFO_new(int status, int fail_info, const char *text);
+
+/* from cmp_hdr.c */
+ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_transactionID(const OSSL_CMP_PKIHEADER *hdr);
+ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_recipNonce(const OSSL_CMP_PKIHEADER *hdr);
+STACK_OF(OSSL_CMP_ITAV)
+*OSSL_CMP_HDR_get0_geninfo_ITAVs(const OSSL_CMP_PKIHEADER *hdr);
+
+/* from cmp_msg.c */
+OSSL_CMP_PKIHEADER *OSSL_CMP_MSG_get0_header(const OSSL_CMP_MSG *msg);
+int OSSL_CMP_MSG_get_bodytype(const OSSL_CMP_MSG *msg);
+X509_PUBKEY *OSSL_CMP_MSG_get0_certreq_publickey(const OSSL_CMP_MSG *msg);
+int OSSL_CMP_MSG_update_transactionID(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg);
+int OSSL_CMP_MSG_update_recipNonce(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg);
+OSSL_CRMF_MSG *OSSL_CMP_CTX_setup_CRM(OSSL_CMP_CTX *ctx, int for_KUR, int rid);
+OSSL_CMP_MSG *OSSL_CMP_MSG_read(const char *file, OSSL_LIB_CTX *libctx,
+    const char *propq);
+int OSSL_CMP_MSG_write(const char *file, const OSSL_CMP_MSG *msg);
+OSSL_CMP_MSG *d2i_OSSL_CMP_MSG_bio(BIO *bio, OSSL_CMP_MSG **msg);
+int i2d_OSSL_CMP_MSG_bio(BIO *bio, const OSSL_CMP_MSG *msg);
+
+/* from cmp_vfy.c */
+int OSSL_CMP_validate_msg(OSSL_CMP_CTX *ctx, const OSSL_CMP_MSG *msg);
+int OSSL_CMP_validate_cert_path(const OSSL_CMP_CTX *ctx,
+    X509_STORE *trusted_store, X509 *cert);
+
+/* from cmp_http.c */
+#ifndef OPENSSL_NO_HTTP
+OSSL_CMP_MSG *OSSL_CMP_MSG_http_perform(OSSL_CMP_CTX *ctx,
+    const OSSL_CMP_MSG *req);
+#endif
+
+/* from cmp_server.c */
+typedef struct ossl_cmp_srv_ctx_st OSSL_CMP_SRV_CTX;
+OSSL_CMP_MSG *OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX *srv_ctx,
+    const OSSL_CMP_MSG *req);
+OSSL_CMP_MSG *OSSL_CMP_CTX_server_perform(OSSL_CMP_CTX *client_ctx,
+    const OSSL_CMP_MSG *req);
+OSSL_CMP_SRV_CTX *OSSL_CMP_SRV_CTX_new(OSSL_LIB_CTX *libctx, const char *propq);
+void OSSL_CMP_SRV_CTX_free(OSSL_CMP_SRV_CTX *srv_ctx);
+typedef OSSL_CMP_PKISI *(*OSSL_CMP_SRV_cert_request_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx, const OSSL_CMP_MSG *req, int certReqId,
+    const OSSL_CRMF_MSG *crm, const X509_REQ *p10cr,
+    X509 **certOut, STACK_OF(X509) **chainOut, STACK_OF(X509) **caPubs);
+typedef OSSL_CMP_PKISI *(*OSSL_CMP_SRV_rr_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+    const OSSL_CMP_MSG *req,
+    const X509_NAME *issuer,
+    const ASN1_INTEGER *serial);
+typedef int (*OSSL_CMP_SRV_genm_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+    const OSSL_CMP_MSG *req,
+    const STACK_OF(OSSL_CMP_ITAV) *in,
+    STACK_OF(OSSL_CMP_ITAV) **out);
+typedef void (*OSSL_CMP_SRV_error_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+    const OSSL_CMP_MSG *req,
+    const OSSL_CMP_PKISI *statusInfo,
+    const ASN1_INTEGER *errorCode,
+    const OSSL_CMP_PKIFREETEXT *errDetails);
+typedef int (*OSSL_CMP_SRV_certConf_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+    const OSSL_CMP_MSG *req,
+    int certReqId,
+    const ASN1_OCTET_STRING *certHash,
+    const OSSL_CMP_PKISI *si);
+typedef int (*OSSL_CMP_SRV_pollReq_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+    const OSSL_CMP_MSG *req, int certReqId,
+    OSSL_CMP_MSG **certReq,
+    int64_t *check_after);
+int OSSL_CMP_SRV_CTX_init(OSSL_CMP_SRV_CTX *srv_ctx, void *custom_ctx,
+    OSSL_CMP_SRV_cert_request_cb_t process_cert_request,
+    OSSL_CMP_SRV_rr_cb_t process_rr,
+    OSSL_CMP_SRV_genm_cb_t process_genm,
+    OSSL_CMP_SRV_error_cb_t process_error,
+    OSSL_CMP_SRV_certConf_cb_t process_certConf,
+    OSSL_CMP_SRV_pollReq_cb_t process_pollReq);
+typedef int (*OSSL_CMP_SRV_delayed_delivery_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+    const OSSL_CMP_MSG *req);
+typedef int (*OSSL_CMP_SRV_clean_transaction_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+    const ASN1_OCTET_STRING *id);
+int OSSL_CMP_SRV_CTX_init_trans(OSSL_CMP_SRV_CTX *srv_ctx,
+    OSSL_CMP_SRV_delayed_delivery_cb_t delay,
+    OSSL_CMP_SRV_clean_transaction_cb_t clean);
+OSSL_CMP_CTX *OSSL_CMP_SRV_CTX_get0_cmp_ctx(const OSSL_CMP_SRV_CTX *srv_ctx);
+void *OSSL_CMP_SRV_CTX_get0_custom_ctx(const OSSL_CMP_SRV_CTX *srv_ctx);
+int OSSL_CMP_SRV_CTX_set_send_unprotected_errors(OSSL_CMP_SRV_CTX *srv_ctx,
+    int val);
+int OSSL_CMP_SRV_CTX_set_accept_unprotected(OSSL_CMP_SRV_CTX *srv_ctx, int val);
+int OSSL_CMP_SRV_CTX_set_accept_raverified(OSSL_CMP_SRV_CTX *srv_ctx, int val);
+int OSSL_CMP_SRV_CTX_set_grant_implicit_confirm(OSSL_CMP_SRV_CTX *srv_ctx,
+    int val);
+
+/* from cmp_client.c */
+X509 *OSSL_CMP_exec_certreq(OSSL_CMP_CTX *ctx, int req_type,
+    const OSSL_CRMF_MSG *crm);
+#define OSSL_CMP_IR 0
+#define OSSL_CMP_CR 2
+#define OSSL_CMP_P10CR 4
+#define OSSL_CMP_KUR 7
+#define OSSL_CMP_GENM 21
+#define OSSL_CMP_ERROR 23
+#define OSSL_CMP_exec_IR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_IR, NULL)
+#define OSSL_CMP_exec_CR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_CR, NULL)
+#define OSSL_CMP_exec_P10CR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_P10CR, NULL)
+#define OSSL_CMP_exec_KUR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_KUR, NULL)
+int OSSL_CMP_try_certreq(OSSL_CMP_CTX *ctx, int req_type,
+    const OSSL_CRMF_MSG *crm, int *checkAfter);
+int OSSL_CMP_exec_RR_ses(OSSL_CMP_CTX *ctx);
+STACK_OF(OSSL_CMP_ITAV) *OSSL_CMP_exec_GENM_ses(OSSL_CMP_CTX *ctx);
+
+/* from cmp_genm.c */
+int OSSL_CMP_get1_caCerts(OSSL_CMP_CTX *ctx, STACK_OF(X509) **out);
+int OSSL_CMP_get1_rootCaKeyUpdate(OSSL_CMP_CTX *ctx,
+    const X509 *oldWithOld, X509 **newWithNew,
+    X509 **newWithOld, X509 **oldWithNew);
+int OSSL_CMP_get1_crlUpdate(OSSL_CMP_CTX *ctx, const X509 *crlcert,
+    const X509_CRL *last_crl,
+    X509_CRL **crl);
+int OSSL_CMP_get1_certReqTemplate(OSSL_CMP_CTX *ctx,
+    OSSL_CRMF_CERTTEMPLATE **certTemplate,
+    OSSL_CMP_ATAVS **keySpec);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !defined(OPENSSL_NO_CMP) */
+#endif /* !defined(OPENSSL_CMP_H) */

miniconda3/envs/active_proaction/include/openssl/cmp_util.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2007-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright Nokia 2007-2019
+ * Copyright Siemens AG 2015-2019
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMP_UTIL_H
+#define OPENSSL_CMP_UTIL_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#ifndef OPENSSL_NO_CMP
+
+#include <openssl/macros.h>
+#include <openssl/trace.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int OSSL_CMP_log_open(void);
+void OSSL_CMP_log_close(void);
+#define OSSL_CMP_LOG_PREFIX "CMP "
+
+/*
+ * generalized logging/error callback mirroring the severity levels of syslog.h
+ */
+typedef int OSSL_CMP_severity;
+#define OSSL_CMP_LOG_EMERG 0
+#define OSSL_CMP_LOG_ALERT 1
+#define OSSL_CMP_LOG_CRIT 2
+#define OSSL_CMP_LOG_ERR 3
+#define OSSL_CMP_LOG_WARNING 4
+#define OSSL_CMP_LOG_NOTICE 5
+#define OSSL_CMP_LOG_INFO 6
+#define OSSL_CMP_LOG_DEBUG 7
+#define OSSL_CMP_LOG_TRACE 8
+#define OSSL_CMP_LOG_MAX OSSL_CMP_LOG_TRACE
+typedef int (*OSSL_CMP_log_cb_t)(const char *func, const char *file, int line,
+    OSSL_CMP_severity level, const char *msg);
+
+int OSSL_CMP_print_to_bio(BIO *bio, const char *component, const char *file,
+    int line, OSSL_CMP_severity level, const char *msg);
+/* use of the logging callback for outputting error queue */
+void OSSL_CMP_print_errors_cb(OSSL_CMP_log_cb_t log_fn);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !defined(OPENSSL_NO_CMP) */
+#endif /* !defined(OPENSSL_CMP_UTIL_H) */

miniconda3/envs/active_proaction/include/openssl/cmperr.h

@@ -0,0 +1,132 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMPERR_H
+#define OPENSSL_CMPERR_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
+
+#ifndef OPENSSL_NO_CMP
+
+/*
+ * CMP reason codes.
+ */
+#define CMP_R_ALGORITHM_NOT_SUPPORTED 139
+#define CMP_R_BAD_CHECKAFTER_IN_POLLREP 167
+#define CMP_R_BAD_REQUEST_ID 108
+#define CMP_R_CERTHASH_UNMATCHED 156
+#define CMP_R_CERTID_NOT_FOUND 109
+#define CMP_R_CERTIFICATE_NOT_ACCEPTED 169
+#define CMP_R_CERTIFICATE_NOT_FOUND 112
+#define CMP_R_CERTREQMSG_NOT_FOUND 157
+#define CMP_R_CERTRESPONSE_NOT_FOUND 113
+#define CMP_R_CERT_AND_KEY_DO_NOT_MATCH 114
+#define CMP_R_CHECKAFTER_OUT_OF_RANGE 181
+#define CMP_R_ENCOUNTERED_KEYUPDATEWARNING 176
+#define CMP_R_ENCOUNTERED_WAITING 162
+#define CMP_R_ERROR_CALCULATING_PROTECTION 115
+#define CMP_R_ERROR_CREATING_CERTCONF 116
+#define CMP_R_ERROR_CREATING_CERTREP 117
+#define CMP_R_ERROR_CREATING_CERTREQ 163
+#define CMP_R_ERROR_CREATING_ERROR 118
+#define CMP_R_ERROR_CREATING_GENM 119
+#define CMP_R_ERROR_CREATING_GENP 120
+#define CMP_R_ERROR_CREATING_PKICONF 122
+#define CMP_R_ERROR_CREATING_POLLREP 123
+#define CMP_R_ERROR_CREATING_POLLREQ 124
+#define CMP_R_ERROR_CREATING_RP 125
+#define CMP_R_ERROR_CREATING_RR 126
+#define CMP_R_ERROR_PARSING_PKISTATUS 107
+#define CMP_R_ERROR_PROCESSING_MESSAGE 158
+#define CMP_R_ERROR_PROTECTING_MESSAGE 127
+#define CMP_R_ERROR_SETTING_CERTHASH 128
+#define CMP_R_ERROR_UNEXPECTED_CERTCONF 160
+#define CMP_R_ERROR_VALIDATING_PROTECTION 140
+#define CMP_R_ERROR_VALIDATING_SIGNATURE 171
+#define CMP_R_EXPECTED_POLLREQ 104
+#define CMP_R_FAILED_BUILDING_OWN_CHAIN 164
+#define CMP_R_FAILED_EXTRACTING_CENTRAL_GEN_KEY 203
+#define CMP_R_FAILED_EXTRACTING_PUBKEY 141
+#define CMP_R_FAILURE_OBTAINING_RANDOM 110
+#define CMP_R_FAIL_INFO_OUT_OF_RANGE 129
+#define CMP_R_GENERATE_CERTREQTEMPLATE 197
+#define CMP_R_GENERATE_CRLSTATUS 198
+#define CMP_R_GETTING_GENP 192
+#define CMP_R_GET_ITAV 199
+#define CMP_R_INVALID_ARGS 100
+#define CMP_R_INVALID_GENP 193
+#define CMP_R_INVALID_KEYSPEC 202
+#define CMP_R_INVALID_OPTION 174
+#define CMP_R_INVALID_ROOTCAKEYUPDATE 195
+#define CMP_R_MISSING_CENTRAL_GEN_KEY 204
+#define CMP_R_MISSING_CERTID 165
+#define CMP_R_MISSING_KEY_INPUT_FOR_CREATING_PROTECTION 130
+#define CMP_R_MISSING_KEY_USAGE_DIGITALSIGNATURE 142
+#define CMP_R_MISSING_P10CSR 121
+#define CMP_R_MISSING_PBM_SECRET 166
+#define CMP_R_MISSING_PRIVATE_KEY 131
+#define CMP_R_MISSING_PRIVATE_KEY_FOR_POPO 190
+#define CMP_R_MISSING_PROTECTION 143
+#define CMP_R_MISSING_PUBLIC_KEY 183
+#define CMP_R_MISSING_REFERENCE_CERT 168
+#define CMP_R_MISSING_SECRET 178
+#define CMP_R_MISSING_SENDER_IDENTIFICATION 111
+#define CMP_R_MISSING_TRUST_ANCHOR 179
+#define CMP_R_MISSING_TRUST_STORE 144
+#define CMP_R_MULTIPLE_REQUESTS_NOT_SUPPORTED 161
+#define CMP_R_MULTIPLE_RESPONSES_NOT_SUPPORTED 170
+#define CMP_R_MULTIPLE_SAN_SOURCES 102
+#define CMP_R_NO_STDIO 194
+#define CMP_R_NO_SUITABLE_SENDER_CERT 145
+#define CMP_R_NULL_ARGUMENT 103
+#define CMP_R_PKIBODY_ERROR 146
+#define CMP_R_PKISTATUSINFO_NOT_FOUND 132
+#define CMP_R_POLLING_FAILED 172
+#define CMP_R_POTENTIALLY_INVALID_CERTIFICATE 147
+#define CMP_R_RECEIVED_ERROR 180
+#define CMP_R_RECIPNONCE_UNMATCHED 148
+#define CMP_R_REQUEST_NOT_ACCEPTED 149
+#define CMP_R_REQUEST_REJECTED_BY_SERVER 182
+#define CMP_R_SENDER_GENERALNAME_TYPE_NOT_SUPPORTED 150
+#define CMP_R_SRVCERT_DOES_NOT_VALIDATE_MSG 151
+#define CMP_R_TOTAL_TIMEOUT 184
+#define CMP_R_TRANSACTIONID_UNMATCHED 152
+#define CMP_R_TRANSFER_ERROR 159
+#define CMP_R_UNCLEAN_CTX 191
+#define CMP_R_UNEXPECTED_CENTRAL_GEN_KEY 205
+#define CMP_R_UNEXPECTED_CERTPROFILE 196
+#define CMP_R_UNEXPECTED_CRLSTATUSLIST 201
+#define CMP_R_UNEXPECTED_PKIBODY 133
+#define CMP_R_UNEXPECTED_PKISTATUS 185
+#define CMP_R_UNEXPECTED_POLLREQ 105
+#define CMP_R_UNEXPECTED_PVNO 153
+#define CMP_R_UNEXPECTED_SENDER 106
+#define CMP_R_UNKNOWN_ALGORITHM_ID 134
+#define CMP_R_UNKNOWN_CERT_TYPE 135
+#define CMP_R_UNKNOWN_CRL_ISSUER 200
+#define CMP_R_UNKNOWN_PKISTATUS 186
+#define CMP_R_UNSUPPORTED_ALGORITHM 136
+#define CMP_R_UNSUPPORTED_KEY_TYPE 137
+#define CMP_R_UNSUPPORTED_PKIBODY 101
+#define CMP_R_UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC 154
+#define CMP_R_VALUE_TOO_LARGE 175
+#define CMP_R_VALUE_TOO_SMALL 177
+#define CMP_R_WRONG_ALGORITHM_OID 138
+#define CMP_R_WRONG_CERTID 189
+#define CMP_R_WRONG_CERTID_IN_RP 187
+#define CMP_R_WRONG_PBM_VALUE 155
+#define CMP_R_WRONG_RP_COMPONENT_COUNT 188
+#define CMP_R_WRONG_SERIAL_IN_RP 173
+
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/cms.h

@@ -0,0 +1,515 @@
+/*
+ * WARNING: do not edit!
+ * Generated by Makefile from include/openssl/cms.h.in
+ *
+ * Copyright 2008-2025 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/* clang-format off */
+
+/* clang-format on */
+
+#ifndef OPENSSL_CMS_H
+#define OPENSSL_CMS_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CMS_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_CMS
+#include <openssl/x509.h>
+#include <openssl/x509v3.h>
+#include <openssl/cmserr.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct CMS_EnvelopedData_st CMS_EnvelopedData;
+typedef struct CMS_ContentInfo_st CMS_ContentInfo;
+typedef struct CMS_SignerInfo_st CMS_SignerInfo;
+typedef struct CMS_SignedData_st CMS_SignedData;
+typedef struct CMS_CertificateChoices CMS_CertificateChoices;
+typedef struct CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice;
+typedef struct CMS_RecipientInfo_st CMS_RecipientInfo;
+typedef struct CMS_ReceiptRequest_st CMS_ReceiptRequest;
+typedef struct CMS_Receipt_st CMS_Receipt;
+typedef struct CMS_RecipientEncryptedKey_st CMS_RecipientEncryptedKey;
+typedef struct CMS_OtherKeyAttribute_st CMS_OtherKeyAttribute;
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_SignerInfo, CMS_SignerInfo, CMS_SignerInfo)
+#define sk_CMS_SignerInfo_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_value(sk, idx) ((CMS_SignerInfo *)OPENSSL_sk_value(ossl_check_const_CMS_SignerInfo_sk_type(sk), (idx)))
+#define sk_CMS_SignerInfo_new(cmp) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new(ossl_check_CMS_SignerInfo_compfunc_type(cmp)))
+#define sk_CMS_SignerInfo_new_null() ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new_null())
+#define sk_CMS_SignerInfo_new_reserve(cmp, n) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new_reserve(ossl_check_CMS_SignerInfo_compfunc_type(cmp), (n)))
+#define sk_CMS_SignerInfo_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_SignerInfo_sk_type(sk), (n))
+#define sk_CMS_SignerInfo_free(sk) OPENSSL_sk_free(ossl_check_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_delete(sk, i) ((CMS_SignerInfo *)OPENSSL_sk_delete(ossl_check_CMS_SignerInfo_sk_type(sk), (i)))
+#define sk_CMS_SignerInfo_delete_ptr(sk, ptr) ((CMS_SignerInfo *)OPENSSL_sk_delete_ptr(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr)))
+#define sk_CMS_SignerInfo_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_pop(sk) ((CMS_SignerInfo *)OPENSSL_sk_pop(ossl_check_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_shift(sk) ((CMS_SignerInfo *)OPENSSL_sk_shift(ossl_check_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_SignerInfo_sk_type(sk),ossl_check_CMS_SignerInfo_freefunc_type(freefunc))
+#define sk_CMS_SignerInfo_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr), (idx))
+#define sk_CMS_SignerInfo_set(sk, idx, ptr) ((CMS_SignerInfo *)OPENSSL_sk_set(ossl_check_CMS_SignerInfo_sk_type(sk), (idx), ossl_check_CMS_SignerInfo_type(ptr)))
+#define sk_CMS_SignerInfo_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr), pnum)
+#define sk_CMS_SignerInfo_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_dup(sk) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_dup(ossl_check_const_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_copyfunc_type(copyfunc), ossl_check_CMS_SignerInfo_freefunc_type(freefunc)))
+#define sk_CMS_SignerInfo_set_cmp_func(sk, cmp) ((sk_CMS_SignerInfo_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey)
+#define sk_CMS_RecipientEncryptedKey_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_value(sk, idx) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_value(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk), (idx)))
+#define sk_CMS_RecipientEncryptedKey_new(cmp) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new(ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp)))
+#define sk_CMS_RecipientEncryptedKey_new_null() ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new_null())
+#define sk_CMS_RecipientEncryptedKey_new_reserve(cmp, n) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp), (n)))
+#define sk_CMS_RecipientEncryptedKey_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (n))
+#define sk_CMS_RecipientEncryptedKey_free(sk) OPENSSL_sk_free(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_delete(sk, i) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_delete(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (i)))
+#define sk_CMS_RecipientEncryptedKey_delete_ptr(sk, ptr) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr)))
+#define sk_CMS_RecipientEncryptedKey_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_pop(sk) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_pop(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_shift(sk) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_shift(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk),ossl_check_CMS_RecipientEncryptedKey_freefunc_type(freefunc))
+#define sk_CMS_RecipientEncryptedKey_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr), (idx))
+#define sk_CMS_RecipientEncryptedKey_set(sk, idx, ptr) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_set(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (idx), ossl_check_CMS_RecipientEncryptedKey_type(ptr)))
+#define sk_CMS_RecipientEncryptedKey_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr), pnum)
+#define sk_CMS_RecipientEncryptedKey_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_dup(sk) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_dup(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_copyfunc_type(copyfunc), ossl_check_CMS_RecipientEncryptedKey_freefunc_type(freefunc)))
+#define sk_CMS_RecipientEncryptedKey_set_cmp_func(sk, cmp) ((sk_CMS_RecipientEncryptedKey_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_RecipientInfo, CMS_RecipientInfo, CMS_RecipientInfo)
+#define sk_CMS_RecipientInfo_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_value(sk, idx) ((CMS_RecipientInfo *)OPENSSL_sk_value(ossl_check_const_CMS_RecipientInfo_sk_type(sk), (idx)))
+#define sk_CMS_RecipientInfo_new(cmp) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new(ossl_check_CMS_RecipientInfo_compfunc_type(cmp)))
+#define sk_CMS_RecipientInfo_new_null() ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new_null())
+#define sk_CMS_RecipientInfo_new_reserve(cmp, n) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RecipientInfo_compfunc_type(cmp), (n)))
+#define sk_CMS_RecipientInfo_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RecipientInfo_sk_type(sk), (n))
+#define sk_CMS_RecipientInfo_free(sk) OPENSSL_sk_free(ossl_check_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_delete(sk, i) ((CMS_RecipientInfo *)OPENSSL_sk_delete(ossl_check_CMS_RecipientInfo_sk_type(sk), (i)))
+#define sk_CMS_RecipientInfo_delete_ptr(sk, ptr) ((CMS_RecipientInfo *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr)))
+#define sk_CMS_RecipientInfo_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_pop(sk) ((CMS_RecipientInfo *)OPENSSL_sk_pop(ossl_check_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_shift(sk) ((CMS_RecipientInfo *)OPENSSL_sk_shift(ossl_check_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RecipientInfo_sk_type(sk),ossl_check_CMS_RecipientInfo_freefunc_type(freefunc))
+#define sk_CMS_RecipientInfo_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr), (idx))
+#define sk_CMS_RecipientInfo_set(sk, idx, ptr) ((CMS_RecipientInfo *)OPENSSL_sk_set(ossl_check_CMS_RecipientInfo_sk_type(sk), (idx), ossl_check_CMS_RecipientInfo_type(ptr)))
+#define sk_CMS_RecipientInfo_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr), pnum)
+#define sk_CMS_RecipientInfo_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_dup(sk) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_dup(ossl_check_const_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_copyfunc_type(copyfunc), ossl_check_CMS_RecipientInfo_freefunc_type(freefunc)))
+#define sk_CMS_RecipientInfo_set_cmp_func(sk, cmp) ((sk_CMS_RecipientInfo_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_RevocationInfoChoice, CMS_RevocationInfoChoice, CMS_RevocationInfoChoice)
+#define sk_CMS_RevocationInfoChoice_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_value(sk, idx) ((CMS_RevocationInfoChoice *)OPENSSL_sk_value(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk), (idx)))
+#define sk_CMS_RevocationInfoChoice_new(cmp) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new(ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp)))
+#define sk_CMS_RevocationInfoChoice_new_null() ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new_null())
+#define sk_CMS_RevocationInfoChoice_new_reserve(cmp, n) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp), (n)))
+#define sk_CMS_RevocationInfoChoice_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (n))
+#define sk_CMS_RevocationInfoChoice_free(sk) OPENSSL_sk_free(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_delete(sk, i) ((CMS_RevocationInfoChoice *)OPENSSL_sk_delete(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (i)))
+#define sk_CMS_RevocationInfoChoice_delete_ptr(sk, ptr) ((CMS_RevocationInfoChoice *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr)))
+#define sk_CMS_RevocationInfoChoice_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_pop(sk) ((CMS_RevocationInfoChoice *)OPENSSL_sk_pop(ossl_check_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_shift(sk) ((CMS_RevocationInfoChoice *)OPENSSL_sk_shift(ossl_check_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RevocationInfoChoice_sk_type(sk),ossl_check_CMS_RevocationInfoChoice_freefunc_type(freefunc))
+#define sk_CMS_RevocationInfoChoice_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr), (idx))
+#define sk_CMS_RevocationInfoChoice_set(sk, idx, ptr) ((CMS_RevocationInfoChoice *)OPENSSL_sk_set(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (idx), ossl_check_CMS_RevocationInfoChoice_type(ptr)))
+#define sk_CMS_RevocationInfoChoice_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr), pnum)
+#define sk_CMS_RevocationInfoChoice_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_dup(sk) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_dup(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_copyfunc_type(copyfunc), ossl_check_CMS_RevocationInfoChoice_freefunc_type(freefunc)))
+#define sk_CMS_RevocationInfoChoice_set_cmp_func(sk, cmp) ((sk_CMS_RevocationInfoChoice_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp)))
+
+/* clang-format on */
+
+DECLARE_ASN1_ITEM(CMS_EnvelopedData)
+DECLARE_ASN1_ALLOC_FUNCTIONS(CMS_SignedData)
+DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo)
+DECLARE_ASN1_FUNCTIONS(CMS_ReceiptRequest)
+DECLARE_ASN1_PRINT_FUNCTION(CMS_ContentInfo)
+
+DECLARE_ASN1_DUP_FUNCTION(CMS_EnvelopedData)
+
+CMS_ContentInfo *CMS_ContentInfo_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+#define CMS_SIGNERINFO_ISSUER_SERIAL 0
+#define CMS_SIGNERINFO_KEYIDENTIFIER 1
+
+#define CMS_RECIPINFO_NONE -1
+#define CMS_RECIPINFO_TRANS 0
+#define CMS_RECIPINFO_AGREE 1
+#define CMS_RECIPINFO_KEK 2
+#define CMS_RECIPINFO_PASS 3
+#define CMS_RECIPINFO_OTHER 4
+
+/* S/MIME related flags */
+
+#define CMS_TEXT 0x1
+#define CMS_NOCERTS 0x2
+#define CMS_NO_CONTENT_VERIFY 0x4
+#define CMS_NO_ATTR_VERIFY 0x8
+#define CMS_NOSIGS \
+    (CMS_NO_CONTENT_VERIFY | CMS_NO_ATTR_VERIFY)
+#define CMS_NOINTERN 0x10
+#define CMS_NO_SIGNER_CERT_VERIFY 0x20
+#define CMS_NOVERIFY 0x20
+#define CMS_DETACHED 0x40
+#define CMS_BINARY 0x80
+#define CMS_NOATTR 0x100
+#define CMS_NOSMIMECAP 0x200
+#define CMS_NOOLDMIMETYPE 0x400
+#define CMS_CRLFEOL 0x800
+#define CMS_STREAM 0x1000
+#define CMS_NOCRL 0x2000
+#define CMS_PARTIAL 0x4000
+#define CMS_REUSE_DIGEST 0x8000
+#define CMS_USE_KEYID 0x10000
+#define CMS_DEBUG_DECRYPT 0x20000
+#define CMS_KEY_PARAM 0x40000
+#define CMS_ASCIICRLF 0x80000
+#define CMS_CADES 0x100000
+#define CMS_USE_ORIGINATOR_KEYID 0x200000
+#define CMS_NO_SIGNING_TIME 0x400000
+
+const ASN1_OBJECT *CMS_get0_type(const CMS_ContentInfo *cms);
+
+BIO *CMS_dataInit(CMS_ContentInfo *cms, BIO *icont);
+int CMS_dataFinal(CMS_ContentInfo *cms, BIO *bio);
+
+ASN1_OCTET_STRING **CMS_get0_content(CMS_ContentInfo *cms);
+int CMS_is_detached(CMS_ContentInfo *cms);
+int CMS_set_detached(CMS_ContentInfo *cms, int detached);
+
+#ifdef OPENSSL_PEM_H
+DECLARE_PEM_rw(CMS, CMS_ContentInfo)
+#endif
+int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms);
+CMS_ContentInfo *d2i_CMS_bio(BIO *bp, CMS_ContentInfo **cms);
+int i2d_CMS_bio(BIO *bp, CMS_ContentInfo *cms);
+
+BIO *BIO_new_CMS(BIO *out, CMS_ContentInfo *cms);
+int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags);
+int PEM_write_bio_CMS_stream(BIO *out, CMS_ContentInfo *cms, BIO *in,
+    int flags);
+CMS_ContentInfo *SMIME_read_CMS(BIO *bio, BIO **bcont);
+CMS_ContentInfo *SMIME_read_CMS_ex(BIO *bio, int flags, BIO **bcont, CMS_ContentInfo **ci);
+int SMIME_write_CMS(BIO *bio, CMS_ContentInfo *cms, BIO *data, int flags);
+
+int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont,
+    unsigned int flags);
+int CMS_final_digest(CMS_ContentInfo *cms,
+    const unsigned char *md, unsigned int mdlen, BIO *dcont,
+    unsigned int flags);
+
+CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey,
+    STACK_OF(X509) *certs, BIO *data,
+    unsigned int flags);
+CMS_ContentInfo *CMS_sign_ex(X509 *signcert, EVP_PKEY *pkey,
+    STACK_OF(X509) *certs, BIO *data,
+    unsigned int flags, OSSL_LIB_CTX *libctx,
+    const char *propq);
+
+CMS_ContentInfo *CMS_sign_receipt(CMS_SignerInfo *si,
+    X509 *signcert, EVP_PKEY *pkey,
+    STACK_OF(X509) *certs, unsigned int flags);
+
+int CMS_data(CMS_ContentInfo *cms, BIO *out, unsigned int flags);
+CMS_ContentInfo *CMS_data_create(BIO *in, unsigned int flags);
+CMS_ContentInfo *CMS_data_create_ex(BIO *in, unsigned int flags,
+    OSSL_LIB_CTX *libctx, const char *propq);
+
+int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
+    unsigned int flags);
+CMS_ContentInfo *CMS_digest_create(BIO *in, const EVP_MD *md,
+    unsigned int flags);
+CMS_ContentInfo *CMS_digest_create_ex(BIO *in, const EVP_MD *md,
+    unsigned int flags, OSSL_LIB_CTX *libctx,
+    const char *propq);
+
+int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms,
+    const unsigned char *key, size_t keylen,
+    BIO *dcont, BIO *out, unsigned int flags);
+CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher,
+    const unsigned char *key,
+    size_t keylen, unsigned int flags);
+CMS_ContentInfo *CMS_EncryptedData_encrypt_ex(BIO *in, const EVP_CIPHER *cipher,
+    const unsigned char *key,
+    size_t keylen, unsigned int flags,
+    OSSL_LIB_CTX *libctx,
+    const char *propq);
+
+int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph,
+    const unsigned char *key, size_t keylen);
+
+int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs,
+    X509_STORE *store, BIO *dcont, BIO *out, unsigned int flags);
+
+int CMS_verify_receipt(CMS_ContentInfo *rcms, CMS_ContentInfo *ocms,
+    STACK_OF(X509) *certs,
+    X509_STORE *store, unsigned int flags);
+
+STACK_OF(X509) *CMS_get0_signers(CMS_ContentInfo *cms);
+
+CMS_ContentInfo *CMS_encrypt(STACK_OF(X509) *certs, BIO *in,
+    const EVP_CIPHER *cipher, unsigned int flags);
+CMS_ContentInfo *CMS_encrypt_ex(STACK_OF(X509) *certs, BIO *in,
+    const EVP_CIPHER *cipher, unsigned int flags,
+    OSSL_LIB_CTX *libctx, const char *propq);
+
+int CMS_decrypt(CMS_ContentInfo *cms, EVP_PKEY *pkey, X509 *cert,
+    BIO *dcont, BIO *out, unsigned int flags);
+
+int CMS_decrypt_set1_pkey(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert);
+int CMS_decrypt_set1_pkey_and_peer(CMS_ContentInfo *cms, EVP_PKEY *pk,
+    X509 *cert, X509 *peer);
+int CMS_decrypt_set1_key(CMS_ContentInfo *cms,
+    unsigned char *key, size_t keylen,
+    const unsigned char *id, size_t idlen);
+int CMS_decrypt_set1_password(CMS_ContentInfo *cms,
+    unsigned char *pass, ossl_ssize_t passlen);
+
+STACK_OF(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo *cms);
+int CMS_RecipientInfo_type(CMS_RecipientInfo *ri);
+EVP_PKEY_CTX *CMS_RecipientInfo_get0_pkey_ctx(CMS_RecipientInfo *ri);
+CMS_ContentInfo *CMS_AuthEnvelopedData_create(const EVP_CIPHER *cipher);
+CMS_ContentInfo *
+CMS_AuthEnvelopedData_create_ex(const EVP_CIPHER *cipher, OSSL_LIB_CTX *libctx,
+    const char *propq);
+CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher);
+CMS_ContentInfo *CMS_EnvelopedData_create_ex(const EVP_CIPHER *cipher,
+    OSSL_LIB_CTX *libctx,
+    const char *propq);
+BIO *CMS_EnvelopedData_decrypt(CMS_EnvelopedData *env, BIO *detached_data,
+    EVP_PKEY *pkey, X509 *cert,
+    ASN1_OCTET_STRING *secret, unsigned int flags,
+    OSSL_LIB_CTX *libctx, const char *propq);
+
+CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms,
+    X509 *recip, unsigned int flags);
+CMS_RecipientInfo *CMS_add1_recipient(CMS_ContentInfo *cms, X509 *recip,
+    EVP_PKEY *originatorPrivKey, X509 *originator, unsigned int flags);
+int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pkey);
+int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo *ri, X509 *cert);
+int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo *ri,
+    EVP_PKEY **pk, X509 **recip,
+    X509_ALGOR **palg);
+int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo *ri,
+    ASN1_OCTET_STRING **keyid,
+    X509_NAME **issuer,
+    ASN1_INTEGER **sno);
+
+CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid,
+    unsigned char *key, size_t keylen,
+    unsigned char *id, size_t idlen,
+    ASN1_GENERALIZEDTIME *date,
+    ASN1_OBJECT *otherTypeId,
+    ASN1_TYPE *otherType);
+
+int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri,
+    X509_ALGOR **palg,
+    ASN1_OCTET_STRING **pid,
+    ASN1_GENERALIZEDTIME **pdate,
+    ASN1_OBJECT **potherid,
+    ASN1_TYPE **pothertype);
+
+int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri,
+    unsigned char *key, size_t keylen);
+
+int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri,
+    const unsigned char *id, size_t idlen);
+
+int CMS_RecipientInfo_set0_password(CMS_RecipientInfo *ri,
+    unsigned char *pass,
+    ossl_ssize_t passlen);
+
+CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms,
+    int iter, int wrap_nid,
+    int pbe_nid,
+    unsigned char *pass,
+    ossl_ssize_t passlen,
+    const EVP_CIPHER *kekciph);
+
+int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri);
+int CMS_RecipientInfo_encrypt(const CMS_ContentInfo *cms, CMS_RecipientInfo *ri);
+
+int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
+    unsigned int flags);
+CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags);
+
+int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid);
+const ASN1_OBJECT *CMS_get0_eContentType(CMS_ContentInfo *cms);
+
+CMS_CertificateChoices *CMS_add0_CertificateChoices(CMS_ContentInfo *cms);
+int CMS_add0_cert(CMS_ContentInfo *cms, X509 *cert);
+int CMS_add1_cert(CMS_ContentInfo *cms, X509 *cert);
+STACK_OF(X509) *CMS_get1_certs(CMS_ContentInfo *cms);
+
+CMS_RevocationInfoChoice *CMS_add0_RevocationInfoChoice(CMS_ContentInfo *cms);
+int CMS_add0_crl(CMS_ContentInfo *cms, X509_CRL *crl);
+int CMS_add1_crl(CMS_ContentInfo *cms, X509_CRL *crl);
+STACK_OF(X509_CRL) *CMS_get1_crls(CMS_ContentInfo *cms);
+
+int CMS_SignedData_init(CMS_ContentInfo *cms);
+CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms,
+    X509 *signer, EVP_PKEY *pk, const EVP_MD *md,
+    unsigned int flags);
+EVP_PKEY_CTX *CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo *si);
+EVP_MD_CTX *CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo *si);
+STACK_OF(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo *cms);
+
+void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer);
+int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si,
+    ASN1_OCTET_STRING **keyid,
+    X509_NAME **issuer, ASN1_INTEGER **sno);
+int CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert);
+int CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *certs,
+    unsigned int flags);
+void CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk,
+    X509 **signer, X509_ALGOR **pdig,
+    X509_ALGOR **psig);
+ASN1_OCTET_STRING *CMS_SignerInfo_get0_signature(CMS_SignerInfo *si);
+int CMS_SignerInfo_sign(CMS_SignerInfo *si);
+int CMS_SignerInfo_verify(CMS_SignerInfo *si);
+int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain);
+BIO *CMS_SignedData_verify(CMS_SignedData *sd, BIO *detached_data,
+    STACK_OF(X509) *scerts, X509_STORE *store,
+    STACK_OF(X509) *extra, STACK_OF(X509_CRL) *crls,
+    unsigned int flags,
+    OSSL_LIB_CTX *libctx, const char *propq);
+
+int CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs);
+int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs,
+    int algnid, int keysize);
+int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap);
+
+int CMS_signed_get_attr_count(const CMS_SignerInfo *si);
+int CMS_signed_get_attr_by_NID(const CMS_SignerInfo *si, int nid,
+    int lastpos);
+int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo *si, const ASN1_OBJECT *obj,
+    int lastpos);
+X509_ATTRIBUTE *CMS_signed_get_attr(const CMS_SignerInfo *si, int loc);
+X509_ATTRIBUTE *CMS_signed_delete_attr(CMS_SignerInfo *si, int loc);
+int CMS_signed_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr);
+int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo *si,
+    const ASN1_OBJECT *obj, int type,
+    const void *bytes, int len);
+int CMS_signed_add1_attr_by_NID(CMS_SignerInfo *si,
+    int nid, int type,
+    const void *bytes, int len);
+int CMS_signed_add1_attr_by_txt(CMS_SignerInfo *si,
+    const char *attrname, int type,
+    const void *bytes, int len);
+void *CMS_signed_get0_data_by_OBJ(const CMS_SignerInfo *si,
+    const ASN1_OBJECT *oid,
+    int lastpos, int type);
+
+int CMS_unsigned_get_attr_count(const CMS_SignerInfo *si);
+int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo *si, int nid,
+    int lastpos);
+int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo *si,
+    const ASN1_OBJECT *obj, int lastpos);
+X509_ATTRIBUTE *CMS_unsigned_get_attr(const CMS_SignerInfo *si, int loc);
+X509_ATTRIBUTE *CMS_unsigned_delete_attr(CMS_SignerInfo *si, int loc);
+int CMS_unsigned_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr);
+int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo *si,
+    const ASN1_OBJECT *obj, int type,
+    const void *bytes, int len);
+int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo *si,
+    int nid, int type,
+    const void *bytes, int len);
+int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo *si,
+    const char *attrname, int type,
+    const void *bytes, int len);
+void *CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid,
+    int lastpos, int type);
+
+int CMS_get1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest **prr);
+CMS_ReceiptRequest *CMS_ReceiptRequest_create0(
+    unsigned char *id, int idlen, int allorfirst,
+    STACK_OF(GENERAL_NAMES) *receiptList,
+    STACK_OF(GENERAL_NAMES) *receiptsTo);
+CMS_ReceiptRequest *CMS_ReceiptRequest_create0_ex(
+    unsigned char *id, int idlen, int allorfirst,
+    STACK_OF(GENERAL_NAMES) *receiptList,
+    STACK_OF(GENERAL_NAMES) *receiptsTo,
+    OSSL_LIB_CTX *libctx);
+
+int CMS_add1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest *rr);
+void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest *rr,
+    ASN1_STRING **pcid,
+    int *pallorfirst,
+    STACK_OF(GENERAL_NAMES) **plist,
+    STACK_OF(GENERAL_NAMES) **prto);
+int CMS_RecipientInfo_kari_get0_alg(CMS_RecipientInfo *ri,
+    X509_ALGOR **palg,
+    ASN1_OCTET_STRING **pukm);
+STACK_OF(CMS_RecipientEncryptedKey)
+*CMS_RecipientInfo_kari_get0_reks(CMS_RecipientInfo *ri);
+
+int CMS_RecipientInfo_kari_get0_orig_id(CMS_RecipientInfo *ri,
+    X509_ALGOR **pubalg,
+    ASN1_BIT_STRING **pubkey,
+    ASN1_OCTET_STRING **keyid,
+    X509_NAME **issuer,
+    ASN1_INTEGER **sno);
+
+int CMS_RecipientInfo_kari_orig_id_cmp(CMS_RecipientInfo *ri, X509 *cert);
+
+int CMS_RecipientEncryptedKey_get0_id(CMS_RecipientEncryptedKey *rek,
+    ASN1_OCTET_STRING **keyid,
+    ASN1_GENERALIZEDTIME **tm,
+    CMS_OtherKeyAttribute **other,
+    X509_NAME **issuer, ASN1_INTEGER **sno);
+int CMS_RecipientEncryptedKey_cert_cmp(CMS_RecipientEncryptedKey *rek,
+    X509 *cert);
+int CMS_RecipientInfo_kari_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pk);
+int CMS_RecipientInfo_kari_set0_pkey_and_peer(CMS_RecipientInfo *ri, EVP_PKEY *pk, X509 *peer);
+EVP_CIPHER_CTX *CMS_RecipientInfo_kari_get0_ctx(CMS_RecipientInfo *ri);
+int CMS_RecipientInfo_kari_decrypt(CMS_ContentInfo *cms,
+    CMS_RecipientInfo *ri,
+    CMS_RecipientEncryptedKey *rek);
+
+int CMS_SharedInfo_encode(unsigned char **pder, X509_ALGOR *kekalg,
+    ASN1_OCTET_STRING *ukm, int keylen);
+
+/* Backward compatibility for spelling errors. */
+#define CMS_R_UNKNOWN_DIGEST_ALGORITM CMS_R_UNKNOWN_DIGEST_ALGORITHM
+#define CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE \
+    CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/cmserr.h

@@ -0,0 +1,125 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMSERR_H
+#define OPENSSL_CMSERR_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
+
+#ifndef OPENSSL_NO_CMS
+
+/*
+ * CMS reason codes.
+ */
+#define CMS_R_ADD_SIGNER_ERROR 99
+#define CMS_R_ATTRIBUTE_ERROR 161
+#define CMS_R_CERTIFICATE_ALREADY_PRESENT 175
+#define CMS_R_CERTIFICATE_HAS_NO_KEYID 160
+#define CMS_R_CERTIFICATE_VERIFY_ERROR 100
+#define CMS_R_CIPHER_AEAD_IN_ENVELOPED_DATA 200
+#define CMS_R_CIPHER_AEAD_SET_TAG_ERROR 184
+#define CMS_R_CIPHER_GET_TAG 185
+#define CMS_R_CIPHER_INITIALISATION_ERROR 101
+#define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR 102
+#define CMS_R_CMS_DATAFINAL_ERROR 103
+#define CMS_R_CMS_LIB 104
+#define CMS_R_CONTENTIDENTIFIER_MISMATCH 170
+#define CMS_R_CONTENT_NOT_FOUND 105
+#define CMS_R_CONTENT_TYPE_MISMATCH 171
+#define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA 106
+#define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA 107
+#define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA 108
+#define CMS_R_CONTENT_VERIFY_ERROR 109
+#define CMS_R_CTRL_ERROR 110
+#define CMS_R_CTRL_FAILURE 111
+#define CMS_R_DECODE_ERROR 187
+#define CMS_R_DECRYPT_ERROR 112
+#define CMS_R_ERROR_GETTING_PUBLIC_KEY 113
+#define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE 114
+#define CMS_R_ERROR_SETTING_KEY 115
+#define CMS_R_ERROR_SETTING_RECIPIENTINFO 116
+#define CMS_R_ERROR_UNSUPPORTED_STATIC_KEY_AGREEMENT 196
+#define CMS_R_ESS_SIGNING_CERTID_MISMATCH_ERROR 183
+#define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH 117
+#define CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER 176
+#define CMS_R_INVALID_KEY_LENGTH 118
+#define CMS_R_INVALID_LABEL 190
+#define CMS_R_INVALID_OAEP_PARAMETERS 191
+#define CMS_R_KDF_PARAMETER_ERROR 186
+#define CMS_R_MD_BIO_INIT_ERROR 119
+#define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH 120
+#define CMS_R_MESSAGEDIGEST_WRONG_LENGTH 121
+#define CMS_R_MSGSIGDIGEST_ERROR 172
+#define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE 162
+#define CMS_R_MSGSIGDIGEST_WRONG_LENGTH 163
+#define CMS_R_NEED_ONE_SIGNER 164
+#define CMS_R_NOT_A_SIGNED_RECEIPT 165
+#define CMS_R_NOT_ENCRYPTED_DATA 122
+#define CMS_R_NOT_KEK 123
+#define CMS_R_NOT_KEY_AGREEMENT 181
+#define CMS_R_NOT_KEY_TRANSPORT 124
+#define CMS_R_NOT_PWRI 177
+#define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 125
+#define CMS_R_NO_CIPHER 126
+#define CMS_R_NO_CONTENT 127
+#define CMS_R_NO_CONTENT_TYPE 173
+#define CMS_R_NO_DEFAULT_DIGEST 128
+#define CMS_R_NO_DIGEST_SET 129
+#define CMS_R_NO_KEY 130
+#define CMS_R_NO_KEY_OR_CERT 174
+#define CMS_R_NO_MATCHING_DIGEST 131
+#define CMS_R_NO_MATCHING_RECIPIENT 132
+#define CMS_R_NO_MATCHING_SIGNATURE 166
+#define CMS_R_NO_MSGSIGDIGEST 167
+#define CMS_R_NO_PASSWORD 178
+#define CMS_R_NO_PRIVATE_KEY 133
+#define CMS_R_NO_PUBLIC_KEY 134
+#define CMS_R_NO_RECEIPT_REQUEST 168
+#define CMS_R_NO_SIGNERS 135
+#define CMS_R_OPERATION_UNSUPPORTED 182
+#define CMS_R_PEER_KEY_ERROR 188
+#define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 136
+#define CMS_R_RECEIPT_DECODE_ERROR 169
+#define CMS_R_RECIPIENT_ERROR 137
+#define CMS_R_SHARED_INFO_ERROR 189
+#define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND 138
+#define CMS_R_SIGNFINAL_ERROR 139
+#define CMS_R_SMIME_TEXT_ERROR 140
+#define CMS_R_STORE_INIT_ERROR 141
+#define CMS_R_TYPE_NOT_COMPRESSED_DATA 142
+#define CMS_R_TYPE_NOT_DATA 143
+#define CMS_R_TYPE_NOT_DIGESTED_DATA 144
+#define CMS_R_TYPE_NOT_ENCRYPTED_DATA 145
+#define CMS_R_TYPE_NOT_ENVELOPED_DATA 146
+#define CMS_R_UNABLE_TO_FINALIZE_CONTEXT 147
+#define CMS_R_UNKNOWN_CIPHER 148
+#define CMS_R_UNKNOWN_DIGEST_ALGORITHM 149
+#define CMS_R_UNKNOWN_ID 150
+#define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM 151
+#define CMS_R_UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM 194
+#define CMS_R_UNSUPPORTED_CONTENT_TYPE 152
+#define CMS_R_UNSUPPORTED_ENCRYPTION_TYPE 192
+#define CMS_R_UNSUPPORTED_KEK_ALGORITHM 153
+#define CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM 179
+#define CMS_R_UNSUPPORTED_LABEL_SOURCE 193
+#define CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE 155
+#define CMS_R_UNSUPPORTED_RECIPIENT_TYPE 154
+#define CMS_R_UNSUPPORTED_SIGNATURE_ALGORITHM 195
+#define CMS_R_UNSUPPORTED_TYPE 156
+#define CMS_R_UNWRAP_ERROR 157
+#define CMS_R_UNWRAP_FAILURE 180
+#define CMS_R_VERIFICATION_FAILURE 158
+#define CMS_R_WRAP_ERROR 159
+
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/comp.h

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2015-2024 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/* clang-format off */
+
+/* clang-format on */
+
+#ifndef OPENSSL_COMP_H
+#define OPENSSL_COMP_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_COMP_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#include <openssl/crypto.h>
+#include <openssl/comperr.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef OPENSSL_NO_COMP
+
+COMP_CTX *COMP_CTX_new(COMP_METHOD *meth);
+const COMP_METHOD *COMP_CTX_get_method(const COMP_CTX *ctx);
+int COMP_CTX_get_type(const COMP_CTX *comp);
+int COMP_get_type(const COMP_METHOD *meth);
+const char *COMP_get_name(const COMP_METHOD *meth);
+void COMP_CTX_free(COMP_CTX *ctx);
+
+int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen,
+    unsigned char *in, int ilen);
+int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen,
+    unsigned char *in, int ilen);
+
+COMP_METHOD *COMP_zlib(void);
+COMP_METHOD *COMP_zlib_oneshot(void);
+COMP_METHOD *COMP_brotli(void);
+COMP_METHOD *COMP_brotli_oneshot(void);
+COMP_METHOD *COMP_zstd(void);
+COMP_METHOD *COMP_zstd_oneshot(void);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define COMP_zlib_cleanup() \
+    while (0)               \
+    continue
+#endif
+
+#ifdef OPENSSL_BIO_H
+const BIO_METHOD *BIO_f_zlib(void);
+const BIO_METHOD *BIO_f_brotli(void);
+const BIO_METHOD *BIO_f_zstd(void);
+#endif
+
+#endif
+
+typedef struct ssl_comp_st SSL_COMP;
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(SSL_COMP, SSL_COMP, SSL_COMP)
+#define sk_SSL_COMP_num(sk) OPENSSL_sk_num(ossl_check_const_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_value(sk, idx) ((SSL_COMP *)OPENSSL_sk_value(ossl_check_const_SSL_COMP_sk_type(sk), (idx)))
+#define sk_SSL_COMP_new(cmp) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new(ossl_check_SSL_COMP_compfunc_type(cmp)))
+#define sk_SSL_COMP_new_null() ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new_null())
+#define sk_SSL_COMP_new_reserve(cmp, n) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new_reserve(ossl_check_SSL_COMP_compfunc_type(cmp), (n)))
+#define sk_SSL_COMP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SSL_COMP_sk_type(sk), (n))
+#define sk_SSL_COMP_free(sk) OPENSSL_sk_free(ossl_check_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_zero(sk) OPENSSL_sk_zero(ossl_check_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_delete(sk, i) ((SSL_COMP *)OPENSSL_sk_delete(ossl_check_SSL_COMP_sk_type(sk), (i)))
+#define sk_SSL_COMP_delete_ptr(sk, ptr) ((SSL_COMP *)OPENSSL_sk_delete_ptr(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr)))
+#define sk_SSL_COMP_push(sk, ptr) OPENSSL_sk_push(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_pop(sk) ((SSL_COMP *)OPENSSL_sk_pop(ossl_check_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_shift(sk) ((SSL_COMP *)OPENSSL_sk_shift(ossl_check_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SSL_COMP_sk_type(sk),ossl_check_SSL_COMP_freefunc_type(freefunc))
+#define sk_SSL_COMP_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr), (idx))
+#define sk_SSL_COMP_set(sk, idx, ptr) ((SSL_COMP *)OPENSSL_sk_set(ossl_check_SSL_COMP_sk_type(sk), (idx), ossl_check_SSL_COMP_type(ptr)))
+#define sk_SSL_COMP_find(sk, ptr) OPENSSL_sk_find(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr), pnum)
+#define sk_SSL_COMP_sort(sk) OPENSSL_sk_sort(ossl_check_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_dup(sk) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_dup(ossl_check_const_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_deep_copy(ossl_check_const_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_copyfunc_type(copyfunc), ossl_check_SSL_COMP_freefunc_type(freefunc)))
+#define sk_SSL_COMP_set_cmp_func(sk, cmp) ((sk_SSL_COMP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_compfunc_type(cmp)))
+
+/* clang-format on */
+
+#ifdef __cplusplus
+}
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/comperr.h

@@ -0,0 +1,36 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_COMPERR_H
+#define OPENSSL_COMPERR_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
+
+#ifndef OPENSSL_NO_COMP
+
+/*
+ * COMP reason codes.
+ */
+#define COMP_R_BROTLI_DECODE_ERROR 102
+#define COMP_R_BROTLI_ENCODE_ERROR 103
+#define COMP_R_BROTLI_NOT_SUPPORTED 104
+#define COMP_R_ZLIB_DEFLATE_ERROR 99
+#define COMP_R_ZLIB_INFLATE_ERROR 100
+#define COMP_R_ZLIB_NOT_SUPPORTED 101
+#define COMP_R_ZSTD_COMPRESS_ERROR 105
+#define COMP_R_ZSTD_DECODE_ERROR 106
+#define COMP_R_ZSTD_DECOMPRESS_ERROR 107
+#define COMP_R_ZSTD_NOT_SUPPORTED 108
+
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/conf.h

@@ -0,0 +1,219 @@
+/*
+ * WARNING: do not edit!
+ * Generated by Makefile from include/openssl/conf.h.in
+ *
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/* clang-format off */
+
+/* clang-format on */
+
+#ifndef OPENSSL_CONF_H
+#define OPENSSL_CONF_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CONF_H
+#endif
+
+#include <openssl/bio.h>
+#include <openssl/lhash.h>
+#include <openssl/safestack.h>
+#include <openssl/e_os2.h>
+#include <openssl/types.h>
+#include <openssl/conferr.h>
+#ifndef OPENSSL_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    char *section;
+    char *name;
+    char *value;
+} CONF_VALUE;
+
+/* clang-format off */
+SKM_DEFINE_STACK_OF_INTERNAL(CONF_VALUE, CONF_VALUE, CONF_VALUE)
+#define sk_CONF_VALUE_num(sk) OPENSSL_sk_num(ossl_check_const_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_value(sk, idx) ((CONF_VALUE *)OPENSSL_sk_value(ossl_check_const_CONF_VALUE_sk_type(sk), (idx)))
+#define sk_CONF_VALUE_new(cmp) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new(ossl_check_CONF_VALUE_compfunc_type(cmp)))
+#define sk_CONF_VALUE_new_null() ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new_null())
+#define sk_CONF_VALUE_new_reserve(cmp, n) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new_reserve(ossl_check_CONF_VALUE_compfunc_type(cmp), (n)))
+#define sk_CONF_VALUE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CONF_VALUE_sk_type(sk), (n))
+#define sk_CONF_VALUE_free(sk) OPENSSL_sk_free(ossl_check_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_zero(sk) OPENSSL_sk_zero(ossl_check_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_delete(sk, i) ((CONF_VALUE *)OPENSSL_sk_delete(ossl_check_CONF_VALUE_sk_type(sk), (i)))
+#define sk_CONF_VALUE_delete_ptr(sk, ptr) ((CONF_VALUE *)OPENSSL_sk_delete_ptr(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr)))
+#define sk_CONF_VALUE_push(sk, ptr) OPENSSL_sk_push(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_pop(sk) ((CONF_VALUE *)OPENSSL_sk_pop(ossl_check_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_shift(sk) ((CONF_VALUE *)OPENSSL_sk_shift(ossl_check_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CONF_VALUE_sk_type(sk),ossl_check_CONF_VALUE_freefunc_type(freefunc))
+#define sk_CONF_VALUE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr), (idx))
+#define sk_CONF_VALUE_set(sk, idx, ptr) ((CONF_VALUE *)OPENSSL_sk_set(ossl_check_CONF_VALUE_sk_type(sk), (idx), ossl_check_CONF_VALUE_type(ptr)))
+#define sk_CONF_VALUE_find(sk, ptr) OPENSSL_sk_find(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr), pnum)
+#define sk_CONF_VALUE_sort(sk) OPENSSL_sk_sort(ossl_check_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_dup(sk) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_dup(ossl_check_const_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_deep_copy(ossl_check_const_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_copyfunc_type(copyfunc), ossl_check_CONF_VALUE_freefunc_type(freefunc)))
+#define sk_CONF_VALUE_set_cmp_func(sk, cmp) ((sk_CONF_VALUE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_compfunc_type(cmp)))
+DEFINE_LHASH_OF_INTERNAL(CONF_VALUE);
+#define lh_CONF_VALUE_new(hfn, cmp) ((LHASH_OF(CONF_VALUE) *)OPENSSL_LH_set_thunks(OPENSSL_LH_new(ossl_check_CONF_VALUE_lh_hashfunc_type(hfn), ossl_check_CONF_VALUE_lh_compfunc_type(cmp)), lh_CONF_VALUE_hash_thunk, lh_CONF_VALUE_comp_thunk, lh_CONF_VALUE_doall_thunk, lh_CONF_VALUE_doall_arg_thunk))
+#define lh_CONF_VALUE_free(lh) OPENSSL_LH_free(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_flush(lh) OPENSSL_LH_flush(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_insert(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_insert(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_delete(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_delete(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_const_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_retrieve(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_retrieve(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_const_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_error(lh) OPENSSL_LH_error(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_num_items(lh) OPENSSL_LH_num_items(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_CONF_VALUE_lh_type(lh), out)
+#define lh_CONF_VALUE_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_CONF_VALUE_lh_type(lh), out)
+#define lh_CONF_VALUE_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_CONF_VALUE_lh_type(lh), out)
+#define lh_CONF_VALUE_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_CONF_VALUE_lh_type(lh), dl)
+#define lh_CONF_VALUE_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_CONF_VALUE_lh_doallfunc_type(dfn))
+
+/* clang-format on */
+
+struct conf_st;
+struct conf_method_st;
+typedef struct conf_method_st CONF_METHOD;
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#include <openssl/conftypes.h>
+#endif
+
+/* Module definitions */
+typedef struct conf_imodule_st CONF_IMODULE;
+typedef struct conf_module_st CONF_MODULE;
+
+STACK_OF(CONF_MODULE);
+STACK_OF(CONF_IMODULE);
+
+/* DSO module function typedefs */
+typedef int conf_init_func(CONF_IMODULE *md, const CONF *cnf);
+typedef void conf_finish_func(CONF_IMODULE *md);
+
+#define CONF_MFLAGS_IGNORE_ERRORS 0x1
+#define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2
+#define CONF_MFLAGS_SILENT 0x4
+#define CONF_MFLAGS_NO_DSO 0x8
+#define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10
+#define CONF_MFLAGS_DEFAULT_SECTION 0x20
+
+int CONF_set_default_method(CONF_METHOD *meth);
+void CONF_set_nconf(CONF *conf, LHASH_OF(CONF_VALUE) *hash);
+LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf, const char *file,
+    long *eline);
+#ifndef OPENSSL_NO_STDIO
+LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp,
+    long *eline);
+#endif
+LHASH_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp,
+    long *eline);
+STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf,
+    const char *section);
+char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf, const char *group,
+    const char *name);
+long CONF_get_number(LHASH_OF(CONF_VALUE) *conf, const char *group,
+    const char *name);
+void CONF_free(LHASH_OF(CONF_VALUE) *conf);
+#ifndef OPENSSL_NO_STDIO
+int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out);
+#endif
+int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void OPENSSL_config(const char *config_name);
+#endif
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define OPENSSL_no_config() \
+    OPENSSL_init_crypto(OPENSSL_INIT_NO_LOAD_CONFIG, NULL)
+#endif
+
+/*
+ * New conf code.  The semantics are different from the functions above. If
+ * that wasn't the case, the above functions would have been replaced
+ */
+
+CONF *NCONF_new_ex(OSSL_LIB_CTX *libctx, CONF_METHOD *meth);
+OSSL_LIB_CTX *NCONF_get0_libctx(const CONF *conf);
+CONF *NCONF_new(CONF_METHOD *meth);
+CONF_METHOD *NCONF_default(void);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 CONF_METHOD *NCONF_WIN32(void);
+#endif
+void NCONF_free(CONF *conf);
+void NCONF_free_data(CONF *conf);
+
+int NCONF_load(CONF *conf, const char *file, long *eline);
+#ifndef OPENSSL_NO_STDIO
+int NCONF_load_fp(CONF *conf, FILE *fp, long *eline);
+#endif
+int NCONF_load_bio(CONF *conf, BIO *bp, long *eline);
+STACK_OF(OPENSSL_CSTRING) *NCONF_get_section_names(const CONF *conf);
+STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,
+    const char *section);
+char *NCONF_get_string(const CONF *conf, const char *group, const char *name);
+int NCONF_get_number_e(const CONF *conf, const char *group, const char *name,
+    long *result);
+#ifndef OPENSSL_NO_STDIO
+int NCONF_dump_fp(const CONF *conf, FILE *out);
+#endif
+int NCONF_dump_bio(const CONF *conf, BIO *out);
+
+#define NCONF_get_number(c, g, n, r) NCONF_get_number_e(c, g, n, r)
+
+/* Module functions */
+
+int CONF_modules_load(const CONF *cnf, const char *appname,
+    unsigned long flags);
+int CONF_modules_load_file_ex(OSSL_LIB_CTX *libctx, const char *filename,
+    const char *appname, unsigned long flags);
+int CONF_modules_load_file(const char *filename, const char *appname,
+    unsigned long flags);
+void CONF_modules_unload(int all);
+void CONF_modules_finish(void);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define CONF_modules_free() \
+    while (0)               \
+    continue
+#endif
+int CONF_module_add(const char *name, conf_init_func *ifunc,
+    conf_finish_func *ffunc);
+
+const char *CONF_imodule_get_name(const CONF_IMODULE *md);
+const char *CONF_imodule_get_value(const CONF_IMODULE *md);
+void *CONF_imodule_get_usr_data(const CONF_IMODULE *md);
+void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data);
+CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md);
+unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md);
+void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags);
+void *CONF_module_get_usr_data(CONF_MODULE *pmod);
+void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data);
+
+char *CONF_get1_default_config_file(void);
+
+int CONF_parse_list(const char *list, int sep, int nospc,
+    int (*list_cb)(const char *elem, int len, void *usr),
+    void *arg);
+
+void OPENSSL_load_builtin_modules(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/conf_api.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CONF_API_H
+#define OPENSSL_CONF_API_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CONF_API_H
+#endif
+
+#include <openssl/lhash.h>
+#include <openssl/conf.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Up until OpenSSL 0.9.5a, this was new_section */
+CONF_VALUE *_CONF_new_section(CONF *conf, const char *section);
+/* Up until OpenSSL 0.9.5a, this was get_section */
+CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section);
+/* Up until OpenSSL 0.9.5a, this was CONF_get_section */
+STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf,
+    const char *section);
+
+int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value);
+char *_CONF_get_string(const CONF *conf, const char *section,
+    const char *name);
+long _CONF_get_number(const CONF *conf, const char *section,
+    const char *name);
+
+int _CONF_new_data(CONF *conf);
+void _CONF_free_data(CONF *conf);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

miniconda3/envs/active_proaction/include/openssl/conferr.h

@@ -0,0 +1,50 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CONFERR_H
+#define OPENSSL_CONFERR_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
+
+/*
+ * CONF reason codes.
+ */
+#define CONF_R_ERROR_LOADING_DSO 110
+#define CONF_R_INVALID_PRAGMA 122
+#define CONF_R_LIST_CANNOT_BE_NULL 115
+#define CONF_R_MANDATORY_BRACES_IN_VARIABLE_EXPANSION 123
+#define CONF_R_MISSING_CLOSE_SQUARE_BRACKET 100
+#define CONF_R_MISSING_EQUAL_SIGN 101
+#define CONF_R_MISSING_INIT_FUNCTION 112
+#define CONF_R_MODULE_INITIALIZATION_ERROR 109
+#define CONF_R_NO_CLOSE_BRACE 102
+#define CONF_R_NO_CONF 105
+#define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE 106
+#define CONF_R_NO_SECTION 107
+#define CONF_R_NO_SUCH_FILE 114
+#define CONF_R_NO_VALUE 108
+#define CONF_R_NUMBER_TOO_LARGE 121
+#define CONF_R_OPENSSL_CONF_REFERENCES_MISSING_SECTION 124
+#define CONF_R_RECURSIVE_DIRECTORY_INCLUDE 111
+#define CONF_R_RECURSIVE_SECTION_REFERENCE 126
+#define CONF_R_RELATIVE_PATH 125
+#define CONF_R_SSL_COMMAND_SECTION_EMPTY 117
+#define CONF_R_SSL_COMMAND_SECTION_NOT_FOUND 118
+#define CONF_R_SSL_SECTION_EMPTY 119
+#define CONF_R_SSL_SECTION_NOT_FOUND 120
+#define CONF_R_UNABLE_TO_CREATE_NEW_SECTION 103
+#define CONF_R_UNKNOWN_MODULE_NAME 113
+#define CONF_R_VARIABLE_EXPANSION_TOO_LONG 116
+#define CONF_R_VARIABLE_HAS_NO_VALUE 104
+
+#endif

miniconda3/envs/active_proaction/include/openssl/configuration.h

@@ -0,0 +1,199 @@
+/*
+ * WARNING: do not edit!
+ * Generated by configdata.pm from Configurations/common0.tmpl, Configurations/unix-Makefile.tmpl
+ * via Makefile.in
+ *
+ * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CONFIGURATION_H
+#define OPENSSL_CONFIGURATION_H
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef OPENSSL_ALGORITHM_DEFINES
+#error OPENSSL_ALGORITHM_DEFINES no longer supported
+#endif
+
+/*
+ * OpenSSL was configured with the following options:
+ */
+
+/* clang-format off */
+# define OPENSSL_CONFIGURED_API 30500
+# ifndef OPENSSL_RAND_SEED_OS
+#  define OPENSSL_RAND_SEED_OS
+# endif
+# ifndef OPENSSL_THREADS
+#  define OPENSSL_THREADS
+# endif
+# ifndef OPENSSL_NO_ACVP_TESTS
+#  define OPENSSL_NO_ACVP_TESTS
+# endif
+# ifndef OPENSSL_NO_ASAN
+#  define OPENSSL_NO_ASAN
+# endif
+# ifndef OPENSSL_NO_BROTLI
+#  define OPENSSL_NO_BROTLI
+# endif
+# ifndef OPENSSL_NO_BROTLI_DYNAMIC
+#  define OPENSSL_NO_BROTLI_DYNAMIC
+# endif
+# ifndef OPENSSL_NO_CRYPTO_MDEBUG
+#  define OPENSSL_NO_CRYPTO_MDEBUG
+# endif
+# ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
+#  define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
+# endif
+# ifndef OPENSSL_NO_DEMOS
+#  define OPENSSL_NO_DEMOS
+# endif
+# ifndef OPENSSL_NO_DEVCRYPTOENG
+#  define OPENSSL_NO_DEVCRYPTOENG
+# endif
+# ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
+#  define OPENSSL_NO_EC_NISTP_64_GCC_128
+# endif
+# ifndef OPENSSL_NO_EGD
+#  define OPENSSL_NO_EGD
+# endif
+# ifndef OPENSSL_NO_EXTERNAL_TESTS
+#  define OPENSSL_NO_EXTERNAL_TESTS
+# endif
+# ifndef OPENSSL_NO_FIPS_JITTER
+#  define OPENSSL_NO_FIPS_JITTER
+# endif
+# ifndef OPENSSL_NO_FIPS_POST
+#  define OPENSSL_NO_FIPS_POST
+# endif
+# ifndef OPENSSL_NO_FIPS_SECURITYCHECKS
+#  define OPENSSL_NO_FIPS_SECURITYCHECKS
+# endif
+# ifndef OPENSSL_NO_FUZZ_AFL
+#  define OPENSSL_NO_FUZZ_AFL
+# endif
+# ifndef OPENSSL_NO_FUZZ_LIBFUZZER
+#  define OPENSSL_NO_FUZZ_LIBFUZZER
+# endif
+# ifndef OPENSSL_NO_H3DEMO
+#  define OPENSSL_NO_H3DEMO
+# endif
+# ifndef OPENSSL_NO_HQINTEROP
+#  define OPENSSL_NO_HQINTEROP
+# endif
+# ifndef OPENSSL_NO_JITTER
+#  define OPENSSL_NO_JITTER
+# endif
+# ifndef OPENSSL_NO_LOADERENG
+#  define OPENSSL_NO_LOADERENG
+# endif
+# ifndef OPENSSL_NO_MD2
+#  define OPENSSL_NO_MD2
+# endif
+# ifndef OPENSSL_NO_MSAN
+#  define OPENSSL_NO_MSAN
+# endif
+# ifndef OPENSSL_NO_PIE
+#  define OPENSSL_NO_PIE
+# endif
+# ifndef OPENSSL_NO_RC5
+#  define OPENSSL_NO_RC5
+# endif
+# ifndef OPENSSL_NO_SCTP
+#  define OPENSSL_NO_SCTP
+# endif
+# ifndef OPENSSL_NO_SSL3
+#  define OPENSSL_NO_SSL3
+# endif
+# ifndef OPENSSL_NO_SSL3_METHOD
+#  define OPENSSL_NO_SSL3_METHOD
+# endif
+# ifndef OPENSSL_NO_SSLKEYLOG
+#  define OPENSSL_NO_SSLKEYLOG
+# endif
+# ifndef OPENSSL_NO_TFO
+#  define OPENSSL_NO_TFO
+# endif
+# ifndef OPENSSL_NO_TRACE
+#  define OPENSSL_NO_TRACE
+# endif
+# ifndef OPENSSL_NO_UBSAN
+#  define OPENSSL_NO_UBSAN
+# endif
+# ifndef OPENSSL_NO_UNIT_TEST
+#  define OPENSSL_NO_UNIT_TEST
+# endif
+# ifndef OPENSSL_NO_UPLINK
+#  define OPENSSL_NO_UPLINK
+# endif
+# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+#  define OPENSSL_NO_WEAK_SSL_CIPHERS
+# endif
+# ifndef OPENSSL_NO_WINSTORE
+#  define OPENSSL_NO_WINSTORE
+# endif
+# ifndef OPENSSL_NO_ZLIB
+#  define OPENSSL_NO_ZLIB
+# endif
+# ifndef OPENSSL_NO_ZLIB_DYNAMIC
+#  define OPENSSL_NO_ZLIB_DYNAMIC
+# endif
+# ifndef OPENSSL_NO_ZSTD
+#  define OPENSSL_NO_ZSTD
+# endif
+# ifndef OPENSSL_NO_ZSTD_DYNAMIC
+#  define OPENSSL_NO_ZSTD_DYNAMIC
+# endif
+# ifndef OPENSSL_NO_DYNAMIC_ENGINE
+#  define OPENSSL_NO_DYNAMIC_ENGINE
+# endif
+
+/* clang-format on */
+
+/* Generate 80386 code? */
+/* clang-format off */
+# undef I386_ONLY
+/* clang-format on */
+
+/*
+ * The following are cipher-specific, but are part of the public API.
+ */
+#if !defined(OPENSSL_SYS_UEFI)
+    /* clang-format off */
+#  undef BN_LLONG
+    /* clang-format on */
+    /* Only one for the following should be defined */
+    /* clang-format off */
+#  define SIXTY_FOUR_BIT_LONG
+    /* clang-format on */
+    /* clang-format off */
+#  undef SIXTY_FOUR_BIT
+    /* clang-format on */
+    /* clang-format off */
+#  undef THIRTY_TWO_BIT
+/* clang-format on */
+#endif
+
+/* clang-format off */
+# define RC4_INT unsigned int
+/* clang-format on */
+
+#if defined(OPENSSL_NO_COMP) || (defined(OPENSSL_NO_BROTLI) && defined(OPENSSL_NO_ZSTD) && defined(OPENSSL_NO_ZLIB))
+#define OPENSSL_NO_COMP_ALG
+#else
+#undef OPENSSL_NO_COMP_ALG
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OPENSSL_CONFIGURATION_H */

miniconda3/envs/active_proaction/include/openssl/conftypes.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CONFTYPES_H
+#define OPENSSL_CONFTYPES_H
+#pragma once
+
+#ifndef OPENSSL_CONF_H
+#include <openssl/conf.h>
+#endif
+
+/*
+ * The contents of this file are deprecated and will be made opaque
+ */
+struct conf_method_st {
+    const char *name;
+    CONF *(*create)(CONF_METHOD *meth);
+    int (*init)(CONF *conf);
+    int (*destroy)(CONF *conf);
+    int (*destroy_data)(CONF *conf);
+    int (*load_bio)(CONF *conf, BIO *bp, long *eline);
+    int (*dump)(const CONF *conf, BIO *bp);
+    int (*is_number)(const CONF *conf, char c);
+    int (*to_int)(const CONF *conf, char c);
+    int (*load)(CONF *conf, const char *name, long *eline);
+};
+
+struct conf_st {
+    CONF_METHOD *meth;
+    void *meth_data;
+    LHASH_OF(CONF_VALUE) *data;
+    int flag_dollarid;
+    int flag_abspath;
+    char *includedir;
+    OSSL_LIB_CTX *libctx;
+};
+
+#endif

miniconda3/envs/active_proaction/include/openssl/core.h

@@ -0,0 +1,235 @@
+/*
+ * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CORE_H
+#define OPENSSL_CORE_H
+#pragma once
+
+#include <stddef.h>
+#include <openssl/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*-
+ * Base types
+ * ----------
+ *
+ * These are the types that the OpenSSL core and providers have in common
+ * to communicate data between them.
+ */
+
+/* Opaque handles to be used with core upcall functions from providers */
+typedef struct ossl_core_handle_st OSSL_CORE_HANDLE;
+typedef struct openssl_core_ctx_st OPENSSL_CORE_CTX;
+typedef struct ossl_core_bio_st OSSL_CORE_BIO;
+
+/*
+ * Dispatch table element.  function_id numbers and the functions are defined
+ * in core_dispatch.h, see macros with 'OSSL_CORE_MAKE_FUNC' in their names.
+ *
+ * An array of these is always terminated by function_id == 0
+ */
+struct ossl_dispatch_st {
+    int function_id;
+    void (*function)(void);
+};
+
+#define OSSL_DISPATCH_END \
+    { 0, NULL }
+
+/*
+ * Other items, essentially an int<->pointer map element.
+ *
+ * We make this type distinct from OSSL_DISPATCH to ensure that dispatch
+ * tables remain tables with function pointers only.
+ *
+ * This is used whenever we need to pass things like a table of error reason
+ * codes <-> reason string maps, ...
+ *
+ * Usage determines which field works as key if any, rather than field order.
+ *
+ * An array of these is always terminated by id == 0 && ptr == NULL
+ */
+struct ossl_item_st {
+    unsigned int id;
+    void *ptr;
+};
+
+/*
+ * Type to tie together algorithm names, property definition string and
+ * the algorithm implementation in the form of a dispatch table.
+ *
+ * An array of these is always terminated by algorithm_names == NULL
+ */
+struct ossl_algorithm_st {
+    const char *algorithm_names; /* key */
+    const char *property_definition; /* key */
+    const OSSL_DISPATCH *implementation;
+    const char *algorithm_description;
+};
+
+/*
+ * Type to pass object data in a uniform way, without exposing the object
+ * structure.
+ *
+ * An array of these is always terminated by key == NULL
+ */
+struct ossl_param_st {
+    const char *key; /* the name of the parameter */
+    unsigned int data_type; /* declare what kind of content is in buffer */
+    void *data; /* value being passed in or out */
+    size_t data_size; /* data size */
+    size_t return_size; /* returned content size */
+};
+
+/* Currently supported OSSL_PARAM data types */
+/*
+ * OSSL_PARAM_INTEGER and OSSL_PARAM_UNSIGNED_INTEGER
+ * are arbitrary length and therefore require an arbitrarily sized buffer,
+ * since they may be used to pass numbers larger than what is natively
+ * available.
+ *
+ * The number must be buffered in native form, i.e. MSB first on B_ENDIAN
+ * systems and LSB first on L_ENDIAN systems.  This means that arbitrary
+ * native integers can be stored in the buffer, just make sure that the
+ * buffer size is correct and the buffer itself is properly aligned (for
+ * example by having the buffer field point at a C integer).
+ */
+#define OSSL_PARAM_INTEGER 1
+#define OSSL_PARAM_UNSIGNED_INTEGER 2
+/*-
+ * OSSL_PARAM_REAL
+ * is a C binary floating point values in native form and alignment.
+ */
+#define OSSL_PARAM_REAL 3
+/*-
+ * OSSL_PARAM_UTF8_STRING
+ * is a printable string.  It is expected to be printed as it is.
+ */
+#define OSSL_PARAM_UTF8_STRING 4
+/*-
+ * OSSL_PARAM_OCTET_STRING
+ * is a string of bytes with no further specification.  It is expected to be
+ * printed as a hexdump.
+ */
+#define OSSL_PARAM_OCTET_STRING 5
+/*-
+ * OSSL_PARAM_UTF8_PTR
+ * is a pointer to a printable string.  It is expected to be printed as it is.
+ *
+ * The difference between this and OSSL_PARAM_UTF8_STRING is that only pointers
+ * are manipulated for this type.
+ *
+ * This is more relevant for parameter requests, where the responding
+ * function doesn't need to copy the data to the provided buffer, but
+ * sets the provided buffer to point at the actual data instead.
+ *
+ * WARNING!  Using these is FRAGILE, as it assumes that the actual
+ * data and its location are constant.
+ *
+ * EXTRA WARNING!  If you are not completely sure you most likely want
+ * to use the OSSL_PARAM_UTF8_STRING type.
+ */
+#define OSSL_PARAM_UTF8_PTR 6
+/*-
+ * OSSL_PARAM_OCTET_PTR
+ * is a pointer to a string of bytes with no further specification.  It is
+ * expected to be printed as a hexdump.
+ *
+ * The difference between this and OSSL_PARAM_OCTET_STRING is that only pointers
+ * are manipulated for this type.
+ *
+ * This is more relevant for parameter requests, where the responding
+ * function doesn't need to copy the data to the provided buffer, but
+ * sets the provided buffer to point at the actual data instead.
+ *
+ * WARNING!  Using these is FRAGILE, as it assumes that the actual
+ * data and its location are constant.
+ *
+ * EXTRA WARNING!  If you are not completely sure you most likely want
+ * to use the OSSL_PARAM_OCTET_STRING type.
+ */
+#define OSSL_PARAM_OCTET_PTR 7
+
+/*
+ * Typedef for the thread stop handling callback. Used both internally and by
+ * providers.
+ *
+ * Providers may register for notifications about threads stopping by
+ * registering a callback to hear about such events. Providers register the
+ * callback using the OSSL_FUNC_CORE_THREAD_START function in the |in| dispatch
+ * table passed to OSSL_provider_init(). The arg passed back to a provider will
+ * be the provider side context object.
+ */
+typedef void (*OSSL_thread_stop_handler_fn)(void *arg);
+
+/*-
+ * Provider entry point
+ * --------------------
+ *
+ * This function is expected to be present in any dynamically loadable
+ * provider module.  By definition, if this function doesn't exist in a
+ * module, that module is not an OpenSSL provider module.
+ */
+/*-
+ * |handle|     pointer to opaque type OSSL_CORE_HANDLE.  This can be used
+ *              together with some functions passed via |in| to query data.
+ * |in|         is the array of functions that the Core passes to the provider.
+ * |out|        will be the array of base functions that the provider passes
+ *              back to the Core.
+ * |provctx|    a provider side context object, optionally created if the
+ *              provider needs it.  This value is passed to other provider
+ *              functions, notably other context constructors.
+ */
+typedef int(OSSL_provider_init_fn)(const OSSL_CORE_HANDLE *handle,
+    const OSSL_DISPATCH *in,
+    const OSSL_DISPATCH **out,
+    void **provctx);
+#ifdef __VMS
+#pragma names save
+#pragma names uppercase, truncated
+#endif
+OPENSSL_EXPORT OSSL_provider_init_fn OSSL_provider_init;
+#ifdef __VMS
+#pragma names restore
+#endif
+
+/*
+ * Generic callback function signature.
+ *
+ * The expectation is that any provider function that wants to offer
+ * a callback / hook can do so by taking an argument with this type,
+ * as well as a pointer to caller-specific data.  When calling the
+ * callback, the provider function can populate an OSSL_PARAM array
+ * with data of its choice and pass that in the callback call, along
+ * with the caller data argument.
+ *
+ * libcrypto may use the OSSL_PARAM array to create arguments for an
+ * application callback it knows about.
+ */
+typedef int(OSSL_CALLBACK)(const OSSL_PARAM params[], void *arg);
+typedef int(OSSL_INOUT_CALLBACK)(const OSSL_PARAM in_params[],
+    OSSL_PARAM out_params[], void *arg);
+/*
+ * Passphrase callback function signature
+ *
+ * This is similar to the generic callback function above, but adds a
+ * result parameter.
+ */
+typedef int(OSSL_PASSPHRASE_CALLBACK)(char *pass, size_t pass_size,
+    size_t *pass_len,
+    const OSSL_PARAM params[], void *arg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

miniconda3/envs/active_proaction/include/openssl/core_dispatch.h

@@ -0,0 +1,1054 @@
+/*
+ * Copyright 2019-2025 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CORE_NUMBERS_H
+#define OPENSSL_CORE_NUMBERS_H
+#pragma once
+
+#include <stdarg.h>
+#include <openssl/core.h>
+#include <openssl/indicator.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Generic function pointer for provider method arrays, or other contexts where
+ * functions of various signatures must occupy a common slot in an array of
+ * structures.
+ */
+typedef void (*OSSL_FUNC)(void);
+
+/*-
+ * Identities
+ * ----------
+ *
+ * All series start with 1, to allow 0 to be an array terminator.
+ * For any FUNC identity, we also provide a function signature typedef
+ * and a static inline function to extract a function pointer from a
+ * OSSL_DISPATCH element in a type safe manner.
+ *
+ * Names:
+ * for any function base name 'foo' (uppercase form 'FOO'), we will have
+ * the following:
+ * - a macro for the identity with the name OSSL_FUNC_'FOO' or derivatives
+ *   thereof (to be specified further down)
+ * - a function signature typedef with the name OSSL_FUNC_'foo'_fn
+ * - a function pointer extractor function with the name OSSL_FUNC_'foo'
+ */
+
+/*
+ * Helper macro to create the function signature typedef and the extractor
+ * |type| is the return-type of the function, |name| is the name of the
+ * function to fetch, and |args| is a parenthesized list of parameters
+ * for the function (that is, it is |name|'s function signature).
+ * Note: This is considered a "reserved" internal macro. Applications should
+ * not use this or assume its existence.
+ */
+#define OSSL_CORE_MAKE_FUNC(type, name, args)          \
+    typedef type(OSSL_FUNC_##name##_fn) args;          \
+    static ossl_unused ossl_inline                     \
+        OSSL_FUNC_##name##_fn *                        \
+        OSSL_FUNC_##name(const OSSL_DISPATCH *opf)     \
+    {                                                  \
+        return (OSSL_FUNC_##name##_fn *)opf->function; \
+    }
+
+/*
+ * Core function identities, for the two OSSL_DISPATCH tables being passed
+ * in the OSSL_provider_init call.
+ *
+ * 0 serves as a marker for the end of the OSSL_DISPATCH array, and must
+ * therefore NEVER be used as a function identity.
+ */
+/* Functions provided by the Core to the provider, reserved numbers 1-1023 */
+#define OSSL_FUNC_CORE_GETTABLE_PARAMS 1
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+    core_gettable_params, (const OSSL_CORE_HANDLE *prov))
+#define OSSL_FUNC_CORE_GET_PARAMS 2
+OSSL_CORE_MAKE_FUNC(int, core_get_params, (const OSSL_CORE_HANDLE *prov, OSSL_PARAM params[]))
+#define OSSL_FUNC_CORE_THREAD_START 3
+OSSL_CORE_MAKE_FUNC(int, core_thread_start, (const OSSL_CORE_HANDLE *prov, OSSL_thread_stop_handler_fn handfn, void *arg))
+#define OSSL_FUNC_CORE_GET_LIBCTX 4
+OSSL_CORE_MAKE_FUNC(OPENSSL_CORE_CTX *, core_get_libctx,
+    (const OSSL_CORE_HANDLE *prov))
+#define OSSL_FUNC_CORE_NEW_ERROR 5
+OSSL_CORE_MAKE_FUNC(void, core_new_error, (const OSSL_CORE_HANDLE *prov))
+#define OSSL_FUNC_CORE_SET_ERROR_DEBUG 6
+OSSL_CORE_MAKE_FUNC(void, core_set_error_debug,
+    (const OSSL_CORE_HANDLE *prov,
+        const char *file, int line, const char *func))
+#define OSSL_FUNC_CORE_VSET_ERROR 7
+OSSL_CORE_MAKE_FUNC(void, core_vset_error,
+    (const OSSL_CORE_HANDLE *prov,
+        uint32_t reason, const char *fmt, va_list args))
+#define OSSL_FUNC_CORE_SET_ERROR_MARK 8
+OSSL_CORE_MAKE_FUNC(int, core_set_error_mark, (const OSSL_CORE_HANDLE *prov))
+#define OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK 9
+OSSL_CORE_MAKE_FUNC(int, core_clear_last_error_mark,
+    (const OSSL_CORE_HANDLE *prov))
+#define OSSL_FUNC_CORE_POP_ERROR_TO_MARK 10
+OSSL_CORE_MAKE_FUNC(int, core_pop_error_to_mark, (const OSSL_CORE_HANDLE *prov))
+
+/* Functions to access the OBJ database */
+
+#define OSSL_FUNC_CORE_OBJ_ADD_SIGID 11
+#define OSSL_FUNC_CORE_OBJ_CREATE 12
+
+OSSL_CORE_MAKE_FUNC(int, core_obj_add_sigid,
+    (const OSSL_CORE_HANDLE *prov, const char *sign_name,
+        const char *digest_name, const char *pkey_name))
+OSSL_CORE_MAKE_FUNC(int, core_obj_create,
+    (const OSSL_CORE_HANDLE *prov, const char *oid,
+        const char *sn, const char *ln))
+
+/* Memory allocation, freeing, clearing. */
+#define OSSL_FUNC_CRYPTO_MALLOC 20
+OSSL_CORE_MAKE_FUNC(void *,
+    CRYPTO_malloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_ZALLOC 21
+OSSL_CORE_MAKE_FUNC(void *,
+    CRYPTO_zalloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_FREE 22
+OSSL_CORE_MAKE_FUNC(void,
+    CRYPTO_free, (void *ptr, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_CLEAR_FREE 23
+OSSL_CORE_MAKE_FUNC(void,
+    CRYPTO_clear_free, (void *ptr, size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_REALLOC 24
+OSSL_CORE_MAKE_FUNC(void *,
+    CRYPTO_realloc, (void *addr, size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_CLEAR_REALLOC 25
+OSSL_CORE_MAKE_FUNC(void *,
+    CRYPTO_clear_realloc, (void *addr, size_t old_num, size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_MALLOC 26
+OSSL_CORE_MAKE_FUNC(void *,
+    CRYPTO_secure_malloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_ZALLOC 27
+OSSL_CORE_MAKE_FUNC(void *,
+    CRYPTO_secure_zalloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_FREE 28
+OSSL_CORE_MAKE_FUNC(void,
+    CRYPTO_secure_free, (void *ptr, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE 29
+OSSL_CORE_MAKE_FUNC(void,
+    CRYPTO_secure_clear_free, (void *ptr, size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_ALLOCATED 30
+OSSL_CORE_MAKE_FUNC(int,
+    CRYPTO_secure_allocated, (const void *ptr))
+#define OSSL_FUNC_OPENSSL_CLEANSE 31
+OSSL_CORE_MAKE_FUNC(void,
+    OPENSSL_cleanse, (void *ptr, size_t len))
+
+/* Bio functions provided by the core */
+#define OSSL_FUNC_BIO_NEW_FILE 40
+#define OSSL_FUNC_BIO_NEW_MEMBUF 41
+#define OSSL_FUNC_BIO_READ_EX 42
+#define OSSL_FUNC_BIO_WRITE_EX 43
+#define OSSL_FUNC_BIO_UP_REF 44
+#define OSSL_FUNC_BIO_FREE 45
+#define OSSL_FUNC_BIO_VPRINTF 46
+#define OSSL_FUNC_BIO_VSNPRINTF 47
+#define OSSL_FUNC_BIO_PUTS 48
+#define OSSL_FUNC_BIO_GETS 49
+#define OSSL_FUNC_BIO_CTRL 50
+
+OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO *, BIO_new_file, (const char *filename, const char *mode))
+OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO *, BIO_new_membuf, (const void *buf, int len))
+OSSL_CORE_MAKE_FUNC(int, BIO_read_ex, (OSSL_CORE_BIO * bio, void *data, size_t data_len, size_t *bytes_read))
+OSSL_CORE_MAKE_FUNC(int, BIO_write_ex, (OSSL_CORE_BIO * bio, const void *data, size_t data_len, size_t *written))
+OSSL_CORE_MAKE_FUNC(int, BIO_gets, (OSSL_CORE_BIO * bio, char *buf, int size))
+OSSL_CORE_MAKE_FUNC(int, BIO_puts, (OSSL_CORE_BIO * bio, const char *str))
+OSSL_CORE_MAKE_FUNC(int, BIO_up_ref, (OSSL_CORE_BIO * bio))
+OSSL_CORE_MAKE_FUNC(int, BIO_free, (OSSL_CORE_BIO * bio))
+OSSL_CORE_MAKE_FUNC(int, BIO_vprintf, (OSSL_CORE_BIO * bio, const char *format, va_list args))
+OSSL_CORE_MAKE_FUNC(int, BIO_vsnprintf,
+    (char *buf, size_t n, const char *fmt, va_list args))
+OSSL_CORE_MAKE_FUNC(int, BIO_ctrl, (OSSL_CORE_BIO * bio, int cmd, long num, void *ptr))
+
+/* New seeding functions prototypes with the 101-104 series */
+#define OSSL_FUNC_CLEANUP_USER_ENTROPY 96
+#define OSSL_FUNC_CLEANUP_USER_NONCE 97
+#define OSSL_FUNC_GET_USER_ENTROPY 98
+#define OSSL_FUNC_GET_USER_NONCE 99
+
+#define OSSL_FUNC_INDICATOR_CB 95
+OSSL_CORE_MAKE_FUNC(void, indicator_cb, (OPENSSL_CORE_CTX * ctx, OSSL_INDICATOR_CALLBACK **cb))
+#define OSSL_FUNC_SELF_TEST_CB 100
+OSSL_CORE_MAKE_FUNC(void, self_test_cb, (OPENSSL_CORE_CTX * ctx, OSSL_CALLBACK **cb, void **cbarg))
+
+/* Functions to get seed material from the operating system */
+#define OSSL_FUNC_GET_ENTROPY 101
+#define OSSL_FUNC_CLEANUP_ENTROPY 102
+#define OSSL_FUNC_GET_NONCE 103
+#define OSSL_FUNC_CLEANUP_NONCE 104
+OSSL_CORE_MAKE_FUNC(size_t, get_entropy, (const OSSL_CORE_HANDLE *handle, unsigned char **pout, int entropy, size_t min_len, size_t max_len))
+OSSL_CORE_MAKE_FUNC(size_t, get_user_entropy, (const OSSL_CORE_HANDLE *handle, unsigned char **pout, int entropy, size_t min_len, size_t max_len))
+OSSL_CORE_MAKE_FUNC(void, cleanup_entropy, (const OSSL_CORE_HANDLE *handle, unsigned char *buf, size_t len))
+OSSL_CORE_MAKE_FUNC(void, cleanup_user_entropy, (const OSSL_CORE_HANDLE *handle, unsigned char *buf, size_t len))
+OSSL_CORE_MAKE_FUNC(size_t, get_nonce, (const OSSL_CORE_HANDLE *handle, unsigned char **pout, size_t min_len, size_t max_len, const void *salt, size_t salt_len))
+OSSL_CORE_MAKE_FUNC(size_t, get_user_nonce, (const OSSL_CORE_HANDLE *handle, unsigned char **pout, size_t min_len, size_t max_len, const void *salt, size_t salt_len))
+OSSL_CORE_MAKE_FUNC(void, cleanup_nonce, (const OSSL_CORE_HANDLE *handle, unsigned char *buf, size_t len))
+OSSL_CORE_MAKE_FUNC(void, cleanup_user_nonce, (const OSSL_CORE_HANDLE *handle, unsigned char *buf, size_t len))
+
+/* Functions to access the core's providers */
+#define OSSL_FUNC_PROVIDER_REGISTER_CHILD_CB 105
+#define OSSL_FUNC_PROVIDER_DEREGISTER_CHILD_CB 106
+#define OSSL_FUNC_PROVIDER_NAME 107
+#define OSSL_FUNC_PROVIDER_GET0_PROVIDER_CTX 108
+#define OSSL_FUNC_PROVIDER_GET0_DISPATCH 109
+#define OSSL_FUNC_PROVIDER_UP_REF 110
+#define OSSL_FUNC_PROVIDER_FREE 111
+
+OSSL_CORE_MAKE_FUNC(int, provider_register_child_cb,
+    (const OSSL_CORE_HANDLE *handle,
+        int (*create_cb)(const OSSL_CORE_HANDLE *provider, void *cbdata),
+        int (*remove_cb)(const OSSL_CORE_HANDLE *provider, void *cbdata),
+        int (*global_props_cb)(const char *props, void *cbdata),
+        void *cbdata))
+OSSL_CORE_MAKE_FUNC(void, provider_deregister_child_cb,
+    (const OSSL_CORE_HANDLE *handle))
+OSSL_CORE_MAKE_FUNC(const char *, provider_name,
+    (const OSSL_CORE_HANDLE *prov))
+OSSL_CORE_MAKE_FUNC(void *, provider_get0_provider_ctx,
+    (const OSSL_CORE_HANDLE *prov))
+OSSL_CORE_MAKE_FUNC(const OSSL_DISPATCH *, provider_get0_dispatch,
+    (const OSSL_CORE_HANDLE *prov))
+OSSL_CORE_MAKE_FUNC(int, provider_up_ref,
+    (const OSSL_CORE_HANDLE *prov, int activate))
+OSSL_CORE_MAKE_FUNC(int, provider_free,
+    (const OSSL_CORE_HANDLE *prov, int deactivate))
+
+/* Additional error functions provided by the core */
+#define OSSL_FUNC_CORE_COUNT_TO_MARK 120
+OSSL_CORE_MAKE_FUNC(int, core_count_to_mark, (const OSSL_CORE_HANDLE *prov))
+
+/* Functions provided by the provider to the Core, reserved numbers 1024-1535 */
+#define OSSL_FUNC_PROVIDER_TEARDOWN 1024
+OSSL_CORE_MAKE_FUNC(void, provider_teardown, (void *provctx))
+#define OSSL_FUNC_PROVIDER_GETTABLE_PARAMS 1025
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+    provider_gettable_params, (void *provctx))
+#define OSSL_FUNC_PROVIDER_GET_PARAMS 1026
+OSSL_CORE_MAKE_FUNC(int, provider_get_params, (void *provctx, OSSL_PARAM params[]))
+#define OSSL_FUNC_PROVIDER_QUERY_OPERATION 1027
+OSSL_CORE_MAKE_FUNC(const OSSL_ALGORITHM *, provider_query_operation,
+    (void *provctx, int operation_id, int *no_store))
+#define OSSL_FUNC_PROVIDER_UNQUERY_OPERATION 1028
+OSSL_CORE_MAKE_FUNC(void, provider_unquery_operation,
+    (void *provctx, int operation_id, const OSSL_ALGORITHM *))
+#define OSSL_FUNC_PROVIDER_GET_REASON_STRINGS 1029
+OSSL_CORE_MAKE_FUNC(const OSSL_ITEM *, provider_get_reason_strings,
+    (void *provctx))
+#define OSSL_FUNC_PROVIDER_GET_CAPABILITIES 1030
+OSSL_CORE_MAKE_FUNC(int, provider_get_capabilities, (void *provctx, const char *capability, OSSL_CALLBACK *cb, void *arg))
+#define OSSL_FUNC_PROVIDER_SELF_TEST 1031
+OSSL_CORE_MAKE_FUNC(int, provider_self_test, (void *provctx))
+#define OSSL_FUNC_PROVIDER_RANDOM_BYTES 1032
+OSSL_CORE_MAKE_FUNC(int, provider_random_bytes, (void *provctx, int which, void *buf, size_t n, unsigned int strength))
+
+/* Libssl related functions */
+#define OSSL_FUNC_SSL_QUIC_TLS_CRYPTO_SEND 2001
+OSSL_CORE_MAKE_FUNC(int, SSL_QUIC_TLS_crypto_send,
+    (SSL * s, const unsigned char *buf, size_t buf_len,
+        size_t *consumed, void *arg))
+#define OSSL_FUNC_SSL_QUIC_TLS_CRYPTO_RECV_RCD 2002
+OSSL_CORE_MAKE_FUNC(int, SSL_QUIC_TLS_crypto_recv_rcd,
+    (SSL * s, const unsigned char **buf, size_t *bytes_read,
+        void *arg))
+#define OSSL_FUNC_SSL_QUIC_TLS_CRYPTO_RELEASE_RCD 2003
+OSSL_CORE_MAKE_FUNC(int, SSL_QUIC_TLS_crypto_release_rcd,
+    (SSL * s, size_t bytes_read, void *arg))
+#define OSSL_FUNC_SSL_QUIC_TLS_YIELD_SECRET 2004
+OSSL_CORE_MAKE_FUNC(int, SSL_QUIC_TLS_yield_secret,
+    (SSL * s, uint32_t prot_level, int direction,
+        const unsigned char *secret, size_t secret_len, void *arg))
+#define OSSL_FUNC_SSL_QUIC_TLS_GOT_TRANSPORT_PARAMS 2005
+OSSL_CORE_MAKE_FUNC(int, SSL_QUIC_TLS_got_transport_params,
+    (SSL * s, const unsigned char *params, size_t params_len,
+        void *arg))
+#define OSSL_FUNC_SSL_QUIC_TLS_ALERT 2006
+OSSL_CORE_MAKE_FUNC(int, SSL_QUIC_TLS_alert,
+    (SSL * s, unsigned char alert_code, void *arg))
+
+/* Operations */
+
+#define OSSL_OP_DIGEST 1
+#define OSSL_OP_CIPHER 2 /* Symmetric Ciphers */
+#define OSSL_OP_MAC 3
+#define OSSL_OP_KDF 4
+#define OSSL_OP_RAND 5
+#define OSSL_OP_KEYMGMT 10
+#define OSSL_OP_KEYEXCH 11
+#define OSSL_OP_SIGNATURE 12
+#define OSSL_OP_ASYM_CIPHER 13
+#define OSSL_OP_KEM 14
+#define OSSL_OP_SKEYMGMT 15
+/* New section for non-EVP operations */
+#define OSSL_OP_ENCODER 20
+#define OSSL_OP_DECODER 21
+#define OSSL_OP_STORE 22
+/* Highest known operation number */
+#define OSSL_OP__HIGHEST 22
+
+/* Digests */
+
+#define OSSL_FUNC_DIGEST_NEWCTX 1
+#define OSSL_FUNC_DIGEST_INIT 2
+#define OSSL_FUNC_DIGEST_UPDATE 3
+#define OSSL_FUNC_DIGEST_FINAL 4
+#define OSSL_FUNC_DIGEST_DIGEST 5
+#define OSSL_FUNC_DIGEST_FREECTX 6
+#define OSSL_FUNC_DIGEST_DUPCTX 7
+#define OSSL_FUNC_DIGEST_GET_PARAMS 8
+#define OSSL_FUNC_DIGEST_SET_CTX_PARAMS 9
+#define OSSL_FUNC_DIGEST_GET_CTX_PARAMS 10
+#define OSSL_FUNC_DIGEST_GETTABLE_PARAMS 11
+#define OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS 12
+#define OSSL_FUNC_DIGEST_GETTABLE_CTX_PARAMS 13
+#define OSSL_FUNC_DIGEST_SQUEEZE 14
+#define OSSL_FUNC_DIGEST_COPYCTX 15
+
+OSSL_CORE_MAKE_FUNC(void *, digest_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, digest_init, (void *dctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, digest_update,
+    (void *dctx, const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(int, digest_final,
+    (void *dctx,
+        unsigned char *out, size_t *outl, size_t outsz))
+OSSL_CORE_MAKE_FUNC(int, digest_squeeze,
+    (void *dctx,
+        unsigned char *out, size_t *outl, size_t outsz))
+OSSL_CORE_MAKE_FUNC(int, digest_digest,
+    (void *provctx, const unsigned char *in, size_t inl,
+        unsigned char *out, size_t *outl, size_t outsz))
+
+OSSL_CORE_MAKE_FUNC(void, digest_freectx, (void *dctx))
+OSSL_CORE_MAKE_FUNC(void *, digest_dupctx, (void *dctx))
+OSSL_CORE_MAKE_FUNC(void, digest_copyctx, (void *outctx, void *inctx))
+
+OSSL_CORE_MAKE_FUNC(int, digest_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, digest_set_ctx_params,
+    (void *vctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, digest_get_ctx_params,
+    (void *vctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_gettable_params,
+    (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_settable_ctx_params,
+    (void *dctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_gettable_ctx_params,
+    (void *dctx, void *provctx))
+
+/* Symmetric Ciphers */
+
+#define OSSL_FUNC_CIPHER_NEWCTX 1
+#define OSSL_FUNC_CIPHER_ENCRYPT_INIT 2
+#define OSSL_FUNC_CIPHER_DECRYPT_INIT 3
+#define OSSL_FUNC_CIPHER_UPDATE 4
+#define OSSL_FUNC_CIPHER_FINAL 5
+#define OSSL_FUNC_CIPHER_CIPHER 6
+#define OSSL_FUNC_CIPHER_FREECTX 7
+#define OSSL_FUNC_CIPHER_DUPCTX 8
+#define OSSL_FUNC_CIPHER_GET_PARAMS 9
+#define OSSL_FUNC_CIPHER_GET_CTX_PARAMS 10
+#define OSSL_FUNC_CIPHER_SET_CTX_PARAMS 11
+#define OSSL_FUNC_CIPHER_GETTABLE_PARAMS 12
+#define OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS 13
+#define OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS 14
+#define OSSL_FUNC_CIPHER_PIPELINE_ENCRYPT_INIT 15
+#define OSSL_FUNC_CIPHER_PIPELINE_DECRYPT_INIT 16
+#define OSSL_FUNC_CIPHER_PIPELINE_UPDATE 17
+#define OSSL_FUNC_CIPHER_PIPELINE_FINAL 18
+#define OSSL_FUNC_CIPHER_ENCRYPT_SKEY_INIT 19
+#define OSSL_FUNC_CIPHER_DECRYPT_SKEY_INIT 20
+
+OSSL_CORE_MAKE_FUNC(void *, cipher_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, cipher_encrypt_init, (void *cctx, const unsigned char *key, size_t keylen, const unsigned char *iv, size_t ivlen, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_decrypt_init, (void *cctx, const unsigned char *key, size_t keylen, const unsigned char *iv, size_t ivlen, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_update,
+    (void *cctx,
+        unsigned char *out, size_t *outl, size_t outsize,
+        const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(int, cipher_final,
+    (void *cctx,
+        unsigned char *out, size_t *outl, size_t outsize))
+OSSL_CORE_MAKE_FUNC(int, cipher_cipher,
+    (void *cctx,
+        unsigned char *out, size_t *outl, size_t outsize,
+        const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(int, cipher_pipeline_encrypt_init,
+    (void *cctx,
+        const unsigned char *key, size_t keylen,
+        size_t numpipes, const unsigned char **iv, size_t ivlen,
+        const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_pipeline_decrypt_init,
+    (void *cctx,
+        const unsigned char *key, size_t keylen,
+        size_t numpipes, const unsigned char **iv, size_t ivlen,
+        const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_pipeline_update,
+    (void *cctx, size_t numpipes,
+        unsigned char **out, size_t *outl, const size_t *outsize,
+        const unsigned char **in, const size_t *inl))
+OSSL_CORE_MAKE_FUNC(int, cipher_pipeline_final,
+    (void *cctx, size_t numpipes,
+        unsigned char **out, size_t *outl, const size_t *outsize))
+OSSL_CORE_MAKE_FUNC(void, cipher_freectx, (void *cctx))
+OSSL_CORE_MAKE_FUNC(void *, cipher_dupctx, (void *cctx))
+OSSL_CORE_MAKE_FUNC(int, cipher_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_get_ctx_params, (void *cctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_set_ctx_params, (void *cctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_gettable_params,
+    (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_settable_ctx_params,
+    (void *cctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_gettable_ctx_params,
+    (void *cctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, cipher_encrypt_skey_init, (void *cctx, void *skeydata, const unsigned char *iv, size_t ivlen, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_decrypt_skey_init, (void *cctx, void *skeydata, const unsigned char *iv, size_t ivlen, const OSSL_PARAM params[]))
+
+/* MACs */
+
+#define OSSL_FUNC_MAC_NEWCTX 1
+#define OSSL_FUNC_MAC_DUPCTX 2
+#define OSSL_FUNC_MAC_FREECTX 3
+#define OSSL_FUNC_MAC_INIT 4
+#define OSSL_FUNC_MAC_UPDATE 5
+#define OSSL_FUNC_MAC_FINAL 6
+#define OSSL_FUNC_MAC_GET_PARAMS 7
+#define OSSL_FUNC_MAC_GET_CTX_PARAMS 8
+#define OSSL_FUNC_MAC_SET_CTX_PARAMS 9
+#define OSSL_FUNC_MAC_GETTABLE_PARAMS 10
+#define OSSL_FUNC_MAC_GETTABLE_CTX_PARAMS 11
+#define OSSL_FUNC_MAC_SETTABLE_CTX_PARAMS 12
+#define OSSL_FUNC_MAC_INIT_SKEY 13
+
+OSSL_CORE_MAKE_FUNC(void *, mac_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, mac_dupctx, (void *src))
+OSSL_CORE_MAKE_FUNC(void, mac_freectx, (void *mctx))
+OSSL_CORE_MAKE_FUNC(int, mac_init, (void *mctx, const unsigned char *key, size_t keylen, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, mac_update,
+    (void *mctx, const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(int, mac_final,
+    (void *mctx,
+        unsigned char *out, size_t *outl, size_t outsize))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_gettable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_gettable_ctx_params,
+    (void *mctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_settable_ctx_params,
+    (void *mctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, mac_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, mac_get_ctx_params,
+    (void *mctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, mac_set_ctx_params,
+    (void *mctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, mac_init_skey, (void *mctx, void *key, const OSSL_PARAM params[]))
+
+/* KDFs and PRFs */
+
+#define OSSL_FUNC_KDF_NEWCTX 1
+#define OSSL_FUNC_KDF_DUPCTX 2
+#define OSSL_FUNC_KDF_FREECTX 3
+#define OSSL_FUNC_KDF_RESET 4
+#define OSSL_FUNC_KDF_DERIVE 5
+#define OSSL_FUNC_KDF_GETTABLE_PARAMS 6
+#define OSSL_FUNC_KDF_GETTABLE_CTX_PARAMS 7
+#define OSSL_FUNC_KDF_SETTABLE_CTX_PARAMS 8
+#define OSSL_FUNC_KDF_GET_PARAMS 9
+#define OSSL_FUNC_KDF_GET_CTX_PARAMS 10
+#define OSSL_FUNC_KDF_SET_CTX_PARAMS 11
+
+OSSL_CORE_MAKE_FUNC(void *, kdf_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, kdf_dupctx, (void *src))
+OSSL_CORE_MAKE_FUNC(void, kdf_freectx, (void *kctx))
+OSSL_CORE_MAKE_FUNC(void, kdf_reset, (void *kctx))
+OSSL_CORE_MAKE_FUNC(int, kdf_derive, (void *kctx, unsigned char *key, size_t keylen, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_gettable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_gettable_ctx_params,
+    (void *kctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_settable_ctx_params,
+    (void *kctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, kdf_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kdf_get_ctx_params,
+    (void *kctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kdf_set_ctx_params,
+    (void *kctx, const OSSL_PARAM params[]))
+
+/* RAND */
+
+#define OSSL_FUNC_RAND_NEWCTX 1
+#define OSSL_FUNC_RAND_FREECTX 2
+#define OSSL_FUNC_RAND_INSTANTIATE 3
+#define OSSL_FUNC_RAND_UNINSTANTIATE 4
+#define OSSL_FUNC_RAND_GENERATE 5
+#define OSSL_FUNC_RAND_RESEED 6
+#define OSSL_FUNC_RAND_NONCE 7
+#define OSSL_FUNC_RAND_ENABLE_LOCKING 8
+#define OSSL_FUNC_RAND_LOCK 9
+#define OSSL_FUNC_RAND_UNLOCK 10
+#define OSSL_FUNC_RAND_GETTABLE_PARAMS 11
+#define OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS 12
+#define OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS 13
+#define OSSL_FUNC_RAND_GET_PARAMS 14
+#define OSSL_FUNC_RAND_GET_CTX_PARAMS 15
+#define OSSL_FUNC_RAND_SET_CTX_PARAMS 16
+#define OSSL_FUNC_RAND_VERIFY_ZEROIZATION 17
+#define OSSL_FUNC_RAND_GET_SEED 18
+#define OSSL_FUNC_RAND_CLEAR_SEED 19
+
+OSSL_CORE_MAKE_FUNC(void *, rand_newctx,
+    (void *provctx, void *parent,
+        const OSSL_DISPATCH *parent_calls))
+OSSL_CORE_MAKE_FUNC(void, rand_freectx, (void *vctx))
+OSSL_CORE_MAKE_FUNC(int, rand_instantiate,
+    (void *vdrbg, unsigned int strength,
+        int prediction_resistance,
+        const unsigned char *pstr, size_t pstr_len,
+        const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, rand_uninstantiate, (void *vdrbg))
+OSSL_CORE_MAKE_FUNC(int, rand_generate,
+    (void *vctx, unsigned char *out, size_t outlen,
+        unsigned int strength, int prediction_resistance,
+        const unsigned char *addin, size_t addin_len))
+OSSL_CORE_MAKE_FUNC(int, rand_reseed,
+    (void *vctx, int prediction_resistance,
+        const unsigned char *ent, size_t ent_len,
+        const unsigned char *addin, size_t addin_len))
+OSSL_CORE_MAKE_FUNC(size_t, rand_nonce,
+    (void *vctx, unsigned char *out, unsigned int strength,
+        size_t min_noncelen, size_t max_noncelen))
+OSSL_CORE_MAKE_FUNC(int, rand_enable_locking, (void *vctx))
+OSSL_CORE_MAKE_FUNC(int, rand_lock, (void *vctx))
+OSSL_CORE_MAKE_FUNC(void, rand_unlock, (void *vctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, rand_gettable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, rand_gettable_ctx_params,
+    (void *vctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, rand_settable_ctx_params,
+    (void *vctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, rand_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, rand_get_ctx_params,
+    (void *vctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, rand_set_ctx_params,
+    (void *vctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(void, rand_set_callbacks,
+    (void *vctx, OSSL_INOUT_CALLBACK *get_entropy,
+        OSSL_CALLBACK *cleanup_entropy,
+        OSSL_INOUT_CALLBACK *get_nonce,
+        OSSL_CALLBACK *cleanup_nonce, void *arg))
+OSSL_CORE_MAKE_FUNC(int, rand_verify_zeroization,
+    (void *vctx))
+OSSL_CORE_MAKE_FUNC(size_t, rand_get_seed,
+    (void *vctx, unsigned char **buffer,
+        int entropy, size_t min_len, size_t max_len,
+        int prediction_resistance,
+        const unsigned char *adin, size_t adin_len))
+OSSL_CORE_MAKE_FUNC(void, rand_clear_seed,
+    (void *vctx, unsigned char *buffer, size_t b_len))
+
+/*-
+ * Key management
+ *
+ * The Key Management takes care of provider side key objects, and includes
+ * all current functionality to create them, destroy them, set parameters
+ * and key material, etc, essentially everything that manipulates the keys
+ * themselves and their parameters.
+ *
+ * The key objects are commonly referred to as |keydata|, and it MUST be able
+ * to contain parameters if the key has any, the public key and the private
+ * key.  All parts are optional, but their presence determines what can be
+ * done with the key object in terms of encryption, signature, and so on.
+ * The assumption from libcrypto is that the key object contains any of the
+ * following data combinations:
+ *
+ * - parameters only
+ * - public key only
+ * - public key + private key
+ * - parameters + public key
+ * - parameters + public key + private key
+ *
+ * What "parameters", "public key" and "private key" means in detail is left
+ * to the implementation.  In the case of DH and DSA, they would typically
+ * include domain parameters, while for certain variants of RSA, they would
+ * typically include PSS or OAEP parameters.
+ *
+ * Key objects are created with OSSL_FUNC_keymgmt_new() and destroyed with
+ * OSSL_FUNC_keymgmt_free().  Key objects can have data filled in with
+ * OSSL_FUNC_keymgmt_import().
+ *
+ * Three functions are made available to check what selection of data is
+ * present in a key object: OSSL_FUNC_keymgmt_has_parameters(),
+ * OSSL_FUNC_keymgmt_has_public_key(), and OSSL_FUNC_keymgmt_has_private_key(),
+ */
+
+/* Key data subset selection - individual bits */
+#define OSSL_KEYMGMT_SELECT_PRIVATE_KEY 0x01
+#define OSSL_KEYMGMT_SELECT_PUBLIC_KEY 0x02
+#define OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS 0x04
+#define OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS 0x80
+
+/* Key data subset selection - combinations */
+#define OSSL_KEYMGMT_SELECT_ALL_PARAMETERS \
+    (OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS \
+        | OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS)
+#define OSSL_KEYMGMT_SELECT_KEYPAIR \
+    (OSSL_KEYMGMT_SELECT_PRIVATE_KEY | OSSL_KEYMGMT_SELECT_PUBLIC_KEY)
+#define OSSL_KEYMGMT_SELECT_ALL \
+    (OSSL_KEYMGMT_SELECT_KEYPAIR | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS)
+
+#define OSSL_KEYMGMT_VALIDATE_FULL_CHECK 0
+#define OSSL_KEYMGMT_VALIDATE_QUICK_CHECK 1
+
+/* Basic key object creation */
+#define OSSL_FUNC_KEYMGMT_NEW 1
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_new, (void *provctx))
+
+/* Generation, a more complex constructor */
+#define OSSL_FUNC_KEYMGMT_GEN_INIT 2
+#define OSSL_FUNC_KEYMGMT_GEN_SET_TEMPLATE 3
+#define OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS 4
+#define OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS 5
+#define OSSL_FUNC_KEYMGMT_GEN 6
+#define OSSL_FUNC_KEYMGMT_GEN_CLEANUP 7
+#define OSSL_FUNC_KEYMGMT_GEN_GET_PARAMS 15
+#define OSSL_FUNC_KEYMGMT_GEN_GETTABLE_PARAMS 16
+
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_gen_init,
+    (void *provctx, int selection, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_set_template,
+    (void *genctx, void *templ))
+OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_set_params,
+    (void *genctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+    keymgmt_gen_settable_params,
+    (void *genctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_get_params,
+    (void *genctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_gen_gettable_params,
+    (void *genctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_gen,
+    (void *genctx, OSSL_CALLBACK *cb, void *cbarg))
+OSSL_CORE_MAKE_FUNC(void, keymgmt_gen_cleanup, (void *genctx))
+
+/* Key loading by object reference */
+#define OSSL_FUNC_KEYMGMT_LOAD 8
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_load,
+    (const void *reference, size_t reference_sz))
+
+/* Basic key object destruction */
+#define OSSL_FUNC_KEYMGMT_FREE 10
+OSSL_CORE_MAKE_FUNC(void, keymgmt_free, (void *keydata))
+
+/* Key object information, with discovery */
+#define OSSL_FUNC_KEYMGMT_GET_PARAMS 11
+#define OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS 12
+OSSL_CORE_MAKE_FUNC(int, keymgmt_get_params,
+    (void *keydata, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_gettable_params,
+    (void *provctx))
+
+#define OSSL_FUNC_KEYMGMT_SET_PARAMS 13
+#define OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS 14
+OSSL_CORE_MAKE_FUNC(int, keymgmt_set_params,
+    (void *keydata, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_settable_params,
+    (void *provctx))
+
+/* Key checks - discovery of supported operations */
+#define OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME 20
+OSSL_CORE_MAKE_FUNC(const char *, keymgmt_query_operation_name,
+    (int operation_id))
+
+/* Key checks - key data content checks */
+#define OSSL_FUNC_KEYMGMT_HAS 21
+OSSL_CORE_MAKE_FUNC(int, keymgmt_has, (const void *keydata, int selection))
+
+/* Key checks - validation */
+#define OSSL_FUNC_KEYMGMT_VALIDATE 22
+OSSL_CORE_MAKE_FUNC(int, keymgmt_validate, (const void *keydata, int selection, int checktype))
+
+/* Key checks - matching */
+#define OSSL_FUNC_KEYMGMT_MATCH 23
+OSSL_CORE_MAKE_FUNC(int, keymgmt_match,
+    (const void *keydata1, const void *keydata2,
+        int selection))
+
+/* Import and export functions, with discovery */
+#define OSSL_FUNC_KEYMGMT_IMPORT 40
+#define OSSL_FUNC_KEYMGMT_IMPORT_TYPES 41
+#define OSSL_FUNC_KEYMGMT_EXPORT 42
+#define OSSL_FUNC_KEYMGMT_EXPORT_TYPES 43
+OSSL_CORE_MAKE_FUNC(int, keymgmt_import,
+    (void *keydata, int selection, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_import_types,
+    (int selection))
+OSSL_CORE_MAKE_FUNC(int, keymgmt_export,
+    (void *keydata, int selection,
+        OSSL_CALLBACK *param_cb, void *cbarg))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_export_types,
+    (int selection))
+
+/* Dup function, constructor */
+#define OSSL_FUNC_KEYMGMT_DUP 44
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_dup,
+    (const void *keydata_from, int selection))
+
+/* Extended import and export functions */
+#define OSSL_FUNC_KEYMGMT_IMPORT_TYPES_EX 45
+#define OSSL_FUNC_KEYMGMT_EXPORT_TYPES_EX 46
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_import_types_ex,
+    (void *provctx, int selection))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_export_types_ex,
+    (void *provctx, int selection))
+
+/* Key Exchange */
+
+#define OSSL_FUNC_KEYEXCH_NEWCTX 1
+#define OSSL_FUNC_KEYEXCH_INIT 2
+#define OSSL_FUNC_KEYEXCH_DERIVE 3
+#define OSSL_FUNC_KEYEXCH_SET_PEER 4
+#define OSSL_FUNC_KEYEXCH_FREECTX 5
+#define OSSL_FUNC_KEYEXCH_DUPCTX 6
+#define OSSL_FUNC_KEYEXCH_SET_CTX_PARAMS 7
+#define OSSL_FUNC_KEYEXCH_SETTABLE_CTX_PARAMS 8
+#define OSSL_FUNC_KEYEXCH_GET_CTX_PARAMS 9
+#define OSSL_FUNC_KEYEXCH_GETTABLE_CTX_PARAMS 10
+
+OSSL_CORE_MAKE_FUNC(void *, keyexch_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, keyexch_init, (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, keyexch_derive, (void *ctx, unsigned char *secret, size_t *secretlen, size_t outlen))
+OSSL_CORE_MAKE_FUNC(int, keyexch_set_peer, (void *ctx, void *provkey))
+OSSL_CORE_MAKE_FUNC(void, keyexch_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, keyexch_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, keyexch_set_ctx_params, (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keyexch_settable_ctx_params,
+    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, keyexch_get_ctx_params, (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keyexch_gettable_ctx_params,
+    (void *ctx, void *provctx))
+
+/* Signature */
+
+#define OSSL_FUNC_SIGNATURE_NEWCTX 1
+#define OSSL_FUNC_SIGNATURE_SIGN_INIT 2
+#define OSSL_FUNC_SIGNATURE_SIGN 3
+#define OSSL_FUNC_SIGNATURE_VERIFY_INIT 4
+#define OSSL_FUNC_SIGNATURE_VERIFY 5
+#define OSSL_FUNC_SIGNATURE_VERIFY_RECOVER_INIT 6
+#define OSSL_FUNC_SIGNATURE_VERIFY_RECOVER 7
+#define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT 8
+#define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE 9
+#define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL 10
+#define OSSL_FUNC_SIGNATURE_DIGEST_SIGN 11
+#define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT 12
+#define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE 13
+#define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL 14
+#define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY 15
+#define OSSL_FUNC_SIGNATURE_FREECTX 16
+#define OSSL_FUNC_SIGNATURE_DUPCTX 17
+#define OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS 18
+#define OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS 19
+#define OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS 20
+#define OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS 21
+#define OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS 22
+#define OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS 23
+#define OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS 24
+#define OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS 25
+#define OSSL_FUNC_SIGNATURE_QUERY_KEY_TYPES 26
+#define OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_INIT 27
+#define OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_UPDATE 28
+#define OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_FINAL 29
+#define OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_INIT 30
+#define OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_UPDATE 31
+#define OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_FINAL 32
+
+OSSL_CORE_MAKE_FUNC(void *, signature_newctx, (void *provctx, const char *propq))
+OSSL_CORE_MAKE_FUNC(int, signature_sign_init, (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_sign, (void *ctx, unsigned char *sig, size_t *siglen, size_t sigsize, const unsigned char *tbs, size_t tbslen))
+OSSL_CORE_MAKE_FUNC(int, signature_sign_message_init,
+    (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_sign_message_update,
+    (void *ctx, const unsigned char *in, size_t inlen))
+OSSL_CORE_MAKE_FUNC(int, signature_sign_message_final,
+    (void *ctx, unsigned char *sig,
+        size_t *siglen, size_t sigsize))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_init, (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_verify, (void *ctx, const unsigned char *sig, size_t siglen, const unsigned char *tbs, size_t tbslen))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_message_init,
+    (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_message_update,
+    (void *ctx, const unsigned char *in, size_t inlen))
+/*
+ * signature_verify_final requires that the signature to be verified against
+ * is specified via an OSSL_PARAM.
+ */
+OSSL_CORE_MAKE_FUNC(int, signature_verify_message_final, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_recover_init,
+    (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_recover,
+    (void *ctx, unsigned char *rout, size_t *routlen,
+        size_t routsize, const unsigned char *sig, size_t siglen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_init,
+    (void *ctx, const char *mdname, void *provkey,
+        const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_update,
+    (void *ctx, const unsigned char *data, size_t datalen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_final,
+    (void *ctx, unsigned char *sig, size_t *siglen,
+        size_t sigsize))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign,
+    (void *ctx, unsigned char *sigret, size_t *siglen,
+        size_t sigsize, const unsigned char *tbs, size_t tbslen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_init,
+    (void *ctx, const char *mdname, void *provkey,
+        const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_update,
+    (void *ctx, const unsigned char *data, size_t datalen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_final,
+    (void *ctx, const unsigned char *sig, size_t siglen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify,
+    (void *ctx, const unsigned char *sig, size_t siglen,
+        const unsigned char *tbs, size_t tbslen))
+OSSL_CORE_MAKE_FUNC(void, signature_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, signature_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, signature_get_ctx_params,
+    (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_gettable_ctx_params,
+    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, signature_set_ctx_params,
+    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_settable_ctx_params,
+    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, signature_get_ctx_md_params,
+    (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_gettable_ctx_md_params,
+    (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, signature_set_ctx_md_params,
+    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_settable_ctx_md_params,
+    (void *ctx))
+OSSL_CORE_MAKE_FUNC(const char **, signature_query_key_types, (void))
+
+/*-
+ * Symmetric key management
+ *
+ * The Key Management takes care of provider side of symmetric key objects, and
+ * includes essentially everything that manipulates the keys  themselves and
+ * their parameters.
+ *
+ * The key objects are commonly referred to as |keydata|, and it MUST be able
+ * to contain parameters if the key has any, and the secret key.
+ *
+ * Key objects are created with OSSL_FUNC_skeymgmt_import() (there is no
+ * dedicated memory allocation function), exported with
+ * OSSL_FUNC_skeymgmt_export() and destroyed with OSSL_FUNC_keymgmt_free().
+ *
+ */
+
+/* Key data subset selection - individual bits */
+#define OSSL_SKEYMGMT_SELECT_PARAMETERS 0x01
+#define OSSL_SKEYMGMT_SELECT_SECRET_KEY 0x02
+
+/* Key data subset selection - combinations */
+#define OSSL_SKEYMGMT_SELECT_ALL \
+    (OSSL_SKEYMGMT_SELECT_PARAMETERS | OSSL_SKEYMGMT_SELECT_SECRET_KEY)
+
+#define OSSL_FUNC_SKEYMGMT_FREE 1
+#define OSSL_FUNC_SKEYMGMT_IMPORT 2
+#define OSSL_FUNC_SKEYMGMT_EXPORT 3
+#define OSSL_FUNC_SKEYMGMT_GENERATE 4
+#define OSSL_FUNC_SKEYMGMT_GET_KEY_ID 5
+#define OSSL_FUNC_SKEYMGMT_IMP_SETTABLE_PARAMS 6
+#define OSSL_FUNC_SKEYMGMT_GEN_SETTABLE_PARAMS 7
+
+OSSL_CORE_MAKE_FUNC(void, skeymgmt_free, (void *keydata))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+    skeymgmt_imp_settable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, skeymgmt_import, (void *provctx, int selection, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, skeymgmt_export,
+    (void *keydata, int selection,
+        OSSL_CALLBACK *param_cb, void *cbarg))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+    skeymgmt_gen_settable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, skeymgmt_generate, (void *provctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const char *, skeymgmt_get_key_id, (void *keydata))
+
+/* Asymmetric Ciphers */
+
+#define OSSL_FUNC_ASYM_CIPHER_NEWCTX 1
+#define OSSL_FUNC_ASYM_CIPHER_ENCRYPT_INIT 2
+#define OSSL_FUNC_ASYM_CIPHER_ENCRYPT 3
+#define OSSL_FUNC_ASYM_CIPHER_DECRYPT_INIT 4
+#define OSSL_FUNC_ASYM_CIPHER_DECRYPT 5
+#define OSSL_FUNC_ASYM_CIPHER_FREECTX 6
+#define OSSL_FUNC_ASYM_CIPHER_DUPCTX 7
+#define OSSL_FUNC_ASYM_CIPHER_GET_CTX_PARAMS 8
+#define OSSL_FUNC_ASYM_CIPHER_GETTABLE_CTX_PARAMS 9
+#define OSSL_FUNC_ASYM_CIPHER_SET_CTX_PARAMS 10
+#define OSSL_FUNC_ASYM_CIPHER_SETTABLE_CTX_PARAMS 11
+
+OSSL_CORE_MAKE_FUNC(void *, asym_cipher_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_encrypt_init, (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_encrypt, (void *ctx, unsigned char *out, size_t *outlen, size_t outsize, const unsigned char *in, size_t inlen))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_decrypt_init, (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_decrypt, (void *ctx, unsigned char *out, size_t *outlen, size_t outsize, const unsigned char *in, size_t inlen))
+OSSL_CORE_MAKE_FUNC(void, asym_cipher_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, asym_cipher_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_get_ctx_params,
+    (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, asym_cipher_gettable_ctx_params,
+    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_set_ctx_params,
+    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, asym_cipher_settable_ctx_params,
+    (void *ctx, void *provctx))
+
+/* Asymmetric Key encapsulation */
+#define OSSL_FUNC_KEM_NEWCTX 1
+#define OSSL_FUNC_KEM_ENCAPSULATE_INIT 2
+#define OSSL_FUNC_KEM_ENCAPSULATE 3
+#define OSSL_FUNC_KEM_DECAPSULATE_INIT 4
+#define OSSL_FUNC_KEM_DECAPSULATE 5
+#define OSSL_FUNC_KEM_FREECTX 6
+#define OSSL_FUNC_KEM_DUPCTX 7
+#define OSSL_FUNC_KEM_GET_CTX_PARAMS 8
+#define OSSL_FUNC_KEM_GETTABLE_CTX_PARAMS 9
+#define OSSL_FUNC_KEM_SET_CTX_PARAMS 10
+#define OSSL_FUNC_KEM_SETTABLE_CTX_PARAMS 11
+#define OSSL_FUNC_KEM_AUTH_ENCAPSULATE_INIT 12
+#define OSSL_FUNC_KEM_AUTH_DECAPSULATE_INIT 13
+
+OSSL_CORE_MAKE_FUNC(void *, kem_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, kem_encapsulate_init, (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kem_auth_encapsulate_init, (void *ctx, void *provkey, void *authprivkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kem_encapsulate, (void *ctx, unsigned char *out, size_t *outlen, unsigned char *secret, size_t *secretlen))
+OSSL_CORE_MAKE_FUNC(int, kem_decapsulate_init, (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kem_auth_decapsulate_init, (void *ctx, void *provkey, void *authpubkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kem_decapsulate, (void *ctx, unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen))
+OSSL_CORE_MAKE_FUNC(void, kem_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, kem_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, kem_get_ctx_params, (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kem_gettable_ctx_params,
+    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, kem_set_ctx_params,
+    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kem_settable_ctx_params,
+    (void *ctx, void *provctx))
+
+/* Encoders and decoders */
+#define OSSL_FUNC_ENCODER_NEWCTX 1
+#define OSSL_FUNC_ENCODER_FREECTX 2
+#define OSSL_FUNC_ENCODER_GET_PARAMS 3
+#define OSSL_FUNC_ENCODER_GETTABLE_PARAMS 4
+#define OSSL_FUNC_ENCODER_SET_CTX_PARAMS 5
+#define OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS 6
+#define OSSL_FUNC_ENCODER_DOES_SELECTION 10
+#define OSSL_FUNC_ENCODER_ENCODE 11
+#define OSSL_FUNC_ENCODER_IMPORT_OBJECT 20
+#define OSSL_FUNC_ENCODER_FREE_OBJECT 21
+OSSL_CORE_MAKE_FUNC(void *, encoder_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void, encoder_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, encoder_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, encoder_gettable_params,
+    (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, encoder_set_ctx_params,
+    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, encoder_settable_ctx_params,
+    (void *provctx))
+
+OSSL_CORE_MAKE_FUNC(int, encoder_does_selection,
+    (void *provctx, int selection))
+OSSL_CORE_MAKE_FUNC(int, encoder_encode,
+    (void *ctx, OSSL_CORE_BIO *out,
+        const void *obj_raw, const OSSL_PARAM obj_abstract[],
+        int selection,
+        OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg))
+
+OSSL_CORE_MAKE_FUNC(void *, encoder_import_object,
+    (void *ctx, int selection, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(void, encoder_free_object, (void *obj))
+
+#define OSSL_FUNC_DECODER_NEWCTX 1
+#define OSSL_FUNC_DECODER_FREECTX 2
+#define OSSL_FUNC_DECODER_GET_PARAMS 3
+#define OSSL_FUNC_DECODER_GETTABLE_PARAMS 4
+#define OSSL_FUNC_DECODER_SET_CTX_PARAMS 5
+#define OSSL_FUNC_DECODER_SETTABLE_CTX_PARAMS 6
+#define OSSL_FUNC_DECODER_DOES_SELECTION 10
+#define OSSL_FUNC_DECODER_DECODE 11
+#define OSSL_FUNC_DECODER_EXPORT_OBJECT 20
+OSSL_CORE_MAKE_FUNC(void *, decoder_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void, decoder_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, decoder_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, decoder_gettable_params,
+    (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, decoder_set_ctx_params,
+    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, decoder_settable_ctx_params,
+    (void *provctx))
+
+OSSL_CORE_MAKE_FUNC(int, decoder_does_selection,
+    (void *provctx, int selection))
+OSSL_CORE_MAKE_FUNC(int, decoder_decode,
+    (void *ctx, OSSL_CORE_BIO *in, int selection,
+        OSSL_CALLBACK *data_cb, void *data_cbarg,
+        OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
+OSSL_CORE_MAKE_FUNC(int, decoder_export_object,
+    (void *ctx, const void *objref, size_t objref_sz,
+        OSSL_CALLBACK *export_cb, void *export_cbarg))
+
+/*-
+ * Store
+ *
+ * Objects are scanned by using the 'open', 'load', 'eof' and 'close'
+ * functions, which implement an OSSL_STORE loader.
+ *
+ * store_load() works in a way that's very similar to the decoders, in
+ * that they pass an abstract object through a callback, either as a DER
+ * octet string or as an object reference, which libcrypto will have to
+ * deal with.
+ */
+
+#define OSSL_FUNC_STORE_OPEN 1
+#define OSSL_FUNC_STORE_ATTACH 2
+#define OSSL_FUNC_STORE_SETTABLE_CTX_PARAMS 3
+#define OSSL_FUNC_STORE_SET_CTX_PARAMS 4
+#define OSSL_FUNC_STORE_LOAD 5
+#define OSSL_FUNC_STORE_EOF 6
+#define OSSL_FUNC_STORE_CLOSE 7
+#define OSSL_FUNC_STORE_EXPORT_OBJECT 8
+#define OSSL_FUNC_STORE_DELETE 9
+#define OSSL_FUNC_STORE_OPEN_EX 10
+OSSL_CORE_MAKE_FUNC(void *, store_open, (void *provctx, const char *uri))
+OSSL_CORE_MAKE_FUNC(void *, store_attach, (void *provctx, OSSL_CORE_BIO *in))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, store_settable_ctx_params,
+    (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, store_set_ctx_params,
+    (void *loaderctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, store_load,
+    (void *loaderctx,
+        OSSL_CALLBACK *object_cb, void *object_cbarg,
+        OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
+OSSL_CORE_MAKE_FUNC(int, store_eof, (void *loaderctx))
+OSSL_CORE_MAKE_FUNC(int, store_close, (void *loaderctx))
+OSSL_CORE_MAKE_FUNC(int, store_export_object,
+    (void *loaderctx, const void *objref, size_t objref_sz,
+        OSSL_CALLBACK *export_cb, void *export_cbarg))
+OSSL_CORE_MAKE_FUNC(int, store_delete,
+    (void *provctx, const char *uri, const OSSL_PARAM params[],
+        OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
+OSSL_CORE_MAKE_FUNC(void *, store_open_ex,
+    (void *provctx, const char *uri, const OSSL_PARAM params[],
+        OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

miniconda3/envs/active_proaction/include/openssl/core_names.h

@@ -0,0 +1,579 @@
+/*
+ * WARNING: do not edit!
+ * Generated by Makefile from include/openssl/core_names.h.in
+ *
+ * Copyright 2019-2025 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+/* clang-format off */
+
+/* clang-format on */
+
+#ifndef OPENSSL_CORE_NAMES_H
+#define OPENSSL_CORE_NAMES_H
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* OSSL_CIPHER_PARAM_CTS_MODE Values */
+#define OSSL_CIPHER_CTS_MODE_CS1 "CS1"
+#define OSSL_CIPHER_CTS_MODE_CS2 "CS2"
+#define OSSL_CIPHER_CTS_MODE_CS3 "CS3"
+
+/* Known CIPHER names (not a complete list) */
+#define OSSL_CIPHER_NAME_AES_128_GCM_SIV "AES-128-GCM-SIV"
+#define OSSL_CIPHER_NAME_AES_192_GCM_SIV "AES-192-GCM-SIV"
+#define OSSL_CIPHER_NAME_AES_256_GCM_SIV "AES-256-GCM-SIV"
+
+/* Known DIGEST names (not a complete list) */
+#define OSSL_DIGEST_NAME_MD5 "MD5"
+#define OSSL_DIGEST_NAME_MD5_SHA1 "MD5-SHA1"
+#define OSSL_DIGEST_NAME_SHA1 "SHA1"
+#define OSSL_DIGEST_NAME_SHA2_224 "SHA2-224"
+#define OSSL_DIGEST_NAME_SHA2_256 "SHA2-256"
+#define OSSL_DIGEST_NAME_SHA2_256_192 "SHA2-256/192"
+#define OSSL_DIGEST_NAME_SHA2_384 "SHA2-384"
+#define OSSL_DIGEST_NAME_SHA2_512 "SHA2-512"
+#define OSSL_DIGEST_NAME_SHA2_512_224 "SHA2-512/224"
+#define OSSL_DIGEST_NAME_SHA2_512_256 "SHA2-512/256"
+#define OSSL_DIGEST_NAME_MD2 "MD2"
+#define OSSL_DIGEST_NAME_MD4 "MD4"
+#define OSSL_DIGEST_NAME_MDC2 "MDC2"
+#define OSSL_DIGEST_NAME_RIPEMD160 "RIPEMD160"
+#define OSSL_DIGEST_NAME_SHA3_224 "SHA3-224"
+#define OSSL_DIGEST_NAME_SHA3_256 "SHA3-256"
+#define OSSL_DIGEST_NAME_SHA3_384 "SHA3-384"
+#define OSSL_DIGEST_NAME_SHA3_512 "SHA3-512"
+#define OSSL_DIGEST_NAME_KECCAK_KMAC128 "KECCAK-KMAC-128"
+#define OSSL_DIGEST_NAME_KECCAK_KMAC256 "KECCAK-KMAC-256"
+#define OSSL_DIGEST_NAME_SM3 "SM3"
+
+/* Known MAC names */
+#define OSSL_MAC_NAME_BLAKE2BMAC "BLAKE2BMAC"
+#define OSSL_MAC_NAME_BLAKE2SMAC "BLAKE2SMAC"
+#define OSSL_MAC_NAME_CMAC "CMAC"
+#define OSSL_MAC_NAME_GMAC "GMAC"
+#define OSSL_MAC_NAME_HMAC "HMAC"
+#define OSSL_MAC_NAME_KMAC128 "KMAC128"
+#define OSSL_MAC_NAME_KMAC256 "KMAC256"
+#define OSSL_MAC_NAME_POLY1305 "POLY1305"
+#define OSSL_MAC_NAME_SIPHASH "SIPHASH"
+
+/* Known KDF names */
+#define OSSL_KDF_NAME_HKDF "HKDF"
+#define OSSL_KDF_NAME_TLS1_3_KDF "TLS13-KDF"
+#define OSSL_KDF_NAME_PBKDF1 "PBKDF1"
+#define OSSL_KDF_NAME_PBKDF2 "PBKDF2"
+#define OSSL_KDF_NAME_SCRYPT "SCRYPT"
+#define OSSL_KDF_NAME_SSHKDF "SSHKDF"
+#define OSSL_KDF_NAME_SSKDF "SSKDF"
+#define OSSL_KDF_NAME_TLS1_PRF "TLS1-PRF"
+#define OSSL_KDF_NAME_X942KDF_ASN1 "X942KDF-ASN1"
+#define OSSL_KDF_NAME_X942KDF_CONCAT "X942KDF-CONCAT"
+#define OSSL_KDF_NAME_X963KDF "X963KDF"
+#define OSSL_KDF_NAME_KBKDF "KBKDF"
+#define OSSL_KDF_NAME_KRB5KDF "KRB5KDF"
+#define OSSL_KDF_NAME_HMACDRBGKDF "HMAC-DRBG-KDF"
+
+/* RSA padding modes */
+#define OSSL_PKEY_RSA_PAD_MODE_NONE "none"
+#define OSSL_PKEY_RSA_PAD_MODE_PKCSV15 "pkcs1"
+#define OSSL_PKEY_RSA_PAD_MODE_OAEP "oaep"
+#define OSSL_PKEY_RSA_PAD_MODE_X931 "x931"
+#define OSSL_PKEY_RSA_PAD_MODE_PSS "pss"
+
+/* RSA pss padding salt length */
+#define OSSL_PKEY_RSA_PSS_SALT_LEN_DIGEST "digest"
+#define OSSL_PKEY_RSA_PSS_SALT_LEN_MAX "max"
+#define OSSL_PKEY_RSA_PSS_SALT_LEN_AUTO "auto"
+#define OSSL_PKEY_RSA_PSS_SALT_LEN_AUTO_DIGEST_MAX "auto-digestmax"
+
+/* OSSL_PKEY_PARAM_EC_ENCODING values */
+#define OSSL_PKEY_EC_ENCODING_EXPLICIT "explicit"
+#define OSSL_PKEY_EC_ENCODING_GROUP "named_curve"
+
+#define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_UNCOMPRESSED "uncompressed"
+#define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_COMPRESSED "compressed"
+#define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_HYBRID "hybrid"
+
+#define OSSL_PKEY_EC_GROUP_CHECK_DEFAULT "default"
+#define OSSL_PKEY_EC_GROUP_CHECK_NAMED "named"
+#define OSSL_PKEY_EC_GROUP_CHECK_NAMED_NIST "named-nist"
+
+/* PROV_SKEY well known key types */
+#define OSSL_SKEY_TYPE_GENERIC "GENERIC-SECRET"
+#define OSSL_SKEY_TYPE_AES "AES"
+
+/* OSSL_KEM_PARAM_OPERATION values */
+#define OSSL_KEM_PARAM_OPERATION_RSASVE "RSASVE"
+#define OSSL_KEM_PARAM_OPERATION_DHKEM "DHKEM"
+
+/* Provider configuration variables */
+#define OSSL_PKEY_RETAIN_SEED "pkey_retain_seed"
+
+/* Parameter name definitions - generated by util/perl/OpenSSL/paramnames.pm */
+/* clang-format off */
+# define OSSL_ALG_PARAM_ALGORITHM_ID "algorithm-id"
+# define OSSL_ALG_PARAM_ALGORITHM_ID_PARAMS "algorithm-id-params"
+# define OSSL_ALG_PARAM_CIPHER "cipher"
+# define OSSL_ALG_PARAM_DIGEST "digest"
+# define OSSL_ALG_PARAM_ENGINE "engine"
+# define OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR "fips-indicator"
+# define OSSL_ALG_PARAM_MAC "mac"
+# define OSSL_ALG_PARAM_PROPERTIES "properties"
+# define OSSL_ASYM_CIPHER_PARAM_DIGEST OSSL_PKEY_PARAM_DIGEST
+# define OSSL_ASYM_CIPHER_PARAM_ENGINE OSSL_PKEY_PARAM_ENGINE
+# define OSSL_ASYM_CIPHER_PARAM_FIPS_APPROVED_INDICATOR OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR
+# define OSSL_ASYM_CIPHER_PARAM_FIPS_KEY_CHECK OSSL_PKEY_PARAM_FIPS_KEY_CHECK
+# define OSSL_ASYM_CIPHER_PARAM_FIPS_RSA_PKCS15_PAD_DISABLED OSSL_PROV_PARAM_RSA_PKCS15_PAD_DISABLED
+# define OSSL_ASYM_CIPHER_PARAM_IMPLICIT_REJECTION "implicit-rejection"
+# define OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST OSSL_PKEY_PARAM_MGF1_DIGEST
+# define OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS OSSL_PKEY_PARAM_MGF1_PROPERTIES
+# define OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST OSSL_ALG_PARAM_DIGEST
+# define OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS "digest-props"
+# define OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL "oaep-label"
+# define OSSL_ASYM_CIPHER_PARAM_PAD_MODE OSSL_PKEY_PARAM_PAD_MODE
+# define OSSL_ASYM_CIPHER_PARAM_PROPERTIES OSSL_PKEY_PARAM_PROPERTIES
+# define OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION "tls-client-version"
+# define OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION "tls-negotiated-version"
+# define OSSL_CAPABILITY_TLS_GROUP_ALG "tls-group-alg"
+# define OSSL_CAPABILITY_TLS_GROUP_ID "tls-group-id"
+# define OSSL_CAPABILITY_TLS_GROUP_IS_KEM "tls-group-is-kem"
+# define OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS "tls-max-dtls"
+# define OSSL_CAPABILITY_TLS_GROUP_MAX_TLS "tls-max-tls"
+# define OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS "tls-min-dtls"
+# define OSSL_CAPABILITY_TLS_GROUP_MIN_TLS "tls-min-tls"
+# define OSSL_CAPABILITY_TLS_GROUP_NAME "tls-group-name"
+# define OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL "tls-group-name-internal"
+# define OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS "tls-group-sec-bits"
+# define OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT "tls-sigalg-code-point"
+# define OSSL_CAPABILITY_TLS_SIGALG_HASH_NAME "tls-sigalg-hash-name"
+# define OSSL_CAPABILITY_TLS_SIGALG_HASH_OID "tls-sigalg-hash-oid"
+# define OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME "tls-sigalg-iana-name"
+# define OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE "tls-sigalg-keytype"
+# define OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE_OID "tls-sigalg-keytype-oid"
+# define OSSL_CAPABILITY_TLS_SIGALG_MAX_DTLS "tls-max-dtls"
+# define OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS "tls-max-tls"
+# define OSSL_CAPABILITY_TLS_SIGALG_MIN_DTLS "tls-min-dtls"
+# define OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS "tls-min-tls"
+# define OSSL_CAPABILITY_TLS_SIGALG_NAME "tls-sigalg-name"
+# define OSSL_CAPABILITY_TLS_SIGALG_OID "tls-sigalg-oid"
+# define OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS "tls-sigalg-sec-bits"
+# define OSSL_CAPABILITY_TLS_SIGALG_SIG_NAME "tls-sigalg-sig-name"
+# define OSSL_CAPABILITY_TLS_SIGALG_SIG_OID "tls-sigalg-sig-oid"
+# define OSSL_CIPHER_PARAM_AEAD "aead"
+# define OSSL_CIPHER_PARAM_AEAD_IVLEN OSSL_CIPHER_PARAM_IVLEN
+# define OSSL_CIPHER_PARAM_AEAD_IV_GENERATED "iv-generated"
+# define OSSL_CIPHER_PARAM_AEAD_MAC_KEY "mackey"
+# define OSSL_CIPHER_PARAM_AEAD_TAG "tag"
+# define OSSL_CIPHER_PARAM_AEAD_TAGLEN "taglen"
+# define OSSL_CIPHER_PARAM_AEAD_TLS1_AAD "tlsaad"
+# define OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD "tlsaadpad"
+# define OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN "tlsivgen"
+# define OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED "tlsivfixed"
+# define OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV "tlsivinv"
+# define OSSL_CIPHER_PARAM_ALGORITHM_ID OSSL_ALG_PARAM_ALGORITHM_ID
+# define OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS OSSL_ALG_PARAM_ALGORITHM_ID_PARAMS
+# define OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD "alg_id_param"
+# define OSSL_CIPHER_PARAM_BLOCK_SIZE "blocksize"
+# define OSSL_CIPHER_PARAM_CTS "cts"
+# define OSSL_CIPHER_PARAM_CTS_MODE "cts_mode"
+# define OSSL_CIPHER_PARAM_CUSTOM_IV "custom-iv"
+# define OSSL_CIPHER_PARAM_DECRYPT_ONLY "decrypt-only"
+# define OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR
+# define OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK "encrypt-check"
+# define OSSL_CIPHER_PARAM_HAS_RAND_KEY "has-randkey"
+# define OSSL_CIPHER_PARAM_IV "iv"
+# define OSSL_CIPHER_PARAM_IVLEN "ivlen"
+# define OSSL_CIPHER_PARAM_KEYLEN "keylen"
+# define OSSL_CIPHER_PARAM_MODE "mode"
+# define OSSL_CIPHER_PARAM_NUM "num"
+# define OSSL_CIPHER_PARAM_PADDING "padding"
+# define OSSL_CIPHER_PARAM_PIPELINE_AEAD_TAG "pipeline-tag"
+# define OSSL_CIPHER_PARAM_RANDOM_KEY "randkey"
+# define OSSL_CIPHER_PARAM_RC2_KEYBITS "keybits"
+# define OSSL_CIPHER_PARAM_ROUNDS "rounds"
+# define OSSL_CIPHER_PARAM_SPEED "speed"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK "tls-multi"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD "tls1multi_aad"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN "tls1multi_aadpacklen"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC "tls1multi_enc"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN "tls1multi_encin"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN "tls1multi_enclen"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE "tls1multi_interleave"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE "tls1multi_maxbufsz"
+# define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT "tls1multi_maxsndfrag"
+# define OSSL_CIPHER_PARAM_TLS_MAC "tls-mac"
+# define OSSL_CIPHER_PARAM_TLS_MAC_SIZE "tls-mac-size"
+# define OSSL_CIPHER_PARAM_TLS_VERSION "tls-version"
+# define OSSL_CIPHER_PARAM_UPDATED_IV "updated-iv"
+# define OSSL_CIPHER_PARAM_USE_BITS "use-bits"
+# define OSSL_CIPHER_PARAM_XTS_STANDARD "xts_standard"
+# define OSSL_DECODER_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_DIGEST_PARAM_ALGID_ABSENT "algid-absent"
+# define OSSL_DIGEST_PARAM_BLOCK_SIZE "blocksize"
+# define OSSL_DIGEST_PARAM_MICALG "micalg"
+# define OSSL_DIGEST_PARAM_PAD_TYPE "pad-type"
+# define OSSL_DIGEST_PARAM_SIZE "size"
+# define OSSL_DIGEST_PARAM_SSL3_MS "ssl3-ms"
+# define OSSL_DIGEST_PARAM_XOF "xof"
+# define OSSL_DIGEST_PARAM_XOFLEN "xoflen"
+# define OSSL_DRBG_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+# define OSSL_DRBG_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST
+# define OSSL_DRBG_PARAM_ENTROPY_REQUIRED "entropy_required"
+# define OSSL_DRBG_PARAM_FIPS_APPROVED_INDICATOR OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR
+# define OSSL_DRBG_PARAM_FIPS_DIGEST_CHECK OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK
+# define OSSL_DRBG_PARAM_MAC OSSL_ALG_PARAM_MAC
+# define OSSL_DRBG_PARAM_MAX_ADINLEN "max_adinlen"
+# define OSSL_DRBG_PARAM_MAX_ENTROPYLEN "max_entropylen"
+# define OSSL_DRBG_PARAM_MAX_LENGTH "maxium_length"
+# define OSSL_DRBG_PARAM_MAX_NONCELEN "max_noncelen"
+# define OSSL_DRBG_PARAM_MAX_PERSLEN "max_perslen"
+# define OSSL_DRBG_PARAM_MIN_ENTROPYLEN "min_entropylen"
+# define OSSL_DRBG_PARAM_MIN_LENGTH "minium_length"
+# define OSSL_DRBG_PARAM_MIN_NONCELEN "min_noncelen"
+# define OSSL_DRBG_PARAM_PREDICTION_RESISTANCE "prediction_resistance"
+# define OSSL_DRBG_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_DRBG_PARAM_RANDOM_DATA "random_data"
+# define OSSL_DRBG_PARAM_RESEED_COUNTER "reseed_counter"
+# define OSSL_DRBG_PARAM_RESEED_REQUESTS "reseed_requests"
+# define OSSL_DRBG_PARAM_RESEED_TIME "reseed_time"
+# define OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL "reseed_time_interval"
+# define OSSL_DRBG_PARAM_SIZE "size"
+# define OSSL_DRBG_PARAM_USE_DF "use_derivation_function"
+# define OSSL_ENCODER_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+# define OSSL_ENCODER_PARAM_ENCRYPT_LEVEL "encrypt-level"
+# define OSSL_ENCODER_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_ENCODER_PARAM_SAVE_PARAMETERS "save-parameters"
+# define OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE "ecdh-cofactor-mode"
+# define OSSL_EXCHANGE_PARAM_FIPS_APPROVED_INDICATOR OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR
+# define OSSL_EXCHANGE_PARAM_FIPS_DIGEST_CHECK OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK
+# define OSSL_EXCHANGE_PARAM_FIPS_ECDH_COFACTOR_CHECK OSSL_PROV_PARAM_ECDH_COFACTOR_CHECK
+# define OSSL_EXCHANGE_PARAM_FIPS_KEY_CHECK OSSL_PKEY_PARAM_FIPS_KEY_CHECK
+# define OSSL_EXCHANGE_PARAM_KDF_DIGEST "kdf-digest"
+# define OSSL_EXCHANGE_PARAM_KDF_DIGEST_PROPS "kdf-digest-props"
+# define OSSL_EXCHANGE_PARAM_KDF_OUTLEN "kdf-outlen"
+# define OSSL_EXCHANGE_PARAM_KDF_TYPE "kdf-type"
+# define OSSL_EXCHANGE_PARAM_KDF_UKM "kdf-ukm"
+# define OSSL_EXCHANGE_PARAM_PAD "pad"
+# define OSSL_GEN_PARAM_ITERATION "iteration"
+# define OSSL_GEN_PARAM_POTENTIAL "potential"
+# define OSSL_KDF_PARAM_ARGON2_AD "ad"
+# define OSSL_KDF_PARAM_ARGON2_LANES "lanes"
+# define OSSL_KDF_PARAM_ARGON2_MEMCOST "memcost"
+# define OSSL_KDF_PARAM_ARGON2_VERSION "version"
+# define OSSL_KDF_PARAM_CEK_ALG "cekalg"
+# define OSSL_KDF_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+# define OSSL_KDF_PARAM_CONSTANT "constant"
+# define OSSL_KDF_PARAM_DATA "data"
+# define OSSL_KDF_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST
+# define OSSL_KDF_PARAM_EARLY_CLEAN "early_clean"
+# define OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR
+# define OSSL_KDF_PARAM_FIPS_DIGEST_CHECK OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK
+# define OSSL_KDF_PARAM_FIPS_EMS_CHECK "ems_check"
+# define OSSL_KDF_PARAM_FIPS_KEY_CHECK OSSL_PKEY_PARAM_FIPS_KEY_CHECK
+# define OSSL_KDF_PARAM_HMACDRBG_ENTROPY "entropy"
+# define OSSL_KDF_PARAM_HMACDRBG_NONCE "nonce"
+# define OSSL_KDF_PARAM_INFO "info"
+# define OSSL_KDF_PARAM_ITER "iter"
+# define OSSL_KDF_PARAM_KBKDF_R "r"
+# define OSSL_KDF_PARAM_KBKDF_USE_L "use-l"
+# define OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR "use-separator"
+# define OSSL_KDF_PARAM_KEY "key"
+# define OSSL_KDF_PARAM_LABEL "label"
+# define OSSL_KDF_PARAM_MAC OSSL_ALG_PARAM_MAC
+# define OSSL_KDF_PARAM_MAC_SIZE "maclen"
+# define OSSL_KDF_PARAM_MODE "mode"
+# define OSSL_KDF_PARAM_PASSWORD "pass"
+# define OSSL_KDF_PARAM_PKCS12_ID "id"
+# define OSSL_KDF_PARAM_PKCS5 "pkcs5"
+# define OSSL_KDF_PARAM_PREFIX "prefix"
+# define OSSL_KDF_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_KDF_PARAM_SALT "salt"
+# define OSSL_KDF_PARAM_SCRYPT_MAXMEM "maxmem_bytes"
+# define OSSL_KDF_PARAM_SCRYPT_N "n"
+# define OSSL_KDF_PARAM_SCRYPT_P "p"
+# define OSSL_KDF_PARAM_SCRYPT_R "r"
+# define OSSL_KDF_PARAM_SECRET "secret"
+# define OSSL_KDF_PARAM_SEED "seed"
+# define OSSL_KDF_PARAM_SIZE "size"
+# define OSSL_KDF_PARAM_SSHKDF_SESSION_ID "session_id"
+# define OSSL_KDF_PARAM_SSHKDF_TYPE "type"
+# define OSSL_KDF_PARAM_SSHKDF_XCGHASH "xcghash"
+# define OSSL_KDF_PARAM_THREADS "threads"
+# define OSSL_KDF_PARAM_UKM "ukm"
+# define OSSL_KDF_PARAM_X942_ACVPINFO "acvp-info"
+# define OSSL_KDF_PARAM_X942_PARTYUINFO "partyu-info"
+# define OSSL_KDF_PARAM_X942_PARTYVINFO "partyv-info"
+# define OSSL_KDF_PARAM_X942_SUPP_PRIVINFO "supp-privinfo"
+# define OSSL_KDF_PARAM_X942_SUPP_PUBINFO "supp-pubinfo"
+# define OSSL_KDF_PARAM_X942_USE_KEYBITS "use-keybits"
+# define OSSL_KEM_PARAM_FIPS_APPROVED_INDICATOR OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR
+# define OSSL_KEM_PARAM_FIPS_KEY_CHECK OSSL_PKEY_PARAM_FIPS_KEY_CHECK
+# define OSSL_KEM_PARAM_IKME "ikme"
+# define OSSL_KEM_PARAM_OPERATION "operation"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING "block_padding"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_HS_PADDING "hs_padding"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA "max_early_data"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN "max_frag_len"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE "mode"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS "options"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD "read_ahead"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC "stream_mac"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE "tlstree"
+# define OSSL_LIBSSL_RECORD_LAYER_PARAM_USE_ETM "use_etm"
+# define OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN "read_buffer_len"
+# define OSSL_MAC_PARAM_BLOCK_SIZE "block-size"
+# define OSSL_MAC_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+# define OSSL_MAC_PARAM_CUSTOM "custom"
+# define OSSL_MAC_PARAM_C_ROUNDS "c-rounds"
+# define OSSL_MAC_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST
+# define OSSL_MAC_PARAM_DIGEST_NOINIT "digest-noinit"
+# define OSSL_MAC_PARAM_DIGEST_ONESHOT "digest-oneshot"
+# define OSSL_MAC_PARAM_D_ROUNDS "d-rounds"
+# define OSSL_MAC_PARAM_FIPS_APPROVED_INDICATOR OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR
+# define OSSL_MAC_PARAM_FIPS_KEY_CHECK OSSL_PKEY_PARAM_FIPS_KEY_CHECK
+# define OSSL_MAC_PARAM_FIPS_NO_SHORT_MAC OSSL_PROV_PARAM_NO_SHORT_MAC
+# define OSSL_MAC_PARAM_IV "iv"
+# define OSSL_MAC_PARAM_KEY "key"
+# define OSSL_MAC_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_MAC_PARAM_SALT "salt"
+# define OSSL_MAC_PARAM_SIZE "size"
+# define OSSL_MAC_PARAM_TLS_DATA_SIZE "tls-data-size"
+# define OSSL_MAC_PARAM_XOF "xof"
+# define OSSL_OBJECT_PARAM_DATA "data"
+# define OSSL_OBJECT_PARAM_DATA_STRUCTURE "data-structure"
+# define OSSL_OBJECT_PARAM_DATA_TYPE "data-type"
+# define OSSL_OBJECT_PARAM_DESC "desc"
+# define OSSL_OBJECT_PARAM_INPUT_TYPE "input-type"
+# define OSSL_OBJECT_PARAM_REFERENCE "reference"
+# define OSSL_OBJECT_PARAM_TYPE "type"
+# define OSSL_PASSPHRASE_PARAM_INFO "info"
+# define OSSL_PKEY_PARAM_ALGORITHM_ID OSSL_ALG_PARAM_ALGORITHM_ID
+# define OSSL_PKEY_PARAM_ALGORITHM_ID_PARAMS OSSL_ALG_PARAM_ALGORITHM_ID_PARAMS
+# define OSSL_PKEY_PARAM_BITS "bits"
+# define OSSL_PKEY_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+# define OSSL_PKEY_PARAM_DEFAULT_DIGEST "default-digest"
+# define OSSL_PKEY_PARAM_DHKEM_IKM "dhkem-ikm"
+# define OSSL_PKEY_PARAM_DH_GENERATOR "safeprime-generator"
+# define OSSL_PKEY_PARAM_DH_PRIV_LEN "priv_len"
+# define OSSL_PKEY_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST
+# define OSSL_PKEY_PARAM_DIGEST_SIZE "digest-size"
+# define OSSL_PKEY_PARAM_DIST_ID "distid"
+# define OSSL_PKEY_PARAM_EC_A "a"
+# define OSSL_PKEY_PARAM_EC_B "b"
+# define OSSL_PKEY_PARAM_EC_CHAR2_M "m"
+# define OSSL_PKEY_PARAM_EC_CHAR2_PP_K1 "k1"
+# define OSSL_PKEY_PARAM_EC_CHAR2_PP_K2 "k2"
+# define OSSL_PKEY_PARAM_EC_CHAR2_PP_K3 "k3"
+# define OSSL_PKEY_PARAM_EC_CHAR2_TP_BASIS "tp"
+# define OSSL_PKEY_PARAM_EC_CHAR2_TYPE "basis-type"
+# define OSSL_PKEY_PARAM_EC_COFACTOR "cofactor"
+# define OSSL_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS "decoded-from-explicit"
+# define OSSL_PKEY_PARAM_EC_ENCODING "encoding"
+# define OSSL_PKEY_PARAM_EC_FIELD_TYPE "field-type"
+# define OSSL_PKEY_PARAM_EC_GENERATOR "generator"
+# define OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE "group-check"
+# define OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC "include-public"
+# define OSSL_PKEY_PARAM_EC_ORDER "order"
+# define OSSL_PKEY_PARAM_EC_P "p"
+# define OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT "point-format"
+# define OSSL_PKEY_PARAM_EC_PUB_X "qx"
+# define OSSL_PKEY_PARAM_EC_PUB_Y "qy"
+# define OSSL_PKEY_PARAM_EC_SEED "seed"
+# define OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY "encoded-pub-key"
+# define OSSL_PKEY_PARAM_ENGINE OSSL_ALG_PARAM_ENGINE
+# define OSSL_PKEY_PARAM_FFC_COFACTOR "j"
+# define OSSL_PKEY_PARAM_FFC_DIGEST OSSL_PKEY_PARAM_DIGEST
+# define OSSL_PKEY_PARAM_FFC_DIGEST_PROPS OSSL_PKEY_PARAM_PROPERTIES
+# define OSSL_PKEY_PARAM_FFC_G "g"
+# define OSSL_PKEY_PARAM_FFC_GINDEX "gindex"
+# define OSSL_PKEY_PARAM_FFC_H "hindex"
+# define OSSL_PKEY_PARAM_FFC_P "p"
+# define OSSL_PKEY_PARAM_FFC_PBITS "pbits"
+# define OSSL_PKEY_PARAM_FFC_PCOUNTER "pcounter"
+# define OSSL_PKEY_PARAM_FFC_Q "q"
+# define OSSL_PKEY_PARAM_FFC_QBITS "qbits"
+# define OSSL_PKEY_PARAM_FFC_SEED "seed"
+# define OSSL_PKEY_PARAM_FFC_TYPE "type"
+# define OSSL_PKEY_PARAM_FFC_VALIDATE_G "validate-g"
+# define OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY "validate-legacy"
+# define OSSL_PKEY_PARAM_FFC_VALIDATE_PQ "validate-pq"
+# define OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR
+# define OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK "digest-check"
+# define OSSL_PKEY_PARAM_FIPS_KEY_CHECK "key-check"
+# define OSSL_PKEY_PARAM_FIPS_SIGN_CHECK "sign-check"
+# define OSSL_PKEY_PARAM_GROUP_NAME "group"
+# define OSSL_PKEY_PARAM_IMPLICIT_REJECTION "implicit-rejection"
+# define OSSL_PKEY_PARAM_MANDATORY_DIGEST "mandatory-digest"
+# define OSSL_PKEY_PARAM_MASKGENFUNC "mgf"
+# define OSSL_PKEY_PARAM_MAX_SIZE "max-size"
+# define OSSL_PKEY_PARAM_MGF1_DIGEST "mgf1-digest"
+# define OSSL_PKEY_PARAM_MGF1_PROPERTIES "mgf1-properties"
+# define OSSL_PKEY_PARAM_ML_DSA_INPUT_FORMATS "ml-dsa.input_formats"
+# define OSSL_PKEY_PARAM_ML_DSA_OUTPUT_FORMATS "ml-dsa.output_formats"
+# define OSSL_PKEY_PARAM_ML_DSA_PREFER_SEED "ml-dsa.prefer_seed"
+# define OSSL_PKEY_PARAM_ML_DSA_RETAIN_SEED "ml-dsa.retain_seed"
+# define OSSL_PKEY_PARAM_ML_DSA_SEED "seed"
+# define OSSL_PKEY_PARAM_ML_KEM_IMPORT_PCT_TYPE "ml-kem.import_pct_type"
+# define OSSL_PKEY_PARAM_ML_KEM_INPUT_FORMATS "ml-kem.input_formats"
+# define OSSL_PKEY_PARAM_ML_KEM_OUTPUT_FORMATS "ml-kem.output_formats"
+# define OSSL_PKEY_PARAM_ML_KEM_PREFER_SEED "ml-kem.prefer_seed"
+# define OSSL_PKEY_PARAM_ML_KEM_RETAIN_SEED "ml-kem.retain_seed"
+# define OSSL_PKEY_PARAM_ML_KEM_SEED "seed"
+# define OSSL_PKEY_PARAM_PAD_MODE "pad-mode"
+# define OSSL_PKEY_PARAM_PRIV_KEY "priv"
+# define OSSL_PKEY_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+# define OSSL_PKEY_PARAM_PUB_KEY "pub"
+# define OSSL_PKEY_PARAM_RSA_BITS OSSL_PKEY_PARAM_BITS
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT "rsa-coefficient"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT1 "rsa-coefficient1"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT2 "rsa-coefficient2"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT3 "rsa-coefficient3"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT4 "rsa-coefficient4"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT5 "rsa-coefficient5"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT6 "rsa-coefficient6"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT7 "rsa-coefficient7"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT8 "rsa-coefficient8"
+# define OSSL_PKEY_PARAM_RSA_COEFFICIENT9 "rsa-coefficient9"
+# define OSSL_PKEY_PARAM_RSA_D "d"
+# define OSSL_PKEY_PARAM_RSA_DERIVE_FROM_PQ "rsa-derive-from-pq"
+# define OSSL_PKEY_PARAM_RSA_DIGEST OSSL_PKEY_PARAM_DIGEST
+# define OSSL_PKEY_PARAM_RSA_DIGEST_PROPS OSSL_PKEY_PARAM_PROPERTIES
+# define OSSL_PKEY_PARAM_RSA_E "e"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT "rsa-exponent"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT1 "rsa-exponent1"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT10 "rsa-exponent10"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT2 "rsa-exponent2"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT3 "rsa-exponent3"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT4 "rsa-exponent4"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT5 "rsa-exponent5"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT6 "rsa-exponent6"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT7 "rsa-exponent7"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT8 "rsa-exponent8"
+# define OSSL_PKEY_PARAM_RSA_EXPONENT9 "rsa-exponent9"
+# define OSSL_PKEY_PARAM_RSA_FACTOR "rsa-factor"
+# define OSSL_PKEY_PARAM_RSA_FACTOR1 "rsa-factor1"
+# define OSSL_PKEY_PARAM_RSA_FACTOR10 "rsa-factor10"
+# define OSSL_PKEY_PARAM_RSA_FACTOR2 "rsa-factor2"
+# define OSSL_PKEY_PARAM_RSA_FACTOR3 "rsa-factor3"
+# define OSSL_PKEY_PARAM_RSA_FACTOR4 "rsa-factor4"
+# define OSSL_PKEY_PARAM_RSA_FACTOR5 "rsa-factor5"
+# define OSSL_PKEY_PARAM_RSA_FACTOR6 "rsa-factor6"
+# define OSSL_PKEY_PARAM_RSA_FACTOR7 "rsa-factor7"
+# define OSSL_PKEY_PARAM_RSA_FACTOR8 "rsa-factor8"
+# define OSSL_PKEY_PARAM_RSA_FACTOR9 "rsa-factor9"
+# define OSSL_PKEY_PARAM_RSA_MASKGENFUNC OSSL_PKEY_PARAM_MASKGENFUNC
+# define OSSL_PKEY_PARAM_RSA_MGF1_DIGEST OSSL_PKEY_PARAM_MGF1_DIGEST
+# define OSSL_PKEY_PARAM_RSA_N "n"
+# define OSSL_PKEY_PARAM_RSA_PRIMES "primes"
+# define OSSL_PKEY_PARAM_RSA_PSS_SALTLEN "saltlen"
+# define OSSL_PKEY_PARAM_RSA_TEST_P1 "p1"
+# define OSSL_PKEY_PARAM_RSA_TEST_P2 "p2"
+# define OSSL_PKEY_PARAM_RSA_TEST_Q1 "q1"
+# define OSSL_PKEY_PARAM_RSA_TEST_Q2 "q2"
+# define OSSL_PKEY_PARAM_RSA_TEST_XP "xp"
+# define OSSL_PKEY_PARAM_RSA_TEST_XP1 "xp1"
+# define OSSL_PKEY_PARAM_RSA_TEST_XP2 "xp2"
+# define OSSL_PKEY_PARAM_RSA_TEST_XQ "xq"
+# define OSSL_PKEY_PARAM_RSA_TEST_XQ1 "xq1"
+# define OSSL_PKEY_PARAM_RSA_TEST_XQ2 "xq2"
+# define OSSL_PKEY_PARAM_SECURITY_BITS "security-bits"
+# define OSSL_PKEY_PARAM_SLH_DSA_SEED "seed"
+# define OSSL_PKEY_PARAM_USE_COFACTOR_ECDH OSSL_PKEY_PARAM_USE_COFACTOR_FLAG
+# define OSSL_PKEY_PARAM_USE_COFACTOR_FLAG "use-cofactor-flag"
+# define OSSL_PROV_PARAM_BUILDINFO "buildinfo"
+# define OSSL_PROV_PARAM_CORE_MODULE_FILENAME "module-filename"
+# define OSSL_PROV_PARAM_CORE_PROV_NAME "provider-name"
+# define OSSL_PROV_PARAM_CORE_VERSION "openssl-version"
+# define OSSL_PROV_PARAM_DRBG_TRUNC_DIGEST "drbg-no-trunc-md"
+# define OSSL_PROV_PARAM_DSA_SIGN_DISABLED "dsa-sign-disabled"
+# define OSSL_PROV_PARAM_ECDH_COFACTOR_CHECK "ecdh-cofactor-check"
+# define OSSL_PROV_PARAM_HKDF_DIGEST_CHECK "hkdf-digest-check"
+# define OSSL_PROV_PARAM_HKDF_KEY_CHECK "hkdf-key-check"
+# define OSSL_PROV_PARAM_HMAC_KEY_CHECK "hmac-key-check"
+# define OSSL_PROV_PARAM_KBKDF_KEY_CHECK "kbkdf-key-check"
+# define OSSL_PROV_PARAM_KMAC_KEY_CHECK "kmac-key-check"
+# define OSSL_PROV_PARAM_NAME "name"
+# define OSSL_PROV_PARAM_NO_SHORT_MAC "no-short-mac"
+# define OSSL_PROV_PARAM_PBKDF2_LOWER_BOUND_CHECK "pbkdf2-lower-bound-check"
+# define OSSL_PROV_PARAM_RSA_PKCS15_PAD_DISABLED "rsa-pkcs15-pad-disabled"
+# define OSSL_PROV_PARAM_RSA_PSS_SALTLEN_CHECK "rsa-pss-saltlen-check"
+# define OSSL_PROV_PARAM_RSA_SIGN_X931_PAD_DISABLED "rsa-sign-x931-pad-disabled"
+# define OSSL_PROV_PARAM_SECURITY_CHECKS "security-checks"
+# define OSSL_PROV_PARAM_SELF_TEST_DESC "st-desc"
+# define OSSL_PROV_PARAM_SELF_TEST_PHASE "st-phase"
+# define OSSL_PROV_PARAM_SELF_TEST_TYPE "st-type"
+# define OSSL_PROV_PARAM_SIGNATURE_DIGEST_CHECK "signature-digest-check"
+# define OSSL_PROV_PARAM_SSHKDF_DIGEST_CHECK "sshkdf-digest-check"
+# define OSSL_PROV_PARAM_SSHKDF_KEY_CHECK "sshkdf-key-check"
+# define OSSL_PROV_PARAM_SSKDF_DIGEST_CHECK "sskdf-digest-check"
+# define OSSL_PROV_PARAM_SSKDF_KEY_CHECK "sskdf-key-check"
+# define OSSL_PROV_PARAM_STATUS "status"
+# define OSSL_PROV_PARAM_TDES_ENCRYPT_DISABLED "tdes-encrypt-disabled"
+# define OSSL_PROV_PARAM_TLS13_KDF_DIGEST_CHECK "tls13-kdf-digest-check"
+# define OSSL_PROV_PARAM_TLS13_KDF_KEY_CHECK "tls13-kdf-key-check"
+# define OSSL_PROV_PARAM_TLS1_PRF_DIGEST_CHECK "tls1-prf-digest-check"
+# define OSSL_PROV_PARAM_TLS1_PRF_EMS_CHECK "tls1-prf-ems-check"
+# define OSSL_PROV_PARAM_TLS1_PRF_KEY_CHECK "tls1-prf-key-check"
+# define OSSL_PROV_PARAM_VERSION "version"
+# define OSSL_PROV_PARAM_X942KDF_KEY_CHECK "x942kdf-key-check"
+# define OSSL_PROV_PARAM_X963KDF_DIGEST_CHECK "x963kdf-digest-check"
+# define OSSL_PROV_PARAM_X963KDF_KEY_CHECK "x963kdf-key-check"
+# define OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR
+# define OSSL_RAND_PARAM_GENERATE "generate"
+# define OSSL_RAND_PARAM_MAX_REQUEST "max_request"
+# define OSSL_RAND_PARAM_STATE "state"
+# define OSSL_RAND_PARAM_STRENGTH "strength"
+# define OSSL_RAND_PARAM_TEST_ENTROPY "test_entropy"
+# define OSSL_RAND_PARAM_TEST_NONCE "test_nonce"
+# define OSSL_SIGNATURE_PARAM_ADD_RANDOM "additional-random"
+# define OSSL_SIGNATURE_PARAM_ALGORITHM_ID OSSL_PKEY_PARAM_ALGORITHM_ID
+# define OSSL_SIGNATURE_PARAM_ALGORITHM_ID_PARAMS OSSL_PKEY_PARAM_ALGORITHM_ID_PARAMS
+# define OSSL_SIGNATURE_PARAM_CONTEXT_STRING "context-string"
+# define OSSL_SIGNATURE_PARAM_DETERMINISTIC "deterministic"
+# define OSSL_SIGNATURE_PARAM_DIGEST OSSL_PKEY_PARAM_DIGEST
+# define OSSL_SIGNATURE_PARAM_DIGEST_SIZE OSSL_PKEY_PARAM_DIGEST_SIZE
+# define OSSL_SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR
+# define OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK
+# define OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK OSSL_PKEY_PARAM_FIPS_KEY_CHECK
+# define OSSL_SIGNATURE_PARAM_FIPS_RSA_PSS_SALTLEN_CHECK "rsa-pss-saltlen-check"
+# define OSSL_SIGNATURE_PARAM_FIPS_SIGN_CHECK OSSL_PKEY_PARAM_FIPS_SIGN_CHECK
+# define OSSL_SIGNATURE_PARAM_FIPS_SIGN_X931_PAD_CHECK "sign-x931-pad-check"
+# define OSSL_SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE "verify-message"
+# define OSSL_SIGNATURE_PARAM_INSTANCE "instance"
+# define OSSL_SIGNATURE_PARAM_KAT "kat"
+# define OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING "message-encoding"
+# define OSSL_SIGNATURE_PARAM_MGF1_DIGEST OSSL_PKEY_PARAM_MGF1_DIGEST
+# define OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES OSSL_PKEY_PARAM_MGF1_PROPERTIES
+# define OSSL_SIGNATURE_PARAM_MU "mu"
+# define OSSL_SIGNATURE_PARAM_NONCE_TYPE "nonce-type"
+# define OSSL_SIGNATURE_PARAM_PAD_MODE OSSL_PKEY_PARAM_PAD_MODE
+# define OSSL_SIGNATURE_PARAM_PROPERTIES OSSL_PKEY_PARAM_PROPERTIES
+# define OSSL_SIGNATURE_PARAM_PSS_SALTLEN "saltlen"
+# define OSSL_SIGNATURE_PARAM_SIGNATURE "signature"
+# define OSSL_SIGNATURE_PARAM_TEST_ENTROPY "test-entropy"
+# define OSSL_SKEY_PARAM_KEY_LENGTH "key-length"
+# define OSSL_SKEY_PARAM_RAW_BYTES "raw-bytes"
+# define OSSL_STORE_PARAM_ALIAS "alias"
+# define OSSL_STORE_PARAM_DIGEST "digest"
+# define OSSL_STORE_PARAM_EXPECT "expect"
+# define OSSL_STORE_PARAM_FINGERPRINT "fingerprint"
+# define OSSL_STORE_PARAM_INPUT_TYPE "input-type"
+# define OSSL_STORE_PARAM_ISSUER "name"
+# define OSSL_STORE_PARAM_PROPERTIES "properties"
+# define OSSL_STORE_PARAM_SERIAL "serial"
+# define OSSL_STORE_PARAM_SUBJECT "subject"
+/* clang-format on */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif