src/rx/rx_identity.c

   1 /*
   2  * Copyright (c) 2010 Your File System Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR `AS IS'' AND ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 #include <afsconfig.h>
  26 #include <afs/param.h>
  27
  28 #ifndef KERNEL
  29 # include <roken.h>
  30 #else
  31 # include "afs/sysincludes.h"
  32 # include "afsincludes.h"
  33 #endif
  34
  35 #include <rx/rx.h>
  36 #include <rx/rx_identity.h>
  37
  38 /*!
  39  * Check to see if two rx identities match
  40  *
  41  * @param a
  42  *      First identity
  43  * @param b
  44  *      Second identity
  45  * @returns
  46  *      True if a and b are identical, otherwise false
  47  */
  48 int
  49 rx_identity_match(struct rx_identity *a, struct rx_identity *b)
  50 {
  51     return (a->kind == b->kind && a->exportedName.len == b->exportedName.len
  52             && (memcmp(a->exportedName.val, b->exportedName.val,
  53                        a->exportedName.len) == 0));
  54 }
  55
  56 /*!
  57  * Populate an identity
  58  *
  59  * Populate an existing identity with copies of the data passed to the
  60  * function. This will replace (without freeing) any existing identity
  61  * contents.
  62  *
  63  * @param identity
  64  *      The identity to populate
  65  * @param kind
  66  *      The type of data contained within this identity
  67  * @param displayName
  68  *      The displayName of this identity
  69  * @param enameData
  70  *      The opaque data that represents this identity
  71  * @param enameLength
  72  *      The length of enameData
  73  */
  74
  75 void
  76 rx_identity_populate(struct rx_identity *identity, rx_identity_kind kind,
  77                      char *displayName, void *enameData, size_t enameLength)
  78 {
  79     memset(identity, 0, sizeof(struct rx_identity));
  80
  81     identity->kind = kind;
  82
  83     if (displayName) {
  84         identity->displayName = rxi_Alloc(strlen(displayName)+1);
  85         memcpy(identity->displayName, displayName, strlen(displayName)+1);
  86     }
  87
  88     rx_opaque_populate(&identity->exportedName, enameData, enameLength);
  89 }
  90
  91 /*!
  92  * Copy an identity
  93  *
  94  * Create a new identity as a copy of an existing one.
  95  *
  96  * @param from
  97  *      The identity to copy from
  98  * @return
  99  *      The new identity
 100  */
 101 struct rx_identity *
 102 rx_identity_copy(struct rx_identity *from)
 103 {
 104    return rx_identity_new(from->kind, from->displayName,
 105                           from->exportedName.val, from->exportedName.len);
 106 }
 107
 108
 109 /*!
 110  * Copy an identity's contents
 111  *
 112  * Copy the contents of one identity into another one. This will replace
 113  * (without freeing) any existing identity contents
 114  *
 115  * @param to
 116  *      The identity to copy to
 117  * @param from
 118  *      The identity to copy from
 119  */
 120
 121 void
 122 rx_identity_copyContents(struct rx_identity *to, struct rx_identity *from)
 123 {
 124     rx_identity_populate(to, from->kind, from->displayName,
 125                          from->exportedName.val, from->exportedName.len);
 126     return;
 127 }
 128
 129 /*!
 130  * Build a new identity
 131  *
 132  * Create a new identity, with copies of the data passed to this function.
 133  *
 134  * @param kind
 135  *      The type of data contained within this identity
 136  * @param displayName
 137  *      The displayName of this identity
 138  * @param enameData
 139  *      The opaque data that represents this identity
 140  * @param enameLength
 141  *      The length of enameData
 142  * @returns
 143  *      The new identity
 144  */
 145
 146 struct rx_identity *
 147 rx_identity_new(rx_identity_kind kind, char *displayName, void *enameData,
 148                 size_t enameLength)
 149 {
 150     struct rx_identity *identity;
 151
 152     identity = rxi_Alloc(sizeof(struct rx_identity));
 153     rx_identity_populate(identity, kind, displayName, enameData, enameLength);
 154
 155     return identity;
 156 }
 157
 158 /*!
 159  * Free the contents of an identity
 160  *
 161  * @param identity
 162  *      The identity to free the contents of
 163  */
 164
 165 void
 166 rx_identity_freeContents(struct rx_identity *identity)
 167 {
 168     if (identity->displayName) {
 169         rxi_Free(identity->displayName, strlen(identity->displayName));
 170         identity->displayName = NULL;
 171     }
 172
 173     rx_opaque_freeContents(&identity->exportedName);
 174 }
 175
 176 /*!
 177  * Free an identity
 178  *
 179  * @param identity
 180  *      The identity to free (passed by reference)
 181  */
 182
 183 void
 184 rx_identity_free(struct rx_identity **a_identity)
 185 {
 186     struct rx_identity *identity = *a_identity;
 187     *a_identity = NULL;
 188     if (identity == NULL) {
 189         return;
 190     }
 191     rx_identity_freeContents(identity);
 192     rxi_Free(identity, sizeof(*identity));
 193 }