bloomy_t* bloomy_new(size_t size, hash_t hash1, hash_t hash2, hash_t hash3)
{
bloomy_t *bloomy;
if (size < 1)
return NULL;
bloomy = (bloomy_t *) malloc(sizeof(bloomy_t));
if (bloomy == NULL)
goto fail;
cgc_memset(bloomy, 0, sizeof(bloomy_t));
bloomy->size = size;
bloomy->bits = (uint8_t *) malloc(size);
if (bloomy->bits == NULL)
goto fail;
cgc_memset(bloomy->bits, 0, size);
bloomy->hashes[0] = hash1;
bloomy->hashes[1] = hash2;
bloomy->hashes[2] = hash3;
return bloomy;
fail:
bloomy_free(bloomy);
return NULL;
}
// initialize game data
void init_game_data(tt_data * data) {
cgc_memset(data->top, EMPTY, 3);
cgc_memset(data->middle, EMPTY, 3);
cgc_memset(data->bottom, EMPTY, 3);
data->moves = 0;
data->winner = EMPTY;
}
void cgc_handle_decompress()
{
int i;
unsigned char buf[95], *out = NULL;
unsigned char data[MAX_DATA_SIZE];
cgc_size_t outlen = 0, len = 0;
sc_obj_t *sc = NULL;
cgc_printf("Key?\n");
if (cgc_fread(buf, sizeof(buf), cgc_stdin) != sizeof(buf))
goto fail;
cgc_memset(data, 0, sizeof(data));
for (i = 0; i < sizeof(buf); ++i)
{
if (buf[i] < 32 || buf[i] > 126)
goto fail;
if (data[buf[i]]++ > 0)
goto fail;
}
cgc_printf("Length?\n");
cgc_memset(data, 0, sizeof(data));
cgc_fflush(cgc_stdout);
if (cgc_freaduntil((char *) data, sizeof(data), '\n', cgc_stdin) < 0)
goto fail;
len = cgc_strtoul((char *) data, NULL, 10);
if (len > MAX_DATA_SIZE)
goto fail;
cgc_printf("Data?\n");
cgc_memset(data, 0, sizeof(data));
if (cgc_fread((char *) data, len, cgc_stdin) < 0)
goto fail;
sc = cgc_sc_new(buf);
sc->data = data;
sc->data_len = len;
if (cgc_sc_sdecompress(sc, &out, &outlen) < 0)
goto fail;
cgc_printf("Compressed Size: %d\n", sc->data_len);
cgc_printf("Original Size: %d\n", cgc_strlen((char *) out));
cgc_printf("Original Data: ");
cgc_fwrite(out, outlen, cgc_stdout);
cgc_fwrite("\n", 1, cgc_stdout);
goto done;
fail:
cgc_printf("error.\n");
done:
if (sc)
cgc_free(sc);
if (out)
cgc_free(out);
}
error_t cgc_team_new(team_t **team)
{
if (!team)
return ERR_INTERNAL;
*team = (team_t *) cgc_malloc(sizeof(team_t));
cgc_memset(*team, 0, sizeof(team_t));
(*team)->members = (user_t **) cgc_malloc(sizeof(user_t *) * 8);
(*team)->sz_members = 8;
cgc_memset((*team)->members, 0, (*team)->sz_members * sizeof(user_t *));
return ERR_OK;
}
void FlushOutput() {
printf("@s\n", line);
cgc_memset(line, '\0', sizeof(line));
if (in_a_box) {
cgc_memset(line, ' ', sizeof(line) - 1);
line[0] = '*';
line[79] = '*';
line_length = 2;
} else {
line_length = 0;
}
}
void cgc_handle_compress()
{
int i;
unsigned char buf[95], *out = NULL;
unsigned char data[MAX_DATA_SIZE];
cgc_size_t outlen = 0;
sc_obj_t *sc = NULL;
cgc_printf("Key?\n");
if (cgc_fread(buf, sizeof(buf), cgc_stdin) != sizeof(buf))
goto fail;
cgc_memset(data, 0, sizeof(data));
for (i = 0; i < sizeof(buf); ++i)
{
if (buf[i] < 32 || buf[i] > 126)
goto fail;
if (data[buf[i]]++ > 0)
goto fail;
}
cgc_printf("Data?\n");
cgc_memset(data, 0, sizeof(data));
cgc_fflush(cgc_stdout);
if (cgc_freaduntil((char *) data, sizeof(data), '\0', cgc_stdin) < 0)
goto fail;
sc = cgc_sc_new(buf);
sc->data = data;
sc->data_len = cgc_strlen((char *)data);
if (cgc_sc_scompress(sc, &out, &outlen) < 0)
goto fail;
cgc_printf("Original Size: %d\n", sc->data_len);
cgc_printf("Compressed Size: %d (%d%%)\n", outlen, ((int) ((outlen / (sc->data_len * 1.0)) * 100)));
cgc_printf("Compressed Data: ");
for (i = 0; i < outlen && i < 32; ++i)
cgc_printf("%02X", out[i]);
cgc_printf("\n");
goto done;
fail:
cgc_printf("error.\n");
done:
if (sc)
cgc_free(sc);
if (out)
cgc_free(out);
}
/**
* Take the order of one customer
*
* @param c Customer
* @return Pointer to a new Order or NULL if no order
*/
static Order *cgc_take_customer_order(Customer *c) {
Order *o = cgc_malloc(sizeof(Order));
MALLOC_OK(o);
cgc_memset(o, '\0', sizeof(Order));
o->t_id = table.id;
o->c_id = c->id;
DBG("Table status: %U\n", table.status);
switch(table.status) {
case APP_RTO: // RTO => ready to order
o->ftype = APP_TYPE;
o->item = cgc_select_appetizer(cgc_get_appetizer_list(), c);
DBG("Customer %U ordering appetizer\n", c->id);
break;
case MEAL_RTO:
o->ftype = MEAL_TYPE;
o->item = cgc_select_meal(cgc_get_meal_list(), c);
DBG("Customer %U ordering meal\n", c->id);
break;
case DES_RTO:
o->ftype = DES_TYPE;
o->item = cgc_select_dessert(cgc_get_dessert_list(), c);
DBG("Customer %U ordering dessert\n", c->id);
break;
default: // WAIT => already ordered, VACANT, FINISHED
DBG("Customer %U NOT ordering\n", c->id);
cgc_free(o);
return NULL;
}
return o;
}
void cgc_table_setup(void) {
cgc_memset(&table, '\0', sizeof(Table));
table.id = TABLE_ID;
table.status = VACANT;
table.seats = cgc_calculate_seats_count();
table.customers = NULL;
}
int main(void) {
int ret = SUCCESS;
// Get op (1st byte), dispatch to function.
while(1) {
rx_bytes = 0;
cgc_memset(rx_buf, 0, BUF_RX_SZ);
if (SUCCESS != (ret = receive_all(STDIN, (void *)&rx_buf, BUF_RX_SZ, &rx_bytes))) {
#ifdef DEBUG
fprintf(stderr, "[E] main | during receive_all()\n");
#endif
ret = ERRNO_RECV;
goto _bail_main;
}
// "zero indicates nothing was received or end-of-file"
// Not sending any more calculations is a way to cgc_exit the calculator.
if (0 == rx_bytes) {
#ifdef DEBUG
fprintf(stderr, "[E] main | got no bytes; bailing...\n", rx_bytes);
#endif
goto _bail_main;
}
dispatch();
}
_bail_main:
return ret;
}
int main(void) {
char buf[1024];
int ret;
do_config();
setup();
sleep(2);
while (1) {
cgc_memset(buf, 0, sizeof(buf));
ret = read_until(read_fd, buf, sizeof(buf), '\n');
if (ret == -1)
cgc_exit(4);
if (ret > 0) {
if (buf[0] == 0) {
cgc_exit(0);
}
ret = search(buf, cgc_strlen(buf));
if (ret != 1) {
printf(write_fd, "%s\n", buf);
}
}
}
cgc_exit(1);
}
int main(void)
{
unsigned size = 0;
size_t cgc_read = 0;
uint8_t buf[MAX_SIZE];
cgc_memset(buf, 0, sizeof(buf));
if (receive(STDIN, &size, sizeof(size), &cgc_read) != 0)
cgc_exit(1);
if (cgc_read != 4)
cgc_exit(1);
if (size > MAX_SIZE) {
printf("too big\n");
cgc_exit(1);
}
if (read_exactly(STDIN, buf, size) != 0)
cgc_exit(1);
element *e = decode(buf, (unsigned) buf + size);
if (e == NULL)
cgc_exit(1);
pprint(e);
}
char *word_list_to_str(const list *l)
{
if (!l)
return NULL;
#define START_SIZE 128
char *flat = calloc(1, START_SIZE);
size_t cur_size = START_SIZE;
if (!flat)
error(EALLOC);
const list *p = l;
while (p && p->d) {
size_t cur_len = cgc_strlen(flat);
if (cgc_strlen(flat) + cgc_strlen(p->d) + cgc_strlen(word_sep) + 1 > cur_size) {
cur_size = (cgc_strlen(flat) + cgc_strlen(p->d) + cgc_strlen(word_sep) + 1) * 2;
flat = realloc(flat, cur_size);
if (!flat)
error(EALLOC);
cgc_memset(flat + cur_len, 0, cur_size - cur_len);
}
strcat(flat, p->d);
strcat(flat, word_sep);
p = p->n;
}
return flat;
}
error_t cgc_user_new(user_t **user)
{
if (!user)
return ERR_INTERNAL;
*user = (user_t *) cgc_malloc(sizeof(user_t));
cgc_memset(*user, 0, sizeof(user_t));
return ERR_OK;
}
void create_resp_pkt(tfttp_pkt* pkt, char *resp) {
cgc_memset(pkt,'\0', TFTTP_STRUCT_SIZE);
strcpy((char *)pkt->data, resp);
pkt->hdr.code = RESP;
//for now, fixed length responses until pollers can support otherwise
//pkt->size = sizeof(enum pkttype)+cgc_strlen(resp)+1;
pkt->hdr.size = 256; //-_-
}
static void gf_poly_mul(poly_t *dst, const poly_t *a, const poly_t *b)
{
dst->degree = a->degree + b->degree - 1;
cgc_memset(dst->terms, 0, dst->degree);
for (int i = 0; i < a->degree; i++)
for (int j = 0; j < b->degree; j++)
dst->terms[i + j] ^= gf_mul(a->terms[i], b->terms[j]);
}
error_t cgc_user_set_nick(user_t *user, const char *nick)
{
if (!user || !nick)
return ERR_INTERNAL;
if (cgc_strlen(nick) >= sizeof(user->nick))
return ERR_NICK_LONG;
cgc_memset(user->nick, 0, sizeof(user->nick));
cgc_strcpy(user->nick, nick);
return ERR_OK;
}
error_t cgc_user_set_pass(user_t *user, const char *pass)
{
if (!user || !pass)
return ERR_INTERNAL;
if (cgc_strlen(pass) >= sizeof(user->pass))
return ERR_PASS_LONG;
cgc_memset(user->pass, 0, sizeof(user->pass));
cgc_strcpy(user->pass, pass);
return ERR_OK;
}
error_t cgc_team_change_name(team_t *team, const char *name)
{
if (!team || !name)
return ERR_INTERNAL;
if (cgc_strlen(name) >= sizeof(team->name))
return ERR_NAME_LONG;
cgc_memset(team->name, 0, sizeof(team->name));
cgc_strcpy(team->name, name);
return ERR_OK;
}
void *cgc_calloc( cgc_size_t count, cgc_size_t obj_size )
{
cgc_size_t allocation_size = (count * obj_size);
void *pMemBuffer;
pMemBuffer = cgc_malloc( allocation_size );
cgc_memset( pMemBuffer, 0, allocation_size );
return (pMemBuffer);
}
void *calloc(size_t nmemb, size_t size)
{
uint64_t total = (uint64_t)nmemb * size;
if (total > UINT32_MAX)
return NULL;
void *ret = malloc((size_t)total);
if (ret == NULL)
return NULL;
cgc_memset(ret, 0, (size_t)total);
return ret;
}
/*
* Database
*/
int InitializeSignatureDatabase(signature_db* SignatureDatabase)
{
if (!SignatureDatabase)
return -1;
SignatureDatabase->SignatureCount = 0;
cgc_memset(SignatureDatabase->Signatures, 0, sizeof(signature *) * MAX_SIGNATURES);
SignatureDatabase->Trie = NULL;
SignatureDatabase->SearchMachine = xcalloc(1, sizeof(search_machine));
return 0;
}
int delete_message(uint8_t msg_num)
{
if (msg_num >= APPLICATION_MAX_MESSAGES)
{
return -1;
}
cgc_memset(APPLICATION_MSG_BOARD[msg_num], 0, APPLICATION_MSG_LENGTH);
for (int i = msg_num; i < APPLICATION_MAX_MESSAGES - 1; i++)
{
cgc_memcpy(APPLICATION_MSG_BOARD[i], APPLICATION_MSG_BOARD[i+1], APPLICATION_MSG_LENGTH);
}
numMessages--;
return 1;
}
static int
xor_login(char *name)
{
size_t secret_size = sizeof(secret) - 1;
size_t token_size, sig_size, signed_token_size;
char *token, *signed_token;
char sig[secret_size];
if ((token = make_token(name)) == NULL)
return -1;
token_size = cgc_strlen(token);
signed_token_size = token_size + 2 * secret_size + 2;
if ((signed_token = realloc(token, signed_token_size)) == NULL) {
free(token);
return -1;
}
if ((sig_size = xor_sig(signed_token, token_size, sig)) == 0) {
free(signed_token);
return -1;
}
signed_token[token_size] = '|';
bin_to_hex(signed_token + token_size + 1, sig, sig_size);
signed_token[signed_token_size - 1] = '\n';
if (write_all(STDOUT, signed_token, signed_token_size) != signed_token_size)
return -1;
cgc_memset(sig, '\x00', sig_size);
cgc_memset(signed_token, '\x00', signed_token_size);
free(signed_token);
return 0;
}
int play_ttt(int turn)
{
unsigned char len_resp[128];
//unsigned int resp_len = 0;
//unsigned char *resp = NULL;
char *select_guess_num_game = "3\n";
cgc_memset(len_resp, 0, 128);
read_until_game_prompt();
length_read(STDIN, len_resp, cgc_strlen("Game # "));
transmit_all(STDOUT, select_guess_num_game, cgc_strlen(select_guess_num_game));
if (turn == COMPUTER) {
switch(find_corner()) {
case 0:
transmit_all(STDOUT, "1,1\n", 4);
transmit_all(STDOUT, "0,2\n", 4);
transmit_all(STDOUT, "1,0\n", 4);
transmit_all(STDOUT, "2,2\n", 4);
return 0;
case 1:
transmit_all(STDOUT, "1,1\n", 4);
transmit_all(STDOUT, "0,1\n", 4);
transmit_all(STDOUT, "1,0\n", 4);
transmit_all(STDOUT, "2,2\n", 4);
return 1;
case 2:
transmit_all(STDOUT, "1,1\n", 4);
transmit_all(STDOUT, "1,0\n", 4);
transmit_all(STDOUT, "2,2\n", 4);
transmit_all(STDOUT, "0,2\n", 4);
return 2;
case 3:
transmit_all(STDOUT, "1,1\n", 4);
transmit_all(STDOUT, "2,1\n", 4);
transmit_all(STDOUT, "0,2\n", 4);
transmit_all(STDOUT, "1,0\n", 4);
return 3;
}
} else {
transmit_all(STDOUT, "2,0\n", 4);
transmit_all(STDOUT, "2,1\n", 4);
transmit_all(STDOUT, "0,0\n", 4);
transmit_all(STDOUT, "1,2\n", 4);
transmit_all(STDOUT, "0,2\n", 4);
return 5;
}
return -1;
}
void init_db()
{
int i;
record rec;
cgc_memset(&rec, 0, sizeof(rec));
for (i = 0; i < sizeof(g_items) / sizeof(g_items[0]); i++)
{
rec.k.data.count = cgc_strlen(g_items[i].name) + 1;
rec.k.data.data = (opaque *)g_items[i].name;
rec.data.count = sizeof(g_items[i].details);
rec.data.data = (opaque *)&g_items[i].details;
db_insert(rec);
}
}
void *calloc(size_t count, size_t size)
{
size_t n = count * size;
void *ptr;
if ((uintmax_t)count * size > (uintmax_t)SIZE_MAX)
return NULL;
ptr = malloc_alloc(&g_heap, n);
if (ptr == NULL)
return NULL;
cgc_memset(ptr, 0, n);
return ptr;
}
int play_rps()
{
unsigned char len_resp[128];
unsigned int resp_len = 0;
unsigned char *resp = NULL;
char *select_guess_num_game = "1\n";
char *hammer = "HAMMER\n";
cgc_memset(len_resp, 0, 128);
read_until_game_prompt();
length_read(STDIN, len_resp, cgc_strlen("Game # "));
transmit_all(STDOUT, select_guess_num_game, cgc_strlen(select_guess_num_game));
cgc_memset(len_resp, 0, 128);
length_read(STDIN, len_resp, cgc_strlen("Choose [HAMMER, SHEET, SHEERS]: "));
transmit_all(STDOUT, hammer, cgc_strlen(hammer));
delimited_read(STDIN, &resp, &resp_len, (unsigned char *)"\n", 1);
delimited_read(STDIN, &resp, &resp_len, (unsigned char *)"\n", 1);
if(memcmp(resp, "You Win!", 8) == 0) {
return 0;
}
return 1;
}
int PMPGenerate(PMP_File *pmp, Canvas *c) {
int row_pad = 0;
int odd_bytes = (c->x_size * 3) % 4;
if (odd_bytes != 0) {
row_pad = 4 - odd_bytes;
}
pmp->header.magic = 0x4d50;
pmp->header.reserved = 0;
pmp->header.header_size = sizeof(PMP_Info) + sizeof(PMP_Header);
pmp->header.filesize = pmp->header.header_size + c->y_size * (c->x_size * 3 + row_pad);
int file_pad = 0;
odd_bytes = pmp->header.filesize % 4;
if (odd_bytes != 0) {
file_pad = 4 - odd_bytes;
pmp->header.filesize = pmp->header.filesize + file_pad;
}
pmp->data_size = c->y_size * (c->x_size * 3 + row_pad) + file_pad;
if (allocate(pmp->data_size, 0, (void **)&pmp->data) != 0) {
_terminate(-1);
}
cgc_memset(pmp->data, 0, pmp->data_size);
pmp->info.size = sizeof(PMP_Info);
pmp->info.y_size = c->y_size;
pmp->info.x_size = c->x_size;
pmp->info.magic1 = 0x00180001;
pmp->info.reserved1 = 0;
pmp->info.image_size = c->y_size * (c->x_size * 3 + row_pad);
pmp->info.magic2 = 0xb13;
pmp->info.magic3 = 0xb13;
pmp->info.reserved2 = 0;
pmp->info.reserved3 = 0;
char *data = pmp->data;
int x, y;
for (y = c->y_size - 1; y >= 0; y--) {
for (x = 0; x < c->x_size; x++) {
RGB_Color *color = GetColor(c, y, x, 0);
cgc_memcpy(data, color, sizeof(RGB_Color));
data += sizeof(RGB_Color);
}
data += row_pad;
}
return 0;
}
char* strdup(char *s)
{
int sz = 0;
if (s)
{
sz = cgc_strlen(s) + 1;
char *d = malloc(sz);
if (d)
{
cgc_memset(d, 0, sz);
cgc_memcpy(d, s, sz);
return d;
}
}
return NULL;
}
int main() {
int numInstructions;
int recvd;
int i;
pruCPU cpu;
cpu.numExecuted = 0;
cgc_memset(cpu.code, 0xff, 0x4000);
numInstructions = recvInt();
for(i=0;i<numInstructions;i++) {
cpu.code[i] = recvInt();
}
execute(&cpu);
dumpState(&cpu);
_terminate(0);
}
