{
    "mode": "man",
    "parameter": "string_copying",
    "section": "7",
    "url": "https://www.chedong.com/phpMan.php/man/string_copying/7/json",
    "generated": "2026-10-04T07:00:26Z",
    "synopsis": "",
    "sections": {
        "NAME": {
            "content": "stpcpy, strcpy, strcat, stpecpy, strtcpy, strlcpy, strlcat, stpncpy, strncpy, strncat - copy‐\ning strings and character sequences\n",
            "subsections": []
        },
        "SYNOPSIS": {
            "content": "",
            "subsections": [
                {
                    "name": "Strings",
                    "content": "// Chain-copy a string.\nchar *stpcpy(char *restrict dst, const char *restrict src);\n\n// Copy/catenate a string.\nchar *strcpy(char *restrict dst, const char *restrict src);\nchar *strcat(char *restrict dst, const char *restrict src);\n\n// Chain-copy a string with truncation.\nchar *stpecpy(char *dst, char end[0], const char *restrict src);\n\n// Copy/catenate a string with truncation.\nssizet strtcpy(char dst[restrict .dsize], const char *restrict src,\nsizet dsize);\nsizet strlcpy(char dst[restrict .dsize], const char *restrict src,\nsizet dsize);\nsizet strlcat(char dst[restrict .dsize], const char *restrict src,\nsizet dsize);\n"
                },
                {
                    "name": "Null-padded character sequences",
                    "content": "// Fill a fixed-size buffer with characters from a string\n// and pad with null bytes.\nchar *strncpy(char dst[restrict .dsize], const char *restrict src,\nsizet dsize);\nchar *stpncpy(char dst[restrict .dsize], const char *restrict src,\nsizet dsize);\n\n// Chain-copy a null-padded character sequence into a character sequence.\nmempcpy(dst, src, strnlen(src, NITEMS(src)));\n\n// Chain-copy a null-padded character sequence into a string.\nstpcpy(mempcpy(dst, src, strnlen(src, NITEMS(src))), \"\");\n\n// Catenate a null-padded character sequence into a string.\nchar *strncat(char *restrict dst, const char src[restrict .ssize],\nsizet ssize);\n"
                },
                {
                    "name": "Known-length character sequences",
                    "content": "// Chain-copy a known-length character sequence.\nvoid *mempcpy(void dst[restrict .len], const void src[restrict .len],\nsizet len);\n\n// Chain-copy a known-length character sequence into a string.\nstpcpy(mempcpy(dst, src, len), \"\");\n"
                }
            ]
        },
        "DESCRIPTION": {
            "content": "",
            "subsections": [
                {
                    "name": "Terms (and abbreviations)",
                    "content": "string (str)\nis a sequence of zero or more non-null characters followed by a null character.\n\ncharacter sequence\nis a sequence of zero or more non-null characters.  A program should never use a char‐\nacter  sequence  where a string is required.  However, with appropriate care, a string\ncan be used in the place of a character sequence.\n\nnull-padded character sequence\nCharacter sequences can be  contained  in  fixed-size  buffers,  which  contain\npadding null bytes after the character sequence, to fill the rest of the buffer\nwithout affecting the character sequence; however, those padding null bytes are\nnot part of the character sequence.  Don't confuse null-padded with null-termi‐\nnated:  null-padded  means  0 or more padding null bytes, while null-terminated\nmeans exactly 1 terminating null character.\n\nknown-length character sequence\nCharacter sequence delimited by its length.  It may be  a  slice  of  a  larger\ncharacter sequence, or even of a string.\n\nlength (len)\nis the number of non-null characters in a string or character sequence.  It is the re‐\nturn value of strlen(str) and of strnlen(buf, size).\n\nsize   refers to the entire buffer where the string or character sequence is contained.\n\nend    is  the  name of a pointer to one past the last element of a buffer.  It is equivalent\nto &str[size].  It is used as a sentinel value, to be  able  to  truncate  strings  or\ncharacter sequences instead of overrunning the containing buffer.\n\ncopy   This term is used when the writing starts at the first element pointed to by dst.\n\ncatenate\nThis  term  is used when a function first finds the terminating null character in dst,\nand then starts writing at that position.\n\nchain  This term is used when it's the programmer who provides a pointer to  the  terminating\nnull  character  in the string dst (or one after the last character in a character se‐\nquence), and the function starts writing at that location.   The  function  returns  a\npointer  to  the new location of the terminating null character (or one after the last\ncharacter in a character sequence) after the call, so that the programmer can  use  it\nto chain such calls.\n"
                },
                {
                    "name": "Copy, catenate, and chain-copy",
                    "content": "Originally,  there  was  a  distinction  between functions that copy and those that catenate.\nHowever, newer functions that copy while allowing chaining cover both use cases with a single\nAPI.  They are also algorithmically faster, since they don't need to search for the terminat‐\ning null character of the existing string.  However, functions that catenate have a much sim‐\npler use, so if performance is not important, it can make sense to  use  them  for  improving\nreadability.\n\nThe  pointer  returned by functions that allow chaining is a byproduct of the copy operation,\nso it has no performance costs.  Functions that return  such  a  pointer,  and  thus  can  be\nchained, have names of the form *stp*(), since it's common to name the pointer just p.\n\nChain-copying  functions  that truncate should accept a pointer to the end of the destination\nbuffer, and have names of the form *stpe*().  This allows not having to recalculate  the  re‐\nmaining size after each call.\n"
                },
                {
                    "name": "Truncate or not?",
                    "content": "The  first  thing  to note is that programmers should be careful with buffers, so they always\nhave the correct size, and truncation is not necessary.\n\nIn most cases, truncation is not desired, and it is simpler to just  do  the  copy.   Simpler\ncode  is  safer code.  Programming against programming mistakes by adding more code just adds\nmore points where mistakes can be made.\n\nNowadays, compilers can detect most programmer errors with features like  compiler  warnings,\nstatic  analyzers,  and  FORTIFYSOURCE  (see  ftm(7)).  Keeping the code simple helps these\noverflow-detection features be more precise.\n\nWhen validating user input, code should normally not truncate, but instead fail  and  prevent\nthe copy at all.\n\nIn some cases, however, it makes sense to truncate.\n\nFunctions that truncate:\n\n•  stpecpy()\n\n•  strtcpy()\n\n•  strlcpy(3bsd)  and strlcat(3bsd) are similar, but have important performance problems; see\nBUGS.\n\n•  stpncpy(3) and strncpy(3) also truncate, but they don't write strings,  but  rather  null-\npadded character sequences.\n"
                },
                {
                    "name": "Null-padded character sequences",
                    "content": "For  historic  reasons, some standard APIs and file formats, such as utmpx(5) and tar(1), use\nnull-padded character sequences in fixed-size buffers.  To interface with  them,  specialized\nfunctions need to be used.\n\nTo copy bytes from strings into these buffers, use strncpy(3) or stpncpy(3).\n\nTo  read  a  null-padded  character sequence, use strnlen(src, NITEMS(src)), and then you can\ntreat it as a known-length character sequence; or use strncat(3) directly.\n"
                },
                {
                    "name": "Known-length character sequences",
                    "content": "The simplest character sequence copying function is mempcpy(3).  It requires  always  knowing\nthe  length of your character sequences, for which structures can be used.  It makes the code\nmuch faster, since you always know the length of your character sequences,  and  can  do  the\nminimal  copies  and length measurements.  mempcpy(3) copies character sequences, so you need\nto explicitly set the terminating null character if you need a string.\n\nIn programs that make considerable use of strings or character sequences, and need  the  best\nperformance,  using  overlapping  character  sequences  can make a big difference.  It allows\nholding subsequences of a larger character sequence, while not duplicating memory  nor  using\ntime to do a copy.\n\nHowever,  this  is delicate, since it requires using character sequences.  C library APIs use\nstrings, so programs that use character sequences will have to take care  of  differentiating\nstrings from character sequences.\n\nTo copy a known-length character sequence, use mempcpy(3).\n\nTo     copy     a     known-length     character     sequence     into    a    string,    use\nstpcpy(mempcpy(dst, src, len), \"\").\n\nA string is also accepted as input, because mempcpy(3) asks for the length, and a  string  is\ncomposed of a character sequence of the same length plus a terminating null character.\n"
                },
                {
                    "name": "String vs character sequence",
                    "content": "Some  functions  only  operate on strings.  Those require that the input src is a string, and\nguarantee an output string (even when truncation occurs).  Functions that catenate  also  re‐\nquire that dst holds a string before the call.  List of functions:\n\n•  stpcpy(3)\n•  strcpy(3), strcat(3)\n•  stpecpy()\n•  strtcpy()\n•  strlcpy(3bsd), strlcat(3bsd)\n\nOther  functions  require  an input string, but create a character sequence as output.  These\nfunctions have confusing names, and have a long history of misuse.  List of functions:\n\n•  stpncpy(3)\n•  strncpy(3)\n\nOther functions operate on an input character sequence, and create an output  string.   Func‐\ntions  that catenate also require that dst holds a string before the call.  strncat(3) has an\neven more misleading name than the functions above.  List of functions:\n\n•  strncat(3)\n\nOther functions operate on an input character sequence to  create  an  output  character  se‐\nquence.  List of functions:\n\n•  mempcpy(3)\n"
                },
                {
                    "name": "Functions",
                    "content": "stpcpy(3)\nCopy  the  input  string into a destination string.  The programmer is responsible for\nallocating a buffer large enough.  It returns a pointer suitable for chaining.\n\nstrcpy(3)\nstrcat(3)\nCopy and catenate the input string into a destination string.  The programmer  is  re‐\nsponsible for allocating a buffer large enough.  The return value is useless.\n\nstpcpy(3) is a faster alternative to these functions.\n\nstpecpy()\nChain-copy  the  input  string  into a destination string.  If the destination buffer,\nlimited by a pointer to its end, isn't large enough to hold the  copy,  the  resulting\nstring  is  truncated  (but  it  is  guaranteed  to be null-terminated).  It returns a\npointer suitable for chaining.  Truncation needs to be detected only  once  after  the\nlast chained call.\n\nThis function is not provided by any library; see EXAMPLES for a reference implementa‐\ntion.\n\nstrtcpy()\nCopy  the  input  string  into  a destination string.  If the destination buffer isn't\nlarge enough to hold the copy, the resulting string is truncated (but it is guaranteed\nto be null-terminated).  It returns the length of the string, or -1 if it truncated.\n\nThis function is not provided by any library; see EXAMPLES for a reference implementa‐\ntion.\n\nstrlcpy(3bsd)\nstrlcat(3bsd)\nCopy and catenate the input string into a  destination  string.   If  the  destination\nbuffer, limited by its size, isn't large enough to hold the copy, the resulting string\nis  truncated (but it is guaranteed to be null-terminated).  They return the length of\nthe total string they tried to create.\n\nCheck BUGS before using these functions.\n\nstrtcpy() and stpecpy() are better alternatives to these functions.\n\nstpncpy(3)\nCopy the input string into a destination null-padded character sequence  in  a  fixed-\nsize  buffer.   If  the destination buffer, limited by its size, isn't large enough to\nhold the copy, the resulting character sequence is  truncated.   Since  it  creates  a\ncharacter  sequence,  it doesn't need to write a terminating null character.  It's im‐\npossible to distinguish truncation by the result of the call,  from  a  character  se‐\nquence that just fits the destination buffer; truncation should be detected by compar‐\ning the length of the input string with the size of the destination buffer.\n\nstrncpy(3)\nThis function is identical to stpncpy(3) except for the useless return value.\n\nstpncpy(3) is a more useful alternative to this function.\n\nstrncat(3)\nCatenate  the  input character sequence, contained in a null-padded fixed-size buffer,\ninto a destination string.  The programmer is  responsible  for  allocating  a  buffer\nlarge enough.  The return value is useless.\n\nDo not confuse this function with strncpy(3); they are not related at all.\n\nstpcpy(mempcpy(dst, src, strnlen(src, NITEMS(src))), \"\")  is  a  faster alternative to\nthis function.\n\nmempcpy(3)\nCopy the input character sequence, limited by its length, into a destination character\nsequence.  The programmer is responsible for allocating a buffer large enough.  It re‐\nturns a pointer suitable for chaining.\n"
                }
            ]
        },
        "RETURN VALUE": {
            "content": "stpcpy(3)\nA pointer to the terminating null character in the destination string.\n\nstpecpy()\nA pointer to the terminating null character in the destination string, on success.  On\nerror, NULL is returned, and errno is set to indicate the error.\n\nmempcpy(3)\nstpncpy(3)\nA pointer to one after the last character in the destination character sequence.\n\nstrtcpy()\nThe length of the string, on success.  On error, -1 is returned, and errno is  set  to\nindicate the error.\n\nstrlcpy(3bsd)\nstrlcat(3bsd)\nThe  length of the total string that they tried to create (as if truncation didn't oc‐\ncur).\n\nstrcpy(3)\nstrcat(3)\nstrncpy(3)\nstrncat(3)\nThe dst pointer, which is useless.\n",
            "subsections": []
        },
        "ERRORS": {
            "content": "Most of these functions don't set errno.\n\nstpecpy()\nstrtcpy()\n\nENOBUFS\ndsize was 0.\n\nE2BIG  The string has been truncated.\n",
            "subsections": []
        },
        "NOTES": {
            "content": "The Linux kernel has an internal function for copying strings, strscpy(9), which is identical\nto strtcpy(), except that it returns -E2BIG instead of -1 and it doesn't set errno.\n",
            "subsections": []
        },
        "CAVEATS": {
            "content": "Don't mix chain calls to truncating and non-truncating functions.  It is  conceptually  wrong\nunless  you know that the first part of a copy will always fit.  Anyway, the performance dif‐\nference will probably be negligible, so it will probably be more clear if you use  consistent\nsemantics:  either  truncating  or non-truncating.  Calling a non-truncating function after a\ntruncating one is necessarily wrong.\n",
            "subsections": []
        },
        "BUGS": {
            "content": "All catenation functions share the same performance problem: Shlemiel the painter.  As a mit‐\nigation, compilers are able to transform some calls to catenation functions into normal  copy\nfunctions, since strlen(dst) is usually a byproduct of the previous copy.\n\nstrlcpy(3)  and strlcat(3) need to read the entire src string, even if the destination buffer\nis small.  This makes them vulnerable to Denial of Service (DoS) attacks if an  attacker  can\ncontrol the length of the src string.  And if not, they're still unnecessarily slow.\n",
            "subsections": []
        },
        "EXAMPLES": {
            "content": "The following are examples of correct use of each of these functions.\n\nstpcpy(3)\np = buf;\np = stpcpy(p, \"Hello \");\np = stpcpy(p, \"world\");\np = stpcpy(p, \"!\");\nlen = p - buf;\nputs(buf);\n\nstrcpy(3)\nstrcat(3)\nstrcpy(buf, \"Hello \");\nstrcat(buf, \"world\");\nstrcat(buf, \"!\");\nlen = strlen(buf);\nputs(buf);\n\nstpecpy()\nend = buf + NITEMS(buf);\np = buf;\np = stpecpy(p, end, \"Hello \");\np = stpecpy(p, end, \"world\");\np = stpecpy(p, end, \"!\");\nif (p == NULL) {\nlen = NITEMS(buf) - 1;\ngoto toolong;\n}\nlen = p - buf;\nputs(buf);\n\nstrtcpy()\nlen = strtcpy(buf, \"Hello world!\", NITEMS(buf));\nif (len == -1)\ngoto toolong;\nputs(buf);\n\nstrlcpy(3bsd)\nstrlcat(3bsd)\nif (strlcpy(buf, \"Hello \", NITEMS(buf)) >= NITEMS(buf))\ngoto toolong;\nif (strlcat(buf, \"world\", NITEMS(buf)) >= NITEMS(buf))\ngoto toolong;\nlen = strlcat(buf, \"!\", NITEMS(buf));\nif (len >= NITEMS(buf))\ngoto toolong;\nputs(buf);\n\nstpncpy(3)\np = stpncpy(u->utuser, \"alx\", NITEMS(u->utuser));\nif (NITEMS(u->utuser) < strlen(\"alx\"))\ngoto toolong;\nlen = p - u->utuser;\nfwrite(u->utuser, 1, len, stdout);\n\nstrncpy(3)\nstrncpy(u->utuser, \"alx\", NITEMS(u->utuser));\nif (NITEMS(u->utuser) < strlen(\"alx\"))\ngoto toolong;\nlen = strnlen(u->utuser, NITEMS(u->utuser));\nfwrite(u->utuser, 1, len, stdout);\n\nmempcpy(dst, src, strnlen(src, NITEMS(src)))\nchar  buf[NITEMS(u->utuser)];\np = buf;\np = mempcpy(p, u->utuser, strnlen(u->utuser, NITEMS(u->utuser)));\nlen = p - buf;\nfwrite(buf, 1, len, stdout);\n\nstpcpy(mempcpy(dst, src, strnlen(src, NITEMS(src))), \"\")\nchar  buf[NITEMS(u->utuser) + 1];\np = buf;\np = mempcpy(p, u->utuser, strnlen(u->utuser, NITEMS(u->utuser)));\np = stpcpy(p, \"\");\nlen = p - buf;\nputs(buf);\n\nstrncat(3)\nchar  buf[NITEMS(u->utuser) + 1];\nstrcpy(buf, \"\");\nstrncat(buf, u->utuser, NITEMS(u->utuser));\nlen = strlen(buf);\nputs(buf);\n\nmempcpy(3)\np = buf;\np = mempcpy(p, \"Hello \", 6);\np = mempcpy(p, \"world\", 5);\np = mempcpy(p, \"!\", 1);\nlen = p - buf;\nfwrite(buf, 1, len, stdout);\n\nstpcpy(mempcpy(dst, src, len), \"\")\np = buf;\np = mempcpy(p, \"Hello \", 6);\np = mempcpy(p, \"world\", 5);\np = mempcpy(p, \"!\", 1);\np = stpcpy(p, \"\");\nlen = p - buf;\nputs(buf);\n",
            "subsections": [
                {
                    "name": "Implementations",
                    "content": "Here are reference implementations for functions not provided by libc.\n\n/* This code is in the public domain. */\n\nchar *\nstpecpy(char *dst, char end[0], const char *restrict src)\n{\nsizet  dlen;\n\nif (dst == NULL)\nreturn NULL;\n\ndlen = strtcpy(dst, src, end - dst);\nreturn (dlen == -1) ? NULL : dst + dlen;\n}\n\nssizet\nstrtcpy(char *restrict dst, const char *restrict src, sizet dsize)\n{\nbool    trunc;\nsizet  dlen, slen;\n\nif (dsize == 0) {\nerrno = ENOBUFS;\nreturn -1;\n}\n\nslen = strnlen(src, dsize);\ntrunc = (slen == dsize);\ndlen = slen - trunc;\n\nstpcpy(mempcpy(dst, src, dlen), \"\");\nif (trunc)\nerrno = E2BIG;\nreturn trunc ? -1 : slen;\n}\n"
                }
            ]
        },
        "SEE ALSO": {
            "content": "bzero(3),  memcpy(3),  memccpy(3),  mempcpy(3),  stpcpy(3),  strlcpy(3bsd),  strncat(3), stp‐\nncpy(3), string(3)\n\nLinux man-pages 6.7                          2023-12-17                            stringcopying(7)",
            "subsections": []
        }
    },
    "summary": "stpcpy, strcpy, strcat, stpecpy, strtcpy, strlcpy, strlcat, stpncpy, strncpy, strncat - copy‐ ing strings and character sequences",
    "flags": [],
    "examples": [
        "The following are examples of correct use of each of these functions.",
        "stpcpy(3)",
        "p = buf;",
        "p = stpcpy(p, \"Hello \");",
        "p = stpcpy(p, \"world\");",
        "p = stpcpy(p, \"!\");",
        "len = p - buf;",
        "puts(buf);",
        "strcpy(3)",
        "strcat(3)",
        "strcpy(buf, \"Hello \");",
        "strcat(buf, \"world\");",
        "strcat(buf, \"!\");",
        "len = strlen(buf);",
        "puts(buf);",
        "stpecpy()",
        "end = buf + NITEMS(buf);",
        "p = buf;",
        "p = stpecpy(p, end, \"Hello \");",
        "p = stpecpy(p, end, \"world\");",
        "p = stpecpy(p, end, \"!\");",
        "if (p == NULL) {",
        "len = NITEMS(buf) - 1;",
        "goto toolong;",
        "len = p - buf;",
        "puts(buf);",
        "strtcpy()",
        "len = strtcpy(buf, \"Hello world!\", NITEMS(buf));",
        "if (len == -1)",
        "goto toolong;",
        "puts(buf);",
        "strlcpy(3bsd)",
        "strlcat(3bsd)",
        "if (strlcpy(buf, \"Hello \", NITEMS(buf)) >= NITEMS(buf))",
        "goto toolong;",
        "if (strlcat(buf, \"world\", NITEMS(buf)) >= NITEMS(buf))",
        "goto toolong;",
        "len = strlcat(buf, \"!\", NITEMS(buf));",
        "if (len >= NITEMS(buf))",
        "goto toolong;",
        "puts(buf);",
        "stpncpy(3)",
        "p = stpncpy(u->utuser, \"alx\", NITEMS(u->utuser));",
        "if (NITEMS(u->utuser) < strlen(\"alx\"))",
        "goto toolong;",
        "len = p - u->utuser;",
        "fwrite(u->utuser, 1, len, stdout);",
        "strncpy(3)",
        "strncpy(u->utuser, \"alx\", NITEMS(u->utuser));",
        "if (NITEMS(u->utuser) < strlen(\"alx\"))",
        "goto toolong;",
        "len = strnlen(u->utuser, NITEMS(u->utuser));",
        "fwrite(u->utuser, 1, len, stdout);",
        "mempcpy(dst, src, strnlen(src, NITEMS(src)))",
        "char  buf[NITEMS(u->utuser)];",
        "p = buf;",
        "p = mempcpy(p, u->utuser, strnlen(u->utuser, NITEMS(u->utuser)));",
        "len = p - buf;",
        "fwrite(buf, 1, len, stdout);",
        "stpcpy(mempcpy(dst, src, strnlen(src, NITEMS(src))), \"\")",
        "char  buf[NITEMS(u->utuser) + 1];",
        "p = buf;",
        "p = mempcpy(p, u->utuser, strnlen(u->utuser, NITEMS(u->utuser)));",
        "p = stpcpy(p, \"\");",
        "len = p - buf;",
        "puts(buf);",
        "strncat(3)",
        "char  buf[NITEMS(u->utuser) + 1];",
        "strcpy(buf, \"\");",
        "strncat(buf, u->utuser, NITEMS(u->utuser));",
        "len = strlen(buf);",
        "puts(buf);",
        "mempcpy(3)",
        "p = buf;",
        "p = mempcpy(p, \"Hello \", 6);",
        "p = mempcpy(p, \"world\", 5);",
        "p = mempcpy(p, \"!\", 1);",
        "len = p - buf;",
        "fwrite(buf, 1, len, stdout);",
        "stpcpy(mempcpy(dst, src, len), \"\")",
        "p = buf;",
        "p = mempcpy(p, \"Hello \", 6);",
        "p = mempcpy(p, \"world\", 5);",
        "p = mempcpy(p, \"!\", 1);",
        "p = stpcpy(p, \"\");",
        "len = p - buf;",
        "puts(buf);",
        "Here are reference implementations for functions not provided by libc.",
        "/* This code is in the public domain. */",
        "char *",
        "stpecpy(char *dst, char end[0], const char *restrict src)",
        "sizet  dlen;",
        "if (dst == NULL)",
        "return NULL;",
        "dlen = strtcpy(dst, src, end - dst);",
        "return (dlen == -1) ? NULL : dst + dlen;",
        "ssizet",
        "strtcpy(char *restrict dst, const char *restrict src, sizet dsize)",
        "bool    trunc;",
        "sizet  dlen, slen;",
        "if (dsize == 0) {",
        "errno = ENOBUFS;",
        "return -1;",
        "slen = strnlen(src, dsize);",
        "trunc = (slen == dsize);",
        "dlen = slen - trunc;",
        "stpcpy(mempcpy(dst, src, dlen), \"\");",
        "if (trunc)",
        "errno = E2BIG;",
        "return trunc ? -1 : slen;"
    ],
    "see_also": [
        {
            "name": "bzero",
            "section": "3",
            "url": "https://www.chedong.com/phpMan.php/man/bzero/3/json"
        },
        {
            "name": "memcpy",
            "section": "3",
            "url": "https://www.chedong.com/phpMan.php/man/memcpy/3/json"
        },
        {
            "name": "memccpy",
            "section": "3",
            "url": "https://www.chedong.com/phpMan.php/man/memccpy/3/json"
        },
        {
            "name": "mempcpy",
            "section": "3",
            "url": "https://www.chedong.com/phpMan.php/man/mempcpy/3/json"
        },
        {
            "name": "stpcpy",
            "section": "3",
            "url": "https://www.chedong.com/phpMan.php/man/stpcpy/3/json"
        },
        {
            "name": "strlcpy",
            "section": "3bsd",
            "url": "https://www.chedong.com/phpMan.php/man/strlcpy/3bsd/json"
        },
        {
            "name": "strncat",
            "section": "3",
            "url": "https://www.chedong.com/phpMan.php/man/strncat/3/json"
        },
        {
            "name": "ncpy",
            "section": "3",
            "url": "https://www.chedong.com/phpMan.php/man/ncpy/3/json"
        },
        {
            "name": "string",
            "section": "3",
            "url": "https://www.chedong.com/phpMan.php/man/string/3/json"
        }
    ]
}