Update copyright year

[thirdparty/openssl.git] / doc / internal / man3 / evp_generic_fetch.pod

diff --git a/doc/internal/man3/evp_generic_fetch.pod b/doc/internal/man3/evp_generic_fetch.pod
index c4734394bb5770c896d88d4f21882374272bcf4d..243f6c952fb61e4ac05ed45b6d7e977d3e46ba88 100644 (file)
--- a/doc/internal/man3/evp_generic_fetch.pod
+++ b/doc/internal/man3/evp_generic_fetch.pod
@@ -10,7 +10,7 @@ evp_generic_fetch, evp_generic_fetch_by_number
  /* Only for EVP source */
  #include "evp_local.h"
 
- void *evp_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
+ void *evp_generic_fetch(OSSL_LIB_CTX *libctx, int operation_id,
                          const char *name, const char *properties,
                          void *(*new_method)(int name_id,
                                              const OSSL_DISPATCH *fns,
@@ -20,7 +20,7 @@ evp_generic_fetch, evp_generic_fetch_by_number
                          int (*up_ref_method)(void *),
                          void (*free_method)(void *));
 
- void *evp_generic_fetch_by_number(OPENSSL_CTX *ctx, int operation_id,
+ void *evp_generic_fetch_by_number(OSSL_LIB_CTX *ctx, int operation_id,
                                    int name_id, const char *properties,
                                    void *(*new_method)(int name_id,
                                                        const OSSL_DISPATCH *fns,
@@ -38,7 +38,7 @@ it to create an EVP method with the help of the functions
 I<new_method>, I<up_ref_method>, and I<free_method>.
 
 evp_generic_fetch_by_number() does the same thing as evp_generic_fetch(), 
-but takes a I<name_id> instead of a number.
+but takes a numeric I<name_id> instead of a name.
 I<name_id> must always be nonzero; as a matter of fact, it being zero
 is considered a programming error.
 This is meant to be used when one method needs to fetch an associated
@@ -78,22 +78,23 @@ This is a short example of the fictitious EVP API and operation called
 B<EVP_FOO>.
 
 To begin with, let's assume something like this in
-F<include/openssl/core_numbers.h>:
-
-    #define OSSL_OP_FOO                         100
-
-    #define OSSL_OP_FOO_NEWCTX_FUNC            2001
-    #define OSSL_OP_FOO_INIT                   2002
-    #define OSSL_OP_FOO_OPERATE                2003
-    #define OSSL_OP_FOO_CLEANCTX_FUNC          2004
-    #define OSSL_OP_FOO_FREECTX_FUNC           2005
-    OSSL_CORE_MAKE_FUNC(void *,OP_foo_newctx,(void))
-    OSSL_CORE_MAKE_FUNC(int,OP_foo_init,(void *vctx))
-    OSSL_CORE_MAKE_FUNC(int,OP_foo_operate,(void *vctx,
-                                            unsigned char *out, size_t *out_l,
-                                            unsigned char *in, size_t in_l))
-    OSSL_CORE_MAKE_FUNC(void,OP_foo_cleanctx,(void *vctx))
-    OSSL_CORE_MAKE_FUNC(void,OP_foo_freectx,(void *vctx))
+F<include/openssl/core_dispatch.h>:
+
+    #define OSSL_OP_FOO                           100
+
+    #define OSSL_FUNC_FOO_NEWCTX_FUNC            2001
+    #define OSSL_FUNC_FOO_INIT                   2002
+    #define OSSL_FUNC_FOO_OPERATE                2003
+    #define OSSL_FUNC_FOO_CLEANCTX_FUNC          2004
+    #define OSSL_FUNC_FOO_FREECTX_FUNC           2005
+
+    OSSL_CORE_MAKE_FUNC(void *, foo_newctx, (void))
+    OSSL_CORE_MAKE_FUNC(int, foo_init, (void *vctx))
+    OSSL_CORE_MAKE_FUNC(int, foo_operate, (void *vctx,
+                                           unsigned char *out, size_t *out_l,
+                                           unsigned char *in, size_t in_l))
+    OSSL_CORE_MAKE_FUNC(void, foo_cleanctx, (void *vctx))
+    OSSL_CORE_MAKE_FUNC(void, foo_freectx, (void *vctx))
 
 And here's the implementation of the FOO method fetcher:
 
@@ -102,21 +103,21 @@ And here's the implementation of the FOO method fetcher:
         OSSL_PROVIDER *prov;
         int name_id;
        CRYPTO_REF_COUNT refcnt;
-        OSSL_OP_foo_newctx_fn *newctx;
-        OSSL_OP_foo_init_fn *init;
-        OSSL_OP_foo_operate_fn *operate;
-        OSSL_OP_foo_cleanctx_fn *cleanctx;
-        OSSL_OP_foo_freectx_fn *freectx;
+        OSSL_FUNC_foo_newctx_fn *newctx;
+        OSSL_FUNC_foo_init_fn *init;
+        OSSL_FUNC_foo_operate_fn *operate;
+        OSSL_FUNC_foo_cleanctx_fn *cleanctx;
+        OSSL_FUNC_foo_freectx_fn *freectx;
     };
 
     /*
      * In this example, we have a public method creator and destructor.
      * It's not absolutely necessary, but is in the spirit of OpenSSL.
      */
-    EVP_FOO *EVP_FOO_meth_from_dispatch(int name_id,
-                                        const OSSL_DISPATCH *fns,
-                                        OSSL_PROVIDER *prov,
-                                        void *data)
+    EVP_FOO *EVP_FOO_meth_from_algorithm(int name_id,
+                                         const OSSL_DISPATCH *fns,
+                                         OSSL_PROVIDER *prov,
+                                         void *data)
     {
         EVP_FOO *foo = NULL;
 
@@ -127,20 +128,20 @@ And here's the implementation of the FOO method fetcher:
 
         for (; fns->function_id != 0; fns++) {
             switch (fns->function_id) {
-            case OSSL_OP_FOO_NEWCTX_FUNC:
-                foo->newctx = OSSL_get_OP_foo_newctx(fns);
+            case OSSL_FUNC_FOO_NEWCTX:
+                foo->newctx = OSSL_FUNC_foo_newctx(fns);
                 break;
-            case OSSL_OP_FOO_INIT:
-                foo->init = OSSL_get_OP_foo_init(fns);
+            case OSSL_FUNC_FOO_INIT:
+                foo->init = OSSL_FUNC_foo_init(fns);
                 break;
-            case OSSL_OP_FOO_OPERATE:
-                foo->operate = OSSL_get_OP_foo_operate(fns);
+            case OSSL_FUNC_FOO_OPERATE:
+                foo->operate = OSSL_FUNC_foo_operate(fns);
                 break;
-            case OSSL_OP_FOO_CLEANCTX_FUNC:
-                foo->cleanctx = OSSL_get_OP_foo_cleanctx(fns);
+            case OSSL_FUNC_FOO_CLEANCTX:
+                foo->cleanctx = OSSL_FUNC_foo_cleanctx(fns);
                 break;
-            case OSSL_OP_FOO_FREECTX_FUNC:
-                foo->freectx = OSSL_get_OP_foo_freectx(fns);
+            case OSSL_FUNC_FOO_FREECTX:
+                foo->freectx = OSSL_FUNC_foo_freectx(fns);
                 break;
             }
         }
@@ -161,10 +162,10 @@ And here's the implementation of the FOO method fetcher:
         }
     }
 
-    static void *foo_from_dispatch(const OSSL_DISPATCH *fns,
-                                   OSSL_PROVIDER *prov)
+    static void *foo_from_algorithm(const OSSL_DISPATCH *fns,
+                                    OSSL_PROVIDER *prov)
     {
-        return EVP_FOO_meth_from_dispatch(fns, prov);
+        return EVP_FOO_meth_from_algorithm(fns, prov);
     }
 
     static int foo_up_ref(void *vfoo)
@@ -181,13 +182,13 @@ And here's the implementation of the FOO method fetcher:
         EVP_FOO_meth_free(vfoo);
     }
 
-    EVP_FOO *EVP_FOO_fetch(OPENSSL_CTX *ctx,
+    EVP_FOO *EVP_FOO_fetch(OSSL_LIB_CTX *ctx,
                            const char *name,
                            const char *properties)
     {
         EVP_FOO *foo =
             evp_generic_fetch(ctx, OSSL_OP_FOO, name, properties,
-                              foo_from_dispatch, foo_up_ref, foo_free);
+                              foo_from_algorithm, foo_up_ref, foo_free);
 
         /*
          * If this method exists in legacy form, with a constant NID for the
@@ -252,7 +253,7 @@ And finally, the library functions:
 
 =head1 SEE ALSO
 
-L<ossl_method_construct>
+L<ossl_method_construct(3)>
 
 =head1 HISTORY
 
@@ -260,7 +261,7 @@ The functions described here were all added in OpenSSL 3.0.
 
 =head1 COPYRIGHT
 
-Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
+Copyright 2019-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