Hiding characters typed in by user

I wrote a password program in C for MS-DOS. The only problem with it is that the password is visible. Is there anyway to have *'s printed instead of the actual characters?
GreatOneAsked:
Who is Participating?

[Product update] Infrastructure Analysis Tool is now available with Business Accounts.Learn More

x
I wear a lot of hats...

"The solutions and answers provided on Experts Exchange have been extremely helpful to me over the last few years. I wear a lot of hats - Developer, Database Administrator, Help Desk, etc., so I know a lot of things but not a lot about one thing. Experts Exchange gives me answers from people who do know a lot about one thing, in a easy to use platform." -Todd S.

rbrCommented:
Yes

int pos,c;
char string[100];
pos=0;
c=0;
while (c!=13) {
      while (!kbhit());
      c=gtech();
      if (c!=13) {
      printf ("*");
     string[pos]=(char)c;
       pos++:
    }
}
string[pos]=0;

If you are interested in general input output functions send an email to rbr@physik.kfunigraz.ac.at
0

Experts Exchange Solution brought to you by

Your issues matter to us.

Facing a tech roadblock? Get the help and guidance you need from experienced professionals who care. Ask your question anytime, anywhere, with no hassle.

Start your 7-day free trial
rbrCommented:
sorry mistyped:
Use getch() instead of gtech()
0
GreatOneAuthor Commented:
I put your code into a main(). It compiled fine but when i run it , the prog just hangs. Nothing is read into string or printed to the string? Any ideas
0
Exploring SQL Server 2016: Fundamentals

Learn the fundamentals of Microsoft SQL Server, a relational database management system that stores and retrieves data when requested by other software applications.

RONSLOWCommented:
Try this (from the snippets site)...

/* +++Date last modified: 05-Jul-1997 */

/* editgets.c - line input w/editing                                        */
/* this code is released to the public domain                               */
/* written by Jon Burchmore                                                 */
/* modifications & enhancements by Bob Stout                                */

/* This is as close to ANSI compliant C that I could come, but it was made  */
/* on an IBM compatible computer, so I designed it for that platform.       */

/* EXT_KEYS.C in SNIPPETS provides the ext_getch() function, which returns  */
/* a single extended character from the KEYBOARD, not stdin, and waits if   */
/* it must. It is be possible to re-write this function for a computer      */
/* besides an IBM PC. To do so, just rewrite EXT_KEYS.C and using the same  */
/* key definitions in EXT_KEYS.H                                            */

/* Similarly, CURSOR.C in SNIPPETS is used to make the cursor larger when   */
/* in insert mode and smaller when in overwrite mode. To port to a non-PC   */
/* system, simply rewrite CURSOR.C using the same prototype and calling     */
/* parameters as specified in CURSOR.H.                                     */

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include "sniptype.h"
#include "ext_keys.h"
#include "cursor.h"
#include "editgets.h"
#include "minmax.h"

#define CTRL_CHARS_ALLOWED 0  /* Non-zero allows entry of Ctrl-characters   */

#define BAD_KEY() {fputc('\a', stderr); break;}
#define putch(x)   fputc((x), stderr)

int TabSize = 8;

/*
**  Password mode:
**
**  0 - Normal operation
**  1 - Conventional password mode - '*' is echoed for all characters,
**      only ESC, ENTER, BACKSPC, and CTLHOME are active.
**  2 - Secure password mode - same as above except random characters are
**      displayed rather than '*'s to distract snoops from watching the keys.
*/

int password_mode = 0;

static const char PWchars[] = /* Frequency approximates English usage   */
      "aaabbccddeeeeffgghhiiijklllmmmnnnoooppqrrrsssstttuuvwwxyz"
      "1234567890-|,@._"
      "aaabbccddeeeeffgghhiiijklllmmmnnnoooppqrrrsssstttuuvwwxyz";

static int pickPWchar(void);

/*
**  Arguments: 1) Buffer to receive string
**             2) Size of buffer
**             3) Default string
*/

int editgets(char *s, int maxlen, char *string)
{
      char temp[500];         /* Working buffer                         */
      int   insert,           /* Non-zero if in insert mode             */
            done = 0,         /* Non-Zero if done                       */
            pos,              /* Our position within the string         */
            len,              /* The current length of the string       */
            i, j, k,          /* Temporary variables                    */
            c,                /* Keyboard input                         */
            skip;             /* Spaces to skip when tabbing            */

      if (NULL == string)
            string = "";

      if (0 != (pos = len = strlen(string)))
            strncpy(temp, string, min(len, maxlen));

      for (i = 0; i < maxlen; ++i)
      {
            if (NUL == *string)
                  putch('_');
            else  putch(*string++);
      }
      for (i = 0; i < (maxlen - len); ++i)
            putch('\b');
      fflush(stderr);

      /* Set insert mode, save cursor, and use a big cursor */

      insert = 1;
      cursor('S');
      cursor('B');

      while (!done)
      {
            c = ext_getch();
            switch (c)
            {
            case Key_ESC :
                  if (len == 0)
                        break;
                  if (pos != len)
                  {
                        for (i = pos; i < len; i++)
                              putch('_');
                  }
                  for (i = len; i > 0; i--)
                  {
                        putch('\b');
                        putch('_');
                        putch('\b');
                  }
                  pos = len = 0;
                  break;

            case Key_LTARROW :
            case Key_PLTARROW :
                  if (password_mode)
                        BAD_KEY();
                  if (pos == 0)
                        break;
                  pos--;
                  putch('\b');
                  break;

            case Key_RTARROW :
            case Key_PRTARROW :
                  if (password_mode)
                        BAD_KEY();
                  if (pos == len)
                        break;
                  if (pos != maxlen)
                  {
                        putch(temp[pos]);
                        pos++;
                  }
                  break;

            case Key_HOME :
            case Key_PHOME :
                  if (password_mode)
                        BAD_KEY();
                  while (pos-- > 0)
                        putch('\b');
                  pos = 0;
                  break;

            case Key_END :
            case Key_PEND :
                  if (password_mode)
                        BAD_KEY();
                  while (pos < len)
                        putch(temp[pos++]);
                  break;

            case Key_INS :
            case Key_PINS :
                  if (password_mode)
                        BAD_KEY();
                  insert = (!(insert));
                  cursor(insert ? 'B' : 'N');
                  break;

            case Key_DEL :
            case Key_PDEL :
                  if (password_mode)
                        BAD_KEY();
                  if (pos == len)
                        break;
                  for (i = pos; i < len; i++)
                        temp[i] = temp[i + 1];
                  len--;
                  for (i = pos; i < len; i++)
                        putch(temp[i]);
                  putch('_');
                  for (i = len + 1; i > pos; i--)
                        putch('\b');
                  break;

            case Key_BACKSPC :
                  if (pos == 0)
                        break;
                  if (pos != len)
                  {
                        for (i = pos - 1; i < len; i++)
                              temp[i] = temp[i + 1];
                        pos--;
                        len--;
                        putch('\b');
                        for (i = pos; i < len; i++)
                              putch(temp[i]);
                        putch('_');
                        for (i = len; i >= pos; i--)
                              putch('\b');
                  }
                  else
                  {
                        putch('\b');
                        putch('_');
                        putch('\b');
                        pos = --len;
                  }
                  break;

            case Key_ENTER :
            case Key_PADENTER :
            case Key_NL :
                  done = 1;
                  break;

            case Key_CEND :
            case Key_CPEND :
                  if (password_mode)
                        BAD_KEY();
                  for (i = pos; i < len; ++i)
                        putch('_');
                  for (i = pos; i < len; ++i)
                        putch('\b');
                  len = pos;
                  break;

            case Key_CHOME :
            case Key_CPHOME :
                  if (pos == 0)
                        break;
                  if (pos != len)
                  {
                        while (0 != pos)
                        {
                              for (i = pos - 1; i < len; i++)
                                    temp[i] = temp[i + 1];
                              pos--;
                              len--;
                              putch('\b');
                              for (i = pos; i < len; i++)
                                    putch(temp[i]);
                              putch('_');
                              for (i = len; i >= pos; i--)
                                    putch('\b');
                        }
                  }
                  else
                  {
                        while (0 != pos)
                        {
                              putch('\b');
                              putch('_');
                              putch('\b');
                              pos = --len;
                        }
                  }
                  break;

            case Key_CRTARROW :
            case Key_CPRTARROW :
                  if (password_mode)
                        BAD_KEY();
                  do
                  {
                        if (pos == len)
                              break;
                        if (pos != maxlen)
                        {
                              putch(temp[pos]);
                              pos++;
                        }
                  } while (isspace(temp[pos]));
                  do
                  {
                        if (pos == len)
                              break;
                        if (pos != maxlen)
                        {
                              putch(temp[pos]);
                              pos++;
                        }
                  } while (!isspace(temp[pos]));
                  break;

            case Key_CLTARROW :
            case Key_CPLTARROW :
                  if (password_mode)
                        BAD_KEY();
                  do
                  {
                        if (pos == 0)
                              break;
                        pos--;
                        putch('\b');
                  } while (isspace(temp[pos]));
                  do
                  {
                        if (pos == 0)
                              break;
                        pos--;
                        putch('\b');
                  } while (!isspace(temp[pos]));
                  break;

            case Key_TAB :
                  if (password_mode)
                        BAD_KEY();
                  if (pos == maxlen)
                        break;

                  skip = TabSize - ((pos + TabSize) % TabSize);

                  if (insert)
                  {
                        if ((len + skip) > maxlen)
                              skip = maxlen - len;

                        for (i = pos, j = len + skip - 1, k = len - 1;
                              i < len ; ++i, --j, --k)
                        {
                              temp[j] = temp[k];
                        }
                  }
                  else  /* overwrite */
                  {
                        if ((pos + skip) > maxlen)
                              skip = maxlen - pos;
                  }
                  for (i = 0; i < skip; ++i)
                  {
                        temp[pos++] = ' ';
                        putch(' ');
                  }
                  len = insert ? len + skip : max(len, pos);
                  for (i = pos; i < len; ++i)
                        putch(temp[i]);
                  for (i = len; i > pos; --i)
                        putch('\b');
                  break;

            default :
                  if (pos == maxlen)
                        break;

                  if (c & 0xff00          /* Illegal extended character */

#if !CTRL_CHARS_ALLOWED

                  || iscntrl(c)
#endif
                  )
                  {
                        BAD_KEY();
                  }

                  if ((!(insert)) || pos == len)
                  {
                        temp[pos++] = (char)c;
                        if (pos > len) len++;
                        if (password_mode)
                        {
                              if (2 == password_mode)
                                    putch(pickPWchar());
                              else  putch('*');
                        }
                        else  putch(c);
                  }
                  else
                  {
                        if (len == maxlen)
                              break;
                        for (i = len++; i >= pos; i--)
                              temp[i + 1] = temp[i];
                        temp[pos++] = (char)c;
                        if (password_mode)
                        {
                              if (2 == password_mode)
                                    putch(pickPWchar());
                              else  putch('*');
                        }
                        else  putch(c);
                        for (i = pos; i < len; i++)
                              putch(temp[i]);
                        for (i = len; i > pos; i--)
                              putch('\b');
                  }
            }
      }
      temp[len] = '\0';
      strcpy(s, temp);
      cursor('Z');            /* Restore cursor size  */
      return len;
}

static int pickPWchar(void)
{
      static int inited = 0;

      if (!inited)
      {
            srand(((unsigned int)time(NULL)) | 1);
            inited = 1;
      }
     
      return PWchars[rand() % (sizeof(PWchars) - 1)];
}

#ifdef TEST

main()
{
      char mystring[60];

      memset(mystring, 0, 60);
      puts("                  "
            "0        1         2         3         4         5         6");
      puts("                  "
            "123456789012345678901234567890123456789012345678901234567890");
      fputs("Enter any string: ", stderr);
      editgets(mystring, 60, "This is a test");
      puts("");
      printf("editgets() returned:\n\"%s\"\n", mystring);

      password_mode = 1;
      memset(mystring, 0, 60);
      fputs("Enter any password: ", stderr);
      editgets(mystring, 50, NULL);
      puts("");
      printf("editgets() returned:\n\"%s\"\n", mystring);

      password_mode = 2;
      memset(mystring, 0, 60);
      fputs("Enter any password: ", stderr);
      editgets(mystring, 50, NULL);
      puts("");
      printf("editgets() returned:\n\"%s\"\n", mystring);

      return 0;
}

#endif /* TEST */


go to the snippets site for more info (and support files)
and maybe let me answer the question :-)
0
GreatOneAuthor Commented:
Ronslow,
Wow thats a lot of code. I went to the snippets site to get all the necessary files but it wouldnt compile. So it really didnt help me out

anyone else got an idea?
0
GreatOneAuthor Commented:
ok rbr, i got the code to work but it didnt do what i thought it would. I wanted it to print the *'s as the user types in the password. Your's prints the *'s after the enter key is pressed. Is there anyway to make it print the *'s as they are typed in?

0
RONSLOWCommented:
I'll see if I can et the example code from snippets to compile.  If so, I'll post it here.

Unfortunately I've only got access to Win32 dev environment and any DOS specific stuff won't work for me :-(
0
rbrCommented:
Can posz me pls yout code, since the program should print out a * each time a key is pressed. Which compiler which os to you use since in a unix system the * will be printed after the return is pressed.
0
GreatOneAuthor Commented:
rbr,
the code i used was the same one you posted. I compiled it using djgpp which I use to make it a DOS executable. Does that help?

0
rbrCommented:
Strange. Pls send an email to rbr@physik.kfunigraz.ac.at to get your email adress and I`ll send you a code which is tested for Dos, Unix, Os/2, Macintosh. It is to long to post here.
0
It's more than this solution.Get answers and train to solve all your tech problems - anytime, anywhere.Try it for free Edge Out The Competitionfor your dream job with proven skills and certifications.Get started today Stand Outas the employee with proven skills.Start learning today for free Move Your Career Forwardwith certification training in the latest technologies.Start your trial today
Fonts Typography

From novice to tech pro — start learning today.