/*Last Modified:   8-MAR-1993 10:46:18.40, By: MARK */
/* Derived from an
* Example of server using TCP protocol
* pp 284-5 Stevens UNIX Network Programming
*/


#include "vmsgopherd.h"
void LOGGopher();

char Zehostname[128];
int GopherPort = GOPHER_PORT;

extern int vmserrno;
extern int socket_errno;

main(argc, argv)
 int   argc;
 char  *argv[];
{
    int sockfd;
    int newsockfd;
    int clilen;
    int childpid;
    int i, argcounter;
    char *vms_errno_string();
    int ret_status, write_len, equiv_len, lnm_index;
    unsigned int lnm_attrib;
    unsigned char acmode;
    char *LOGFile, *SecurityFile, *equiv_string, *datadir_def;

    struct sockaddr_in cli_addr;
    struct sockaddr_in serv_addr;

    /*** for getopt processing ***/
    int c;
    extern char *optarg;
    extern int optind;
    int errflag =0;
    char *colon_pos;

    $DESCRIPTOR( d_gopherroot, "GOPHER_ROOT" );
    $DESCRIPTOR( d_datadef, "DATA_DIRECTORY_DEF" );
    $DESCRIPTOR( d_logfile, "GOPHER_LOGFILE" );
    $DESCRIPTOR( d_SecurityFile, "GOPHER_SecurityFile" );
    $DESCRIPTOR( d_datadir, "GOPHER_DATADIR" );
    $DESCRIPTOR( d_tcpport, "GOPHER_TCPPORT" );
    $DESCRIPTOR( d_stable, "LNM$SYSTEM_TABLE" );
    $DESCRIPTOR( d_jtable, "LNM$JOB" );
    $DESCRIPTOR( d_equiv, equiv_string );

    acmode = PSL$C_EXEC;
    lnm_attrib = LNM$M_CONCEALED + LNM$M_TERMINAL;
    pname = argv[0];
    strcpy(Data_Dir, DATA_DIRECTORY);

/*      do logical name translations here to get port, data_dir, logfile,
*      and security file.  How do I determine if I got here from inetd?
*/

    LOGFile = ( char * ) malloc( 255 );
    SecurityFile = ( char * ) malloc( 255 );
    equiv_string = ( char * ) malloc( 255 );
    datadir_def = ( char * ) malloc( 255 );

/*
* Now we set up to translate the logical names if they exist for the logfile,
* the security file, the data directory, and the port.
*/

    strncpy( LOGFile, "\0", 255 );
    strncpy( SecurityFile, "\0", 255 );
    strncpy( equiv_string, "\0", 255 );
    strncpy( datadir_def, "\0", 255 );

    lnmlst[0].length = 255;
    lnmlst[0].code = LNM$_STRING;
    lnmlst[0].bufadr = equiv_string;
    lnmlst[0].retlen = &equiv_len;

    lnmlst[1].length = 4;
    lnmlst[1].code = LNM$_INDEX;
    lnmlst[1].bufadr = &lnm_index;
    lnmlst[1].retlen = 0;

    lnmlst[2].length = 0;
    lnmlst[2].code = 0;
    lnmlst[2].bufadr = 0;
    lnmlst[2].retlen = 0;

    lnm_index = 0;
    equiv_len = 0;
/*
* Translate the logical name for the log file if it exists
*/
    ret_status = sys$trnlnm( 0, &d_stable, &d_logfile, &acmode, &lnmlst );

    if ( ret_status == SS$_NORMAL )
       strncpy( LOGFile, equiv_string, equiv_len );

    strncpy( equiv_string, "\0", 255 );
    equiv_len = 0;
/*
* Translate the logical name for the security file if it exists
*/
    ret_status = sys$trnlnm( 0, &d_stable, &d_SecurityFile, &acmode, &lnmlst );

    if ( ret_status == SS$_NORMAL )
       strncpy( SecurityFile, equiv_string, equiv_len );

    strncpy( equiv_string, "\0", 255 );
    equiv_len = 0;
/*
* Translate the logical name for the data directory if it exists
*/
    ret_status = sys$trnlnm( 0, &d_stable, &d_datadir, &acmode, &lnmlst );

    if ( ret_status == SS$_NORMAL )
       strncpy( Data_Dir, equiv_string, equiv_len );

    strncpy( equiv_string, "\0", 255 );
    equiv_len = 0;
/*
* Translate the logical name for the tcpport to use if it exists
*/
    ret_status = sys$trnlnm( 0, &d_stable, &d_tcpport, &acmode, &lnmlst );

    if ( ret_status == SS$_NORMAL ) {
       d_equiv.dsc$w_length = equiv_len;
       d_equiv.dsc$a_pointer = equiv_string;
       ret_status = ots$cvt_ti_l( &d_equiv, &GopherPort, 4, 1 );
    }

    strncpy( equiv_string, "\0", 255 );
    equiv_len = 0;
/*
* Translate the logical name to create the logical name for the root
* directory of the gopher data
*/
    ret_status = sys$trnlnm( 0, &d_stable, &d_datadef, &acmode, &lnmlst );

    if ( ret_status != SS$_NORMAL ) {
      strncpy( equiv_string, "\0", 255 );
      equiv_len = 0;
      ret_status = sys$trnlnm( 0, &d_stable, &d_gopherroot, &acmode, &lnmlst );
    }

    lnmlst[0].length = 4;
    lnmlst[0].code = LNM$_ATTRIBUTES;
    lnmlst[0].bufadr = &lnm_attrib;
    lnmlst[0].retlen = 0;

    lnmlst[1].length = equiv_len;
    lnmlst[1].code = LNM$_STRING;
    lnmlst[1].bufadr = equiv_string;
    lnmlst[1].retlen = 0;

    lnmlst[2].length = 0;
    lnmlst[2].code = 0;
    lnmlst[2].bufadr = 0;
    lnmlst[2].retlen = 0;

    ret_status = sys$crelnm( 0, &d_jtable, &d_gopherroot, &acmode, &lnmlst );

    if (!RunFromInetd) {
         printf("Data directory is %s\n", Data_Dir);
         printf("Port is %d\n", GopherPort);
    }

    if (*LOGFile != '\0' && !RunFromInetd)
         fprintf(stdout,"Logging to File %s\n", LOGFile);

    if (*SecurityFile != '\0' && !RunFromInetd)
         fprintf(stdout,"Using Security file %s\n", SecurityFile);

    if (chdir(Data_Dir)) {
         fprintf(stderr, "Cannot change to data directory!! %s \n",Data_Dir);
         exit(-1);
    }

    /** Open up the LOGFile and the SecurityFile
        **Warning!** we have to do this over because the daemon_start
        function closes all fd's

        This part just checks to see if the files exist...
     **/

    if (*LOGFile != '\0') {
         LOGFileHandle = fopen(LOGFile, "a");

         if (LOGFileHandle == NULL) {
              printf("Can't open the logfile: %s\n", LOGFile);
              exit(-1);
         }

         fclose(LOGFileHandle);
    }

    if (*SecurityFile != '\0') {
         SECFileHandle = fopen(SecurityFile, "r");

         if (SECFileHandle == NULL) {
              fprintf(stderr,"Can't open the security file: %s\n", SecurityFile);
              exit(-1);
         }
         fclose(SECFileHandle);
    }

    /*** Hmmm, does this look familiar? :-) ***/

    if (LOGFile[0] != '\0') {
         LOGFileHandle = fopen(LOGFile, "a");

         if (LOGFileHandle == NULL) {
              fprintf(stderr,"Can't open the logfile: %s\n", LOGFile);
              exit(-1);
         }
         fclose(LOGFileHandle);
         LOGGopher(-1, "Starting gopher daemon\n");
    }

    if (*SecurityFile != '\0') {
         SECFileHandle = fopen(SecurityFile, "r");

         if (SECFileHandle == NULL) {
              fprintf(stderr,"Can't open the security file: %s\n", SecurityFile);
              exit(-1);
         }
    }

    /* Work out our fully-qualified name, for later use */

    if (gethostname(Zehostname, 128) != 0) {
         strcpy(Zehostname, "<<no-name>>");
    }
    strcat(Zehostname, DOMAIN_NAME);

    if (RunFromInetd) {
         while(do_command(0)!=0);      /* process the request */
         exit(0);
    }

    /** Open a TCP socket (an internet stream socket **/

    if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
         err_dump("server: can't open stream socket");

    /*
     * Bind our local address so that the client can send to us
     */

    bzero((char *) &serv_addr, sizeof(serv_addr));
    serv_addr.sin_family               = AF_INET;
    serv_addr.sin_addr.s_addr  = htonl(INADDR_ANY);
    serv_addr.sin_port         = htons(GopherPort);

    if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) <0)
         err_dump("server: can't bind local address");

    listen(sockfd, 5);

    for ( ; ; ) {
         /*
          * Wait for a connection from a client process.
          * This is an example of a concurrent server.
          */

         clilen = sizeof(cli_addr);
         newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr,
                            &clilen);

         /*** weird.. with this thing here our gethostaddrs work.
           without it, it fails..... why?
          ***/

         if (newsockfd < 0)
              err_dump("server: accept error");

         while(do_command(newsockfd)!=0);{}    /* process the request */

#ifdef WOLLONGONG
         netclose(newsockfd);          /* parent process */
#endif

#ifdef MULTINET
         socket_close(newsockfd);              /* parent process */
#endif

#ifdef UCX
         close(newsockfd);             /* parent process */
#endif

    }
}

/*
*
*  Code stolen from nntp.....
*
* inet_netnames -- return the network, subnet, and host names of
* our peer process for the Internet domain.
*
*      Parameters:     "sock" is our socket, which we don't need.
*                      "sin" is a pointer to the result of
*                      a getpeername() call.
*                      "host_name"
*                      is filled in by this routine with the
*                      corresponding ASCII names of our peer.
*      Returns:        Nothing.
*      Side effects:   None.
*/
inet_netnames(sock, sin, host_name)
       int                     sock;
       struct sockaddr_in      *sin;
       char                    *host_name;
{
       u_long                  net_addr;
       struct hostent          *hp;
       struct netent           *np;

       net_addr = inet_netof(sin->sin_addr);   /* net_addr in host order */
       np = getnetbyaddr(net_addr, AF_INET);

       hp = gethostbyaddr((char *) &sin->sin_addr.s_addr,
               sizeof (sin->sin_addr.s_addr), AF_INET);

       if (hp != NULL)
               (void) strcpy(host_name, hp->h_name);
       else
               (void) strcpy(host_name, inet_ntoa(sin->sin_addr));
}

/*
* This finds the current peer and the time and  jams it into the
* logfile (if any) and adds the message at the end
*/
void
LOGGopher(sockfd, message)
 int sockfd;
 char *message;
{
    struct sockaddr sa;
    int             length;
    static char     host_name[256];
    time_t          Now;
    char *cp;

    host_name[0] = '\0';

    LOGFileHandle = fopen(LOGFile, "a");

    if (LOGFileHandle != NULL) {

         if (sockfd > -1) {
              length = sizeof (sa);
              getpeername(sockfd, &sa, &length);
              inet_netnames(sockfd, &sa, host_name);
         }

         time(&Now);
         cp = (char *) ctime(&Now);
         ZapCRLF(cp);

         fprintf(LOGFileHandle, "%s %s : %s\n", cp, host_name, message);
         fflush(LOGFileHandle);
         fclose(LOGFileHandle);
    }
}

process_mailfile(sockfd, Mailfname)
 int sockfd;
 char *Mailfname;
{
    FILE *Mailfile;
    char Zeline[MAXLINE];
    char outputline[MAXLINE];
    char Title[MAXLINE];
    long Startbyte=0, Endbyte, Bytecount;

    Mailfile = fopen(Mailfname, "r");

    if (Mailfile == NULL) {
         writestring(sockfd, "- Cannot access file\r\n.\r\n");
         return;
    }

    while (fgets(Zeline, MAXLINE, Mailfile) != NULL) {

         if (strncmp(Zeline, "Subject: ", 9)==0) {
              strcpy(Title, Zeline + 9);
              ZapCRLF(Title);
              if (DEBUG)
                   fprintf(stderr, "Found title %s", Title);
         }

         if (strncmp(Zeline, "From ", 5) == 0) {
              Endbyte = Bytecount;

              if (Endbyte != 0) {
                   sprintf(outputline, "0%s\tR%d-%d-%s\t%s\t%d\r\n",
                           Title, Startbyte, Endbyte, Mailfname,
                           Zehostname, GopherPort);
                   writestring(sockfd, outputline);

                   Startbyte=Bytecount;
                   *Title = '\0';
              }
         }

         Bytecount += strlen(Zeline);
    }

    if (*Title != '\0') {
         sprintf(outputline, "0%s\tR%d-%d-%s\t%s\t%d\r\n",
                 Title, Startbyte, Endbyte, Mailfname,
                 Zehostname, GopherPort);
         writestring(sockfd, outputline);
    }

    writestring(sockfd, ".\r\n");
}

boolean
Can_Read(sockfd)
 int sockfd;
{
    struct sockaddr sa;
    int             length;
    char            host_name[256];
    char *cp;
    boolean         MatchReturn;
    char            inputline[MAXLINE];

    if (*SecurityFile == '\0')
         return(TRUE);

    length = sizeof (sa);
    getpeername(sockfd, &sa, &length);
    inet_netnames(sockfd, &sa, host_name);

    fseek(SECFileHandle, 0, 0);  /** Go to beginning of Security File **/

    while (fgets(inputline, MAXLINE, SECFileHandle) != NULL) {
         ZapCRLF(inputline);

         MatchReturn = TRUE;
         cp = inputline;

         if (*cp == '!') {
              MatchReturn = FALSE;
              cp++;
         }

         if (isdigit(*cp)) {
              /** Internet address x.x.x.x ..***/
              /** Check for a match from the beginning **/
              if (strstr(host_name,cp) == host_name)
                   return(MatchReturn);
         }

         else if (*cp == '*') {
              return(MatchReturn);
         }

         else if (*cp != '#') {
              /*** Not a comment, must be a host name **/
              if ((strstr(host_name, cp) + strlen(cp)) == (host_name + strlen(host_name))) {
                   return(MatchReturn);
              }
         }
    }

    /*** Hmmm, didn't find a match...  Let em have it***/

    return(TRUE);
}

int
do_command(sockfd)
 int sockfd;
{
    char inputline[MAXLINE];
    int length;                /* Length of the command line */
    char logline[MAXLINE];

    /*** Reopen the security file ***/

    if (*SecurityFile != '\0') {
         SECFileHandle = fopen(SecurityFile, "r");

         if (SECFileHandle == NULL) {
              LOGGopher(sockfd, "Security File dissappeared!");
              exit(-1);
         }
    }

    GDinit(&SortDir);

    length = readline(sockfd, inputline, MAXLINE); /** Get the line **/

    if (length <= 0)
         err_dump("getcommand: readline error");

    ZapCRLF(inputline);

    /*** With the funky new capability system we can just check the
         first letter, end decide what the object refers to. ***/

    switch (inputline[0]) {
    case '\0':
    case '\t':

         /*** The null capability, so it's not a file, probably wants
              to talk to a directory server ***/

         /*** we'll just do a "list" of the root directory, with no user
              capability.  ***/

         listdir(sockfd, "gopher_root:[000000]");
         LOGGopher(sockfd, "Root Connection");
         return(0);
         break;

    case '0':
         /*** It's a generic file capability ***/
         printfile(sockfd, inputline+1, 0, -1);

         /*** Log it ***/
         strcpy(logline, "retrieved file ");
         strcat(logline, inputline+1);
         LOGGopher(sockfd, logline);
         break;

    case '1':
         /*** It's a directory capability ***/
         listdir(sockfd, inputline+1);

         /** Log it **/
         strcpy(logline, "retrieved directory ");
         strcat(logline, inputline+1);
         LOGGopher(sockfd, logline);

         break;

    case '7':
         /*** It's an index capability ***/
         Do_IndexTrans(sockfd, inputline+1);

         /*** Log it **/
         strcpy(logline, "did a search ");
         strcat(logline, inputline+1);
         LOGGopher(sockfd, logline);

         break;

    case 's':
         /*** It's a sound capability ***/
         echosound(sockfd, inputline+1);

         /* Log it */
         strcpy(logline, "retrieved sound ");
         strcat(logline, inputline);
         LOGGopher(sockfd, logline);
         break;

    case 'm':
         /*** This is an internal identifier ***/
         /*** The m paired with an Objtype of 1 makes a mail spool file
              into a directory.
         ***/

         process_mailfile(sockfd, inputline + 1);
         break;

    case 'R':
         /*** This is an internal identifier ***/
         /*** The R defines a range  ****/
         /*** The format is R<startbyte>-<endbyte>-<filename> **/
    {
         int startbyte, endbyte;
         char *cp, *oldcp;

         cp = ( char * ) strchr(inputline+1, '-');

         if (cp == NULL) {
              writestring(sockfd, "Range specifier error.\r\n.\r\n");
              break;
         }

         *cp = '\0';
         startbyte = atoi(inputline+1);
         oldcp = cp+1;

         cp = ( char * ) strchr(oldcp, '-');

         if (cp == NULL) {
              writestring(sockfd, "Range specifier error.\r\n.\r\n");
              break;
         }

         *cp = '\0';
         endbyte = atoi(oldcp);
         oldcp = cp + 1;
         if (DEBUG)
              fprintf(stderr, "Start: %d, End: %d  File: %s\n", startbyte, endbyte, oldcp);

         printfile(sockfd, oldcp, startbyte, endbyte);

         break;
    }
    default:
         /*** Hmmm, must be an old link... Let's see if it exists ***/

         switch (isadir(inputline) == 1) {
         case -1:
              /* no such file */
              return(1);
         case 0:
              /* it's a file */
              printfile(sockfd, inputline, 0, -1);

              /* Log it... */
              strcpy(logline, "retrieved file ");
              strcat(logline, inputline);
              LOGGopher(sockfd, logline);

              break;
         case 1:
              /* it's a directory */
              listdir(sockfd, inputline);

              /* Log it */
              strcpy(logline, "retrieved directory ");
              strcat(logline, inputline);
              LOGGopher(sockfd, logline);

              break;
         }
    }

    return(0);
}

/*
* Returns true (1) for a directory
*         false (0) for a file
*         -1 for anything else
*/
boolean
isadir(path)
 char *path;
{
    struct stat buf;
    int result;

    result = stat(path, &buf);

    if (result != 0)
         return(-1);

#ifdef BROKENDIRS

#define S_ISDIR(m)      (((m)&S_IFMT) == S_IFDIR)
#define S_ISREG(m)      (((m)&S_IFMT) == S_IFREG)

#endif

    if (S_ISDIR(buf.st_mode))
         return(1);
    else if (S_ISREG(buf.st_mode))
         return(0);
    else
         return(-1);
}

/*
** filedate does a stat and returns the last modified date
*/
time_t
filedate(pathname)
 char *pathname;
{
    struct stat buf;
    int result;

    result = stat(pathname, &buf);

    if (result != 0)
         return(0);

    return(buf.st_ctime);
}

void
process_old_link(sockfd, filename)
 int sockfd;
 char *filename;
{
    FILE *DotFile;
    int            DoneFlags[5];
    static char    inputline[1024];

    static GopherStruct Gopherp;
    char *cp;

    if (DEBUG == TRUE)
         printf("Calling process_old_link with sockfd: %d, file: %s\n", sockfd, filename);

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

    DoneFlags[0] = DoneFlags[1] = DoneFlags[2]
         = DoneFlags[3] = DoneFlags[4] = 0;

    for (;;) {
         for (;;) {
              cp = fgets(inputline, 1024, DotFile);
              if (inputline[0] != '#' || cp == NULL)
                   break;
         }

         /*** Test for EOF ***/

         if (cp==NULL)
              break;

         /*** Test for the various field values. **/

         if (strncmp(inputline, "Type=", 5)==0) {
              GSsetType(&Gopherp, inputline[5]);
              DoneFlags[0] = 1;
         }

         if (strncmp(inputline, "Name=", 5)==0) {
              ZapCRLF(inputline);
              GSsetTitle(&Gopherp, inputline+5);
              DoneFlags[1] = 1;
         }

         if (strncmp(inputline, "Path=", 5)==0) {
              ZapCRLF(inputline);
              GSsetPath(&Gopherp, inputline+5);
              DoneFlags[2] = 1;
         }

         if (strncmp(inputline, "Host=", 5)==0) {
              ZapCRLF(inputline);
              GSsetHost(&Gopherp, inputline+5);
              DoneFlags[3] = 1;
         }

         if (strncmp(inputline, "Port=", 5)==0) {
              ZapCRLF(inputline);
              GSsetPort(&Gopherp, atoi(inputline+5));
              DoneFlags[4] = 1;
         }

         if (strncmp(inputline, "Numb=", 5)==0) {
              ZapCRLF(inputline);
              GSsetNum(&Gopherp, atoi(inputline+5));
         }

         /** Check to see if we've got all the parameters **/
         /** If we do, then send out the line ***/

         if ((DoneFlags[0] + DoneFlags[1] +
              DoneFlags[2] + DoneFlags[3] +
              DoneFlags[4]) == 5) {

              DoneFlags[0] = DoneFlags[1] = DoneFlags[2]
                   = DoneFlags[3] = DoneFlags[4] = 0;

              GDaddGS(&SortDir, &Gopherp);
         }
    }
    fclose(DotFile);
}

/*
* This function tries to find out what type of file a pathname is.
* It then fills in the VAR type variables ObjType & ServerPath with
* corresponding info.
*/
char
Getfiletypes(newpath, ObjType, ServerPath)
 char *newpath;
 char **ObjType;
 char **ServerPath;
{
    boolean dirresult;
    int Zefilefd;
    static char Zebuf[64];
    char *cp;
    static char Selstr[256];

    if (ServerPath != NULL)         /* Don't overwrite existing path if any */
         *ServerPath = Selstr;

    dirresult = isadir(newpath);

    if (dirresult == -1)             /** Symlink or Special **/
         return('3');

    if (dirresult == 1) {
         *ObjType = "1";
         *Selstr = '1';
         strcpy(Selstr +1, newpath);
         return;
    }
    else if (dirresult == 0) {       /** Some kind of data file.... */

         if ((Zefilefd = open(newpath, O_RDONLY)) < 0) {
              return('3');
         }

         bzero(Zebuf, 64);
         read(Zefilefd, Zebuf, 64);
         close(Zefilefd);

         /*** Check the first few bytes for sound data ***/

         cp = Zebuf;

         if (*cp++ == '.' && *cp++ == 's' &&
             *cp++ == 'n' && *cp++ == 'd') {
              *ObjType = "s";
              *Selstr = 's';
              strcpy(Selstr+1, newpath);

              return;
         }

         /*** Check and see if it's mailbox data ***/

         cp = Zebuf;

         if (*cp++ == 'F' && *cp++ == 'r' &&
             *cp++ == 'o' && *cp++ == 'm' &&
             *cp++ == ' ') {
              *ObjType = "1";
              *Selstr = 'm';
              strcpy(Selstr+1, newpath);

              return;
         }

         /*** Check for uuencoding data ***/

         cp = Zebuf;

         if (*cp++ == 'b' && *cp++ == 'e' && *cp++ == 'g' &&
             *cp++ == 'i' && *cp++ == 'n')  {
              *ObjType = "6";
              *Selstr = '6';
              strcpy(Selstr+1, newpath);

              return;
         }

         /*** The default is a generic text file ***/

         *ObjType = "0";
         *Selstr = '0';
         strcpy(Selstr + 1, newpath);
         return;
    }
    return('3');  /*** we shouldn't be able to get here..... ***/
}

/*
** This function lists out what is in a particular directory.
** it also outputs the contents of link files.
**
** Ack is this ugly.
*/
void
listdir(sockfd, pathname)
 int sockfd;
 char *pathname;
{
    struct FAB wild_fab;       /* Used in wildcard search */
    struct NAM wild_nam;       /* Used in conjunction with wild_fab */

    char template[] = "*.*;*"; /* default template */
    char fullname[256];        /* Input file spec given by user */
    char expanded[256];        /* filespec after logical expansion */
    char result[256];          /* result from search */
    char *pointer1, *pointer2, *pointer3, *pathp2, *sidep1;
    char *lbracketp, *rbracketp;
    int result2_len, side_len;
    register status;

    int            i;
    char           *cp, ch;

    char           sidename[256];
    char           filename[256];
    char           newpath[512];

    FILE           *SideFile;

    static char    portnum[16];
    GopherStruct   Gopherp;
    char           *Typep, *Pathp;

/* Initialize the wildcard FAB and NAM */
    wild_fab = cc$rms_fab;
    wild_nam = cc$rms_nam;

    wild_fab.fab$l_fna = fullname;
    wild_fab.fab$b_fac = FAB$M_GET;
    wild_fab.fab$l_fop = FAB$V_NAM;
    wild_fab.fab$l_nam = &wild_nam;
    wild_fab.fab$l_dna = template;
    wild_fab.fab$b_dns = strlen(template);

    wild_nam.nam$l_esa = expanded;
    wild_nam.nam$b_ess = 255;
    wild_nam.nam$l_rsa = result;
    wild_nam.nam$b_rss = 255;

    strcpy(fullname, pathname);
    wild_fab.fab$b_fns = strlen(fullname);
    if (((status = SYS$PARSE(&wild_fab)) &1) != 1) {
      fprintf(stderr, "Error %d on parse\n",status);
      fprintf(stderr, "pathname: %s\n",pathname);
      writestring(sockfd, "- Cannot access that directory\r\n.\r\n");
      return;
    }

    pointer1 = ( char * ) strchr( pathname, '[' );
    if ( (pointer1 != pathname) &&
         (strncmp(pathname, "gopher_root", 11) != 0) ) {
         writestring(sockfd, "- Cannot access that directory\r\n.\r\n");
         return;
    }

    if (chdir(pathname)<0) {
/*        fprintf(stderr, "error: %d %s\n",vmserrno,vms_errno_string()); */
         writestring(sockfd, "- Cannot access that directory\r\n.\r\n");
         return;
    }

    sprintf(portnum, "%d", GopherPort);

    for ( ; ; ) {
      if ((( status = SYS$SEARCH(&wild_fab)) &1) != 1) {
        if ( (status == RMS$_NMF) || (status == RMS$_FNF) )
          break;
        else {
          fprintf(stderr, "Error %d on search\n",status);
          writestring(sockfd, "- There were no files, or we had some other error on the search\r\n.\r\n");
          return;
        }
      }

         expanded[wild_nam.nam$b_esl] = 0;
         result[wild_nam.nam$b_rsl] = 0;
         pointer1 = ( char * ) strchr(result,']') + 1;
         pointer2 = ( char * ) strchr(result,';');
         result2_len = pointer2 - pointer1;
         pointer3 = ( char * ) malloc(result2_len + 1);
         strncpy(pointer3, "\0", result2_len + 1);
         strncpy(pointer3, pointer1, result2_len);

         strcpy(newpath, pathname);
         sidep1 = ( char * ) strchr(pathname, ']');
         side_len = sidep1 - pathname;
         strncpy(sidename, "\0", 256 );
         strncpy(sidename, pathname, side_len);
         strcat(sidename, ".cap]\0" );
         strcat(newpath, pointer3);
         strcpy(filename, pointer3);
         strcat(sidename, pointer3);
         free(pointer3);

         /** Only chew list out files that don't start with a dot **/
         /** or aren't named dev, usr, bin, etc, or core.         **/

         if ((filename[0] == '.') && isadir(filename)==0) {
              /*** This is a link file, let's process it ***/
              process_old_link(sockfd, filename);
         }


         if ((filename[0] != '.')
             && strcmp(filename, "bin") != 0 &&
                strcmp(filename, "dev") != 0 &&
                strcmp(filename, "usr") != 0 &&
                strcmp(filename, "core")!= 0 &&
                strcmp(filename, "etc") != 0)   {

              /** Check to see if there's a set-aside file with more info ***/
              /** But first initialize the Gopherstruct **/

              GSinit(&Gopherp);

              GSsetHost(&Gopherp, Zehostname);
              GSsetPort(&Gopherp, GopherPort);
              Typep = Pathp = NULL;


              if ((SideFile = fopen(sidename, "r"))!=0) {
                   if (DEBUG == TRUE)
                        printf("Side file name: %s\n", sidename);
                   Process_Side(SideFile, &Gopherp);
              }

              if (GSgetType(&Gopherp)=='\0' && *GSgetPath(&Gopherp) == '\0') {
                   Getfiletypes(newpath, &Typep, &Pathp);

                   if (*Typep =='3')
                        break;

                   GSsetType(&Gopherp, Typep[0]);

                   if ( *Typep == '1' ) {
                       pointer2 = ( char * ) strrchr(result,'.');
                       result2_len = pointer2 - pointer1;
/*                      gopher20 = 0;
                       gopher20 = strncmp(pathname,"gopher_root:[000000]",20);  */
                       lbracketp = ( char * ) strchr(pathname, '[');
                       if ((strncmp(pathname,"gopher_root",11) == 0 ) &&
                           (strncmp(lbracketp,"[000000]",8) == 0 ) )
                         pathp2 = ( char * ) strchr(pathname, '[');
                       else
                         pathp2 = ( char * ) strchr(pathname, ']');
                       strncpy(newpath, "\0", 511);
                       strncpy(newpath, "1", 1);
                       /*if (strncmp(pathname,"gopher_root:[000000]",20) == 0 ) */
                       if ((strncmp(pathname,"gopher_root",11) == 0 ) &&
                           (strncmp(lbracketp,"[000000]",8) == 0 ) )
                         strncat(newpath,pathname, (pathp2 - pathname) + 1);
                       else  {
                         strncat(newpath,pathname, (pathp2 - pathname) );
                         strcat(newpath,".");
                       }
                       strncat(newpath,pointer1,result2_len);
                       strcat(newpath,"]\0");
                       GSsetPath(&Gopherp, newpath);
                   }
                   else
                       GSsetPath(&Gopherp, Pathp);
              }

              if (GSgetTitle(&Gopherp) == NULL) {
                   /*** Check to see if we have a compressed file ***/

                   if (strcmp(filename + strlen(filename) -2, ".Z") ==0)
                        filename[strlen(filename) - 2] = '\0';

                   GSsetTitle(&Gopherp, filename);
              }
              else
                   GSsetTitle(&Gopherp, filename);

              /** Send out the complete line **/

              GDaddGS(&SortDir, &Gopherp);
         }
    }
    GDsort(&SortDir);
    GDtoNet(&SortDir, sockfd);

    writestring(sockfd, ".\r\n");
}


/*
* This processes a file containing any subset of
* Type, Name, Path, Port or Host, and returns pointers to the
* overriding data that it finds.
*
* The caller may choose to initialise the pointers - so we don't
* touch them unless we find an over-ride.
*/
Process_Side(sidefile, Gopherp)
 FILE *sidefile;
 GopherStruct *Gopherp;
{
    char inputline[MAXLINE];
    static char ItemType[3];
    static char ItemName[255];
    static char Path[255];
    static char Host[64];
    static char Port[10];
    char *cp;

    inputline[0] = '\0';

    for (;;) {
         for (;;) {
              cp = fgets(inputline, 1024, sidefile);
              if (inputline[0] != '#' || cp == NULL)
                   break;
         }

         /*** Test for EOF ***/
         if (cp==NULL)
              break;

         ZapCRLF(inputline);  /* should zap tabs as well! */

         /*** Test for the various field values. **/

         if (strncmp(inputline, "Type=", 5)==0) {
              GSsetType(Gopherp, inputline[5]);
         }
         else if (strncmp(inputline, "Host=", 5)==0) {
              GSsetHost(Gopherp, inputline+5);
         }

         else if (strncmp(inputline, "Port=", 5)==0) {
              GSsetPort(Gopherp, atoi(inputline+5));
         }

         else if (strncmp(inputline, "Path=", 5)==0) {
              GSsetPath(Gopherp, inputline+5);
         }

         else if (strncmp(inputline, "Numb=", 5)==0) {
              GSsetNum(Gopherp, atoi(inputline+5));
         }
    }
    fclose(sidefile);
}


/*
** This function opens the specified file, starts a zcat if needed,
** and barfs the file across the socket.
**
** It now also checks and sees if access is allowed
**
**
*/
void
printfile(sockfd, pathname, startbyte, endbyte)
 int sockfd;
 char *pathname;
 int startbyte, endbyte;
{
    FILE *ZeFile;
    char inputline[512];
    int i, rmtmpfile;
    char Zcatcommand[256];
    char *cp, *pointer1;

    chdir("gopher_root:[000000]");

    rmtmpfile = 0;
    pointer1 = (char * ) strchr( pathname, ':' );
    if ( (pointer1 != 0) &&
         (strncmp(pathname, "gopher_root", 11) != 0) ) {
         writestring(sockfd, "- Cannot access that file\r\n.\r\n");
         return;
    }

    /*** Check and see if the peer has permissions to read files ***/

    if (Can_Read(sockfd) == FALSE) {
         writestring(sockfd, BUMMERSTR);
         writestring(sockfd, "\r\nBummer.....\r\n.\r\n");
         close(sockfd);
         return;
    }

    if ( (ZeFile = fopen(pathname, "r")) == NULL) {
         /*
          * The specified file does not exist
          */
         writestring(sockfd, "- File does not exist!!!!!\r\n");
         writestring(sockfd, ".\r\n");
         return;
    }

    if (startbyte != 0)
         fseek(ZeFile, startbyte, 0);
    {
         FILE *pp;
         if (pp = specialfile(ZeFile, pathname)) {
              fclose(ZeFile);
              ZeFile = pp;
              rmtmpfile = 1;
         }
    }

    while (fgets(inputline, MAXLINE, ZeFile) != NULL) {

         ZapCRLF(inputline);
         if( inputline[0] != '$' ) {
           writestring(sockfd, inputline);
           writestring(sockfd, "\r\n");
         }

         if (endbyte >0) {
              if (ftell(ZeFile) >= endbyte)
                   break;
         }
    }
    Specialclose(ZeFile);
    if ( rmtmpfile == 1 )
      remove( pathname );
    writestring(sockfd, ".\r\n");
}

/*
* Warning! this part isn't working yet!
*/
#ifdef BUILTIN_SEARCH

Do_IndexTrans(sockfd, inputline)
 int sockfd;
 char *inputline;
{
    char *IndexDirectory;
    char *SearchString;
    char *cp;


    /** First siphon off the directory pathname **/
    IndexDirectory = inputline;

    cp = (char *) strchr(inputline, '\t');

    if (cp == NULL) {
         /** Give up it won't work..... **/
         writestring(sockfd, ".\r\n");
         return;
    }
    else
         *cp = '\0';


    /** And siphon off the search string **/

    SearchString = cp +1;

    /** Just in case, get rid of anything following a tab **/

    cp = (char *) strchr(SearchString, '\t');
    if (cp != NULL)
         *cp = '\0';

    /** Read in the proper hostdata file.... **/


    /** And call the appropriate query function **/

#ifdef NEXTSEARCH
    NeXTIndexQuery(sockfd, IndexDirectory, SearchString);
#endif

#ifdef WAISSEARCH
/*     WaisIndexQuery(sockfd, IndexDirectory, SearchString);*/
#endif

}

#endif /* BUILTIN_SEARCH */


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

void
echosound(sockfd, filename)
 int sockfd;
 char *filename;
{
    FILE *sndfile;
    unsigned char in[BUFSIZE];
    register int j;
    int gotbytes;

/*     if (strcmp(filename, "-") == 0) { */
         /*** Do some live digitization!! **/
/*        sndfile = popen("record -", "r");
    }
    else
         sndfile = fopen(filename, "r");
*/
    while(1) {
         gotbytes = fread(in, 1, BUFSIZE, sndfile);

         if (gotbytes == 0)
              break;       /*** end of file or error... ***/

         j = writen(sockfd, in, gotbytes);

         if (j == 0)
              break;       /*** yep another error condition ***/
    }
}

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.