{"id":3873,"date":"2019-12-07T00:01:09","date_gmt":"2019-12-07T08:01:09","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=3873"},"modified":"2019-12-14T08:39:19","modified_gmt":"2019-12-14T16:39:19","slug":"non-standard-function-strlcpy","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=3873","title":{"rendered":"Non-Standard Function: strlcpy()<\/em>"},"content":{"rendered":"

I though writing a substitute strlcpy()<\/em> function would be easy. Boy was I wrong!
\n
\nFirst, a look at the strlcpy()<\/em> function’s prototype:<\/p>\n

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

For comparison, here is the man<\/em> page definition for the strcpy()<\/em> function:<\/p>\n

char * stpcpy(char * dst, const char * src);<\/code><\/p>\n

In both functions, the contents of string src<\/code> are copied into buffer dst<\/code>. With the strlcpy()<\/em> function, however, only dstsize<\/code> characters maximum are copied, and the value returned is the size of string src<\/code>. (The value returned is always the size of string src<\/code> regardless of how many characters are copied.)<\/p>\n

Oh, and the nerds argue over whether the value returned is really a size_t<\/em> value or an int<\/em>. Nerds.<\/p>\n

My first attempt was simple enough: Copy up to dstsize<\/code> characters from src<\/code> to dst<\/code>, terminating the operation when the null character is found in string dst<\/code> or the value of dstsize<\/code> was reached. Easy.<\/p>\n

But.<\/p>\n

The code seemed to run too well. Plus I had concerns about the function’s return value. So I wisely decided to run a control program first, just to monitor the behavior of the real strlcpy()<\/em> function. Here is the code:<\/p>\n

\r\n#include <stdio.h>\r\n#include <string.h>\r\n\r\nvoid test(int size)\r\n{\r\n    char string[] = \"Hello there, Venus\";\r\n    char buffer[19];\r\n    int r;\r\n\r\n    r = strlcpy(buffer,string,size);\r\n\r\n    printf(\"Copied '%s' into '%s', length %d\\n\",\r\n            string,\r\n            buffer,\r\n            r\r\n          );\r\n}\r\n\r\nint main()\r\n{\r\n    test(19);\r\n    test(10);\r\n    test(1);\r\n    test(0);\r\n\r\n    return(0);\r\n}<\/pre>\n
The main()<\/em> function runs four tests, each with a different value for the number of characters to copy. In the test()<\/em> function, array string[<\/code>] is copied up to size<\/code> characters into buffer<\/code>. Output generated offers the original string, the copy, and the value returned by the strlcpy()<\/em> function. These are all valid data points I must know if I am to properly reverse engineer the function. Here’s the test run;<\/p>\n
Copied 19 characters from 'Hello there, Venus' into 'Hello there, Venus', length 18
\nCopied 10 characters from 'Hello there, Venus' into 'Hello the', length 18
\nCopied 1 characters from 'Hello there, Venus' into '', length 18
\nCopied 0 characters from 'Hello there, Venus' into '', length 18<\/code><\/p>\n
In the first test, only 18 characters are copied because the null character is encountered.<\/p>\n
The second test copies 10 characters (9 plus the null character).<\/p>\n
The third and fourth tests copy no characters.<\/p>\n
In each test, the value 18 is returned, which is the length of the string[]<\/code> array as would be reported by the strlen()<\/em> function; the string’s buffer size is 19 when you include the null character.<\/p>\n
With this information in hand, I was better able to craft my version of the strlcpy()<\/em> function, ensuring that it exhibited the same behavior as the actual function. I present my solution in next week’s Lesson<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
The non-standard strlcpy()<\/em> function copies a string but limits the destination buffer length — a much-needed, secure improvement over the standard strcpy()<\/em> function. 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-3873","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\/3873","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=3873"}],"version-history":[{"count":7,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/3873\/revisions"}],"predecessor-version":[{"id":3907,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/3873\/revisions\/3907"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=3873"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=3873"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=3873"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}