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

int main (void) {
    
    char s1[] = { 't', 'e', 's', 't', '\0' };
    char s2[] = { 't', 'e', 's', '\0' };
    int result = strcasecmp(s1, s2);

    printf("s1 = %s\n", s1);
    printf("s2 = %s\n", s2);
        
    if ( result == 0 ) {
       puts("Strings are equal");
    }
    else {
         puts("Strings are not equal");
    }

    return 0;
}

[james@jamespc devel]$ ./strcasecmp_example 
s1 = test
s2 = tes
Strings are not equal

     stat *infobuffer_pointer;
     int return_code;

     return_code = stat ("/path/to/file", infobuffer_pointer);
     if (return_code == -1)                       //stat returned an error
     {
          if (errno == ENOENT)                    //error was "No such entity"
          {
               printf ("No such file as /path/to/file");
          }
          else
          {
               printf ("File exists but can't be opened");  
          }
          exit(1);     //no point in continuing!            
     }

/* Copyright (C) 1991-2019 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#include <string.h>


/* Parse S into tokens separated by characters in DELIM.
   If S is NULL, the last string strtok() was called with is
   used.  For example:
	char s[] = "-abc-=-def";
	x = strtok(s, "-");		// x = "abc"
	x = strtok(NULL, "-=");		// x = "def"
	x = strtok(NULL, "=");		// x = NULL
		// s = "abc\0=-def\0"
*/
char *
strtok (char *s, const char *delim)
{
  static char *olds;
  return __strtok_r (s, delim, &olds);
}

/* Reentrant string tokenizer.  Generic version.
   Copyright (C) 1991-2019 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <string.h>

#ifndef _LIBC
/* Get specification.  */
# include "strtok_r.h"
# define __strtok_r strtok_r
#endif

/* Parse S into tokens separated by characters in DELIM.
   If S is NULL, the saved pointer in SAVE_PTR is used as
   the next starting point.  For example:
	char s[] = "-abc-=-def";
	char *sp;
	x = strtok_r(s, "-", &sp);	// x = "abc", sp = "=-def"
	x = strtok_r(NULL, "-=", &sp);	// x = "def", sp = NULL
	x = strtok_r(NULL, "=", &sp);	// x = NULL
		// s = "abc\0-def\0"
*/
char *
__strtok_r (char *s, const char *delim, char **save_ptr)
{
  char *end;

  if (s == NULL)
    s = *save_ptr;

  if (*s == '\0')
    {
      *save_ptr = s;
      return NULL;
    }

  /* Scan leading delimiters.  */
  s += strspn (s, delim);
  if (*s == '\0')
    {
      *save_ptr = s;
      return NULL;
    }

  /* Find the end of the token.  */
  end = s + strcspn (s, delim);
  if (*end == '\0')
    {
      *save_ptr = end;
      return s;
    }

  /* Terminate the token and make *SAVE_PTR point past it.  */
  *end = '\0';
  *save_ptr = end + 1;
  return s;
}
#ifdef weak_alias
libc_hidden_def (__strtok_r)
weak_alias (__strtok_r, strtok_r)
#endif

// int result = strcasecmp(resultstr, string);

int result = strcasecmp(chunk, string);

james@jamespc: devel> ./build_array
Original string: ffmpeg: -i: something: blah: blah: blah
chunk = ffmpeg
chunk not the same
resultstr = ffmpe

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

int main(void) {
  
    char string[100] = "ffmpeg: -i: something: blah: blah: blah";
    char resultstr[100] ="ffmpe" ;
    char *chunk;
       
    printf("Original string: %s\n", string);
        
    chunk = strtok(string, ":");
    printf("chunk = %s\n", chunk);
    int result = strcasecmp(chunk, string);
   // int result = strcasecmp(resultstr, string);
    if ( result == 0 ) {
      //  strcpy(resultstr, string);
       strcat(resultstr, chunk);
       while( chunk != NULL ) {
             chunk = strtok(NULL, ":");  
	     printf("Token: %s\n", chunk);
	     if (chunk) {
	        printf("chunk = %s\n", chunk);
                strcat(resultstr, chunk);
	     }
	   
       }
    }
    else {
            puts("chunk not the same");
    }
     
    printf("resultstr = %s\n", resultstr);
   
 // concatenate string in "s2" in "s1"
 //   strcat(s1, s2);
   
    return 0;

}

james@jamespc: devel> ./build_array
Original string: ffmpeg: -i: something: blah: blah: blah
chunk = ffmpeg
Token:  -i
chunk =  -i
Token:  something
chunk =  something
Token:  blah
chunk =  blah
Token:  blah
chunk =  blah
Token:  blah
chunk =  blah
Token: (null)
resultstr = ffmpeffmpeg -i something blah blah blah

// includes
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdbool.h>

char readConfigFile(char *argv[]);
//char readConfigFile(char *filename, char *formatID);
//char execFfmpeg(char ffargs[]);

// main function
int main(int argc, char *argv[]) {
  
    if ( argc < 4 ) {
       fprintf (stderr, "Missing option or filename\nUSAGE: ffcliFront <format_id> <input_file> <output_file>\n");
       return 1;
    }
    
    // check if input file exists
    FILE *inputfile;
        
    if ( (inputfile = fopen(argv[2], "r")) == NULL ) {
       fprintf(stderr, "Input file not found, exiting.\n");
       return 1;        
    }
    fclose(inputfile);
          
    readConfigFile(argv);
    //readConfigFile(argv[1], argv[2]);

    return 0;
    
}

//char readConfigFile(char *filename, char *formatID) {
char readConfigFile(char *argv[]) {

    char configLine[128];
    char ffargs[128];
    char *tokenPtr;
    bool foundStr = false;
                  
    // read config file
    FILE *configfile;
      
    if ( (configfile = fopen("ffcliFront.conf", "r")) == NULL )  {
       fprintf(stderr, "Configuration file not found, exiting.\n");
       return 1;        
    }
    
    printf("argv[1] = %s\n", argv[1]);
       
    while( fgets(configLine, 128, configfile ) != NULL) {
          printf("Line from config file: %s\n", configLine);
          tokenPtr = strtok(configLine, ","); 
          int result = strcasecmp(tokenPtr, argv[1]);
          if ( result == 0 ) {
   	     foundStr = true;
	     printf("Found string: %s\ntokenPtr = %s\n", configLine, tokenPtr);
	     strcpy(ffargs, "-i ");
             strcat(ffargs, argv[2]);
		 
             while( tokenPtr != NULL ) {
                   tokenPtr = strtok(NULL, ","); 
		   printf("Token: %s\n", tokenPtr);
	           if (tokenPtr) {
	              printf("tokenPtr = %s\n", tokenPtr);
	              strcat(ffargs, tokenPtr);
                   }
		      	 
             }
          //strcat(ffargs, argv[3]); 
	  break;	          
	  }
	       	      
    }
    if (foundStr == false) {
       fprintf(stderr, "\"%s\" format_id not found in configuration file, exiting.\nCheck ffcliFront.conf for a valid format_id or specify a format_id that exists.\n", argv[1]);
       return 1;
    }       
    fclose(configfile);
             
    printf("ffargs = %s\n", ffargs);
        
    // pass char array with ffmpeg args & call execFfmpeg() fuction with args from config file
   // execFfmpeg(ffargs);
 
    return 0;
}      

//char execFfmpeg(char ffargs[]) {
  
    //char *ffcmdline[128];  
     
    //printf("%s\n", ffargs); 
    // run fmpeg with args from config file & filename supplied to this program. 
    // execv ("ffmpeg", ffcmdline);
	
    //return 0;
//}

james@jamespc: ffcliFront> ./ffcliFront tes testinput out
argv[1] = tes
Line from config file: test, ffmpeg, ehe, te, teyeyyes, y, eye, yeh, eyh, eeee, eyeye, e, ey

Line from config file: test1, ffmpeg, ehe1, te, teyeyyes, y, eye, yeh, eyh, eeee, eyeye, e, ey

Line from config file: test2, ffmpeg, ehe2, te, teyeyyes, y, eye, yeh, eyh, eeee, eyeye, e, ey

Line from config file: 

Line from config file: 

Line from config file: 

"tes" format_id not found in configuration file, exiting.
Check ffcliFront.conf for a valid format_id or specify a format_id that exists.

james@jamespc: ffcliFront> ./ffcliFront test2 testinput out
argv[1] = test2
Line from config file: test, ffmpeg, ehe, te, teyeyyes, y, eye, yeh, eyh, eeee, eyeye, e, ey

Line from config file: test1, ffmpeg, ehe1, te, teyeyyes, y, eye, yeh, eyh, eeee, eyeye, e, ey

Line from config file: test2, ffmpeg, ehe2, te, teyeyyes, y, eye, yeh, eyh, eeee, eyeye, e, ey

Found string: test2
tokenPtr = test2
Token:  ffmpeg
tokenPtr =  ffmpeg
Token:  ehe2
tokenPtr =  ehe2
Token:  te
tokenPtr =  te
Token:  teyeyyes
tokenPtr =  teyeyyes
Token:  y
tokenPtr =  y
Token:  eye
tokenPtr =  eye
Token:  yeh
tokenPtr =  yeh
Token:  eyh
tokenPtr =  eyh
Token:  eeee
tokenPtr =  eeee
Token:  eyeye
tokenPtr =  eyeye
Token:  e
tokenPtr =  e
Token:  ey

tokenPtr =  ey

Token: (null)
ffargs = -i testinput ffmpeg ehe2 te teyeyyes y eye yeh eyh eeee eyeye e ey