/*
 This software is copyrighted by the University of Pennsylvania.
 Read COPYRIGHT for details.
 */

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <sys/resource.h>
#include <signal.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <limits.h>
#include <string.h>

#include "network.h"
#include "pdb.h"
#include "node.h"
#include "gophernodes.h"

extern int      addednewnodes;
extern int      tables_changed;
extern short    todaysdate;
extern pid_t    savedatastruct_pid;
extern struct   s1 *getnode_bygopherinfo(char **fields);
extern struct   s1 *init_gopher_node (char **fields, long nid, short lastu,
                                     int chkexists);
extern void     nio_send_file(int s, char *fn, long stpt, long req, int isnlist);
extern void     send_empty_document (int s);
extern void     send_empty_menu (int s);
extern char     *nodeinfostr(long nid, struct s1 *node, int flgfmt);


extern CONN     conntab[];
#define conn_established(cn)    (conntab[cn].c_socket != -1)

extern void remove_helper(WAITFORHELPER *ptr)
{
 int i, found;

 if (ptr == NULL)
   return;

 kill (ptr->pid, SIGTERM); /* just in case child is out there */
 do_free (ptr->file);
 do_free (ptr->cachefile);
 /* DONT free the ptr->node, it's part of the datastruct */

 for (i=0, found = 0; !found && i < FD_SETSIZE; ) {
   if (conntab[i].c_hptr == ptr)
     found  = 1;
   else
     i++;
 }
 free (ptr);
 if (found)
   conntab[i].c_hptr = NULL;
 return;
}

int next_id;

/* increments next id in memory + on disk */
/* assumes that get_nextid() has been called already */
static void
inc_nextid(void)
{
 char            line[20];
 int dfd;

 if ((dfd = open(NEXTID_FILE, O_WRONLY | O_TRUNC | O_CREAT)) <= 0)
   {
     printf("error incrementing next id\n");
     return;
   }
 next_id++;
 sprintf(line, "%d\n", next_id);
 write(dfd, line, strlen(line));
 close(dfd);
 return;
}

/* reads the next id from disk */
extern void
 get_nextid(void)
{
 char            line[20];
 int             red;
 int             dfd;

 if ((dfd = open(NEXTID_FILE, O_RDONLY)) <= 0){
   printf("error getting next id\n");
   return;
 }
 red = read(dfd, line, 20);
 if (red <= 0){
   printf("error reading next id\n");
   return;
 }
 line[red] = '\0';
 next_id = atoi(line);
 close(dfd);
 return;
}

static void conv_textfile(FILE *ifile, char *filnam)
{
 FILE        *ofile;
 char        line[NLINE_MAXLEN];
 char        *cp;

 ofile = fopen(filnam, "w");
 if (ofile == NULL) {
   fprintf (stderr, "Unable to open temp nlist file\n");
   perror(filnam);
   return;
 }
 while (fgets (line,NLINE_MAXLEN-1,ifile) != NULL) {
   cp = rindex (line, '\r');
   if (cp)
     if (*(cp+1) == '\n') {
       *cp = '\n';
       *(cp+1) = 0;
     }
   /* gopher protocol: text file ends with a . on a line by itself */
   if (strcmp(line, ".\n") == 0)
     break;
   else
     fprintf (ofile, "%s", line);
 }
 fclose (ofile);
}


static void child_punt (char gophertype, long nodeid, int sock, int flgsfmt)
{
 char *cp;

 if (gophertype == GOPHTYP_TEXT || gophertype == GOPHTYP_GIF ||
     gophertype == GOPHTYP_IMAGE) {
   send_empty_document(sock);
 }
 else if (gophertype == GOPHTYP_MENU) {
   /* send this-
      2:
      0:nodeinfo of node we were working on
      1:nodeinfo of reserved node that says "menu not available"
      */
   cp = (char *) malloc (2*BUFSIZ);
   sprintf (cp, "2:\n0:%s\n", nodeinfostr(nodeid, NULL, flgsfmt));
   strcat (cp, "1:");
   strcat (cp, nodeinfostr(MENU_NOT_AVAILABLE, NULL, flgsfmt));
   strcat (cp, "\n.\r\n");
   sendbuf(cp, strlen(cp), sock);
   /* sendbuf will free cp */
 }
 else {
   send_empty_menu (sock);
 }
}

static int create_cached_nlist (FILE *ifile, char *tempname)
{
 FILE *tempfile;
 char line[BUFSIZ];
 char *gophfields[NUMFIELDS_GOPHER];
 int numf;
 struct s1 *node;
 int numlines;

 tempfile = fopen (tempname, "w");
 if (tempfile == NULL) {
   fprintf (stderr, "Unable to write temp output nlist file\n");
   perror (tempname);
   return 0;
 }

 /* ifile is an already open FILE */
 for (rewind (ifile), numlines = 0;
      fgets(line, sizeof(line)-1, ifile) != NULL; ) {
   if (*line != GOPHTYP_DUPSRV) {
     parsefields (line, gophfields, &numf, GOPHER_DLM, NUMFIELDS_GOPHER);
     if (numf >= NUMFIELDS_GOPHER) {
       node = getnode_bygopherinfo(gophfields);
       if (node == NULL) {  /* create a new node in tables */
         get_nextid();
         node = init_gopher_node (gophfields, next_id, todaysdate, 0);
         inc_nextid();
         addednewnodes++;
         tables_changed++;
       }

       /*    gopher info is already known, therefore just use the existing nodeid */

       fprintf (tempfile, "%ld\n", node->nodeid);
       numlines++;
     }   /* enough gopher fields */
   }     /* it wasn't a dupl server line */
 }    /* foreach line of ifile */
 fclose (tempfile);
 return 1;
}





static int find_helper_conn (pid_t pid)
{
 int found;
 int con;

 for (found = 0, con = 0; con < FD_SETSIZE && !found;) {
   if (conn_established(con) && (conntab[con].c_hptr) &&
       (conntab[con].c_hptr)->pid == pid) {
     found = 1;
   }
   else
     con++;
 }
 if (!found)
   return -1;
 else
   return con;
}


extern void catch_child (void)
{
 pid_t pid;
 union wait status;
 struct rusage rusage;
 int c, found;
 FILE *childfile;
 WAITFORHELPER *hptr;
 char *filename2;
 sigset_t currmask;

 pid = wait3 (&status, WNOHANG, &rusage);

 if (pid == 0) {
   fprintf (stderr, "Funny, wait3 returned pid 0!\n");
   return;  /* don't know if there's a connect out there waiting */
 }
 else if (pid < 0) {
   fprintf (stderr, "wait3 returned %d\n", pid);
   perror ("wait3");
   return;   /* don't know if there's a connect out there waiting */
 }

 /* (pid > 0) */

 fprintf (stderr, "\nT=%d.  Caught pid %d, exitstat = %d.  ",
          time(0), pid, WEXITSTATUS(status));

 if ((c=find_helper_conn (pid)) < 0) {
   if (pid != savedatastruct_pid)
     fprintf (stderr, "Unknown what connection %d went with\n", pid);
   else {
     savedatastruct_pid = 0;
     fprintf(stderr, "save_datastruct child.\n");
   }
   return;
 }
 else
   fprintf (stderr, "Goes with conn #%d, sock %d\n",  c, conntab[c].c_socket);


 hptr = conntab[c].c_hptr;
 /* Assumption: c_hptr->node still points to a valid node in a1[] */

 /* if child exited with non-zero status, must be an error */
 if (WEXITSTATUS(status) != 0) {
   child_punt((hptr->node)->gophertype, (hptr->node)->nodeid,
              conntab[c].c_socket, conntab[c].c_output_fmt);
   unlink (hptr->file);
   return;
 }

 childfile = fopen (hptr->file,"r");
 if (childfile == NULL) {  /* File wasn't there ??? */
   fprintf (stderr, "Could not open child's output file\n");
   perror (hptr->file);
   child_punt ((hptr->node)->gophertype, (hptr->node)->nodeid,
               conntab[c].c_socket, conntab[c].c_output_fmt);
   return;
 }
 else {
   filename2 = tempnam(CACHEDIR, "convert");
   /* has to be the same dir as the cache because rename() needs that */

   switch ((hptr->node)->gophertype) {
   case GOPHTYP_IMAGE:
   case GOPHTYP_GIF:
     /* No conversion is needed for GIF files */
     fclose (childfile);
     rename (hptr->file, hptr->cachefile);
     nio_send_file(conntab[c].c_socket, hptr->cachefile,
                   hptr->startpoint, hptr->requested, 0);
     remove_helper(hptr);
     do_free(filename2);
     break;

   case GOPHTYP_TEXT:
     conv_textfile (childfile, filename2);
     rename (filename2, hptr->cachefile);
     nio_send_file(conntab[c].c_socket, hptr->cachefile,
                   hptr->startpoint, hptr->requested, 0);
     fclose (childfile); /* conv_... did NOT close file */
     unlink (hptr->file); /* remove child's file */
     remove_helper(hptr);
     do_free (filename2);
     break;

   case GOPHTYP_MENU:
   case GOPHTYP_SEARCH:
     if (!create_cached_nlist (childfile, filename2)) {
       child_punt((hptr->node)->gophertype,
                  (hptr->node)->nodeid,
                  conntab[c].c_socket, conntab[c].c_output_fmt);
     }
     else {
       rename (filename2, hptr->cachefile);
       send_cached_nlist (hptr->node, conntab[c].c_socket, hptr->cachefile,
                          conntab[c].c_output_fmt);
     }
     fclose (childfile);
     unlink (hptr->file);  /* remove child's file from the filesystem */
     remove_helper(hptr);  /* remove the buf associated with child */
     do_free(filename2);
     break;

   default:
     fprintf (stderr, "catch_child() doesn't handle type '%c'.",
              (hptr->node)->gophertype);
     child_punt ((hptr->node)->gophertype, (hptr->node)->nodeid,
                 conntab[c].c_socket, conntab[c].c_output_fmt);
     fclose (childfile); /* close file */
     unlink (hptr->file); /* remove child's file */
     remove_helper(hptr);
     do_free (filename2);
     break;
   }
 } /* childfile was okay */
}

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.