The Tor Browser / file comparison
comparison: security/nss/cmd/libpkix/perf/libpkix_buildthreads.c
security/nss/cmd/libpkix/perf/libpkix_buildthreads.c
- branch
- TOR_BUG_9701
- changeset 3
- 141e0f1194b1
equal
deleted
inserted
replaced
| -1:000000000000 | 0:18e1716fa556 |
|---|---|
| 1 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 2 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 4 /* | |
| 5 * libpkixBuildThreads.c | |
| 6 * | |
| 7 * libpkix Builder Performance Evaluation application (multi-threaded) | |
| 8 * | |
| 9 */ | |
| 10 | |
| 11 #include <stdio.h> | |
| 12 #include <string.h> | |
| 13 | |
| 14 #include "secutil.h" | |
| 15 | |
| 16 #include "nspr.h" | |
| 17 #include "prtypes.h" | |
| 18 #include "prtime.h" | |
| 19 #include "prlong.h" | |
| 20 | |
| 21 #include "pk11func.h" | |
| 22 #include "secasn1.h" | |
| 23 #include "cert.h" | |
| 24 #include "cryptohi.h" | |
| 25 #include "secoid.h" | |
| 26 #include "certdb.h" | |
| 27 #include "nss.h" | |
| 28 | |
| 29 #include "pkix.h" | |
| 30 #include "pkix_tools.h" | |
| 31 #include "pkix_pl_cert.h" | |
| 32 | |
| 33 #include "testutil.h" | |
| 34 #include "testutil_nss.h" | |
| 35 | |
| 36 static void *plContext = NULL; | |
| 37 | |
| 38 #undef pkixTempResult | |
| 39 #define PERF_DECREF(obj) \ | |
| 40 { \ | |
| 41 PKIX_Error *pkixTempResult = NULL; \ | |
| 42 if (obj){ \ | |
| 43 pkixTempResult = PKIX_PL_Object_DecRef \ | |
| 44 ((PKIX_PL_Object *)(obj), plContext); \ | |
| 45 obj = NULL; \ | |
| 46 } \ | |
| 47 } | |
| 48 | |
| 49 static void finish(char* message, int code); | |
| 50 | |
| 51 typedef struct ThreadDataStr tData; | |
| 52 | |
| 53 struct ThreadDataStr { | |
| 54 CERTCertificate* anchor; | |
| 55 char* eecertName; | |
| 56 PRIntervalTime duration; | |
| 57 CERTCertDBHandle *handle; | |
| 58 PRUint32 iterations; | |
| 59 }; | |
| 60 | |
| 61 #define PKIX_LOGGER_ON 1 | |
| 62 | |
| 63 #ifdef PKIX_LOGGER_ON | |
| 64 | |
| 65 char *logLevels[] = { | |
| 66 "None", | |
| 67 "Fatal Error", | |
| 68 "Error", | |
| 69 "Warning", | |
| 70 "Debug", | |
| 71 "Trace" | |
| 72 }; | |
| 73 | |
| 74 static PKIX_Error *loggerCallback( | |
| 75 PKIX_Logger *logger, | |
| 76 PKIX_PL_String *message, | |
| 77 PKIX_UInt32 logLevel, | |
| 78 PKIX_ERRORCLASS logComponent, | |
| 79 void *plContext) | |
| 80 { | |
| 81 char *msg = NULL; | |
| 82 static int callCount = 0; | |
| 83 | |
| 84 msg = PKIX_String2ASCII(message, plContext); | |
| 85 printf("Logging %s (%s): %s\n", | |
| 86 logLevels[logLevel], | |
| 87 PKIX_ERRORCLASSNAMES[logComponent], | |
| 88 msg); | |
| 89 PR_Free((void *)msg); | |
| 90 | |
| 91 return(NULL); | |
| 92 } | |
| 93 | |
| 94 #endif /* PKIX_LOGGER_ON */ | |
| 95 | |
| 96 static void ThreadEntry(void* data) | |
| 97 { | |
| 98 tData* tdata = (tData*) data; | |
| 99 PRIntervalTime duration = tdata->duration; | |
| 100 PRIntervalTime start = PR_IntervalNow(); | |
| 101 | |
| 102 PKIX_List *anchors = NULL; | |
| 103 PKIX_ProcessingParams *procParams = NULL; | |
| 104 PKIX_BuildResult *buildResult = NULL; | |
| 105 CERTCertificate* nsseecert; | |
| 106 PKIX_PL_Cert *eeCert = NULL; | |
| 107 PKIX_CertStore *certStore = NULL; | |
| 108 PKIX_List *certStores = NULL; | |
| 109 PKIX_ComCertSelParams *certSelParams = NULL; | |
| 110 PKIX_CertSelector *certSelector = NULL; | |
| 111 PKIX_PL_Date *nowDate = NULL; | |
| 112 void *state = NULL; /* only relevant with non-blocking I/O */ | |
| 113 void *nbioContext = NULL; /* only relevant with non-blocking I/O */ | |
| 114 | |
| 115 PR_ASSERT(duration); | |
| 116 if (!duration){ | |
| 117 return; | |
| 118 } | |
| 119 | |
| 120 do { | |
| 121 | |
| 122 /* libpkix code */ | |
| 123 | |
| 124 /* keep more update time, testing cache */ | |
| 125 PKIX_PL_Date_Create_UTCTime(NULL, &nowDate, plContext); | |
| 126 | |
| 127 /* CertUsage is 0x10 and no NSS arena */ | |
| 128 /* We haven't determined how we obtain the value of wincx */ | |
| 129 | |
| 130 nsseecert = CERT_FindCertByNicknameOrEmailAddr(tdata->handle, | |
| 131 tdata->eecertName); | |
| 132 if (!nsseecert) finish("Unable to find eecert.\n", 1); | |
| 133 | |
| 134 pkix_pl_Cert_CreateWithNSSCert | |
| 135 (nsseecert, &eeCert, plContext); | |
| 136 | |
| 137 PKIX_List_Create(&anchors, plContext); | |
| 138 | |
| 139 /* | |
| 140 * This code is retired. | |
| 141 * pkix_pl_Cert_CreateWithNSSCert | |
| 142 * (tdata->anchor, &anchorCert, NULL); | |
| 143 * PKIX_TrustAnchor_CreateWithCert(anchorCert, &anchor, NULL); | |
| 144 * PKIX_List_AppendItem(anchors, (PKIX_PL_Object *)anchor, NULL); | |
| 145 */ | |
| 146 | |
| 147 PKIX_ProcessingParams_Create(anchors, &procParams, plContext); | |
| 148 | |
| 149 PKIX_ProcessingParams_SetRevocationEnabled | |
| 150 (procParams, PKIX_TRUE, plContext); | |
| 151 | |
| 152 PKIX_ProcessingParams_SetDate | |
| 153 (procParams, nowDate, plContext); | |
| 154 | |
| 155 /* create CertSelector with target certificate in params */ | |
| 156 | |
| 157 PKIX_ComCertSelParams_Create(&certSelParams, plContext); | |
| 158 | |
| 159 PKIX_ComCertSelParams_SetCertificate | |
| 160 (certSelParams, eeCert, plContext); | |
| 161 | |
| 162 PKIX_CertSelector_Create | |
| 163 (NULL, NULL, &certSelector, plContext); | |
| 164 | |
| 165 PKIX_CertSelector_SetCommonCertSelectorParams | |
| 166 (certSelector, certSelParams, plContext); | |
| 167 | |
| 168 PKIX_ProcessingParams_SetTargetCertConstraints | |
| 169 (procParams, certSelector, plContext); | |
| 170 | |
| 171 PKIX_PL_Pk11CertStore_Create(&certStore, plContext); | |
| 172 | |
| 173 PKIX_List_Create(&certStores, plContext); | |
| 174 PKIX_List_AppendItem | |
| 175 (certStores, (PKIX_PL_Object *)certStore, plContext); | |
| 176 PKIX_ProcessingParams_SetCertStores | |
| 177 (procParams, certStores, plContext); | |
| 178 | |
| 179 PKIX_BuildChain | |
| 180 (procParams, | |
| 181 &nbioContext, | |
| 182 &state, | |
| 183 &buildResult, | |
| 184 NULL, | |
| 185 plContext); | |
| 186 | |
| 187 /* | |
| 188 * As long as we use only CertStores with blocking I/O, we | |
| 189 * know we must be done at this point. | |
| 190 */ | |
| 191 | |
| 192 if (!buildResult){ | |
| 193 (void) fprintf(stderr, "libpkix BuildChain failed.\n"); | |
| 194 PORT_Assert(0); | |
| 195 return; | |
| 196 } | |
| 197 | |
| 198 tdata->iterations ++; | |
| 199 | |
| 200 PERF_DECREF(nowDate); | |
| 201 PERF_DECREF(anchors); | |
| 202 PERF_DECREF(procParams); | |
| 203 PERF_DECREF(buildResult); | |
| 204 PERF_DECREF(certStore); | |
| 205 PERF_DECREF(certStores); | |
| 206 PERF_DECREF(certSelParams); | |
| 207 PERF_DECREF(certSelector); | |
| 208 PERF_DECREF(eeCert); | |
| 209 | |
| 210 } while ((PR_IntervalNow() - start) < duration); | |
| 211 | |
| 212 | |
| 213 } | |
| 214 | |
| 215 static void | |
| 216 Test( | |
| 217 CERTCertificate* anchor, | |
| 218 char* eecertName, | |
| 219 PRIntervalTime duration, | |
| 220 CERTCertDBHandle *handle, | |
| 221 PRUint32 threads) | |
| 222 { | |
| 223 tData data; | |
| 224 tData** alldata; | |
| 225 PRIntervalTime starttime, endtime, elapsed; | |
| 226 PRUint32 msecs; | |
| 227 float total = 0; | |
| 228 PRThread** pthreads = NULL; | |
| 229 PRUint32 i = 0; | |
| 230 | |
| 231 data.duration = duration; | |
| 232 data.anchor = anchor; | |
| 233 data.eecertName = eecertName; | |
| 234 data.handle = handle; | |
| 235 | |
| 236 data.iterations = 0; | |
| 237 | |
| 238 starttime = PR_IntervalNow(); | |
| 239 pthreads = (PRThread**)PR_Malloc(threads*sizeof (PRThread*)); | |
| 240 alldata = (tData**)PR_Malloc(threads*sizeof (tData*)); | |
| 241 for (i = 0; i < threads; i++){ | |
| 242 alldata[i] = (tData*)PR_Malloc(sizeof (tData)); | |
| 243 *alldata[i] = data; | |
| 244 pthreads[i] = | |
| 245 PR_CreateThread(PR_USER_THREAD, | |
| 246 ThreadEntry, | |
| 247 (void*) alldata[i], | |
| 248 PR_PRIORITY_NORMAL, | |
| 249 PR_GLOBAL_THREAD, | |
| 250 PR_JOINABLE_THREAD, | |
| 251 0); | |
| 252 } | |
| 253 | |
| 254 for (i = 0; i < threads; i++) { | |
| 255 tData* args = alldata[i]; | |
| 256 PR_JoinThread(pthreads[i]); | |
| 257 total += args->iterations; | |
| 258 PR_Free((void*)args); | |
| 259 } | |
| 260 | |
| 261 PR_Free((void*) pthreads); | |
| 262 PR_Free((void*) alldata); | |
| 263 endtime = PR_IntervalNow(); | |
| 264 | |
| 265 endtime = PR_IntervalNow(); | |
| 266 elapsed = endtime - starttime; | |
| 267 msecs = PR_IntervalToMilliseconds(elapsed); | |
| 268 total /= msecs; | |
| 269 total *= 1000; | |
| 270 (void) fprintf(stdout, "%f operations per second.\n", total); | |
| 271 } | |
| 272 | |
| 273 | |
| 274 static void finish(char* message, int code) | |
| 275 { | |
| 276 (void) printf(message); | |
| 277 exit(code); | |
| 278 } | |
| 279 | |
| 280 static void usage(char* progname) | |
| 281 { | |
| 282 (void) printf("Usage : %s <-d certStoreDirectory> <duration> <threads> " | |
| 283 "<anchorNickname> <eecertNickname>\n\n", progname); | |
| 284 finish("", 0); | |
| 285 } | |
| 286 | |
| 287 int | |
| 288 libpkix_buildthreads(int argc, char** argv) | |
| 289 { | |
| 290 CERTCertDBHandle *handle = NULL; | |
| 291 CERTCertificate* eecert = NULL; | |
| 292 PRIntervalTime duration = PR_SecondsToInterval(1); | |
| 293 PRUint32 threads = 1; | |
| 294 PKIX_UInt32 actualMinorVersion; | |
| 295 PKIX_UInt32 j = 0; | |
| 296 PKIX_Logger *logger = NULL; | |
| 297 void *wincx = NULL; | |
| 298 | |
| 299 /* if (argc != 5) -- when TrustAnchor used to be on command line */ | |
| 300 if (argc != 4) | |
| 301 { | |
| 302 usage(argv[0]); | |
| 303 } | |
| 304 if (atoi(argv[1]) > 0) | |
| 305 { | |
| 306 duration = PR_SecondsToInterval(atoi(argv[1])); | |
| 307 } | |
| 308 if (atoi(argv[2]) > 0) | |
| 309 { | |
| 310 threads = atoi(argv[2]); | |
| 311 } | |
| 312 | |
| 313 PKIX_PL_NssContext_Create(certificateUsageEmailSigner, PKIX_FALSE, | |
| 314 NULL, &plContext); | |
| 315 | |
| 316 handle = CERT_GetDefaultCertDB(); | |
| 317 PR_ASSERT(handle); | |
| 318 | |
| 319 #ifdef PKIX_LOGGER_ON | |
| 320 | |
| 321 /* set logger to log trace and up */ | |
| 322 PKIX_SetLoggers(NULL, plContext); | |
| 323 PKIX_Logger_Create(loggerCallback, NULL, &logger, plContext); | |
| 324 PKIX_Logger_SetMaxLoggingLevel | |
| 325 (logger, PKIX_LOGGER_LEVEL_WARNING, plContext); | |
| 326 PKIX_AddLogger(logger, plContext); | |
| 327 | |
| 328 #endif /* PKIX_LOGGER_ON */ | |
| 329 | |
| 330 /* | |
| 331 * This code is retired | |
| 332 * anchor = CERT_FindCertByNicknameOrEmailAddr(handle, argv[3]); | |
| 333 * if (!anchor) finish("Unable to find anchor.\n", 1); | |
| 334 * | |
| 335 * eecert = CERT_FindCertByNicknameOrEmailAddr(handle, argv[4]); | |
| 336 | |
| 337 * if (!eecert) finish("Unable to find eecert.\n", 1); | |
| 338 * | |
| 339 * Test(anchor, eecert, duration, threads); | |
| 340 */ | |
| 341 | |
| 342 Test(NULL, argv[3], duration, handle, threads); | |
| 343 | |
| 344 PERF_DECREF(logger); | |
| 345 | |
| 346 PKIX_Shutdown(plContext); | |
| 347 | |
| 348 return (0); | |
| 349 } |
