{"id":64247,"date":"2022-05-10T09:01:22","date_gmt":"2022-05-10T09:01:22","guid":{"rendered":"https:\/\/www.cryptocabaret.com\/?p=64247"},"modified":"2022-05-10T09:01:22","modified_gmt":"2022-05-10T09:01:22","slug":"how-to-safely-read-user-input-with-the-getline-function","status":"publish","type":"post","link":"https:\/\/www.cryptocabaret.com\/?p=64247","title":{"rendered":"How to (safely) read user input with the getline function"},"content":{"rendered":"

How to (safely) read user input with the getline function<\/span>
\nJim Hall<\/a><\/span>
\nTue, 05\/10\/2022 – 03:00<\/span><\/p>\n

\n
Register<\/a> or Login<\/a> to like<\/div>\n
Register<\/a> or Login<\/a> to like<\/div>\n<\/div>\n
\n

Reading strings in C used to be a very dangerous thing to do. When reading input from the user, programmers might be tempted to use the gets<\/code> function from the C Standard Library. The usage for gets<\/code> is simple enough:<\/p>\n

char *gets(char *string);<\/code><\/p>\n

That is, gets<\/code> reads data from standard input, and stores the result in a string variable. Using gets<\/code> returns a pointer to the string, or the value NULL if nothing was read.<\/p>\n

As a simple example, we might ask the user a question and read the result into a string:<\/p>\n

\n
#include <\/stdio.h><\/span>
#include <\/string.h><\/span>

\nint
\nmain(<\/span>)<\/span>
{<\/span>
\n\u00a0 char city[<\/span>10<\/span>]<\/span>; \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \/\/<\/span> Such as<\/span> \"Chicago\"<\/span>

\n\u00a0 \/\/<\/span> this is bad .. please don't use gets

\n\u00a0 puts(\"Where do you live?\");
\n\u00a0 gets(city);

\n\u00a0 printf(\" is length %ldn\", city, strlen(city));

\n\u00a0 return 0;
\n}<\/span><\/div><\/div><\/pre>\n
Entering a relatively short value with the above program works well enough:<\/p>\n
\n
Where do<\/span> you live?
\nChicago
Chicago><\/span> is length 7<\/span><\/span><\/div><\/div><\/pre>\n<\/p>\n
\n
Programming and development<\/div>\n
\n
Red Hat Developers Blog<\/a><\/div>\n
Programming cheat sheets<\/a><\/div>\n
Try for free: Red Hat Learning Subscription<\/a><\/div>\n
eBook: An introduction to programming with Bash<\/a><\/div>\n
Bash shell scripting cheat sheet<\/a><\/div>\n
eBook: Modernizing Enterprise Java<\/a><\/div>\n<\/p><\/div>\n<\/p><\/div>\n
However, the gets<\/code> function is very simple, and will naively read data until it thinks the user is finished. But gets<\/code> doesn’t check that the string is long enough to hold the user’s input. Entering a very long value will cause gets<\/code> to store more data than the string variable can hold, resulting in overwriting other parts of memory.<\/p>\n
\n
Where do<\/span> you live?
\nLlanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch
Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch><\/span> is length 58<\/span>
\nSegmentation fault (<\/span>core dumped)<\/span><\/span><\/div><\/div><\/pre>\n
At best, overwriting parts of memory simply breaks the program. At worst, this introduces a critical security bug where a bad user can insert arbitrary data into the computer’s memory via your program.<\/p>\n
That’s why the gets<\/code> function is dangerous to use in a program. Using gets<\/code>, you have no control over how much data your program attempts to read from the user. This often leads to buffer overflow.<\/p>\n
The safer way<\/h1>\n
The fgets<\/code> function has historically been the recommended way to read strings safely. This version of gets<\/code> provides a safety check by only reading up to a certain number of characters, passed as a function argument:<\/p>\n
char *fgets(char *string, int size, FILE *stream);<\/code><\/p>\n
The fgets<\/code> function reads from the file pointer, and stores data into a string variable, but only up to the length indicated by size<\/code>. We can test this by updating our sample program to use fgets<\/code> instead of gets<\/code>:<\/p>\n
\n
#include <\/stdio.h><\/span>

#include <\/string.h><\/span>

\nint

\nmain(<\/span>)<\/span>

{<\/span>

\nchar city[<\/span>10<\/span>]<\/span>; \/\/<\/span> Such as<\/span> \u201cChicago\u201d

\/\/<\/span> fgets is better but not perfect

\nputs(<\/span>\u201cWhere do<\/span> you live?\u201d)<\/span>;

\nfgets(<\/span>city, 10<\/span>, stdin)<\/span>;

printf<\/span>(<\/span>\" is length %ldn<\/span>\"<\/span>, city, strlen(<\/span>city)<\/span>)<\/span>;

return<\/span> 0<\/span>;

}<\/span><\/div><\/div><\/pre>\n
If you compile and run this program, you can enter an arbitrarily long city name at the prompt. However, the program will only read enough data to fit into a string variable of size<\/code>=10. And because C adds a null (\u2018\u0000’) character to the ends of strings, that meansfgets<\/code> will only read 9 characters into the string:<\/p>\n
\n
Where do<\/span> you live?
\nMinneapolis
Minneapol><\/span> is length 9<\/span><\/span><\/div><\/div><\/pre>\n
While this is certainly safer than using fgets<\/code> to read user input, it does so at the cost of “cutting off” your user’s input if it is too long.<\/p>\n
The new safe way<\/h1>\n
A more flexible solution to reading long data is to allow the string-reading function to allocate more memory to the string, if the user entered more data than the variable might hold. By resizing the string variable as necessary, the program always has enough room to store the user’s input.<\/p>\n
The getline<\/code> function does exactly that. This function reads input from an input stream, such as the keyboard or a file, and stores the data in a string variable. But unlike fgets<\/code> and gets<\/code>, getline<\/code> resizes the string with realloc<\/code> to ensure there is enough memory to store the complete input.<\/p>\n
ssize_t getline(char **pstring, size_t *size, FILE *stream);<\/code><\/p>\n
The getline<\/code> is actually a wrapper to a similar function called getdelim<\/code> that reads data up to a special delimiter character. In this case, getline<\/code> uses a newline (‘n’) as the delimiter, because when reading user input either from the keyboard or from a file, lines of data are separated by a newline character.<\/p>\n
The result is a much safer method to read arbitrary data, one line at a time. To use getline<\/code>, define a string pointer and set it to NULL to indicate no memory has been set aside yet. Also define a “string size” variable of type size_t<\/code> and give it a zero value. When you call getline<\/code>, you’ll use pointers to both the string and the string size variables, and indicate where to read data. For a sample program, we can read from the standard input:<\/p>\n
\n
#include <\/stdio.h><\/span>
#include <\/stdlib.h><\/span>
#include <\/string.h><\/span>

\nint
\nmain(<\/span>)<\/span>
{<\/span>
\n\u00a0 char *<\/span>string = NULL;
\n\u00a0 size_t size<\/span> = 0<\/span>;
\n\u00a0 ssize_t chars_read;

\n\u00a0 \/\/<\/span> read<\/span> a long string with getline

\n\u00a0 puts(<\/span>\"Enter a really long string:\"<\/span>)<\/span>;

\n\u00a0 chars_read = getline(<\/span>&<\/span>string, &<\/span>size<\/span>, stdin)<\/span>;
\n\u00a0 printf<\/span>(<\/span>\"getline returned %ldn<\/span>\"<\/span>, chars_read)<\/span>;

\n\u00a0 \/\/<\/span> check for<\/span> errors

\n\u00a0 if<\/span> (<\/span>chars_read  0<\/span>)<\/span> {<\/span>
\n\u00a0 \u00a0 puts(<\/span>\"couldn't read the input\"<\/span>)<\/span>;
\n\u00a0 \u00a0 free<\/span>(<\/span>string)<\/span>;
\n\u00a0 \u00a0 return<\/span> 1<\/span>;
\n\u00a0 }<\/span>

\n\u00a0 \/\/<\/span> print the string

\n\u00a0 printf<\/span>(<\/span>\" is length %ldn<\/span>\"<\/span>, string, strlen(<\/span>string)<\/span>)<\/span>;

\n\u00a0 \/\/<\/span> free<\/span> the memory used by string

\n\u00a0 free<\/span>(<\/span>string)<\/span>;

\n\u00a0 return<\/span> 0<\/span>;
}<\/span><\/span><\/div><\/div><\/pre>\n
As the getline<\/code> reads data, it will automatically reallocate more memory for the string variable as needed. When the function has read all the data from one line, it updates the size of the string via the pointer, and returns the number of characters read, including the delimiter.<\/p>\n
\n
\u200b
\nEnter a really long string:
\nSupercalifragilisticexpialidocious
\ngetline returned 35<\/span>
Supercalifragilisticexpialidocious
><\/span> is length 35<\/span>


\n\u200b<\/span><\/div><\/div><\/pre>\n
Note that the string includes the delimiter character. For getline<\/code>, the delimiter is the newline, which is why the output has a line feed in there. If you don’t want the delimiter in your string value, you can use another function to change the delimiter to a null character in the string.<\/p>\n
With getline<\/code>, programmers can safely avoid one of the common pitfalls of C programming. You can never tell what data your user might try to enter, which is why using gets<\/code> is unsafe, and fgets<\/code> is awkward. Instead, getline<\/code> offers a more flexible way to read user data into your program without breaking the system.<\/p>\n<\/div>\n
\n
Getline offers a more flexible way to read user data into your program without breaking the system.<\/p>\n<\/div>\n
\n
\n
  \"Business<\/div>\n
Image by: <\/span><\/p>\n
Image by Mapbox Uncharted ERG,\u00a0CC-BY 3.0 US<\/a><\/p>\n<\/div>\n<\/article>\n<\/div>\n
What to read next<\/div>\n

\n        \"Creative<\/a>This work is licensed under a Creative Commons Attribution-Share Alike 4.0 International License.<\/div>\n
\n
\n
Register<\/a> or Login<\/a> to post a comment.<\/div>\n<\/p><\/div>\n<\/section>\n
Powered by WPeMatico<\/a><\/small><\/p>\n","protected":false},"excerpt":{"rendered":"
How to (safely) read user input with the getline function Jim Hall Tue, 05\/10\/2022 – 03:00 Register or Login to like Register or Login to like Reading strings in C used to be a very dangerous thing to do. When reading input from the user, programmers might be tempted to use the gets function from […]<\/p>\n","protected":false},"author":1,"featured_media":64248,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[307],"tags":[],"class_list":["post-64247","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-open-source"],"_links":{"self":[{"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/posts\/64247","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=64247"}],"version-history":[{"count":0,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/posts\/64247\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=\/wp\/v2\/media\/64248"}],"wp:attachment":[{"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=64247"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=64247"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.cryptocabaret.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=64247"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}