trp/trp_conn.c

   1 #include <gsscon.h>
   2 #include <fcntl.h>
   3 #include <talloc.h>
   4 #include <unistd.h>
   5
   6 #include <tr_debug.h>
   7 #include <trp_internal.h>
   8
   9 /* Threading note: mutex lock is only used for protecting get_status() and set_status().
  10  * If needed, locking for other operations (notably adding/removing connections) must be managed
  11  * by whomever is holding on to the connection list. */
  12
  13 int trp_connection_lock(TRP_CONNECTION *conn)
  14 {
  15   return pthread_mutex_lock(&(conn->mutex));
  16 }
  17
  18 int trp_connection_unlock(TRP_CONNECTION *conn)
  19 {
  20   return pthread_mutex_unlock(&(conn->mutex));
  21 }
  22
  23 int trp_connection_get_fd(TRP_CONNECTION *conn)
  24 {
  25   return conn->fd;
  26 }
  27
  28 void trp_connection_set_fd(TRP_CONNECTION *conn, int fd)
  29 {
  30   conn->fd=fd;
  31 }
  32
  33 TR_NAME *trp_connection_get_peer(TRP_CONNECTION *conn)
  34 {
  35   return conn->peer;
  36 }
  37
  38 void trp_connection_set_peer(TRP_CONNECTION *conn, TR_NAME *peer)
  39 {
  40   conn->peer=peer;
  41 }
  42
  43 TR_NAME *trp_connection_get_gssname(TRP_CONNECTION *conn)
  44 {
  45   return conn->gssname;
  46 }
  47
  48 void trp_connection_set_gssname(TRP_CONNECTION *conn, TR_NAME *gssname)
  49 {
  50   conn->gssname=gssname;
  51 }
  52
  53 gss_ctx_id_t *trp_connection_get_gssctx(TRP_CONNECTION *conn)
  54 {
  55   return conn->gssctx;
  56 }
  57
  58 void trp_connection_set_gssctx(TRP_CONNECTION *conn, gss_ctx_id_t *gssctx)
  59 {
  60   conn->gssctx=gssctx;
  61 }
  62
  63 TRP_CONNECTION_STATUS trp_connection_get_status(TRP_CONNECTION *conn)
  64 {
  65   TRP_CONNECTION_STATUS status;
  66   trp_connection_lock(conn);
  67   status=conn->status;
  68   trp_connection_unlock(conn);
  69   return status;
  70 }
  71
  72 static void trp_connection_set_status(TRP_CONNECTION *conn, TRP_CONNECTION_STATUS status)
  73 {
  74   trp_connection_lock(conn);
  75   conn->status=status;
  76   trp_connection_unlock(conn);
  77 }
  78
  79 pthread_t *trp_connection_get_thread(TRP_CONNECTION *conn)
  80 {
  81   return conn->thread;
  82 }
  83
  84 void trp_connection_set_thread(TRP_CONNECTION *conn, pthread_t *thread)
  85 {
  86   conn->thread=thread;
  87 }
  88
  89 TRP_CONNECTION *trp_connection_get_next(TRP_CONNECTION *conn)
  90 {
  91   return conn->next;
  92 }
  93
  94 static void trp_connection_set_next(TRP_CONNECTION *conn, TRP_CONNECTION *next)
  95 {
  96   conn->next=next;
  97 }
  98
  99 /* Ok to call more than once; guarantees connection no longer in the list. Does not free removed element.
 100  * Returns handle to new list, you must replace your old handle on the list with this.  */
 101 TRP_CONNECTION *trp_connection_remove(TRP_CONNECTION *conn, TRP_CONNECTION *remove)
 102 {
 103   TRP_CONNECTION *cur=conn;
 104   TRP_CONNECTION *last=NULL;
 105
 106   if (cur==NULL)
 107     return NULL;
 108
 109   /* first element is a special case */
 110   if (cur==remove) {
 111     conn=trp_connection_get_next(cur); /* advance list head */
 112   } else {
 113     /* it was not the first element */
 114     last=cur;
 115     cur=trp_connection_get_next(cur);
 116     while (cur!=NULL) {
 117       if (cur==remove) {
 118         trp_connection_set_next(last, trp_connection_get_next(cur));
 119         break;
 120       }
 121       last=cur;
 122       cur=trp_connection_get_next(cur);
 123     }
 124   }
 125   return conn;
 126 }
 127
 128 static TRP_CONNECTION *trp_connection_get_tail(TRP_CONNECTION *conn)
 129 {
 130   while((conn!=NULL)&&(trp_connection_get_next(conn)!=NULL))
 131     conn=trp_connection_get_next(conn);
 132   return conn;
 133 }
 134
 135 void trp_connection_append(TRP_CONNECTION *conn, TRP_CONNECTION *new)
 136 {
 137   trp_connection_set_next(trp_connection_get_tail(conn), new);
 138 }
 139
 140 static void trp_connection_mutex_init(TRP_CONNECTION *conn)
 141 {
 142   pthread_mutex_init(&(conn->mutex), NULL);
 143 }
 144
 145 /* talloc destructor for a connection: ensures connection is closed, memory freed */
 146 static int trp_connection_destructor(void *object)
 147 {
 148   TRP_CONNECTION *conn=talloc_get_type_abort(object, TRP_CONNECTION); /* aborts on wrong type */
 149   if ((trp_connection_get_status(conn)!=TRP_CONNECTION_DOWN)
 150      && (trp_connection_get_fd(conn)!=-1))
 151     close(trp_connection_get_fd(conn));
 152   if (conn->peer!=NULL)
 153     tr_free_name(conn->peer);
 154   if (conn->gssname!=NULL)
 155     tr_free_name(conn->gssname);
 156   return 0;
 157 }
 158
 159 TRP_CONNECTION *trp_connection_new(TALLOC_CTX *mem_ctx)
 160 {
 161   TRP_CONNECTION *new_conn=talloc(mem_ctx, TRP_CONNECTION);
 162   gss_ctx_id_t *gssctx=NULL;
 163   pthread_t *thread=NULL;
 164
 165
 166   if (new_conn != NULL) {
 167     trp_connection_set_next(new_conn, NULL);
 168     trp_connection_set_fd(new_conn, -1);
 169     trp_connection_set_peer(new_conn, NULL);
 170     trp_connection_set_gssname(new_conn, NULL);
 171     trp_connection_mutex_init(new_conn);
 172     trp_connection_set_status(new_conn, TRP_CONNECTION_DOWN);
 173     thread=talloc(new_conn, pthread_t);
 174     gssctx=talloc(new_conn, gss_ctx_id_t);
 175     if (gssctx==NULL) {
 176       talloc_free(new_conn);
 177       return NULL;
 178     }
 179     trp_connection_set_gssctx(new_conn, gssctx);
 180     if (thread==NULL) {
 181       talloc_free(new_conn);
 182       return NULL;
 183     }
 184     trp_connection_set_thread(new_conn, thread);
 185     talloc_set_destructor((void *)new_conn, trp_connection_destructor);
 186   }
 187   return new_conn;
 188 }
 189
 190 void trp_connection_free(TRP_CONNECTION *conn)
 191 {
 192   talloc_free(conn);
 193 }
 194
 195 void trp_connection_close(TRP_CONNECTION *conn)
 196 {
 197   close(trp_connection_get_fd(conn));
 198   trp_connection_set_fd(conn, -1);
 199   trp_connection_set_status(conn, TRP_CONNECTION_DOWN);
 200 }
 201
 202 /* returns 0 on authorization success, 1 on failure, or -1 in case of error */
 203 int trp_connection_auth(TRP_CONNECTION *conn, TRP_AUTH_FUNC auth_callback, void *callback_data)
 204 {
 205   int rc = 0;
 206   int auth, autherr = 0;
 207   gss_buffer_desc nameBuffer = {0, NULL};
 208   gss_ctx_id_t *gssctx=trp_connection_get_gssctx(conn);
 209
 210   /* TODO: shouldn't really peek into TR_NAME... */
 211   nameBuffer.length = trp_connection_get_gssname(conn)->len;
 212   nameBuffer.value = trp_connection_get_gssname(conn)->buf;
 213
 214   tr_debug("trp_connection_auth: beginning passive authentication");
 215   rc = gsscon_passive_authenticate(trp_connection_get_fd(conn), nameBuffer, gssctx, auth_callback, callback_data);
 216   gss_release_buffer(NULL, &nameBuffer);
 217   if (rc!=0) {
 218     tr_debug("trp_connection_auth: Error from gsscon_passive_authenticate(), rc = 0x%08X.", rc);
 219     return -1;
 220   }
 221
 222   tr_debug("trp_connection_auth: beginning second stage authentication");
 223   if (rc = gsscon_authorize(*gssctx, &auth, &autherr)) {
 224     tr_debug("trp_connection_auth: Error from gsscon_authorize, rc = %d, autherr = %d.",
 225              rc, autherr);
 226     return -1;
 227   }
 228
 229   if (auth)
 230     tr_debug("trp_connection_auth: Connection authenticated, fd = %d.", trp_connection_get_fd(conn));
 231   else
 232     tr_debug("trp_connection_auth: Authentication failed, fd = %d.", trp_connection_get_fd(conn));
 233
 234   return !auth;
 235 }
 236
 237 /* Accept connection */
 238 TRP_CONNECTION *trp_connection_accept(TALLOC_CTX *mem_ctx, int listen, TR_NAME *gssname)
 239 {
 240   int conn_fd=-1;
 241   TRP_CONNECTION *conn=NULL;
 242
 243   conn_fd = accept(listen, NULL, NULL);
 244
 245   if (0 > conn_fd) {
 246     tr_notice("trp_connection_accept: accept() returned error.");
 247     return NULL;
 248   }
 249   conn=trp_connection_new(mem_ctx);
 250   trp_connection_set_fd(conn, conn_fd);
 251   trp_connection_set_gssname(conn, gssname);
 252   trp_connection_set_status(conn, TRP_CONNECTION_UP);
 253   return conn;
 254 }
 255
 256 /* Initiate connection */
 257 TRP_RC trp_connection_initiate(TRP_CONNECTION *conn, const char *server, unsigned int port)
 258 {
 259   int err = 0;
 260   int fd=-1;
 261   unsigned int use_port=0;
 262
 263   if (0 == port)
 264     use_port = TRP_PORT;
 265   else
 266     use_port = port;
 267
 268   if (conn==NULL) {
 269     tr_err("trp_connection_initiate: null TRP_CONNECTION");
 270     return TRP_BADARG;
 271   }
 272
 273   tr_debug("trp_connection_initiate: opening GSS connection to %s:%d",
 274            server,
 275            use_port);
 276   err = gsscon_connect(server,
 277                        use_port,
 278                        "trustrouter",
 279                       &fd,
 280                        trp_connection_get_gssctx(conn));
 281   tr_debug("trp_connection_initiate: connected");
 282
 283   if (err) {
 284     talloc_free(conn);
 285     return TRP_ERROR;
 286   } else {
 287     trp_connection_set_fd(conn, fd);
 288     trp_connection_set_peer(conn, tr_new_name(server));
 289     trp_connection_set_status(conn, TRP_CONNECTION_UP);
 290     return TRP_SUCCESS;
 291   }
 292 }