{"id":2801,"date":"2017-12-02T00:01:51","date_gmt":"2017-12-02T08:01:51","guid":{"rendered":"http:\/\/c-for-dummies.com\/blog\/?p=2801"},"modified":"2017-12-09T08:07:03","modified_gmt":"2017-12-09T16:07:03","slug":"safe-coding-practices-string-handling-2","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=2801","title":{"rendered":"Safe Coding Practices – String Handling 2"},"content":{"rendered":"

As with the strcpy()<\/em> function, covered in last week’s Lesson<\/a>, you run a risk of buffer overflow with strcat()<\/em>. The compiler doesn’t check for an overflow; to ensure that you’re practicing safe coding habits<\/a>, that task is up to you.
\n
\nThe strcat()<\/em> function sticks one string onto the end of another, a concatenation<\/em> in geek-speak. You must ensure that enough room is available in the first string’s buffer to handle the length of the second string.<\/p>\n

I could show you the bad example first, instead the following code demonstrates one effective way to handle concatenation that ensures the buffers don’t overflow.<\/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    char input[32];\r\n    char *result;\r\n\r\n    \/* get first string *\/<\/span>\r\n    printf(\"Secret code: \");\r\n    fgets(input,32,stdin);\r\n\r\n    \/* create buffer and copy *\/<\/span>\r\n    result = (char *)malloc( strlen(input) + 1);\r\n    if(!result)\r\n    {\r\n        puts(\"Memory allocation error\");\r\n        exit(1);\r\n    }\r\n    strcpy(result,input);\r\n\r\n    \/* get second string *\/<\/span>\r\n    printf(\"Confirmation: \");\r\n    fgets(input,32,stdin);\r\n\r\n    \/* append to buffer *\/<\/span>\r\n    result = (char *)realloc(result,strlen(result)+strlen(input)+1);\r\n    if(!result)\r\n    {\r\n        puts(\"Memory allocation error\");\r\n        exit(1);\r\n    }\r\n    strcat(result,input);\r\n\r\n    printf(\"Resulting string below\\n%s\\n\",\r\n            result);\r\n\r\n    return(0);\r\n}<\/pre>\n
The first safe coding practice is to use the fgets()<\/em> function to fetch the string. The size<\/em> argument in fgets()<\/em> is identical to the input[]<\/code> buffer size; fgets()<\/em> stops input at one less than its size value or whenever a newline ('\\n'<\/code>) or EOF<\/code> is encountered.<\/p>\n
At Line 15, the malloc()<\/em> function allocates enough storage for the string input<\/code>. Upon success, that location is assigned to the result<\/code> pointer. The string is then copied from the input<\/code> buffer to the result<\/code> buffer at Line 21.<\/p>\n
Line 25 uses the input<\/code> buffer again to fetch the second string. This approach is valid as any new content replaces the existing content in the input<\/code> buffer; if nothing is input, the buffer holds a single null character ('\\0'<\/code>).<\/p>\n
At Line 28, the realloc()<\/em> function attempts to resize the result<\/code> buffer. The new size is calculated based on the length of the string currently in the result<\/code> buffer, plus the new string in the input<\/code> buffer, plus one for a null character. Upon success, the strcat()<\/em> function (Line 34) appends the string in input<\/code> to the string in result<\/code>.<\/p>\n
Whether you use malloc()<\/em> or realloc()<\/em> any of the other applicable *alloc()<\/em> functions, the goal is the same: Ensure that the buffer has adequate storage to handle all characters in the final string. That way, you don’t risk a buffer overflow when using the strcat()<\/em> function. You must, however, use a buffer to collect input, which is the input[]<\/code> array in this example.<\/p>\n
If you’re dealing with string constants in your code, or you know the maximum allowed storage for a string, you can use static buffer sizes that provide plenty of wiggle room. That’s okay, assuming that you monitor the strings’ lengths diligently, but if you’re truly after safe coding practices, allocate the storage as the program runs.
\nNext week’s Lesson<\/a> covers a third aspect of string booboos, which are manually-created strings that lack a termination character.<\/p>\n","protected":false},"excerpt":{"rendered":"
Buffer overflow occurs magically when working with strings, unless you’re very careful. 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-2801","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\/2801","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=2801"}],"version-history":[{"count":6,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2801\/revisions"}],"predecessor-version":[{"id":2868,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2801\/revisions\/2868"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=2801"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=2801"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=2801"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}