/* -------------------------------------------------
*       g2fd.c          Gopher to FTP gateway daemon.
*       Version 0.3 Hacked up: April 1992.  Farhad Anklesaria.
*       Based on a Perl story by John Ladwig.
*       Based on a Perl story by Farhad Anklesaria.
*
*       To be run by inetd.
*       For installation, read the companion README.... or
*       if you don't feel like doing that, the brief instructions
*       are below:
*
*       First edit the local parameters in defines below.
*       Then do a "make g2fd"
*       Then place the binary (g2fd) in some reasonable place,
*               eg in /usr/local/bin
*       Finally, edit /etc/services and /etc/servers or
*               /etc/inetd.conf as the case may be.  Kill
*               and restart inetd.
*
*       This file looks best with tabstops set to 4 rather than 8.
---------------------------------------------------- */

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <signal.h>
/*==============Local parameters to be edited in===============*/
#define LOCALHOST       "hell.micro.umn.edu"    /* This host's domain name */
#define LOCALPORT       70                                      /* This daemon's port */
#define MAXLOAD         8.0                                             /* For load limit if > 1 */
#define FTP                     "/usr/ucb/ftp"                  /* To invoke ftp */
#define UPTIME          "/usr/ucb/uptime"               /* To check loadavg.  Ick. */
#define LIST            "/tmp/gftpL+"                   /* Temp list file prefix */
#define DATA            "/tmp/gftpD+"                   /* Temp data file prefix */
/*=============================================================*/

#define GFILE   0               /* Gopher item types */
#define GDIR    1
#define GBINHEX 4
#define GDOSB   5
#define GUNIXB  9

#define SLEN    255             /* Generic small buffer length */
#define TMOUT   1200    /* 20 minutes is plenty long enough */

char    *appname;
char    ftp[SLEN] = FTP;
char    myName[SLEN] = LOCALHOST;
char    tmpList[SLEN] = LIST;
char    tmpData[SLEN] = DATA;
char    query[BUFSIZ];                          /* input redirected by inetd */
char    *host, *thing;                          /* pointers into query */
int             gettingFile = 1;
int             gettingBinary = 0;
int             childpid;

main(argc, argv)
       int argc;
       char * argv[];

{
       char buf[BUFSIZ];
       int pid, Cleanup();


       appname = argv[0];
       GenerateUniqueFiles(tmpList, tmpData);

       if ((childpid = fork()) == -1) {
               Abort("Can't fork.");
       } else if (childpid != 0) {   /* We are the parent and we wait*/
               WaitForChild();
       }

       /* If we get here we are the child and we can do some work */
       signal(SIGPIPE, Cleanup);  /* This and the extra fork is paranoia */
       if (LoadTooHigh())
                       Abort("Too many connections.  Try again later.");
       gets(query);                                    /* Courtesy of inetd */

       SendQuery(query);
       TranslateResults();
       Cleanup();
       exit(0);

}

/*--------------------------------*/

WaitForChild()
{
       int status, RoundEmUp();

       signal(SIGALRM, RoundEmUp);
       alarm(TMOUT);
       wait(&status);
       exit(status);
}

/*--------------------------------*/
LoadTooHigh()
{
       char stuff[SLEN];   float load; char *t;
       FILE *fd, *popen();

       if (MAXLOAD <= 1.0) return(0);

       if (((fd = popen(UPTIME, "r")) == NULL) ||
               (fgets(stuff, sizeof stuff, fd) == NULL))
                       Abort("Can't determinine load average.");
       pclose(fd);
       t = strtok(stuff, " \t");
       while ((t != NULL) && (strcasecmp(t, "average:") != 0)) {
               t = strtok(NULL, " \t");
       }
       if (t == NULL) Abort("Can't determinine load average.");
       t = strtok(NULL, " \t");
       sscanf(t, "%f", &load);
       return(load > MAXLOAD);
}

/*--------------------------------*/

SendQuery(query)
       char *query;

{
       int sLen, termCh;
       char *at;
       FILE *fd, *popen();

       /*  printf("The full query was %s\n", query);  Debug  */

       if ((sLen = strlen(query)) <= 2) Abort("No host name specified.");
       query[--sLen] = '\0';                   /* Knock off the CR: host@path/<cr>*/
       host = query;
       at = strchr(query, '@');
       if (at == NULL) Abort("Not a valid ftp query.");
       thing = at + 1;
       *at = '\0';                     /*Sneakily chop it into two strings*/
       sprintf(ftp + strlen(ftp), " -n %s > %s", host, tmpList);
       if ((fd = popen(ftp, "w")) == NULL) Abort("Can't run ftp.");
       FailErr(fprintf(fd, "user anonymous gopher@%s\n", LOCALHOST));

       sLen = strlen(thing);
       termCh = thing[sLen - 1];                       /* Grab possible end char: / etc */
       if ((termCh == '*') || (termCh == '@'))    /*  || (termCh == '/')  */
               thing[sLen - 1] = '\0';
       /* printf("At this point host: %s   thing: %s\n", host, thing); */
       if (termCh == '/') {    /* We have a directory */
               gettingFile = 0;
               if (strlen(thing) > 0) FailErr(fprintf(fd, "cd \"%s\"\n", thing));
               FailErr(fprintf(fd, "ls -F\n"));
       } else {                                /* We have a file */
               gettingFile = 1;
               if (gettingBinary = IsBinaryType(thing))
                               FailErr(fprintf(fd, "binary\n"));
               FailErr(fprintf(fd, "get \"%s\" \"%s\"\n", thing, tmpData));
       }
       FailErr(fprintf(fd, "quit\n"));
       pclose(fd);


}

/*--------------------------------*/

TranslateResults()
{
       FILE *fp, *OpenOrDie();
       char buf[BUFSIZ], theName[SLEN];
       int fd, nRead, checkIt;

       checkIt = 1;
       if (gettingFile) {
               if (gettingBinary) {                            /* icky binary file */
                       /* printf("Whoa!  That's a binary file\n"); */
                       fd = open(tmpData, "r");
                       while ((nRead = read(fd, buf, sizeof buf)) > 0) {
                               write(1, buf, nRead);
                       }
                       close(fd);
               } else {                                                        /* must be a nice texty file */
                       fp = OpenOrDie(tmpData, "r");
                       while (fgets(buf, sizeof buf, fp) != NULL) {
                               if (checkIt) { /* Just peek at it once */
                                       checkIt = 0;
                                       if (NotText(buf)) {
                                               fclose(fp);
                                               Abort("Sorry.  File does not appear to contain text.");
                                       }
                               }
                               buf[strlen(buf) - 1] = '\0';    /* munge LF */
                               FailErr(printf("%s\r\n", buf));
                       }
                       fclose(fp);
                       FailErr(printf(".\r\n"));
               }
       } else {                                                /* Must be a directory */
               fp = OpenOrDie(tmpList, "r");
               while (fgets(buf, sizeof buf, fp) != NULL) {
                       GopherType(buf, theName);
                       FailErr(printf("%s\t%s@%s%s\t%s\t%d\r\n", theName, host, thing,
                                       buf, myName, LOCALPORT));
               }
               fclose(fp);
               FailErr(printf(".\r\n"));
       }
}

/*--------------------------------*/

FILE *OpenOrDie(file, mode)
       char *file, *mode;
{
       FILE *fp, *fopen();
       if ((fp = fopen(file, mode)) != NULL) {
               return(fp);
       } else {
               Abort("Could not complete the transfer.");
       }
}

/*--------------------------------*/
NotText(buf)
       char * buf;
{
       int max;   char *c;

       if ((max = strlen(buf)) >= (BUFSIZ - 50)) max = BUFSIZ - 50;
       for (c = buf; c < (buf + max); c++) {
               if (*c > '~') return(1);
       }
       return(0);
}

/*--------------------------------*/

Abort(complaint)
       char *complaint;

{
       printf("3 Error: %s\r\n.\r\n", complaint);
       Cleanup();
       exit(1);
}

/*--------------------------------*/

IsBinaryType(thing)
       char *thing;
{
       static char *binExt[] = {
               ".zip", ".zoo", ".arj", ".arc", ".lzh", ".hyp", ".pak", ".exe", ".com",
               ".ps", ".gif", ".pict", ".pct", ".tiff", ".tif", ".tar", ".Z"
       };

       int extType, i;

       for (extType = 0; extType < 17; extType++) {
               i = strcasecmp(thing + strlen(thing) - strlen(binExt[extType]),
                                               binExt[extType]);
               if (i == 0) return(1);
       }
       return(0);

}

/*--------------------------------*/

GenerateUniqueFiles(tmpList, tmpData)
       char *tmpList, *tmpData;
{
       char *s;
       int pid;

       pid = getpid();
       s = strchr(tmpList, '+');
       sprintf(s, "%d", pid);
       s = strchr(tmpData, '+');
       sprintf(s, "%d", pid);
}

/*--------------------------------*/

GopherType(buf, theName)
       char *buf, *theName;

{
       static char ext4[] = ".hqx";
       static char *ext5[] = {".zip", ".zoo", ".arj", ".arc", ".lzh", ".hyp",
                                               ".pak", ".exe", ".com", ".ps", ".gif", ".pict",
                                               ".pct", ".tiff", ".tif"};
       static char *ext9[] = {".tar", ".Z"};
       int extType, i, last;
       char    tmpName[SLEN];

       last = strlen(buf) - 1;     buf[last--] = '\0';  /* Munge the LF */
       strcpy(tmpName, buf);
       if (buf[last] == '/') {
               tmpName[last] = '\0';
               sprintf(theName, "%d%s", GDIR, tmpName);
               return;
       }
       if ((buf[last] == '*') || (buf[last] == '@')) {         /* Hack out * and @ */
               buf[last] = '\0';
               tmpName[last] = '\0';
       }

       /* At this point we're looking at a file */
       if (strcasecmp(buf + strlen(buf) - strlen(ext4), ext4) == 0) { /* BinHex? */
               sprintf(theName, "%d%s", GBINHEX, tmpName);
               return;
       }

       for (extType = 0; extType < 15; extType++) {                    /* PC garbage? */
               i = strcasecmp(buf + strlen(buf) - strlen(ext5[extType]),
                                               ext5[extType]);
               if (i == 0) {
                       sprintf(theName, "%d%s", GDOSB, tmpName);
                       return;
               }
       }

       for (extType = 0; extType < 2; extType++) {                             /* unix binary? */
               i = strcasecmp(buf + strlen(buf) - strlen(ext9[extType]),
                                               ext9[extType]);
               if (i == 0) {
                       sprintf(theName, "%d%s", GUNIXB, tmpName);
                       return;
               }
       }

       sprintf(theName, "%d%s", GFILE, tmpName);
       return;         /* Some other and hopefully text file */
}

/*--------------------------------*/

Cleanup()
{
       unlink(tmpList);
       unlink(tmpData);
       exit(1);
}

/*--------------------------------*/

RoundEmUp()
{

       kill(childpid, SIGKILL);
       Cleanup();
}

/*--------------------------------*/

FailErr(result)
       int result;
{
       if (result < 0) {
               Cleanup();
       }
}

/*--------------------------------*/

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.