tid/tid_req.c

   1 /*
   2  * Copyright (c) 2012, JANET(UK)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * 3. Neither the name of JANET(UK) nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  31  * OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  */
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <assert.h>
  38 #include <talloc.h>
  39
  40 #include <tid_internal.h>
  41 #include <tr_debug.h>
  42
  43 #include <jansson.h>
  44
  45 static int destroy_tid_req(TID_REQ *req)
  46 {
  47   if (req->json_references)
  48     json_decref(req->json_references);
  49   return 0;
  50 }
  51
  52 TID_REQ *tid_req_new()
  53 {
  54   TID_REQ *req = talloc_zero(NULL, TID_REQ);
  55   if(!req)
  56     return NULL;
  57   talloc_set_destructor(req, destroy_tid_req);
  58   req->json_references = json_array();
  59   assert(req->json_references);
  60   req->conn = -1;
  61   return req;
  62 }
  63
  64 TID_REQ *tid_req_get_next_req(TID_REQ *req)
  65 {
  66   return(req->next_req);
  67 }
  68
  69 void tid_req_set_next_req(TID_REQ *req, TID_REQ *next_req)
  70 {
  71   req->next_req = next_req;
  72 }
  73
  74 int tid_req_get_resp_sent(TID_REQ *req)
  75 {
  76   return(req->resp_sent);
  77 }
  78
  79 void tid_req_set_resp_sent(TID_REQ *req, int resp_sent)
  80 {
  81   req->resp_sent = resp_sent;
  82 }
  83
  84 int tid_req_get_conn(TID_REQ *req)
  85 {
  86   return(req->conn);
  87 }
  88
  89 void tid_req_set_conn(TID_REQ *req, int conn)
  90 {
  91   req->conn = conn;
  92 }
  93
  94 gss_ctx_id_t tid_req_get_gssctx(TID_REQ *req)
  95 {
  96   return(req->gssctx);
  97 }
  98
  99 void tid_req_set_gssctx(TID_REQ *req, gss_ctx_id_t gssctx)
 100 {
 101   req->gssctx = gssctx;
 102 }
 103
 104 int tid_req_get_resp_rcvd(TID_REQ *req)
 105 {
 106   return(req->resp_rcvd);
 107 }
 108
 109 void tid_req_set_resp_rcvd(TID_REQ *req, int resp_rcvd)
 110 {
 111   req->resp_rcvd = resp_rcvd;
 112 }
 113
 114 TR_NAME *tid_req_get_rp_realm(TID_REQ *req)
 115 {
 116   return(req->rp_realm);
 117 }
 118
 119 void tid_req_set_rp_realm(TID_REQ *req, TR_NAME *rp_realm)
 120 {
 121   req->rp_realm = rp_realm;
 122 }
 123
 124 TR_NAME *tid_req_get_realm(TID_REQ *req)
 125 {
 126   return(req->realm);
 127 }
 128
 129 void tid_req_set_realm(TID_REQ *req, TR_NAME *realm)
 130 {
 131   req->realm = realm;
 132 }
 133
 134 TR_NAME *tid_req_get_comm(TID_REQ *req)
 135 {
 136   return(req->comm);
 137 }
 138
 139 void tid_req_set_comm(TID_REQ *req, TR_NAME *comm)
 140 {
 141   req->comm = comm;
 142 }
 143
 144 TR_NAME *tid_req_get_orig_coi(TID_REQ *req)
 145 {
 146   return(req->orig_coi);
 147 }
 148
 149 void tid_req_set_rp_orig_coi(TID_REQ *req, TR_NAME *orig_coi)
 150 {
 151   req->orig_coi = orig_coi;
 152 }
 153
 154 TIDC_RESP_FUNC *tid_req_get_resp_func(TID_REQ *req)
 155 {
 156   return(req->resp_func);
 157 }
 158
 159 void tid_req_set_resp_func(TID_REQ *req, TIDC_RESP_FUNC *resp_func)
 160 {
 161   req->resp_func = resp_func;
 162 }
 163
 164 void *tid_req_get_cookie(TID_REQ *req)
 165 {
 166   return(req->cookie);
 167 }
 168
 169 void tid_req_set_cookie(TID_REQ *req, void *cookie)
 170 {
 171   req->cookie = cookie;
 172 }
 173
 174 TID_REQ *tid_dup_req (TID_REQ *orig_req)
 175 {
 176   TID_REQ *new_req = NULL;
 177
 178   if (NULL == (new_req = malloc(sizeof(TID_REQ)))) {
 179     tr_crit("tid_dup_req: Can't allocated duplicate request.");
 180     return NULL;
 181   }
 182
 183   /* Memcpy for flat fields, not valid until names are duped. */
 184   memcpy(new_req, orig_req, sizeof(TID_REQ));
 185   json_incref(new_req->json_references);
 186
 187   if ((NULL == (new_req->rp_realm = tr_dup_name(orig_req->rp_realm))) ||
 188       (NULL == (new_req->realm = tr_dup_name(orig_req->realm))) ||
 189       (NULL == (new_req->comm = tr_dup_name(orig_req->comm)))) {
 190         tr_crit("tid_dup_req: Can't duplicate request (names).");
 191   }
 192
 193   if (orig_req->orig_coi) {
 194     if (NULL == (new_req->orig_coi = tr_dup_name(orig_req->orig_coi))) {
 195       tr_crit("tid_dup_req: Can't duplicate request (orig_coi).");
 196     }
 197   }
 198
 199   return new_req;
 200 }
 201
 202
 203 void tid_req_cleanup_json( TID_REQ *req, json_t *ref)
 204 {
 205   (void) json_array_append_new(req->json_references, ref);
 206 }
 207
 208 void tid_req_free(TID_REQ *req)
 209 {
 210   talloc_free(req);
 211 }
 212
 213
 214 void tid_srvr_get_address(const TID_SRVR_BLK *blk,
 215                           const struct sockaddr **out_addr,
 216                           size_t *out_len)
 217 {
 218   struct sockaddr_in *sa = NULL;
 219     assert(blk);
 220     sa = talloc_zero(blk, struct sockaddr_in);
 221     sa->sin_family = AF_INET;
 222     sa->sin_addr = blk->aaa_server_addr;
 223     sa->sin_port = htons(2083);
 224     *out_addr = (struct sockaddr *) sa;
 225     *out_len = sizeof( struct sockaddr_in);
 226 }
 227
 228 DH *tid_srvr_get_dh( TID_SRVR_BLK *blk)
 229 {
 230   assert(blk);
 231   return blk->aaa_server_dh;
 232 }
 233
 234 const TR_NAME *tid_srvr_get_key_name(
 235                                     const TID_SRVR_BLK *blk)
 236 {
 237   assert(blk);
 238   return blk->key_name;
 239 }