ch = getchar();
ret = ch == 'y';
while (ch != EOF && ch != '\n') {
    ch = getchar();
}
return ret;

ret = ch == 'y';

if (ch == 'y') {
    ret = 1;
} else {
    ret = 0;
}

- Make a test.c file, like you have.
- Declare a local variable "char *ret" to be the return from fgets().
- Test that value.
- Print that value.  If the return fails (NULL in this case) print out errno; include <errno.h>
- Compilation command would be something like: gcc test.c -o test -ggdb
  - gcc - compile, you probably know
  - -o directs the output to be test versus "a.out"
  - -ggdb - should enable GDB debugging, although I think it may be available anyways.
- Run the program using: gdb test, you'll get a gdb prompt.
- Set breakpoints like: b test.c:32 - sets breakpoint in test.c at line 32; it should be a code line; otherwise it may set the breakpoint at the next code line it feels is appropriate.
- You can set more than one breakpoint.
- Type run, to run it.  Note if you have arguments for your program you can set them either entering GDB or at the GDB prompt, read up on GDB for advanced stuff.
- Once you hit a breakpoint, you can do stuff like "print" or "examine" variables and memory:
p str - prints the variable str; it will print the legal string that str has.
x/32b str - examines the array str, byte by byte and prints out the decimal value of each array entry, there's a way to change it to show you hex, here's an online ASCII table which shows hex, ascii, octal, decimal; I find that more helpful than constantly relearning something I always forget to do in gdb. Ascii Table.

Other GDB commands:
s - single step
c - continue either to end, or if it hits a breakpoint, or runs forever because there's a loop (CTRL-C will get you out)
quit - quit GDB, it may complain that you have a process running, you intend to quit, so do so.

ch = getchar();
ret = ch == 'y';
while (ch != EOF && ch != '\n') {
    ch = getchar();
}
return ret;

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>

#define	ERRORLINELEN	1024

void pr_stdio(const char *name, FILE *fp);
static void	err_doit(int, int, const char *, va_list);
void sys_err(const char *fmt, ...);

/*   NOTE: we perform I/O on each stream before printing its buffering
     status, since the first I/O operation usually causes the buffers to
     be allocated for a stream.  The structure members:
        _IO_file_flags
        _IO_buf_base
        _IO_buf_end
     and the constants:
        _IO_UNBUFFERED
        _IO_LINE_BUF
     are defined by the GNU standard I/O library used on Linux.  Be aware
     that other UNIX systems may have different implementations of the
     standard I/O library.
*/
int main(int argc, char **argv) {
	FILE *fp;

	fputs("enter any character",stdout);
	if(getchar() == EOF)
		sys_err("getchar error");
	else
		putc('\n',stdout);
	fputs("one line to standard error\n",stderr);

	pr_stdio("stdin",stdin);
	pr_stdio("stdout",stdout);
	pr_stdio("stderr",stderr);

	fp = fopen("/etc/motd","r");
	if(!fp)
		sys_err("fopen error on /etc/motd");
	if(getc(fp) == EOF)
		sys_err("getc error");
	pr_stdio("/etc/motd",fp);
	exit(0);
}

void pr_stdio(const char *name, FILE *fp) {
	printf("stream = %s, ",name);

	/*	The following is nonportable */
	if(fp->_IO_file_flags & _IO_UNBUFFERED)
		printf("unbuffered");
	else if(fp->_IO_file_flags & _IO_LINE_BUF)
		printf("line buffered");
	else
		printf("fully buffered");
	printf(", buffer size = %d\n",fp->_IO_buf_end - fp->_IO_buf_base);
}

/*	sys_err: error related to a system call that needs to terminate
	processing.  Print a message and exit.
*/
void sys_err(const char *fmt, ...) {
	va_list		ap;

	va_start(ap, fmt);
	err_doit(1, errno, fmt, ap);
	va_end(ap);
	exit(1);
}

/*	err_doit: print a message and return to caller.
	Caller specifies "errnoflag".
*/
static void err_doit(int errnoflag,int error,const char *fmt, va_list ap) {
	char	buf[ERRORLINELEN];

	vsnprintf(buf, ERRORLINELEN, fmt, ap);
	if (errnoflag)
		snprintf(buf+strlen(buf),ERRORLINELEN-strlen(buf),": %s",strerror(error));
	strcat(buf, "\n");
	fflush(stdout);		/* in case stdout and stderr are the same */
	fputs(buf, stderr);
	fflush(NULL);		/* flushes all stdio output streams */
}

// read and save the first character
int first_char = getchar();
// read and ignore the rest 
while (1) {
    int ch = getchar();
    if (ch == EOF || ch == '\n') break;
}
ret = (first_char == 'y');
return ret;

fgets(input, 2, stdin);

ret = ch == 'n';

} while (loop_input == 1);