mirror of
https://github.com/estkme-group/lpac
synced 2024-09-11 19:40:49 +02:00
944 lines
23 KiB
C
944 lines
23 KiB
C
#include "es10c.h"
|
|
#include "es10x.private.h"
|
|
|
|
#include "hexutil.h"
|
|
#include "base64.h"
|
|
|
|
#include <inttypes.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
|
|
#include "asn1c/asn1/ProfileInfoListRequest.h"
|
|
#include "asn1c/asn1/ProfileInfoListResponse.h"
|
|
#include "asn1c/asn1/EnableProfileRequest.h"
|
|
#include "asn1c/asn1/EnableProfileResponse.h"
|
|
#include "asn1c/asn1/DisableProfileRequest.h"
|
|
#include "asn1c/asn1/DisableProfileResponse.h"
|
|
#include "asn1c/asn1/DeleteProfileRequest.h"
|
|
#include "asn1c/asn1/DeleteProfileResponse.h"
|
|
#include "asn1c/asn1/EuiccMemoryResetRequest.h"
|
|
#include "asn1c/asn1/EuiccMemoryResetResponse.h"
|
|
#include "asn1c/asn1/GetEuiccDataRequest.h"
|
|
#include "asn1c/asn1/GetEuiccDataResponse.h"
|
|
#include "asn1c/asn1/SetNicknameRequest.h"
|
|
#include "asn1c/asn1/SetNicknameResponse.h"
|
|
|
|
int es10c_get_profiles_info(struct euicc_ctx *ctx, struct es10c_profile_info **profiles, int *profiles_count)
|
|
{
|
|
int fret = 0;
|
|
uint8_t *respbuf = NULL;
|
|
unsigned resplen;
|
|
asn_enc_rval_t asn1erval;
|
|
asn_dec_rval_t asn1drval;
|
|
ProfileInfoListRequest_t *asn1req = NULL;
|
|
ProfileInfoListResponse_t *asn1resp = NULL;
|
|
|
|
*profiles = NULL;
|
|
*profiles_count = 0;
|
|
|
|
asn1req = malloc(sizeof(ProfileInfoListRequest_t));
|
|
if (!asn1req)
|
|
{
|
|
goto err;
|
|
}
|
|
memset(asn1req, 0, sizeof(*asn1req));
|
|
|
|
asn1erval = der_encode_to_buffer(&asn_DEF_ProfileInfoListRequest, asn1req, ctx->g_asn1_der_request_buf, sizeof(ctx->g_asn1_der_request_buf));
|
|
ASN_STRUCT_FREE(asn_DEF_ProfileInfoListRequest, asn1req);
|
|
asn1req = NULL;
|
|
if (asn1erval.encoded == -1)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
if (es10x_command(ctx, &respbuf, &resplen, ctx->g_asn1_der_request_buf, asn1erval.encoded) < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1drval = ber_decode(NULL, &asn_DEF_ProfileInfoListResponse, (void **)&asn1resp, respbuf, resplen);
|
|
free(respbuf);
|
|
respbuf = NULL;
|
|
|
|
if (asn1drval.code != RC_OK)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
if (asn1resp->present != ProfileInfoListResponse_PR_profileInfoListOk)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
*profiles_count = asn1resp->choice.profileInfoListOk.list.count;
|
|
*profiles = malloc(sizeof(struct es10c_profile_info) * (*profiles_count));
|
|
if (!(*profiles))
|
|
{
|
|
goto err;
|
|
}
|
|
memset(*profiles, 0, sizeof(struct es10c_profile_info) * (*profiles_count));
|
|
|
|
for (int i = 0; i < *profiles_count; i++)
|
|
{
|
|
struct es10c_profile_info *p = &((*profiles)[i]);
|
|
struct ProfileInfo *asn1p = asn1resp->choice.profileInfoListOk.list.array[i];
|
|
|
|
if (asn1p->iccid)
|
|
{
|
|
if (euicc_hexutil_bin2gsmbcd(p->iccid, sizeof(p->iccid), asn1p->iccid->buf, asn1p->iccid->size))
|
|
{
|
|
memset(p->iccid, 0, sizeof(p->iccid));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (asn1p->isdpAid)
|
|
{
|
|
for (int j = 0; j < asn1p->isdpAid->size; j++)
|
|
{
|
|
sprintf(p->isdpAid + (j * 2), "%02X", (uint8_t)(asn1p->isdpAid->buf[j]));
|
|
}
|
|
}
|
|
|
|
if (asn1p->profileState)
|
|
{
|
|
long profileState;
|
|
|
|
asn_INTEGER2long(asn1p->profileState, &profileState);
|
|
|
|
switch (profileState)
|
|
{
|
|
case ES10C_PROFILE_INFO_STATE_DISABLED:
|
|
p->profileState = "disabled";
|
|
break;
|
|
case ES10C_PROFILE_INFO_STATE_ENABLED:
|
|
p->profileState = "enabled";
|
|
break;
|
|
default:
|
|
p->profileState = "unknown";
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (asn1p->profileClass)
|
|
{
|
|
long profileClass;
|
|
|
|
asn_INTEGER2long(asn1p->profileClass, &profileClass);
|
|
|
|
switch (profileClass)
|
|
{
|
|
case ES10C_PROFILE_INFO_CLASS_TEST:
|
|
p->profileClass = "test";
|
|
break;
|
|
case ES10C_PROFILE_INFO_CLASS_PROVISIONING:
|
|
p->profileClass = "provisioning";
|
|
break;
|
|
case ES10C_PROFILE_INFO_CLASS_OPERATIONAL:
|
|
p->profileClass = "operational";
|
|
break;
|
|
default:
|
|
p->profileClass = "unknown";
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (asn1p->profileNickname)
|
|
{
|
|
p->profileNickname = malloc(asn1p->profileNickname->size + 1);
|
|
if (p->profileNickname)
|
|
{
|
|
memcpy(p->profileNickname, asn1p->profileNickname->buf, asn1p->profileNickname->size);
|
|
p->profileNickname[asn1p->profileNickname->size] = '\0';
|
|
}
|
|
}
|
|
|
|
if (asn1p->serviceProviderName)
|
|
{
|
|
p->serviceProviderName = malloc(asn1p->serviceProviderName->size + 1);
|
|
if (p->serviceProviderName)
|
|
{
|
|
memcpy(p->serviceProviderName, asn1p->serviceProviderName->buf, asn1p->serviceProviderName->size);
|
|
p->serviceProviderName[asn1p->serviceProviderName->size] = '\0';
|
|
}
|
|
}
|
|
|
|
if (asn1p->profileName)
|
|
{
|
|
p->profileName = malloc(asn1p->profileName->size + 1);
|
|
if (p->profileName)
|
|
{
|
|
memcpy(p->profileName, asn1p->profileName->buf, asn1p->profileName->size);
|
|
p->profileName[asn1p->profileName->size] = '\0';
|
|
}
|
|
}
|
|
|
|
if (asn1p->iconType)
|
|
{
|
|
long iconType;
|
|
|
|
asn_INTEGER2long(asn1p->iconType, &iconType);
|
|
|
|
switch (iconType)
|
|
{
|
|
case ES10C_ICON_TYPE_JPEG:
|
|
p->iconType = "jpeg";
|
|
break;
|
|
case ES10C_ICON_TYPE_PNG:
|
|
p->iconType = "png";
|
|
break;
|
|
default:
|
|
p->iconType = "unknown";
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
p->iconType = "none";
|
|
}
|
|
|
|
if (asn1p->icon)
|
|
{
|
|
p->icon = malloc(euicc_base64_encode_len(asn1p->icon->size));
|
|
if (p->icon)
|
|
{
|
|
euicc_base64_encode(p->icon, asn1p->icon->buf, asn1p->icon->size);
|
|
}
|
|
}
|
|
}
|
|
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
free(*profiles);
|
|
*profiles = NULL;
|
|
*profiles_count = 0;
|
|
exit:
|
|
free(respbuf);
|
|
ASN_STRUCT_FREE(asn_DEF_ProfileInfoListRequest, asn1req);
|
|
ASN_STRUCT_FREE(asn_DEF_ProfileInfoListResponse, asn1resp);
|
|
|
|
return fret;
|
|
}
|
|
|
|
static int iter_EnableProfileResponse(struct apdu_response *response, void *userdata)
|
|
{
|
|
long *eresult = (long *)userdata;
|
|
int fret = 0;
|
|
asn_dec_rval_t asn1drval;
|
|
EnableProfileResponse_t *asn1resp = NULL;
|
|
|
|
asn1drval = ber_decode(NULL, &asn_DEF_EnableProfileResponse, (void **)&asn1resp, response->data, response->length);
|
|
if (asn1drval.code != RC_OK)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn_INTEGER2long(&asn1resp->enableResult, eresult);
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1resp)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_EnableProfileResponse, asn1resp);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
int es10c_enable_profile_aid(struct euicc_ctx *ctx, const char *aid, int refreshflag)
|
|
{
|
|
int fret = 0;
|
|
int ret;
|
|
asn_enc_rval_t asn1erval;
|
|
EnableProfileRequest_t *asn1req = NULL;
|
|
uint8_t asn1aid[16];
|
|
unsigned long eresult;
|
|
|
|
ret = euicc_hexutil_hex2bin(asn1aid, sizeof(asn1aid), aid);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1req = malloc(sizeof(EnableProfileRequest_t));
|
|
if (!asn1req)
|
|
{
|
|
goto err;
|
|
}
|
|
memset(asn1req, 0, sizeof(*asn1req));
|
|
|
|
asn1req->refreshFlag = (refreshflag == 0) ? 0 : 1;
|
|
|
|
asn1req->profileIdentifier.present = EnableProfileRequest__profileIdentifier_PR_isdpAid;
|
|
ret = OCTET_STRING_fromBuf(&asn1req->profileIdentifier.choice.isdpAid, (const char *)asn1aid, ret);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1erval = der_encode_to_buffer(&asn_DEF_EnableProfileRequest, asn1req, ctx->g_asn1_der_request_buf, sizeof(ctx->g_asn1_der_request_buf));
|
|
ASN_STRUCT_FREE(asn_DEF_EnableProfileRequest, asn1req);
|
|
asn1req = NULL;
|
|
if (asn1erval.encoded == -1)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = es10x_command_iter(ctx, ctx->g_asn1_der_request_buf, asn1erval.encoded, iter_EnableProfileResponse, &eresult);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
fret = eresult;
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1req)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_EnableProfileRequest, asn1req);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
int es10c_enable_profile_iccid(struct euicc_ctx *ctx, const char *iccid, int refreshflag)
|
|
{
|
|
int fret = 0;
|
|
int ret;
|
|
asn_enc_rval_t asn1erval;
|
|
EnableProfileRequest_t *asn1req = NULL;
|
|
uint8_t asn1iccid[20];
|
|
unsigned long eresult;
|
|
|
|
ret = euicc_hexutil_gsmbcd2bin(asn1iccid, sizeof(asn1iccid), iccid);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1req = malloc(sizeof(EnableProfileRequest_t));
|
|
if (!asn1req)
|
|
{
|
|
goto err;
|
|
}
|
|
memset(asn1req, 0, sizeof(*asn1req));
|
|
|
|
asn1req->refreshFlag = (refreshflag == 0) ? 0 : 1;
|
|
|
|
asn1req->profileIdentifier.present = EnableProfileRequest__profileIdentifier_PR_iccid;
|
|
ret = OCTET_STRING_fromBuf(&asn1req->profileIdentifier.choice.iccid, (const char *)asn1iccid, ret);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1erval = der_encode_to_buffer(&asn_DEF_EnableProfileRequest, asn1req, ctx->g_asn1_der_request_buf, sizeof(ctx->g_asn1_der_request_buf));
|
|
ASN_STRUCT_FREE(asn_DEF_EnableProfileRequest, asn1req);
|
|
asn1req = NULL;
|
|
if (asn1erval.encoded == -1)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = es10x_command_iter(ctx, ctx->g_asn1_der_request_buf, asn1erval.encoded, iter_EnableProfileResponse, &eresult);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
fret = eresult;
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1req)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_EnableProfileRequest, asn1req);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
static int iter_DisableProfileResponse(struct apdu_response *response, void *userdata)
|
|
{
|
|
long *eresult = (long *)userdata;
|
|
int fret = 0;
|
|
asn_dec_rval_t asn1drval;
|
|
DisableProfileResponse_t *asn1resp = NULL;
|
|
|
|
asn1drval = ber_decode(NULL, &asn_DEF_DisableProfileResponse, (void **)&asn1resp, response->data, response->length);
|
|
if (asn1drval.code != RC_OK)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn_INTEGER2long(&asn1resp->disableResult, eresult);
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1resp)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_DisableProfileResponse, asn1resp);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
int es10c_disable_profile_aid(struct euicc_ctx *ctx, const char *aid, int refreshflag)
|
|
{
|
|
int fret = 0;
|
|
int ret;
|
|
asn_enc_rval_t asn1erval;
|
|
DisableProfileRequest_t *asn1req = NULL;
|
|
uint8_t asn1aid[16];
|
|
unsigned long eresult;
|
|
|
|
ret = euicc_hexutil_hex2bin(asn1aid, sizeof(asn1aid), aid);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1req = malloc(sizeof(DisableProfileRequest_t));
|
|
if (!asn1req)
|
|
{
|
|
goto err;
|
|
}
|
|
memset(asn1req, 0, sizeof(*asn1req));
|
|
|
|
asn1req->refreshFlag = (refreshflag == 0) ? 0 : 1;
|
|
|
|
asn1req->profileIdentifier.present = DisableProfileRequest__profileIdentifier_PR_isdpAid;
|
|
ret = OCTET_STRING_fromBuf(&asn1req->profileIdentifier.choice.isdpAid, (const char *)asn1aid, ret);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1erval = der_encode_to_buffer(&asn_DEF_DisableProfileRequest, asn1req, ctx->g_asn1_der_request_buf, sizeof(ctx->g_asn1_der_request_buf));
|
|
ASN_STRUCT_FREE(asn_DEF_DisableProfileRequest, asn1req);
|
|
asn1req = NULL;
|
|
if (asn1erval.encoded == -1)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = es10x_command_iter(ctx, ctx->g_asn1_der_request_buf, asn1erval.encoded, iter_DisableProfileResponse, &eresult);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
fret = eresult;
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1req)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_DisableProfileRequest, asn1req);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
int es10c_disable_profile_iccid(struct euicc_ctx *ctx, const char *iccid, int refreshflag)
|
|
{
|
|
int fret = 0;
|
|
int ret;
|
|
asn_enc_rval_t asn1erval;
|
|
DisableProfileRequest_t *asn1req = NULL;
|
|
uint8_t asn1iccid[20];
|
|
unsigned long eresult;
|
|
|
|
ret = euicc_hexutil_gsmbcd2bin(asn1iccid, sizeof(asn1iccid), iccid);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1req = malloc(sizeof(DisableProfileRequest_t));
|
|
if (!asn1req)
|
|
{
|
|
goto err;
|
|
}
|
|
memset(asn1req, 0, sizeof(*asn1req));
|
|
|
|
asn1req->refreshFlag = (refreshflag == 0) ? 0 : 1;
|
|
|
|
asn1req->profileIdentifier.present = DisableProfileRequest__profileIdentifier_PR_iccid;
|
|
ret = OCTET_STRING_fromBuf(&asn1req->profileIdentifier.choice.iccid, (const char *)asn1iccid, ret);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1erval = der_encode_to_buffer(&asn_DEF_DisableProfileRequest, asn1req, ctx->g_asn1_der_request_buf, sizeof(ctx->g_asn1_der_request_buf));
|
|
ASN_STRUCT_FREE(asn_DEF_DisableProfileRequest, asn1req);
|
|
asn1req = NULL;
|
|
if (asn1erval.encoded == -1)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = es10x_command_iter(ctx, ctx->g_asn1_der_request_buf, asn1erval.encoded, iter_DisableProfileResponse, &eresult);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
fret = eresult;
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1req)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_DisableProfileRequest, asn1req);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
static int iter_DeleteProfileResponse(struct apdu_response *response, void *userdata)
|
|
{
|
|
long *eresult = (long *)userdata;
|
|
int fret = 0;
|
|
asn_dec_rval_t asn1drval;
|
|
DeleteProfileResponse_t *asn1resp = NULL;
|
|
|
|
asn1drval = ber_decode(NULL, &asn_DEF_DeleteProfileResponse, (void **)&asn1resp, response->data, response->length);
|
|
if (asn1drval.code != RC_OK)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn_INTEGER2long(&asn1resp->deleteResult, eresult);
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1resp)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_DeleteProfileResponse, asn1resp);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
int es10c_delete_profile_aid(struct euicc_ctx *ctx, const char *aid)
|
|
{
|
|
int fret = 0;
|
|
int ret;
|
|
asn_enc_rval_t asn1erval;
|
|
DeleteProfileRequest_t *asn1req = NULL;
|
|
uint8_t asn1aid[16];
|
|
unsigned long eresult;
|
|
|
|
ret = euicc_hexutil_hex2bin(asn1aid, sizeof(asn1aid), aid);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1req = malloc(sizeof(DeleteProfileRequest_t));
|
|
if (!asn1req)
|
|
{
|
|
goto err;
|
|
}
|
|
memset(asn1req, 0, sizeof(*asn1req));
|
|
|
|
asn1req->present = DeleteProfileRequest_PR_isdpAid;
|
|
ret = OCTET_STRING_fromBuf(&asn1req->choice.isdpAid, (const char *)asn1aid, ret);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1erval = der_encode_to_buffer(&asn_DEF_DeleteProfileRequest, asn1req, ctx->g_asn1_der_request_buf, sizeof(ctx->g_asn1_der_request_buf));
|
|
ASN_STRUCT_FREE(asn_DEF_DeleteProfileRequest, asn1req);
|
|
asn1req = NULL;
|
|
if (asn1erval.encoded == -1)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = es10x_command_iter(ctx, ctx->g_asn1_der_request_buf, asn1erval.encoded, iter_DeleteProfileResponse, &eresult);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
fret = eresult;
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1req)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_DeleteProfileRequest, asn1req);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
int es10c_delete_profile_iccid(struct euicc_ctx *ctx, const char *iccid)
|
|
{
|
|
int fret = 0;
|
|
int ret;
|
|
asn_enc_rval_t asn1erval;
|
|
DeleteProfileRequest_t *asn1req = NULL;
|
|
uint8_t asn1iccid[20];
|
|
unsigned long eresult;
|
|
|
|
ret = euicc_hexutil_gsmbcd2bin(asn1iccid, sizeof(asn1iccid), iccid);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1req = malloc(sizeof(DeleteProfileRequest_t));
|
|
if (!asn1req)
|
|
{
|
|
goto err;
|
|
}
|
|
memset(asn1req, 0, sizeof(*asn1req));
|
|
|
|
asn1req->present = DeleteProfileRequest_PR_iccid;
|
|
ret = OCTET_STRING_fromBuf(&asn1req->choice.iccid, (const char *)asn1iccid, ret);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1erval = der_encode_to_buffer(&asn_DEF_DeleteProfileRequest, asn1req, ctx->g_asn1_der_request_buf, sizeof(ctx->g_asn1_der_request_buf));
|
|
ASN_STRUCT_FREE(asn_DEF_DeleteProfileRequest, asn1req);
|
|
asn1req = NULL;
|
|
if (asn1erval.encoded == -1)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = es10x_command_iter(ctx, ctx->g_asn1_der_request_buf, asn1erval.encoded, iter_DeleteProfileResponse, &eresult);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
fret = eresult;
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1req)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_DeleteProfileRequest, asn1req);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
static int iter_EuiccMemoryResetResponse(struct apdu_response *response, void *userdata)
|
|
{
|
|
long *eresult = (long *)userdata;
|
|
int fret = 0;
|
|
asn_dec_rval_t asn1drval;
|
|
EuiccMemoryResetResponse_t *asn1resp = NULL;
|
|
|
|
asn1drval = ber_decode(NULL, &asn_DEF_EuiccMemoryResetResponse, (void **)&asn1resp, response->data, response->length);
|
|
if (asn1drval.code != RC_OK)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn_INTEGER2long(&asn1resp->resetResult, eresult);
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1resp)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_EuiccMemoryResetResponse, asn1resp);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
int es10c_euicc_memory_reset(struct euicc_ctx *ctx, int op, int tp, int addr)
|
|
{
|
|
int fret = 0;
|
|
int ret;
|
|
asn_enc_rval_t asn1erval;
|
|
EuiccMemoryResetRequest_t *asn1req = NULL;
|
|
unsigned long eresult;
|
|
|
|
asn1req = malloc(sizeof(EuiccMemoryResetRequest_t));
|
|
if (!asn1req)
|
|
{
|
|
goto err;
|
|
}
|
|
memset(asn1req, 0, sizeof(*asn1req));
|
|
|
|
asn1req->resetOptions.bits_unused = 5;
|
|
asn1req->resetOptions.size = 1;
|
|
asn1req->resetOptions.buf = malloc(asn1req->resetOptions.size);
|
|
if (!asn1req->resetOptions.buf)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1req->resetOptions.buf[0] = 0;
|
|
|
|
if (op)
|
|
{
|
|
asn1req->resetOptions.buf[0] |= 1 << (7 - EuiccMemoryResetRequest__resetOptions_deleteOperationalProfiles);
|
|
}
|
|
|
|
if (tp)
|
|
{
|
|
asn1req->resetOptions.buf[0] |= 1 << (7 - EuiccMemoryResetRequest__resetOptions_deleteFieldLoadedTestProfiles);
|
|
}
|
|
|
|
if (addr)
|
|
{
|
|
asn1req->resetOptions.buf[0] |= 1 << (7 - EuiccMemoryResetRequest__resetOptions_resetDefaultSmdpAddress);
|
|
}
|
|
|
|
asn1erval = der_encode_to_buffer(&asn_DEF_EuiccMemoryResetRequest, asn1req, ctx->g_asn1_der_request_buf, sizeof(ctx->g_asn1_der_request_buf));
|
|
ASN_STRUCT_FREE(asn_DEF_EuiccMemoryResetRequest, asn1req);
|
|
asn1req = NULL;
|
|
if (asn1erval.encoded == -1)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = es10x_command_iter(ctx, ctx->g_asn1_der_request_buf, asn1erval.encoded, iter_EuiccMemoryResetResponse, &eresult);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1req)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_EuiccMemoryResetRequest, asn1req);
|
|
}
|
|
return fret;
|
|
}
|
|
|
|
static int iter_GetEuiccDataResponse(struct apdu_response *response, void *userdata)
|
|
{
|
|
int fret = 0;
|
|
char **eid = (char **)userdata;
|
|
asn_dec_rval_t asn1drval;
|
|
GetEuiccDataResponse_t *asn1resp = NULL;
|
|
|
|
*eid = NULL;
|
|
|
|
asn1drval = ber_decode(NULL, &asn_DEF_GetEuiccDataResponse, (void **)&asn1resp, response->data, response->length);
|
|
if (asn1drval.code != RC_OK)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
*eid = malloc((asn1resp->eidValue.size * 2) + 1);
|
|
if (*eid == NULL)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
if (euicc_hexutil_bin2hex(*eid, (asn1resp->eidValue.size * 2) + 1, asn1resp->eidValue.buf, asn1resp->eidValue.size))
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
free(*eid);
|
|
*eid = NULL;
|
|
exit:
|
|
if (asn1resp)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_GetEuiccDataResponse, asn1resp);
|
|
}
|
|
|
|
return fret;
|
|
}
|
|
|
|
int es10c_get_eid(struct euicc_ctx *ctx, char **eid)
|
|
{
|
|
int fret = 0;
|
|
int ret;
|
|
asn_enc_rval_t asn1erval;
|
|
GetEuiccDataRequest_t *asn1req = NULL;
|
|
|
|
asn1req = malloc(sizeof(GetEuiccDataRequest_t));
|
|
if (!asn1req)
|
|
{
|
|
goto err;
|
|
}
|
|
memset(asn1req, 0, sizeof(*asn1req));
|
|
|
|
ret = OCTET_STRING_fromBuf(&asn1req->tagList, "\x5A", 1);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1erval = der_encode_to_buffer(&asn_DEF_GetEuiccDataRequest, asn1req, ctx->g_asn1_der_request_buf, sizeof(ctx->g_asn1_der_request_buf));
|
|
ASN_STRUCT_FREE(asn_DEF_GetEuiccDataRequest, asn1req);
|
|
asn1req = NULL;
|
|
if (asn1erval.encoded == -1)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = es10x_command_iter(ctx, ctx->g_asn1_der_request_buf, asn1erval.encoded, iter_GetEuiccDataResponse, eid);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1req)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_GetEuiccDataRequest, asn1req);
|
|
}
|
|
|
|
return fret;
|
|
}
|
|
|
|
static int iter_SetNicknameResponse(struct apdu_response *response, void *userdata)
|
|
{
|
|
long *eresult = (long *)userdata;
|
|
int fret = 0;
|
|
asn_dec_rval_t asn1drval;
|
|
SetNicknameResponse_t *asn1resp = NULL;
|
|
|
|
asn1drval = ber_decode(NULL, &asn_DEF_SetNicknameResponse, (void **)&asn1resp, response->data, response->length);
|
|
if (asn1drval.code != RC_OK)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn_INTEGER2long(&asn1resp->setNicknameResult, eresult);
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1resp)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_SetNicknameResponse, asn1resp);
|
|
}
|
|
|
|
return fret;
|
|
}
|
|
|
|
int es10c_set_nickname(struct euicc_ctx *ctx, const char *iccid, const char *nickname)
|
|
{
|
|
int fret = 0;
|
|
int ret;
|
|
asn_enc_rval_t asn1erval;
|
|
SetNicknameRequest_t *asn1req = NULL;
|
|
uint8_t asn1iccid[20];
|
|
unsigned long eresult;
|
|
|
|
asn1req = malloc(sizeof(SetNicknameRequest_t));
|
|
if (!asn1req)
|
|
{
|
|
goto err;
|
|
}
|
|
memset(asn1req, 0, sizeof(*asn1req));
|
|
|
|
ret = euicc_hexutil_gsmbcd2bin(asn1iccid, sizeof(asn1iccid), iccid);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = OCTET_STRING_fromBuf(&asn1req->iccid, (const char *)asn1iccid, ret);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = OCTET_STRING_fromBuf(&asn1req->profileNickname, nickname, strlen(nickname));
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
asn1erval = der_encode_to_buffer(&asn_DEF_SetNicknameRequest, asn1req, ctx->g_asn1_der_request_buf, sizeof(ctx->g_asn1_der_request_buf));
|
|
ASN_STRUCT_FREE(asn_DEF_SetNicknameRequest, asn1req);
|
|
asn1req = NULL;
|
|
if (asn1erval.encoded == -1)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
ret = es10x_command_iter(ctx, ctx->g_asn1_der_request_buf, asn1erval.encoded, iter_SetNicknameResponse, &eresult);
|
|
if (ret < 0)
|
|
{
|
|
goto err;
|
|
}
|
|
|
|
fret = eresult;
|
|
goto exit;
|
|
|
|
err:
|
|
fret = -1;
|
|
exit:
|
|
if (asn1req)
|
|
{
|
|
ASN_STRUCT_FREE(asn_DEF_SetNicknameRequest, asn1req);
|
|
}
|
|
|
|
return fret;
|
|
}
|
|
|
|
void es10c_profile_info_free_all(struct es10c_profile_info *profiles, int count)
|
|
{
|
|
if (!profiles)
|
|
{
|
|
return;
|
|
}
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
free(profiles[i].profileNickname);
|
|
free(profiles[i].serviceProviderName);
|
|
free(profiles[i].profileName);
|
|
free(profiles[i].icon);
|
|
}
|
|
free(profiles);
|
|
}
|
|
|
|
void es10c_profile_info_print(struct es10c_profile_info *p)
|
|
{
|
|
printf("\ticcid: %s\n", p->iccid);
|
|
printf("\tisdpAid: %s\n", p->isdpAid);
|
|
printf("\tprofileState: %s\n", p->profileState);
|
|
printf("\tprofileNickname: %s\n", p->profileNickname ? p->profileNickname : "(null)");
|
|
printf("\tserviceProviderName: %s\n", p->serviceProviderName ? p->serviceProviderName : "(null)");
|
|
printf("\tprofileName: %s\n", p->profileName ? p->profileName : "(null)");
|
|
printf("\tprofileClass: %s\n", p->profileClass);
|
|
}
|