{"id":3896,"date":"2019-12-21T00:01:56","date_gmt":"2019-12-21T08:01:56","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=3896"},"modified":"2019-12-14T10:23:39","modified_gmt":"2019-12-14T18:23:39","slug":"decoding-the-strlcat-function","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=3896","title":{"rendered":"Decoding the strlcat()<\/em> Function"},"content":{"rendered":"

The strlcat()<\/em> function (with the L) achieves the same goal as the venerable strcat()<\/em> function: to append one string onto the end of the other. The problem with strcat()<\/em>, however, is that a size limitation isn’t set for the destination buffer. It’s quite possible for this buffer to overflow.
\n
\nAs a solution, the strlcat()<\/em> function offers an additional argument, dstsize<\/code>. This argument sets the length of the destination string, effectively equal to its buffer size. Here’s the function’s prototype:<\/p>\n

size_t strlcat(char * restrict dst, const char * restrict src, size_t dstsize);<\/code><\/p>\n

Characters from string src<\/code> are appended to string dst<\/code>. The dstsize<\/code> argument is equal to the size of the dst<\/code> buffer, which caps the number of characters copied to this size, minus one for the null character. Here’s the awkward way the man<\/em> page puts it:<\/p>\n

strlcat()<\/strong> appends string src to the end of dst<\/span>. It will append at most dstsize<\/span> – strlen(dst) – 1 characters. It will then NUL-terminate, unless dstsize<\/span> is 0 or the original dst<\/span> string was longer than dstsize<\/span> (in practice this should not happen as it means that either dstsize<\/span> is incorrect or that dst<\/span> is not a proper string).<\/p><\/blockquote>\n

Ugh. Again, argument dstsize<\/code> must be equal to the size of the dst<\/code> buffer. That’s the only value it can be.<\/p>\n

The strlcat()<\/em> function returns the combined length of both src<\/code> and dst<\/code> strings (not counting their terminating null characters). This result is used to determine whether the final string was truncated. Here’s sample code:<\/p>\n

\r\n#include <stdio.h>\r\n#include <string.h>\r\n\r\nint main()\r\n{\r\n    char first[] = \"This is \";\r\n    char last[] = \"a potentially long string\";\r\n    int r;\r\n    int size = 16;\r\n    char buffer[size];\r\n\r\n    strcpy(buffer,first);\r\n    r = strlcat(buffer,last,size);\r\n\r\n    puts(buffer);\r\n    printf(\"Value returned: %d\\n\",r);\r\n    if( r > size )\r\n        puts(\"String truncated\");\r\n    else\r\n        puts(\"String was fully copied\");\r\n\r\n    return(0);\r\n}<\/pre>\n
The strlcat()<\/em> function at Line 13 appends string last<\/code> to string first<\/code>, which has been copied into char<\/em> array buffer[]<\/code>. The size of the buffer[]<\/code> array is set to 16, which is too short to accommodate the entire last<\/code> string. Yet, because the same value, 16, is specified in the strlcat()<\/em> function, a buffer overflow doesn’t occur.<\/p>\n
A test is made at Line 17 comparing values r<\/code> (returned from strlcat()<\/em>) and size<\/code> to determine whether the string was truncated.<\/p>\n
Here’s sample output:<\/p>\n
This is a poten
\nValue returned: 33
\nString truncated<\/code><\/p>\n
The value returned (33) is equal to the size of both original strings, first<\/code> and last<\/code>. It’s the strlen()<\/em> value, not the strings’ size in memory, which would include two more bytes for the two null characters at the end of each string.<\/p>\n
If you modify Line 9 to change the size<\/code> variable (and buffer size) to 64, the buffer is now large enough to accommodate the concatenated strings. Here’s the updated output:<\/p>\n
This is a potentially long string
\nValue returned: 33
\nString was fully copied<\/code><\/p>\n
Armed with all this data, it becomes a simpler task for me to craft my own, substitute strlcat()<\/em> function. I present this solution in next week’s Lesson.<\/p>\n","protected":false},"excerpt":{"rendered":"
The strlcat()<\/em> function’s return values must be deciphered before I attempt to code my own version. 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-3896","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\/3896","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=3896"}],"version-history":[{"count":6,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/3896\/revisions"}],"predecessor-version":[{"id":3911,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/3896\/revisions\/3911"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=3896"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=3896"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=3896"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}