void tr_rc4_set_key(tr_rc4_ctx_t handle, uint8_t const* key, size_t key_length) { TR_ASSERT(handle != NULL); TR_ASSERT(key != NULL); API(Arc4SetKey)(handle, key, key_length); }
void t0 (ComplexI sz) { char * name = "../IM_CAD/MOUSSAN_AA/Moussan_AA.tif"; EL_API_VECTO::ParamSkel PSkel; EL_API_VECTO::ParamApprox PApp; EL_API_VECTO API(PSkel,PApp,20); EL_API_VECTO::ParamFile PFile(name,false); int x,y; scanf("%d %d",&x,&y); MyVectoAct MVA; API.vecto ( PFile, MVA, ComplexI(x,y), sz ); }
int32_t nvram_set(char * section, char * key, char * value) { API(); if (OK == _nvram_buf_set(section, key, value)) return nvram_commit(0); return NG; }
int32_t nvram_show(char * section) { int32_t i = 0, j = 0, counter = 0; API(); for (i=0; i<sectionnum; i++) { if (nvramcache[i].flag & NV_IV) // skip invisible section continue; if (section && 0 != strcmp(section, nvramcache[i].name)) continue; printf("\n\n++++++++++++ %s ++++++++++++ 0x%x\n", nvramcache[i].name, nvramcache[i].flag); counter = 0; for (j=0; j<MAX_ENTRY; j++) { if (nvramcache[i].cache[j].name) { counter++; printf("%s=%s\n",nvramcache[i].cache[j].name, nvramcache[i].cache[j].value); } } printf("++++++++++++ %s ++++++++++++ %d\n", nvramcache[i].name, counter); } return OK; }
int32_t nvram_filecache(char * defile) { int32_t rc = OK; FILE * fp = NULL; struct stat statbuf; char * buffer = NULL; API(); /* create a cache file */ rc = stat(defile, &statbuf); if (!rc) { DEBUG("cache file %s is ready.\n", defile); return OK; } fp = fopen(defile, "w+b"); if (!fp) { DEBUG("failed to create %s, %s, %s\n", defile, strerror(errno), __FUNCTION__); return NG; } DEBUG("cache file %s, created.\n", defile); buffer = (char *)malloc(nvram_mtd_size); if(!buffer) { DEBUG("failed to alloc %d bytes for , %s, %s\n", nvram_mtd_size, defile, __FUNCTION__); fclose(fp); return NG; } /* dump "Config" partition into a cache file. */ memset(buffer, 0, nvram_mtd_size); DEBUG("read original data from flash.\n"); if (flash_read(buffer,0,nvram_mtd_size) < 0) { fclose(fp); return NG; } //dump(buffer, nvram_mtd_size, 0); DEBUG("write into cache file.\n"); rc = fwrite(buffer, 1, nvram_mtd_size, fp); if (rc != nvram_mtd_size) { DEBUG("failed to write data into %s, %s, %s\n", defile, strerror(errno), __FUNCTION__); return NG; } fclose(fp); return OK; }
int32_t nvram_del(char * section, char * key) { API(); if (OK == _nvram_buf_del(section, key)) return nvram_commit(0); return NG; }
int32_t nvram_reset(char * section, char * defile) { API(); if (OK == nvram_parse(section, defile)) return nvram_commit(1); return NG; }
Filtro::Filtro(cv::Mat pImagen, int pN, int pM) { aN = pN; //filas aM = pM; //columnas cv::Mat Matrix1(pN,pM,CV_8UC1); cv::Mat Matrix2(pN,pM,CV_8UC1); cvtColor(pImagen,Matrix1,CV_RGB2GRAY); aMatrix1 = Matrix1; aMatrix2 = Matrix2; aAPI = API(); }
tr_dh_ctx_t tr_dh_new(uint8_t const* prime_num, size_t prime_num_length, uint8_t const* generator_num, size_t generator_num_length) { struct tr_dh_ctx* handle = tr_new0(struct tr_dh_ctx, 1); TR_ASSERT(prime_num != NULL); TR_ASSERT(generator_num != NULL); API(InitDhKey)(&handle->dh); if (!check_result(API(DhSetKey)(&handle->dh, prime_num, prime_num_length, generator_num, generator_num_length))) { tr_free(handle); return NULL; } handle->key_length = prime_num_length; return handle; }
int usb_open(struct usb *usb) { int (*rom_get_per_driver)(struct per_driver **io, u32 device_type); int (*rom_get_per_device)(struct per_handle **rh); struct per_handle *boot; int n; u32 base; memset(usb, 0, sizeof(*usb)); if (get_omap_rev() >= OMAP_4460_ES1_DOT_0) base = PUBLIC_API_BASE_4460; else base = PUBLIC_API_BASE_4430; rom_get_per_driver = API(base + PUBLIC_GET_DRIVER_PER_OFFSET); rom_get_per_device = API(base + PUBLIC_GET_DEVICE_PER_OFFSET); n = rom_get_per_device(&boot); if (n) return n; if ((boot->device_type != DEVICE_USB) && (boot->device_type != DEVICE_USBEXT)) return -1; n = rom_get_per_driver(&usb->io, boot->device_type); if (n) return n; usb->dread.xfer_mode = boot->xfer_mode; usb->dread.options = boot->options; usb->dread.device_type = boot->device_type; usb->dwrite.xfer_mode = boot->xfer_mode; usb->dwrite.options = boot->options; usb->dwrite.device_type = boot->device_type; return 0; }
tr_sha1_ctx_t tr_sha1_init(void) { Sha* handle = tr_new(Sha, 1); if (check_result(API(InitSha)(handle))) { return handle; } tr_free(handle); return NULL; }
bool tr_rand_buffer(void* buffer, size_t length) { bool ret; tr_lock* rng_lock = get_rng_lock(); TR_ASSERT(buffer != NULL); tr_lockLock(rng_lock); ret = check_result(API(RNG_GenerateBlock)(get_rng(), buffer, length)); tr_lockUnlock(rng_lock); return ret; }
void tr_dh_free(tr_dh_ctx_t raw_handle) { struct tr_dh_ctx* handle = raw_handle; if (handle == NULL) { return; } API(FreeDhKey)(&handle->dh); tr_free(handle->private_key); tr_free(handle); }
bool tr_sha1_update(tr_sha1_ctx_t handle, void const* data, size_t data_length) { TR_ASSERT(handle != NULL); if (data_length == 0) { return true; } TR_ASSERT(data != NULL); return check_result(API(ShaUpdate)(handle, data, data_length)); }
void tr_rc4_process(tr_rc4_ctx_t handle, void const* input, void* output, size_t length) { TR_ASSERT(handle != NULL); if (length == 0) { return; } TR_ASSERT(input != NULL); TR_ASSERT(output != NULL); API(Arc4Process)(handle, output, input, length); }
bool tr_sha1_final(tr_sha1_ctx_t handle, uint8_t* hash) { bool ret = true; if (hash != NULL) { TR_ASSERT(handle != NULL); ret = check_result(API(ShaFinal)(handle, hash)); } tr_free(handle); return ret; }
int32_t nvram_clear(char * section) { int32_t i = 0; FILE * fp = NULL; section_t * sec = NULL; char * buffer = NULL; API(); fp = fopen(NVRAM_CACHE_FILE, "r+b"); if (!fp) { DEBUG("failed to create %s, %s, %s\n", NVRAM_CACHE_FILE, strerror(errno), __FUNCTION__); return NG; } sec = _nvram_section(section); if(!sec || (sec->flag & NV_RO)) { DEBUG("invalid section!\n"); return NG; } fseek(fp, sec->offset, SEEK_SET); buffer = (char *)malloc(sec->size); if(!buffer) { DEBUG("failed to alloc buffer (%d) for nvram! %s.\n", sec->size, __FUNCTION__); fclose(fp); return NG; } memset(buffer, 0, sec->size); if(strcmp(sec->name,"uboot") == 0) sec->crc = crc32(0, (uint8_t *)(buffer+4), sec->size-4); else sec->crc = crc32(0, (uint8_t *)(buffer+5), sec->size-5); *(uint32_t *)(buffer) = sec->crc; i = fwrite(buffer, sec->size, 1, fp); ASSERT(i == 1); fclose(fp); return OK; }
static void log_cyassl_error(int error_code, char const* file, int line) { if (tr_logLevelIsActive(TR_LOG_ERROR)) { #if API_VERSION_HEX >= 0x03004000 char const* error_message = API(GetErrorString)(error_code); #elif API_VERSION_HEX >= 0x03000002 char const* error_message = CTaoCryptGetErrorString(error_code); #else char error_message[CYASSL_MAX_ERROR_SZ]; CTaoCryptErrorString(error_code, error_message); #endif tr_logAddMessage(file, line, TR_LOG_ERROR, MY_NAME, "CyaSSL error: %s", error_message); } }
int32_t nvram_show(char * section) { int32_t i = 0, j = 0; API(); for (i=0; i<sectionnum; i++) { if (section && 0 != strcmp(section, nvramcache[i].name)) continue; for (j=0; j<MAX_ENTRY; j++) { if (nvramcache[i].cache[j].name) printf("%s=%s\n",nvramcache[i].cache[j].name, nvramcache[i].cache[j].value); } } return OK; }
static RNG* get_rng(void) { static RNG rng; static bool rng_initialized = false; if (!rng_initialized) { if (!check_result(API(InitRng)(&rng))) { return NULL; } rng_initialized = true; } return &rng; }
int load_image(unsigned device, unsigned start, unsigned count, void *data) { int (*rom_get_mem_driver)(struct mem_driver **io, u32 type); struct mem_driver *io = 0; struct mem_device local_md_device, *md = 0; struct read_desc rd; u16 options; u32 base; int z; if (get_omap_rev() >= OMAP_4460_ES1_DOT_0) base = PUBLIC_API_BASE_4460; else base = PUBLIC_API_BASE_4430; rom_get_mem_driver = API(base + PUBLIC_GET_DRIVER_MEM_OFFSET); z = rom_get_mem_driver(&io, device); if (z) return -1; md = &local_md_device; memset(md, 0, sizeof(struct mem_device)); options = 0; // 1 = init phoenix pmic? md->initialized = 0; md->device_type = device; md->xip_device = 0; md->search_size = 0; md->base_address = 0; md->hs_toc_mask = 0; md->gp_toc_mask = 0; md->boot_options = &options; md->device_data = (void*) 0x80000000; memset(md->device_data, 0, 2500); z = io->init(md); if (z) return -1; rd.sector_start = start; rd.sector_count = count; rd.destination = data; z = io->read(md, &rd); return 0; }
void HelpDialog::checkUpdates() { if (networkManager->networkAccessible()==QNetworkAccessManager::Accessible) { if (updateState==HelpDialog::Updating) { qWarning() << "Already checking updates..."; return; } QUrl API("https://api.github.com/repos/Stellarium/stellarium/releases/latest"); connect(networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(downloadComplete(QNetworkReply*))); QNetworkRequest request; request.setUrl(API); request.setRawHeader("User-Agent", StelUtils::getUserAgentString().toUtf8()); #if QT_VERSION >= 0x050600 request.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true); #endif downloadReply = networkManager->get(request); updateState = HelpDialog::Updating; } }
bool tr_dh_make_key(tr_dh_ctx_t raw_handle, size_t private_key_length UNUSED, uint8_t* public_key, size_t* public_key_length) { struct tr_dh_ctx* handle = raw_handle; word32 my_private_key_length; word32 my_public_key_length; tr_lock* rng_lock = get_rng_lock(); TR_ASSERT(handle != NULL); TR_ASSERT(public_key != NULL); if (handle->private_key == NULL) { handle->private_key = tr_malloc(handle->key_length); } tr_lockLock(rng_lock); if (!check_result(API(DhGenerateKeyPair)(&handle->dh, get_rng(), handle->private_key, &my_private_key_length, public_key, &my_public_key_length))) { tr_lockUnlock(rng_lock); return false; } tr_lockUnlock(rng_lock); tr_dh_align_key(public_key, my_public_key_length, handle->key_length); handle->private_key_length = my_private_key_length; if (public_key_length != NULL) { *public_key_length = handle->key_length; } return true; }
tr_dh_secret_t tr_dh_agree(tr_dh_ctx_t raw_handle, uint8_t const* other_public_key, size_t other_public_key_length) { struct tr_dh_ctx* handle = raw_handle; struct tr_dh_secret* ret; word32 my_secret_key_length; TR_ASSERT(handle != NULL); TR_ASSERT(other_public_key != NULL); ret = tr_dh_secret_new(handle->key_length); if (check_result(API(DhAgree)(&handle->dh, ret->key, &my_secret_key_length, handle->private_key, handle->private_key_length, other_public_key, other_public_key_length))) { tr_dh_secret_align(ret, my_secret_key_length); } else { tr_dh_secret_free(ret); ret = NULL; } return ret; }
static void on_junk (GObject *gobject, GParamSpec *pspec, gpointer user_data) { (void)user_data; g_print("junk happened!: %s: %s\n", pspec->name, api_get_junk(API(gobject))); }
Filtro::Filtro() { aAPI = API(); }
fail("unknown symbol %S", part); value += sym->value; } } return value; } #define API(n) { L#n, do_##n } struct api { const wchar_t *name; int (*fn)(int argc, wchar_t **argv); }; struct api apitab[] = { API(CreateFile), API(DeleteFile), API(CreateDirectory), API(RemoveDirectory), API(GetFileInformation), API(SetFileAttributes), API(SetFileTime), API(SetEndOfFile), API(FindFiles), API(FindStreams), API(MoveFileEx), API(RenameStream), }; static int apicmp(const void *p1, const void *p2) { const struct api *api1 = (const struct api *)p1;
char * nvram_get(char * section, char * key) { API(); return _nvram_buf_get(section, key); }
int32_t nvram_commit(char flash) { int32_t rc = OK; int32_t sect = 0, i = 0; FILE * fp = NULL; char * buffer, * p, * q; API(); fp = fopen(NVRAM_CACHE_FILE, "r+"); if(!fp) { DEBUG("failed to open %s, %s.\n", NVRAM_CACHE_FILE, __FUNCTION__); rc = NG; goto __quit; } buffer = (char *)malloc(nvram_mtd_size); if(!buffer) { DEBUG("failed to alloc buffer (%d) for nvram! %s.\n", nvram_mtd_size, __FUNCTION__); rc = NG; goto __quit; } for (sect=0; sect<sectionnum; sect++) { p = buffer + nvramcache[sect].offset + 4; /* reserve 4 bytes for crc32 */ if(strcmp(nvramcache[sect].name,"uboot") != 0) { *p = '\0'; p++; } q = p + nvramcache[sect].size; for (i=0; i<MAX_ENTRY; i++) { if (nvramcache[sect].cache[i].name) { int32_t l; ASSERT(nvramcache[sect].cache[i].value); l = strlen(nvramcache[sect].cache[i].name) + strlen(nvramcache[sect].cache[i].value) + 2; if (p+l>=q) { DEBUG("exceed nvram section size %u!\n", nvramcache[sect].size); rc = NG; goto __quit; } sprintf(p, "%s=%s", nvramcache[sect].cache[i].name, nvramcache[sect].cache[i].value); p += l; } } *p = '\0'; // just make sure if(strcmp(nvramcache[sect].name,"uboot") == 0) nvramcache[sect].crc = crc32(0, (uint8_t *)(buffer + nvramcache[sect].offset+4), nvramcache[sect].size-4); else nvramcache[sect].crc = crc32(0, (uint8_t *)(buffer + nvramcache[sect].offset+5), nvramcache[sect].size-5); *(uint32_t *)(buffer + nvramcache[sect].offset) = nvramcache[sect].crc; DEBUG("cal crc32 = 0x%8x!\n", nvramcache[sect].crc); p = buffer + nvramcache[sect].offset; fseek(fp, nvramcache[sect].offset, SEEK_SET); DEBUG("write nvram raw data, offset %u, size %u!\n", nvramcache[sect].offset, nvramcache[sect].size); i = fwrite(buffer + nvramcache[sect].offset, 1, nvramcache[sect].size, fp); ASSERT(i == nvramcache[sect].size); } if (flash) { i = flash_write(buffer, 0, nvram_mtd_size); ASSERT(i>0); } __quit: sfree(buffer); fclose(fp); return rc; }
int32_t nvram_parse(char * section, char * cachefile) { int32_t rc = 0; FILE * fp = NULL; size_t len = 0; char * data, * p, * q; int32_t i = 0, j = 0; API(); fp = fopen(cachefile, "r+b"); if (!fp) { DEBUG("failed to load %s, %s, %s\n", cachefile, strerror(errno), __FUNCTION__); return NG; } fseek(fp, 0, SEEK_END); len = ftell(fp); fseek(fp, 0, SEEK_SET); data = (char *)malloc(len); if(!data) { DEBUG("failed to alloc buffer (%zu) for nvram! %s.\n", len, __FUNCTION__); fclose(fp); return NG; } memset(data, 0, len); rc = fread(data, 1, len, fp); DEBUG("rc %d, len %zu\n", rc, len); ASSERT(rc == len); nvramcache = (section_t *)malloc(sizeof(section_t)*sectionnum); memset(nvramcache, 0, sizeof(sizeof(section_t)*sectionnum)); for (i = 0; i<sectionnum; i++) { uint32_t secrc = 0; nvramcache[i].name = nvlayout[i].name; nvramcache[i].flag = nvlayout[i].flag; nvramcache[i].size = nvlayout[i].size; nvramcache[i].offset = nvlayout[i].offset; j = 0; p = data+nvramcache[i].offset; secrc = *(uint32_t *)p; if(strcmp(nvramcache[i].name,"uboot") == 0) nvramcache[i].crc = crc32(0, (uint8_t *)(data + nvramcache[i].offset+4), nvramcache[i].size-4); else nvramcache[i].crc = crc32(0, (uint8_t *)(data + nvramcache[i].offset+5), nvramcache[i].size-5); // DEBUG("file crc: %x, cal crc: %x\n", secrc, nvramcache[i].crc); if (secrc == 0 || secrc != nvramcache[i].crc) { DEBUG("data error in section %s.\n", nvramcache[i].name); continue; } if(strcmp(nvramcache[i].name,"uboot") == 0) p = p + 4; else p = p + 4 + 1; /* parsing the content, k=v\0k1=v1\0......kx=vx */ while (p < data+nvramcache[i].offset+nvramcache[i].size+1 && j < MAX_ENTRY) { if (*p == 0) break; q = strchr(p, '='); if (!q) { DEBUG("nvram format error!\n"); break; } *q = 0; q++; // DEBUG("\t<%s>=<%s>\n", p, q); nvramcache[i].cache[j].name = strdup(p); nvramcache[i].cache[j].value = strdup(q); p = q + strlen(q) + 1; j++; } } fclose(fp); return OK; }