s32 cellSslCertificateLoader(u64 flag, vm::ptr<char> buffer, u32 size, vm::ptr<u32> required)
{
cellSsl.trace("cellSslCertificateLoader(flag=%llu, buffer=0x%x, size=%zu, required=0x%x)", flag, buffer, size, required);
const std::bitset<58> flagBits(flag);
const std::string certPath = vfs::get("/dev_flash/") + "data/cert/";
if (required)
{
*required = 0;
for (int i = 1; i <= flagBits.size(); i++)
{
if (!flagBits[i-1])
continue;
// If we're loading cert 6 (the baltimore cert), then we need set that we're loading the 'normal' set of certs.
*required += (u32)(getCert(certPath, i, flagBits[BaltimoreCert-1]).size());
}
}
else
{
std::string final;
for (int i = 1; i <= flagBits.size(); i++)
{
if (!flagBits[i-1])
continue;
// If we're loading cert 6 (the baltimore cert), then we need set that we're loading the 'normal' set of certs.
final.append(getCert(certPath, i, flagBits[BaltimoreCert-1]));
}
memset(buffer.get_ptr(), '\0', size - 1);
memcpy(buffer.get_ptr(), final.c_str(), final.size());
}
CByteArray APL_Certifs::getXML(bool bNoHeader)
{
/*
<certificates count=��>
<certificate>
</certificate>
</certificates>
*/
char buffer[50];
CByteArray xml;
if(!bNoHeader)
xml+="<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
xml+="<certificates count=\"";
sprintf_s(buffer,sizeof(buffer),"%ld",countAll(true));
xml+=buffer;
xml+="\">\n";
for(unsigned long i=0;i<countAll(true);i++)
{
xml+=getCert(i,true)->getXML(true);
}
xml+="</certificates>\n";
return xml;
}
/* verifier
return value: -438: You should send a 438-reply.
-437: You should send a 437-reply.
-436: You should send a 436-reply.
-428: You should send a 428-reply.
-3: Error verifying Date header field.
-2: Authentication service is not authoritative.
-1: An error occured.
1: verification OK
*/
static int verifier_(struct sip_msg* msg, char* str1, char* str2)
{
char identityHF[MAX_IDENTITY] = "\0";
X509 * cert = NULL;
int retval = -1;
STACK_OF(X509) * certchain = NULL;
/* parse all headers */
if (parse_headers(msg, HDR_EOH_F, 0)!=0) {
LM_ERR("failed to parse headers\n");
return -1;
}
retval = getIdentityHF(identityHF, msg);
switch(retval)
{
case 0:
/* Identity header field does not exist */
return -428;
case -1:
LM_ERR("getIdentityHF failed\n");
return -1;
}
if(!getCert(&cert, &certchain, msg))
{
return -436;
}
if(!validateCert(cert, certchain))
{
X509_free(cert);
sk_X509_pop_free(certchain, X509_free);
return -437;
}
sk_X509_pop_free(certchain, X509_free);
if(!checkAuthority(cert, msg))
{
X509_free(cert);
return -2;
}
if(!checkSign(cert, identityHF, msg))
{
X509_free(cert);
return -438;
}
if(!checkDate(cert, msg))
{
X509_free(cert);
return -3;
}
X509_free(cert);
return 1;
}
APL_Certif *APL_Certifs::getRoot(unsigned long ulIndex,bool bOnlyVisible)
{
try
{
return getCert(APL_CERTIF_TYPE_ROOT);
}
catch(CMWException &e)
{
if(e.GetError()==(long)EIDMW_ERR_PARAM_RANGE)
throw CMWEXCEPTION(EIDMW_ERR_CERT_NOROOT);
throw;
}
}
int digidoc::EstEIDSigner::type() const
{
int result = digidoc::Digest::toMethod( Conf::getInstance()->getSignatureUri() );
if( result == NID_sha1 )
return result;
char buf[50];
bool found = false;
CERTIFICATEPOLICIES *cp = (CERTIFICATEPOLICIES*)X509_get_ext_d2i(getCert(), NID_certificate_policies, 0, 0);
for( int i = 0; i < sk_POLICYINFO_num(cp); ++i )
{
memset(buf, 0, 50);
int len = OBJ_obj2txt(buf, 50, sk_POLICYINFO_value(cp, i)->policyid, 1);
if(len != NID_undef &&
(strncmp(buf, "1.3.6.1.4.1.10015.1.2.", 22) == 0 ||
strncmp(buf, "1.3.6.1.4.1.10015.3.2.", 22) == 0))
found = true;
}
sk_POLICYINFO_pop_free(cp, POLICYINFO_free);
if(!found)
return X509Cert(getCert()).getPaddingSize() > 128 ? result : NID_sha224;
return result;
}
CByteArray APL_Certifs::getCSV()
{
/*
certificatescount;certificate1;certificate2;...
*/
char buffer[50];
CByteArray csv;
sprintf_s(buffer,sizeof(buffer),"%ld",countAll(true));
csv+=buffer;
csv+=CSV_SEPARATOR;
for(unsigned long i=0;i<countAll(true);i++)
{
csv+=getCert(i,true)->getCSV();
}
return csv;
}
CByteArray APL_Certifs::getTLV()
{
//First we add all the certs in a tlv
CTLVBuffer tlvNested;
CByteArray baCount;
baCount.AppendLong(countAll(true));
tlvNested.SetTagData(0x00,baCount.GetBytes(),baCount.Size()); //Tag 0x00 contain the number of certificates
unsigned char j=1;
for(unsigned long i=0;i<countAll(true);i++)
{
APL_Certif *cert=getCert(i,true);
CByteArray baCert=cert->getTLV();
tlvNested.SetTagData(j++,baCert.GetBytes(),baCert.Size());
}
unsigned long ulLen=tlvNested.GetLengthNeeded();
unsigned char *pucData= new unsigned char[ulLen];
tlvNested.Extract(pucData,ulLen);
CByteArray baCerts(pucData,ulLen);
delete[] pucData;
//We nest the tlv into the enclosing tlv
CTLVBuffer tlv;
tlv.SetTagData(BEID_TLV_TAG_FILE_CERTS,baCerts.GetBytes(),baCerts.Size());
ulLen=tlv.GetLengthNeeded();
pucData= new unsigned char[ulLen];
tlv.Extract(pucData,ulLen);
CByteArray ba(pucData,ulLen);
delete[] pucData;
return ba;
}
PTEID_Certificate &PTEID_Certificates::getCA()
{
return getCert(PTEID_CERTIF_TYPE_ROOT_AUTH);
}
PTEID_Certificate &PTEID_Certificates::getRoot()
{
return getCert(PTEID_CERTIF_TYPE_ROOT);
}
int
main(int argc, char *argv[], char *envp[])
{
char * certDir = NULL;
char * progName = NULL;
char * oidStr = NULL;
CERTCertificate * cert;
CERTCertificate * firstCert = NULL;
CERTCertificate * issuerCert = NULL;
CERTCertDBHandle * defaultDB = NULL;
PRBool isAscii = PR_FALSE;
PRBool trusted = PR_FALSE;
SECStatus secStatus;
SECCertificateUsage certUsage = certificateUsageSSLServer;
PLOptState * optstate;
PRTime time = 0;
PLOptStatus status;
int usePkix = 0;
int rv = 1;
int usage;
CERTVerifyLog log;
CERTCertList *builtChain = NULL;
PRBool certFetching = PR_FALSE;
int revDataIndex = 0;
PRBool ocsp_fetchingFailureIsAFailure = PR_TRUE;
PRBool useDefaultRevFlags = PR_TRUE;
int vfyCounts = 1;
PR_Init( PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
progName = PL_strdup(argv[0]);
optstate = PL_CreateOptState(argc, argv, "ab:c:d:efg:h:i:m:o:prs:tu:vw:W:");
while ((status = PL_GetNextOpt(optstate)) == PL_OPT_OK) {
switch(optstate->option) {
case 0 : /* positional parameter */ goto breakout;
case 'a' : isAscii = PR_TRUE; break;
case 'b' : secStatus = DER_AsciiToTime(&time, optstate->value);
if (secStatus != SECSuccess) Usage(progName); break;
case 'd' : certDir = PL_strdup(optstate->value); break;
case 'e' : ocsp_fetchingFailureIsAFailure = PR_FALSE; break;
case 'f' : certFetching = PR_TRUE; break;
case 'g' :
if (revMethodsData[revDataIndex].testTypeStr ||
revMethodsData[revDataIndex].methodTypeStr) {
revDataIndex += 1;
if (revDataIndex == REV_METHOD_INDEX_MAX) {
fprintf(stderr, "Invalid revocation configuration"
"specified.\n");
secStatus = SECFailure;
break;
}
}
useDefaultRevFlags = PR_FALSE;
revMethodsData[revDataIndex].
testTypeStr = PL_strdup(optstate->value); break;
case 'h' :
revMethodsData[revDataIndex].
testFlagsStr = PL_strdup(optstate->value);break;
case 'i' : vfyCounts = PORT_Atoi(optstate->value); break;
break;
case 'm' :
if (revMethodsData[revDataIndex].methodTypeStr) {
revDataIndex += 1;
if (revDataIndex == REV_METHOD_INDEX_MAX) {
fprintf(stderr, "Invalid revocation configuration"
"specified.\n");
secStatus = SECFailure;
break;
}
}
useDefaultRevFlags = PR_FALSE;
revMethodsData[revDataIndex].
methodTypeStr = PL_strdup(optstate->value); break;
case 'o' : oidStr = PL_strdup(optstate->value); break;
case 'p' : usePkix += 1; break;
case 'r' : isAscii = PR_FALSE; break;
case 's' :
revMethodsData[revDataIndex].
methodFlagsStr = PL_strdup(optstate->value); break;
case 't' : trusted = PR_TRUE; break;
case 'u' : usage = PORT_Atoi(optstate->value);
if (usage < 0 || usage > 62) Usage(progName);
certUsage = ((SECCertificateUsage)1) << usage;
if (certUsage > certificateUsageHighest) Usage(progName);
break;
case 'w':
pwdata.source = PW_PLAINTEXT;
pwdata.data = PORT_Strdup(optstate->value);
break;
case 'W':
pwdata.source = PW_FROMFILE;
pwdata.data = PORT_Strdup(optstate->value);
break;
case 'v' : verbose++; break;
default : Usage(progName); break;
}
}
breakout:
if (status != PL_OPT_OK)
Usage(progName);
if (usePkix < 2) {
if (oidStr) {
fprintf(stderr, "Policy oid(-o) can be used only with"
" CERT_PKIXVerifyChain(-pp) function.\n");
Usage(progName);
}
if (trusted) {
fprintf(stderr, "Cert trust flag can be used only with"
" CERT_PKIXVerifyChain(-pp) function.\n");
Usage(progName);
}
}
if (!useDefaultRevFlags && parseRevMethodsAndFlags()) {
fprintf(stderr, "Invalid revocation configuration specified.\n");
goto punt;
}
/* Set our password function callback. */
PK11_SetPasswordFunc(SECU_GetModulePassword);
/* Initialize the NSS libraries. */
if (certDir) {
secStatus = NSS_Init(certDir);
} else {
secStatus = NSS_NoDB_Init(NULL);
/* load the builtins */
SECMOD_AddNewModule("Builtins", DLL_PREFIX"nssckbi."DLL_SUFFIX, 0, 0);
}
if (secStatus != SECSuccess) {
exitErr("NSS_Init");
}
SECU_RegisterDynamicOids();
if (isOCSPEnabled()) {
CERT_EnableOCSPChecking(CERT_GetDefaultCertDB());
CERT_DisableOCSPDefaultResponder(CERT_GetDefaultCertDB());
if (!ocsp_fetchingFailureIsAFailure) {
CERT_SetOCSPFailureMode(ocspMode_FailureIsNotAVerificationFailure);
}
}
while (status == PL_OPT_OK) {
switch(optstate->option) {
default : Usage(progName); break;
case 'a' : isAscii = PR_TRUE; break;
case 'r' : isAscii = PR_FALSE; break;
case 't' : trusted = PR_TRUE; break;
case 0 : /* positional parameter */
if (usePkix < 2 && trusted) {
fprintf(stderr, "Cert trust flag can be used only with"
" CERT_PKIXVerifyChain(-pp) function.\n");
Usage(progName);
}
cert = getCert(optstate->value, isAscii, progName);
if (!cert)
goto punt;
rememberCert(cert, trusted);
if (!firstCert)
firstCert = cert;
trusted = PR_FALSE;
}
status = PL_GetNextOpt(optstate);
}
PL_DestroyOptState(optstate);
if (status == PL_OPT_BAD || !firstCert)
Usage(progName);
/* Initialize log structure */
log.arena = PORT_NewArena(512);
log.head = log.tail = NULL;
log.count = 0;
do {
if (usePkix < 2) {
/* NOW, verify the cert chain. */
if (usePkix) {
/* Use old API with libpkix validation lib */
CERT_SetUsePKIXForValidation(PR_TRUE);
}
if (!time)
time = PR_Now();
defaultDB = CERT_GetDefaultCertDB();
secStatus = CERT_VerifyCertificate(defaultDB, firstCert,
PR_TRUE /* check sig */,
certUsage,
time,
&pwdata, /* wincx */
&log, /* error log */
NULL);/* returned usages */
} else do {
static CERTValOutParam cvout[4];
static CERTValInParam cvin[6];
SECOidTag oidTag;
int inParamIndex = 0;
static PRUint64 revFlagsLeaf[2];
static PRUint64 revFlagsChain[2];
static CERTRevocationFlags rev;
if (oidStr) {
PRArenaPool *arena;
SECOidData od;
memset(&od, 0, sizeof od);
od.offset = SEC_OID_UNKNOWN;
od.desc = "User Defined Policy OID";
od.mechanism = CKM_INVALID_MECHANISM;
od.supportedExtension = INVALID_CERT_EXTENSION;
arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
if ( !arena ) {
fprintf(stderr, "out of memory");
goto punt;
}
secStatus = SEC_StringToOID(arena, &od.oid, oidStr, 0);
if (secStatus != SECSuccess) {
PORT_FreeArena(arena, PR_FALSE);
fprintf(stderr, "Can not encode oid: %s(%s)\n", oidStr,
SECU_Strerror(PORT_GetError()));
break;
}
oidTag = SECOID_AddEntry(&od);
PORT_FreeArena(arena, PR_FALSE);
if (oidTag == SEC_OID_UNKNOWN) {
fprintf(stderr, "Can not add new oid to the dynamic "
"table: %s\n", oidStr);
secStatus = SECFailure;
break;
}
cvin[inParamIndex].type = cert_pi_policyOID;
cvin[inParamIndex].value.arraySize = 1;
cvin[inParamIndex].value.array.oids = &oidTag;
inParamIndex++;
}
if (trustedCertList) {
cvin[inParamIndex].type = cert_pi_trustAnchors;
cvin[inParamIndex].value.pointer.chain = trustedCertList;
inParamIndex++;
}
cvin[inParamIndex].type = cert_pi_useAIACertFetch;
cvin[inParamIndex].value.scalar.b = certFetching;
inParamIndex++;
rev.leafTests.cert_rev_flags_per_method = revFlagsLeaf;
rev.chainTests.cert_rev_flags_per_method = revFlagsChain;
secStatus = configureRevocationParams(&rev);
if (secStatus) {
fprintf(stderr, "Can not config revocation parameters ");
break;
}
cvin[inParamIndex].type = cert_pi_revocationFlags;
cvin[inParamIndex].value.pointer.revocation = &rev;
inParamIndex++;
if (time) {
cvin[inParamIndex].type = cert_pi_date;
cvin[inParamIndex].value.scalar.time = time;
inParamIndex++;
}
cvin[inParamIndex].type = cert_pi_end;
cvout[0].type = cert_po_trustAnchor;
cvout[0].value.pointer.cert = NULL;
cvout[1].type = cert_po_certList;
cvout[1].value.pointer.chain = NULL;
/* setting pointer to CERTVerifyLog. Initialized structure
* will be used CERT_PKIXVerifyCert */
cvout[2].type = cert_po_errorLog;
cvout[2].value.pointer.log = &log;
cvout[3].type = cert_po_end;
secStatus = CERT_PKIXVerifyCert(firstCert, certUsage,
cvin, cvout, &pwdata);
if (secStatus != SECSuccess) {
break;
}
issuerCert = cvout[0].value.pointer.cert;
builtChain = cvout[1].value.pointer.chain;
} while (0);
/* Display validation results */
if (secStatus != SECSuccess || log.count > 0) {
CERTVerifyLogNode *node = NULL;
PRIntn err = PR_GetError();
fprintf(stderr, "Chain is bad, %d = %s\n", err, SECU_Strerror(err));
SECU_displayVerifyLog(stderr, &log, verbose);
/* Have cert refs in the log only in case of failure.
* Destroy them. */
for (node = log.head; node; node = node->next) {
if (node->cert)
CERT_DestroyCertificate(node->cert);
}
rv = 1;
} else {
fprintf(stderr, "Chain is good!\n");
if (issuerCert) {
if (verbose > 1) {
rv = SEC_PrintCertificateAndTrust(issuerCert, "Root Certificate",
NULL);
if (rv != SECSuccess) {
SECU_PrintError(progName, "problem printing certificate");
}
} else if (verbose > 0) {
SECU_PrintName(stdout, &issuerCert->subject, "Root "
"Certificate Subject:", 0);
}
CERT_DestroyCertificate(issuerCert);
}
if (builtChain) {
CERTCertListNode *node;
int count = 0;
char buff[256];
if (verbose) {
for(node = CERT_LIST_HEAD(builtChain); !CERT_LIST_END(node, builtChain);
node = CERT_LIST_NEXT(node), count++ ) {
sprintf(buff, "Certificate %d Subject", count + 1);
SECU_PrintName(stdout, &node->cert->subject, buff, 0);
}
}
CERT_DestroyCertList(builtChain);
}
rv = 0;
}
} while (--vfyCounts > 0);
/* Need to destroy CERTVerifyLog arena at the end */
PORT_FreeArena(log.arena, PR_FALSE);
punt:
forgetCerts();
if (NSS_Shutdown() != SECSuccess) {
SECU_PrintError(progName, "NSS_Shutdown");
rv = 1;
}
PORT_Free(progName);
PORT_Free(certDir);
PORT_Free(oidStr);
freeRevocationMethodData();
if (pwdata.data) {
PORT_Free(pwdata.data);
}
PR_Cleanup();
return rv;
}
APL_Certif *APL_Certifs::getCA(unsigned long ulIndex,bool bOnlyVisible)
{
return getCert(APL_CERTIF_TYPE_CA);
}
APL_Certif *APL_Certifs::getAuthentication(unsigned long ulIndex,bool bOnlyVisible)
{
return getCert(APL_CERTIF_TYPE_AUTHENTICATION);
}
bool isSsl() const { return getCert() && getKey(); }
PTEID_Certificate &PTEID_Certificates::getAuthentication()
{
return getCert(PTEID_CERTIF_TYPE_AUTHENTICATION);
}
APL_Certif *APL_Certifs::getSignature(unsigned long ulIndex,bool bOnlyVisible)
{
return getCert(APL_CERTIF_TYPE_SIGNATURE);
}
PTEID_Certificate &PTEID_Certificates::getSignature()
{
return getCert(PTEID_CERTIF_TYPE_SIGNATURE);
}
int getFileFromUrl(char * url, char * dest,
struct loaderData_s * loaderData) {
char ret[47];
struct iurlinfo ui;
enum urlprotocol_t proto =
!strncmp(url, "ftp://", 6) ? URL_METHOD_FTP : URL_METHOD_HTTP;
char * host = NULL, * file = NULL, * chptr = NULL;
char * user = NULL, * password = NULL;
int fd, rc;
struct networkDeviceConfig netCfg;
char * ehdrs = NULL;
ip_addr_t *tip;
#ifdef ROCKS
char *drivername;
#endif
#ifdef ROCKS
/*
* Call non-interactive, exhaustive NetworkUp() if we are
* a cluster appliance.
*/
if (!strlen(url)) {
logMessage(INFO, "ROCKS:getFileFromUrl:calling rocksNetworkUp");
rc = rocksNetworkUp(loaderData, &netCfg);
} else {
logMessage(INFO, "ROCKS:getFileFromUrl:calling kickstartNetworkUp");
rc = kickstartNetworkUp(loaderData, &netCfg);
}
if (rc) return 1;
fd = 0;
/*
* this will be used when starting up mini_httpd()
*
* Get the nextServer from PUMP if we DHCP, otherwise it
* better be on the command line.
*/
if ( netCfg.dev.set & PUMP_INTFINFO_HAS_BOOTFILE ) {
tip = &(netCfg.dev.nextServer);
inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip));
if (strlen(ret) > 0) {
loaderData->nextServer = strdup(ret);
} else {
loaderData->nextServer = NULL;
}
}
/*
* If no nextServer use the gateway.
*/
if ( !loaderData->nextServer ) {
loaderData->nextServer = strdup(loaderData->gateway);
}
logMessage(INFO, "%s: nextServer %s",
"ROCKS:getFileFromUrl", loaderData->nextServer);
#else
if (kickstartNetworkUp(loaderData, &netCfg)) {
logMessage(ERROR, "unable to bring up network");
return 1;
}
#endif /* ROCKS */
memset(&ui, 0, sizeof(ui));
ui.protocol = proto;
#ifdef ROCKS
{
struct sockaddr_in *sin;
int string_size;
int ncpus;
char np[16];
char *arch;
char *base;
#if defined(__i386__)
arch = "i386";
#elif defined(__ia64__)
arch = "ia64";
#elif defined(__x86_64__)
arch = "x86_64";
#endif
if (!strlen(url)) {
base = strdup("install/sbin/kickstart.cgi");
host = strdup(loaderData->nextServer);
}
else {
char *p, *q;
base = NULL;
host = NULL;
p = strstr(url, "//");
if (p != NULL) {
p += 2;
/*
* 'base' is the file name
*/
base = strchr(p, '/');
if (base != NULL) {
base += 1;
}
/*
* now get the host portion of the URL
*/
q = strchr(p, '/');
if (q != NULL) {
*q = '\0';
host = strdup(p);
}
}
if (!base || !host) {
logMessage(ERROR,
"kickstartFromUrl:url (%s) not well formed.\n",
url);
return(1);
}
}
/* We always retrieve our kickstart file via HTTPS,
* however the official install method (for *.img and rpms)
* is still HTTP.
*/
ui.protocol = URL_METHOD_HTTPS;
winStatus(40, 3, _("Secure Kickstart"),
_("Looking for Kickstart keys..."));
getCert(loaderData);
newtPopWindow();
/* seed random number generator with our IP: unique for our purposes.
* Used for nack backoff.
*/
tip = &(netCfg.dev.nextServer);
sin = (struct sockaddr_in *)IP_ADDR(tip);
if (sin == NULL) {
srand(time(NULL));
} else {
srand((unsigned int)sin->sin_addr.s_addr);
}
ncpus = num_cpus();
sprintf(np, "%d", ncpus);
string_size = strlen(base) + strlen("?arch=") + strlen(arch) +
strlen("&np=") + strlen(np) + 1;
if ((file = alloca(string_size)) == NULL) {
logMessage(ERROR, "kickstartFromUrl:alloca failed\n");
return(1);
}
memset(file, 0, string_size);
sprintf(file, "/%s?arch=%s&np=%s", base, arch, np);
}
logMessage(INFO, "ks location: https://%s%s", host, file);
#else
tip = &(netCfg.dev.ip);
inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip));
getHostPathandLogin((proto == URL_METHOD_FTP ? url + 6 : url + 7),
&host, &file, &user, &password, ret);
logMessage(INFO, "file location: %s://%s/%s",
(proto == URL_METHOD_FTP ? "ftp" : "http"), host, file);
#endif /* ROCKS */
chptr = strchr(host, '/');
if (chptr == NULL) {
ui.address = strdup(host);
ui.prefix = strdup("/");
} else {
*chptr = '\0';
ui.address = strdup(host);
host = chptr;
*host = '/';
ui.prefix = strdup(host);
}
if (user && strlen(user)) {
ui.login = strdup(user);
if (password && strlen(password)) ui.password = strdup(password);
}
if (proto == URL_METHOD_HTTP) {
ehdrs = (char *) malloc(24+strlen(VERSION));
sprintf(ehdrs, "User-Agent: anaconda/%s\r\n", VERSION);
}
if (proto == URL_METHOD_HTTP && FL_KICKSTART_SEND_MAC(flags)) {
/* find all ethernet devices and make a header entry for each one */
int i;
unsigned int hdrlen;
char *dev, *mac, tmpstr[128];
struct device ** devices;
hdrlen = 0;
devices = probeDevices(CLASS_NETWORK, BUS_UNSPEC, PROBE_LOADED);
for (i = 0; devices && devices[i]; i++) {
dev = devices[i]->device;
mac = nl_mac2str(dev);
#ifdef ROCKS
drivername = get_driver_name(dev);
#endif
if (mac) {
#ifdef ROCKS
/* A hint as to our primary interface. */
if (!strcmp(dev, loaderData->netDev)) {
snprintf(tmpstr, sizeof(tmpstr),
"X-RHN-Provisioning-MAC-%d: %s %s %s ks\r\n",
i, dev, mac, drivername);
} else {
snprintf(tmpstr, sizeof(tmpstr),
"X-RHN-Provisioning-MAC-%d: %s %s %s\r\n",
i, dev, mac, drivername);
}
#else
snprintf(tmpstr, sizeof(tmpstr),
"X-RHN-Provisioning-MAC-%d: %s %s\r\n", i, dev, mac);
#endif /* ROCKS */
#ifdef ROCKS
free(drivername);
#endif
free(mac);
if (!ehdrs) {
hdrlen = 128;
ehdrs = (char *) malloc(hdrlen);
*ehdrs = '\0';
} else if ( strlen(tmpstr) + strlen(ehdrs) + 2 > hdrlen) {
hdrlen += 128;
ehdrs = (char *) realloc(ehdrs, hdrlen);
}
strcat(ehdrs, tmpstr);
}
}
}
#ifdef ROCKS
{
/* Retrieve the kickstart file via HTTPS */
BIO *sbio;
sbio = urlinstStartSSLTransfer(&ui, file, ehdrs, 1, flags,
loaderData->nextServer);
if (!sbio) {
logMessage(ERROR, "failed to retrieve https://%s/%s",
ui.address, file);
return 1;
}
rc = copyFileSSL(sbio, dest);
if (rc) {
unlink (dest);
logMessage(ERROR, "failed to copy file to %s", dest);
return 1;
}
urlinstFinishSSLTransfer(sbio);
if (haveCertificate())
umount("/mnt/rocks-disk");
}
#else
fd = urlinstStartTransfer(&ui, file, ehdrs);
if (fd < 0) {
logMessage(ERROR, "failed to retrieve http://%s/%s/%s", ui.address, ui.prefix, file);
if (ehdrs) free(ehdrs);
return 1;
}
rc = copyFileFd(fd, dest);
if (rc) {
unlink (dest);
logMessage(ERROR, "failed to copy file to %s", dest);
if (ehdrs) free(ehdrs);
return 1;
}
urlinstFinishTransfer(&ui, fd);
#endif /* ROCKS */
if (ehdrs) free(ehdrs);
return 0;
}
