Print this page
first pass


  28 
  29 #include <mechglueP.h>
  30 #include "gssapiP_generic.h"
  31 
  32 OM_uint32
  33 gss_unseal(minor_status,
  34                 context_handle,
  35                 input_message_buffer,
  36                 output_message_buffer,
  37                 conf_state,
  38                 qop_state)
  39 
  40 OM_uint32 *             minor_status;
  41 gss_ctx_id_t            context_handle;
  42 gss_buffer_t            input_message_buffer;
  43 gss_buffer_t            output_message_buffer;
  44 int *                   conf_state;
  45 int *                   qop_state;
  46 
  47 {
  48 /* EXPORT DELETE START */
  49         OM_uint32               status;
  50         gss_union_ctx_id_t      ctx;
  51         gss_mechanism           mech;
  52 
  53         if (minor_status != NULL)
  54                 *minor_status = 0;
  55 
  56         if (output_message_buffer != GSS_C_NO_BUFFER) {
  57                 output_message_buffer->length = 0;
  58                 output_message_buffer->value = NULL;
  59         }
  60 
  61         if (minor_status == NULL)
  62                 return (GSS_S_CALL_INACCESSIBLE_WRITE);
  63 
  64         if (context_handle == GSS_C_NO_CONTEXT)
  65                 return (GSS_S_CALL_INACCESSIBLE_READ | GSS_S_NO_CONTEXT);
  66 
  67         if (input_message_buffer == GSS_C_NO_BUFFER ||
  68             GSS_EMPTY_BUFFER(input_message_buffer))


  80         mech = __gss_get_mechanism(ctx->mech_type);
  81 
  82         if (mech) {
  83                 if (mech->gss_unseal) {
  84                         status = mech->gss_unseal(
  85                                                 mech->context,
  86                                                 minor_status,
  87                                                 ctx->internal_ctx_id,
  88                                                 input_message_buffer,
  89                                                 output_message_buffer,
  90                                                 conf_state,
  91                                                 qop_state);
  92                         if (status != GSS_S_COMPLETE)
  93                                 map_error(minor_status, mech);
  94                 } else
  95                         status = GSS_S_UNAVAILABLE;
  96 
  97                 return (status);
  98         }
  99 
 100 /* EXPORT DELETE END */
 101 
 102         return (GSS_S_BAD_MECH);
 103 }
 104 
 105 OM_uint32
 106 gss_unwrap(minor_status,
 107                 context_handle,
 108                 input_message_buffer,
 109                 output_message_buffer,
 110                 conf_state,
 111                 qop_state)
 112 
 113 OM_uint32 *             minor_status;
 114 const gss_ctx_id_t      context_handle;
 115 const gss_buffer_t      input_message_buffer;
 116 gss_buffer_t            output_message_buffer;
 117 int *                   conf_state;
 118 gss_qop_t *             qop_state;
 119 
 120 {
 121         return (gss_unseal(minor_status, (gss_ctx_id_t)context_handle,


  28 
  29 #include <mechglueP.h>
  30 #include "gssapiP_generic.h"
  31 
  32 OM_uint32
  33 gss_unseal(minor_status,
  34                 context_handle,
  35                 input_message_buffer,
  36                 output_message_buffer,
  37                 conf_state,
  38                 qop_state)
  39 
  40 OM_uint32 *             minor_status;
  41 gss_ctx_id_t            context_handle;
  42 gss_buffer_t            input_message_buffer;
  43 gss_buffer_t            output_message_buffer;
  44 int *                   conf_state;
  45 int *                   qop_state;
  46 
  47 {

  48         OM_uint32               status;
  49         gss_union_ctx_id_t      ctx;
  50         gss_mechanism           mech;
  51 
  52         if (minor_status != NULL)
  53                 *minor_status = 0;
  54 
  55         if (output_message_buffer != GSS_C_NO_BUFFER) {
  56                 output_message_buffer->length = 0;
  57                 output_message_buffer->value = NULL;
  58         }
  59 
  60         if (minor_status == NULL)
  61                 return (GSS_S_CALL_INACCESSIBLE_WRITE);
  62 
  63         if (context_handle == GSS_C_NO_CONTEXT)
  64                 return (GSS_S_CALL_INACCESSIBLE_READ | GSS_S_NO_CONTEXT);
  65 
  66         if (input_message_buffer == GSS_C_NO_BUFFER ||
  67             GSS_EMPTY_BUFFER(input_message_buffer))


  79         mech = __gss_get_mechanism(ctx->mech_type);
  80 
  81         if (mech) {
  82                 if (mech->gss_unseal) {
  83                         status = mech->gss_unseal(
  84                                                 mech->context,
  85                                                 minor_status,
  86                                                 ctx->internal_ctx_id,
  87                                                 input_message_buffer,
  88                                                 output_message_buffer,
  89                                                 conf_state,
  90                                                 qop_state);
  91                         if (status != GSS_S_COMPLETE)
  92                                 map_error(minor_status, mech);
  93                 } else
  94                         status = GSS_S_UNAVAILABLE;
  95 
  96                 return (status);
  97         }
  98 


  99         return (GSS_S_BAD_MECH);
 100 }
 101 
 102 OM_uint32
 103 gss_unwrap(minor_status,
 104                 context_handle,
 105                 input_message_buffer,
 106                 output_message_buffer,
 107                 conf_state,
 108                 qop_state)
 109 
 110 OM_uint32 *             minor_status;
 111 const gss_ctx_id_t      context_handle;
 112 const gss_buffer_t      input_message_buffer;
 113 gss_buffer_t            output_message_buffer;
 114 int *                   conf_state;
 115 gss_qop_t *             qop_state;
 116 
 117 {
 118         return (gss_unseal(minor_status, (gss_ctx_id_t)context_handle,