static void docheck(pmResult *result) { int i, j, k; int sts; pmDesc desc; pmAtomValue av; pmValue *vp; pmValueSet *vsp; __pmHashNode *hptr = NULL; checkData *checkdata = NULL; double diff; struct timeval timediff; for (i = 0; i < result->numpmid; i++) { vsp = result->vset[i]; #ifdef PCP_DEBUG if (pmDebug & DBG_TRACE_APPL1) { if (vsp->numval == 0) { fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol); print_stamp(stderr, &result->timestamp); fprintf(stderr, "] "); print_metric(stderr, vsp->pmid); fprintf(stderr, ": no values returned\n"); continue; } else if (vsp->numval < 0) { fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol); print_stamp(stderr, &result->timestamp); fprintf(stderr, "] "); print_metric(stderr, vsp->pmid); fprintf(stderr, ": error from numval: %s\n", pmErrStr(vsp->numval)); continue; } } #endif if (vsp->numval <= 0) continue; /* check if pmid already in hash list */ if ((hptr = __pmHashSearch(vsp->pmid, &hashlist)) == NULL) { if ((sts = pmLookupDesc(vsp->pmid, &desc)) < 0) { fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol); print_stamp(stderr, &result->timestamp); fprintf(stderr, "] "); print_metric(stderr, vsp->pmid); fprintf(stderr, ": pmLookupDesc failed: %s\n", pmErrStr(sts)); continue; } if (desc.type != PM_TYPE_32 && desc.type != PM_TYPE_U32 && desc.type != PM_TYPE_64 && desc.type != PM_TYPE_U64 && desc.type != PM_TYPE_FLOAT && desc.type != PM_TYPE_DOUBLE) { continue; /* no checks for non-numeric metrics */ } /* create a new one & add to list */ checkdata = (checkData*) malloc(sizeof(checkData)); newHashItem(vsp, &desc, checkdata, &result->timestamp); if (__pmHashAdd(checkdata->desc.pmid, (void*)checkdata, &hashlist) < 0) { fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol); print_stamp(stderr, &result->timestamp); fprintf(stderr, "] "); print_metric(stderr, vsp->pmid); fprintf(stderr, ": __pmHashAdd failed (internal pmlogcheck error)\n"); /* free memory allocated above on insert failure */ for (j = 0; j < vsp->numval; j++) { if (checkdata->instlist[j] != NULL) free(checkdata->instlist[j]); } if (checkdata->instlist != NULL) free(checkdata->instlist); continue; } } else { /* pmid exists - update statistics */ checkdata = (checkData *)hptr->data; for (j = 0; j < vsp->numval; j++) { /* iterate thro result values */ vp = &vsp->vlist[j]; k = j; /* index into stored inst list, result may differ */ if ((vsp->numval > 1) || (checkdata->desc.indom != PM_INDOM_NULL)) { /* must store values using correct inst - probably in correct order already */ if ((k < checkdata->listsize) && (checkdata->instlist[k]->inst != vp->inst)) { for (k = 0; k < checkdata->listsize; k++) { if (vp->inst == checkdata->instlist[k]->inst) { break; /* k now correct */ } } if (k == checkdata->listsize) { /* no matching inst was found */ newHashInst(vp, checkdata, vsp->valfmt, &result->timestamp, k); continue; } } else if (k >= checkdata->listsize) { k = checkdata->listsize; newHashInst(vp, checkdata, vsp->valfmt, &result->timestamp, k); continue; } } if (k >= checkdata->listsize) { /* only error values observed so far */ k = checkdata->listsize; newHashInst(vp, checkdata, vsp->valfmt, &result->timestamp, k); continue; } timediff = result->timestamp; tsub(&timediff, &(checkdata->instlist[k]->lasttime)); if (timediff.tv_sec < 0) { /* clip negative values at zero */ timediff.tv_sec = 0; timediff.tv_usec = 0; } diff = __pmtimevalToReal(&timediff); if ((sts = pmExtractValue(vsp->valfmt, vp, checkdata->desc.type, &av, PM_TYPE_DOUBLE)) < 0) { fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol); print_stamp(stderr, &result->timestamp); fprintf(stderr, "] "); print_metric(stderr, vsp->pmid); fprintf(stderr, ": pmExtractValue failed: %s\n", pmErrStr(sts)); continue; } if (checkdata->desc.sem == PM_SEM_COUNTER) { if (diff == 0.0) continue; diff *= checkdata->scale; #ifdef PCP_DEBUG if (pmDebug & DBG_TRACE_APPL2) { fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol); print_stamp(stderr, &result->timestamp); fprintf(stderr, "] "); print_metric(stderr, checkdata->desc.pmid); fprintf(stderr, ": current counter value is %.0f\n", av.d); } #endif unwrap(av.d, &(result->timestamp), checkdata, k); } checkdata->instlist[k]->lastval = av.d; checkdata->instlist[k]->lasttime = result->timestamp; } } } }
void reset(const auv_msgs::NavSts& ref, const auv_msgs::NavSts& state) { con.internalState = 0; con.lastState = useIP?unwrap(state.orientation.yaw):state.orientation.yaw; };
// Prepares interpolator instance, e.g. setups spline object. void interpolator::prepare (int interpol, int repitition, int domain) { interpolType = interpol; dataType |= (domain & DATA_MASK_DOMAIN); repeat = repitition; // preparations for cyclic interpolations if (repeat & REPEAT_YES) { duration = rx[length - 1] - rx[0]; // set first value to the end of the value vector if (cy) cy[length - 1] = cy[0]; if (ry) ry[length - 1] = ry[0]; } // preparations for polar complex data if (cy != NULL && (domain & DATA_POLAR) && length > 1) { // unwrap phase of complex data vector vector ang = vector (length); for (int i = 0; i < length; i++) ang (i) = arg (cy[i]); ang = unwrap (ang); // store complex data for (int i = 0; i < length; i++) { cy[i] = rect (abs (cy[i]), real (ang (i))); } } // preparations spline interpolations if (interpolType & INTERPOL_CUBIC) { // prepare complex vector interpolation using splines if (cy != NULL) { // create splines if necessary if (rsp) delete rsp; if (isp) delete isp; rsp = new spline (SPLINE_BC_NATURAL); isp = new spline (SPLINE_BC_NATURAL); if (repeat & REPEAT_YES) { rsp->setBoundary (SPLINE_BC_PERIODIC); isp->setBoundary (SPLINE_BC_PERIODIC); } // prepare data vectors vector rv = vector (length); vector iv = vector (length); vector rt = vector (length); for (int i = 0; i < length; i++) { rv (i) = real (cy[i]); iv (i) = imag (cy[i]); rt (i) = rx[i]; } // pass data vectors to splines and construct these rsp->vectors (rv, rt); isp->vectors (iv, rt); rsp->construct (); isp->construct (); } // prepare real vector interpolation using spline else { if (rsp) delete rsp; rsp = new spline (SPLINE_BC_NATURAL); if (repeat & REPEAT_YES) rsp->setBoundary (SPLINE_BC_PERIODIC); rsp->vectors (ry, rx, length); rsp->construct (); } } }
session_iterator session_iterator::operator++() { obj_ = pn_session_next(unwrap(obj_), 0); return *this; }
Handle<Value> Proxy::proxyOnPropertiesChanged(const Arguments& args) { HandleScope scope; Handle<Object> jsProxy = args.Holder(); if (args.Length() < 1 || !args[0]->IsArray()) { return JSException::Error("Proxy.propertiesChanged requires a list of lists of property name, the old value, and the new value"); } JNIEnv *env = JNIScope::getEnv(); if (!env) { return JSException::GetJNIEnvironmentError(); } Proxy *proxy = unwrap(jsProxy); if (!proxy) { return JSException::Error("Failed to unwrap Proxy instance"); } Local<Array> changes = Local<Array>::Cast(args[0]); uint32_t length = changes->Length(); jobjectArray jChanges = env->NewObjectArray(length, JNIUtil::objectClass, NULL); for (uint32_t i = 0; i < length; ++i) { Local<Array> change = Local<Array>::Cast(changes->Get(i)); Local<String> name = change->Get(INDEX_NAME)->ToString(); Local<Value> oldValue = change->Get(INDEX_OLD_VALUE); Local<Value> value = change->Get(INDEX_VALUE); jobjectArray jChange = env->NewObjectArray(3, JNIUtil::objectClass, NULL); jstring jName = TypeConverter::jsStringToJavaString(name); env->SetObjectArrayElement(jChange, INDEX_NAME, jName); env->DeleteLocalRef(jName); bool isNew; jobject jOldValue = TypeConverter::jsValueToJavaObject(oldValue, &isNew); env->SetObjectArrayElement(jChange, INDEX_OLD_VALUE, jOldValue); if (isNew) { env->DeleteLocalRef(jOldValue); } jobject jValue = TypeConverter::jsValueToJavaObject(value, &isNew); env->SetObjectArrayElement(jChange, INDEX_VALUE, jValue); if (isNew) { env->DeleteLocalRef(jValue); } env->SetObjectArrayElement(jChanges, i, jChange); env->DeleteLocalRef(jChange); } jobject javaProxy = proxy->getJavaObject(); env->CallVoidMethod(javaProxy, JNIUtil::krollProxyOnPropertiesChangedMethod, jChanges); env->DeleteLocalRef(jChanges); if (!JavaObject::useGlobalRefs) { env->DeleteLocalRef(javaProxy); } return Undefined(); }
/* * KW-AD as defined in SP 800-38F section 6.2 * KWP-AD as defined in SP 800-38F section 6.3 */ int mbedtls_nist_kw_unwrap( mbedtls_nist_kw_context *ctx, mbedtls_nist_kw_mode_t mode, const unsigned char *input, size_t in_len, unsigned char *output, size_t *out_len, size_t out_size ) { int ret = 0; size_t i, olen; unsigned char A[KW_SEMIBLOCK_LENGTH]; unsigned char diff, bad_padding = 0; *out_len = 0; if( out_size < in_len - KW_SEMIBLOCK_LENGTH ) { return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); } if( mode == MBEDTLS_KW_MODE_KW ) { /* * According to SP 800-38F Table 1, the ciphertext length for KW * must be between 3 to 2^54 semiblocks inclusive. */ if( in_len < 24 || #if SIZE_MAX > 0x200000000000000 in_len > 0x200000000000000 || #endif in_len % KW_SEMIBLOCK_LENGTH != 0 ) { return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); } ret = unwrap( ctx, input, in_len / KW_SEMIBLOCK_LENGTH, A, output, out_len ); if( ret != 0 ) goto cleanup; /* Check ICV in "constant-time" */ diff = mbedtls_nist_kw_safer_memcmp( NIST_KW_ICV1, A, KW_SEMIBLOCK_LENGTH ); if( diff != 0 ) { ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED; goto cleanup; } } else if( mode == MBEDTLS_KW_MODE_KWP ) { size_t padlen = 0; uint32_t Plen; /* * According to SP 800-38F Table 1, the ciphertext length for KWP * must be between 2 to 2^29 semiblocks inclusive. */ if( in_len < KW_SEMIBLOCK_LENGTH * 2 || #if SIZE_MAX > 0x100000000 in_len > 0x100000000 || #endif in_len % KW_SEMIBLOCK_LENGTH != 0 ) { return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA ); } if( in_len == KW_SEMIBLOCK_LENGTH * 2 ) { unsigned char outbuff[KW_SEMIBLOCK_LENGTH * 2]; ret = mbedtls_cipher_update( &ctx->cipher_ctx, input, 16, outbuff, &olen ); if( ret != 0 ) goto cleanup; memcpy( A, outbuff, KW_SEMIBLOCK_LENGTH ); memcpy( output, outbuff + KW_SEMIBLOCK_LENGTH, KW_SEMIBLOCK_LENGTH ); mbedtls_platform_zeroize( outbuff, sizeof( outbuff ) ); *out_len = KW_SEMIBLOCK_LENGTH; } else { /* in_len >= KW_SEMIBLOCK_LENGTH * 3 */ ret = unwrap( ctx, input, in_len / KW_SEMIBLOCK_LENGTH, A, output, out_len ); if( ret != 0 ) goto cleanup; } /* Check ICV in "constant-time" */ diff = mbedtls_nist_kw_safer_memcmp( NIST_KW_ICV2, A, KW_SEMIBLOCK_LENGTH / 2 ); if( diff != 0 ) { ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED; } GET_UINT32_BE( Plen, A, KW_SEMIBLOCK_LENGTH / 2 ); /* * Plen is the length of the plaintext, when the input is valid. * If Plen is larger than the plaintext and padding, padlen will be * larger than 8, because of the type wrap around. */ padlen = in_len - KW_SEMIBLOCK_LENGTH - Plen; if ( padlen > 7 ) { padlen &= 7; ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED; } /* Check padding in "constant-time" */ for( diff = 0, i = 0; i < KW_SEMIBLOCK_LENGTH; i++ ) { if( i >= KW_SEMIBLOCK_LENGTH - padlen ) diff |= output[*out_len - KW_SEMIBLOCK_LENGTH + i]; else bad_padding |= output[*out_len - KW_SEMIBLOCK_LENGTH + i]; } if( diff != 0 ) { ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED; } if( ret != 0 ) { goto cleanup; } memset( output + Plen, 0, padlen ); *out_len = Plen; } else { ret = MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE; goto cleanup; } cleanup: if( ret != 0 ) { memset( output, 0, *out_len ); *out_len = 0; } mbedtls_platform_zeroize( &bad_padding, sizeof( bad_padding) ); mbedtls_platform_zeroize( &diff, sizeof( diff ) ); mbedtls_platform_zeroize( A, sizeof( A ) ); return( ret ); }
: imp_(seq) { seq->api_internal = this; } DbSequence::~DbSequence() { DB_SEQUENCE *seq; seq = unwrap(this); if (seq != NULL) (void)seq->close(seq, 0); } DBSEQ_METHOD(open, (DbTxn *txnid, Dbt *key, u_int32_t flags), (seq, unwrap(txnid), key, flags), 0) DBSEQ_METHOD(initial_value, (db_seq_t value), (seq, value), 0) DBSEQ_METHOD(close, (u_int32_t flags), (seq, flags), 1) DBSEQ_METHOD(remove, (DbTxn *txnid, u_int32_t flags), (seq, unwrap(txnid), flags), 1) DBSEQ_METHOD(stat, (DB_SEQUENCE_STAT **sp, u_int32_t flags), (seq, sp, flags), 0) DBSEQ_METHOD(stat_print, (u_int32_t flags), (seq, flags), 0) DBSEQ_METHOD(get, (DbTxn *txnid, u_int32_t delta, db_seq_t *retp, u_int32_t flags), (seq, unwrap(txnid), delta, retp, flags), 0) DBSEQ_METHOD(get_cachesize, (u_int32_t *sizep), (seq, sizep), 0) DBSEQ_METHOD(set_cachesize, (u_int32_t size), (seq, size), 0) DBSEQ_METHOD(get_flags, (u_int32_t *flagsp), (seq, flagsp), 0) DBSEQ_METHOD(set_flags, (u_int32_t flags), (seq, flags), 0)
TITANIUM_FUNCTION(GeneralTransform, TransformBounds) { auto context = get_context(); if (arguments.size() == 1) { auto _0 = arguments.at(0); TITANIUM_ASSERT_AND_THROW(_0.IsObject(), "Expected Object"); auto object_rect = static_cast<JSObject>(_0); ::Windows::Foundation::Rect rect; // Assign fields explicitly since we didn't use a constructor auto object_rect_X = object_rect.GetProperty("X"); TITANIUM_ASSERT_AND_THROW(object_rect_X.IsNumber(), "Expected Number"); auto object_rect_X_ = static_cast<float>(static_cast<double>(object_rect_X)); rect.X = object_rect_X_; auto object_rect_Y = object_rect.GetProperty("Y"); TITANIUM_ASSERT_AND_THROW(object_rect_Y.IsNumber(), "Expected Number"); auto object_rect_Y_ = static_cast<float>(static_cast<double>(object_rect_Y)); rect.Y = object_rect_Y_; auto object_rect_Width = object_rect.GetProperty("Width"); TITANIUM_ASSERT_AND_THROW(object_rect_Width.IsNumber(), "Expected Number"); auto object_rect_Width_ = static_cast<float>(static_cast<double>(object_rect_Width)); rect.Width = object_rect_Width_; auto object_rect_Height = object_rect.GetProperty("Height"); TITANIUM_ASSERT_AND_THROW(object_rect_Height.IsNumber(), "Expected Number"); auto object_rect_Height_ = static_cast<float>(static_cast<double>(object_rect_Height)); rect.Height = object_rect_Height_; auto method_result = unwrap()->TransformBounds(rect); auto result = context.CreateObject(); auto method_result_X_ = context.CreateNumber(static_cast<double>(method_result.X)); result.SetProperty("X", method_result_X_); auto method_result_Y_ = context.CreateNumber(static_cast<double>(method_result.Y)); result.SetProperty("Y", method_result_Y_); auto method_result_Width_ = context.CreateNumber(static_cast<double>(method_result.Width)); result.SetProperty("Width", method_result_Width_); auto method_result_Height_ = context.CreateNumber(static_cast<double>(method_result.Height)); result.SetProperty("Height", method_result_Height_); return result; } // Catch-all if no arg count matches! TITANIUM_LOG_DEBUG("No method signature matched GeneralTransform::TransformBounds with # of args: ", arguments.size()); return context.CreateUndefined(); }
TITANIUM_FUNCTION(GeneralTransform, TryTransform) { auto context = get_context(); if (arguments.size() == 2) { auto _0 = arguments.at(0); TITANIUM_ASSERT_AND_THROW(_0.IsObject(), "Expected Object"); auto object_inPoint = static_cast<JSObject>(_0); ::Windows::Foundation::Point inPoint; // Assign fields explicitly since we didn't use a constructor auto object_inPoint_X = object_inPoint.GetProperty("X"); TITANIUM_ASSERT_AND_THROW(object_inPoint_X.IsNumber(), "Expected Number"); auto object_inPoint_X_ = static_cast<float>(static_cast<double>(object_inPoint_X)); inPoint.X = object_inPoint_X_; auto object_inPoint_Y = object_inPoint.GetProperty("Y"); TITANIUM_ASSERT_AND_THROW(object_inPoint_Y.IsNumber(), "Expected Number"); auto object_inPoint_Y_ = static_cast<float>(static_cast<double>(object_inPoint_Y)); inPoint.Y = object_inPoint_Y_; auto _1 = arguments.at(1); TITANIUM_ASSERT_AND_THROW(_1.IsObject(), "Expected Object"); auto object_outPoint = static_cast<JSObject>(_1); ::Windows::Foundation::Point outPoint; // Assign fields explicitly since we didn't use a constructor auto object_outPoint_X = object_outPoint.GetProperty("X"); TITANIUM_ASSERT_AND_THROW(object_outPoint_X.IsNumber(), "Expected Number"); auto object_outPoint_X_ = static_cast<float>(static_cast<double>(object_outPoint_X)); outPoint.X = object_outPoint_X_; auto object_outPoint_Y = object_outPoint.GetProperty("Y"); TITANIUM_ASSERT_AND_THROW(object_outPoint_Y.IsNumber(), "Expected Number"); auto object_outPoint_Y_ = static_cast<float>(static_cast<double>(object_outPoint_Y)); outPoint.Y = object_outPoint_Y_; auto method_result = unwrap()->TryTransform(inPoint, &outPoint); auto result = context.CreateBoolean(method_result); auto out_1 = context.CreateObject(); auto outPoint_X_ = context.CreateNumber(static_cast<double>(outPoint.X)); out_1.SetProperty("X", outPoint_X_); auto outPoint_Y_ = context.CreateNumber(static_cast<double>(outPoint.Y)); out_1.SetProperty("Y", outPoint_Y_); _1 = out_1; return result; } // Catch-all if no arg count matches! TITANIUM_LOG_DEBUG("No method signature matched GeneralTransform::TryTransform with # of args: ", arguments.size()); return context.CreateUndefined(); }