char * __fgets_chk (char *buf, size_t size, int n, _IO_FILE *fp) { _IO_size_t count; char *result; CHECK_FILE (fp, NULL); if (n <= 0) return NULL; _IO_acquire_lock (fp); /* This is very tricky since a file descriptor may be in the non-blocking mode. The error flag doesn't mean much in this case. We return an error only when there is a new error. */ int old_error = fp->_IO_file_flags & _IO_ERR_SEEN; fp->_IO_file_flags &= ~_IO_ERR_SEEN; count = _IO_getline (fp, buf, MIN ((size_t) n - 1, size), '\n', 1); /* If we read in some bytes and errno is EAGAIN, that error will be reported for next read. */ if (count == 0 || ((fp->_IO_file_flags & _IO_ERR_SEEN) && errno != EAGAIN)) result = NULL; else if (count >= size) __chk_fail (); else { buf[count] = '\0'; result = buf; } fp->_IO_file_flags |= old_error; _IO_release_lock (fp); return result; }
char * __gets_chk (char *buf, size_t size) { size_t count; int ch; char *retval; if (size == 0) __chk_fail (); _IO_acquire_lock (stdin); ch = _IO_getc_unlocked (stdin); if (ch == EOF) { retval = NULL; goto unlock_return; } if (ch == '\n') count = 0; else { /* This is very tricky since a file descriptor may be in the non-blocking mode. The error flag doesn't mean much in this case. We return an error only when there is a new error. */ int old_error = stdin->_flags & _IO_ERR_SEEN; stdin->_flags &= ~_IO_ERR_SEEN; buf[0] = (char) ch; count = _IO_getline (stdin, buf + 1, size - 1, '\n', 0) + 1; if (stdin->_flags & _IO_ERR_SEEN) { retval = NULL; goto unlock_return; } else stdin->_flags |= old_error; } if (count >= size) __chk_fail (); buf[count] = 0; retval = buf; unlock_return: _IO_release_lock (stdin); return retval; }
char * _IO_gets (char *buf) { _IO_size_t count; int ch; char *retval; _IO_acquire_lock (_IO_stdin); ch = _IO_getc_unlocked (_IO_stdin); if (ch == EOF) { retval = NULL; goto unlock_return; } if (ch == '\n') count = 0; else { /* This is very tricky since a file descriptor may be in the non-blocking mode. The error flag doesn't mean much in this case. We return an error only when there is a new error. */ int old_error = _IO_stdin->_IO_file_flags & _IO_ERR_SEEN; _IO_stdin->_IO_file_flags &= ~_IO_ERR_SEEN; buf[0] = (char) ch; count = _IO_getline (_IO_stdin, buf + 1, INT_MAX, '\n', 0) + 1; if (_IO_stdin->_IO_file_flags & _IO_ERR_SEEN) { retval = NULL; goto unlock_return; } else _IO_stdin->_IO_file_flags |= old_error; } buf[count] = 0; retval = buf; unlock_return: _IO_release_lock (_IO_stdin); return retval; }
char * _IO_fgets (char *buf, int n, FILE *fp) { size_t count; char *result; int old_error; CHECK_FILE (fp, NULL); if (n <= 0) return NULL; if (__glibc_unlikely (n == 1)) { /* Another irregular case: since we have to store a NUL byte and there is only room for exactly one byte, we don't have to read anything. */ buf[0] = '\0'; return buf; } _IO_acquire_lock (fp); /* This is very tricky since a file descriptor may be in the non-blocking mode. The error flag doesn't mean much in this case. We return an error only when there is a new error. */ old_error = fp->_flags & _IO_ERR_SEEN; fp->_flags &= ~_IO_ERR_SEEN; count = _IO_getline (fp, buf, n - 1, '\n', 1); /* If we read in some bytes and errno is EAGAIN, that error will be reported for next read. */ if (count == 0 || ((fp->_flags & _IO_ERR_SEEN) && errno != EAGAIN)) result = NULL; else { buf[count] = '\0'; result = buf; } fp->_flags |= old_error; _IO_release_lock (fp); return result; }