{"id":3833,"date":"2019-11-16T00:01:33","date_gmt":"2019-11-16T08:01:33","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=3833"},"modified":"2019-11-09T11:01:33","modified_gmt":"2019-11-09T19:01:33","slug":"deviously-playing-with-memory","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=3833","title":{"rendered":"Deviously Playing with Memory"},"content":{"rendered":"

When a buffer is void<\/em>, its contents are treated as raw memory, not assigned to any specific data type. This ambiguity means your code can cast the memory’s data type and do interesting things with it.
\n
\nTo get data into a void<\/em> buffer, use the memcpy()<\/em> function, which was introduced in last week’s Lesson<\/a>.<\/p>\n

For example, say buffer<\/code> is a void<\/em> pointer: void *buffer<\/code>. The malloc()<\/em> function allocates storage as void<\/em> by default, so you can easily set aside a memory chunk and assign it to buffer easy-peasy:<\/p>\n

buffer = malloc( sizeof(struct person) );<\/code><\/p>\n

To access the contents of void<\/em> buffer<\/code>, however, it’s best to use a specific data type. For example, create an unsigned char<\/em> pointer bufchar<\/code>. Assign its address to the void<\/em> buffer<\/code> pointer:<\/p>\n

bufchar = buffer;<\/code><\/p>\n

At this point, you can use the bufchar<\/code> pointer to peer into memory, viewing the byte values directly, which is what I’ve done in the following code:<\/p>\n

\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\nint main()\r\n{\r\n    struct person {\r\n        int age;\r\n        char name[12];\r\n    } man = { 34, \"George\" };\r\n    void *buffer;\r\n    unsigned char *bufchar;\r\n    int x;\r\n\r\n    \/* output the structure *\/<\/span>\r\n    printf(\"%s is %d years old\\n\",man.name,man.age);\r\n\r\n    \/* allocate the void buffer *\/<\/span>\r\n    buffer = malloc( sizeof(struct person) );\r\n    if( buffer==NULL )\r\n    {\r\n        fprintf(stderr,\"Unable to allocate memory\\n\");\r\n        exit(1);\r\n    }\r\n\r\n    \/* copy memory *\/<\/span>\r\n    memcpy(buffer,&man,sizeof(struct person));\r\n    \r\n    \/* dump the buffer *\/<\/span>\r\n    puts(\"Buffer dump:\");\r\n        \/* reference (void)buffer as (char)bufchar *\/<\/span>\r\n    bufchar = buffer;\r\n    for( x=0; x<(int)sizeof(struct person); x++ )\r\n    {\r\n        printf(\" %02X\",*(bufchar+x));\r\n    }\r\n    putchar('\\n');\r\n\r\n    return(0);\r\n}<\/pre>\n
The person<\/em> structure man<\/code> is copied into the void<\/em> buffer<\/code> at Line 27. At Line 32, unsigned char<\/em> pointer bufchar<\/code> is assigned the same address as buffer<\/code>. The contents of buffer<\/code> are then dumped as unsigned char<\/em> hexadecimal digits, effectively peering into buffer<\/code> at a raw-byte level. Here’s the output:<\/p>\n
George is 34 years old
\nBuffer dump:
\n 22 00 00 00 47 65 6F 72 67 65 00 00 00 00 00 00<\/code><\/p>\n
The buffer<\/code> consists of two members: The first four bytes are the integer member age<\/em>, the next 12 bytes store the name<\/em> string, “George,” which occupies only the first seven bytes of this storage. This allocation is illustrated in Figure 1.<\/p>\n
\"\"
Figure 1. Memory allocation for the person<\/em> structure variable man<\/code>, shown as unsigned char<\/em> hex values.<\/p><\/div>\n
Because the data types and their offsets within the void<\/em> buffer<\/code> are known, you can access them directly. To access the integer portion, an int<\/em> pointer bufint<\/code> can be used. This pointer would be initialized to the start of buffer<\/code>, which is where the integer value dwells:<\/p>\n
bufint = (int)buffer;<\/code><\/p>\n
You can re-use the bufchar<\/code> pointer to access the string. Its location is at offset 4 (the fifth byte) in buffer<\/code>:<\/p>\n
bufchar = (char *)buffer+4;<\/code><\/p>\n
The final part of this code update shows the modifications:<\/p>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\nint main()\r\n{\r\n    struct person {\r\n        int age;\r\n        char name[12];\r\n    } man = { 34, \"George\" };\r\n    void *buffer;\r\n    int *bufint;\r\n    char *bufchar;\r\n    int x;\r\n\r\n    \/* output the structure *\/<\/span>\r\n    printf(\"%s is %d years old\\n\",man.name,man.age);\r\n\r\n    \/* allocate the void buffer *\/<\/span>\r\n    buffer = malloc( sizeof(struct person) );\r\n    if( buffer==NULL )\r\n    {\r\n        fprintf(stderr,\"Unable to allocate memory\\n\");\r\n        exit(1);\r\n    }\r\n\r\n    \/* copy memory *\/<\/span>\r\n    memcpy(buffer,&man,sizeof(struct person));\r\n    \r\n    \/* dump the buffer *\/<\/span>\r\n    puts(\"Buffer dump:\");\r\n        \/* reference (void)buffer as (char)bufchar *\/<\/span>\r\n    bufchar = buffer;\r\n    for( x=0; x<(int)sizeof(struct person); x++ )\r\n    {\r\n        printf(\" %02X\",*(bufchar+x));\r\n    }\r\n    putchar('\\n');\r\n\r\n    \/* sneak into the buffer *\/<\/span>\r\n        \/* reference (void)buffer as (int)bufint *\/<\/span>\r\n    bufint = (int *)buffer;\r\n        \/* reference (void)buffer (offset 4) as (char)bufchar *\/<\/span>\r\n    bufchar = (char *)buffer+4;\r\n        \/* data can now be accessed directly *\/<\/span>\r\n    printf(\"Int portion: %d\\n\",*(bufint));\r\n    printf(\"String portion: %s\\n\",bufchar);\r\n\r\n    return(0);\r\n}<\/pre>\n
And here’s the output:<\/p>\n
George is 34 years old
\nBuffer dump:
\n 22 00 00 00 47 65 6F 72 67 65 00 00 00 00 00 00
\nInt portion: 34
\nString portion: George<\/code><\/p>\n
Because the memcpy()<\/em> function duplicates the structure into a void<\/em> buffer, other pointers of specific data types can access the void<\/em> data, interpreting it accordingly.<\/p>\n
This type of memory manipulation isn’t without risk: Accessing unknown (void<\/em>) buffers with any old data type can lead to unpredictable results. Ensure that you know the data you’re accessing and, should you want to manipulate it, that your actions result in safe and secure coding practices.<\/p>\n","protected":false},"excerpt":{"rendered":"
Using the memcpy()<\/em> function and playing with pointer data types allows you to examine raw memory in your code. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-3833","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/3833","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=3833"}],"version-history":[{"count":8,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/3833\/revisions"}],"predecessor-version":[{"id":3859,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/3833\/revisions\/3859"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=3833"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=3833"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=3833"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}