/*Last Modified:  30-APR-1992 08:45:25.44, By: MARK */
/* ourutils.c
*
* Part of the Internet Gopher program, copyright (C) 1991
* University of Minnesota Microcomputer Workstation and Networks Center
*
*/

#include "gopher.h"

int readkey_row, readkey_col;

/*
** This procedure exits out of the curses environment and
** displays the file indicated by pathname to the screen
** using a pager command of some sort
*/

void
display_file(Filename)
 char *Filename;
{
    FILE *tmpfile, *fNew;
    char command[MAXSTR];
    char SaveName[MAXSTR];
    short int ch;
    int ret_status;

    strncpy(command, "\0", MAXSTR );
    strcpy(command, PagerCommand);

    /** Execute the PAGER command **/
    strcat(command, " ");
    strcat(command, Filename);


    if (strcmp(PagerCommand, "builtin") != 0)
         system(command);
    else
         Ourpager(Filename);

    printf("Press <RETURN> to continue");

    if (!SecureMode)
         printf(", <s> to save, or <p> to print:");
    else
         printf(":");

    fflush(stdout);

    ch = 0;
    while (ch == 0) {
         ret_status = smg$read_keystroke( &KeyboardId, &ch );

         if (SecureMode) {
              switch (ch) {
              case SMG$K_TRM_LF:
              case SMG$K_TRM_CR:
              case SMG$K_TRM_SPACE:
                   break;
              default:
                   ret_status = smg$ring_bell( &DisplayId );
                   fflush(stdout);
                   ch=0;
                   break;
              }
         }
         else {

              switch(ch) {
              case SMG$K_TRM_LF:
              case SMG$K_TRM_CR:
              case SMG$K_TRM_SPACE :
                   if (strcmp(Filename,GOPHERHELP)!=0) {
                       if (remove(Filename) != 0 )
                         fprintf(stderr, "Couldn't remove %s!!!\n",Filename);
                       }

                   break;

              case SMG$K_TRM_LOWERCASE_S:
              case SMG$K_TRM_UPPERCASE_S:
                   strncpy(command, "\0", MAXSTR );
                   strncpy(SaveName, "\0", MAXSTR );
                   sprintf(command, "Enter save file name: ");
                   GetOneOption(command, SaveName);
                   if (strlen(SaveName) == 0)
                        break;
                   while ((fNew = fopen(SaveName, "w")) == NULL) {
                        bzero(SaveName, MAXSTR);
                        strncpy(command, "\0", MAXSTR );
                        sprintf(command, "Error opening %s:  Enter new name or <Enter> to cancel: ", SaveName);
                        GetOneOption(command, SaveName);
                        if (SaveName[0] == 0)
                             break;
                   }

                   if (fNew == NULL)
                        break;

                   if ((tmpfile = fopen(Filename, "r")) == NULL)
                        fprintf(stderr, "%s cannot be opened.\n", Filename), exit(-1);
                   while (!feof(tmpfile)) fputc(fgetc(tmpfile), fNew);

                   fclose(tmpfile);
                   fclose(fNew);

                   if (strcmp(Filename,GOPHERHELP)!=0) {
                       if( remove(Filename) != 0 )
                         fprintf(stderr, "Couldn't remove %s!!!\n",Filename);
                       }

                   break;

              case SMG$K_TRM_LOWERCASE_P:
              case SMG$K_TRM_UPPERCASE_P:
                   bzero(SaveName, MAXSTR);
                   strncpy(SaveName,"sys$scratch:gopher.print",MAXSTR);
                   while ((fNew = fopen(SaveName, "w")) == NULL) {
                     bzero(SaveName, MAXSTR);
                     strncpy(command, "\0", MAXSTR );
                     sprintf(command, "Error opening %s:  Enter new name or <Enter> to cancel: ", SaveName);
                     GetOneOption(command, SaveName);
                     if (SaveName[0] == 0)
                        break;
                   }

                   if (fNew == NULL)
                        break;

                   if ((tmpfile = fopen(Filename, "r")) == NULL)
                        fprintf(stderr, "%s cannot be opened.\n", Filename), exit(-1);
                   while (!feof(tmpfile)) fputc(fgetc(tmpfile), fNew);

                   fclose(tmpfile);
                   fclose(fNew);
                   strncpy(command, "\0", MAXSTR );
                   sprintf(command, "%s %s", PrinterCommand, Filename);
                   system(command);
                   break;

              default:
                   ret_status = smg$ring_bell( &DisplayId );
                   fflush(stdout);
                   ch=0;
                   break;
              }
         }
    }

    ret_status = smg$erase_display( &DisplayId );
    fflush(stdout);
}


/*
** This mini pager is intended for people worried about shell escapes from
** more or less or whatever
*/

Ourpager(filename)
 char *filename;
{
    FILE *InFile;
    int i;
    char inputline[512], *cp;
    int Done = FALSE;
    char ZeTypedChar;
    int ret_status;

    if ((InFile = fopen(filename, "r")) == NULL)
         return;

    while (Done == FALSE) {
         ret_status = smg$erase_display( &DisplayId );

         for (i=0 ; i < LINES-1; i++) {
              cp = fgets(inputline, 512, InFile);
              ZapCRLF(inputline);
              puts(inputline);
         }

         printf("----Press <ENTER> for next page, q to exit------");

         ret_status = smg$read_keystroke( &KeyboardId, &ZeTypedChar );

         if ((ZeTypedChar == 'q') || (cp == NULL)) {
              printf("\n");
              Done = TRUE;
         }
    }

    fclose(InFile);
}

/*
** Non System V getstr's all seem to be broken in some way.  Anyways
** a normal getstr wouldn't do for us.  This one displays a current value
** That the user can edit.
**
** Also, if a non-printable character is pressed we stop and return it.
** (tab, esc etc. )
*/

char
Mygetstr(inputline)
 char *inputline;
{
    int pointer = 0;
    short int ch;
    int ret_status, read_pos;
    char *typedch, *outch;

    $DESCRIPTOR( d_outch, outch );
    $DESCRIPTOR( d_ch, typedch );
    $DESCRIPTOR( d_space, " " );

    typedch = ( char * ) malloc( 1 );
    outch = ( char * ) malloc( 1 );

    d_ch.dsc$a_pointer = typedch;
    d_ch.dsc$w_length = 1;

    /*** Check to see if there's something in the inputline already ***/

    d_outch.dsc$w_length = 1;
    while ( inputline[pointer] != '\0' ) {
         d_outch.dsc$a_pointer = &inputline[pointer];
         ret_status = smg$put_chars( &DisplayId, &d_outch, &readkey_row,
                       &readkey_col );
         readkey_col = readkey_col + 1;
         pointer ++;
    }

    for (;;) {
         ret_status = smg$read_keystroke( &KeyboardId, &ch );
         *typedch = ch;

         switch (ch) {

         case SMG$K_TRM_LF:
         case SMG$K_TRM_CR:
         case SMG$K_TRM_HT:
              inputline[pointer] = '\0';
              return;
              break;

         /**  Backspace and delete **/

         case SMG$K_TRM_BS:
         case SMG$K_TRM_DELETE:
              if (pointer > 0) {
                   readkey_col = readkey_col - 1;
                   ret_status = smg$set_physical_cursor( &PasteId,
                       &readkey_row, &readkey_col );
                   ret_status = smg$put_chars( &DisplayId, &d_space,
                               &readkey_row, &readkey_col );
                   ret_status = smg$set_physical_cursor( &PasteId,
                       &readkey_row, &readkey_col );
                   inputline[--pointer] = '\0';
              }
              break;

         default:
              if (isprint(ch)) {
                   inputline[pointer++]= ch;
                   ret_status = smg$put_chars( &DisplayId, &d_ch,
                       &readkey_row, &readkey_col );
                   readkey_col = readkey_col + 1;
              }
              else
                   return(ch);
         }
    }
}

/*
** This routine will allow the user to change a whole bunch of fields.
**
** The maximum number of options is hard set at 9 right now.  It may be
** different in the future.
**
** The space for storing stuff is provided by the caller.  This routine
** will present it to the user in this fashion:
**
**           Option1 : responses1
**           Option2 : responses2
**           .....
**
** It would be wise to keep the length of the options and responses
** below 38 characters.
**
*/


Get_Options(Title, Err, numOptions, Options, Responses)
 char *Title;
 char Err[MAXSTR];
 int    numOptions;
 char **Options;
 char Responses[MAXRESP][MAXSTR];
{
    int         availlines;
    char printstring[WHOLELINE];
    char inputline[WHOLELINE];
    int         optionlen, ret_status, row, col;
    int         maxoptionlen;
    int         i,j;          /** Acme Buggy whips and integers **/
    BOOLEAN     Done = FALSE;
    char        ch, fooch;
    char        *outstr;

    $DESCRIPTOR( d_title, Title );
    $DESCRIPTOR( d_err, Err );
    $DESCRIPTOR( d_outstr, outstr );
    $DESCRIPTOR( d_options, Options );
    $DESCRIPTOR( d_colon, ": " );
    $DESCRIPTOR( d_resp, Responses );
    $DESCRIPTOR( d_prstr, printstring );

    outstr = ( char * )malloc( 5 );

    while (Done == FALSE) {

         ret_status = smg$erase_display( &DisplayId );
         Draw_Banner();
         Draw_Status("Press <RETURN> to exit");
         row = 4;
         col = (80 - strlen( Title )) / 2;
         d_title.dsc$w_length = strlen( Title );
         ret_status = smg$put_chars( &DisplayId, &d_title, &row, &col );
         row = 5;
         col = (80 - strlen( Err )) / 2;
         d_err.dsc$w_length = strlen( Err );
         ret_status = smg$put_chars( &DisplayId, &d_err, &row, &col );

         availlines = LINES - 6;

         /** Find the longest width of the options strings **/

         maxoptionlen = 0;

         for (i=0; i<numOptions; i++) {
              j= strlen(Options[i]);
              maxoptionlen = (maxoptionlen > j) ? maxoptionlen:j;
         }


         /*** Print out the options in a nice looking fashion ***/

         for (i=0; i<numOptions; i++) {
              optionlen = strlen(Options[i]);
              row = i+6;
              col = 3;
              sprintf(outstr,"%d. ",i+1);
              d_outstr.dsc$w_length = strlen( outstr );
              d_outstr.dsc$a_pointer = outstr;
              ret_status = smg$put_chars( &DisplayId, &d_outstr, &row, &col );
              col = 3 + strlen( outstr );
              d_options.dsc$w_length = strlen( Options[i] );
              d_options.dsc$a_pointer = Options[i];
              ret_status = smg$put_chars( &DisplayId, &d_options, &row, &col );
              col = maxoptionlen + 6;
              ret_status = smg$put_chars( &DisplayId, &d_colon, &row, &col );
              col = maxoptionlen + 8;
              d_resp.dsc$w_length = strlen( Responses[i] );
              d_resp.dsc$a_pointer = Responses[i];
              ret_status = smg$put_chars( &DisplayId, &d_resp, &row, &col );
         }

         sprintf(printstring, "Press 1-%d to change a field, Return to accept fields and continue", numOptions);

         row = LINES - 2;
         col = (80 - strlen(printstring)) / 2;
         d_prstr.dsc$w_length = strlen( printstring );
         ret_status = smg$put_chars( &DisplayId, &d_prstr, &row, &col );

         /*** Now get some user input ***/

         ret_status = smg$read_keystroke( &KeyboardId, &ch );


#ifdef STUPIDTERM
         /*** Suck off a return ***/
         if (ch != '\n' && ch != '\r')

              do {
                   ret_status = smg$read_keystroke( &KeyboardId, &fooch );
              }
              while (fooch != '\n' && fooch != '\r');

#endif

         if (ch == '\n' || ch == '\r' || ch == 'Q' || ch=='q')
              Done = TRUE;

         else if (isdigit(ch)) {
              i = ch - '1' ;
              Draw_Status("Press Return when finished");
              readkey_row = i + 6;
              readkey_col = maxoptionlen + 8;
              row = i + 6;
              col = maxoptionlen + 8;
              ret_status = smg$set_physical_cursor( &PasteId, &row, &col );
              inputline[0] = '\0';
              Mygetstr(Responses[i]);
         }
         else
              ret_status = smg$ring_bell( &DisplayId );
    }
}

/*
* This allows the user to add or change data in a form.
*
* It returns true if the user wants to keep the changes
* It returns false if the user wants to abort
*
*/

BOOLEAN
NewForm(ZeForm)
 Form *ZeForm;
{
    int         availlines;
    static char printstring[WHOLELINE];
    int         optionlen;
    int         maxoptionlen;
    int         i,j;          /** Acme Buggy whips and integers **/
    char        ch;

    while (1) {

         DisplayForm(ZeForm);

         sprintf(printstring, "Press <ESC> to accept fields and continue");

/*        Centerline("Press <ESC> to accept fields and continue", LINES-3);
         Centerline("or press <CTRL-A> to abort", LINES-2);
*/
         /*** Now get some user input ***/

         for (i=0; i< ZeForm->numfields; i++) {

              move(ZeForm->yloc[i],ZeForm->xloc[i] + strlen(ZeForm->tags[i])+2);
              echo();

              ch = Mygetstr(ZeForm->values[i]);

              /*** ESC key ***/
              if (ch == '\033') {
                   noecho();
                   return(TRUE);
              }

              /*** CTRL-A ***/
              else if (ch == '\001') {
                   noecho();
                   return(FALSE);
              }
              noecho();
         }
    }
}



/*
* This Displays a form and a "menu".  It displays the Form
* and then it waits for a keypress.  It returns the value of the
* key that is pressed.
*/

void
DisplayForm(ZeForm)
 Form *ZeForm;
{
    int         availlines;
    static char printstring[WHOLELINE];
    int         optionlen;
    int         maxoptionlen;
    int         i,j;          /** Acme Buggy whips and integers **/
    BOOLEAN     Done = FALSE;
    char        ch;

    Draw_Banner();
/*     Centerline( ZeForm->Title, 2);
*/
    availlines = LINES - 6;

    /*** Print out the options according to the Form structure ***/

    for (i=0; i<ZeForm->numfields; i++) {
         optionlen = strlen((ZeForm->tags)[i]);
         mvaddstr(ZeForm->yloc[i],ZeForm->xloc[i],
                  ZeForm->tags[i]);
         addch(':');
         addch(' ');

         /*** Now add the current value ***/
         addstr((ZeForm->values)[i]);
    }
}


void
CursesErrorMsg(Message)
 char *Message;
{
    short int ch;
    int i, row, col, ret_status;

    $DESCRIPTOR( d_message, Message );
    $DESCRIPTOR( d_hitcr, " <press RETURN> " );

    d_message.dsc$w_length = strlen( Message );
    row = LINES;
    col =1;
    ret_status = smg$erase_line( &DisplayId, &row, &col );
    ret_status = smg$put_chars( &DisplayId, &d_message, &row, &col );

    col = strlen( Message ) + 2;
    ret_status = smg$put_chars( &DisplayId, &d_hitcr, &row, &col );
    while (ch != SMG$K_TRM_CR )
         ret_status = smg$read_keystroke( &KeyboardId, &ch );
}

GetOneOption(OptionName, Response)
 char *OptionName, *Response;
{
    int ret_status, row, col, resp_len, maxlen;
    char *resp_p1;

    $DESCRIPTOR( d_option, OptionName );
    $DESCRIPTOR( d_resp, Response );

    d_resp.dsc$w_length = MAXSTR-1;
    d_option.dsc$w_length = strlen( OptionName );
    maxlen = MAXSTR - 1;

    row = LINES;
    readkey_row = LINES;
    readkey_col = strlen( OptionName ) + 1;

    col = 1;
    ret_status = smg$erase_line( &DisplayId, &row, &col );
    ret_status = smg$put_chars( &DisplayId, &d_option, &row, &col );

    Mygetstr(Response);
}


/*
** This strips off  CR's and LF's leaving us with a nice pure string.
*/

void
ZapCRLF(inputline)
char *inputline;
{
    char *cp;

    cp = strchr(inputline, '\r');    /* Zap CR-LF */
    if (cp != NULL)
         *cp = '\0';
    else {
         cp = strchr(inputline, '\n');
         if (cp != NULL)
              *cp = '\0';
    }
}


/*
* This routine allows the user to "find" a specific event.
* It doesn't allow them to look at documents, etc.  It just lets
* them cruise around directories
*/

GopherStruct*
cruise_dirs(ZeGopher, Message)
 GopherStruct *ZeGopher;
 char *Message;
{
    int Line;
    char SavedTitle;
    short int TypedChar = 0;
    GopherStruct TmpGopher;

    process_request(ZeGopher);

    while (1) {

         Line = GetMenu(iMenuLines, Gopher, Message, &TypedChar);

         switch (TypedChar)
         {

         case SMG$K_TRM_CR:
         case SMG$K_TRM_LF:

              if (Gopher[Line-1].sFileType == '1')
                   process_request(&(Gopher[Line - 1]));
              else
                   CursesErrorMsg("Cannot select these at this time");
              break;

         case SMG$K_TRM_SPACE:
              /*** Use this directory/calendar ***/

              return(&(Gopher[Line -1]));
              break;

         case SMG$K_TRM_LOWERCASE_U:
         case SMG$K_TRM_UPPERCASE_U:
              /*** Go up a directory level ***/
              popgopher(&TmpGopher);
              popgopher(&TmpGopher);
              process_request(&TmpGopher);
              break;

         }
    }
}



int
OpenGopherConn(ZeGopher)
 GopherStruct *ZeGopher;
{
    int sockfd;
    static char inputline[MAXLINE];
    int length;

    inputline[0] = '\0';

    if ((sockfd = connect_to_gopher(ZeGopher->sHost, ZeGopher->iPort)) <0) {
         check_sock(sockfd, ZeGopher->sHost);
         return(-1);
    }


    /*** Get rid of that darn Banner line ***
    length = readline(sockfd, inputline, MAXLINE); */

    return(sockfd);
    /*** TODO check to see if the server version is cool. ***/

}

#ifdef UCX

int bzero(ptr, len)
char *ptr;
int len;
{
 long count;
 for (count = 0; count < len; count++){
   *(char*)(ptr + count) = 0;
   }
}

char *bcopy(src, dest, len)
char *dest, *src;
int len;
{
 return((char*)memmove(dest, src, len));
}

#endif

You are viewing proxied material from gopher.meulie.net. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.