C99 standard prog buggy with Linux but not Windows

Hello all. I've run into a problem I just can't figure out and I'm beginning to think it's my compiler. I'll attach the source file, it's rather long to post on this message. The problem is when get_data() is called from main() the first input (Enter First Name)is skipped completely. But when get_data() is called from continue_function(), it runs fine. There is also a problem with display_report(), but I'm not too concerned about that now; I think both problems are related.

I have no idea what the problem is. The strange thing is it runs-bug free on my friend's windows system (compiled with dev-c++), but is buggy with my Linux system.

Thank you all in advance!

P.S. This is a "type-and-run" program in book I'm trying to learn from. It's just basically a long program at the end of the chapter to pull together everything learned so far. It's supposed to collect information (you can see what sort of information in the struct before the start of main() I've replaced a few things, such as the gets() functions with fgets().

> fflush(stdin); /* remove extra characters from keyboard buffer */
Does absolutely nothing on any kind of operating system which isn't Microsoft.

If you want to argue about it, the bug is really in the M$ side, because it's doing something non-standard with a standard function.

This is why it's wrong - FAQ

This is a short-term fix - FAQ

The long-term fix is to replace all the varieties of input reading you have (scanf(), getchar()) with fgets() calls, and the whole flushing input problem goes away.

Your line in main should be replaced with

Code:

---

char buff[BUFSIZ];

//      ch = getchar();
//      fflush(stdin);  /* remove extra characters from keyboard buffer */
        fgets( buff, BUFSIZ, stdin );
        ch = buff[0];

---

Similarly, your use of scanf() later on should be replaced with a fgets() followed by a sscanf()

Quote:

---

Originally posted by Salem
The long-term fix is to replace all the varieties of input reading you have (scanf(), getchar()) with fgets() calls, and the whole flushing input problem goes away.

---

I've seen this show up with fgets() on Slackware Linux... I've been using:

Code:

---

#include <stdio.h>
#include "clearkb.h"

void clearkb(void)
{
  char junk[80];
  fgets(junk,80,stdin);
}

---

to get around it. (Ha, I got it outta a book ;-) )

Quote:

---

Originally posted by punkCow

Code:

---

#include <stdio.h>
#include "clearkb.h"

void clearkb(void)
{
  char junk[80];
  fgets(junk,80,stdin);
}

---

---

what if there's more then 80 char's left in the buffer? :rolleyes:

Then he can get them with another fgets call.

come on guys the easiest way for even infinite number of characters in the buffer

Code:

---

while(getchar()!='\n');

---

I would think this would be even better:

Code:

---

do
{
  ch=getchar();
}while( (ch != '\n') && (ch != EOF) );

---

Which is what I use for my input buffer flushing.

Thank you guys. I have the program working now. I wrote a function that I'd like to use to accept user input, but I'd like to get an opinion of someone more experienced.

Here goes...

Code:

---

void gstring(char *string, int string_length)
{
    char buffer[BUFSIZ];
    int counter;   

    fgets(buffer, BUFSIZ, stdin);
    for(counter = 0; counter < string_length; counter++)
            string[counter] = buffer[counter];
    string[string_length - 1] = '\0';
   
}

---

usage...

Code:

---

char sentance[20];

gstring(sentance, 20);

---

So basically if I only want 20 characters to be read, it'll read just the 20.. but not leave anything standing around in stdin.

I would like to have a function that's universal to strings that use arrays to allocate the memory and strings that use malloc() or some other memory allocation function to allocate the memory.

like if I were to do the following...

Code:

---

char *string;
string = malloc(80 * sizeof(char));

---

how could I just get 80 characters or less without leaving anything in stdin?

Thank you all again for reading this (long) post. I find all this "extra characters waiting in stdin" to be very troublesome and confusing.

Your code will do it, 99.999999% of the time. The only time it won't will be when some bozo decides to type in BUFSIZ or more characters. Assuming BUFSIZ is huge (or the default), probably not a problem.

Slightly modified, this might work a little better:

Code:

---

void gstring(char *string, int string_length)
{
    char buffer[BUFSIZ];
    int k;   

    fgets(buffer, BUFSIZ, stdin);
    buffer[string_length - 1] = '\0';      // clear at the max return length
    k = strlen(buffer)-1;                  // index of last character
    if (buffer[k] == '\n') buffer[k]= '\0'; // clear trailing return
    strcpy(string, buffer);                // copy buffer to return value
}

---

> The only time it won't will be when some bozo decides to type in BUFSIZ or more characters
The bozo typically being someone trying a buffer overflow attack on your code. At which point, you can reasonably do anything you like so long as you maintain the integrity of your code.

If your current fgets() buffer does not contain a newline, you can either read ahead until you do get a newline, or just leave it there for the next fgets() call to see if it still makes any sense.


> fgets(buffer, BUFSIZ, stdin);
For additional safety, you should check whether this returns NULL or not. If it does return NULL, buffer is undefined (and should not therefore be used).

> buffer[string_length - 1] = '\0';
pedantic: what if string_length > BUFSIZ

The use of the local buffer is pointless (and potentially dangerous). Just write to the memory provided as a pointer in the function parameter, for the specified length.

A considerably better solution for gstring would be to use fgets, remove the newline (if you need to. It can be useful sometimes), and return status codes to let the client know the state of both the buffer and the stream. The four minimum conditions you want to handle are success, extraneous data in the stream, end of file, and read error:

Code:

---

#include <stdio.h>
#include <string.h>

int prefgets ( char *buff, size_t size, FILE *in )
{
  int rc = 1;  /* Success */
 
  if ( fgets ( buff, size, in ) != NULL ) {
    char *newline = strrchr ( buff, '\n' );
    if ( newline != NULL )
      *newline = '\0';
    else
      rc = 2;  /* More input */
  }
  else {
    if ( feof ( in ) )
      rc = 0;  /* End of file */
    if ( ferror ( in ) )
      rc = -1; /* Read error */
  }
 
  return rc;
}

int main ( void )
{
  char buff[5];
  int rc;

  rc = prefgets ( buff, sizeof buff, stdin );
  if ( rc > 0 ) {
    printf ( "%s\n", buff );
    if ( rc == 2 )
      printf ( "There's still more data in the stream\n" );
  }
  else {
    if ( rc == -1 )
      perror ( NULL );
    else
      printf ( "EOF found\n" );
  }

  return 0;
}

---

Quote:

---

Originally posted by WaltP
Your code will do it, 99.999999% of the time. The only time it won't will be when some bozo decides to type in BUFSIZ or more characters. Assuming BUFSIZ is huge (or the default), probably not a problem.

---

Doesn't BUFSIZ have a value of 5xx bytes. Or does it depend on the bit bt value of your Platform. 16,32, 64 ? Just wondering.

>Doesn't BUFSIZ have a value of 5xx bytes.
No, but it does have to be at least 256. The actual size depends on the size of the buffer used by the setbuf function.

Quote:

---

Originally posted by Hammer
The use of the local buffer is pointless (and potentially dangerous). Just write to the memory provided as a pointer in the function parameter, for the specified length.

---

I don't know about pointless. I keeps the input stream clean when more than string_length characters are entered. If you use the provided pointer, this call will only load the first string_length characters leaving the rest of the input in the stream. The next fgets() call will load the next portion of the input from the first fgets -- definitely not a good idea.

And dangerous? Why?

Quote:

---

Originally posted by WaltP
I don't know about pointless. I keeps the input stream clean when more than string_length characters are entered. If you use the provided pointer, this call will only load the first string_length characters leaving the rest of the input in the stream. The next fgets() call will load the next portion of the input from the first fgets -- definitely not a good idea.

And dangerous? Why?

---

Pointless - because all you are doing is loading the data into one buffer, making minor amendments, then moving it to another buffer. You might as well write directly to the target buffer. I'd write an example, but Prelude's already done so.

Dangerous - because of this:

Code:

---

#define BUFSIZ 512  /* copied from my stdio.h for clarity */
char buff[1024];
gstring (buff, sizeof(buff));

---

In this case, the line:
buffer[string_length - 1] = '\0';
writes to no-mans-land. Obviously we shouldn't write code like this, but in the defence of the programmer, I think it's safe to presume that if you pass a valid length indicator, the function shouldn't use it to access undefined memory addresses.