int main(void) {
sodium_init();
//create a user_store
user_store *store = user_store_create();
//check the content
buffer_t *list = user_store_list(store);
if (list->content_length != 0) {
fprintf(stderr, "ERROR: List of users is not empty.\n");
user_store_destroy(store);
buffer_destroy_from_heap(list);
return EXIT_FAILURE;
}
buffer_destroy_from_heap(list);
int status;
//create three users with prekeys and identity keys
//first alice
//alice identity key
buffer_t *alice_private_identity = buffer_create(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t *alice_public_identity = buffer_create(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
status = generate_and_print_keypair(
alice_public_identity->content,
alice_private_identity->content,
"Alice",
"identity");
if (status != 0) {
fprintf(stderr, "ERROR: Failed to generate Alice's identity keypair.\n");
buffer_clear(alice_private_identity);
return status;
}
//alice prekeys
buffer_t *alice_private_prekeys = buffer_create(PREKEY_AMOUNT * crypto_box_SECRETKEYBYTES, PREKEY_AMOUNT * crypto_box_SECRETKEYBYTES);
buffer_t *alice_public_prekeys = buffer_create(PREKEY_AMOUNT * crypto_box_PUBLICKEYBYTES, PREKEY_AMOUNT * crypto_box_PUBLICKEYBYTES);
status = generate_prekeys(alice_private_prekeys, alice_public_prekeys);
if (status != 0) {
fprintf(stderr, "ERROR: Failed to generate Alice's prekeys.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
return status;
}
//make illegal access to the user store
printf("User store length: %zi\n", store->length); //The program should crash here!
user_store_destroy(store);
return EXIT_SUCCESS;
}
int main(void) {
if (sodium_init() == -1) {
return -1;
}
return_status status = return_status_init();
//create buffers
//alice keys
buffer_t * const alice_public_identity = buffer_create_on_heap(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
buffer_t * const alice_private_identity = buffer_create_on_heap(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t * const alice_public_ephemeral = buffer_create_on_heap(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
buffer_t * const alice_private_ephemeral = buffer_create_on_heap(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t * const alice_shared_secret = buffer_create_on_heap(crypto_generichash_BYTES, crypto_generichash_BYTES);
//bobs keys
buffer_t * const bob_public_identity = buffer_create_on_heap(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
buffer_t * const bob_private_identity = buffer_create_on_heap(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t * const bob_public_ephemeral = buffer_create_on_heap(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
buffer_t * const bob_private_ephemeral = buffer_create_on_heap(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t * const bob_shared_secret = buffer_create_on_heap(crypto_generichash_BYTES, crypto_generichash_BYTES);
printf("Generate Alice's keys -------------------------------------------------------\n\n");
int status_int = 0;
//create Alice's identity keypair
buffer_create_from_string(alice_string, "Alice");
buffer_create_from_string(identity_string, "identity");
status = generate_and_print_keypair(
alice_public_identity,
alice_private_identity,
alice_string,
identity_string);
throw_on_error(KEYGENERATION_FAILED, "Failed to generate and print Alice' identity keypair.");
//create Alice's ephemeral keypair
buffer_create_from_string(ephemeral_string, "ephemeral");
status = generate_and_print_keypair(
alice_public_ephemeral,
alice_private_ephemeral,
alice_string,
ephemeral_string);
throw_on_error(KEYGENERATION_FAILED, "Failed to generate and print Alice' ephemeral keypair.");
printf("Generate Bob's keys ---------------------------------------------------------\n\n");
//create Bob's identity keypair
buffer_create_from_string(bob_string, "Bob");
status = generate_and_print_keypair(
bob_public_identity,
bob_private_identity,
bob_string,
identity_string);
throw_on_error(KEYGENERATION_FAILED, "Failed to generate and print Bob's identity keypair.");
//create Bob's ephemeral keypair
status = generate_and_print_keypair(
bob_public_ephemeral,
bob_private_ephemeral,
bob_string,
ephemeral_string);
throw_on_error(KEYGENERATION_FAILED, "Failed to generate and print Bob's ephemeral keypair.");
printf("Calculate shared secret via Triple Diffie Hellman ---------------------------\n\n");
//Triple Diffie Hellman on Alice's side
status = triple_diffie_hellman(
alice_shared_secret,
alice_private_identity,
alice_public_identity,
alice_private_ephemeral,
alice_public_ephemeral,
bob_public_identity,
bob_public_ephemeral,
true);
buffer_clear(alice_private_identity);
buffer_clear(alice_private_ephemeral);
throw_on_error(KEYGENERATION_FAILED, "Triple Diffie Hellman for Alice failed.");
//print Alice's shared secret
printf("Alice's shared secret H(DH(A_priv,B0_pub)||DH(A0_priv,B_pub)||DH(A0_priv,B0_pub)):\n");
print_hex(alice_shared_secret);
putchar('\n');
//Triple Diffie Hellman on Bob's side
status = triple_diffie_hellman(
bob_shared_secret,
bob_private_identity,
bob_public_identity,
bob_private_ephemeral,
bob_public_ephemeral,
alice_public_identity,
alice_public_ephemeral,
false);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_ephemeral);
throw_on_error(KEYGENERATION_FAILED, "Triple Diffie Hellnan for Bob failed.");
//print Bob's shared secret
printf("Bob's shared secret H(DH(B0_priv, A_pub)||DH(B_priv, A0_pub)||DH(B0_priv, A0_pub)):\n");
print_hex(bob_shared_secret);
putchar('\n');
//compare both shared secrets
status_int = buffer_compare(alice_shared_secret, bob_shared_secret);
buffer_clear(alice_shared_secret);
buffer_clear(bob_shared_secret);
if (status_int != 0) {
throw(INCORRECT_DATA, "Triple Diffie Hellman didn't produce the same shared secret.");
}
printf("Both shared secrets match!\n");
cleanup:
//alice keys
buffer_destroy_from_heap(alice_public_identity);
buffer_destroy_from_heap(alice_private_identity);
buffer_destroy_from_heap(alice_public_ephemeral);
buffer_destroy_from_heap(alice_private_ephemeral);
buffer_destroy_from_heap(alice_shared_secret);
//bobs keys
buffer_destroy_from_heap(bob_public_identity);
buffer_destroy_from_heap(bob_private_identity);
buffer_destroy_from_heap(bob_public_ephemeral);
buffer_destroy_from_heap(bob_private_ephemeral);
buffer_destroy_from_heap(bob_shared_secret);
on_error {
print_errors(&status);
}
return_status_destroy_errors(&status);
return status.status;
}
int main(void) {
sodium_init();
//create a user_store
user_store *store = user_store_create();
//check the content
buffer_t *list = user_store_list(store);
if (list->content_length != 0) {
fprintf(stderr, "ERROR: List of users is not empty.\n");
user_store_destroy(store);
buffer_destroy_from_heap(list);
return EXIT_FAILURE;
}
buffer_destroy_from_heap(list);
int status;
//create three users with prekeys and identity keys
//first alice
//alice identity key
buffer_t *alice_private_identity = buffer_create(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t *alice_public_identity = buffer_create(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
status = generate_and_print_keypair(
alice_public_identity,
alice_private_identity,
buffer_create_from_string("Alice"),
buffer_create_from_string("identity"));
if (status != 0) {
fprintf(stderr, "ERROR: Failed to generate Alice's identity keypair.\n");
buffer_clear(alice_private_identity);
return status;
}
//alice prekeys
buffer_t *alice_private_prekeys = buffer_create(PREKEY_AMOUNT * crypto_box_SECRETKEYBYTES, PREKEY_AMOUNT * crypto_box_SECRETKEYBYTES);
buffer_t *alice_public_prekeys = buffer_create(PREKEY_AMOUNT * crypto_box_PUBLICKEYBYTES, PREKEY_AMOUNT * crypto_box_PUBLICKEYBYTES);
status = generate_prekeys(alice_private_prekeys, alice_public_prekeys);
if (status != 0) {
fprintf(stderr, "ERROR: Failed to generate Alice's prekeys.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
return status;
}
//then bob
//bob's identity key
buffer_t *bob_private_identity = buffer_create(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t *bob_public_identity = buffer_create(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
status = generate_and_print_keypair(
bob_public_identity,
bob_private_identity,
buffer_create_from_string("Bob"),
buffer_create_from_string("identity"));
if (status != 0) {
fprintf(stderr, "ERROR: Failed to generate Bob's identity keypair.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
return status;
}
//bob's prekeys
buffer_t *bob_private_prekeys = buffer_create(PREKEY_AMOUNT * crypto_box_SECRETKEYBYTES, PREKEY_AMOUNT * crypto_box_SECRETKEYBYTES);
buffer_t *bob_public_prekeys = buffer_create(PREKEY_AMOUNT * crypto_box_PUBLICKEYBYTES, PREKEY_AMOUNT * crypto_box_PUBLICKEYBYTES);
status = generate_prekeys(bob_private_prekeys, bob_public_prekeys);
if (status != 0) {
fprintf(stderr, "ERROR: Failed to generate Bob's prekeys.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
return status;
}
//then charlie
//charlie's identity key
buffer_t *charlie_private_identity = buffer_create(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t *charlie_public_identity = buffer_create(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
status = generate_and_print_keypair(
charlie_public_identity,
charlie_private_identity,
buffer_create_from_string("Charlie"),
buffer_create_from_string("identity"));
if (status != 0) {
fprintf(stderr, "ERROR: Failed to generate Charlie's identity keypair.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
return status;
}
//charlie's prekeys
buffer_t *charlie_private_prekeys = buffer_create(PREKEY_AMOUNT * crypto_box_SECRETKEYBYTES, PREKEY_AMOUNT * crypto_box_SECRETKEYBYTES);
buffer_t *charlie_public_prekeys = buffer_create(PREKEY_AMOUNT * crypto_box_PUBLICKEYBYTES, PREKEY_AMOUNT * crypto_box_PUBLICKEYBYTES);
status = generate_prekeys(charlie_private_prekeys, charlie_public_prekeys);
if (status != 0) {
fprintf(stderr, "ERROR: Failed to generate Charlie's prekeys.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
return status;
}
//add alice to the user store
status = user_store_add(
store,
alice_public_identity,
alice_private_identity,
alice_public_prekeys,
alice_private_prekeys);
if (status != 0) {
fprintf(stderr, "ERROR: Failed to add Alice to the user store.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return status;
}
printf("Successfully added Alice to the user store.\n");
//check length of the user store
sodium_mprotect_readonly(store);
if (store->length != 1) {
fprintf(stderr, "ERROR: User store has incorrect length.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return EXIT_FAILURE;
}
sodium_mprotect_noaccess(store);
printf("Length of the user store matches.");
//list user store
list = user_store_list(store);
if (buffer_compare(list, alice_public_identity) != 0) {
fprintf(stderr, "ERROR: Failed to list users.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
buffer_destroy_from_heap(list);
user_store_destroy(store);
return EXIT_FAILURE;
}
buffer_destroy_from_heap(list);
printf("Successfully listed users.\n");
//add bob to the user store
status = user_store_add(
store,
bob_public_identity,
bob_private_identity,
bob_public_prekeys,
bob_private_prekeys);
if (status != 0) {
fprintf(stderr, "ERROR: Failed to add Bob to the user store.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return status;
}
printf("Successfully added Bob to the user store.\n");
//check length of the user store
sodium_mprotect_readonly(store);
if (store->length != 2) {
fprintf(stderr, "ERROR: User store has incorrect length.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return EXIT_FAILURE;
}
sodium_mprotect_noaccess(store);
printf("Length of the user store matches.");
//list user store
list = user_store_list(store);
if ((buffer_compare_partial(list, 0, alice_public_identity, 0, crypto_box_PUBLICKEYBYTES) != 0)
|| (buffer_compare_partial(list, crypto_box_PUBLICKEYBYTES, bob_public_identity, 0, crypto_box_PUBLICKEYBYTES) != 0)) {
fprintf(stderr, "ERROR: Failed to list users.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
buffer_destroy_from_heap(list);
user_store_destroy(store);
return EXIT_FAILURE;
}
buffer_destroy_from_heap(list);
printf("Successfully listed users.\n");
//add charlie to the user store
status = user_store_add(
store,
charlie_public_identity,
charlie_private_identity,
charlie_public_prekeys,
charlie_private_prekeys);
if (status != 0) {
fprintf(stderr, "ERROR: Failed to add Charlie to the user store.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return status;
}
printf("Successfully added Charlie to the user store.\n");
//check length of the user store
sodium_mprotect_readonly(store);
if (store->length != 3) {
fprintf(stderr, "ERROR: User store has incorrect length.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return EXIT_FAILURE;
}
sodium_mprotect_noaccess(store);
printf("Length of the user store matches.");
//list user store
list = user_store_list(store);
if ((buffer_compare_partial(list, 0, alice_public_identity, 0, crypto_box_PUBLICKEYBYTES) != 0)
|| (buffer_compare_partial(list, crypto_box_PUBLICKEYBYTES, bob_public_identity, 0, crypto_box_PUBLICKEYBYTES) != 0)
|| (buffer_compare_partial(list, 2 * crypto_box_PUBLICKEYBYTES, charlie_public_identity, 0, crypto_box_PUBLICKEYBYTES) != 0)) {
fprintf(stderr, "ERROR: Failed to list users.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
buffer_destroy_from_heap(list);
user_store_destroy(store);
return EXIT_FAILURE;
}
buffer_destroy_from_heap(list);
printf("Successfully listed users.\n");
//find node
user_store_node *bob_node = user_store_find_node(store, bob_public_identity);
if (bob_node == NULL) {
fprintf(stderr, "ERROR: Failed to find Bob's node.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return EXIT_FAILURE;
}
printf("Node found.\n");
sodium_mprotect_readonly(bob_node);
if ((buffer_compare(&(bob_node->public_identity_key), bob_public_identity) != 0)
|| (buffer_compare(&(bob_node->private_identity_key), bob_private_identity) != 0)
|| (buffer_compare(&(bob_node->public_prekeys), bob_public_prekeys) != 0)
|| (buffer_compare(&(bob_node->private_prekeys), bob_private_prekeys) != 0)) {
fprintf(stderr, "ERROR: Bob's data from the user store doesn't match.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return EXIT_FAILURE;
}
sodium_mprotect_noaccess(bob_node);
printf("Data from the node matches.\n");
//remove a user identified by it's key
user_store_remove_by_key(store, bob_public_identity);
//check the length
sodium_mprotect_readonly(store);
if (store->length != 2) {
fprintf(stderr, "ERROR: User store has incorrect length.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return EXIT_FAILURE;
}
sodium_mprotect_noaccess(store);
printf("Length of the user store matches.");
//check the user list
list = user_store_list(store);
if ((buffer_compare_partial(list, 0, alice_public_identity, 0, crypto_box_PUBLICKEYBYTES) != 0)
|| (buffer_compare_partial(list, crypto_box_PUBLICKEYBYTES, charlie_public_identity, 0, crypto_box_PUBLICKEYBYTES) != 0)) {
fprintf(stderr, "ERROR: Removing user failed.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
buffer_destroy_from_heap(list);
return EXIT_FAILURE;
}
buffer_destroy_from_heap(list);
printf("Successfully removed user.\n");
//readd bob
status = user_store_add(
store,
bob_public_identity,
bob_private_identity,
bob_public_prekeys,
bob_private_prekeys);
if (status != 0) {
fprintf(stderr, "ERROR: Failed to readd Bob to the user store.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return status;
}
printf("Successfully readded Bob to the user store.\n");
//now find bob again
bob_node = user_store_find_node(store, bob_public_identity);
if (bob_node == NULL) {
fprintf(stderr, "ERROR: Failed to find Bob's node.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return EXIT_FAILURE;
}
printf("Bob's node found again.\n");
//remove bob by it's node
user_store_remove(store, bob_node);
//check the length
sodium_mprotect_readonly(store);
if (store->length != 2) {
fprintf(stderr, "ERROR: User store has incorrect length.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
return EXIT_FAILURE;
}
sodium_mprotect_noaccess(store);
printf("Length of the user store matches.");
//check the user list
list = user_store_list(store);
if ((buffer_compare_partial(list, 0, alice_public_identity, 0, crypto_box_PUBLICKEYBYTES) != 0)
|| (buffer_compare_partial(list, crypto_box_PUBLICKEYBYTES, charlie_public_identity, 0, crypto_box_PUBLICKEYBYTES) != 0)) {
fprintf(stderr, "ERROR: Removing user failed.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
user_store_destroy(store);
buffer_destroy_from_heap(list);
return EXIT_FAILURE;
}
buffer_destroy_from_heap(list);
printf("Successfully removed user.\n");
buffer_clear(alice_private_identity);
buffer_clear(alice_private_prekeys);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_prekeys);
buffer_clear(charlie_private_identity);
buffer_clear(charlie_private_prekeys);
//clear the user store
user_store_clear(store);
//check the length
sodium_mprotect_readonly(store);
if (store->length != 0) {
fprintf(stderr, "ERROR: User store has incorrect length.\n");
user_store_destroy(store);
return EXIT_FAILURE;
}
printf("Successfully cleared user store.\n");
sodium_mprotect_noaccess(store);
user_store_destroy(store);
return EXIT_SUCCESS;
}
/* Create a bunch of objects as demonstration. */
int create_objects(FILE *output_file) {
/* declare a few. */
mcJSON *root;
mcJSON *fmt;
mcJSON *img;
mcJSON *thm;
mcJSON *fld;
int i;
/* Our "days of the week" array: */
buffer_create_from_string(sunday, "Sunday");
buffer_create_from_string(monday, "Monday");
buffer_create_from_string(tuesday, "Tuesday");
buffer_create_from_string(wednesday, "Wednesday");
buffer_create_from_string(thursday, "Thursday");
buffer_create_from_string(friday, "Friday");
buffer_create_from_string(saturday, "Saturday");
buffer_t *strings[7] = {
sunday,
monday,
tuesday,
wednesday,
thursday,
friday,
saturday
};
/* Our matrix: */
int numbers[3][3] = {{0, -1, 0}, {1, 0, 0}, {0, 0, 1}};
/* Our "gallery" item: */
int ids[4] = {116, 943, 234, 38793};
/* Our array of "records": */
buffer_create_from_string(zip_buffer, "zip");
buffer_create_from_string(empty_string_buffer, "");
buffer_create_from_string(san_francisco_buffer, "SAN FRANCISCO");
buffer_create_from_string(ca_buffer, "CA");
buffer_create_from_string(zip_number, "94107");
buffer_create_from_string(us_buffer, "US");
buffer_create_from_string(sunnyvale_buffer, "SUNNYVALE");
buffer_create_from_string(zip_number2, "94085");
struct record fields[2] = {
{
zip_buffer,
37.7668,
-1.223959e+2,
empty_string_buffer,
san_francisco_buffer,
ca_buffer,
zip_number,
us_buffer
},
{
zip_buffer,
37.371991,
-1.22026e+2,
empty_string_buffer,
sunnyvale_buffer,
ca_buffer,
zip_number2,
us_buffer
}
};
/* Here we construct some JSON standards, from the JSON site. */
/* Our "Video" datatype: */
root = mcJSON_CreateObject(NULL);
buffer_create_from_string(jack_buffer, "Jack (\"Bee\") Nimble");
buffer_create_from_string(name_buffer, "name");
mcJSON_AddItemToObject(root, name_buffer, mcJSON_CreateString(jack_buffer, NULL), NULL);
buffer_create_from_string(format_buffer, "format");
mcJSON_AddItemToObject(root, format_buffer, fmt=mcJSON_CreateObject(NULL), NULL);
buffer_create_from_string(rect_buffer, "rect");
buffer_create_from_string(type_buffer, "type");
mcJSON_AddStringToObject(fmt, type_buffer, rect_buffer, NULL);
buffer_create_from_string(width_buffer, "width");
mcJSON_AddNumberToObject(fmt, width_buffer, 1920, NULL);
buffer_create_from_string(height_buffer, "height");
mcJSON_AddNumberToObject(fmt, height_buffer, 1080, NULL);
buffer_create_from_string(interlace, "interlace");
mcJSON_AddFalseToObject (fmt, interlace, NULL);
buffer_create_from_string(fps_buffer, "frame rate");
mcJSON_AddNumberToObject(fmt, fps_buffer, 24, NULL);
buffer_t *output = NULL;
/* Print to text, Delete the mcJSON, print it, release the string. */
output = mcJSON_Print(root);
mcJSON_Delete(root);
if (output == NULL) {
return EXIT_FAILURE;
}
printf("%.*s\n", (int) output->content_length, (char*)output->content);
if (output_file != NULL) {
fprintf(output_file, "%.*s\n", (int)output->content_length, (char*)output->content);
}
buffer_destroy_from_heap(output);
/* Our "days of the week" array: */
root = mcJSON_CreateStringArray((const buffer_t **)strings, 7, NULL);
output = mcJSON_Print(root);
mcJSON_Delete(root);
if (output == NULL) {
return EXIT_FAILURE;
}
printf("%.*s\n", (int)output->content_length, (char*)output->content);
if (output_file != NULL) {
fprintf(output_file, "%.*s\n", (int)output->content_length, (char*)output->content);
}
buffer_destroy_from_heap(output);
/* Our matrix: */
root = mcJSON_CreateArray(NULL);
for (i = 0; i < 3; i++) {
mcJSON_AddItemToArray(root, mcJSON_CreateIntArray(numbers[i], 3, NULL), NULL);
}
/*mcJSON_ReplaceItemInArray(root,1,mcJSON_CreateString("Replacement")); */
output = mcJSON_Print(root);
mcJSON_Delete(root);
if (output == NULL) {
return EXIT_FAILURE;
}
printf("%.*s\n", (int)output->content_length, (char*)output->content);
if (output_file != NULL) {
fprintf(output_file, "%.*s\n", (int)output->content_length, (char*)output->content);
}
buffer_destroy_from_heap(output);
/* Our "gallery" item: */
root = mcJSON_CreateObject(NULL);
buffer_create_from_string(image_buffer, "Image");
mcJSON_AddItemToObject(root, image_buffer, img = mcJSON_CreateObject(NULL), NULL);
buffer_create_from_string(Width_buffer, "Width");
mcJSON_AddNumberToObject(img, Width_buffer, 800, NULL);
buffer_create_from_string(Height_buffer, "Height");
mcJSON_AddNumberToObject(img, Height_buffer, 600, NULL);
buffer_create_from_string(title_buffer, "Title");
buffer_create_from_string(view_buffer, "View from 15th Floor");
mcJSON_AddStringToObject(img, title_buffer, view_buffer, NULL);
buffer_create_from_string(thumbnail_buffer, "Thumbnail");
mcJSON_AddItemToObject(img, thumbnail_buffer, thm = mcJSON_CreateObject(NULL), NULL);
buffer_create_from_string(url_buffer, "Url");
buffer_create_from_string(url, "http:/*www.example.com/image/481989943");
mcJSON_AddStringToObject(thm, url_buffer, url, NULL);
mcJSON_AddNumberToObject(thm, Height_buffer, 125, NULL);
buffer_create_from_string(hundred_buffer, "100");
mcJSON_AddStringToObject(thm, Width_buffer, hundred_buffer, NULL);
buffer_create_from_string(ids_buffer, "IDs");
mcJSON_AddItemToObject(img, ids_buffer, mcJSON_CreateIntArray(ids, 4, NULL), NULL);
output = mcJSON_Print(root);
mcJSON_Delete(root);
if (output == NULL) {
return EXIT_FAILURE;
}
printf("%.*s\n", (int)output->content_length, (char*)output->content);
if (output_file != NULL) {
fprintf(output_file, "%.*s\n", (int)output->content_length, (char*)output->content);
}
buffer_destroy_from_heap(output);
/* Our array of "records": */
root = mcJSON_CreateArray(NULL);
for (i = 0; i < 2; i++) {
mcJSON_AddItemToArray(root, fld = mcJSON_CreateObject(NULL), NULL);
buffer_create_from_string(precision_buffer, "precision");
mcJSON_AddStringToObject(fld, precision_buffer, fields[i].precision, NULL);
buffer_create_from_string(latitude_buffer, "Latitude");
mcJSON_AddNumberToObject(fld, latitude_buffer, fields[i].lat, NULL);
buffer_create_from_string(longitude_buffer, "Longitude");
mcJSON_AddNumberToObject(fld, longitude_buffer, fields[i].lon, NULL);
buffer_create_from_string(address_buffer, "Address");
mcJSON_AddStringToObject(fld, address_buffer, fields[i].address, NULL);
buffer_create_from_string(city_buffer, "City");
mcJSON_AddStringToObject(fld, city_buffer, fields[i].city, NULL);
buffer_create_from_string(state_buffer, "State");
mcJSON_AddStringToObject(fld, state_buffer, fields[i].state, NULL);
buffer_create_from_string(zip_buffer, "Zip");
mcJSON_AddStringToObject(fld, zip_buffer, fields[i].zip, NULL);
buffer_create_from_string(country_buffer, "Country");
mcJSON_AddStringToObject(fld, country_buffer, fields[i].country, NULL);
}
/* mcJSON_ReplaceItemInObject(mcJSON_GetArrayItem(root,1),"City",mcJSON_CreateIntArray(ids,4,NULL)); */
output = mcJSON_Print(root);
mcJSON_Delete(root);
if (output == NULL) {
return EXIT_FAILURE;
}
printf("%.*s\n", (int)output->content_length, (char*)output->content);
if (output_file != NULL) {
fprintf(output_file, "%.*s\n", (int)output->content_length, (char*)output->content);
}
buffer_destroy_from_heap(output);
root = mcJSON_CreateObject(NULL);
buffer_create_from_string(number_buffer, "number");
mcJSON_AddNumberToObject(root, number_buffer, INFINITY, NULL);
output = mcJSON_Print(root);
mcJSON_Delete(root);
if (output == NULL) {
return EXIT_FAILURE;
}
printf("%.*s\n", (int)output->content_length, (char*)output->content);
if (output_file != NULL) {
fprintf(output_file, "%.*s\n", (int)output->content_length, (char*)output->content);
}
buffer_destroy_from_heap(output);
/* Check mcJSON_GetObjectItem and make sure it's case sensitive */
root = mcJSON_CreateObject(NULL);
buffer_create_from_string(a_buffer, "a");
mcJSON_AddNumberToObject(root, a_buffer, 1, NULL);
buffer_create_from_string(A_buffer, "A");
mcJSON_AddNumberToObject(root, A_buffer, 2, NULL);
output = mcJSON_Print(root);
if (output == NULL) {
mcJSON_Delete(root);
return EXIT_FAILURE;
}
printf("%.*s\n", (int)output->content_length, (char*)output->content);
if (output_file != NULL) {
fprintf(output_file, "%.*s\n", (int)output->content_length, (char*)output->content);
}
buffer_destroy_from_heap(output);
mcJSON *one = mcJSON_GetObjectItem(root, a_buffer);
mcJSON *two = mcJSON_GetObjectItem(root, A_buffer);
if ((one == NULL) || (one->valueint != 1)
|| (two == NULL) || (two->valueint != 2)) {
fprintf(stderr, "ERROR: Failed to get item from object.\n");
return EXIT_FAILURE;
}
mcJSON_Delete(root);
/* test creation of hex strings */
buffer_create_from_string(newline_buffer, "\r\n");
root = mcJSON_CreateHexString(newline_buffer, NULL);
if (root == NULL) {
return EXIT_FAILURE;
}
output = mcJSON_Print(root);
if (output == NULL) {
mcJSON_Delete(root);
return EXIT_FAILURE;
}
/* TODO: Make function that does this! */
printf("%.*s\n", (int)output->content_length, (char*)output->content);
if (output_file != NULL) {
fprintf(output_file, "%.*s\n", (int)output->content_length, (char*)output->content);
}
buffer_destroy_from_heap(output);
mcJSON_Delete(root);
return 0;
}