1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/security/nss/cmd/pk11util/pk11util.c Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,2160 @@
1.4 +/* This Source Code Form is subject to the terms of the Mozilla Public
1.5 + * License, v. 2.0. If a copy of the MPL was not distributed with this
1.6 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
1.7 +
1.8 +
1.9 +#include <stdio.h>
1.10 +#include <string.h>
1.11 +
1.12 +#if defined(WIN32)
1.13 +#undef __STDC__
1.14 +#include "fcntl.h"
1.15 +#include "io.h"
1.16 +#include <fcntl.h>
1.17 +#else
1.18 +#include <unistd.h>
1.19 +#include <fcntl.h>
1.20 +#endif
1.21 +
1.22 +#include "secutil.h"
1.23 +
1.24 +
1.25 +#include "nspr.h"
1.26 +#include "prtypes.h"
1.27 +#include "prtime.h"
1.28 +#include "prlong.h"
1.29 +#include "prinrval.h"
1.30 +#include "prenv.h"
1.31 +
1.32 +#include "pkcs11.h"
1.33 +
1.34 +#include "pk11table.h"
1.35 +
1.36 +#ifndef O_BINARY
1.37 +#define O_BINARY 0
1.38 +#endif
1.39 +
1.40 +CK_ULONG systemFlags;
1.41 +#define FLAG_NEGATE 0x80000000
1.42 +#define FLAG_Verify 0x00000001
1.43 +#define FLAG_VerifyFile 0x00000002
1.44 +#define CKR_QUIT 0x80000000
1.45 +
1.46 +int ArgSize(ArgType type);
1.47 +const char *constLookup(const char *bp, CK_ULONG *value, ConstType *type);
1.48 +
1.49 +int
1.50 +isNum(char c)
1.51 +{
1.52 + return (c >= '0' && c <= '9');
1.53 +}
1.54 +
1.55 +int
1.56 +isConst(const char *c)
1.57 +{
1.58 + CK_ULONG value;
1.59 + ConstType type;
1.60 +
1.61 + constLookup(c, &value, &type);
1.62 + return type != ConstNone;
1.63 +}
1.64 +
1.65 +/*
1.66 + * see if the variable is really a 'size' function. This
1.67 + * function may modify var if it is a size function.
1.68 + */
1.69 +char *
1.70 +isSize(char *var, int *isArray)
1.71 +{
1.72 + char *ptr = NULL;
1.73 + char *end;
1.74 + int array = 0;
1.75 +
1.76 + if (PL_strncasecmp(var,"sizeof(",/*)*/ 7) == 0) {
1.77 + ptr = var + 7;
1.78 + } else if (PL_strncasecmp(var,"size(",/*)*/ 5) == 0) {
1.79 + ptr = var + 5;
1.80 + } else if (PL_strncasecmp(var,"sizeofarray(",/*)*/ 12) == 0) {
1.81 + ptr = var + 12;
1.82 + array = 1;
1.83 + } else if (PL_strncasecmp(var,"sizea(",/*)*/ 6) == 0) {
1.84 + ptr = var + 6;
1.85 + array = 1;
1.86 + } else {
1.87 + return NULL;
1.88 + }
1.89 + end = strchr(ptr,/*(*/ ')') ;
1.90 + if (end == NULL) {
1.91 + return NULL;
1.92 + }
1.93 + if (isArray) *isArray = array;
1.94 + *end = 0;
1.95 + return ptr;
1.96 +}
1.97 +
1.98 +void
1.99 +printConst(CK_ULONG value, ConstType type, int newLine)
1.100 +{
1.101 + int i;
1.102 +
1.103 + for (i=0; i < constCount; i++) {
1.104 + if (consts[i].type == type && consts[i].value == value) {
1.105 + printf("%s",consts[i].name);
1.106 + break;
1.107 + }
1.108 + if (type == ConstNone && consts[i].value == value) {
1.109 + printf("%s",consts[i].name);
1.110 + break;
1.111 + }
1.112 + }
1.113 + if (i == constCount) {
1.114 + if ((type == ConstAvailableSizes) || (type == ConstCurrentSize)) {
1.115 + printf("%lu",value);
1.116 + } else {
1.117 + printf("Unknown %s (%lu:0x%lx)",constTypeString[type],value,value);
1.118 + }
1.119 + }
1.120 + if (newLine) {
1.121 + printf("\n");
1.122 + }
1.123 +}
1.124 +
1.125 +ConstType
1.126 +getConstFromAttribute(CK_ATTRIBUTE_TYPE type)
1.127 +{
1.128 + int i;
1.129 +
1.130 + for (i=0; i < constCount; i++) {
1.131 + if (consts[i].type == ConstAttribute && consts[i].value == type) {
1.132 + return consts[i].attrType;
1.133 + }
1.134 + }
1.135 + return ConstNone;
1.136 +}
1.137 +
1.138 +void
1.139 +printChars(const char *name, CK_ULONG size)
1.140 +{
1.141 + CK_ULONG i;
1.142 + for (i=0; i < size; i++) {
1.143 + if (name[i] == 0) {
1.144 + break;
1.145 + }
1.146 + printf("%c",name[i]);
1.147 + }
1.148 + printf("\n");
1.149 +}
1.150 +
1.151 +#define DUMP_LEN 16
1.152 +void printDump(const unsigned char *buf, int size)
1.153 +{
1.154 + int i,j;
1.155 +
1.156 + for(i=0; i < size; i+= DUMP_LEN) {
1.157 + printf(" ");
1.158 + for (j=0; j< DUMP_LEN; j++) {
1.159 + if (i+j < size) {
1.160 + printf("%02x ",buf[i+j]);
1.161 + } else {
1.162 + printf(" ");
1.163 + }
1.164 + }
1.165 + for (j=0; j< DUMP_LEN; j++) {
1.166 + if (i+j < size) {
1.167 + if (buf[i+j] < ' ' || buf[i+j] >= 0x7f) {
1.168 + printf(".");
1.169 + } else {
1.170 + printf("%c",buf[i+j]);
1.171 + }
1.172 + } else {
1.173 + printf(" ");
1.174 + }
1.175 + }
1.176 + printf("\n");
1.177 + }
1.178 +}
1.179 +
1.180 +/*
1.181 + * free an argument structure
1.182 + */
1.183 +void
1.184 +argFreeData(Value *arg)
1.185 +{
1.186 + if (arg->data && ((arg->type & ArgStatic) == 0)) {
1.187 + if ((arg->type & ArgMask) == ArgAttribute) {
1.188 + int i;
1.189 + CK_ATTRIBUTE *template = (CK_ATTRIBUTE *)arg->data;
1.190 +
1.191 + for (i=0; i < arg->arraySize; i++) {
1.192 + free(template[i].pValue);
1.193 + }
1.194 + }
1.195 + if ((arg->type & ArgMask) == ArgInitializeArgs) {
1.196 + CK_C_INITIALIZE_ARGS *init = (CK_C_INITIALIZE_ARGS *)arg->data;
1.197 + if (init->LibraryParameters) {
1.198 + free(init->LibraryParameters);
1.199 + }
1.200 + }
1.201 + free(arg->data);
1.202 + }
1.203 + arg->type &= ~ArgStatic;
1.204 + arg->data = NULL;
1.205 +}
1.206 +
1.207 +void
1.208 +argFree(Value *arg)
1.209 +{
1.210 + if (arg == NULL) return;
1.211 +
1.212 + arg->reference--;
1.213 + if (arg->reference == 0) {
1.214 + if (arg->type & ArgFile) {
1.215 + free(arg->filename);
1.216 + }
1.217 + argFreeData(arg);
1.218 + free (arg);
1.219 + }
1.220 +}
1.221 +
1.222 +/*
1.223 + * free and argument list
1.224 + */
1.225 +void
1.226 +parseFree(Value **ap)
1.227 +{
1.228 + int i;
1.229 + for (i=0 ; i < MAX_ARGS; i++) {
1.230 + argFree(ap[i]);
1.231 + }
1.232 +}
1.233 +
1.234 +/*
1.235 + * getEnd: how for to the end of this argmument list?
1.236 + */
1.237 +int
1.238 +getEnd(const char *bp)
1.239 +{
1.240 + int count = 0;
1.241 +
1.242 + while (*bp) {
1.243 + if (*bp == ' ' || *bp == '\t' || *bp == '\n') return count;
1.244 + count++;
1.245 + bp++;
1.246 + }
1.247 + return (count);
1.248 +}
1.249 +
1.250 +
1.251 +/*
1.252 + * strip: return the first none white space character
1.253 + */
1.254 +const char *
1.255 +strip(const char *bp)
1.256 +{
1.257 + while (*bp && (*bp == ' ' || *bp == '\t' || *bp == '\n')) bp++;
1.258 + return bp;
1.259 +}
1.260 +
1.261 +/*
1.262 + * read in the next argument into dp ... don't overflow
1.263 + */
1.264 +const char *
1.265 +readChars(const char *bp, char *dp, int max )
1.266 +{
1.267 + int count = 1;
1.268 + while (*bp) {
1.269 + if (*bp == ' ' || *bp == '\t' || *bp == '\n' ) {
1.270 + *dp = 0;
1.271 + return bp;
1.272 + }
1.273 + *dp++ = *bp++;
1.274 + if (++count == max) break;
1.275 + }
1.276 + while (*bp && (*bp != ' ' && *bp != '\t' && *bp != '\n')) bp++;
1.277 + *dp = 0;
1.278 + return (bp);
1.279 +}
1.280 +
1.281 +Value * varLookup(const char *bp, char *vname, int max, int *error);
1.282 +
1.283 +CK_ULONG
1.284 +getValue(const char *v, int *error)
1.285 +{
1.286 + Value * varVal = NULL;
1.287 + CK_ULONG retVal = 0;
1.288 + ConstType type;
1.289 + char tvar[512];
1.290 +
1.291 + *error = 0;
1.292 +
1.293 + varVal = varLookup( v, tvar, sizeof(tvar), error);
1.294 +
1.295 + if (varVal) {
1.296 + if ((varVal->type & ArgMask) == ArgULong) {
1.297 + retVal = *(CK_ULONG *)varVal->data;
1.298 + } else {
1.299 + fprintf(stderr,"%s: is not a ulong\n", v);
1.300 + *error = 1;
1.301 + }
1.302 + argFree(varVal);
1.303 + return retVal;
1.304 + }
1.305 + constLookup(v, &retVal, &type);
1.306 + return retVal;
1.307 +}
1.308 +
1.309 +Value *
1.310 +NewValue(ArgType type, CK_ULONG arraySize)
1.311 +{
1.312 + Value *value;
1.313 +
1.314 + value = (Value *)malloc(sizeof(Value));
1.315 + if (!value) return NULL;
1.316 + value->size = ArgSize(type)*arraySize;
1.317 + value->type = type;
1.318 + value->filename = NULL;
1.319 + value->constType = ConstNone;
1.320 + value->data = (void *)malloc(value->size);
1.321 + if (!value->data) {
1.322 + free(value);
1.323 + return NULL;
1.324 + }
1.325 + value->reference = 1;
1.326 + value->arraySize = (type == ArgChar) ? 1: arraySize;
1.327 +
1.328 + memset(value->data, 0, value->size);
1.329 + return value;
1.330 +}
1.331 +
1.332 +#define INVALID_INDEX 0xffffffff
1.333 +
1.334 +CK_ULONG
1.335 +handleArray(char *vname, int *error)
1.336 +{
1.337 + char *bracket;
1.338 + CK_ULONG index = INVALID_INDEX;
1.339 +
1.340 + if ((bracket = strchr(vname,'[')) != 0) {
1.341 + char *tmpv = bracket+1;
1.342 + *bracket = 0;
1.343 + bracket = strchr(tmpv,']');
1.344 +
1.345 + if (bracket == 0) {
1.346 + fprintf(stderr,"%s: missing closing brace\n", vname);
1.347 + return INVALID_INDEX;
1.348 + }
1.349 + *bracket = 0;
1.350 +
1.351 + index = getValue(tmpv, error);
1.352 + if (*error == 1) {
1.353 + return INVALID_INDEX;
1.354 + } else if (index == INVALID_INDEX) {
1.355 + fprintf(stderr, "%s: 0x%lx is an invalid index\n",vname,index);
1.356 + *error = 1;
1.357 + }
1.358 + }
1.359 + return index;
1.360 +}
1.361 +
1.362 +void *
1.363 +makeArrayTarget(const char *vname, const Value *value, CK_ULONG index)
1.364 +{
1.365 + char * target;
1.366 + CK_ULONG elementSize;
1.367 +
1.368 + if (index >= (CK_ULONG)value->arraySize) {
1.369 + fprintf(stderr, "%s[%lu]: index larger than array size (%d)\n",
1.370 + vname, index, value->arraySize);
1.371 + return NULL;
1.372 + }
1.373 +
1.374 + target = (char *)value->data;
1.375 + elementSize = value->size/value->arraySize;
1.376 + target += index * elementSize;
1.377 + return target;
1.378 +}
1.379 +
1.380 +/*
1.381 + * look up a variable from the variable chain
1.382 + */
1.383 +static Variable *varHead = NULL;
1.384 +Value *
1.385 +varLookup(const char *bp, char *vname, int max, int *error)
1.386 +{
1.387 + Variable *current;
1.388 + CK_ULONG index = INVALID_INDEX;
1.389 + int isArray = 0;
1.390 + char *ptr;
1.391 + *error = 0;
1.392 +
1.393 + if (bp != NULL) {
1.394 + readChars(bp, vname, max);
1.395 + }
1.396 +
1.397 + /* don't make numbers into variables */
1.398 + if (isNum(vname[0])) {
1.399 + return NULL;
1.400 + }
1.401 + /* nor consts */
1.402 + if (isConst(vname)) {
1.403 + return NULL;
1.404 + }
1.405 + /* handle sizeof() */
1.406 + if ((ptr = isSize(vname, &isArray)) != NULL) {
1.407 + CK_ULONG size;
1.408 + Value *targetValue = NULL;
1.409 + Value *sourceValue = varLookup(NULL, ptr, 0, error);
1.410 + if (!sourceValue) {
1.411 + if (*error == 0) {
1.412 + /* just didn't find it */
1.413 + *error = 1;
1.414 + fprintf(stderr,"Couldn't find variable %s to take size of\n",
1.415 + ptr);
1.416 + return NULL;
1.417 + }
1.418 + }
1.419 + size = isArray ? sourceValue->arraySize : sourceValue->size;
1.420 + targetValue = NewValue(ArgULong,1);
1.421 + memcpy(targetValue->data, &size, sizeof(size));
1.422 +
1.423 + return targetValue;
1.424 + }
1.425 +
1.426 + /* modifies vname */
1.427 + index = handleArray(vname, error);
1.428 + if (*error == 1) {
1.429 + return NULL;
1.430 + }
1.431 +
1.432 + for (current = varHead; current; current = current->next) {
1.433 + if (PL_strcasecmp(current->vname, vname) == 0) {
1.434 + char *target;
1.435 + if (index == INVALID_INDEX) {
1.436 + (current->value->reference)++;
1.437 + return current->value;
1.438 + }
1.439 + target = makeArrayTarget(vname, current->value, index);
1.440 + if (target) {
1.441 + Value *element = NewValue(current->value->type, 1);
1.442 + if (!element) {
1.443 + fprintf(stderr, "MEMORY ERROR!\n");
1.444 + *error = 1;
1.445 + }
1.446 + argFreeData(element);
1.447 + element->data = target;
1.448 + element->type |= ArgStatic;
1.449 + return element;
1.450 + }
1.451 + *error = 1;
1.452 + return NULL;
1.453 + }
1.454 + }
1.455 + return NULL;
1.456 +}
1.457 +
1.458 +static CK_RV
1.459 +list(void)
1.460 +{
1.461 + Variable *current;
1.462 +
1.463 + if (varHead) {
1.464 + printf(" %10s\t%16s\t%8s\tSize\tElements\n","Name","Type","Const");
1.465 + } else {
1.466 + printf(" no variables set\n");
1.467 + }
1.468 +
1.469 + for (current = varHead; current; current = current->next) {
1.470 + printf(" %10s\t%16s\t%8s\t%d\t%d\n", current->vname,
1.471 + valueString[current->value->type&ArgMask],
1.472 + constTypeString[current->value->constType],
1.473 + current->value->size, current->value->arraySize);
1.474 + }
1.475 + return CKR_OK;
1.476 +}
1.477 +
1.478 +CK_RV
1.479 +printFlags(const char *s, CK_ULONG flags, ConstType type)
1.480 +{
1.481 + CK_ULONG i;
1.482 + int needComma = 0;
1.483 +
1.484 + printf("%s",s);
1.485 + for (i=1; i ; i=i << 1) {
1.486 + if (flags & i) {
1.487 + printf("%s",needComma?",":"");
1.488 + printConst(i, type, 0);
1.489 + needComma=1;
1.490 + }
1.491 + }
1.492 + if (!needComma) {
1.493 + printf("Empty");
1.494 + }
1.495 + printf("\n");
1.496 + return CKR_OK;
1.497 +}
1.498 +
1.499 +/*
1.500 + * add a new variable to the chain
1.501 + */
1.502 +const char *
1.503 +AddVariable(const char *bp, Value **ptr)
1.504 +{
1.505 + char vname[512];
1.506 + Variable *current;
1.507 + int index = INVALID_INDEX;
1.508 + int size;
1.509 + int error = 0;
1.510 +
1.511 + bp = readChars(bp,vname,sizeof(vname));
1.512 +
1.513 + /* don't make numbers into variables */
1.514 + if (isNum(vname[0])) {
1.515 + return bp;
1.516 + }
1.517 + /* or consts */
1.518 + if (isConst(vname)) {
1.519 + return bp;
1.520 + }
1.521 + /* or NULLs */
1.522 + if (vname[0] == 0) {
1.523 + return bp;
1.524 + }
1.525 + /* or sizeof */
1.526 + if (isSize(vname, NULL)) {
1.527 + return bp;
1.528 + }
1.529 + /* arrays values should be written back to the original */
1.530 + index = handleArray(vname, &error);
1.531 + if (error == 1) {
1.532 + return bp;
1.533 + }
1.534 +
1.535 +
1.536 + for (current = varHead; current; current = current->next) {
1.537 + if (PL_strcasecmp(current->vname,vname) == 0) {
1.538 + char *target;
1.539 + /* found a complete object, return the found one */
1.540 + if (index == INVALID_INDEX) {
1.541 + argFree(*ptr);
1.542 + *ptr = current->value;
1.543 + return bp;
1.544 + }
1.545 + /* found an array, update the array element */
1.546 + target = makeArrayTarget(vname, current->value, index);
1.547 + if (target) {
1.548 + memcpy(target, (*ptr)->data, (*ptr)->size);
1.549 + argFreeData(*ptr);
1.550 + (*ptr)->data = target;
1.551 + (*ptr)->type |= ArgStatic;
1.552 + }
1.553 + return bp;
1.554 + }
1.555 + }
1.556 +
1.557 + /* we are looking for an array and didn't find one */
1.558 + if (index != INVALID_INDEX) {
1.559 + return bp;
1.560 + }
1.561 +
1.562 +
1.563 + current = (Variable *)malloc(sizeof(Variable));
1.564 + size = strlen(vname);
1.565 + current->vname = (char *)malloc(size+1);
1.566 + strcpy(current->vname,vname);
1.567 + current->value = *ptr;
1.568 + (*ptr)->reference++;
1.569 +
1.570 + current->next = varHead;
1.571 + varHead = current;
1.572 + return bp;
1.573 +}
1.574 +
1.575 +ArgType
1.576 +FindTypeByName(const char *typeName)
1.577 +{
1.578 + int i;
1.579 +
1.580 + for (i=0; i < valueCount; i++) {
1.581 + if (PL_strcasecmp(typeName,valueString[i]) == 0) {
1.582 + return (ArgType) i;
1.583 + }
1.584 + if (valueString[i][0] == 'C' && valueString[i][1] == 'K' &&
1.585 + valueString[i][2] == '_' &&
1.586 + (PL_strcasecmp(typeName,&valueString[i][3]) == 0)) {
1.587 + return (ArgType) i;
1.588 + }
1.589 + }
1.590 + return ArgNone;
1.591 +}
1.592 +
1.593 +CK_RV
1.594 +ArrayVariable(const char *bp, const char *typeName, CK_ULONG count)
1.595 +{
1.596 + ArgType type;
1.597 + Value *value; /* new Value */
1.598 +
1.599 + type = FindTypeByName(typeName);
1.600 + if (type == ArgNone) {
1.601 + fprintf(stderr,"Invalid type (%s)\n", typeName);
1.602 + return CKR_FUNCTION_FAILED;
1.603 + }
1.604 + value = NewValue(type, count);
1.605 + (void) AddVariable(bp, &value);
1.606 + return CKR_OK;
1.607 +}
1.608 +
1.609 +#define MAX_TEMPLATE 25
1.610 +
1.611 +CK_RV
1.612 +ArrayTemplate(const char *bp, char *attributes)
1.613 +{
1.614 + char aname[512];
1.615 + CK_ULONG attributeTypes[MAX_TEMPLATE];
1.616 + CK_ATTRIBUTE *template;
1.617 + Value *value; /* new Value */
1.618 + char *ap;
1.619 + int i, count = 0;
1.620 +
1.621 + memcpy(aname,attributes,strlen(attributes)+1);
1.622 +
1.623 + for (ap = aname, count = 0; ap && *ap && count < MAX_TEMPLATE; count++) {
1.624 + char *cur = ap;
1.625 + ConstType type;
1.626 +
1.627 + ap = strchr(ap,',');
1.628 + if (ap) {
1.629 + *ap++ = 0;
1.630 + }
1.631 +
1.632 + (void)constLookup(cur, &attributeTypes[count], &type);
1.633 + if ((type != ConstAttribute) && (type != ConstNone)) {
1.634 + fprintf(stderr, "Unknown Attribute %s\n", cur);
1.635 + return CKR_FUNCTION_FAILED;
1.636 + }
1.637 + }
1.638 +
1.639 + value = NewValue(ArgAttribute, count);
1.640 +
1.641 + template = (CK_ATTRIBUTE *)value->data;
1.642 + for (i=0; i < count ; i++) {
1.643 + template[i].type = attributeTypes[i];
1.644 + }
1.645 + (void) AddVariable(bp, &value);
1.646 + return CKR_OK;
1.647 +}
1.648 +
1.649 +CK_RV
1.650 +BuildTemplate(Value *vp)
1.651 +{
1.652 + CK_ATTRIBUTE *template = (CK_ATTRIBUTE *)vp->data;
1.653 + int i;
1.654 +
1.655 + for (i=0; i < vp->arraySize; i++) {
1.656 + if (((signed long)template[i].ulValueLen) > 0) {
1.657 + if (template[i].pValue) free(template[i].pValue);
1.658 + template[i].pValue = malloc(template[i].ulValueLen);
1.659 + }
1.660 + }
1.661 + return CKR_OK;
1.662 +}
1.663 +
1.664 +CK_RV
1.665 +SetTemplate(Value *vp, CK_ULONG index, CK_ULONG value)
1.666 +{
1.667 + CK_ATTRIBUTE *template = (CK_ATTRIBUTE *)vp->data;
1.668 + int isbool = 0;
1.669 + CK_ULONG len;
1.670 + ConstType attrType;
1.671 +
1.672 + if (index >= (CK_ULONG) vp->arraySize) {
1.673 + fprintf(stderr,"index (%lu) greater than array (%d)\n",
1.674 + index, vp->arraySize);
1.675 + return CKR_ARGUMENTS_BAD;
1.676 + }
1.677 + attrType = getConstFromAttribute(template[index].type);
1.678 +
1.679 + if (attrType == ConstNone) {
1.680 + fprintf(stderr,"can't set index (%lu) because ", index);
1.681 + printConst(template[index].type,ConstAttribute, 0);
1.682 + fprintf(stderr, " is not a CK_BBOOL or CK_ULONG\n");
1.683 + return CKR_ARGUMENTS_BAD;
1.684 + }
1.685 + isbool = (attrType == ConstBool);
1.686 + len = isbool ? sizeof (CK_BBOOL) : sizeof(CK_ULONG);
1.687 + if ((template[index].ulValueLen != len) || (template[index].pValue)) {
1.688 + free(template[index].pValue);
1.689 + template[index].pValue = malloc(len);
1.690 + template[index].ulValueLen = len;
1.691 + }
1.692 + if (isbool) {
1.693 + *(CK_BBOOL *)template[index].pValue = (CK_BBOOL) value;
1.694 + } else {
1.695 + *(CK_ULONG *)template[index].pValue = (CK_ULONG) value;
1.696 + }
1.697 + return CKR_OK;
1.698 +
1.699 +}
1.700 +
1.701 +CK_RV
1.702 +NewMechanism(const char *bp, CK_ULONG mechType)
1.703 +{
1.704 + Value *value; /* new Value */
1.705 + CK_MECHANISM *mechanism;
1.706 +
1.707 + value = NewValue(ArgMechanism, 1);
1.708 + mechanism = (CK_MECHANISM *)value->data;
1.709 + mechanism->mechanism = mechType;
1.710 + mechanism->pParameter = NULL;
1.711 + mechanism->ulParameterLen = 0;
1.712 + (void) AddVariable(bp, &value);
1.713 + return CKR_OK;
1.714 +}
1.715 +
1.716 +CK_RV
1.717 +NewInitializeArgs(const char *bp, CK_ULONG flags, const char *param)
1.718 +{
1.719 + Value *value; /* new Value */
1.720 + CK_C_INITIALIZE_ARGS *init;
1.721 +
1.722 + value = NewValue(ArgInitializeArgs, 1);
1.723 + init = (CK_C_INITIALIZE_ARGS *)value->data;
1.724 + init->flags = flags;
1.725 + if (strcmp(param, "null") != 0) {
1.726 + init->LibraryParameters = (CK_CHAR_PTR *)strdup(param);
1.727 + }
1.728 + (void) AddVariable(bp, &value);
1.729 + return CKR_OK;
1.730 +}
1.731 +
1.732 +/*
1.733 + * add a new variable to the chain
1.734 + */
1.735 +CK_RV
1.736 +DeleteVariable(const char *bp)
1.737 +{
1.738 + char vname[512];
1.739 + Variable **current;
1.740 +
1.741 + bp = readChars(bp,vname,sizeof(vname));
1.742 +
1.743 + for (current = &varHead; *current; current = &(*current)->next) {
1.744 + if (PL_strcasecmp((*current)->vname,vname) == 0) {
1.745 + argFree((*current)->value);
1.746 + *current = (*current)->next;
1.747 + break;
1.748 + }
1.749 + }
1.750 + return CKR_OK;
1.751 +}
1.752 +
1.753 +/*
1.754 + * convert an octal value to integer
1.755 + */
1.756 +CK_ULONG
1.757 +otoi(const char *o)
1.758 +{
1.759 + CK_ULONG value = 0;
1.760 +
1.761 + while (*o) {
1.762 + if ((*o >= '0') && (*o <= '7')) {
1.763 + value = (value << 3) | (unsigned)(*o - '0');
1.764 + } else {
1.765 + break;
1.766 + }
1.767 + }
1.768 + return value;
1.769 +}
1.770 +
1.771 +/*
1.772 + * convert a hex value to integer
1.773 + */
1.774 +CK_ULONG
1.775 +htoi(const char *x)
1.776 +{
1.777 + CK_ULONG value = 0;
1.778 +
1.779 + while (*x) {
1.780 + if ((*x >= '0') && (*x <= '9')) {
1.781 + value = (value << 4) | (unsigned)(*x - '0');
1.782 + } else if ((*x >= 'a') && (*x <= 'f')) {
1.783 + value = (value << 4) | (unsigned)(*x - 'a');
1.784 + } else if ((*x >= 'A') && (*x <= 'F')) {
1.785 + value = (value << 4) | (unsigned)(*x - 'A');
1.786 + } else {
1.787 + break;
1.788 + }
1.789 + }
1.790 + return value;
1.791 +}
1.792 +
1.793 +
1.794 +/*
1.795 + * look up or decode a constant value
1.796 + */
1.797 +const char *
1.798 +constLookup(const char *bp, CK_ULONG *value, ConstType *type)
1.799 +{
1.800 + char vname[512];
1.801 + int i;
1.802 +
1.803 + bp = readChars(bp,vname,sizeof(vname));
1.804 +
1.805 + for (i=0; i < constCount; i++) {
1.806 + if ((PL_strcasecmp(consts[i].name,vname) == 0) ||
1.807 + PL_strcasecmp(consts[i].name+5,vname) == 0) {
1.808 + *value = consts[i].value;
1.809 + *type = consts[i].type;
1.810 + return bp;
1.811 + }
1.812 + }
1.813 +
1.814 + *type = ConstNone;
1.815 + if (vname[0] == '0' && vname[1] == 'X') {
1.816 + *value = htoi(&vname[2]);
1.817 + } else if (vname[0] == '0') {
1.818 + *value = otoi(&vname[1]);
1.819 + } else {
1.820 + *value = atoi(vname);
1.821 + }
1.822 + return bp;
1.823 +}
1.824 +
1.825 +int
1.826 +ArgSize(ArgType type)
1.827 +{
1.828 + int size=0;
1.829 + type &= ArgMask;
1.830 +
1.831 + switch (type) {
1.832 + case ArgNone:
1.833 + size = 0;
1.834 + break;
1.835 + case ArgULong:
1.836 + size = sizeof(CK_ULONG);
1.837 + break;
1.838 + case ArgVar:
1.839 + size = 1; /* get's changed later */
1.840 + break;
1.841 + case ArgChar:
1.842 + case ArgUTF8:
1.843 + size = 1;
1.844 + break;
1.845 + case ArgInfo:
1.846 + size = sizeof(CK_INFO);
1.847 + break;
1.848 + case ArgSlotInfo:
1.849 + size = sizeof(CK_SLOT_INFO);
1.850 + break;
1.851 + case ArgTokenInfo:
1.852 + size = sizeof(CK_TOKEN_INFO);
1.853 + break;
1.854 + case ArgSessionInfo:
1.855 + size = sizeof(CK_SESSION_INFO);
1.856 + break;
1.857 + case ArgAttribute:
1.858 + size = sizeof(CK_ATTRIBUTE);
1.859 + break;
1.860 + case ArgMechanism:
1.861 + size = sizeof(CK_MECHANISM);
1.862 + break;
1.863 + case ArgMechanismInfo:
1.864 + size = sizeof(CK_MECHANISM_INFO);
1.865 + break;
1.866 + case ArgInitializeArgs:
1.867 + size = sizeof(CK_C_INITIALIZE_ARGS);
1.868 + break;
1.869 + case ArgFunctionList:
1.870 + size = sizeof(CK_FUNCTION_LIST);
1.871 + break;
1.872 + default:
1.873 + break;
1.874 + }
1.875 +
1.876 + return (size);
1.877 +}
1.878 +
1.879 +CK_RV
1.880 +restore(const char *filename,Value *ptr)
1.881 +{
1.882 + int fd,size;
1.883 +
1.884 + fd = open(filename,O_RDONLY|O_BINARY);
1.885 + if (fd < 0) {
1.886 + perror(filename);
1.887 + return CKR_FUNCTION_FAILED;
1.888 + }
1.889 +
1.890 + size = read(fd,ptr->data,ptr->size);
1.891 + if (systemFlags & FLAG_VerifyFile) {
1.892 + printDump(ptr->data,ptr->size);
1.893 + }
1.894 + if (size < 0) {
1.895 + perror(filename);
1.896 + return CKR_FUNCTION_FAILED;
1.897 + } else if (size != ptr->size) {
1.898 + fprintf(stderr,"%s: only read %d bytes, needed to read %d bytes\n",
1.899 + filename,size,ptr->size);
1.900 + return CKR_FUNCTION_FAILED;
1.901 + }
1.902 + close(fd);
1.903 + return CKR_OK;
1.904 +}
1.905 +
1.906 +CK_RV
1.907 +save(const char *filename,Value *ptr)
1.908 +{
1.909 + int fd,size;
1.910 +
1.911 + fd = open(filename,O_WRONLY|O_BINARY|O_CREAT,0666);
1.912 + if (fd < 0) {
1.913 + perror(filename);
1.914 + return CKR_FUNCTION_FAILED;
1.915 + }
1.916 +
1.917 + size = write(fd,ptr->data,ptr->size);
1.918 + if (size < 0) {
1.919 + perror(filename);
1.920 + return CKR_FUNCTION_FAILED;
1.921 + } else if (size != ptr->size) {
1.922 + fprintf(stderr,"%s: only wrote %d bytes, need to write %d bytes\n",
1.923 + filename,size,ptr->size);
1.924 + return CKR_FUNCTION_FAILED;
1.925 + }
1.926 + close(fd);
1.927 + return CKR_OK;
1.928 +}
1.929 +
1.930 +static CK_RV
1.931 +increment(Value *ptr, CK_ULONG value)
1.932 +{
1.933 + if ((ptr->type & ArgMask) != ArgULong) {
1.934 + return CKR_ARGUMENTS_BAD;
1.935 + }
1.936 + *(CK_ULONG *)ptr->data += value;
1.937 + return CKR_OK;
1.938 +}
1.939 +
1.940 +static CK_RV
1.941 +decrement(Value *ptr, CK_ULONG value)
1.942 +{
1.943 + if ((ptr->type & ArgMask) != ArgULong) {
1.944 + return CKR_ARGUMENTS_BAD;
1.945 + }
1.946 + *(CK_ULONG *)ptr->data -= value;
1.947 + return CKR_OK;
1.948 +}
1.949 +
1.950 +CK_RV
1.951 +printArg(Value *ptr,int arg_number)
1.952 +{
1.953 + ArgType type = ptr->type & ArgMask;
1.954 + CK_INFO *info;
1.955 + CK_SLOT_INFO *slotInfo;
1.956 + CK_TOKEN_INFO *tokenInfo;
1.957 + CK_SESSION_INFO *sessionInfo;
1.958 + CK_ATTRIBUTE *attribute;
1.959 + CK_MECHANISM *mechanism;
1.960 + CK_MECHANISM_INFO *mechanismInfo;
1.961 + CK_C_INITIALIZE_ARGS *initArgs;
1.962 + CK_FUNCTION_LIST *functionList;
1.963 + CK_RV ckrv = CKR_OK;
1.964 + ConstType constType;
1.965 +
1.966 + if (arg_number) {
1.967 + printf("Arg %d: \n",arg_number);
1.968 + }
1.969 + if (ptr->arraySize > 1) {
1.970 + Value element;
1.971 + int i;
1.972 + int elementSize = ptr->size/ptr->arraySize;
1.973 + char *dp = (char *)ptr->data;
1.974 +
1.975 + /* build a temporary Value to hold a single element */
1.976 + element.type = type;
1.977 + element.constType = ptr->constType;
1.978 + element.size = elementSize;
1.979 + element.filename = ptr->filename;
1.980 + element.reference = 1;
1.981 + element.arraySize = 1;
1.982 + for (i=0; i < ptr->arraySize; i++) {
1.983 + printf(" -----[ %d ] -----\n", i);
1.984 + element.data = (void *) &dp[i*elementSize];
1.985 + (void) printArg(&element, 0);
1.986 + }
1.987 + return ckrv;
1.988 + }
1.989 + if (ptr->data == NULL) {
1.990 + printf(" NULL ptr to a %s\n", valueString[type]);
1.991 + return ckrv;
1.992 + }
1.993 + switch (type) {
1.994 + case ArgNone:
1.995 + printf(" None\n");
1.996 + break;
1.997 + case ArgULong:
1.998 + printf(" %lu (0x%lx)\n", *((CK_ULONG *)ptr->data),
1.999 + *((CK_ULONG *)ptr->data));
1.1000 + if (ptr->constType != ConstNone) {
1.1001 + printf(" ");
1.1002 + printConst(*(CK_ULONG *)ptr->data,ptr->constType,1);
1.1003 + }
1.1004 + break;
1.1005 + case ArgVar:
1.1006 + printf(" %s\n",(char *)ptr->data);
1.1007 + break;
1.1008 + case ArgUTF8:
1.1009 + printf(" %s\n",(char *)ptr->data);
1.1010 + break;
1.1011 + case ArgChar:
1.1012 + printDump(ptr->data,ptr->size);
1.1013 + break;
1.1014 + case ArgInfo:
1.1015 +#define VERSION(x) (x).major, (x).minor
1.1016 + info = (CK_INFO *)ptr->data;
1.1017 + printf(" Cryptoki Version: %d.%02d\n",
1.1018 + VERSION(info->cryptokiVersion));
1.1019 + printf(" Manufacturer ID: ");
1.1020 + printChars((char *)info->manufacturerID,
1.1021 + sizeof(info->manufacturerID));
1.1022 + printFlags(" Flags: ", info->flags, ConstInfoFlags);
1.1023 + printf(" Library Description: ");
1.1024 + printChars((char *)info->libraryDescription,
1.1025 + sizeof(info->libraryDescription));
1.1026 + printf(" Library Version: %d.%02d\n",
1.1027 + VERSION(info->libraryVersion));
1.1028 + break;
1.1029 + case ArgSlotInfo:
1.1030 + slotInfo = (CK_SLOT_INFO *)ptr->data;
1.1031 + printf(" Slot Description: ");
1.1032 + printChars((char *)slotInfo->slotDescription,
1.1033 + sizeof(slotInfo->slotDescription));
1.1034 + printf(" Manufacturer ID: ");
1.1035 + printChars((char *)slotInfo->manufacturerID,
1.1036 + sizeof(slotInfo->manufacturerID));
1.1037 + printFlags(" Flags: ", slotInfo->flags, ConstSlotFlags);
1.1038 + printf(" Hardware Version: %d.%02d\n",
1.1039 + VERSION(slotInfo->hardwareVersion));
1.1040 + printf(" Firmware Version: %d.%02d\n",
1.1041 + VERSION(slotInfo->firmwareVersion));
1.1042 + break;
1.1043 + case ArgTokenInfo:
1.1044 + tokenInfo = (CK_TOKEN_INFO *)ptr->data;
1.1045 + printf(" Label: ");
1.1046 + printChars((char *) tokenInfo->label,sizeof(tokenInfo->label));
1.1047 + printf(" Manufacturer ID: ");
1.1048 + printChars((char *)tokenInfo->manufacturerID,
1.1049 + sizeof(tokenInfo->manufacturerID));
1.1050 + printf(" Model: ");
1.1051 + printChars((char *)tokenInfo->model,sizeof(tokenInfo->model));
1.1052 + printf(" Serial Number: ");
1.1053 + printChars((char *)tokenInfo->serialNumber,
1.1054 + sizeof(tokenInfo->serialNumber));
1.1055 + printFlags(" Flags: ", tokenInfo->flags, ConstTokenFlags);
1.1056 + printf(" Max Session Count: ");
1.1057 + printConst(tokenInfo->ulMaxSessionCount, ConstAvailableSizes, 1);
1.1058 + printf(" Session Count: ");
1.1059 + printConst(tokenInfo->ulSessionCount, ConstCurrentSize, 1);
1.1060 + printf(" RW Session Count: ");
1.1061 + printConst(tokenInfo->ulMaxRwSessionCount, ConstAvailableSizes, 1);
1.1062 + printf(" Max Pin Length : ");
1.1063 + printConst(tokenInfo->ulMaxPinLen, ConstCurrentSize, 1);
1.1064 + printf(" Min Pin Length : ");
1.1065 + printConst(tokenInfo->ulMinPinLen, ConstCurrentSize, 1);
1.1066 + printf(" Total Public Memory: ");
1.1067 + printConst(tokenInfo->ulTotalPublicMemory, ConstAvailableSizes, 1);
1.1068 + printf(" Free Public Memory: ");
1.1069 + printConst(tokenInfo->ulFreePublicMemory, ConstCurrentSize, 1);
1.1070 + printf(" Total Private Memory: ");
1.1071 + printConst(tokenInfo->ulTotalPrivateMemory, ConstAvailableSizes, 1);
1.1072 + printf(" Free Private Memory: ");
1.1073 + printConst(tokenInfo->ulFreePrivateMemory, ConstCurrentSize, 1);
1.1074 + printf(" Hardware Version: %d.%02d\n",
1.1075 + VERSION(tokenInfo->hardwareVersion));
1.1076 + printf(" Firmware Version: %d.%02d\n",
1.1077 + VERSION(tokenInfo->firmwareVersion));
1.1078 + printf(" UTC Time: ");
1.1079 + printChars((char *)tokenInfo->utcTime,sizeof(tokenInfo->utcTime));
1.1080 + break;
1.1081 + case ArgSessionInfo:
1.1082 + sessionInfo = (CK_SESSION_INFO *)ptr->data;
1.1083 + printf(" SlotID: 0x%08lx\n", sessionInfo->slotID);
1.1084 + printf(" State: ");
1.1085 + printConst(sessionInfo->state, ConstSessionState, 1);
1.1086 + printFlags(" Flags: ", sessionInfo->flags, ConstSessionFlags);
1.1087 + printf(" Device error: %lu 0x%08lx\n",sessionInfo->ulDeviceError,
1.1088 + sessionInfo->ulDeviceError);
1.1089 + break;
1.1090 + case ArgAttribute:
1.1091 + attribute = (CK_ATTRIBUTE *)ptr->data;
1.1092 + printf(" Attribute Type: ");
1.1093 + printConst(attribute->type, ConstAttribute, 1);
1.1094 + printf(" Attribute Data: ");
1.1095 + if (attribute->pValue == NULL) {
1.1096 + printf("NULL\n");
1.1097 + printf("Attribute Len: %lu\n",attribute->ulValueLen);
1.1098 + } else {
1.1099 + constType = getConstFromAttribute(attribute->type);
1.1100 + if (constType != ConstNone) {
1.1101 + CK_ULONG value = (constType == ConstBool) ?
1.1102 + *(CK_BBOOL *)attribute->pValue :
1.1103 + *(CK_ULONG *)attribute->pValue;
1.1104 + printConst(value, constType, 1);
1.1105 + } else {
1.1106 + printf("\n");
1.1107 + printDump(attribute->pValue, attribute->ulValueLen);
1.1108 + }
1.1109 + }
1.1110 + break;
1.1111 + case ArgMechanism:
1.1112 + mechanism = (CK_MECHANISM *)ptr->data;
1.1113 + printf(" Mechanism Type: ");
1.1114 + printConst(mechanism->mechanism, ConstMechanism, 1);
1.1115 + printf(" Mechanism Data:\n");
1.1116 + printDump(mechanism->pParameter, mechanism->ulParameterLen);
1.1117 + break;
1.1118 + case ArgMechanismInfo:
1.1119 + mechanismInfo = (CK_MECHANISM_INFO *)ptr->data;
1.1120 + printf(" Minimum Key Size: %ld\n",mechanismInfo->ulMinKeySize);
1.1121 + printf(" Maximum Key Size: %ld\n",mechanismInfo->ulMaxKeySize);
1.1122 + printFlags(" Flags: ", mechanismInfo->flags, ConstMechanismFlags);
1.1123 + break;
1.1124 + case ArgInitializeArgs:
1.1125 + initArgs = (CK_C_INITIALIZE_ARGS *)ptr->data;
1.1126 + printFlags(" Flags: ", initArgs->flags, ConstInitializeFlags);
1.1127 + if (initArgs->LibraryParameters) {
1.1128 + printf("Params: %s\n",(char *)initArgs->LibraryParameters);
1.1129 + }
1.1130 + case ArgFunctionList:
1.1131 + functionList = (CK_FUNCTION_LIST *)ptr->data;
1.1132 + printf(" Version: %d.%02d\n", VERSION(functionList->version));
1.1133 +#ifdef notdef
1.1134 +#undef CK_NEED_ARG_LIST
1.1135 +#define CK_PKCS11_FUNCTION_INFO(func) \
1.1136 + printf(" %s: 0x%08lx\n", #func, (unsigned long) functionList->func );
1.1137 +#include "pkcs11f.h"
1.1138 +#undef CK_NEED_ARG_LIST
1.1139 +#undef CK_PKCS11_FUNCTION_INFO
1.1140 +#endif
1.1141 + default:
1.1142 + ckrv = CKR_ARGUMENTS_BAD;
1.1143 + break;
1.1144 + }
1.1145 +
1.1146 + return ckrv;
1.1147 +}
1.1148 +
1.1149 +
1.1150 +/*
1.1151 + * Feeling ambitious? turn this whole thing into lexx yacc parser
1.1152 + * with full expressions.
1.1153 + */
1.1154 +Value **
1.1155 +parseArgs(int index, const char * bp)
1.1156 +{
1.1157 + const Commands *cp = &commands[index];
1.1158 + int size = strlen(cp->fname);
1.1159 + int i;
1.1160 + CK_ULONG value;
1.1161 + char vname[512];
1.1162 + Value **argList,*possible;
1.1163 + ConstType constType;
1.1164 +
1.1165 + /*
1.1166 + * skip pass the command
1.1167 + */
1.1168 + if ((cp->fname[0] == 'C') && (cp->fname[1] == '_') && (bp[1] != '_')) {
1.1169 + size -= 2;
1.1170 + }
1.1171 + bp += size;
1.1172 +
1.1173 + /*
1.1174 + * Initialize our argument list
1.1175 + */
1.1176 + argList = (Value **)malloc(sizeof(Value*)*MAX_ARGS);
1.1177 + for (i=0; i < MAX_ARGS; i++) { argList[i] = NULL; }
1.1178 +
1.1179 + /*
1.1180 + * Walk the argument list parsing it...
1.1181 + */
1.1182 + for (i=0 ;i < MAX_ARGS; i++) {
1.1183 + ArgType type = cp->args[i] & ArgMask;
1.1184 + int error;
1.1185 +
1.1186 + /* strip blanks */
1.1187 + bp = strip(bp);
1.1188 +
1.1189 + /* if we hit ArgNone, we've nabbed all the arguments we need */
1.1190 + if (type == ArgNone) {
1.1191 + break;
1.1192 + }
1.1193 +
1.1194 + /* if we run out of space in the line, we weren't given enough
1.1195 + * arguments... */
1.1196 + if (*bp == '\0') {
1.1197 + /* we're into optional arguments, ok to quit now */
1.1198 + if (cp->args[i] & ArgOpt) {
1.1199 + break;
1.1200 + }
1.1201 + fprintf(stderr,"%s: only %d args found,\n",cp->fname,i);
1.1202 + parseFree(argList);
1.1203 + return NULL;
1.1204 + }
1.1205 +
1.1206 + /* collect all the rest of the command line and send
1.1207 + * it as a single argument */
1.1208 + if (cp->args[i] & ArgFull) {
1.1209 + int size = strlen(bp)+1;
1.1210 + argList[i] = NewValue(type, size);
1.1211 + memcpy(argList[i]->data, bp, size);
1.1212 + break;
1.1213 + }
1.1214 +
1.1215 + /*
1.1216 + * look up the argument in our variable list first... only
1.1217 + * exception is the new argument type for set...
1.1218 + */
1.1219 + error = 0;
1.1220 + if ((cp->args[i] != (ArgVar|ArgNew)) &&
1.1221 + (possible = varLookup(bp,vname,sizeof(vname),&error))) {
1.1222 + /* ints are only compatible with other ints... all other types
1.1223 + * are interchangeable... */
1.1224 + if (type != ArgVar) { /* ArgVar's match anyone */
1.1225 + if ((type == ArgULong) ^
1.1226 + ((possible->type & ArgMask) == ArgULong)) {
1.1227 + fprintf(stderr,"%s: Arg %d incompatible type with <%s>\n",
1.1228 + cp->fname,i+1,vname);
1.1229 + argFree(possible);
1.1230 + parseFree(argList);
1.1231 + return NULL;
1.1232 + }
1.1233 + /*
1.1234 + * ... that is as long as they are big enough...
1.1235 + */
1.1236 + if (ArgSize(type) > possible->size) {
1.1237 + fprintf(stderr,
1.1238 + "%s: Arg %d %s is too small (%d bytes needs to be %d bytes)\n",
1.1239 + cp->fname,i+1,vname,possible->size,ArgSize(type));
1.1240 + argFree(possible);
1.1241 + parseFree(argList);
1.1242 + return NULL;
1.1243 + }
1.1244 + }
1.1245 +
1.1246 + /* everything looks kosher here, use it */
1.1247 + argList[i] = possible;
1.1248 +
1.1249 + bp = readChars(bp,vname,sizeof(vname));
1.1250 + if (cp->args[i] & ArgOut) {
1.1251 + possible->type |= ArgOut;
1.1252 + }
1.1253 + continue;
1.1254 + }
1.1255 +
1.1256 + if (error == 1) {
1.1257 + parseFree(argList);
1.1258 + return NULL;
1.1259 + }
1.1260 +
1.1261 + /* create space for our argument */
1.1262 + argList[i] = NewValue(type, 1);
1.1263 +
1.1264 + if ((PL_strncasecmp(bp, "null", 4) == 0) && ((bp[4] == 0)
1.1265 + || (bp[4] == ' ') || (bp[4] =='\t') || (bp[4] =='\n'))) {
1.1266 + if (cp->args[i] == ArgULong) {
1.1267 + fprintf(stderr, "%s: Arg %d CK_ULONG can't be NULL\n",
1.1268 + cp->fname,i+1);
1.1269 + parseFree(argList);
1.1270 + return NULL;
1.1271 + }
1.1272 + argFreeData(argList[i]);
1.1273 + argList[i]->data = NULL;
1.1274 + argList[i]->size = 0;
1.1275 + bp += 4;
1.1276 + if (*bp) bp++;
1.1277 + continue;
1.1278 + }
1.1279 +
1.1280 + /* if we're an output variable, we need to add it */
1.1281 + if (cp->args[i] & ArgOut) {
1.1282 + if (PL_strncasecmp(bp,"file(",5) == 0 /* ) */ ) {
1.1283 + char filename[512];
1.1284 + bp = readChars(bp+5,filename,sizeof(filename));
1.1285 + size = PL_strlen(filename);
1.1286 + if ((size > 0) && (/* ( */filename[size-1] == ')')) {
1.1287 + filename[size-1] = 0;
1.1288 + }
1.1289 + filename[size] = 0;
1.1290 + argList[i]->filename = (char *)malloc(size+1);
1.1291 +
1.1292 + PL_strcpy(argList[i]->filename,filename);
1.1293 +
1.1294 + argList[i]->type |= ArgOut|ArgFile;
1.1295 + break;
1.1296 + }
1.1297 + bp = AddVariable(bp,&argList[i]);
1.1298 + argList[i]->type |= ArgOut;
1.1299 + continue;
1.1300 + }
1.1301 +
1.1302 + if (PL_strncasecmp(bp, "file(", 5) == 0 /* ) */ ) {
1.1303 + char filename[512];
1.1304 +
1.1305 + bp = readChars(bp+5,filename,sizeof(filename));
1.1306 + size = PL_strlen(filename);
1.1307 + if ((size > 0) && ( /* ( */ filename[size-1] == ')')) {
1.1308 + filename[size-1] = 0;
1.1309 + }
1.1310 +
1.1311 + if (restore(filename,argList[i]) != CKR_OK) {
1.1312 + parseFree(argList);
1.1313 + return NULL;
1.1314 + }
1.1315 + continue;
1.1316 + }
1.1317 +
1.1318 + switch (type) {
1.1319 + case ArgULong:
1.1320 + bp = constLookup(bp, &value, &constType);
1.1321 + *(int *)argList[i]->data = value;
1.1322 + argList[i]->constType = constType;
1.1323 + break;
1.1324 + case ArgVar:
1.1325 + argFreeData(argList[i]);
1.1326 + size = getEnd(bp)+1;
1.1327 + argList[i]->data = (void *)malloc(size);
1.1328 + argList[i]->size = size;
1.1329 + /* fall through */
1.1330 + case ArgInfo:
1.1331 + case ArgSlotInfo:
1.1332 + case ArgTokenInfo:
1.1333 + case ArgSessionInfo:
1.1334 + case ArgAttribute:
1.1335 + case ArgMechanism:
1.1336 + case ArgMechanismInfo:
1.1337 + case ArgInitializeArgs:
1.1338 + case ArgUTF8:
1.1339 + case ArgChar:
1.1340 + bp = readChars(bp,(char *)argList[i]->data,argList[i]->size);
1.1341 + case ArgNone:
1.1342 + default:
1.1343 + break;
1.1344 + }
1.1345 + }
1.1346 +
1.1347 + return argList;
1.1348 +}
1.1349 +
1.1350 +/* lookup the command in the array */
1.1351 +int
1.1352 +lookup(const char *buf)
1.1353 +{
1.1354 + int size,i;
1.1355 + int buflen;
1.1356 +
1.1357 + buflen = PL_strlen(buf);
1.1358 +
1.1359 + for ( i = 0; i < commandCount; i++) {
1.1360 + size = PL_strlen(commands[i].fname);
1.1361 +
1.1362 + if (size <= buflen) {
1.1363 + if (PL_strncasecmp(buf,commands[i].fname,size) == 0) {
1.1364 + return i;
1.1365 + }
1.1366 + }
1.1367 + if (size-2 <= buflen) {
1.1368 + if (commands[i].fname[0] == 'C' && commands[i].fname[1] == '_' &&
1.1369 + (PL_strncasecmp(buf,&commands[i].fname[2],size-2) == 0)) {
1.1370 + return i;
1.1371 + }
1.1372 + }
1.1373 + }
1.1374 + fprintf(stderr,"Can't find command %s\n",buf);
1.1375 + return -1;
1.1376 +}
1.1377 +
1.1378 +void
1.1379 +putOutput(Value **ptr)
1.1380 +{
1.1381 + int i;
1.1382 +
1.1383 + for (i=0; i < MAX_ARGS; i++) {
1.1384 + ArgType type;
1.1385 +
1.1386 + if (ptr[i] == NULL) break;
1.1387 +
1.1388 + type = ptr[i]->type;
1.1389 +
1.1390 + ptr[i]->type &= ~ArgOut;
1.1391 + if (type == ArgNone) {
1.1392 + break;
1.1393 + }
1.1394 + if (type & ArgOut) {
1.1395 + (void) printArg(ptr[i],i+1);
1.1396 + }
1.1397 + if (type & ArgFile) {
1.1398 + save(ptr[i]->filename,ptr[i]);
1.1399 + free(ptr[i]->filename);
1.1400 + ptr[i]->filename= NULL; /* paranoia */
1.1401 + }
1.1402 + }
1.1403 +}
1.1404 +
1.1405 +CK_RV
1.1406 +unloadModule(Module *module)
1.1407 +{
1.1408 + char *disableUnload = NULL;
1.1409 +
1.1410 + disableUnload = PR_GetEnv("NSS_DISABLE_UNLOAD");
1.1411 +
1.1412 + if (module->library && !disableUnload) {
1.1413 + PR_UnloadLibrary(module->library);
1.1414 + }
1.1415 +
1.1416 + module->library = NULL;
1.1417 + module->functionList = NULL;
1.1418 +
1.1419 + return CKR_OK;
1.1420 +}
1.1421 +
1.1422 +CK_RV
1.1423 +loadModule(Module *module, char *library)
1.1424 +{
1.1425 + PRLibrary *newLibrary;
1.1426 + CK_C_GetFunctionList getFunctionList;
1.1427 + CK_FUNCTION_LIST *functionList;
1.1428 + CK_RV ckrv;
1.1429 +
1.1430 + newLibrary = PR_LoadLibrary(library);
1.1431 + if (!newLibrary) {
1.1432 + fprintf(stderr,"Couldn't load library %s\n",library);
1.1433 + return CKR_FUNCTION_FAILED;
1.1434 + }
1.1435 + getFunctionList = (CK_C_GetFunctionList)
1.1436 + PR_FindSymbol(newLibrary,"C_GetFunctionList");
1.1437 + if (!getFunctionList) {
1.1438 + fprintf(stderr,"Couldn't find \"C_GetFunctionList\" in %s\n",library);
1.1439 + return CKR_FUNCTION_FAILED;
1.1440 + }
1.1441 +
1.1442 + ckrv = (*getFunctionList)(&functionList);
1.1443 + if (ckrv != CKR_OK) {
1.1444 + return ckrv;
1.1445 + }
1.1446 +
1.1447 + if (module->library) {
1.1448 + PR_UnloadLibrary(module->library);
1.1449 + }
1.1450 +
1.1451 + module->library = newLibrary;
1.1452 + module->functionList = functionList;
1.1453 +
1.1454 + return CKR_OK;
1.1455 +}
1.1456 +
1.1457 +static void
1.1458 +printHelp(int index, int full)
1.1459 +{
1.1460 + int j;
1.1461 + printf(" %s", commands[index].fname);
1.1462 + for (j=0; j < MAX_ARGS; j++) {
1.1463 + ArgType type = commands[index].args[j] & ArgMask;
1.1464 + if (type == ArgNone) {
1.1465 + break;
1.1466 + }
1.1467 + printf(" %s", valueString[type]);
1.1468 + }
1.1469 + printf("\n");
1.1470 + printf(" %s\n",commands[index].helpString);
1.1471 +}
1.1472 +
1.1473 +/* add Topical help here ! */
1.1474 +static CK_RV
1.1475 +printTopicHelp(char *topic)
1.1476 +{
1.1477 + int size,i;
1.1478 + int topicLen;
1.1479 +
1.1480 + topicLen = PL_strlen(topic);
1.1481 +
1.1482 + for ( i = 0; i < topicCount; i++) {
1.1483 + size = PL_strlen(topics[i].name);
1.1484 +
1.1485 + if (size <= topicLen) {
1.1486 + if (PL_strncasecmp(topic,topics[i].name,size) == 0) {
1.1487 + break;
1.1488 + }
1.1489 + }
1.1490 + }
1.1491 +
1.1492 + if (i == topicCount) {
1.1493 + fprintf(stderr,"Can't find topic '%s'\n", topic);
1.1494 + return CKR_DATA_INVALID;
1.1495 + }
1.1496 +
1.1497 + printf(" %s", topic);
1.1498 + printf("\n");
1.1499 + printf(" %s\n",topics[i].helpString);
1.1500 + return CKR_OK;
1.1501 +}
1.1502 +
1.1503 +static CK_RV
1.1504 +printGeneralHelp(void)
1.1505 +{
1.1506 + int i;
1.1507 + printf(" To get help on commands, select from the list below:");
1.1508 + for ( i = 0; i < commandCount; i++) {
1.1509 + if (i % 5 == 0) printf("\n");
1.1510 + printf("%s,", commands[i].fname);
1.1511 + }
1.1512 + printf("\n");
1.1513 + /* print help topics */
1.1514 + printf(" To get help on a topic, select from the list below:");
1.1515 + for ( i = 0; i < topicCount; i++) {
1.1516 + if (i % 5 == 0) printf("\n");
1.1517 + printf("%s,", topics[i].name);
1.1518 + }
1.1519 + printf("\n");
1.1520 + return CKR_OK;
1.1521 +}
1.1522 +
1.1523 +static CK_RV
1.1524 +quitIf(CK_ULONG a, const char *cmp, CK_ULONG b)
1.1525 +{
1.1526 + if (strcmp(cmp, "<") == 0) {
1.1527 + return (a < b) ? CKR_QUIT : CKR_OK;
1.1528 + } else if (strcmp(cmp, ">") == 0) {
1.1529 + return (a > b) ? CKR_QUIT : CKR_OK;
1.1530 + } else if (strcmp(cmp, "<=") == 0) {
1.1531 + return (a <= b) ? CKR_QUIT : CKR_OK;
1.1532 + } else if (strcmp(cmp, ">=") == 0) {
1.1533 + return (a >= b) ? CKR_QUIT : CKR_OK;
1.1534 + } else if (strcmp(cmp, "=") == 0) {
1.1535 + return (a == b) ? CKR_QUIT : CKR_OK;
1.1536 + } else if (strcmp(cmp, "!=") == 0) {
1.1537 + return (a != b) ? CKR_QUIT : CKR_OK;
1.1538 + }
1.1539 + printf("Unkown integer comparator: '%s'\n", cmp);
1.1540 + return CKR_ARGUMENTS_BAD;
1.1541 +}
1.1542 +
1.1543 +static CK_RV
1.1544 +quitIfString(const char *a, const char *cmp, const char *b)
1.1545 +{
1.1546 +
1.1547 + if (strcmp(cmp, "=") == 0) {
1.1548 + return (strcmp(a,b) == 0) ? CKR_QUIT : CKR_OK;
1.1549 + } else if (strcmp(cmp, "!=") == 0) {
1.1550 + return (strcmp(a,b) != 0) ? CKR_QUIT : CKR_OK;
1.1551 + }
1.1552 + printf("Unkown string comparator: '%s'\n", cmp);
1.1553 + return CKR_ARGUMENTS_BAD;
1.1554 +}
1.1555 +
1.1556 +CK_RV run(const char *);
1.1557 +CK_RV timeCommand(const char *);
1.1558 +CK_RV loop(const char *filename, const char *var,
1.1559 + CK_ULONG start, CK_ULONG end, CK_ULONG step) ;
1.1560 +
1.1561 +/*
1.1562 + * Actually dispatch the function... Bad things happen
1.1563 + * if these don't match the commands array.
1.1564 + */
1.1565 +CK_RV
1.1566 +do_func(int index, Value **a)
1.1567 +{
1.1568 + int value, helpIndex;
1.1569 + static Module module = { NULL, NULL} ;
1.1570 + CK_FUNCTION_LIST *func = module.functionList;
1.1571 +
1.1572 + switch (commands[index].fType) {
1.1573 + case F_C_Initialize:
1.1574 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1575 + return func->C_Initialize((void *)a[0]->data);
1.1576 + case F_C_Finalize:
1.1577 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1578 + return func->C_Finalize((void *)a[0]->data);
1.1579 + case F_C_GetInfo:
1.1580 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1581 + return func->C_GetInfo((CK_INFO *)a[0]->data);
1.1582 + case F_C_GetFunctionList:
1.1583 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1584 + return func->C_GetFunctionList((CK_FUNCTION_LIST **)a[0]->data);
1.1585 + case F_C_GetSlotList:
1.1586 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1587 + return func->C_GetSlotList((CK_BBOOL)*(CK_ULONG *)a[0]->data,
1.1588 + (CK_SLOT_ID *)a[1]->data,
1.1589 + (CK_ULONG *)a[2]->data);
1.1590 + case F_C_GetSlotInfo:
1.1591 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1592 + return func->C_GetSlotInfo(*(CK_ULONG *)a[0]->data,
1.1593 + (CK_SLOT_INFO *)a[1]->data);
1.1594 + case F_C_GetTokenInfo:
1.1595 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1596 + return func->C_GetTokenInfo(*(CK_ULONG *)a[0]->data,
1.1597 + (CK_TOKEN_INFO *)a[1]->data);
1.1598 + case F_C_GetMechanismList:
1.1599 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1600 + if (a[1]->data) {
1.1601 + a[1]->constType = ConstMechanism;
1.1602 + }
1.1603 + return func->C_GetMechanismList(*(CK_ULONG *)a[0]->data,
1.1604 + (CK_MECHANISM_TYPE*)a[1]->data,
1.1605 + (CK_ULONG *)a[2]->data);
1.1606 + case F_C_GetMechanismInfo:
1.1607 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1608 + return func->C_GetMechanismInfo(*(CK_ULONG *)a[0]->data,
1.1609 + *(CK_ULONG *)a[1]->data,
1.1610 + (CK_MECHANISM_INFO *)a[2]->data);
1.1611 + case F_C_InitToken:
1.1612 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1613 + return func->C_InitToken(*(CK_ULONG *)a[0]->data,
1.1614 + (CK_CHAR *)a[1]->data,
1.1615 + *(CK_ULONG *)a[2]->data,
1.1616 + (CK_CHAR *)a[3]->data);
1.1617 + case F_C_InitPIN:
1.1618 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1619 + return func->C_InitPIN(*(CK_ULONG *)a[0]->data,
1.1620 + (CK_CHAR *)a[1]->data,
1.1621 + *(CK_ULONG *)a[2]->data);
1.1622 + case F_C_SetPIN:
1.1623 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1624 + return func->C_SetPIN(*(CK_ULONG *)a[0]->data,
1.1625 + (CK_CHAR *)a[1]->data,
1.1626 + *(CK_ULONG *)a[2]->data,
1.1627 + (CK_CHAR *)a[3]->data,
1.1628 + *(CK_ULONG *)a[4]->data);
1.1629 + case F_C_OpenSession:
1.1630 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1631 + return func->C_OpenSession(*(CK_ULONG *)a[0]->data,
1.1632 + *(CK_ULONG *)a[1]->data,
1.1633 + (void *)NULL,
1.1634 + (CK_NOTIFY) NULL,
1.1635 + (CK_ULONG *)a[2]->data);
1.1636 + case F_C_CloseSession:
1.1637 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1638 + return func->C_CloseSession(*(CK_ULONG *)a[0]->data);
1.1639 + case F_C_CloseAllSessions:
1.1640 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1641 + return func->C_CloseAllSessions(*(CK_ULONG *)a[0]->data);
1.1642 + case F_C_GetSessionInfo:
1.1643 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1644 + return func->C_GetSessionInfo(*(CK_ULONG *)a[0]->data,
1.1645 + (CK_SESSION_INFO *)a[1]->data);
1.1646 + case F_C_GetOperationState:
1.1647 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1648 + return func->C_GetOperationState(*(CK_ULONG *)a[0]->data,
1.1649 + (CK_BYTE *)a[1]->data,
1.1650 + (CK_ULONG *)a[2]->data);
1.1651 + case F_C_SetOperationState:
1.1652 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1653 + return func->C_SetOperationState(*(CK_ULONG *)a[0]->data,
1.1654 + (CK_CHAR *)a[1]->data,
1.1655 + *(CK_ULONG *)a[2]->data,
1.1656 + *(CK_ULONG *)a[3]->data,
1.1657 + *(CK_ULONG *)a[4]->data);
1.1658 + case F_C_Login:
1.1659 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1660 + return func->C_Login(*(CK_ULONG *)a[0]->data,
1.1661 + *(CK_ULONG *)a[1]->data,
1.1662 + (CK_CHAR *)a[2]->data,
1.1663 + *(CK_ULONG *)a[3]->data);
1.1664 + case F_C_Logout:
1.1665 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1666 + return func->C_Logout(*(CK_ULONG *)a[0]->data);
1.1667 + case F_C_CreateObject:
1.1668 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1669 + return func->C_CreateObject(*(CK_ULONG *)a[0]->data,
1.1670 + (CK_ATTRIBUTE *)a[1]->data,
1.1671 + *(CK_ULONG *)a[2]->data,
1.1672 + (CK_ULONG *)a[3]->data);
1.1673 + case F_C_CopyObject:
1.1674 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1675 + return func->C_CopyObject(*(CK_ULONG *)a[0]->data,
1.1676 + *(CK_ULONG *)a[0]->data,
1.1677 + (CK_ATTRIBUTE *)a[1]->data,
1.1678 + *(CK_ULONG *)a[2]->data,
1.1679 + (CK_ULONG *)a[3]->data);
1.1680 + case F_C_DestroyObject:
1.1681 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1682 + return func->C_DestroyObject(*(CK_ULONG *)a[0]->data,
1.1683 + *(CK_ULONG *)a[1]->data);
1.1684 + case F_C_GetObjectSize:
1.1685 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1686 + return func->C_GetObjectSize(*(CK_ULONG *)a[0]->data,
1.1687 + *(CK_ULONG *)a[1]->data,
1.1688 + (CK_ULONG *)a[2]->data);
1.1689 + case F_C_GetAttributeValue:
1.1690 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1691 + return func->C_GetAttributeValue(*(CK_ULONG *)a[0]->data,
1.1692 + *(CK_ULONG *)a[1]->data,
1.1693 + (CK_ATTRIBUTE *)a[2]->data,
1.1694 + *(CK_ULONG *)a[3]->data);
1.1695 + case F_C_SetAttributeValue:
1.1696 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1697 + return func->C_SetAttributeValue(*(CK_ULONG *)a[0]->data,
1.1698 + *(CK_ULONG *)a[1]->data,
1.1699 + (CK_ATTRIBUTE *)a[2]->data,
1.1700 + *(CK_ULONG *)a[3]->data);
1.1701 + case F_C_FindObjectsInit:
1.1702 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1703 + return func->C_FindObjectsInit(*(CK_ULONG *)a[0]->data,
1.1704 + (CK_ATTRIBUTE *)a[1]->data,
1.1705 + *(CK_ULONG *)a[2]->data);
1.1706 + case F_C_FindObjects:
1.1707 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1708 + return func->C_FindObjects(*(CK_ULONG *)a[0]->data,
1.1709 + (CK_ULONG *)a[1]->data,
1.1710 + *(CK_ULONG *)a[2]->data,
1.1711 + (CK_ULONG *)a[3]->data);
1.1712 + case F_C_FindObjectsFinal:
1.1713 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1714 + return func->C_FindObjectsFinal(*(CK_ULONG *)a[0]->data);
1.1715 + case F_C_EncryptInit:
1.1716 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1717 + return func->C_EncryptInit(*(CK_ULONG *)a[0]->data,
1.1718 + (CK_MECHANISM *)a[1]->data,
1.1719 + *(CK_ULONG *)a[2]->data);
1.1720 + case F_C_Encrypt:
1.1721 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1722 + return func->C_Encrypt(*(CK_ULONG *)a[0]->data,
1.1723 + (CK_CHAR *)a[1]->data,
1.1724 + *(CK_ULONG *)a[2]->data,
1.1725 + (CK_CHAR *)a[3]->data,
1.1726 + (CK_ULONG *)a[4]->data);
1.1727 + case F_C_EncryptUpdate:
1.1728 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1729 + return func->C_EncryptUpdate(*(CK_ULONG *)a[0]->data,
1.1730 + (CK_CHAR *)a[1]->data,
1.1731 + *(CK_ULONG *)a[2]->data,
1.1732 + (CK_CHAR *)a[3]->data,
1.1733 + (CK_ULONG *)a[4]->data);
1.1734 + case F_C_EncryptFinal:
1.1735 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1736 + return func->C_EncryptFinal(*(CK_ULONG *)a[0]->data,
1.1737 + (CK_CHAR *)a[1]->data,
1.1738 + (CK_ULONG *)a[2]->data);
1.1739 + case F_C_DecryptInit:
1.1740 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1741 + return func->C_DecryptInit(*(CK_ULONG *)a[0]->data,
1.1742 + (CK_MECHANISM *)a[1]->data,
1.1743 + *(CK_ULONG *)a[2]->data);
1.1744 + case F_C_Decrypt:
1.1745 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1746 + return func->C_Decrypt(*(CK_ULONG *)a[0]->data,
1.1747 + (CK_CHAR *)a[1]->data,
1.1748 + *(CK_ULONG *)a[2]->data,
1.1749 + (CK_CHAR *)a[3]->data,
1.1750 + (CK_ULONG *)a[4]->data);
1.1751 + case F_C_DecryptUpdate:
1.1752 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1753 + return func->C_DecryptUpdate(*(CK_ULONG *)a[0]->data,
1.1754 + (CK_CHAR *)a[1]->data,
1.1755 + *(CK_ULONG *)a[2]->data,
1.1756 + (CK_CHAR *)a[3]->data,
1.1757 + (CK_ULONG *)a[4]->data);
1.1758 + case F_C_DecryptFinal:
1.1759 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1760 + return func->C_DecryptFinal(*(CK_ULONG *)a[0]->data,
1.1761 + (CK_CHAR *)a[1]->data,
1.1762 + (CK_ULONG *)a[2]->data);
1.1763 + case F_C_DigestInit:
1.1764 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1765 + return func->C_DigestInit(*(CK_ULONG *)a[0]->data,
1.1766 + (CK_MECHANISM *)a[1]->data);
1.1767 + case F_C_Digest:
1.1768 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1769 + return func->C_Digest(*(CK_ULONG *)a[0]->data,
1.1770 + (CK_CHAR *)a[1]->data,
1.1771 + *(CK_ULONG *)a[2]->data,
1.1772 + (CK_CHAR *)a[3]->data,
1.1773 + (CK_ULONG *)a[4]->data);
1.1774 + case F_C_DigestUpdate:
1.1775 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1776 + return func->C_DigestUpdate(*(CK_ULONG *)a[0]->data,
1.1777 + (CK_CHAR *)a[1]->data,
1.1778 + *(CK_ULONG *)a[2]->data);
1.1779 + case F_C_DigestKey:
1.1780 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1781 + return func->C_DigestKey(*(CK_ULONG *)a[0]->data,
1.1782 + *(CK_ULONG *)a[1]->data);
1.1783 + case F_C_DigestFinal:
1.1784 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1785 + return func->C_DigestFinal(*(CK_ULONG *)a[0]->data,
1.1786 + (CK_CHAR *)a[1]->data,
1.1787 + (CK_ULONG *)a[2]->data);
1.1788 + case F_C_SignInit:
1.1789 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1790 + return func->C_SignInit(*(CK_ULONG *)a[0]->data,
1.1791 + (CK_MECHANISM *)a[1]->data,
1.1792 + *(CK_ULONG *)a[2]->data);
1.1793 + case F_C_Sign:
1.1794 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1795 + return func->C_Sign(*(CK_ULONG *)a[0]->data,
1.1796 + (CK_CHAR *)a[1]->data,
1.1797 + *(CK_ULONG *)a[2]->data,
1.1798 + (CK_CHAR *)a[3]->data,
1.1799 + (CK_ULONG *)a[4]->data);
1.1800 + case F_C_SignUpdate:
1.1801 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1802 + return func->C_SignUpdate(*(CK_ULONG *)a[0]->data,
1.1803 + (CK_CHAR *)a[1]->data,
1.1804 + *(CK_ULONG *)a[2]->data);
1.1805 + case F_C_SignFinal:
1.1806 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1807 + return func->C_SignFinal(*(CK_ULONG *)a[0]->data,
1.1808 + (CK_CHAR *)a[1]->data,
1.1809 + (CK_ULONG *)a[2]->data);
1.1810 +
1.1811 + case F_C_SignRecoverInit:
1.1812 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1813 + return func->C_SignRecoverInit(*(CK_ULONG *)a[0]->data,
1.1814 + (CK_MECHANISM *)a[1]->data,
1.1815 + *(CK_ULONG *)a[2]->data);
1.1816 + case F_C_SignRecover:
1.1817 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1818 + return func->C_SignRecover(*(CK_ULONG *)a[0]->data,
1.1819 + (CK_CHAR *)a[1]->data,
1.1820 + *(CK_ULONG *)a[2]->data,
1.1821 + (CK_CHAR *)a[3]->data,
1.1822 + (CK_ULONG *)a[4]->data);
1.1823 + case F_C_VerifyInit:
1.1824 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1825 + return func->C_VerifyInit(*(CK_ULONG *)a[0]->data,
1.1826 + (CK_MECHANISM *)a[1]->data,
1.1827 + *(CK_ULONG *)a[2]->data);
1.1828 + case F_C_Verify:
1.1829 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1830 + return func->C_Verify(*(CK_ULONG *)a[0]->data,
1.1831 + (CK_CHAR *)a[1]->data,
1.1832 + *(CK_ULONG *)a[2]->data,
1.1833 + (CK_CHAR *)a[3]->data,
1.1834 + *(CK_ULONG *)a[4]->data);
1.1835 + case F_C_VerifyUpdate:
1.1836 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1837 + return func->C_VerifyUpdate(*(CK_ULONG *)a[0]->data,
1.1838 + (CK_CHAR *)a[1]->data,
1.1839 + *(CK_ULONG *)a[2]->data);
1.1840 + case F_C_VerifyFinal:
1.1841 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1842 + return func->C_VerifyFinal(*(CK_ULONG *)a[0]->data,
1.1843 + (CK_CHAR *)a[1]->data,
1.1844 + *(CK_ULONG *)a[2]->data);
1.1845 +
1.1846 + case F_C_VerifyRecoverInit:
1.1847 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1848 + return func->C_VerifyRecoverInit(*(CK_ULONG *)a[0]->data,
1.1849 + (CK_MECHANISM *)a[1]->data,
1.1850 + *(CK_ULONG *)a[2]->data);
1.1851 + case F_C_VerifyRecover:
1.1852 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1853 + return func->C_VerifyRecover(*(CK_ULONG *)a[0]->data,
1.1854 + (CK_CHAR *)a[1]->data,
1.1855 + *(CK_ULONG *)a[2]->data,
1.1856 + (CK_CHAR *)a[3]->data,
1.1857 + (CK_ULONG *)a[4]->data);
1.1858 + case F_C_DigestEncryptUpdate:
1.1859 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1860 + return func->C_DigestEncryptUpdate(*(CK_ULONG *)a[0]->data,
1.1861 + (CK_CHAR *)a[1]->data,
1.1862 + *(CK_ULONG *)a[2]->data,
1.1863 + (CK_CHAR *)a[3]->data,
1.1864 + (CK_ULONG *)a[4]->data);
1.1865 + case F_C_DecryptDigestUpdate:
1.1866 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1867 + return func->C_DecryptDigestUpdate(*(CK_ULONG *)a[0]->data,
1.1868 + (CK_CHAR *)a[1]->data,
1.1869 + *(CK_ULONG *)a[2]->data,
1.1870 + (CK_CHAR *)a[3]->data,
1.1871 + (CK_ULONG *)a[4]->data);
1.1872 + case F_C_SignEncryptUpdate:
1.1873 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1874 + return func->C_SignEncryptUpdate(*(CK_ULONG *)a[0]->data,
1.1875 + (CK_CHAR *)a[1]->data,
1.1876 + *(CK_ULONG *)a[2]->data,
1.1877 + (CK_CHAR *)a[3]->data,
1.1878 + (CK_ULONG *)a[4]->data);
1.1879 + case F_C_DecryptVerifyUpdate:
1.1880 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1881 + return func->C_DecryptVerifyUpdate(*(CK_ULONG *)a[0]->data,
1.1882 + (CK_CHAR *)a[1]->data,
1.1883 + *(CK_ULONG *)a[2]->data,
1.1884 + (CK_CHAR *)a[3]->data,
1.1885 + (CK_ULONG *)a[4]->data);
1.1886 + case F_C_GenerateKey:
1.1887 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1888 + return func->C_GenerateKey(*(CK_ULONG *)a[0]->data,
1.1889 + (CK_MECHANISM *)a[1]->data,
1.1890 + (CK_ATTRIBUTE *)a[2]->data,
1.1891 + *(CK_ULONG *)a[3]->data,
1.1892 + (CK_ULONG *)a[4]->data);
1.1893 + case F_C_GenerateKeyPair:
1.1894 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1895 + return func->C_GenerateKeyPair(*(CK_ULONG *)a[0]->data,
1.1896 + (CK_MECHANISM *)a[1]->data,
1.1897 + (CK_ATTRIBUTE *)a[2]->data,
1.1898 + *(CK_ULONG *)a[3]->data,
1.1899 + (CK_ATTRIBUTE *)a[4]->data,
1.1900 + *(CK_ULONG *)a[5]->data,
1.1901 + (CK_ULONG *)a[6]->data,
1.1902 + (CK_ULONG *)a[7]->data);
1.1903 + case F_C_WrapKey:
1.1904 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1905 + return func->C_WrapKey(*(CK_ULONG *)a[0]->data,
1.1906 + (CK_MECHANISM *)a[1]->data,
1.1907 + *(CK_ULONG *)a[2]->data,
1.1908 + *(CK_ULONG *)a[3]->data,
1.1909 + (CK_CHAR *)a[5]->data,
1.1910 + (CK_ULONG *)a[6]->data);
1.1911 + case F_C_UnwrapKey:
1.1912 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1913 + return func->C_UnwrapKey(*(CK_ULONG *)a[0]->data,
1.1914 + (CK_MECHANISM *)a[1]->data,
1.1915 + *(CK_ULONG *)a[2]->data,
1.1916 + (CK_CHAR *)a[3]->data,
1.1917 + *(CK_ULONG *)a[4]->data,
1.1918 + (CK_ATTRIBUTE *)a[5]->data,
1.1919 + *(CK_ULONG *)a[6]->data,
1.1920 + (CK_ULONG *)a[7]->data);
1.1921 + case F_C_DeriveKey:
1.1922 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1923 + return func->C_DeriveKey (*(CK_ULONG *)a[0]->data,
1.1924 + (CK_MECHANISM *)a[1]->data,
1.1925 + *(CK_ULONG *)a[2]->data,
1.1926 + (CK_ATTRIBUTE *)a[3]->data,
1.1927 + *(CK_ULONG *)a[4]->data,
1.1928 + (CK_ULONG *)a[5]->data);
1.1929 + case F_C_SeedRandom:
1.1930 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1931 + return func->C_SeedRandom(*(CK_ULONG *)a[0]->data,
1.1932 + (CK_CHAR *)a[1]->data,
1.1933 + *(CK_ULONG *)a[2]->data);
1.1934 + case F_C_GenerateRandom:
1.1935 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1936 + return func->C_GenerateRandom(*(CK_ULONG *)a[0]->data,
1.1937 + (CK_CHAR *)a[1]->data,
1.1938 + *(CK_ULONG *)a[2]->data);
1.1939 + case F_C_GetFunctionStatus:
1.1940 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1941 + return func->C_GetFunctionStatus(*(CK_ULONG *)a[0]->data);
1.1942 + case F_C_CancelFunction:
1.1943 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1944 + return func->C_CancelFunction(*(CK_ULONG *)a[0]->data);
1.1945 + case F_C_WaitForSlotEvent:
1.1946 + if (!func) return CKR_CRYPTOKI_NOT_INITIALIZED;
1.1947 + return func->C_WaitForSlotEvent(*(CK_ULONG *)a[0]->data,
1.1948 + (CK_ULONG *)a[1]->data,
1.1949 + (void *)a[2]->data);
1.1950 + /* set a variable */
1.1951 + case F_SetVar:
1.1952 + case F_SetStringVar:
1.1953 + (void) DeleteVariable(a[0]->data);
1.1954 + (void) AddVariable(a[0]->data,&a[1]);
1.1955 + return CKR_OK;
1.1956 + /* print a value */
1.1957 + case F_Print:
1.1958 + return printArg(a[0],0);
1.1959 + case F_SaveVar:
1.1960 + return save(a[0]->data,a[1]);
1.1961 + case F_RestoreVar:
1.1962 + return restore(a[0]->data,a[1]);
1.1963 + case F_Delete:
1.1964 + return DeleteVariable(a[0]->data);
1.1965 + case F_Increment:
1.1966 + return increment(a[0], *(CK_ULONG *)a[1]->data);
1.1967 + case F_Decrement:
1.1968 + return decrement(a[0], *(CK_ULONG *)a[1]->data);
1.1969 + case F_List:
1.1970 + return list();
1.1971 + case F_Run:
1.1972 + return run(a[0]->data);
1.1973 + case F_Time:
1.1974 + return timeCommand(a[0]->data);
1.1975 + case F_Load:
1.1976 + return loadModule(&module,a[0]->data);
1.1977 + case F_Unload:
1.1978 + return unloadModule(&module);
1.1979 + case F_NewArray:
1.1980 + (void) DeleteVariable(a[0]->data);
1.1981 + return ArrayVariable(a[0]->data,a[1]->data,*(CK_ULONG *)a[2]->data);
1.1982 + case F_NewTemplate:
1.1983 + (void) DeleteVariable(a[0]->data);
1.1984 + return ArrayTemplate(a[0]->data,a[1]->data);
1.1985 + case F_BuildTemplate:
1.1986 + return BuildTemplate(a[0]);
1.1987 + case F_SetTemplate:
1.1988 + return SetTemplate(a[0],
1.1989 + *(CK_ULONG *)a[1]->data,
1.1990 + *(CK_ULONG *)a[2]->data);
1.1991 + case F_NewMechanism:
1.1992 + (void) DeleteVariable(a[0]->data);
1.1993 + return NewMechanism(a[0]->data,*(CK_ULONG *)a[1]->data);
1.1994 + case F_NewInitializeArgs:
1.1995 + (void) DeleteVariable(a[0]->data);
1.1996 + return NewInitializeArgs(a[0]->data,*(CK_ULONG *)a[1]->data,a[2]->data);
1.1997 + case F_System:
1.1998 + value = *(int *)a[0]->data;
1.1999 + if (value & 0x80000000) {
1.2000 + systemFlags &= ~value;
1.2001 + } else {
1.2002 + systemFlags |= value;
1.2003 + }
1.2004 + return CKR_OK;
1.2005 + case F_Loop:
1.2006 + return loop(a[0]->data,a[1]->data,*(CK_ULONG *)a[2]->data,
1.2007 + *(CK_ULONG *)a[3]->data,*(CK_ULONG *)a[4]->data);
1.2008 + case F_Help:
1.2009 + if (a[0]) {
1.2010 + helpIndex = lookup(a[0]->data);
1.2011 + if (helpIndex < 0) {
1.2012 + return printTopicHelp(a[0]->data);
1.2013 + }
1.2014 + printHelp(helpIndex, 1);
1.2015 + return CKR_OK;
1.2016 + }
1.2017 + return printGeneralHelp();
1.2018 + case F_QuitIfString:
1.2019 + return quitIfString(a[0]->data,a[1]->data,a[2]->data);
1.2020 + case F_QuitIf:
1.2021 + return quitIf(*(CK_ULONG *)a[0]->data,a[1]->data,*(CK_ULONG *)a[2]->data);
1.2022 + case F_Quit:
1.2023 + return CKR_QUIT;
1.2024 + default:
1.2025 + fprintf(stderr,
1.2026 + "Function %s not yet supported\n",commands[index].fname );
1.2027 + return CKR_OK;
1.2028 + }
1.2029 + /* Not Reached */
1.2030 + return CKR_OK;
1.2031 +}
1.2032 +
1.2033 +CK_RV
1.2034 +processCommand(const char * buf)
1.2035 +{
1.2036 + CK_RV error = CKR_OK;
1.2037 + int index;
1.2038 + const char *bp;
1.2039 + Value **arglist;
1.2040 +
1.2041 + bp = strip(buf);
1.2042 + /* allow comments and blank lines in scripts */
1.2043 + if ((*bp == '#') || (*bp == 0) || (*bp == '\n')){
1.2044 + return CKR_OK;
1.2045 + }
1.2046 +
1.2047 + index = lookup(bp);
1.2048 +
1.2049 + if (index < 0) {
1.2050 + return CKR_OK;
1.2051 + }
1.2052 +
1.2053 + arglist = parseArgs(index,bp);
1.2054 + if (arglist == NULL) {
1.2055 + return CKR_OK;
1.2056 + }
1.2057 +
1.2058 + error = do_func(index,arglist);
1.2059 + if (error == CKR_OK) {
1.2060 + putOutput(arglist);
1.2061 + } else if (error != CKR_QUIT) {
1.2062 + printf(">> Error : ");
1.2063 + printConst(error, ConstResult, 1);
1.2064 + }
1.2065 +
1.2066 + parseFree(arglist);
1.2067 + return error;
1.2068 +}
1.2069 +
1.2070 +CK_RV
1.2071 +timeCommand(const char *command)
1.2072 +{
1.2073 + CK_RV ckrv;
1.2074 + PRIntervalTime startTime = PR_IntervalNow();
1.2075 + PRIntervalTime endTime;
1.2076 + PRIntervalTime elapsedTime;
1.2077 +
1.2078 + ckrv = processCommand(command);
1.2079 +
1.2080 + endTime = PR_IntervalNow();
1.2081 + elapsedTime = endTime - startTime;
1.2082 + printf("Time -- %d msec \n",
1.2083 + PR_IntervalToMilliseconds(elapsedTime));
1.2084 +
1.2085 + return ckrv;
1.2086 +}
1.2087 +
1.2088 +
1.2089 +
1.2090 +CK_RV
1.2091 +process(FILE *inFile,int user)
1.2092 +{
1.2093 + char buf[2048];
1.2094 + CK_RV error;
1.2095 + CK_RV ckrv = CKR_OK;
1.2096 +
1.2097 + if (user) { printf("pkcs11> "); fflush(stdout); }
1.2098 +
1.2099 + while (fgets(buf,2048,inFile) != NULL) {
1.2100 +
1.2101 + if (!user) printf("* %s",buf);
1.2102 + error = processCommand(buf);
1.2103 + if (error == CKR_QUIT) {
1.2104 + break;
1.2105 + } else if (error != CKR_OK) {
1.2106 + ckrv = error;
1.2107 + }
1.2108 + if (user) {
1.2109 + printf("pkcs11> "); fflush(stdout);
1.2110 + }
1.2111 + }
1.2112 + return ckrv;
1.2113 +}
1.2114 +
1.2115 +CK_RV
1.2116 +run(const char *filename)
1.2117 +{
1.2118 + FILE *infile;
1.2119 + CK_RV ckrv;
1.2120 +
1.2121 + infile = fopen(filename,"r");
1.2122 +
1.2123 + if (infile == NULL) {
1.2124 + perror(filename);
1.2125 + return CKR_FUNCTION_FAILED;
1.2126 + }
1.2127 +
1.2128 + ckrv = process(infile, 0);
1.2129 +
1.2130 + fclose(infile);
1.2131 + return ckrv;
1.2132 +}
1.2133 +
1.2134 +CK_RV
1.2135 +loop(const char *filename, const char *var,
1.2136 + CK_ULONG start, CK_ULONG end, CK_ULONG step)
1.2137 +{
1.2138 + CK_ULONG i = 0;
1.2139 + Value *value = 0;
1.2140 + CK_RV ckrv;
1.2141 +
1.2142 + for (i=start; i < end; i += step)
1.2143 + {
1.2144 + value = NewValue(ArgULong, 1);
1.2145 + *(CK_ULONG *)value->data = i;
1.2146 + DeleteVariable(var);
1.2147 + AddVariable(var, &value);
1.2148 + ckrv = run(filename);
1.2149 + argFree(value);
1.2150 + if (ckrv == CKR_QUIT) {
1.2151 + break;
1.2152 + }
1.2153 + }
1.2154 + return ckrv;
1.2155 +}
1.2156 +
1.2157 +int
1.2158 +main(int argc, char **argv)
1.2159 +{
1.2160 + /* I suppose that some day we could parse some arguments */
1.2161 + (void) process(stdin, 1);
1.2162 + return 0;
1.2163 +}
