C-program on macOS cannot open its input file

Question

I have a C-program built on macOS High Sierra using gcc and a makefile. The first thing the program does is read a binary inputfile. The filename can be either specified from the terminal command line together with the shell command or the program will ask for it when it’s not specified.

My issue is that when the input file is not specified together with the shell command, the program returns an error, saying it cannot open the file.

Here’s what works and what doesn’t: (program and input file are in the same directory)

1. open terminal
2. from the command line type:

   ./program_name –i input.dat

=> works fine

1. open terminal
2. from the commandline type:

   ./program_name

3. program prompts: Inputfile:
4. I type: input.dat

=> error opening file

1. open Finder and go to directory with program and input file
2. doubleclick on program_name icon
3. program starts in terminal and prompts: Inputfile:
4. I type: input.dat

=> error opening file

I run the very same source code on linux and windows where it works ok, so I think it must be an OS thing that I don't understand?

I can add that the program was untrusted because it doesn't come from the app store. CTRL-click on the icon solved that.

--EDIT - sorry for not adding the verifyable code.

To clarify: the argc/argv part works fine. it's the last section of the routine where it prompts for the file name where it goes wrong. Maybe it's indeed the path as Jabberwocky suggested. I'll check on that tonight and will follow-up here.

void GetFileName(nr_args, args, filename, json)
 int  nr_args;
 char **args;
 char *filename;
 int* json;
{
  int i = 1;

  filename[0]  = '\0';

  /* the command 'interpreter' itself is stored in argv[0] */

  while (i<nr_args) {
    if (strcmp(args[i], "-e") == 0) {
  /* we cannot set the json flag here, because */
  /* flags have not been initialized yet       */
  *json = 1;
  i++;
}
else {
  if (strcmp(args[i], "-i") == 0) {
    if (nr_args > i+1) {
      /* inputfile was specified */
      strncpy(filename, args[++i], MAX_ID_LENGTH);
      i++;
        }
      }
      else {
        PrintError(41, NULL, args[i]);
        i++;
      }
    }
  }

  if (filename[0] == '\0') {
    printf("\n\nInputfile: ");
    scanf("%19s", filename);
    filename[MAX_ID_LENGTH] = '\0';
    /* clear the input buffer, to prevent parsing an */
    /* empty string as the first user command        */
    /* always do a getchar() independent of OS */
    getchar();

    printf("\n");
  }
}

And this is the part where the file is opened (from main() )

  /* Get filename */
  GetFileName(argc, argv, inputfile, &json);

  /* Open the datafile */
  if ((datafile = fopen(inputfile, "rb")) == NULL) {
    PrintError(40, NULL, inputfile);
    ExitProgram();
    return(OK);
  }

EDIT2-- As per Andrew Henle's reply, this is the prototype.

void    GetFileName(int, char**, char*, int*);

The function is called from the same file as it is defined in.

Answer 1

I run the very same source code on linux and windows where it works ok

That is meaningless.

This is an old K&R-style function definition:

void GetFileName(nr_args, args, filename, json)
 int  nr_args;
 char **args;
 char *filename;
 int* json;
{
   ...

You can not call that function safely if the calling code uses a function prototype. A K&R-defined function expects all of its arguments to have underdone default argument promotion. A prototype for the function means the caller won't perform those promotions. The mismatch will result in undefined behavior.

Don't use such ancient functions. You can't use them with a prototype, and without a prototype you have no type safety in the function call.

Use a proper, C standard-compliant function definition:

void GetFileName( int  nr_args, char **args, char *filename, int* json )
{
...

And then provide a proper prototype for all calls to the function.

Answer 2

I made the following routine that works for me.

So, as an example:

• if the program is in location /usr/mac/my-name/programs/
• and the input filename that was entered is input.dat

Then this routine will return: /usr/mac/my-name/programs/input.dat

Thanks for all your help.

#include <sys/param.h>    /* realpath()            */
#include <limits.h>       /* PATH_MAX              */
#include <mach-o/dyld.h>  /* _NSGetExectablePath() */

char *GetFullPath(const char*);

#define MAX_FILENAME_LEN 100   /* or another value */


char *GetFullPath(const char *filename)
{
  char      path_buf[PATH_MAX + 1];
  char      resolved_name[PATH_MAX + 1];
  char      *real_path;
  char      *return_path;
  uint32_t  buf_size = sizeof(path_buf);
  int       index    = 1;

  /* this functions returns the full path of the current */
  /* running application appended with var 'filename' at */
  /* the end. In case of an error it returns NULL.       */

  if ((return_path = (char *) malloc(MAX_FILENAME_LEN)) == NULL) {
    printf("GetFullPath(): error in Malloc()\n");
    return(NULL);
  }

  /* get relative path */
  if (_NSGetExecutablePath(path_buf, &buf_size) != 0) {
    /* buffer too small */
    printf("File Path too long.");
    free(return_path);
    return(NULL);
  }

  /* convert to absolute path */
  if ( (real_path = realpath(path_buf, resolved_name)) == NULL) {
    printf("Could not determine path.\n");
    free(return_path);
    return(NULL);
  }

  /* strip the application name from the end of the path */
  index = strlen(real_path) - 1;
  while (real_path[index] != '/') {
    index--;
  }

  /* now check if there's enough room in return_path */
  if (strlen(real_path) + strlen(filename) >= MAX_FILENAME_LEN) {
    printf("File path too long.\n");
    free(return_path);
    return(NULL);
  }

  /* there's enough room, copy path and filename to return_path */
  strncpy(return_path, real_path, index+1);
  /* do not try to free() real_path */
  return_path[index+1] = '\0';
  strncat(return_path, filename, strlen(filename));

  return(return_path);  /* caller must free() return_path */
}