A variable cannot be "empty." It always has a value.

You can manually specify a value, which indicates "emptiness" as done with strings: a null byte (with the value 0) indicates the end of the string. Here, it's not emptiness per se but you get what I mean, hopefully.

Because a variable cannot be empty, there is no common NaN value for it; every value is a number, so NaN (not a number) does not make sense.
The floating-point format IEEE 754 supports NaN values but that is only possible because certain values of floating-point numbers have been assigned that meaning.

Change:

char *filename;

To:

char *filename = NULL;

Then your NULL tests will work.

When you don't initialize this pointer, its value is undefined. That's why your tests were failing. The compiler assumed that you didn't care what value it had.

Since C-style strings are always terminated with the null character (\0), you can check whether the string is empty by writing

do {
   ...
} while (url[0] != '\0');

Alternatively, you could use the strcmp function, which is overkill but might be easier to read:

do {
   ...
} while (strcmp(url, ""));

Note that strcmp returns a nonzero value if the strings are different and 0 if they're the same, so this loop continues to loop until the string is empty.

Hope this helps!

In C and C++, pointers are inherently unsafe, that is, when you dereference a pointer, it is your own responsibility to make sure it points somewhere valid; this is part of what "manual memory management" is about (as opposed to the automatic memory management schemes implemented in languages like Java, PHP, or the .NET runtime, which won't allow you to create invalid references without considerable effort).

A common solution that catches many errors is to set all pointers that don't point to anything as NULL (or, in correct C++, 0), and checking for that before accessing the pointer. Specifically, it is common practice to initialize all pointers to NULL (unless you already have something to point them at when you declare them), and set them to NULL when you delete or free() them (unless they go out of scope immediately after that). Example (in C, but also valid C++):

void fill_foo(int* foo) {
    *foo = 23; // this will crash and burn if foo is NULL
}

A better version:

void fill_foo(int* foo) {
    if (!foo) { // this is the NULL check
        printf("This is wrong\n");
        return;
    }
    *foo = 23;
}

Without the null check, passing a NULL pointer into this function will cause a segfault, and there is nothing you can do - the OS will simply kill your process and maybe core-dump or pop up a crash report dialog. With the null check in place, you can perform proper error handling and recover gracefully - correct the problem yourself, abort the current operation, write a log entry, notify the user, whatever is appropriate.

The behavior of isInteger should be defined (or explicitly undefined) for any inputs. It's not unreasonable to leave the behavior of isInteger(NULL) undefined, requiring the caller to pass a valid string pointer.

As unwind's answer suggests, isInteger should probably return false (0) for an empty string.

But if you want to check for an empty string yourself, you can check for a length of 0:

char *aux;
aux=getenv("MAX_OUTPUT");
if (aux==NULL || strlen(aux) == 0 || !(isInteger(aux))){
/*code*/
}

Or, equivalently, you can check whether the first (0th) character of the string is the terminating null '\0' character:

char *aux;
aux=getenv("MAX_OUTPUT");
if (aux==NULL || *aux == '\0' || !(isInteger(aux))){
/*code*/
}

*aux can also be written as aux[0].

Note that this doesn't check for, for example, aux containing a single blank: " ", but again, isInteger should probably handle that.

Assuming that isInteger behaves reasonably, returning a true result for any string that looks like an integer and a false result for any string that doesn't (and perhaps with undefined behavior for a null pointer or a pointer that doesn't point to a valid string), then this:

if (aux == NULL || !isInteger(aux)) {
    /* it's not an integer */
}

should be sufficient.

Check if the first character is '\0'. You should also probably check if your pointer is NULL.

Copychar *c = "";
if ((c != NULL) && (c[0] == '\0')) {
   printf("c is empty\n");
}

You could put both of those checks in a function to make it convenient and easy to reuse.

Edit: In the if statement can be read like this, "If c is not zero and the first character of character array 'c' is not '\0' or zero, then...".

The && simply combines the two conditions. It is basically like saying this:

Copyif (c != NULL) { /* AND (or &&) */
    if (c[0] == '\0') {
        printf("c is empty\n");
    }
}

You may want to get a good C programming book if that is not clear to you. I could recommend a book called "The C Programming Language".

The shortest version equivalent to the above would be:

Copyif (c && !c[0]) {
  printf("c is empty\n");
}