1 files changed, 138 insertions, 131 deletions

diff --git a/src/identity-token/identity-token.c b/src/identity-token/identity-token.c
index dc0154c21..a9f210b14 100644
--- a/src/identity-token/identity-token.c
+++ b/src/identity-token/identity-token.c
@@ -26,7 +26,7 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_signatures.h"
-#include "identity-token.h"
+#include "gnunet_identity_provider_lib.h"
 #include <jansson.h>
 
 
@@ -189,13 +189,22 @@ encrypt_str_ecdhe (const char *plaintext,
  * @param id the JSON API resource id
  * @return a new JSON API resource or NULL on error.
  */
-struct IdentityToken*
-identity_token_create (const char* issuer,
-                       const char* audience)
+struct GNUNET_IDENTITY_PROVIDER_Token*
+GNUNET_IDENTITY_PROVIDER_token_create (const struct GNUNET_CRYPTO_EcdsaPublicKey* iss,
+                                       const struct GNUNET_CRYPTO_EcdsaPublicKey* aud)
 {
-  struct IdentityToken *token;
+  struct GNUNET_IDENTITY_PROVIDER_Token *token;
+  char* audience;
+  char* issuer;
 
-  token = GNUNET_malloc (sizeof (struct IdentityToken));
+  issuer = GNUNET_STRINGS_data_to_string_alloc (iss,
+                                                sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
+  audience = GNUNET_STRINGS_data_to_string_alloc (aud,
+                                                  sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
+
+
+
+  token = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_PROVIDER_Token));
 
   token->header = json_object();
   token->payload = json_object();
@@ -206,16 +215,14 @@ identity_token_create (const char* issuer,
   json_object_set_new (token->payload, "iss", json_string (issuer));
   json_object_set_new (token->payload, "aud", json_string (audience));
 
-  GNUNET_STRINGS_string_to_data  (audience,
-                                  strlen (audience),
-                                  &token->aud_key,
-                                  sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
-
+  token->aud_key = *aud;
+  GNUNET_free (issuer);
+  GNUNET_free (audience);
   return token;
 }
 
 void
-identity_token_destroy (struct IdentityToken *token)
+GNUNET_IDENTITY_PROVIDER_token_destroy (struct GNUNET_IDENTITY_PROVIDER_Token *token)
 {
   json_decref (token->header);
   json_decref (token->payload);
@@ -223,9 +230,9 @@ identity_token_destroy (struct IdentityToken *token)
 }
 
 void
-identity_token_add_attr (const struct IdentityToken *token,
-                         const char* key,
-                         const char* value)
+GNUNET_IDENTITY_PROVIDER_token_add_attr (const struct GNUNET_IDENTITY_PROVIDER_Token *token,
+                                         const char* key,
+                                         const char* value)
 {
   GNUNET_assert (NULL != token);
   GNUNET_assert (NULL != token->payload);
@@ -234,9 +241,9 @@ identity_token_add_attr (const struct IdentityToken *token,
 }
 
 void
-identity_token_add_json (const struct IdentityToken *token,
-                         const char* key,
-                         json_t* value)
+GNUNET_IDENTITY_PROVIDER_token_add_json (const struct GNUNET_IDENTITY_PROVIDER_Token *token,
+                                         const char* key,
+                                         json_t* value)
 {
   GNUNET_assert (NULL != token);
   GNUNET_assert (NULL != token->payload);
@@ -246,10 +253,10 @@ identity_token_add_json (const struct IdentityToken *token,
 
 
 int
-identity_token_parse2 (const char* raw_data,
-                       const struct GNUNET_CRYPTO_EcdhePrivateKey *priv_key,
-                       const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key,
-                       struct IdentityToken **result)
+GNUNET_IDENTITY_PROVIDER_token_parse2 (const char* raw_data,
+                                       const struct GNUNET_CRYPTO_EcdhePrivateKey *priv_key,
+                                       const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key,
+                                       struct GNUNET_IDENTITY_PROVIDER_Token **result)
 {
   char *enc_token_str;
   char *tmp_buf;
@@ -292,7 +299,7 @@ identity_token_parse2 (const char* raw_data,
   //TODO signature
 
 
-  *result = GNUNET_malloc (sizeof (struct IdentityToken));
+  *result = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_PROVIDER_Token));
   (*result)->aud_key =  *aud_key;
   (*result)->header = json_loads (header, JSON_DECODE_ANY, &err_json);
   (*result)->payload = json_loads (payload, JSON_DECODE_ANY, &err_json);
@@ -305,9 +312,9 @@ identity_token_parse2 (const char* raw_data,
 }
 
 int
-identity_token_parse (const char* raw_data,
-                      const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
-                      struct IdentityToken **result)
+GNUNET_IDENTITY_PROVIDER_token_parse (const char* raw_data,
+                                      const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
+                                      struct GNUNET_IDENTITY_PROVIDER_Token **result)
 {
   char *ecdh_pubkey_str;
   char *enc_token_str;
@@ -356,7 +363,7 @@ identity_token_parse (const char* raw_data,
   //TODO signature and aud key
 
 
-  *result = GNUNET_malloc (sizeof (struct IdentityToken));
+  *result = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_PROVIDER_Token));
   (*result)->header = json_loads (header, JSON_DECODE_ANY, &err_json);
   (*result)->payload = json_loads (payload, JSON_DECODE_ANY, &err_json);
   GNUNET_free (enc_token);
@@ -368,9 +375,9 @@ identity_token_parse (const char* raw_data,
 }
 
 int
-identity_token_to_string (const struct IdentityToken *token,
-                          const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
-                          char **result)
+GNUNET_IDENTITY_PROVIDER_token_to_string (const struct GNUNET_IDENTITY_PROVIDER_Token *token,
+                                          const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
+                                          char **result)
 {
   char *payload_str;
   char *header_str;
@@ -436,10 +443,10 @@ identity_token_to_string (const struct IdentityToken *token,
 }
 
 int
-identity_token_serialize (const struct IdentityToken *token,
-                          const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
-                          struct GNUNET_CRYPTO_EcdhePrivateKey **ecdh_privkey,
-                          char **result)
+GNUNET_IDENTITY_PROVIDER_token_serialize (const struct GNUNET_IDENTITY_PROVIDER_Token *token,
+                                          const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
+                                          struct GNUNET_CRYPTO_EcdhePrivateKey **ecdh_privkey,
+                                          char **result)
 {
   char *token_str;
   char *enc_token;
@@ -447,9 +454,9 @@ identity_token_serialize (const struct IdentityToken *token,
   char *enc_token_base64;
   struct GNUNET_CRYPTO_EcdhePublicKey ecdh_pubkey;
 
-  GNUNET_assert (GNUNET_OK == identity_token_to_string (token,
-                                                        priv_key,
-                                                        &token_str));
+  GNUNET_assert (GNUNET_OK == GNUNET_IDENTITY_PROVIDER_token_to_string (token,
+                                                                        priv_key,
+                                                                        &token_str));
 
   GNUNET_assert (GNUNET_OK == encrypt_str_ecdhe (token_str,
                                                  &token->aud_key,
@@ -469,14 +476,14 @@ identity_token_serialize (const struct IdentityToken *token,
   return GNUNET_OK;
 }
 
-struct IdentityTokenCodePayload*
-identity_token_code_payload_create (const char* nonce,
-                                    const struct GNUNET_CRYPTO_EcdsaPublicKey* identity_pkey,
-                                    const char* lbl_str)
+struct GNUNET_IDENTITY_PROVIDER_TokenTicketPayload*
+GNUNET_IDENTITY_PROVIDER_ticket_payload_create (const char* nonce,
+                                                const struct GNUNET_CRYPTO_EcdsaPublicKey* identity_pkey,
+                                                const char* lbl_str)
 {
-  struct IdentityTokenCodePayload* payload;
+  struct GNUNET_IDENTITY_PROVIDER_TokenTicketPayload* payload;
 
-  payload = GNUNET_malloc (sizeof (struct IdentityTokenCodePayload));
+  payload = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_PROVIDER_TokenTicketPayload));
   GNUNET_asprintf (&payload->nonce, nonce, strlen (nonce));
   payload->identity_key = *identity_pkey;
   GNUNET_asprintf (&payload->label, lbl_str, strlen (lbl_str));
@@ -484,7 +491,7 @@ identity_token_code_payload_create (const char* nonce,
 }
 
 void
-identity_token_code_payload_destroy (struct IdentityTokenCodePayload* payload)
+GNUNET_IDENTITY_PROVIDER_ticket_payload_destroy (struct GNUNET_IDENTITY_PROVIDER_TokenTicketPayload* payload)
 {
   GNUNET_free (payload->nonce);
   GNUNET_free (payload->label);
@@ -492,8 +499,8 @@ identity_token_code_payload_destroy (struct IdentityTokenCodePayload* payload)
 }
 
 void
-identity_token_code_payload_serialize (struct IdentityTokenCodePayload *payload,
-                                       char **result)
+GNUNET_IDENTITY_PROVIDER_ticket_payload_serialize (struct GNUNET_IDENTITY_PROVIDER_TokenTicketPayload *payload,
+                                                   char **result)
 {
   char* identity_key_str;
 
@@ -512,60 +519,60 @@ identity_token_code_payload_serialize (struct IdentityTokenCodePayload *payload,
  * Create the token code
  * The metadata is encrypted with a share ECDH derived secret using B (aud_key)
  * and e (ecdh_privkey)
- * The token_code also contains E (ecdh_pubkey) and a signature over the
+ * The ticket also contains E (ecdh_pubkey) and a signature over the
  * metadata and E
  */
-struct IdentityTokenCode*
-identity_token_code_create (const char* nonce_str,
-                            const struct GNUNET_CRYPTO_EcdsaPublicKey* identity_pkey,
-                            const char* lbl_str,
-                            const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key)
+struct GNUNET_IDENTITY_PROVIDER_TokenTicket*
+GNUNET_IDENTITY_PROVIDER_ticket_create (const char* nonce_str,
+                                        const struct GNUNET_CRYPTO_EcdsaPublicKey* identity_pkey,
+                                        const char* lbl_str,
+                                        const struct GNUNET_CRYPTO_EcdsaPublicKey *aud_key)
 {
-  struct IdentityTokenCode *token_code;
-  struct IdentityTokenCodePayload *code_payload;
+  struct GNUNET_IDENTITY_PROVIDER_TokenTicket *ticket;
+  struct GNUNET_IDENTITY_PROVIDER_TokenTicketPayload *code_payload;
 
-  token_code = GNUNET_malloc (sizeof (struct IdentityTokenCode));
-  code_payload = identity_token_code_payload_create (nonce_str,
-                                                     identity_pkey,
-                                                     lbl_str);
-  token_code->aud_key = *aud_key;
-  token_code->payload = code_payload;
+  ticket = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_PROVIDER_TokenTicket));
+  code_payload = GNUNET_IDENTITY_PROVIDER_ticket_payload_create (nonce_str,
+                                                                 identity_pkey,
+                                                                 lbl_str);
+  ticket->aud_key = *aud_key;
+  ticket->payload = code_payload;
 
 
-  return token_code;
+  return ticket;
 }
 
 void
-identity_token_code_destroy (struct IdentityTokenCode *token_code)
+GNUNET_IDENTITY_PROVIDER_ticket_destroy (struct GNUNET_IDENTITY_PROVIDER_TokenTicket *ticket)
 {
-  identity_token_code_payload_destroy (token_code->payload);
-  GNUNET_free (token_code);
+  GNUNET_IDENTITY_PROVIDER_ticket_payload_destroy (ticket->payload);
+  GNUNET_free (ticket);
 }
 
 int
-identity_token_code_serialize (struct IdentityTokenCode *identity_token_code,
-                               const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
-                               char **result)
+GNUNET_IDENTITY_PROVIDER_ticket_serialize (struct GNUNET_IDENTITY_PROVIDER_TokenTicket *ticket,
+                                           const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
+                                           char **result)
 {
   char *code_payload_str;
-  char *enc_token_code_payload;
-  char *token_code_payload_str;
-  char *token_code_sig_str;
-  char *token_code_str;
+  char *enc_ticket_payload;
+  char *ticket_payload_str;
+  char *ticket_sig_str;
+  char *ticket_str;
   char *dh_key_str;
   char *write_ptr;
   struct GNUNET_CRYPTO_EcdhePrivateKey *ecdhe_privkey;
 
   struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
 
-  identity_token_code_payload_serialize (identity_token_code->payload,
-                                         &code_payload_str);
+  GNUNET_IDENTITY_PROVIDER_ticket_payload_serialize (ticket->payload,
+                                                     &code_payload_str);
 
   GNUNET_assert (GNUNET_OK == encrypt_str_ecdhe (code_payload_str,
-                                                 &identity_token_code->aud_key,
-                                                 &enc_token_code_payload,
+                                                 &ticket->aud_key,
+                                                 &enc_ticket_payload,
                                                  &ecdhe_privkey,
-                                                 &identity_token_code->ecdh_pubkey));
+                                                 &ticket->ecdh_pubkey));
 
   GNUNET_free (ecdhe_privkey);
 
@@ -577,44 +584,44 @@ identity_token_code_serialize (struct IdentityTokenCode *identity_token_code,
     htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
            sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
            strlen (code_payload_str));
-  purpose->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_GNUID_TOKEN_CODE);
+  purpose->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_GNUID_TICKET);
   write_ptr = (char*) &purpose[1];
   memcpy (write_ptr,
-          &identity_token_code->ecdh_pubkey,
+          &ticket->ecdh_pubkey,
           sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
   write_ptr += sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
-  memcpy (write_ptr, enc_token_code_payload, strlen (code_payload_str));
+  memcpy (write_ptr, enc_ticket_payload, strlen (code_payload_str));
   GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdsa_sign (priv_key,
                                                         purpose,
-                                                        &identity_token_code->signature));
-  GNUNET_STRINGS_base64_encode (enc_token_code_payload,
+                                                       &ticket->signature));
+  GNUNET_STRINGS_base64_encode (enc_ticket_payload,
                                 strlen (code_payload_str),
-                                &token_code_payload_str);
-  token_code_sig_str = GNUNET_STRINGS_data_to_string_alloc (&identity_token_code->signature,
-                                                            sizeof (struct GNUNET_CRYPTO_EcdsaSignature));
+                                &ticket_payload_str);
+  ticket_sig_str = GNUNET_STRINGS_data_to_string_alloc (&ticket->signature,
+                                                        sizeof (struct GNUNET_CRYPTO_EcdsaSignature));
 
-  dh_key_str = GNUNET_STRINGS_data_to_string_alloc (&identity_token_code->ecdh_pubkey,
+  dh_key_str = GNUNET_STRINGS_data_to_string_alloc (&ticket->ecdh_pubkey,
                                                     sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Using ECDH pubkey %s to encrypt\n", dh_key_str);
-  GNUNET_asprintf (&token_code_str, "{\"meta\": \"%s\", \"ecdh\": \"%s\", \"signature\": \"%s\"}",
-                   token_code_payload_str, dh_key_str, token_code_sig_str);
-  GNUNET_STRINGS_base64_encode (token_code_str, strlen (token_code_str), result);
+  GNUNET_asprintf (&ticket_str, "{\"meta\": \"%s\", \"ecdh\": \"%s\", \"signature\": \"%s\"}",
+                   ticket_payload_str, dh_key_str, ticket_sig_str);
+  GNUNET_STRINGS_base64_encode (ticket_str, strlen (ticket_str), result);
   GNUNET_free (dh_key_str);
   GNUNET_free (purpose);
-  GNUNET_free (token_code_str);
-  GNUNET_free (token_code_sig_str);
+  GNUNET_free (ticket_str);
+  GNUNET_free (ticket_sig_str);
   GNUNET_free (code_payload_str);
-  GNUNET_free (enc_token_code_payload);
-  GNUNET_free (token_code_payload_str);
+  GNUNET_free (enc_ticket_payload);
+  GNUNET_free (ticket_payload_str);
   return GNUNET_OK;
 }
 
 int
-identity_token_code_payload_parse(const char *raw_data,
-                                  ssize_t data_len,
-                                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
-                                  const struct GNUNET_CRYPTO_EcdhePublicKey *ecdhe_pkey,
-                                  struct IdentityTokenCodePayload **result)
+GNUNET_IDENTITY_PROVIDER_ticket_payload_parse(const char *raw_data,
+                                              ssize_t data_len,
+                                              const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
+                                              const struct GNUNET_CRYPTO_EcdhePublicKey *ecdhe_pkey,
+                                              struct GNUNET_IDENTITY_PROVIDER_TokenTicketPayload **result)
 {
   const char* label_str;
   const char* nonce_str;
@@ -690,9 +697,9 @@ identity_token_code_payload_parse(const char *raw_data,
   nonce_str = json_string_value (nonce_json);
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Found nonce: %s\n", nonce_str);
 
-  *result = identity_token_code_payload_create (nonce_str,
-                                                (const struct GNUNET_CRYPTO_EcdsaPublicKey*)&id_pkey,
-                                                label_str);
+  *result = GNUNET_IDENTITY_PROVIDER_ticket_payload_create (nonce_str,
+                                                            (const struct GNUNET_CRYPTO_EcdsaPublicKey*)&id_pkey,
+                                                            label_str);
   GNUNET_free (meta_str);
   json_decref (root);
   return GNUNET_OK;
@@ -700,9 +707,9 @@ identity_token_code_payload_parse(const char *raw_data,
 }
 
 int
-identity_token_code_parse (const char *raw_data,
-                           const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
-                           struct IdentityTokenCode **result)
+GNUNET_IDENTITY_PROVIDER_ticket_parse (const char *raw_data,
+                                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key,
+                                       struct GNUNET_IDENTITY_PROVIDER_TokenTicket **result)
 {
   const char* enc_meta_str;
   const char* ecdh_enc_str;
@@ -714,17 +721,17 @@ identity_token_code_parse (const char *raw_data,
   json_t *enc_meta_json;
   json_error_t err_json;
   char* enc_meta;
-  char* token_code_decoded;
+  char* ticket_decoded;
   char* write_ptr;
   size_t enc_meta_len;
   struct GNUNET_CRYPTO_EccSignaturePurpose *purpose;
-  struct IdentityTokenCode *token_code;
-  struct IdentityTokenCodePayload *token_code_payload;
+  struct GNUNET_IDENTITY_PROVIDER_TokenTicket *ticket;
+  struct GNUNET_IDENTITY_PROVIDER_TokenTicketPayload *ticket_payload;
 
-  token_code_decoded = NULL;
-  GNUNET_STRINGS_base64_decode (raw_data, strlen (raw_data), &token_code_decoded);
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Token Code: %s\n", token_code_decoded);
-  root = json_loads (token_code_decoded, JSON_DECODE_ANY, &err_json);
+  ticket_decoded = NULL;
+  GNUNET_STRINGS_base64_decode (raw_data, strlen (raw_data), &ticket_decoded);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Token Code: %s\n", ticket_decoded);
+  root = json_loads (ticket_decoded, JSON_DECODE_ANY, &err_json);
   if (!root)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -740,27 +747,27 @@ identity_token_code_parse (const char *raw_data,
   ecdh_enc_str = json_string_value (ecdh_json);
   enc_meta_str = json_string_value (enc_meta_json);
 
-  token_code = GNUNET_malloc (sizeof (struct IdentityTokenCode));
+  ticket = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_PROVIDER_TokenTicket));
 
   if (GNUNET_OK != GNUNET_STRINGS_string_to_data (ecdh_enc_str,
                                                   strlen (ecdh_enc_str),
-                                                  &token_code->ecdh_pubkey,
+                                                  &ticket->ecdh_pubkey,
                                                   sizeof  (struct GNUNET_CRYPTO_EcdhePublicKey)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ECDH PKEY %s invalid in metadata\n", ecdh_enc_str);
     json_decref (root);
-    GNUNET_free (token_code);
+    GNUNET_free (ticket);
     return GNUNET_SYSERR;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Using ECDH pubkey %s for metadata decryption\n", ecdh_enc_str);
   if (GNUNET_OK != GNUNET_STRINGS_string_to_data (signature_enc_str,
                                                   strlen (signature_enc_str),
-                                                  &token_code->signature,
+                                                  &ticket->signature,
                                                   sizeof (struct GNUNET_CRYPTO_EcdsaSignature)))
   {
     json_decref (root);
-    GNUNET_free (token_code_decoded);
-    GNUNET_free (token_code);
+    GNUNET_free (ticket_decoded);
+    GNUNET_free (ticket);
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ECDH signature invalid in metadata\n");
     return GNUNET_SYSERR;
   }
@@ -770,13 +777,13 @@ identity_token_code_parse (const char *raw_data,
                                                &enc_meta);
 
 
-  identity_token_code_payload_parse (enc_meta,
-                                     enc_meta_len,
-                                     priv_key,
-                                     (const struct GNUNET_CRYPTO_EcdhePublicKey*)&token_code->ecdh_pubkey,
-                                     &token_code_payload);
+  GNUNET_IDENTITY_PROVIDER_ticket_payload_parse (enc_meta,
+                                                 enc_meta_len,
+                                                 priv_key,
+                                                 (const struct GNUNET_CRYPTO_EcdhePublicKey*)&ticket->ecdh_pubkey,
+                                                 &ticket_payload);
 
-  token_code->payload = token_code_payload;
+  ticket->payload = ticket_payload;
   //TODO: check signature here
   purpose = 
     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) + 
@@ -786,30 +793,30 @@ identity_token_code_parse (const char *raw_data,
     htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
            sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
            enc_meta_len);
-  purpose->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_GNUID_TOKEN_CODE);
+  purpose->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_GNUID_TICKET);
   write_ptr = (char*) &purpose[1];
-  memcpy (write_ptr, &token_code->ecdh_pubkey, sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
+  memcpy (write_ptr, &ticket->ecdh_pubkey, sizeof (struct GNUNET_CRYPTO_EcdhePublicKey));
   write_ptr += sizeof (struct GNUNET_CRYPTO_EcdhePublicKey);
   memcpy (write_ptr, enc_meta, enc_meta_len);
 
-  if (GNUNET_OK != GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_GNUID_TOKEN_CODE,
+  if (GNUNET_OK != GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_GNUID_TICKET,
                                                purpose,
-                                               &token_code->signature,
-                                               &token_code_payload->identity_key))
+                                               &ticket->signature,
+                                               &ticket_payload->identity_key))
   {
-    identity_token_code_destroy (token_code);
-    GNUNET_free (token_code_decoded);
+    GNUNET_IDENTITY_PROVIDER_ticket_destroy (ticket);
+    GNUNET_free (ticket_decoded);
     json_decref (root);
     GNUNET_free (purpose);
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Error verifying signature for token code\n");
     return GNUNET_SYSERR;
   }
-  *result = token_code;
+  *result = ticket;
   GNUNET_free (purpose);
 
   GNUNET_free (enc_meta);
-  GNUNET_free (token_code_decoded);
+  GNUNET_free (ticket_decoded);
   json_decref (root);
   return GNUNET_OK;