strdup()

[Grumble]

As far as I can tell, strdup() is neither in C89 nor in C99.

Is that correct?

<OT>Is it in POSIX perhaps?</OT>

[Keith Thompson]

Grumble <de*****@kma.eu .org> writes:

As far as I can tell, strdup() is neither in C89 nor in C99.

Is that correct?
Yes.
<OT>Is it in POSIX perhaps?</OT>

I believe so.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Chris Croughton]

On Tue, 22 Mar 2005 10:37:25 +0100, Grumble
<de*****@kma.eu .org> wrote:

As far as I can tell, strdup() is neither in C89 nor in C99.

Is that correct?
Correct. It's trivial to implement, though:

#include <stdlib.h>
char *strdup(const char *str)
{
char *cpy = NULL;
if (str)
{
cpy = malloc(strlen(s tr)+1);
if (cpy)
strcpy(cpy, str);
}
return cpy;
}

(Actually, POSIX doesn't specify what happens if a null pointer is
passed in, but I prefer the trivial test so that strdup(NULL) == NULL.)
<OT>Is it in POSIX perhaps?</OT>

It is. Some useful URLs for POSIX:

http://www.opengroup.org/onlinepubs/...9/nfindex.html
http://www.opengroup.org/onlinepubs/007908799/toc.htm
http://www.everything2.com/?node=Posix

Chris C

[Tor Rustad]

"Grumble" <de*****@kma.eu .org> wrote in message

As far as I can tell, strdup() is neither in C89 nor in C99.

Is that correct?
sure
<OT>Is it in POSIX perhaps?</OT>

strdup() was manditory in UNIX 95.

http://www.unix.org/

--
Tor <torust AT online DOT no>

[Robert Bachmann]

Grumble wrote:

As far as I can tell, strdup() is neither in C89 nor in C99.

Is that correct?

<OT>Is it in POSIX perhaps?</OT>

Here are my replacements for strdup (specified in POSIX) and
strndup (an extension from GNU libc).

/*
dupstr() and dupstrn(): Replacements for strdup() and strndup()

Written in 2004 by Robert Bachmann <rbach [AT] rbach.priv.at>
Public domain.
*/

#include <assert.h>
#include <stdlib.h>
#include <string.h>

/*
char* dupstr (const char *s)

Returns a pointer to a new string
which is a duplicate of the string s,
or NULL if malloc() failed.
*/
char* dupstr (const char *s)
{
char *p;
size_t n;

assert(s != NULL);

n=strlen(s) + 1;
p = malloc(n);

if (p)
p=memcpy(p,s,n) ;

return p;
}

/*
char* dupnstr (const char *s,size_t n)

Works like dupstr() but it only copies the
first n characters.
A terminating '\0' is *always* added.
*/
char* dupnstr (const char *s,size_t n)
{
char *p;

assert(s != NULL);

p = malloc(n+1);

if (p) {
p=strncpy(p,s,n );
p[n]='\0';
}
return p;
}

--
Robert Bachmann <ne**@rbach.pri v.at>, PGP-KeyID: 0x8994A748

[CBFalconer]

Robert Bachmann wrote:

.... snip ...
Here are my replacements for strdup (specified in POSIX) and
strndup (an extension from GNU libc).

/*
dupstr() and dupstrn(): Replacements for strdup() and strndup()

Written in 2004 by Robert Bachmann <rbach [AT] rbach.priv.at>
Public domain.
*/

#include <assert.h>
#include <stdlib.h>
#include <string.h>

/*
char* dupstr (const char *s)

Returns a pointer to a new string
which is a duplicate of the string s,
or NULL if malloc() failed.
*/
char* dupstr (const char *s)
{
char *p;
size_t n;

assert(s != NULL);

n=strlen(s) + 1;
p = malloc(n);

if (p)
p=memcpy(p,s,n) ;

return p;
}

/*
char* dupnstr (const char *s,size_t n)

Works like dupstr() but it only copies the
first n characters.
A terminating '\0' is *always* added.
*/
char* dupnstr (const char *s,size_t n)
{
char *p;

assert(s != NULL);

p = malloc(n+1);

if (p) {
p=strncpy(p,s,n );
p[n]='\0';
}
return p;
}

Try this modification (untested) which does reasonable things with
NULL input and eliminates the assert.

#include <stdlib.h>
#include <string.h>

char *dupstr(const char *s)
{
char *p;
size_t n;

if (!s || !(p = malloc(n = 1 + strlen(s))) return NULL;
else return memcpy(p, s, n);
}

and dupnstr is probably better built out of strlcpy from the BSD
world, an implementation of which is available on my site
<http://cbfalconer.home .att.net/download/>. There is no need to
insert those possibly very length strings of zeroes.

--
"I conclude that there are two ways of constructing a software
design: One way is to make it so simple that there are obviously
no deficiencies and the other way is to make it so complicated
that there are no obvious deficiencies." -- C. A. R. Hoare

[Nils Weller]

In article <42************ ***@yahoo.com>, CBFalconer wrote:

Robert Bachmann wrote:

#include <assert.h>
#include <stdlib.h>
#include <string.h>

/*
char* dupstr (const char *s)

Returns a pointer to a new string
which is a duplicate of the string s,
or NULL if malloc() failed.
*/
char* dupstr (const char *s)
{
char *p;
size_t n;

assert(s != NULL);

n=strlen(s) + 1;
p = malloc(n);

if (p)
p=memcpy(p,s,n) ;

return p;
}

[...]

Try this modification (untested) which does reasonable things with
NULL input and eliminates the assert.

#include <stdlib.h>
#include <string.h>

char *dupstr(const char *s)
{
char *p;
size_t n;

if (!s || !(p = malloc(n = 1 + strlen(s))) return NULL;
else return memcpy(p, s, n);
}

I would argue that your version is inferior because it masks the bug of
passing a null pointer to dupstr(), and there is no convenient way to
distinguish between this bug and failure to allocate memory. How is the
caller supposed to put your check to good use? Although the standard
does not say anything about errno being set to an appropriate error code
when malloc() fails, the ``Quality of Implementation' ' factor is usually
such that malloc() does this. Therefore, callers of this function may
reasonably wish to rely on a meaningful errno value in order to diagnose
the error as ``dupstr() failed becaue of ...'' rather than ``dupstr()
failed for an unknown reason'':

char *p = dupstr(str);
if (p == NULL) {
perror("dupstr failed");
/* handle error */
}

If you really wish to keep the null pointer check, it is more useful to
set errno accordingly;

if (s == NULL) {
errno = EINVAL;
return NULL;
} else if ((p = malloc(n = strlen(s) + 1)) == NULL) {
return NULL;
}

(Of course, this decreases portability for no good reason because EINVAL
is not standard so it is not a very good solution either.)

--
My real email address is ``nils<at>gnuli nux<dot>nl''

[Tor Rustad]

"Nils Weller" <[e-mail] > wrote in message

<snip>

char *p = dupstr(str);
if (p == NULL) {
perror("dupstr failed");
/* handle error */
}

If you really wish to keep the null pointer check, it is more useful to set errno accordingly;

if (s == NULL) {
errno = EINVAL;
return NULL;
} else if ((p = malloc(n = strlen(s) + 1)) == NULL) {
return NULL;
}

Normally, a "mean and lean" attitude is sufficient. Why keep
on going -- if there isn't going to be done any recovery of
malloc failures anyway?

/* Warning: untested code follows ...*/
/* xmalloc: exit on failure */
void *xmalloc(size_t size)
{
void *mem;

/* pre-condition catch implementation defined behavoir */
assert (size > 0);

mem = malloc(size);
if (mem == NULL)
{
perror("xmalloc : Out of memory");
exit(EXIT_FAILU RE);
}

return mem;
}

then our "strdup" can simply be written

/* xstrdup: exit on failure, never return NULL */
char *xstrdup(const char *str)
{
char *mem;

/* pre-condition catch UB */
assert(str != NULL);

mem = xmalloc(strlen( str) + 1);

/* post-condition */
assert(mem != NULL);

return strcpy(mem, str);
}

This simplify coding, since a lot if tests for NULL can be removed.
However, for a non-stop server, more advanced mem handling
is wanted, perhaps even using a GC.

--
Tor <torust AT online DOT no>

[Guillaume]

Tor Rustad wrote:

Normally, a "mean and lean" attitude is sufficient. Why keep
on going -- if there isn't going to be done any recovery of
malloc failures anyway?

Oh my.

[Gordon Burditt]

>Normally, a "mean and lean" attitude is sufficient. Why keep

on going -- if there isn't going to be done any recovery of
malloc failures anyway?

I hope you don't design airplanes, nuclear power plants,
weapons systems, or firmware for automobile engines :-)

Gordon L. Burditt