String read in by fgets doesn't write newline with fputs

I am writing a program that takes in user input on a person's details that consists of name, ID and phone number. I am limiting my ID and phone number to be maximum of 14 and 13 characters respectively (excluding newline char) - e.g. 010203-1234567 for ID and 010-1111-2222 for phone number. By right if I understood correctly, fgets should automatically add in a newline byte after it reads in a string from user input and fputs should write the newline at the end of the string stored in id and phoneNum, but when try to input more characters than allowed, e.g. 010203-12345678 for ID, the following fputs doesn't write out the newline as it should. How do I ensure even if the user inputs more characters than allowed, the newline is written out by fputs?

Following is my code:

#include <stdio.h>

void FlushInputBuf(void)
{
    while (getchar() != '\n');
}

int main(void)
{
    FILE *fp = fopen("details.txt", "wt");
    if (fp == NULL)
    {
        puts("File open failed.\n");
        return -1;
    }
    char name[20];
    char id[15];
    char phoneNum[14];

    printf("Enter name: ");
    fgets(name, sizeof(name), stdin);
    printf("Enter ID: ");
    fgets(id, sizeof(id), stdin);
    FlushInputBuf();
    printf("Enter phone number: ");
    fgets(phoneNum, sizeof(phoneNum), stdin);

    fputs("#Name: ", fp);
    fputs(name, fp);
    fputs("#SSID: ", fp);
    fputs(id, fp);
    fputs("#Phone number: ", fp);
    fputs(phoneNum, fp);
  
    fclose(fp);

    return 0;
}

I am assuming input for name will not be longer than 20.
When I input ID to be 010203-1234567 and phone number to be 010-1111-2222 I get the following result in details.txt:

#Name: John
#SSID: 010203-1234567#Phone number: 010-1111-2222

How do I get the code to write to details.txt as following:

#Name: John
#SSID: 010203-1234567
#Phone number: 010-1111-2222

> By right if I understood correctly, fgets should automatically add in a newline char after it reads in a string from user's input

No. fgets() will copy characters into the buffer until it runs out of room (while reserving space for a string terminator), or it has copied a newline. It does not add any newline that wasn't in the input already, and (therefore) it cannot ensure that there is a newline at the end of the string. Often there is one, but if your buffer is too small for the whole line then there won't be. That's the primary way to tell whether you got a full line.

> fputs should write the newline char at the end of the string stored in id and phoneNum

Yes, fputs will write any newlines appearing in the specified string. That none are being printed is strong evidence that none are being read into your id (and phoneNum) buffer.

> when try to input more characters than allowed, e.g. "010203-12345678" for ID, the following fputs doesn't write out the newline as it should.

It doesn't print a newline as you expected. But it it is doing exactly what it should.

Your id array is 15 chars long, which is big enough for 14 characters of ID and one null terminator. Accordingly, fgets stops reading after copying the 14th character, the '7', and terminates the string with the last byte of the buffer. Your FlushInputBuf() function then reads and discards the tail of the line, up to and including the next newline. No newline is stored. The same thing will happen with an entry that is exactly 14 characters, too. And if the ID entered is shorter than that, then the FlushInputBuf() call will force you to type a second newline before it prompts for the phone number (and will discard anything else you type before that).

A good way to do this would be

1. Provide a buffer at least long enough to accommodate the expected input, plus an newline, plus a string terminator.

   #define MAX_ID_LENGTH 14
   // ...
   char id[MAX_ID_LENGTH + 2];
   

   Sometimes it's advantageous to allow for a little more than you actually expect.

2. After the fgets() call, check for a newline in the buffer. Consume the tail of the input line only if there is any -- that is, if no newline was already read.

   size_t newline_pos = strcspn(id, "\n");
   if (id[newline_pos] != '
   size_t newline_pos = strcspn(id, "\n");
   if (id[newline_pos] != '\0') {
   assert(id[newline_pos] == '\n');
   FlushInputBuf();
   }
   ') {
       assert(id[newline_pos] == '\n');
       FlushInputBuf();
   }
   

3. Validate or at least fix up the input. In particular, remove the newline, if present, since it is not actually part of the ID.

   id[newline_pos] = '
   id[newline_pos] = '\0';
   ';
   

   Reject or truncate IDs that are otherwise too long.

   // maybe:
   id[MAX_ID_LENGTH] = '
   // maybe:
   id[MAX_ID_LENGTH] = '\0';
   ';
   

   Perform any other validations that are appropriate.

4. Print newlines to the output manually where you want them. In your particular case, I would use one fprintf() call in place of each pair of fputs() calls, with newlines placed appropriately in the formats.

   fprintf(fp, "#SSID: %s\n", id);
   

   But if you must use fputs() only, then you can instead add a fputs("\n", fp);.

   If you were not concerned about the effects of short entries (which you should be), then this step would be sufficient by itself.

In addition to @JohnBollinger's excellent response, here is a modified version of your code, using an ancillary function for controlled user input:

#include <errno.h>
#include <stdio.h>
#include <string.h>
int input_string(const char *prompt, char *dest, int size) {
int c;      // byte read from stdin
int i = 0;  // index into dest
int n = 0;  // number of bytes read excluding the newline
printf("%s", prompt);
/* ensure prompt is visible (necessary on some older systems) */
fflush(stdout);
/* read all bytes from the user input line */
while ((c = getchar()) != EOF && c != '\n') {
if (i + 1 < size) {
/* append the character to dest, space permitting */
dest[i++] = (char)c;
}
n++;
}
if (size > 0) {
// set the null terminator
dest[i] = '\0';
}
if (n >= size) {
printf("discarded %d extra characters\n", n - size - 1);
}
if (c == EOF) {
if (i == 0)
printf("premature end of file\n");
return EOF;
} else {
printf("missing newline at end of file\n");
}
}
/* return the number of characters stored into dest */
return i;
}
int main(void) {
FILE *fp = fopen("details.txt", "w");
if (fp == NULL) {
fprintf(stderr, "Failed to open %s: %s\n", "details.txt",
strerror(errno));
return 1;
}
char name[20];
char id[15];
char phoneNum[14];
if (input_string("Enter name: ", name, sizeof(name)) < 0
||  input_string("Enter ID: ", id, sizeof(id)) < 0
||  input_string("Enter phone number: ", phoneNum, sizeof(phoneNum)) < 0) {
fprintf(stderr, "Missing input\n");
fclose(fp);
return 1;
}
fprintf(fp, "#Name: %s\n", name);
fprintf(fp, "#SSID: %s\n", id);
fprintf(fp, "#Phone number: %s\n", phoneNum);
fclose(fp);
return 0;
}