type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
defines | #define MAXLEN 100 /* max length of any input line */ |
defines | #define ALLOC_SIZE 10000 |
functions | int readlines( char *lineptr[], int maxlines ) {
int len, nlines;
char line[ MAXLEN ], *p;
nlines = 0;
while ( (len = getline( line, MAXLEN )) > 0 ) {
//printf( "=========line is: '%s'\n", line );
if ( nlines >= maxlines || (p = alloc( len+1 )) == NULL ) {
return -1;
} |
functions | void writelines( char *lineptr[], int nlines ) {
int i;
for ( i = 0; i < nlines; i++ ) {
printf( "%s\n", lineptr[ i ] );
} |
functions | void swap( char *v[], int i, int j ) {
char *temp;
temp = v[ i ];
v[ i ] = v[ j ];
v[ j ] = temp;
} |
functions | int ncmp( char *a, char *b ) {
double v1, v2;
v1 = atof( a );
v2 = atof( b );
if ( v1 < v2 ) {
return -1;
} |
functions | else if ( v1 > v2 ) {
return 1;
} |
functions | void afree( char *p ) {
if ( p >= allocbuf && p < allocbuf + ALLOC_SIZE ) {
allocp = p;
} |
functions | int getline( char *line, int len ) {
char ch;
int i;
i = 0;
while ( i < len && (ch = getchar()) != EOF && ch != '\n' ) {
line[ i++ ] = ch;
} |
functions | int strcmp( char *a, char *b ) {
while ( *a == *b ) {
if ( *a == '\0' ) {
return 0;
} |
functions | int strcpy( char *a, char *b ) {
while ( *a++ = *b++ )
;
return 0;
} |
main | int main( int argc, char *argv[] ) {
int nlines;
int numeric = 0; /* 1 -- numeric; 0 -- string */
char ch;
while ( --argc > 0 && (*++argv)[0] == '-' ) {
while ( (ch = *(*argv)++) != '\0' ) {
switch ( ch ) {
case 'n':
numeric = 1;
break;
case 'r':
reverse = -1;
break;
default:
b... |
includes | #include <stdio.h> |
includes | #include <stdlib.h> |
includes | #include <string.h> |
includes | #include <math.h> |
functions | void dr_nlgs(RelayProblem* problem, double *z, double *w, int *info, SolverOptions* options)
{
double* vec = problem->M->matrix0;
double* q = problem->q;
int n = problem -> size;
double *a = problem->ub;
double *b = problem->lb;
//\todo Rewrite completely the algorithm with a projection.
int ib;
for(ib ... |
includes |
#include <zephyr.h> |
includes | #include <misc/reboot.h> |
includes | #include <board.h> |
includes | #include <device.h> |
includes | #include <string.h> |
includes | #include <nvs/nvs.h> |
defines |
#define NVS_SECTOR_SIZE FLASH_ERASE_BLOCK_SIZE /* Multiple of FLASH_PAGE_SIZE */ |
defines | #define NVS_SECTOR_COUNT 3 /* At least 2 sectors */ |
defines | #define NVS_STORAGE_OFFSET FLASH_AREA_STORAGE_OFFSET /* Start address of the |
defines | #define SLEEP_TIME 100 |
defines | #define MAX_REBOOT 400 |
defines |
#define ADDRESS_ID 1 |
defines | #define KEY_ID 2 |
defines | #define RBT_CNT_ID 3 |
defines | #define STRING_ID 4 |
defines | #define LONG_ID 5 |
functions | void main(void)
{
int rc = 0, cnt = 0, cnt_his = 0;
char buf[16];
u8_t key[8], longarray[128];
u32_t reboot_counter = 0, reboot_counter_his;
rc = nvs_init(&fs, FLASH_DEV_NAME);
if (rc) {
printk("Flash Init failed\n");
} |
includes |
#include <arm.h> |
includes | #include <assert.h> |
includes | #include <kernel/panic.h> |
includes | #include <kernel/tee_common.h> |
includes | #include <kernel/tee_misc.h> |
includes | #include <kernel/tz_ssvce.h> |
includes | #include <mm/tee_mmu.h> |
includes | #include <mm/tee_mmu_types.h> |
includes | #include <mm/tee_mmu_defs.h> |
includes | #include <mm/pgt_cache.h> |
includes | #include <mm/tee_mm.h> |
includes | #include <mm/core_memprot.h> |
includes | #include <mm/core_mmu.h> |
includes | #include <sm/optee_smc.h> |
includes | #include <stdlib.h> |
includes | #include <trace.h> |
includes | #include <types_ext.h> |
includes | #include <user_ta_header.h> |
includes | #include <util.h> |
includes | #include <kernel/tee_l2cc_mutex.h> |
defines |
#define TEE_MMU_UMAP_STACK_IDX 0 |
defines | #define TEE_MMU_UMAP_CODE_IDX 1 |
defines | #define TEE_MMU_UMAP_NUM_CODE_SEGMENTS 3 |
defines |
#define TEE_MMU_UMAP_PARAM_IDX (TEE_MMU_UMAP_CODE_IDX + \ |
defines | #define TEE_MMU_UMAP_MAX_ENTRIES (TEE_MMU_UMAP_PARAM_IDX + 4) |
defines |
#define TEE_MMU_UDATA_ATTR (TEE_MATTR_VALID_BLOCK | \ |
defines | #define TEE_MMU_UCODE_ATTR (TEE_MATTR_VALID_BLOCK | \ |
defines |
#define TEE_MMU_UCACHE_DEFAULT_ATTR (TEE_MATTR_CACHE_CACHED << \ |
functions | void tee_mmu_umap_set_pa(struct tee_mmap_region *tbl,
size_t granule, paddr_t pa, size_t size, uint32_t attr)
{
paddr_t upa = ROUNDDOWN(pa, granule);
size_t usz = ROUNDUP(pa - upa + size, granule);
tbl->pa = upa;
tbl->size = usz;
tbl->attr = attr;
} |
functions | TEE_Result tee_mmu_umap_add_param(struct tee_mmu_info *mmu, paddr_t pa,
size_t size, uint32_t attr)
{
struct tee_mmap_region *last_entry = NULL;
size_t n;
paddr_t npa;
size_t nsz;
/* Check that we can map memory using this attribute */
if (!core_mmu_mattr_is_ok(attr))
return TEE_ERROR_BAD_PARAMETERS;
/* F... |
functions | TEE_Result tee_mmu_umap_set_vas(struct tee_mmu_info *mmu)
{
const size_t granule = CORE_MMU_USER_PARAM_SIZE;
vaddr_t va_range_base;
vaddr_t va;
size_t va_range_size;
size_t n;
/* Find last table entry used to map code and data */
n = TEE_MMU_UMAP_PARAM_IDX - 1;
while (n && !mmu->table[n].size)
n--;
va = mmu... |
functions | TEE_Result tee_mmu_init(struct user_ta_ctx *utc)
{
uint32_t asid = 1;
if (!utc->context) {
utc->context = 1;
/* Find available ASID */
while (!(asid & g_asid) && (asid != 0)) {
utc->context++;
asid = asid << 1;
} |
functions | TEE_Result check_pgt_avail(vaddr_t base, vaddr_t end)
{
vaddr_t b = ROUNDDOWN(base, CORE_MMU_PGDIR_SIZE);
vaddr_t e = ROUNDUP(end, CORE_MMU_PGDIR_SIZE);
size_t ntbl = (e - b) >> CORE_MMU_PGDIR_SHIFT;
if (!pgt_check_avail(ntbl)) {
EMSG("%zu page tables not available", ntbl);
return TEE_ERROR_OUT_OF_MEMORY;
} |
functions | TEE_Result check_pgt_avail(vaddr_t base __unused, vaddr_t end __unused)
{
return TEE_SUCCESS;
} |
functions | void tee_mmu_map_stack(struct user_ta_ctx *utc, paddr_t pa, size_t size,
uint32_t prot)
{
const uint32_t attr = TEE_MATTR_VALID_BLOCK | TEE_MATTR_SECURE |
(TEE_MATTR_CACHE_CACHED << TEE_MATTR_CACHE_SHIFT);
const size_t granule = CORE_MMU_USER_CODE_SIZE;
struct tee_mmap_region *tbl = utc->mmu->table;
tb... |
functions | TEE_Result tee_mmu_map_add_segment(struct user_ta_ctx *utc, paddr_t base_pa,
size_t offs, size_t size, uint32_t prot)
{
const uint32_t attr = TEE_MATTR_VALID_BLOCK | TEE_MATTR_SECURE |
(TEE_MATTR_CACHE_CACHED << TEE_MATTR_CACHE_SHIFT);
const size_t granule = CORE_MMU_USER_CODE_SIZE;
struct tee_mmap_regio... |
functions | void tee_mmu_map_clear(struct user_ta_ctx *utc)
{
utc->mmu->ta_private_vmem_end = 0;
memset(utc->mmu->table, 0,
TEE_MMU_UMAP_MAX_ENTRIES * sizeof(struct tee_mmap_region));
} |
functions | TEE_Result tee_mmu_map_param(struct user_ta_ctx *utc,
struct tee_ta_param *param)
{
TEE_Result res = TEE_SUCCESS;
size_t n;
/* Clear all the param entries as they can hold old information */
memset(utc->mmu->table + TEE_MMU_UMAP_PARAM_IDX, 0,
(TEE_MMU_UMAP_MAX_ENTRIES - TEE_MMU_UMAP_PARAM_IDX) *
sizeof(struc... |
functions | void tee_mmu_final(struct user_ta_ctx *utc)
{
uint32_t asid = 1 << ((utc->context - 1) & 0xff);
/* return ASID */
g_asid |= asid;
/* clear MMU entries to avoid clash when asid is reused */
secure_mmu_unifiedtlbinv_byasid(utc->context & 0xff);
utc->context = 0;
if (utc->mmu) {
free(utc->mmu->table);
free(u... |
functions | bool tee_mmu_is_vbuf_inside_ta_private(const struct user_ta_ctx *utc,
const void *va, size_t size)
{
return core_is_buffer_inside(va, size,
utc->mmu->ta_private_vmem_start,
utc->mmu->ta_private_vmem_end - utc->mmu->ta_private_vmem_start + 1);
} |
functions | bool tee_mmu_is_vbuf_intersect_ta_private(const struct user_ta_ctx *utc,
const void *va, size_t size)
{
return core_is_buffer_intersect(va, size,
utc->mmu->ta_private_vmem_start,
utc->mmu->ta_private_vmem_end - utc->mmu->ta_private_vmem_start + 1);
} |
functions | TEE_Result tee_mmu_user_va2pa_attr(const struct user_ta_ctx *utc,
void *ua, paddr_t *pa, uint32_t *attr)
{
size_t n;
if (!utc->mmu->table)
return TEE_ERROR_ACCESS_DENIED;
for (n = 0; n < utc->mmu->size; n++) {
if (core_is_buffer_inside(ua, 1, utc->mmu->table[n].va,
utc->mmu->table[n].size)) {
*pa ... |
functions | TEE_Result tee_mmu_user_va2pa_helper(const struct user_ta_ctx *utc, void *ua,
paddr_t *pa)
{
return tee_mmu_user_va2pa_attr(utc, ua, pa, NULL);
} |
functions | TEE_Result tee_mmu_user_pa2va_helper(const struct user_ta_ctx *utc,
paddr_t pa, void **va)
{
size_t n;
if (!utc->mmu->table)
return TEE_ERROR_ACCESS_DENIED;
for (n = 0; n < utc->mmu->size; n++) {
if (core_is_buffer_inside(pa, 1, utc->mmu->table[n].pa,
utc->mmu->table[n].size)) {
*va = (void... |
functions | TEE_Result tee_mmu_check_access_rights(const struct user_ta_ctx *utc,
uint32_t flags, tee_uaddr_t uaddr,
size_t len)
{
tee_uaddr_t a;
size_t addr_incr = MIN(CORE_MMU_USER_CODE_SIZE,
CORE_MMU_USER_PARAM_SIZE);
/* Address wrap */
if ((uaddr + len) < uaddr)
return TEE_ERROR_ACCESS_DE... |
functions | void tee_mmu_set_ctx(struct tee_ta_ctx *ctx)
{
if (!ctx || !is_user_ta_ctx(ctx)) {
core_mmu_set_user_map(NULL);
#ifdef CFG_SMALL_PAGE_USER_TA
/*
* We're not needing the user page tables for the moment,
* release them as some other thread may be waiting for
* them.
*/
pgt_free(&thread_get_tsd()->pgt_c... |
functions | uintptr_t tee_mmu_get_load_addr(const struct tee_ta_ctx *const ctx)
{
const struct user_ta_ctx *utc = to_user_ta_ctx((void *)ctx);
assert(utc->mmu && utc->mmu->table);
if (utc->mmu->size != TEE_MMU_UMAP_MAX_ENTRIES)
panic("invalid size");
return utc->mmu->table[1].va;
} |
functions | void teecore_init_ta_ram(void)
{
vaddr_t s;
vaddr_t e;
paddr_t ps;
paddr_t pe;
/* get virtual addr/size of RAM where TA are loaded/executedNSec
* shared mem allcated from teecore */
core_mmu_get_mem_by_type(MEM_AREA_TA_RAM, &s, &e);
ps = virt_to_phys((void *)s);
pe = virt_to_phys((void *)(e - 1)) + 1;
if (... |
functions | void teecore_init_pub_ram(void)
{
vaddr_t s;
vaddr_t e;
/* get virtual addr/size of NSec shared mem allcated from teecore */
core_mmu_get_mem_by_type(MEM_AREA_NSEC_SHM, &s, &e);
if (s >= e || s & SMALL_PAGE_MASK || e & SMALL_PAGE_MASK)
panic("invalid PUB RAM");
/* extra check: we could rely on core_mmu_get_... |
functions | uint32_t tee_mmu_user_get_cache_attr(struct user_ta_ctx *utc, void *va)
{
paddr_t pa;
uint32_t attr;
if (tee_mmu_user_va2pa_attr(utc, va, &pa, &attr) != TEE_SUCCESS)
panic("cannot get attr");
return (attr >> TEE_MATTR_CACHE_SHIFT) & TEE_MATTR_CACHE_MASK;
} |
includes |
#include <ngx_config.h> |
includes | #include <ngx_core.h> |
includes | #include <ngx_event.h> |
defines |
#define NGX_SSL_PASSWORD_BUFFER_SIZE 4096 |
defines | #define ngx_ssl_session_ticket_md EVP_sha1 |
defines | #define ngx_ssl_session_ticket_md EVP_sha256 |
functions | ngx_int_t
ngx_ssl_init(ngx_log_t *log)
{
OPENSSL_config(NULL);
SSL_library_init();
SSL_load_error_strings();
OpenSSL_add_all_algorithms();
#if OPENSSL_VERSION_NUMBER >= 0x0090800fL
#ifndef SSL_OP_NO_COMPRESSION
{
/*
* Disable gzip compression in OpenSSL prior to 1.0.0 version,
* thi... |
functions | ngx_int_t
ngx_ssl_create(ngx_ssl_t *ssl, ngx_uint_t protocols, void *data)
{
ssl->ctx = SSL_CTX_new(SSLv23_method());
if (ssl->ctx == NULL) {
ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0, "SSL_CTX_new() failed");
return NGX_ERROR;
} |
functions | ngx_int_t
ngx_ssl_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
ngx_str_t *key, ngx_array_t *passwords)
{
BIO *bio;
X509 *x509;
u_long n;
ngx_str_t *pwd;
ngx_uint_t tries;
if (ngx_conf_full_name(cf->cycle, cert, 1) != NGX_OK) {
return NGX_ERRO... |
functions | int
ngx_ssl_password_callback(char *buf, int size, int rwflag, void *userdata)
{
ngx_str_t *pwd = userdata;
if (rwflag) {
ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
"ngx_ssl_password_callback() is called for encryption");
return 0;
} |
functions | ngx_int_t
ngx_ssl_client_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
ngx_int_t depth)
{
STACK_OF(X509_NAME) *list;
SSL_CTX_set_verify(ssl->ctx, SSL_VERIFY_PEER, ngx_ssl_verify_callback);
SSL_CTX_set_verify_depth(ssl->ctx, depth);
if (cert->len == 0) {
return NGX_OK;
... |
functions | ngx_int_t
ngx_ssl_trusted_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
ngx_int_t depth)
{
SSL_CTX_set_verify_depth(ssl->ctx, depth);
if (cert->len == 0) {
return NGX_OK;
} |
functions | ngx_int_t
ngx_ssl_crl(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *crl)
{
X509_STORE *store;
X509_LOOKUP *lookup;
if (crl->len == 0) {
return NGX_OK;
} |
functions | int
ngx_ssl_verify_callback(int ok, X509_STORE_CTX *x509_store)
{
#if (NGX_DEBUG)
char *subject, *issuer;
int err, depth;
X509 *cert;
X509_NAME *sname, *iname;
ngx_connection_t *c;
ngx_ssl_conn_t *ssl_conn;
ssl_conn = X509_STORE_CTX_get_e... |
functions | void
ngx_ssl_info_callback(const ngx_ssl_conn_t *ssl_conn, int where, int ret)
{
BIO *rbio, *wbio;
ngx_connection_t *c;
if (where & SSL_CB_HANDSHAKE_START) {
c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn);
if (c->ssl->handshaked) {
c->ssl->renegotiation ... |
functions | void
ngx_ssl_passwords_cleanup(void *data)
{
ngx_array_t *passwords = data;
ngx_str_t *pwd;
ngx_uint_t i;
pwd = passwords->elts;
for (i = 0; i < passwords->nelts; i++) {
ngx_memzero(pwd[i].data, pwd[i].len);
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.