/* * === 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; }