/*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, "<>"); } 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-- **/ { 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 ***/ } }