自学教程：C++ ss_malloc函数代码示例

static voidss_rq_test8(void){	ssa a;	ss_aopen(&a, &ss_stda);	ssrq q;	t( ss_rqinit(&q, &a, 10, 100) == 0 );	ssrqnode *an = ss_malloc(&a, sizeof(ssrqnode));	ssrqnode *bn = ss_malloc(&a, sizeof(ssrqnode));	ssrqnode *cn = ss_malloc(&a, sizeof(ssrqnode));	ssrqnode *dn = ss_malloc(&a, sizeof(ssrqnode));	t( an != NULL );	t( bn != NULL );	t( cn != NULL );	t( dn != NULL );	ss_rqinitnode(an);	ss_rqinitnode(bn);	ss_rqinitnode(cn);	ss_rqinitnode(dn);	ss_rqadd(&q, an, 0);	ss_rqadd(&q, bn, 10);	ss_rqadd(&q, cn, 20);	ss_rqadd(&q, dn, 30);	int i = 30;	ssrqnode *n = NULL;	while ((n = ss_rqprev(&q, n)))		i -= 10;	ss_rqfree(&q, &a);	ss_free(&a, an);	ss_free(&a, bn);	ss_free(&a, cn);	ss_free(&a, dn);}

static voidss_rq_test7(void){	ssa a;	ss_aopen(&a, &ss_stda);	ssrq q;	t( ss_rqinit(&q, &a, 1, 10) == 0 );	ssrqnode *an = ss_malloc(&a, sizeof(ssrqnode));	ssrqnode *bn = ss_malloc(&a, sizeof(ssrqnode));	ssrqnode *cn = ss_malloc(&a, sizeof(ssrqnode));	t( an != NULL );	t( bn != NULL );	t( cn != NULL );	ss_rqinitnode(an);	ss_rqinitnode(bn);	ss_rqinitnode(cn);	ss_rqadd(&q, an, 1);	ss_rqadd(&q, bn, 2);	ss_rqadd(&q, cn, 3);	ss_rqdelete(&q, bn);	ss_rqdelete(&q, cn);	ss_rqdelete(&q, an);	int i = 0;	ssrqnode *n = NULL;	while ((n = ss_rqprev(&q, n))) {		i++;	}	t( i == 0 );	ss_rqfree(&q, &a);	ss_free(&a, an);	ss_free(&a, bn);	ss_free(&a, cn);}

static remote_t *new_remote(int fd, int timeout){    remote_t *remote;    remote = ss_malloc(sizeof(remote_t));    memset(remote, 0, sizeof(remote_t));    remote->buf                 = ss_malloc(sizeof(buffer_t));    remote->recv_ctx            = ss_malloc(sizeof(remote_ctx_t));    remote->send_ctx            = ss_malloc(sizeof(remote_ctx_t));    remote->fd                  = fd;    remote->recv_ctx->remote    = remote;    remote->recv_ctx->connected = 0;    remote->send_ctx->remote    = remote;    remote->send_ctx->connected = 0;    ev_io_init(&remote->recv_ctx->io, remote_recv_cb, fd, EV_READ);    ev_io_init(&remote->send_ctx->io, remote_send_cb, fd, EV_WRITE);    ev_timer_init(&remote->send_ctx->watcher, remote_timeout_cb,                  min(MAX_CONNECT_TIMEOUT, timeout), 0);    balloc(remote->buf, BUF_SIZE);    return remote;}

struct query_ctx *new_query_ctx(char *buf, size_t len){    struct query_ctx *ctx = ss_malloc(sizeof(struct query_ctx));    memset(ctx, 0, sizeof(struct query_ctx));    ctx->buf = ss_malloc(sizeof(buffer_t));    balloc(ctx->buf, len);    memcpy(ctx->buf->array, buf, len);    ctx->buf->len = len;    return ctx;}

cipher_t *aead_key_init(int method, const char *pass, const char *key){    if (method < AES128GCM || method >= AEAD_CIPHER_NUM) {        LOGE("aead_key_init(): Illegal method");        return NULL;    }    cipher_t *cipher = (cipher_t *)ss_malloc(sizeof(cipher_t));    memset(cipher, 0, sizeof(cipher_t));    // Initialize sodium for random generator    if (sodium_init() == -1) {        FATAL("Failed to initialize sodium");    }    if (method >= CHACHA20POLY1305IETF) {        cipher_kt_t *cipher_info = (cipher_kt_t *)ss_malloc(sizeof(cipher_kt_t));        cipher->info             = cipher_info;        cipher->info->base       = NULL;        cipher->info->key_bitlen = supported_aead_ciphers_key_size[method] * 8;        cipher->info->iv_size    = supported_aead_ciphers_nonce_size[method];    } else {        cipher->info = (cipher_kt_t *)aead_get_cipher_type(method);    }    if (cipher->info == NULL && cipher->key_len == 0) {        LOGE("Cipher %s not found in crypto library", supported_aead_ciphers[method]);        FATAL("Cannot initialize cipher");    }    if (key != NULL)        cipher->key_len = crypto_parse_key(key, cipher->key,                supported_aead_ciphers_key_size[method]);    else        cipher->key_len = crypto_derive_key(pass, cipher->key,                supported_aead_ciphers_key_size[method]);    if (cipher->key_len == 0) {        FATAL("Cannot generate key and nonce");    }    cipher->nonce_len = supported_aead_ciphers_nonce_size[method];    cipher->tag_len   = supported_aead_ciphers_tag_size[method];    cipher->method    = method;    return cipher;}

voidresolv_start(const char *hostname, uint16_t port,             void (*client_cb)(struct sockaddr *, void *),             void (*free_cb)(void *), void *data){    /*     * Wrap c-ares's call back in our own     */    struct resolv_query *query = ss_malloc(sizeof(struct resolv_query));    memset(query, 0, sizeof(struct resolv_query));    query->port           = port;    query->client_cb      = client_cb;    query->response_count = 0;    query->responses      = NULL;    query->data           = data;    query->free_cb        = free_cb;    query->requests[0] = AF_INET;    query->requests[1] = AF_INET6;    ares_gethostbyname(default_ctx.channel, hostname, AF_INET, dns_query_v4_cb, query);    ares_gethostbyname(default_ctx.channel, hostname, AF_INET6, dns_query_v6_cb, query);    reset_timer();}

static voidaead_cipher_ctx_init(cipher_ctx_t *cipher_ctx, int method, int enc){    if (method < AES128GCM || method >= AEAD_CIPHER_NUM) {        LOGE("cipher_context_init(): Illegal method");        return;    }    if (method >= CHACHA20POLY1305IETF) {        return;    }    const char *ciphername = supported_aead_ciphers[method];    const cipher_kt_t *cipher = aead_get_cipher_type(method);    cipher_ctx->evp = ss_malloc(sizeof(cipher_evp_t));    memset(cipher_ctx->evp, 0, sizeof(cipher_evp_t));    cipher_evp_t *evp = cipher_ctx->evp;    if (cipher == NULL) {        LOGE("Cipher %s not found in mbed TLS library", ciphername);        FATAL("Cannot initialize mbed TLS cipher");    }    mbedtls_cipher_init(evp);    if (mbedtls_cipher_setup(evp, cipher) != 0) {        FATAL("Cannot initialize mbed TLS cipher context");    }#ifdef SS_DEBUG    dump("KEY", (char *)cipher_ctx->cipher->key, cipher_ctx->cipher->key_len);#endif}

sinode *si_nodenew(sr *r){	sinode *n = (sinode*)ss_malloc(r->a, sizeof(sinode));	if (ssunlikely(n == NULL)) {		sr_oom_malfunction(r->e);		return NULL;	}	n->recover = 0;	n->backup = 0;	n->lru = 0;	n->ac = 0;	n->flags = 0;	n->update_time = 0;	n->used = 0;	n->in_memory = 0;	si_branchinit(&n->self, r);	n->branch = NULL;	n->branch_count = 0;	n->temperature = 0;	n->temperature_reads = 0;	ss_fileinit(&n->file, r->vfs);	ss_mmapinit(&n->map);	ss_mmapinit(&n->map_swap);	sv_indexinit(&n->i0);	sv_indexinit(&n->i1);	ss_rbinitnode(&n->node);	ss_rqinitnode(&n->nodecompact);	ss_rqinitnode(&n->nodebranch);	ss_rqinitnode(&n->nodetemp);	ss_listinit(&n->commit);	return n;}

intupdate_block_list(char *addr, int err_level){    size_t addr_len = strlen(addr);    if (cache_key_exist(block_list, addr, addr_len)) {        int *count = NULL;        cache_lookup(block_list, addr, addr_len, &count);        if (count != NULL) {            if (*count > MAX_TRIES)                return 1;            (*count) += err_level;        }    } else if (err_level > 0) {        int *count = (int *)ss_malloc(sizeof(int));        *count = 1;        cache_insert(block_list, addr, addr_len, count);#ifdef __linux__        if (mode != NO_FIREWALL_MODE)            set_firewall_rule(addr, 1);#endif    }    return 0;}

/** C = alpha*A + beta*B */cs* X(ss_add) (const cs *A, const cs *B, SS_ENTRY alpha, SS_ENTRY beta){    SS_INT p, j, nz = 0, anz, *Cp, *Ci, *Bp, m, n, bnz, *w, values ;    SS_ENTRY *x, *Bx, *Cx ;    cs *C ;    if (!SS_CSC (A) || !SS_CSC (B)) return (NULL) ;         /* check inputs */    if (A->m != B->m || A->n != B->n) return (NULL) ;    m = A->m ; anz = A->p [A->n] ;    n = B->n ; Bp = B->p ; Bx = B->x ; bnz = Bp [n] ;    w = ss_calloc (m, sizeof (SS_INT)) ;                       /* get workspace */    values = (A->x != NULL) && (Bx != NULL) ;    x = values ? ss_malloc (m, sizeof (SS_ENTRY)) : NULL ;    /* get workspace */    C = ss_spalloc (m, n, anz + bnz, values, 0) ;           /* allocate result*/    if (!C || !w || (values && !x)) return (ss_done (C, w, x, 0)) ;    Cp = C->p ; Ci = C->i ; Cx = C->x ;    for (j = 0 ; j < n ; j++)    {        Cp [j] = nz ;                   /* column j of C starts here */        nz = ss_scatter (A, j, alpha, w, x, j+1, C, nz) ;   /* alpha*A(:,j)*/        nz = ss_scatter (B, j, beta, w, x, j+1, C, nz) ;    /* beta*B(:,j) */        if (values) for (p = Cp [j] ; p < nz ; p++) Cx [p] = x [Ci [p]] ;    }    Cp [n] = nz ;                       /* finalize the last column of C */    ss_sprealloc (C, 0) ;               /* remove extra space from C */    return (ss_done (C, w, x, 1)) ;     /* success; free workspace, return C */}

ss_INLINEss* ss_m_cell(ss v){  ss *c = ss_malloc(sizeof(*c));  *c = v;  return c;}

/** allocate a sparse matrix (triplet form or compressed-column form) */static cs *ss_spalloc (SS_INT m, SS_INT n, SS_INT nzmax, SS_INT values, SS_INT triplet){    cs *A = ss_calloc (1, sizeof (cs)) ;    /* allocate the cs struct */    if (!A) return (NULL) ;                 /* out of memory */    A->id = M_SPT;    A->m = m ;                              /* define dimensions and nzmax */    A->n = n ;    A->nzmax = nzmax = SS_MAX (nzmax, 1) ;    A->nz = triplet ? 0 : -1 ;              /* allocate triplet or comp.col */    A->p = ss_malloc (triplet ? nzmax : n+1, sizeof (SS_INT)) ;    A->i = ss_malloc (nzmax, sizeof (SS_INT)) ;    A->x = values ? ss_malloc (nzmax, sizeof (SS_ENTRY)) : NULL ;    A->nref=calloc(1,sizeof(long));    A->nref[0]=1;    return ((!A->p || !A->i || (values && !A->x)) ? ss_spfree (A) : A) ;}

int balloc(buffer_t *ptr, size_t capacity){    sodium_memzero(ptr, sizeof(buffer_t));    ptr->array    = ss_malloc(capacity);    ptr->capacity = capacity;    return capacity;}

int balloc(buffer_t *ptr, size_t capacity){    memset(ptr, 0, sizeof(buffer_t));    ptr->array    = ss_malloc(capacity);    ptr->capacity = capacity;    return capacity;}

voidstream_cipher_ctx_init(cipher_ctx_t *ctx, int method, int enc){    if (method <= TABLE || method >= STREAM_CIPHER_NUM) {        LOGE("stream_ctx_init(): Illegal method");        return;    }    if (method >= SALSA20) {        return;    }    const char *ciphername    = supported_stream_ciphers[method];    const cipher_kt_t *cipher = stream_get_cipher_type(method);    ctx->evp = ss_malloc(sizeof(cipher_evp_t));    memset(ctx->evp, 0, sizeof(cipher_evp_t));    cipher_evp_t *evp = ctx->evp;    if (cipher == NULL) {        LOGE("Cipher %s not found in mbed TLS library", ciphername);        FATAL("Cannot initialize mbed TLS cipher");    }    mbedtls_cipher_init(evp);    if (mbedtls_cipher_setup(evp, cipher) != 0) {        FATAL("Cannot initialize mbed TLS cipher context");    }}

JNIEXPORT void JNICALL Java_me_smartproxy_crypto_CryptoUtils_initEncryptor(JNIEnv *env, jclass thiz, jstring jpassword, jstring jmethod, jlong id) {    enc_connection *connection = enc_ctx_map[id];    if(connection == NULL) {        const char *password = env->GetStringUTFChars(jpassword, 0);        const char *method = env->GetStringUTFChars(jmethod, 0);        connection = (enc_connection *)ss_malloc(sizeof(struct enc_connection));        connection->text_e_ctx = (enc_ctx *)ss_malloc(sizeof(struct enc_ctx));        connection->text_d_ctx = (enc_ctx *)ss_malloc(sizeof(struct enc_ctx));        int enc_method = enc_init(password, method);        enc_ctx_init(enc_method, connection->text_e_ctx, 1);        enc_ctx_init(enc_method, connection->text_d_ctx, 0);        enc_ctx_map[id] = connection;        env->ReleaseStringUTFChars(jpassword, password);        env->ReleaseStringUTFChars(jmethod, method);    }}

int sr_meta_write(srmeta *m, srmetastmt *s){    if (m->flags & SR_RO) {        sr_error(s->r->e, "%s is read-only", s->path);        return -1;    }    switch (m->type) {    case SS_U32:        if (s->valuetype == SS_I64) {            *((uint32_t*)m->value) = *(int64_t*)s->value;        } else if (s->valuetype == SS_U32) {            *((uint32_t*)m->value) = *(uint32_t*)s->value;        } else if (s->valuetype == SS_U64) {            *((uint32_t*)m->value) = *(uint64_t*)s->value;        } else {            goto bad_type;        }        break;    case SS_U64:        if (s->valuetype == SS_I64) {            *((uint64_t*)m->value) = *(int64_t*)s->value;        } else if (s->valuetype == SS_U32) {            *((uint64_t*)m->value) = *(uint32_t*)s->value;        } else if (s->valuetype == SS_U64) {            *((uint64_t*)m->value) = *(uint64_t*)s->value;        } else {            goto bad_type;        }        break;    case SS_STRINGPTR: {        char **string = m->value;        if (s->valuetype == SS_STRING) {            char *sz = s->value;            if (s->valuesize > 0) {                sz = ss_malloc(s->r->a, s->valuesize);                if (ssunlikely(sz == NULL))                    return sr_oom(s->r->e);                memcpy(sz, s->value, s->valuesize);            }            if (*string)                ss_free(s->r->a, *string);            *string = sz;        } else {            goto bad_type;        }        break;    }    default:        assert(0);        return -1;    }    return 0;bad_type:    return sr_error(s->r->e, "bad meta write type (%s) for (%s) %s",                    ss_typeof(s->valuetype),                    ss_typeof(m->type), s->path);}

ss_INLINEss ss_alloc(ss type, size_t size){  ss *ptr = ss_malloc(sizeof(ss) + size);  *(ptr ++) = type;  if ( type && ! ss_fixnumQ(((ss_s_type*) type)->instance_size) )    ((ss_s_type*) type)->instance_size = ss_i(size);  return ptr;}

static voidssa_malloc(void){	ssa a;	ss_aopen(&a, &ss_stda);	void *buf = ss_malloc(&a, 123);	t( buf != NULL );	ss_free(&a, buf);	ss_aclose(&a);}

cipher_t *stream_key_init(int method, const char *pass, const char *key){    if (method <= TABLE || method >= STREAM_CIPHER_NUM) {        LOGE("cipher->key_init(): Illegal method");        return NULL;    }    cipher_t *cipher = (cipher_t *)ss_malloc(sizeof(cipher_t));    memset(cipher, 0, sizeof(cipher_t));    if (method == SALSA20 || method == CHACHA20 || method == CHACHA20IETF) {        cipher_kt_t *cipher_info = (cipher_kt_t *)ss_malloc(sizeof(cipher_kt_t));        cipher->info             = cipher_info;        cipher->info->base       = NULL;        cipher->info->key_bitlen = supported_stream_ciphers_key_size[method] * 8;        cipher->info->iv_size    = supported_stream_ciphers_nonce_size[method];    } else {        cipher->info = (cipher_kt_t *)stream_get_cipher_type(method);    }    if (cipher->info == NULL && cipher->key_len == 0) {        LOGE("Cipher %s not found in crypto library", supported_stream_ciphers[method]);        FATAL("Cannot initialize cipher");    }    if (key != NULL)        cipher->key_len = crypto_parse_key(key, cipher->key, cipher_key_size(cipher));    else        cipher->key_len = crypto_derive_key(pass, cipher->key, cipher_key_size(cipher));    if (cipher->key_len == 0) {        FATAL("Cannot generate key and NONCE");    }    if (method == RC4_MD5) {        cipher->nonce_len = 16;    } else {        cipher->nonce_len = cipher_nonce_size(cipher);    }    cipher->method = method;    return cipher;}

struct ResolvQuery *resolv_query(const char *hostname, void (*client_cb)(struct sockaddr *, void *),             void (*client_free_cb)(void *), void *client_cb_data,             uint16_t port){    struct dns_ctx *ctx = (struct dns_ctx *)resolv_io_watcher.data;    /*     * Wrap udns's call back in our own     */    struct ResolvQuery *cb_data = ss_malloc(sizeof(struct ResolvQuery));    if (cb_data == NULL) {        LOGE("Failed to allocate memory for DNS query callback data.");        return NULL;    }    memset(cb_data, 0, sizeof(struct ResolvQuery));    cb_data->client_cb      = client_cb;    cb_data->client_free_cb = client_free_cb;    cb_data->client_cb_data = client_cb_data;    memset(cb_data->queries, 0, sizeof(cb_data->queries));    cb_data->response_count = 0;    cb_data->responses      = NULL;    cb_data->port           = port;    /* Submit A and AAAA queries */    if (resolv_mode != MODE_IPV6_ONLY) {        cb_data->queries[0] = dns_submit_a4(ctx,                                            hostname, 0,                                            dns_query_v4_cb, cb_data);        if (cb_data->queries[0] == NULL) {            LOGE("Failed to submit DNS query: %s",                 dns_strerror(dns_status(ctx)));        }    }    if (resolv_mode != MODE_IPV4_ONLY) {        cb_data->queries[1] = dns_submit_a6(ctx,                                            hostname, 0,                                            dns_query_v6_cb, cb_data);        if (cb_data->queries[1] == NULL) {            LOGE("Failed to submit DNS query: %s",                 dns_strerror(dns_status(ctx)));        }    }    if (all_queries_are_null(cb_data)) {        if (cb_data->client_free_cb != NULL) {            cb_data->client_free_cb(cb_data->client_cb_data);        }        ss_free(cb_data);    }    return cb_data;}

static intse_dbscheme_init(sedb *db, char *name, int size){	se *e = se_of(&db->o);	/* database id */	uint32_t id = sr_seq(&e->seq, SR_DSN);	sr_seq(&e->seq, SR_DSNNEXT);	/* prepare index scheme */	sischeme *scheme = db->scheme;	if (size == 0)		size = strlen(name);	scheme->name = ss_malloc(&e->a, size + 1);	if (ssunlikely(scheme->name == NULL))		goto error;	memcpy(scheme->name, name, size);	scheme->name[size] = 0;	scheme->id                  = id;	scheme->sync                = 2;	scheme->mmap                = 0;	scheme->storage             = SI_SCACHE;	scheme->node_size           = 64 * 1024 * 1024;	scheme->node_compact_load   = 0;	scheme->node_page_size      = 128 * 1024;	scheme->node_page_checksum  = 1;	scheme->compression_copy    = 0;	scheme->compression_cold    = 0;	scheme->compression_cold_if = &ss_nonefilter;	scheme->compression_hot     = 0;	scheme->compression_hot_if  = &ss_nonefilter;	scheme->temperature         = 0;	scheme->expire              = 0;	scheme->amqf                = 0;	scheme->fmt_storage         = SF_RAW;	scheme->lru                 = 0;	scheme->lru_step            = 128 * 1024;	scheme->buf_gc_wm           = 1024 * 1024;	scheme->storage_sz = ss_strdup(&e->a, "cache");	if (ssunlikely(scheme->storage_sz == NULL))		goto error;	scheme->compression_cold_sz =		ss_strdup(&e->a, scheme->compression_cold_if->name);	if (ssunlikely(scheme->compression_cold_sz == NULL))		goto error;	scheme->compression_hot_sz =		ss_strdup(&e->a, scheme->compression_hot_if->name);	if (ssunlikely(scheme->compression_hot_sz == NULL))		goto error;	sf_upsertinit(&scheme->fmt_upsert);	sf_schemeinit(&scheme->scheme);	return 0;error:	sr_oom(&e->error);	return -1;}

static server_t *new_server(int fd, int method){    server_t *server;    server = ss_malloc(sizeof(server_t));    server->recv_ctx            = ss_malloc(sizeof(server_ctx_t));    server->send_ctx            = ss_malloc(sizeof(server_ctx_t));    server->buf                 = ss_malloc(sizeof(buffer_t));    server->fd                  = fd;    server->recv_ctx->server    = server;    server->recv_ctx->connected = 0;    server->send_ctx->server    = server;    server->send_ctx->connected = 0;    server->hostname     = NULL;    server->hostname_len = 0;    if (method) {        server->e_ctx = ss_malloc(sizeof(enc_ctx_t));        server->d_ctx = ss_malloc(sizeof(enc_ctx_t));        enc_ctx_init(method, server->e_ctx, 1);        enc_ctx_init(method, server->d_ctx, 0);    } else {        server->e_ctx = NULL;        server->d_ctx = NULL;    }    ev_io_init(&server->recv_ctx->io, server_recv_cb, fd, EV_READ);    ev_io_init(&server->send_ctx->io, server_send_cb, fd, EV_WRITE);    balloc(server->buf, BUF_SIZE);    return server;}

void enc_table_init(const char *pass){    uint32_t i;    uint64_t key = 0;    uint8_t *digest;    enc_table = ss_malloc(256);    dec_table = ss_malloc(256);    digest = enc_md5((const uint8_t *)pass, strlen(pass), NULL);    for (i = 0; i < 8; i++)        key += OFFSET_ROL(digest, i);    for (i = 0; i < 256; ++i)        enc_table[i] = i;    for (i = 1; i < 1024; ++i)        merge_sort(enc_table, 256, i, key);    for (i = 0; i < 256; ++i)        // gen decrypt table from encrypt table        dec_table[enc_table[i]] = i;}

static voidssaslab_reuse(stc *cx){	sspager p;	ss_pagerinit(&p, 3, 1024);	ssa slab;	t( ss_aopen(&slab, &ss_slaba, &p, 32) == 0 );	void *alloc0[1000];	void *alloc1[1000];	memset(alloc0, 0, sizeof(alloc0));	memset(alloc1, 0, sizeof(alloc1));	int i = 0;	while (i < 1000) {		alloc0[i] = ss_malloc(&slab, 0);		t( alloc0[i] != NULL );		i++;	}	i--;	int pools = p.pools;	while (i >= 0) {		ss_free(&slab, alloc0[i]);		i--;	}	t( p.pools == pools );	i++;	while (i < 1000) {		alloc1[i] = ss_malloc(&slab, 0);		t( alloc0[i] == alloc1[i] );		i++;	}	t( p.pools == pools );	ss_aclose(&slab);	ss_pagerfree(&p);}

so *sc_readpool_new(screadpool *p, so *o, int add){	scread *r = (scread*)o;	scread *n = ss_malloc(p->r->a, sizeof(scread));	if (ssunlikely(r == NULL)) {		sr_oom(p->r->e);		return NULL;	}	memcpy(n, r, sizeof(*r));	if (add) {		sc_readpool_add(p, n);	}	return &r->o;}