|
/* This file is auto-generated from "ssl_cert_descr.xml" by the typemaker
|
|
tool of Gwenhywfar.
|
|
Do not edit this file -- all changes will be lost! */
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#include "ssl_cert_descr_p.h"
|
|
#include <gwenhywfar/misc.h>
|
|
#include <gwenhywfar/db.h>
|
|
#include <gwenhywfar/debug.h>
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <strings.h>
|
|
|
|
#include <gwenhywfar/gwentime.h>
|
|
#include <gwenhywfar/ssl_cert_flags.h>
|
|
|
|
|
|
GWEN_LIST_FUNCTIONS(GWEN_SSLCERTDESCR, GWEN_SslCertDescr)
|
|
GWEN_LIST2_FUNCTIONS(GWEN_SSLCERTDESCR, GWEN_SslCertDescr)
|
|
|
|
|
|
|
|
static GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2__freeAll_cb(GWEN_SSLCERTDESCR *st, void *user_data);
|
|
|
|
|
|
|
|
GWEN_SSLCERTDESCR *GWEN_SslCertDescr_new(void)
|
|
{
|
|
GWEN_SSLCERTDESCR *st;
|
|
|
|
GWEN_NEW_OBJECT(GWEN_SSLCERTDESCR, st)
|
|
st->_usage=1;
|
|
GWEN_LIST_INIT(GWEN_SSLCERTDESCR, st)
|
|
return st;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_free(GWEN_SSLCERTDESCR *st)
|
|
{
|
|
if (st) {
|
|
assert(st->_usage);
|
|
if (--(st->_usage)==0) {
|
|
if (st->countryName)
|
|
free(st->countryName);
|
|
if (st->commonName)
|
|
free(st->commonName);
|
|
if (st->organizationName)
|
|
free(st->organizationName);
|
|
if (st->organizationalUnitName)
|
|
free(st->organizationalUnitName);
|
|
if (st->localityName)
|
|
free(st->localityName);
|
|
if (st->stateOrProvinceName)
|
|
free(st->stateOrProvinceName);
|
|
if (st->notBefore)
|
|
GWEN_Time_free(st->notBefore);
|
|
if (st->notAfter)
|
|
GWEN_Time_free(st->notAfter);
|
|
if (st->ipAddress)
|
|
free(st->ipAddress);
|
|
if (st->fingerPrint)
|
|
free(st->fingerPrint);
|
|
if (st->fingerPrintSha1)
|
|
free(st->fingerPrintSha1);
|
|
if (st->fingerPrintSha512)
|
|
free(st->fingerPrintSha512);
|
|
if (st->pubKeyModulus)
|
|
free(st->pubKeyModulus);
|
|
if (st->pubKeyExponent)
|
|
free(st->pubKeyExponent);
|
|
if (st->statusText)
|
|
free(st->statusText);
|
|
GWEN_LIST_FINI(GWEN_SSLCERTDESCR, st)
|
|
GWEN_FREE_OBJECT(st);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
GWEN_SSLCERTDESCR *GWEN_SslCertDescr_dup(const GWEN_SSLCERTDESCR *d)
|
|
{
|
|
GWEN_SSLCERTDESCR *st;
|
|
|
|
assert(d);
|
|
st=GWEN_SslCertDescr_new();
|
|
if (d->countryName)
|
|
st->countryName=strdup(d->countryName);
|
|
if (d->commonName)
|
|
st->commonName=strdup(d->commonName);
|
|
if (d->organizationName)
|
|
st->organizationName=strdup(d->organizationName);
|
|
if (d->organizationalUnitName)
|
|
st->organizationalUnitName=strdup(d->organizationalUnitName);
|
|
if (d->localityName)
|
|
st->localityName=strdup(d->localityName);
|
|
if (d->stateOrProvinceName)
|
|
st->stateOrProvinceName=strdup(d->stateOrProvinceName);
|
|
if (d->notBefore)
|
|
st->notBefore=GWEN_Time_dup(d->notBefore);
|
|
if (d->notAfter)
|
|
st->notAfter=GWEN_Time_dup(d->notAfter);
|
|
if (d->ipAddress)
|
|
st->ipAddress=strdup(d->ipAddress);
|
|
if (d->fingerPrint)
|
|
st->fingerPrint=strdup(d->fingerPrint);
|
|
if (d->fingerPrintSha1)
|
|
st->fingerPrintSha1=strdup(d->fingerPrintSha1);
|
|
if (d->fingerPrintSha512)
|
|
st->fingerPrintSha512=strdup(d->fingerPrintSha512);
|
|
if (d->pubKeyModulus)
|
|
st->pubKeyModulus=strdup(d->pubKeyModulus);
|
|
if (d->pubKeyExponent)
|
|
st->pubKeyExponent=strdup(d->pubKeyExponent);
|
|
if (d->statusText)
|
|
st->statusText=strdup(d->statusText);
|
|
st->isError=d->isError;
|
|
st->statusFlags=d->statusFlags;
|
|
return st;
|
|
}
|
|
|
|
|
|
int GWEN_SslCertDescr_toDb(const GWEN_SSLCERTDESCR *st, GWEN_DB_NODE *db)
|
|
{
|
|
assert(st);
|
|
assert(db);
|
|
if (st->countryName)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "countryName", st->countryName))
|
|
return -1;
|
|
if (st->commonName)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "commonName", st->commonName))
|
|
return -1;
|
|
if (st->organizationName)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "organizationName", st->organizationName))
|
|
return -1;
|
|
if (st->organizationalUnitName)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "organizationalUnitName", st->organizationalUnitName))
|
|
return -1;
|
|
if (st->localityName)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "localityName", st->localityName))
|
|
return -1;
|
|
if (st->stateOrProvinceName)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "stateOrProvinceName", st->stateOrProvinceName))
|
|
return -1;
|
|
if (st->notBefore)
|
|
if (GWEN_Time_toDb(st->notBefore, GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "notBefore")))
|
|
return -1;
|
|
if (st->notAfter)
|
|
if (GWEN_Time_toDb(st->notAfter, GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "notAfter")))
|
|
return -1;
|
|
if (st->ipAddress)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "ipAddress", st->ipAddress))
|
|
return -1;
|
|
if (st->fingerPrint)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "fingerPrint", st->fingerPrint))
|
|
return -1;
|
|
if (st->fingerPrintSha1)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "fingerPrintSha1", st->fingerPrintSha1))
|
|
return -1;
|
|
if (st->fingerPrintSha512)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "fingerPrintSha512", st->fingerPrintSha512))
|
|
return -1;
|
|
if (st->pubKeyModulus)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "pubKeyModulus", st->pubKeyModulus))
|
|
return -1;
|
|
if (st->pubKeyExponent)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "pubKeyExponent", st->pubKeyExponent))
|
|
return -1;
|
|
if (st->statusText)
|
|
if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "statusText", st->statusText))
|
|
return -1;
|
|
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "isError", st->isError))
|
|
return -1;
|
|
if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "statusFlags", st->statusFlags))
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int GWEN_SslCertDescr_ReadDb(GWEN_SSLCERTDESCR *st, GWEN_DB_NODE *db)
|
|
{
|
|
assert(st);
|
|
assert(db);
|
|
GWEN_SslCertDescr_SetCountryName(st, GWEN_DB_GetCharValue(db, "countryName", 0, 0));
|
|
GWEN_SslCertDescr_SetCommonName(st, GWEN_DB_GetCharValue(db, "commonName", 0, 0));
|
|
GWEN_SslCertDescr_SetOrganizationName(st, GWEN_DB_GetCharValue(db, "organizationName", 0, 0));
|
|
GWEN_SslCertDescr_SetOrganizationalUnitName(st, GWEN_DB_GetCharValue(db, "organizationalUnitName", 0, 0));
|
|
GWEN_SslCertDescr_SetLocalityName(st, GWEN_DB_GetCharValue(db, "localityName", 0, 0));
|
|
GWEN_SslCertDescr_SetStateOrProvinceName(st, GWEN_DB_GetCharValue(db, "stateOrProvinceName", 0, 0));
|
|
if (1) { /* for local vars */
|
|
GWEN_DB_NODE *dbT;
|
|
|
|
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "notBefore");
|
|
if (dbT) {
|
|
if (st->notBefore)
|
|
GWEN_Time_free(st->notBefore);
|
|
st->notBefore=GWEN_Time_fromDb(dbT);
|
|
}
|
|
}
|
|
if (1) { /* for local vars */
|
|
GWEN_DB_NODE *dbT;
|
|
|
|
dbT=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "notAfter");
|
|
if (dbT) {
|
|
if (st->notAfter)
|
|
GWEN_Time_free(st->notAfter);
|
|
st->notAfter=GWEN_Time_fromDb(dbT);
|
|
}
|
|
}
|
|
GWEN_SslCertDescr_SetIpAddress(st, GWEN_DB_GetCharValue(db, "ipAddress", 0, 0));
|
|
GWEN_SslCertDescr_SetFingerPrint(st, GWEN_DB_GetCharValue(db, "fingerPrint", 0, 0));
|
|
GWEN_SslCertDescr_SetFingerPrintSha1(st, GWEN_DB_GetCharValue(db, "fingerPrintSha1", 0, 0));
|
|
GWEN_SslCertDescr_SetFingerPrintSha512(st, GWEN_DB_GetCharValue(db, "fingerPrintSha512", 0, 0));
|
|
GWEN_SslCertDescr_SetPubKeyModulus(st, GWEN_DB_GetCharValue(db, "pubKeyModulus", 0, 0));
|
|
GWEN_SslCertDescr_SetPubKeyExponent(st, GWEN_DB_GetCharValue(db, "pubKeyExponent", 0, 0));
|
|
GWEN_SslCertDescr_SetStatusText(st, GWEN_DB_GetCharValue(db, "statusText", 0, 0));
|
|
GWEN_SslCertDescr_SetIsError(st, GWEN_DB_GetIntValue(db, "isError", 0, 0));
|
|
GWEN_SslCertDescr_SetStatusFlags(st, GWEN_DB_GetIntValue(db, "statusFlags", 0, 0));
|
|
return 0;
|
|
}
|
|
|
|
|
|
GWEN_SSLCERTDESCR *GWEN_SslCertDescr_fromDb(GWEN_DB_NODE *db)
|
|
{
|
|
GWEN_SSLCERTDESCR *st;
|
|
|
|
assert(db);
|
|
st=GWEN_SslCertDescr_new();
|
|
GWEN_SslCertDescr_ReadDb(st, db);
|
|
st->_modified=0;
|
|
return st;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetCountryName(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->countryName;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetCountryName(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->countryName)
|
|
free(st->countryName);
|
|
if (d && *d)
|
|
st->countryName=strdup(d);
|
|
else
|
|
st->countryName=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetCommonName(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->commonName;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetCommonName(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->commonName)
|
|
free(st->commonName);
|
|
if (d && *d)
|
|
st->commonName=strdup(d);
|
|
else
|
|
st->commonName=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetOrganizationName(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->organizationName;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetOrganizationName(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->organizationName)
|
|
free(st->organizationName);
|
|
if (d && *d)
|
|
st->organizationName=strdup(d);
|
|
else
|
|
st->organizationName=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetOrganizationalUnitName(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->organizationalUnitName;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetOrganizationalUnitName(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->organizationalUnitName)
|
|
free(st->organizationalUnitName);
|
|
if (d && *d)
|
|
st->organizationalUnitName=strdup(d);
|
|
else
|
|
st->organizationalUnitName=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetLocalityName(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->localityName;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetLocalityName(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->localityName)
|
|
free(st->localityName);
|
|
if (d && *d)
|
|
st->localityName=strdup(d);
|
|
else
|
|
st->localityName=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetStateOrProvinceName(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->stateOrProvinceName;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetStateOrProvinceName(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->stateOrProvinceName)
|
|
free(st->stateOrProvinceName);
|
|
if (d && *d)
|
|
st->stateOrProvinceName=strdup(d);
|
|
else
|
|
st->stateOrProvinceName=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const GWEN_TIME *GWEN_SslCertDescr_GetNotBefore(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->notBefore;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetNotBefore(GWEN_SSLCERTDESCR *st, const GWEN_TIME *d)
|
|
{
|
|
assert(st);
|
|
if (st->notBefore)
|
|
GWEN_Time_free(st->notBefore);
|
|
if (d)
|
|
st->notBefore=GWEN_Time_dup(d);
|
|
else
|
|
st->notBefore=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const GWEN_TIME *GWEN_SslCertDescr_GetNotAfter(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->notAfter;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetNotAfter(GWEN_SSLCERTDESCR *st, const GWEN_TIME *d)
|
|
{
|
|
assert(st);
|
|
if (st->notAfter)
|
|
GWEN_Time_free(st->notAfter);
|
|
if (d)
|
|
st->notAfter=GWEN_Time_dup(d);
|
|
else
|
|
st->notAfter=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetIpAddress(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->ipAddress;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetIpAddress(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->ipAddress)
|
|
free(st->ipAddress);
|
|
if (d && *d)
|
|
st->ipAddress=strdup(d);
|
|
else
|
|
st->ipAddress=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetFingerPrint(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->fingerPrint;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetFingerPrint(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->fingerPrint)
|
|
free(st->fingerPrint);
|
|
if (d && *d)
|
|
st->fingerPrint=strdup(d);
|
|
else
|
|
st->fingerPrint=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetFingerPrintSha1(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->fingerPrintSha1;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetFingerPrintSha1(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->fingerPrintSha1)
|
|
free(st->fingerPrintSha1);
|
|
if (d && *d)
|
|
st->fingerPrintSha1=strdup(d);
|
|
else
|
|
st->fingerPrintSha1=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetFingerPrintSha512(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->fingerPrintSha512;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetFingerPrintSha512(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->fingerPrintSha512)
|
|
free(st->fingerPrintSha512);
|
|
if (d && *d)
|
|
st->fingerPrintSha512=strdup(d);
|
|
else
|
|
st->fingerPrintSha512=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetPubKeyModulus(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->pubKeyModulus;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetPubKeyModulus(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->pubKeyModulus)
|
|
free(st->pubKeyModulus);
|
|
if (d && *d)
|
|
st->pubKeyModulus=strdup(d);
|
|
else
|
|
st->pubKeyModulus=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetPubKeyExponent(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->pubKeyExponent;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetPubKeyExponent(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->pubKeyExponent)
|
|
free(st->pubKeyExponent);
|
|
if (d && *d)
|
|
st->pubKeyExponent=strdup(d);
|
|
else
|
|
st->pubKeyExponent=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *GWEN_SslCertDescr_GetStatusText(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->statusText;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetStatusText(GWEN_SSLCERTDESCR *st, const char *d)
|
|
{
|
|
assert(st);
|
|
if (st->statusText)
|
|
free(st->statusText);
|
|
if (d && *d)
|
|
st->statusText=strdup(d);
|
|
else
|
|
st->statusText=0;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
int GWEN_SslCertDescr_GetIsError(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->isError;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetIsError(GWEN_SSLCERTDESCR *st, int d)
|
|
{
|
|
assert(st);
|
|
st->isError=d;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
uint32_t GWEN_SslCertDescr_GetStatusFlags(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->statusFlags;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetStatusFlags(GWEN_SSLCERTDESCR *st, uint32_t d)
|
|
{
|
|
assert(st);
|
|
st->statusFlags=d;
|
|
st->_modified=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
int GWEN_SslCertDescr_IsModified(const GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
return st->_modified;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_SetModified(GWEN_SSLCERTDESCR *st, int i)
|
|
{
|
|
assert(st);
|
|
st->_modified=i;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_Attach(GWEN_SSLCERTDESCR *st)
|
|
{
|
|
assert(st);
|
|
st->_usage++;
|
|
}
|
|
GWEN_SSLCERTDESCR *GWEN_SslCertDescr_List2__freeAll_cb(GWEN_SSLCERTDESCR *st, GWEN_UNUSED void *user_data)
|
|
{
|
|
GWEN_SslCertDescr_free(st);
|
|
return 0;
|
|
}
|
|
|
|
|
|
void GWEN_SslCertDescr_List2_freeAll(GWEN_SSLCERTDESCR_LIST2 *stl)
|
|
{
|
|
if (stl) {
|
|
GWEN_SslCertDescr_List2_ForEach(stl, GWEN_SslCertDescr_List2__freeAll_cb, 0);
|
|
GWEN_SslCertDescr_List2_free(stl);
|
|
}
|
|
}
|
|
|
|
|
|
GWEN_SSLCERTDESCR_LIST *GWEN_SslCertDescr_List_dup(const GWEN_SSLCERTDESCR_LIST *stl)
|
|
{
|
|
if (stl) {
|
|
GWEN_SSLCERTDESCR_LIST *nl;
|
|
GWEN_SSLCERTDESCR *e;
|
|
|
|
nl=GWEN_SslCertDescr_List_new();
|
|
e=GWEN_SslCertDescr_List_First(stl);
|
|
while (e) {
|
|
GWEN_SSLCERTDESCR *ne;
|
|
|
|
ne=GWEN_SslCertDescr_dup(e);
|
|
assert(ne);
|
|
GWEN_SslCertDescr_List_Add(ne, nl);
|
|
e=GWEN_SslCertDescr_List_Next(e);
|
|
} /* while (e) */
|
|
return nl;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|