示例#1
0
文件: trans_c.c 项目: nawawi/klone
static int push_code_block(lang_c_ctx_t *ctx, parser_t *p,
                           const char *buf, size_t sz)
{
    code_block_t *node;

    dbg_return_if (p == NULL, ~0);
    dbg_return_if (ctx == NULL, ~0);

    node = (code_block_t*)u_zalloc(sizeof(code_block_t));
    dbg_err_if(node == NULL);

    node->sz = sz;
    node->buf = (char*)u_malloc(sz);
    dbg_err_if(node->buf == NULL);

    node->code_line = p->code_line;
    node->file_in = ctx->ti->file_in;

    memcpy(node->buf, buf, sz);

    TAILQ_INSERT_TAIL(&ctx->code_blocks, node, np);

    return 0;
err:
    if(node)
        free_code_block(node);
    return ~0;
}
示例#2
0
文件: buf.c 项目: fdotli/libu
/**
 *  \brief  Fill a buffer object with the content of a file
 *
 *  Open \p filename and copy its whole content into the given buffer \p ubuf
 *
 *  \param  ubuf        an already allocated ::u_buf_t object
 *  \param  filename    path of the source file
 *
 *  \retval  0  on success
 *  \retval ~0  on failure
 */
int u_buf_load (u_buf_t *ubuf, const char *filename)
{
    struct stat st;
    FILE *fp = NULL;

    dbg_return_if (ubuf == NULL, ~0);
    dbg_return_if (filename == NULL, ~0);

    dbg_err_sif (stat(filename, &st) == -1);

    /* clear the current data */
    dbg_err_if (u_buf_clear(ubuf));

    /* be sure to have a big enough buffer */
    dbg_err_if (u_buf_reserve(ubuf, st.st_size));

    dbg_err_sifm ((fp = fopen(filename, "r")) == NULL, "%s", filename);

    /* fill the buffer with the whole file content */
    dbg_err_if (fread(ubuf->data, st.st_size, 1, fp) != 1);
    ubuf->len = st.st_size;

    (void) fclose(fp);

    return 0;
err:
    U_FCLOSE(fp);
    return ~0;
}
示例#3
0
文件: date.c 项目: nawawi/klone
/**
 * \brief   Convert an asctime(3) string to \c time_t
 *
 * Convert the asctime(3) string \p str to its \c time_t representation \p tp.
 *
 * \param   str     the string to be converted
 * \param   tp      the \c time_t conversion of \p str as a value-result
 *                  argument
 * \return
 * - \c 0   successful
 * - \c ~0  failure
 */
int u_asctime_to_tt(const char *str, time_t *tp)
{
    enum { BUFSZ = 64 };
    char wday[BUFSZ], mon[BUFSZ];
    unsigned int day, year, hour, min, sec;
    struct tm tm;
    int i;

    dbg_return_if (str == NULL, ~0);
    dbg_return_if (tp == NULL, ~0);
    dbg_return_if (strlen(str) >= BUFSZ, ~0);

    dbg_err_if((i = sscanf(str, "%s %s %u %u:%u:%u %u", wday,
                           mon, &day, &hour, &min, &sec, &year)) != 7);

    memset(&tm, 0, sizeof(struct tm));

    /* time */
    tm.tm_sec = sec;
    tm.tm_min = min;
    tm.tm_hour = hour;

    /* date */
    tm.tm_mday = day;
    tm.tm_mon = month_idx(mon);
    tm.tm_year = year - 1900;

    dbg_err_if(tm.tm_mon < 0);

    *tp = timegm(&tm);

    return 0;
err:
    return ~0;
}
示例#4
0
/* remove a child process whose pid is 'pid' to children list */
static int server_reap_child(server_t *s, pid_t pid)
{
    child_t *child;
    backend_t *be;

    dbg_err_if (s == NULL);
    
    /* get the child object */
    dbg_err_if(children_get_by_pid(s->children, pid, &child));

    /* remove the child from the list */
    dbg_err_if(children_del(s->children, child));
    be = child->be;

    /* check that the minimum number of process are active */
    be->nchild--;
    if(be->nchild < be->start_child)
        be->fork_child = be->start_child - be->nchild;

    U_FREE(child);

    return 0;
err:
    return ~0;
}
示例#5
0
文件: date.c 项目: nawawi/klone
/**
 * \brief   Convert a \c time_t value to a rfc822 time string
 *
 * Convert the \c time_t value \p ts to a rfc822 time string
 *
 * \param   dst     placeholder for the rfc822 time string.  The buffer,
 *                  of at least RFC822_DATE_BUFSZ bytes, must be preallocated
 *                  by the caller.
 * \param   ts      the \c time_t value to be converted
 *
 * \return
 * - \c 0   successful
 * - \c ~0  failure
 */
int u_tt_to_rfc822(char dst[RFC822_DATE_BUFSZ], time_t ts)
{
    char buf[RFC822_DATE_BUFSZ];
    struct tm tm;

    dbg_return_if (dst == NULL, ~0);

#ifdef OS_WIN
    memcpy(&tm, gmtime(&ts), sizeof(tm));
#else
    dbg_err_if(gmtime_r(&ts, &tm) == NULL);
#endif

    dbg_err_if(tm.tm_wday > 6 || tm.tm_wday < 0);
    dbg_err_if(tm.tm_mon > 11 || tm.tm_mon < 0);

    dbg_err_if(u_snprintf(buf, sizeof buf,
                          "%s, %02u %s %02u %02u:%02u:%02u GMT",
                          days3[tm.tm_wday],
                          tm.tm_mday, months[tm.tm_mon], tm.tm_year + 1900,
                          tm.tm_hour, tm.tm_min, tm.tm_sec));

    /* copy out */
    u_strlcpy(dst, buf, RFC822_DATE_BUFSZ);

    return 0;
err:
    return ~0;
}
示例#6
0
/** 
 *  \brief Parse an URI string and create the corresponding ::u_uri_t object 
 *
 *  Parse the NUL-terminated string \p uri and create an ::u_uri_t object at 
 *  \p *pu 
 *
 *  \param  uri     the NUL-terminated string that must be parsed
 *  \param  opts    bitmask of or'ed ::u_uri_opts_t values
 *  \param  pu      the newly created ::u_uri_t object containing the b
 *
 *  \retval  0  on success
 *  \retval ~0  on error
 */
int u_uri_crumble (const char *uri, u_uri_opts_t opts, u_uri_t **pu)
{
    u_uri_t *u = NULL;
    int rc = 0;
    char es[1024];
    regex_t re;
    regmatch_t pmatch[10];

    dbg_return_if (uri == NULL, ~0);
    dbg_return_if (pu == NULL, ~0);

    dbg_err_if ((rc = regcomp(&re, uri_pat, REG_EXTENDED)));
    dbg_err_if ((rc = regexec(&re, uri, 10, pmatch, 0)));

    dbg_err_if (u_uri_new(opts, &u));
    dbg_err_if (u_uri_fill(u, uri, pmatch));

    regfree(&re);

    *pu = u;

    return 0;
err:
    if (rc)
    {
        regerror(rc, &re, es, sizeof es);
        u_dbg("%s: %s", uri, es);
    }
    regfree(&re);

    if (u)
        u_uri_free(u);

    return ~0;
}
示例#7
0
static int so_atom_delete_oldest(session_opt_t *so)
{
    atom_t *atom, *oldest;
    size_t count, i;

    dbg_err_if (so == NULL);

    count = atoms_count(so->atoms);
    nop_err_if(count == 0);

    dbg_err_if(atoms_getn(so->atoms, 0, &oldest));
    for(i = 1; i < count; ++i)
    {
        dbg_err_if(atoms_getn(so->atoms, i, &atom));

        /* save if older */
        if(atom->arg <= oldest->arg)
            oldest = atom;
    }

    dbg_err_if(atoms_remove(so->atoms, oldest));

    return 0;
err:
    return ~0;
}
示例#8
0
文件: var.c 项目: DanielTillett/klone
/**
 * \ingroup vars
 * \brief   Set binary value of a variable
 *
 * Set binary value of variable \p v.
 *
 * \param v      variable object
 * \param data   value data
 * \param size   value size
 *
 * \return \c 0 if successful, non-zero on error
 */
int var_set_bin_value(var_t *v, const unsigned char *data, size_t size)
{
    dbg_err_if (v == NULL);
    dbg_err_if (data == NULL);
    
    U_FREE(v->data);

    if(data && size)
    {
        v->size = size;
        v->data = u_malloc(size+1);
        dbg_err_if(v->data == NULL);

        memcpy(v->data, data, size);
        v->data[size] = 0; /* zero-term v->data so it can be used as a string */
    } else {
        v->size = 0;
        v->data = NULL;
    }

    if(v->svalue)
        dbg_err_if(u_string_set(v->svalue, v->data, v->size));

    return 0; 
err:
    return ~0;
}
示例#9
0
文件: entry.c 项目: SuperPeanut/klone
/* uninstall this service from the system */
int RemoveService(void) 
{
    SC_HANDLE hSCM, hService;
    int rc;

    hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);

    dbg_err_if(hSCM == NULL);

    /* Open this service for DELETE access */
    hService = OpenService(hSCM, ss_name, DELETE);

    dbg_err_if(hService == NULL);

    /* Remove this service from the SCM's database */
    rc = DeleteService(hService);

    dbg_err_if(rc == 0);

    /* success */
    MessageBox(NULL, "Uninstall succeeded", ss_name, MB_OK);
    return 0;
err:
    /* common error handling */
    warn_strerror(GetLastError());
    MessageBox(NULL, "Uninstall failed", ss_name, MB_OK);
    return ~0;
}
示例#10
0
int io_mem_create(char *buf, size_t size, int flags, io_t **pio)
{
    io_mem_t *im = NULL;

    dbg_err_if (buf == NULL);
    dbg_err_if (pio == NULL);
    
    dbg_err_if(io_create(io_mem_t, (io_t**)&im));

    im->io.type = IO_TYPE_MEM;

    im->buf = buf;
    im->size = size;
    im->flags = flags;
    im->off = 0;
    im->io.read = (io_read_op) io_mem_read;
    im->io.write = (io_write_op) io_mem_write;
    im->io.seek = (io_seek_op) io_mem_seek;
    im->io.tell = (io_tell_op) io_mem_tell;
    im->io.close = (io_close_op) io_mem_close; 
    im->io.free = (io_free_op) io_mem_free; 

    *pio = (io_t*)im;

    return 0;
err:
    if(im)
        io_free((io_t *)im);
    return ~0;
}
示例#11
0
ec_pdu_t *kache_get_evcoap_response(kache_evcoap_t *ke, 
        ec_client_t *cli, 
        char *uri)
{
    kache_obj_t *obj;
    dbg_err_if((obj = kache_get(ke->kache,uri))==NULL);
    ec_pdu_t *pdu;
    dbg_err_if((pdu = malloc(sizeof(ec_pdu_t))) == NULL);
    ec_opts_init(&pdu->opts);
    ec_pdu_t *req = &cli->req;

    ev_uint16_t ct;

    ec_opts_get_content_type(
                &req->opts, 
                &ct);

    kache_content_type_t *mt;
    dbg_err_if((mt = malloc(sizeof(kache_content_type_t)))==NULL);
    kache_ct_from_ecct(mt,&ct);
    kache_rep_t *rep;
    rep = kache_get_rep_by_media_type(obj,mt);

    //Translation
    dbg_err_if(kache_rep_to_evcoap_pdu_(rep, pdu));
    
    return pdu;
err:
    return NULL;
    

}
示例#12
0
/**
 * \brief   create a \c klog_t object reading configuration parameters from
 *          a configuration "log" record
 *
 * \param ls        a log configuration record
 * \param pkl       the corresponding \c klog_args_t object as a value-result 
 *                  argument
 * \return
 * - \c 0  success
 * - \c ~0 on failure (\p pka MUST not be referenced)
 */
int klog_open_from_config(u_config_t *ls, klog_t **pkl)
{
    klog_t *kl = NULL;
    klog_args_t *kargs = NULL;

    /* parse config parameters */
    dbg_err_if(klog_args(ls, &kargs));

    /* create a klog object */
    dbg_err_if(klog_open(kargs, &kl));

    klog_args_free(kargs);
    kargs = NULL;

    /* stick it */
    *pkl = kl;

    return 0;
err:
    if(kargs)
        klog_args_free(kargs);
    if(kl)
        klog_close(kl);
    return ~0;
}
示例#13
0
static int session_mem_remove(session_t *ss)
{
    ppc_t *ppc;

    dbg_err_if (ss == NULL);
    
    if(ctx->pipc)
    {   /* children context */
        ppc = server_get_ppc(ctx->server);
        dbg_err_if(ppc == NULL);

        dbg_err_if(ppc_write(ppc, ctx->pipc, PPC_CMD_MSES_REMOVE, ss->filename, 
            strlen(ss->filename) + 1) < 0);

        /* remove the session-atom from the (local copy) atom list */
        dbg_err_if(so_atom_remove(ss->so, ss->filename));
    } else {
        /* parent context */
        dbg_err_if(so_atom_remove(ss->so, ss->filename));
    }

    return 0;
err:
    return ~0;
}
示例#14
0
/* this function will be called once by the server during startup */
int session_client_module_init(u_config_t *config, session_opt_t *so)
{
    u_config_t *c;
    const char *v;

    /* config may be NULL */
    dbg_err_if (so == NULL);
    
    /* default */
    so->hash = EVP_sha1(); 

    /* always enable encryption for client-side sessions */
    if(!so->encrypt)
        warn("encryption is required for client side session");
    so->encrypt = 1;

    if(config && !u_config_get_subkey(config, "client", &c))
    {
        if((v = u_config_get_subkey_value(c, "hash_function")) != NULL)
        {
            if(!strcasecmp(v, "md5"))
                so->hash = EVP_md5();
            else if(!strcasecmp(v, "sha1"))
                so->hash = EVP_sha1();
#ifdef SSL_OPENSSL
            else if(!strcasecmp(v, "ripemd160"))
                so->hash = EVP_ripemd160();
#endif
            else
                warn_err("config error: bad hash_function");
        } 
    }

#ifdef SSL_OPENSSL
    /* initialize OpenSSL HMAC stuff */
    HMAC_CTX_init(&so->hmac_ctx);

    /* gen HMAC key */
    dbg_err_if(!RAND_bytes(so->hmac_key, HMAC_KEY_LEN));

    /* init HMAC with our key and chose hash algorithm */
    HMAC_Init_ex(&so->hmac_ctx, so->hmac_key, HMAC_KEY_LEN, so->hash, NULL);
#endif

#ifdef SSL_CYASSL
    /* gen HMAC key */
    dbg_err_if(!RAND_bytes(so->hmac_key, HMAC_KEY_LEN));

    if(strcmp(so->hash, "MD5") == 0)
        HmacSetKey(&so->hmac_ctx, MD5, so->hmac_key, HMAC_KEY_LEN);
    else if(strcmp(so->hash, "SHA") == 0)
        HmacSetKey(&so->hmac_ctx, SHA, so->hmac_key, HMAC_KEY_LEN);
#endif

    return 0;
err:
    return ~0;
}
示例#15
0
文件: buf.c 项目: fdotli/libu
/**
 *  \brief  Removes bytes from the tail of the buffer
 *
 *  Set the new length of the buffer; \p newlen must be less or equal to the
 *  current buffer length.
 *
 *  \param  ubuf    a previously allocated buffer object
 *  \param  newlen     new length of the buffer
 *
 *  \return 
 *  \retval  0  on success
 *  \retval ~0  on error
 */
int u_buf_shrink(u_buf_t *ubuf, size_t newlen)
{
    dbg_err_if (ubuf == NULL);
    dbg_err_if (newlen > ubuf->len);

    ubuf->len = newlen;

    return 0;
err:
    return ~0;
}
示例#16
0
char *io_mem_get_buf(io_t *io)
{
    io_mem_t *im = (io_mem_t*)io;

    dbg_err_if(io == NULL);
    dbg_err_if(im->io.type != IO_TYPE_MEM);

    return im->buf;
err:
    return NULL;
}
示例#17
0
文件: var.c 项目: DanielTillett/klone
/**
 * \ingroup vars
 * \brief   Set the name of a variable
 *
 * Set the name of variable \p v
 *
 * \param v     variable object
 * \param name  variable name (null-terminated)
 *
 * \return \c 0 if successful, non-zero on error
 */
int var_set_name(var_t *v, const char *name)
{
    dbg_err_if (v == NULL);
    dbg_err_if (name == NULL);

    dbg_err_if(u_string_set(v->sname, name, strlen(name)));

    return 0; 
err:
    return ~0;
}
示例#18
0
size_t io_mem_get_bufsz(io_t *io)
{
    io_mem_t *im = (io_mem_t*)io;

    dbg_err_if(io == NULL);
    dbg_err_if(im->io.type != IO_TYPE_MEM);

    return im->size;
err:
    return 0;
}
示例#19
0
文件: var.c 项目: DanielTillett/klone
/** 
 * \ingroup vars
 * \brief   Set the name and value of a variable
 *  
 * Set variable \p var to \p name and \p value.
 *
 * \param var   variable object
 * \param name  string name (null-terminated)
 * \param value string value (null-terminated)
 *  
 * \return \c 0 if successful, non-zero on error
 */ 
int var_set(var_t *var, const char *name, const char *value)
{
    dbg_err_if (var == NULL);
    dbg_err_if (name == NULL);
    dbg_err_if (value == NULL);
    
    dbg_err_if(var_set_name(var, name));
    dbg_err_if(var_set_value(var, value));

    return 0;
err:
    return ~0;
}
示例#20
0
文件: buf.c 项目: fdotli/libu
/**
 *  \brief  Set the value of a buffer
 *
 *  Explicitly set the value of \a ubuf to \a data.  If needed the buffer
 *  object will call ::u_buf_append to enlarge the storage needed to copy-in
 *  the \a data value.
 *
 *  \param  ubuf    a previously allocated ::u_buf_t object
 *  \param  data    a reference to the memory block that will be copied into
 *                  the buffer
 *  \param  size    size of \a data in bytes
 *
 *  \retval  0  on success
 *  \retval ~0  on error
 */
int u_buf_set (u_buf_t *ubuf, const void *data, size_t size)
{
    dbg_return_if (ubuf == NULL, ~0);
    dbg_return_if (data == NULL, ~0);
    dbg_return_if (size == 0, ~0);

    dbg_err_if (u_buf_clear(ubuf));
    dbg_err_if (u_buf_append(ubuf, data, size));

    return 0;
err:
    return ~0;
}
示例#21
0
mystruct_t *mystruct_create (void)
{
    mystruct_t *myval = NULL;

    dbg_err_if ((myval = (mystruct_t *) u_zalloc(sizeof(mystruct_t))) == NULL);
    dbg_err_if ((myval->a = strdup("first string")) == NULL);
    dbg_err_if ((myval->b = strdup("second string")) == NULL);

    return myval;
err:
    U_FREEF(myval, mystruct_free);

    return NULL;
}
示例#22
0
/* [parent] delete oldest session */
static int session_cmd_delold(ppc_t *ppc, int fd, unsigned char cmd, 
    char *data, size_t size, void *vso)
{
    session_opt_t *so = vso;

    u_unused_args(ppc, fd, cmd, data, size);

    dbg_err_if (vso == NULL);

    dbg_err_if (so_atom_delete_oldest(so));

    return 0;
err:
    return ~0;
}
示例#23
0
/**
 * \brief  Create a new buffer
 *
 * Create a new buffer object and save its pointer to \a *ps.
 *
 * \param pubuf    on success will get the new buffer object
 *
 * \return \c 0 on success, not zero on failure
 */
int u_buf_create(u_buf_t **pubuf)
{
    u_buf_t *ubuf = NULL;

    dbg_err_if(pubuf == NULL);

    ubuf = (u_buf_t*)u_zalloc(sizeof(u_buf_t));
    dbg_err_if(ubuf == NULL);

    *pubuf = ubuf;

    return 0;
err:
    return ~0;
}
示例#24
0
int proxy_init(void)
{
    dbg_err_if ((g_ctx.base = event_base_new()) == NULL);
    dbg_err_if ((g_ctx.dns = evdns_base_new(g_ctx.base, 1)) == NULL);
    dbg_err_if ((g_ctx.coap = ec_init(g_ctx.base, g_ctx.dns)) == NULL);
    dbg_err_if ((g_ctx.cache = ec_filesys_create(false)) == NULL);

    if (g_ctx.block_sz)
        dbg_err_if(ec_set_block_size(g_ctx.coap, g_ctx.block_sz));

    return 0;
err:
    proxy_term();
    return -1;
}
示例#25
0
int server_init(void)
{
    dbg_err_if((g_ctx.base = event_base_new()) == NULL);
    dbg_err_if((g_ctx.dns = evdns_base_new(g_ctx.base, 1)) == NULL);
    dbg_err_if((g_ctx.coap = ec_init(g_ctx.base, g_ctx.dns)) == NULL);
    dbg_err_if((g_ctx.fs = ec_filesys_create(g_ctx.rel_refs)) == NULL);

    if (g_ctx.bsz)
        dbg_err_if(ec_set_block_size(g_ctx.coap, g_ctx.bsz));

    return 0;
err:
    server_term();
    return -1;
}
示例#26
0
int vhost_load_allowed_methods(const char *m, ec_method_mask_t *pmm)
{
    size_t nelems, i;
    char **tv = NULL;

    dbg_return_if(m == NULL, -1);
    dbg_return_if(pmm == NULL, -1);

    *pmm = EC_METHOD_MASK_UNSET;

    dbg_err_if(u_strtok(m, " \t", &tv, &nelems));

    for (i = 0; i < nelems; ++i)
    {
        if (!strcasecmp(tv[i], "GET"))
            *pmm |= EC_GET_MASK;
        else if (!strcasecmp(tv[i], "POST"))
            *pmm |= EC_POST_MASK;
        else if (!strcasecmp(tv[i], "PUT"))
            *pmm |= EC_PUT_MASK;
        else if (!strcasecmp(tv[i], "DELETE"))
            *pmm |= EC_DELETE_MASK;
        else
            dbg_err("unknown method %s", tv[i]);
    }

    u_strtok_cleanup(tv, nelems);

    return 0;
err:
    if (tv)
        u_strtok_cleanup(tv, nelems);
    return -1;
}
示例#27
0
int vhost_load_contents(u_config_t *vhost, const char *origin)
{
    size_t i;
    char wkc[1024] = { '\0' };
    u_config_t *res, *contents;

    dbg_return_if(vhost == NULL, -1);
    dbg_return_if(origin == NULL, -1);

    /* Pick up the "contents" section. */
    dbg_err_ifm(u_config_get_subkey(vhost, "contents", &contents),
            "no contents in virtual host !");

    /* Load hosted resources. */
    for (i = 0;
            (res = u_config_get_child_n(contents, "resource", i)) != NULL;
            ++i)
    {
        dbg_err_ifm(vhost_load_resource(res, origin),
                "error loading resource");
    }

    dbg_err_ifm(i == 0, "no resources in virtual host");

    /* Add the default /.well-known/core interface. */
    dbg_err_if(u_snprintf(wkc, sizeof wkc, "%s/.well-known/core", origin));
    CHAT("adding resource %s (AUTO)", wkc);
    dbg_err_ifm(ec_register_cb(g_ctx.coap, wkc, serve, NULL),
            "registering callback for %s failed", wkc);

    return 0;
err:
    return -1;
}
示例#28
0
static ssize_t gzip_transform(codec_t *codec, char *dst, size_t *dcount, 
        const char *src, size_t src_sz)
{
    codec_gzip_t *iz;
    size_t consumed;
 
    dbg_return_if (codec == NULL, -1);
    dbg_return_if (src == NULL, -1);
    dbg_return_if (dst == NULL, -1); 
    dbg_return_if (dcount == NULL || *dcount == 0, -1);
    dbg_return_if (src_sz == 0, -1);

    iz = (codec_gzip_t*)codec;
    
    iz->zstr.next_out = dst;
    iz->zstr.avail_out = *dcount;

    iz->zstr.next_in = (char*)src;
    iz->zstr.avail_in = src_sz;

    iz->err = iz->op(&iz->zstr, Z_NO_FLUSH);
    dbg_err_if(iz->err != Z_OK && iz->err != Z_STREAM_END);

    consumed = src_sz - iz->zstr.avail_in;  /* consumed */
    *dcount = *dcount - iz->zstr.avail_out; /* written */

    return consumed; /* # of consumed input bytes */
err:
    u_dbg("%s", zError(iz->err));
    return -1;
}
示例#29
0
/**
 *  \brief  Append a NUL-terminated string to a string object
 *
 *  Append the NUL-terminated string \p buf to the ::u_string_t object \p s
 *
 *  \param  s   an ::u_string_t object
 *  \param  buf NUL-terminated string that will be appended to \p s
 *  \param  len length of \p buf
 *
 *  \retval  0  on success
 *  \retval ~0  on failure
 */
int u_string_append (u_string_t *s, const char *buf, size_t len)
{
    size_t nsz, min;

    dbg_return_if (s == NULL, ~0);
    dbg_return_if (buf == NULL, ~0);
    nop_return_if (len == 0, 0);    /* nothing to do */

    /* if there's not enough space on s->data alloc a bigger buffer */
    if (s->data_len + len + 1 > s->data_sz)
    {
        min = s->data_len + len + 1; /* min required buffer length */
        nsz = s->data_sz;
        while (nsz <= min)
            nsz += (BLOCK_SIZE << s->shift_cnt++);

        dbg_err_if (u_string_reserve(s, nsz));
    }

    /* append this chunk to the data buffer */
    strncpy(s->data + s->data_len, buf, len);
    s->data_len += len;
    s->data[s->data_len] = '\0';
    
    return 0;
err:
    return ~0;
}
示例#30
0
/* [parent] remove a sessioin*/
static int session_cmd_remove(ppc_t *ppc, int fd, unsigned char cmd, 
    char *data, size_t size, void *vso)
{
    session_opt_t *so = vso;

    u_unused_args(ppc, fd, cmd, size);

    dbg_err_if (data == NULL);
    dbg_err_if (vso == NULL);

    dbg_err_if(so_atom_remove(so, data /* filename */));

    return 0;
err:
    return ~0;
}