Char array, bzw string

#include <stdio.h>  // Fn_GetInput
#include <stdlib.h> // Fn_GetInput, Fn_GetLong
#include <string.h> // Fn_GetLong
#include <ctype.h>  // Fn_GetLong
#include <errno.h>  // Fn_GetLong

/* Benutzereingabe als nullterminierten String (ohne Zeilenumbruch) lesen mit dynamischer Speichererweiterung */
int Fn_GetInput(char ** const pszInput_out, size_t * const pcchLength_out)
{
  size_t ic = 0; // Index im Puffer - später Anzahl Zeichen
  int ch = EOF; // hält später den ASCII Wert des eingelesenen Zeichens
  char *szBuffer = malloc(1), *pchMoreSpace = NULL; // Speicher für den Puffer reservieren, Pointer für eine Puffererweiterung deklarieren
  if (pszInput_out) *pszInput_out = NULL; // Initialwert
  if (pcchLength_out) *pcchLength_out = 0; // Initialwert
  if (szBuffer) // wenn malloc() erfolgreich war
  {
    while ((ch = fgetc(stdin)) != '\n' && ch != EOF && !feof(stdin)) // lese das (nächste) Zeichen, iteriere solang das Zeichen kein Zeilenumbruch ist und nicht das Ende des eingehenden Streams erreicht ist  
    {
      szBuffer[ic++] = ch; // weise das Zeichen der aktuellen Position (ic=Index) im Puffer zu und erhöhe danach um 1 (ic++=nächster Index=Stringlänge)
      pchMoreSpace = realloc(szBuffer, ic + 1); // Puffergröße um 1 erweitern
      if (!pchMoreSpace) // falls die Erweiterung fehlgeschlagen ist
      {
        free(szBuffer); // Speicher freigeben
        return EXIT_FAILURE; // Fehler, raus hier
      }
      szBuffer = pchMoreSpace; // neuen Pointer der Variablen szBuffer zuweisen
    }
    szBuffer[ic] = 0; // Nullterminierung
    if (pszInput_out)
      *pszInput_out = szBuffer; // Pointer zum Puffer geht nach draußen
    else
      free(szBuffer); // falls ein Nullpointer übergeben wurde, Speicher freigeben
    if (pcchLength_out) *pcchLength_out = ic; // Anzahl eingelesener Zeichen geht nach draußen
  }
  return (szBuffer == NULL); // 0 (EXIT_SUCCESS) wenn szBuffer nicht NULL
} // ACHTUNG: Reservierten Speicher in der aufrufenden Funktion freigeben!

/* C-String zu Long Integer */
unsigned Fn_GetLong(const char * const szNum_in, const int iBase_in, long * const pNum_out)
{
  char *szCpy = NULL, *szTrunc = NULL, *pchEnd = NULL; // szCpy bekommt eine Kopie von szNum_in, szTrunc bekommt einen Pointer zum ersten Zeichen in szCpy das kein Whitespace ist, der Variablen pchEnd wird strtol() den Pointer zuweisen, an dem die Verarbeitung abgebrochen wurde
  unsigned rgbitRet = 0; // zurückgegebene Fehlerbits
  if (pNum_out) *pNum_out = 0; // Initialwert
  if (!szNum_in || !pNum_out || iBase_in < 0 || iBase_in > 36 || iBase_in == 1) return 8; // wenn einer der übergebenen Pointer NULL ist oder iBase_in nicht zwischen 0 und 36 liegt bzw. 1 ist, Fatal Error und raus hier
  szCpy = malloc(strlen(szNum_in) + 1); // Speicher für szCpy reservieren
  if (!szCpy) return 8; // wenn malloc() fehlgeschlagen ist, Fatal Error und raus
  szTrunc = strcpy(szCpy, szNum_in); // String kopieren, um nicht über ein Cast letztlich doch im als konstant deklarierten Speicherbereich von szNum_in arbeiten zu müssen
  while (isspace(*szTrunc)) ++szTrunc; // führende Whitespaces "abschneiden", danach zeigt der Pointer auf das erste Zeichen innerhalb szCpy das kein Whitespace ist 
  errno = 0; // der Integerwert errno wird durch strtol() mit der Konstante ERANGE befüllt, wenn der Bereich eines Long Integer überschritten wird
  *pNum_out = strtol(szNum_in, &pchEnd, iBase_in); // die eigentliche C Funktion String zu Long Integer
  if (ERANGE == errno) rgbitRet |= 4; // Zahl außerhalb Typbreite?
  if // hier soll betrachtet werden, ob strtol() 0 zurückgibt, weil "0" gelesen wurde, oder weil kein numerischer String zu extrahieren war - Bsp.: "0$" OK, "$" nicht OK 
  (
    *pNum_out == 0 // sollte strtol() etwas anderes als 0 zurückgeben, OK und der Rest braucht nicht betrachtet zu werden
    && ! // das ! beachten
    (
      szTrunc == 48 // wenn das erste Zeichen '0' ist, dann OK 
      || // oder
      (
        (szTrunc == 43 || szTrunc == 45) // wenn das erste Zeichen '+' oder '-' ist ... 
        && szTrunc[1] == 48 // ... und das zweite Zeichen '0', dann auch OK 
      )
    )
  ) rgbitRet |= 4; // Ergo: Folgt nach ggf. abgeschnittenen führenden Whitespaces ein Teilstring, der nicht numerisch interpretiert werden konnte?
  free(szCpy); // Speicher freigeben
  if (*pchEnd) rgbitRet |= 2; // Abbruch nicht an Nullterminierung?
  if (isspace(*szNum_in)) rgbitRet |= 1; // Whitespace am Stringanfang?
  return rgbitRet; // 0 wenn OK, sonst Flags: 2^0 - Whitespaces am Stringanfang, 2^1 - Stringende nicht numerisch, 2^2 - nicht numerisch interpretierbar oder numerischer Stringteil außerhalb Typbreite, (2^3 - Fatal Error, siehe oben)
}

// wenn Fn_GetLong() eine Zahl von 1 bis 3 zurückgibt, war strtol() in der Lage einen Long Integer vom Stringanfang zu extrahieren
#define OK  0
#define ERR 4

int main(void)
{
  char *szStr = NULL;
  size_t cchLen = 0;

  long lNum = 0;
  unsigned rgbitFlags = -1, i = 0;
  const char * const rgszErrMsg[4] = {"vorangestellte Whitespaces", "Abbruch vor Stringende", "nicht als Long Integer interpretiertbar", "Anwender-/Verarbeitungsfehler"};  
  const char * const rgszAckMsg[4] = {"keine vorangestellten Whitespaces", "Abbruch am Stringende", "als Long Integer interpretiertbar", "kein Anwender-/Verarbeitungsfehler"};  

  if (EXIT_SUCCESS == Fn_GetInput(&szStr, &cchLen)) // Benutzereingabe einholen und auf Verarbeitungsfehler prüfen.
  {

    printf("\nFn_GetInput:\n Laenge: %u\n String: %s\n", cchLen, szStr); // Anzeigen, was wir bekommen haben.  

    rgbitFlags = Fn_GetLong(szStr, 10, &lNum); // Versuch die Benutzereingabe als Long Integer zu interpretieren.

    free(szStr); // Speicher (reserviert in Fn_GetInput()) freigeben, da szStr nicht länger benötigt wird!

    // Beispiel, wie man auf die einzelnen Flags zugreifen könnte.
    puts("\nFn_GetLong:\n Fehlerflags");  
    for (; i < 4; ++i)
    {
      if ((rgbitFlags >> i) & 1)
        fprintf(stderr, "  1 - %s\n", rgszErrMsg[i]);  
      else
        printf("  0 - OK (%s)\n", rgszAckMsg[i]);  
    }

    // Beispiel, wie man den Rückgabewert weiterhin interpretieren kann.
    if (rgbitFlags == OK)
    {
      printf(" Gesamter String konnte als Long Integer interpretiert werden:\n  %ld\n", lNum);  
      return EXIT_SUCCESS;
    }
    else if (rgbitFlags < ERR)
      {
        printf(" Long Integer wurde aus Teilstring extrahiert:\n  %ld\n", lNum);  
        return EXIT_SUCCESS;
      }
      else
      {
        fprintf(stderr, " String/-anfang konnte nicht als Long Integer interpretiert werden.\n");  
        return EXIT_FAILURE;
      }
  }

  fprintf(stderr, "Fn_GetInput: Verarbeitungsfehler.\n");  
  return EXIT_FAILURE;
}