/********************************************************************
 * $Author: tfurrows
 * $Revision: 1.11
 * $Date: 2018/01/04
 * $Source: /home/jlyman/src/gopher/gopher_master/gopher/gopher.c,v $
 *
 * Paul Lindner, University of Minnesota CIS.
 *
 * Copyright 1991, 1992 by the Regents of the University of Minnesota
 * see the file "Copyright" in the distribution for conditions of use.
 *********************************************************************
 * MODULE: gopher.c
 * Main functions for the gopher client
 *********************************************************************
 * Revision History:
 *
 * Revision 1.11  2018/01/04 22:00:39  tfurrows
 * changed default startup behavior; starts with bookmarks
 * unless an address was provided on the command line
 * 
 * added color, and fixed line 9 space, previously
 *
 * Revision 1.10  2002/04/26 14:59:54  jgoerzen
 * Preparations for 3.0.5.
 *
 * Lots of old revision info removed...
 *
 *********************************************************************/


#include "gopher.h"
#if defined(VMS) && defined(A_LANGUAGE)
static	CursesObj	*LangScreen = NULL;
#endif
#include "Stdlib.h"
#include "Debug.h"

#include <errno.h>
#include "fileio.h"
#include "Malloc.h"
#include "patchlevel.h"

#ifdef HAVE_TIME_H
#  include <time.h>
#endif /* HAVE_TIME_H */

void describe_gopher(char *banner, GopherStruct *ZeGopher, FILE *gripefile);
extern int  twirl(void);


/*
** Open a connection to another host using telnet or tn3270
*/

void
do_tel_3270(GopherStruct *ZeGopher)
{
     char *Dialogmess[9];

     char sMessage1[128];
     char sMessage2[128];

     char sTelCmd[128];
     
     char *cp;

     /* retrieve the gopher information for the telnet command*/

     clear();
#ifdef VMS
     refresh();
#endif
     Dialogmess[0] = Gtxt("Warning!!!!!, you are about to leave the Internet",34);
     Dialogmess[1] = Gtxt("Gopher program and connect to another host. If",35);
     Dialogmess[2] = Gtxt("you get stuck press the control key and the",36);
#if defined(VMS) && defined(MULTINET)
     Dialogmess[3] = Gtxt("^ key, and then type q.",38);
#else
     Dialogmess[3] = Gtxt("] key, and then type quit",37);
#endif
     Dialogmess[4] = "";
     
     if (GSgetPort(ZeGopher) != 0)
	  sprintf(sMessage1,Gtxt("Connecting to %.40s, port %d using %s.",39), 
		  GSgetHost(ZeGopher),GSgetPort(ZeGopher), 
		  (GSgetType(ZeGopher) == A_TN3270) ? "tn3270" : "telnet");
     else
	  sprintf(sMessage1, Gtxt("Connecting to %.40s using %s.",40),
		  GSgetHost(ZeGopher),
		  (GSgetType(ZeGopher) == A_TN3270) ? "tn3270" : "telnet");

     Dialogmess[5] = sMessage1;

     cp = GSgetPath(ZeGopher);
     if (*cp != '\0')
	  sprintf(sMessage2,
		  Gtxt("Use the account name \"%.40s\" to log in",41),
		  GSgetPath(ZeGopher));
     else
	  sMessage2[0] = '\0';

     Dialogmess[6] = "";
     Dialogmess[7] = sMessage2;
     Dialogmess[8] = NULL;

     if (CURDialog(CursesScreen, GSgetTitle(ZeGopher), Dialogmess) <0)
	  return;

     CURexit(CursesScreen);

     if (GSgetType(ZeGopher) == 'T') {
	  /**** A TN3270 connection ****/
	  RCdisplayCommand(GlobalRC, "Terminal/tn3270", GSgetHost(ZeGopher),
			   sTelCmd);

     } else {

	  RCdisplayCommand(GlobalRC, "Terminal/telnet", GSgetHost(ZeGopher), 
			   sTelCmd);
     }

     if (GSgetPort(ZeGopher) != 0 && GSgetPort(ZeGopher) != 23) 
#if defined(VMS) && (defined(MULTINET) || defined(CMUIP))
	  sprintf(sTelCmd+strlen(sTelCmd),
		  "/PORT=%d", GSgetPort(ZeGopher));
#else
     sprintf(sTelCmd+strlen(sTelCmd), " %d", GSgetPort(ZeGopher));
#endif
     
     CURexit(CursesScreen);

#ifdef Telnet_Trace
     Telnet_Trace(sTelCmd, ZeGopher);
#endif
     FIOsystem(sTelCmd);
     printf("\n\n");
     printf(Gtxt("\nPress <RETURN> to continue",120));
     fflush(stdout);
     fflush(stdin);
     fflush(stdin);
     (void) getchar();
     CURenter(CursesScreen);
     return;
}


#if defined(VMS) && defined(TELNET_TRACE)

/*
** Some sites are really paranoid about attempts to connect from their site 
** to specific telnet hosts (e.g., MUDDs, etc.) -- so provide a log facility 
** to track specific connectsions just to see how clients are finding them.
*/
#include <descrip.h>
#include <lnmdef.h>
#include <ssdef.h>
#include "syslog.h"

/*
**  Like logrequest() but should use a different log file just for this...
*/

int
trace_telnet(msg, gs)
  char *msg;
  GopherObj *gs;
{
     static boolean inited = FALSE;
     char *url = "";
     char *name = "";

     if (!gs)
	return(0);

     if (inited == FALSE) {
	  openlog("gopher", (LOG_PID), LOG_LOCAL7); /* MULTINET allows LOCAL7 */
	  setlogmask(LOG_UPTO(LOG_INFO));
	  inited = TRUE;
     }
     if (gs != NULL) {
	  url = GSgetURL(gs, "");
	  name = GSgetTitle(gs);
     }

     syslog(LOG_INFO, "%s %s%s%s%s", msg, url, strlen(name)?" \"":"",
						    name, strlen(name)?"\"":"");

     return(0);
}

int
Telnet_Trace(char *sTelCmd, GopherStruct *ZeGopher)
{
	char	text[255];
        int	l;
static	int	buf_len;
static	int	i;
static	int	junk;
static	int	max_len;

	int	no_case = LNM$M_CASE_BLIND;
static	$DESCRIPTOR(lname_desc,"GOPHER_TELNET_LOG");
static	$DESCRIPTOR(tabnam,"LNM$SYSTEM_TABLE");
struct itmlst
    {
	short int buf_len;
	short int item_code;
	char *buffer;
	int *buf_length;
    };
static
    struct itmlst
		item_max[] = { {4,LNM$_MAX_INDEX,(char *)&max_len,&buf_len},
					{0,0,0,0}};
static	
    struct itmlst
		item_str[] = { {4,LNM$_INDEX,(char *)&i,&junk},
					{0,LNM$_STRING,0,&buf_len},
					{0,0,0,0}};

  if (SS$_NORMAL != SYS$TRNLNM(&no_case,&tabnam,&lname_desc,0,&item_max))
	return;
  item_str[1].buffer = text;
  for (i=0; i<=max_len; i++) {
    item_str[1].buf_len = 255;
    if (SS$_NORMAL==SYS$TRNLNM(&no_case,&tabnam,&lname_desc,0,&item_str)) {
	text[buf_len] = '\0';
	if (strcmp(text,GSgetHost(ZeGopher))==0) {
	    /* Log this session */
	    text[sprintf(text," *-%.*s>",iLevel,
			"-------------------------------")]='\0';
	    trace_telnet(text,ZeGopher);
	    if(GDgetLocation(CurrentDir) != NULL) {
		text[sprintf(text," + %.*s ",iLevel,
			    "                               ")]='\0';
		trace_telnet(text,GDgetLocation(CurrentDir));
	    }
	    for (l = iLevel; l>0; l--) {
		text[sprintf(text," +%.*s>",l,
			"-------------------------------")]='\0';
		trace_telnet(text, GDgetEntry(OldDirs[l-1], 
				    GDgetCurrentItem(OldDirs[l-1])-1));
	    }
	    return;
	}
    }
  }
    return;
}
#endif


void
Gripe(GopherObj *gs)
{
     char *gripeprompt[15];
     char *gripemess[15];
     char *cp = NULL;
     char  email[128], version[128];
     int   i, j;
     char *mailargv[3];
     FileIO *fio;

#ifdef VMS
     char mailcmd[256],
     FILE *f;
     char MailAddress[512], *tmpfilename;
#endif

     GSgetginfo(gs, TRUE);

     if (GSisGplus(gs) && (GSgetAdmin(gs) != NULL))
	  cp = strchr(GSgetAdmin(gs),'<');

     /* at this point cp is NULL if (and hopefully only if)
      * the item is not Gopher+, there is no Admin for the item,
      * or there is no e-mail address in the admin definition 
      */
     if (cp == NULL) {

#ifdef LOCAL_GRIPE_ADMINISTRATOR
# ifdef DOMAIN_FOR_LOCAL_GRIPES
	  if (strstr(GSgetHost(gs),DOMAIN_FOR_LOCAL_GRIPES) != NULL )
# endif
	       cp = LOCAL_GRIPE_ADMINISTRATOR;
#endif

	  /* if the local gripe admin won't take it, either let the user
	   * edit it, or put up an error message
	   */
	  if (cp == NULL) {
#ifdef MODIFIABLE_GRIPE_TO
	       cp = "<>";
#else
	       CursesErrorMsg(
		 Gtxt("Can't find an administrator for this item, sorry!",48));
	       return;
#endif
	  }
     }

     strncpy(email, cp+1, sizeof(email));
     cp = strrchr(email, '>');
     if (cp != NULL)
	  *cp = '\0';

#define ACHARS "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789%.@!-_"
		    
     if (SecureMode || NoShellMode)
	  if ( strspn(email, ACHARS) != strlen(email)||
	      *email == '-') {
		  CursesErrorMsg("Can't find an administrator for this item, sorry!");
		  return;
	  }

     /** Empty out the array **/
     for (i=3; i< 15; i++) {
	  cp = (char *) malloc(sizeof(char) * COLS);
	  bzero(cp,COLS*sizeof(char));
	  gripeprompt[i] = "";
	  gripemess[i] = cp;
     }

     for (i=0; i < 3; i++)
	  gripemess[i] = NULL;

     

     gripeprompt[0] = Gtxt("Hit the Tab key at the end of each line you type.",49);
#ifdef CONTROLX
     gripeprompt[1] = Gtxt("Press Control-X to send your message.",50);
#else
     gripeprompt[1] = Gtxt("Hit the Enter key to send your message.",50);
#endif


#ifdef MODIFIABLE_GRIPE_TO
     gripeprompt[2] = Gtxt("To",230);
     gripemess[2] = email;
     gripeprompt[13] = Gtxt("<Last Line>",231);
#else
     gripeprompt[2] = "";
#endif
     gripeprompt[3] = Gtxt("Subject",51);
     gripeprompt[4] = Gtxt("Problem",52);
     gripeprompt[14] = NULL;

     if (CURRequest(CursesScreen, GSgetAdmin(gs), gripeprompt, gripemess)!=0) {
	  return;
     }
     if (strlen(gripemess[3]) == 0) {
	  CursesErrorMsg(Gtxt("Cannot send, no subject...",228));
	  return;
     }
     for (i=4, j=0; i<14; i++)
	  j += strlen(gripemess[i]);
     if (j < 20) {
	  CursesErrorMsg(Gtxt("Cannot send, message too small...",228));
	  return;
     }

#ifdef MODIFIABLE_GRIPE_TO
     if (strlen(strcpy(email,gripemess[2])) == 0) {
	CursesErrorMsg(Gtxt("Cannot send mail to null address...",228));
	return;
     }
#endif
#ifdef VMS
     if ((strchr(email, '@') != NULL) && (strchr(email, '\"') == NULL))
	   sprintf(MailAddress, MAIL_ADRS, email);
     else
	   strcpy(MailAddress, email);

     tmpfilename = tempnam(NULL,NULL);

     if ((f = fopen(tmpfilename, "w")) == NULL) {
	  CursesErrorMsg(Gtxt("Cannot send mail...",53));
	  return;
     }

     sprintf(mailcmd, "%s/subject=\"%.70s\" %s %s",
           MAIL_COMMAND, gripemess[3], tmpfilename, MailAddress);
     free(gripemess[3]);
#ifdef DESCRIBE_GOPHER_GRIPE
     fprintf(f, Gtxt("Regarding the following Gopher item:\n",229));
     describe_gopher(" ",
		    GDgetEntry(CurrentDir, GDgetCurrentItem(CurrentDir)-1),
			f);
     fprintf(f, "\n");
#endif
     for (i=14; i>3 && strlen(gripemess[i])==0; i--) {
	  free(gripemess[i]);
	  gripemess[i] = NULL;
     }

     for (i=4; (i< 15) && gripemess[i]; i++) {
	  fprintf(f, "%s\n", gripemess[i]);
	  free(gripemess[i]);
     }
     fprintf(f, "\n[Sent from within the ");
     fprintf(f, Gtxt("Internet Gopher Information Client v%s.%s.%d",102),
		GOPHER_MAJOR_VERSION, GOPHER_MINOR_VERSION, PATCHLEVEL);
     fprintf(f, "]\n");

     fclose(f);

     CURexit(CursesScreen);
     printf(Gtxt("Mailing gripe to %s...",54), MailAddress);
     FIOsystem(mailcmd);
     unlink(tmpfilename);
     free(tmpfilename);
     CURenter(CursesScreen);
#else

     mailargv[0] = MAIL_COMMAND;
     mailargv[1] = email;
     mailargv[2] = NULL;

     fio = FIOopenProcess(mailargv[0], mailargv, "w");

     if (fio == NULL) {
	  CursesErrorMsg(Gtxt("Cannot send mail...",53));
	  return;
     }

     *(gripemess[3] + 71) = '\0';
     FIOwritestring(fio, "Subject: ");
     FIOwritestring(fio, gripemess[3]);
     FIOwritestring(fio, "\n\n");

     free(gripemess[3]);

#ifdef DESCRIBE_GOPHER_GRIPE
    FIOwritestring(fio, Gtxt("Regarding the following Gopher item:\n",229));
    GStoLink(GDgetEntry(CurrentDir, GDgetCurrentItem(CurrentDir)-1),
	     FIOgetfd(fio), TRUE);
    FIOwritestring(fio, "\n");
#endif


     for (i=14; i>3 && strlen(gripemess[i])==0; i--) {
	    free(gripemess[i]);
	    gripemess[i] = NULL;
     }

     for (i=4; i< 15 && gripemess[i]; i++) {
	  FIOwritestring(fio, gripemess[i]);
	  FIOwritestring(fio, "\n");
	  free(gripemess[i]);
     }

     FIOwritestring(fio, "\n[Sent from within the ");
     sprintf(version, Gtxt("Internet Gopher Information Client v%s.%s.%d",102),
	     GOPHER_MAJOR_VERSION, GOPHER_MINOR_VERSION, PATCHLEVEL);
     FIOwritestring(fio, version);
     FIOwritestring(fio, "]\n");

     FIOclose(fio);
#endif
}

/*
** do_index gets keywords from the user to search for.  It returns
** it to the calling process.  This storage is volotile. Callers should
** make a copy if they want to call do_index multiple times.
*/

char* do_index(GopherObj *ZeGopher)
{
     static char *inputline = NULL;
     static char *prompt[2];
     static char *response[2];

     if (inputline == NULL) {
	  inputline = (char *) malloc(sizeof(char)*256);
	  if (inputline == NULL)
	       perror("Out of memory"), CleanupandExit(-1);
	  *inputline = '\0';
     }

     prompt[0] = Gtxt("Words to search for",55);
     prompt[1] = NULL;

     response[0] = inputline;
     response[1] = NULL;

     if (CURRequest(CursesScreen, GSgetTitle(ZeGopher),prompt, response) == -1 )
	  return(NULL);

     if (*inputline == '\0')
	  return(NULL);
     else
	  return(inputline);
}


/*
 * this procedure just retrieves binary data from the socket and
 * pumps it into a "play" process.
 */

#define BUFSIZE 1400  /* A pretty good value for ethernet */

#ifndef VMS
void
suck_sound(int sockfd)
{
     FileIO *Play;
     int j;
     char buf[BUFSIZE];
     char playCmd[BUFSIZE];

     if (!RCdisplayCommand(GlobalRC, "Audio/basic", "", playCmd) ||
         !strncasecmp(playCmd, "- none -", 8) ||
	 playCmd == NULL || playCmd[0] == '\0') {
	  /*** Hey! no play command, bummer ***/
	  /** We're forked at this point, and we can't display anything.. **/
	  /*	  CursesErrorMsg(Gtxt("Sorry, this machine doesn't support sounds",159));*/

	  return;
     }
     
     Play = FIOopenCmdline(playCmd, "w");

     
     while(1) {
          j = read(sockfd, buf, BUFSIZE);
	  
	  if (j == 0)
	       break;
	  
	  FIOwriten(Play, buf, j);
     }
}
#endif

/*
 * fork off a sound process to siphon the data across the net.
 * So the user can listen to tunage while browsing the directories.
 */

void
do_sound(GopherStruct *ZeGopher)
{
#ifdef VMS
     CursesErrorMsg(Gtxt("Sorry, this machine doesn't support sounds",159));
#else
     int sockfd;
     BOOLEAN Waitforchld = FALSE;

     if ((sockfd = GSconnect(ZeGopher)) <0) {
	  check_sock(sockfd, GSgetHost(ZeGopher), GSgetPort(ZeGopher));
	  return;
     }

     /** Send out the request **/
     GStransmit(ZeGopher, sockfd, NULL, NULL, NULL);
     
     /** Okay, it's cool, we can fork off **/

     if (SOUNDCHILD != 0)
	  Waitforchld = TRUE;

     if ( (SOUNDCHILD = fork()) < 0)
	  ;/* Fork Error */
     
     else if (SOUNDCHILD == 0) {  /* Child Process */
	  suck_sound(sockfd);
	  exit(0);
     }
     
     /* Parent Process */
     
     closenet(sockfd);
     return;
#endif  /* not VMS */
}




/**
*** Show file takes a gopher text thing, writes it to a file
*** and passes it to your favorite pager.
**/

void
showfile(GopherObj *ZeGopher)
{
     char    *tmpfilename = NULL;
     FILE    *tmpfile;
     char    inputline[512];
     char    *view = NULL;
     char    mkstemp_template[] = "/tmp/gopher-XXXXXX";
     int     mkstemp_fd = -1;
     boolean WritePipe = FALSE,
             ForkOff   = FALSE;
     boolean GS2FileSucceeded = TRUE;
     int     Child;

     DebugGSplusPrint(ZeGopher, "showfile:start");

     view = Choose_View(ZeGopher);

     Debug("showfile:Choose_View returned view=%s\n",view);

     if ((view == NULL) || (*view == '\0'))
	  return;

     if (!RCdisplayCommand(GlobalRC, view, "", inputline) ||
         !strncasecmp(inputline, "- none -", 8) ||
	 inputline == NULL || inputline[0] == '\0') {
          CursesErrorMsg(Gtxt("No display command is mapped to this view!",113));
	  return;
     }
     Debug("showfile:inputline=%s\n",inputline);

     if (GSgetLocalFile(ZeGopher) == NULL ||
	 GSgetLocalView(ZeGopher) == NULL ||
	 strcmp(GSgetLocalView(ZeGopher), view)!= 0) {
	  /*** We need to retrieve the file ***/

	  if (*inputline == '|') {
#ifdef VMS
	       CursesErrorMsg(Gtxt("Unix piping requested.  Check your configuration!",176));
	       return;
#endif
	       if ((tmpfile = popen(inputline+1, "w")) == NULL) {
                   char buf[75];
                   snprintf(buf, sizeof(buf) - 1,
                            Gtxt("Coultn't execute %s", 81), inputline);
                   CursesErrorMsg(buf);
                   return;
               }
	       WritePipe = TRUE;
	       CURexit(CursesScreen);
	  } else {
	       /** Open a temporary file **/
#ifdef VMS
	       tmpfilename = tempnam(NULL,NULL);
#else /* !VMS */
#ifdef HAVE_MKSTEMP
               mkstemp_fd = mkstemp(mkstemp_template);
               tmpfilename = strdup(mkstemp_template);
               tmpfile = fdopen(mkstemp_fd, "w");
#else  /* ! HAVE_MKSTEMP */
	       tmpfilename = tempnam("/tmp","gopher");
               tmpfile = fopen(tmpfilename, "w");
#endif /* HAVE_MKSTEMP */
#endif /* VMS */

#if defined(VMS)  && defined(VMSRecords)
	       if (GSisText(ZeGopher, view))
		    /*** Use VARIABLE length records for text on VMS ***/
		    tmpfile = fopen_VAR(tmpfilename, "w");
	       else
		    /*** Use FIXED 512 records for binaries on VMS ***/
	            tmpfile = fopen_FIX(tmpfilename, "w");
#endif      /* VMS */
	       if (tmpfile == NULL) {
		    CURexit(CursesScreen);
		    fprintf(stderr, Gtxt("Couldn't make a tmp file!\n",83)), 
		    CleanupandExit(-1);
	       }
	       if (GSgetLocalFile(ZeGopher) != NULL &&
		   GSgetLocalView(ZeGopher) != NULL &&
		   strcmp(GSgetLocalView(ZeGopher), view) != 0)
		    unlink(GSgetLocalFile(ZeGopher));
	       GSsetLocalFile(ZeGopher, tmpfilename);
	  } /* | */
	  
	  if (inputline[strlen(inputline)-1] == '&') {
	       inputline[strlen(inputline)-1] = '\0';
	       ForkOff = TRUE;
	  }

#ifndef VMS
	  /* This is the child process, so exit.. */
	  if (ForkOff) {
	       if ((Child = fork()) < 0) {
		    ;/** Fork Error ***/
		    CursesErrorMsg("Fork Error!");
	       }
	       else if (Child >0) {
		    /*** Parent Process ***/
		    ;
		    CURenter(CursesScreen);
		    return;
	       }
	  }  /* Forkoff */
#endif
	  
 	  Debug("\n\rshowfile: view=%s ",view);
 	  Debug("\n\rcommand=%s ",inputline);
 	  Debug("\n\rfile=%s",tmpfilename);
 	  Debug("\n\r/%s\n",GSgetLocalFile(ZeGopher));
	  
	  GS2FileSucceeded = GStoFile(ZeGopher, tmpfile, view, twirl);

	  if (!GS2FileSucceeded) {
	       GSsetLocalFile(ZeGopher, NULL);
	       GSsetLocalView(ZeGopher, NULL);
	  }
	  else
	       GSsetLocalView(ZeGopher, view);


	  if (WritePipe)
	       pclose(tmpfile);  /* data went down pipe - displayed there */
	  else
	       fclose(tmpfile);  /* data is in tmpfile, will display below */

     } /* GopehrPluss || LocalFile = NULL */

     logrequest("ARRIVED AT", ZeGopher);

     if (!WritePipe && GS2FileSucceeded)
	  GSdisplay(ZeGopher);
     if (!GS2FileSucceeded)
          unlink(tmpfilename);

/*     if (!ForkOff) {
	  printf("\nPress <RETURN> to continue: ");
	  fflush(stdin);
	  fflush(stdin);
	  getchar();
	  CURenter(CursesScreen);
     }*/


     if (tmpfilename!=NULL) free(tmpfilename);

     if (ForkOff)
	  exit(-1);

     CURenter(CursesScreen);
     return;
}


/*
 * Eventually this routine should allow viewing of the movie type by
 * forking off a movie process to siphon the data across the net.
 */

void
do_movie(GopherStruct *ZeGopher)
{
     showfile(ZeGopher);
}


/*
** Pushgopher takes a GopherThing pointer and adds it to it's stack.
**
** Ick this must be fixed!
*/

void
pushgopher(GopherDirObj *ZeDir)
{

     OldDirs[iLevel]= ZeDir;
     iLevel ++;
}

/*
** If the stack is empty, popgopher returns a -1
*/

int
popgopher(GopherDirObj **ZeDir)
{

     if (iLevel == 0)
	  return(-1);

     iLevel --;

     *ZeDir =  OldDirs[iLevel];

     return(0);
}


#ifdef VMS
#include <perror.h>
#else
extern int h_errno;
#ifndef HAVE_STRERROR
extern int sys_nerr;
extern char *sys_errlist[];
#endif
extern int  errno;
#endif

void check_sock(int sockfd, char *host, int port)
{
     char DispString[WHOLELINE];
     char DispString2[WHOLELINE];
     char *DispStrings[4];

     /* NULL DispStrings entries here, so can override below */
     DispStrings[3] = NULL;

     if (sockfd <0) {
	  sprintf(DispString, 
		  Gtxt("Cannot connect to host %.40s, port %d.",72), 
		  host, port);

	  switch (sockfd) {
	  case -2:
	       DispStrings[2] = Gtxt("Hostname is unknown.",100);
	       break;
	  case -3:
	       DispStrings[2] = Gtxt("Unable to allocate a socket.",175);
	       break;
	  case -4:
#if defined(VMS) && defined(MULTINET)
	       sprintf(DispString2, "%.78s.", vms_errno_string());
	       DispStrings[2] = DispString2;
#else
#ifdef __DECC
	       if (errno > 0 && errno <= 65) {
#else
#ifdef HAVE_STRERROR
               if (1) {
#else
	       if (errno > 0 && errno <= sys_nerr) {
#endif
#endif
		    sprintf(DispString2, Gtxt("Connection failed: %s.",78),
#if defined(VMS) || defined(HAVE_STRERROR)
			    strerror(errno));
#else
		    sys_errlist[errno]);
#endif
	            DispStrings[2] = DispString2;
	       } else
		    DispStrings[2] = 
			 Gtxt("Connection to remote host failed.",79);
#endif

	  default:
	       DispStrings[2] = Gtxt("Unknown error.",177);
	  }
	  DispStrings[0] = DispString;
	  DispStrings[1] = "";
          DispStrings[3] = NULL;
      
          CURBeep(CursesScreen);

	  CURDialog(CursesScreen, Gtxt("Network Error",110), DispStrings);
     }
}


BOOLEAN
ReallyQuit(void)
{
     char yesno[3];
	       
     yesno[0] = 'y';
     yesno[1] = '\0';
     
     CURgetYesorNo(CursesScreen, Gtxt("Really quit (y/n) ?",124), yesno);
     if (*yesno == 'y') {
	  return(TRUE);
     }
     
     return(FALSE);
}
     

RETSIGTYPE
CleanupandExit(int exitval)
{
     GopherDirObj *gd;
#ifdef VMS
     extern boolean DidCleanup;
#endif

#ifdef SIGWINCH
     signal(SIGWINCH, SIG_IGN);
#endif
     signal(SIGINT, SIG_IGN);
     signal(SIGQUIT, SIG_IGN);
     signal(SIGPIPE, SIG_IGN);
     signal(SIGTERM, SIG_IGN);
     signal(SIGHUP, SIG_IGN);


     if (CursesScreen)
	  CURexit(CursesScreen);

     if (ChangedDefs)
	  RCtoFile(GlobalRC);

     do {
	  if (CurrentDir != NULL && CurrentDir != RCgetBookmarkDir(GlobalRC))
	       GDdestroy(CurrentDir);
     }
     while (popgopher(&CurrentDir) != -1);
     
     if (GlobalRC) {
	  gd = RCgetBookmarkDir(GlobalRC);
	  if (gd != NULL)
	       GDdestroy(gd);
     }
     logrequest("EXIT", NULL);
#ifdef VMS
     DidCleanup = TRUE;
#endif
     exit(exitval);
}



/**************
** This bit of code catches control-c's, it cleans up the curses stuff.
*/

RETSIGTYPE
controlc_old(int sig)
{

#ifdef VMS
     if (!CursesScreen->inCurses) {
          /** Reprime the signal and set flag **/
          if (signal(SIGINT, controlc) == SIG_ERR)
	       perror("signal died:\n"), CleanupandExit(-1);
 	  HadVMSInt = TRUE;
          return;
     }
#endif

     if (CurrentDir == NULL || GDgetNumitems(CurrentDir) <= 0) {
          CURexit(CursesScreen);
	  fprintf(stderr,Gtxt("gopher: Nothing received for main menu, can't continue\n",60));
	  CleanupandExit(1);
     }

     if (ReallyQuit())
     {
	  CleanupandExit(0);
     }
     else {
	  CURresize(CursesScreen);
	  /* scline(-1, 1, CurrentDir); */
	  /** Interrupt search, go back a level?? **/
     }

     /*
      * Reprime the signals...
      */

     if (signal(SIGINT, controlc) == SIG_ERR)
	  perror("signal died:\n"), CleanupandExit(-1);


     /** Really should be siglongjmp **/
     longjmp(Jmpenv,1);
}


/**************
** This bit of code catches window size change signals
**/

RETSIGTYPE
sizechange(int sig)
{
     int lines, cols;
     
#ifdef  TIOCGWINSZ
     static struct      winsize zewinsize;        /* 4.3 BSD window sizing */
#endif

     lines = LINES;
     cols  = COLS;
     
#ifdef  TIOCGWINSZ
     if (ioctl(0, TIOCGWINSZ, (char *) &zewinsize) == 0) {
	  lines = zewinsize.ws_row;
	  cols  = zewinsize.ws_col;
     } else {
#endif
	  /* code here to use sizes from termcap/terminfo, not yet... */
	  ;
#ifdef  TIOCGWINSZ
     }

     if (lines != LINES || cols != COLS) {
	  LINES = lines;
	  COLS  = cols;
	  CURresize(CursesScreen);
     
	  scline(-1, 1, CurrentDir);
     }

     if (signal(SIGWINCH, sizechange)==SIG_ERR)
	  perror("signal died:\n"), CleanupandExit(-1);

	    
#endif

}



/**********
**
** Set up all the global variables.
**
***********/

void
Initialize(void)
{

     Debugmsg("Initialize\n")
     GlobalRC        = RCnew();

     /** get defaults from the rc file **/

     RCfromUser(GlobalRC);


     /*** Set up the curses environment ***/
     
     CursesScreen = CURnew();

     if (strcmp(CURgetTerm(CursesScreen), "unknown")==0)
	  fprintf(stderr, Gtxt("I don't understand your terminal type\n",101)), 
	  CleanupandExit(-1);


     /*** Make a signal handler for window size changes ***/

#ifdef SIGWINCH
     CURsetSIGWINCH(CursesScreen, sizechange);
     if (signal(SIGWINCH, sizechange)==SIG_ERR)
	  perror("signal died:\n"), 
	  CleanupandExit(-1);

#endif

     if (signal(SIGINT, controlc) == SIG_ERR)
	  perror("signal died:\n"), 
	  CleanupandExit(-1);

     if (signal(SIGQUIT, CleanupandExit) == SIG_ERR)
	  perror("signal died:\n"),
	  CleanupandExit(-1);

     if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
	  perror("signal died:\n"), 
	  CleanupandExit(-1);

     if (signal(SIGTERM, CleanupandExit) == SIG_ERR)
	  perror("signal died:\n"),
	  CleanupandExit(-1);

     if (signal(SIGHUP, CleanupandExit) == SIG_ERR)
	  perror("signal died:\n"),
	  CleanupandExit(-1);

       

     /*** Init MainWindow ****/
     CURenter(CursesScreen);


     /*** Check for new global configuration file ***/
     if (RCisGlobalNew()) {
	  int result;
	  char *mess[2];
	  mess[0] =  Gtxt("A new configuration is available.  Load it?",218);
	  mess[1] = NULL;

	  /*** Ask if the user wants to reload values from globalrc ***/
	  result = CURDialog(CursesScreen, "", mess);

	  if (result == 0) {
	       /*** Do it...  ****/
	       RCreadGlobalRC(GlobalRC);
	  }
	  ChangedDefs = TRUE;
	       
     }
}



/*
 * This stuff will set the options in a nice way...
 */

void
SetOptions(void)
{
     int choice, restricted = FALSE;
     char     *shell;

     static char **OptionNewApp = NULL, **OptionsMenu = NULL;
     static char **noyes = NULL;
     static char **printchoice = NULL;

     if (OptionNewApp == NULL) {
	  OptionNewApp = (char**) malloc(sizeof(char*) * 4);
	  OptionNewApp[0] = Gtxt("Content-Type Name",27);
	  OptionNewApp[1] = Gtxt("Display Application",28);
	  OptionNewApp[2] = Gtxt("Printing Application",29),
	  OptionNewApp[3] = NULL;
     }

     if (OptionsMenu == NULL) {
	  OptionsMenu = (char **) malloc(sizeof(char*) * 5);
	  OptionsMenu[0] = Gtxt("General Options",30);
	  OptionsMenu[1] = Gtxt("Configure Display Applications",31);
	  OptionsMenu[2] = Gtxt("Configure Printing Applications",32);
	  OptionsMenu[3] = Gtxt("Define New Content-Type",33);
	  OptionsMenu[4] = NULL;
     }
     if (noyes == NULL) {
	  noyes = (char**) malloc(sizeof(char*) * 3);
	  noyes[0] = Gtxt("No",111);
	  noyes[1] = Gtxt("Yes",180);
	  noyes[2] = NULL;
     }
     if (printchoice == NULL) {
	  printchoice = (char**) malloc(sizeof(char*) * 3);
	  printchoice[0] = Gtxt("Default System Printer", 219);
	  printchoice[1] = Gtxt("ANSI attached Printer", 220);
	  printchoice[2] = NULL;
     }

     /*
      * If the user is running a restricted shell, don't allow him/her to
      * set applications, because he/she can specify a shell.  This is
      * independent of -s and -S because rsh users may have a shell.
      */
#ifndef VMS
     restricted = (shell = getenv("SHELL")) == NULL
	  || strcmp(shell+strlen(shell) - 3, "rsh") == 0;
     
#endif

     if (SecureMode || NoShellMode || restricted) {
	  CursesErrorMsg(Gtxt("Sorry, you are not allowed to set options in secure mode.",163));
	  return;
     }

     /** Display Configuration Menu and allow user to choose **/
     choice = CURChoice(CursesScreen, Gtxt("Gopher Options",94), OptionsMenu,
			Gtxt("Your Choice",181), -1);

     if (choice == -1)
	  return;

     switch (choice) {

     case 0:
     {
	  /** General Options **/
	  
	  Requestitem *items[3];
	  Requestitem bold;
	  Requestitem printer;
	  
	  bold.prompt  = Gtxt("Bold Search words in Builtin Pager",66);
	  bold.thing   = CUR_CHOICE;
	  bold.choices = noyes;
	  bold.chooseitem = RCsearchBolding(GlobalRC);

	  printer.prompt  = Gtxt("Print to",221);
	  printer.thing   = CUR_CHOICE;
	  printer.choices = printchoice;
	  printer.chooseitem = RCuseANSIprinter(GlobalRC);


	  items[0] = &bold;
	  items[1] = &printer;
	  items[2] = NULL;

	  if (CURrequester(CursesScreen, Gtxt("General Options",30), items)==0) {
	       RCsetSearchBolding(GlobalRC, items[0]->chooseitem);
	       RCsetANSIprinter(GlobalRC,  items[1]->chooseitem);
	       ChangedDefs = TRUE;
	  }

	  break;
     }

     case 1:
     case 2:
     {
	  /** Display/Print Applications **/

	  char     **gplusviews;
	  int      i;
	  int      numoptions;
	  RCMapObj *rcm;
	  char     **Responses;
	  char     *zetitle;

	  numoptions = RCMAgetNumEntries(GlobalRC->commands);
	  gplusviews = (char **) malloc(sizeof(char *) * (numoptions + 1));
	  Responses = (char **) malloc(sizeof(char *) * (numoptions + 1));

	  for (i = 0 ; i < numoptions; i++) {
	       rcm = RCMAgetEntry(GlobalRC->commands, i);
	       gplusviews[i] = RCMgetView(rcm);
	       Responses[i] = (char *) malloc(sizeof(char) * MAXSTR);
	       if (choice == 1)
		    strcpy(Responses[i], RCMgetDisplaycmd(rcm));
	       else
		    strcpy(Responses[i], RCMgetPrintcmd(rcm));
	  }
	  gplusviews[i] = NULL;
	  Responses[i] = NULL;

	  if (choice == 1)
	       zetitle = Gtxt("Configure Display Applications",31);
	  else
	       zetitle = Gtxt("Configure Printing Applications",32);

	  if (CURRequest(CursesScreen, zetitle, gplusviews, 
			 Responses) == 0) {
	       char tmpstr[512];
	       
	       while (i-- > 0) {
		    rcm = RCMAgetEntry(GlobalRC->commands, i);
		    if (choice == 1)
			 /** Display Applications **/
			 sprintf(tmpstr, "%s,%s,%s", gplusviews[i], 
				 Responses[i], RCMgetPrintcmd(rcm));
		    else
			 /** Print Applications **/
			 sprintf(tmpstr, "%s,%s,%s", gplusviews[i], 
				 RCMgetDisplaycmd(rcm), Responses[i]);
			 
		    RCMAfromLine(GlobalRC->commands, tmpstr);
	       }
	       ChangedDefs = TRUE;
	  }

	  for (i = 0 ; i <= numoptions; i++)
	       if (Responses[i])
		    free(Responses[i]);
	  free(Responses);
	  free(gplusviews);

	  break;
     }

     case 3:
     {
	  /** Add a new Content-Type and define **/
	  /** its Display and Printing applications **/
	  
	  int  i;
	  char *Responses[4];

	  for (i = 0; i < 3; i++) {
	       Responses[i] = (char *) malloc(sizeof(char) * MAXSTR);
	       Responses[i][0] = '\0';
	  }
	  Responses[3] = NULL;
	  
	  if ((CURRequest(CursesScreen, Gtxt("Define New Content-Type",33), 
	       OptionNewApp, Responses) == 0) && (*Responses[0] != '\0')) {
	       char tmpstr[512];
	       
	       sprintf(tmpstr, "%s,%s,%s", Responses[0], Responses[1],
		       Responses[2]);
	       RCMAfromLine(GlobalRC->commands, tmpstr);
	       ChangedDefs = TRUE;
	  }

	  for (i = 0; i < 3; i++)
	       free(Responses[i]);
          break;
     }

     }  /** End of switch on option type **/
}



static char *search_string = NULL;

int
main(int argc, char **argv)
{
     BOOLEAN bDone = FALSE;
     char sTmp[80];
     GopherStruct *RootGophers[2];
     int numhosts = 2;
     int TypedChar;
     /*** for getopt processing ***/
     int c;
     extern char *optarg;
     extern int optind;
     int errflag =0, i;
     int curitem;
     int Garbled = TRUE;
     
     boolean Bkmarksfirst = TRUE;
     boolean startAtHome = FALSE;
     
     /*** Initialize international languages ***/
     Gtxtlocale(LC_ALL, "");


#if defined(GINTERNATIONAL) && !defined(VMS)

#ifdef LC_CTYPE
     Gtxtlocale(LC_CTYPE, "iso_8859_1");
#endif

#ifdef LC_MESSAGES
     if (getenv("LC_MESSAGES") != NULL)
	 Gtxtlocale(LC_MESSAGES, getenv("LC_MESSAGES"));
#endif /* LC_MESSAGES */

#ifndef __osf__
     Gtxtopen("gopher", 0);  /** OSF seems to mess this up... **/
#endif

     if (Gcatd == (nl_catd) -1) {
	  /** Try finding it elsewhere.. **/
	  char fname[256];
	  if (getenv("LC_MESSAGES") != NULL) {
	       sprintf(fname, "%s/gophernls/%s.cat", GOPHERLIB, getenv("LC_MESSAGES"));
	       Gtxtopen(fname, 0);
	  }
     }
#endif	  /* GINTERNATIONAL & !VMS */

#ifdef VMS
     argv[0] = "gopher";
#endif

     for (i=0; i<2; i++) {
	  RootGophers[i] = GSnew();
	  GSsetType (RootGophers[i], A_DIRECTORY);   
	  GSsetPath (RootGophers[i],"");
	  GSsetGplus(RootGophers[i], TRUE);
     }
     
     /** Should generalize this to >2 hosts .... Sigh... ***/
     GSsetHost (RootGophers[0], CLIENT1_HOST);
     GSsetPath (RootGophers[0], CLIENT1_PATH);
     GSsetPort (RootGophers[0], CLIENT1_PORT);

     GSsetHost (RootGophers[1], CLIENT2_HOST);
     GSsetHost (RootGophers[1], CLIENT2_PATH);
     GSsetPort (RootGophers[1], CLIENT2_PORT);

     if (CLIENT2_PORT == 0)
	  numhosts = 1;

     sTmp[0] = '\0';

     while ((c = getopt(argc, argv, "DsSbrp:t:T:i:")) != -1)
	  switch (c) {
	  case 's':
	       SecureMode = TRUE;
	       break;
	  case 'S':	/* Similar to secure, but assumes own Unix account */
			/* No change in behaviour if this not set */
		NoShellMode = TRUE;
		break;
	  case 'i':
	       search_string = optarg;
	       break;

	  case 'p':
	       GSsetPath(RootGophers[0], optarg);
	       GSsetPath(RootGophers[1], optarg);
	       GSsetGplus(RootGophers[0], FALSE);
	       GSsetGplus(RootGophers[1], FALSE);

	       startAtHome = FALSE;
	       Bkmarksfirst = FALSE;
	       break;
	  case 'T':
	       GSsetType(RootGophers[0], *optarg);
	       GSsetType(RootGophers[1], *optarg);
	       if (optarg[1] == '+') {
		    GSsetGplus(RootGophers[0], TRUE);
		    GSsetGplus(RootGophers[1], TRUE);
	       } else if (optarg[1] == '?') {
		    GSsetAsk(RootGophers[0], TRUE);
		    GSsetAsk(RootGophers[1], TRUE);
	       }
	       startAtHome = FALSE;
	       break;
	  case 't':
	       GSsetTitle(RootGophers[0], optarg);
	       GSsetTitle(RootGophers[1], optarg);
	       break;
	  case 'D':
	       DEBUG = TRUE;
	       Debugmsg("gopher starting - debug on\n")
	       break;
	  case 'r':
	       RemoteUser = TRUE;
	       break;
	  case 'b':
	       Bkmarksfirst = TRUE;
	       break;
	  case '?':
	       errflag++;
	  }


     if (errflag) {
	  
	  fprintf(stderr, Gtxt("Internet Gopher Information Client v%s.%s.%d\n",8),
		GOPHER_MAJOR_VERSION, GOPHER_MINOR_VERSION, PATCHLEVEL);
	  
	  fprintf(stderr, Gtxt("Usage: %s [-sSbDr] [-T type] [-p path] [-t title] [hostname port]+\n",9), argv[0]);
	  fprintf(stderr, 
	    Gtxt("     -s      secure mode, users without own account\n",10));
	  fprintf(stderr,
	    Gtxt("     -S      secure mode, users with own account\n",11));
	  fprintf(stderr,
	    Gtxt("     -p path specify path to initial item\n",12));
	  fprintf(stderr,
            Gtxt("     -T type Type of initial item\n",13));
	  fprintf(stderr,
            Gtxt("     -i      Search argument (for -T 7)\n",14));
	  fprintf(stderr, 
	    Gtxt("     -b      Bookmarks first\n",15));
	  fprintf(stderr,
            Gtxt("     -r      Remote user\n",16));
	  fprintf(stderr, 
	    Gtxt("     -D      Debug mode\n",17));
	  CleanupandExit(-1);
     }

     /**** Get host #1 from the command line ****/
     
     if (optind < argc) {

	  if (strchr(argv[optind], ':') != NULL) {
	       startAtHome = TRUE;
	       GopherObj *tempGopher = GSnew();
	       int doneflags = 0;

	       doneflags = GSfromURL(tempGopher, argv[optind],
	       			     AFTP_HOST, AFTP_PORT, doneflags);
	       GScpy(RootGophers[0], tempGopher);
	       GScpy(RootGophers[1], tempGopher);
	       GSdestroy(tempGopher);
	       startAtHome = FALSE;
	       Bkmarksfirst = FALSE;
	       optind++;
	  } else {
    	       startAtHome = TRUE; 
	       GSsetPort(RootGophers[0], 70);  /* Just in case the default */
	       GSsetPort(RootGophers[1], 70);  /* isn't 70 */
	       
               /* Restore blank path if a host was specified but -p was not */

	       if (startAtHome)
	           GSsetPath(RootGophers[0], "");

	       GSsetHost(RootGophers[0], argv[optind]);
	       GSsetHost(RootGophers[1], "");  /** Nuke the 2nd alternative host **/
	       GSsetPort(RootGophers[1], 0);
	       numhosts = 1;
	       startAtHome = FALSE;
	       Bkmarksfirst = FALSE;
	       optind++;
	  }
     }
     if (optind < argc) {
	  GSsetPort(RootGophers[0], atoi(argv[optind]));
	  optind++;
     }

     /*** Get host #2 from the command line... ***/
     if (optind < argc) {
	  GSsetHost(RootGophers[1], argv[optind]);
	  numhosts = 2;
	  optind++;
     }
     if (optind < argc) {
	  GSsetPort(RootGophers[1], atoi(argv[optind]));
	  optind++;
     }

     /*** If the title hasn't been set, then add a default title **/
     if (GSgetTitle(RootGophers[0]) == NULL) {
	  sprintf(sTmp, Gtxt("Home Gopher server: %.59s",97),
		  GSgetHost(RootGophers[0]));
	  GSsetTitle(RootGophers[0], sTmp);
	  sprintf(sTmp, Gtxt("Home Gopher server: %.59s",97),
		  GSgetHost(RootGophers[1]));
	  GSsetTitle(RootGophers[1], sTmp);
     }

     /*** Set up global variables, etc. ***/

#ifdef SOCKS
     SOCKSinit(argv[0]);
#endif

     Initialize();

     if (startAtHome && (RCgetHome(GlobalRC) != NULL)) {
	  GScpy(RootGophers[0], RCgetHome(GlobalRC));
	  GScpy(RootGophers[1], RCgetHome(GlobalRC));
     }

     if (Bkmarksfirst) {
	  CurrentDir = RCgetBookmarkDir(GlobalRC);
	  
     } else {
	  int rnum;

	  srand(time(NULL));
	  rnum = rand() % numhosts;
	  process_request(RootGophers[rnum]);

          /* just process the command line entry */
          if( GSgetType(RootGophers[0]) != A_DIRECTORY &&
	      GSgetType(RootGophers[0]) != A_INDEX) {
	       refresh();
	       if( GSgetLocalFile(RootGophers[0]) != NULL)
	           unlink(GSgetLocalFile(RootGophers[0]));
	       CleanupandExit(0);
          }
     }

#ifdef DEBUGGING
	if (CurrentDir == NULL)  {
	     Debugmsg("CurrentDir=NULL\n");
	}
	else
	     if (GDgetNumitems(CurrentDir) <=0) {
		  Debugmsg("GDgetNumitems<=0\n");
	     }
#endif

     if (CurrentDir == NULL || GDgetNumitems(CurrentDir) <= 0) {
	  /*
	   * We didn't get anything from that gopher server.  Either
	   * it is down, doesn't exist, or is empty or otherwise
	   * busted.
           *
           * Try any alternative hosts that are available..
	   */

	  while (optind < argc && CurrentDir == NULL) {
	       Debugmsg("Trying alternate site\n");
	       GSsetHost(RootGophers[0], argv[optind]);
	       optind++;
		   if (optind < argc) {
			   GSsetPort(RootGophers[0], atoi(argv[optind]));
			   optind++;
		   }
	       process_request(RootGophers[0]);
	  }
     }	  

     if (CurrentDir == NULL || GDgetNumitems(CurrentDir) <= 0) {
#ifdef DEBUGGING
	if (CurrentDir == NULL)  {
	     Debugmsg("B: CurrentDir=NULL\n");
	}
	else if (GDgetNumitems(CurrentDir) <=0) {
	     Debugmsg("B: GDgetNumitems<=0\n");
	}
#endif	

	CURexit(CursesScreen);
	fprintf(stderr,
		Gtxt("%s: Nothing received for main menu, can't continue\n",188)
		, argv[0]);
	CleanupandExit(1);
   }

     while (bDone == FALSE)
     {
	  GetMenu(CurrentDir, &TypedChar, Garbled);
	  Garbled = TRUE;
#ifdef DESCRIBE_GOPHER
#undef DESCRIBE_GOPHER
#endif
#ifdef DESCRIBE_GOPHER_GRIPE
#define	DESCRIBE_GOPHER(a,b)	describe_gopher((a),(b), NULL)
#else
#define	DESCRIBE_GOPHER(a,b)	describe_gopher((a),(b))
#endif

	  switch(TypedChar)
	  {
	  case '\r':
	  case '\n':
	       /*** Select the designated item ***/
	       if ((curitem = GDgetCurrentItem(CurrentDir)) <= 0)
			   curitem = 1;
	       if (process_request(GDgetEntry(CurrentDir, curitem-1))==1)
		    ;  /** Don't do anything if we failed, I guess **/
#if defined(VMS) && defined(A_LANGUAGE)
	       if (CurrentDir == setlocale_LangDir) {
		    sprintf(sTmp, Gtxt("Home Gopher server: %.59s",97),
		    GSgetHost(RootGophers[0]));
		    GDsetTitle(OldDirs[0], sTmp);
		    GSsetTitle(RootGophers[0], sTmp);
		    Garbled = TRUE;
		    goto Backup_Resetlocale;
	       }		    
#endif
	       break;
	       
	  case '\0':
	       /*** What the heck? ***/
	       CursesErrorMsg("Strange Error occurred!");
	       break;
	       
	  case 'u':
	  case 'U': 
#ifdef AUTOEXITONU
	  case 'q':
#endif
#if defined(VMS) && defined(A_LANGUAGE)
	  Backup_Resetlocale:
#endif
	  {
	       GopherDirObj *tempGdir;

	       logrequest("PREVIOUS DIRECTORY", NULL);

	       /*** Don't highlight texts which aren't search hits ***/
	       Searchstring = NULL;

	       /*** Go up a directory level ***/
	       tempGdir = CurrentDir;
	       /** Don't destroy root level directory, or bookmarks **/
	       if (popgopher(&CurrentDir)==0 && tempGdir != CurrentDir) {
		    if (tempGdir != RCgetBookmarkDir(GlobalRC))
#if defined(VMS) && defined(A_LANGUAGE)
		      if (tempGdir != setlocale_LangDir)
#endif
			 GDdestroy(tempGdir);
#ifdef AUTOEXITONU
	       } else {
	       		bDone = TRUE;
	       		CURexit(CursesScreen);
#else
	       } else {
		    Garbled = FALSE;
#endif
	       }
	  }
	       break;

	  case 'g':
	       /*** Gripe! ***/
#ifdef NOGRIPE_SECURE
	       if (SecureMode || NoShellMode) {
		    CursesErrorMsg(Gtxt
				   ("Sorry, can't submit gripes in securemode",
							227));
		    break;
	       }
#endif
	       Gripe(GDgetEntry(CurrentDir,GDgetCurrentItem(CurrentDir)-1));
	       break;

	  case 's':  /*** Save a file directly ***/
	       if (SecureMode || NoShellMode) {
		    CursesErrorMsg(Gtxt("Sorry, can't save files with this account",152));
		    break;
	       }
	       Save_file(GDgetEntry(CurrentDir,GDgetCurrentItem(CurrentDir)-1), NULL, NULL);
	       break;
	       
          case 'S':   /*** Save list of menu items (objects) to a file ***/
	       if (SecureMode || NoShellMode) {
		    CursesErrorMsg(Gtxt("Sorry, can't save files with this account",152));
		    break;
	       }
	       Save_list(CurrentDir);
	       break;
	       
	  case 'D':
	       Download_file(GDgetEntry(CurrentDir,GDgetCurrentItem(CurrentDir)-1));
	       break;

	  case 'o': /** Open a new session **/
	  {
	       GopherObj *tempgs = GSnew();
	       char *prompts[4];
	       char *responses[4];
	       int i;

	       if (SecureMode) {
		    CursesErrorMsg(Gtxt("Sorry, you're not allowed to do this",164));
		    break;
	       }

	       prompts[0]=Gtxt("Hostname",99);
	       prompts[1]=Gtxt("Port",118);
	       prompts[2]=Gtxt("Selector (Optional)",144);
	       prompts[3]=NULL;
	       
	       for (i=0; i<3; i++) {
		    responses[i] = (char*)malloc(COLS*sizeof(char));
		    *responses[i] = '\0';
	       }
	       strcpy(responses[1], "70");
		    
	       responses[3] = NULL;
	       
	       if ((CURRequest(CursesScreen, 
			       Gtxt("Connect to a new Gopher Server",75),
			       prompts, responses) != -1) 
		   && *responses[0]!='\0') {
		    
		    GSsetType(tempgs, A_DIRECTORY);
		    GSsetTitle(tempgs, responses[0]);
		    GSsetHost(tempgs, responses[0]);
		    GSsetPort(tempgs, atoi(responses[1]));
		    GSsetPath(tempgs, responses[2]);
	       
		    Load_Dir(tempgs);
	       }

	       GSdestroy(tempgs);
	       for (i=0; i<3; i++)
		    free(responses[i]);
	       break;
	  }


	  case 'w': /** Open a new session from a URL **/
	  {
	       GopherObj *tempgs = GSnew();
	       char *prompt[2];
	       char *response[2];
	       int doneflags = 0;

	       if (SecureMode) {
		    CursesErrorMsg("Sorry, you're not allowed to do this");
		    break;
	       }

	       prompt[0]=
	           "http, gopher, ftp, telnet or tn3270 URL to connect to:";
	       prompt[1]=NULL;
	       
	        response[0] = (char*)malloc(COLS*sizeof(char));
	       *response[0] = '\0';
		response[1] = NULL;
	       
	       if ((CURRequest(CursesScreen, "Connect to a new server",
			  prompt, response) != -1) && *response[0]!='\0') {
		    
		    doneflags = GSfromURL(tempgs, response[0],
		    			  AFTP_HOST, AFTP_PORT, doneflags);
		    if (doneflags & G_HOST) {
			 if (!(doneflags & G_PATH))
			      GSsetPath(tempgs, "");
			 if (!(doneflags & G_TYPE))
			      GSsetType(tempgs, A_DIRECTORY);
			 if (!(doneflags & G_NAME))
			      GSsetTitle(tempgs, response[0]);

			 process_request(tempgs);
		    }
	       }

	       GSdestroy(tempgs);
	       free(response[0]);
	       break;
	  }

	  case 'f': /** Open an aFTP session **/
	  {
	       GopherObj *tempgs = GSnew();
	       char *prompts[3];
	       char *responses[3];
	       char FTPpath[256];
	       int i;

	       if (SecureMode) {
		    CursesErrorMsg(Gtxt("Sorry, you're not allowed to do this",164));
		    break;
	       }

	       prompts[0]=Gtxt("anonymous FTP Host",187);
	       prompts[1]=Gtxt("Selector (Optional)",144);
	       prompts[2]=NULL;
	       
	       for (i=0; i<2; i++) {
		    responses[i] = (char *) malloc(sizeof(char)*COLS);
		    *responses[i] = '\0';
	       }
		    
	       responses[2] = NULL;
	       
	       if ((CURRequest(CursesScreen,
		   Gtxt("Connect to an anonymous FTP Server via the Gopher gateway",76),
			   prompts, responses) == -1) || *responses[0] == '\0')
		    break;

	       GSsetType(tempgs, A_DIRECTORY);
	       GSsetTitle(tempgs, responses[0]);
	       GSsetHost(tempgs, AFTP_HOST);
	       GSsetPort(tempgs, AFTP_PORT);
	       if (responses[1][strlen(responses[1])-1] != '/')
	            strcat(responses[1], "/");
	       sprintf(FTPpath, "ftp:%s@%s%s", responses[0],
		              (*responses[1] == '/') ? "" : "/", responses[1]);
	       GSsetPath(tempgs, FTPpath);
	       
	       Load_Dir(tempgs);

	       GSdestroy(tempgs);
	       for (i=0; i<2; i++)
		    free(responses[i]);
	       break;
	  }

	  case 'r':  /** Go to root menu of current item **/
	  {
	       char GSType;
	       GopherObj *tempgs;

	       if (SecureMode) {
		    CursesErrorMsg(Gtxt("Sorry, you're not allowed to do this",164));
		    break;
	       }

		   if ((curitem = GDgetCurrentItem(CurrentDir)) <= 0)
			   curitem = 1;
	       GSType = GSgetType(GDgetEntry(CurrentDir, curitem-1));

	       tempgs = GSnew();

	       /** These Gopher objects don't necessarily point 
		   to machines running Gopher servers **/
	       if (GSType == A_CSO || GSType == A_TELNET || 
		   GSType == A_TN3270 || GSType == A_ERROR ||
		   GSType == A_INFO) {

		    /** Try the parent instead **/
		    if(GDgetLocation(CurrentDir) != NULL)
			 GScpy(tempgs, GDgetLocation(CurrentDir));
		    else
			 GScpy(tempgs, GDgetEntry(OldDirs[iLevel-1], 
				     GDgetCurrentItem(OldDirs[iLevel-1])-1));
	       }
	       else
		    if ((curitem = GDgetCurrentItem(OldDirs[iLevel-1])) <= 0)
			 curitem = 1;
		    GScpy(tempgs, GDgetEntry(CurrentDir, 
			  GDgetCurrentItem(CurrentDir)-1));

	       GSsetType(tempgs, A_DIRECTORY);
	       GSsetTitle(tempgs, Gtxt("Root menu: ",135));
	       STRcat(tempgs->Title, GSgetHost(tempgs));
	       GSsetPath(tempgs, NULL);

	       Load_Dir(tempgs);
	       GSdestroy(tempgs);
	       break;
	  }

	  case 'R':  /** Go to root menu of current menu **/
	  {
	       GopherObj *tempgs;

	       if (SecureMode) {
		    CursesErrorMsg(Gtxt("Sorry, you're not allowed to do this",164));
		    break;
	       }

	       if (iLevel == 0) {
		    Garbled = FALSE;
		    break;
	       }

	       tempgs = GSnew();

	       if (GDgetLocation(CurrentDir) != NULL)
		    GScpy(tempgs, GDgetLocation(CurrentDir));
	       else
		    GScpy(tempgs, GDgetEntry(OldDirs[iLevel-1], 
				   GDgetCurrentItem(OldDirs[iLevel-1])-1));

	       GSsetType(tempgs, A_DIRECTORY);
	       GSsetTitle(tempgs, Gtxt("Root menu: ",135));
	       STRcat(tempgs->Title, GSgetHost(tempgs));
	       GSsetPath(tempgs, NULL);

	       Load_Dir(tempgs);
	       GSdestroy(tempgs);
	       break;
	  }

	  case 'v':  /** View bookmark list **/
	  {
	       logrequest("VIEW BOOKMARKS", NULL);

	       if (RCgetBookmarkDir(GlobalRC) == NULL) {
		    CursesErrorMsg(Gtxt("No bookmarks are defined",112));
		    break;
	       }

	       /** Don't do anything if we are already viewing bookmarks **/
	       if (CurrentDir == RCgetBookmarkDir(GlobalRC)) {
		    Garbled = FALSE;
		    break;
	       }

	       /** Don't push an empty gopher directory... **/
	       if (CurrentDir != NULL)
		    pushgopher(CurrentDir); 
	       
	       CurrentDir = RCgetBookmarkDir(GlobalRC);

	       break;
	  }	       

	  case 'a': /** add current item as a bookmark **/
	  {
	       GopherObj *tmpgs;
	       char newtitle[256];
	       
	       if (RCgetBookmarkDir(GlobalRC) == NULL) {
 		    RCsetBookmarkDir(GlobalRC,GDnew(32));
		    GDsetTitle(RCgetBookmarkDir(GlobalRC), Gtxt("Bookmarks",67));
	       }

	       tmpgs = GSnew();
	       GScpy(tmpgs, GDgetEntry(CurrentDir, GDgetCurrentItem(CurrentDir)-1));
	       
	       strcpy(newtitle, GSgetTitle(tmpgs));
	       if (CURGetOneOption(CursesScreen, newtitle,
	       		   Gtxt("Name for this bookmark:",109), newtitle)==0) {
		    if (*newtitle != '\0') {
			 GSsetTitle(tmpgs, newtitle);
			 GDaddGS(RCgetBookmarkDir(GlobalRC), tmpgs);
			 ChangedDefs = TRUE;
		    }
	       }

	       logrequest("ADD BOOKMARK", tmpgs);

               /* Clear the local file name so the file isn't deleted */
               GSsetLocalFile(tmpgs, NULL);

	       GSdestroy(tmpgs);

	       break;
	  }

	  case 'A': /*** Add current directory/search as a bookmark **/
	  {
	       GopherObj *tmpgs;
	       char newtitle[256];
		   char *tmps;

	       if (RCgetBookmarkDir(GlobalRC) == NULL) {
		    RCsetBookmarkDir(GlobalRC,GDnew(32));
		    GDsetTitle(RCgetBookmarkDir(GlobalRC), Gtxt("Bookmarks",67));
	       }

	       if (CurrentDir == RCgetBookmarkDir(GlobalRC)) {
		    CursesErrorMsg(Gtxt("Sorry, can't make a bookmark of bookmarks",151));
		    break;
	       }
	       
	       tmpgs = GSnew();
	       if (GDgetLocation(CurrentDir) != NULL)
		    GScpy(tmpgs, GDgetLocation(CurrentDir));
	       else if (iLevel == 0)
		    GScpy(tmpgs, RootGophers[0]);
	       else
		    GScpy(tmpgs, GDgetEntry(OldDirs[iLevel-1], 
					    GDgetCurrentItem(OldDirs[iLevel-1])-1));
	       
		   if ((GSgetType(tmpgs) == '7') &&
			   ((tmps = GSgetPath(tmpgs)) == NULL ||
				*tmps == '\0' ||
				Searchstring == NULL ||
				*Searchstring== '\0')) {
			   CursesErrorMsg("Sorry, can't make a bookmark of this search");
			   GSdestroy(tmpgs);
			   break;
           }
	       strcpy(newtitle, GDgetTitle(CurrentDir));
	       if (CURGetOneOption(CursesScreen, newtitle,
	       		Gtxt("Name for this bookmark:",109), newtitle)==0) {

		    if (*newtitle != '\0') {
			 GSsetTitle(tmpgs, newtitle);

			 /*** Freeze the search, if there was one. ***/
			 if (GSgetType(tmpgs) == '7') {
			      char ickypath[512];
			      strcpy(ickypath, GSgetPath(tmpgs));
			      strcat(ickypath, "\t");
			      strcat(ickypath, Searchstring);
			      GSsetPath(tmpgs, ickypath);
			      GSsetType(tmpgs, '1');
			 }
			 
			 GDaddGS(RCgetBookmarkDir(GlobalRC), tmpgs);
			 ChangedDefs = TRUE;
		    }
	       }
	       logrequest("ADD BOOKMARK", tmpgs);

	       GSdestroy(tmpgs);
	       break;
	  }

	  case 'd':  /*** Delete a bookmark ***/
	  {
	       GopherDirObj *tempgd;


#ifdef DELETE_BOOKMARKS_ONLY
              if (CurrentDir != RCgetBookmarkDir(GlobalRC)) {
                   CursesErrorMsg(Gtxt("The 'd'elete command is only for bookmarks.",189));
                  break;
             }
#endif
 	       if (CurrentDir != RCgetBookmarkDir(GlobalRC)) {
		    Download_file(GDgetEntry(CurrentDir,GDgetCurrentItem(CurrentDir)-1));
		    break;
	       }


	       logrequest("DELETE BOOKMARK", GDgetEntry(CurrentDir, GDgetCurrentItem(CurrentDir)-1));
	       
	       if (GDgetNumitems(CurrentDir) == 1)
		    tempgd = NULL;
	       else
		    tempgd=GDdeleteGS(CurrentDir,(GDgetCurrentItem(CurrentDir)-1));

	       if (CurrentDir == RCgetBookmarkDir(GlobalRC))
		    RCsetBookmarkDir(GlobalRC, tempgd);

	       if (tempgd == NULL) {
		    Debugmsg("Last item - pip up a directory")
		    tempgd = CurrentDir;
		    if (popgopher(&CurrentDir)==0 && tempgd != CurrentDir)
			 GDdestroy(tempgd);
		    else {
			 CursesErrorMsg(Gtxt("Sorry, can't delete top level directory.",149));
			 scline(-1, 1, CurrentDir);
		    }
		    ChangedDefs = TRUE;
	       } else {
		     CurrentDir = tempgd;
		     
		     ChangedDefs = TRUE;
	       }
	       break;
	  }

#if defined(VMS) && defined(A_LANGUAGE)
	  case 'L':  /** add language change	**/
	       if (CurrentDir == setlocale_LangDir)
	            break;
	       if (setlocale_LangDir== NULL) {
 		    CursesErrorMsg(Gtxt("Sorry, no language choice available",
					239));
	       }
	       else
	       {
		   /** Don't push an empty gopher directory... **/
		   if (CurrentDir != NULL)
			pushgopher(CurrentDir); 
		   
		   CurrentDir = setlocale_LangDir;
	       }
	       break;
#endif

	  case '$':
	  case '!':
#ifdef NEVERSPAWN
	       CursesErrorMsg(Gtxt("Sorry, can't spawn in with this account",153));
	       break;
#else
	       if (SecureMode || NoShellMode) {
		    CursesErrorMsg(Gtxt("Sorry, can't spawn in with this account",153));
		    break;
	       }
	       /*** Spawn to shell or DCL ***/
	       CURexit(CursesScreen);
#ifdef VMS
	       printf(Gtxt("Spawning DCL subprocess.  Logout to return to Gopher.\n",169));
	       fflush(stdout);
	       i = FIOsystem("");
#else
	       printf(Gtxt("Spawning your default shell.  Type 'exit' to return to Gopher.\n\n",170));
	       fflush(stdout);
	       i = FIOsystem(getenv("SHELL"));
#endif
	       CURenter(CursesScreen);
	       if (i < 0)
#ifdef VMS
		    CursesErrorMsg(Gtxt("Spawn to DCL failed!",167));
#else
		    CursesErrorMsg(Gtxt("Spawn to default shell failed!",168));
#endif
#endif	  /* NEVERSPAWN */
	       break;
	       

	       /*** Pop back to the main menu ***/
	  case 'M':
	  case 'm': 
	  {
	       GopherDirObj *tempGdir;

	       tempGdir = CurrentDir;
	       while (popgopher(&CurrentDir) != -1) {
		    if (tempGdir != NULL && tempGdir != RCgetBookmarkDir(GlobalRC))
			 GDdestroy(tempGdir);
		    tempGdir = CurrentDir;
	       }

	  }

	       break;

#ifndef AUTOEXITONU
	  case 'q':
	       /*** Quit the program ***/
	       if (TRUE == ReallyQuit()) {
		    bDone = TRUE;
		    CURexit(CursesScreen);
		    break;
	       }

	       break;
#endif /*AUTOEXITONU*/
#ifdef VMS
	  case '\032': /* ^Z */
#endif
	  case 'Q':
	       /*** Quit the program, don't ask ***/
	       bDone = TRUE;
	       CURexit(CursesScreen);
	       break;
	       
	  case 'O':
	       /*** Change various program things ***/
#ifdef NEVERSETOPTIONS
	       CursesErrorMsg(Gtxt("Sorry, you're not allowed to do this",164));
#else
	       SetOptions();
#endif
	       break;
		      
	  case '=':
	  {
	       DESCRIBE_GOPHER(Gtxt("Gopher Item Information",93), 
			       GDgetEntry(CurrentDir, GDgetCurrentItem(CurrentDir)-1));
	       break;
	  }
	  case '^':
	  {
	       if (GDgetLocation(CurrentDir) != NULL)
		    DESCRIBE_GOPHER(Gtxt("Gopher Directory Information",89),
				    GDgetLocation(CurrentDir));
	       else if (iLevel == 0)
		    DESCRIBE_GOPHER(Gtxt("Gopher Directory Information",89),
				    RootGophers[0]);
	       else
		    DESCRIBE_GOPHER(Gtxt("Gopher Directory Information",89),
				    GDgetEntry(OldDirs[iLevel-1],
					       GDgetCurrentItem(OldDirs[iLevel-1])-1));
	       break;
	  }
			       

	  case '?':
	  case KEY_HELP:
	  {
	       /*** Display help file ***/
	       GopherObj *tmpgs;
	       char *tmpurl = (char *)malloc(17+255);
	       char line[80];
	       
	       tmpgs = GSnew();
	       GSsetType(tmpgs, A_FILE);
	       sprintf(line, Gtxt("Internet Gopher Information Client v%s.%s.%d",102),
		       GOPHER_MAJOR_VERSION, GOPHER_MINOR_VERSION, PATCHLEVEL);

/*	       GSsetTitle(tmpgs, Gtxt("Gopher Help File",92));*/
	       GSsetTitle(tmpgs, line);
	       
#ifdef VMS
	       GSsetLocalFile(tmpgs, Gtxt(GOPHERHELP,223));
#else
	       GSsetLocalFile(tmpgs, Gtxt(GOPHERHELP,225));
#endif
#ifdef GOPHERHELP_SECURE
	       if (SecureMode)
#ifdef VMS
		  GSsetLocalFile(tmpgs, Gtxt(GOPHERHELP_SECURE,224));
#else
		  GSsetLocalFile(tmpgs, Gtxt(GOPHERHELP_SECURE,226));
#endif
#endif
	       GSsetLocalView(tmpgs, "text/plain");

	       if (tmpurl != NULL) {
		    /* set a URL for logrequest() in showfile() */
		    strcpy(tmpurl, "file://localhost");
#ifdef VMS
		    strcat(tmpurl, Gtxt(GOPHERHELP,223));
#else
		    strcat(tmpurl, Gtxt(GOPHERHELP,225));
#endif
#ifdef GOPHERHELP_SECURE
		    if (SecureMode)
#ifdef VMS
			strcat(tmpurl, Gtxt(GOPHERHELP_SECURE,224));
#else
			strcat(tmpurl, Gtxt(GOPHERHELP_SECURE,226));
#endif
#endif
		    GSsetURL(tmpgs, tmpurl);
		    free(tmpurl);
	       }
	       
	       showfile(tmpgs);

	       GSsetLocalFile(tmpgs, NULL);
	       GSdestroy(tmpgs);
	       break;
	  }

	  case 20:	/* Control-T */
	  {
	       /*** Show host's local date and time ***/	
	       GopherObj *tempgs = GSnew();
	       char *prompts[2];
	       char *responses[2];

	       prompts[0]=Gtxt("Host to query:",98);
	       prompts[1]=NULL;
	       
	       /*** Offer current gopher host as default ***/
	       responses[0] = (char *) malloc(sizeof(char)*COLS);
	       if (GDgetLocation(CurrentDir) != NULL)
		    strcpy(responses[0], GSgetHost(GDgetLocation(CurrentDir)));
	       else if (iLevel == 0)
		    strcpy(responses[0], GSgetHost(RootGophers[0]));
	       else
		    strcpy(responses[0],
		           GSgetHost(GDgetEntry(OldDirs[iLevel-1], 
			             GDgetCurrentItem(OldDirs[iLevel-1])-1)));
	       responses[1] = NULL;
	       
	       if ((CURRequest(CursesScreen,
			       Gtxt("Show host's local date and time",145),
			   prompts, responses) == -1) || *responses[0] == '\0')
		    break;

	       GSsetType(tempgs, A_FILE);
	       GSsetTitle(tempgs, Gtxt("Local Date and Time",104));
	       GSsetHost(tempgs, responses[0]);
	       GSsetPort(tempgs, 13);
	       GSsetPath(tempgs, NULL);
	       
	       showfile(tempgs);

	       GSdestroy(tempgs);
	       free(responses[0]);
	       break;
	  }

	  default:
	       Debug("main beep %d\r\n",TypedChar)
	       CURBeep(CursesScreen);
	       Garbled = FALSE;
	       break;

	  } /* switch */

#ifdef DESCRIBE_GOPHER
#undef DESCRIBE_GOPHER
#endif

     }      /* while */

     CleanupandExit(0);

     exit(0); /* Never get here... */
}


#if defined(VMS) && defined(A_LANGUAGE)
/*
 *  This procedure displays the available language menu and reports the
 *	user's language selection
 */

int
setlocale_screen()
{
    int status;

    if (!LangScreen)
	LangScreen = CURnew();
    CURenter(LangScreen);
    GetMenu(setlocale_LangDir, &status, 1);
    status = GDgetCurrentItem(setlocale_LangDir)-1;   
    CURexit(LangScreen);
    return(status);
}
#endif


int
Load_Index(GopherObj *ZeGopher)
{
     Draw_Status(Gtxt("Searching...",143));
     refresh();

     return(Load_Index_or_Dir(ZeGopher, Searchstring));
}

int
Load_Dir(GopherObj *ZeGopher)
{
     Searchstring= NULL;
     return(Load_Index_or_Dir(ZeGopher, NULL));
}


int
Load_Index_or_Dir(GopherObj *ZeGopher, char *Searchmungestr)
{
     int failed = 0;
     int sockfd;
     int i, numbytes;
     static char DirTitle[512];
     GopherDirObj *NewDir = NULL;

     DebugGSplusPrint(ZeGopher,"Load_Index_or_Dir");
     NewDir = GDnew(32);

     Draw_Status(Gtxt("Connecting...",77)); refresh();

     if ((sockfd = GSconnect(ZeGopher)) <0) {
	  check_sock(sockfd, GSgetHost(ZeGopher), GSgetPort(ZeGopher));
	  failed = 1;
     }
     else {
	  if (GSgetType(ZeGopher) == A_DIRECTORY) {
	       Draw_Status(Gtxt("Retrieving Directory...",133)); refresh();
	       GStransmit(ZeGopher, sockfd, NULL, "$", NULL);
	  }
	  else if (GSgetType(ZeGopher) == A_INDEX) {
	       Draw_Status(Gtxt("Searching...",143)); refresh();
	       GStransmit(ZeGopher, sockfd, Searchmungestr, "$", NULL);
	  }

	  numbytes = GSrecvHeader(ZeGopher, sockfd);

	  if (numbytes == 0) {
	       Gplus_Error(sockfd);
	       failed = 1;
	       return(failed);
	  }

	  if (GSisGplus(ZeGopher))
	       GDplusfromNet(NewDir, sockfd, twirl);
	  else
	       GDfromNet(NewDir, sockfd, twirl);

	  logrequest("ARRIVED AT", ZeGopher);


	  if (GDgetNumitems(NewDir) <= 0) {
	       CursesErrorMsg(Gtxt("Nothing available.", 214));
	       failed = 1;
	       GDdestroy(NewDir);
	       closenet(sockfd);
	       return(failed);
	  }

	  if (GSgetType(ZeGopher) == A_INDEX) {
	       sprintf(DirTitle, "%s: %s", GSgetTitle(ZeGopher), Searchmungestr);
	       GDsetTitle(NewDir, DirTitle);
	  }
          else
	       GDsetTitle(NewDir, GSgetTitle(ZeGopher));

	  GDsetLocation(NewDir, ZeGopher);

	  /** Don't push an empty gopher directory... **/
	  if (CurrentDir != NULL)
	       pushgopher(CurrentDir); 

	  CurrentDir = NewDir;
	  
     }
     i = closenet(sockfd);
     return(failed);
}

/*
 * This dispatches the appropriate fcns depending on what the object is.. 
 */

int
process_request(GopherObj *ZeGopher)
{
     int failed=0;
     char ImageCmd[128];
     char MovieCmd[128];

     if (GSisAsk(ZeGopher)) {
	  char **askdata = AskBlock(ZeGopher);
	  
	  if (askdata == NULL)
	       return(1);
	  GSsetAskdata(ZeGopher, askdata);
     }

     /** Decide what to do with it.. **/

     Debug("process_request type=%c\n",GSgetType(ZeGopher));
     logrequest("GOING TO", ZeGopher);

     switch(GSgetType(ZeGopher)) {
     case -1:
	  break;

#if defined(VMS) && defined(A_LANGUAGE)
     case A_LANGUAGE:
	  rsetlocale(GSgetPort(ZeGopher));
	  break;
#endif

     case A_INFO:
	  /** Do nothing **/
	  break;

     case A_FILE:
	  Draw_Status(Gtxt("Receiving Information...",128));
	  refresh();
	  showfile(ZeGopher);
	  break;

     case A_GIF:
     case A_IMAGE:
          if (!RCdisplayCommand(GlobalRC, "Image", "", ImageCmd) ||
	      !strncasecmp(ImageCmd, "- none -", 8) ||
	      ImageCmd == NULL || ImageCmd == '\0') {
	       CursesErrorMsg(Gtxt("Sorry, this machine doesn't support images",158));
	       break;
	  }
	  Draw_Status(Gtxt("Receiving Image...",132));
	  refresh();
	  if (RemoteUser)
		Download_file(ZeGopher);
	  else
		showfile(ZeGopher);
	  break;

     case A_MIME:
	  if (!SecureMode) {
	       Draw_Status(Gtxt("Receiving MIME File...",129));
	       refresh();
	       showfile(ZeGopher);
	  }
	  else
	       CursesErrorMsg(Gtxt("Sorry, cannot display this file",148));
	  break;

     case A_MACHEX:
     case A_PCBIN:
     case A_UNIXBIN:
	if (RemoteUser || SecureMode || NoShellMode) {
		Draw_Status(Gtxt("Receiving File...",126));
		refresh();
		Download_file(ZeGopher);
	}
	else
	       Save_file(ZeGopher, NULL, NULL);
	  break;
	  
     case A_DIRECTORY:
	  Draw_Status(Gtxt("Receiving Directory...",125));
	  refresh();
	  failed = Load_Dir(ZeGopher);
	  break;
		    
     case A_TELNET:
     case A_TN3270:
          {
	      char type, buf[512];

	      if ((type=GSgetType(ZeGopher)) == A_TELNET &&
	          (!RCdisplayCommand(GlobalRC, "Terminal/telnet", "", buf) ||
		   !strncasecmp(buf, "- none -", 8) ||
	 	   buf == NULL || buf[0] == '\0')) {
	          CursesErrorMsg(Gtxt("Sorry, telnet is not available.",157));
		  break;
	      }
	      else if (type == A_TN3270 &&
	          (!RCdisplayCommand(GlobalRC, "Terminal/tn3270", "", buf) ||
		   !strncasecmp(buf, "- none -", 8) ||
	 	   buf == NULL || buf[0] == '\0')) {
	          CursesErrorMsg(Gtxt("Sorry, tn3270 is not available.",160));
		  break;
	      }
	      else
	          do_tel_3270(ZeGopher);
	  }
	  break;

     case A_INDEX:
	  refresh();
	  if (search_string) { /* search_string in commandline */
	       Searchstring = search_string;
	       search_string = NULL;
	  } else
	       Searchstring = do_index(ZeGopher);

	  Draw_Status(Gtxt("Searching Text...",142));
	  if (Searchstring != NULL)
	       failed=Load_Index(ZeGopher);
	  else
	       failed = 1;
	  break;
	  
     case A_CSO:
	  do_cso(ZeGopher);
	  break;

     case A_SOUND:
	  Draw_Status(Gtxt("Receiving Sound...",131));
	  refresh();
	  do_sound(ZeGopher);
	  break;

      case A_MOVIE:
	  if (!RCdisplayCommand(GlobalRC, "video", "", MovieCmd) ||
	      !strncasecmp(MovieCmd, "- none -", 8) ||
	      MovieCmd == NULL || MovieCmd == '\0') {
		CursesErrorMsg(Gtxt("Sorry, this machine doesn't support movies",165));
		break;
	  }
	  Draw_Status(Gtxt("Receiving Movie...",130));
	  refresh();
	  if (RemoteUser)
	        Download_file(ZeGopher);
	  else
	        do_movie(ZeGopher);
	  break;

     case A_HTML:
	  Draw_Status(Gtxt("Receiving HTML page...",127));
	  refresh();
	  do_html(ZeGopher);
	  break;
     }
     if (GSisAsk(ZeGopher) && GSgetLocalFile(ZeGopher) != NULL) {
	  unlink(GSgetLocalFile(ZeGopher));
	  GSsetLocalFile(ZeGopher, NULL);
     }
     (void)GSsetAskdata(ZeGopher, NULL);
     return(failed);
}


/*
 * Provide information about a gopher item...
 * Should use curses...  But....
 */

void
#ifdef DESCRIBE_GOPHER_GRIPE
describe_gopher(char *banner, GopherStruct *ZeGopher, FILE *gripefile)
                  
#else
                                 
#endif
               
                         
{
     char *tmpfilename;
     char mkstemp_template[] = "/tmp/gopher-XXXXXX";
     int  mkstemp_fd = -1;
     FILE *tmpfile;
     Blockobj *bl;
     int i,j, views;
     GopherObj *infogs;

     infogs = GSnew();
     GSsetType(infogs, A_FILE);
     GSsetTitle(infogs, Gtxt("Link Info",103));

     GSgetginfo(ZeGopher, TRUE);

#ifdef DESCRIBE_GOPHER_GRIPE
     if (!gripefile)
	goto normal_describe;
     tmpfile = gripefile;
     GSdestroy(infogs);
     goto format_description;

normal_describe:
#endif
#ifdef VMS
     Gopenfile = tmpfilename = tempnam(NULL,NULL);
     tmpfile = fopen(tmpfilename, "w");
#else  /* ! VMS */
#ifdef HAVE_MKSTEMP
     mkstemp_fd = mkstemp(mkstemp_template);
     tmpfilename = strdup(mkstemp_template);
     Gopenfile = tmpfilename;
     tmpfile = fdopen(mkstemp_fd, "w");
#else /* ! HAVE_MKSTEMP */
     Gopenfile = tmpfilename = tempnam("/tmp", "gopher");
     tmpfile = fopen(tmpfilename, "w");
#endif /* HAVE_MKSTEMP */
#endif /* VMS */
     GSsetLocalFile(infogs, tmpfilename);
     GSsetLocalView(infogs, "text/plain");
     if (tmpfile == NULL) {
	  CURexit(CursesScreen);
	  fprintf(stderr, Gtxt("Couldn't make a tmp file!\n",83)), 
	  CleanupandExit(-1);
     }
     free(tmpfilename);

#ifdef DESCRIBE_GOPHER_GRIPE
format_description:
#endif

     GStoLink(ZeGopher, fileno(tmpfile), TRUE);

     fprintf(tmpfile, "<URL:%s>\n\n", GSgetURL(ZeGopher,""));
     fflush(tmpfile);

     if (GSisGplus(ZeGopher)) {
	  GopherObj *server;

	  server = GSnew();
	  GScpy(server, ZeGopher);
	  GSsetPath(server, "");
	  GSsetLocalFile(server, "");

	  fputc('\n', tmpfile);
	  /** Search out for specific blocks **/
	  for (i=0; i<GSgetNumBlocks(ZeGopher); i++) {
	       if (strcmp(BLgetName(GSgetBlock(ZeGopher, i)),"ABSTRACT")==0){
		    bl = GSgetBlock(ZeGopher, i);
		    fprintf(tmpfile, "%s\n---------\n\n",BLgetName(bl));
		    for (j=0; j < BLgetNumLines(bl); j++) {
			 fprintf(tmpfile, "%s\n", BLgetLine(bl, j));
		    }
		    fprintf(tmpfile, "\n");
		    break;
	       }
	  }

	  fprintf(tmpfile, Gtxt("Size       Language      Document Type\n",146));
	  fprintf(tmpfile, Gtxt("---------- ------------- ----------------------------\n",147));
	  
	  for (views=0; views< GSgetNumViews(ZeGopher); views++) {
	       char *cp; 
	       VIewobj *ZeView = GSgetView(ZeGopher, views);

	       if (ZeView == NULL)
		    continue;

	       cp = VIgetSize(ZeView);
	       if (cp != NULL)
		    fprintf(tmpfile, "%s", cp);
	       else
		    cp = "";

	       for (i=strlen(cp); i<11; i++)
		    fputc(' ', tmpfile);

	       
	       cp = VIprettyLang(ZeView, "En_US"); 
	       if (cp != NULL)
		    fprintf(tmpfile, "%s", cp);
	       else
		    cp = VIgetLang(ZeView);
	       for (i=(cp?strlen(cp):0); i<14; i++)
		    fputc(' ', tmpfile);

	       cp = VIgetType(ZeView);
	       fprintf(tmpfile, "%s\n", cp);
	  }


	  for (i=0; i<GSgetNumBlocks(ZeGopher); i++) {
	       bl = GSgetBlock(ZeGopher, i);
	       if (strcmp(BLgetName(bl),"ADMIN")==0) {
		    fprintf(tmpfile, Gtxt("\n\nServer Information\n",186));
		    fprintf(tmpfile, "------------------\n");
		    for (j=0; j < BLgetNumLines(bl); j++) {
			 char *cp = BLgetLine(bl, j);

			 if ( (strncmp(cp, "Admin:", 5) != 0) &&
			      (strncmp(cp, "Mod-Date:", 9) != 0) &&
			      (strncmp(cp, "TTL:", 4) != 0) ) {
			      fprintf(tmpfile, "%s\n", cp);
			 }
		    }
		    fprintf(tmpfile, "\n");
		    break;
	       }
	  }
	  GSdestroy(server);
     }

#ifdef DESCRIBE_GOPHER_GRIPE
     if (gripefile)
	return;
#endif
     fclose(tmpfile);

     showfile(infogs);

     CURenter(CursesScreen); /* do this after unlink fails */

     GSdestroy(infogs);
     return;
}