Text File

---- Cut Here and feed the following to sh ---- #!/bin/sh # This is part 03 of a multipart archive # ============= Gopher.cc ============== if test -f 'Gopher.cc' -a X"$1" != X"-c"; then echo 'x - skipping Gopher.cc (File already exists)' else echo 'x - extracting Gopher.cc (Text)' sed 's/^X//' << 'SHAR_EOF' > 'Gopher.cc' && // // Gopher.cc // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // Implementation of the Gopher class // #include "Gopher.h" #include "String.h" #include "Connection.h" #include "GWindow.h" #include "Response.h" #include <unistd.h> #include <stdio.h> #include <xview/notify.h> #include <fcntl.h> #include <time.h> X #define LINE_COUNT_INCREMENT 20 #define MAX_LIST_LINES 1023 X X //*************************************************************************** // Gopher::Gopher(GWindow *gwin) // Gopher::Gopher(GWindow *gwin) { X fd = -1; X gwindow = gwin; X *filename = '\0'; X connection = (Connection *) 0; } X X //*************************************************************************** // Gopher::~Gopher() // Gopher::~Gopher() { X if (connection->isopen()) X (void) notify_set_input_func((Notify_client) this, NOTIFY_FUNC_NULL, connection->get_socket()); X fd = -1; X if (*filename) X unlink(filename); X if (connection) X delete connection; } X X //*************************************************************************** // Gopher::Gopher(char *server, int port, GWindow *gwin) // Gopher::Gopher(char *server, int port, GWindow *gwin) { X fd = -1; X gwindow = gwin; X *filename = '\0'; X if (open(server, port) == NOTOK) X exit(1); } X X //*************************************************************************** // int Gopher::open(server, port) // PURPOSE: // Build a connection with the gopher server. // int Gopher::open(char *server, int port) { X connection = new Connection; X X if (connection->open() == NOTOK) X return NOTOK; X if (connection->assign_port(port) == NOTOK) X return NOTOK; X if (connection->assign_server(server) == NOTOK) X return NOTOK; X if (connection->connect() == NOTOK) X return NOTOK; X X return OK; } X X //*************************************************************************** // int Gopher::read(char type, char *cmd) // PURPOSE: // Send cmd to the server and receive the information until the // connection is closed by the server // int Gopher::read(char type, char *cmd) { X gwindow->status("Retrieving information..."); X X // X // First send the command. We need to terminate the command with X // a return. Since we do not know how big cmd is, we will just make X // it into two writes. X // X if (cmd == NULL) X cmd = ""; X connection->write(cmd, strlen(cmd)); X connection->write("\r\n", 2); X X // X // Now we are ready to receive the information. The type of information X // depends on the command we sent to the server, so we will use it X // to determine where this information will be stored. X // X switch (type) X { X case GOPHER_FILE: X // X // Plain ASCII file coming through... Save it someplace X // X read_ascii(); X break; X case GOPHER_DIRECTORY: X case '\0': X // X // We are getting a directory listing. Read it into our List X // X read_list(); X break; X case GOPHER_CSO: X break; X case GOPHER_ERROR: X break; X case GOPHER_UU: X break; X case GOPHER_INDEX: X break; X case GOPHER_TELNET: X break; X case GOPHER_BINHEX: X case GOPHER_DOS: X case GOPHER_BIN: X // X // Some binary file coming in. Read until connection closes X // X read_binary(); X break; X case GOPHER_SOUND: X // X // Some binary file coming in. Read until connection closes X // X read_binary(); X datatype = TYPE_SOUND; X break; X case GOPHER_IMAGE: X case GOPHER_GIF: X // X // Some binary file coming in. Read until connection closes X // X read_binary(); X datatype = TYPE_IMAGE; X break; X case GOPHER_REDUNDANT: X break; X default: X printf("Hmm. The I don't know how to read data of type '%c'\n", type); X break; X } X return OK; } X X //*************************************************************************** // void Gopher::start_get() // PURPOSE: // Set up the list of data so we can retrieve data in order // void Gopher::start_get() { X list.start_get(); } X X //*************************************************************************** // char *Gopher::get_next() // PURPOSE: // Get the next item from our list // char *Gopher::get_next() { X String *str = (String *) list.get_next(); X X if (str) X return str->get(); X else X return NULL; } X X //*************************************************************************** // void Gopher::read_list() // void Gopher::read_list() { X // X // In order not to block on a read, we will use the xview read notify X // to tell us when data is actually available. X // X datatype = TYPE_LIST; X length = 0; X (void) notify_set_input_func((Notify_client) this, (Notify_func) read_list_proc, connection->get_socket()); } X #define INPUT_BUF_SIZE 50000 X //*************************************************************************** // void Gopher::read_list_proc(Gopher *gopher, int ifd) // void Gopher::read_list_proc(Gopher *gopher, int ifd) { X char buffer[INPUT_BUF_SIZE]; X static time_t last = 0; X char *p; X X if (gopher->connection->read_line(buffer, INPUT_BUF_SIZE) == NULL || gopher->length > MAX_LIST_LINES) X { X // X // End of file reached. X // X (void) notify_set_input_func((Notify_client) gopher, NOTIFY_FUNC_NULL, ifd); X gopher->connection->close(); X gopher->gwindow->display(); X sprintf(buffer, "Total of %d item%s", gopher->length, gopher->length == 1 ? "" : "s"); X gopher->gwindow->status(buffer); X X if (gopher->length == 0) X { X // X // Nothing was found. Let the user know... X // X gopher->gwindow->nothing_found(); X } X } X else X { X if (*buffer == '.' && buffer[1] == '\0') X return; X p = buffer; X while (*p == '-' || *p > 126 || *p < 32) X p++; X gopher->list.add(new String(p)); X X // X // Keep a running count and display the results every second X // X gopher->length++; X if (gopher->length > MAX_LIST_LINES) X gopher->gwindow->list_full(); X X if (last < time(NULL)) X { X char str[20]; X sprintf(str, "%d line%s...", gopher->length, gopher->length == 1 ? "" : "s"); X gopher->gwindow->status(str); X last = time(NULL); X } X } } X X //*************************************************************************** // void Gopher::read_ascii() // void Gopher::read_ascii() { X datatype = TYPE_ASCII; X strcpy(filename, "/tmp/gophXXXXXX"); X fd = mkstemp(filename); X length = 0; X (void) notify_set_input_func((Notify_client) this, (Notify_func) read_ascii_proc, connection->get_socket()); } X X //*************************************************************************** // void Gopher::read_ascii_proc(Gopher *gopher, int ifd) // void Gopher::read_ascii_proc(Gopher *gopher, int ifd) { X char buffer[INPUT_BUF_SIZE]; X static time_t last = 0; X X if (gopher->connection->read_line(buffer, INPUT_BUF_SIZE) == NULL) X { X // X // End of file reached. X // X ::close(gopher->fd); X (void) notify_set_input_func((Notify_client) gopher, NOTIFY_FUNC_NULL, ifd); X gopher->connection->close(); X gopher->gwindow->display(); X char str[30]; X sprintf(str, "Total of %d lines", gopher->length); X gopher->gwindow->status(str); X } X else X { X if (*buffer == '.' && buffer[1] == '\0') X return; X write(gopher->fd, buffer, strlen(buffer)); X write(gopher->fd, "\n", 1); X gopher->length++; X if (last < time(NULL)) X { X char str[20]; X sprintf(str, "%d line%s...", gopher->length, gopher->length == 1 ? "" : "s"); X gopher->gwindow->status(str); X last = time(NULL); X } X } } X X //*************************************************************************** // void Gopher::read_binary() // void Gopher::read_binary() { X datatype = TYPE_BINARY; X strcpy(filename, "/tmp/gophXXXXXX"); X fd = mkstemp(filename); X length = 0; X gwindow->status("Waiting for first data to arrive..."); X (void) notify_set_input_func((Notify_client) this, (Notify_func) read_binary_proc, connection->get_socket()); } X X //*************************************************************************** // void Gopher::read_binary_proc(Gopher *gopher, int ifd) // void Gopher::read_binary_proc(Gopher *gopher, int ifd) { X char buffer[INPUT_BUF_SIZE]; X static time_t last = 0; X X int n = gopher->connection->read_partial(buffer, INPUT_BUF_SIZE); X if (n <= 0) X { X // X // End of file reached. X // X ::close(gopher->fd); X (void) notify_set_input_func((Notify_client) gopher, NOTIFY_FUNC_NULL, ifd); X gopher->connection->close(); X gopher->gwindow->display(); X sprintf(buffer, "Total of %d bytes", gopher->length); X gopher->gwindow->status(buffer); X } X else X { X ::write(gopher->fd, buffer, n); X gopher->length += n; X if (last < time(NULL)) X { X char status[40]; X sprintf(status, "%d byte%s...", gopher->length, gopher->length == 1 ? "" : "s"); X gopher->gwindow->status(status); X last = time(NULL); X } X } } X X SHAR_EOF chmod 0664 Gopher.cc || echo 'restore of Gopher.cc failed' Wc_c="`wc -c < 'Gopher.cc'`" test 8621 -eq "" || echo 'Gopher.cc: original size 8621, current size' "" fi # ============= List.cc ============== if test -f 'List.cc' -a X"$1" != X"-c"; then echo 'x - skipping List.cc (File already exists)' else echo 'x - extracting List.cc (Text)' sed 's/^X//' << 'SHAR_EOF' > 'List.cc' && // // List.cc // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // Implementation of the List class // #include "List.h" X #define NULL ((void *) 0) X X //*************************************************************************** // List::List() // List::List() { X first = last = current = (Object *) 0; X size = 0; } X X //*************************************************************************** // List::~List() // List::~List() { X if (first) X { X Object *obj; X start_get(); X while (obj = get_next()) X { X delete obj; X } X } } X X //*************************************************************************** // void List::add(Object *obj) // PURPOSE: // Add an object to the list. The adding will be done at the end of the // list. void List::add(Object *obj) { X if (!first) X { X // X // The list is empty. Easy! Just put the object in it. X // X first = last = obj; X obj->Next((Object *) 0); X obj->Previous((Object *) 0); X } X else X { X // X // There is something already in the list. Just append it X // X last->Next(obj); X obj->Previous(last); X obj->Next((Object *) 0); X last = obj; X } X size++; } X X //*************************************************************************** // void List::start_get() // PURPOSE: // Prepare the list for itteration. This needs to be called so that // get_next() will return the first element of the list // void List::start_get() { X current = first; } X X //*************************************************************************** // Object *List::get_next() // PURPOSE: // Return the next object in the list // Object *List::get_next() { X if (current) X { X Object *temp = current; X current = current->Next(); X return temp; X } X else X return (Object *) 0; } X SHAR_EOF chmod 0644 List.cc || echo 'restore of List.cc failed' Wc_c="`wc -c < 'List.cc'`" test 1821 -eq "" || echo 'List.cc: original size 1821, current size' "" fi # ============= Preferences.cc ============== if test -f 'Preferences.cc' -a X"$1" != X"-c"; then echo 'x - skipping Preferences.cc (File already exists)' else echo 'x - extracting Preferences.cc (Text)' sed 's/^X//' << 'SHAR_EOF' > 'Preferences.cc' && // // Preferences.cc // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // Implementation of the Preferences class // #include "Preferences.h" #include "xvgopher.h" #include <stdlib.h> #include <fstream.h> #include <xview/xview.h> #include <xview/defaults.h> X X //*************************************************************************** // Preferences::Preferences() // Preferences::Preferences() { X // X // Get the path to the .xvgopher-defaults file in the user's home directory X // X char *home = getenv("HOME"); X if (!home) X home = "."; X char filename[100]; X sprintf(filename, "%s/.xvgopher-defaults", home); X X // X // Read in any values from it X // X defaults_load_db(filename); X X // X // Now get the values we are interested in. X // X remove_children = defaults_get_boolean("xvgopher.removeclients", "XvGopher.RemoveClients", FALSE); X popup_bookmarks = defaults_get_boolean("xvgopher.popupbookmarks", "XvGopher.PopupBookmarks", FALSE); X mail_filter = strdup(defaults_get_string("xvgopher.mailfilter", "XvGopher.MailFilter", DEFAULT_MAILER)); X print_filter = strdup(defaults_get_string("xvgopher.printfilter", "XvGopher.PrintFilter", DEFAULT_PRINT_FILTER)); X play_filter = strdup(defaults_get_string("xvgopher.playfilter", "XvGopher.PlayFilter", DEFAULT_PLAYER)); X image_filter = strdup(defaults_get_string("xvgopher.imagefilter", "XvGopher.ImageFilter", DEFAULT_IMAGER)); X telnet_command = strdup(defaults_get_string("xvgopher.telnetcommand", "XvGopher.TelnetCommand", DEFAULT_TELNET)); } X X //*************************************************************************** // Preferences::~Preferences() // Preferences::~Preferences() { X // X // Get the path to the .xvgopher-defaults file in the user's home directory X // X char *home = getenv("HOME"); X if (!home) X home = "."; X char filename[100]; X sprintf(filename, "%s/.xvgopher-defaults", home); X X ofstream out(filename); X if (out.fail()) X return; X X static char *truth[2] = {"False", "True"}; X X // X // Write the things we know about to the file X // X out << "XvGopher.RemoveClients:\t" << truth[remove_children] << "\n"; X out << "XvGopher.PopupBookmarks:\t" << truth[popup_bookmarks] << "\n"; X out << "XvGopher.MailFilter:\t" << mail_filter << "\n"; X out << "XvGopher.PrintFilter:\t" << print_filter << "\n"; X out << "XvGopher.PlayFilter:\t" << play_filter << "\n"; X out << "XvGopher.ImageFilter:\t" << image_filter << "\n"; X out << "XvGopher.TelnetCommand:\t" << telnet_command << "\n"; X out.close(); X X // X // For good measures, we should delete the storage used by the preferences X // X delete mail_filter; X delete print_filter; X delete play_filter; X delete image_filter; X delete telnet_command; } X X //*************************************************************************** // int Preferences::get_remove_children() // int Preferences::get_remove_children() { X return remove_children; } X X //*************************************************************************** // void Preferences::set_remove_children(int x) // void Preferences::set_remove_children(int x) { X remove_children = x != 0; } X X //*************************************************************************** // int Preferences::get_popup_bookmarks() // int Preferences::get_popup_bookmarks() { X return popup_bookmarks; } X X //*************************************************************************** // void Preferences::set_popup_bookmarks(int x) // void Preferences::set_popup_bookmarks(int x) { X popup_bookmarks = x != 0; } X X //*************************************************************************** // char *Preferences::get_mail_filter() // char *Preferences::get_mail_filter() { X return mail_filter; } X X //*************************************************************************** // void Preferences::set_mail_filter(char *s) // void Preferences::set_mail_filter(char *s) { X delete mail_filter; X mail_filter = strdup(s); } X X //*************************************************************************** // char *Preferences::get_print_filter() // char *Preferences::get_print_filter() { X return print_filter; } X X //*************************************************************************** // void Preferences::set_print_filter(char *s) // void Preferences::set_print_filter(char *s) { X delete print_filter; X print_filter = strdup(s); } X X //*************************************************************************** // char *Preferences::get_play_filter() // char *Preferences::get_play_filter() { X return play_filter; } X X //*************************************************************************** // void Preferences::set_play_filter(char *s) // void Preferences::set_play_filter(char *s) { X delete play_filter; X play_filter = strdup(s); } X X //*************************************************************************** // char *Preferences::get_image_filter() // char *Preferences::get_image_filter() { X return image_filter; } X X //*************************************************************************** // void Preferences::set_image_filter(char *s) // void Preferences::set_image_filter(char *s) { X delete image_filter; X image_filter = strdup(s); } X X //*************************************************************************** // char *Preferences::get_telnet_command() // char *Preferences::get_telnet_command() { X return telnet_command; } X X //*************************************************************************** // void Preferences::set_telnet_command(char *s) // void Preferences::set_telnet_command(char *s) { X delete telnet_command; X telnet_command = strdup(s); } X X SHAR_EOF chmod 0664 Preferences.cc || echo 'restore of Preferences.cc failed' Wc_c="`wc -c < 'Preferences.cc'`" test 5632 -eq "" || echo 'Preferences.cc: original size 5632, current size' "" fi # ============= Response.cc ============== if test -f 'Response.cc' -a X"$1" != X"-c"; then echo 'x - skipping Response.cc (File already exists)' else echo 'x - extracting Response.cc (Text)' sed 's/^X//' << 'SHAR_EOF' > 'Response.cc' && // // Response.cc // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // Implementation of the Response class // #include "Response.h" #include <string.h> #include <stdio.h> X X //*************************************************************************** // Response::Response() // Response::Response() { X words[0] = NULL; X wordcount = 0; } X X //*************************************************************************** // Response::Response(Response *r) // Response::Response(Response *r) { X for (wordcount = 0; wordcount < r->wordcount; wordcount++) X words[wordcount] = strdup(r->words[wordcount]); X type = r->type; } X X //*************************************************************************** // Response::Response(char *str) // Response::Response(char *str) { X words[0] = NULL; X wordcount = 0; X X set(str); } X X //*************************************************************************** // Response::~Response() // Response::~Response() { X for (int i = 0; i < wordcount; i++) X if (words[i]) X delete words[i]; } X X //*************************************************************************** // int Response::set(char *str) // int Response::set(char *str) { X extern char *good_strtok(char *, char *); X char *temp = strdup(str); X X type = *temp; X char *token = good_strtok(temp + 1, "\t\r\n"); X if (!token) X { X delete temp; X return 0; X } X words[0] = strdup(token); X for (wordcount = 1; (token = good_strtok((char *) 0, "\t\r\n")); wordcount++) X words[wordcount] = strdup(token); X delete temp; X return wordcount; } X X //*************************************************************************** // char *Response::get_nth(int n) // char *Response::get_nth(int n) { X if (n >= wordcount || n < 0) X return (char *) 0; X else X return words[n]; } X X //*************************************************************************** // void Response::set_nth(int n, char *str) // void Response::set_nth(int n, char *str) { X if (n >= MAX_WORDS || n < 0) X return; X else X { X words[n] = strdup(str); X if (n >= wordcount) X wordcount = n + 1; X } } X X //*************************************************************************** // void Response::set_nth(int n, int x) // void Response::set_nth(int n, int x) { X if (n >= MAX_WORDS || n < 0) X return; X else X { X char buffer[20]; X sprintf(buffer, "%d", x); X words[n] = strdup(buffer); X if (n >= wordcount) X wordcount = n + 1; X } } X X SHAR_EOF chmod 0644 Response.cc || echo 'restore of Response.cc failed' Wc_c="`wc -c < 'Response.cc'`" test 2479 -eq "" || echo 'Response.cc: original size 2479, current size' "" fi # ============= cursor.cc ============== if test -f 'cursor.cc' -a X"$1" != X"-c"; then echo 'x - skipping cursor.cc (File already exists)' else echo 'x - extracting cursor.cc (Text)' sed 's/^X//' << 'SHAR_EOF' > 'cursor.cc' && // // cursor.cc // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // This file deals with the different cursors which may be used // #include <xview/xview.h> #include <xview/svrimage.h> #include <xview/cursor.h> #include <xview/notify.h> X X static Cursor busy_cursor[2]; static Server_image busy_image[2]; static Cursor old_cursor; static int current_cursor = 0; X #define BLINK_DELAY 200000 X static unsigned short busy1_bits[] = { #include "icons/gopher1" }; X static unsigned short busy2_bits[] = { #include "icons/gopher2" }; X //*************************************************************************** // void init_cursors() // static void init_cursors() { X static int had_init = FALSE; X X if (had_init) X return; X X had_init = TRUE; X X busy_image[0] = (Server_image) xv_create(NULL, SERVER_IMAGE, X XV_WIDTH, 64, X XV_HEIGHT, 64, X SERVER_IMAGE_BITS, busy1_bits, X NULL); X busy_cursor[0] = (Cursor) xv_create(NULL, CURSOR, X CURSOR_IMAGE, busy_image[0], X CURSOR_XHOT, 32, X CURSOR_YHOT, 32, X NULL); X busy_image[1] = (Server_image) xv_create(NULL, SERVER_IMAGE, X XV_WIDTH, 64, X XV_HEIGHT, 64, X SERVER_IMAGE_BITS, busy2_bits, X NULL); X busy_cursor[1] = (Cursor) xv_create(NULL, CURSOR, X CURSOR_IMAGE, busy_image[1], X CURSOR_XHOT, 32, X CURSOR_YHOT, 32, X NULL); } X X //*************************************************************************** // Server_image get_gopher(int n) // Server_image get_gopher(int n) { X return busy_image[n]; } X X static int isbusy = FALSE; X //*************************************************************************** // static Notify_value blink_cursor(Frame frame, int which) // Notify_value blink_cursor(Frame frame, int which) { X which = which; X X current_cursor ^= 1; X X Xv_opaque sub; X int n = 1; X while ((sub = (Xv_opaque) xv_get(frame, FRAME_NTH_SUBWINDOW, n)) != NULL) X { X xv_set(sub, X WIN_CURSOR, busy_cursor[current_cursor], X NULL); X n++; X } X return (Notify_value) 0; } X X //*************************************************************************** // void frame_busy(Frame frame) // void frame_busy(Frame frame) { X notify_dispatch(); X if (isbusy) X return; X isbusy = TRUE; X init_cursors(); X old_cursor = (Cursor) xv_get(frame, WIN_CURSOR); X xv_set(frame, X FRAME_BUSY, TRUE, X NULL); X X // X // Now go through all sub windows and change their cursor X // X Xv_opaque sub; X int n = 1; X while ((sub = (Xv_opaque) xv_get(frame, FRAME_NTH_SUBWINDOW, n)) != NULL) X { X xv_set(sub, X WIN_CURSOR, busy_cursor[0], X NULL); X n++; X } X X // X // Start the timer to change the cursor icon every once in a while X // X struct itimerval timer; X timer.it_value.tv_usec = BLINK_DELAY; X timer.it_value.tv_sec = 0; X timer.it_interval.tv_usec = BLINK_DELAY; X timer.it_interval.tv_sec = 0; X notify_set_itimer_func(frame, (Notify_func) blink_cursor, ITIMER_REAL, &timer, NULL); } X X //*************************************************************************** // void frame_unbusy(Frame frame) // void frame_unbusy(Frame frame) { X // X // First stop the interval timer which is blinking the cursor X // X notify_set_itimer_func(frame, NOTIFY_FUNC_NULL, ITIMER_REAL, NULL, NULL); X X notify_dispatch(); X if (!isbusy) X return; X isbusy = FALSE; X init_cursors(); X xv_set(frame, X FRAME_BUSY, FALSE, X NULL); X X // X // Now go through all sub windows and change their cursor X // X Xv_opaque sub; X int n = 1; X while ((sub = (Xv_opaque) xv_get(frame, FRAME_NTH_SUBWINDOW, n)) != NULL) X { X xv_set(sub, X WIN_CURSOR, old_cursor, X NULL); X n++; X } } X X SHAR_EOF chmod 0644 cursor.cc || echo 'restore of cursor.cc failed' Wc_c="`wc -c < 'cursor.cc'`" test 3627 -eq "" || echo 'cursor.cc: original size 3627, current size' "" fi # ============= icons.cc ============== if test -f 'icons.cc' -a X"$1" != X"-c"; then echo 'x - skipping icons.cc (File already exists)' else echo 'x - extracting icons.cc (Text)' sed 's/^X//' << 'SHAR_EOF' > 'icons.cc' && // // icons.cc // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // This file defines all the glyphs used in the xvgopher program // #include <xview/xview.h> #include <xview/svrimage.h> #include "icons.h" X static unsigned short bin_bits[] = { #include "icons/bin" }; static unsigned short cso_bits[] = { #include "icons/cso" }; static unsigned short dir_bits[] = { #include "icons/dir" }; static unsigned short doc_bits[] = { #include "icons/doc" }; static unsigned short dos_bits[] = { #include "icons/dos" }; static unsigned short error_bits[] = { #include "icons/error" }; static unsigned short idx_bits[] = { #include "icons/idx" }; static unsigned short mac_bits[] = { #include "icons/mac" }; static unsigned short tel_bits[] = { #include "icons/tel" }; static unsigned short unknown_bits[] = { #include "icons/unknown" }; static unsigned short uu_bits[] = { #include "icons/uu" }; static unsigned short sound_bits[] = { #include "icons/sound" }; static unsigned short image_bits[] = { #include "icons/image" }; static unsigned short info_bits[] = { #include "icons/info" }; static unsigned short info_dragging_bits[] = { #include "icons/info_dragging" }; X X struct { X unsigned char type; X Server_image image; X unsigned short *bits; } icons[] = { X {'.', NULL, unknown_bits}, X {'0', NULL, doc_bits}, X {'1', NULL, dir_bits}, X {'2', NULL, cso_bits}, X {'3', NULL, error_bits}, X {'4', NULL, mac_bits}, X {'5', NULL, dos_bits}, X {'6', NULL, uu_bits}, X {'7', NULL, idx_bits}, X {'8', NULL, tel_bits}, X {'9', NULL, bin_bits}, X {'s', NULL, sound_bits}, X {'I', NULL, image_bits}, X {'g', NULL, image_bits}, X X // X // The following are images used by other parts of xvgopher. They are X // identified by characters with the high bit set. X // X {'i' | 0x80, NULL, info_bits}, X {'d' | 0x80, NULL, info_dragging_bits}, X {'\0', NULL, NULL} }; X X //*************************************************************************** // void icon_init() // void icon_init() { X static int had_init = FALSE; X if (had_init) X return; X had_init = TRUE; X X for (int i = 0; icons[i].type; i++) X { X icons[i].image = (Server_image) xv_create(NULL, SERVER_IMAGE, X XV_WIDTH, 16, X XV_HEIGHT, 16, X SERVER_IMAGE_BITS, icons[i].bits, X NULL); X } } X X //*************************************************************************** // Server_image get_image(char type) // Server_image get_image(char type) { X icon_init(); X X // X // Search through the list of icons to find the right one... X // X for (int i = 0; icons[i].type; i++) X { X if (icons[i].type == (unsigned char) type) X return icons[i].image; X } X X // X // Nothing found. Return the unknown icons X // X return icons[0].image; } X SHAR_EOF chmod 0664 icons.cc || echo 'restore of icons.cc failed' Wc_c="`wc -c < 'icons.cc'`" test 2754 -eq "" || echo 'icons.cc: original size 2754, current size' "" fi # ============= main.cc ============== if test -f 'main.cc' -a X"$1" != X"-c"; then echo 'x - skipping main.cc (File already exists)' else echo 'x - extracting main.cc (Text)' sed 's/^X//' << 'SHAR_EOF' > 'main.cc' && // // main.cc // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // Main program for xvgopher // #include "xvgopher.h" #include "GWindow.h" #include "Preferences.h" #include <xview/xview.h> X X Preferences preferences; X static int error_proc() { X abort(); X return XV_OK; } X X //*************************************************************************** // main(int ac, char **av) // main(int ac, char **av) { X char *server = GOPHER_SERVER; X char *port = "70"; X X xv_init(XV_INIT_ARGC_PTR_ARGV, &ac, av, X XV_ERROR_PROC, error_proc, X NULL); X X switch (ac) X { X case 2: // A machine was specified X server = av[1]; X break; X case 3: // A machine and port were specified X server = av[1]; X port = av[2]; X break; X } X X Response *r = new Response("1"); X r->set_server(server); X r->set_port(port); X GWindow *main_window = CreateWindow(r); X X if (main_window) X main_window->main_loop(); X X return 0; } SHAR_EOF chmod 0664 main.cc || echo 'restore of main.cc failed' Wc_c="`wc -c < 'main.cc'`" test 996 -eq "" || echo 'main.cc: original size 996, current size' "" fi # ============= Config.h ============== if test -f 'Config.h' -a X"$1" != X"-c"; then echo 'x - skipping Config.h (File already exists)' else echo 'x - extracting Config.h (Text)' sed 's/^X//' << 'SHAR_EOF' > 'Config.h' && // // Config.h // // This class deals with configuration. All configurable options are kept in this class // #ifndef _Config_h_ #define _Config_h_ X #include "List.h" X X class Config { public: X // X // Constructor X // X Config(); X X // X // Configuration file access X // X void read(); X int write(); X X // X // Configuration parameters. These are directly accessible to make it easier. X // X List bookmarks; X String server; X int port; private: }; X #endif _Config_h_ SHAR_EOF chmod 0644 Config.h || echo 'restore of Config.h failed' Wc_c="`wc -c < 'Config.h'`" test 486 -eq "" || echo 'Config.h: original size 486, current size' "" fi # ============= Connection.h ============== if test -f 'Connection.h' -a X"$1" != X"-c"; then echo 'x - skipping Connection.h (File already exists)' else echo 'x - extracting Connection.h (Text)' sed 's/^X//' << 'SHAR_EOF' > 'Connection.h' && // // Connection.h // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // This class forms a easy to use interface to the berkeley tcp socket library. // All the calls are basically the same, but the parameters do not have any // stray _addr or _in mixed in... // X #if !defined(_Connection_h_) # define _Connection_h_ X #include "xvgopher.h" #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> X class Connection { public: X // Constructors & Destructors X Connection(); X Connection(int socket); X ~Connection(); X X // (De)initialization X int open(int priv = 0); X int close(); X X // Port stuff X int assign_port(int port = 0); X int assign_port(char *service); X int get_port(); X int is_privileged(); X X // Host stuff X int assign_server(char *name); X int assign_server(dword addr = INADDR_ANY); X X // Connection establishment X int connect(); X Connection *accept(int priv = 0); X Connection *accept_privileged(); X X // Registration things X int bind(); X int listen(int n = 5); X X // IO X int write(char *buffer, int length); X int write(char *buffer); X int read(char *buffer, int length); X char *read_line(char *buffer, int length); X int read_partial(char *buffer, int maxlength); X int bytes_available(); X int get_char(); X X // Access to socket number X char *socket_as_string(); X int get_socket(); X int isopen(); X private: X enum X { X BUFFER_SIZE = 1024, X }; X int sock; X struct sockaddr_in server; X char buffer[BUFFER_SIZE]; X int pos, pos_max; }; X X //************************************************************************* // inline int Connection::is_privileged() // PURPOSE: // Return whether the port is priveleged or not. // inline int Connection::is_privileged() { X return server.sin_port < 1023; } X X #endif SHAR_EOF chmod 0644 Connection.h || echo 'restore of Connection.h failed' Wc_c="`wc -c < 'Connection.h'`" test 1949 -eq "" || echo 'Connection.h: original size 1949, current size' "" fi # ============= GWAbout.h ============== if test -f 'GWAbout.h' -a X"$1" != X"-c"; then echo 'x - skipping GWAbout.h (File already exists)' else echo 'x - extracting GWAbout.h (Text)' sed 's/^X//' << 'SHAR_EOF' > 'GWAbout.h' && // // GWAbout.h // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // This class produces a popup window describing the who, what, and where of // xvgopher. // #ifndef _GWAbout_h_ #define _GWAbout_h_ X #include "GWindow.h" X class GWAbout : public GWindow { public: X GWAbout(Frame par); X int open(Response *resp); private: X static void done_proc(Frame); X static void dismiss_proc(Panel_item, Event *); X static Notify_value panel_events(Xv_window, Event *, Notify_arg, Notify_event_type); }; X #endif _GWAbout_h_ SHAR_EOF chmod 0644 GWAbout.h || echo 'restore of GWAbout.h failed' Wc_c="`wc -c < 'GWAbout.h'`" test 620 -eq "" || echo 'GWAbout.h: original size 620, current size' "" fi # ============= GWBinary.h ============== if test -f 'GWBinary.h' -a X"$1" != X"-c"; then echo 'x - skipping GWBinary.h (File already exists)' else echo 'x - extracting GWBinary.h (Text)' sed 's/^X//' << 'SHAR_EOF' > 'GWBinary.h' && // // GWBinary.h // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // This class deals with the getting and saving of ASCII files from // a gopher server. // #ifndef _GWBinary_h_ #define _GWBinary_h_ X #include "GWDownload.h" X class GWBinary : public GWDownload { public: X GWBinary(Frame par); }; X #endif _GWBinary_h_ SHAR_EOF chmod 0644 GWBinary.h || echo 'restore of GWBinary.h failed' Wc_c="`wc -c < 'GWBinary.h'`" test 417 -eq "" || echo 'GWBinary.h: original size 417, current size' "" fi # ============= GWBookmarks.h ============== if test -f 'GWBookmarks.h' -a X"$1" != X"-c"; then echo 'x - skipping GWBookmarks.h (File already exists)' else echo 'x - extracting GWBookmarks.h (Text)' sed 's/^X//' << 'SHAR_EOF' > 'GWBookmarks.h' && // // GWBookmarks.h // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // This class deals with bookmarks and the window that displays them. // #ifndef _GWBookmarks_h_ #define _GWBookmarks_h_ X #include "GWList.h" X class GWBookmarks : public GWList { public: X // X // Constructor/Destructor X // X GWBookmarks(Frame); X ~GWBookmarks(); X X // X // Window creation X // X int open(Response *resp); X void show(); X X // X // Bookmarks access X // X void add(Response *r); X protected: X void row_deselect(int, Response *); X void row_select(int, Response *); X X void read_bookmarks(); X void write_bookmarks(); X X static void remove_bookmark_proc(Menu menu, Menu_item mi); X static void done_proc(Frame); X X // X // The following are used to perform certain specific tasks when creating windows. X // They are split up to make the code more readable and modular X // X void modify_list_menu(); X X Menu_item bookmark_mi; X Menu_item show_info_mi; }; X extern GWBookmarks *bookmarks; X #endif _GWBookmarks_h_ SHAR_EOF chmod 0644 GWBookmarks.h || echo 'restore of GWBookmarks.h failed' Wc_c="`wc -c < 'GWBookmarks.h'`" test 1124 -eq "" || echo 'GWBookmarks.h: original size 1124, current size' "" fi # ============= GWDirectory.h ============== if test -f 'GWDirectory.h' -a X"$1" != X"-c"; then echo 'x - skipping GWDirectory.h (File already exists)' else echo 'x - extracting GWDirectory.h (Text)' sed 's/^X//' << 'SHAR_EOF' > 'GWDirectory.h' && // // GWDirectory.h // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // This class deals with the getting and saving of ASCII files from // a gopher server. // #ifndef _GWDirectory_h_ #define _GWDirectory_h_ X #include "GWList.h" X class GWDirectory : public GWList { public: X GWDirectory(Frame par); X int open(Response *resp); X void display(); X protected: X // X // Callbacks for the XView interface X // #if USE_SAVE X static void save_notify(Panel_item item, Event *); #endif USE_SAVE X static void menu_proc(Menu menu, Menu_item mi); X X // X // The next two callbacks are for the menu attached to the scrolling list X // X static void set_bookmark_proc(Menu menu, Menu_item mi); X X void row_deselect(int, Response *); X void row_select(int, Response *); X X // X // Various window thingies that we need to keep track of X // X Menu_item bookmark_mi; X Menu_item show_info_mi; X X // X // The following are used to perform certain specific tasks when creating windows. X // They are split up to make the code more readable and modular X // X void modify_list_menu(); }; X #endif _GWDirectory_h_ SHAR_EOF chmod 0664 GWDirectory.h || echo 'restore of GWDirectory.h failed' Wc_c="`wc -c < 'GWDirectory.h'`" test 1210 -eq "" || echo 'GWDirectory.h: original size 1210, current size' "" fi # ============= GWDownload.h ============== if test -f 'GWDownload.h' -a X"$1" != X"-c"; then echo 'x - skipping GWDownload.h (File already exists)' else echo 'x - extracting GWDownload.h (Text)' sed 's/^X//' << 'SHAR_EOF' > 'GWDownload.h' && // // GWDownload.h // // (c) Copyright 1993, San Diego State University -- College of Sciences // (See the COPYRIGHT file for more Copyright information) // // This class deals with the getting and saving of ASCII files from // a gopher server. // #ifndef _GWDownload_h_ #define _GWDownload_h_ X #include "GWindow.h" X class GWDownload : public GWindow { public: X GWDownload(Frame par, int type, char *btn, char *btncmd); X GWDownload(Frame par, int type); X