Viewing file:  chatchat.c (8.37 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/* *************************************************************************
* NAME: chatchat.c
*
* DESCRIPTION:
*
* This program creates a pipe for the chat process to read. The user
* can supply information (like a password) that will be picked up
* by chat and sent just like the regular contents of a chat script.
*
* Usage is:
*
* chatchat <filename>
*
* where <filename> matches the option given in the chat script.
*
* for instance the chat script fragment:
*
* ...
* name: \\dmyname \
* word: @/var/tmp/p \
* ...
* ^
* (note: leave some whitespace after the filename)
*
* expect "name:", reply with a delay followed by "myname"
* expect "word:", reply with the data read from the pipe /var/tmp/p
*
* the matching usage of chatchat would be:
*
* chatchat /var/tmp/p
*
* eg:
*
* $chatchat /var/tmp/p
* ...
* some other process eventually starts:
* chat ...
* chat parses the "@/var/tmp/p" option and opens
* /var/tmp/p
* (chatchat prompts:)
*
* type PIN into SecurID card
* enter resulting passcode: [user inputs something]
*
* chat reads /var/tmp/p & gets what the
* user typed at chatchat's "enter string" prompt
* chat removes the pipe file
* chat sends the user's input as a response in
* place of "@/var/tmp/p"
*
* PROCESS:
*
* gcc -g -o chatchat chatchat.c
*
*
* GLOBALS: none
*
* REFERENCES:
*
* see the man pages and documentation that come with the 'chat' program
* (part of the ppp package). you will need to use the modified chat
* program that accepts the '@' operator.
*
* LIMITATIONS:
*
* REVISION HISTORY:
*
* STR Description Author
*
* 23-Mar-99 initial coding gpk
* 12-May-99 unlink the pipe after closing paulus
*
* TARGET: ANSI C
* This program is in the public domain.
*
*
* ************************************************************************* */
#include <sys/time.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
/* MAXINPUT - the data typed into chatchat must be fewer */
/* characters than this. */
#define MAXINPUT 80
/* *************************************************************************
NAME: main
USAGE:
int argc;
char * argv[];
main(argc, argv[]);
returns: int
DESCRIPTION:
if the pipe file name is given on the command line,
create the pipe, prompt the user and put whatever
is typed into the pipe.
returns -1 on error
else # characters entered
REFERENCES:
LIMITATIONS:
GLOBAL VARIABLES:
accessed: none
modified: none
FUNCTIONS CALLED:
REVISION HISTORY:
STR Description of Revision Author
25-Mar-99 initial coding gpk
************************************************************************* */
int main(int argc, char * argv[])
{
int retval;
int create_and_write_pipe(char * pipename);
if (argc != 2)
{
fprintf(stderr, "usage: %s pipename\n", argv[0]);
retval = -1;
}
else
{
retval = create_and_write_pipe(argv[1]);
}
return (retval);
}
/* *************************************************************************
NAME: create_and_write_pipe
USAGE:
int some_int;
char * pipename;
some_int = create_and_write_pipe(pipename);
returns: int
DESCRIPTION:
given the pipename, create the pipe, open it,
prompt the user for a string to put into the
pipe, write the string, and close the pipe
on error, print out an error message and return -1
returns -1 on error
else #bytes written into the pipe
REFERENCES:
LIMITATIONS:
GLOBAL VARIABLES:
accessed: none
modified: none
FUNCTIONS CALLED:
REVISION HISTORY:
STR Description of Revision Author
25-Mar-99 initial coding gpk
12-May-99 remove pipe after closing paulus
************************************************************************* */
int create_and_write_pipe(char * pipename)
{
int retval, created, pipefd, nread, nwritten;
char input[MAXINPUT];
char errstring[180];
int create_pipe(char * pipename);
int write_to_pipe(int pipefd, char * input, int nchar);
created = create_pipe(pipename);
if (-1 == created)
{
sprintf(errstring, "unable to create pipe '%s'", pipename);
perror(errstring);
retval = -1;
}
else
{
/* note: this open won't succeed until chat has the pipe */
/* open and ready to read. this makes for nice timing. */
pipefd = open(pipename, O_WRONLY);
if (-1 == pipefd)
{
sprintf(errstring, "unable to open pipe '%s'", pipename);
perror(errstring);
retval = -1;
}
else
{
fprintf(stderr, "%s \n %s",
"type PIN into SecurID card and",
"enter resulting passcode:");
nread = read(STDIN_FILENO, (void *)input, MAXINPUT);
if (0 >= nread)
{
perror("unable to read from stdin");
retval = -1;
}
else
{
/* munch off the newline character, chat supplies */
/* a return when it sends the string out. */
input[nread -1] = 0;
nread--;
nwritten = write_to_pipe(pipefd, input, nread);
/* printf("wrote [%d]: '%s'\n", nwritten, input); */
retval = nwritten;
}
close(pipefd);
/* Now make the pipe go away. It won't actually go away
completely until chat closes it. */
if (unlink(pipename) < 0)
perror("Warning: couldn't remove pipe");
}
}
return(retval);
}
/* *************************************************************************
NAME: create_pipe
USAGE:
int some_int;
char * pipename;
some_int = create_pipe(pipename);
returns: int
DESCRIPTION:
create a pipe of the given name
if there is an error (like the pipe already exists)
print an error message and return
return -1 on failure else success
REFERENCES:
LIMITATIONS:
GLOBAL VARIABLES:
accessed: none
modified: none
FUNCTIONS CALLED:
REVISION HISTORY:
STR Description of Revision Author
25-Mar-99 initial coding gpk
************************************************************************* */
int create_pipe(char * pipename)
{
mode_t old_umask;
int created;
/* hijack the umask temporarily to get the mode I want */
/* on the pipe. */
old_umask = umask(000);
created = mknod(pipename, S_IFIFO | S_IRWXU | S_IWGRP | S_IWOTH,
(dev_t)NULL);
/* now restore umask. */
(void)umask(old_umask);
if (-1 == created)
{
perror("unable to create pipe");
}
return(created);
}
/* *************************************************************************
NAME: write_to_pipe
USAGE:
int some_int;
int pipefd;
char * input;
int nchar;
some_int = write_to_pipe(pipefd, input, nchar);
returns: int
DESCRIPTION:
write nchars of data from input to pipefd
on error print a message to stderr
return -1 on error, else # bytes written
REFERENCES:
LIMITATIONS:
GLOBAL VARIABLES:
accessed: none
modified: none
FUNCTIONS CALLED:
REVISION HISTORY:
STR Description of Revision Author
25-Mar-99 initial coding gpk
12-May-99 don't write count word first paulus
************************************************************************* */
int write_to_pipe(int pipefd, char * input, int nchar)
{
int nwritten;
/* nwritten = write(pipefd, (void *)&nchar, sizeof(nchar)); */
nwritten = write(pipefd, (void *)input, nchar);
if (-1 == nwritten)
{
perror("unable to write to pipe");
}
return(nwritten);
}
|