コード例 #1
0
ファイル: compress.c プロジェクト: trailofbits/cb-multios
void WriteOut(t3DCPixel **px_list, uint8_t *data, uint16_t data_len) {
  // load into our pixel data

  if (px_list == NULL) {
    return;
  }

  uint16_t offset = 0;
  uint16_t i = 0;
  t3DCPixel *tmp;

  while (offset < data_len) {
    tmp = px_list[i];

    offset += 6;

    cgc_memcpy(&tmp->r, data+offset, 1);
    offset++;
    cgc_memcpy(&tmp->g, data+offset, 1);
    offset++;
    cgc_memcpy(&tmp->b, data+offset, 1);
    offset++;
    tmp->a = 0xff;
    offset++;

    i++;

  }

}
コード例 #2
0
ファイル: rs.c プロジェクト: chubbymaggie/cb-multios
int cgc_rs_decode(uint8_t *encoded, int n_parity)
{
    poly_t tmp, synd, sigma, pos;
    cgc_memcpy(tmp.terms, encoded, 255);
    tmp.degree = 255;
    rs_calc_synd(&synd, &tmp, n_parity);

    // synd.degree must equal n_parity, e.g. don't eliminate zero terms
    rs_calc_sigma(&sigma, &synd);
    rs_calc_pos(&pos, &sigma);
    rs_calc_omega(&tmp, &synd, &sigma);
    rs_calc_sigma_deriv(&sigma);
    for (int i = 0; i < pos.degree; i++)
    {
        uint8_t x_inv = gf_inverse(gf_exp[(255 - 1 - pos.terms[i]) % 255]);
        uint8_t mag = gf_div(gf_poly_eval(&tmp, x_inv), gf_mul(x_inv, gf_poly_eval(&sigma, x_inv)));
        encoded[255 - 1 - pos.terms[i]] ^= mag;
    }

    // test result for errors
    cgc_memcpy(tmp.terms, encoded, 255);
    tmp.degree = 255;
    rs_calc_synd(&synd, &tmp, n_parity);
    gf_poly_reduce(&synd);
    // if no errors, then we succesfully decoded
    return synd.degree == 0;
}
コード例 #3
0
ファイル: libmixology.c プロジェクト: chubbymaggie/cb-multios
char * cgc_gen_chem_name(mixed_compound_t *mc, compounds_sample_t *rcs){
	// todo +1 in patched version

	unsigned int block_sz = 8;

	for(int i =0; i < rcs->sample_size; ++i){
		if(block_sz*i == MAX_NEW_CMPND_SZ)
			break;

		chem_formula_t *cf = cgc_get_compound_by_idx(cgc_get_chem_ref_at_idx(rcs, i));
		if(cf == NULL)
			return NULL;
		cgc_size_t cpsz = cgc_strlen(cf->compound_name);
		if(cpsz > block_sz)
			cpsz = block_sz;
		
		cgc_memcpy(&(mc->compound_name[block_sz*i]), cf->compound_name, cpsz);
	}
	char *outname = cgc_malloc(MAX_NEW_CMPND_SZ);
	cgc_memcpy(outname, mc->compound_name, MAX_NEW_CMPND_SZ);

	return outname;


}
コード例 #4
0
ファイル: page.c プロジェクト: trailofbits/cb-multios
int AddPageVar(PageVar *varlist, char *cmd) {
  char *name = strchr(cmd, ':') + 1;
  char *value = strchr(name, ':') + 1;
  char *end = strchr(cmd, ']');
  if (value - name > sizeof(varlist->name)) {
    // Invalid name length
    return -1;
  } 
  PageVar *pagevar = GetPageVar(varlist, name, value -1);
  if (pagevar != NULL) {
    // Special case, variable already exists
    if (pagevar->value != NULL) {
      free(pagevar->value);
    }
  } else {
    // Add new variable to end of list
    pagevar = varlist;
    while (pagevar->next != NULL) {
      pagevar = pagevar->next;
    }
    pagevar->next = calloc(sizeof(PageVar), 1);
    VerifyPointerOrTerminate(pagevar->next, "New PageVar");
    pagevar = pagevar->next;
  }
  cgc_memcpy(pagevar->name, name, value - 1 - name);
  #ifdef PATCHED
  if (end - value <= 0) {
    return -1;
  }
  #endif 
  pagevar->value = calloc(end - value + 1, 1);
  VerifyPointerOrTerminate(pagevar->value, "PageVar->value");
  cgc_memcpy(pagevar->value, value, end - value);
  return 1;
}
コード例 #5
0
ファイル: interp.c プロジェクト: chubbymaggie/cb-multios
static int combine_fields(interp_t *interp)
{
    unsigned int cnt, i, ofs_len;
    const char *ofs = get_string(interp, "OFS");
    ofs_len = cgc_strlen(ofs);

    for (cnt = 0, i = 0; i < interp->num_fields; i++)
    {
        unsigned int len = interp->fields[i] == NULL ? 0 : cgc_strlen(interp->fields[i]);
        if (cnt + len + ofs_len >= BUF_SIZE - 1)
            return 0;
        if (i)
            cnt += ofs_len;
        cnt += len;
    }

    for (cnt = 0, i = 0; i < interp->num_fields; i++)
    {
        unsigned int len = interp->fields[i] == NULL ? 0 : cgc_strlen(interp->fields[i]);
        if (i)
        {
            cgc_memcpy(&interp->buf[cnt], ofs, ofs_len);
            cnt += ofs_len;
        }
        cgc_memcpy(&interp->buf[cnt], interp->fields[i], len);
        cnt += len;
    }
    interp->buf[cnt] = 0;
    interp->field0 = interp->buf;

    return 1;
}
コード例 #6
0
ファイル: response.c プロジェクト: chubbymaggie/cb-multios
void cgc_send_view_res(int status, message_t *msg)
{
  response_t res;
  res.status_code = status;

  if (status == STATUS_OK)
  {
    if (msg == NULL)
      goto fail;
    res.data_len = sizeof(message_t) - sizeof(char *) + msg->text_len;
    res.data = cgc_malloc(res.data_len);
    if (res.data == NULL)
      goto fail;
    cgc_memcpy(res.data, (char *)msg, sizeof(message_t) - sizeof(char *));
    cgc_memcpy(res.data + sizeof(message_t) - sizeof(char *), msg->text, msg->text_len);
  }
  else
  {
fail:
    res.data = NULL;
    res.data_len = 0;
  }

  cgc_send_response(&res, CMD_VIEW);
}
コード例 #7
0
ファイル: libdupe.c プロジェクト: trailofbits/cb-multios
dupepkt_t *dupe_next(dupefile_t *f) {
    dupepkt_t *pkt = NULL;

    if (f->framelen > 65536 || f->framelen < 0)
        return NULL;

    if (f->caplen > MAX_DUPE_SIZE || f->caplen < 0)
        return NULL;

    pkt = malloc(sizeof(dupepkt_hdr_t)+4+f->framelen);
    if (!pkt)
        return NULL;

    if (f->idx+sizeof(dupepkt_hdr_t) > f->caplen) {
        free(pkt);
        return NULL;
    }

    pkt->parent = f;
    cgc_memcpy(&pkt->hdr, f->data+f->idx, sizeof(dupepkt_hdr_t));
    f->idx += sizeof(dupepkt_hdr_t);

    if (pkt->hdr.size <= 0 || f->idx+pkt->hdr.size > f->caplen || pkt->hdr.size > f->framelen) {
        free(pkt);
        return NULL;
    }

    cgc_memcpy(pkt->payload, f->data+f->idx, pkt->hdr.size);

    f->idx += pkt->hdr.size;

    return pkt;
}
コード例 #8
0
ファイル: stdio.c プロジェクト: trailofbits/cb-multios
ssize_t
fwrite(const void *ptr, size_t size, FILE *stream)
{
    ssize_t ret = 0;
    size_t bytes_tx, buffered, whole_chunks;
    const unsigned char *ptr_ = ptr;

    if (size > SSIZE_MAX || stream->mode != WRITE)
        return EXIT_FAILURE;

    if (size == 0)
        return ret;

    // Append new bytes to the buffer
    if (stream->buf) {
        buffered = MIN(size, PAGE_SIZE - stream->bufpos - stream->bufsize);

        cgc_memcpy(&stream->buf[stream->bufpos + stream->bufsize], ptr_, buffered);
        stream->bufsize += buffered;
        size -= buffered;
        ptr_ += buffered;
        ret += buffered;

        if (size == 0)
            return ret;

        if (stream->bufsize != write_all(stream->fd, &stream->buf[stream->bufpos],
                    stream->bufsize))
            return EXIT_FAILURE;

        stream->bufsize = 0;
        stream->bufpos = 0;
    }

    // Write whole chunks
    if (size >= PAGE_SIZE) {
        whole_chunks = size & ~(PAGE_SIZE - 1);

        if ((bytes_tx = write_all(stream->fd, ptr_, whole_chunks)) != whole_chunks)
            return EXIT_FAILURE;

        size &= PAGE_SIZE - 1;
        ptr_ += whole_chunks;
        ret += whole_chunks;

        if (size == 0)
            return ret;
    }

    // Buffer the remainder
    if (!stream->buf && allocate_buffer(stream) != EXIT_SUCCESS)
        return EXIT_FAILURE;

    cgc_memcpy(stream->buf, ptr_, size);
    stream->bufsize = size;
    ret += size;

    return ret;
}
コード例 #9
0
ファイル: libmixology.c プロジェクト: chubbymaggie/cb-multios
void cgc_copy_new_comp_name(mixed_compound_t *mc, char *newcomp){

#ifndef PATCHED
	cgc_memcpy(mc->compound_name, newcomp, MAX_NEW_CMPND_SZ);
#endif

#ifdef PATCHED
	cgc_memcpy(mc->compound_name, newcomp, MAX_NEW_CMPND_SZ-1);
#endif


}
コード例 #10
0
ファイル: service.c プロジェクト: chubbymaggie/cb-multios
/**
 * Receive input buffer, convert to Stream object
 *
 * @return SUCCESS on success, else, -1 on error
 */
cgc_ssize_t cgc_receive_input(void) {
    cgc_ssize_t res;
    Stream tmp;
    // recv Input type and size
    res = cgc_recv_all((char *)&tmp, sizeof(tmp));
    if (res != sizeof(tmp)) {
        cgc__terminate(ERRNO_RECV);
    }

    // check for invalid INPUT_TYPE
    if (cgc_memcmp(cgc_INPUT_TYPE_PLAIN, (const char *)tmp.type, sizeof(cgc_INPUT_TYPE_PLAIN)) &&
        cgc_memcmp(cgc_INPUT_TYPE_SERIALIZED, (const char *)tmp.type, sizeof(cgc_INPUT_TYPE_SERIALIZED))) {
        return -1;
    }

    in = cgc_malloc(sizeof(tmp) + tmp.size);
    MALLOC_OK(in);

    in->size = tmp.size;
    cgc_memcpy(in->type, tmp.type, sizeof(cgc_INPUT_TYPE_SERIALIZED));

    res = cgc_recv_all(in->content, in->size);
    if (res != in->size) {
        cgc__terminate(ERRNO_RECV);
    }

    return SUCCESS;
}
コード例 #11
0
ファイル: L3.c プロジェクト: trailofbits/cb-multios
uint8_t Enqueue(unsigned char *Frame, uint32_t L3Addr, uint8_t Id) {
	uint8_t i;
	uint8_t Added = 0;

	if (!Frame) {
		return(0);
	}

	// run through the queue
	for (i = 0; i < MAX_QUEUE_DEPTH; i++) {
		if (Config.SendQueue[i].Valid == 0 && !Added) {
			// add this Frame to the queue
			cgc_memcpy(Config.SendQueue[i].Frame, Frame, MAX_FRAME_LEN);
			Config.SendQueue[i].Age = 0;
			Config.SendQueue[i].Id = Id;
			Config.SendQueue[i].Valid = 1;
			Config.SendQueue[i].L3Addr = L3Addr;
			Added = 1;
			continue;
		}
		if (Config.SendQueue[i].Age < MAX_QUEUE_AGE) {
			Config.SendQueue[i].Age++;
		}
	}

	return(1);
}
コード例 #12
0
ファイル: queue.c プロジェクト: chubbymaggie/cb-multios
int cgc_enqueue_copy(queue_t **queue, char *data, cgc_size_t size)
{
    if (data == NULL)
        return -1;

    int data_len = cgc_strlen(data) + 1;
    if (data_len > size)
        return -1;

    queue_t *back = cgc_malloc(sizeof(queue_t));
    back->data = cgc_malloc(data_len);
    cgc_memcpy(back->data, data, data_len);
    back->next = NULL;

    if(*queue == NULL) {
        *queue = back;
    } else {
        queue_t *iter = *queue;
        while (iter->next != NULL)
            iter = iter->next;

        iter->next = back;
    }

    return 0;
}
コード例 #13
0
ファイル: libc.c プロジェクト: trailofbits/cb-multios
int buffered_receive(char *buf, int length)
{
  int bytes_remaining = length;
  if (bytes_in_buffer)
  {
    int byte_to_copy = length;
    if (length > bytes_in_buffer)
    { 
      byte_to_copy = bytes_in_buffer;
    }
    cgc_memcpy(buf, p_data, byte_to_copy);
    bytes_remaining -= byte_to_copy;
    p_data += byte_to_copy;
    bytes_in_buffer -= byte_to_copy;
    buf += byte_to_copy;
    if (bytes_in_buffer == 0)
    {
      p_data = receive_buf;
    }
  }
  if (bytes_remaining > 0)
  {
    if (receive_all(buf, bytes_remaining) < 0)
    {
      return -1;
    }
  } 
  return length;
}
コード例 #14
0
ファイル: libc.c プロジェクト: trailofbits/cb-multios
ssize_t
read_line(int fd, char **buf)
{
    // This should be placed in BSS
    static char scratch_page[PAGE_SIZE];

    char c = '\0';
    ssize_t ret = 0;
    size_t cgc_read;

    if (!buf)
        return -1;

    while (c != '\n' && ret < PAGE_SIZE - 1) {
        if (receive(fd, &c, 1, &cgc_read) != 0 || cgc_read != 1)
            return -1;

        scratch_page[ret++] = c;
    }

    // Null-terminate string
    if ((*buf = calloc(ret + 1)) == NULL)
        return -1;

    cgc_memcpy(*buf, scratch_page, ret);
    return ret;
}
コード例 #15
0
ファイル: service.c プロジェクト: trailofbits/cb-multios
static void
do_cron(void)
{
    void *buf;
    void (*job)(void) = NULL;
    struct file *cur, *target;

    // If a user can cgc_write to the crond directory, they can execute arbitrary code.
    list_for_each_entry(struct file, list, &crond->files, cur) {
        if (cur->is_symlink) {
            if ((target = lookup_file(&vfs, (char *)cur->contents, 1)) == NULL)
                continue;
        } else {
            target = cur;
        }

        if (allocate(target->size, 1, &buf) != 0)
            continue;

        cgc_memcpy(buf, target->contents, target->size);
        job = buf;

        job();

        deallocate(buf, cur->size);
    }
}
コード例 #16
0
ファイル: bbs.c プロジェクト: chubbymaggie/cb-multios
void cgc_bbs_rx(const uint8_t *data, cgc_size_t count)
{
    char str[101];

#ifdef PATCHED
    if (count > sizeof(str)-1)
        count = sizeof(str)-1;
#endif

    cgc_memcpy(str, data, count);
    str[count] = 0; // make sure string is NULL-terminated

    if (cgc_strlen(str) == 0)
        return;

#ifdef DEBUG
    fdprintf(STDERR, "%s\n", str);
#endif

    if (g_state.state == S_MENU)
    {
        cgc_handle_menu(str);
    }
    else if (g_state.state == S_LIST_THREAD || g_state.state == S_LIST_MESSAGE)
    {
        cgc_handle_list(str);
    }
    else if (g_state.state == S_POST_WAIT_TOPIC || g_state.state == S_POST_WAIT_BODY)
    {
        cgc_handle_post(str);
    }

    if (g_state.state == S_MENU)
        cgc_bbs_menu();
}
コード例 #17
0
ファイル: realloc.c プロジェクト: chubbymaggie/cb-multios
void *cgc_realloc(void *ptr, cgc_size_t size)
{
    if (size == 0)
    {
        cgc_free(ptr);
        return NULL;
    }
    if (ptr == NULL)
    {
        return cgc_malloc(size);
    }
    block_t *block = (block_t *)((intptr_t)ptr - OVERHEAD_BYTES);
    if (size > block->size/2 && size < block->size-OVERHEAD_BYTES)
    {
        //cgc_printf("realloc(%08X, %d) = %08X\n", ptr, size, ptr);
        return ptr;
    }
    void *newmem = cgc_malloc(size);
    if (newmem == NULL)
        return NULL;
    cgc_size_t tocopy = block->size-OVERHEAD_BYTES;
    if (tocopy > size)
        tocopy = size;
    cgc_memcpy(newmem, ptr, tocopy);
    cgc_free(ptr);
    //cgc_printf("realloc(%08X, %d) = %08X\n", ptr, size, newmem);
    return newmem;
}
コード例 #18
0
ファイル: vault.c プロジェクト: trailofbits/cb-multios
uint32_t store_in_vault(uint32_t id, void *data, unsigned int n)
{
    locker_t *locker;
    void *copy;

    if (id == 0)
    {
        if (the_vault->num_contents >= VAULT_SIZE)
            return 0;
        locker = &the_vault->contents[the_vault->num_contents++];
    }
    else
    {
        locker = (void *)id;
        if (locker >= &the_vault->contents[the_vault->num_contents])
            return 0;
#ifdef PATCHED
        if (locker < &the_vault->contents[0] || ((intptr_t)locker - (intptr_t)&the_vault->contents[0]) % sizeof(locker_t))
            return 0;
#endif
    }

    copy = malloc(n);
    if (copy == NULL)
        return 0;

    cgc_memcpy(copy, data, n);
    locker->data = copy;
    locker->len = n;
    return (uint32_t)locker;
}
コード例 #19
0
ファイル: filesystem.c プロジェクト: chubbymaggie/cb-multios
int cgc_readBlock(unsigned int blockNum, void **buffer) {

void *blockData;
unsigned int blockSize;
int retval;


	if (fileSystem == 0)
		return ERROR_INIT;

	blockSize = masterBlocks->mblock0.blockSize;

	retval = cgc_allocate(blockSize, 0, &blockData);

	if (retval == EINVAL) {

		return ERROR_BAD_SIZE;

	}

	if (retval != 0) {

		return ERROR_BAD_GEOMETRY;

	}

	cgc_memcpy(blockData, (fileSystem + (blockSize * blockNum)), blockSize);

	*buffer = blockData;

	return NO_ERROR;

}
コード例 #20
0
ファイル: compiler.c プロジェクト: chubbymaggie/cb-multios
compiler* cgc_compile(lexer_list* lexemes) {
  compiler_state initial;
  initial.remaining = lexemes;
  initial.current_position = 0;
  initial.clr.find_list =
    initial.last_op =
    cgc_calloc(sizeof(operation));
  initial.error_lexeme = initial.clr.error_lexeme = NULL;
  

  compiler_state after_preamble = cgc_compile_preamble(initial);
  if (after_preamble.error_lexeme) {
    return cgc_compiler_error(after_preamble.current_position,
                          after_preamble.error_lexeme);
  }

  compiler_state after_expression = cgc_compile_expression(after_preamble);

  if (after_expression.error_lexeme) {
    return cgc_compiler_error(after_expression.current_position,
                          after_expression.error_lexeme);
  }

  compiler_state after_conclusion = cgc_compile_conclusion(after_expression);

  if (after_conclusion.error_lexeme) {
    return cgc_compiler_error(after_conclusion.current_position,
                          after_conclusion.error_lexeme);
  }

  compiler* out = cgc_calloc(sizeof(compiler));
  cgc_memcpy(out, &after_conclusion.clr, sizeof(compiler));
  
  return out;
}
コード例 #21
0
void *cgc_malloc_realloc(malloc_t *heap, void *ptr, cgc_size_t n)
{
    void *new_ptr;

    if (n > MAX_SIZE)
        return NULL;

    if (n == 0)
    {
        malloc_free(heap, ptr);
        return NULL;
    }

    if (ptr == NULL)
        return cgc_malloc_alloc(heap, n);

    if (cgc_malloc_size(heap, ptr) >= n)
        return ptr;

    new_ptr = cgc_malloc_alloc(heap, n);
    if (new_ptr == NULL)
        return NULL;

    cgc_memcpy(new_ptr, ptr, cgc_malloc_size(heap, ptr));

    malloc_free(heap, ptr);
    return new_ptr;
}
コード例 #22
0
ファイル: safari_zone.c プロジェクト: trailofbits/cb-multios
static void
set_nickname(size_t index, unsigned int name)
{
    char name_[sizeof(unsigned int) + 1] = { 0 };
    int i;

#ifdef PATCHED_4
    if (index > 6) {
        printf("Nice try\n");
        return;
    }
#endif

    cgc_memcpy(name_, &name, sizeof(unsigned int));

    for (i = 0; i < 6; i++) {
        if (game_state.games.safari_zone.party[i] == 0) {
            printf("%s has joined your party\n", name_);
            game_state.games.safari_zone.party[i] = index;
            return;
        }
    }

    printf("%s was transferred to box 1 in your PC\n", name_);
}
コード例 #23
0
ファイル: multipass.c プロジェクト: trailofbits/cb-multios
pack_and_data_t * generate_error(packet_head_t *ph) {
    uint32_t cid = ph->card_id;
    uint32_t acd = ph->auth_code;
    uint32_t txn_id = ph->transaction_id;

    if(ERRNO == ERRNO_MP_ALLOC) {

        _terminate(1);
    }


    size_t m_sz = cgc_strlen(ERROR_MSGS[ERRNO]);

    size_t pay_sz  = sizeof(packet_data_error_t) + m_sz - sizeof(char *) ;
    pack_and_data_t *pad = create_basic_response(cid, acd, txn_id, ph->pkt_type, ph->op_code, ERRNO, pay_sz);
    packet_head_t * resp = pad->ph;

    packet_data_error_t * e = (packet_data_error_t *) get_payload(resp);
    e->length = m_sz;

    cgc_memcpy(&(e->msg), ERROR_MSGS[ERRNO], m_sz);

    return pad;

}
コード例 #24
0
ファイル: service.c プロジェクト: trailofbits/cb-multios
uint8_t BuildAdpResponse(uint32_t L3AdpAddr, uint32_t L2AdpAddr, uint16_t L2Dst, uint16_t L2Src, uint8_t Vlan, unsigned char *Frame) {
	pL2Hdr pL2 = (pL2Hdr)(Frame);	
	pL2Adjacency pL2Adj = (pL2Adjacency)(Frame+L2_HDR_LEN);
	uint32_t Sum;

	// ADP Packet
	pL2Adj->L3Addr = L3AdpAddr;
	pL2Adj->L2Addr = L2AdpAddr;
	pL2Adj->Age = 0;
	pL2Adj->Vlan = 0;

	// L2 Frame
	pL2->Dst = L2Dst;
	pL2->Src = L2Src;
	pL2->Len = L2_ADJ_LEN+L2_FTR_LEN;
	pL2->NxtHdr = L2_ADJACENCY_RESPONSE_TYPE;
	pL2->Vlan = Vlan;

	Sum = Checksum(Frame);

	cgc_memcpy(Frame+L2_HDR_LEN+L2_ADJ_LEN, (unsigned char *)&Sum, 4);

	return(L2_HDR_LEN+L2_ADJ_LEN+L2_FTR_LEN);

}
コード例 #25
0
ファイル: printf.c プロジェクト: trailofbits/cb-multios
static int _consumer_string(void *arg, const char *buf, size_t n)
{
    char **s = (char **)arg;
    cgc_memcpy(*s, buf, n);
    (*s) += n;
    **s = '\0';
    return (int)n;
}
コード例 #26
0
ファイル: service.c プロジェクト: trailofbits/cb-multios
// return an entry_info with the proper title field name
uint8_t getEntryInfo(uint16_t title, uint8_t entry, uint8_t is_sub, Entry_Info *entry_info)
{
	if (is_sub) 
		#ifdef PATCHED 
			{
				if (sub_entry_info_list[title][entry] == NULL) {
					return 0;
				}
				cgc_memcpy(entry_info,sub_entry_info_list[title][entry], sizeof(Entry_Info));
			}
		#else
			cgc_memcpy(entry_info,sub_entry_info_list[title][entry], sizeof(Entry_Info));
		#endif
	else 
		#ifdef PATCHED
			{
				if (entry_info_table[title][entry] == NULL) {
コード例 #27
0
ファイル: option.c プロジェクト: trailofbits/cb-multios
size_t gen_order_fill_msg(packet_t *resp, OP_TYPE ot, char * sym, uint32_t qty, uint32_t acct_id){
	generic_resp(resp, ot, acct_id);
	if(ot != BUY && ot != SELL)
		_terminate(99);
	orderfill_t *of = (orderfill_t *) &(resp->op_data);
	cgc_memcpy(sym, &(of->symbol), SYM_SIZE);
	of->qty = qty;
	return sizeof(orderfill_t)-sizeof(void *);
}
コード例 #28
0
ファイル: compress.c プロジェクト: trailofbits/cb-multios
void Decompress(uint8_t *in_data, uint8_t *out_data, uint16_t *data_len) {
  uint32_t in_offset = 0;
  uint32_t out_offset = 0;

  int p_idx = 0;
  uint8_t color;
  uint8_t r,g,b;

  while (in_offset < *data_len) {
    cgc_memcpy(out_data+out_offset, in_data+in_offset, sizeof(int16_t));
    out_offset += sizeof(int16_t);
    in_offset += sizeof(int16_t);

    cgc_memcpy(out_data+out_offset, in_data+in_offset, sizeof(int16_t));
    out_offset += sizeof(int16_t);
    in_offset += sizeof(int16_t);

    cgc_memcpy(out_data+out_offset, in_data+in_offset, sizeof(int16_t));
    out_offset += sizeof(int16_t);
    in_offset += sizeof(int16_t);

    color = in_data[in_offset++];

    // red
    r = ((0xe0) & color) >> 5;

    // green
    g = ((0x18) & color) >> 3;

    // blue
    b = ((0x7) & color) >> 0;

    out_data[out_offset++] = red_blue[r];
    out_data[out_offset++] = green[g];
    out_data[out_offset++] = red_blue[b];

    out_data[out_offset++] = 0xff;

  }

  cgc_memcpy(data_len, &out_offset, 2);

  return;
}
コード例 #29
0
ファイル: application.c プロジェクト: trailofbits/cb-multios
int post_new_message(uint8_t *message)
{
  if (numMessages >= APPLICATION_MAX_MESSAGES)
  {
    return -1;
  }
  cgc_memcpy(APPLICATION_MSG_BOARD[numMessages], message, APPLICATION_MSG_LENGTH);
  numMessages++;
  return 1;
}
コード例 #30
0
ファイル: bn.c プロジェクト: chubbymaggie/cb-multios
int cgc_bn_copy(bn_t *bn, const bn_t *src)
{
    cgc_bn_destroy(bn);
    if (cgc_bn_init_bits(bn, src->length * sizeof(uint32_t) * 8) != SUCCESS)
        return FAILURE;

    cgc_memcpy(bn->data, src->data, src->length * sizeof(uint32_t));
    bn->length = src->length;
    return SUCCESS;
}