diff options
Diffstat (limited to 'net-mail/pine/files/os.c')
| -rw-r--r-- | net-mail/pine/files/os.c | 5673 |
1 files changed, 5673 insertions, 0 deletions
diff --git a/net-mail/pine/files/os.c b/net-mail/pine/files/os.c new file mode 100644 index 000000000000..2fd967904207 --- /dev/null +++ b/net-mail/pine/files/os.c @@ -0,0 +1,5673 @@ +/*---------------------------------------------------------------------- + + T H E P I N E M A I L S Y S T E M + + Laurence Lundblade and Mike Seibel + Networks and Distributed Computing + Computing and Communications + University of Washington + Administration Builiding, AG-44 + Seattle, Washington, 98195, USA + Internet: lgl@CAC.Washington.EDU + mikes@CAC.Washington.EDU + + Please address all bugs and comments to "pine-bugs@cac.washington.edu" + + + Pine and Pico are registered trademarks of the University of Washington. + No commercial use of these trademarks may be made without prior written + permission of the University of Washington. + + Pine, Pico, and Pilot software and its included text are Copyright + 1989-1998 by the University of Washington. + + The full text of our legal notices is contained in the file called + CPYRIGHT, included with this distribution. + + + Pine is in part based on The Elm Mail System: + *********************************************************************** + * The Elm Mail System - Revision: 2.13 * + * * + * Copyright (c) 1986, 1987 Dave Taylor * + * Copyright (c) 1988, 1989 USENET Community Trust * + *********************************************************************** + + + ----------------------------------------------------------------------*/ + +/*====================================================================== + + This contains most of Pine's interface to the local operating system +and hardware. Hopefully this file, os-xxx.h and makefile.xxx are the +only ones that have to be modified for most ports. Signals.c, ttyin.c, +and ttyout.c also have some dependencies. See the doc/tech-notes for +notes on porting Pine to other platforms. Here is a list of the functions +required for an implementation: + + + File System Access + can_access -- See if a file can be accessed + name_file_size -- Return the number of bytes in the file (by name) + fp_file_size -- Return the number of bytes in the file (by FILE *) + name_file_mtime -- Return the mtime of a file (by name) + fp_file_mtime -- Return the mtime of a file (by FILE *) + file_attrib_copy -- Copy attributes of one file to another. + is_writable_dir -- Check to see if directory exists and is writable + create_mail_dir -- Make a directory + rename_file -- change name of a file + build_path -- Put together a file system path + last_cmpnt -- Returns pointer to last component of path + expand_foldername -- Expand a folder name to full path + fnexpand -- Do filename exansion for csh style "~" + filter_filename -- Make sure file name hasn't got weird chars + cntxt_allowed -- Check whether a pathname is allowed for read/write + disk_quota -- Check the user's disk quota + read_file -- Read whole file into memory (for small files) + create_tmpfile -- Just like ANSI C tmpfile function + temp_nam -- Almost like common tempnam function + fget_pos,fset_pos -- Just like ANSI C fgetpos, fsetpos functions + + Abort + coredump -- Abort running Pine dumping core if possible + + System Name and Domain + hostname -- Figure out the system's host name, only + used internally in this file. + getdomainnames -- Figure out the system's domain name + canonical_name -- Returns canonical form of host name + + Job Control + have_job_control -- Returns 1 if job control exists + stop_process -- What to do to stop process when it's time to stop + (only used if have_job_control returns 1) + + System Error Messages (in case given one is a problem) + error_description -- Returns string describing error + + System Password and Accounts + gcos_name -- Parses full name from system, only used + locally in this file so if you don't use it you + don't need it + get_user_info -- Finds in login name, full name, and homedir + local_name_lookup -- Get full name of user on system + change_passwd -- Calls system password changer + + MIME utilities + mime_can_display -- Can we display this type/subtype? + exec_mailcap_cmd -- Run the mailcap command to view a type/subtype. + exec_mailcap_test_cmd -- Run mailcap test= test command. + + Other stuff + srandom -- Dummy srandom if you don't have this function + init_debug + do_debug + save_debug_on_crash + + ====*/ + + +#include "headers.h" + + + +/*---------------------------------------------------------------------- + Check if we can access a file in a given way + + Args: file -- The file to check + mode -- The mode ala the access() system call, see ACCESS_EXISTS + and friends in pine.h. + + Result: returns 0 if the user can access the file according to the mode, + -1 if he can't (and errno is set). + ----*/ +int +can_access(file, mode) + char *file; + int mode; +{ + return(access(file, mode)); +} + + +/*---------------------------------------------------------------------- + Check if we can access a file in a given way in the given path + + Args: path -- The path to look for "file" in + file -- The file to check + mode -- The mode ala the access() system call, see ACCESS_EXISTS + and friends in pine.h. + + Result: returns 0 if the user can access the file according to the mode, + -1 if he can't (and errno is set). + ----*/ +can_access_in_path(path, file, mode) + char *path, *file; + int mode; +{ + char tmp[MAXPATH], *path_copy, *p, *t; + int rv = -1; + + if(!path || !*path || *file == '/'){ + rv = access(file, mode); + } + else if(*file == '~'){ + strcpy(tmp, file); + rv = fnexpand(tmp, sizeof(tmp)) ? access(tmp, mode) : -1; + } + else{ + for(p = path_copy = cpystr(path); p && *p; p = t){ + if(t = strindex(p, ':')) + *t++ = '\0'; + + sprintf(tmp, "%s/%s", p, file); + if((rv = access(tmp, mode)) == 0) + break; + } + + fs_give((void **)&path_copy); + } + + return(rv); +} + +/*---------------------------------------------------------------------- + Return the number of bytes in given file + + Args: file -- file name + + Result: the number of bytes in the file is returned or + -1 on error, in which case errno is valid + ----*/ +long +name_file_size(file) + char *file; +{ + struct stat buffer; + + if(stat(file, &buffer) != 0) + return(-1L); + + return((long)buffer.st_size); +} + + +/*---------------------------------------------------------------------- + Return the number of bytes in given file + + Args: fp -- FILE * for open file + + Result: the number of bytes in the file is returned or + -1 on error, in which case errno is valid + ----*/ +long +fp_file_size(fp) + FILE *fp; +{ + struct stat buffer; + + if(fstat(fileno(fp), &buffer) != 0) + return(-1L); + + return((long)buffer.st_size); +} + + +/*---------------------------------------------------------------------- + Return the modification time of given file + + Args: file -- file name + + Result: the time of last modification (mtime) of the file is returned or + -1 on error, in which case errno is valid + ----*/ +time_t +name_file_mtime(file) + char *file; +{ + struct stat buffer; + + if(stat(file, &buffer) != 0) + return((time_t)(-1)); + + return(buffer.st_mtime); +} + + +/*---------------------------------------------------------------------- + Return the modification time of given file + + Args: fp -- FILE * for open file + + Result: the time of last modification (mtime) of the file is returned or + -1 on error, in which case errno is valid + ----*/ +time_t +fp_file_mtime(fp) + FILE *fp; +{ + struct stat buffer; + + if(fstat(fileno(fp), &buffer) != 0) + return((time_t)(-1)); + + return(buffer.st_mtime); +} + + +/*---------------------------------------------------------------------- + Copy the mode, owner, and group of sourcefile to targetfile. + + Args: targetfile -- + sourcefile -- + + We don't bother keeping track of success or failure because we don't care. + ----*/ +void +file_attrib_copy(targetfile, sourcefile) + char *targetfile; + char *sourcefile; +{ + struct stat buffer; + + if(stat(sourcefile, &buffer) == 0){ + chmod(targetfile, buffer.st_mode); +#if !defined(DOS) && !defined(OS2) + chown(targetfile, buffer.st_uid, buffer.st_gid); +#endif + } +} + + + +/*---------------------------------------------------------------------- + Check to see if a directory exists and is writable by us + + Args: dir -- directory name + + Result: returns 0 if it exists and is writable + 1 if it is a directory, but is not writable + 2 if it is not a directory + 3 it doesn't exist. + ----*/ +is_writable_dir(dir) + char *dir; +{ + struct stat sb; + + if(stat(dir, &sb) < 0) + /*--- It doesn't exist ---*/ + return(3); + + if(!(sb.st_mode & S_IFDIR)) + /*---- it's not a directory ---*/ + return(2); + + if(can_access(dir, 07)) + return(1); + else + return(0); +} + + + +/*---------------------------------------------------------------------- + Create the mail subdirectory. + + Args: dir -- Name of the directory to create + + Result: Directory is created. Returns 0 on success, else -1 on error + and errno is valid. + ----*/ +create_mail_dir(dir) + char *dir; +{ + if(mkdir(dir, 0700) < 0) + return(-1); + + (void)chmod(dir, 0700); + /* Some systems need this, on others we don't care if it fails */ + (void)chown(dir, getuid(), getgid()); + return(0); +} + + + +/*---------------------------------------------------------------------- + Rename a file + + Args: tmpfname -- Old name of file + fname -- New name of file + + Result: File is renamed. Returns 0 on success, else -1 on error + and errno is valid. + ----*/ +rename_file(tmpfname, fname) + char *tmpfname, *fname; +{ + return(rename(tmpfname, fname)); +} + + + +/*---------------------------------------------------------------------- + Paste together two pieces of a file name path + + Args: pathbuf -- Put the result here + first_part -- of path name + second_part -- of path name + + Result: New path is in pathbuf. No check is made for overflow. Note that + we don't have to check for /'s at end of first_part and beginning + of second_part since multiple slashes are ok. + +BUGS: This is a first stab at dealing with fs naming dependencies, and others +still exist. + ----*/ +void +build_path(pathbuf, first_part, second_part) + char *pathbuf, *first_part, *second_part; +{ + if(!first_part) + strcpy(pathbuf, second_part); + else + sprintf(pathbuf, "%s%s%s", first_part, + (*first_part && first_part[strlen(first_part)-1] != '/') + ? "/" : "", + second_part); +} + + +/*---------------------------------------------------------------------- + Test to see if the given file path is absolute + + Args: file -- file path to test + + Result: TRUE if absolute, FALSE otw + + ----*/ +int +is_absolute_path(path) + char *path; +{ + return(path && (*path == '/' || *path == '~')); +} + + + +/*---------------------------------------------------------------------- + Return pointer to last component of pathname. + + Args: filename -- The pathname. + + Result: Returned pointer points to last component in the input argument. + ----*/ +char * +last_cmpnt(filename) + char *filename; +{ + register char *p = NULL, *q = filename; + + while(q = strchr(q, '/')) + if(*++q) + p = q; + + return(p); +} + + + +/*---------------------------------------------------------------------- + Expand a folder name, taking account of the folders_dir and `~'. + + Args: filename -- The name of the file that is the folder + + Result: The folder name is expanded in place. + Returns 0 and queues status message if unsuccessful. + Input string is overwritten with expanded name. + Returns 1 if successful. + +BUG should limit length to MAXPATH + ----*/ +int +expand_foldername(filename) + char *filename; +{ + char temp_filename[MAXPATH+1]; + + dprint(5, (debugfile, "=== expand_foldername called (%s) ===\n",filename)); + + /* + * We used to check for valid filename chars here if "filename" + * didn't refer to a remote mailbox. This has been rethought + */ + + strcpy(temp_filename, filename); + if(strucmp(temp_filename, "inbox") == 0) { + strcpy(filename, ps_global->VAR_INBOX_PATH == NULL ? "inbox" : + ps_global->VAR_INBOX_PATH); + } else if(temp_filename[0] == '{') { + strcpy(filename, temp_filename); + } else if(ps_global->restricted + && (strindex("./~", temp_filename[0]) != NULL + || srchstr(temp_filename,"/../"))){ + q_status_message(SM_ORDER, 0, 3, "Can only open local folders"); + return(0); + } else if(temp_filename[0] == '*') { + strcpy(filename, temp_filename); + } else if(ps_global->VAR_OPER_DIR && srchstr(temp_filename,"..")){ + q_status_message(SM_ORDER, 0, 3, + "\"..\" not allowed in folder name"); + return(0); + } else if (temp_filename[0] == '~'){ + if(fnexpand(temp_filename, sizeof(temp_filename)) == NULL) { + char *p = strindex(temp_filename, '/'); + if(p != NULL) + *p = '\0'; + q_status_message1(SM_ORDER, 3, 3, + "Error expanding folder name: \"%s\" unknown user", + temp_filename); + return(0); + } + strcpy(filename, temp_filename); + } else if(temp_filename[0] == '/') { + strcpy(filename, temp_filename); + } else if(F_ON(F_USE_CURRENT_DIR, ps_global)){ + strcpy(filename, temp_filename); + } else if(ps_global->VAR_OPER_DIR){ + build_path(filename, ps_global->VAR_OPER_DIR, temp_filename); + } else { + build_path(filename, ps_global->home_dir, temp_filename); + } + dprint(5, (debugfile, "returning \"%s\"\n", filename)); + return(1); +} + + + +struct passwd *getpwnam(); + +/*---------------------------------------------------------------------- + Expand the ~ in a file ala the csh (as home directory) + + Args: buf -- The filename to expand (nothing happens unless begins with ~) + len -- The length of the buffer passed in (expansion is in place) + + Result: Expanded string is returned using same storage as passed in. + If expansion fails, NULL is returned + ----*/ +char * +fnexpand(buf, len) + char *buf; + int len; +{ + struct passwd *pw; + register char *x,*y; + char name[20]; + + if(*buf == '~') { + for(x = buf+1, y = name; *x != '/' && *x != '\0'; *y++ = *x++); + *y = '\0'; + if(x == buf + 1) + pw = getpwuid(getuid()); + else + pw = getpwnam(name); + if(pw == NULL) + return((char *)NULL); + if(strlen(pw->pw_dir) + strlen(buf) > len) { + return((char *)NULL); + } + rplstr(buf, x - buf, pw->pw_dir); + } + return(len ? buf : (char *)NULL); +} + + + +/*---------------------------------------------------------------------- + Filter file names for strange characters + + Args: file -- the file name to check + + Result: Returns NULL if file name is OK + Returns formatted error message if it is not + ----*/ +char * +filter_filename(file, fatal) + char *file; + int *fatal; +{ +#ifdef ALLOW_WEIRD + static char illegal[] = {'\177', '\0'}; +#else + static char illegal[] = {'"', '#', '$', '%', '&', '\'','(', ')','*', + ',', ':', ';', '<', '=', '>', '?', '[', ']', + '\\', '^', '|', '\177', '\0'}; +#endif + static char error[100]; + char ill_file[MAXPATH+1], *ill_char, *ptr, e2[10]; + int i; + + for(ptr = file; *ptr == ' '; ptr++) ; /* leading spaces gone */ + + while(*ptr && (unsigned char)(*ptr) >= ' ' && strindex(illegal, *ptr) == 0) + ptr++; + + *fatal = TRUE; + if(*ptr != '\0') { + if(*ptr == '\n') { + ill_char = "<newline>"; + } else if(*ptr == '\r') { + ill_char = "<carriage return>"; + } else if(*ptr == '\t') { + ill_char = "<tab>"; + *fatal = FALSE; /* just whitespace */ + } else if(*ptr < ' ') { + sprintf(e2, "control-%c", *ptr + '@'); + ill_char = e2; + } else if (*ptr == '\177') { + ill_char = "<del>"; + } else { + e2[0] = *ptr; + e2[1] = '\0'; + ill_char = e2; + *fatal = FALSE; /* less offensive? */ + } + if(!*fatal){ + strcpy(error, ill_char); + } + else if(ptr != file) { + strncpy(ill_file, file, ptr - file); + ill_file[ptr - file] = '\0'; + sprintf(error, + "Character \"%s\" after \"%s\" not allowed in file name", + ill_char, ill_file); + } else { + sprintf(error, + "First character, \"%s\", not allowed in file name", + ill_char); + } + + return(error); + } + + if((i=is_writable_dir(file)) == 0 || i == 1){ + sprintf(error, "\"%s\" is a directory", file); + return(error); + } + + if(ps_global->restricted || ps_global->VAR_OPER_DIR){ + for(ptr = file; *ptr == ' '; ptr++) ; /* leading spaces gone */ + + if((ptr[0] == '.' && ptr[1] == '.') || srchstr(ptr, "/../")){ + sprintf(error, "\"..\" not allowed in filename"); + return(error); + } + } + + return((char *)NULL); +} + + +/*---------------------------------------------------------------------- + Check to see if user is allowed to read or write this folder. + + Args: s -- the name to check + + Result: Returns 1 if OK + Returns 0 and posts an error message if access is denied + ----*/ +int +cntxt_allowed(s) + char *s; +{ + struct variable *vars = ps_global->vars; + int retval = 1; + MAILSTREAM stream; /* fake stream for error message in mm_notify */ + + if(ps_global->restricted + && (strindex("./~", s[0]) || srchstr(s, "/../"))){ + stream.mailbox = s; + mm_notify(&stream, "Restricted mode doesn't allow operation", WARN); + retval = 0; + } + else if(VAR_OPER_DIR + && s[0] != '{' && !(s[0] == '*' && s[1] == '{') + && strucmp(s,ps_global->inbox_name) != 0 + && strcmp(s, ps_global->VAR_INBOX_PATH) != 0){ + char *p, *free_this = NULL; + + p = s; + if(strindex(s, '~')){ + p = strindex(s, '~'); + free_this = (char *)fs_get(strlen(p) + 200); + strcpy(free_this, p); + fnexpand(free_this, strlen(p)+200); + p = free_this; + } + else if(p[0] != '/'){ /* add home dir to relative paths */ + free_this = p = (char *)fs_get(strlen(s) + + strlen(ps_global->home_dir) + 2); + build_path(p, ps_global->home_dir, s); + } + + if(!in_dir(VAR_OPER_DIR, p)){ + char err[200]; + + sprintf(err, "Not allowed outside of %s", VAR_OPER_DIR); + stream.mailbox = p; + mm_notify(&stream, err, WARN); + retval = 0; + } + else if(srchstr(p, "/../")){ /* check for .. in path */ + stream.mailbox = p; + mm_notify(&stream, "\"..\" not allowed in name", WARN); + retval = 0; + } + + if(free_this) + fs_give((void **)&free_this); + } + + return retval; +} + + + +#if defined(USE_QUOTAS) + +/*---------------------------------------------------------------------- + This system doesn't have disk quotas. + Return space left in disk quota on file system which given path is in. + + Args: path - Path name of file or directory on file system of concern + over - pointer to flag that is set if the user is over quota + + Returns: If *over = 0, the number of bytes free in disk quota as per + the soft limit. + If *over = 1, the number of bytes *over* quota. + -1 is returned on an error looking up quota + 0 is returned if there is no quota + +BUG: If there's more than 2.1Gb free this function will break + ----*/ +long +disk_quota(path, over) + char *path; + int *over; +{ + return(0L); +} +#endif /* USE_QUOTAS */ + + + +/*---------------------------------------------------------------------- + Read whole file into memory + + Args: filename -- path name of file to read + + Result: Returns pointer to malloced memory with the contents of the file + or NULL + +This won't work very well if the file has NULLs in it and is mostly +intended for fairly small text files. + ----*/ +char * +read_file(filename) + char *filename; +{ + int fd; + struct stat statbuf; + char *buf; + int nb; + + fd = open(filename, O_RDONLY); + if(fd < 0) + return((char *)NULL); + + fstat(fd, &statbuf); + + buf = fs_get((size_t)statbuf.st_size + 1); + + /* + * On some systems might have to loop here, if one read isn't guaranteed + * to get the whole thing. + */ + if((nb = read(fd, buf, (int)statbuf.st_size)) < 0) + fs_give((void **)&buf); /* NULL's buf */ + else + buf[nb] = '\0'; + + close(fd); + return(buf); +} + + + +/*---------------------------------------------------------------------- + Create a temporary file, the name of which we don't care about +and that goes away when it is closed. Just like ANSI C tmpfile. + ----*/ +FILE * +create_tmpfile() +{ + return(tmpfile()); +} + + + +/*---------------------------------------------------------------------- + Abort with a core dump + ----*/ +void +coredump() +{ + abort(); +} + + + +/*---------------------------------------------------------------------- + Call system gethostname + + Args: hostname -- buffer to return host name in + size -- Size of buffer hostname is to be returned in + + Result: returns 0 if the hostname is correctly set, + -1 if not (and errno is set). + ----*/ +hostname(hostname,size) + char *hostname; + int size; +{ + return(gethostname(hostname, size)); +} + + + +/*---------------------------------------------------------------------- + Get the current host and domain names + + Args: hostname -- buffer to return the hostname in + hsize -- size of buffer above + domainname -- buffer to return domain name in + dsize -- size of buffer above + + Result: The system host and domain names are returned. If the full host + name is akbar.cac.washington.edu then the domainname is + cac.washington.edu. + +On Internet connected hosts this look up uses /etc/hosts and DNS to +figure all this out. On other less well connected machines some other +file may be read. If there is no notion of a domain name the domain +name may be left blank. On a PC where there really isn't a host name +this should return blank strings. The .pinerc will take care of +configuring the domain names. That is, this should only return the +native system's idea of what the names are if the system has such +a concept. + ----*/ +void +getdomainnames(hostname, hsize, domainname, dsize) + char *hostname, *domainname; + int hsize, dsize; +{ + char *dn, hname[MAX_ADDRESS+1]; + struct hostent *he; + char **alias; + char *maybe = NULL; + + gethostname(hname, MAX_ADDRESS); + he = gethostbyname(hname); + hostname[0] = '\0'; + + if(he == NULL) + strncpy(hostname, hname, hsize-1); + else{ + /* + * If no dot in hostname it may be the case that there + * is an alias which is really the fully-qualified + * hostname. This could happen if the administrator has + * (incorrectly) put the unqualified name first in the + * hosts file, for example. The problem with looking for + * an alias with a dot is that now we're guessing, since + * the aliases aren't supposed to be the official hostname. + * We'll compromise and only use an alias if the primary + * name has no dot and exactly one of the aliases has a + * dot. + */ + strncpy(hostname, he->h_name, hsize-1); + if(strindex(hostname, '.') == NULL){ /* no dot in hostname */ + for(alias = he->h_aliases; *alias; alias++){ + if(strindex(*alias, '.') != NULL){ /* found one */ + if(maybe){ /* oops, this is the second one */ + maybe = NULL; + break; + } + else + maybe = *alias; + } + } + + if(maybe) + strncpy(hostname, maybe, hsize-1); + } + } + + hostname[hsize-1] = '\0'; + + + if((dn = strindex(hostname, '.')) != NULL) + strncpy(domainname, dn+1, dsize-1); + else + strncpy(domainname, hostname, dsize-1); + + domainname[dsize-1] = '\0'; +} + + + +/*---------------------------------------------------------------------- + Return canonical form of host name ala c-client (UNIX version). + + Args: host -- The host name + + Result: Canonical form, or input argument (worst case) + ----*/ +char * +canonical_name(host) + char *host; +{ + struct hostent *hent; + char hostname[MAILTMPLEN]; + char tmp[MAILTMPLEN]; + extern char *lcase(); + /* domain literal is easy */ + if (host[0] == '[' && host[(strlen (host))-1] == ']') + return host; + + strcpy (hostname,host); /* UNIX requires lowercase */ + /* lookup name, return canonical form */ + return (hent = gethostbyname (lcase (strcpy (tmp,host)))) ? + hent->h_name : host; +} + + + +/*---------------------------------------------------------------------- + This routine returns 1 if job control is available. Note, thiis + could be some type of fake job control. It doesn't have to be + real BSD-style job control. + ----*/ +have_job_control() +{ + return 1; +} + + +/*---------------------------------------------------------------------- + If we don't have job control, this routine is never called. + ----*/ +stop_process() +{ + SigType (*save_usr2) SIG_PROTO((int)); + + /* + * Since we can't respond to KOD while stopped, the process that sent + * the KOD is going to go read-only. Therefore, we can safely ignore + * any KODs that come in before we are ready to respond... + */ + save_usr2 = signal(SIGUSR2, SIG_IGN); + kill(0, SIGSTOP); + (void)signal(SIGUSR2, save_usr2); +} + + + +/*---------------------------------------------------------------------- + Return string describing the error + + Args: errnumber -- The system error number (errno) + + Result: long string describing the error is returned + ----*/ +char * +error_description(errnumber) + int errnumber; +{ + static char buffer[50+1]; + + if(errnumber >= 0 && errnumber < sys_nerr) + sprintf(buffer, "%.*s", 50, sys_errlist[errnumber]); + else + sprintf(buffer, "Unknown error #%d", errnumber); + + return ( (char *) buffer); +} + + + +/*---------------------------------------------------------------------- + Pull the name out of the gcos field if we have that sort of /etc/passwd + + Args: gcos_field -- The long name or GCOS field to be parsed + logname -- Replaces occurances of & with logname string + + Result: returns pointer to buffer with name + ----*/ +static char * +gcos_name(gcos_field, logname) + char *logname, *gcos_field; +{ + static char fullname[MAX_FULLNAME+1]; + register char *fncp, *gcoscp, *lncp, *end; + + /* full name is all chars up to first ',' (or whole gcos, if no ',') */ + /* replace any & with logname in upper case */ + + for(fncp = fullname, gcoscp= gcos_field, end = fullname + MAX_FULLNAME - 1; + (*gcoscp != ',' && *gcoscp != '\0' && fncp != end); + gcoscp++) { + + if(*gcoscp == '&') { + for(lncp = logname; *lncp; fncp++, lncp++) + *fncp = toupper((unsigned char)(*lncp)); + } else { + *fncp++ = *gcoscp; + } + } + + *fncp = '\0'; + return(fullname); +} + + +/*---------------------------------------------------------------------- + Fill in homedir, login, and fullname for the logged in user. + These are all pointers to static storage so need to be copied + in the caller. + + Args: ui -- struct pointer to pass back answers + + Result: fills in the fields + ----*/ +void +get_user_info(ui) + struct user_info *ui; +{ + struct passwd *unix_pwd; + + unix_pwd = getpwuid(getuid()); + if(unix_pwd == NULL) { + ui->homedir = cpystr(""); + ui->login = cpystr(""); + ui->fullname = cpystr(""); + }else { + ui->homedir = cpystr(unix_pwd->pw_dir); + ui->login = cpystr(unix_pwd->pw_name); + ui->fullname = cpystr(gcos_name(unix_pwd->pw_gecos, unix_pwd->pw_name)); + } +} + + +/*---------------------------------------------------------------------- + Look up a userid on the local system and return rfc822 address + + Args: name -- possible login name on local system + + Result: returns NULL or pointer to alloc'd string rfc822 address. + ----*/ +char * +local_name_lookup(name) + char *name; +{ + struct passwd *pw = getpwnam(name); + + if(pw == NULL){ + char *p; + + for(p = name; *p; p++) + if(isupper((unsigned char)*p)) + break; + + /* try changing it to all lower case */ + if(p && *p){ + char *lcase; + + lcase = cpystr(name); + for(p = lcase; *p; p++) + if(isupper((unsigned char)*p)) + *p = tolower((unsigned char)*p); + + pw = getpwnam(lcase); + + if(pw) + strcpy(name, lcase); + + fs_give((void **)&lcase); + } + } + + if(pw == NULL) + return((char *)NULL); + + return(cpystr(gcos_name(pw->pw_gecos, name))); +} + + + +/*---------------------------------------------------------------------- + Call the system to change the passwd + +It would be nice to talk to the passwd program via a pipe or ptty so the +user interface could be consistent, but we can't count on the the prompts +and responses from the passwd program to be regular so we just let the user +type at the passwd program with some screen space, hope he doesn't scroll +off the top and repaint when he's done. + ----*/ +change_passwd() +{ + char cmd_buf[100]; + + ClearLines(1, ps_global->ttyo->screen_rows - 1); + + MoveCursor(5, 0); + fflush(stdout); + + PineRaw(0); + strcpy(cmd_buf, PASSWD_PROG); + system(cmd_buf); + sleep(3); + PineRaw(1); +} + + + +/*---------------------------------------------------------------------- + Can we display this type/subtype? + + Args: type -- the MIME type to check + subtype -- the MIME subtype + params -- parameters + use_viewer -- tell caller he should run external viewer cmd to view + + Result: Returns: + + MCD_NONE if we can't display this type at all + MCD_INTERNAL if we can display it internally + MCD_EXTERNAL if it can be displayed via an external viewer + + ----*/ +mime_can_display(type, subtype, params) + int type; + char *subtype; + PARAMETER *params; +{ + return((mailcap_can_display(type, subtype, params) + ? MCD_EXTERNAL : MCD_NONE) + | ((type == TYPETEXT || type == TYPEMESSAGE + || MIME_VCARD(type,subtype)) + ? MCD_INTERNAL : MCD_NONE)); +} + + + +/*====================================================================== + pipe + + Initiate I/O to and from a process. These functions are similar to + popen and pclose, but both an incoming stream and an output file are + provided. + + ====*/ + +#ifndef STDIN_FILENO +#define STDIN_FILENO 0 +#endif +#ifndef STDOUT_FILENO +#define STDOUT_FILENO 1 +#endif +#ifndef STDERR_FILENO +#define STDERR_FILENO 2 +#endif + + +/* + * Defs to help fish child's exit status out of wait(2) + */ +#ifdef HAVE_WAIT_UNION +#define WaitType union wait +#ifndef WIFEXITED +#define WIFEXITED(X) (!(X).w_termsig) /* child exit by choice */ +#endif +#ifndef WEXITSTATUS +#define WEXITSTATUS(X) (X).w_retcode /* childs chosen exit value */ +#endif +#else +#define WaitType int +#ifndef WIFEXITED +#define WIFEXITED(X) (!((X) & 0xff)) /* low bits tell how it died */ +#endif +#ifndef WEXITSTATUS +#define WEXITSTATUS(X) (((X) >> 8) & 0xff) /* high bits tell exit value */ +#endif +#endif + + +/* + * Global's to helpsignal handler tell us child's status has changed... + */ +short child_signalled; +short child_jump = 0; +jmp_buf child_state; +int child_pid; + + +/* + * Internal Protos + */ +void pipe_error_cleanup PROTO((PIPE_S **, char *, char *, char *)); +void zot_pipe PROTO((PIPE_S **)); +static SigType pipe_alarm SIG_PROTO((int)); + + + + +/*---------------------------------------------------------------------- + Spawn a child process and optionally connect read/write pipes to it + + Args: command -- string to hand the shell + outfile -- address of pointer containing file to receive output + errfile -- address of pointer containing file to receive error output + mode -- mode for type of shell, signal protection etc... + Returns: pointer to alloc'd PIPE_S on success, NULL otherwise + + The outfile is either NULL, a pointer to a NULL value, or a pointer + to the requested name for the output file. In the pointer-to-NULL case + the caller doesn't care about the name, but wants to see the pipe's + results so we make one up. It's up to the caller to make sure the + free storage containing the name is cleaned up. + + Mode bits serve several purposes. + PIPE_WRITE tells us we need to open a pipe to write the child's + stdin. + PIPE_READ tells us we need to open a pipe to read from the child's + stdout/stderr. *NOTE* Having neither of the above set means + we're not setting up any pipes, just forking the child and exec'ing + the command. Also, this takes precedence over any named outfile. + PIPE_STDERR means we're to tie the childs stderr to the same place + stdout is going. *NOTE* This only makes sense then if PIPE_READ + or an outfile is provided. Also, this takes precedence over any + named errfile. + PIPE_PROT means to protect the child from the usual nasty signals + that might cause premature death. Otherwise, the default signals are + set so the child can deal with the nasty signals in its own way. + PIPE_NOSHELL means we're to exec the command without the aid of + a system shell. *NOTE* This negates the affect of PIPE_USER. + PIPE_USER means we're to try executing the command in the user's + shell. Right now we only look in the environment, but that may get + more sophisticated later. + PIPE_RESET means we reset the terminal mode to what it was before + we started pine and then exec the command. + ----*/ +PIPE_S * +open_system_pipe(command, outfile, errfile, mode, timeout) + char *command; + char **outfile, **errfile; + int mode, timeout; +{ + PIPE_S *syspipe = NULL; + char shellpath[32], *shell; + int p[2], oparentd = -1, ochildd = -1, iparentd = -1, ichildd = -1; + + dprint(5, (debugfile, "Opening pipe: \"%s\" (%s%s%s%s%s%s)\n", command, + (mode & PIPE_WRITE) ? "W":"", (mode & PIPE_READ) ? "R":"", + (mode & PIPE_NOSHELL) ? "N":"", (mode & PIPE_PROT) ? "P":"", + (mode & PIPE_USER) ? "U":"", (mode & PIPE_RESET) ? "T":"")); + + syspipe = (PIPE_S *)fs_get(sizeof(PIPE_S)); + memset(syspipe, 0, sizeof(PIPE_S)); + + /* + * If we're not using the shell's command parsing smarts, build + * argv by hand... + */ + if(mode & PIPE_NOSHELL){ + char **ap, *p; + size_t n; + + /* parse the arguments into argv */ + for(p = command; *p && isspace((unsigned char)(*p)); p++) + ; /* swallow leading ws */ + + if(*p){ + syspipe->args = cpystr(p); + } + else{ + pipe_error_cleanup(&syspipe, "<null>", "execute", + "No command name found"); + return(NULL); + } + + for(p = syspipe->args, n = 2; *p; p++) /* count the args */ + if(isspace((unsigned char)(*p)) + && *(p+1) && !isspace((unsigned char)(*(p+1)))) + n++; + + syspipe->argv = ap = (char **)fs_get(n * sizeof(char *)); + memset(syspipe->argv, 0, n * sizeof(char *)); + + for(p = syspipe->args; *p; ){ /* collect args */ + while(*p && isspace((unsigned char)(*p))) + *p++ = '\0'; + + *ap++ = (*p) ? p : NULL; + while(*p && !isspace((unsigned char)(*p))) + p++; + } + + /* make sure argv[0] exists in $PATH */ + if(can_access_in_path(getenv("PATH"), syspipe->argv[0], + EXECUTE_ACCESS) < 0){ + pipe_error_cleanup(&syspipe, syspipe->argv[0], "access", + error_description(errno)); + return(NULL); + } + } + + /* fill in any output filenames */ + if(!(mode & PIPE_READ)){ + if(outfile && !*outfile) + *outfile = temp_nam(NULL, "pine_p"); /* asked for, but not named? */ + + if(errfile && !*errfile) + *errfile = temp_nam(NULL, "pine_p"); /* ditto */ + } + + /* create pipes */ + if(mode & (PIPE_WRITE | PIPE_READ)){ + if(mode & PIPE_WRITE){ + pipe(p); /* alloc pipe to write child */ + oparentd = p[STDOUT_FILENO]; + ichildd = p[STDIN_FILENO]; + } + + if(mode & PIPE_READ){ + pipe(p); /* alloc pipe to read child */ + iparentd = p[STDIN_FILENO]; + ochildd = p[STDOUT_FILENO]; + } + } + else if(!(mode & PIPE_SILENT)){ + flush_status_messages(0); /* just clean up display */ + ClearScreen(); + fflush(stdout); + } + + if((syspipe->mode = mode) & PIPE_RESET) + PineRaw(0); + +#ifdef SIGCHLD + /* + * Prepare for demise of child. Use SIGCHLD if it's available so + * we can do useful things, like keep the IMAP stream alive, while + * we're waiting on the child. + */ + child_signalled = child_jump = 0; +#endif + + if((syspipe->pid = vfork()) == 0){ + /* reset child's handlers in requested fashion... */ + (void)signal(SIGINT, (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL); + (void)signal(SIGQUIT, (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL); + (void)signal(SIGHUP, (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL); +#ifdef SIGCHLD + (void) signal(SIGCHLD, SIG_DFL); +#endif + + /* if parent isn't reading, and we have a filename to write */ + if(!(mode & PIPE_READ) && outfile){ /* connect output to file */ + int output = creat(*outfile, 0600); + dup2(output, STDOUT_FILENO); + if(mode & PIPE_STDERR) + dup2(output, STDERR_FILENO); + else if(errfile) + dup2(creat(*errfile, 0600), STDERR_FILENO); + } + + if(mode & PIPE_WRITE){ /* connect process input */ + close(oparentd); + dup2(ichildd, STDIN_FILENO); /* tie stdin to pipe */ + close(ichildd); + } + + if(mode & PIPE_READ){ /* connect process output */ + close(iparentd); + dup2(ochildd, STDOUT_FILENO); /* tie std{out,err} to pipe */ + if(mode & PIPE_STDERR) + dup2(ochildd, STDERR_FILENO); + else if(errfile) + dup2(creat(*errfile, 0600), STDERR_FILENO); + + close(ochildd); + } + + if(mode & PIPE_NOSHELL){ + execvp(syspipe->argv[0], syspipe->argv); + } + else{ + if(mode & PIPE_USER){ + char *env, *sh; + if((env = getenv("SHELL")) && (sh = strrchr(env, '/'))){ + shell = sh + 1; + strcpy(shellpath, env); + } + else{ + shell = "csh"; + strcpy(shellpath, "/bin/csh"); + } + } + else{ + shell = "sh"; + strcpy(shellpath, "/bin/sh"); + } + + execl(shellpath, shell, command ? "-c" : 0, command, 0); + } + + fprintf(stderr, "Can't exec %s\nReason: %s", + command, error_description(errno)); + _exit(-1); + } + + if((child_pid = syspipe->pid) > 0){ + syspipe->isig = signal(SIGINT, SIG_IGN); /* Reset handlers to make */ + syspipe->qsig = signal(SIGQUIT, SIG_IGN); /* sure we don't come to */ + syspipe->hsig = signal(SIGHUP, SIG_IGN); /* a premature end... */ + if((syspipe->timeout = timeout) != 0){ + syspipe->alrm = signal(SIGALRM, pipe_alarm); + syspipe->old_timeo = alarm(timeout); + } + + if(mode & PIPE_WRITE){ + close(ichildd); + if(mode & PIPE_DESC) + syspipe->out.d = oparentd; + else + syspipe->out.f = fdopen(oparentd, "w"); + } + + if(mode & PIPE_READ){ + close(ochildd); + if(mode & PIPE_DESC) + syspipe->in.d = iparentd; + else + syspipe->in.f = fdopen(iparentd, "r"); + } + + dprint(5, (debugfile, "PID: %d, COMMAND: %s\n",syspipe->pid,command)); + } + else{ + if(mode & (PIPE_WRITE | PIPE_READ)){ + if(mode & PIPE_WRITE){ + close(oparentd); + close(ichildd); + } + + if(mode & PIPE_READ){ + close(iparentd); + close(ochildd); + } + } + else if(!(mode & PIPE_SILENT)){ + ClearScreen(); + ps_global->mangled_screen = 1; + } + + if(mode & PIPE_RESET) + PineRaw(1); + +#ifdef SIGCHLD + (void) signal(SIGCHLD, SIG_DFL); +#endif + if(outfile) + fs_give((void **) outfile); + + pipe_error_cleanup(&syspipe, command, "fork",error_description(errno)); + } + + return(syspipe); +} + + + +/*---------------------------------------------------------------------- + Write appropriate error messages and cleanup after pipe error + + Args: syspipe -- address of pointer to struct to clean up + cmd -- command we were trying to exec + op -- operation leading up to the exec + res -- result of that operation + + ----*/ +void +pipe_error_cleanup(syspipe, cmd, op, res) + PIPE_S **syspipe; + char *cmd, *op, *res; +{ + q_status_message3(SM_ORDER, 3, 3, "Pipe can't %s \"%.20s\": %s", + op, cmd, res); + dprint(1, (debugfile, "* * PIPE CAN'T %s(%s): %s\n", op, cmd, res)); + zot_pipe(syspipe); +} + + + +/*---------------------------------------------------------------------- + Free resources associated with the given pipe struct + + Args: syspipe -- address of pointer to struct to clean up + + ----*/ +void +zot_pipe(syspipe) + PIPE_S **syspipe; +{ + if((*syspipe)->args) + fs_give((void **) &(*syspipe)->args); + + if((*syspipe)->argv) + fs_give((void **) &(*syspipe)->argv); + + if((*syspipe)->tmp) + fs_give((void **) &(*syspipe)->tmp); + + fs_give((void **)syspipe); +} + + + +/*---------------------------------------------------------------------- + Close pipe previously allocated and wait for child's death + + Args: syspipe -- address of pointer to struct returned by open_system_pipe + Returns: returns exit status of child or -1 if invalid syspipe + ----*/ +int +close_system_pipe(syspipe) + PIPE_S **syspipe; +{ + WaitType stat; + int status; + + if(!(syspipe && *syspipe)) + return(-1); + + if(((*syspipe)->mode) & PIPE_WRITE){ + if(((*syspipe)->mode) & PIPE_DESC){ + if((*syspipe)->out.d >= 0) + close((*syspipe)->out.d); + } + else if((*syspipe)->out.f) + fclose((*syspipe)->out.f); + } + + if(((*syspipe)->mode) & PIPE_READ){ + if(((*syspipe)->mode) & PIPE_DESC){ + if((*syspipe)->in.d >= 0) + close((*syspipe)->in.d); + } + else if((*syspipe)->in.f) + fclose((*syspipe)->in.f); + } + +#ifdef SIGCHLD + { + SigType (*alarm_sig)(); + int old_cue = F_ON(F_SHOW_DELAY_CUE, ps_global); + + /* + * remember the current SIGALRM handler, and make sure it's + * installed when we're finished just in case the longjmp + * out of the SIGCHLD handler caused sleep() to lose it. + * Don't pay any attention to that man behind the curtain. + */ + alarm_sig = signal(SIGALRM, SIG_IGN); + F_SET(F_SHOW_DELAY_CUE, ps_global, 0); + ps_global->noshow_timeout = 1; + while(!child_signalled){ + /* wake up and prod server */ + new_mail(0, 2, ((*syspipe)->mode & PIPE_RESET) + ? NM_NONE : NM_DEFER_SORT); + + if(!child_signalled){ + if(setjmp(child_state) == 0){ + child_jump = 1; /* prepare to wake up */ + sleep(600); /* give it 5mins to happend */ + } + else + our_sigunblock(SIGCHLD); + } + + child_jump = 0; + } + + ps_global->noshow_timeout = 0; + F_SET(F_SHOW_DELAY_CUE, ps_global, old_cue); + (void) signal(SIGALRM, alarm_sig); + } +#endif + + /* + * Call c-client's pid reaper to wait() on the demise of our child, + * then fish out its exit status... + */ + grim_pid_reap_status((*syspipe)->pid, 0, &stat); + status = WIFEXITED(stat) ? WEXITSTATUS(stat) : -1; + + /* + * restore original handlers... + */ + (void)signal(SIGINT, (*syspipe)->isig); + (void)signal(SIGHUP, (*syspipe)->hsig); + (void)signal(SIGQUIT, (*syspipe)->qsig); + + if((*syspipe)->timeout){ + (void)signal(SIGALRM, (*syspipe)->alrm); + alarm((*syspipe)->old_timeo); + child_pid = 0; + } + + if((*syspipe)->mode & PIPE_RESET) /* restore our tty modes */ + PineRaw(1); + + if(!((*syspipe)->mode & (PIPE_WRITE | PIPE_READ | PIPE_SILENT))){ + ClearScreen(); /* No I/O to forked child */ + ps_global->mangled_screen = 1; + } + + zot_pipe(syspipe); + + return(status); +} + + + +static SigType +pipe_alarm SIG_PROTO((int sig)) +{ + if(child_pid) + kill(child_pid, SIGINT); +} + +/*====================================================================== + post_reap + + Manage exit status collection of a child spawned to handle posting + ====*/ + + + +#if defined(BACKGROUND_POST) && defined(SIGCHLD) +/*---------------------------------------------------------------------- + Check to see if we have any posting processes to clean up after + + Args: none + Returns: any finished posting process reaped + ----*/ +post_reap() +{ + WaitType stat; + int r; + + if(ps_global->post && ps_global->post->pid){ + r = waitpid(ps_global->post->pid, &stat, WNOHANG); + if(r == ps_global->post->pid){ + ps_global->post->status = WIFEXITED(stat) ? WEXITSTATUS(stat) : -1; + ps_global->post->pid = 0; + return(1); + } + else if(r < 0 && errno != EINTR){ /* pid's become bogus?? */ + fs_give((void **) &ps_global->post); + } + } + + return(0); +} +#endif + +/*---------------------------------------------------------------------- + Routines used to hand off messages to local agents for sending/posting + + The two exported routines are: + + 1) smtp_command() -- used to get local transport agent to invoke + 2) post_handoff() -- used to pass messages to local posting agent + + ----*/ + + + +/* + * Protos for "sendmail" internal functions + */ +static char *mta_parse_post PROTO((METAENV *, BODY *, char *, char *)); +static long pine_pipe_soutr_nl PROTO((void *, char *)); + + + +/* ---------------------------------------------------------------------- + Figure out command to start local SMTP agent + + Args: errbuf -- buffer for reporting errors (assumed non-NULL) + + Returns an alloc'd copy of the local SMTP agent invocation or NULL + + ----*/ +char * +smtp_command(errbuf) + char *errbuf; +{ +#if defined(SENDMAIL) && defined(SENDMAILFLAGS) + char tmp[256]; + + sprintf(tmp, "%s %s", SENDMAIL, SENDMAILFLAGS); + return(cpystr(tmp)); +#else + strcpy(errbuf, "No default posting command."); + return(NULL); +#endif +} + + + +/*---------------------------------------------------------------------- + Hand off given message to local posting agent + + Args: envelope -- The envelope for the BCC and debugging + header -- The text of the message header + errbuf -- buffer for reporting errors (assumed non-NULL) + + ----*/ +int +mta_handoff(header, body, errbuf) + METAENV *header; + BODY *body; + char *errbuf; +{ + char cmd_buf[256], *cmd = NULL; + + /* + * A bit of complicated policy implemented here. + * There are two posting variables sendmail-path and smtp-server. + * Precedence is in that order. + * They can be set one of 4 ways: fixed, command-line, user, or globally. + * Precedence is in that order. + * Said differently, the order goes something like what's below. + * + * NOTE: the fixed/command-line/user precendence handling is also + * indicated by what's pointed to by ps_global->VAR_*, but since + * that also includes the global defaults, it's not sufficient. + */ + + if(ps_global->FIX_SENDMAIL_PATH + && ps_global->FIX_SENDMAIL_PATH[0]){ + cmd = ps_global->FIX_SENDMAIL_PATH; + } + else if(!(ps_global->FIX_SMTP_SERVER + && ps_global->FIX_SMTP_SERVER[0])){ + if(ps_global->COM_SENDMAIL_PATH + && ps_global->COM_SENDMAIL_PATH[0]){ + cmd = ps_global->COM_SENDMAIL_PATH; + } + else if(!(ps_global->COM_SMTP_SERVER + && ps_global->COM_SMTP_SERVER[0])){ + if(ps_global->USR_SENDMAIL_PATH + && ps_global->USR_SENDMAIL_PATH[0]){ + cmd = ps_global->USR_SENDMAIL_PATH; + } + else if(!(ps_global->USR_SMTP_SERVER + && ps_global->USR_SMTP_SERVER[0])){ + if(ps_global->GLO_SENDMAIL_PATH + && ps_global->GLO_SENDMAIL_PATH[0]){ + cmd = ps_global->GLO_SENDMAIL_PATH; + } +#ifdef DF_SENDMAIL_PATH + /* + * This defines the default method of posting. So, + * unless we're told otherwise use it... + */ + else if(!(ps_global->GLO_SMTP_SERVER + && ps_global->GLO_SMTP_SERVER[0])){ + strcpy(cmd = cmd_buf, DF_SENDMAIL_PATH); + } +#endif + } + } + } + + *errbuf = '\0'; + if(cmd){ + dprint(4, (debugfile, "call_mailer via cmd: %s\n", cmd)); + + (void) mta_parse_post(header, body, cmd, errbuf); + return(1); + } + else + return(0); +} + + + +/*---------------------------------------------------------------------- + Hand off given message to local posting agent + + Args: envelope -- The envelope for the BCC and debugging + header -- The text of the message header + errbuf -- buffer for reporting errors (assumed non-NULL) + + Fork off mailer process and pipe the message into it + Called to post news via Inews when NNTP is unavailable + + ----*/ +char * +post_handoff(header, body, errbuf) + METAENV *header; + BODY *body; + char *errbuf; +{ + char *err = NULL; +#ifdef SENDNEWS + char *s; + + if(s = strstr(header->env->date," (")) /* fix the date format for news */ + *s = '\0'; + + if(err = mta_parse_post(header, body, SENDNEWS, errbuf)) + sprintf(err = errbuf, "News not posted: \"%s\": %s", SENDNEWS, err); + + if(s) + *s = ' '; /* restore the date */ + +#else /* !SENDNEWS */ /* this is the default case */ + sprintf(err = errbuf, "Can't post, NNTP-server must be defined!"); +#endif /* !SENDNEWS */ + return(err); +} + + + +/*---------------------------------------------------------------------- + Hand off message to local MTA; it parses recipients from 822 header + + Args: header -- struct containing header data + body -- struct containing message body data + cmd -- command to use for handoff (%s says where file should go) + errs -- pointer to buf to hold errors + + ----*/ +static char * +mta_parse_post(header, body, cmd, errs) + METAENV *header; + BODY *body; + char *cmd; + char *errs; +{ + char *result = NULL; + PIPE_S *pipe; + + dprint(1, (debugfile, "=== mta_parse_post(%s) ===\n", cmd)); + + if(pipe = open_system_pipe(cmd, &result, NULL, + PIPE_STDERR|PIPE_WRITE|PIPE_PROT|PIPE_NOSHELL|PIPE_DESC, 0)){ + if(!pine_rfc822_output(header, body, pine_pipe_soutr_nl, + (TCPSTREAM *) pipe)) + strcpy(errs, "Error posting."); + + if(close_system_pipe(&pipe) && !*errs){ + sprintf(errs, "Posting program %s returned error", cmd); + if(result) + display_output_file(result, "POSTING ERRORS", errs, 1); + } + } + else + sprintf(errs, "Error running \"%s\"", cmd); + + if(result){ + unlink(result); + fs_give((void **)&result); + } + + return(*errs ? errs : NULL); +} + + +/* + * pine_pipe_soutr - Replacement for tcp_soutr that writes one of our + * pipes rather than a tcp stream + */ +static long +pine_pipe_soutr_nl (stream,s) + void *stream; + char *s; +{ + long rv = T; + char *p; + size_t n; + + while(*s && rv){ + if(n = (p = strstr(s, "\015\012")) ? p - s : strlen(s)) + while((rv = write(((PIPE_S *)stream)->out.d, s, n)) != n) + if(rv < 0){ + if(errno != EINTR){ + rv = 0; + break; + } + } + else{ + s += rv; + n -= rv; + } + + if(p && rv){ + s = p + 2; /* write UNIX EOL */ + while((rv = write(((PIPE_S *)stream)->out.d,"\n",1)) != 1) + if(rv < 0 && errno != EINTR){ + rv = 0; + break; + } + } + else + break; + } + + return(rv); +} + +/* ---------------------------------------------------------------------- + Execute the given mailcap command + + Args: cmd -- the command to execute + image_file -- the file the data is in + needsterminal -- does this command want to take over the terminal? + ----*/ +void +exec_mailcap_cmd(cmd, image_file, needsterminal) +char *cmd; +char *image_file; +int needsterminal; +{ + char *command = NULL, + *result_file = NULL, + *p; + char **r_file_h; + PIPE_S *syspipe; + int mode; + + p = command = (char *)fs_get((32 + strlen(cmd) + (2*strlen(image_file))) + * sizeof(char)); + if(!needsterminal) /* put in background if it doesn't need terminal */ + *p++ = '('; + sprintf(p, "%s ; rm -f %s", cmd, image_file); + p += strlen(p); + if(!needsterminal){ + *p++ = ')'; + *p++ = ' '; + *p++ = '&'; + } + *p++ = '\n'; + *p = '\0'; + dprint(9, (debugfile, "exec_mailcap_cmd: command=%s\n", command)); + + mode = PIPE_RESET; + if(needsterminal == 1) + r_file_h = NULL; + else{ + mode |= PIPE_WRITE | PIPE_STDERR; + result_file = temp_nam(NULL, "pine_cmd"); + r_file_h = &result_file; + } + + if(syspipe = open_system_pipe(command, r_file_h, NULL, mode, 0)){ + close_system_pipe(&syspipe); + if(needsterminal == 1) + q_status_message(SM_ORDER, 0, 4, "VIEWER command completed"); + else if(needsterminal == 2) + display_output_file(result_file, "VIEWER", " command result", 1); + else + display_output_file(result_file, "VIEWER", " command launched", 1); + } + else + q_status_message1(SM_ORDER, 3, 4, "Cannot spawn command : %s", cmd); + + fs_give((void **)&command); + if(result_file) + fs_give((void **)&result_file); +} + + +/* ---------------------------------------------------------------------- + Execute the given mailcap test= cmd + + Args: cmd -- command to execute + Returns exit status + + ----*/ +int +exec_mailcap_test_cmd(cmd) + char *cmd; +{ + PIPE_S *syspipe; + + return((syspipe = open_system_pipe(cmd, NULL, NULL, PIPE_SILENT, 0)) + ? close_system_pipe(&syspipe) : -1); +} + + + +/*====================================================================== + print routines + + Functions having to do with printing on paper and forking of spoolers + + In general one calls open_printer() to start printing. One of + the little print functions to send a line or string, and then + call print_end() when complete. This takes care of forking off a spooler + and piping the stuff down it. No handles or anything here because there's + only one printer open at a time. + + ====*/ + + + +static char *trailer; /* so both open and close_printer can see it */ + +/*---------------------------------------------------------------------- + Open the printer + + Args: desc -- Description of item to print. Should have one trailing blank. + + Return value: < 0 is a failure. + 0 a success. + +This does most of the work of popen so we can save the standard output of the +command we execute and send it back to the user. + ----*/ +int +open_printer(desc) + char *desc; +{ + char command[201], prompt[200]; + int cmd, rc, just_one; + char *p, *init, *nick; + char aname[100]; + char *printer; + int done = 0, i, lastprinter, cur_printer = 0; + HelpType help; + char **list; + static ESCKEY_S ekey[] = { + {'y', 'y', "Y", "Yes"}, + {'n', 'n', "N", "No"}, + {ctrl('P'), 10, "^P", "Prev Printer"}, + {ctrl('N'), 11, "^N", "Next Printer"}, + {-2, 0, NULL, NULL}, + {'c', 'c', "C", "CustomPrint"}, + {KEY_UP, 10, "", ""}, + {KEY_DOWN, 11, "", ""}, + {-1, 0, NULL, NULL}}; +#define PREV_KEY 2 +#define NEXT_KEY 3 +#define CUSTOM_KEY 5 +#define UP_KEY 6 +#define DOWN_KEY 7 + + trailer = NULL; + init = NULL; + nick = NULL; + command[200] = '\0'; + + if(ps_global->VAR_PRINTER == NULL){ + q_status_message(SM_ORDER | SM_DING, 3, 5, + "No printer has been chosen. Use SETUP on main menu to make choice."); + return(-1); + } + + /* Is there just one print command available? */ + just_one = (ps_global->printer_category!=3&&ps_global->printer_category!=2) + || (ps_global->printer_category == 2 + && !(ps_global->VAR_STANDARD_PRINTER + && ps_global->VAR_STANDARD_PRINTER[0] + && ps_global->VAR_STANDARD_PRINTER[1])) + || (ps_global->printer_category == 3 + && !(ps_global->VAR_PERSONAL_PRINT_COMMAND + && ps_global->VAR_PERSONAL_PRINT_COMMAND[0] + && ps_global->VAR_PERSONAL_PRINT_COMMAND[1])); + + if(F_ON(F_CUSTOM_PRINT, ps_global)) + ekey[CUSTOM_KEY].ch = 'c'; /* turn this key on */ + else + ekey[CUSTOM_KEY].ch = -2; /* turn this key off */ + + if(just_one){ + ekey[PREV_KEY].ch = -2; /* turn these keys off */ + ekey[NEXT_KEY].ch = -2; + ekey[UP_KEY].ch = -2; + ekey[DOWN_KEY].ch = -2; + } + else{ + ekey[PREV_KEY].ch = ctrl('P'); /* turn these keys on */ + ekey[NEXT_KEY].ch = ctrl('N'); + ekey[UP_KEY].ch = KEY_UP; + ekey[DOWN_KEY].ch = KEY_DOWN; + /* + * count how many printers in list and find the default in the list + */ + if(ps_global->printer_category == 2) + list = ps_global->VAR_STANDARD_PRINTER; + else + list = ps_global->VAR_PERSONAL_PRINT_COMMAND; + + for(i = 0; list[i]; i++) + if(strcmp(ps_global->VAR_PRINTER, list[i]) == 0) + cur_printer = i; + + lastprinter = i - 1; + } + + help = NO_HELP; + ps_global->mangled_footer = 1; + + while(!done){ + if(init) + fs_give((void **)&init); + + if(trailer) + fs_give((void **)&trailer); + + if(just_one) + printer = ps_global->VAR_PRINTER; + else + printer = list[cur_printer]; + + parse_printer(printer, &nick, &p, &init, &trailer, NULL, NULL); + strncpy(command, p, 200); + fs_give((void **)&p); + sprintf(prompt, "Print %.50s%susing \"%.50s\" ? ", + desc ? desc : "", + (desc && *desc && desc[strlen(desc) - 1] != ' ') ? " " : "", + *nick ? nick : command); + + fs_give((void **)&nick); + + cmd = radio_buttons(prompt, -FOOTER_ROWS(ps_global), + ekey, 'y', 'x', help, RB_NORM); + + switch(cmd){ + case 'y': + q_status_message1(SM_ORDER, 0, 9, + "Printing with command \"%s\"", command); + done++; + break; + + case 10: + cur_printer = (cur_printer>0) + ? (cur_printer-1) + : lastprinter; + break; + + case 11: + cur_printer = (cur_printer<lastprinter) + ? (cur_printer+1) + : 0; + break; + + case 'n': + case 'x': + done++; + break; + + case 'c': + done++; + break; + + default: + break; + } + } + + if(cmd == 'c'){ + if(init) + fs_give((void **)&init); + + if(trailer) + fs_give((void **)&trailer); + + sprintf(prompt, "Enter custom command : "); + command[0] = '\0'; + rc = 1; + help = NO_HELP; + while(rc){ + int flags = OE_APPEND_CURRENT; + + rc = optionally_enter(command, -FOOTER_ROWS(ps_global), 0, + 200, prompt, NULL, help, &flags); + + if(rc == 1){ + cmd = 'x'; + rc = 0; + } + else if(rc == 3) + help = (help == NO_HELP) ? h_custom_print : NO_HELP; + else if(rc == 0){ + removing_trailing_white_space(command); + removing_leading_white_space(command); + q_status_message1(SM_ORDER, 0, 9, + "Printing with command \"%s\"", command); + } + } + } + + if(cmd == 'x' || cmd == 'n'){ + q_status_message(SM_ORDER, 0, 2, "Print cancelled"); + if(init) + fs_give((void **)&init); + + if(trailer) + fs_give((void **)&trailer); + + return(-1); + } + + display_message('x'); + + ps_global->print = (PRINT_S *)fs_get(sizeof(PRINT_S)); + memset(ps_global->print, 0, sizeof(PRINT_S)); + + strcat(strcpy(aname, ANSI_PRINTER), "-no-formfeed"); + if(strucmp(command, ANSI_PRINTER) == 0 + || strucmp(command, aname) == 0){ + /*----------- Printer attached to ansi device ---------*/ + q_status_message(SM_ORDER, 0, 9, + "Printing to attached desktop printer..."); + display_message('x'); + xonxoff_proc(1); /* make sure XON/XOFF used */ + crlf_proc(1); /* AND LF->CR xlation */ + fputs("\033[5i", stdout); + ps_global->print->fp = stdout; + if(strucmp(command, ANSI_PRINTER) == 0){ + /* put formfeed at the end of the trailer string */ + if(trailer){ + int len = strlen(trailer); + + fs_resize((void **)&trailer, len+2); + trailer[len] = '\f'; + trailer[len+1] = '\0'; + } + else + trailer = cpystr("\f"); + } + } + else{ + /*----------- Print by forking off a UNIX command ------------*/ + dprint(4, (debugfile, "Printing using command \"%s\"\n", command)); + ps_global->print->result = temp_nam(NULL, "pine_prt"); + if(ps_global->print->pipe = open_system_pipe(command, + &ps_global->print->result, NULL, + PIPE_WRITE | PIPE_STDERR, 0)){ + ps_global->print->fp = ps_global->print->pipe->out.f; + } + else{ + fs_give((void **)&ps_global->print->result); + q_status_message1(SM_ORDER | SM_DING, 3, 4, + "Error opening printer: %s", + error_description(errno)); + dprint(2, (debugfile, "Error popening printer \"%s\"\n", + error_description(errno))); + if(init) + fs_give((void **)&init); + + if(trailer) + fs_give((void **)&trailer); + + return(-1); + } + } + + ps_global->print->err = 0; + if(init){ + if(*init) + fputs(init, ps_global->print->fp); + + fs_give((void **)&init); + } + + return(0); +} + + + +/*---------------------------------------------------------------------- + Close printer + + If we're piping to a spooler close down the pipe and wait for the process +to finish. If we're sending to an attached printer send the escape sequence. +Also let the user know the result of the print + ----*/ +void +close_printer() +{ + if(trailer){ + if(*trailer) + fputs(trailer, ps_global->print->fp); + + fs_give((void **)&trailer); + } + + if(ps_global->print->fp == stdout) { + fputs("\033[4i", stdout); + fflush(stdout); + if(F_OFF(F_PRESERVE_START_STOP, ps_global)) + xonxoff_proc(0); /* turn off XON/XOFF */ + + crlf_proc(0); /* turn off CF->LF xlantion */ + } else { + (void) close_system_pipe(&ps_global->print->pipe); + display_output_file(ps_global->print->result, "PRINT", NULL, 1); + fs_give((void **)&ps_global->print->result); + } + + fs_give((void **)&ps_global->print); + + q_status_message(SM_ASYNC, 0, 3, "Print command completed"); + display_message('x'); +} + + + +/*---------------------------------------------------------------------- + Print a single character + + Args: c -- char to print + Returns: 1 on success, 0 on ps_global->print->err + ----*/ +int +print_char(c) + int c; +{ + if(!ps_global->print->err && putc(c, ps_global->print->fp) == EOF) + ps_global->print->err = 1; + + return(!ps_global->print->err); +} + + + +/*---------------------------------------------------------------------- + Send a line of text to the printer + + Args: line -- Text to print + + ----*/ + +void +print_text(line) + char *line; +{ + if(!ps_global->print->err && fputs(line, ps_global->print->fp) == EOF) + ps_global->print->err = 1; +} + + + +/*---------------------------------------------------------------------- + printf style formatting with one arg for printer + + Args: line -- The printf control string + a1 -- The 1st argument for printf + ----*/ +void +print_text1(line, a1) + char *line, *a1; +{ + if(!ps_global->print->err + && fprintf(ps_global->print->fp, line, a1) < 0) + ps_global->print->err = 1; +} + + + +/*---------------------------------------------------------------------- + printf style formatting with one arg for printer + + Args: line -- The printf control string + a1 -- The 1st argument for printf + a2 -- The 2nd argument for printf + ----*/ +void +print_text2(line, a1, a2) + char *line, *a1, *a2; +{ + if(!ps_global->print->err + && fprintf(ps_global->print->fp, line, a1, a2) < 0) + ps_global->print->err = 1; +} + + + +/*---------------------------------------------------------------------- + printf style formatting with one arg for printer + + Args: line -- The printf control string + a1 -- The 1st argument for printf + a2 -- The 2nd argument for printf + a3 -- The 3rd argument for printf + ----*/ +void +print_text3(line, a1, a2, a3) + char *line, *a1, *a2, *a3; +{ + if(!ps_global->print->err + && fprintf(ps_global->print->fp, line, a1, a2, a3) < 0) + ps_global->print->err = 1; +} + +#ifdef DEBUG +/*---------------------------------------------------------------------- + Initialize debugging - open the debug log file + + Args: none + + Result: opens the debug logfile for dprints + + Opens the file "~/.pine-debug1. Also maintains .pine-debug[2-4] + by renaming them each time so the last 4 sessions are saved. + ----*/ +void +init_debug() +{ + char nbuf[5]; + char newfname[MAXPATH+1], filename[MAXPATH+1]; + int i, fd; + + if(!(debug || ps_global->debug_imap)) + return; + + for(i = ps_global->debug_nfiles - 1; i > 0; i--){ + build_path(filename, ps_global->home_dir, DEBUGFILE); + strcpy(newfname, filename); + sprintf(nbuf, "%d", i); + strcat(filename, nbuf); + sprintf(nbuf, "%d", i+1); + strcat(newfname, nbuf); + (void)rename_file(filename, newfname); + } + + build_path(filename, ps_global->home_dir, DEBUGFILE); + strcat(filename, "1"); + + debugfile = NULL; + if((fd = open(filename, O_TRUNC|O_RDWR|O_CREAT, 0600)) >= 0) + debugfile = fdopen(fd, "w+"); + + if(debugfile != NULL){ + time_t now = time((time_t *)0); + if(ps_global->debug_flush) + setbuf(debugfile, NULL); + + if(ps_global->debug_nfiles == 0){ + /* + * If no debug files are asked for, make filename a tempfile + * to be used for a record should pine later crash... + */ + if(debug < 9 && !ps_global->debug_flush && ps_global->debug_imap<4) + unlink(filename); + } + + dprint(0, (debugfile, + "Debug output of the Pine program (debug=%d debug_imap=%d). Version %s\n%s\n", + debug, ps_global->debug_imap, pine_version, ctime(&now))); + } +} + + +/*---------------------------------------------------------------------- + Try to save the debug file if we crash in a controlled way + + Args: dfile: pointer to open debug file + + Result: tries to move the appropriate .pine-debugx file to .pine-crash + + Looks through the four .pine-debug files hunting for the one that is + associated with this pine, and then renames it. + ----*/ +void +save_debug_on_crash(dfile) +FILE *dfile; +{ + char nbuf[5], crashfile[MAXPATH+1], filename[MAXPATH+1]; + int i; + struct stat dbuf, tbuf; + time_t now = time((time_t *)0); + + if(!(dfile && fstat(fileno(dfile), &dbuf) != 0)) + return; + + fprintf(dfile, "\nsave_debug_on_crash: Version %s: debug level %d\n", + pine_version, debug); + fprintf(dfile, "\n : %s\n", ctime(&now)); + + build_path(crashfile, ps_global->home_dir, ".pine-crash"); + + fprintf(dfile, "\nAttempting to save debug file to %s\n", crashfile); + fprintf(stderr, + "\n\n Attempting to save debug file to %s\n\n", crashfile); + + /* Blat out last n keystrokes */ + fputs("========== Latest keystrokes ==========\n", dfile); + while((i = key_playback(0)) != -1) + fprintf(dfile, "\t%s\t(0x%04.4x)\n", pretty_command(i), i); + + /* look for existing debug file */ + for(i = 1; i <= ps_global->debug_nfiles; i++){ + build_path(filename, ps_global->home_dir, DEBUGFILE); + sprintf(nbuf, "%d", i); + strcat(filename, nbuf); + if(stat(filename, &tbuf) != 0) + continue; + + /* This must be the current debug file */ + if(tbuf.st_dev == dbuf.st_dev && tbuf.st_ino == dbuf.st_ino){ + rename_file(filename, crashfile); + break; + } + } + + /* if current debug file name not found, write it by hand */ + if(i > ps_global->debug_nfiles){ + FILE *cfp; + char buf[1025]; + + /* + * Copy the debug temp file into the + */ + if(cfp = fopen(crashfile, "w")){ + buf[1024] = '\0'; + fseek(dfile, 0L, 0); + while(fgets(buf, 1025, dfile) && fputs(buf, cfp) != EOF) + ; + + fclose(cfp); + } + } + + fclose(dfile); +} + + +#define CHECK_EVERY_N_TIMES 100 +#define MAX_DEBUG_FILE_SIZE 200000L +/* + * This is just to catch runaway Pines that are looping spewing out + * debugging (and filling up a file system). The stop doesn't have to be + * at all precise, just soon enough to hopefully prevent filling the + * file system. If the debugging level is high (9 for now), then we're + * presumably looking for some problem, so don't truncate. + */ +int +do_debug(debug_fp) +FILE *debug_fp; +{ + static int counter = CHECK_EVERY_N_TIMES; + static int ok = 1; + long filesize; + + if(debug == DEFAULT_DEBUG + && !ps_global->debug_flush + && !ps_global->debug_timestamp + && ps_global->debug_imap < 2 + && ok + && --counter <= 0){ + if((filesize = fp_file_size(debug_fp)) != -1L) + ok = (unsigned long)filesize < (unsigned long)MAX_DEBUG_FILE_SIZE; + + counter = CHECK_EVERY_N_TIMES; + if(!ok){ + fprintf(debug_fp, "\n\n --- No more debugging ---\n"); + fprintf(debug_fp, + " (debug file growing too large - over %ld bytes)\n\n", + MAX_DEBUG_FILE_SIZE); + fflush(debug_fp); + } + } + + if(ok && ps_global->debug_timestamp) + fprintf(debug_fp, "\n%s\n", debug_time(0)); + + return(ok); +} + + +/* + * Returns a pointer to static string for a timestamp. + * + * If timestamp is set .subseconds are added if available. + * If include_date is set the date is appended. + */ +char * +debug_time(include_date) + int include_date; +{ + time_t t; + struct tm *tm_now; + struct timeval tp; + struct timezone tzp; + static char timestring[23]; + char subsecond[8]; + char datestr[7]; + + if(gettimeofday(&tp, &tzp) == 0){ + t = (time_t)tp.tv_sec; + if(include_date){ + tm_now = localtime(&t); + sprintf(datestr, " %d/%d", tm_now->tm_mon+1, tm_now->tm_mday); + } + else + datestr[0] = '\0'; + + if(ps_global->debug_timestamp) + sprintf(subsecond, ".%06ld", tp.tv_usec); + else + subsecond[0] = '\0'; + + sprintf(timestring, "%.8s%s%s", ctime(&t)+11, subsecond, datestr); + } + else + timestring[0] = '\0'; + + return(timestring); +} +#endif /* DEBUG */ + + +/* + * Fills in the passed in structure with the current time. + * + * Returns 0 if ok + * -1 if can't do it + */ +int +get_time(our_time_val) + TIMEVAL_S *our_time_val; +{ + struct timeval tp; + struct timezone tzp; + + if(gettimeofday(&tp, &tzp) == 0){ + our_time_val->sec = tp.tv_sec; + our_time_val->usec = tp.tv_usec; + return 0; + } + else + return -1; +} + + +/* + * Returns the difference between the two values, in microseconds. + * Value returned is first - second. + */ +long +time_diff(first, second) + TIMEVAL_S *first, + *second; +{ + return(1000000L*(first->sec - second->sec) + (first->usec - second->usec)); +} + + + +/*====================================================================== + Things having to do with reading from the tty driver and keyboard + - initialize tty driver and reset tty driver + - read a character from terminal with keyboard escape seqence mapping + - initialize keyboard (keypad or such) and reset keyboard + - prompt user for a line of input + - read a command from keyboard with timeouts. + + ====*/ + + +/* + * Helpful definitions + */ +#define RETURN_CH(X) return(key_recorder((X))) +/* + * Should really be using pico's TERM's t_getchar to read a character but + * we're just calling ttgetc directly for now. Ttgetc is the same as + * t_getchar whenever we use it so we're avoiding the trouble of initializing + * the TERM struct and calling ttgetc directly. + */ +#define READ_A_CHAR() ttgetc(NO_OP_COMMAND, key_recorder, read_bail) + + +/* + * Internal prototypes + */ +int pine_simple_ttgetc PROTO((int (*)(), void (*)())); +void line_paint PROTO((int, int *)); +int process_config_input PROTO((int *)); +int check_for_timeout PROTO((int)); +void read_bail PROTO((void)); + + +/*---------------------------------------------------------------------- + Initialize the tty driver to do single char I/O and whatever else (UNIX) + + Args: struct pine + + Result: tty driver is put in raw mode so characters can be read one + at a time. Returns -1 if unsuccessful, 0 if successful. + +Some file descriptor voodoo to allow for pipes across vforks. See +open_mailer for details. + ----------------------------------------------------------------------*/ +init_tty_driver(ps) + struct pine *ps; +{ +#ifdef MOUSE + if(F_ON(F_ENABLE_MOUSE, ps_global)) + init_mouse(); +#endif /* MOUSE */ + + /* turn off talk permission by default */ + + if(F_ON(F_ALLOW_TALK, ps)) + allow_talk(ps); + else + disallow_talk(ps); + + return(PineRaw(1)); +} + + + +/*---------------------------------------------------------------------- + Set or clear the specified tty mode + + Args: ps -- struct pine + mode -- mode bits to modify + clear -- whether or not to clear or set + + Result: tty driver mode change. + ----------------------------------------------------------------------*/ +void +tty_chmod(ps, mode, func) + struct pine *ps; + int mode; + int func; +{ + char *tty_name; + int new_mode; + struct stat sbuf; + static int saved_mode = -1; + + /* if no problem figuring out tty's name & mode? */ + if((((tty_name = (char *) ttyname(STDIN_FD)) != NULL + && fstat(STDIN_FD, &sbuf) == 0) + || ((tty_name = (char *) ttyname(STDOUT_FD)) != NULL + && fstat(STDOUT_FD, &sbuf) == 0)) + && !(func == TMD_RESET && saved_mode < 0)){ + new_mode = (func == TMD_RESET) + ? saved_mode + : (func == TMD_CLEAR) + ? (sbuf.st_mode & ~mode) + : (sbuf.st_mode | mode); + /* assign tty new mode */ + if(chmod(tty_name, new_mode) == 0){ + if(func == TMD_RESET) /* forget we knew */ + saved_mode = -1; + else if(saved_mode < 0) + saved_mode = sbuf.st_mode; /* remember original */ + } + } +} + + + +/*---------------------------------------------------------------------- + End use of the tty, put it back into it's normal mode (UNIX) + + Args: ps -- struct pine + + Result: tty driver mode change. + ----------------------------------------------------------------------*/ +void +end_tty_driver(ps) + struct pine *ps; +{ + ps = ps; /* get rid of unused parameter warning */ + +#ifdef MOUSE + end_mouse(); +#endif /* MOUSE */ + fflush(stdout); + dprint(2, (debugfile, "about to end_tty_driver\n")); + + tty_chmod(ps, 0, TMD_RESET); + PineRaw(0); +} + + + +/*---------------------------------------------------------------------- + Actually set up the tty driver (UNIX) + + Args: state -- which state to put it in. 1 means go into raw, 0 out of + + Result: returns 0 if successful and < 0 if not. + ----*/ + +PineRaw(state) +int state; +{ + int result; + + result = Raw(state); + + if(result == 0 && state == 1){ + /* + * Only go into 8 bit mode if we are doing something other + * than plain ASCII. This will save the folks that have + * their parity on their serial lines wrong thr trouble of + * getting it right + */ + if(ps_global->VAR_CHAR_SET && ps_global->VAR_CHAR_SET[0] && + strucmp(ps_global->VAR_CHAR_SET, "us-ascii")) + bit_strip_off(); + +#ifdef DEBUG + if(debug < 9) /* only on if full debugging set */ +#endif + quit_char_off(); + ps_global->low_speed = ttisslow(); + crlf_proc(0); + xonxoff_proc(F_ON(F_PRESERVE_START_STOP, ps_global)); + } + + return(result); +} + + +#ifdef RESIZING +jmp_buf winch_state; +int winch_occured = 0; +int ready_for_winch = 0; +#endif + +/*---------------------------------------------------------------------- + This checks whether or not a character (UNIX) + is ready to be read, or it times out. + + Args: time_out -- number of seconds before it will timeout + + Result: Returns a NO_OP_IDLE or a NO_OP_COMMAND if the timeout expires + before input is available, or a KEY_RESIZE if a resize event + occurs, or READY_TO_READ if input is available before the timeout. + ----*/ +int +check_for_timeout(time_out) + int time_out; +{ + int res; + + fflush(stdout); + +#ifdef RESIZING + if(!winch_occured){ + if(setjmp(winch_state) != 0){ + winch_occured = 1; + ready_for_winch = 0; + + /* + * Need to unblock signal after longjmp from handler, because + * signal is normally unblocked upon routine exit from the handler. + */ + our_sigunblock(SIGWINCH); + } + else + ready_for_winch = 1; + } + + if(winch_occured){ + winch_occured = ready_for_winch = 0; + fix_windsize(ps_global); + return(KEY_RESIZE); + } +#endif /* RESIZING */ + + switch(res = input_ready(time_out)){ + case BAIL_OUT: + read_bail(); /* non-tragic exit */ + /* NO RETURN */ + + case PANIC_NOW: + panic1("Select error: %s\n", error_description(errno)); + /* NO RETURN */ + + case READ_INTR: + res = NO_OP_COMMAND; + /* fall through */ + + case NO_OP_IDLE: + case NO_OP_COMMAND: + case READY_TO_READ: +#ifdef RESIZING + ready_for_winch = 0; +#endif + return(res); + } +} + + + +/*---------------------------------------------------------------------- + Read input characters with lots of processing for arrow keys and such (UNIX) + + Args: time_out -- The timeout to for the reads + + Result: returns the character read. Possible special chars. + + This deals with function and arrow keys as well. + + The idea is that this routine handles all escape codes so it done in + only one place. Especially so the back arrow key can work when entering + things on a line. Also so all function keys can be disabled and not + cause weird things to happen. + ---*/ +int +read_char(time_out) + int time_out; +{ + int ch, status, cc; + + /* Get input from initial-keystrokes */ + if(process_config_input(&ch)) + return(ch); + + /* + * We only check for timeouts at the start of read_char, not in the + * middle of escape sequences. + */ + if((ch = check_for_timeout(time_out)) != READY_TO_READ) + goto done; + + ps_global->time_of_last_input = time((time_t *)0); + + switch(status = kbseq(pine_simple_ttgetc, key_recorder, read_bail, &ch)){ + case KEY_DOUBLE_ESC: + /* + * Special hack to get around comm devices eating control characters. + */ + if(check_for_timeout(5) != READY_TO_READ){ + ch = KEY_JUNK; /* user typed ESC ESC, then stopped */ + goto done; + } + else + ch = READ_A_CHAR(); + + ch &= 0x7f; + if(isdigit((unsigned char)ch)){ + int n = 0, i = ch - '0'; + + if(i < 0 || i > 2){ + ch = KEY_JUNK; + goto done; /* bogus literal char value */ + } + + while(n++ < 2){ + if(check_for_timeout(5) != READY_TO_READ + || (!isdigit((unsigned char) (ch = READ_A_CHAR())) + || (n == 1 && i == 2 && ch > '5') + || (n == 2 && i == 25 && ch > '5'))){ + ch = KEY_JUNK; /* user typed ESC ESC #, stopped */ + goto done; + } + + i = (i * 10) + (ch - '0'); + } + + ch = i; + } + else{ + if(islower((unsigned char)ch)) /* canonicalize if alpha */ + ch = toupper((unsigned char)ch); + + ch = (isalpha((unsigned char)ch) || ch == '@' + || (ch >= '[' && ch <= '_')) + ? ctrl(ch) : ((ch == SPACE) ? ctrl('@'): ch); + } + + goto done; + +#ifdef MOUSE + case KEY_XTERM_MOUSE: + if(mouseexist()){ + /* + * Special hack to get mouse events from an xterm. + * Get the details, then pass it past the keymenu event + * handler, and then to the installed handler if there + * is one... + */ + static int down = 0; + int x, y, button; + unsigned cmd; + + clear_cursor_pos(); + button = READ_A_CHAR() & 0x03; + + x = READ_A_CHAR() - '!'; + y = READ_A_CHAR() - '!'; + + ch = NO_OP_COMMAND; + if(button == 0){ /* xterm button 1 down */ + down = 1; + if(checkmouse(&cmd, 1, x, y)) + ch = (int)cmd; + } + else if (down && button == 3){ + down = 0; + if(checkmouse(&cmd, 0, x, y)) + ch = (int)cmd; + } + + goto done; + } + + break; +#endif /* MOUSE */ + + case KEY_UP : + case KEY_DOWN : + case KEY_RIGHT : + case KEY_LEFT : + case KEY_PGUP : + case KEY_PGDN : + case KEY_HOME : + case KEY_END : + case KEY_DEL : + case PF1 : + case PF2 : + case PF3 : + case PF4 : + case PF5 : + case PF6 : + case PF7 : + case PF8 : + case PF9 : + case PF10 : + case PF11 : + case PF12 : + dprint(9, (debugfile, "Read char returning: %d %s\n", + status, pretty_command(status))); + return(status); + + case KEY_SWALLOW_Z: + status = KEY_JUNK; + case KEY_SWAL_UP: + case KEY_SWAL_DOWN: + case KEY_SWAL_LEFT: + case KEY_SWAL_RIGHT: + do + if(check_for_timeout(2) != READY_TO_READ){ + status = KEY_JUNK; + break; + } + while(!strchr("~qz", READ_A_CHAR())); + ch = (status == KEY_JUNK) ? status : status - (KEY_SWAL_UP - KEY_UP); + goto done; + + case KEY_KERMIT: + do{ + cc = ch; + if(check_for_timeout(2) != READY_TO_READ){ + status = KEY_JUNK; + break; + } + else + ch = READ_A_CHAR(); + }while(cc != '\033' && ch != '\\'); + + ch = KEY_JUNK; + goto done; + + case BADESC: + ch = KEY_JUNK; + goto done; + + case 0: /* regular character */ + default: + /* + * we used to strip (ch &= 0x7f;), but this seems much cleaner + * in the face of line noise and has the benefit of making it + * tougher to emit mistakenly labeled MIME... + */ + if((ch & 0x80) && (!ps_global->VAR_CHAR_SET + || !strucmp(ps_global->VAR_CHAR_SET, "US-ASCII"))){ + dprint(9, (debugfile, "Read char returning: %d %s\n", + status, pretty_command(status))); + return(KEY_JUNK); + } + else if(ch == ctrl('Z')){ + dprint(9, (debugfile, "Read char calling do_suspend\n")); + return(do_suspend()); + } + + + done: + dprint(9, (debugfile, "Read char returning: %d %s\n", + ch, pretty_command(ch))); + return(ch); + } +} + + +/*---------------------------------------------------------------------- + Reading input somehow failed and we need to shutdown now + + Args: none + + Result: pine exits + + ---*/ +void +read_bail() +{ + end_signals(1); + if(ps_global->inbox_stream){ + if(ps_global->inbox_stream == ps_global->mail_stream) + ps_global->mail_stream = NULL; + + if(!ps_global->inbox_stream->lock) /* shouldn't be... */ + pine_close_stream(ps_global->inbox_stream); + } + + if(ps_global->mail_stream && !ps_global->mail_stream->lock) + pine_close_stream(ps_global->mail_stream); + + end_keyboard(F_ON(F_USE_FK,ps_global)); + end_tty_driver(ps_global); + if(filter_data_file(0)) + unlink(filter_data_file(0)); + + exit(0); +} + + +int +pine_simple_ttgetc(fi, fv) + int (*fi)(); + void (*fv)(); +{ + int ch; + +#ifdef RESIZING + if(!winch_occured){ + if(setjmp(winch_state) != 0){ + winch_occured = 1; + ready_for_winch = 0; + + /* + * Need to unblock signal after longjmp from handler, because + * signal is normally unblocked upon routine exit from the handler. + */ + our_sigunblock(SIGWINCH); + } + else + ready_for_winch = 1; + } + + if(winch_occured){ + winch_occured = ready_for_winch = 0; + fix_windsize(ps_global); + return(KEY_RESIZE); + } +#endif /* RESIZING */ + + ch = simple_ttgetc(fi, fv); + +#ifdef RESIZING + ready_for_winch = 0; +#endif + + return(ch); +} + + + +extern char term_name[]; +/* ------------------------------------------------------------------- + Set up the keyboard -- usually enable some function keys (UNIX) + + Args: struct pine + +So far all we do here is turn on keypad mode for certain terminals + +Hack for NCSA telnet on an IBM PC to put the keypad in the right mode. +This is the same for a vtXXX terminal or [zh][12]9's which we have +a lot of at UW + ----*/ +void +init_keyboard(use_fkeys) + int use_fkeys; +{ + if(use_fkeys && (!strucmp(term_name,"vt102") + || !strucmp(term_name,"vt100"))) + printf("\033\133\071\071\150"); +} + + + +/*---------------------------------------------------------------------- + Clear keyboard, usually disable some function keys (UNIX) + + Args: pine state (terminal type) + + Result: keyboard state reset + ----*/ +void +end_keyboard(use_fkeys) + int use_fkeys; +{ + if(use_fkeys && (!strcmp(term_name, "vt102") + || !strcmp(term_name, "vt100"))){ + printf("\033\133\071\071\154"); + fflush(stdout); + } +} + + +#ifdef _WINDOWS +#line 3 "osdep/termin.gen" + +static int g_mc_row, g_mc_col; + +int pcpine_oe_cursor PROTO((int, long)); +#endif + + +/* + * Generic tty input routines + */ + + +/*---------------------------------------------------------------------- + Read a character from keyboard with timeout + Input: none + + Result: Returns command read via read_char + Times out and returns a null command every so often + + Calculates the timeout for the read, and does a few other house keeping +things. The duration of the timeout is set in pine.c. + ----------------------------------------------------------------------*/ +int +read_command() +{ + int ch, tm = 0; + long dtime; + + cancel_busy_alarm(-1); + tm = (messages_queued(&dtime) > 1) ? (int)dtime : timeo; + + /* + * Before we sniff at the input queue, make sure no external event's + * changed our picture of the message sequence mapping. If so, + * recalculate the dang thing and run thru whatever processing loop + * we're in again... + */ + if(ps_global->expunge_count){ + q_status_message3(SM_ORDER, 3, 3, + "%s message%s expunged from folder \"%s\"", + long2string(ps_global->expunge_count), + plural(ps_global->expunge_count), + pretty_fn(ps_global->cur_folder)); + ps_global->expunge_count = 0L; + display_message('x'); + } + + if(ps_global->inbox_expunge_count){ + q_status_message3(SM_ORDER, 3, 3, + "%s message%s expunged from folder \"%s\"", + long2string(ps_global->inbox_expunge_count), + plural(ps_global->inbox_expunge_count), + pretty_fn(ps_global->inbox_name)); + ps_global->inbox_expunge_count = 0L; + display_message('x'); + } + + if(ps_global->mail_box_changed && ps_global->new_mail_count){ + dprint(2, (debugfile, "Noticed %ld new msgs! \n", + ps_global->new_mail_count)); + return(NO_OP_COMMAND); /* cycle thru so caller can update */ + } + + ch = read_char(tm); + dprint(9, (debugfile, "Read command returning: %d %s\n", ch, + pretty_command(ch))); + if(ch != NO_OP_COMMAND && ch != NO_OP_IDLE && ch != KEY_RESIZE) + zero_new_mail_count(); + +#ifdef BACKGROUND_POST + /* + * Any expired children to report on? + */ + if(ps_global->post && ps_global->post->pid == 0){ + int winner = 0; + + if(ps_global->post->status < 0){ + q_status_message(SM_ORDER | SM_DING, 3, 3, "Abysmal failure!"); + } + else{ + (void) pine_send_status(ps_global->post->status, + ps_global->post->fcc, tmp_20k_buf, + &winner); + q_status_message(SM_ORDER | (winner ? 0 : SM_DING), 3, 3, + tmp_20k_buf); + + } + + if(!winner) + q_status_message(SM_ORDER, 0, 3, + "Re-send via \"Compose\" then \"Yes\" to \"Continue INTERRUPTED?\""); + + if(ps_global->post->fcc) + fs_give((void **) &ps_global->post->fcc); + + fs_give((void **) &ps_global->post); + } +#endif + + return(ch); +} + + + + +/* + * + */ +static struct display_line { + int row, col; /* where display starts */ + int dlen; /* length of display line */ + char *dl; /* line on display */ + char *vl; /* virtual line */ + int vlen; /* length of virtual line */ + int vused; /* length of virtual line in use */ + int vbase; /* first virtual char on display */ +} dline; + + + +static struct key oe_keys[] = + {{"^G","Help",KS_SCREENHELP}, {"^C","Cancel",KS_NONE}, + {"^T","xxx",KS_NONE}, {"Ret","Accept",KS_NONE}, + {NULL,NULL,KS_NONE}, {NULL,NULL,KS_NONE}, + {NULL,NULL,KS_NONE}, {NULL,NULL,KS_NONE}, + {NULL,NULL,KS_NONE}, {NULL,NULL,KS_NONE}, + {NULL,NULL,KS_NONE}, {NULL,NULL,KS_NONE}}; +INST_KEY_MENU(oe_keymenu, oe_keys); +#define OE_HELP_KEY 0 +#define OE_CANCEL_KEY 1 +#define OE_CTRL_T_KEY 2 +#define OE_ENTER_KEY 3 + + +/*---------------------------------------------------------------------- + Prompt user for a string in status line with various options + + Args: string -- the buffer result is returned in, and original string (if + any) is passed in. + y_base -- y position on screen to start on. 0,0 is upper left + negative numbers start from bottom + x_base -- column position on screen to start on. 0,0 is upper left + field_len -- Maximum length of string to accept + prompt -- The string to prompt with + escape_list -- pointer to array of ESCKEY_S's. input chars matching + those in list return value from list. + help -- Arrary of strings for help text in bottom screen lines + flags -- pointer (because some are return values) to flags + OE_USER_MODIFIED - Set on return if user modified buffer + OE_DISALLOW_CANCEL - No cancel in menu. + OE_DISALLOW_HELP - No help in menu. + OE_KEEP_TRAILING_SPACE - Allow trailing space. + OE_SEQ_SENSITIVE - Caller is sensitive to sequence + number changes. + OE_APPEND_CURRENT - String should not be truncated + before accepting user input. + OE_PASSWD - Don't echo on screen. + + Result: editing input string + returns -1 unexpected errors + returns 0 normal entry typed (editing and return or PF2) + returns 1 typed ^C or PF2 (cancel) + returns 3 typed ^G or PF1 (help) + returns 4 typed ^L for a screen redraw + + WARNING: Care is required with regard to the escape_list processing. + The passed array is terminated with an entry that has ch = -1. + Function key labels and key strokes need to be setup externally! + Traditionally, a return value of 2 is used for ^T escapes. + + Unless in escape_list, tabs are trapped by isprint(). +This allows near full weemacs style editing in the line + ^A beginning of line + ^E End of line + ^R Redraw line + ^G Help + ^F forward + ^B backward + ^D delete +----------------------------------------------------------------------*/ + +optionally_enter(string, y_base, x_base, field_len, + prompt, escape_list, help, flags) + char *string, *prompt; + ESCKEY_S *escape_list; + HelpType help; + int x_base, y_base, field_len; + int *flags; +{ + register char *s2; + register int field_pos; + int i, j, return_v, cols, ch, prompt_len, too_thin, + real_y_base, km_popped, passwd; + char *saved_original = NULL, *k, *kb; + char *kill_buffer = NULL; + char **help_text; + int fkey_table[12]; + struct key_menu *km; + bitmap_t bitmap; + COLOR_PAIR *lastc = NULL, *promptc = NULL; + struct variable *vars = ps_global->vars; +#ifdef _WINDOWS + int cursor_shown; +#endif + + dprint(5, (debugfile, "=== optionally_enter called ===\n")); + dprint(9, (debugfile, "string:\"%s\" y:%d x:%d length: %d append: %d\n", + string, x_base, y_base, field_len, + (flags && *flags & OE_APPEND_CURRENT))); + dprint(9, (debugfile, "passwd:%d prompt:\"%s\" label:\"%s\"\n", + (flags && *flags & OE_PASSWD), + prompt, (escape_list && escape_list[0].ch != -1) + ? escape_list[0].label: "")); + +#ifdef _WINDOWS + if (mswin_usedialog ()) { + MDlgButton button_list[12]; + int b; + int i; + + memset (&button_list, 0, sizeof (MDlgButton) * 12); + b = 0; + for (i = 0; escape_list && escape_list[i].ch != -1 && i < 11; ++i) { + if (escape_list[i].name != NULL + && escape_list[i].ch > 0 && escape_list[i].ch < 256) { + button_list[b].ch = escape_list[i].ch; + button_list[b].rval = escape_list[i].rval; + button_list[b].name = escape_list[i].name; + button_list[b].label = escape_list[i].label; + ++b; + } + } + button_list[b].ch = -1; + + + help_text = get_help_text (help); + return_v = mswin_dialog (prompt, string, field_len, + (flags && *flags & OE_APPEND_CURRENT), + (flags && *flags & OE_PASSWD), + button_list, + help_text, flags ? *flags : OE_NONE); + free_list_array (&help_text); + return (return_v); + } +#endif + + suspend_busy_alarm(); + cols = ps_global->ttyo->screen_cols; + prompt_len = strlen(prompt); + too_thin = 0; + km_popped = 0; + if(y_base > 0) { + real_y_base = y_base; + } else { + real_y_base= y_base + ps_global->ttyo->screen_rows; + if(real_y_base < 2) + real_y_base = ps_global->ttyo->screen_rows; + } + + flush_ordered_messages(); + mark_status_dirty(); + if(flags && *flags & OE_APPEND_CURRENT) /* save a copy in case of cancel */ + saved_original = cpystr(string); + + /* + * build the function key mapping table, skipping predefined keys... + */ + memset(fkey_table, NO_OP_COMMAND, 12 * sizeof(int)); + for(i = 0, j = 0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){ + if(i+j == OE_HELP_KEY) + j++; + + if(i+j == OE_CANCEL_KEY) + j++; + + if(i+j == OE_ENTER_KEY) + j++; + + fkey_table[i+j] = escape_list[i].ch; + } + +#if defined(HELPFILE) + help_text = (help != NO_HELP) ? get_help_text(help) : (char **)NULL; +#else + help_text = help; +#endif + if(help_text){ /*---- Show help text -----*/ + int width = ps_global->ttyo->screen_cols - x_base; + + if(FOOTER_ROWS(ps_global) == 1){ + km_popped++; + FOOTER_ROWS(ps_global) = 3; + clearfooter(ps_global); + + y_base = -3; + real_y_base = y_base + ps_global->ttyo->screen_rows; + } + + for(j = 0; j < 2 && help_text[j]; j++){ + MoveCursor(real_y_base + 1 + j, x_base); + CleartoEOLN(); + + if(width < strlen(help_text[j])){ + char *tmp = fs_get((width + 1) * sizeof(char)); + strncpy(tmp, help_text[j], width); + tmp[width] = '\0'; + PutLine0(real_y_base + 1 + j, x_base, tmp); + fs_give((void **)&tmp); + } + else + PutLine0(real_y_base + 1 + j, x_base, help_text[j]); + } + +#if defined(HELPFILE) + free_list_array(&help_text); +#endif + + } else { + clrbitmap(bitmap); + clrbitmap((km = &oe_keymenu)->bitmap); /* force formatting */ + if(!(flags && (*flags) & OE_DISALLOW_HELP)) + setbitn(OE_HELP_KEY, bitmap); + + setbitn(OE_ENTER_KEY, bitmap); + if(!(flags && (*flags) & OE_DISALLOW_CANCEL)) + setbitn(OE_CANCEL_KEY, bitmap); + + setbitn(OE_CTRL_T_KEY, bitmap); + + /*---- Show the usual possible keys ----*/ + for(i=0,j=0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){ + if(i+j == OE_HELP_KEY) + j++; + + if(i+j == OE_CANCEL_KEY) + j++; + + if(i+j == OE_ENTER_KEY) + j++; + + oe_keymenu.keys[i+j].label = escape_list[i].label; + oe_keymenu.keys[i+j].name = escape_list[i].name; + setbitn(i+j, bitmap); + } + + for(i = i+j; i < 12; i++) + if(!(i == OE_HELP_KEY || i == OE_ENTER_KEY || i == OE_CANCEL_KEY)) + oe_keymenu.keys[i].name = NULL; + + draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global), 0, FirstMenu); + } + + if(pico_usingcolor() && VAR_PROMPT_FORE_COLOR && + VAR_PROMPT_BACK_COLOR && + pico_is_good_color(VAR_PROMPT_FORE_COLOR) && + pico_is_good_color(VAR_PROMPT_BACK_COLOR)){ + lastc = pico_get_cur_color(); + if(lastc){ + promptc = new_color_pair(VAR_PROMPT_FORE_COLOR, + VAR_PROMPT_BACK_COLOR); + (void)pico_set_colorp(promptc, PSC_NONE); + } + } + else + StartInverse(); + + /* + * if display length isn't wide enough to support input, + * shorten up the prompt... + */ + if((dline.dlen = cols - (x_base + prompt_len + 1)) < 5){ + prompt_len += (dline.dlen - 5); /* adding negative numbers */ + prompt -= (dline.dlen - 5); /* subtracting negative numbers */ + dline.dlen = 5; + } + + dline.dl = fs_get((size_t)dline.dlen + 1); + memset((void *)dline.dl, 0, (size_t)(dline.dlen + 1) * sizeof(char)); + dline.row = real_y_base; + dline.col = x_base + prompt_len; + dline.vl = string; + dline.vlen = --field_len; /* -1 for terminating NULL */ + dline.vbase = field_pos = 0; + +#ifdef _WINDOWS + cursor_shown = mswin_showcaret(1); +#endif + + PutLine0(real_y_base, x_base, prompt); + /* make sure passed in string is shorter than field_len */ + /* and adjust field_pos.. */ + + while((flags && *flags & OE_APPEND_CURRENT) && + field_pos < field_len && string[field_pos] != '\0') + field_pos++; + + string[field_pos] = '\0'; + dline.vused = (int)(&string[field_pos] - string); + passwd = (flags && *flags & OE_PASSWD) ? 1 : 0; + line_paint(field_pos, &passwd); + + /*---------------------------------------------------------------------- + The main loop + + here field_pos is the position in the string. + s always points to where we are in the string. + loops until someone sets the return_v. + ----------------------------------------------------------------------*/ + return_v = -10; + + while(return_v == -10) { + +#ifdef MOUSE + mouse_in_content(KEY_MOUSE, -1, -1, 0x5, 0); + register_mfunc(mouse_in_content, + real_y_base, x_base + prompt_len, + real_y_base, ps_global->ttyo->screen_cols); +#endif +#ifdef _WINDOWS + mswin_allowpaste(MSWIN_PASTE_LINE); + g_mc_row = real_y_base; + g_mc_col = x_base + prompt_len; + mswin_mousetrackcallback(pcpine_oe_cursor); +#endif + + /* Timeout 10 min to keep imap mail stream alive */ + ch = read_char(600); + +#ifdef MOUSE + clear_mfunc(mouse_in_content); +#endif +#ifdef _WINDOWS + mswin_allowpaste(MSWIN_PASTE_DISABLE); + mswin_mousetrackcallback(NULL); +#endif + + /* + * Don't want to intercept all characters if typing in passwd. + * We select an ad hoc set that we will catch and let the rest + * through. We would have caught the set below in the big switch + * but we skip the switch instead. Still catch things like ^K, + * DELETE, ^C, RETURN. + */ + if(passwd) + switch(ch) { + case ctrl('F'): + case KEY_RIGHT: + case ctrl('B'): + case KEY_LEFT: + case ctrl('U'): + case ctrl('A'): + case KEY_HOME: + case ctrl('E'): + case KEY_END: + case TAB: + goto ok_for_passwd; + } + + if(too_thin && ch != KEY_RESIZE && ch != ctrl('Z') && ch != ctrl('C')) + goto bleep; + + switch(ch) { + + /*--------------- KEY RIGHT ---------------*/ + case ctrl('F'): + case KEY_RIGHT: + if(field_pos >= field_len || string[field_pos] == '\0') + goto bleep; + + line_paint(++field_pos, &passwd); + break; + + /*--------------- KEY LEFT ---------------*/ + case ctrl('B'): + case KEY_LEFT: + if(field_pos <= 0) + goto bleep; + + line_paint(--field_pos, &passwd); + break; + + /*-------------------- WORD SKIP --------------------*/ + case ctrl('@'): + /* + * Note: read_char *can* return NO_OP_COMMAND which is + * the def'd with the same value as ^@ (NULL), BUT since + * read_char has a big timeout (>25 secs) it won't. + */ + + /* skip thru current word */ + while(string[field_pos] + && isalnum((unsigned char) string[field_pos])) + field_pos++; + + /* skip thru current white space to next word */ + while(string[field_pos] + && !isalnum((unsigned char) string[field_pos])) + field_pos++; + + line_paint(field_pos, &passwd); + break; + + /*-------------------- RETURN --------------------*/ + case PF4: + if(F_OFF(F_USE_FK,ps_global)) goto bleep; + case ctrl('J'): + case ctrl('M'): + return_v = 0; + break; + + /*-------------------- Destructive backspace --------------------*/ + case '\177': /* DEL */ + case ctrl('H'): + /* Try and do this with by telling the terminal to delete a + a character. If that fails, then repaint the rest of the + line, acheiving the same much less efficiently + */ + if(field_pos <= 0) + goto bleep; + + field_pos--; + /* drop thru to pull line back ... */ + + /*-------------------- Delete char --------------------*/ + case ctrl('D'): + case KEY_DEL: + if(field_pos >= field_len || !string[field_pos]) + goto bleep; + + dline.vused--; + for(s2 = &string[field_pos]; *s2 != '\0'; s2++) + *s2 = s2[1]; + + *s2 = '\0'; /* Copy last NULL */ + line_paint(field_pos, &passwd); + if(flags) /* record change if requested */ + *flags |= OE_USER_MODIFIED; + + break; + + + /*--------------- Kill line -----------------*/ + case ctrl('K'): + if(kill_buffer != NULL) + fs_give((void **)&kill_buffer); + + if(field_pos != 0 || string[0]){ + if(!passwd && F_ON(F_DEL_FROM_DOT, ps_global)) + dline.vused -= strlen(&string[i = field_pos]); + else + dline.vused = i = 0; + + kill_buffer = cpystr(&string[field_pos = i]); + string[field_pos] = '\0'; + line_paint(field_pos, &passwd); + if(flags) /* record change if requested */ + *flags |= OE_USER_MODIFIED; + + } + + break; + + /*------------------- Undelete line --------------------*/ + case ctrl('U'): + if(kill_buffer == NULL) + goto bleep; + + /* Make string so it will fit */ + kb = cpystr(kill_buffer); + dprint(2, (debugfile, + "Undelete: %d %d\n", strlen(string), field_len)); + if(strlen(kb) + strlen(string) > field_len) + kb[field_len - strlen(string)] = '\0'; + dprint(2, (debugfile, + "Undelete: %d %d\n", field_len - strlen(string), + strlen(kb))); + + if(string[field_pos] == '\0') { + /*--- adding to the end of the string ----*/ + for(k = kb; *k; k++) + string[field_pos++] = *k; + + string[field_pos] = '\0'; + } else { + goto bleep; + /* To lazy to do insert in middle of string now */ + } + + if(*kb && flags) /* record change if requested */ + *flags |= OE_USER_MODIFIED; + + dline.vused = strlen(string); + fs_give((void **)&kb); + line_paint(field_pos, &passwd); + break; + + + /*-------------------- Interrupt --------------------*/ + case ctrl('C'): /* ^C */ + if(F_ON(F_USE_FK,ps_global) + || (flags && ((*flags) & OE_DISALLOW_CANCEL))) + goto bleep; + + goto cancel; + + case PF2: + if(F_OFF(F_USE_FK,ps_global) + || (flags && ((*flags) & OE_DISALLOW_CANCEL))) + goto bleep; + + cancel: + return_v = 1; + if(saved_original) + strcpy(string, saved_original); + + break; + + + case ctrl('A'): + case KEY_HOME: + /*-------------------- Start of line -------------*/ + line_paint(field_pos = 0, &passwd); + break; + + + case ctrl('E'): + case KEY_END: + /*-------------------- End of line ---------------*/ + line_paint(field_pos = dline.vused, &passwd); + break; + + + /*-------------------- Help --------------------*/ + case ctrl('G') : + case PF1: + if(flags && ((*flags) & OE_DISALLOW_HELP)) + goto bleep; + else if(FOOTER_ROWS(ps_global) == 1 && km_popped == 0){ + km_popped++; + FOOTER_ROWS(ps_global) = 3; + clearfooter(ps_global); + if(lastc) + (void)pico_set_colorp(lastc, PSC_NONE); + else + EndInverse(); + + draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global), + 0, FirstMenu); + + if(promptc) + (void)pico_set_colorp(promptc, PSC_NONE); + else + StartInverse(); + + mark_keymenu_dirty(); + y_base = -3; + dline.row = real_y_base = y_base + ps_global->ttyo->screen_rows; + PutLine0(real_y_base, x_base, prompt); + fs_resize((void **)&dline.dl, (size_t)dline.dlen + 1); + memset((void *)dline.dl, 0, (size_t)(dline.dlen + 1)); + line_paint(field_pos, &passwd); + break; + } + + if(FOOTER_ROWS(ps_global) > 1){ + mark_keymenu_dirty(); + return_v = 3; + } + else + goto bleep; + + break; + +#ifdef MOUSE + case KEY_MOUSE : + { + MOUSEPRESS mp; + + mouse_get_last (NULL, &mp); + + /* The clicked line have anything special on it? */ + switch(mp.button){ + case M_BUTTON_LEFT : /* position cursor */ + mp.col -= x_base + prompt_len; /* normalize column */ + if(dline.vbase + mp.col <= dline.vused) + line_paint(field_pos = dline.vbase + mp.col, &passwd); + + break; + + case M_BUTTON_RIGHT : +#ifdef _WINDOWS + mp.col -= x_base + prompt_len; /* normalize column */ + if(dline.vbase + mp.col <= dline.vused) + line_paint(field_pos = dline.vbase + mp.col, &passwd); + + mswin_allowpaste(MSWIN_PASTE_LINE); + mswin_paste_popup(); + mswin_allowpaste(MSWIN_PASTE_DISABLE); + break; +#endif + + case M_BUTTON_MIDDLE : /* NO-OP for now */ + default: /* just ignore */ + break; + } + } + + break; +#endif + + case NO_OP_IDLE: + /* Keep mail stream alive */ + i = new_mail(0, 2, NM_DEFER_SORT); + if(ps_global->expunge_count && + flags && ((*flags) & OE_SEQ_SENSITIVE)) + goto cancel; + + if(i < 0){ + line_paint(field_pos, &passwd); + break; /* no changes, get on with life */ + } + /* Else fall into redraw */ + + /*-------------------- Redraw --------------------*/ + case ctrl('L'): + /*---------------- re size ----------------*/ + case KEY_RESIZE: + + dline.row = real_y_base = y_base > 0 ? y_base : + y_base + ps_global->ttyo->screen_rows; + if(lastc) + (void)pico_set_colorp(lastc, PSC_NONE); + else + EndInverse(); + + ClearScreen(); + redraw_titlebar(); + if(ps_global->redrawer != (void (*)())NULL) + (*ps_global->redrawer)(); + + redraw_keymenu(); + if(promptc) + (void)pico_set_colorp(promptc, PSC_NONE); + else + StartInverse(); + + PutLine0(real_y_base, x_base, prompt); + cols = ps_global->ttyo->screen_cols; + too_thin = 0; + if(cols < x_base + prompt_len + 4) { + Writechar(BELL, 0); + PutLine0(real_y_base, 0, "Screen's too thin. Ouch!"); + too_thin = 1; + } else { + dline.col = x_base + prompt_len; + dline.dlen = cols - (x_base + prompt_len + 1); + fs_resize((void **)&dline.dl, (size_t)dline.dlen + 1); + memset((void *)dline.dl, 0, (size_t)(dline.dlen + 1)); + line_paint(field_pos, &passwd); + } + fflush(stdout); + + dprint(9, (debugfile, + "optionally_enter RESIZE new_cols:%d too_thin: %d\n", + cols, too_thin)); + break; + + case PF3 : /* input to potentially remap */ + case PF5 : + case PF6 : + case PF7 : + case PF8 : + case PF9 : + case PF10 : + case PF11 : + case PF12 : + if(F_ON(F_USE_FK,ps_global) + && fkey_table[ch - PF1] != NO_OP_COMMAND) + ch = fkey_table[ch - PF1]; /* remap function key input */ + + default: + if(escape_list){ /* in the escape key list? */ + for(j=0; escape_list[j].ch != -1; j++){ + if(escape_list[j].ch == ch){ + return_v = escape_list[j].rval; + break; + } + } + + if(return_v != -10) + break; + } + + if(iscntrl(ch & 0x7f)){ + bleep: + putc(BELL, stdout); + continue; + } + + ok_for_passwd: + /*--- Insert a character -----*/ + if(dline.vused >= field_len) + goto bleep; + + /*---- extending the length of the string ---*/ + for(s2 = &string[++dline.vused]; s2 - string > field_pos; s2--) + *s2 = *(s2-1); + + string[field_pos++] = ch; + line_paint(field_pos, &passwd); + if(flags) /* record change if requested */ + *flags |= OE_USER_MODIFIED; + + } /*---- End of switch on char ----*/ + } + +#ifdef _WINDOWS + if(!cursor_shown) + mswin_showcaret(0); +#endif + + fs_give((void **)&dline.dl); + if(saved_original) + fs_give((void **)&saved_original); + + if(kill_buffer) + fs_give((void **)&kill_buffer); + + if (!(flags && (*flags) & OE_KEEP_TRAILING_SPACE)) + removing_trailing_white_space(string); + + if(lastc){ + (void)pico_set_colorp(lastc, PSC_NONE); + free_color_pair(&lastc); + if(promptc) + free_color_pair(&promptc); + } + else + EndInverse(); + + MoveCursor(real_y_base, x_base); /* Move the cursor to show we're done */ + fflush(stdout); + resume_busy_alarm(0); + if(km_popped){ + FOOTER_ROWS(ps_global) = 1; + clearfooter(ps_global); + ps_global->mangled_body = 1; + } + + return(return_v); +} + + +/* + * line_paint - where the real work of managing what is displayed gets done. + * The passwd variable is overloaded: if non-zero, don't + * output anything, else only blat blank chars across line + * once and use this var to tell us we've already written the + * line. + */ +void +line_paint(offset, passwd) + int offset; /* current dot offset into line */ + int *passwd; /* flag to hide display of chars */ +{ + register char *pfp, *pbp; + register char *vfp, *vbp; + int extra = 0; +#define DLEN (dline.vbase + dline.dlen) + + /* + * for now just leave line blank, but maybe do '*' for each char later + */ + if(*passwd){ + if(*passwd > 1) + return; + else + *passwd = 2; /* only blat once */ + + extra = 0; + MoveCursor(dline.row, dline.col); + while(extra++ < dline.dlen) + Writechar(' ', 0); + + MoveCursor(dline.row, dline.col); + return; + } + + /* adjust right margin */ + while(offset >= DLEN + ((dline.vused > DLEN) ? -1 : 1)) + dline.vbase += dline.dlen/2; + + /* adjust left margin */ + while(offset < dline.vbase + ((dline.vbase) ? 2 : 0)) + dline.vbase = max(dline.vbase - (dline.dlen/2), 0); + + if(dline.vbase){ /* off screen cue left */ + vfp = &dline.vl[dline.vbase+1]; + pfp = &dline.dl[1]; + if(dline.dl[0] != '<'){ + MoveCursor(dline.row, dline.col); + Writechar(dline.dl[0] = '<', 0); + } + } + else{ + vfp = dline.vl; + pfp = dline.dl; + if(dline.dl[0] == '<'){ + MoveCursor(dline.row, dline.col); + Writechar(dline.dl[0] = ' ', 0); + } + } + + if(dline.vused > DLEN){ /* off screen right... */ + vbp = vfp + (long)(dline.dlen-(dline.vbase ? 2 : 1)); + pbp = pfp + (long)(dline.dlen-(dline.vbase ? 2 : 1)); + if(pbp[1] != '>'){ + MoveCursor(dline.row, dline.col+dline.dlen); + Writechar(pbp[1] = '>', 0); + } + } + else{ + extra = dline.dlen - (dline.vused - dline.vbase); + vbp = &dline.vl[max(0, dline.vused-1)]; + pbp = &dline.dl[dline.dlen]; + if(pbp[0] == '>'){ + MoveCursor(dline.row, dline.col+dline.dlen); + Writechar(pbp[0] = ' ', 0); + } + } + + while(*pfp == *vfp && vfp < vbp) /* skip like chars */ + pfp++, vfp++; + + if(pfp == pbp && *pfp == *vfp){ /* nothing to paint! */ + MoveCursor(dline.row, dline.col + (offset - dline.vbase)); + return; + } + + /* move backward thru like characters */ + if(extra){ + while(extra >= 0 && *pbp == ' ') /* back over spaces */ + extra--, pbp--; + + while(extra >= 0) /* paint new ones */ + pbp[-(extra--)] = ' '; + } + + if((vbp - vfp) == (pbp - pfp)){ /* space there? */ + while((*pbp == *vbp) && pbp != pfp) /* skip like chars */ + pbp--, vbp--; + } + + if(pfp != pbp || *pfp != *vfp){ /* anything to paint?*/ + MoveCursor(dline.row, dline.col + (int)(pfp - dline.dl)); + + do + Writechar((unsigned char)((vfp <= vbp && *vfp) + ? ((*pfp = *vfp++) == TAB) ? ' ' : *pfp + : (*pfp = ' ')), 0); + while(++pfp <= pbp); + } + + MoveCursor(dline.row, dline.col + (offset - dline.vbase)); +} + + + +/*---------------------------------------------------------------------- + Check to see if the given command is reasonably valid + + Args: ch -- the character to check + + Result: A valid command is returned, or a well know bad command is returned. + + ---*/ +validatekeys(ch) + int ch; +{ +#ifndef _WINDOWS + if(F_ON(F_USE_FK,ps_global)) { + if(ch >= 'a' && ch <= 'z') + return(KEY_JUNK); + } else { + if(ch >= PF1 && ch <= PF12) + return(KEY_JUNK); + } +#else + /* + * In windows menu items are bound to a single key command which + * gets inserted into the input stream as if the user had typed + * that key. But all the menues are bonund to alphakey commands, + * not PFkeys. to distinguish between a keyboard command and a + * menu command we insert a flag (KEY_MENU_FLAG) into the + * command value when setting up the bindings in + * configure_menu_items(). Here we strip that flag. + */ + if(F_ON(F_USE_FK,ps_global)) { + if(ch >= 'a' && ch <= 'z' && !(ch & KEY_MENU_FLAG)) + return(KEY_JUNK); + ch &= ~ KEY_MENU_FLAG; + } else { + ch &= ~ KEY_MENU_FLAG; + if(ch >= PF1 && ch <= PF12) + return(KEY_JUNK); + } +#endif + + return(ch); +} + + + +/*---------------------------------------------------------------------- + Prepend config'd commands to keyboard input + + Args: ch -- pointer to storage for returned command + + Returns: TRUE if we're passing back a useful command, FALSE otherwise + + ---*/ +int +process_config_input(ch) + int *ch; +{ + static char firsttime = (char) 1; + + /* commands in config file */ + if(ps_global->initial_cmds && *ps_global->initial_cmds) { + /* + * There are a few commands that may require keyboard input before + * we enter the main command loop. That input should be interactive, + * not from our list of initial keystrokes. + */ + if(ps_global->dont_use_init_cmds) + return(0); + + *ch = *ps_global->initial_cmds++; + if(!*ps_global->initial_cmds && ps_global->free_initial_cmds){ + fs_give((void **)&(ps_global->free_initial_cmds)); + ps_global->initial_cmds = 0; + } + + return(1); + } + + if(firsttime) { + firsttime = 0; + if(ps_global->in_init_seq) { + ps_global->in_init_seq = 0; + ps_global->save_in_init_seq = 0; + clear_cursor_pos(); + F_SET(F_USE_FK,ps_global,ps_global->orig_use_fkeys); + /* draw screen */ + *ch = ctrl('L'); + return(1); + } + } + + return(0); +} + + +#define TAPELEN 256 +static int tape[TAPELEN]; +static long recorded = 0L; +static short length = 0; + + +/* + * record user keystrokes + * + * Args: ch -- the character to record + * + * Returns: character recorded + */ +int +key_recorder(ch) + int ch; +{ + tape[recorded++ % TAPELEN] = ch; + if(length < TAPELEN) + length++; + + return(ch); +} + + +/* + * playback user keystrokes + * + * Args: ch -- ignored + * + * Returns: character played back or -1 to indicate end of tape + */ +int +key_playback(ch) + int ch; +{ + ch = length ? tape[(recorded + TAPELEN - length--) % TAPELEN] : -1; + return(ch); +} + + +#ifdef _WINDOWS +int +pcpine_oe_cursor(col, row) + int col; + long row; +{ + return((row == g_mc_row + && col >= g_mc_col + && col < ps_global->ttyo->screen_cols) + ? MSWIN_CURSOR_IBEAM + : MSWIN_CURSOR_ARROW); +} +#endif + +/*====================================================================== + Routines for painting the screen + - figure out what the terminal type is + - deal with screen size changes + - save special output sequences + - the usual screen clearing, cursor addressing and scrolling + + + This library gives programs the ability to easily access the + termcap information and write screen oriented and raw input + programs. The routines can be called as needed, except that + to use the cursor / screen routines there must be a call to + InitScreen() first. The 'Raw' input routine can be used + independently, however. (Elm comment) + + Not sure what the original source of this code was. It got to be + here as part of ELM. It has been changed significantly from the + ELM version to be more robust in the face of inconsistent terminal + autowrap behaviour. Also, the unused functions were removed, it was + made to pay attention to the window size, and some code was made nicer + (in my opinion anyways). It also outputs the terminal initialization + strings and provides for minimal scrolling and detects terminals + with out enough capabilities. (Pine comment, 1990) + + +This code used to pay attention to the "am" auto margin and "xn" +new line glitch fields, but they were so often incorrect because many +terminals can be configured to do either that we've taken it out. It +now assumes it dosn't know where the cursor is after outputing in the +80th column. +*/ + +#define PUTLINE_BUFLEN 256 + +static int _lines, _columns; +static int _line = FARAWAY; +static int _col = FARAWAY; +static int _in_inverse; + + +/* + * Internal prototypes + */ +static void moveabsolute PROTO((int, int)); +static void CursorUp PROTO((int)); +static void CursorDown PROTO((int)); +static void CursorLeft PROTO((int)); +static void CursorRight PROTO((int)); + + +extern char *_clearscreen, *_moveto, *_up, *_down, *_right, *_left, + *_setinverse, *_clearinverse, + *_cleartoeoln, *_cleartoeos, + *_startinsert, *_endinsert, *_insertchar, *_deletechar, + *_deleteline, *_insertline, + *_scrollregion, *_scrollup, *_scrolldown, + *_termcap_init, *_termcap_end; +extern char term_name[]; +extern int _tlines, _tcolumns, _bce; + +static enum {NoScroll,UseScrollRegion,InsertDelete} _scrollmode; + +char *tgoto(); /* and the goto stuff */ + + + +/*---------------------------------------------------------------------- + Initialize the screen for output, set terminal type, etc + + Args: tt -- Pointer to variable to store the tty output structure. + + Result: terminal size is discovered and set in pine state + termcap entry is fetched and stored + make sure terminal has adequate capabilites + evaluate scrolling situation + returns status of indicating the state of the screen/termcap entry + + Returns: + -1 indicating no terminal name associated with this shell, + -2..-n No termcap for this terminal type known + -3 Can't open termcap file + -4 Terminal not powerful enough - missing clear to eoln or screen + or cursor motion + ----*/ +int +config_screen(tt) + struct ttyo **tt; +{ + struct ttyo *ttyo; + int err; + + ttyo = (struct ttyo *)fs_get(sizeof (struct ttyo)); + + _line = 0; /* where are we right now?? */ + _col = 0; /* assume zero, zero... */ + + /* + * This is an ugly hack to let vtterminalinfo know it's being called + * from pine. + */ + Pmaster = (PICO *)1; + if(err = vtterminalinfo(F_ON(F_TCAP_WINS, ps_global))) + return(err); + + Pmaster = NULL; + + if(_tlines <= 0) + _lines = DEFAULT_LINES_ON_TERMINAL; + else + _lines = _tlines; + + if(_tcolumns <= 0) + _columns = DEFAULT_COLUMNS_ON_TERMINAL; + else + _columns = _tcolumns; + + get_windsize(ttyo); + + ttyo->header_rows = 2; + ttyo->footer_rows = 3; + + /*---- Make sure this terminal has the capability. + All we need is cursor address, clear line, and + reverse video. + ---*/ + if(_moveto == NULL || _cleartoeoln == NULL || + _setinverse == NULL || _clearinverse == NULL) { + return(-4); + } + + dprint(1, (debugfile, "Terminal type: %s\n", term_name)); + + /*------ Figure out scrolling mode -----*/ + if(_scrollregion != NULL && _scrollregion[0] != '\0' && + _scrollup != NULL && _scrollup[0] != '\0'){ + _scrollmode = UseScrollRegion; + } else if(_insertline != NULL && _insertline[0] != '\0' && + _deleteline != NULL && _deleteline[0] != '\0') { + _scrollmode = InsertDelete; + } else { + _scrollmode = NoScroll; + } + dprint(7, (debugfile, "Scroll mode: %s\n", + _scrollmode==NoScroll ? "No Scroll" : + _scrollmode==InsertDelete ? "InsertDelete" : "Scroll Regions")); + + if (!_left) { + _left = "\b"; + } + + *tt = ttyo; + + return(0); +} + + + +/*---------------------------------------------------------------------- + Initialize the screen with the termcap string + ----*/ +void +init_screen() +{ + if(_termcap_init) /* init using termcap's rule */ + tputs(_termcap_init, 1, outchar); + + /* and make sure there are no scrolling surprises! */ + BeginScroll(0, ps_global->ttyo->screen_rows - 1); + + pico_toggle_color(0); + switch(ps_global->color_style){ + case COL_NONE: + case COL_TERMDEF: + pico_set_color_options(0); + break; + case COL_ANSI8: + pico_set_color_options(COLOR_ANSI8_OPT); + break; + case COL_ANSI16: + pico_set_color_options(COLOR_ANSI16_OPT); + break; + } + + if(ps_global->color_style != COL_NONE) + pico_toggle_color(1); + + /* set colors */ + if(pico_usingcolor()){ + if(ps_global->VAR_NORM_FORE_COLOR) + pico_nfcolor(ps_global->VAR_NORM_FORE_COLOR); + + if(ps_global->VAR_NORM_BACK_COLOR) + pico_nbcolor(ps_global->VAR_NORM_BACK_COLOR); + + if(ps_global->VAR_REV_FORE_COLOR) + pico_rfcolor(ps_global->VAR_REV_FORE_COLOR); + + if(ps_global->VAR_REV_BACK_COLOR) + pico_rbcolor(ps_global->VAR_REV_BACK_COLOR); + + pico_set_normal_color(); + } + + /* and make sure icon text starts out consistent */ + icon_text(NULL); + fflush(stdout); +} + + + + +/*---------------------------------------------------------------------- + Get the current window size + + Args: ttyo -- pointer to structure to store window size in + + NOTE: we don't override the given values unless we know better + ----*/ +int +get_windsize(ttyo) +struct ttyo *ttyo; +{ +#ifdef RESIZING + struct winsize win; + + /* + * Get the window size from the tty driver. If we can't fish it from + * stdout (pine's output is directed someplace else), try stdin (which + * *must* be associated with the terminal; see init_tty_driver)... + */ + if(ioctl(1, TIOCGWINSZ, &win) >= 0 /* 1 is stdout */ + || ioctl(0, TIOCGWINSZ, &win) >= 0){ /* 0 is stdin */ + if(win.ws_row) + _lines = min(win.ws_row, MAX_SCREEN_ROWS); + + if(win.ws_col) + _columns = min(win.ws_col, MAX_SCREEN_COLS); + + dprint(2, (debugfile, "new win size -----<%d %d>------\n", + _lines, _columns)); + } + else + /* Depending on the OS, the ioctl() may have failed because + of a 0 rows, 0 columns setting. That happens on DYNIX/ptx 1.3 + (with a kernel patch that happens to involve the negotiation + of window size in the telnet streams module.) In this case + the error is EINVARG. Leave the default settings. */ + dprint(1, (debugfile, "ioctl(TIOCWINSZ) failed :%s\n", + error_description(errno))); +#endif + + ttyo->screen_cols = min(_columns, MAX_SCREEN_COLS); + ttyo->screen_rows = min(_lines, MAX_SCREEN_ROWS); + return(0); +} + + +/*---------------------------------------------------------------------- + End use of the screen. + Print status message, if any. + Flush status messages. + ----*/ +void +end_screen(message) + char *message; +{ + int footer_rows_was_one = 0; + + dprint(9, (debugfile, "end_screen called\n")); + + if(FOOTER_ROWS(ps_global) == 1){ + footer_rows_was_one++; + FOOTER_ROWS(ps_global) = 3; + mark_status_unknown(); + } + + flush_status_messages(1); + blank_keymenu(_lines - 2, 0); + MoveCursor(_lines - 2, 0); + + /* unset colors */ + if(pico_hascolor()) + pico_endcolor(); + + if(_termcap_end != NULL) + tputs(_termcap_end, 1, outchar); + + if(message){ + printf("%s\r\n", message); + } + + if(F_ON(F_ENABLE_XTERM_NEWMAIL, ps_global) && getenv("DISPLAY")) + icon_text("xterm"); + + fflush(stdout); + + if(footer_rows_was_one){ + FOOTER_ROWS(ps_global) = 1; + mark_status_unknown(); + } +} + + + +/*---------------------------------------------------------------------- + Clear the terminal screen + + Result: The screen is cleared + internal cursor position set to 0,0 + ----*/ +void +ClearScreen() +{ + _line = 0; /* clear leaves us at top... */ + _col = 0; + + if(ps_global->in_init_seq) + return; + + mark_status_unknown(); + mark_keymenu_dirty(); + mark_titlebar_dirty(); + + /* + * If the terminal doesn't have back color erase, then we have to + * erase manually to preserve the background color. + */ + if(pico_usingcolor() && (!_bce || !_clearscreen)){ + ClearLines(0, _lines-1); + MoveCursor(0, 0); + } + else if(_clearscreen){ + tputs(_clearscreen, 1, outchar); + moveabsolute(0, 0); /* some clearscreens don't move correctly */ + } +} + + +/*---------------------------------------------------------------------- + Internal move cursor to absolute position + + Args: col -- column to move cursor to + row -- row to move cursor to + + Result: cursor is moved (variables, not updates) + ----*/ + +static void +moveabsolute(col, row) +{ + + char *stuff, *tgoto(); + + stuff = tgoto(_moveto, col, row); + tputs(stuff, 1, outchar); +} + + +/*---------------------------------------------------------------------- + Move the cursor to the row and column number + Args: row number + column number + + Result: Cursor moves + internal position updated + ----*/ +void +MoveCursor(row, col) + int row, col; +{ + /** move cursor to the specified row column on the screen. + 0,0 is the top left! **/ + + int scrollafter = 0; + + /* we don't want to change "rows" or we'll mangle scrolling... */ + + if(ps_global->in_init_seq) + return; + + if (col < 0) + col = 0; + if (col >= ps_global->ttyo->screen_cols) + col = ps_global->ttyo->screen_cols - 1; + if (row < 0) + row = 0; + if (row > ps_global->ttyo->screen_rows) { + if (col == 0) + scrollafter = row - ps_global->ttyo->screen_rows; + row = ps_global->ttyo->screen_rows; + } + + if (!_moveto) + return; + + if (row == _line) { + if (col == _col) + return; /* already there! */ + + else if (abs(col - _col) < 5) { /* within 5 spaces... */ + if (col > _col && _right) + CursorRight(col - _col); + else if (col < _col && _left) + CursorLeft(_col - col); + else + moveabsolute(col, row); + } + else /* move along to the new x,y loc */ + moveabsolute(col, row); + } + else if (col == _col && abs(row - _line) < 5) { + if (row < _line && _up) + CursorUp(_line - row); + else if (_line > row && _down) + CursorDown(row - _line); + else + moveabsolute(col, row); + } + else if (_line == row-1 && col == 0) { + putchar('\n'); /* that's */ + putchar('\r'); /* easy! */ + } + else + moveabsolute(col, row); + + _line = row; /* to ensure we're really there... */ + _col = col; + + if (scrollafter) { + while (scrollafter--) { + putchar('\n'); + putchar('\r'); + + } + } + + return; +} + + + +/*---------------------------------------------------------------------- + Newline, move the cursor to the start of next line + + Result: Cursor moves + ----*/ +void +NewLine() +{ + /** move the cursor to the beginning of the next line **/ + + Writechar('\n', 0); + Writechar('\r', 0); +} + + + +/*---------------------------------------------------------------------- + Move cursor up n lines with terminal escape sequence + + Args: n -- number of lines to go up + + Result: cursor moves, + internal position updated + + Only for ttyout use; not outside callers + ----*/ +static void +CursorUp(n) +int n; +{ + /** move the cursor up 'n' lines **/ + /** Calling function must check that _up is not null before calling **/ + + _line = (_line-n > 0? _line - n: 0); /* up 'n' lines... */ + + while (n-- > 0) + tputs(_up, 1, outchar); +} + + + +/*---------------------------------------------------------------------- + Move cursor down n lines with terminal escape sequence + + Arg: n -- number of lines to go down + + Result: cursor moves, + internal position updated + + Only for ttyout use; not outside callers + ----*/ +static void +CursorDown(n) + int n; +{ + /** move the cursor down 'n' lines **/ + /** Caller must check that _down is not null before calling **/ + + _line = (_line+n < ps_global->ttyo->screen_rows ? _line + n + : ps_global->ttyo->screen_rows); + /* down 'n' lines... */ + + while (n-- > 0) + tputs(_down, 1, outchar); +} + + + +/*---------------------------------------------------------------------- + Move cursor left n lines with terminal escape sequence + + Args: n -- number of lines to go left + + Result: cursor moves, + internal position updated + + Only for ttyout use; not outside callers + ----*/ +static void +CursorLeft(n) +int n; +{ + /** move the cursor 'n' characters to the left **/ + /** Caller must check that _left is not null before calling **/ + + _col = (_col - n> 0? _col - n: 0); /* left 'n' chars... */ + + while (n-- > 0) + tputs(_left, 1, outchar); +} + + +/*---------------------------------------------------------------------- + Move cursor right n lines with terminal escape sequence + + Args: number of lines to go right + + Result: cursor moves, + internal position updated + + Only for ttyout use; not outside callers + ----*/ +static void +CursorRight(n) +int n; +{ + /** move the cursor 'n' characters to the right (nondestructive) **/ + /** Caller must check that _right is not null before calling **/ + + _col = (_col+n < ps_global->ttyo->screen_cols? _col + n : + ps_global->ttyo->screen_cols); /* right 'n' chars... */ + + while (n-- > 0) + tputs(_right, 1, outchar); + +} + + + +/*---------------------------------------------------------------------- + Insert character on screen pushing others right + + Args: c -- character to insert + + Result: charcter is inserted if possible + return -1 if it can't be done + ----------------------------------------------------------------------*/ +InsertChar(c) + int c; +{ + if(_insertchar != NULL && *_insertchar != '\0') { + tputs(_insertchar, 1, outchar); + Writechar(c, 0); + } else if(_startinsert != NULL && *_startinsert != '\0') { + tputs(_startinsert, 1, outchar); + Writechar(c, 0); + tputs(_endinsert, 1, outchar); + } else { + return(-1); + } + return(0); +} + + + +/*---------------------------------------------------------------------- + Delete n characters from line, sliding rest of line left + + Args: n -- number of characters to delete + + + Result: characters deleted on screen + returns -1 if it wasn't done + ----------------------------------------------------------------------*/ +DeleteChar(n) + int n; +{ + if(_deletechar == NULL || *_deletechar == '\0') + return(-1); + + while(n) { + tputs(_deletechar, 1, outchar); + n--; + } + return(0); +} + + + +/*---------------------------------------------------------------------- + Go into scrolling mode, that is set scrolling region if applicable + + Args: top -- top line of region to scroll + bottom -- bottom line of region to scroll + (These are zero-origin numbers) + + Result: either set scrolling region or + save values for later scrolling + returns -1 if we can't scroll + + Unfortunately this seems to leave the cursor in an unpredictable place + at least the manuals don't say where, so we force it here. +-----*/ +static int __t, __b; + +BeginScroll(top, bottom) + int top, bottom; +{ + char *stuff; + + if(_scrollmode == NoScroll) + return(-1); + + __t = top; + __b = bottom; + if(_scrollmode == UseScrollRegion){ + stuff = tgoto(_scrollregion, bottom, top); + tputs(stuff, 1, outchar); + /*-- a location very far away to force a cursor address --*/ + _line = FARAWAY; + _col = FARAWAY; + } + return(0); +} + + + +/*---------------------------------------------------------------------- + End scrolling -- clear scrolling regions if necessary + + Result: Clear scrolling region on terminal + -----*/ +void +EndScroll() +{ + if(_scrollmode == UseScrollRegion && _scrollregion != NULL){ + /* Use tgoto even though we're not cursor addressing because + the format of the capability is the same. + */ + char *stuff = tgoto(_scrollregion, ps_global->ttyo->screen_rows -1, 0); + tputs(stuff, 1, outchar); + /*-- a location very far away to force a cursor address --*/ + _line = FARAWAY; + _col = FARAWAY; + } +} + + +/* ---------------------------------------------------------------------- + Scroll the screen using insert/delete or scrolling regions + + Args: lines -- number of lines to scroll, positive forward + + Result: Screen scrolls + returns 0 if scroll succesful, -1 if not + + positive lines goes foward (new lines come in at bottom + Leaves cursor at the place to insert put new text + + 0,0 is the upper left + -----*/ +ScrollRegion(lines) + int lines; +{ + int l; + + if(lines == 0) + return(0); + + if(_scrollmode == UseScrollRegion) { + if(lines > 0) { + MoveCursor(__b, 0); + for(l = lines ; l > 0 ; l--) + tputs((_scrolldown == NULL || _scrolldown[0] =='\0') ? "\n" : + _scrolldown, 1, outchar); + } else { + MoveCursor(__t, 0); + for(l = -lines; l > 0; l--) + tputs(_scrollup, 1, outchar); + } + } else if(_scrollmode == InsertDelete) { + if(lines > 0) { + MoveCursor(__t, 0); + for(l = lines; l > 0; l--) + tputs(_deleteline, 1, outchar); + MoveCursor(__b, 0); + for(l = lines; l > 0; l--) + tputs(_insertline, 1, outchar); + } else { + for(l = -lines; l > 0; l--) { + MoveCursor(__b, 0); + tputs(_deleteline, 1, outchar); + MoveCursor(__t, 0); + tputs(_insertline, 1, outchar); + } + } + } else { + return(-1); + } + fflush(stdout); + return(0); +} + + + +/*---------------------------------------------------------------------- + Write a character to the screen, keeping track of cursor position + + Args: ch -- character to output + + Result: character output + cursor position variables updated + ----*/ +void +Writechar(ch, new_esc_len) + register unsigned int ch; + int new_esc_len; +{ + static int esc_len = 0; + + if(ps_global->in_init_seq /* silent */ + || (F_ON(F_BLANK_KEYMENU, ps_global) /* or bottom, */ + && !esc_len /* right cell */ + && _line + 1 == ps_global->ttyo->screen_rows + && _col + 1 == ps_global->ttyo->screen_cols)) + return; + + if(!iscntrl(ch & 0x7f)){ + putchar(ch); + if(esc_len > 0) + esc_len--; + else + _col++; + } + else{ + switch(ch){ + case LINE_FEED: + /*-- Don't have to watch out for auto wrap or newline glitch + because we never let it happen. See below + ---*/ + putchar('\n'); + _line = min(_line+1,ps_global->ttyo->screen_rows); + esc_len = 0; + break; + + case RETURN : /* move to column 0 */ + putchar('\r'); + _col = 0; + esc_len = 0; + break; + + case BACKSPACE : /* move back a space if not in column 0 */ + if(_col != 0) { + putchar('\b'); + _col--; + } /* else BACKSPACE does nothing */ + + break; + + case BELL : /* ring the bell but don't advance _col */ + putchar(ch); + break; + + case TAB : /* if a tab, output it */ + do /* BUG? ignores tty driver's spacing */ + putchar(' '); + while(_col < ps_global->ttyo->screen_cols - 1 + && ((++_col)&0x07) != 0); + break; + + case ESCAPE : + /* If we're outputting an escape here, it may be part of an iso2022 + escape sequence in which case take up no space on the screen. + Unfortunately such sequences are variable in length. + */ + esc_len = new_esc_len - 1; + putchar(ch); + break; + + default : /* Change remaining control characters to ? */ + if(F_ON(F_PASS_CONTROL_CHARS, ps_global)) + putchar(ch); + else + putchar('?'); + + if(esc_len > 0) + esc_len--; + else + _col++; + + break; + } + } + + + /* Here we are at the end of the line. We've decided to make no + assumptions about how the terminal behaves at this point. + What can happen now are the following + 1. Cursor is at start of next line, and next character will + apear there. (autowrap, !newline glitch) + 2. Cursor is at start of next line, and if a newline is output + it'll be ignored. (autowrap, newline glitch) + 3. Cursor is still at end of line and next char will apear + there over the top of what is there now (no autowrap). + We ignore all this and force the cursor to the next line, just + like case 1. A little expensive but worth it to avoid problems + with terminals configured so they don't match termcap + */ + if(_col == ps_global->ttyo->screen_cols) { + _col = 0; + if(_line + 1 < ps_global->ttyo->screen_rows) + _line++; + + moveabsolute(_col, _line); + } +} + + + +/*---------------------------------------------------------------------- + Write string to screen at current cursor position + + Args: string -- string to be output + + Result: String written to the screen + ----*/ +void +Write_to_screen(string) /* UNIX */ + register char *string; +{ + while(*string) + Writechar((unsigned char) *string++, 0); +} + + +/*---------------------------------------------------------------------- + Write no more than n chars of string to screen at current cursor position + + Args: string -- string to be output + n -- number of chars to output + + Result: String written to the screen + ----*/ +void +Write_to_screen_n(string, n) /* UNIX */ + register char *string; + int n; +{ + while(n-- && *string) + Writechar((unsigned char) *string++, 0); +} + + + +/*---------------------------------------------------------------------- + Clear screen to end of line on current line + + Result: Line is cleared + ----*/ +void +CleartoEOLN() +{ + int c, starting_col, starting_line; + char *last_bg_color; + + /* + * If the terminal doesn't have back color erase, then we have to + * erase manually to preserve the background color. + */ + if(pico_usingcolor() && (!_bce || !_cleartoeoln)){ + starting_col = _col; + starting_line = _line; + last_bg_color = pico_get_last_bg_color(); + pico_set_nbg_color(); + for(c = _col; c < _columns; c++) + Writechar(' ', 0); + + MoveCursor(starting_line, starting_col); + if(last_bg_color){ + (void)pico_set_bg_color(last_bg_color); + fs_give((void **)&last_bg_color); + } + } + else if(_cleartoeoln) + tputs(_cleartoeoln, 1, outchar); +} + + + +/*---------------------------------------------------------------------- + Clear screen to end of screen from current point + + Result: screen is cleared + ----*/ +CleartoEOS() +{ + int starting_col, starting_line; + + /* + * If the terminal doesn't have back color erase, then we have to + * erase manually to preserve the background color. + */ + if(pico_usingcolor() && (!_bce || !_cleartoeos)){ + starting_col = _col; + starting_line = _line; + CleartoEOLN(); + ClearLines(_line+1, _lines-1); + MoveCursor(starting_line, starting_col); + } + else if(_cleartoeos) + tputs(_cleartoeos, 1, outchar); +} + + + +/*---------------------------------------------------------------------- + function to output character used by termcap + + Args: c -- character to output + + Result: character output to screen via stdio + ----*/ +void +outchar(c) +int c; +{ + /** output the given character. From tputs... **/ + /** Note: this CANNOT be a macro! **/ + + putc((unsigned char)c, stdout); +} + + + +/*---------------------------------------------------------------------- + function to output string such that it becomes icon text + + Args: s -- string to write + + Result: string indicated become our "icon" text + ----*/ +void +icon_text(s) + char *s; +{ + static char *old_s; + static enum {ukn, yes, no} xterm; + + if(xterm == ukn) + xterm = (getenv("DISPLAY") != NULL) ? yes : no; + + if(F_ON(F_ENABLE_XTERM_NEWMAIL,ps_global) && xterm == yes && (s || old_s)){ + fputs("\033]1;", stdout); + fputs((old_s = s) ? s : ps_global->pine_name, stdout); + fputs("\007", stdout); + fflush(stdout); + } +} + + +#ifdef _WINDOWS +#line 3 "osdep/termout.gen" +#endif + +/* + * Generic tty output routines... + */ + +/*---------------------------------------------------------------------- + Printf style output line to the screen at given position, 0 args + + Args: x -- column position on the screen + y -- row position on the screen + line -- line of text to output + + Result: text is output + cursor position is update + ----*/ +void +PutLine0(x, y, line) + int x,y; + register char *line; +{ + MoveCursor(x,y); + Write_to_screen(line); +} + + + +/*---------------------------------------------------------------------- + Output line of length len to the display observing embedded attributes + + Args: x -- column position on the screen + y -- column position on the screen + line -- text to be output + length -- length of text to be output + + Result: text is output + cursor position is updated + ----------------------------------------------------------------------*/ +void +PutLine0n8b(x, y, line, length, handles) + int x, y, length; + register char *line; + HANDLE_S *handles; +{ + unsigned char c; +#ifdef _WINDOWS + int hkey = 0; +#endif + + MoveCursor(x,y); + while(length-- && (c = (unsigned char)*line++)){ + + if(c == (unsigned char)TAG_EMBED && length){ + length--; + switch(*line++){ + case TAG_INVON : + StartInverse(); + break; + case TAG_INVOFF : + EndInverse(); + break; + case TAG_BOLDON : + StartBold(); + break; + case TAG_BOLDOFF : + EndBold(); + break; + case TAG_ULINEON : + StartUnderline(); + break; + case TAG_ULINEOFF : + EndUnderline(); + break; + case TAG_HANDLE : + length -= *line + 1; /* key length plus length tag */ + if(handles){ + int key, n; + + for(key = 0, n = *line++; n; n--) /* forget Horner? */ + key = (key * 10) + (*line++ - '0'); + +#if _WINDOWS + hkey = key; +#endif + + if(key == handles->key){ + if(pico_usingcolor() && + ps_global->VAR_SLCTBL_FORE_COLOR && + ps_global->VAR_SLCTBL_BACK_COLOR){ + pico_set_normal_color(); + } + else + EndBold(); + + StartInverse(); + } + } + else{ + /* BUG: complain? */ + line += *line + 1; + } + + break; + case TAG_FGCOLOR : + if(length < RGBLEN){ + Writechar(TAG_EMBED, 0); + Writechar(*(line-1), 0); + break; + } + + (void)pico_set_fg_color(line); + length -= RGBLEN; + line += RGBLEN; + break; + case TAG_BGCOLOR : + if(length < RGBLEN){ + Writechar(TAG_EMBED, 0); + Writechar(*(line-1), 0); + break; + } + + (void)pico_set_bg_color(line); + length -= RGBLEN; + line += RGBLEN; + break; + default : /* literal "embed" char? */ + Writechar(TAG_EMBED, 0); + Writechar(*(line-1), 0); + break; + } /* tag with handle, skip it */ + } + else if(c == '\033') /* check for iso-2022 escape */ + Writechar(c, match_escapes(line)); + else + Writechar(c, 0); + } + + +#if _WINDOWS_X + if(hkey) { + char *tmp_file = NULL, ext[32], mtype[128]; + HANDLE_S *h; + extern HANDLE_S *get_handle (HANDLE_S *, int); + + if((h = get_handle(handles, hkey)) && h->type == Attach){ + ext[0] = '\0'; + strcpy(mtype, body_type_names(h->h.attach->body->type)); + if (h->h.attach->body->subtype) { + strcat (mtype, "/"); + strcat (mtype, h->h.attach->body->subtype); + } + + if(!set_mime_extension_by_type(ext, mtype)){ + char *namep, *dotp, *p; + + if(namep = rfc2231_get_param(h->h.attach->body->parameter, + "name", NULL, NULL)){ + for(dotp = NULL, p = namep; *p; p++) + if(*p == '.') + dotp = p + 1; + + if(dotp && strlen(dotp) < sizeof(ext) - 1) + strcpy(ext, dotp); + + fs_give((void **) &namep); + } + } + + if(ext[0] && (tmp_file = temp_nam_ext(NULL, "im", ext))){ + FILE *f = fopen(tmp_file, "w"); + + mswin_registericon(x, h->key, tmp_file); + + fclose(f); + unlink(tmp_file); + fs_give((void **)&tmp_file); + } + } + } +#endif +} + + +/*---------------------------------------------------------------------- + Printf style output line to the screen at given position, 1 arg + + Input: position on the screen + line of text to output + + Result: text is output + cursor position is update + ----------------------------------------------------------------------*/ +void +/*VARARGS2*/ +PutLine1(x, y, line, arg1) + int x, y; + char *line; + void *arg1; +{ + char buffer[PUTLINE_BUFLEN]; + + sprintf(buffer, line, arg1); + PutLine0(x, y, buffer); +} + + +/*---------------------------------------------------------------------- + Printf style output line to the screen at given position, 2 args + + Input: position on the screen + line of text to output + + Result: text is output + cursor position is update + ----------------------------------------------------------------------*/ +void +/*VARARGS3*/ +PutLine2(x, y, line, arg1, arg2) + int x, y; + char *line; + void *arg1, *arg2; +{ + char buffer[PUTLINE_BUFLEN]; + + sprintf(buffer, line, arg1, arg2); + PutLine0(x, y, buffer); +} + + +/*---------------------------------------------------------------------- + Printf style output line to the screen at given position, 3 args + + Input: position on the screen + line of text to output + + Result: text is output + cursor position is update + ----------------------------------------------------------------------*/ +void +/*VARARGS4*/ +PutLine3(x, y, line, arg1, arg2, arg3) + int x, y; + char *line; + void *arg1, *arg2, *arg3; +{ + char buffer[PUTLINE_BUFLEN]; + + sprintf(buffer, line, arg1, arg2, arg3); + PutLine0(x, y, buffer); +} + + +/*---------------------------------------------------------------------- + Printf style output line to the screen at given position, 4 args + + Args: x -- column position on the screen + y -- column position on the screen + line -- printf style line of text to output + + Result: text is output + cursor position is update + ----------------------------------------------------------------------*/ +void +/*VARARGS5*/ +PutLine4(x, y, line, arg1, arg2, arg3, arg4) + int x, y; + char *line; + void *arg1, *arg2, *arg3, *arg4; +{ + char buffer[PUTLINE_BUFLEN]; + + sprintf(buffer, line, arg1, arg2, arg3, arg4); + PutLine0(x, y, buffer); +} + + + +/*---------------------------------------------------------------------- + Printf style output line to the screen at given position, 5 args + + Args: x -- column position on the screen + y -- column position on the screen + line -- printf style line of text to output + + Result: text is output + cursor position is update + ----------------------------------------------------------------------*/ +void +/*VARARGS6*/ +PutLine5(x, y, line, arg1, arg2, arg3, arg4, arg5) + int x, y; + char *line; + void *arg1, *arg2, *arg3, *arg4, *arg5; +{ + char buffer[PUTLINE_BUFLEN]; + + sprintf(buffer, line, arg1, arg2, arg3, arg4, arg5); + PutLine0(x, y, buffer); +} + + + +/*---------------------------------------------------------------------- + Output a line to the screen, centered + + Input: Line number to print on, string to output + + Result: String is output to screen + Returns column number line is output on + ----------------------------------------------------------------------*/ +int +Centerline(line, string) + int line; + char *string; +{ + register int length, col; + + length = strlen(string); + + if (length > ps_global->ttyo->screen_cols) + col = 0; + else + col = (ps_global->ttyo->screen_cols - length) / 2; + + PutLine0(line, col, string); + return(col); +} + + + +/*---------------------------------------------------------------------- + Clear specified line on the screen + + Result: The line is blanked and the cursor is left at column 0. + + ----*/ +void +ClearLine(n) + int n; +{ + if(ps_global->in_init_seq) + return; + + MoveCursor(n, 0); + CleartoEOLN(); +} + + + +/*---------------------------------------------------------------------- + Clear specified lines on the screen + + Result: The lines starting at 'x' and ending at 'y' are blanked + and the cursor is left at row 'x', column 0 + + ----*/ +void +ClearLines(x, y) + int x, y; +{ + int i; + + for(i = x; i <= y; i++) + ClearLine(i); + + MoveCursor(x, 0); +} + + + +/*---------------------------------------------------------------------- + Indicate to the screen painting here that the position of the cursor + has been disturbed and isn't where these functions might think. + ----*/ +void +clear_cursor_pos() +{ + _line = FARAWAY; + _col = FARAWAY; +} + + |