No format string passed to variable argument list function

[Adam]

Hi,

I have a simple printf-like function:

int print(const char *format, ...)
{
char buffer[1024];
va_list argptr;
int i;

va_start(argptr , format);
i = vsnprintf(buffe r, sizeof(buffer), format, argptr);
va_end(argptr);

buffer[sizeof(buffer)-1] = '\0';

printf("%s\n",b uffer); /* this bit just for the sake of testing */

return i;
}

If I call the function using something like:
char message[50];
strcpy(message, "hi there");
print("%s",mess age);

everything works, but if I do:
print(message);

it doesn't (program crashes with an abort).

Is there something wrong with what I'm doing, or should I be looking
elsewhere to work out the cause of my crash?

Thanks a lot,
Adam

[Ian Collins]

Peter Nilsson wrote:

Ian Collins <[e-mail] mwrote:

>Keith Thompson wrote:

>>Ian Collins <[e-mail] mwrites:
Adam wrote:
I have a simple printf-like function:
Did you include <stdarg.h>?
He must have; otherwise the identifier "va_arg"
wouldn't be visible.

Or va_list. Yes it was a silly question!

Not necessarily. How do you know Adam isn't using
<varargs.h>?

He would have seen a warning for the va_start with 2 parameters.

--
Ian Collins

[Peter Nilsson]

Ben Bacarisse <ben.use...@bsb .me.ukwrote:

Peter Nilsson <[e-mail] .auwrites:

Adam <n...@snowstone .org.ukwrote:

* printf("%s\n",b uffer);

puts(buffer) is better since the result string
could have % characters...

Did you misread the printf?

Yes, I did.

>*It looks fine to me

It is. I think I was thinking out aloud about the
later...

print(message);

Thanks for pointing it out.

--
Peter

[Kenny McCormack]

In article <51************ *************** *******@l33g200 0pri.googlegrou ps.com>,
Peter Nilsson <ai***@acay.com .auwrote:

>Adam <n...@snowstone .org.ukwrote:

>I have a simple printf-like function:

int print(const char *format, ...)
{
* char buffer[1024];

Maybe make this static. There's no upper or lower limit
on automatic storage, but I prefer not to allocate more
than 256 bytes in a single function.

(CLC pedant mode)

I would imagine that the lower limit is 0 in most cases.

Are you aware of any implementations that require at least one
automatic object?

[Harald van =?UTF-8?b?RMSzaw==?=]

On Thu, 16 Oct 2008 08:18:38 +0000, Kenny McCormack wrote:

In article
<51************ *************** *******@l33g200 0pri.googlegrou ps.com>,
Peter Nilsson <ai***@acay.com .auwrote:

>>There's no upper or lower limit on automatic
storage, but I prefer not to allocate more than 256 bytes in a single
function.

(CLC pedant mode)

I would imagine that the lower limit is 0 in most cases.

Are you aware of any implementations that require at least one automatic
object?

(Continued pedant mode)

I think whatever location is used to store the return address qualifies as
an object, and while some may have that location fixed (making it a non-
automatic object), plenty of others don't. I'm not aware of
implementations that don't have a lower limit at all, though.

[s0suk3]

On Oct 15, 5:02*pm, Adam <ne**@snowstone .org.ukwrote:

Hi,

I have a simple printf-like function:

int print(const char *format, ...)
{
* char buffer[1024];
* va_list argptr;
* int i;

* va_start(argptr , format);
* i = vsnprintf(buffe r, sizeof(buffer), format, argptr);
* va_end(argptr);

* buffer[sizeof(buffer)-1] = '\0';

* printf("%s\n",b uffer); /* this bit just for the sake of testing */

* return i;

}

You're using [v]snprintf() as a "safer [v]sprintf()", which is already
OK, but you should also take advantage of the fact that [v]snprintf()
returns the required length when you pass it zero as the size (the 2nd
argument). That will ensure that the result won't be truncated (in
this case, to 1024 characters).

int print(const char *format, ...)
{
va_list ap;

va_start(ap, format);
int len = vsnprintf(NULL, 0, format, ap); // figure out the length
va_end(ap);

char buffer[len + 1];
va_start(ap, format);
vsnprintf(buffe r, len + 1, format, ap);
va_end(ap);

printf("%s\n", buffer);

return len;
}

Sebastian

[Adam]

On 16 Oct, 00:50, Nate Eldredge <[e-mail] nwrote:

Adam <n...@snowstone .org.ukwrites:

Hi,

I have a simple printf-like function:

int print(const char *format, ...)
{
* char buffer[1024];
* va_list argptr;
* int i;

* va_start(argptr , format);
* i = vsnprintf(buffe r, sizeof(buffer), format, argptr);
* va_end(argptr);

* buffer[sizeof(buffer)-1] = '\0';

* printf("%s\n",b uffer); /* this bit just for the sake of testing */

* return i;
}

If I call the function using something like:
char message[50];
strcpy(message, "hi there");
print("%s",mess age);

everything works, but if I do:
print(message);

it doesn't (program crashes with an abort).

I don't see a problem myself. *I took your function and added a main function:

#include <stdarg.h>
#include <stdio.h>

/* your function */

int main(void) {
* print("%s\n", "Hello world!");
* print("Goodbye world!\n");
* return 0;

}

and it compiles and runs without problems on three different systems.

Actually, the bit I was wondering about was passing a (char *) to the
print function, rather than a literal string. I did find this page:
http://www.eskimo.com/~scs/cclass/int/sx11c.html
....which seems to suggest (in the first paragraph) this might be
wrong.

There could be something that I'm missing, though, which doesn't show up
on those systems. *Can you post a complete program that aborts, and tell
us the system and compiler you're using?

Well, the compiler is GCC. Trouble is, I can't replicate it in a
simple example (and a complex example would take me well out of
comp.lang.c territory). I though perhaps that some undefined behaviour
was causing problems in one case but not in another, but
I guess I need to look elsewhere for my problem.
Keith wrote:

This isn't your problem, but what's the purpose of [buffer[sizeof(buffer)-1] = '\0']?

Hmm, well when I originally wrote a function like this I wasn't sure
about the rules for whether it would get terminated or not and it
seemed it didn't if the incoming string was truncated. However, a
similar test now seems to reveal it does work, as you say.
Thanks,
Adam

[Keith Thompson]

Adam <ne**@snowstone .org.ukwrites:
[...]

Keith wrote:

>This isn't your problem, but what's the purpose of [buffer[sizeof(buffer)-1] = '\0']?

Hmm, well when I originally wrote a function like this I wasn't sure
about the rules for whether it would get terminated or not and it
seemed it didn't if the incoming string was truncated. However, a
similar test now seems to reveal it does work, as you say.

Testing doesn't prove anything. The way to confirm that the string
will be properly terminated string is to read the documentation for
the functions you're using.

If you were using a function that *isn't* guaranteed to produce a
properly terminated string, testing will very likely fail to detect
the problem; consider that uninitialized memory is often set to zero
(though that's by no means guaranteed).

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[jameskuyper]

Adam wrote:

On 16 Oct, 00:50, Nate Eldredge <[e-mail] nwrote:

Adam <n...@snowstone .org.ukwrites:

Hi,

I have a simple printf-like function:

int print(const char *format, ...)
{
� char buffer[1024];
� va_list argptr;
� int i;

� va_start(argptr , format);
� i = vsnprintf(buffe r, sizeof(buffer), format, argptr);
� va_end(argptr);

� buffer[sizeof(buffer)-1] = '\0';

� printf("%s\n",b uffer); /* this bit just for the sake of testing */

� return i;
}

If I call the function using something like:
char message[50];
strcpy(message, "hi there");
print("%s",mess age);

everything works, but if I do:
print(message);

it doesn't (program crashes with an abort).

I don't see a problem myself. �I took your function and added amain function:

#include <stdarg.h>
#include <stdio.h>

/* your function */

int main(void) {
� print("%s\n", "Hello world!");
� print("Goodbye world!\n");
� return 0;

}

and it compiles and runs without problems on three different systems.

Actually, the bit I was wondering about was passing a (char *) to the
print function, rather than a literal string. I did find this page:
http://www.eskimo.com/~scs/cclass/int/sx11c.html
...which seems to suggest (in the first paragraph) this might be
wrong.

In C, the type of a string literal is char*; when used in this
contexts, (and most other contexts) "message" decays to a char* too.
Therefore, whatever issue might arise with a string literal will also
arise with "message".

The first paragraph that you refer to on that web page talks about the
integer promotions, which only apply to integer types like 'char'.
Pointer types like 'char *' remain unaffected by the integer
promotions.

There could be something that I'm missing, though, which doesn't show up
on those systems. �Can you post a complete program that aborts,and tell
us the system and compiler you're using?

Well, the compiler is GCC. Trouble is, I can't replicate it in a
simple example (and a complex example would take me well out of
comp.lang.c territory).

Start with your complicated example, and start simplifying it by
removing things. Test after each removal. When a removal causes the
problem to disappear, put it back in and remove something else. If you
do this systematically, you will either produce a minimum-size program
that demonstrates the problem which you can post to this group, no
matter how long it is; or you'll realize what the problem is. In my
experience, it's usually the second possibility that actually comes
up.

This isn't your problem, but what's the purpose of [buffer[sizeof(buffer)-1] = '\0']?

Hmm, well when I originally wrote a function like this I wasn't sure
about the rules for whether it would get terminated or not and it
seemed it didn't if the incoming string was truncated. However, a
similar test now seems to reveal it does work, as you say.

Performing a test is not a goodway to figure this out. The test will
tell you what your compiler does; it won't tell you whether this a
special case, or something you can rely on. Reading and understanding
the documentation of the vsnprintf() function is the best way. The
standard's description of vsnprintf() cross-references snprintf(). The
description of snprintf() says "a null character is written at the end
of the characters actually written into the array." The documentation
that comes with your compiler should say roughly the same thing.

[vippstar]

On Oct 20, 10:09 pm, jameskuy...@ver izon.net wrote:

>
In C, the type of a string literal is char*; when used in this
contexts, (and most other contexts) "message" decays to a char* too.
Therefore, whatever issue might arise with a string literal will also
arise with "message".

The type of a string literal is char [n] where n is size of the string
literal.
What are you talking about? I hope I haven't took this out of context.

[jameskuyper]

vipps...@gmail. com wrote:

On Oct 20, 10:09 pm, jameskuy...@ver izon.net wrote:

In C, the type of a string literal is char*; when used in this
contexts, (and most other contexts) "message" decays to a char* too.

....

The type of a string literal is char [n] where n is size of the string
literal.
What are you talking about? I hope I haven't took this out of context.

What I should have done is replace the first sentence with:

In C, in this context (and in most other contexts) both string
literals and arrays of char like "message" are converted to char*
pointers.