Print this page
3882 remove xmod & friends


  66 }
  67 
  68 /*ARGSUSED*/
  69 OM_uint32
  70 gss_seal(minor_status,
  71                 context_handle,
  72                 conf_req_flag,
  73                 qop_req,
  74                 input_message_buffer,
  75                 conf_state,
  76                 output_message_buffer)
  77 
  78 OM_uint32 *                     minor_status;
  79 gss_ctx_id_t                    context_handle;
  80 int                             conf_req_flag;
  81 int                             qop_req;
  82 gss_buffer_t                    input_message_buffer;
  83 int *                           conf_state;
  84 gss_buffer_t                    output_message_buffer;
  85 {
  86 /* EXPORT DELETE START */
  87 
  88         OM_uint32               status;
  89         gss_union_ctx_id_t      ctx;
  90         gss_mechanism           mech;
  91 
  92         status = val_seal_args(minor_status,
  93                         context_handle,
  94                         input_message_buffer,
  95                         output_message_buffer);
  96         if (status != GSS_S_COMPLETE)
  97                 return (status);
  98 
  99         /*
 100          * select the approprate underlying mechanism routine and
 101          * call it.
 102          */
 103 
 104         ctx = (gss_union_ctx_id_t) context_handle;
 105         mech = __gss_get_mechanism(ctx->mech_type);
 106 
 107         if (mech) {
 108                 if (mech->gss_seal) {
 109                         status = mech->gss_seal(
 110                                                 mech->context,
 111                                                 minor_status,
 112                                                 ctx->internal_ctx_id,
 113                                                 conf_req_flag,
 114                                                 qop_req,
 115                                                 input_message_buffer,
 116                                                 conf_state,
 117                                                 output_message_buffer);
 118                         if (status != GSS_S_COMPLETE)
 119                                 map_error(minor_status, mech);
 120                 } else
 121                         status = GSS_S_UNAVAILABLE;
 122 
 123                 return (status);
 124         }
 125 /* EXPORT DELETE END */
 126 
 127         return (GSS_S_BAD_MECH);
 128 }
 129 
 130 OM_uint32
 131 gss_wrap(minor_status,
 132                 context_handle,
 133                 conf_req_flag,
 134                 qop_req,
 135                 input_message_buffer,
 136                 conf_state,
 137                 output_message_buffer)
 138 
 139 OM_uint32 *                     minor_status;
 140 const gss_ctx_id_t              context_handle;
 141 int                             conf_req_flag;
 142 gss_qop_t                       qop_req;
 143 const gss_buffer_t              input_message_buffer;
 144 int *                           conf_state;
 145 gss_buffer_t                    output_message_buffer;




  66 }
  67 
  68 /*ARGSUSED*/
  69 OM_uint32
  70 gss_seal(minor_status,
  71                 context_handle,
  72                 conf_req_flag,
  73                 qop_req,
  74                 input_message_buffer,
  75                 conf_state,
  76                 output_message_buffer)
  77 
  78 OM_uint32 *                     minor_status;
  79 gss_ctx_id_t                    context_handle;
  80 int                             conf_req_flag;
  81 int                             qop_req;
  82 gss_buffer_t                    input_message_buffer;
  83 int *                           conf_state;
  84 gss_buffer_t                    output_message_buffer;
  85 {


  86         OM_uint32               status;
  87         gss_union_ctx_id_t      ctx;
  88         gss_mechanism           mech;
  89 
  90         status = val_seal_args(minor_status,
  91                         context_handle,
  92                         input_message_buffer,
  93                         output_message_buffer);
  94         if (status != GSS_S_COMPLETE)
  95                 return (status);
  96 
  97         /*
  98          * select the approprate underlying mechanism routine and
  99          * call it.
 100          */
 101 
 102         ctx = (gss_union_ctx_id_t) context_handle;
 103         mech = __gss_get_mechanism(ctx->mech_type);
 104 
 105         if (mech) {
 106                 if (mech->gss_seal) {
 107                         status = mech->gss_seal(
 108                                                 mech->context,
 109                                                 minor_status,
 110                                                 ctx->internal_ctx_id,
 111                                                 conf_req_flag,
 112                                                 qop_req,
 113                                                 input_message_buffer,
 114                                                 conf_state,
 115                                                 output_message_buffer);
 116                         if (status != GSS_S_COMPLETE)
 117                                 map_error(minor_status, mech);
 118                 } else
 119                         status = GSS_S_UNAVAILABLE;
 120 
 121                 return (status);
 122         }

 123 
 124         return (GSS_S_BAD_MECH);
 125 }
 126 
 127 OM_uint32
 128 gss_wrap(minor_status,
 129                 context_handle,
 130                 conf_req_flag,
 131                 qop_req,
 132                 input_message_buffer,
 133                 conf_state,
 134                 output_message_buffer)
 135 
 136 OM_uint32 *                     minor_status;
 137 const gss_ctx_id_t              context_handle;
 138 int                             conf_req_flag;
 139 gss_qop_t                       qop_req;
 140 const gss_buffer_t              input_message_buffer;
 141 int *                           conf_state;
 142 gss_buffer_t                    output_message_buffer;