0

I am trying to execute a execv() command, the second parameter is a list of arguments to pass.

My arguments are currently held in a string format i.e

--config=moo --console --something=moo2 --path="this can have spaces" --format=x

What I'd like to do is split this up into char** parmeters i.e

argv[0] = "--config=moo"
argv[1] = "--console"

What I don't quite get is one thing (and apologies, its been a very long time since I last used C). If I want to build a string up to put into this argv array how would I do it, for example :- 

char* argv[10];
char* myPath = getMyPath();
argv[0] = "--config=moo";
argv[1] = ... ... ... 
...
...
argv[10] = "--path=" + myPath;

I believe this wouldn't be allowed in C since I have to allocate all memory in advance so by allocating the argv to be 10 elements, I can't then go and define each one individually.. or can I?

I know the + modifier doesn't work in C, but I'm unsure what function I would need to replicate it (I realise I can use strcat to add to an existing defined array, but didn't think this would work with a newly formed array)

Improve this question
1
  • 1
    Welcome to the world of C string manipulation... It's easy, but first, only try to realize the truth... There are no strings. Commented Apr 6, 2013 at 17:59

4 Answers 4

Reset to default
1

General malloc

man malloc may be helpful. malloc takes the minimum number of bytes you need of memory (i.e. malloc can choose to provide you more). So if you need exactly 10 elements in your char array, it may be best to simply allocate char* argv[10] as you have already done. However, this creates a container for exactly 10 char* which are not yet defined. Thus, for each char*, argv[0]...argv[9] you can define exactly what goes in there. For instance, if you want to malloc a string of size 200 for argv[0], you would use a statement as follows (notice that 200 can be held in either a constant or a variable):

argv[0] = malloc(200 * sizeof(char));

Generally, sizeof(char) == 1 byte, so this value is probably going to try to get 200 bytes. However, at this point you can modify argv[0] in any way you need to (i.e. strncpy, strncat, etc.).

Now, if you do not know how many arguments you may have, you can allocate your container on the fly. So instead of char* argv[10], you can try to allocate a char** argv. To do this, you would execute the following statement:

int SOME_SIZE = 1500 ; // Or some dynamic value read, etc.
char** argv = malloc(SOME_SIZE * sizeof(char*));

Often times the sizeof(char*) == 4 bytes on a 32-bit system (size of a typical pointer). Now you can use this chunk of memory, argv, in a similar way that has been done before. For ease of thinking about this, using malloc in this way allowed you to perform a relatively equivalent operation of char* argv[WITH_SOME_DYNAMIC_NUMBER]. Thus, you can manipulate this new container in a similar way as I have described above.

Remember though, when you are done with memory created by malloc, you must call free or else it will not be deallocated until the program terminates.

Your Problem

If I understand your question correctly, you have a flattened string which you want to turn into a string array for execve. I will work out a simple example trying to explain one of the many ways this can be done.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void someMethod()
{
  char* argv[10];
  char* path = getMyPath();

  // Notice - this is a little messy and can/should be encapsulated away in another
  // method for ease of use - this is to explicitly show, however, how this can work.
  argv[9] = malloc((strlen(path) + strlen("--path=") + 1) * sizeof(char));
  strncpy(argv[9], "--path=", strlen("--path="));
  argv[9][strlen("--path=")] = '\0'; // NULL-terminate since strncpy doesn't
  strncat(argv[9], path, strlen(path));

  // Do stuff with array
  printf("%s\n", argv[9]);

  // Technically, you should never get here if execve succeeds since it will blow this
  // entire program away (unless you are fork()'ing first)
  free(argv[9]);
}
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

1

you can malloc the memory that strcat() will use, or you can use a larger-than-needed char buffer[N] on the stack.

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


const char * someFunction();

int main(int argc, char ** argv) {

  const char[] path = "commandName";
  const char[] arg1 = "--config=moo";
  const char[] arg2 = "--console";
  const char[] arg3 = "--something=moo2";
  //arg4 is skiiped
  const char[] arg5 = "--format=x";

  const char * mypath = someFunction();
  const char[] pathprefix = "--path=";

  size_t pathprefixlength = strlen(pathprefix);
  size_t stringlength =  pathprefixlength + strlen(mypath);

  char * arg4 = (char *)malloc(stringlength + 1);

  strcpy(arg4, pathprefix);
  strcpy(arg4 +  pathprefixlength, mypath);

  arg4[stringlength] = '\0'; //null terminate
  char *argvec[7]; // array of pointers
  argvec[0] = path;
  argvec[1] = arg1;
  argvec[2] = arg2;
  argvec[3] = arg3;
  argvec[4] = arg4;
  argvec[5] = arg;
  argvec[6] = NULL;
  //do something with argvec;
  free(arg4);
}
Improve this answer

2 Comments

Can you give me a sample on how to malloc the memory that it'll use? I think my biggest issue is that its a array of an array of chars here, probably just confusing myself.
It contributed yes thanks, I've voted up, afraid RageD slightly beat you to an answer though.
0 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* strcata(char* s1, char* s2){
    char *p;
    p=(char*)malloc(sizeof(char)*(strlen(s1)+strlen(s2)+1));
    if(p == NULL) return NULL;

    *p='\0';

    return strcat(strcat(p, s1), s2);
}

int main(int argc, char *argv[])
{
    char *p;

    p=strcata("--path=", ".:./bin");
    printf("%s\n", p);

   return 0;
}
Improve this answer

Comments

0

You can use malloc for dynamic memory allocation

For Example let say we have following simple structure:

struct myRecord {

 char firstName[60];

 char lastName[60];

 int employeeID;

 struct myRecord * nextRecord;

};

struct myRecord * headPtr; // point to first structure in the list
// This line allocates memory for the first record:
headPtr = (struct myRecord *)malloc(sizeof(myRecord));
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.