modifying the strings pointed to by argv

[subramanian100in]

The standard allows that we can copy strings onto arg[0], arg[1], etc.
Why is it allowed ?
What can be the maximum length of such a string that is copied ?

[Richard Heathfield]

su************* *@yahoo.com, India said:

The standard allows that we can copy strings onto arg[0], arg[1], etc.
Why is it allowed ?

Good question. Why indeed? It's a stupid stupid stupid idea, if ever
there was one.

What can be the maximum length of such a string that is copied ?

0, if you have lots of sense. If you have only a little sense, then find
out how long the existing string is, and don't exceed that value. If
you have no sense whatsoever, pay no attention to either of the above
suggestions.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[Bryan]

On 14 Mar, 13:19, Richard Heathfield <[e-mail].i nvalidwrote:

subramanian10.. [e-mail], India said:

The standard allows that we can copy strings onto arg[0], arg[1], etc.
Why is it allowed ?

Good question. Why indeed? It's a stupid stupid stupid idea, if ever
there was one.

Well, possibly, but there's no particularly good reason I can see for
the arguments passed to your function to be read-only. It could
potentially be useful to space-trim or similar the input arguments and
certainly there's at least one (admittedly sub-optimal) unix[1] hack
involving modifying the argv[] values so that program arguments do not
appear in the ps process listing.

Can you clear up why you think this functionality is unwise ?
[1] Granted, slightly off-topic here, but then again there's a good
few things in the C standard that are that way to avoid breaking how
existng code works, so I'd like to apply for a temporary on-topic
licence for this discussion.

[Cong Wang]

On Mar 14, 9:09Â*pm, "subramanian10. [e-mail], India"
<subramanian10. [e-mail] te:

The standard allows that we can copy strings onto arg[0], arg[1], etc.
Why is it allowed ?
What can be the maximum length of such a string that is copied ?

Well. There is still something to be clarify.

The standard just says "argc and argv and the strings pointed to by
the argv array shall be modi�able by the program." But the argv array
_itself_ is _not_ required to be modi�able.

The following buggy code only works well when argc >=2 and
strlen(argv[1]) >=1:

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
char buf[2] = {0};
strcpy(argv[1], buf);
return 0;
}

I guess making that modifiable may be considered for exec*() functions
or for the recursion of main(). And the maximum length maybe found in
POSIX.

[subramanian100in]

On Mar 14, 6:41Â*pm, "Cong Wang" <xiyou.wangc... @gmail.comwrote :

On Mar 14, 9:09Â*pm, "subramanian10. [e-mail], India"

<subramanian10. [e-mail] te:

The standard allows that we can copy strings onto arg[0], arg[1], etc.
Why is it allowed ?
What can be the maximum length of such a string that is copied ?

Well. There is still something to be clarify.

The standard just says "argc and argv and the strings pointed to by
the argv array shall be modi�able by the program." But the argv array
_itself_ is _not_ required to be modi�able.

The following buggy code only works well when argc >=2 and
strlen(argv[1]) >=1:

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
Â* Â* Â* Â* char buf[2] = {0};
Â* Â* Â* Â* strcpy(argv[1], buf);
Â* Â* Â* Â* return 0;

}

I guess making that modifiable may be considered for exec*() functions
or for the recursion of main(). And the maximum length maybe found in
POSIX.

No. in VC++ 2005 Express Edition, it allows us to copy, say, "test
message" onto argv[0] itself. Prior to modification argv[0] happened
to be the execautable name. Anyway, I just asked this question for
learning purpose.

[Cong Wang]

On Mar 14, 9:51Â*pm, "subramanian10. [e-mail], India"
<subramanian10. [e-mail] te:

On Mar 14, 6:41Â*pm, "Cong Wang" <xiyou.wangc... @gmail.comwrote :

On Mar 14, 9:09Â*pm, "subramanian10. [e-mail], India"

<subramanian10. [e-mail] te:

The standard allows that we can copy strings onto arg[0], arg[1], etc.
Why is it allowed ?
What can be the maximum length of such a string that is copied ?

Well. There is still something to be clarify.

The standard just says "argc and argv and the strings pointed to by
the argv array shall be modi�able by the program." But the argvarray
_itself_ is _not_ required to be modi�able.

The following buggy code only works well when argc >=2 and
strlen(argv[1]) >=1:

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
Â* Â* Â* Â* char buf[2] = {0};
Â* Â* Â* Â* strcpy(argv[1], buf);
Â* Â* Â* Â* return 0;

}

I guess making that modifiable may be considered for exec*() functions
or for the recursion of main(). And the maximum length maybe found in
POSIX.

No. in VC++ 2005 Express Edition, it allows us to copy, say, "test
message" onto argv[0] itself. Prior to modification argv[0] happened
to be the execautable name. Anyway, I just asked this question for
learning purpose.

No for what?

Copying "test message" onto argv[0] is _not_ modifying argv[0] itself,
only changing the contents of the array which argv[0] points to.
What's more, copying to argv[0] is UB.

[subramanian100in]

On Mar 14, 7:13Â*pm, "Cong Wang" <xiyou.wangc... @gmail.comwrote :

On Mar 14, 9:51Â*pm, "subramanian10. [e-mail], India"

<subramanian10. [e-mail] te:

On Mar 14, 6:41Â*pm, "Cong Wang" <xiyou.wangc... @gmail.comwrote :

On Mar 14, 9:09Â*pm, "subramanian10. [e-mail], India"

<subramanian10. [e-mail] te:
The standard allows that we can copy strings onto arg[0], arg[1], etc.
Why is it allowed ?
What can be the maximum length of such a string that is copied ?

Well. There is still something to be clarify.

The standard just says "argc and argv and the strings pointed to by
the argv array shall be modi�able by the program." But the argv array
_itself_ is _not_ required to be modi�able.

The following buggy code only works well when argc >=2 and
strlen(argv[1]) >=1:

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
Â* Â* Â* Â* char buf[2] = {0};
Â* Â* Â* Â* strcpy(argv[1], buf);
Â* Â* Â* Â* return 0;

}

I guess making that modifiable may be considered for exec*() functions
or for the recursion of main(). And the maximum length maybe found in
POSIX.

No. in VC++ 2005 Express Edition, it allows us to copy, say, "test
message" onto argv[0] itself. Prior to modification argv[0] happened
to be the execautable name. Anyway, I just asked this question for
learning purpose.

No for what?

Copying "test message" onto argv[0] is _not_ modifying argv[0] itself,
only changing the contents of the array which argv[0] points to.
What's more, copying to argv[0] is UB.- Hide quoted text -

- Show quoted text -

I am sorry. Entire post of mine in this thread is wrong.

[=?utf-8?B?SGFyYWxkIHZhbiBExLNr?=]

On Mar 14, 1:41 pm, "Cong Wang" <xiyou.wangc... @gmail.comwrote :

On Mar 14, 9:09 pm, "subramanian10. [e-mail], India"

<subramanian10. [e-mail] te:

The standard allows that we can copy strings onto arg[0], arg[1], etc.
Why is it allowed ?
What can be the maximum length of such a string that is copied ?

Well. There is still something to be clarify.

The standard just says "argc and argv and the strings pointed to by
the argv array shall be modi�able by the program." But the argv array
_itself_ is _not_ required to be modi�able.

This came up on comp.std.c again recently. The intent is that the argv
array itself /is/ required to be modifiable, and the actual wording of
the standard can be argued to require the same.

[J. J. Farrell]

On Mar 14, 6:19 am, Richard Heathfield <[e-mail].i nvalidwrote:

subramanian10.. [e-mail], India said:

The standard allows that we can copy strings onto arg[0], arg[1], etc.
Why is it allowed ?

Good question. Why indeed? It's a stupid stupid stupid idea, if ever
there was one.

As with many aspects of Standard C it was to support common pre-
existing practice. In UNIXes of the time the ps command could be used
to view the current argv data. Programs made use of this facility
either to hide the parameters they were invoked with (for example, if
a password was passed as a command line option) or to make application
status information available through ps (sendmail did this if I
remember correctly). I don't know if modern UNIXes and similar still
use this.

[CBFalconer]

Cong Wang wrote:

>

.... snip ...

>
The standard just says "argc and argv and the strings pointed to
by the argv array shall be modi�able by the program." But the
argv array _itself_ is _not_ required to be modi�able.

^^^
I fail to understand why this char-set cannot include the normal
coding for 'f' and 'i', thus causing abnormal displays.

>
The following buggy code only works well when argc >=2 and
strlen(argv[1]) >=1:

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
char buf[2] = {0};
strcpy(argv[1], buf);
return 0;
}

I guess making that modifiable may be considered for exec*()
functions or for the recursion of main(). And the maximum length
maybe found in POSIX.

There are _no_ restrictions against modifying argv and argc. After
all, those are values local to main. The only restrictions are
against modifying *argv (forbidden) and *argv[i] (for i <= argc),
which is not allowed to extend the length of the string argv[i].
So this has nothing to do with any possible recursive call to main.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net>

--
Posted via a free Usenet account from http://www.teranews.com