/*
* === Class methods begin now! ===
*/
nsresult
MediaRecorder::Init()
{
a_rec = PR_FALSE;
v_rec = PR_FALSE;
m_session = PR_FALSE;
log = PR_NewLogModule("MediaRecorder");
pipeStream = nsnull;
params = (Properties *)PR_Calloc(1, sizeof(Properties));
aState = (Audio *)PR_Calloc(1, sizeof(Audio));
vState = (Video *)PR_Calloc(1, sizeof(Video));
return NS_OK;
}
SECStatus
launch_threads(
startFn *startFunc,
PRFileDesc *a,
PRFileDesc *b,
int c,
PRBool local)
{
int i;
SECStatus rv = SECSuccess;
/* create the thread management serialization structs */
qLock = PZ_NewLock(nssILockSelfServ);
jobQNotEmptyCv = PZ_NewCondVar(qLock);
freeListNotEmptyCv = PZ_NewCondVar(qLock);
threadCountChangeCv = PZ_NewCondVar(qLock);
/* create monitor for crl reload procedure */
lastLoadedCrlLock = PR_NewLock();
/* allocate the array of thread slots */
threads = PR_Calloc(maxThreads, sizeof(perThread));
if ( NULL == threads ) {
fprintf(stderr, "Oh Drat! Can't allocate the perThread array\n");
return SECFailure;
}
/* 5 is a little extra, intended to keep the jobQ from underflowing.
** That is, from going empty while not stopping and clients are still
** trying to contact us.
*/
rv = setupJobs(maxThreads + 5);
if (rv != SECSuccess)
return rv;
PZ_Lock(qLock);
for (i = 0; i < maxThreads; ++i) {
perThread * slot = threads + i;
slot->state = rs_running;
slot->a = a;
slot->b = b;
slot->c = c;
slot->startFunc = startFunc;
slot->prThread = PR_CreateThread(PR_USER_THREAD,
thread_wrapper, slot, PR_PRIORITY_NORMAL,
(PR_TRUE==local)?PR_LOCAL_THREAD:PR_GLOBAL_THREAD,
PR_UNJOINABLE_THREAD, 0);
if (slot->prThread == NULL) {
printf("selfserv: Failed to launch thread!\n");
slot->state = rs_idle;
rv = SECFailure;
break;
}
++threadCount;
}
PZ_Unlock(qLock);
return rv;
}
static PRIntervalTime ContentiousLock(PRUint32 loops)
{
PRStatus status;
PRThread *thread = NULL;
LockContentious_t * contention;
PRIntervalTime rv, overhead, timein = PR_IntervalNow();
contention = (LockContentious_t *) PR_Calloc( 1, sizeof(LockContentious_t));
contention->loops = loops;
contention->overhead = 0;
contention->ml = PR_NewLock();
contention->interval = contention_interval;
thread = PR_CreateThread(
PR_USER_THREAD, LockContender, contention,
PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_ASSERT(thread != NULL);
overhead = PR_IntervalNow() - timein;
while (contention->loops > 0)
{
PR_Lock(contention->ml);
contention->overhead += contention->interval;
PR_Sleep(contention->interval);
PR_Unlock(contention->ml);
}
timein = PR_IntervalNow();
status = PR_JoinThread(thread);
PR_DestroyLock(contention->ml);
overhead += (PR_IntervalNow() - timein);
rv = overhead + contention->overhead;
PR_Free(contention);
return rv;
} /* ContentiousLock */
static PRIntervalTime ContentiousCMonitor(PRUint32 loops)
{
PRStatus status;
PRThread *thread = NULL;
MonitorContentious_t * contention;
PRIntervalTime overhead, timein = PR_IntervalNow();
contention = (MonitorContentious_t *) PR_Calloc(1, sizeof(MonitorContentious_t));
contention->ml = NULL;
contention->overhead = 0;
contention->loops = loops;
contention->interval = contention_interval;
thread = PR_CreateThread(
PR_USER_THREAD, Contender, contention,
PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_ASSERT(thread != NULL);
overhead = PR_IntervalNow() - timein;
while (contention->loops > 0)
{
PR_CEnterMonitor(contention);
contention->overhead += contention->interval;
PR_Sleep(contention->interval);
PR_CExitMonitor(contention);
}
timein = PR_IntervalNow();
status = PR_JoinThread(thread);
overhead += (PR_IntervalNow() - timein);
return overhead + contention->overhead;
} /* ContentiousCMonitor */
NS_IMETHODIMP nsAbView::OnItemAdded(nsISupports *parentDir, nsISupports *item)
{
nsresult rv;
nsCOMPtr <nsIAbDirectory> directory = do_QueryInterface(parentDir,&rv);
NS_ENSURE_SUCCESS(rv,rv);
if (directory.get() == mDirectory.get()) {
nsCOMPtr <nsIAbCard> addedCard = do_QueryInterface(item);
if (addedCard) {
// Malloc these from an arena
AbCard *abcard = (AbCard *) PR_Calloc(1, sizeof(struct AbCard));
if (!abcard)
return NS_ERROR_OUT_OF_MEMORY;
abcard->card = addedCard;
NS_IF_ADDREF(abcard->card);
rv = GenerateCollationKeysForCard(mSortColumn.get(), abcard);
NS_ENSURE_SUCCESS(rv,rv);
PRInt32 index;
rv = AddCard(abcard, false /* select card */, &index);
NS_ENSURE_SUCCESS(rv,rv);
}
}
return rv;
}
/*
* Get an audio packet from the pipe.
*/
PRInt16 *
MediaRecorder::GetAudioPacket(PRInt32 len)
{
nsresult rv;
PRUint32 rd;
PRInt16 *a_frames;
a_frames = (PRInt16 *) PR_Calloc(len, sizeof(PRUint8));
do aState->aPipeIn->Available(&rd);
while ((rd < (PRUint32)len) && !a_stp);
rv = aState->aPipeIn->Read((char *)a_frames, len, &rd);
if (rd == 0) {
/* EOF. We're done. */
PR_Free(a_frames);
return NULL;
} else if (rd != (PRUint32)len) {
/* Hmm. I sure hope this is the end of the recording. */
if (!a_stp) {
fprintf(stderr, "only read %u of %d from audio pipe\n", rd, len);
}
PR_Free(a_frames);
return NULL;
}
return a_frames;
}
/*
* Get an audio packet from the pipe.
*/
PRUint8 *
MediaRecorder::GetVideoPacket(PRInt32 *len, PRFloat64 *times)
{
nsresult rv;
PRUint32 rd;
PRUint8 *v_frame;
/* Get video frame header */
rv = vState->vPipeIn->Read((char *)times, sizeof(PRFloat64), &rd);
rv = vState->vPipeIn->Read((char *)len, sizeof(PRUint32), &rd);
//fprintf(stderr, "Got %d video packets at %f\n", *len / vState->backend->GetFrameSize(), *times);
v_frame = (PRUint8 *)PR_Calloc(*len, sizeof(PRUint8));
do vState->vPipeIn->Available(&rd);
while ((rd < (PRUint32)*len) && !v_stp);
rv = vState->vPipeIn->Read((char *)v_frame, *len, &rd);
if (rd == 0) {
PR_Free(v_frame);
return NULL;
} else if (rd != (PRUint32)*len) {
PR_LOG(log, PR_LOG_NOTICE,
("only read %u of %d from video pipe\n", rd, *len));
PR_Free(v_frame);
return NULL;
}
return v_frame;
}
static nsresult dir_GetPrefs(nsVoidArray **list)
{
nsresult rv;
nsCOMPtr<nsIPrefBranch> pPref(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
if (NS_FAILED(rv))
return rv;
(*list) = new nsVoidArray();
if (!(*list))
return NS_ERROR_OUT_OF_MEMORY;
char **children;
PRUint32 prefCount;
rv = dir_GetChildList(NS_LITERAL_CSTRING(PREF_LDAP_SERVER_TREE_NAME "."),
&prefCount, &children);
if (NS_FAILED(rv))
return rv;
/* TBD: Temporary code to read broken "ldap" preferences tree.
* Remove line with if statement after M10.
*/
if (dir_UserId == 0)
pPref->GetIntPref(PREF_LDAP_GLOBAL_TREE_NAME".user_id", &dir_UserId);
for (PRUint32 i = 0; i < prefCount; ++i)
{
DIR_Server *server;
server = (DIR_Server *)PR_Calloc(1, sizeof(DIR_Server));
if (server)
{
DIR_InitServer(server);
server->prefName = strdup(children[i]);
DIR_GetPrefsForOneServer(server);
if (server->description && server->description[0] &&
((server->dirType == PABDirectory ||
server->dirType == IMDirectory ||
server->dirType == MAPIDirectory ||
server->dirType == FixedQueryLDAPDirectory || // this one might go away
server->dirType == LDAPDirectory)))
{
if (!dir_IsServerDeleted(server))
{
(*list)->AppendElement(server);
}
else
DIR_DeleteServer(server);
}
else
{
DIR_DeleteServer(server);
}
}
}
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, children);
return NS_OK;
}
void *
PORT_ZAlloc(size_t bytes)
{
void *rv;
/* Always allocate a non-zero amount of bytes */
rv = (void *)PR_Calloc(1, bytes ? bytes : 1);
return rv;
}
/* XXX this needs to be real */
static jchar *
char2unicode(char *str, int32 len)
{
char *r;
if (r = PR_Calloc(len, sizeof(jchar))) {
while (*str && --len >= 0) {
*r++ = (char)0xff;
*r++ = *str++;
}
}
return (jchar *)r;
}
/* # 874 "arena.c" */
void *
nss_ZAlloc
(
NSSArena *arenaOpt,
PRUint32 size
)
{
struct pointer_header *h;
PRUint32 my_size = size + sizeof(struct pointer_header);
if( my_size < sizeof(struct pointer_header) ) {
nss_SetError(NSS_ERROR_NO_MEMORY);
return (void *)((void *)0);
}
if( (NSSArena *)((void *)0) == arenaOpt ) {
h = (struct pointer_header *)PR_Calloc(1, my_size);
if( (struct pointer_header *)((void *)0) == h ) {
nss_SetError(NSS_ERROR_NO_MEMORY);
return (void *)((void *)0);
}
h->arena = (NSSArena *)((void *)0);
h->size = size;
return (void *)((char *)h + sizeof(struct pointer_header));
} else {
void *rv;
if( (PRLock *)((void *)0) == arenaOpt->lock ) {
nss_SetError(NSS_ERROR_INVALID_ARENA);
return (void *)((void *)0);
}
PR_Lock(arenaOpt->lock);
/* # 929 "arena.c" */
rv = nss_zalloc_arena_locked(arenaOpt, size);
PR_Unlock(arenaOpt->lock);
return rv;
}
}
/*
* Function: prldap_tsd_realloc()
* Description: enlarge the thread-private data array.
* Returns: the new PRLDAP_TPDHeader value (non-NULL if successful).
* Note: tsdhdr can be NULL (allocates a new PRLDAP_TPDHeader).
*/
static PRLDAP_TPDHeader *
prldap_tsd_realloc( PRLDAP_TPDHeader *tsdhdr, int maxindex )
{
void *newdataitems = NULL;
int count;
if ( tsdhdr == NULL ) {
/* allocate a new thread private data header */
if (( tsdhdr = PR_Calloc( 1, sizeof( PRLDAP_TPDHeader ))) == NULL ) {
return( NULL );
}
(void)PR_SetThreadPrivate( prldap_tpdindex, tsdhdr );
}
/*
* Make the size of the new array the next highest multiple of
* the array increment value that is greater than maxindex.
*/
count = PRLDAP_TPD_ARRAY_INCREMENT *
( 1 + ( maxindex / PRLDAP_TPD_ARRAY_INCREMENT ));
/* increase the size of the data item array if necessary */
if ( count > tsdhdr->ptpdh_tpd_count ) {
newdataitems = (PRLDAP_ErrorInfo *)PR_Calloc( count, sizeof( void * ));
if ( newdataitems == NULL ) {
return( NULL );
}
if ( tsdhdr->ptpdh_dataitems != NULL ) { /* preserve old data */
memcpy( newdataitems, tsdhdr->ptpdh_dataitems,
tsdhdr->ptpdh_tpd_count * sizeof( void * ));
PR_Free( tsdhdr->ptpdh_dataitems );
}
tsdhdr->ptpdh_tpd_count = count;
tsdhdr->ptpdh_dataitems = newdataitems;
}
return( tsdhdr );
}
void *
PORT_ZAlloc(size_t bytes)
{
void *rv;
/* Always allocate a non-zero amount of bytes */
rv = (void *)PR_Calloc(1, bytes ? bytes : 1);
if (!rv) {
++port_allocFailures;
PORT_SetError(SEC_ERROR_NO_MEMORY);
}
return rv;
}
void
VideoSourceCanvas::Grabber(void *data)
{
nsresult rv;
PRUint32 wr;
VideoSourceCanvas *vs = static_cast<VideoSourceCanvas*>(data);
int isize = vs->GetFrameSize();
int fsize = vs->width * vs->height * 4;
char *i420 = (char *)PR_Calloc(isize, 1);
PRUint8 *rgb32 = (PRUint8 *)PR_Calloc(fsize, 1);
PRTime epoch_c;
PRFloat64 epoch;
PRIntervalTime ticks = PR_TicksPerSecond() / 30;
while (vs->running) {
PR_Sleep(ticks);
if (vs->is_rec == PR_FALSE) continue;
rv = vs->vCanvas->GetImageData_explicit(
0, 0, vs->width, vs->height, rgb32, fsize
);
if (NS_FAILED(rv)) continue;
RGB32toI420(vs->width, vs->height, (const char *)rgb32, i420);
epoch_c = PR_Now();
epoch = (PRFloat64)(epoch_c / MICROSECONDS);
epoch += ((PRFloat64)(epoch_c % MICROSECONDS)) / MICROSECONDS;
rv = vs->output->Write((const char *)&epoch, sizeof(PRFloat64), &wr);
rv = vs->output->Write((const char *)&isize, sizeof(PRUint32), &wr);
rv = vs->output->Write((const char *)i420, isize, &wr);
}
PR_Free(i420);
PR_Free(rgb32);
return;
}
void *
PORT_ZAlloc(size_t bytes)
{
void *rv = NULL;
if (bytes <= MAX_SIZE) {
/* Always allocate a non-zero amount of bytes */
rv = PR_Calloc(1, bytes ? bytes : 1);
}
if (!rv) {
PORT_SetError(SEC_ERROR_NO_MEMORY);
}
return rv;
}
// Decode Q encoding (RFC 2047).
// static
char *DecodeQ(const char *in, PRUint32 length)
{
char *out, *dest = 0;
out = dest = (char *)PR_Calloc(length + 1, sizeof(char));
if (dest == nsnull)
return nsnull;
while (length > 0) {
PRUintn c = 0;
switch (*in) {
case '=':
// check if |in| in the form of '=hh' where h is [0-9a-fA-F].
if (length < 3 || !ISHEXCHAR(in[1]) || !ISHEXCHAR(in[2]))
goto badsyntax;
PR_sscanf(in + 1, "%2X", &c);
*out++ = (char) c;
in += 3;
length -= 3;
break;
case '_':
*out++ = ' ';
in++;
length--;
break;
default:
if (*in & 0x80) goto badsyntax;
*out++ = *in++;
length--;
}
}
*out++ = '\0';
for (out = dest; *out ; ++out) {
if (*out == '\t')
*out = ' ';
}
return dest;
badsyntax:
PR_Free(dest);
return nsnull;
}
SECStatus
setupJobs(int maxJobs)
{
int i;
jobTable = (JOB *)PR_Calloc(maxJobs, sizeof(JOB));
if (!jobTable)
return SECFailure;
PR_INIT_CLIST(&jobQ);
PR_INIT_CLIST(&freeJobs);
for (i = 0; i < maxJobs; ++i) {
JOB *pJob = jobTable + i;
PR_APPEND_LINK(&pJob->link, &freeJobs);
}
return SECSuccess;
}
static error_stack *
error_get_my_stack ( void)
{
PRStatus st;
error_stack *rv;
PRUintn new_size;
PRUint32 new_bytes;
error_stack *new_stack;
if( INVALID_TPD_INDEX == error_stack_index ) {
st = PR_CallOnce(&error_call_once, error_once_function);
if( PR_SUCCESS != st ) {
return (error_stack *)NULL;
}
}
rv = (error_stack *)PR_GetThreadPrivate(error_stack_index);
if( (error_stack *)NULL == rv ) {
/* Doesn't exist; create one */
new_size = 16;
} else if( rv->header.count == rv->header.space &&
rv->header.count < NSS_MAX_ERROR_STACK_COUNT ) {
/* Too small, expand it */
new_size = PR_MIN( rv->header.space * 2, NSS_MAX_ERROR_STACK_COUNT);
} else {
/* Okay, return it */
return rv;
}
new_bytes = (new_size * sizeof(PRInt32)) + sizeof(error_stack);
/* Use NSPR's calloc/realloc, not NSS's, to avoid loops! */
new_stack = PR_Calloc(1, new_bytes);
if( (error_stack *)NULL != new_stack ) {
if( (error_stack *)NULL != rv ) {
(void)nsslibc_memcpy(new_stack,rv,rv->header.space);
}
new_stack->header.space = new_size;
}
/* Set the value, whether or not the allocation worked */
PR_SetThreadPrivate(error_stack_index, new_stack);
return new_stack;
}
nsresult nsAbView::EnumerateCards()
{
nsresult rv;
nsCOMPtr<nsISimpleEnumerator> cardsEnumerator;
nsCOMPtr<nsIAbCard> card;
if (!mDirectory)
return NS_ERROR_UNEXPECTED;
rv = mDirectory->GetChildCards(getter_AddRefs(cardsEnumerator));
if (NS_SUCCEEDED(rv) && cardsEnumerator)
{
nsCOMPtr<nsISupports> item;
bool more;
while (NS_SUCCEEDED(cardsEnumerator->HasMoreElements(&more)) && more)
{
rv = cardsEnumerator->GetNext(getter_AddRefs(item));
if (NS_SUCCEEDED(rv))
{
nsCOMPtr <nsIAbCard> card = do_QueryInterface(item);
// Malloc these from an arena
AbCard *abcard = (AbCard *) PR_Calloc(1, sizeof(struct AbCard));
if (!abcard)
return NS_ERROR_OUT_OF_MEMORY;
abcard->card = card;
NS_IF_ADDREF(abcard->card);
// XXX todo
// Would it be better to do an insertion sort, than append and sort?
// XXX todo
// If we knew how many cards there was going to be
// we could allocate an array of the size,
// instead of growing and copying as we append.
rv = mCards.AppendElement((void *)abcard);
NS_ASSERTION(NS_SUCCEEDED(rv), "failed to append card");
}
}
}
return NS_OK;
}
static void
prldap_set_ld_error( int err, char *matched, char *errmsg, void *errorarg )
{
PRLDAP_TPDMap *map;
PRLDAP_ErrorInfo *eip;
if (( map = (PRLDAP_TPDMap *)errorarg ) != NULL ) {
if (( eip = (PRLDAP_ErrorInfo *)prldap_get_thread_private(
map->prtm_index )) == NULL ) {
/*
* Error info. has not yet been allocated for this thread.
* Do so now. Note that we free this memory only for the
* thread that calls prldap_thread_dispose_handle(), which
* should be the one that called ldap_unbind() -- see
* prldap_return_map(). Not freeing the memory used by
* other threads is deemed acceptable since it will be
* recycled and used by other LDAP sessions. All of the
* thread-private memory is freed when a thread exits
* (inside the prldap_tsd_destroy() function).
*/
eip = (PRLDAP_ErrorInfo *)PR_Calloc( 1,
sizeof( PRLDAP_ErrorInfo ));
if ( eip == NULL ) {
return; /* punt */
}
eip->plei_magic = PRLDAP_ERRORINFO_MAGIC;
(void)prldap_set_thread_private( map->prtm_index, eip );
}
eip->plei_lderrno = err;
if ( eip->plei_matched != NULL ) {
ldap_memfree( eip->plei_matched );
}
eip->plei_matched = matched;
if ( eip->plei_errmsg != NULL ) {
ldap_memfree( eip->plei_errmsg );
}
eip->plei_errmsg = errmsg;
}
}
PRIntn main(PRIntn argc, char **argv)
{
PRStatus rv;
PRSysInfo cmd;
PRFileDesc *output = PR_GetSpecialFD(PR_StandardOutput);
char *info = (char*)PR_Calloc(SYS_INFO_BUFFER_LENGTH, 1);
for (cmd = PR_SI_HOSTNAME; cmd <= PR_SI_ARCHITECTURE; Incr(&cmd))
{
rv = PR_GetSystemInfo(cmd, info, SYS_INFO_BUFFER_LENGTH);
if (PR_SUCCESS == rv) PR_fprintf(output, "%s: %s\n", tag[cmd], info);
else PL_FPrintError(output, tag[cmd]);
}
PR_DELETE(info);
PR_fprintf(output, "Host page size is %d\n", PR_GetPageSize());
PR_fprintf(output, "Page shift is %d\n", PR_GetPageShift());
PR_fprintf(output, "Number of processors is: %d\n", PR_GetNumberOfProcessors());
return 0;
} /* main */
/*
* FUNCTION: PKIX_PL_Calloc (see comments in pkix_pl_system.h)
*/
PKIX_Error *
PKIX_PL_Calloc(
PKIX_UInt32 nElem,
PKIX_UInt32 elSize,
void **pMemory,
void *plContext)
{
PKIX_PL_NssContext *nssContext = NULL;
void *result = NULL;
PKIX_ENTER(MEM, "PKIX_PL_Calloc");
PKIX_NULLCHECK_ONE(pMemory);
if ((nElem == 0) || (elSize == 0)){
*pMemory = NULL;
} else {
nssContext = (PKIX_PL_NssContext *)plContext;
if (nssContext != NULL && nssContext->arena != NULL) {
PKIX_MEM_DEBUG("\tCalling PORT_ArenaAlloc.\n");
*pMemory = PORT_ArenaAlloc(nssContext->arena, elSize);
} else {
PKIX_MEM_DEBUG("\tCalling PR_Calloc.\n");
result = (void *) PR_Calloc(nElem, elSize);
if (result == NULL) {
PKIX_MEM_DEBUG("Fatal Error Occurred: "
"PR_Calloc failed.\n");
PKIX_ERROR_ALLOC_ERROR();
} else {
*pMemory = result;
}
}
}
cleanup:
PKIX_RETURN(MEM);
}
static char *
AppendAndAlloc(char *string, const char *newSubstring, bool withComma)
{
if (!newSubstring) return NULL;
if (!string) return PL_strdup(newSubstring);
char *separator = (char *) (withComma ? ", " : " ");
char *oldString = string;
string = (char *)PR_Calloc(PL_strlen(oldString) +
PL_strlen(separator) +
PL_strlen(newSubstring) + 1,
sizeof(char));
PL_strcpy(string, oldString);
PL_strcat(string, separator);
PL_strcat(string, newSubstring);
PR_Free(oldString);
return string;
}
void
AudioSourceNix::CaptureThread(void *data)
{
int err;
nsresult rv;
PRUint32 wr;
SAMPLE *buffer;
int frames_read;
signed short *ptr;
AudioSourceNix *asn = static_cast<AudioSourceNix*>(data);
buffer = (short *)PR_Calloc(asn->GetFrameSize(), FRAMES_BUFFER);
while (asn->rec) {
ptr = buffer;
frames_read = 0;
while (frames_read < FRAMES_BUFFER && asn->rec) {
err = snd_pcm_readi(
asn->device, ptr, FRAMES_BUFFER - frames_read
);
if (err < 0) {
// uh-oh
PR_Free(buffer);
return;
}
frames_read += err;
ptr += err * asn->channels;
}
rv = asn->output->Write(
(const char*)buffer, asn->GetFrameSize() * frames_read, &wr
);
}
PR_Free(buffer);
}
int
rmain
(
int argc,
char *argv[]
)
{
char *argv0 = argv[0];
PRLibrary *lib;
CK_C_GetFunctionList gfl;
CK_FUNCTION_LIST_PTR epv = (CK_FUNCTION_LIST_PTR)NULL;
CK_RV ck_rv;
CK_INFO info;
CK_ULONG nSlots;
CK_SLOT_ID *pSlots;
CK_ULONG i;
CK_C_INITIALIZE_ARGS ia, *iap;
(void)memset(&ia, 0, sizeof(CK_C_INITIALIZE_ARGS));
iap = (CK_C_INITIALIZE_ARGS *)NULL;
while( argv++, --argc ) {
if( '-' == argv[0][0] ) {
switch( argv[0][1] ) {
case 'i':
iap = &ia;
if( ((char *)NULL != argv[1]) && ('-' != argv[1][0]) ) {
#ifdef WITH_NSS
ia.pConfig = argv[1];
ia.ulConfigLen = strlen(argv[1]);
argv++, --argc;
#else
return usage(argv0);
#endif /* WITH_NSS */
}
break;
case '-':
argv++, --argc;
goto endargs;
default:
return usage(argv0);
}
} else {
break;
}
}
endargs:;
if( 1 != argc ) {
return usage(argv0);
}
lib = PR_LoadLibrary(argv[0]);
if( (PRLibrary *)NULL == lib ) {
PR_fprintf(PR_STDERR, "Can't load %s: %ld, %ld\n", argv[1], PR_GetError(), PR_GetOSError());
return 1;
}
gfl = (CK_C_GetFunctionList)PR_FindSymbol(lib, "C_GetFunctionList");
if( (CK_C_GetFunctionList)NULL == gfl ) {
PR_fprintf(PR_STDERR, "Can't find C_GetFunctionList in %s: %ld, %ld\n", argv[1],
PR_GetError(), PR_GetOSError());
return 1;
}
ck_rv = (*gfl)(&epv);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "CK_GetFunctionList returned 0x%08x\n", ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, "Module %s loaded, epv = 0x%08x.\n\n", argv[1], (CK_ULONG)epv);
/* C_Initialize */
ck_rv = epv->C_Initialize(iap);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_Initialize returned 0x%08x\n", ck_rv);
return 1;
}
/* C_GetInfo */
(void)memset(&info, 0, sizeof(CK_INFO));
ck_rv = epv->C_GetInfo(&info);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_GetInfo returned 0x%08x\n", ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, "Module Info:\n");
PR_fprintf(PR_STDOUT, " cryptokiVersion = %lu.%02lu\n",
(PRUint32)info.cryptokiVersion.major, (PRUint32)info.cryptokiVersion.minor);
PR_fprintf(PR_STDOUT, " manufacturerID = \"%.32s\"\n", info.manufacturerID);
PR_fprintf(PR_STDOUT, " flags = 0x%08lx\n", info.flags);
PR_fprintf(PR_STDOUT, " libraryDescription = \"%.32s\"\n", info.libraryDescription);
PR_fprintf(PR_STDOUT, " libraryVersion = %lu.%02lu\n",
(PRUint32)info.libraryVersion.major, (PRUint32)info.libraryVersion.minor);
PR_fprintf(PR_STDOUT, "\n");
/* C_GetSlotList */
nSlots = 0;
ck_rv = epv->C_GetSlotList(CK_FALSE, (CK_SLOT_ID_PTR)CK_NULL_PTR, &nSlots);
switch( ck_rv ) {
case CKR_BUFFER_TOO_SMALL:
case CKR_OK:
break;
default:
PR_fprintf(PR_STDERR, "C_GetSlotList(FALSE, NULL, ) returned 0x%08x\n", ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, "There are %lu slots.\n", nSlots);
pSlots = (CK_SLOT_ID_PTR)PR_Calloc(nSlots, sizeof(CK_SLOT_ID));
if( (CK_SLOT_ID_PTR)NULL == pSlots ) {
PR_fprintf(PR_STDERR, "[memory allocation of %lu bytes failed]\n", nSlots * sizeof(CK_SLOT_ID));
return 1;
}
ck_rv = epv->C_GetSlotList(CK_FALSE, pSlots, &nSlots);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_GetSlotList(FALSE, , ) returned 0x%08x\n", ck_rv);
return 1;
}
for( i = 0; i < nSlots; i++ ) {
PR_fprintf(PR_STDOUT, " [%lu]: CK_SLOT_ID = %lu\n", (i+1), pSlots[i]);
}
PR_fprintf(PR_STDOUT, "\n");
/* C_GetSlotInfo */
for( i = 0; i < nSlots; i++ ) {
CK_SLOT_INFO sinfo;
PR_fprintf(PR_STDOUT, "[%lu]: CK_SLOT_ID = %lu\n", (i+1), pSlots[i]);
(void)memset(&sinfo, 0, sizeof(CK_SLOT_INFO));
ck_rv = epv->C_GetSlotInfo(pSlots[i], &sinfo);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_GetSlotInfo(%lu, ) returned 0x%08x\n", pSlots[i], ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Slot Info:\n");
PR_fprintf(PR_STDOUT, " slotDescription = \"%.64s\"\n", sinfo.slotDescription);
PR_fprintf(PR_STDOUT, " manufacturerID = \"%.32s\"\n", sinfo.manufacturerID);
PR_fprintf(PR_STDOUT, " flags = 0x%08lx\n", sinfo.flags);
PR_fprintf(PR_STDOUT, " -> TOKEN PRESENT = %s\n",
sinfo.flags & CKF_TOKEN_PRESENT ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> REMOVABLE DEVICE = %s\n",
sinfo.flags & CKF_REMOVABLE_DEVICE ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> HW SLOT = %s\n",
sinfo.flags & CKF_HW_SLOT ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " hardwareVersion = %lu.%02lu\n",
(PRUint32)sinfo.hardwareVersion.major, (PRUint32)sinfo.hardwareVersion.minor);
PR_fprintf(PR_STDOUT, " firmwareVersion = %lu.%02lu\n",
(PRUint32)sinfo.firmwareVersion.major, (PRUint32)sinfo.firmwareVersion.minor);
if( sinfo.flags & CKF_TOKEN_PRESENT ) {
CK_TOKEN_INFO tinfo;
CK_MECHANISM_TYPE *pMechanismList;
CK_ULONG nMechanisms = 0;
CK_ULONG j;
(void)memset(&tinfo, 0, sizeof(CK_TOKEN_INFO));
ck_rv = epv->C_GetTokenInfo(pSlots[i], &tinfo);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_GetTokenInfo(%lu, ) returned 0x%08x\n", pSlots[i], ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Token Info:\n");
PR_fprintf(PR_STDOUT, " label = \"%.32s\"\n", tinfo.label);
PR_fprintf(PR_STDOUT, " manufacturerID = \"%.32s\"\n", tinfo.manufacturerID);
PR_fprintf(PR_STDOUT, " model = \"%.16s\"\n", tinfo.model);
PR_fprintf(PR_STDOUT, " serialNumber = \"%.16s\"\n", tinfo.serialNumber);
PR_fprintf(PR_STDOUT, " flags = 0x%08lx\n", tinfo.flags);
PR_fprintf(PR_STDOUT, " -> RNG = %s\n",
tinfo.flags & CKF_RNG ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> WRITE PROTECTED = %s\n",
tinfo.flags & CKF_WRITE_PROTECTED ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> LOGIN REQUIRED = %s\n",
tinfo.flags & CKF_LOGIN_REQUIRED ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> USER PIN INITIALIZED = %s\n",
tinfo.flags & CKF_USER_PIN_INITIALIZED ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> RESTORE KEY NOT NEEDED = %s\n",
tinfo.flags & CKF_RESTORE_KEY_NOT_NEEDED ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> CLOCK ON TOKEN = %s\n",
tinfo.flags & CKF_CLOCK_ON_TOKEN ? "TRUE" : "FALSE");
#ifdef CKF_SUPPORTS_PARALLEL
PR_fprintf(PR_STDOUT, " -> SUPPORTS PARALLEL = %s\n",
tinfo.flags & CKF_SUPPORTS_PARALLEL ? "TRUE" : "FALSE");
#endif /* CKF_SUPPORTS_PARALLEL */
PR_fprintf(PR_STDOUT, " -> PROTECTED AUTHENTICATION PATH = %s\n",
tinfo.flags & CKF_PROTECTED_AUTHENTICATION_PATH ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> DUAL_CRYPTO_OPERATIONS = %s\n",
tinfo.flags & CKF_DUAL_CRYPTO_OPERATIONS ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " ulMaxSessionCount = %lu\n", tinfo.ulMaxSessionCount);
PR_fprintf(PR_STDOUT, " ulSessionCount = %lu\n", tinfo.ulSessionCount);
PR_fprintf(PR_STDOUT, " ulMaxRwSessionCount = %lu\n", tinfo.ulMaxRwSessionCount);
PR_fprintf(PR_STDOUT, " ulRwSessionCount = %lu\n", tinfo.ulRwSessionCount);
PR_fprintf(PR_STDOUT, " ulMaxPinLen = %lu\n", tinfo.ulMaxPinLen);
PR_fprintf(PR_STDOUT, " ulMinPinLen = %lu\n", tinfo.ulMinPinLen);
PR_fprintf(PR_STDOUT, " ulTotalPublicMemory = %lu\n", tinfo.ulTotalPublicMemory);
PR_fprintf(PR_STDOUT, " ulFreePublicMemory = %lu\n", tinfo.ulFreePublicMemory);
PR_fprintf(PR_STDOUT, " ulTotalPrivateMemory = %lu\n", tinfo.ulTotalPrivateMemory);
PR_fprintf(PR_STDOUT, " ulFreePrivateMemory = %lu\n", tinfo.ulFreePrivateMemory);
PR_fprintf(PR_STDOUT, " hardwareVersion = %lu.%02lu\n",
(PRUint32)tinfo.hardwareVersion.major, (PRUint32)tinfo.hardwareVersion.minor);
PR_fprintf(PR_STDOUT, " firmwareVersion = %lu.%02lu\n",
(PRUint32)tinfo.firmwareVersion.major, (PRUint32)tinfo.firmwareVersion.minor);
PR_fprintf(PR_STDOUT, " utcTime = \"%.16s\"\n", tinfo.utcTime);
ck_rv = epv->C_GetMechanismList(pSlots[i], (CK_MECHANISM_TYPE_PTR)CK_NULL_PTR, &nMechanisms);
switch( ck_rv ) {
case CKR_BUFFER_TOO_SMALL:
case CKR_OK:
break;
default:
PR_fprintf(PR_STDERR, "C_GetMechanismList(%lu, NULL, ) returned 0x%08x\n", pSlots[i], ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " %lu mechanisms:\n", nMechanisms);
pMechanismList = (CK_MECHANISM_TYPE_PTR)PR_Calloc(nMechanisms, sizeof(CK_MECHANISM_TYPE));
if( (CK_MECHANISM_TYPE_PTR)NULL == pMechanismList ) {
PR_fprintf(PR_STDERR, "[memory allocation of %lu bytes failed]\n",
nMechanisms * sizeof(CK_MECHANISM_TYPE));
return 1;
}
ck_rv = epv->C_GetMechanismList(pSlots[i], pMechanismList, &nMechanisms);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_GetMechanismList(%lu, , ) returned 0x%08x\n", pSlots[i], ck_rv);
return 1;
}
for( j = 0; j < nMechanisms; j++ ) {
PR_fprintf(PR_STDOUT, " {%lu}: CK_MECHANISM_TYPE = %lu\n", (j+1), pMechanismList[j]);
}
PR_fprintf(PR_STDOUT, "\n");
for( j = 0; j < nMechanisms; j++ ) {
CK_MECHANISM_INFO minfo;
(void)memset(&minfo, 0, sizeof(CK_MECHANISM_INFO));
ck_rv = epv->C_GetMechanismInfo(pSlots[i], pMechanismList[j], &minfo);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_GetMechanismInfo(%lu, %lu, ) returned 0x%08x\n", pSlots[i],
pMechanismList[j]);
return 1;
}
PR_fprintf(PR_STDOUT, " [%lu]: CK_MECHANISM_TYPE = %lu\n", (j+1), pMechanismList[j]);
PR_fprintf(PR_STDOUT, " ulMinKeySize = %lu\n", minfo.ulMinKeySize);
PR_fprintf(PR_STDOUT, " ulMaxKeySize = %lu\n", minfo.ulMaxKeySize);
PR_fprintf(PR_STDOUT, " flags = 0x%08x\n", minfo.flags);
PR_fprintf(PR_STDOUT, " -> HW = %s\n", minfo.flags & CKF_HW ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> ENCRYPT = %s\n", minfo.flags & CKF_ENCRYPT ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> DECRYPT = %s\n", minfo.flags & CKF_DECRYPT ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> DIGEST = %s\n", minfo.flags & CKF_DIGEST ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> SIGN = %s\n", minfo.flags & CKF_SIGN ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> SIGN_RECOVER = %s\n", minfo.flags & CKF_SIGN_RECOVER ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> VERIFY = %s\n", minfo.flags & CKF_VERIFY ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> VERIFY_RECOVER = %s\n", minfo.flags & CKF_VERIFY_RECOVER ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> GENERATE = %s\n", minfo.flags & CKF_GENERATE ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> GENERATE_KEY_PAIR = %s\n", minfo.flags & CKF_GENERATE_KEY_PAIR ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> WRAP = %s\n", minfo.flags & CKF_WRAP ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> UNWRAP = %s\n", minfo.flags & CKF_UNWRAP ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> DERIVE = %s\n", minfo.flags & CKF_DERIVE ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> EXTENSION = %s\n", minfo.flags & CKF_EXTENSION ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, "\n");
}
if( tinfo.flags & CKF_LOGIN_REQUIRED ) {
PR_fprintf(PR_STDERR, "*** LOGIN REQUIRED but not yet implemented ***\n");
/* all the stuff about logging in as SO and setting the user pin if needed, etc. */
return 2;
}
/* session to find objects */
{
CK_SESSION_HANDLE h = (CK_SESSION_HANDLE)0;
CK_SESSION_INFO sinfo;
CK_ATTRIBUTE_PTR pTemplate;
CK_ULONG tnObjects = 0;
ck_rv = epv->C_OpenSession(pSlots[i], CKF_SERIAL_SESSION, (CK_VOID_PTR)CK_NULL_PTR, (CK_NOTIFY)CK_NULL_PTR, &h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_OpenSession(%lu, CKF_SERIAL_SESSION, , ) returned 0x%08x\n", pSlots[i], ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Opened a session: handle = 0x%08x\n", h);
(void)memset(&sinfo, 0, sizeof(CK_SESSION_INFO));
ck_rv = epv->C_GetSessionInfo(h, &sinfo);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDOUT, "C_GetSessionInfo(%lu, ) returned 0x%08x\n", h, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " SESSION INFO:\n");
PR_fprintf(PR_STDOUT, " slotID = %lu\n", sinfo.slotID);
PR_fprintf(PR_STDOUT, " state = %lu\n", sinfo.state);
PR_fprintf(PR_STDOUT, " flags = 0x%08x\n", sinfo.flags);
#ifdef CKF_EXCLUSIVE_SESSION
PR_fprintf(PR_STDOUT, " -> EXCLUSIVE SESSION = %s\n", sinfo.flags & CKF_EXCLUSIVE_SESSION ? "TRUE" : "FALSE");
#endif /* CKF_EXCLUSIVE_SESSION */
PR_fprintf(PR_STDOUT, " -> RW SESSION = %s\n", sinfo.flags & CKF_RW_SESSION ? "TRUE" : "FALSE");
PR_fprintf(PR_STDOUT, " -> SERIAL SESSION = %s\n", sinfo.flags & CKF_SERIAL_SESSION ? "TRUE" : "FALSE");
#ifdef CKF_INSERTION_CALLBACK
PR_fprintf(PR_STDOUT, " -> INSERTION CALLBACK = %s\n", sinfo.flags & CKF_INSERTION_CALLBACK ? "TRUE" : "FALSE");
#endif /* CKF_INSERTION_CALLBACK */
PR_fprintf(PR_STDOUT, " ulDeviceError = %lu\n", sinfo.ulDeviceError);
PR_fprintf(PR_STDOUT, "\n");
ck_rv = epv->C_FindObjectsInit(h, (CK_ATTRIBUTE_PTR)CK_NULL_PTR, 0);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDOUT, "C_FindObjectsInit(%lu, NULL_PTR, 0) returned 0x%08x\n", h, ck_rv);
return 1;
}
pTemplate = (CK_ATTRIBUTE_PTR)PR_Calloc(number_of_all_known_attribute_types, sizeof(CK_ATTRIBUTE));
if( (CK_ATTRIBUTE_PTR)NULL == pTemplate ) {
PR_fprintf(PR_STDERR, "[memory allocation of %lu bytes failed]\n",
number_of_all_known_attribute_types * sizeof(CK_ATTRIBUTE));
return 1;
}
PR_fprintf(PR_STDOUT, " All objects:\n");
while(1) {
CK_OBJECT_HANDLE o = (CK_OBJECT_HANDLE)0;
CK_ULONG nObjects = 0;
CK_ULONG k;
CK_ULONG nAttributes = 0;
CK_ATTRIBUTE_PTR pT2;
CK_ULONG l;
ck_rv = epv->C_FindObjects(h, &o, 1, &nObjects);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjects(%lu, , 1, ) returned 0x%08x\n", h, ck_rv);
return 1;
}
if( 0 == nObjects ) {
PR_fprintf(PR_STDOUT, "\n");
break;
}
tnObjects++;
PR_fprintf(PR_STDOUT, " OBJECT HANDLE %lu:\n", o);
for( k = 0; k < number_of_all_known_attribute_types; k++ ) {
pTemplate[k].type = all_known_attribute_types[k];
pTemplate[k].pValue = (CK_VOID_PTR)CK_NULL_PTR;
pTemplate[k].ulValueLen = 0;
}
ck_rv = epv->C_GetAttributeValue(h, o, pTemplate, number_of_all_known_attribute_types);
switch( ck_rv ) {
case CKR_OK:
case CKR_ATTRIBUTE_SENSITIVE:
case CKR_ATTRIBUTE_TYPE_INVALID:
case CKR_BUFFER_TOO_SMALL:
break;
default:
PR_fprintf(PR_STDERR, "C_GetAtributeValue(%lu, %lu, {all attribute types}, %lu) returned 0x%08x\n",
h, o, number_of_all_known_attribute_types, ck_rv);
return 1;
}
for( k = 0; k < number_of_all_known_attribute_types; k++ ) {
if( -1 != (CK_LONG)pTemplate[k].ulValueLen ) {
nAttributes++;
}
}
if( 1 ) {
PR_fprintf(PR_STDOUT, " %lu attributes:\n", nAttributes);
for( k = 0; k < number_of_all_known_attribute_types; k++ ) {
if( -1 != (CK_LONG)pTemplate[k].ulValueLen ) {
PR_fprintf(PR_STDOUT, " 0x%08x (len = %lu)\n", pTemplate[k].type,
pTemplate[k].ulValueLen);
}
}
PR_fprintf(PR_STDOUT, "\n");
}
pT2 = (CK_ATTRIBUTE_PTR)PR_Calloc(nAttributes, sizeof(CK_ATTRIBUTE));
if( (CK_ATTRIBUTE_PTR)NULL == pT2 ) {
PR_fprintf(PR_STDERR, "[memory allocation of %lu bytes failed]\n",
nAttributes * sizeof(CK_ATTRIBUTE));
return 1;
}
for( l = 0, k = 0; k < number_of_all_known_attribute_types; k++ ) {
if( -1 != (CK_LONG)pTemplate[k].ulValueLen ) {
pT2[l].type = pTemplate[k].type;
pT2[l].ulValueLen = pTemplate[k].ulValueLen;
pT2[l].pValue = (CK_VOID_PTR)PR_Malloc(pT2[l].ulValueLen);
if( (CK_VOID_PTR)NULL == pT2[l].pValue ) {
PR_fprintf(PR_STDERR, "[memory allocation of %lu bytes failed]\n", pT2[l].ulValueLen);
return 1;
}
l++;
}
}
PR_ASSERT( l == nAttributes );
ck_rv = epv->C_GetAttributeValue(h, o, pT2, nAttributes);
switch( ck_rv ) {
case CKR_OK:
case CKR_ATTRIBUTE_SENSITIVE:
case CKR_ATTRIBUTE_TYPE_INVALID:
case CKR_BUFFER_TOO_SMALL:
break;
default:
PR_fprintf(PR_STDERR, "C_GetAtributeValue(%lu, %lu, {existent attribute types}, %lu) returned 0x%08x\n",
h, o, nAttributes, ck_rv);
return 1;
}
for( l = 0; l < nAttributes; l++ ) {
PR_fprintf(PR_STDOUT, " type = 0x%08x, len = %ld", pT2[l].type, (CK_LONG)pT2[l].ulValueLen);
if( -1 == (CK_LONG)pT2[l].ulValueLen ) {
;
} else {
CK_ULONG m;
if( pT2[l].ulValueLen <= 8 ) {
PR_fprintf(PR_STDOUT, ", value = ");
} else {
PR_fprintf(PR_STDOUT, ", value = \n ");
}
for( m = 0; (m < pT2[l].ulValueLen) && (m < 20); m++ ) {
PR_fprintf(PR_STDOUT, "%02x", (CK_ULONG)(0xff & ((CK_CHAR_PTR)pT2[l].pValue)[m]));
}
PR_fprintf(PR_STDOUT, " ");
for( m = 0; (m < pT2[l].ulValueLen) && (m < 20); m++ ) {
CK_CHAR c = ((CK_CHAR_PTR)pT2[l].pValue)[m];
if( (c < 0x20) || (c >= 0x7f) ) {
c = '.';
}
PR_fprintf(PR_STDOUT, "%c", c);
}
}
PR_fprintf(PR_STDOUT, "\n");
}
PR_fprintf(PR_STDOUT, "\n");
for( l = 0; l < nAttributes; l++ ) {
PR_Free(pT2[l].pValue);
}
PR_Free(pT2);
} /* while(1) */
ck_rv = epv->C_FindObjectsFinal(h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08x\n", h, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " (%lu objects total)\n", tnObjects);
ck_rv = epv->C_CloseSession(h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CloseSession(%lu) returned 0x%08x\n", h, ck_rv);
return 1;
}
} /* session to find objects */
/* session to create, find, and delete a couple session objects */
{
CK_SESSION_HANDLE h = (CK_SESSION_HANDLE)0;
CK_ATTRIBUTE one[7], two[7], three[7], delta[1], mask[1];
CK_OBJECT_CLASS cko_data = CKO_DATA;
CK_BBOOL false = CK_FALSE, true = CK_TRUE;
char *key = "TEST PROGRAM";
CK_ULONG key_len = strlen(key);
CK_OBJECT_HANDLE hOneIn = (CK_OBJECT_HANDLE)0, hTwoIn = (CK_OBJECT_HANDLE)0,
hThreeIn = (CK_OBJECT_HANDLE)0, hDeltaIn = (CK_OBJECT_HANDLE)0;
CK_OBJECT_HANDLE found[10];
CK_ULONG nFound;
ck_rv = epv->C_OpenSession(pSlots[i], CKF_SERIAL_SESSION, (CK_VOID_PTR)CK_NULL_PTR, (CK_NOTIFY)CK_NULL_PTR, &h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_OpenSession(%lu, CKF_SERIAL_SESSION, , ) returned 0x%08x\n", pSlots[i], ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Opened a session: handle = 0x%08x\n", h);
one[0].type = CKA_CLASS;
one[0].pValue = &cko_data;
one[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
one[1].type = CKA_TOKEN;
one[1].pValue = &false;
one[1].ulValueLen = sizeof(CK_BBOOL);
one[2].type = CKA_PRIVATE;
one[2].pValue = &false;
one[2].ulValueLen = sizeof(CK_BBOOL);
one[3].type = CKA_MODIFIABLE;
one[3].pValue = &true;
one[3].ulValueLen = sizeof(CK_BBOOL);
one[4].type = CKA_LABEL;
one[4].pValue = "Test data object one";
one[4].ulValueLen = strlen(one[4].pValue);
one[5].type = CKA_APPLICATION;
one[5].pValue = key;
one[5].ulValueLen = key_len;
one[6].type = CKA_VALUE;
one[6].pValue = "Object one";
one[6].ulValueLen = strlen(one[6].pValue);
two[0].type = CKA_CLASS;
two[0].pValue = &cko_data;
two[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
two[1].type = CKA_TOKEN;
two[1].pValue = &false;
two[1].ulValueLen = sizeof(CK_BBOOL);
two[2].type = CKA_PRIVATE;
two[2].pValue = &false;
two[2].ulValueLen = sizeof(CK_BBOOL);
two[3].type = CKA_MODIFIABLE;
two[3].pValue = &true;
two[3].ulValueLen = sizeof(CK_BBOOL);
two[4].type = CKA_LABEL;
two[4].pValue = "Test data object two";
two[4].ulValueLen = strlen(two[4].pValue);
two[5].type = CKA_APPLICATION;
two[5].pValue = key;
two[5].ulValueLen = key_len;
two[6].type = CKA_VALUE;
two[6].pValue = "Object two";
two[6].ulValueLen = strlen(two[6].pValue);
three[0].type = CKA_CLASS;
three[0].pValue = &cko_data;
three[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
three[1].type = CKA_TOKEN;
three[1].pValue = &false;
three[1].ulValueLen = sizeof(CK_BBOOL);
three[2].type = CKA_PRIVATE;
three[2].pValue = &false;
three[2].ulValueLen = sizeof(CK_BBOOL);
three[3].type = CKA_MODIFIABLE;
three[3].pValue = &true;
three[3].ulValueLen = sizeof(CK_BBOOL);
three[4].type = CKA_LABEL;
three[4].pValue = "Test data object three";
three[4].ulValueLen = strlen(three[4].pValue);
three[5].type = CKA_APPLICATION;
three[5].pValue = key;
three[5].ulValueLen = key_len;
three[6].type = CKA_VALUE;
three[6].pValue = "Object three";
three[6].ulValueLen = strlen(three[6].pValue);
ck_rv = epv->C_CreateObject(h, one, 7, &hOneIn);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CreateObject(%lu, one, 7, ) returned 0x%08x\n", h, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Created object one: handle = %lu\n", hOneIn);
ck_rv = epv->C_CreateObject(h, two, 7, &hTwoIn);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CreateObject(%lu, two, 7, ) returned 0x%08x\n", h, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Created object two: handle = %lu\n", hTwoIn);
ck_rv = epv->C_CreateObject(h, three, 7, &hThreeIn);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CreateObject(%lu, three, 7, ) returned 0x%08x\n", h, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Created object three: handle = %lu\n", hThreeIn);
delta[0].type = CKA_VALUE;
delta[0].pValue = "Copied object";
delta[0].ulValueLen = strlen(delta[0].pValue);
ck_rv = epv->C_CopyObject(h, hThreeIn, delta, 1, &hDeltaIn);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CopyObject(%lu, %lu, delta, 1, ) returned 0x%08x\n",
h, hThreeIn, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Copied object three: new handle = %lu\n", hDeltaIn);
mask[0].type = CKA_APPLICATION;
mask[0].pValue = key;
mask[0].ulValueLen = key_len;
ck_rv = epv->C_FindObjectsInit(h, mask, 1);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 1) returned 0x%08x\n",
h, ck_rv);
return 1;
}
(void)memset(&found, 0, sizeof(found));
nFound = 0;
ck_rv = epv->C_FindObjects(h, found, 10, &nFound);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjects(%lu,, 10, ) returned 0x%08x\n",
h, ck_rv);
return 1;
}
if( 4 != nFound ) {
PR_fprintf(PR_STDERR, "Found %lu objects, not 4.\n", nFound);
return 1;
}
PR_fprintf(PR_STDOUT, " Found 4 objects: %lu, %lu, %lu, %lu\n",
found[0], found[1], found[2], found[3]);
ck_rv = epv->C_FindObjectsFinal(h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08x\n", h, ck_rv);
return 1;
}
ck_rv = epv->C_DestroyObject(h, hThreeIn);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_DestroyObject(%lu, %lu) returned 0x%08x\n", h, hThreeIn, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Destroyed object three (handle = %lu)\n", hThreeIn);
delta[0].type = CKA_APPLICATION;
delta[0].pValue = "Changed application";
delta[0].ulValueLen = strlen(delta[0].pValue);
ck_rv = epv->C_SetAttributeValue(h, hTwoIn, delta, 1);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_SetAttributeValue(%lu, %lu, delta, 1) returned 0x%08x\n",
h, hTwoIn, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Changed object two (handle = %lu).\n", hTwoIn);
/* Can another session find these session objects? */
{
CK_SESSION_HANDLE h2 = (CK_SESSION_HANDLE)0;
ck_rv = epv->C_OpenSession(pSlots[i], CKF_SERIAL_SESSION, (CK_VOID_PTR)CK_NULL_PTR, (CK_NOTIFY)CK_NULL_PTR, &h2);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_OpenSession(%lu, CKF_SERIAL_SESSION, , ) returned 0x%08x\n", pSlots[i], ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Opened a second session: handle = 0x%08x\n", h2);
/* mask is still the same */
ck_rv = epv->C_FindObjectsInit(h2, mask, 1);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 1) returned 0x%08x\n",
h2, ck_rv);
return 1;
}
(void)memset(&found, 0, sizeof(found));
nFound = 0;
ck_rv = epv->C_FindObjects(h2, found, 10, &nFound);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjects(%lu,, 10, ) returned 0x%08x\n",
h2, ck_rv);
return 1;
}
if( 2 != nFound ) {
PR_fprintf(PR_STDERR, "Found %lu objects, not 2.\n", nFound);
return 1;
}
PR_fprintf(PR_STDOUT, " Found 2 objects: %lu, %lu\n",
found[0], found[1]);
ck_rv = epv->C_FindObjectsFinal(h2);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08x\n", h2, ck_rv);
return 1;
}
/* Leave the session hanging open, we'll CloseAllSessions later */
} /* Can another session find these session objects? */
ck_rv = epv->C_CloseAllSessions(pSlots[i]);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CloseAllSessions(%lu) returned 0x%08x\n", pSlots[i], ck_rv);
return 1;
}
} /* session to create, find, and delete a couple session objects */
/* Might be interesting to do a find here to verify that all session objects are gone. */
if( tinfo.flags & CKF_WRITE_PROTECTED ) {
PR_fprintf(PR_STDOUT, "Token is write protected, skipping token-object tests.\n");
} else {
CK_SESSION_HANDLE h = (CK_SESSION_HANDLE)0;
CK_ATTRIBUTE tobj[7], tsobj[7], stobj[7], delta[1], mask[2];
CK_OBJECT_CLASS cko_data = CKO_DATA;
CK_BBOOL false = CK_FALSE, true = CK_TRUE;
char *key = "TEST PROGRAM";
CK_ULONG key_len = strlen(key);
CK_OBJECT_HANDLE hTIn = (CK_OBJECT_HANDLE)0, hTSIn = (CK_OBJECT_HANDLE)0,
hSTIn = (CK_OBJECT_HANDLE)0, hDeltaIn = (CK_OBJECT_HANDLE)0;
CK_OBJECT_HANDLE found[10];
CK_ULONG nFound;
ck_rv = epv->C_OpenSession(pSlots[i], CKF_SERIAL_SESSION, (CK_VOID_PTR)CK_NULL_PTR, (CK_NOTIFY)CK_NULL_PTR, &h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_OpenSession(%lu, CKF_SERIAL_SESSION, , ) returned 0x%08x\n", pSlots[i], ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Opened a session: handle = 0x%08x\n", h);
tobj[0].type = CKA_CLASS;
tobj[0].pValue = &cko_data;
tobj[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
tobj[1].type = CKA_TOKEN;
tobj[1].pValue = &true;
tobj[1].ulValueLen = sizeof(CK_BBOOL);
tobj[2].type = CKA_PRIVATE;
tobj[2].pValue = &false;
tobj[2].ulValueLen = sizeof(CK_BBOOL);
tobj[3].type = CKA_MODIFIABLE;
tobj[3].pValue = &true;
tobj[3].ulValueLen = sizeof(CK_BBOOL);
tobj[4].type = CKA_LABEL;
tobj[4].pValue = "Test data object token";
tobj[4].ulValueLen = strlen(tobj[4].pValue);
tobj[5].type = CKA_APPLICATION;
tobj[5].pValue = key;
tobj[5].ulValueLen = key_len;
tobj[6].type = CKA_VALUE;
tobj[6].pValue = "Object token";
tobj[6].ulValueLen = strlen(tobj[6].pValue);
tsobj[0].type = CKA_CLASS;
tsobj[0].pValue = &cko_data;
tsobj[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
tsobj[1].type = CKA_TOKEN;
tsobj[1].pValue = &true;
tsobj[1].ulValueLen = sizeof(CK_BBOOL);
tsobj[2].type = CKA_PRIVATE;
tsobj[2].pValue = &false;
tsobj[2].ulValueLen = sizeof(CK_BBOOL);
tsobj[3].type = CKA_MODIFIABLE;
tsobj[3].pValue = &true;
tsobj[3].ulValueLen = sizeof(CK_BBOOL);
tsobj[4].type = CKA_LABEL;
tsobj[4].pValue = "Test data object token->session";
tsobj[4].ulValueLen = strlen(tsobj[4].pValue);
tsobj[5].type = CKA_APPLICATION;
tsobj[5].pValue = key;
tsobj[5].ulValueLen = key_len;
tsobj[6].type = CKA_VALUE;
tsobj[6].pValue = "Object token->session";
tsobj[6].ulValueLen = strlen(tsobj[6].pValue);
stobj[0].type = CKA_CLASS;
stobj[0].pValue = &cko_data;
stobj[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
stobj[1].type = CKA_TOKEN;
stobj[1].pValue = &false;
stobj[1].ulValueLen = sizeof(CK_BBOOL);
stobj[2].type = CKA_PRIVATE;
stobj[2].pValue = &false;
stobj[2].ulValueLen = sizeof(CK_BBOOL);
stobj[3].type = CKA_MODIFIABLE;
stobj[3].pValue = &true;
stobj[3].ulValueLen = sizeof(CK_BBOOL);
stobj[4].type = CKA_LABEL;
stobj[4].pValue = "Test data object session->token";
stobj[4].ulValueLen = strlen(stobj[4].pValue);
stobj[5].type = CKA_APPLICATION;
stobj[5].pValue = key;
stobj[5].ulValueLen = key_len;
stobj[6].type = CKA_VALUE;
stobj[6].pValue = "Object session->token";
stobj[6].ulValueLen = strlen(stobj[6].pValue);
ck_rv = epv->C_CreateObject(h, tobj, 7, &hTIn);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CreateObject(%lu, tobj, 7, ) returned 0x%08x\n", h, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Created object token: handle = %lu\n", hTIn);
ck_rv = epv->C_CreateObject(h, tsobj, 7, &hTSIn);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CreateObject(%lu, tobj, 7, ) returned 0x%08x\n", h, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Created object token->session: handle = %lu\n", hTSIn);
ck_rv = epv->C_CreateObject(h, stobj, 7, &hSTIn);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CreateObject(%lu, tobj, 7, ) returned 0x%08x\n", h, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Created object session->token: handle = %lu\n", hSTIn);
/* I've created two token objects and one session object; find the two */
mask[0].type = CKA_APPLICATION;
mask[0].pValue = key;
mask[0].ulValueLen = key_len;
mask[1].type = CKA_TOKEN;
mask[1].pValue = &true;
mask[1].ulValueLen = sizeof(CK_BBOOL);
ck_rv = epv->C_FindObjectsInit(h, mask, 2);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 2) returned 0x%08x\n",
h, ck_rv);
return 1;
}
(void)memset(&found, 0, sizeof(found));
nFound = 0;
ck_rv = epv->C_FindObjects(h, found, 10, &nFound);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjects(%lu,, 10, ) returned 0x%08x\n",
h, ck_rv);
return 1;
}
if( 2 != nFound ) {
PR_fprintf(PR_STDERR, "Found %lu objects, not 2.\n", nFound);
return 1;
}
PR_fprintf(PR_STDOUT, " Found 2 objects: %lu, %lu\n",
found[0], found[1]);
ck_rv = epv->C_FindObjectsFinal(h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08x\n", h, ck_rv);
return 1;
}
/* Convert a token to session object */
delta[0].type = CKA_TOKEN;
delta[0].pValue = &false;
delta[0].ulValueLen = sizeof(CK_BBOOL);
ck_rv = epv->C_SetAttributeValue(h, hTSIn, delta, 1);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_SetAttributeValue(%lu, %lu, delta, 1) returned 0x%08x\n",
h, hTSIn, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Changed object from token to session (handle = %lu).\n", hTSIn);
/* Now find again; there should be one */
mask[0].type = CKA_APPLICATION;
mask[0].pValue = key;
mask[0].ulValueLen = key_len;
mask[1].type = CKA_TOKEN;
mask[1].pValue = &true;
mask[1].ulValueLen = sizeof(CK_BBOOL);
ck_rv = epv->C_FindObjectsInit(h, mask, 2);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 2) returned 0x%08x\n",
h, ck_rv);
return 1;
}
(void)memset(&found, 0, sizeof(found));
nFound = 0;
ck_rv = epv->C_FindObjects(h, found, 10, &nFound);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjects(%lu,, 10, ) returned 0x%08x\n",
h, ck_rv);
return 1;
}
if( 1 != nFound ) {
PR_fprintf(PR_STDERR, "Found %lu objects, not 1.\n", nFound);
return 1;
}
PR_fprintf(PR_STDOUT, " Found 1 objects: %lu\n",
found[0]);
ck_rv = epv->C_FindObjectsFinal(h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08x\n", h, ck_rv);
return 1;
}
/* Convert a session to a token object */
delta[0].type = CKA_TOKEN;
delta[0].pValue = &true;
delta[0].ulValueLen = sizeof(CK_BBOOL);
ck_rv = epv->C_SetAttributeValue(h, hSTIn, delta, 1);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_SetAttributeValue(%lu, %lu, delta, 1) returned 0x%08x\n",
h, hSTIn, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Changed object from session to token (handle = %lu).\n", hSTIn);
/* Now find again; there should be two again */
mask[0].type = CKA_APPLICATION;
mask[0].pValue = key;
mask[0].ulValueLen = key_len;
mask[1].type = CKA_TOKEN;
mask[1].pValue = &true;
mask[1].ulValueLen = sizeof(CK_BBOOL);
ck_rv = epv->C_FindObjectsInit(h, mask, 2);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 2) returned 0x%08x\n",
h, ck_rv);
return 1;
}
(void)memset(&found, 0, sizeof(found));
nFound = 0;
ck_rv = epv->C_FindObjects(h, found, 10, &nFound);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjects(%lu,, 10, ) returned 0x%08x\n",
h, ck_rv);
return 1;
}
if( 2 != nFound ) {
PR_fprintf(PR_STDERR, "Found %lu objects, not 2.\n", nFound);
return 1;
}
PR_fprintf(PR_STDOUT, " Found 2 objects: %lu, %lu\n",
found[0], found[1]);
ck_rv = epv->C_FindObjectsFinal(h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08x\n", h, ck_rv);
return 1;
}
/* Delete the two (found) token objects to clean up */
ck_rv = epv->C_DestroyObject(h, found[0]);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_DestroyObject(%lu, %lu) returned 0x%08x\n", h, found[0], ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Destroyed token object (handle = %lu)\n", found[0]);
ck_rv = epv->C_DestroyObject(h, found[1]);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_DestroyObject(%lu, %lu) returned 0x%08x\n", h, found[1], ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Destroyed token object (handle = %lu)\n", found[1]);
/* Close the session and all objects should be gone */
ck_rv = epv->C_CloseSession(h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CloseSession(%lu) returned 0x%08x\n", h, ck_rv);
return 1;
}
} /* if( tinfo.flags & CKF_WRITE_PROTECTED ) */
if( tinfo.flags & CKF_WRITE_PROTECTED ) {
PR_fprintf(PR_STDOUT, "Token is write protected, skipping leaving a record.\n");
} else {
CK_SESSION_HANDLE h = (CK_SESSION_HANDLE)0;
CK_ATTRIBUTE record[7], mask[2];
CK_OBJECT_CLASS cko_data = CKO_DATA;
CK_BBOOL false = CK_FALSE, true = CK_TRUE;
char *key = "TEST RECORD";
CK_ULONG key_len = strlen(key);
CK_OBJECT_HANDLE hin = (CK_OBJECT_HANDLE)0;
char timebuffer[256];
ck_rv = epv->C_OpenSession(pSlots[i], CKF_SERIAL_SESSION, (CK_VOID_PTR)CK_NULL_PTR, (CK_NOTIFY)CK_NULL_PTR, &h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_OpenSession(%lu, CKF_SERIAL_SESSION, , ) returned 0x%08x\n", pSlots[i], ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Opened a session: handle = 0x%08x\n", h);
/* I can't believe how hard NSPR makes this operation */
{
time_t now = 0;
struct tm *tm;
time(&now);
tm = localtime(&now);
strftime(timebuffer, sizeof(timebuffer), "%Y-%m-%d %T %Z", tm);
}
record[0].type = CKA_CLASS;
record[0].pValue = &cko_data;
record[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
record[1].type = CKA_TOKEN;
record[1].pValue = &true;
record[1].ulValueLen = sizeof(CK_BBOOL);
record[2].type = CKA_PRIVATE;
record[2].pValue = &false;
record[2].ulValueLen = sizeof(CK_BBOOL);
record[3].type = CKA_MODIFIABLE;
record[3].pValue = &true;
record[3].ulValueLen = sizeof(CK_BBOOL);
record[4].type = CKA_LABEL;
record[4].pValue = "Test record";
record[4].ulValueLen = strlen(record[4].pValue);
record[5].type = CKA_APPLICATION;
record[5].pValue = key;
record[5].ulValueLen = key_len;
record[6].type = CKA_VALUE;
record[6].pValue = timebuffer;
record[6].ulValueLen = strlen(timebuffer)+1;
PR_fprintf(PR_STDOUT, " Timestamping with \"%s\"\n", timebuffer);
ck_rv = epv->C_CreateObject(h, record, 7, &hin);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_CreateObject(%lu, tobj, 7, ) returned 0x%08x\n", h, ck_rv);
return 1;
}
PR_fprintf(PR_STDOUT, " Created record object: handle = %lu\n", hin);
PR_fprintf(PR_STDOUT, " == All test timestamps ==\n");
mask[0].type = CKA_CLASS;
mask[0].pValue = &cko_data;
mask[0].ulValueLen = sizeof(CK_OBJECT_CLASS);
mask[1].type = CKA_APPLICATION;
mask[1].pValue = key;
mask[1].ulValueLen = key_len;
ck_rv = epv->C_FindObjectsInit(h, mask, 2);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsInit(%lu, mask, 1) returned 0x%08x\n",
h, ck_rv);
return 1;
}
while( 1 ) {
CK_OBJECT_HANDLE o = (CK_OBJECT_HANDLE)0;
CK_ULONG nObjects = 0;
CK_ATTRIBUTE value[1];
char buffer[1024];
ck_rv = epv->C_FindObjects(h, &o, 1, &nObjects);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjects(%lu, , 1, ) returned 0x%08x\n", h, ck_rv);
return 1;
}
if( 0 == nObjects ) {
PR_fprintf(PR_STDOUT, "\n");
break;
}
value[0].type = CKA_VALUE;
value[0].pValue = buffer;
value[0].ulValueLen = sizeof(buffer);
ck_rv = epv->C_GetAttributeValue(h, o, value, 1);
switch( ck_rv ) {
case CKR_OK:
PR_fprintf(PR_STDOUT, " %s\n", value[0].pValue);
break;
case CKR_ATTRIBUTE_SENSITIVE:
PR_fprintf(PR_STDOUT, " [Sensitive???]\n");
break;
case CKR_ATTRIBUTE_TYPE_INVALID:
PR_fprintf(PR_STDOUT, " [Invalid attribute???]\n");
break;
case CKR_BUFFER_TOO_SMALL:
PR_fprintf(PR_STDOUT, " (result > 1k (%lu))\n", value[0].ulValueLen);
break;
default:
PR_fprintf(PR_STDERR, "C_GetAtributeValue(%lu, %lu, CKA_VALUE, 1) returned 0x%08x\n",
h, o);
return 1;
}
} /* while */
ck_rv = epv->C_FindObjectsFinal(h);
if( CKR_OK != ck_rv ) {
PR_fprintf(PR_STDERR, "C_FindObjectsFinal(%lu) returned 0x%08x\n", h, ck_rv);
return 1;
}
} /* "leaving a record" else clause */
}
PR_fprintf(PR_STDOUT, "\n");
}
return 0;
}
STDMETHODIMP
VideoSourceWin::SampleCB(double Time, IMediaSample *pSample)
{
HRESULT hr;
nsresult rv;
PRUint32 wr;
BYTE *pBuffer;
long bufferLen;
PRUint8 *i420buf;
int start, end, fsize, isize, bpp;
bpp = 4;
fsize = width * height * 4;
isize = width * height * 3 / 2;
bufferLen = pSample->GetActualDataLength();
hr = pSample->GetPointer(&pBuffer);
nsAutoArrayPtr<PRUint8> rgb32(new PRUint8[bufferLen]);
memcpy(rgb32.get(), pBuffer, bufferLen);
pBuffer = rgb32.get();
/* Reverse RGB32 top-down */
PRUint8 tmp;
for (start = 0, end = bufferLen - bpp;
start < bufferLen / 2;
start += bpp, end -= bpp) {
/* While we're here let's do a RGB<->BGR swap */
tmp = pBuffer[start];
pBuffer[start] = pBuffer[end+2];
pBuffer[end+2] = tmp;
tmp = pBuffer[start+1];
pBuffer[start+1] = pBuffer[end+1];
pBuffer[end+1] = tmp;
tmp = pBuffer[start+2];
pBuffer[start+2] = pBuffer[end];
pBuffer[end] = tmp;
tmp = pBuffer[start+3];
pBuffer[start+3] = pBuffer[end+3];
pBuffer[end+3] = tmp;
}
/* Write header: timestamp + length */
if (is_rec != PR_TRUE)
return S_OK;
//PRFloat64 current = epoch + Time;
PRTime epoch_c = PR_Now();
PRFloat64 epoch = (PRFloat64)(epoch_c / MICROSECONDS);
epoch += ((PRFloat64)(epoch_c % MICROSECONDS)) / MICROSECONDS;
rv = output->Write(
(const char *)&epoch, sizeof(PRFloat64), &wr
);
rv = output->Write(
(const char *)&isize, sizeof(PRUint32), &wr
);
/* Write to pipe after converting to i420 */
i420buf = (PRUint8 *)PR_Calloc(isize, sizeof(PRUint8));
RGB32toI420(width, height, (const char *)pBuffer, (char *)i420buf);
rv = output->Write((const char *)i420buf, isize, &wr);
PR_Free(i420buf);
/* Write sample to canvas if neccessary */
if (vCanvas) {
nsCOMPtr<nsIRunnable> render = new CanvasRenderer(
vCanvas, width, height, rgb32, fsize
);
rv = NS_DispatchToMainThread(render);
}
rgb32 = NULL; // AutoPtr should free this?
return S_OK;
}
/* # 1022 "arena.c" */
extern void *
nss_ZRealloc
(
void *pointer,
PRUint32 newSize
)
{
NSSArena *arena;
struct pointer_header *h, *new_h;
PRUint32 my_newSize = newSize + sizeof(struct pointer_header);
void *rv;
if( my_newSize < sizeof(struct pointer_header) ) {
nss_SetError(NSS_ERROR_NO_MEMORY);
return (void *)((void *)0);
}
if( (void *)((void *)0) == pointer ) {
nss_SetError(NSS_ERROR_INVALID_POINTER);
return (void *)((void *)0);
}
h = (struct pointer_header *)((char *)pointer
- sizeof(struct pointer_header));
if( newSize == h->size ) {
return pointer;
}
arena = h->arena;
if (!arena) {
new_h = (struct pointer_header *)PR_Calloc(1, my_newSize);
if( (struct pointer_header *)((void *)0) == new_h ) {
nss_SetError(NSS_ERROR_NO_MEMORY);
return (void *)((void *)0);
}
new_h->arena = (NSSArena *)((void *)0);
new_h->size = newSize;
rv = (void *)((char *)new_h + sizeof(struct pointer_header));
if( newSize > h->size ) {
(void)nsslibc_memcpy(rv, pointer, h->size);
(void)nsslibc_memset(&((char *)rv)[ h->size ],
0, (newSize - h->size));
} else {
(void)nsslibc_memcpy(rv, pointer, newSize);
}
(void)nsslibc_memset(pointer, 0, h->size);
h->size = 0;
PR_Free(h);
return rv;
} else {
void *p;
if (!arena->lock) {
nss_SetError(NSS_ERROR_INVALID_POINTER);
return (void *)((void *)0);
}
PR_Lock(arena->lock);
/* # 1107 "arena.c" */
if( newSize < h->size ) {
/* # 1120 "arena.c" */
char *extra = &((char *)pointer)[ newSize ];
(void)nsslibc_memset(extra, 0, (h->size - newSize));
PR_Unlock(arena->lock);
return pointer;
}
do { PLArena *_a = (&arena->pool)->current; PRUint32 _nb = (((PRUword)(my_newSize) + (&arena->pool)->mask) & ~(&arena->pool)->mask); PRUword _p = _a->avail; PRUword _q = _p + _nb; if (_q > _a->limit) _p = (PRUword)PL_ArenaAllocate(&arena->pool, _nb); else _a->avail = _q; p = (void *)_p; ; } while (0);
if( (void *)((void *)0) == p ) {
PR_Unlock(arena->lock);
nss_SetError(NSS_ERROR_NO_MEMORY);
return (void *)((void *)0);
}
new_h = (struct pointer_header *)p;
new_h->arena = arena;
new_h->size = newSize;
rv = (void *)((char *)new_h + sizeof(struct pointer_header));
if (rv != pointer) {
(void)nsslibc_memcpy(rv, pointer, h->size);
(void)nsslibc_memset(pointer, 0, h->size);
}
(void)nsslibc_memset(&((char *)rv)[ h->size ], 0, (newSize - h->size));
h->arena = (NSSArena *)((void *)0);
h->size = 0;
PR_Unlock(arena->lock);
return rv;
}
}
/**
* Given an nsIArray of nsILDAPControls, return the appropriate
* zero-terminated array of LDAPControls ready to pass in to the C SDK.
*/
static nsresult
convertControlArray(nsIArray *aXpcomArray, LDAPControl ***aArray)
{
// get the size of the original array
PRUint32 length;
nsresult rv = aXpcomArray->GetLength(&length);
NS_ENSURE_SUCCESS(rv, rv);
// don't allocate an array if someone passed us in an empty one
if (!length) {
*aArray = 0;
return NS_OK;
}
// allocate a local array of the form understood by the C-SDK;
// +1 is to account for the final null terminator. PR_Calloc is
// is used so that ldap_controls_free will work anywhere during the
// iteration
LDAPControl **controls =
static_cast<LDAPControl **>
(PR_Calloc(length+1, sizeof(LDAPControl)));
// prepare to enumerate the array
nsCOMPtr<nsISimpleEnumerator> enumerator;
rv = aXpcomArray->Enumerate(getter_AddRefs(enumerator));
NS_ENSURE_SUCCESS(rv, rv);
bool moreElements;
rv = enumerator->HasMoreElements(&moreElements);
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 i = 0;
while (moreElements) {
// get the next array element
nsCOMPtr<nsISupports> isupports;
rv = enumerator->GetNext(getter_AddRefs(isupports));
if (NS_FAILED(rv)) {
ldap_controls_free(controls);
return rv;
}
nsCOMPtr<nsILDAPControl> control = do_QueryInterface(isupports, &rv);
if (NS_FAILED(rv)) {
ldap_controls_free(controls);
return NS_ERROR_INVALID_ARG; // bogus element in the array
}
nsLDAPControl *ctl = static_cast<nsLDAPControl *>
(static_cast<nsILDAPControl *>
(control.get()));
// convert it to an LDAPControl structure placed in the new array
rv = ctl->ToLDAPControl(&controls[i]);
if (NS_FAILED(rv)) {
ldap_controls_free(controls);
return rv;
}
// on to the next element
rv = enumerator->HasMoreElements(&moreElements);
if (NS_FAILED(rv)) {
ldap_controls_free(controls);
return NS_ERROR_UNEXPECTED;
}
++i;
}
*aArray = controls;
return NS_OK;
}
PR_IMPLEMENT(PRInt32) PR_Select(
PRInt32 unused, PR_fd_set *pr_rd, PR_fd_set *pr_wr,
PR_fd_set *pr_ex, PRIntervalTime timeout)
{
#if !defined(NEED_SELECT)
PRInt32 npds = 0;
/*
** Find out how many fds are represented in the three lists.
** Then allocate a polling descriptor for the logical union
** (there can't be any overlapping) and call PR_Poll().
*/
PRPollDesc *copy, *poll;
static PRBool warning = PR_TRUE;
if (warning) warning = _PR_Obsolete( "PR_Select()", "PR_Poll()");
/* try to get an initial guesss at how much space we need */
npds = 0;
if ((NULL != pr_rd) && ((pr_rd->hsize + pr_rd->nsize - npds) > 0))
npds = pr_rd->hsize + pr_rd->nsize;
if ((NULL != pr_wr) && ((pr_wr->hsize + pr_wr->nsize - npds) > 0))
npds = pr_wr->hsize + pr_wr->nsize;
if ((NULL != pr_ex) && ((pr_ex->hsize + pr_ex->nsize - npds) > 0))
npds = pr_ex->hsize + pr_ex->nsize;
if (0 == npds)
{
PR_Sleep(timeout);
return 0;
}
copy = poll = (PRPollDesc*)PR_Calloc(npds + PD_INCR, sizeof(PRPollDesc));
if (NULL == poll) goto out_of_memory;
poll[npds + PD_INCR - 1].fd = (PRFileDesc*)-1;
poll = _pr_setfd(pr_rd, PR_POLL_READ, poll);
if (NULL == poll) goto out_of_memory;
poll = _pr_setfd(pr_wr, PR_POLL_WRITE, poll);
if (NULL == poll) goto out_of_memory;
poll = _pr_setfd(pr_ex, PR_POLL_EXCEPT, poll);
if (NULL == poll) goto out_of_memory;
unused = 0;
while (NULL != poll[unused].fd && (PRFileDesc*)-1 != poll[unused].fd)
{
++unused;
}
PR_ASSERT(unused > 0);
npds = PR_Poll(poll, unused, timeout);
if (npds > 0)
{
/* Copy the results back into the fd sets */
if (NULL != pr_rd) pr_rd->nsize = pr_rd->hsize = 0;
if (NULL != pr_wr) pr_wr->nsize = pr_wr->hsize = 0;
if (NULL != pr_ex) pr_ex->nsize = pr_ex->hsize = 0;
for (copy = &poll[unused - 1]; copy >= poll; --copy)
{
if (copy->out_flags & PR_POLL_NVAL)
{
PR_SetError(PR_BAD_DESCRIPTOR_ERROR, 0);
npds = -1;
break;
}
if (copy->out_flags & PR_POLL_READ)
if (NULL != pr_rd) pr_rd->harray[pr_rd->hsize++] = copy->fd;
if (copy->out_flags & PR_POLL_WRITE)
if (NULL != pr_wr) pr_wr->harray[pr_wr->hsize++] = copy->fd;
if (copy->out_flags & PR_POLL_EXCEPT)
if (NULL != pr_ex) pr_ex->harray[pr_ex->hsize++] = copy->fd;
}
}
PR_DELETE(poll);
return npds;
out_of_memory:
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return -1;
#endif /* !defined(NEED_SELECT) */
}
NS_IMETHODIMP nsAbView::OnItemPropertyChanged(nsISupports *item, const char *property, const PRUnichar *oldValue, const PRUnichar *newValue)
{
nsresult rv;
nsCOMPtr <nsIAbCard> card = do_QueryInterface(item);
if (!card)
return NS_OK;
PRInt32 index = FindIndexForCard(card);
if (index == -1)
return NS_OK;
AbCard *oldCard = (AbCard*) (mCards.ElementAt(index));
// Malloc these from an arena
AbCard *newCard = (AbCard *) PR_Calloc(1, sizeof(struct AbCard));
if (!newCard)
return NS_ERROR_OUT_OF_MEMORY;
newCard->card = card;
NS_IF_ADDREF(newCard->card);
rv = GenerateCollationKeysForCard(mSortColumn.get(), newCard);
NS_ENSURE_SUCCESS(rv,rv);
bool cardWasSelected = false;
if (mTreeSelection) {
rv = mTreeSelection->IsSelected(index, &cardWasSelected);
NS_ENSURE_SUCCESS(rv,rv);
}
if (!CompareCollationKeys(newCard->primaryCollationKey,newCard->primaryCollationKeyLen,oldCard->primaryCollationKey,oldCard->primaryCollationKeyLen)
&& CompareCollationKeys(newCard->secondaryCollationKey,newCard->secondaryCollationKeyLen,oldCard->secondaryCollationKey,oldCard->secondaryCollationKeyLen)) {
// No need to remove and add, since the collation keys haven't changed.
// Since they haven't changed, the card will sort to the same place.
// We just need to clean up what we allocated.
NS_IF_RELEASE(newCard->card);
if (newCard->primaryCollationKey)
nsMemory::Free(newCard->primaryCollationKey);
if (newCard->secondaryCollationKey)
nsMemory::Free(newCard->secondaryCollationKey);
PR_FREEIF(newCard);
// Still need to invalidate, as the other columns may have changed.
rv = InvalidateTree(index);
NS_ENSURE_SUCCESS(rv,rv);
}
else {
mSuppressSelectionChange = true;
mSuppressCountChange = true;
// Remove the old card.
rv = RemoveCardAt(index);
NS_ASSERTION(NS_SUCCEEDED(rv), "remove card failed\n");
// Add the card we created, and select it (to restore selection) if it was selected.
rv = AddCard(newCard, cardWasSelected /* select card */, &index);
NS_ASSERTION(NS_SUCCEEDED(rv), "add card failed\n");
mSuppressSelectionChange = false;
mSuppressCountChange = false;
// Ensure restored selection is visible
if (cardWasSelected && mTree)
mTree->EnsureRowIsVisible(index);
}
// Although the selection hasn't changed, the card that is selected may need
// to be displayed differently, therefore pretend that the selection has
// changed to force that update.
if (cardWasSelected)
SelectionChanged();
return NS_OK;
}
