unpost/ 40755 23453 0 0 5613467556 11707 5ustar jeanpaulsystemunpost/changes.doc100644 23453 0 40034 5543404774 14117 0ustar jeanpaulsystemChanges for UNPOST Version 2.0.2 -------------------------------- 1) Fixed minor bug with zero length lines. 2) Added if-defs around sys_errlist declarations so that they can be conditionally not compiled. 3) Modified part 0/# processing so that description articles are written to the incompletes file ONLY if the -d switch is set on the command line. 4) Added version printing switch, -v. 5) Added AIX make file. 6) Added an NNTP client for automated extraction of all articles from specified news groups. The source code is in the nntp directory, and it can be compiled by typing: gcc -o client -ansi client.c on a Sun running: SunOS 4.1 4 using gcc: version 2.1 Documentation for CLIENT is in the nntp directory. This program is NOT portable. As far as I know, it can only be used by the people who have, at a bare minimum, a Unix that supports sockets as used in the program for communications. If the above does not make sense to you, don't even try it, unless you have a Unix/C/Socket/BDS/Communications expert to try to help you. CLIENT is provided as a tool only for use by experts. You have been warned. Changes for UNPOST Version 2.0.3 -------------------------------- 1) Fixed bug in the way part 0/# segments were handled, as they were not being written out properly. 2) Fixed bug in the way part 1/# segments with no uuencode begin line are handled. An error check was placed in the decode logic to report an error if the file name is missing, even though all the segments are present. 3) Fixed def.cfg so that it would get through the new parser (removed unnecesary commas). 4) Removed '^From ' as one of the segment prefix recognition regular expressions from the default configuration. Sorry about that, for you people whose news readers (like nn, I think) use that as the first line, and who process email. To make up for it, a configuration file (called email.cfg) has been included that should make UNPOST act properly. 5) Added an OS/2 EMX/gcc makefile (called makefile.os2) that has the necesary define set to compile out the sys_errlist declarations. 6) Added a summary file (you're reading it now), that contains the latest changes as well as a summary for use in posting a description and keeping providing a location for only the changes that have occured since the last version. All changes from version to version, from now on will be copied to the changes.doc file. 7) Added a syntax check and very brief syntax description line to retest. 8) Added a new debugging utility, mofs. It is a single file program that allows the user to view a file, ala more, starting at a decimal offset. 9) Added a configuration file for use in UNPOSTing comp.binaries.ibm.pc and comp.binaries.ms-windows postings (named cbip.cfg). 10) Added a new command line switch (-b) to tell UNPOST to write the segments of an incomplete (or damaged) posting to separate files, instead of to the incompletes file. Changes for UNPOST Version 2.1.0 -------------------------------- 1) Bug Fix: UNPOST would not recognize a short (does not start with a 'M', ' ' or '`' character) UU encoded line as the first uuencoded line of a segment. Major bug (truncates files), rarely happens (UNPOST will only skip this line if it is the first line in a segment, and that only happens when a segment is posted with only three lines) therefore hard to notice, but very easy to fix. 2) Bug Fix: UNPOST would add one or two extra bytes at the end of a file when decoding. This is due to uuencoders that put out four characters irregardless of whether or not all three bytes are valid. I've been told that this is the standard, so UNPOST was wrong (BZzzt! Got me!). 3) Modified the email.cfg file so that it is valid for both the nn news reader and email extraction. Thanks to the alert user who not only found the problem, but also designed THEIR OWN CONFIGURATION FILE (yes, it can be done!) and sent the change to me. 4) If a segment has multiple sources of information for the part # of # of parts and binary ID information, the last source now wins. The last source is usually a header dumped into the body by an auto uuencode and split program, and this information is more likely to be correct than the hand typed Subject: stuff in the header. 5) Tacked the Subject: line tree into the body, as well as the header in the default configuration. This is for the new anonymous service postings that put a copy of the header from the original message into the body of the posting (irritating, to say the least, that the two Subject: lines often disagree). 6) Moved all compiler header files (.h) files into a file called "compiler.h" to simplify making changes as new systems are brought up, and for things that are not the same across all systems. I hated doing this, but it should make things a little easier for those who know enough to make some minor changes to port it to their systems. This suggestion was from Tom Lane (Independent JPEG group, check out the djpeg and cjpeg code, this stuff is really useful to have around). 7) Made a few changes according to the suggestions sent to me by a user who modified the program slightly to run under VMS. 8) Added if-def's for nn vs. rn news readers, and defines for setting the binary switch default settings. See file compiler.h. Another Tom Lane suggestion. 9) Changed source slightly so that the SEGMENT begin line will also be checked for part # of # of parts and binary ID information. This change was made to assist me in creating a working configuration file for Fido Gateway and UUNET users. 10) I added an example to the Theory of Operations section in the documentation, and moved some other sections around as per request by a user who thought the order of the configuration, configuration file and regular expression tutorial sections was confusing. Thanks for the input. 11) Wrote my own MemCopy and MemMove functions to quash the idiocy with having to if def the hell out of the code to decide which one of three functions to use. Also, I have exactly the same version of gcc on two exactly similiar machines (both the same type of Sparc Station, running exactly the same version of the operating system) but on one machine, gcc bitches about conflicting definitions for memcpy between the builtin function versus the header file, while on the other machine. . . silence. I really hate this sort of garbage. Hey, Tom! Give me solution for this one, and I'll implement it without expressing any opinion at all. . . :-) 12) Changed the routine that extracts the binary ID string to use only one word (a string delimited by white space) out of the string, preferably one that has a '.' character in it. This string is filtered to have only MS-DOS/USENET standard file name characters in it. Hopefully, this will reduce the number of misinterpretations, and avoid putting segments of the same posting into different file segment lists. It should, for example, solve the problem of putting Subject: WHITE.GIF (Part 1/2) and Subject: WHITE.GIF, part 1 of 2 into two separate file lists, as the comma is NOT an acceptable file name character. Changes for UNPOST Version 2.1.1 -------------------------------- 1) Bug fix. On MS-DOS and OS/2 systems, if you feed UNPOST a non-text file (one that has only line feeds, no carriage returns), very strange things happen. The simple fix was to change from opening the source files in text mode to opening them in binary mode. 2) Change 12 for version 2.1.0 had a bug in it that in some (rare) circumstances, would cause core dumps due to accessing a NULL pointer. This has (fingers crossed) been fixed. Thanks to the user who analyzed the problem and sent me the article header that was causing the core dump. 3) The help summary now tells the default state of the binary switches. 4) In response to the people who need support, a small amount of debugging code has been added. This is activated by defining the UNPOST_DEBUG variable (in compiler.h). 5) New switch (-r) tells UNPOST which one of four news readers you are using. -r r For RN, -r e For Email -r n For NN, -r g Look for Newsgroups: line. 6) For OS/2 only and if the proper variable is defined, UNPOST will set the file name munging switch on the basis of the file system type of the default drive. Changes for UNPOST Version 2.1.2 -------------------------------- 1) Bug fix. I screwed up the regular expression compilation for the -r switch. Fixed. See note 5 for version 2.1.1 in the changes.doc file for information on how to select one of four sources for your news. Changes for UNPOST Version 2.1.3 -------------------------------- 1) Changed sys_errlist[] references to strerror(). More ANSI compatible. according to DaviD W. Sanderson (who ought to know, folks). Many thanks for your comments/suggestions. Sorry, the command line change we talked about is WAY to hairy considering the small gains it affords. Incidentally, the "t" in the fopen strings is ANSI compatible on the basis that any unrecognized options should be ignored. . . hence the reason that the t flag was added to all fopen strings except the non-ansi compiler selection. 2) Changed CLIENT so that it will no longer delete a newsgroup from the configuration file if there were any errors in processing the group. 3) Added makefiles for IBM C Set++ and SGI, as well as changing the makefile names. Thanks to the contributors (who are noted in the makefile comments) for sending them in. 4) Modified the algorithm for determing which segments go together so that the routine first looks for a file name (anything that has and extension separator character in it, usually a '.') and if it doesn't find one, it munches all the words together and uses that. This should solve the problems with binaries being posted that are part of a series. The old version didn't handle: locomotive Pict#15 (Part 1/1) locomotive Pict#16 (Part 1/1) correctly because it would use the longest word (which is locomotive) from each subject line then decide it had duplicate segments. The new algorithm is somewhat of a return to the old method, where if there is no word with a '.' in it, it just jams the words together (minus punctuation, and monocased) to produce: locomotivepict15 and locomotivepict16 as it's binary ID strings. UNPOST still looks for a file name first, though. 5) Changed CLIENT so that it has a kill file capability. Get rid of those nasty, unwanted articles by NOT EVEN READING THEM from the news server! CLIENT reads the article header first, looks at the specified line and applies all regular expressions listed in the kill file for that news group to the line. If any of the regular expressions match, that article is ignored (and for now, the article number and the subject line are printed to standard error for warm-fuzzy-I-guess-I-can-trust-this-facility- after-all reasons). CLIENT now uses some utilities and the regular expression stuff from UNPOST, so the makefiles for UNPOST now create CLIENT. And, of course, the client.c file has been moved up to the UNPOST source directory. CLIENT is not automatically made by os/2 and dos makefiles, only the Unix workstation makefiles do this. 6) UNPOST will no longer overwrite a description (*.inf) file. Sorry about this, but the .inf is being changed to .dsc for OS/2 niceness. This extension probably clashes with some other vitally important file name extension on some other machine. . . so shoot me. Changes for UNPOST Version 2.2.0 -------------------------------- 1) UNPOST now can handle segments spread across multiple files in interpretation mode. The new option is -l (for file list) and an example of its use is: ls -1 /usr/spool/news/* | unpost -e errors -i incomps -l - This will create a list of file names, one per line and pipe that into UNPOST. UNPOST will attempt to interpret the headers in the files and extract any complete, correct binaries. Any segments that are part of incomplete or damaged binaries will be written to the incomps file. 2) UUXFER is no longer considered to be a valid auto Split/Encode program by UNPOST. There have been way to many postings that have UUXFER headers in them that are six parts, but UUXFER says that they have 7 parts. . . and they really are just six parts. If the author fixes this bug, let me know and I will re-enable UUXFER signature recognition. . . Changes for UNPOST Version 2.3.0 -------------------------------- 1) UNPOST will now look for the POST 1.2.0 signature and CRC info and if found, UNPOST will run a CRC check on the decoded binary file. This is a CCITT standard 32 bit CRC, so BRIK and other programs should be able to generate the same CRC's. If I can get a version of brik to run on my PC, I'll check this out to be sure. 2) Text only segments are dumped to the text only (-t) file when the -l switch is being used. Changes for UNPOST Version 2.3.3 -------------------------------- 1) Bug fixes: when the -b switch and -l switch were used together, segments that were part of an incomplete posting were still written to the -i file, even though the separate file was created. This has been fixed. 2) The character set routines have been modified to use unsigned characters for those people who insist on running source files through UNPOST that have characters with the high bit set. 3) In those cases where the file name mungling was turned off, but description files were being created, a file name such as a.b.c was modified to be a.dsc for the description file, instead of a.b.dsc. This has been fixed. 4) A new option has been added, the -o option. All successfully decoded binaries will have their file names written to this file. This option is specifically for use with the XRn extract button. 5) UNPOST now returns error codes, again for the XRn extract button. This is the change most-likely-to-add-new-bugs (tm). Use with caution. 6) A very nice person sent me the UNPOST changes and a makefile for getting UNPOST working on an Amiga. Unfortunately, it was sent in .lha archive format, and I have up until now been unable to dearchive this stuff. If you are running on an Amiga and have need of this, send me email and I'll forward it to you. Please, people (begging tone turned on), use .zip format when you send something to me. Every system that I know of can use the zip/unzip code. I just can't keep a copy of every archive/ dearchive utility in existance on my machine (begging tone turned off). Changes for UNPOST Version 2.3.4 -------------------------------- 1) Bug fixes: when the -l switch was used, UNPOST would use up file descriptors 'cause I wasn't closing the part files. This has been fixed, thanks to Daniel Dissett, who found the problem and sent me a fix for it. 2) The regular expression matching code would blow up on lines that were just Subject:, nothing else (blank subject lines). This has been fixed. 3) A tool for creating lists of files has been added for those of you who are so poor that you are using vanilla MS-DOS. It's called list.exe and it can be found in the msdos directory. Source code is not included, 'cause it's so boring. Due to massive system changes, etc, I have lost some notes on new features, bug fixes, etc. If you sent me a note on a bug, or feature that you would like to see implemented, and it hasn't been addressed yet, please re-email me. Thanks. jstevens@csn.org unpost/calccrc.c100644 23453 0 11603 5543402236 13545 0ustar jeanpaulsystem/****************************************************************************** * Module : Calculate CRC --- Calculate a cyclic redundancy checksum * for a file. * * Author : John W. M. Stevens (Based on a number of different sources, * most notably a book on C serial communications). ******************************************************************************/ #include "compiler.h" #include "unpost.h" #define FD_BACK_SZ 256 static CRC_TYPE CrcFeedBack[FD_BACK_SZ] = { 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL }; CRC_TYPE CalcCRC(FILE *BinFlPtr) { register int i; register int size; auto CRC_TYPE Crc; auto unsigned char Bfr[512]; extern FILE *ErrFile; /* Initialize the CRC. */ Crc = 0xffffffffL; /* Position file pointer. */ if (fseek(BinFlPtr, 0L, SEEK_SET) != 0) { fprintf(ErrFile, "%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); exit( 1 ); } /* Read and calculate a CRC for whole file. */ while ((size = fread(Bfr, 1, 512, BinFlPtr)) > 0) { /* Loop through bytes in buffer. */ for (i = 0; i < size; i++) Crc = CrcFeedBack[(int) (Crc ^ Bfr[i]) & 0xff] ^ ((Crc >> 8) & 0x00FFFFFFL); } return( Crc ); } unpost/client.c100644 23453 0 65474 5543402236 13450 0ustar jeanpaulsystem/****************************************************************************** * Module : NNTP Client for the automatic extraction of all news articles * from a news group without the use of a news reader. * * Author : John W. M. Stevens ******************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "utils.h" #include "regexp.h" #define MAX_BFR 513 #define YES 1 #define NO 0 typedef enum { ST_LINE, ST_NORM, ST_CR } STATES; typedef struct kill_st { char *NewsGroup; REG_EXP_NODE *PreFix; int NoKillREs; REG_EXP_NODE **KillREs; struct kill_st *Next; } KILL_ND; FILE *ErrFile = stderr; char *Version = "CLIENT V1.1.0"; extern int errno; static KILL_ND *KillList; /*----------------------------------------------------------------------------- | Routine : MkTmpFl() --- Make a temporary file, and return the name. | | Outputs : FileName - Returns the name of the temporary file. -----------------------------------------------------------------------------*/ FILE *MkTmpFl(char *FileName) { register int i; auto int ret; auto char TmBfr[10]; /* Use the time value to create a temporary file name. */ sprintf(TmBfr, "%08x", time( (time_t *) 0 )); /* Make sure that the file does not already exist. */ for (i = 0; i < 1000; i++) { /* Create the file name. */ sprintf(FileName, "%03d%.5s.%.3s", i, TmBfr, TmBfr + 5); /* Check to see if the file exists. */ if ((ret = access(FileName, 0)) != 0) { if (errno == ENOENT) break; } } /* Check to see if we failed utterly. */ if (i == 1000) return( NULL ); /* Open the file whose name we just constructed. */ return( fopen(FileName, "w") ); } /*----------------------------------------------------------------------------- | Routine : WrtSrvr() --- Write a buffer to the server. | | Inputs : SockDesc - Socket descriptor. | Bfr - Buffer to read into. | Len - Length of message in buffer. -----------------------------------------------------------------------------*/ void WrtSrvr(int SockDesc, char *Bfr, int Len) { auto int ret; /* Write buffer to server. */ if ((ret = write(SockDesc, Bfr, Len)) <= 0) { fprintf(stderr, "%s %d - Error in writing to news server.\n", __FILE__, __LINE__); fprintf(stderr, "\tReturn = %d, Error number = %d\n", ret, errno); exit( 1 ); } } /*----------------------------------------------------------------------------- | Routine : RdSrvr() --- Read a buffer from the server. | | Inputs : SockDesc - Socket descriptor. | Bfr - Buffer to read into. | MaxLen - Maximum length of buffer. -----------------------------------------------------------------------------*/ int RdSrvr(int SockDesc, char *Bfr, int MaxLen) { auto int ret; /* Get the buffer full. */ if ((ret = read(SockDesc, Bfr, MaxLen - 1)) < 0) { fprintf(stderr, "%s %d - Error in reading from news server.\n", __FILE__, __LINE__); fprintf(stderr, "\tReturn = %d, Error number = %d\n", ret, errno); exit( 1 ); } Bfr[ret] = '\0'; return( ret ); } /*----------------------------------------------------------------------------- | Routine : GetLine() --- Extract a line from the buffer into the | line buffer. | | Inputs : SockDesc - Socket descriptor number. | Line - Pointer to line buffer to read into. -----------------------------------------------------------------------------*/ static int Size = 0; static int BfrIdx = 0; static char Bfr[MAX_BFR]; void GetLine(int SockDesc, char *Line) { register int i; auto int State; /* Read a buffer full. */ if (BfrIdx >= Size) { Size = RdSrvr(SockDesc, Bfr, MAX_BFR); BfrIdx = 0; } /* Get and put characters from buffer to output file. */ for (State = ST_NORM, i = 0; State != ST_LINE && Size; ) { /* Determine operation based on state. */ switch ( State ) { case ST_NORM: if (Bfr[BfrIdx] == '\n') { fprintf(stderr, "%s %d : Warning - saw '\\n' before '\\r'.\n", __FILE__, __LINE__); Line[i++] = Bfr[BfrIdx]; State = ST_LINE; } else if (Bfr[BfrIdx] == '\r') State = ST_CR; else Line[i++] = Bfr[BfrIdx]; break; case ST_CR: if (Bfr[BfrIdx] == '\n') Line[i++] = Bfr[BfrIdx]; else if (Bfr[BfrIdx] == '\r') break; else { /* Report warning. */ fprintf(stderr, "%s %d : Warning - saw '.\\r' but no '\\n'.\n", __FILE__, __LINE__); } State = ST_LINE; break; } /* Next character, get new buffer if empty. */ if (++BfrIdx >= Size && State != ST_LINE) { /* Read a buffer full. */ Size = RdSrvr(SockDesc, Bfr, MAX_BFR); BfrIdx = 0; } } /* NUL terminate the line and return. */ Line[i] = '\0'; } /*----------------------------------------------------------------------------- | Routine : GetArt() --- Get an article from the news server. | | Inputs : SockDesc - Socket descriptor number. | OutFp - Pointer to output file. -----------------------------------------------------------------------------*/ void GetArt(int SockDesc, FILE *OutFp) { auto char Line[MAX_BFR]; /* Get a line from the server. */ GetLine(SockDesc, Line); /* Until the last line is seen, get and output lines. */ while ( strcmp(Line, ".\n") ) { /* Output line. */ fputs(Line, OutFp); /* Get a line from the server. */ GetLine(SockDesc, Line); } /* Check for underflow. */ if (BfrIdx < Size) { fprintf(stderr, "%s %d : Error, did not use complete article body.\n", __FILE__, __LINE__); } /* Put a blank line between articles. */ fprintf(OutFp, "\n"); } /*----------------------------------------------------------------------------- | Routine : RdArt() --- Read an article from the server. | | Inputs : SockDesc - Socket descriptor. | OutFp - Pointer to output file. -----------------------------------------------------------------------------*/ void RdArt(int SockDesc, long ArtNo, char *NewsGroup, KILL_ND *KillNd, FILE *OutFp) { register int i; auto int Status; auto char **SubStrs; auto int Kill; static char Line[1025]; /* Do we need to do kill checks? */ if ( KillNd ) { /* Get article header. */ sprintf(Bfr, "HEAD %ld\r\n", ArtNo); WrtSrvr(SockDesc, Bfr, strlen( Bfr )); /* Get status, etc. */ GetLine(SockDesc, Line); sscanf(Line, "%d %ld", &Status, &ArtNo); /* Execute the command. */ switch ( Status ) { case 221: break; case 220: case 222: case 223: fprintf(stderr, "%s %d : Error, response to ARTICLE = %d.\n", __FILE__, __LINE__, Status); return; case 412: fprintf(stderr, "%s %d : Error, no news group selected.\n", __FILE__, __LINE__); return; case 420: fprintf(stderr, "%s %d : Error, no current article selected.\n", __FILE__, __LINE__); return; case 423: return; case 430: return; } /* Get article header lines and process header. */ Kill = NO; GetLine(SockDesc, Line); while ( strcmp(Line, ".\n") ) { /* Look for Subject: line. */ if ( ReMatch(Line, IGN_CASE, KillNd->PreFix, &SubStrs) ) { /* Now run list of kill RE's and decide whether or not * we have an article to kill. . . */ for (i = 0; i < KillNd->NoKillREs; i++) if ( ReMatch(Line, IGN_CASE, KillNd->KillREs[i], &SubStrs) ) { fprintf(stderr, "Killing Article #%ld\n", ArtNo); fprintf(stderr, "%s\n", Line); Kill = YES; break; } } /* Get the next line. */ GetLine(SockDesc, Line); } /* Check for article kill. */ if (Kill == YES) return; } /* Get whole article now. */ fputc('.', stderr); sprintf(Bfr, "ARTICLE %ld\r\n", ArtNo); WrtSrvr(SockDesc, Bfr, strlen( Bfr )); /* Get status, etc. */ GetLine(SockDesc, Line); sscanf(Line, "%d %ld", &Status, &ArtNo); /* Execute the command. */ switch ( Status ) { case 220: /* Get all text that follows, write it to * the output file. */ fprintf(OutFp, "Article: %ld of %s\n", ArtNo, NewsGroup); break; case 221: case 222: case 223: fprintf(stderr, "%s %d : Error, response to BODY = %d.\n", __FILE__, __LINE__, Status); return; case 412: fprintf(stderr, "%s %d : Error, no news group selected.\n", __FILE__, __LINE__); return; case 420: fprintf(stderr, "%s %d : Error, no current article selected.\n", __FILE__, __LINE__); return; case 423: return; case 430: return; } /* Get article body lines and write to output file. */ GetArt(SockDesc, OutFp); } /*----------------------------------------------------------------------------- | Routine : GetPortNo() --- This routine converts a character string | to a port number. It looks up the service by name, and if | there is none, then it converts the string to a number with | scanf. | | Inputs : PortName - Name of port to convert. | | Returns : Returns the TCP port number for this server. -----------------------------------------------------------------------------*/ int GetPortNo(char *PortName) { auto int PortNo; struct servent *Service; /* If no port name string, return no port number. */ if (PortName == NULL) return 0; /* Get server by name and make sure that the protocol * matches as well. */ Service = getservbyname(PortName, "tcp"); /* Return either the port number, or 0 for no port number. */ if (Service != NULL) return( Service->s_port ); else if (sscanf(PortName, "%i", &PortNo) != 1) return 0; else return( htons( PortNo ) ); } /*----------------------------------------------------------------------------- | Routine : GetHostAddr() --- Convert the host name to an address. | | Inputs : HostName - Host name to convert. | Addr - Host address. | | Returns : Returns 0 for error, 1 for address being returned. -----------------------------------------------------------------------------*/ int GetHostAddr(char *HostName, struct in_addr *Addr) { auto int len; struct hostent *Host; auto int count; unsigned int a1, a2, a3, a4; /* Get a pointer to the host name data. */ Host = gethostbyname( HostName ); if (Host != NULL) bcopy(Host->h_addr, Addr, Host->h_length); else { /* Convert the string representation of the internet * address into bytes. */ count = sscanf(HostName, "%i.%i.%i.%i%n", &a1, &a2, &a3, &a4, &len); if (count != 4 || HostName[len] != 0) return( 0 ); /* Insert the bytes of the internet address into the * return address structure. I suspect that this is highly * machine specific code. */ Addr->S_un.S_un_b.s_b1 = a1; Addr->S_un.S_un_b.s_b2 = a2; Addr->S_un.S_un_b.s_b3 = a3; Addr->S_un.S_un_b.s_b4 = a4; } /* Return no errors occurred. */ return( 1 ); } /*----------------------------------------------------------------------------- | Routine : SetupSocket() --- Set up the socket. | | Inputs : HostName - Name of host. | PortName - Name of port. -----------------------------------------------------------------------------*/ int SetupSocket(char *HostName, char *PortName) { auto int SockDesc; /* Socket handle (descriptor). */ struct sockaddr SockAddr; /* Socket address structure. */ struct sockaddr_in *InAddr; /* Internet address structure. */ struct in_addr *AdrPtr; /* Get the address of the server. */ InAddr=(struct sockaddr_in *) &SockAddr; InAddr->sin_family = AF_INET; if (! GetHostAddr(HostName, &InAddr->sin_addr)) { fprintf(stderr, "%s %d : Error - Could not convert ", __FILE__, __LINE__); fprintf(stderr, "'%s' to a host address.\n", HostName); exit( 1 ); } AdrPtr = (struct in_addr *) (&InAddr->sin_addr); fprintf(stderr, "Host '%s', address = %u.%u.%u.%u\n", HostName, AdrPtr->S_un.S_un_b.s_b1, AdrPtr->S_un.S_un_b.s_b2, AdrPtr->S_un.S_un_b.s_b3, AdrPtr->S_un.S_un_b.s_b4); /* Convert a service name to a port number. */ InAddr->sin_port = GetPortNo( PortName ); if (InAddr->sin_port == 0) { fprintf(stderr, "%s %d : Error - bogus port number '%s'.\n", __FILE__, __LINE__, PortName); exit( 1 ); } fprintf(stderr, "NNTP port number = %d\n", InAddr->sin_port); /* Attempt to get a socket descriptor. */ SockDesc = socket(AF_INET, SOCK_STREAM, 0); if (SockDesc < 0) { perror("opening stream socket"); exit( 1 ); } /* Connect to the server. */ if (connect(SockDesc , &SockAddr, sizeof( SockAddr )) < 0) { /* Close the old socket descriptor. */ perror("connecting"); fprintf(stderr, "%s %d : Error - could not connect to news server.\n", __FILE__, __LINE__); exit( 1 ); } /* Return the socket descriptor. */ return( SockDesc ); } /*----------------------------------------------------------------------------- | Routine : RdConfig() --- Open and read the configuration file. | | Inputs : CfgFlNm - Name of configuration file. | SockDesc - Socket description. -----------------------------------------------------------------------------*/ void RdConfig(char *CfgFlNm, int SockDesc) { register long i; auto FILE *CfgFp; auto FILE *NewFp; auto FILE *OutFp; auto int ret; auto int Status; auto long Number; auto long LastRd; auto long Start; auto long End; auto KILL_ND *KillNd; static char TmpFlNm[MAX_BFR]; static char OutFlNm[MAX_BFR]; static char Bfr[MAX_BFR]; static char Cmd[MAX_BFR]; static char GroupName[MAX_BFR]; /* Open configuration file. */ if ((CfgFp = fopen(CfgFlNm, "r")) == NULL) { fprintf(stderr, "%s %d : Error, could not open configuration file.\n", __FILE__, __LINE__); return; } /* Open new configuration file. */ if ((NewFp = MkTmpFl( TmpFlNm )) == NULL) { fprintf(stderr, "%s %d : Error, could not open new configuration file.\n", __FILE__, __LINE__); fclose( CfgFp ); return; } /* Read the file a line at a time. */ while (! feof( CfgFp )) { /* Get a line. */ if (fgets(Bfr, MAX_BFR, CfgFp) == NULL) break; /* Parse configuration file line. */ ret = sscanf(Bfr, "group %s %s %ld", GroupName, OutFlNm, &LastRd); if (ret != 3) { fprintf(stderr, "%s %d : Error - bad configuration file line.\n", __FILE__, __LINE__); fprintf(stderr, "\t'%s'\n", Bfr); } else { /* Switch to appropriate group. */ sprintf(Cmd, "GROUP %s\r\n", GroupName); WrtSrvr(SockDesc, Cmd, strlen( Cmd )); RdSrvr(SockDesc, Bfr, MAX_BFR); fprintf(stderr, "%s", Bfr); /* Check return status and article number range. */ ret = sscanf(Bfr, "%d %ld %ld %ld %s", &Status, &Number, &Start, &End, Cmd); /* Check for non-existant news group. */ if (Status == 411) { fprintf(stderr, "%s %d : Error, no such news group '%s'.\n", __FILE__, __LINE__, GroupName); } else { /* Check for no articles in news group. */ if (Number == 0L || Start > End) { fprintf(stderr, "%s %d : No news in group '%s'.\n", __FILE__, __LINE__, GroupName); } else { /* Open output file, get all articles. */ if ((OutFp = fopen(OutFlNm, "a")) == NULL) { fprintf(stderr, "%s %d : Error, could not open file ", __FILE__, __LINE__); fprintf(stderr, "'%s' for writing.\n", OutFlNm); } else { /* Is there a kill file? */ if ( KillList ) { /* Search kill list. */ for (KillNd = KillList; KillNd; KillNd = KillNd->Next) if (! strcmp(GroupName, KillNd->NewsGroup)) break; } else KillNd = NULL; /* Get all articles, write to file. */ if (LastRd <= End) { /* Get all articles. */ for (i = (LastRd > Start) ? LastRd : Start; i <= End; i++) RdArt(SockDesc, i, GroupName, KillNd, OutFp); LastRd = i; } fputc('\n', stderr); /* Close the output file pointer. */ fclose( OutFp ); } } } } /* Write the new value for the configuration file. */ fprintf(NewFp, "group %s %s %ld\n", GroupName, OutFlNm, LastRd); } /* Close the configuration files. */ fclose( CfgFp ); fclose( NewFp ); /* Delete the old configuration file, and rename the new to * be the same as the old. */ remove( CfgFlNm ); rename(TmpFlNm, CfgFlNm); } /*----------------------------------------------------------------------------- | Routine : AddKillRE() --- Add a kill RE to the list. | | Inputs : Bfr - RE source string. -----------------------------------------------------------------------------*/ void AddKillRE(KILL_ND *KillNd, char *Bfr) { auto REG_EXP_NODE **ReExpr; /* Up the number and allocate a new list. */ KillNd->NoKillREs++; ReExpr = KillNd->KillREs; /* Allocate new list. */ KillNd->KillREs = (REG_EXP_NODE **) malloc(KillNd->NoKillREs * sizeof(REG_EXP_NODE *)); if (KillNd->KillREs == NULL) { fprintf(stderr, "%s %d - Out of memory.\n", __FILE__, __LINE__); exit( 1 ); } /* Copy old list to new and deallocate old list. */ if ( ReExpr ) { MemCopy(KillNd->KillREs, ReExpr, KillNd->NoKillREs * sizeof(REG_EXP_NODE *)); free( ReExpr ); } /* Add new kill regular expression to list. */ KillNd->KillREs[KillNd->NoKillREs - 1] = ReCompile( Bfr ); } /*----------------------------------------------------------------------------- | Routine : BldKill() --- Build kill list. | | Inputs : Bfr - RE source string. -----------------------------------------------------------------------------*/ void BldKill(FILE *KillFp) { auto KILL_ND *KillNd; auto char String[MAX_BFR]; /* Assume that the first line is the news group name. */ while ( fgets(Bfr, MAX_BFR, KillFp) ) { /* Allocate a kill list node. */ if ((KillNd = (KILL_ND *) calloc(1, sizeof( KILL_ND ))) == NULL) { fprintf(stderr, "%s %d - Out of memory.\n", __FILE__, __LINE__); exit( 1 ); } /* Initialize the kill list. */ if (KillList != NULL) KillNd->Next = KillList; KillList = KillNd; /* Save the news group name string. */ sscanf(Bfr, "%s", String); KillNd->NewsGroup = StrDup( String ); /* Get begin. */ if (fgets(Bfr, MAX_BFR, KillFp) == NULL) { fprintf(stderr, "%s %d - Error in kill file 'begin'.\n", __FILE__, __LINE__); fprintf(stderr, "\tNewsgroup: '%s'\n", String); exit( 1 ); } /* Get and create the prefix RE. */ sscanf(Bfr, "begin /%[^/]", String); KillNd->PreFix = ReCompile( String ); /* Get kill RE's. */ while ( fgets(Bfr, MAX_BFR, KillFp) ) { /* Get the RE. */ if (sscanf(Bfr, " /%[^/]", String) == 0) if (sscanf(Bfr, "%s", String) == 1 && strcmp(String, "end") == 0) break; else { /* Report missing 'end' error. */ fprintf(stderr, "%s %d - Error, missing kill file 'end'.\n", __FILE__, __LINE__); exit( 1 ); } /* Add kill RE to list. */ AddKillRE(KillNd, String); } } } void main(int argc, char **argv) { auto int SockDesc; auto FILE *KillFp; /* Check the argument count. */ if (argc < 3) { /* Bad argument count, give synopsis. */ fprintf(stderr, "Usage : %s \n", argv[0]); exit( 1 ); } else if (argc == 4) { /* Open kill file. */ if ((KillFp = fopen(argv[3], "r")) == NULL) { fprintf(stderr, "%s %d : Error, could not open kill file.\n", __FILE__, __LINE__); exit( 1 ); } /* Build kill list. */ BldKill( KillFp ); /* Close kill file. */ fclose( KillFp ); } /* Attempt to set up the socket. */ SockDesc = SetupSocket(argv[1], "nntp"); /* Read the sign on message and print it. */ fprintf(stderr, "%s\n", Version); RdSrvr(SockDesc, Bfr, MAX_BFR); fprintf(stderr, "%s", Bfr); /* Read and execute the commands out of the configuration file. */ RdConfig(argv[2], SockDesc); /* Quit server. */ sprintf(Bfr, "QUIT\r\n"); WrtSrvr(SockDesc, Bfr, strlen( Bfr )); RdSrvr(SockDesc, Bfr, MAX_BFR); fprintf(stderr, "%s", Bfr); /* Close the socket descriptor and exit with no errors. */ close( SockDesc ); exit( 0 ); } unpost/compiler.h100644 23453 0 13543 5543402240 13772 0ustar jeanpaulsystem/****************************************************************************** * Module : Compiler include files, separated out to make configuration * different systems a little easier (I hate this, I really * hate this, but it has been requested, so here it is). * * Author : John W. M. Stevens ******************************************************************************/ #include #include #include #include #include /*============================================================================= * Configure the program. . . * * WARNING! Be sure what you are doing here. . . =============================================================================*/ /* Debug macro. Uncomment to get debug output. */ /* #define UNPOST_DEBUG 1 */ /* Uncomment to give you different file name munging under OS/2 * on the basis of the File System. * * Suggestions and help courtesy of: * * Darrel R Hankerson * * Without whose help and discussion, this would not have been done. * In other words, blame it all on him. . . :-) */ /* #define MUNGE_FILE_NAMES_PER_FS 1 */ /* Change the one to a zero to make file name mungling default to * being off. */ #define MUNGE_FILE_NMS 1 /* Change the one to a zero to make description file dumping * default to being off. */ #define DUMP_DESC_FILES 1 /* Change zero to one to make incompletes separation be turned on * by default. */ #define SEP_INCOMPLETES 0 /*----------------------------------------------------------------------------- * Compiler specific stuff below. * * The first set is for the Lattice C compiler on the Amiga. -----------------------------------------------------------------------------*/ #if defined(LATTICE_C_COMPILER) /* Defines for fopen calls. */ #define TXT_APPEND "at" #define TXT_READ "rt" #define BIN_READ "rb" #define TXT_WRITE "wt" #define BIN_WRITE "wb" #define BIN_RD_WRT "wb+" #define SEEK_SET 0 /*----------------------------------------------------------------------------- * This set is for the GCC compiler on Unix systems. -----------------------------------------------------------------------------*/ #elif defined(GCC_COMPILER) extern char *sys_errlist[]; #define strerror(x) sys_errlist[x] /* Defines for fopen calls. */ #define TXT_APPEND "a" #define TXT_READ "r" #define BIN_READ "r" #define TXT_WRITE "w" #define BIN_WRITE "w" #define BIN_RD_WRT "w+" #include #include /*----------------------------------------------------------------------------- * The GCC compiler on OS/2. -----------------------------------------------------------------------------*/ #elif defined(EMX_GCC_COMPILER) /* Defines for fopen calls. */ #define TXT_APPEND "at" #define TXT_READ "rt" #define BIN_READ "rb" #define TXT_WRITE "wt" #define BIN_WRITE "wb" #define BIN_RD_WRT "wb+" #include #include #if defined(SYSTEM_OS_2) #define INCL_DOSFILEMGR #include #else #include #endif #include #include /*----------------------------------------------------------------------------- * The IBM C Set++ compiler on OS/2. * * With thanks to: kevin@elvis.wicat.com -----------------------------------------------------------------------------*/ #elif defined(IBM_CSET_COMPILER) /* Defines for fopen calls. */ #define TXT_APPEND "at" #define TXT_READ "rt" #define BIN_READ "rb" #define TXT_WRITE "wt" #define BIN_WRITE "wb" #define BIN_RD_WRT "wb+" #include #include #if defined(SYSTEM_OS_2) #define INCL_DOSFILEMGR #include #else #include #endif #include /*----------------------------------------------------------------------------- * The MSC compiler on OS/2. -----------------------------------------------------------------------------*/ #elif defined(OS_2_MSC_COMPILER) /* Defines for fopen calls. */ #define TXT_APPEND "at" #define TXT_READ "rt" #define BIN_READ "rb" #define TXT_WRITE "wt" #define BIN_WRITE "wb" #define BIN_RD_WRT "wb+" #include #include #if defined(SYSTEM_OS_2) #define INCL_DOSFILEMGR #include #else #include #endif /*----------------------------------------------------------------------------- * The BCC compiler on MS-DOS. -----------------------------------------------------------------------------*/ #elif defined(BCC_COMPILER) #include /* Defines for fopen calls. */ #define TXT_APPEND "at" #define TXT_READ "rt" #define BIN_READ "rb" #define TXT_WRITE "wt" #define BIN_WRITE "wb" #define BIN_RD_WRT "wb+" #include /*----------------------------------------------------------------------------- * This set is for the CC compiler on VAX/VMS. -----------------------------------------------------------------------------*/ #elif defined(VMS) /* Defines for fopen calls. */ #define TXT_APPEND "a" #define TXT_READ "r" #define BIN_READ "r" #define TXT_WRITE "w" #define BIN_WRITE "w" #define BIN_RD_WRT "w+" /*----------------------------------------------------------------------------- * All others (Non-ANSI compatible). -----------------------------------------------------------------------------*/ #else /* Defines for fopen calls. */ #define TXT_APPEND "a" #define TXT_READ "r" #define BIN_READ "r" #define TXT_WRITE "w" #define BIN_WRITE "w" #define BIN_RD_WRT "w+" #define strerror(x) sys_errlist[x] #include #endif unpost/utils/ 40755 23453 0 0 5613467452 13042 5ustar jeanpaulsystemunpost/utils/mofs.c100644 23453 0 5234 5457221114 14240 0ustar jeanpaulsystem/****************************************************************************** * Module : Used for debugging UNPOST, this routine will start doing * a MORE at the specified offset in the file. * * Author : John W. M. Stevens ******************************************************************************/ #include #include #include void main(int argc, char **argv) { register int i; register int j; auto FILE *FlPtr; auto long Ofs; static char Bfr[513]; /* Check the command line arguments. */ if (argc != 3) { fprintf(stderr, "%s %d : Error - Syntax is: mofs <+ofs> \n", __FILE__, __LINE__); exit( 1 ); } /* Get the offset. */ if (argv[1][0] != '+') { fprintf(stderr, "%s %d : Error - Syntax is: mofs <+ofs> \n", __FILE__, __LINE__); exit( 1 ); } Ofs = atol(argv[1] + 1); /* Open the file to more. */ if ((FlPtr = fopen(argv[2], "r")) == NULL) { fprintf(stderr, "%s %d : Error - %s\n", __FILE__, __LINE__, sys_errlist[errno]); exit( 1 ); } /* Position the file pointer. */ if ( fseek(FlPtr, Ofs, SEEK_SET) ) { fprintf(stderr, "%s %d : Error - %s\n", __FILE__, __LINE__, sys_errlist[errno]); exit( 1 ); } /* More the file. */ for ( ; ; ) { /* Dump out lines. */ for (i = 0; i < 24; i++) { /* Get a line. */ if (fgets(Bfr, 512, FlPtr) == NULL) exit( 0 ); /* Check for auto scroll. */ j = strlen( Bfr ); if (j > 80) i += j / 80; fputs(Bfr, stdout); } /* Get the input from the user. */ fgets(Bfr, 512, stdin); if (*Bfr >= '0' && *Bfr <= '9') { /* Get the offset. */ Ofs = atol( Bfr ); /* Position the file pointer. */ if ( fseek(FlPtr, Ofs, SEEK_SET) ) { fprintf(stderr, "%s %d : Error - %s\n", __FILE__, __LINE__, sys_errlist[errno]); exit( 1 ); } } else if (*Bfr == 'q' || *Bfr == 'Q') break; } /* Close the file. */ fclose( FlPtr ); } unpost/utils/tokens100644 23453 0 473 5457221126 14341 0ustar jeanpaulsystemalternate T_ALTERNATE body T_BODY case T_CASE header T_HEADER id T_ID ignore T_IGNORE number T_NUMBER part T_PART segment T_SEGMENT segments T_SEGMENTS sensitive T_SENSITIVE string T_STRING total T_TOTAL { T_L_BRACE } T_R_BRACE unpost/utils/trie.c100644 23453 0 15244 5457221142 14262 0ustar jeanpaulsystem/***************************************************************************** * Program: Trie --- Create a trie in a 'C' compiler readable format. * * Author : John W. M. Stevens *****************************************************************************/ #include #include #include #include #include /* Type definition. */ typedef struct { char c; char *val; struct trie *branch; } KEY; typedef struct trie { int NoEls; int Size; char Lbl[10]; KEY Keys[1]; } TRIE; static TRIE *Head = NULL; /*---------------------------------------------------------------------------- | Routine: TrieIns() --- Insert a string into the trie. | | Inputs : Trie - The trie to insert into. | str - The string to insert. | val - The value string for this key string. | Outputs: Returns the pointer to the trie level. ----------------------------------------------------------------------------*/ static long LblNo = 0L; TRIE *TrieIns(TRIE *Trie, char *str, char *val) { register int i; register int j; auto int hi; auto int lo; auto int ret; /* Create a level if neccesary. */ if (Trie == NULL) { /* Calculate the size of the level in bytes. */ i = sizeof( TRIE ) + 4 * sizeof( KEY ); /* Allocate a level. */ if ((Trie = malloc( i )) == NULL) { perror( "TrieIns (malloc) " ); return( NULL ); } /* Clear the memory to all zeros. */ memset((char *) Trie, '\0', i); /* Initialize the new trie level. */ Trie->NoEls = 1; Trie->Size = 5; Trie->Keys[0].c = *str++; sprintf(Trie->Lbl, "%x", LblNo++); /* End of string? */ if ( *str ) { Trie->Keys[0].val = "0"; Trie->Keys[0].branch = TrieIns(NULL, str, val); } else Trie->Keys[0].val = val; return( Trie ); } /* Search for the current character of the string to insert. */ hi = Trie->NoEls - 1; lo = 0; do { /* Find mid point of current array piece. */ i = (hi + lo) >> 1; /* Do character comparison. */ ret = *str - Trie->Keys[i].c; /* Shrink the search limits. */ if (ret <= 0) hi = i - 1; if (ret >= 0) lo = i + 1; } while (hi >= lo); /* Did we find the character? */ if (ret == 0) { /* Yes, continue the search. */ if ( *++str ) Trie->Keys[i].branch = TrieIns(Trie->Keys[i].branch, str, val); return( Trie ); } /* If the trie level is not big enough, reallocate it. */ if (Trie->Size == Trie->NoEls) { /* Calculate the size of the new level. */ i = sizeof( TRIE ) + (5 + Trie->Size) * sizeof( KEY ); /* Attempt to reallocate the trie level. */ if ((Trie = realloc(Trie, i)) == NULL) { perror( "TrieIns (realloc) " ); return( NULL ); } /* Up the size of the trie level. */ Trie->Size += 5; } /* Make room for new character. */ if (hi < Trie->NoEls - 1) { j = sizeof( KEY ) * (Trie->NoEls - lo); memmove(Trie->Keys + lo + 1, Trie->Keys + lo, j); } /* Insert new object. */ i = lo; Trie->Keys[i].c = *str++; Trie->Keys[i].branch = NULL; Trie->NoEls++; /* Continue insert if not at end of string. */ if ( *str ) { Trie->Keys[i].val = "0"; Trie->Keys[i].branch = TrieIns(NULL, str, val); } else Trie->Keys[i].val = val; return( Trie ); } /*---------------------------------------------------------------------------- | Routine: TrieDump() --- Dump the trie in a form usable by the 'C' | compiler. | | Inputs : Trie - The trie to dump. | Lable - Trie level label. | Outputs: Returns the pointer to the trie level. ----------------------------------------------------------------------------*/ void TrieDump(TRIE *Trie) { register int i; register int j; auto char NxtLbl[12]; /* Do a post order traversal of tree. */ for (i = j = 0; i < Trie->NoEls; i++) { /* Check for children. */ if (Trie->Keys[i].branch == NULL) continue; /* Do current branch. */ TrieDump( Trie->Keys[i].branch ); } /* Print label for this level. */ printf("static\nKEY\tT%s[%d] = {\n", Trie->Lbl, Trie->NoEls + 1); printf("\t{\t' ',\t%15d,\t%-20s\t}", Trie->NoEls + 1, "NULL"); /* Dump current level. */ for (i = j = 0; i < Trie->NoEls; i++) { /* Check for children. */ printf(",\n\t"); if (Trie->Keys[i].branch == NULL) { printf("{\t'%c',\t%15s,\t%-20s\t}", Trie->Keys[i].c, Trie->Keys[i].val, "NULL"); continue; } /* Print the key. */ printf("{\t'%c',\t%15s,\tT%-19s\t}", Trie->Keys[i].c, Trie->Keys[i].val, Trie->Keys[i].branch->Lbl); } printf("\n};\n\n"); } void main(int argc, char *argv[]) { auto FILE *fp; auto char bf[256]; auto char *tp; auto char *token; auto char *val; /* Check the number of command line parameters. */ if (argc != 2) { fprintf(stderr, "Syntax error: trie \n"); exit( -1 ); } /* Open the token file for reading. */ if ((fp = fopen(argv[1], "rt")) == NULL) { perror( "trie (fopen) " ); exit( -1 ); } /* Get and insert all strings into the trie. */ while ( fgets(bf, 256, fp) ) { /* Strip white space. */ tp = bf; while (*tp == ' ' || *tp == '\t') tp++; /* Find end of token. */ token = tp; while (*tp != ' ' && *tp != '\t' && *tp != '\n') tp++; *tp++ = '\0'; /* Strip white space. */ while (*tp == ' ' || *tp == '\t') tp++; /* Find end of the value string. */ val = tp; while (*tp != ' ' && *tp != '\t' && *tp != '\n') tp++; *tp = '\0'; /* Duplicate the value string. */ if ((val = strdup( val )) == NULL) { perror( "trie (strdup) " ); exit( -1 ); } /* Do string insert into trie. */ Head = TrieIns(Head, token, val); } TrieDump( Head ); } unpost/config.c100644 23453 0 33751 5543402236 13430 0ustar jeanpaulsystem/****************************************************************************** * Module : Parse Configuration File --- Build the regular expression * hierarchy tree by reading data from a configuration file. * * Notes : Configuration file grammar: * * CONFIG_FILE ::= SEGMENT * | SEGMENT CONFIG_FILE * * SEGMENT ::= 'segment' STRING '{' ID_LINES '}' * * ID_LINES ::= 'header' '{' PREFIXES '}' * 'body' '{' PREFIXES '}' * * PREFIXES ::= PREFIX * | PREFIX PREFIXES * * PREFIX ::= STRING '{' ID_PARTS '}' * * ID_PARTS ::= ID_PART_RE * | ID_PART_RE ID_PARTS * * ID_PART_RE := STRING '{' * 'id' NUMBER * 'segment' 'number' NUMBER * 'segments' NUMBER * 'alternate' 'id' NUMBER * 'case' CASE_TYPE * '}' * * CASE_TYPE ::= 'sensitive' * | 'ignore' * * STRING ::= '"' [ -~]* '"' * * NUMBER ::= [0-9]+ * * Author : John W. M. Stevens ******************************************************************************/ #include "compiler.h" #include "unpost.h" #include "lex.h" #include "list.h" #include "parse.h" #include "regexp.h" #include "config.h" #include "utils.h" typedef enum { ID_SUB_EXPR, SEG_NO_SUB_EXPR, NO_SEGS_SUB_EXPR, ALT_ID_SUB_EXPR, CASE_SENSITIVITY } ID_PARTS_IDX; static char ReStr[512]; /*----------------------------------------------------------------------------- | Routine : ParseParts() --- Parse the ID line part number blocks. | | Returns : A pointer to the root of the ID part regular expression tree. -----------------------------------------------------------------------------*/ static PART_RE *ParseParts(void) { register int i; auto TOKEN sym; auto int tkn; auto int Elements[5]; auto char *tp; auto PART_RE NewPart; auto LIST *PartList; /* Create ID list. */ PartList = CrtList( sizeof( PART_RE ) ); /* Get list of part extraction regular expressions. */ while ((tkn = Lex( &sym )) == T_DBL_QUOTE) { /* Initialize new part re structure. */ NewPart.IDStr = 0; NewPart.SegNo = 0; NewPart.NoSegs = 0; NewPart.AltIDStr = 0; NewPart.Case = IGN_CASE; /* Get IDENT line part regular expression string. */ for (tp = ReStr; ; tp = ReStr + strlen( ReStr )) { /* Copy string from token structure to buffer. */ strcpy(tp, sym.str); /* Get next token. */ if ((tkn = Lex( &sym )) != T_DBL_QUOTE) break; } /* Create ID prefix regular expression string. */ NewPart.ReExpStr = StrDup( ReStr ); /* Check for opening curly brace. */ if (tkn != T_L_BRACE) { ParseErr("expecting '{' to open ID part block."); exit( 1 ); } /* Process components in ANY order. */ for (i = ID_SUB_EXPR; i <= CASE_SENSITIVITY; i++) Elements[i] = 0; for (i = ID_SUB_EXPR; i <= CASE_SENSITIVITY; i++) { /* Get a token. */ if ((tkn = Lex( &sym )) == T_R_BRACE) break; /* Select parse action based on token. */ switch ( tkn ) { case T_ID: /* Check for duplication. */ if (Elements[ID_SUB_EXPR] != 0) { ParseErr("duplicate sub-expression numbers."); exit( 1 ); } /* Get the sub-expression number for the ID sub-string. */ if ((tkn = Lex( &sym )) != T_INT_NO) { ParseErr("missing sub-expression number."); exit( 1 ); } NewPart.IDStr = sym.no; Elements[ID_SUB_EXPR] = 1; break; case T_SEGMENT: /* Check for duplication. */ if (Elements[SEG_NO_SUB_EXPR] != 0) { ParseErr("duplicate sub-expression numbers."); exit( 1 ); } /* Get next token. */ if ((tkn = Lex( &sym )) != T_NUMBER) { ParseErr("missing 'number' after 'segment'."); exit( 1 ); } /* Get sub-expression number for the segment number * sub-string. */ if ((tkn = Lex( &sym )) != T_INT_NO) { ParseErr("missing sub-expression number."); exit( 1 ); } NewPart.SegNo = sym.no; Elements[SEG_NO_SUB_EXPR] = 1; break; case T_SEGMENTS: /* Check for duplication. */ if (Elements[NO_SEGS_SUB_EXPR] != 0) { ParseErr("duplicate sub-expression numbers."); exit( 1 ); } /* Get number of segments sub-expression number. */ if ((tkn = Lex( &sym )) != T_INT_NO) { ParseErr("missing sub-expression number."); exit( 1 ); } NewPart.NoSegs = sym.no; Elements[NO_SEGS_SUB_EXPR] = 1; break; case T_ALTERNATE: /* Check for duplication. */ if (Elements[ALT_ID_SUB_EXPR] != 0) { ParseErr("duplicate sub-expression numbers."); exit( 1 ); } /* Get next token. */ if ((tkn = Lex( &sym )) != T_ID) { ParseErr("missing 'id' after 'alternate'."); exit( 1 ); } /* Get alternate ID string sub-expression number. */ if ((tkn = Lex( &sym )) != T_INT_NO) { ParseErr("missing sub-expression number."); exit( 1 ); } NewPart.AltIDStr = sym.no; Elements[ALT_ID_SUB_EXPR] = 1; break; case T_CASE: /* Check for duplication. */ if (Elements[CASE_SENSITIVITY] != 0) { ParseErr("duplicate sub-expression numbers."); exit( 1 ); } /* Get case sensitivity type. */ if ((tkn = Lex( &sym )) == T_SENSITIVE) NewPart.Case = CASE_SENSITIVE; else if (tkn == T_IGNORE) NewPart.Case = IGN_CASE; else { ParseErr("expected case sensitivity type after 'case'."); exit( 1 ); } Elements[CASE_SENSITIVITY] = 1; break; default: ParseErr( "Unexpected token in ID part block" ); break; } } /* Compile string and save pointer to expression tree in * structure, then save structure in segment list. */ NewPart.ReExpr = ReCompile( NewPart.ReExpStr ); PartList = AppList(PartList, &NewPart); /* Get closing token. */ if (tkn != T_R_BRACE) { /* Get and discard the right brace. */ if ((tkn = Lex( &sym )) != T_R_BRACE) { ParseErr("expecting '}' to close ID part block."); exit( 1 ); } } } /* Check closing token. */ if (tkn != T_R_BRACE) { ParseErr("expecting '}' to close ID prefix block."); exit( 1 ); } /* Append a null record. */ memset(&NewPart, 0, sizeof( PART_RE )); PartList = AppList(PartList, &NewPart); /* Return pointer to list. */ MemCopy(PartList, PartList->List, sizeof( PART_RE ) * PartList->NoElems); /* Return pointer to list. */ return( (PART_RE *) PartList ); } /*----------------------------------------------------------------------------- | Routine : ParseIDs() --- Parse the ID blocks. | | Returns : A pointer to the root of the ID regular expression tree. -----------------------------------------------------------------------------*/ static IDENT *ParseIDs(void) { auto TOKEN sym; auto int tkn; auto char *tp; auto IDENT NewID; auto LIST *PreFixList; /* Create ID list. */ PreFixList = CrtList( sizeof( IDENT ) ); /* Get regular expression source string. */ while ((tkn = Lex( &sym )) == T_DBL_QUOTE) { /* Get IDENT line regular expression string. */ for (tp = ReStr; ; tp = ReStr + strlen( ReStr )) { /* Copy string from token structure to buffer. */ strcpy(tp, sym.str); /* Get next token. */ if ((tkn = Lex( &sym )) != T_DBL_QUOTE) break; } /* Check for opening curly brace. */ if (tkn != T_L_BRACE) { ParseErr("expecting '{' after ID prefix regular expression."); exit( 1 ); } /* Create ID prefix regular expression string. */ NewID.ReExprStr = StrDup( ReStr ); /* Parse header regular expression configuration block. */ NewID.IdParts = ParseParts(); /* Compile string and save pointer to expression tree in * structure, then save structure in segment list. */ NewID.ReExpr = ReCompile( NewID.ReExprStr ); PreFixList = AppList(PreFixList, &NewID); } /* Check closing token. */ if (tkn != T_R_BRACE) { ParseErr("expecting '}' to close ID block."); exit( 1 ); } /* Append a null record. */ memset(&NewID, 0, sizeof( IDENT )); PreFixList = AppList(PreFixList, &NewID); /* Return pointer to list. */ MemCopy(PreFixList, PreFixList->List, sizeof( IDENT ) * PreFixList->NoElems); /* Return pointer to list. */ return( (IDENT *) PreFixList ); } /*----------------------------------------------------------------------------- | Routine : ReadConfig() --- Read the configuration file. | | Inputs : CfgFlNm - Name of configuration file name. | | Returns : A pointer to the root of the SEGMENT regular expression tree. -----------------------------------------------------------------------------*/ SEGMENT *ReadConfig(char *CfgFlNm) { auto TOKEN sym; auto int tkn; auto char *tp; auto SEGMENT NewSeg; auto LIST *SegList; /* Open the configuration file. */ OpenCfg( CfgFlNm ); /* Get token. */ if ((tkn = Lex( &sym )) != T_SEGMENT) { ParseErr("expecting SEGMENT token."); exit( 1 ); } /* Create segment list. */ SegList = CrtList( sizeof( SEGMENT ) ); /* Process multiple SEGMENT begin line blocks. */ while (tkn == T_SEGMENT) { /* Get regular expression source string. */ if ((tkn = Lex( &sym )) != T_DBL_QUOTE) { ParseErr("expecting regular expression source string."); exit( 1 ); } /* Get SEGMENT begin line regular expression string. */ for (tp = ReStr; ; tp = ReStr + strlen( ReStr )) { /* Copy string from token structure to buffer. */ strcpy(tp, sym.str); /* Get next token. */ if ((tkn = Lex( &sym )) != T_DBL_QUOTE) break; } /* Check for opening curly brace. */ if (tkn != T_L_BRACE) { ParseErr("expecting '{' to open SEGMENT block."); exit( 1 ); } /* Create SEGMENT regular expression string. */ NewSeg.ReExprStr = StrDup( ReStr ); /* Get header block prefix. */ if ((tkn = Lex( &sym )) != T_HEADER) { ParseErr("expecting 'header' in SEGMENT block."); exit( 1 ); } /* Get open curly brace. */ if ((tkn = Lex( &sym )) != T_L_BRACE) { ParseErr("expecting '{' to open HEADER block."); exit( 1 ); } /* Get header block. */ NewSeg.Header = ParseIDs(); /* Get body block prefix. */ if ((tkn = Lex( &sym )) != T_BODY) { ParseErr("expecting 'body' in SEGMENT block."); exit( 1 ); } /* Get open curly brace. */ if ((tkn = Lex( &sym )) != T_L_BRACE) { ParseErr("expecting '{' to open BODY block."); exit( 1 ); } /* Parse body ID block. */ NewSeg.Body = ParseIDs(); /* Compile string and save pointer to expression tree in * structure, then save structure in SEGMENT begin line list. */ NewSeg.ReExpr = ReCompile( NewSeg.ReExprStr ); SegList = AppList(SegList, &NewSeg); /* Get closing token. */ if ((tkn = Lex( &sym )) != T_R_BRACE) { ParseErr("expecting '}' to close SEGMENT block."); exit( 1 ); } /* Get next token. */ if ((tkn = Lex( &sym )) == EOF) break; } /* Append a null record. */ memset(&NewSeg, 0, sizeof( SEGMENT )); SegList = AppList(SegList, &NewSeg); /* Return pointer to list. */ MemCopy(SegList, SegList->List, sizeof( SEGMENT ) * SegList->NoElems); /* Close the configuration file and return a pointer to the new * configuration tree. */ CloseCfg(); return( (SEGMENT *) SegList ); } unpost/config.h100644 23453 0 704 5543402240 13360 0ustar jeanpaulsystem/****************************************************************************** * Module : Configuration File Parser --- Parse the configuration file. * * Author : John W. M. Stevens ******************************************************************************/ #if ! defined(CONFIG_FILE_PARSER) #define CONFIG_FILE_PARSER #include "parse.h" /* External function prototypes. */ extern SEGMENT *ReadConfig(char *CfgFlNm); #endif unpost/decode.c100644 23453 0 55341 5543402236 13405 0ustar jeanpaulsystem/****************************************************************************** * Module : Decode --- Decode a file. * * Author : John W. M. Stevens ******************************************************************************/ #include "compiler.h" #include "unpost.h" #include "regexp.h" #include "parse.h" #include "uudec.h" #include "decode.h" #include "modflnm.h" #include "utils.h" /*----------------------------------------------------------------------------- | Routine : OpenBinFile() --- Find the begin line, and open the output | binary file. | | Inputs : InFlPtr - Pointer to input source file. | FlName - File to open for writing. | InBfr - Buffer to read lines into when searching for | begin line. | | Returns : Pointer to the binary file to write to. -----------------------------------------------------------------------------*/ static FILE *OpenBinFile(FILE *InFlPtr, char *FlName, char *InBfr) { auto FILE *OutFlPtr; auto char **RetStrs; extern FILE *ErrFile; /* Get begin line. */ if (ReadLine(InFlPtr, InBfr, BFR_SIZE) != EOF) { /* Is this the begin line? */ if ( MatchBegin(InBfr, &RetStrs) ) { /* Check to make sure that file does not already exist. */ if ( FileExists( FlName ) ) { fprintf(ErrFile, "\t%s %d : Error - file '%s' already exists.\n", __FILE__, __LINE__, FlName); return( NULL ); } /* Open the file. */ if ((OutFlPtr = fopen(FlName, BIN_RD_WRT)) == NULL) { fprintf(ErrFile, "\t%s %d : Error - %s\n\t'%s'\n", __FILE__, __LINE__, strerror( errno ), FlName); return( NULL ); } /* Return the file pointer. */ return( OutFlPtr ); } else { /* Missing begin line. */ fprintf(ErrFile, "\t%s %d : Error - missing begin line.\n", __FILE__, __LINE__); fprintf(ErrFile, "\t'%s'\n", InBfr); } } else { /* Missing begin line. */ fprintf(ErrFile, "\t%s %d : Error - missing begin line.\n", __FILE__, __LINE__); } /* Return NULL file pointer. */ return( NULL ); } /*----------------------------------------------------------------------------- | Routine : WriteDesc() --- Write descriptions to a separate file. | | Inputs : InFlPtr - Pointer to source file. | DescFlName - Name of description file. | FlDesc - Pointer to file descriptor structure. | InBfr - Pointer to buffer to read lines into. -----------------------------------------------------------------------------*/ static int WriteDesc(FILE *InFlPtr, char *DescFlName, FL_LIST *FlDesc, char *InBfr) { auto CHK_UU_ENC UULnType; auto char **RetStrs; auto int EncLen; auto IDENT *Hdr; auto IDENT *Body; auto FILE *DescFile; extern FILE *ErrFile; /* Check to make sure that file does not already exist. */ if ( FileExists( DescFlName ) ) { fprintf(ErrFile, "\t%s %d : Error - file '%s' already exists.\n", __FILE__, __LINE__, DescFlName); return( ERROR ); } /* Open the description file. */ if ((DescFile = fopen(DescFlName, TXT_WRITE)) == NULL) { fprintf(ErrFile, "\t%s %d : Error - Could not open description file ", __FILE__, __LINE__); fprintf(ErrFile, "'%s' for writing.\n", DescFlName); return( ERROR ); } /* Check to see which one of the segments exist. */ if ( FlDesc->Segs[0].Exists ) { /* Position file pointer to start of segment. */ if (fseek(InFlPtr, FlDesc->Segs[0].SegOfs, SEEK_SET) != 0) { fprintf(ErrFile, "\t%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); fclose( DescFile ); return( ERROR ); } /* Dump lines until the start of the next segment is seen. */ if (ReadLine(InFlPtr, InBfr, BFR_SIZE) != EOF) { /* Print the line. */ fprintf(DescFile, "%s\n", InBfr); /* Print description. */ while (ReadLine(InFlPtr, InBfr, BFR_SIZE) != EOF) { /* Is this a SEGMENT begin line? */ if ( MatchSegment(InBfr, &Hdr, &Body) ) break; /* Print the line. */ fprintf(DescFile, "%s\n", InBfr); } } } /* Position file pointer to start of segment. */ if (fseek(InFlPtr, FlDesc->Segs[1].SegOfs, SEEK_SET) != 0) { fprintf(ErrFile, "\t%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); fclose( DescFile ); return( ERROR ); } /* Dump lines until first UU encoded line is seen. */ while (ReadLine(InFlPtr, InBfr, BFR_SIZE) != EOF) { /* Print the line. */ fprintf(DescFile, "%s\n", InBfr); /* Check to see if this line is a UU encoded line. */ UULnType = ChkUULine(InBfr, &RetStrs, &EncLen); if (UULnType == UU_BEGIN || UULnType == UU_END || UULnType == IS_UU_LINE) break; } /* Return no error. */ fprintf(DescFile, "\n"); fclose( DescFile ); return( OK ); } /*----------------------------------------------------------------------------- | Routine : DecSeg() --- Decode a single segment. | | Inputs : InFlPtr - Pointer to source file. | OutFlPtr - Pointer to output binary file. | Outputs : UULnType - Returns UU line type. | | Returns : EOF - For end of file. | ERROR - For a binary file write error. -----------------------------------------------------------------------------*/ int DecSeg(FILE *InFlPtr, FILE *OutFlPtr, CHK_UU_ENC *UULnType) { auto int OutLen; /* Externals used by this function. */ extern char InBfr[]; extern BYTE OutBfr[]; extern FILE *ErrFile; /* Decode lines until end of segment. */ for ( ; ; ) { /* Get a line from the file. */ if (ReadLine(InFlPtr, InBfr, BFR_SIZE) == EOF) return( EOF ); /* Check the line to make sure that it is a UUENCODE * line, and if it is, decode it. */ *UULnType = DecUULine(InBfr, &OutLen, OutBfr); if (*UULnType == NOT_UU_LINE || *UULnType == UU_BEGIN || *UULnType == UU_END) break; else if (*UULnType == UU_SPACE) continue; /* Are there any bytes to write? */ if ( OutLen ) { /* Write the buffer to the output file. */ if (fwrite(OutBfr, 1, OutLen, OutFlPtr) != OutLen) { fprintf(ErrFile, "\t%s %d : Error - Bad write to binary file.\n", __FILE__, __LINE__); return( ERROR ); } } } /* No errors, all is cool. */ return( OK ); } /*----------------------------------------------------------------------------- | Routine : DeCode() --- Decode the file. | | Inputs : InFlPtr - Pointer to source file. | FlDesc - Pointer to file descriptor. -----------------------------------------------------------------------------*/ int DeCode(FILE *InFlPtr, FL_LIST *FlDesc) { register int i; auto FILE *OutFlPtr; auto int ret; auto CHK_UU_ENC UULnType; auto char OutFlNm[FL_NM_SZ]; auto CRC_TYPE UnpostCRC; /* Externals used by this function. */ extern int DumpDesc; extern char InBfr[]; extern FILE *ErrFile; /* Check to make sure that all segments are present before we * decode. */ for (i = 1; i <= FlDesc->NoSegs; i++) { /* Check for missing segments. */ if (FlDesc->Segs[i].SegNo == 0) { fprintf(ErrFile, "\t%s %d : Error - missing segment #%d.\n", __FILE__, __LINE__, i); fprintf(ErrFile, "\tBinary ID: '%s'\n", FlDesc->IDString); return( ERROR ); } } /* Check for file name. If none, report error. */ if (! FlDesc->FlName) { fprintf(ErrFile, "\t%s %d : Error - missing file name.\n", __FILE__, __LINE__); fprintf(ErrFile, "\tBinary ID: '%s'\n", FlDesc->IDString); return( ERROR ); } /* If we want descriptions, dump the first part of segment one. */ if ( DumpDesc ) { /* Dump description for zero segment, if one exists, and * dump the first part of segment one (up to and including * the begin line. */ ModExten(FlDesc->FlName, ".dsc", OutFlNm); WriteDesc(InFlPtr, OutFlNm, FlDesc, InBfr); } /* Now that we have scanned all lines, decode file. */ for (i = 1; i <= FlDesc->NoSegs; i++) { /* Position file pointer to first UUencoded * line of segment. */ if (fseek(InFlPtr, FlDesc->Segs[i].UUOfs, SEEK_SET) != 0) { fprintf(ErrFile, "\t%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); return( ERROR ); } /* Open the binary file. */ if (i == 1) { /* Open the binary file. */ if ((OutFlPtr = OpenBinFile(InFlPtr, FlDesc->FlName, InBfr)) == NULL) return( ERROR ); } /* Decode lines until end of segment. */ if ((ret = DecSeg(InFlPtr, OutFlPtr, &UULnType)) == EOF || ret == ERROR) { /* Close output file, return error. */ fclose( OutFlPtr ); return( ret ); } /* Check for various errors. */ if (UULnType == NOT_UU_LINE) { /* Is there supposed to be a end line in this segment? */ if (i == FlDesc->NoSegs) { fprintf(ErrFile, "\t%s %d : Error - Missing UU end line.\n", __FILE__, __LINE__); fprintf(ErrFile, "\t'%s'\n", InBfr); fclose( OutFlPtr ); return( ERROR ); } } else if (UULnType == UU_END) { /* Is this supposed to be the end? */ if (i < FlDesc->NoSegs) { fprintf(ErrFile, "\t%s %d : Warning - Early uuencode end line.\n", __FILE__, __LINE__); } break; } else if (UULnType == UU_BEGIN) { /* What the HELL is this doing here?! */ fprintf(ErrFile, "\t%s %d : Error - Unexpected UU begin line.\n", __FILE__, __LINE__); return( ERROR ); } } /* If the CRC should be checked, calculate it and check it. */ if ( FlDesc->ChkCRC ) if (FlDesc->PostCRC != (UnpostCRC = CalcCRC( OutFlPtr ))) { fprintf(ErrFile, "%s %d : Error - POST CRC is ", __FILE__, __LINE__); fprintf(ErrFile, "0x%08lx, UNPOST CRC is 0x%08lx.\n", FlDesc->PostCRC, UnpostCRC); } /* Close the output file. */ fclose( OutFlPtr ); return( OK ); } /*----------------------------------------------------------------------------- | Routine : MultiWriteDesc() --- Write descriptions to a separate file. | | Inputs : DescFlName - Name of description file. | FlDesc - Pointer to file descriptor structure. | InBfr - Pointer to buffer to read lines into. -----------------------------------------------------------------------------*/ static int MultiWriteDesc(char *DescFlName, FL_LIST *FlDesc, char *InBfr) { auto FILE *InFlPtr; auto CHK_UU_ENC UULnType; auto char **RetStrs; auto int EncLen; auto IDENT *Hdr; auto IDENT *Body; auto FILE *DescFile; extern FILE *ErrFile; /* Check to make sure that file does not already exist. */ if ( FileExists( DescFlName ) ) { fprintf(ErrFile, "\t%s %d : Error - file '%s' already exists.\n", __FILE__, __LINE__, DescFlName); return( ERROR ); } /* Open the description file. */ if ((DescFile = fopen(DescFlName, TXT_WRITE)) == NULL) { fprintf(ErrFile, "\t%s %d : Error - Could not open description file ", __FILE__, __LINE__); fprintf(ErrFile, "'%s' for writing.\n", DescFlName); return( ERROR ); } /* Check to see which one of the segments exist. */ if ( FlDesc->Segs[0].Exists ) { /* Open the first file. */ if ((InFlPtr = fopen(FlDesc->Segs[0].SrcFlNm, BIN_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' for reading.\n", __FILE__, __LINE__, FlDesc->Segs[0].SrcFlNm); fclose( DescFile ); return( ERROR ); } /* Position file pointer to start of segment. */ if (fseek(InFlPtr, FlDesc->Segs[0].SegOfs, SEEK_SET) != 0) { fprintf(ErrFile, "\t%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); fclose( InFlPtr ); fclose( DescFile ); return( ERROR ); } /* Dump lines until the start of the next segment is seen. */ if (ReadLine(InFlPtr, InBfr, BFR_SIZE) != EOF) { /* Print the line. */ fprintf(DescFile, "%s\n", InBfr); /* Print description. */ while (ReadLine(InFlPtr, InBfr, BFR_SIZE) != EOF) { /* Is this a SEGMENT begin line? */ if ( MatchSegment(InBfr, &Hdr, &Body) ) break; /* Print the line. */ fprintf(DescFile, "%s\n", InBfr); } } fclose( InFlPtr ); } /* Open the first file. */ if ((InFlPtr = fopen(FlDesc->Segs[1].SrcFlNm, BIN_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' for reading.\n", __FILE__, __LINE__, FlDesc->Segs[0].SrcFlNm); fclose( DescFile ); return( ERROR ); } /* Position file pointer to start of segment. */ if (fseek(InFlPtr, FlDesc->Segs[1].SegOfs, SEEK_SET) != 0) { fprintf(ErrFile, "\t%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); fclose( InFlPtr ); fclose( DescFile ); return( ERROR ); } /* Dump lines until first UU encoded line is seen. */ while (ReadLine(InFlPtr, InBfr, BFR_SIZE) != EOF) { /* Print the line. */ fprintf(DescFile, "%s\n", InBfr); /* Check to see if this line is a UU encoded line. */ UULnType = ChkUULine(InBfr, &RetStrs, &EncLen); if (UULnType == UU_BEGIN || UULnType == UU_END || UULnType == IS_UU_LINE) break; } fprintf(DescFile, "\n"); /* Return no error. */ fclose( InFlPtr ); fclose( DescFile ); return( OK ); } /*----------------------------------------------------------------------------- | Routine : MultiDeCode() --- Decode a uuencoded posting that is | scattered across multiple source files. | | Inputs : InFlPtr - Pointer to source file. | FlDesc - Pointer to file descriptor. -----------------------------------------------------------------------------*/ int MultiDeCode(FL_LIST *FlDesc) { register int i; auto FILE *InFlPtr; auto FILE *OutFlPtr; auto int ret; auto CHK_UU_ENC UULnType; auto char OutFlNm[FL_NM_SZ]; auto CRC_TYPE UnpostCRC; /* Externals used by this function. */ extern int DumpDesc; extern char InBfr[]; extern FILE *ErrFile; /* Check to make sure that all segments are present before we * decode. */ for (i = 1; i <= FlDesc->NoSegs; i++) { /* Check for missing segments. */ if (FlDesc->Segs[i].SegNo == 0) { fprintf(ErrFile, "\t%s %d : Error - missing segment #%d.\n", __FILE__, __LINE__, i); fprintf(ErrFile, "\tBinary ID: '%s'\n", FlDesc->IDString); return( ERROR ); } } /* Check for file name. If none, report error. */ if (! FlDesc->FlName) { fprintf(ErrFile, "\t%s %d : Error - missing file name.\n", __FILE__, __LINE__); fprintf(ErrFile, "\tBinary ID: '%s'\n", FlDesc->IDString); return( ERROR ); } /* Modify the file name for writing descriptions. */ if ( DumpDesc ) { ModExten(FlDesc->FlName, ".dsc", OutFlNm); MultiWriteDesc(OutFlNm, FlDesc, InBfr); } /* Now that we have scanned all lines, decode file. */ for (i = 1; i <= FlDesc->NoSegs; i++) { /* Open the first file. */ if ((InFlPtr = fopen(FlDesc->Segs[i].SrcFlNm, BIN_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' for reading.\n", __FILE__, __LINE__, FlDesc->Segs[i].SrcFlNm); return( ERROR ); } /* Position file pointer to first UUencoded * line of segment. */ if (fseek(InFlPtr, FlDesc->Segs[i].UUOfs, SEEK_SET) != 0) { fprintf(ErrFile, "\t%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); fclose( InFlPtr ); return( ERROR ); } /* Open the binary file. */ if (i == 1) { /* Open the binary file. */ if ((OutFlPtr = OpenBinFile(InFlPtr, FlDesc->FlName, InBfr)) == NULL) { fclose( InFlPtr ); return( ERROR ); } } /* Decode lines until end of segment. */ if ((ret = DecSeg(InFlPtr, OutFlPtr, &UULnType)) == EOF || ret == ERROR) { /* Close output file, return error. */ fclose( InFlPtr ); fclose( OutFlPtr ); return( ret ); } /* Check for various errors. */ if (UULnType == NOT_UU_LINE) { /* Is there supposed to be a end line in this segment? */ if (i == FlDesc->NoSegs) { fprintf(ErrFile, "\t%s %d : Error - Missing UU end line.\n", __FILE__, __LINE__); fprintf(ErrFile, "\t'%s'\n", InBfr); fclose( InFlPtr ); fclose( OutFlPtr ); return( ERROR ); } } else if (UULnType == UU_END) { /* Is this supposed to be the end? */ if (i < FlDesc->NoSegs) { fprintf(ErrFile, "\t%s %d : Warning - Early uuencode end line.\n", __FILE__, __LINE__); } fclose( InFlPtr ); break; } else if (UULnType == UU_BEGIN) { /* What the HELL is this doing here?! */ fprintf(ErrFile, "\t%s %d : Error - Unexpected UU begin line.\n", __FILE__, __LINE__); fclose( InFlPtr ); fclose( OutFlPtr ); return( ERROR ); } /* Close the input file pointer. */ fclose( InFlPtr ); } /* If the CRC should be checked, calculate it and check it. */ if ( FlDesc->ChkCRC ) if (FlDesc->PostCRC != (UnpostCRC = CalcCRC( OutFlPtr ))) { fprintf(ErrFile, "%s %d : Error - POST CRC is ", __FILE__, __LINE__); fprintf(ErrFile, "0x%08lx, UNPOST CRC is 0x%08lx.\n", FlDesc->PostCRC, UnpostCRC); } /* Close the output file. */ fclose( OutFlPtr ); return( OK ); } unpost/decode.h100644 23453 0 1327 5543402240 13360 0ustar jeanpaulsystem/****************************************************************************** * Module : Decode segments. * * Author : John W. Stevens ******************************************************************************/ #if ! defined(DECODE_HELPER_HEADER) #define DECODE_HELPER_HEADER #include "parse.h" /* Function prototypes. */ extern int DecSeg(FILE *InFlPtr, FILE *OutFlPtr, CHK_UU_ENC *UULnType); extern int DeCode(FILE *InFlPtr, FL_LIST *FlDesc); extern void DecTruncUULn(char *Line, int *Len, BYTE *Bfr); extern int MultiDeCode(FL_LIST *FlDesc); #endif unpost/ident.c100644 23453 0 4521 5543402236 13237 0ustar jeanpaulsystem/****************************************************************************** * Module : Identify a binary file. * * Author : John Stevens ******************************************************************************/ #include "compiler.h" #include "ident.h" /* Define file type information for static storage. */ typedef struct { int Offset; int length; char *string; char ext[5]; BIN_TYPES FileType; } FILE_TYPES; static FILE_TYPES FileTypes[] = { { 0, 6, "GIF87a", ".gif", GIF87A }, { 0, 6, "GIF89a", ".gif", GIF89A }, { 6, 4, "JFIF", ".jpg", JFIF_JPEG }, { 0, 4, "hsi1", ".hsi", HSI1_JPEG }, { 0, 0, "", "", UNKNOWN_TYPE } }; /*----------------------------------------------------------------------------- | Routine : IdUUFile() --- Identify a uuencoded binary file from it's | first line. Currently this only works for graphics that | I have access to. | | Inputs : Bfr - Buffer containing first line. | Len - Number of bytes in buffer. | Ext - Pointer to extension buffer. | | Returns : Returns the file type. -----------------------------------------------------------------------------*/ BIN_TYPES IdUUFile(BYTE *Bfr, int Len, char *Ext) { register int i; register int j; auto BYTE *tp; /* Run file types, looking for all listed types. */ *Ext = '\0'; for (i = 0; FileTypes[i].length; i++) { /* Make sure that there are enough bytes in the buffer * to identify this file. */ if (FileTypes[i].length + (int) FileTypes[i].Offset > Len) continue; /* Compare the buffers. */ for (j = 0, tp = Bfr + FileTypes[i].Offset; j < FileTypes[i].length; j++) if (FileTypes[i].string[j] != (char) tp[j]) break; /* Check for file type found. */ if (j == FileTypes[i].length) { strcpy(Ext, FileTypes[i].ext); return( FileTypes[i].FileType ); } } /* Return type unknown. */ return( UNKNOWN_TYPE ); } unpost/ident.h100644 23453 0 1060 5543402240 13232 0ustar jeanpaulsystem/****************************************************************************** * Module : Identify a binary file. * * Author : John W. M. Stevens ******************************************************************************/ #if ! defined(IDENT_HEADER_FILE) #include "unpost.h" /* Define binary file type enumerations. */ typedef enum { UNKNOWN_TYPE, GIF87A, GIF89A, JFIF_JPEG, HSI1_JPEG } BIN_TYPES; extern BIN_TYPES IdUUFile(BYTE *Bfr, int Len, char *Ext); #endif unpost/lex.c100644 23453 0 40243 5543402236 12745 0ustar jeanpaulsystem/****************************************************************************** * Module : Lexical Analyzer --- Process the input text file into tokens * that the configuration file parser can understand. * * Routines : Lex() - Return the next token from the file. * OpenPrg - Open the back up program script file. * * Author : John W. M. Stevens ******************************************************************************/ #include "compiler.h" #include "lex.h" /* Type definitions for this file. */ typedef struct key_st { char c; TKNS val; struct key_st *branch; } KEY; /* Constants local to this file. */ #define NOT_FND -2 /* Object Data. */ static char word[80]; /* Last string analyzed. */ static int LnNo = 0; /* The current line number reading the script. */ static FILE *PrgFl; /* Pointer to the ASCII file that contains the * backup program script. */ /* Trie data structure containing all the keywords and punctuation marks for * the backup language. */ static KEY T8[2] = { { ' ', 2, NULL }, { 'e', T_ALTERNATE, NULL } }; static KEY T7[2] = { { ' ', 2, NULL }, { 't', 0, T8 } }; static KEY T6[2] = { { ' ', 2, NULL }, { 'a', 0, T7 } }; static KEY T5[2] = { { ' ', 2, NULL }, { 'n', 0, T6 } }; static KEY T4[2] = { { ' ', 2, NULL }, { 'r', 0, T5 } }; static KEY T3[2] = { { ' ', 2, NULL }, { 'e', 0, T4 } }; static KEY T2[2] = { { ' ', 2, NULL }, { 't', 0, T3 } }; static KEY T1[2] = { { ' ', 2, NULL }, { 'l', 0, T2 } }; static KEY Tb[2] = { { ' ', 2, NULL }, { 'y', T_BODY, NULL } }; static KEY Ta[2] = { { ' ', 2, NULL }, { 'd', 0, Tb } }; static KEY T9[2] = { { ' ', 2, NULL }, { 'o', 0, Ta } }; static KEY Te[2] = { { ' ', 2, NULL }, { 'e', T_CASE, NULL } }; static KEY Td[2] = { { ' ', 2, NULL }, { 's', 0, Te } }; static KEY Tc[2] = { { ' ', 2, NULL }, { 'a', 0, Td } }; static KEY T13[2] = { { ' ', 2, NULL }, { 'r', T_HEADER, NULL } }; static KEY T12[2] = { { ' ', 2, NULL }, { 'e', 0, T13 } }; static KEY T11[2] = { { ' ', 2, NULL }, { 'd', 0, T12 } }; static KEY T10[2] = { { ' ', 2, NULL }, { 'a', 0, T11 } }; static KEY Tf[2] = { { ' ', 2, NULL }, { 'e', 0, T10 } }; static KEY T18[2] = { { ' ', 2, NULL }, { 'e', T_IGNORE, NULL } }; static KEY T17[2] = { { ' ', 2, NULL }, { 'r', 0, T18 } }; static KEY T16[2] = { { ' ', 2, NULL }, { 'o', 0, T17 } }; static KEY T15[2] = { { ' ', 2, NULL }, { 'n', 0, T16 } }; static KEY T14[3] = { { ' ', 3, NULL }, { 'd', T_ID, NULL }, { 'g', 0, T15 } }; static KEY T1d[2] = { { ' ', 2, NULL }, { 'r', T_NUMBER, NULL } }; static KEY T1c[2] = { { ' ', 2, NULL }, { 'e', 0, T1d } }; static KEY T1b[2] = { { ' ', 2, NULL }, { 'b', 0, T1c } }; static KEY T1a[2] = { { ' ', 2, NULL }, { 'm', 0, T1b } }; static KEY T19[2] = { { ' ', 2, NULL }, { 'u', 0, T1a } }; static KEY T20[2] = { { ' ', 2, NULL }, { 't', T_PART, NULL } }; static KEY T1f[2] = { { ' ', 2, NULL }, { 'r', 0, T20 } }; static KEY T1e[2] = { { ' ', 2, NULL }, { 'a', 0, T1f } }; static KEY T27[2] = { { ' ', 2, NULL }, { 's', T_SEGMENTS, NULL } }; static KEY T26[2] = { { ' ', 2, NULL }, { 't', T_SEGMENT, T27 } }; static KEY T25[2] = { { ' ', 2, NULL }, { 'n', 0, T26 } }; static KEY T24[2] = { { ' ', 2, NULL }, { 'e', 0, T25 } }; static KEY T23[2] = { { ' ', 2, NULL }, { 'm', 0, T24 } }; static KEY T2d[2] = { { ' ', 2, NULL }, { 'e', T_SENSITIVE, NULL } }; static KEY T2c[2] = { { ' ', 2, NULL }, { 'v', 0, T2d } }; static KEY T2b[2] = { { ' ', 2, NULL }, { 'i', 0, T2c } }; static KEY T2a[2] = { { ' ', 2, NULL }, { 't', 0, T2b } }; static KEY T29[2] = { { ' ', 2, NULL }, { 'i', 0, T2a } }; static KEY T28[2] = { { ' ', 2, NULL }, { 's', 0, T29 } }; static KEY T22[3] = { { ' ', 3, NULL }, { 'g', 0, T23 }, { 'n', 0, T28 } }; static KEY T31[2] = { { ' ', 2, NULL }, { 'g', T_STRING, NULL } }; static KEY T30[2] = { { ' ', 2, NULL }, { 'n', 0, T31 } }; static KEY T2f[2] = { { ' ', 2, NULL }, { 'i', 0, T30 } }; static KEY T2e[2] = { { ' ', 2, NULL }, { 'r', 0, T2f } }; static KEY T21[3] = { { ' ', 3, NULL }, { 'e', 0, T22 }, { 't', 0, T2e } }; static KEY T35[2] = { { ' ', 2, NULL }, { 'l', T_TOTAL, NULL } }; static KEY T34[2] = { { ' ', 2, NULL }, { 'a', 0, T35 } }; static KEY T33[2] = { { ' ', 2, NULL }, { 't', 0, T34 } }; static KEY T32[2] = { { ' ', 2, NULL }, { 'o', 0, T33 } }; static KEY T0[12] = { { ' ', 12, NULL }, { 'a', 0, T1 }, { 'b', 0, T9 }, { 'c', 0, Tc }, { 'h', 0, Tf }, { 'i', 0, T14 }, { 'n', 0, T19 }, { 'p', 0, T1e }, { 's', 0, T21 }, { 't', 0, T32 }, { '{', T_L_BRACE, NULL }, { '}', T_R_BRACE, NULL } }; /*----------------------------------------------------------------------------- | Routine : TrieSrch() --- Search the trie for a token. | | Inputs : Keys - The trie level pointer. | ch - The current character to search for. | WordPtr - The pointer to the current byte of the word buffer. | Outputs : The token number or TKN_NOT_FND for not found. -----------------------------------------------------------------------------*/ static int TrieSrch(KEY *Keys, int ch, char *WordPtr) { register int mid; /* Mid point of array piece. */ register TKNS ret; /* Return value of comparison. */ auto int cmp; /* Comparison. */ auto int lo; /* Limits of current array piece. */ auto int hi; /* Make sure that input is lower case. */ ch = tolower( ch ); /* Search for a token. */ hi = Keys[0].val - 1; lo = 1; do { /* Find mid point of current array piece. */ mid = (lo + hi) >> 1; /* Do character comparison. */ cmp = ch - Keys[mid].c; /* Fix the array limits. */ if (cmp <= 0) hi = mid - 1; if (cmp >= 0) lo = mid + 1; } while (hi >= lo); /* If the character matches one of the entries in this level and this * entry has a child, recurse. If a match is found but the matching * entry has no child, return the token value associated with the * match. If the return value from the recursive call indicates that * no match was found at a lower level, return the token value * associated with the match at this level of the trie. */ if (cmp == 0) { /* Save the current character. */ *WordPtr++ = ch; /* Is this the last character in the string? */ if ( Keys[mid].branch ) { /* Get the next character. */ if ((ch = fgetc( PrgFl )) == EOF) return( EOF ); /* Search next level. */ if ((ret = TrieSrch(Keys[mid].branch, ch, WordPtr)) == T_NOT_FND) { ungetc(ch, PrgFl); return( Keys[mid].val ); } return( ret ); } else { *WordPtr = '\0'; return( Keys[mid].val ); } } /* Return not found. */ *WordPtr = '\0'; return( T_NOT_FND ); } /*----------------------------------------------------------------------------- | Routine : Lex() --- Get the next key word from the input file. | | Outputs : sym - The symbolic data read from the file. | | Return : Returns the token read or EOF. -----------------------------------------------------------------------------*/ int Lex(TOKEN *sym) { register int tkn; auto int ch; extern FILE *ErrFile; /* Strip comments and white space. If the character read is a '#', * every thing to the end of the line is a comment. */ ch = fgetc( PrgFl ); while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '#') { /* Process the special characters '#' and '\n'. */ if (ch == '\n') LnNo++; else if (ch == '#') { while (fgetc( PrgFl ) != '\n') ; LnNo++; } /* Get the next character. */ ch = fgetc( PrgFl ); } /* Get strings, etc. */ if (ch == '"') { auto char *bf; /* Get contents of string. */ bf = sym->str; while ((ch = fgetc( PrgFl )) != '"' && ch != EOF) *bf++ = ch; *bf = '\0'; /* Return string token. */ return( T_DBL_QUOTE ); } else if (ch >= '0' && ch <= '9') { /* Get the number. */ sym->no = 0; do { sym->no = sym->no * 10 + (ch - '0'); } while ((ch = fgetc( PrgFl )) >= '0' && ch <= '9'); /* Return the unused character. */ ungetc(ch, PrgFl); return( T_INT_NO ); } else if (ch == EOF) return( EOF ); /* Call the trie search routine to return the next token, EOF * or NOT_FND. If not found, print an error and quit. */ if ((tkn = TrieSrch(T0, ch, word)) == T_NOT_FND || tkn == 0) { fprintf(ErrFile, "%s %d : Error - cannot identify string '%s' ", __FILE__, __LINE__, word); fprintf(ErrFile, "in line %d\n", LnNo + 1); exit( 1 ); } /* Return the token found. */ return( tkn ); } /*----------------------------------------------------------------------------- | Routine : OpenCfg() --- Open the ASCII text file that contains the | configuration data. -----------------------------------------------------------------------------*/ void OpenCfg(char *FileNm) { extern FILE *ErrFile; /* Open the program script file. */ if ((PrgFl = fopen(FileNm, TXT_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); fprintf(ErrFile, "\tFile Name: '%s'\n", FileNm); exit( 1 ); } } /*----------------------------------------------------------------------------- | Routine : CloseCfg() --- Close the ASCII text file that contains the | configuration data. -----------------------------------------------------------------------------*/ void CloseCfg(void) { fclose( PrgFl ); } /*----------------------------------------------------------------------------- | Routine : ParseErr() --- Report a parse error. | | Inputs : ErrStr - The error string. -----------------------------------------------------------------------------*/ void ParseErr(char *ErrStr) { extern FILE *ErrFile; fprintf(ErrFile, "%s %d : Error - %s\n", __FILE__, __LINE__, ErrStr); fprintf(ErrFile, "\tLine %d, word '%s'\n", LnNo + 1, word); exit( 1 ); } unpost/lex.h100644 23453 0 1633 5543402242 12727 0ustar jeanpaulsystem/****************************************************************************** * Module : Lexical Analyzer --- Extract tokens from the source file. * * Author : John W. M. Stevens ******************************************************************************/ #if ! defined(LEXICAL_ANALYZER) #define LEXICAL_ANALYZER typedef enum { T_NOT_FND, T_ALTERNATE, T_BODY, T_CASE, T_HEADER, T_ID, T_IGNORE, T_NUMBER, T_PART, T_SEGMENT, T_SEGMENTS, T_SENSITIVE, T_STRING, T_TOTAL, T_L_BRACE, T_R_BRACE, T_DBL_QUOTE, T_INT_NO } TKNS; /* Token structure for returning values. */ typedef struct { char str[256]; int no; } TOKEN; /* Function prototypes. */ extern void ParseErr(char *ErrStr); extern void OpenCfg(char *FileNm); extern void CloseCfg(void); extern int Lex(TOKEN *sym); #endif unpost/list.c100644 23453 0 14546 5543402236 13137 0ustar jeanpaulsystem/****************************************************************************** * Module : List --- List building and maintenance module. * * Author : John Stevens. ******************************************************************************/ #include "compiler.h" #include "unpost.h" #include "list.h" #include "utils.h" #define INIT_SIZE 2 #define INCREASE 5 /*----------------------------------------------------------------------------- | Routine : AddList() --- Add an element to a list. | | Inputs : Head - Pointer to begining of list. | Elem - New element to add to list. | InsPt - List ordinal for add. | | Returns : Pointer to list head. -----------------------------------------------------------------------------*/ void *AddList(LIST *Head, void *Elem, int InsPt) { auto char *List; extern FILE *ErrFile; /* Create or add to list. */ if (Head->NoElems >= Head->TotElems) { auto int NewSize; /* Reallocate the list header. */ NewSize = (Head->TotElems + INCREASE) * Head->ElemSz + sizeof( LIST ); if ((Head = (LIST *) realloc(Head, NewSize)) == NULL) { fprintf(ErrFile, "%s %d : Error - Out of memory.\n", __FILE__, __LINE__); exit( 1 ); } /* Update list size. */ Head->TotElems += INCREASE; } /* Move list elements up to make room. */ List = Head->List + Head->ElemSz * InsPt; if (InsPt < Head->NoElems) { MemMv(List + Head->ElemSz, List, Head->ElemSz * (Head->NoElems - InsPt)); } /* Copy new element to it's proper location. */ MemCopy(List, Elem, Head->ElemSz); Head->NoElems++; return( Head ); } /*----------------------------------------------------------------------------- | Routine : CrtList() --- Create a new (empty) list. | | Inputs : ElemSz - Size of element in bytes. | | Returns : Pointer to list head. -----------------------------------------------------------------------------*/ void *CrtList(int ElemSz) { auto LIST *Head; auto int Size; extern FILE *ErrFile; /* Calculate the size of the new list and allocate it. */ Size = INIT_SIZE * ElemSz + sizeof( LIST ); if ((Head = (LIST *) calloc(1, Size)) == NULL) { fprintf(ErrFile, "%s %d : Error - Out of memory.\n", __FILE__, __LINE__); exit( 1 ); } /* Return the pointer to the list. */ Head->ElemSz = ElemSz; Head->TotElems = INIT_SIZE; return( Head ); } /*----------------------------------------------------------------------------- | Routine : SrchList() --- Search the list. | | Inputs : Head - Pointer to begining of list. | Elem - Element to search list for. | CmpFn - Function to compare in search. | Outputs : InsPt - List pointer for insert/found. | | Returns : TRUE for found, FALSE for not found. -----------------------------------------------------------------------------*/ int SrchList(LIST *Head, void *Elem, int (*CmpFn)(void *, void *), int *InsPt) { /* Search the list for an element. * * Do binary search. */ if (Head->NoElems > 0) { auto char *List; auto int hi; auto int lo; auto int ret; auto int mid; lo = 0; hi = Head->NoElems - 1; do { /* Get midpoint of list. */ mid = (hi + lo) >> 1; List = Head->List + Head->ElemSz * mid; /* Do string compare. */ ret = CmpFn(Elem, List); /* Adjust array pointers. */ if (ret <= 0) hi = mid - 1; if (ret >= 0) lo = mid + 1; } while (hi >= lo); /* Did we find it? */ if (ret == 0) { /* We found it. */ *InsPt = mid; return( TRUE ); } /* We did not find it. */ *InsPt = lo; return( FALSE ); } /* Return that we did not find it, and the point at * which it should be inserted. */ *InsPt = 0; return( FALSE ); } /*----------------------------------------------------------------------------- | Routine : ListIdx() --- Get pointer to a list element. | | Inputs : Head - Pointer to begining of list. | Index - Index of element to return pointer for. | | Returns : NULL for index outside of list limits, Pointer to list | element otherwise. -----------------------------------------------------------------------------*/ void *ListIdx(LIST *Head, int Index) { /* Determine if index is inside list limits. */ if (Index < 0 || Index >= Head->NoElems) return( NULL ); return( Head->List + Index * Head->ElemSz ); } /*----------------------------------------------------------------------------- | Routine : AppList() --- Append an element to a list. | | Inputs : Head - Pointer to begining of list. | Elem - New element to add to list. | | Returns : Pointer to list head. -----------------------------------------------------------------------------*/ void *AppList(LIST *Head, void *Elem) { auto char *List; extern FILE *ErrFile; /* Create or add to list. */ if (Head->NoElems >= Head->TotElems) { auto int NewSize; /* Reallocate the list header. */ NewSize = (Head->TotElems + INCREASE) * Head->ElemSz + sizeof( LIST ); if ((Head = (LIST *) realloc(Head, NewSize)) == NULL) { fprintf(ErrFile, "%s %d : Error - Out of memory.\n", __FILE__, __LINE__); exit( 1 ); } /* Update list size. */ Head->TotElems += INCREASE; } /* Copy new element to it's proper location. */ List = Head->List + Head->ElemSz * Head->NoElems; MemCopy(List, Elem, Head->ElemSz); Head->NoElems++; return( Head ); } unpost/list.h100644 23453 0 1513 5543402242 13107 0ustar jeanpaulsystem/****************************************************************************** * Module : List --- List building and maintenance module. * * Author : John Stevens. ******************************************************************************/ #if ! defined(LIST_HEADER_FILE) #define LIST_HEADER_FILE /* Define a list header structure. */ typedef struct { int NoElems; int TotElems; int ElemSz; char List[1]; } LIST; /* Function prototypes. */ extern void *AddList(LIST *, void *, int); extern void *CrtList(int); extern int SrchList(LIST *Head, void *Elem, int (*CmpFn)(void *, void *), int *InsPt); extern void *ListIdx(LIST *, int); extern void *AppList(LIST *, void *); #endif unpost/read_me.doc100644 23453 0 5475 5517261552 14071 0ustar jeanpaulsystemTo compile: At this point, you have the archive unpacked, or you will never see this message. If you run MS-DOS and do not have a compiler, just use the .exe files. All text files may have only the LF as a line terminator. If you have problems, you will have to convert the files them. To compile, copy the appropriate file from the makefils directory to the source code directory (*.c, *.h), rename it to makefile and run make. Example: cp makefils/gcc_sun.mkf makefile make There are makefiles and one VAX/VMS MMS file: apollo.mkf - Makefile for HP Apollo workstation. borland.mkf - Makefile for Borland Turbo C++ under MS-DOS. ibm_aix.mkf - Makefile for IBM running AIX. os2_cset.mkf - OS/2 C Set++ compiler. os2_gcc.mkf - OS/2 EMX/GNU C compiler. sgi.mkf - Silicon Graphics makefile. sun_gcc.mkf - GNU C compiler on Sun 4. And the odd one in the bunch: vax_vms.mms - This one is entirely some one elses work, and I have no idea whether or not it depends on some system specific stuff or not. I don't see definitions for the macros used ( $(LINK), for instance ) so I am hoping that the VAX/VMS system somehow creates these automatically . . . If you have any trouble with this, don't waste your time emailing me, as I have not one clue! Be aware that UNPOST requires an ANSI C compatible compiler, as it uses the ANSI C function headers for full type checking and maximum portability. (If it ain't ANSI C, it ain't portable in the long run). If you have any problems, edit the compiler.h file and uncomment the variable UNPOST_DEBUG. Then run unpost on your input file, capture the output sent to standard out and email it to me. Save the input file, as I will probably email back asking you to send me one or more article headers out of it. If you have compilation problems, send me as much information as possible and I will do my best to help you. Simplest way to use UNPOST: Capture all articles in a file called source.uue (How is system and news access method dependent, see unpost.doc for an rn example), then run unpost by doing: unpost -e errors -t text -i incomp source.uue That's it. All complete and correct binary postings that were in file source.uue will be in the directory that you ran the above command in. The file 'errors' will have a summary of warnings, errors, the binary postings, parts and byte offsets into the source file. The 'text' file will contain text only articles, and the 'incomp' file will contain any incomplete or incorrect postings. Please read the unpost.doc and changes.doc files. They are the result of a lot of work on my part, and I will feel slighted if you don't at least take a few seconds to scan them. . . :-) jstevens@csn.org unpost/modflnm.c100644 23453 0 21441 5543402240 13603 0ustar jeanpaulsystem/****************************************************************************** * Module : File Names --- File name utilities. * * Author : John W. M. Stevens ******************************************************************************/ #include "compiler.h" #include "unpost.h" #include "sets.h" #include "modflnm.h" /* Sets. */ static int InitSets = 1; static SET StandSet; static SET ThrowSet; static SET NoSet; static SET AlphaSet; /* Strings for character sets. */ static char *Stand = "a-z0-9_.-"; static char *Throw = "aeiouy_-"; static char *Numbers = "0-9"; static char *Alpha = "a-z"; /*----------------------------------------------------------------------------- | Routine : ChkFlNmLen() --- Check the file name length. | | Inputs : FileName - File name. -----------------------------------------------------------------------------*/ static int ChkFlNmLen(char *FileNm) { register int i; /* Count file characters. */ for (i = 0; FileNm[i] && FileNm[i] != EXT_SEP_CHAR; i++) ; /* Return True or False. */ return( i ); } /*----------------------------------------------------------------------------- | Routine : FlNmFilter() --- Filter a string so that only characters from | the set of standard file name characters are left. | | Inputs : -----------------------------------------------------------------------------*/ void FlNmFilter(char *FlName) { auto char *cp; auto char *tp; auto char c; /* Create character sets. */ if ( InitSets ) { tp = Stand; CrtSet((unsigned char **) &tp, StandSet); tp = Throw; CrtSet((unsigned char **) &tp, ThrowSet); tp = Numbers; CrtSet((unsigned char **) &tp, NoSet); tp = Alpha; CrtSet((unsigned char **) &tp, AlphaSet); InitSets = 0; } /* Convert string to lower case and strip out illegal characters. */ for (cp = tp = FlName; *tp; tp++) { /* First, convert to lower case. */ c = (char) tolower( *tp ); /* Next, check for standards conformity. */ if (c == ' ' || c == '\t' || InSet(StandSet, (unsigned char) c)) *cp++ = c; } *cp = '\0'; } /*----------------------------------------------------------------------------- | Routine : ModifyFlNm() --- Convert to lower case and make sure that | this file name conforms to MS-DOS restrictions/limitations | and USENET posting standards. | | Inputs : FlName - File name. | Ext - Extension. | Outputs : OutName - Modified file name. -----------------------------------------------------------------------------*/ int ModifyFlNm(char *FlName, char *Ext, char *OutName) { register int i; auto int len; auto int ChopFlag; auto char *cp; auto char *tp; auto char c; extern FILE *ErrFile; /* Create character sets. */ if ( InitSets ) { tp = Stand; CrtSet((unsigned char **) &tp, StandSet); tp = Throw; CrtSet((unsigned char **) &tp, ThrowSet); tp = Numbers; CrtSet((unsigned char **) &tp, NoSet); tp = Alpha; CrtSet((unsigned char **) &tp, AlphaSet); InitSets = 0; } /* Convert string to lower case and strip out illegal characters. */ for (cp = OutName, tp = FlName; *tp; tp++) { /* First, convert to lower case. */ c = (char) tolower( *tp ); /* Next, check for standards conformity. */ if ( InSet(StandSet, (unsigned char) c) ) *cp++ = c; } *cp = '\0'; /* If we have more than MAX_FILE characters in the file name, * then shorten the file name. */ if ((len = ChkFlNmLen( OutName )) > MAX_FILE) { /* Shorten by removing vowels and separator characters. */ for (tp = cp = OutName, i = len; *tp && *tp != EXT_SEP_CHAR && i > MAX_FILE; tp++) { /* If this is not a throw away character, save it back * in the string. */ if (! InSet(ThrowSet, (unsigned char) *tp)) { *cp++ = *tp; continue; } else if (tp == OutName) { *cp++ = *tp; continue; } /* Decrement the file name size. */ i--; } strcpy(cp, tp); } else goto ShortEnough; /* If we still have more than MAX_FILE characters in the file * name, chop off leading zeros in any numeric strings in the * file name. */ if ((len = ChkFlNmLen( OutName )) > MAX_FILE) { /* Loop through string. */ for (tp = cp = OutName, i = len; *tp && *tp != EXT_SEP_CHAR && i > MAX_FILE; tp++) { /* If this is a numeric sub-string, strip any leading * zeros. */ if (tp[1] && tp[1] != '.' && InSet(NoSet, (unsigned char) *tp) && InSet(NoSet, (unsigned char) tp[1]) && *tp == '0') { i--; continue; } /* Copy character in. */ *cp++ = *tp; } strcpy(cp, tp); } else goto ShortEnough; /* If we still have more than MAX_FILE characters in the file name, chop * alphabetic strings short by throwing away excess characters. */ while ((len = ChkFlNmLen( OutName )) > MAX_FILE) { /* Loop through string. */ for (tp = cp = OutName, ChopFlag = 0, i = len; *tp && *tp != EXT_SEP_CHAR && i > MAX_FILE; tp++) { /* Do not throw away numeric characters at this point. */ if ( InSet(NoSet, (unsigned char) *tp) ) { *cp++ = *tp; continue; } /* Throw away the trailing character in an alphabetic * substring. */ if (*tp && tp[1] != EXT_SEP_CHAR && InSet(AlphaSet, (unsigned char) *tp) && InSet(AlphaSet, (unsigned char) tp[1])) { *cp++ = *tp; continue; } /* Yup, we are chopping out a character. */ i--; ChopFlag = 1; } strcpy(cp, tp); /* If not even one character is chopped out in a pass * through the file name list, drop out and issue an * error. */ if (ChopFlag == 0) { fprintf(ErrFile, "%s %d : Error - Could not modify file name to be ", __FILE__, __LINE__); fprintf(ErrFile, "MS-DOS conformant.\n"); return( 1 ); } } /* Done with file name, now fix extension. */ ShortEnough: for (tp = OutName; *tp && *tp != EXT_SEP_CHAR; tp++) ; if (*tp == EXT_SEP_CHAR) { /* Were we able to identify this file? */ if ( *Ext ) strcpy(tp, Ext); else { /* Move four characters across (including '.') and we * are done. */ for (i = 0, tp++; *tp && *tp != EXT_SEP_CHAR && i < MAX_EXT; i++, tp++) ; *tp = '\0'; } } else { /* No extension, so append one. */ strcpy(tp, Ext); } /* Return no error. */ return( 0 ); } /*----------------------------------------------------------------------------- | Routine : ModExten() --- Modify the file name extension. | | Inputs : FlName - File name. -----------------------------------------------------------------------------*/ void ModExten(char *FlName, char *Exten, char *OutFlNm) { auto char *InPtr; auto char *OutPtr; auto char *ExtPtr; /* Search for the first file name extension separator character. */ for (InPtr = FlName, OutPtr = OutFlNm, ExtPtr = NULL; *InPtr; InPtr++, OutPtr++ ) { /* Copy Characters. */ *OutPtr = *InPtr; /* Check for extension separator character. */ if (*OutPtr == EXT_SEP_CHAR) ExtPtr = OutPtr; } *OutPtr = '\0'; /* Copy in new extension. */ if ( ExtPtr ) strcpy(ExtPtr, Exten); else strcpy(OutPtr, Exten); } unpost/modflnm.h100644 23453 0 1567 5543402242 13601 0ustar jeanpaulsystem/****************************************************************************** * Module : File name utilities. * * Author : John W. M. Stevens ******************************************************************************/ #if ! defined(MOD_FL_NM_HEADER) #define MOD_FL_NM_HEADER /* Define maximum base and extension file name string lengths. * Currently, as MS-DOS is the most restrictive, names will tested * for fit into MS-DOS length restrictions. */ #define MAX_FILE 8 #define MAX_EXT 3 #define EXT_SEP_CHAR '.' /* Function prototypes. */ extern void FlNmFilter(char *FlName); extern int ModifyFlNm(char *FlName, char *Ext, char *OutName); extern void ModExten(char *FlName, char *Exten, char *OutFlNm); #endif unpost/parse.c100644 23453 0 102734 5543402240 13306 0ustar jeanpaulsystem/****************************************************************************** * Module : Parse --- Search for a particular line. * * Author : John W. M. Stevens ******************************************************************************/ #include "compiler.h" #include "unpost.h" #include "regexp.h" #include "uudec.h" #include "modflnm.h" #include "ident.h" #include "parse.h" #include "config.h" #include "utils.h" /* These are the elements we have to parse out of either the header or * the body of the message BEFORE we find the first UUencoded line. */ typedef enum { ID_STRING, SEGMENT_NO, NO_SEGMENTS } PARSE_ELS; /* * Regular expression source strings. * * To configure the program for different systems, these are the * strings to change. */ static PART_RE Parts1[] = { { "^Subject:(.*)[[({]Part[_ \t]*([0-9]+)[^0-9]+([0-9]+)[)\\]}](.*)", 1, 2, 3, 4, IGN_CASE, NULL }, { "^Subject:(.*)Part[_ \t]*[[({]([0-9]+)[^0-9]+([0-9]+)[)\\]}](.*)", 1, 2, 3, 4, IGN_CASE, NULL }, { "^Subject:(.*)Part[_ \t]+([0-9]+)[^0-9]+([0-9]+)(.*)", 1, 2, 3, 4, IGN_CASE, NULL }, { "^Subject:(.*)[([{][ \t]*([0-9]+)[^0-9]+([0-9]+)[ \t]*[)\\]}](.*)", 1, 2, 3, 4, IGN_CASE, NULL }, { "^Subject:(.*)([0-9]+)([/|]|[ \t]+of[ \t]+)([0-9]+)(.*)", 1, 2, 4, 5, IGN_CASE, NULL }, { "^Subject:(.*)", 1, 0, 0, 0, IGN_CASE, NULL }, { NULL, 0, 0, 0, 0, IGN_CASE, NULL } }; static PART_RE Parts3[] = { { "^X-File-Name:[ \t]+(.*)", 1, 0, 0, 0, CASE_SENSITIVE, NULL }, { NULL, 0, 0, 0, 0, IGN_CASE, NULL } }; static PART_RE Parts4[] = { { "^X-Part:[ \t]+([0-9]+)", 0, 1, 0, 0, CASE_SENSITIVE, NULL }, { NULL, 0, 0, 0, 0, IGN_CASE, NULL } }; static PART_RE Parts5[] = { { "^X-Part-Total:[ \t]+([0-9]+)", 0, 0, 1, 0, CASE_SENSITIVE, NULL }, { NULL, 0, 0, 0, 0, IGN_CASE, NULL } }; static PART_RE Parts6[] = { { "^Uusplit-part:[ \t]+([0-9]+)", 0, 1, 0, 0, CASE_SENSITIVE, NULL }, { NULL, 0, 0, 0, 0, IGN_CASE, NULL } }; static PART_RE Parts7[] = { { "^Uusplit-parts:[ \t]+([0-9]+)", 0, 0, 1, 0, CASE_SENSITIVE, NULL }, { NULL, 0, 0, 0, 0, IGN_CASE, NULL } }; static PART_RE Parts8[] = { { "^section ([0-9]+) of uuencode [0-9]+\\.[0-9]+ of file ([^ \t]+)[ \t]+by R.E.M.", 2, 1, 0, 0, CASE_SENSITIVE, NULL }, { NULL, 0, 0, 0, 0, IGN_CASE, NULL } }; /* static PART_RE Parts9[] = { { "^([^ \t]+)[ \t]+section[ \t]+([0-9]+)/([0-9]+)[ \t]+UUXFER ver ", 1, 2, 3, 0, CASE_SENSITIVE, NULL }, { NULL, 0, 0, 0, 0, IGN_CASE, NULL } }; */ static PART_RE Parts10[] = { { "^POST V.* ([^ \t]+).*\\(Part ([0-9]+)/([0-9]+)\\)", 1, 2, 3, 0, CASE_SENSITIVE, NULL }, { NULL, 0, 0, 0, 0, IGN_CASE, NULL } }; static IDENT Hdr1[] = { { "^Subject:", Parts1, NULL }, { "^X-File-Name:", Parts3, NULL }, { "^X-Part:", Parts4, NULL }, { "^X-Part-Total:", Parts5, NULL }, { "^Uusplit-part:", Parts6, NULL }, { "^Uusplit-parts:", Parts7, NULL }, { NULL, NULL, NULL } }; static IDENT Body1[] = { { "^Subject:", Parts1, NULL }, { "^section [0-9]+ of uuencode [0-9]+\\.[0-9]+ of file [^ \t]+ by R.E.M.", Parts8, NULL }, { "^POST V", Parts10, NULL }, /* { "^[^ \t]+[ \t]+section[ \t]+[0-9]+/[0-9]+[ \t]+UUXFER ver ", Parts9, NULL }, */ { NULL, NULL, NULL } }; /*============================================================================= || SEGMENT begin line regular expressions are defined below. || || These can be set by command line switch. =============================================================================*/ static SEGMENT RnSegs[] = { { "^(Article[:]?|X-NEWS:) ", Hdr1, Body1, NULL }, { NULL, NULL, NULL, NULL } }; static SEGMENT NnSegs[] = { { "^From[:]? ", Hdr1, Body1, NULL }, { NULL, NULL, NULL, NULL } }; static SEGMENT EmailSegs[] = { { "^From ", Hdr1, Body1, NULL }, { NULL, NULL, NULL, NULL } }; static SEGMENT GroupsSegs[] = { { "^Newsgroups: ", Hdr1, Body1, NULL }, { NULL, NULL, NULL, NULL } }; static SEGMENT *Segments = RnSegs; static REG_EXP_NODE *Begin = NULL; static REG_EXP_NODE *End = NULL; static REG_EXP_NODE *CrcRE = NULL; static char *BeginStr = "^begin[ \t]+([0-7]+)[ \t]+([^ \t]+)"; static char *EndStr = "^end[ \t]*$"; static char *CrcStr = "^POST Crc: 0x([0-9a-fA-F]+)"; /*----------------------------------------------------------------------------- | Routine : GetBinFlNm() --- Get the binary file name. | | Inputs : InFlPtr - Pointer to source file. | Outputs : FlName - Pointer to file name buffer. -----------------------------------------------------------------------------*/ int GetBinFlNm(FILE *InFlPtr, char **RetStrs, char *FlName) { auto long LnOfs; auto int RetVal; auto char *tp; auto char *sp; auto int OutLen; auto char Exten[5]; auto char BeginName[FL_NM_SZ]; /* Externals used by this function. */ extern BYTE OutBfr[]; extern char SegLine[]; extern char InBfr[]; extern char UULine[]; extern FILE *ErrFile; extern int MsDosFileNms; /* Extract the file name. */ for (tp = BeginName, sp = RetStrs[2]; *sp && *sp != '\n' && *sp != ' ' && *sp != '\t'; ) *tp++ = *sp++; *tp = '\0'; /* Munge file name? */ RetVal = 0; if ( MsDosFileNms ) { /* Get the current file offset. */ LnOfs = ftell( InFlPtr ); /* Get next line and identify file type. */ *Exten = '\0'; if (ReadLine(InFlPtr, InBfr, BFR_SIZE) == EOF) { fprintf(ErrFile, "%s %d : Warning - Unexpected end of file in segment:\n", __FILE__, __LINE__); fprintf(ErrFile, "\tSegment: '%s'\n", SegLine); RetVal = 2; } else if (DecUULine(InBfr, &OutLen, OutBfr) == NOT_UU_LINE) { fprintf(ErrFile, "%s %d : Warning - No UU line after begin.\n", __FILE__, __LINE__); fprintf(ErrFile, "\tSegment: '%s'\n", SegLine); RetVal = 2; } else { /* Attempt to ID the file. */ IdUUFile(OutBfr, OutLen, Exten); /* Modify the file name to be MS-DOS compatible. */ ModifyFlNm(BeginName, Exten, FlName); } /* Position file pointer to start of line. */ if (fseek(InFlPtr, LnOfs, SEEK_SET) != 0) { fprintf(ErrFile, "%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); exit( 1 ); } } else strcpy(FlName, BeginName); #if defined(UNPOST_DEBUG) printf("\tBinary File Name: '%s'\n", FlName); #endif return( RetVal ); } /*----------------------------------------------------------------------------- | Routine : MatchEnd() --- Match a uuencode end line. | | Inputs : Line - The line to attempt to match against. -----------------------------------------------------------------------------*/ int MatchEnd(char *Line) { auto char **RetStrs; /* Attempt to match the line. */ return( ReMatch(Line, CASE_SENSITIVE, End, &RetStrs) ); } /*----------------------------------------------------------------------------- | Routine : MatchBegin() --- Match a uuencode begin line. | | Inputs : Line - The line to attempt to match against. | Outputs : RetStrs - Returned sub-strings. -----------------------------------------------------------------------------*/ int MatchBegin(char *Line, char ***RetStrs) { /* Attempt to match the line. */ return( ReMatch(Line, CASE_SENSITIVE, Begin, RetStrs) ); } /*----------------------------------------------------------------------------- | Routine : MatchSegment() --- Match a SEGMENT begin line. | | Inputs : Line - The line to attempt to match against. | Outputs : Hdr - Pointer to header ID line RE's. | Body - Pointer to body ID line RE's. -----------------------------------------------------------------------------*/ int MatchSegment(char *Line, IDENT **Hdr, IDENT **Body) { register int i; auto char **RetStrs; /* Attempt to match the line. */ for (i = 0; Segments[i].ReExprStr; i++) { /* Attempt to match one of the segment begin lines. */ if (ReMatch(Line, CASE_SENSITIVE, Segments[i].ReExpr, &RetStrs) != 0) { *Hdr = Segments[i].Header; *Body = Segments[i].Body; return( 1 ); } } /* Return not matched. */ Hdr = NULL; Body = NULL; return( 0 ); } /*----------------------------------------------------------------------------- | Routine : GetBinID() --- Get binary ID string. | | Inputs : SubStr - Pointer to possible ID sub-string. | Outputs : IDStr - Pointer to ID string buffer. -----------------------------------------------------------------------------*/ static void GetBinID(char *SubStr, char *IDStr) { auto int ExtSep; auto char *DestPtr; auto char *tp; extern int MsDosFileNms; /* Filter string. */ FlNmFilter( SubStr ); /* Attempt to guess at a file name. */ for (tp = SubStr; *tp; ) { /* Skip white space. */ while (*tp == ' ' || *tp == '\t') tp++; /* Get word. */ for (DestPtr = IDStr, ExtSep = 0; *tp && *tp != ' ' && *tp != '\t'; tp++) { /* Check to see if this is and extension separator * character, and if so, count how many. */ if (*tp == EXT_SEP_CHAR) ExtSep++; /* Copy character. */ *DestPtr++ = *tp; } *DestPtr = '\0'; /* Does this look like a file name? */ if ( ExtSep ) { #if defined(UNPOST_DEBUG) printf("\tBinary ID: '%s'\n", IDStr); #endif return; } } /* OK, we didn't find anything that looks like it could possibly * be a file name, so munge all the pieces together. */ for (tp = SubStr, DestPtr = IDStr; *tp; ) { /* Skip white space. */ if (*tp == ' ' || *tp == '\t') tp++; else *DestPtr++ = *tp++; } *DestPtr = '\0'; #if defined(UNPOST_DEBUG) printf("\tBinary ID: '%s'\n", IDStr); #endif } /*----------------------------------------------------------------------------- | Routine : ParseIDLine() --- Extract the ID string, part number and | total number of parts from the ID line. | | Inputs : IDLine - Pointer to ID line. | PartREs - Array of part number parsing RE's. | Outputs : Elements - Aqquisition flags for the three items to | parse out, ID string, Segment number and | total number of segments. | SegInfo - Pointer to segment information buffer. -----------------------------------------------------------------------------*/ static void ParseIDLine(char *IDLine, PART_RE *PartREs, int *Elements, SEG_INFO *SegInfo) { register int i; auto char **RetStrs; auto PART_RE *PartRec; auto char IDBfr[FL_NM_SZ]; /* Externals used in this function. */ extern FILE *ErrFile; /* Seach for a matching part number parsing regular expression. */ for (PartRec = NULL, i = 0; PartREs[i].ReExpStr; i++) { /* Does this RE match the ID line? */ if (ReMatch(IDLine, PartREs[i].Case, PartREs[i].ReExpr, &RetStrs) != 0) { #if defined(UNPOST_DEBUG) printf("\tExtract RE: /%s/\n", PartREs[i].ReExpStr); #endif PartRec = PartREs + i; break; } } /* If no match found, return. */ if (PartRec == NULL) return; /* Get what elements we do not yet have. */ for (i = ID_STRING; i <= NO_SEGMENTS; i++) { /* Get this element, if it is available. */ switch ( i ) { case 0: /* Get ID string. */ /* Check for no ID string. */ if (PartRec->IDStr == 0) break; /* Extract ID string from sub string. */ GetBinID(RetStrs[ PartRec->IDStr ], IDBfr); /* Check to see if there was an ID string or not. */ if (*IDBfr == '\0') { /* Is there an alternate regular expression for * extracting the binary ID string? */ if (PartRec->AltIDStr > 0) { /* OK, try other side. */ GetBinID(RetStrs[ PartRec->AltIDStr ], IDBfr); if (*IDBfr == '\0') break; } else break; } /* Duplicate the ID string. */ if (SegInfo->IDString != NULL) free( SegInfo->IDString ); SegInfo->IDString = StrDup( IDBfr ); Elements[i] = 1; break; case 1: /* Get the segment number. */ /* Check for no segment number. */ if (PartRec->SegNo == 0) break; /* Get the segment number. */ if ((SegInfo->SegNo = atoi( RetStrs[ PartRec->SegNo ] )) < 0) break; Elements[i] = 1; break; case 2: /* Get total number of segments. */ /* Check for no total number of segments. */ if (PartRec->NoSegs == 0) break; /* Get the total number of segments. */ if ((SegInfo->NoSegs = atoi( RetStrs[ PartRec->NoSegs ] )) <= 0) break; Elements[i] = 1; break; } } } /*----------------------------------------------------------------------------- | Routine : IdSearch() --- Search for an ID line. | | Inputs : InFlPtr - Input file pointer. | IdPtr - Pointer to ID RE hierarchy for this SEGMENT. | Outputs : Elements - Check list for data elements. | IDLine - Contains ID line. | UULnType - Type of UU encoded line found. | RetStrs - Returned sub strings from RE match. | SegInfo - Pointer to segment information buffer. | | Returns : Returns one of: -----------------------------------------------------------------------------*/ static long IdSearch(FILE *InFlPtr, IDENT *IdPtr, int *Elements, char *IDLine, CHK_UU_ENC *UULnType, char ***RetStrs, SEG_INFO *SegInfo) { register int i; auto long LnOfs; auto int EncLen; auto IDENT *Hdr; auto IDENT *Body; extern FILE *ErrFile; /* Search forwards through the file for the first ID line. */ for ( ; ; ) { /* Get the current file offset. */ LnOfs = ftell( InFlPtr ); /* Get a line from the file. */ if (ReadLine(InFlPtr, IDLine, BFR_SIZE) == EOF) { LnOfs = PRS_NO_UU_LN; break; } /* Is this a SEGMENT begin line? */ if ( MatchSegment(IDLine, &Hdr, &Body) ) { /* Position file pointer to start of line. */ if (fseek(InFlPtr, LnOfs, SEEK_SET) != 0) { fprintf(ErrFile, "%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); exit( 1 ); } /* Return that no UU encoded line was found. */ LnOfs = PRS_NO_UU_LN; break; } /* Is this a UUencoded line? */ *UULnType = ChkUULine(IDLine, RetStrs, &EncLen); if (*UULnType == IS_UU_LINE || *UULnType == UU_BEGIN || *UULnType == UU_END) { /* Did we miss getting a piece of data we would like to * have? */ if (Elements[SEGMENT_NO] == 0 && Elements[NO_SEGMENTS]) { /* Error message. */ fprintf(ErrFile, "%s %d : Error - Got number of segments but not ", __FILE__, __LINE__); fprintf(ErrFile, "segment number.\n"); /* Check for totally idiotic mess. */ if (SegInfo->NoSegs == 1) { /* Attempt assumption. */ fprintf(ErrFile, "\tNumber of Segments: %d\n", SegInfo->NoSegs); fprintf(ErrFile, "\tAssuming Part 1 of 1\n"); SegInfo->SegNo = SegInfo->NoSegs = 1; } else LnOfs = PRS_NO_SEG_NUM; } else if (Elements[SEGMENT_NO] && Elements[NO_SEGMENTS] == 0) { /* Error message. */ fprintf(ErrFile, "%s %d : Error - Got segment number but not number ", __FILE__, __LINE__); fprintf(ErrFile, "of segments.\n"); /* Check segment number. */ if (SegInfo->SegNo == 1) { /* Attempt assumption. */ fprintf(ErrFile, "Segment Number: %d\n\tAssuming Part 1 of 1\n", SegInfo->SegNo); SegInfo->SegNo = SegInfo->NoSegs = 1; } else LnOfs = PRS_NO_NUM_SEGS; } else if (Elements[SEGMENT_NO] == 0 && Elements[NO_SEGMENTS] == 0) SegInfo->SegNo = SegInfo->NoSegs = 1; break; } /* Is this an ID line? */ for (i = 0; IdPtr[i].ReExprStr; i++) { /* Does this line match? */ if (ReMatch(IDLine, CASE_SENSITIVE, IdPtr[i].ReExpr, RetStrs) != 0) { #if defined(UNPOST_DEBUG) printf("\n\tID Line: '%s'\n", IDLine); printf("\tBody RE: /%s/\n", IdPtr[i].ReExprStr); #endif /* Attempt to parse out one or more elements. */ ParseIDLine(IDLine, IdPtr[i].IdParts, Elements, SegInfo); break; } } /* Is this a POST CRC line? */ if (ReMatch(IDLine, IGN_CASE, CrcRE, RetStrs) != 0) { /* Convert the string to an unsigned long. */ SegInfo->PostCRC = (CRC_TYPE) HexToUL( (*RetStrs)[1] ); SegInfo->ChkCRC = 1; } } /* Return status. */ return( LnOfs ); } /*----------------------------------------------------------------------------- | Routine : Header() --- Search for legal header ID lines. | | Inputs : InFlPtr - Input file pointer. | IdPtr - Pointer to ID RE hierarchy for this SEGMENT. | Outputs : Elements - Checklist for needed pieces of information. | IDLine - Contains ID line. | SegInfo - Pointer to segment information buffer. | | Returns : Returns one of: | PRS_NO_UU_LN - For no uuencoded line found in segment. | 1L - OK. -----------------------------------------------------------------------------*/ static long Header(FILE *InFlPtr, IDENT *IdPtr, int *Elements, char *IDLine, SEG_INFO *SegInfo) { register int i; auto char **RetStrs; auto char *tp; extern FILE *ErrFile; /* Search forwards through the file for the first ID line. */ for ( ; ; ) { /* Is this an ID line? */ for (i = 0; IdPtr[i].ReExprStr; i++) { /* Does this line match? */ if (ReMatch(IDLine, CASE_SENSITIVE, IdPtr[i].ReExpr, &RetStrs) != 0) { #if defined(UNPOST_DEBUG) printf("\n\tID Line: '%s'\n", IDLine); printf("\tHeader RE: /%s/\n", IdPtr[i].ReExprStr); #endif /* Attempt to parse out one or more elements. */ ParseIDLine(IDLine, IdPtr[i].IdParts, Elements, SegInfo); break; } } /* Get a line from the file. */ if (ReadLine(InFlPtr, IDLine, BFR_SIZE) == EOF) return( PRS_NO_UU_LN ); /* Check for a blank line, which is the header delimiter. */ for (tp = IDLine; *tp == ' ' || *tp == '\t'; tp++) ; if (*tp == '\0' || *tp == '\n') break; } /* Return that no errors occured. */ return( 1L ); } /*----------------------------------------------------------------------------- | Routine : Parse() --- Parse out a SEGMENT and ID line. | | Inputs : InFlPtr - Input file pointer. | Outputs : SegLine - Contains the segment line. | IDLine - Contains ID line. | UULine - Contains the first UU encoded line. | SegInfo - Pointer to segment information buffer. | | Returns : Returns one of: | PRS_NO_SEGMENT - End of file found. | PRS_NO_UU_LN - No uuencoded line found in article. | PRS_NO_ID_STR - No ID string found at all. | PRS_NO_BEGIN - No uuencode begin line found in first | segment. -----------------------------------------------------------------------------*/ long Parse(FILE *InFlPtr, char *SegLine, char *IDLine, SEG_INFO *SegInfo) { register int i; auto long LnOfs; auto char **RetStrs; auto IDENT *Hdr; auto IDENT *Body; auto CHK_UU_ENC UULnType; auto int Elements[NO_SEGMENTS + 1]; auto char FlName[FL_NM_SZ]; /* Externals used by this function. */ extern FILE *ErrFile; extern int MsDosFileNms; /* Initialize the elements array to show that we have none of the * elements. */ for (i = ID_STRING; i <= NO_SEGMENTS; i++) Elements[i] = 0; /* Search forwards through the file for the first SEGMENT * begin line. */ for ( ; ; ) { /* Get the current file offset. */ LnOfs = ftell( InFlPtr ); /* Get a line from the file. */ if (ReadLine(InFlPtr, SegLine, BFR_SIZE) == EOF) return( PRS_NO_SEGMENT ); /* Is this a SEGMENT begin line? */ if ( MatchSegment(SegLine, &Hdr, &Body) ) { #if defined(UNPOST_DEBUG) printf("Segment Begin: '%s'\n", SegLine); #endif strcpy(IDLine, SegLine); break; } } /* Initialize new segment. */ SegInfo->SegOfs = LnOfs; /* Process header block. */ LnOfs = Header(InFlPtr, Hdr, Elements, IDLine, SegInfo); if (LnOfs < 0L) return( LnOfs ); /* Process body to end of segment or first UU line. */ LnOfs = IdSearch(InFlPtr, Body, Elements, IDLine, &UULnType, &RetStrs, SegInfo); if (LnOfs < 0L) return( LnOfs ); /* Is this the begin line? */ SegInfo->UUOfs = LnOfs; if (UULnType != UU_BEGIN) { /* If this is segment number 1 and we did not find a begin line, * that is BIG trouble, so report an error. */ if (SegInfo->SegNo == 1) { fprintf(ErrFile, "%s %d : Error - No begin line in first segment:\n", __FILE__, __LINE__); fprintf(ErrFile, "\tSegment: '%s'\n", SegLine); return( PRS_NO_BEGIN ); } return( 0L ); } /* Get file name from begin line. */ GetBinFlNm(InFlPtr, RetStrs, FlName); #if defined(UNPOST_DEBUG) printf("\tFile Name: '%s'\n", FlName); #endif /* Return no errors occurred. */ if ( *FlName ) SegInfo->FlName = StrDup( FlName ); return( 0L ); } /*----------------------------------------------------------------------------- | Routine : FreeCfg() --- Free a configuration that was created by | reading a configuration file. -----------------------------------------------------------------------------*/ static void FreeCfg(void) { register int i; register int j; register int k; /* If the default configuration is in place, do nothing, else * free the old configuration. */ if (Segments != NnSegs && Segments != RnSegs && Segments != GroupsSegs && Segments != EmailSegs) { /* Free all ID prefix lists in SEGMENT list. */ for (i = 0; Segments[i].ReExprStr; i++) { /* Free all ID part lists in ID prefix list. */ for (j = 0; Segments[i].Header[j].ReExprStr; j++) { /* Free all part extraction RE's, etc. */ for (k = 0; Segments[i].Header[j].IdParts[k].ReExpStr; k++) { free( Segments[i].Header[j].IdParts[k].ReExpStr ); FreeReExpr( Segments[i].Header[j].IdParts[k].ReExpr ); } /* Free list memory and regular expression. */ free( Segments[i].Header[j].IdParts ); free( Segments[i].Header[j].ReExprStr ); (void) FreeReExpr( Segments[i].Header[j].ReExpr ); } free( Segments[i].Header ); /* Free all ID part lists in ID prefix list. */ for (j = 0; Segments[i].Body[j].ReExprStr; j++) { /* Free all part extraction RE's, etc. */ for (k = 0; Segments[i].Body[j].IdParts[k].ReExpStr; k++) { free( Segments[i].Body[j].IdParts[k].ReExpStr ); FreeReExpr( Segments[i].Body[j].IdParts[k].ReExpr ); } /* Free list memory and regular expression. */ free( Segments[i].Body[j].IdParts ); free( Segments[i].Body[j].ReExprStr ); (void) FreeReExpr( Segments[i].Body[j].ReExpr ); } free( Segments[i].Body ); /* Free the regular expression graph for the segment. */ free( Segments[i].ReExprStr ); (void) FreeReExpr( Segments[i].ReExpr ); } /* Free SEGMENT list. */ free( Segments ); } } /*----------------------------------------------------------------------------- | Routine : SetSegBegin() --- Set the segment begin line regular | expression. | | Inputs : SegType - Either 'e', 'g', 'n', 'm', 'r'. -----------------------------------------------------------------------------*/ void SetSegBegin(char *SegType) { register int i; /* Free any previously allocated configurations (configurations * read in from a config file only. */ FreeCfg(); /* Determine which type, based on input string. */ switch ( tolower( *SegType ) ) { case 'e': Segments = EmailSegs; break; case 'g': Segments = GroupsSegs; break; case 'n': Segments = NnSegs; break; case 'r': default: Segments = RnSegs; break; } /* Compile SEGMENT begin RE's. */ for (i = 0; Segments[i].ReExprStr; i++) if (Segments[i].ReExpr == NULL) Segments[i].ReExpr = ReCompile( Segments[i].ReExprStr ); } /*----------------------------------------------------------------------------- | Routine : CompCfg() --- Compile a configuration. -----------------------------------------------------------------------------*/ static void CompCfg(void) { register int i; register int j; register int k; auto PART_RE *PartPtr; auto IDENT *IdPtr; auto SEGMENT *SegPtr; /* Compile the regular expressions. */ for (i = 0; Segments[i].ReExprStr; i++) { /* Compile the unique SEGMENT line prefix. */ SegPtr = Segments + i; if (SegPtr->ReExpr == NULL) SegPtr->ReExpr = ReCompile( SegPtr->ReExprStr ); /* Compile all Header ID line information. */ for (j = 0; SegPtr->Header[j].ReExprStr; j++) { /* Compile the unique ID line prefix. */ IdPtr = SegPtr->Header + j; IdPtr->ReExpr = ReCompile( IdPtr->ReExprStr ); /* Compile the part number parsing RE's. */ for (k = 0; IdPtr->IdParts[k].ReExpStr; k++) { PartPtr = IdPtr->IdParts + k; PartPtr->ReExpr = ReCompile( PartPtr->ReExpStr ); } } /* Compile all Body ID line information. */ for (j = 0; SegPtr->Body[j].ReExprStr; j++) { /* Compile the unique Body ID line prefix. */ IdPtr = SegPtr->Body + j; IdPtr->ReExpr = ReCompile( IdPtr->ReExprStr ); /* Compile the part number parsing RE's. */ for (k = 0; IdPtr->IdParts[k].ReExpStr; k++) { PartPtr = IdPtr->IdParts + k; PartPtr->ReExpr = ReCompile( PartPtr->ReExpStr ); } } } } /*----------------------------------------------------------------------------- | Routine : LoadCfg() --- Load a configuration file. | | Inputs : CfgFlNm - Configuration file name. -----------------------------------------------------------------------------*/ void LoadCfg(char *CfgFlNm) { extern FILE *ErrFile; /* Check for reading a configuration file. */ if (CfgFlNm == NULL || *CfgFlNm == '\0') { fprintf(ErrFile, "%s %d : Error - Missing configuraiton file name.\n", __FILE__, __LINE__); return; } /* Free any previously allocated configuration trees. */ FreeCfg(); /* Parse configuration file. */ Segments = ReadConfig( CfgFlNm ); /* Compile the configuration. */ CompCfg(); } /*----------------------------------------------------------------------------- | Routine : ParseInit() --- Compile regular expressions here that will | not change during run time, and compile the default | configuration. -----------------------------------------------------------------------------*/ void ParseInit(void) { /* Compile the RN default configuration. */ CompCfg(); /* Compile the UU encoding RE's. */ Begin = ReCompile( BeginStr ); End = ReCompile( EndStr ); CrcRE = ReCompile( CrcStr ); } unpost/parse.h100644 23453 0 10145 5543402242 13267 0ustar jeanpaulsystem/****************************************************************************** * Module : Parser header file. * * Author : John W. M. Stevens ******************************************************************************/ #if ! defined(PARSER_HEADER_FILE) #define PARSER_HEADER_FILE #include "regexp.h" #include "uudec.h" #define PRS_NO_SEGMENT -1L /* Found end of file before SEGMENT begin. */ #define PRS_NO_ID_STR -2L /* Did not find an ID string. */ #define PRS_NO_UU_LN -3L /* Did not find a UU line in SEGMENT. */ #define PRS_NO_BEGIN -4L /* Did not find expected uuencode begin. */ #define PRS_NO_SEG_NUM -5L /* Did not find a SEGMENT number. */ #define PRS_NO_NUM_SEGS -6L /* Did not find total number of SEGMENTs. */ #define PRS_UNX_END_SEG -7L /* Found unexpected end of segment. */ /* Part numbering parsing RE's. */ typedef struct { char *ReExpStr; /* RE source string. */ int IDStr; /* Sub-Expr. number for ID string. */ int SegNo; /* Sub-Expr. for segment number. */ int NoSegs; /* Sub-Expr. for number of segments. */ int AltIDStr; /* Sub-Expr. for alternate ID string. */ CASE_CMP Case; /* Case sensitivity switch. */ REG_EXP_NODE *ReExpr; /* Pointer to compiled RE. */ } PART_RE; /* Subject line structure. */ typedef struct { char *ReExprStr; /* Pointer to RE source string. */ PART_RE *IdParts; /* List of part number parsing RE's. */ REG_EXP_NODE *ReExpr; /* Pointer to compiled RE. */ } IDENT; /* Segment RE structure. */ typedef struct { char *ReExprStr; /* Pointer to RE source string. */ IDENT *Header; /* Header ID regular expressions. */ IDENT *Body; /* Body ID regular expressions. */ REG_EXP_NODE *ReExpr; /* Pointer to compiled RE. */ } SEGMENT; /* Define a structure to store the results of the first pass. */ typedef struct { char *SrcFlNm; /* Source file name. */ long SegOfs; /* Offset of begining of segment. */ long UUOfs; /* Offset of first UU line in segement. */ int Exists; /* Segment exists. */ int SegNo; /* Segment number. */ int SegLstOrd; /* Segment list ordinal. */ } SEGS; /* File list structure. */ typedef struct { char *IDString; /* Pointer to SEGMENT ID string. */ char *FlName; /* File name. */ int Success; /* Successful unpost flag. */ int NoSegs; /* Number of segments in binary. */ CRC_TYPE PostCRC; /* POST CCITT CRC. */ int ChkCRC; /* Flag to check CRC. */ SEGS *Segs; /* Pointer to list of segment desc. */ } FL_LIST; /* Segment information. */ typedef struct { int NoSegs; int SegNo; long SegOfs; long UUOfs; CRC_TYPE PostCRC; int ChkCRC; char *IDString; char *FlName; } SEG_INFO; /* Function prototypes. */ extern int GetBinFlNm(FILE *InFlPtr, char **RetStrs, char *FlName); extern int MatchEnd(char *Line); extern int MatchBegin(char *Line, char ***RetStrs); extern int MatchSegment(char *Line, IDENT **Hdr, IDENT **Body); extern long Parse(FILE *InFlPtr, char *SegLine, char *IDLine, SEG_INFO *SegInfo); extern void SetSegBegin(char *SegType); extern void LoadCfg(char *CfgFlNm); extern void ParseInit(void); #endif unpost/recomp.c100644 23453 0 53704 5543402240 13443 0ustar jeanpaulsystem/****************************************************************************** * Module : Regular Expression Compiling. * * Author : John W. M. Stevens. * * Notes : Use UNIX style regular expressions. Grammar is: * * REG_EXPR ::= ANCHOR * | ANCHOR '|' REG_EXPR * * ANCHOR ::= CATENATION * | '^' CATENATION * | CATENATION '$' * | '^' CATENATION '$' * * CATENATION ::= PHRASE * | PHRASE CATENATION * * PHRASE ::= UNARY * | UNARY ENUM_OP * * ENUM_OP ::= '*' * | '+' * | '?' * | '{' SPAN_RNG '}' * * SPAN_RNG ::= NUMBER * | NUMBER ',' NUMBER * * UNARY ::= '(' REG_EXPR ')' * | CHAR_STR * | '[' SET ']' * | '[' '^' SET ']' * | '.' * * SET ::= CHAR_STR * | CHAR_STR SET * | CHAR '-' CHAR * | CHAR '-' CHAR SET * * CHAR_STR ::= CHARACTER * | CHARACTER CHARACTER_STR * * CHARACTER ::= ' ' - '~' except for []()|{}+*? which are special without * being escaped. ******************************************************************************/ #include "compiler.h" #include "unpost.h" #include "sets.h" #include "regexp.h" #include "utils.h" /* Character Sets. */ static int ReInitFlag = 0; static char *SpecStr = "[().|$"; static SET SpecSet; static char *PostFixStr = "{*?+"; static SET PostSet; static char *DecStr = "0-9"; static SET DecSet; static UINT SubExprNo; static REG_EXP_NODE *Alternation(char **); #if defined( RE_TEST ) /*----------------------------------------------------------------------------- | Routine : PrtReExpr() --- Print a regular expression for debugging | purposes. (This may be used in the configuration helper | in a later release, so make it pretty). | | Inputs : Node - Pointer to current level regular expression node. | Level - Current level in tree. -----------------------------------------------------------------------------*/ static void PrtReExpr(REG_EXP_NODE *Node, int Level) { register int i; register int j; /* Traverse right to left so that the tree can be printed * on a screen or page rotated 90 degrees to the left. * * (Right to left == top to bottom of screen or page) */ if ( Node->Right ) PrtReExpr(Node->Right, Level + 1); /* Print indentation. */ for (i = 0; i < Level; i++) printf(" "); /* Print node type and information. */ switch ( Node->NodeType ) { case OP_L_PAREN: printf("(\n"); break; case DATA_LEFT_ANCHOR: printf("^\n"); break; case DATA_RIGHT_ANCHOR: printf("$\n"); break; case OP_ENUM: printf("Enum {%d, %u}\n", Node->MinSpan, Node->MaxSpan); break; case OP_OR: printf("|\n"); break; case OP_AND: printf("&\n"); break; case DATA_ANY: printf(".\n"); break; case DATA_SPAN: printf("Span {%d, %u}\n", Node->MinSpan, Node->MaxSpan); break; case DATA_STRING: printf("'%s'\n", Node->data.MatchStr, Node->SubExprNo); break; case DATA_SET: printf("["); for (j = 0; j < 128; j++) if ( InSet(Node->data.CSet, (unsigned char) j) ) { if (j < 32 || j > 127) printf("\\x%02x"); else putchar( (char) j ); } printf("] %d\n", Node->SubExprNo); break; case NODE_TYPE_NOT_SET: default: printf(">>>> ERROR !, no node type set.\n"); break; } /* Now print left child. */ if ( Node->Left ) PrtReExpr(Node->Left, Level + 1); } #endif /*----------------------------------------------------------------------------- | Routine : AllocRegExpNode() --- Allocate a regular expression node. | | Returns : Returns a pointer to the newly allocated regular expression | node. -----------------------------------------------------------------------------*/ static REG_EXP_NODE *AllocRegExpNode(void) { auto REG_EXP_NODE *New; extern FILE *ErrFile; /* Allocate the node. */ if ((New = (REG_EXP_NODE *) calloc(1, sizeof( REG_EXP_NODE ))) == NULL) { fprintf(ErrFile, "%s %d : Out of memory.\n", __FILE__, __LINE__); exit( 1 ); } return( New ); } /*----------------------------------------------------------------------------- | Routine : GetInt() --- Get an integer number for the case of | regular expression enumeration. | | Inputs : Str - Pointer to string to get number from. | Outputs : Str - Pointer to first character in string after number. | | Returns : Returns the integer read from the string. -----------------------------------------------------------------------------*/ static int GetInt(char **Str) { auto int i; /* Strip white space. */ while (**Str == ' ' || **Str == '\t' || **Str == '\n') (*Str)++; /* Get number. */ i = 0; while ( InSet(DecSet, (unsigned char) **Str) ) i = i * 10 + (*(*Str)++ - '0'); /* Strip trailing white space. */ while (**Str == ' ' || **Str == '\t' || **Str == '\n') (*Str)++; /* Return number. */ return( i ); } /*----------------------------------------------------------------------------- | Routine : EnumOp() --- Get the enumeration modifer. | node. | | Inputs : Str - Pointer to enumeration operator. | Root - Pointer to regular expression node. | Outputs : Str - Pointer after enumeration operator. | | Note : A value of zero for maximum span value indicates ANY | number. -----------------------------------------------------------------------------*/ static void EnumOp(char **Str, REG_EXP_NODE *Root) { extern FILE *ErrFile; /* Set up the operator and enumerator values. */ switch ( *(*Str)++ ) { case '+': Root->MinSpan = 1; Root->MaxSpan = ~0; break; case '*': Root->MinSpan = 0; Root->MaxSpan = ~0; break; case '?': Root->MinSpan = 0; Root->MaxSpan = 1; break; case '{': /* Get specifically enumerated span. */ Root->MinSpan = GetInt( Str ); Root->MaxSpan = Root->MinSpan; /* Is there a maximum number of characters? */ if (**Str == ',') { /* Get maximum span. */ (*Str)++; /* Strip white space. */ while (**Str == ' ' || **Str == '\t' || **Str == '\n') (*Str)++; /* Set to maximum, or get maximum. */ if (**Str == '}') Root->MaxSpan = ~0; else if ( InSet(DecSet, (unsigned char) **Str) ) Root->MaxSpan = GetInt( Str ); } /* Check for end brace. */ if (**Str != '}') { fprintf(ErrFile, "%s %d : Error - missing '}' in regular expression.\n", __FILE__, __LINE__); exit( 1 ); } (*Str)++; break; } } /*----------------------------------------------------------------------------- | Routine : Unary() --- Unary Operations. | | Inputs : Str - Pointer to current character in source RE string. | | Returns : Pointer to regular expression node. -----------------------------------------------------------------------------*/ static REG_EXP_NODE *Unary(char **Str) { auto REG_EXP_NODE *Node; auto char Buffer[256]; auto char *Tmp; extern FILE *ErrFile; /* Get the regular expression atoms. */ switch ( **Str ) { case '.': /* Allocate a regular expression node. */ (*Str)++; Node = AllocRegExpNode(); Node->NodeType = DATA_ANY; break; case '[': /* Allocate a regular expression node. */ Node = AllocRegExpNode(); /* Allocate a set. */ if ((Node->data.CSet = (SET_TYPE *) calloc(1, SET_SIZE * sizeof( SET_TYPE ))) == NULL) { fprintf(ErrFile, "%s %d : Out of memory.\n", __FILE__, __LINE__); exit( 1 ); } /* Create the set. */ (*Str)++; CrtSet((unsigned char **) Str, Node->data.CSet); Node->NodeType = DATA_SET; break; case '(': /* Skip parentheses. */ (*Str)++; /* Allocate a regular expression node. */ Node = AllocRegExpNode(); Node->NodeType = OP_L_PAREN; /* Save the sub expression number. */ if (SubExprNo > MAX_SUB_EXPRS) { fprintf(ErrFile, "%s %d : Error - To many sub-expressions.\n", __FILE__, __LINE__); exit( 1 ); } Node->SubExprNo = SubExprNo++; /* Get sub expression. */ Node->Right = Alternation( Str ); /* Check for end parentheses. */ if (**Str != ')') { fprintf(ErrFile, "%s %d : Error - missing ')' in regular expression.\n", __FILE__, __LINE__); exit( 1 ); } (*Str)++; break; default: /* Check for badly formed regular expression. */ if (InSet(SpecSet, (unsigned char) **Str) || InSet(PostSet, (unsigned char) **Str)) { fprintf(ErrFile, "%s %d : Error - badly formed regular expression.\n", __FILE__, __LINE__); fprintf(ErrFile, "\tUnexpected character '%c'\n", **Str); exit( 1 ); } /* Allocate a regular expression node. */ Node = AllocRegExpNode(); /* Get characters while they are not in the set of special * characters. */ for (Tmp = Buffer; **Str; ) if (**Str == '\\' && (*Str)[1]) { *Tmp++ = *++*Str; ++*Str; } else if (InSet(SpecSet, (unsigned char) **Str)|| InSet(PostSet, (unsigned char) **Str)) break; else *Tmp++ = *(*Str)++; *Tmp = '\0'; Node->NodeType = DATA_STRING; /* Duplicate the string and add to the node. */ if ((Node->data.MatchStr = StrDup( Buffer )) == NULL) { fprintf(ErrFile, "%s %d : Out of memory.\n", __FILE__, __LINE__); exit( 1 ); } break; } /* Return a pointer to the new node. */ return( Node ); } /*----------------------------------------------------------------------------- | Routine : Enumerate() --- Enumerate a regular expression. | | Inputs : Str - Pointer to current character in source RE string. | | Returns : Pointer to regular expression node. -----------------------------------------------------------------------------*/ static REG_EXP_NODE *Enumerate(char **Str) { auto REG_EXP_NODE *Node; auto REG_EXP_NODE *New; extern FILE *ErrFile; /* Get the regular expression. */ Node = Unary( Str ); /* Test for enumeration. */ if ( InSet(PostSet, (unsigned char) **Str) ) { /* Check for the special case of enumerating a '.' */ if (Node->NodeType == DATA_ANY) { /* Modify it to be a DATA_SPAN type. */ Node->NodeType = DATA_SPAN; } else if (Node->NodeType == OP_L_PAREN) { fprintf(ErrFile, "%s %d : Error, can not enumerate a sub expression.\n", __FILE__, __LINE__); exit( 1 ); } else { /* Allocate an enumeration node. */ New = AllocRegExpNode(); New->Right = Node; New->NodeType = OP_ENUM; Node = New; } /* Determine enumeration value. */ EnumOp(Str, Node); } return( Node ); } /*----------------------------------------------------------------------------- | Routine : Catenation() --- Concatenate regular expressions. | | Inputs : Str - Pointer to current character in source RE string. | | Returns : Pointer to regular expression node. -----------------------------------------------------------------------------*/ static REG_EXP_NODE *Catenation(char **Str) { auto REG_EXP_NODE *Root; auto REG_EXP_NODE *SubExpr; auto REG_EXP_NODE *Prev; auto REG_EXP_NODE *Next; /* Loop, getting concatenations (and operation) of regular * expressions seperated by OR's. */ Prev = Root = NULL; for ( ; ; ) { /* Get next sub expression. */ SubExpr = Enumerate( Str ); /* Determine type of action to take. */ if (**Str && **Str != '|' && **Str != ')' && **Str != '$') { /* Create new node. */ Next = AllocRegExpNode(); Next->Left = SubExpr; Next->NodeType = OP_AND; /* Link to old node. */ if ( Prev ) Prev->Right = Next; else Root = Next; Prev = Next; } else { /* Determine final link type. */ if ( Prev ) Prev->Right = SubExpr; else Root = SubExpr; /* End loop. */ break; } } /* Return a pointer to the root node. */ return( Root ); } /*----------------------------------------------------------------------------- | Routine : Anchor() --- Parse the two anchoring unary operators. | | Inputs : Str - Regular expression source string. | | Returns : Returns a pointer to the compiled regular expression. -----------------------------------------------------------------------------*/ static REG_EXP_NODE *Anchor(char **Str) { auto REG_EXP_NODE *Root; auto REG_EXP_NODE *Node; /* Check for begining of line anchor. */ if (**Str == '^') { /* Next character. */ (*Str)++; /* Allocate a node. */ Root = AllocRegExpNode(); Root->NodeType = DATA_LEFT_ANCHOR; /* Get expression. */ Root->Right = Catenation( Str ); } else Root = Catenation( Str ); /* Check for end of line anchor. */ if (**Str == '$') { /* Next character. */ (*Str)++; /* Allocate a node. */ Node = AllocRegExpNode(); Node->NodeType = DATA_RIGHT_ANCHOR; Node->Right = Root; Root = Node; } /* Return regular expression. */ return( Root ); } /*----------------------------------------------------------------------------- | Routine : Alternation() --- Parse an alternation expression. | | Inputs : Str - Pointer to current character in source RE string. | | Returns : Pointer to regular expression node. -----------------------------------------------------------------------------*/ static REG_EXP_NODE *Alternation(char **Str) { auto REG_EXP_NODE *Root; auto REG_EXP_NODE *New; /* Get a concatenation of regular expressions. */ Root = Anchor( Str ); /* Loop, getting concatenations (and operation) of regular * expressions seperated by OR's. */ while (**Str == '|') { /* Next character. */ (*Str)++; /* Allocate a node. */ New = AllocRegExpNode(); New->Left = Root; New->NodeType = OP_OR; /* Get right hand of expression. */ New->Right = Anchor( Str ); Root = New; } /* Return root of regular expression tree. */ return( Root ); } /*----------------------------------------------------------------------------- | Routine : ReGraph() --- Convert a regular expression tree into a graph. | | Inputs : Node - Regular expression tree node. | | Returns : Returns a pointer to the compiled regular expression. -----------------------------------------------------------------------------*/ static REG_EXP_NODE *ReGraph(REG_EXP_NODE *Node, REG_EXP_NODE *Link) { auto REG_EXP_NODE *RetLink; auto REG_EXP_NODE *New; /* Determine operation type. */ switch ( Node->NodeType ) { case OP_L_PAREN: /* Allocate an end of parentheses node. */ New = AllocRegExpNode(); New->NodeType = OP_R_PAREN; New->SubExprNo = Node->SubExprNo; New->Right = Link; /* Continue link. */ Node->Right = ReGraph(Node->Right, New); RetLink = Node; break; case OP_ENUM: /* Continue link. */ Node->Left = Node->Right; Node->Right = Link; RetLink = Node; break; case OP_AND: /* Traverse right, returning a pointer that can be used to * link the tree into a graph. */ RetLink = ReGraph(Node->Right, Link); /* Go down left and link together. */ RetLink = ReGraph(Node->Left, RetLink); /* Free AND node and return the link. */ free( Node ); break; case OP_OR: /* Allocate an end of or node. */ New = AllocRegExpNode(); New->NodeType = END_OR; New->Right = Link; /* Process both. */ Node->Right = ReGraph(Node->Right, New); Node->Left = ReGraph(Node->Left, New); /* Return pointer to OR. */ RetLink = Node; break; case DATA_LEFT_ANCHOR: Node->Right = ReGraph(Node->Right, Link); RetLink = Node; break; case DATA_RIGHT_ANCHOR: /* Allocate an end of parentheses node. */ New = Node->Right; Node->Right = Link; RetLink = ReGraph(New, Node); break; case DATA_ANY: case DATA_SPAN: case DATA_STRING: case DATA_SET: Node->Right = Link; RetLink = Node; } /* Return a pointer to the tail end of the graph so far. */ return( RetLink ); } /*----------------------------------------------------------------------------- | Routine : ReCompile() --- Compile a regular expression. | | Inputs : Str - Regular expression source string. | | Returns : Returns a pointer to the compiled regular expression. -----------------------------------------------------------------------------*/ REG_EXP_NODE *ReCompile(char *Str) { auto REG_EXP_NODE *Root; /* Construct sets, if not already constructed. */ if (ReInitFlag == 0) { auto unsigned char **Str; /* Create the sets. */ Str = (unsigned char **) &SpecStr; CrtSet(Str, SpecSet); Str = (unsigned char **) &PostFixStr; CrtSet(Str, PostSet); Str = (unsigned char **) &DecStr; CrtSet(Str, DecSet); /* We have initialized, so set flag saying so. */ ReInitFlag = 1; } /* Check for leading anchor. */ SubExprNo = 1; Root = Alternation( &Str ); /* Print the regular expression tree. */ #if defined( RE_TEST ) PrtReExpr(Root, 0); #endif /* Convert to a graph. */ Root = ReGraph(Root, NULL); /* Return pointer to regular expression. */ return( Root ); } /*----------------------------------------------------------------------------- | Routine : FreeReExpr() --- Free the memory of a regular expression | graph memory. | | Inputs : ReExpr - Regular expression digraph root. -----------------------------------------------------------------------------*/ REG_EXP_NODE *FreeReExpr(REG_EXP_NODE *ReExpr) { auto REG_EXP_NODE *Node; auto REG_EXP_NODE *EndOr; extern FILE *ErrFile; /* Free the different node types. */ while (ReExpr && ReExpr->NodeType != END_OR) { /* Get pointer to next node. */ Node = ReExpr->Right; /* Select operation on node type. */ switch ( ReExpr->NodeType ) { case OP_ENUM: (void) FreeReExpr( ReExpr->Left ); break; case OP_OR: /* Free to end of OR branch. */ (void) FreeReExpr( ReExpr->Right ); /* Free to end of OR branch, and get pointer to next * node. */ EndOr = FreeReExpr( ReExpr->Left ); Node = EndOr->Right; free( EndOr ); break; case DATA_STRING: free( ReExpr->data.MatchStr ); break; case DATA_SET: free( ReExpr->data.CSet ); break; case OP_AND: case OP_L_PAREN: case OP_R_PAREN: case DATA_LEFT_ANCHOR: case DATA_RIGHT_ANCHOR: case DATA_ANY: case DATA_SPAN: break; default: fprintf(ErrFile, "%s %d : Error - illegal regular expression node type.\n", __FILE__, __LINE__); exit( 1 ); } /* Move along. */ free( ReExpr ); ReExpr = Node; } /* Return pointer to end of chain. */ return( ReExpr ); } unpost/regexp.h100644 23453 0 5112 5543402242 13425 0ustar jeanpaulsystem/****************************************************************************** * Module : Regular Expression String Matching --- Defines, typedefs and * function prototypes. * * Author : John Stevens ******************************************************************************/ #if ! defined(REGULAR_EXPRESSION_HEADER_FILE) #define REGULAR_EXPRESSION_HEADER_FILE #include "sets.h" /* Define the maximum number of sub-expressions supported. */ #define MAX_SUB_EXPRS 20 /* Flags for case sensitivity in string compares. */ typedef enum { CASE_SENSITIVE, IGN_CASE } CASE_CMP; /* Type of regular expression node in expression tree. */ typedef enum { NODE_TYPE_NOT_SET, OP_ENUM, /* Enumeration operator. */ OP_OR, /* Alternation operator. */ OP_AND, /* Catenation operator. */ OP_L_PAREN, /* Parentheses. */ OP_R_PAREN, /* Right parentheses. */ END_OR, /* End alternation. */ END_ENUM, /* End enumeration. */ DATA_LEFT_ANCHOR, /* Anchor left side. */ DATA_RIGHT_ANCHOR, /* Anchor right side. */ DATA_ANY, /* Any single character. */ DATA_SPAN, /* Match any character. */ DATA_STRING, /* String data node. */ DATA_SET /* Set data node. */ } NODE_TYPE; /* Type definition for regular expression node in expression tree. */ typedef struct reg_exp_st { NODE_TYPE NodeType; /* Node type, operator or data. */ struct reg_exp_st *Left; /* Expression tree pointers. */ struct reg_exp_st *Right; unsigned int MinSpan; /* Minimum span. */ unsigned int MaxSpan; /* Maximum span. */ unsigned int SubExprNo; /* Sub-expression number. */ union { char *MatchStr; /* String to match against. */ SET_TYPE *CSet; /* Character set to match against. */ } data; } REG_EXP_NODE; /* Function prototypes. */ extern REG_EXP_NODE *ReCompile(char *); extern int ReMatch(char *Str, CASE_CMP Case, REG_EXP_NODE *ReExpr, char ***SubStrs); extern REG_EXP_NODE *FreeReExpr(REG_EXP_NODE *ReExpr); #endif unpost/rematch.c100644 23453 0 32353 5543402240 13576 0ustar jeanpaulsystem/****************************************************************************** * Module : Regular Expression Matching. * * Author : John W. M. Stevens. ******************************************************************************/ #include "compiler.h" #include "sets.h" #include "regexp.h" #include "utils.h" /* Define sub expression list. */ typedef struct { char *Start; /* Start of sub-string in source. */ char *End; /* End of sub-string in source. */ char *SubStr; /* Pointer to sub-string. */ } SUB_EXPR; static SUB_EXPR SubExprs[MAX_SUB_EXPRS + 1]; static CASE_CMP CmpCase = CASE_SENSITIVE; /*----------------------------------------------------------------------------- | Routine : ExtSubStrs() --- Extract the sub-strings from the string to | match against. -----------------------------------------------------------------------------*/ static void ExtSubStrs(void) { register int i; register int StrLen; auto char *Str; extern FILE *ErrFile; /* Extract all sub strings from the source string. */ for (i = 0; i <= MAX_SUB_EXPRS; i++) { /* Report run time error. */ if (SubExprs[i].Start == NULL || SubExprs[i].End == NULL) continue; else if (SubExprs[i].Start > SubExprs[i].End) { fprintf(ErrFile, "%s %d : Error - sub expression #%d extraction failed.\n", __FILE__, __LINE__, i); exit( 1 ); } /* Determine length of string. */ for (StrLen = 0, Str = SubExprs[i].Start; Str != SubExprs[i].End; StrLen++, Str++ ) ; /* Allocate space for the string. */ if ((Str = (char *) calloc(1, StrLen + 1)) == NULL) { fprintf(ErrFile, "%s %d : Out of memory.\n", __FILE__, __LINE__); exit( 1 ); } /* Copy the string to the new space. */ MemCopy(Str, SubExprs[i].Start, StrLen); Str[StrLen] = '\0'; /* Add string to sub expression string buffer. */ SubExprs[i].SubStr = Str; } } /*----------------------------------------------------------------------------- | Routine : ReStrCmp() --- Regular expression string compare. | | Inputs : Str - Pointer to string to attempt to match. | ReStr - Pointer to regular expression string. | | Returns : Returns zero for no match, non-zero for a match. -----------------------------------------------------------------------------*/ static int ReStrCmp(char *Str, char *ReStr) { /* While not end of regular expression string, compare characters. */ while ( *ReStr ) { /* If the characters do not match, return no match. */ if (CmpCase == IGN_CASE) { /* Compare characters regardless of case. */ if (tolower( *ReStr ) != tolower( *Str )) return( 0 ); /* They match. Increment pointers to next characters. */ ReStr++; Str++; } else if (*ReStr++ != *Str++) return( 0 ); } return( 1 ); } /*----------------------------------------------------------------------------- | Routine : ReData() --- Evaluate a regular expression data node. | | Inputs : SrcStart - Start of source string (for left anchor | comparisons). | Str - Pointer to string to attempt to match. | ReExpr - Pointer to regular expression node. | Outputs : Str - Pointer to string after matched portion, or | unchanged since input, if no match. | Srch - Pointer to search description structure. | | Returns : Returns 1 for a match, 0 for no match. -----------------------------------------------------------------------------*/ static int ReData(char *SrcStart, char **Str, REG_EXP_NODE *ReExpr) { register int Match; extern FILE *ErrFile; /* Attempt match. */ switch ( ReExpr->NodeType ) { case DATA_STRING: /* Compare string. */ if ((Match = ReStrCmp(*Str, ReExpr->data.MatchStr)) != 0) { /* Bump the source string pointer. */ (*Str) += strlen( ReExpr->data.MatchStr ); } break; case DATA_SET: /* Is the current character a member of the set? (Don't * forget that negated sets are already negated at this * point.) */ if ((Match = InSet(ReExpr->data.CSet, (unsigned char) **Str)) != 0) { /* Bump source string pointer. */ (*Str)++; } break; case DATA_ANY: /* Match any character except end of line. */ if ((Match = **Str && **Str != '\n') != 0) { /* Bump source string pointer. */ (*Str)++; } break; case DATA_LEFT_ANCHOR: /* Is this the start of the line? */ Match = *Str == SrcStart; break; case DATA_RIGHT_ANCHOR: /* Is the current character an end of line character? */ Match = **Str == '\n' || **Str == '\0'; break; default: fprintf(ErrFile, "%s %d : Error - illegal regular expression node type.\n", __FILE__, __LINE__); exit( 1 ); } /* Return match state. */ return( Match ); } /*----------------------------------------------------------------------------- | Routine : ReOp() --- Execute a regular expression operator. | | Inputs : SrcStart - Start of source string (for left anchor | comparisons). | Str - Pointer to string to attempt to match. | ReExpr - Pointer to regular expression node. | Outputs : Str - Pointer to string after matched portion, or | unchanged since input, if no match. | Cont - Current regular expression node pointer. | | Returns : Returns 1 for a match, 0 for no match. -----------------------------------------------------------------------------*/ static int ReOp(char *SrcStart, char **Str, REG_EXP_NODE *ReExpr, REG_EXP_NODE **Cont) { register int i; register int Match; auto char *ChkPt; auto REG_EXP_NODE *Tmp; auto REG_EXP_NODE *Node; extern FILE *ErrFile; /* Do operations. */ do { /* Attempt match. */ switch ( ReExpr->NodeType ) { case OP_OR: /* Save check point for backtracking. */ ChkPt = *Str; /* Attempt left branch first. */ if ((Match = ReOp(SrcStart, Str, ReExpr->Left, &Node)) == 0) { /* Attempt to match the right hand branch. */ *Str = ChkPt; Match = ReOp(SrcStart, Str, ReExpr->Right, &Node); } /* Get end of OR. */ ReExpr = Node; break; case DATA_SPAN: /* Scan for at least the minimum number of characters. */ for (Match = 1, i = 0; i < ReExpr->MinSpan; i++) if (**Str == '\0' || **Str == '\n') { Match = 0; break; } if (! Match) break; /* Skip over all control node types to see if there is * a terminating expression for this span. */ for (Tmp = ReExpr->Right; Tmp && (Tmp->NodeType == OP_L_PAREN || Tmp->NodeType == OP_R_PAREN || Tmp->NodeType == END_OR); Tmp = Tmp->Right) ; /* If there is no span terminating expression, then we * automatically match to end of line. */ if (Tmp == NULL) { /* Scan to end of input string. */ for ( ; **Str; ++*Str) ; /* This is a definite match. */ Match = 1; break; } /* We matched at least the minimum number. Now attempt the * maximum number. */ for (ChkPt = *Str; i < ReExpr->MaxSpan; i++) { /* Search forward until a match is found, or the * max number of any character has been spanned. */ *Str = ChkPt; if ((Match = ReOp(SrcStart, Str, ReExpr->Right, &Node)) != 0) { break; } /* We need to allow the routines to look at the * NUL char, as there may be an end of line anchor * in this expression. HOWEVER, we MUST NOT go * past end of line. */ if ( *ChkPt ) ChkPt++; else break; } /* Check for a match. */ Match = i < ReExpr->MaxSpan; ReExpr = Node; break; case OP_ENUM: /* Match the correct number of sub-expressions. */ for (i = 0; i < ReExpr->MaxSpan; i++) { /* Attempt data match. */ if ((Match = ReData(SrcStart, Str, ReExpr->Left)) == 0) { /* Have we at least the minimum? */ if (i >= ReExpr->MinSpan) Match = 1; break; } } break; case OP_L_PAREN: /* Save start of sub-expression. */ SubExprs[ReExpr->SubExprNo].Start = *Str; Match = 1; break; case OP_R_PAREN: /* Save start of sub-expression. */ SubExprs[ReExpr->SubExprNo].End = *Str; Match = 1; break; default: Match = ReData(SrcStart, Str, ReExpr); break; } /* Check for end. */ if (ReExpr != NULL) ReExpr = ReExpr->Right; } while (Match && ReExpr && ReExpr->NodeType != END_OR); /* Return match. */ *Cont = ReExpr; return( Match ); } /*----------------------------------------------------------------------------- | Routine : ReMatch() --- Regular expression match. | | Inputs : Str - Pointer to string to attempt to match. | Case - Flag for case sensitivity. | ReExpr - Pointer to regular expression tree root. | Outputs : SubStrs - Pointer to array of returned strings. | NoSubStrs - Size of returned string array. | | Returns : Returns zero for no match, non-zero for a match. -----------------------------------------------------------------------------*/ int ReMatch(char *Str, CASE_CMP Case, REG_EXP_NODE *ReExpr, char ***SubStrs) { register int i; register int Match; auto char *tp; auto char *Loop; auto REG_EXP_NODE *Node; static char *RetStrs[MAX_SUB_EXPRS]; extern FILE *ErrFile; /* Run list and free strings. */ for (i = 1; i < MAX_SUB_EXPRS; i++) { /* Free previous sub strings. */ if (RetStrs[i] != NULL) free( RetStrs[i] ); /* Initialize the sub expression list. */ RetStrs[i] = NULL; SubExprs[i].Start = SubExprs[i].End = SubExprs[i].SubStr = NULL; } /* If the first node is a left anchor, no shifting is necesary. */ tp = Str; CmpCase = Case; if (ReExpr->NodeType == DATA_LEFT_ANCHOR) Match = ReOp(Str, &tp, ReExpr->Right, &Node); else { /* Search forward. */ for (Loop = Str; ; Loop++) { /* Search for a match. */ tp = Loop; if ((Match = ReOp(Str, &tp, ReExpr, &Node)) != 0) break; /* Check for end of loop. */ if (*Loop == '\0' || *Loop == '\n') break; } } /* Create sub string array. */ if ( Match ) { /* Extract sub expression strings. */ ExtSubStrs(); for (i = 1; i < MAX_SUB_EXPRS; i++) RetStrs[i] = SubExprs[i].SubStr; /* Return sub string array. */ *SubStrs = RetStrs; } /* Return match true or false. */ return( Match ); } unpost/retest.c100644 23453 0 3561 5543402240 13440 0ustar jeanpaulsystem/****************************************************************************** * Module : Regular Expression Test Driver --- Test the regular expression * package. * * Author : John Stevens ******************************************************************************/ #include "compiler.h" #include "sets.h" #include "regexp.h" #include "utils.h" FILE *ErrFile; int main(int argc, char **argv) { register int i; auto REG_EXP_NODE *ReExpr; auto FILE *fp; auto char **SubStrs; auto char Bfr[256]; /* Check command line parameters. */ if (argc != 3) { fprintf(stderr, "%s %d : Error - Syntax is: ", __FILE__, __LINE__); fprintf(stderr, "%s \n", argv[0]); exit( 1 ); } ErrFile = stderr; /* Compile the regular expression. */ ReExpr = ReCompile( argv[1] ); /* Match against a line from a test file. */ if ((fp = fopen(argv[2], TXT_READ)) == NULL) { fprintf(stderr, "Error, could not open file '%s' for reading.\n", argv[2]); exit( 1 ); } /* Search file for matching regular expressions, and print all * matched sub-strings. */ while (fgets(Bfr, 256, fp) != NULL) { /* Attempt match. */ SubStrs = NULL; if (ReMatch(Bfr, CASE_SENSITIVE, ReExpr, &SubStrs) != 0) { /* Print matching line and matching sub-strings. */ printf("Line: '%s'\n", Bfr); for (i = 0; i < MAX_SUB_EXPRS; i++) if ( SubStrs[i] ) printf(" #%2d: '%s'\n", i, SubStrs[i]); } } return( 0 ); } unpost/cfg/ 40755 23453 0 0 5613467455 12444 5ustar jeanpaulsystemunpost/cfg/cbip.cfg100644 23453 0 7321 5457221200 14120 0ustar jeanpaulsystem# This is the default configuration modifed to ignore the leading # stuff on the subject line of comp.binaries.ibm.pc and # comp.binaries.ms-windows postings. segment "^(Article[:]?|X-NEWS:)" { header { "^Subject:" { "^Subject:.*:(.*)[[({]Part[_ ]*([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:.*:(.*)Part[_ ]*[[({]([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:.*:(.*)Part[_ ]+([0-9]+)[^0-9]+([0-9]+)(.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:.*:(.*)[([{]([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:.*:(.*)([0-9]+)([/|]|[ \t]+of[ \t]+)([0-9]+)(.*)" { id 1 segment number 2 segments 4 alternate id 5 case ignore } "^Subject:.*:(.*)" { id 1 segment number 0 segments 0 alternate id 0 case ignore } } "^X-File-Name:" { "^X-File-Name:[ ]+(.*)" { id 1 segment number 0 segments 0 alternate id 0 case sensitive } } "^X-Part:" { "^X-Part:[ ]+([0-9]+)" { id 0 segment number 1 segments 0 alternate id 0 case sensitive } } "^X-Part-Total:" { "^X-Part-Total:[ ]+([0-9]+)" { id 0 segment number 0 segments 1 alternate id 0 case sensitive } } "^Uusplit-part:" { "^Uusplit-part:[ ]+([0-9]+)" { id 0 segment number 1 segments 0 alternate id 0 case sensitive } } "^Uusplit-parts:" { "^Uusplit-parts:[ ]+([0-9]+)" { id 0 segment number 0 segments 1 alternate id 0 case sensitive } } } body { "^section [0-9]+ of uuencode [0-9]+\.[0-9]+ of file " "[^ ]+ by R.E.M." { "^section ([0-9]+) of uuencode [0-9]+\.[0-9]+ of file " "([^ ]+)[ ]+by R.E.M." { id 2 segment number 1 segments 0 alternate id 0 case sensitive } } "^[^ ]+[ ]+section[ ]+[0-9]+/[0-9]+[ ]+UUXFER " "ver [^ ]+ by David M. Read" { "^([^ \t]+)[ \t]+section[ \t]+([0-9]+)/([0-9]+)[ \t]+UUXFER " "ver [^ \t]+ by David M. Read" { id 1 segment number 2 segments 3 alternate id 0 case sensitive } } } } unpost/cfg/def.cfg100644 23453 0 12155 5457221210 13763 0ustar jeanpaulsystem# This is the default configuration of UNPOST, shown in configuration # file format for instructional purposes, and for use in situations # where the default needs to be modified. segment "^(Article[:]?|X-NEWS:)" { header { "^Subject:" { "^Subject:(.*)[[({]Part[_ ]*([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)Part[_ ]*[[({]([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)Part[_ ]+([0-9]+)[^0-9]+([0-9]+)(.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)[([{]([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)([0-9]+)([/|]|[ \t]+of[ \t]+)([0-9]+)(.*)" { id 1 segment number 2 segments 4 alternate id 5 case ignore } "^Subject:(.*)" { id 1 segment number 0 segments 0 alternate id 0 case ignore } } "^X-File-Name:" { "^X-File-Name:[ ]+(.*)" { id 1 segment number 0 segments 0 alternate id 0 case sensitive } } "^X-Part:" { "^X-Part:[ ]+([0-9]+)" { id 0 segment number 1 segments 0 alternate id 0 case sensitive } } "^X-Part-Total:" { "^X-Part-Total:[ ]+([0-9]+)" { id 0 segment number 0 segments 1 alternate id 0 case sensitive } } "^Uusplit-part:" { "^Uusplit-part:[ ]+([0-9]+)" { id 0 segment number 1 segments 0 alternate id 0 case sensitive } } "^Uusplit-parts:" { "^Uusplit-parts:[ ]+([0-9]+)" { id 0 segment number 0 segments 1 alternate id 0 case sensitive } } } body { "^section [0-9]+ of uuencode [0-9]+\.[0-9]+ of file " "[^ ]+ by R.E.M." { "^section ([0-9]+) of uuencode [0-9]+\.[0-9]+ of file " "([^ ]+)[ ]+by R.E.M." { id 2 segment number 1 segments 0 alternate id 0 case sensitive } } "^[^ ]+[ ]+section[ ]+[0-9]+/[0-9]+[ ]+UUXFER " "ver [^ ]+ by David M. Read" { "^([^ \t]+)[ \t]+section[ \t]+([0-9]+)/([0-9]+)[ \t]+UUXFER " "ver [^ \t]+ by David M. Read" { id 1 segment number 2 segments 3 alternate id 0 case sensitive } } "^Subject:" { "^Subject:(.*)[[({]Part[_ ]*([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)Part[_ ]*[[({]([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)Part[_ ]+([0-9]+)[^0-9]+([0-9]+)(.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)[([{]([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)([0-9]+)([/|]|[ \t]+of[ \t]+)([0-9]+)(.*)" { id 1 segment number 2 segments 4 alternate id 5 case ignore } "^Subject:(.*)" { id 1 segment number 0 segments 0 alternate id 0 case ignore } } } } unpost/cfg/email.cfg100644 23453 0 7170 5457221216 14303 0ustar jeanpaulsystem# This configuration file tells UNPOST how to handle email (and, # if I remember correctly, nn) segments. segment "^From " { header { "^Subject:" { "^Subject:(.*)[[({]Part[_ ]*([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)Part[_ ]*[[({]([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)Part[_ ]+([0-9]+)[^0-9]+([0-9]+)(.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)[([{]([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)" { id 1 segment number 2 segments 3 alternate id 4 case ignore } "^Subject:(.*)([0-9]+)([/|]|[ \t]+of[ \t]+)([0-9]+)(.*)" { id 1 segment number 2 segments 4 alternate id 5 case ignore } "^Subject:(.*)" { id 1 segment number 0 segments 0 alternate id 0 case ignore } } "^X-File-Name:" { "^X-File-Name:[ ]+(.*)" { id 1 segment number 0 segments 0 alternate id 0 case sensitive } } "^X-Part:" { "^X-Part:[ ]+([0-9]+)" { id 0 segment number 1 segments 0 alternate id 0 case sensitive } } "^X-Part-Total:" { "^X-Part-Total:[ ]+([0-9]+)" { id 0 segment number 0 segments 1 alternate id 0 case sensitive } } "^Uusplit-part:" { "^Uusplit-part:[ ]+([0-9]+)" { id 0 segment number 1 segments 0 alternate id 0 case sensitive } } "^Uusplit-parts:" { "^Uusplit-parts:[ ]+([0-9]+)" { id 0 segment number 0 segments 1 alternate id 0 case sensitive } } } body { "^section [0-9]+ of uuencode [0-9]+\.[0-9]+ of file " "[^ ]+ by R.E.M." { "^section ([0-9]+) of uuencode [0-9]+\.[0-9]+ of file " "([^ ]+)[ ]+by R.E.M." { id 2 segment number 1 segments 0 alternate id 0 case sensitive } } "^[^ ]+[ ]+section[ ]+[0-9]+/[0-9]+[ ]+UUXFER " "ver [^ ]+ by David M. Read" { "^([^ \t]+)[ \t]+section[ \t]+([0-9]+)/([0-9]+)[ \t]+UUXFER " "ver [^ \t]+ by David M. Read" { id 1 segment number 2 segments 3 alternate id 0 case sensitive } } } } unpost/cfg/mufud.cfg100644 23453 0 1103 5457221230 14316 0ustar jeanpaulsystemsegment "^Article[:]?" { header { "^Subject:" { "^Subject:(.*)part[ ]+([0-9]+)[ ]*(of|/)[ ]*([0-9]+)(.*)" { id 1 segment number 2 segments 4 alternate id 5 case ignore } "^Subject:(.*)([0-9]+)[ ]*(of|/)[ ]*([0-9]+)(.*)" { id 1 segment number 2 segments 4 alternate id 5 case ignore } } } body { } } unpost/sets.c100644 23453 0 5705 5543402240 13112 0ustar jeanpaulsystem/****************************************************************************** * Module : Bit Mapped Set Functions. * * Author : John W. M. Stevens. ******************************************************************************/ #include "sets.h" #define NUL '\0' #define EOL '\n' /*----------------------------------------------------------------------------- | Routine : InSet() --- Test to see if a character is a member of a set. | | Inputs : CSet - Character set to test against. | c - Character to test. | | Returns : Zero for not in the set, non-zero for in set. -----------------------------------------------------------------------------*/ int InSet(SET CSet, unsigned char c) { return( (int) (CSet[c / INT_SIZE] & (1 << (c % INT_SIZE))) ); } /*----------------------------------------------------------------------------- | Routine : CrtSet() --- Create a character set. | | Inputs : Str - String containing set elements. | Outputs : CSet - Initialized character set. -----------------------------------------------------------------------------*/ void CrtSet(unsigned char **Str, SET CSet) { register int i; register int c; auto int NegateFlag; auto unsigned char LastCh; /* If the first character of the set is a '^', this is a negated * set. */ if (**Str == '^') { NegateFlag = 1; (*Str)++; } else NegateFlag = 0; /* Clear the set first. */ for (i = 0; i < SET_SIZE; i++) CSet[i] = 0; /* Get characters of set. */ for (LastCh = '\0'; **Str && **Str != ']'; (*Str)++) { /* Check for escape character. */ if (**Str == '\\') (*Str)++; else if (**Str == '-') { /* Check to make sure that this is a range separator * character. */ if ( LastCh ) { /* Get termination character. */ if ((*Str)[1] && (*Str)[1] != ']') { /* Skip escape character. */ if ((c = *++(*Str)) == '\\') c = *++(*Str); /* Fill in range. */ for (i = LastCh + 1; i < c; i++) CSet[i / INT_SIZE] |= 1 << (i % INT_SIZE); LastCh = '\0'; } } } /* Add character to set. */ CSet[**Str / INT_SIZE] |= 1 << (**Str % INT_SIZE); LastCh = **Str; } if (**Str == ']') (*Str)++; /* Negate set if necesary. */ if ( NegateFlag ) { for (i = 0; i < SET_SIZE; i++) CSet[i] = ~CSet[i]; } /* Do not EVER match a '\0' or '\n'. */ CSet[0] &= ~1; CSet[EOL / INT_SIZE] &= ~(1 << (EOL % INT_SIZE)); } unpost/sets.h100644 23453 0 1427 5543402242 13116 0ustar jeanpaulsystem/****************************************************************************** * Module : Bit Map Sets Header File * * Author : John Stevens ******************************************************************************/ #if ! defined(BIT_MAPPED_SETS_HEADER_FILE) #define BIT_MAPPED_SETS_HEADER_FILE /* Type defines and macro defines for character set utilities. */ #if ! defined(_OS2EMX_H) && ! defined(IBM_CSET_COMPILER) typedef unsigned int UINT; #endif typedef UINT SET_TYPE; #define INT_SIZE (sizeof( SET_TYPE ) * 8) #define SET_SIZE (256 / INT_SIZE) typedef SET_TYPE SET[SET_SIZE]; /* Function prototypes. */ extern int InSet(SET, unsigned char); extern void CrtSet(unsigned char **, SET); #endif unpost/unpost.doc100644 23453 0 124344 5517261564 14065 0ustar jeanpaulsystemUNPOST Name: unpost - Extract binary files from multi-segment uuencoded USENET postings or Email. Synopsis: unpost [-b[-]] [-c ] [-d[-]] [-e ] [-f[-]] [-h|-s|-u] [-i ] [-l |-] [-o ] [-r e|g|n|r] [-t ] [-v] Where everything but the source file is optional. Description: UNPOST is a tool designed primarily to extract binaries from USENET binaries postings such as those made to alt.binaries.pictures.misc and comp.binaries.ibm.pc. As well as extracting binaries from USENET postings, UNPOST can extract binaries from multi-segment uuencoded mailings as well, however, to simplify this documentation only USENET article postings will be discussed. The principles are the same for multi-segment mailings. To avoid confusion, this documentation will refer to a single letter OR article as a 'segment'. For clarification on what a segment means to UNPOST, see Theory of Operations. Features: 1) PORTABILITY! UNPOST has been compiled and sucessfully run on MS-DOS, OS/2, Windows, Unix workstations, MacIntoshes, Amiga's and VAX/VMS systems. The code is written to be pure ANSI C, within reasonable limits. (some ANSI C capabilities are not used where they would be appropriate due to lagging compliance in most compilers. I personally check to make sure that it will compile and run on an MS-DOS box running MS-DOS 5 and Windows 3.1, using the Borland 3.1 C++ compiler, as well as a Sun (running SunOs 4.1.1 sun4c) using the gcc compiler (version 2.1). I know for a fact that the Sun cc compiler will NOT compile UNPOST succesfully. I have compiled version 2.1.0 on my Amiga, but no later version has been compiled due to the machine's untimely death. I will be testing all future versions for compilabiliy under OS/2 using the EMX GCC tools. 2) CONFIGURABILITY! UNPOST comes with a default set of rules for detecting and parsing a VERY wide range of possible Subject: line formats, but no configuration can be correct for every situation. With that in mind, UNPOST can be configured by the user by creating a text file that contains the regular expressions, etc. that UNPOST uses to recognize, parse, etc. WARNING! UNPOST depends almost ENTIRELY on the contents of it's configuration file for correct operation. Regular expressions are complex, and writing one that works the way you expect it to takes care and, most importantly, experimentation. To this end, the standard UNPOST installation creates both the UNPOST executable and a regular expression test program called RETEST. RETEST is like grep, feed it a regular expression and a file, and RETEST will tell you what it matched and the sub strings that it extracted. 3) INTELLIGENCE! UNPOST uses every trick in the book to try to guess what the poster/sender REALLY meant. Also, UNPOST is not limited to finding all of it's information on a single line, or even in the header of a posting/letter. UNPOST has succesfully extracted binaries from postings that had, as a subject line, Subject: aaaa because UNPOST recognized the signature placed into the body of the article by a uuencode/split program. 4) FLEXIBILITY! UNPOST has switches that allow it to be configured to do different things for different tastes. For instance, UNPOST will intelligently sort out articles into four different classes: 1) Articles that are part of a complete and correct binary in the input file. These are sorted, concatenated, uudecoded and written out to a file name that is the same as that on the uuencode begin line. Depending on the setting of the file name switch, the file name of the binary may be modified. See below. 2) Articles that are pure text (no uuencoded data in them). If the -t switch and a file name are specified, these articles will be written out to the file for reading. If -t is not set, then these articles are just. . . ignored! Obviously, these articles should NEVER be encountered in a binaries news group, but not a single day has ever gone by that I did not see non-binary postings to binary news groups. 3) Articles that are part of incomplete postings (four parts, but only three have shown up so far), or that comprise a complete binary, but one that had an error in uudecoding, interpretation, etc. If the -i flag and a file name are specified, these articles will be written out to the file. If the -b switch is on, incompletes will be written to separate files. If both are on, those incompletes that can be guessed at as having a file name will be written to a separate file, all else will be written to the file named by the -i switch. In my experience, two types of articles end up in an incompletes file, those that have missing parts, and those that have been misinterpreted by UNPOST as belonging to a different binary than they really do. 4) Articles that are pure text that describe a posting (these are usually found only in the pictures groups). If the -d flag is set, and the binary to which they belong is correct and complete, this article, as well as the header and body up to the uuencode begin line of the first article, will be written to a file that has the same base name as the binary, but with the extension .inf. UNPOST automatically mungles binary file names to be MS-DOS compatible (the lowest common denominator). This is switch controllable, and can be turned on or off (depending on the default setting selected by the person who compiled UNPOST). UNPOST also has two lesser modes, sorted mode and uudecode mode. In sorted mode, UNPOST assumes that the articles still have headers, and that there may be un-uuencoded lines in the middle of a uuencoded file that have to be filtered out, but it assumes that all parts are present, and that they are in order. Header information, however, is ignored. If you use the incompletes file capability of UNPOST, you will notice that it writes out the segments that it did interpret correctly in sorted order. In uudecode mode, UNPOST acts like a simple uudecoder. UUencoded files must be complete, with a begin and end line, and no un-uuencoded lines can appear between the begin and end lines. However, uudecode mode is the ONLY mode where UNPOST will accept a short line (one that was space terminated, but had the spaces chopped off) as a legal uuencoded line and properly decode it. 5) INFORMATIVE! UNPOST is a very talkative program. It detects and reports many kinds of problems, tells you what it thinks is going on, and tells you what it is doing. All this information is written to standard error, or if the -e switch and a file name are specified, written to that file. 6) NEAT TOOLS! UNPOST comes with a client program (called, wierdly enough, CLIENT) for NNTP news servers. CLIENT uses a configuration file that lists the news groups of interest, the file name to append all new articles to, and the number of the next, unread article. CLIENT can be used to call up an NNTP news server on a regular basis (I use cron, myself), get and save all unread articles from the news groups you are interested in (with a nifty new kill feature!). CLIENT, cron and UNPOST (plus a script) can be used to automatically get and decode articles from binaries news groups. Other tools include a regular expression test program to help you construct your own UNPOST configuration files (assuming that the default configuration is not working for you) and a more program that accepts a starting byte offset into a file (for debugging nasty little bugs). Theory of Operations: UNPOST assumes that the source file that is given to it will have the following format: SEGMENT begin line ... HEADER ID line ... BODY ID line ... UUENCODED line Where the lines are: SEGMENT begin line - Is the line that identifies the begining of a segment. HEADER ID line - One or more lines that contain segment number, total number of segments or the ID string in the article or mail header. BODY ID line - One or more lines that contain segment number, total number of segments or the ID string in the article or mail message body. UUENCODED line - Is the first uuencoded line in the file. UUencoded lines include the begin and end lines. ... - Indicates zero or more lines that can contain any information so long as they CANNOT be misidentified as SEGMENT begin, ID or UUENCODED lines. Notice that the ID information can be spread across multiple lines. A segment is assumed to end at the begining of the next segment, or at the end of the source file. An UNPOST source file contains one or more segments. UNPOST has three different modes, interpretation mode, concatenation mode and UU decoder mode. In all three modes, UNPOST can accept one or more input files. In the first mode, interpretation mode, UNPOST looks at segment header and body lines before the first UU encoded line, and attempts to extract three pieces of information from them: segment number, total number of segments that the binary was split into, and an ID string that is common to all segments. If UNPOST finds something that it considers to be an ID string, and a uuencoded line in the segment, but it does not find a segment number and number of segments, UNPOST assumes that the segment is a single segment binary posting (part 1 of 1). To aid in finding out what happened, in interpretation mode UNPOST will write a list of all the different ID strings and their respective segment lists to standard error or the file specified as the error file (see Standards section for details of what an ID string is). Any errors or warnings detected during processing will also be written to standard error or error file. In interpretation mode three other files can optionally be created. All three of these files will contain segments copied out of the source file, and none of these files will be created unless they are turned on and named by a command line switch. The first optional file that UNPOST can create for the user in interpretation mode is the text file (-t switch). This file will have copied to it all segments from the source file that do not contain uuencoded data. Segments that are part 0/# type segments that do not contain uuencoded data will NOT be copied to the text file. They are considered to be description segments, and they will be copied to the description file only if the -d switch is turned on. Also, all binary postings that have all of their segments present will have the segment header and body of segment #1 (up to and including the uuencode begin line) copied into the description file. The third optional file that can be created in interpretation mode is the incomplete or unused uuencode data segments file. This file contains all segments that have uuencoded data, that were not used in a succesful uudecoding. This file will only be created if the -i switch is present. The incompletes file allows the user to hand decode those binarys which could not be interpreted or decoded by UNPOST. Often times, a binary will have all of it's parts, but UNPOST will not be able to put them together because of differences in the ID string between segments, or problems with the part numbering information. The simplest way to solve these problems is to collect the incompletes, edit the ID lines to correct the problem, and rerun UNPOST on the incompletes file. In the second mode, catentation mode, UNPOST assumes that all of the segments in the source file between a uuencode begin and a uuencode end line are part of one binary posting and that the segments are in order. UNPOST scans from the begining of the file until it finds a uuencode begin line, and decodes from there (skipping over non- uuencoded lines such as segment header lines and signatures) until it finds a uuencode end line. In the last mode, UU decoder mode, UNPOST assumes that the source file contains one or more UU encoded files. Only UU encoded lines are allowed between the uuencode begin line and the uuencode end line of any single uuencoded file. Example header: (1) Article 2096 of alt.binaries.pictures.misc: Newsgroups: alt.binaries.pictures.misc Path: csn!csn!convex!cs.utexas.edu! From: a43xz@brain.ac.da (Joe User) (2) Subject: ship.gif (1/3) Organization: Somewhere Near The Sea. Date: Fri, 19 Feb 1993 06:43:48 GMT Message-ID: <21128@brain.ac.da> Sender: news@dep.rnsft.ac.da (Usenet) Lines: 761 Picture of a ship in a bottle, full rigged. How did it get there? (3) section 1 of uuencode 5.20 of file ship.gif by R.E.M. (4) begin 644 ship.gif M1TE&.#=A@`+@`9<```0$!`0$!",G,"LG)RLG,"LG.30G,#TG)RLP,"LP.3TG In the above example, line (1) is the SEGMENT begin line, line (2) is a HEADER ID line, line (3) is a BODY ID line and line (4) is the first UUENCODED line in the body. Options: -b[-] Set this flag to make UNPOST write the incomplete uuencoded segments to separate files. This defaults to off. -c To read and use a different configuration than the default configuration. The default configuration is stored in a file called def.cfg. -d[-] Turns on description capturing and writes descriptions to a file that has the same name as the output but with a .inf extension. This defaults to on. -e Redirects error and information output from standard error to . -f[-] Modify file names to be MS-DOS/USENET compatible. Use of -f turns file name modification on if the default is off, and -f- turns file name modification off if the default is on. File name modification is currently the default. -h Turns on full interpretation mode. This is the default. -i Turns on incomplete binaries capturing and writes the segments to file . -l |- Turns on multi-source file mode. This switch tells unpost that it can expect to find segments spread across multiple files. The file name contains the names of all files to process, and it must be formatted as one file name per line, with fully qualified path names to each file. The single character - means get the list of files from standard input. -o |- When selected, UNPOST will write the file names of successfully decoded binary files to the named file, or to standard out if the - is specified. -r [e|g|n|r] Where -re is for Email, -rg assumes that the NewsGroups: line is the first line of a segment, -rn configures UNPOST for the NN news reader, and -rr configures UNPOST for the RN news reader. -s Switch to ordered segment mode. This mode ignores segment headers, and assumes that the segments are in order. -t Turns on text only segment capturing and writes the segments to . -u Switch to uudecoder mode. Assume only uuencoded data between begin and end lines. Multiple uuencoded files are allowed. -v Show version number and quit. -? Show a summary of the command line switches. It is important to realize that UNPOST parses the command line in parallel with operations, so the order of the switches on the command line is VERY important. For example: unpost -d -e errors -i abpm.inc abpm.uue -c cbip.cfg -d- cbip.uue This will use the default configuration to process the file abpm.uue, writing out description files, writing errors to the file errors, and writing incompletes to the file abpm.inc. After UNPOST finishes processing abpm.uue, it will read in the cbip.cfg configuration, turn off writing description files and process cbip.uue. Note that the errors will continue to be written to the file errors, and that the incomplete binaries will continue to be written to the file abpm.inc. Since we are switching configurations, this is probably not a good idea. Standards: In all modes, UNPOST recognizes and decodes only uuencoded data. In interpretation mode UNPOST requires that: 1) The uuencoded lines be true uuencoded lines. This means that if trailing spaces are truncated by a mailer, editor or news node, UNPOST will not consider those lines to be uuencoded lines. Also, the uuencode character set recognized by UNPOST is ' ' - '`', with no other characters being legal. 2) That all segments of the same binary file posting have the same, recognizable ID string. 3) Segments have a recognizable SEGMENT begin line as the first line in the segment (denoting the begining of a segment). 4) That all ID lines follow the SEGMENT begin line in the segment. 5) That the first UUencoded line of the segment follows the last ID line. 6) That the first uuencode line in the first segment be a begin line. 7) That the last segment contain a uuencode end line. In sorted segment mode, UNPOST requires that: 1) The uuencoded lines be true uuencoded lines. This means that if trailing spaces are truncated by a mailer, editor or news node, UNPOST will not consider those lines to be uuencoded lines. Also, the uuencode character set recognized by UNPOST is ' ' - '`', with no other characters being legal. 2) That the segments be stored in the file in order. 3) That the first uuencode line in the first segment be a begin line. 4) That the last segment contain a uuencode end line. In uudecoder mode, UNPOST requires that: 1) There be only uuencoded lines between a uuencode begin and a uuencode end line. In this mode, UNPOST will recognize and attempt to repair lines that had trailing spaces truncated. Examples: To use UNPOST at it's most powerful: unpost source.uue UNPOST will search the file source.uue looking for the neccesary information to group, sort and uudecode ALL the binary postings saved to that file. In this mode (default interpretation mode) UNPOST can automatically group, sort and decode multiple postings. The file source.uue can be created by simply entering any news group, saving ALL unread articles from that news group (with headers) to the file source.uue. If you can get your news directly out of a spool directory, and each article is written to it's own file, use: ls -1 /usr/spool/. . ./* | unpost -e errors -i incomps -l - This will process multiple files (using the -l switch), write any errors to the file named errors and copy any articles that are part of incomplete or damaged postings to the file named incomps. Output: UNPOST will write diagnostic and informative messages to either standard error or the error file. The error file has three parts, interpretation errors (duplicate segments, missing uuencode begin lines, missing ID string, segment number or number of segments, etc.), a dump of the binaries found, the number of segments in each binary and the segment number and offset of each segment in the source file. The last part is a mixture of information (the name of the binary that UNPOST is attempting to decode) and any errors encountered during decoding. In the example below, UNPOST found one segment that had uuencoded data, the Subject: line had barber.gif as the ID string, the binary has one segment, and in the list of segments below, we see that segment number 1 starts at offset 583 in the source file. If there is a missing segment, it's segment number will be zero, and it's file offset will be zero. There were no interpretation errors, and there were no decoding errors. File ID Segments ---------------------------------------- barber.gif 1 1 583 Decoding Binary ID: 'barber.gif' Returns: UNPOST returns 0 for no errors, 1 for internal or resource allocation errors, 2 for failed to successfully decode everything found in the UU encoded source file. Warning: if the user gives multiple files to UNPOST to decode, and errors occur in unposting the first file, but not in the second, the return code will still indicate an error. I don't know if anybody is using Notes: To use this program to collect all of the binaries posted to, say, the alt.binaries.misc group on a daily basis, start up rn, go to the alt.binaries.misc newsgroup, and save all of the unread segments by using this command: .-$smisc.uue:j This will save all segments from the current number to the last to the file misc.uue, then junk them. After exiting rn, run UNPOST on the file misc.uue in interpretation mode (default mode): unpost -e errors -i misc.1 misc.uue Make sure to check the errors and/or misc.1 file for segments that UNPOST couldn't extract. Diagnostics: Error - file 'filename' already exists. UNPOST will not overwrite an existing file. Delete the file or rename it and try again. Error - missing begin line. UNPOST expected to find a uuencode begin line in this segment, but did not. Error - missing file name. The binary that UNPOST was attempting to decode does not seem to have a uuencode begin line in the first segment, so UNPOST has no idea what the file name is. Error - Could not open description file 'filename' for writing. UNPOST could not open a file of that name for some reason. Possibly a permission problem, or the file exists and is not writeable. Error - Bad write to binary file. A file write failed for some unknown reason. Possibly a full disk? Error - missing segment # Binary ID: 'binaryID' In attempting to decode a file whose ID string is binaryID, one or more segments are missing. Error - Missing UU end line. As this is the last segment, it ought to have a uuencode end line in it, but UNPOST did not find one. Warning - Early uuencode end line. UNPOST found a uuencode end line, but this was not the last segment, so we found it early. Did the poster screw up and misnumber his segments? Error - Unexpected UU begin line. We found an unexpected (read: this is not the first line of the first segment, so what is this doing here?) UU begin line. Error - cannot identify string '' in line # In reading in a configuration file, the configuration file lexical analyzer could not recognize this string. Error - Out of memory. Yup. Out of memory. Split the source file into smaller pieces and try again. Error - Could not modify file name to be MS-DOS conformant. File name mungling is turned on, and the name of one of the files cannot be made conformant (probably due to having to many numbers in it). Warning - Unexpected end of file in segment: Segment: 'segment line' File name mungling is turned on, and UNPOST is attempting to identify the file type (so it can use the proper extension when modifying the file name) but the UU begin line was the last line in the file. Warning - No UU line after begin. Segment: 'segment line' File name mungling is turned on, and UNPOST is attempting to identify the file type (so it can use the proper extension when modifying the file name) but the UU begin line was not followed by a line of UU encoded binary data. Error - Got number of segments but not segment number. Error - Got segment number but not number of segments. UNPOST must have all three pieces of relevant data, but if UNPOST has at least an ID string, UNPOST will attempt to assume a one part binary. Error - Could not get ID string. Fatal error, with no ID string, there is no way to collect the pieces together. Error - No begin line in first segment: Segment: 'segment line' UNPOST did not find a UU begin line in the first segment. Error - missing '}' in regular expression. In a regular expression of the type abc{1, 2}, the closing curly brace is missing. Error - To many sub-expressions. UNPOST has a limit on the number of sub-expressions it allows. This is a compile time option that can be changed by modifying the value of MAX_SUB_EXPRS in regexp.h. Error - missing ')' in regular expression. Mismatched parentheses. Error - badly formed regular expression. Unexpected character 'c' I give up! What is this character doing at this point in a regular expression? Error, can not enumerate a sub expression. Regular expressions of the type: (...)* are not allowed. Error - illegal regular expression node type. Whoops, we have an internal programmers error here. Let me know if you see this. Error - Sub expression # extraction failed. Another internal error that needs to be brought to my attention. Error - could not open file 'filename' for reading. UNPOST could not open file 'filename' for processing. Did you spellit right? Error - Unexpected end of file. Error - Unexpected UU begin line. Error - Segment number # greater than number of segments in: Segment: 'segment line' Either UNPOST got screwed up somehow or the poster posted something like (Part 10/9). Warning - duplicate segment # in: Binary ID: 'binaryID' UNPOST found two segments with the same binary ID and the same segment number. Error - reading source file. Could not read a line from the source file. Error - Could not open file 'filename' for output. Could not open one of the text, incomplete or error files for writing. Regular Expressions: Operands -------- UNPOST regular expressions have three types of operands, character strings (one or more characters), character sets and match any single character. A character string is any series of adjacent characters that are not not meta-characters (special characters). A data set is a string of characters enclosed in square braces with an optional caret (^) as the first character following the open square brace. The match any character operand matches any single character except the end of line character. A character string in a regular expression matches the exact string in the source, including case. Example of character strings: AirPlane - Matches the string 'AirPlane', but not the strings 'airPlane' or 'Airplane'. A character set will match any single character in the source if that character is a member of the set. If the first character of the set is the caret, the character set will match any character that is NOT a member of the set (including control characters!) except for NUL and LF. A character set can be described using ranges. Examples of character sets: [abcd] - Matches either a, b, c or d. [0-9] - Matches any decimal character. [^a-z] - Matches any character that is NOT a lower case alphabetic. The match any character operand does just that, it matches any character. But it does not match the case of no character, NUL or LF. Example of match any character: . - Matches any character. Operators --------- UNPOST regular expressions also contain operators. The operators that upost recognizes are the alternation operator, the span operators, the concatenation operator and the enumeration operators. The alternation operator has the lowest precedence of all the operators and its action is to attempt to match one of two alternatives. Example of alternation: Airplane|drigible - Matches either the string Airplane or the string drigible. The next higher precedence operator is the catenation operator. The catenation operator specifies that both the left and right hand regular expressions must match. The catenation operator does not have a special character, it is assumed to exist between two different operands that have no other operator between them. Example of catenation: [Aa]irplane - Matches either a 'A' or an 'a' followed by the string irplane. This is a catenation of the two regular expressions [Aa] and irplane. The next higher precedence operator is the enumeration operator. The enumeration operator specifies how many instances of a regular expression must be matched. Examples of Enumeration: abc* - Matches zero or more occurences of the string abc. [A-Z]+ - Matches one or more occurences of an upper case alphabetic character. [ ]? - Matches zero or one occurences of the space character. very{1} - Matches one or more occurences of the string very. b{1,3} - Matches a minimum of one to a maximum of three occurences of the string b. An enumeration operator attempts to match the largest source sub- string possible, except in the case of the . (match any character) followed by an enumeration operator. In this case, the smallest possible sub-string is matched. The precedence of the operators can be modified with the use of parentheses. Parentheses have another meaning as well, described below. Example of parenthesis use: Death( defying|wish) - Will match either the string 'Death defying' or the string 'Deathwish'. Without the parentheses, the regular expression would match either the string 'Death defying' or the string 'wish'. Sub Expressions --------------- UNPOST regular expressions are used primarily for identifying a particular line and extracting substrings from that line. To this end, UNPOST regular expressions support sub-expression marking. Subexpressions are marked by parentheses. To determine the sub-expression number of a sub-expression, scan the regular expression from left to right, counting the number of left parentheses. Start with one, and whatever the count for that sub-expression, is it's subexpression number. Example: .*((abcd)((0-9)+/(0-9)+)) Sub-expression ((abcd)((0-9)+/(0-9)+)) is sub-expression #1. Sub-expression (abcd) is #2. Sub-expression ((0-9)+/(0-9)+) is #3. Sub-expression (0-9)+ is #4. Sub-expression (0-9)+ is #5. Anchoring --------- Normally, a regular expression will match a sub-string any where in the source string. If you want to specify that the matching sub-string must start at the begining of the source string, you may use a caret character as the first character of the regular expression. This anchors the regular expression match to the start of the line. To anchor a regular expression to the end of a line, use the dollar sign character. This effectively matches the end of line or end of string character. Anchor operators have a higher precedence than alternation, but lower than catenation. Configuration: Ok, here's how to configure UNPOST to work for you. UNPOST relies heavily on regular expressions. These regular expressions may not be correct for your news reader, or system. There are five classes of regular expressions: 1) The SEGMENT begin line regular expression. 2) The ID line prefix regular expression. 3) The ID line with part description regular expression list. 4) The begin line regular expression. 5) The end line regular expression. Of these five, I don't expect you to have to modify the regular expressions for handling begin and end lines, because they should be correct for all uuencoders that follow the standard format. Be aware that UNPOST has a hierarchy of regular expressions. Each SEGMENT begin line regular expression has underneath it two lists of regular expressions that recognize ID line prefixes, and each element in the list of ID line prefix regular expressions has a list under it that attempts to parse the ID line. The two lists immediately under the SEGMENT begin line regular expression are for 1) the header and 2) the body. The ID line prefix regular expression exists for the sake of efficiency. It is used to find an ID line before we attempt to parse it. Modify or add one of these if you wish to change whether or not a line is recognized by UNPOST as being an ID line. If you modify this, you must modify the list of segment description regular expressions to match. The SEGMENT begin line regular expressions are used to find the begining of a SEGMENT, or the end of a previous segment. Modify these to change the line or lines that UNPOST recognizes as the begining of a segment. If you get an error message that indicates that the Subject line has no identifiable part description, and you see that some bright boy/girl has come up with a brand new part description format, then you have two choices, modify the source and hope they don't post again, or add a new ID line regular expression to the list of ID line regular expressions in the segment.c source file. Be aware that the lists of regular expressions are searched in order from top to bottom to find a match. This means that less specific regular expressions should be placed later in the list. For example: the regular expression '\((0-9)+/(0-9)+\)' should come before the regular expression '(0-9)+ (0-9)+' in the part syntax parsing regular expression list. This reduces the number of misparses that occur. Remember that C uses the backslash (\) as an escape character in strings, so to put a backslash into a regular expression you need to put two into the C source string. All regular expressions can be found at the top of the parse.c source file. Before you modify the actual source code and recompile, I strongly suggest that you test your new regular expression using the regular expression test harness (retest) that was compiled by the makefile when you compiled UNPOST. Then, when you are sure that it is correct, copy the def.cfg file to a new name, make your changes there and use that configuration file for a while. If after all this, you are sure that it works, go in and change the source code in parse.c. Before you add or modify a regular expression, you have to know the syntax of the regular expressions used in this program. The syntax is very similiar to that used by UN*X style regular expressions, but is not exactly the same. See the section titled Regular Expressions before attempting to configure UNPOST. Configuration Files: If you don't want to make permanent changes to UNPOST's configuration, you can make a configuration file. Configuration files are parsed by UNPOST, the regular expressions compiled, and these regular expressions control the operation of UNPOST completely. A configuration file must have the following syntax: segment "..." { header { "...." { "..." { id # segment number # segments # alternate id # case ignore|sensitive } } } body { "...." { "..." { id # segment number # segments # alternate id # case ignore|sensitive } } } } Where "..." is a regular expression string, # is a sub expression number (See the section on regular expressions), and case is either ignored in regular expression string matching, or string matching is case sensitive. The outer most construct, starting with the segment "..." line is used to describe how to recognize the begining of a segment. The two constructs at the first level within the segment construct are used to identify lines that are expected to contain part # of # of parts information in the header, or the body of an article. Within each header or body group are regular expressions that are used to parse out the part # of # of parts information from an identified information line. A very simple example (taken directly out of the MUFUD documentation): segment "^Article[:]?" { header { "^Subject:" { "^Subject:(.*)part[ ]+([0-9]+)[ ]*(of|/)[ ]*([0-9]+)(.*)" { id 1 segment number 2 segments 4 alternate id 5 case ignore } "^Subject:(.*)([0-9]+)[ ]*(of|/)[ ]*([0-9]+)(.*)" { id 1 segment number 2 segments 4 alternate id 5 case ignore } } } body { } } Where: id 1 Specifies the sub expression number of the sub expression that is used to extract the binary ID string. segment number 2 Specifies the sub expression number of the sub expression that is used to extract the segment number. segments 3 Specifies the sub expression number of the sub expression that is used to extract the number of segments that this binary was split into. alternate id 4 Specifies the alternate sub expression number. If the first ID sub expression extracts only an empty string (or one with all white space), the string extracted by this sub expression is used to generate the binary ID string. case ignore Specifies that the case of alphabetical characters is to be ignored in regular expression string matching. See the def.cfg file for another (more complete) example. Default Binary Switch Settings: To modify the default values of the binary switches, edit the file compiler.h, and change the value of the defines. There are defines for file name mungling, breaking incompletes into separate files and for dumping out description files. Bugs: This program has been pretty extensively tested in interpretation mode, and it appears to be both robust and flexible. Unfortunately, about once a week, somebody comes up with a new and unusual way to encode the parts description on the Subject line. Bugs, after being found, are chased unmercifully and terminated with extreme prejudice. If you think you've found one, send all information opinions, prejudices and critcisms to me, and the hunt will begin (just as soon as I can put on my safari hat and grab my debugger. . .). Rights, Copyright, Legal stuff, etc: This program is distributed free of charge, but it has NOT been placed in the public domain! I retain copyright. Why? Because I am pathologically commited to producing and maintaining a quality product, and if every Tom, Dick and Susan modifies UNPOST and redistributes, I will not be able to respond to bug reports or continue to upgrade the product (branch revision problem, and all that. . .). My job isn't done so long as a single bug exists, or even one user is unhappy (or even one system is uninfected. . . er, that is to say, supported :-). However, I am also dedicated to the principle of maximum use. If you wish, you may modify anything in this program you want to. That's why I distribute source. BUT, you may NOT distribute your changes, unless you can be legally sure that you have made so many as to make what you distribute a new work. If you learn any bad habits from reading my source code, tough luck. And if anything in this section is not legally supportable, the joke's on me. Don't bother telling me, I'm to busy coding (So THERE!). Author: John W. M. Stevens - jstevens@csn.org unpost/segment.c100644 23453 0 111103 5543402240 13624 0ustar jeanpaulsystem/****************************************************************************** * Module : Segment --- Find the segments of the posted file. * * Author : John W. M. Stevens ******************************************************************************/ #include "compiler.h" #include "unpost.h" #include "list.h" #include "modflnm.h" #include "parse.h" #include "decode.h" #include "uudec.h" #include "segment.h" #include "utils.h" /* Segment types. */ typedef enum { SEG_USED, /* Used in succesful decoding. */ SEG_TEXT, /* Pure text segment. */ SEG_INCOMP, /* Segment that is part of incomplete posting. */ SEG_DESC /* Segment is a description. */ } SEG_TYPE; /* Segment list structure. */ typedef struct { char *SrcFlNm; /* Source file name. */ long LnOfs; /* Byte offset to start of SEGMENT. */ int CopyFlag; /* Copy out flag. */ } SEG_LIST; /* Line and string buffers. */ char SegLine[BFR_SIZE]; char IDLine[BFR_SIZE]; char UULine[BFR_SIZE]; char InBfr[BFR_SIZE]; BYTE OutBfr[BFR_SIZE]; /*----------------------------------------------------------------------------- | Routine : UUDecode() --- Decode a UU encoded file. | | Inputs : FlName - Name of input file. -----------------------------------------------------------------------------*/ int UUDecode(char *InFlNm) { auto FILE *InFlPtr; auto FILE *OutFlPtr; auto int OutLen; auto char **RetStrs; auto char FlName[FL_NM_SZ]; /* Externals used by this function. */ extern FILE *ErrFile; /* Open file. */ if ((InFlPtr = fopen(InFlNm, BIN_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' for reading.\n", __FILE__, __LINE__, InFlNm); return( 2 ); } /* Get all uuencoded files from single file. */ while (! feof( InFlPtr )) { /* Search forwards through the file for the first * UU encoded line. */ do { /* Get a line from the file. */ if (ReadLine(InFlPtr, InBfr, BFR_SIZE) == EOF) { fclose( InFlPtr ); return( 0 ); } } while (! MatchBegin(InBfr, &RetStrs)); /* Get the binary file name. */ GetBinFlNm(InFlPtr, RetStrs, FlName); /* Check to make sure that file does not already exist. */ if ( FileExists( FlName ) ) { fprintf(ErrFile, "%s %d : Error - file '%s' already exists.\n", __FILE__, __LINE__, FlName); fclose( InFlPtr ); return( 2 ); } /* Open the file. */ if ((OutFlPtr = fopen(FlName, BIN_WRITE)) == NULL) { fprintf(ErrFile, "%s %d : Error - %s\n\t'%s'\n", __FILE__, __LINE__, strerror( errno ), FlName); fclose( InFlPtr ); return( 2 ); } /* It exists, is open, and ready to roll. Now decode to * end line. */ while (ReadLine(InFlPtr, InBfr, BFR_SIZE) != EOF) { /* Test for end line. */ if ( MatchEnd( InBfr ) ) break; /* Space pad line, if necesary. */ DecTruncUULn(InBfr, &OutLen, OutBfr); /* Are there any bytes to write? */ if (OutLen < 1) continue; /* Write the buffer to the output file. */ if (fwrite(OutBfr, 1, OutLen, OutFlPtr) != OutLen) { fprintf(ErrFile, "\t%s %d : Error - Bad write to binary file.\n", __FILE__, __LINE__); exit( 1 ); } } /* Close output file. */ fclose( OutFlPtr ); } /* Close input file. */ fclose( InFlPtr ); return( 0 ); } /*----------------------------------------------------------------------------- | Routine : Single() --- Decode binarys, assumed to be in sorted order. | already. | | Inputs : FileNm - Name of file that contains single binary. -----------------------------------------------------------------------------*/ int Single(char *FileNm) { auto int RetVal; auto long LnOfs; auto CHK_UU_ENC UULnType; auto char **RetStrs; auto int OutLen; auto FILE *InFlPtr; auto FILE *OutFlPtr; auto char FlName[FL_NM_SZ]; /* Externals used by this function. */ extern FILE *ErrFile; /* Open file. */ RetVal = 0; if ((InFlPtr = fopen(FileNm, BIN_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' for reading.\n", __FILE__, __LINE__, FileNm); return( 2 ); } /* Get all uuencoded files from single file. */ while (! feof( InFlPtr )) { /* Search forwards through the file for the first UU encoded line. */ do { /* Get the current file offset. */ LnOfs = ftell( InFlPtr ); /* Get a line from the file. */ if (ReadLine(InFlPtr, InBfr, BFR_SIZE) == EOF) { fclose( InFlPtr ); return( 0 ); } /* Check to see if this is a UUencoded line. */ UULnType = ChkUULine(InBfr, &RetStrs, &OutLen); } while (UULnType != UU_BEGIN); /* Get the binary file name. */ UnExpectedBegin: GetBinFlNm(InFlPtr, RetStrs, FlName); /* Check to make sure that file does not already exist. */ if ( FileExists( FlName ) ) { fprintf(ErrFile, "%s %d : Error - file '%s' already exists.\n", __FILE__, __LINE__, FlName); RetVal = 2; continue; } /* Open the file. */ if ((OutFlPtr = fopen(FlName, BIN_WRITE)) == NULL) { fprintf(ErrFile, "%s %d : Error - %s\n\t'%s'\n", __FILE__, __LINE__, strerror( errno ), FlName); RetVal = 2; continue; } /* Now munch and crunch until done with file. */ do { /* Decode a segment. */ DecSeg(InFlPtr, OutFlPtr, &UULnType); /* Check for proper exit conditions. */ if (UULnType == UU_BEGIN || UULnType == UU_END) break; /* Scan to next UU encoded line. */ do { /* Get the current file offset. */ LnOfs = ftell( InFlPtr ); /* Get next line. */ if (ReadLine(InFlPtr, InBfr, BFR_SIZE) == EOF) { fprintf(ErrFile, "%s %d : Error - Unexpected end of file.\n", __FILE__, __LINE__); fclose( InFlPtr ); fclose( OutFlPtr ); return( 2 ); } /* Check to see if this is a UUencoded line. */ UULnType = ChkUULine(InBfr, &RetStrs, &OutLen); } while (UULnType == NOT_UU_LINE || UULnType == UU_SPACE); /* Reset file pointer to begining of UU line. */ if (fseek(InFlPtr, LnOfs, SEEK_SET) != 0) { fprintf(ErrFile, "%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); exit( 1 ); } } while (UULnType == IS_UU_LINE); /* Close the output file pointer. */ fclose( OutFlPtr ); /* Check the various types. */ if (UULnType == UU_BEGIN) { fprintf(ErrFile, "%s %d : Error - Unexpected UU begin line.\n", __FILE__, __LINE__); goto UnExpectedBegin; } } /* Close the files. */ fclose( InFlPtr ); return( RetVal ); } /*----------------------------------------------------------------------------- | Routine : CmpFl() --- Compare two file list entries. | | Inputs : File1 - File entry one. | File2 - File entry two. -----------------------------------------------------------------------------*/ static int CmpFl(void *File1, void *File2) { return( strcmp(((FL_LIST *) File1)->IDString, ((FL_LIST *) File2)->IDString) ); } /*----------------------------------------------------------------------------- | Routine : DumpSeg() --- Dump a segment to a file. | | Inputs : InFlPtr - File to read segment from (source file). | OutFlPtr - File to write segment to. | NextSeg - Start of next segment. -----------------------------------------------------------------------------*/ static void DumpSeg(FILE *InFlPtr, FILE *OutFlPtr, long NextSeg) { /* Dump segment to output file. */ while (ReadLine(InFlPtr, SegLine, BFR_SIZE) != EOF) { /* Print line. */ fprintf(OutFlPtr, "%s\n", SegLine); /* Get next line offset. */ if (ftell( InFlPtr ) == NextSeg) break; } } /*----------------------------------------------------------------------------- | Routine : Interpret() --- Interpret a file. | | Inputs : FileNm - Name of source file to unpost. | | Notes : This routine expects the source file to have header | information. -----------------------------------------------------------------------------*/ static LIST *FileList; /* File list pointer. */ static LIST *SegList; /* Segment list per file. */ static int Interpret(char *FileNm) { auto FILE *InFlPtr; auto long LnOfs; auto int InsPt; auto int RetVal; auto SEG_INFO SegInfo; auto FL_LIST *FlPtr; auto FL_LIST NewFile; auto SEG_LIST NewSeg; /* Buffers for input and output. */ extern FILE *ErrFile; /* Open file. */ if ((InFlPtr = fopen(FileNm, BIN_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' for reading.\n", __FILE__, __LINE__, FileNm); return( 2 ); } /* Search for all ID lines, building a list of all * files and their segments as we go. */ RetVal = 0; while (! feof( InFlPtr )) { /* Parse article information out of the file. */ memset(&SegInfo, 0, sizeof( SEG_INFO )); LnOfs = Parse(InFlPtr, SegLine, IDLine, &SegInfo); #if defined(UNPOST_DEBUG) printf("\n\tSegInfo:\n"); printf("\t--------\n"); printf("\tNumber of Segments: %d\n", SegInfo.NoSegs); printf("\tSegment Number : %d\n", SegInfo.SegNo); printf("\tSegment Offset : %ld\n", SegInfo.SegOfs); printf("\tUUencode Offset : %ld\n", SegInfo.UUOfs); if ( SegInfo.ChkCRC ) printf("\tPOST CRC Value : 0x%08lx\n", SegInfo.PostCRC); printf("\tBinary ID String : '%s'\n", (SegInfo.IDString == NULL) ? "NULL POINTER" : SegInfo.IDString); printf("\tBinary File Name : '%s'\n\n", (SegInfo.FlName == NULL) ? "NULL POINTER" : SegInfo.FlName); switch ( LnOfs ) { case -1L: printf("\tPRS_NO_SEGMENT\n"); break; case -2L: printf("\tPRS_NO_ID_STR\n"); break; case -3L: printf("\tPRS_NO_UU_LN\n"); break; case -4L: printf("\tPRS_NO_BEGIN\n"); break; case -5L: printf("\tPRS_NO_SEG_NUM\n"); break; case -6L: printf("\tPRS_NO_NUM_SEGS\n"); break; case -7L: printf("\tPRS_UNX_END_SEG\n"); break; } #endif /* Save the segment data. */ NewSeg.LnOfs = SegInfo.SegOfs; NewSeg.SrcFlNm = StrDup( FileNm ); /* Check for errors. */ if (LnOfs == PRS_NO_SEGMENT) break; else if (LnOfs == PRS_NO_UU_LN) { /* Check to see if this is a description segment. */ if (SegInfo.IDString && *SegInfo.IDString && SegInfo.SegNo == 0 && SegInfo.NoSegs > 0) { /* This has part numbering info, and the part number * is zero, but it has no uuencoded data, so this * must be a description segement. */ NewSeg.CopyFlag = SEG_DESC; } else { /* Save as text segment. */ NewSeg.CopyFlag = SEG_TEXT; SegList = AppList(SegList, &NewSeg); /* If the file name or ID string exist, deallocate. */ if ( SegInfo.IDString ) free( SegInfo.IDString ); continue; } } else if (LnOfs == PRS_NO_SEG_NUM || LnOfs == PRS_NO_NUM_SEGS || SegInfo.IDString == NULL || *SegInfo.IDString == '\0') { /* Something important is missing. Do NOT attempt to * put one of these in the file list. */ NewSeg.CopyFlag = SEG_INCOMP; SegList = AppList(SegList, &NewSeg); RetVal = 2; /* If the file name or ID string exist, deallocate. */ if ( SegInfo.IDString ) free( SegInfo.IDString ); continue; } else NewSeg.CopyFlag = SEG_INCOMP; /* Add segment to list. */ SegList = AppList(SegList, &NewSeg); /* Search file list for ID string. */ NewFile.IDString = SegInfo.IDString; if (SrchList(FileList, &NewFile, CmpFl, &InsPt) == FALSE) { /* Did not find file in list, add a new file. First, * allocate segments buffer. */ if ((NewFile.Segs = (SEGS *) calloc(SegInfo.NoSegs + 1, sizeof( SEGS ))) == NULL) { fprintf(ErrFile, "%s %d : Error - out of memory.\n", __FILE__, __LINE__); exit( 1 ); } /* We have a valid ID line, and at least one UUencoded * line, so add this segment to the list. */ NewFile.NoSegs = SegInfo.NoSegs; NewFile.FlName = NULL; NewFile.Success = 0; NewFile.ChkCRC = SegInfo.ChkCRC; NewFile.PostCRC = SegInfo.PostCRC; FileList = AddList(FileList, &NewFile, InsPt); } else free( SegInfo.IDString ); FlPtr = ListIdx(FileList, InsPt); /* Check for irreconcilable differences. */ if (FlPtr->NoSegs < SegInfo.SegNo) { fprintf(ErrFile, "%s %d : Error - Segment number #%d greater than number", __FILE__, __LINE__, SegInfo.SegNo); fprintf(ErrFile, " of segments in:\n\tSegment: '%s'\n", SegLine); RetVal = 2; } else { /* Check CRC stuff. */ if ( FlPtr->ChkCRC ) { /* Check for CRC. */ if (! SegInfo.ChkCRC) { fprintf(ErrFile, "%s %d : Warning - POST CRC expected, ", __FILE__, __LINE__); fprintf(ErrFile, "but missing in segment #%d.\n", SegInfo.SegNo); RetVal = 2; } else if (SegInfo.PostCRC != FlPtr->PostCRC) { fprintf(ErrFile, "%s %d : Warning - POST CRC changed in ", __FILE__, __LINE__); fprintf(ErrFile, " segment #%d.\n", SegInfo.SegNo); RetVal = 2; } } /* Save the offset in the proper segment location. */ if (FlPtr->Segs[SegInfo.SegNo].SegNo != 0) { fprintf(ErrFile, "%s %d : Warning - duplicate segment #%d in:\n", __FILE__, __LINE__, SegInfo.SegNo); fprintf(ErrFile, "\tBinary ID: '%s'\n", FlPtr->IDString); RetVal = 2; } /* Set up file descriptor segment. */ FlPtr->Segs[SegInfo.SegNo].SrcFlNm = NewSeg.SrcFlNm; FlPtr->Segs[SegInfo.SegNo].Exists = 1; FlPtr->Segs[SegInfo.SegNo].SegNo = SegInfo.SegNo; FlPtr->Segs[SegInfo.SegNo].SegOfs = SegInfo.SegOfs; FlPtr->Segs[SegInfo.SegNo].UUOfs = SegInfo.UUOfs; FlPtr->Segs[SegInfo.SegNo].SegLstOrd = SegList->NoElems - 1; } /* Add the file name string, if it isn't already present. */ if ( FlPtr->FlName ) free( SegInfo.FlName ); else if ( SegInfo.FlName ) FlPtr->FlName = SegInfo.FlName; } /* Close the source file. */ fclose( InFlPtr ); return( RetVal ); } /*----------------------------------------------------------------------------- | Routine : Multiple() --- Extract multiple postings from one file. | | Inputs : FileNm - Name of file to unpost. -----------------------------------------------------------------------------*/ int Multiple(char *FileNm) { register int i; register int j; auto int RetVal; auto FILE *InFlPtr; auto FILE *OutFlPtr; auto FL_LIST *FlPtr; auto SEG_LIST *SegPtr; /* Buffers for input and output. */ extern int MsDosFileNms; extern int DumpDesc; extern int SepIncomps; extern FILE *ErrFile; extern FILE *TextFile; extern FILE *IncompFile; extern FILE *UnPstdFile; /* Allocate a file and a segment list. */ FileList = CrtList( sizeof( FL_LIST ) ); SegList = CrtList( sizeof( SEG_LIST ) ); /* Interpret the file. */ RetVal = Interpret( FileNm ); /* Dump Table. */ fprintf(ErrFile, "File ID Segments\n"); fprintf(ErrFile, "----------------------------------------\n"); for (i = 0; i < FileList->NoElems; i++) { FlPtr = ListIdx(FileList, i); fprintf(ErrFile, "%-30.30s %d\n", FlPtr->IDString, FlPtr->NoSegs); for (j = 1; j <= FlPtr->NoSegs; j++) fprintf(ErrFile, "\t%3d %9ld\n", FlPtr->Segs[j].SegNo, FlPtr->Segs[j].SegOfs); } fprintf(ErrFile, "\n"); /* Open file. */ if ((InFlPtr = fopen(FileNm, BIN_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' for reading.\n", __FILE__, __LINE__, FileNm); return( 2 ); } /* Decode the files. */ for (i = 0; i < FileList->NoElems; i++) { /* Get pointer to file list entry. */ FlPtr = ListIdx(FileList, i); /* Report binary id you are attempting to decode. */ fprintf(ErrFile, "Decoding Binary ID: '%s'\n", FlPtr->IDString); /* Attempt to decode the file. */ if (DeCode(InFlPtr, FlPtr) == OK) { /* Print the name of the file successfully decoded * to the successfully decoded files name file (if * specified. */ if ( UnPstdFile ) { fprintf(UnPstdFile, "%s\n", FlPtr->FlName); } /* Scan segment list, marking all segments as having been * successfully used. */ FlPtr->Success = 1; for (j = 1; j <= FlPtr->NoSegs; j++) { SegPtr = ListIdx(SegList, FlPtr->Segs[j].SegLstOrd); SegPtr->CopyFlag = SEG_USED; } } else RetVal = 2; } /* Do we want to save incomplete pieces? */ if (IncompFile || SepIncomps) { /* Write incomplete binaries to uuencoded file in sorted * order. */ for (i = 0; i < FileList->NoElems; i++) { auto long EndOfs; /* Get pointer to file. */ FlPtr = ListIdx(FileList, i); if ( FlPtr->Success ) continue; /* Open file to write segments to, or use incompletes * file. */ if (SepIncomps && FlPtr->IDString && *FlPtr->IDString) { /* Use the binary ID string to create a .uue file name. */ if ( MsDosFileNms ) ModifyFlNm(FlPtr->IDString, ".uue", InBfr); else ModExten(FlPtr->IDString, ".uue", InBfr); /* Open incompletes file. */ if ((OutFlPtr = fopen(InBfr, TXT_APPEND)) == NULL) { fprintf(ErrFile, "%s %d : Error - File '%s' cannot be opened ", __FILE__, __LINE__, InBfr); fprintf(ErrFile, "for appending.\n"); RetVal = 2; continue; } } else OutFlPtr = IncompFile; /* This file was NOT successfully converted, write it's * segments out to the incomplete file. */ for (j = 0; j <= FlPtr->NoSegs; j++) { /* If this segment does not exist, do not copy it. */ if (! FlPtr->Segs[j].Exists) continue; else if (j == 0 && ! DumpDesc) continue; /* Position file pointer to first line of segment. */ if (fseek(InFlPtr, FlPtr->Segs[j].SegOfs, SEEK_SET) != 0) { fprintf(ErrFile, "%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); exit( 1 ); } /* Mark this segment as having been dumped out. */ SegPtr = ListIdx(SegList, FlPtr->Segs[j].SegLstOrd); SegPtr->CopyFlag = SEG_USED; /* Get offset for end of segment. */ if (FlPtr->Segs[j].SegLstOrd + 1 < SegList->NoElems) EndOfs = SegPtr[1].LnOfs; else EndOfs = -1L; /* Write all of segment to file. */ DumpSeg(InFlPtr, OutFlPtr, EndOfs); } /* Check to see if we need to close the file. */ if (OutFlPtr != IncompFile) fclose( OutFlPtr ); } } /* Check to make sure that the user has requested that unused * segments be dumped out to ANY file. */ if (TextFile || IncompFile) { /* Dump unused segments to file. */ for (i = 0, SegPtr = ListIdx(SegList, 0); i < SegList->NoElems; i++, SegPtr++) { /* If this segment was successfully converted, do not * copy it. */ if (SegPtr->CopyFlag == SEG_USED) continue; /* Position file pointer to first UUencoded * line of segment. */ if (fseek(InFlPtr, SegPtr->LnOfs, SEEK_SET) != 0) { fprintf(ErrFile, "%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); exit( 1 ); } /* Read and write lines. */ if (SegPtr->CopyFlag == SEG_TEXT && TextFile) { /* Dump the segment out to the text file. */ DumpSeg(InFlPtr, TextFile, (i < SegList->NoElems - 1) ? SegPtr[1].LnOfs : -1L); } else if (SegPtr->CopyFlag == SEG_INCOMP && IncompFile) { /* Dump the segment out to the text file. */ DumpSeg(InFlPtr, IncompFile, (i < SegList->NoElems - 1) ? SegPtr[1].LnOfs : -1L); } } } /* Deallocate file descriptor list. */ for (i = 0; i < FileList->NoElems; i++) { /* Get pointer to file list entry. */ FlPtr = ListIdx(FileList, i); /* Deallocate the heap memory. */ if ( FlPtr->Segs ) free( FlPtr->Segs ); if ( FlPtr->FlName ) free( FlPtr->FlName ); if ( FlPtr->IDString ) free( FlPtr->IDString ); } /* Free the list. */ free( FileList ); free( SegList ); fclose( InFlPtr ); return( RetVal ); } /*----------------------------------------------------------------------------- | Routine : MultiFile() --- Extract multiple postings from one multiple | files. | | Inputs : FileNm - Name of file to unpost. -----------------------------------------------------------------------------*/ int MultiFile(FILE *FlsPtr) { register int i; register int j; auto int RetVal; auto FILE *InFlPtr; auto FILE *OutFlPtr; auto char FileNm[FL_NM_SZ]; auto FL_LIST *FlPtr; auto SEG_LIST *SegPtr; auto IDENT *Hdr; auto IDENT *Body; /* Buffers for input and output. */ extern int MsDosFileNms; extern int DumpDesc; extern int SepIncomps; extern FILE *ErrFile; extern FILE *TextFile; extern FILE *IncompFile; extern FILE *UnPstdFile; /* Allocate a file and a segment list. */ FileList = CrtList( sizeof( FL_LIST ) ); SegList = CrtList( sizeof( SEG_LIST ) ); /* Interpret the file. */ RetVal = 0; while (ReadLine(FlsPtr, FileNm, FL_NM_SZ) == OK) if ((i = Interpret( FileNm )) != 0 && RetVal == 0) RetVal = i; /* Dump Table. */ fprintf(ErrFile, "File ID Segments\n"); fprintf(ErrFile, "----------------------------------------\n"); for (i = 0; i < FileList->NoElems; i++) { FlPtr = ListIdx(FileList, i); fprintf(ErrFile, "%-30.30s %d\n", FlPtr->IDString, FlPtr->NoSegs); for (j = 1; j <= FlPtr->NoSegs; j++) fprintf(ErrFile, "\t%3d %9ld %s\n", FlPtr->Segs[j].SegNo, FlPtr->Segs[j].SegOfs, (FlPtr->Segs[j].SrcFlNm) ? FlPtr->Segs[j].SrcFlNm : ""); } fprintf(ErrFile, "\n"); /* Decode the files. */ for (i = 0; i < FileList->NoElems; i++) { /* Get pointer to file list entry. */ FlPtr = ListIdx(FileList, i); /* Report binary id you are attempting to decode. */ fprintf(ErrFile, "Decoding Binary ID: '%s'\n", FlPtr->IDString); /* Attempt to decode the file. */ if (MultiDeCode( FlPtr ) == OK) { /* Print the name of the file successfully decoded * to the successfully decoded files name file (if * specified. */ if ( UnPstdFile ) { fprintf(UnPstdFile, "%s\n", FlPtr->FlName); } /* Scan segment list, marking all segments as having been * successfully used. */ FlPtr->Success = 1; for (j = 1; j <= FlPtr->NoSegs; j++) { SegPtr = ListIdx(SegList, FlPtr->Segs[j].SegLstOrd); SegPtr->CopyFlag = SEG_USED; } } else RetVal = 2; } /* Do we want to save incomplete pieces? */ if (IncompFile || SepIncomps) { /* Write incomplete binaries to uuencoded file in sorted * order. */ for (i = 0; i < FileList->NoElems; i++) { /* Get pointer to file. */ FlPtr = ListIdx(FileList, i); if ( FlPtr->Success ) continue; /* Open file to write segments to, or use incompletes * file. */ if (SepIncomps && FlPtr->IDString && *FlPtr->IDString) { /* Use the binary ID string to create a .uue file name. */ if ( MsDosFileNms ) ModifyFlNm(FlPtr->IDString, ".uue", InBfr); else ModExten(FlPtr->IDString, ".uue", InBfr); /* Open incompletes file. */ if ((OutFlPtr = fopen(InBfr, TXT_APPEND)) == NULL) { fprintf(ErrFile, "%s %d : Error - File '%s' cannot be opened ", __FILE__, __LINE__, InBfr); fprintf(ErrFile, "for appending.\n"); RetVal = 2; continue; } } else OutFlPtr = IncompFile; /* This file was NOT successfully converted, write it's * segments out to the incomplete file. */ for (j = 0; j <= FlPtr->NoSegs; j++) { /* If this segment does not exist, do not copy it. */ if (! FlPtr->Segs[j].Exists) continue; else if (FlPtr->Segs[j].SrcFlNm == NULL) continue; /* Open input file. */ if ((InFlPtr = fopen(FlPtr->Segs[j].SrcFlNm, BIN_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' ", __FILE__, __LINE__, FlPtr->Segs[j].SrcFlNm); fprintf(ErrFile, "for reading.\n"); RetVal = 2; continue; } /* Position file pointer to first line of segment. */ if (fseek(InFlPtr, FlPtr->Segs[j].SegOfs, SEEK_SET) != 0) { fprintf(ErrFile, "%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); exit( 1 ); } /* Mark this segment as having been dumped out. */ SegPtr = ListIdx(SegList, FlPtr->Segs[j].SegLstOrd); SegPtr->CopyFlag = SEG_USED; /* Get and dump lines until the next segment is seen * or until end of file. */ if (ReadLine(InFlPtr, SegLine, BFR_SIZE) != EOF) { /* Print the line. */ fprintf(OutFlPtr, "%s\n", SegLine); /* Print description. */ while (ReadLine(InFlPtr, SegLine, BFR_SIZE) != EOF) { /* Is this a SEGMENT begin line? */ if ( MatchSegment(SegLine, &Hdr, &Body) ) break; /* Print the line. */ fprintf(OutFlPtr, "%s\n", SegLine); } } } /* Check to see if we need to close the file. */ if (OutFlPtr != IncompFile) fclose( OutFlPtr ); fclose( InFlPtr ); } } /* Check to make sure that the user has requested that unused * segments be dumped out to ANY file. */ if ( TextFile ) { /* Dump text segments to file. */ for (i = 0, SegPtr = ListIdx(SegList, 0); i < SegList->NoElems; i++, SegPtr++) { /* If this segment was successfully converted, do not * copy it. */ if (SegPtr->CopyFlag != SEG_TEXT) continue; else if (SegPtr->SrcFlNm == NULL) continue; /* Open input file. */ if ((InFlPtr = fopen(SegPtr->SrcFlNm, BIN_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' ", __FILE__, __LINE__, SegPtr->SrcFlNm); fprintf(ErrFile, "for reading.\n"); RetVal = 2; continue; } /* Position file pointer to first line of segment. */ if (fseek(InFlPtr, SegPtr->LnOfs, SEEK_SET) != 0) { fprintf(ErrFile, "%s %d : Error - %s\n", __FILE__, __LINE__, strerror( errno )); exit( 1 ); } /* Get lines and dump to text file. */ if (ReadLine(InFlPtr, SegLine, BFR_SIZE) != EOF) { /* Print the line. */ fprintf(TextFile, "%s\n", SegLine); /* Get and dump lines until the next segment is seen * or until end of file. */ while (ReadLine(InFlPtr, SegLine, BFR_SIZE) != EOF) { /* Is this a SEGMENT begin line? */ if ( MatchSegment(SegLine, &Hdr, &Body) ) break; /* Print the line. */ fprintf(TextFile, "%s\n", SegLine); } } /* Mark this segment as having been dumped out. */ SegPtr->CopyFlag = SEG_USED; fclose( InFlPtr ); } } /* Deallocate file descriptor list. */ for (i = 0; i < FileList->NoElems; i++) { /* Get pointer to file list entry. */ FlPtr = ListIdx(FileList, i); /* Deallocate the heap memory. */ if ( FlPtr->Segs ) free( FlPtr->Segs ); if ( FlPtr->FlName ) free( FlPtr->FlName ); if ( FlPtr->IDString ) free( FlPtr->IDString ); } /* Free the list. */ free( FileList ); free( SegList ); return( RetVal ); } unpost/segment.h100644 23453 0 776 5543402242 13570 0ustar jeanpaulsystem/****************************************************************************** * Module : Segmemt header file. * * Author : John W. M. Stevens ******************************************************************************/ #if ! defined(SEGMENT_HEADER_FILE) #define SEGMENT_HEADER_FILE /* Function prototypes. */ extern int Single(char *FileNm); extern int Multiple(char *FileNm); extern int UUDecode(char *FlName); extern int MultiFile(FILE *FlsPtr); #endif unpost/makefils/ 40755 23453 0 0 5613467457 13502 5ustar jeanpaulsystemunpost/makefils/borland.mkf100644 23453 0 2517 5504043656 15712 0ustar jeanpaulsystem#****************************************************************************** # Module : Makefile for UnPost utility. (MS-DOS, Borland C++ 3.0) # # Author : John W. M. Stevens #****************************************************************************** CC_FLAGS = -w -ml -DSYSTEM_MS_DOS -DBCC_COMPILER .c.obj: bcc -c $(CC_FLAGS) $< all: retest.exe unpost.exe retest.exe: recomp.obj rematch.obj retest.obj sets.obj utils.obj bcc $(CC_FLAGS) retest.obj recomp.obj rematch.obj sets.obj utils.obj unpost.exe: calccrc.obj config.obj decode.obj ident.obj lex.obj \ list.obj modflnm.obj parse.obj recomp.obj rematch.obj \ segment.obj sets.obj unpost.obj utils.obj uudec.obj tlink @&&! /x c0l.obj + calccrc.obj config.obj decode.obj ident.obj lex.obj+ list.obj modflnm.obj parse.obj recomp.obj rematch.obj+ segment.obj sets.obj unpost.obj utils.obj uudec.obj $* $* mathl.lib cl.lib emu.lib ! calccrc.obj: calccrc.c config.obj: config.c decode.obj: decode.c ident.obj: ident.c lex.obj: lex.c list.obj: list.c modflnm.obj: modflnm.c parse.obj: parse.c recomp.obj: recomp.c rematch.obj: rematch.c segment.obj: segment.c sets.obj: sets.c unpost.obj: unpost.c utils.obj: utils.c uudec.obj: uudec.c unpost/makefils/sun_gcc.mkf100644 23453 0 2316 5504043756 15710 0ustar jeanpaulsystem#****************************************************************************** # Module : Makefile for UnPost utility. (GCC on Sun 4) # # Author : John W. M. Stevens #****************************************************************************** CC_FLAGS = -ansi -DGCC_COMPILER .c.o: gcc -c $(CC_FLAGS) $< all: retest client unpost retest: recomp.o rematch.o retest.o sets.o utils.o gcc $(CC_FLAGS) -o retest retest.o recomp.o rematch.o sets.o utils.o client: recomp.o rematch.o sets.o utils.o client.o gcc $(CC_FLAGS) -o client client.o recomp.o rematch.o sets.o utils.o unpost: calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o gcc -o unpost calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o calccrc.o: calccrc.c config.o: config.c decode.o: decode.c ident.o: ident.c lex.o: lex.c list.o: list.c modflnm.o: modflnm.c parse.o: parse.c recomp.o: recomp.c rematch.o: rematch.c segment.o: segment.c sets.o: sets.c unpost.o: unpost.c utils.o: utils.c uudec.o: uudec.c unpost/makefils/apollo.mkf100644 23453 0 2272 5504043642 15550 0ustar jeanpaulsystem#****************************************************************************** # Module : Makefile for UnPost utility. (HP Apollo 700) # # Author : John W. M. Stevens #****************************************************************************** CC_FLAGS = -Aa .c.o: cc -c $(CC_FLAGS) $< all: retest client unpost retest: recomp.o rematch.o retest.o sets.o utils.o cc $(CC_FLAGS) -o retest retest.o recomp.o rematch.o sets.o utils.o client: recomp.o rematch.o sets.o utils.o client.o cc $(CC_FLAGS) -o client client.o recomp.o rematch.o sets.o utils.o unpost: calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o cc -o unpost calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o calccrc.o: calccrc.c config.o: config.c decode.o: decode.c ident.o: ident.c lex.o: lex.c list.o: list.c modflnm.o: modflnm.c parse.o: parse.c recomp.o: recomp.c rematch.o: rematch.c segment.o: segment.c sets.o: sets.c unpost.o: unpost.c utils.o: utils.c uudec.o: uudec.c unpost/makefils/ibm_aix.mkf100644 23453 0 2262 5504043670 15672 0ustar jeanpaulsystem#****************************************************************************** # Module : Makefile for UnPost utility. (IBM AIX) # # Author : John W. M. Stevens #****************************************************************************** CC_FLAGS = .c.o: c89 -c $(CC_FLAGS) $< all: retest client unpost retest: recomp.o rematch.o retest.o sets.o utils.o c89 $(CC_FLAGS) -o retest retest.o recomp.o rematch.o sets.o utils.o client: recomp.o rematch.o sets.o utils.o client.o c89 $(CC_FLAGS) -o client client.o recomp.o rematch.o sets.o utils.o unpost: calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o c89 -o unpost calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o calccrc.o: calccrc.c config.o: config.c decode.o: decode.c ident.o: ident.c lex.o: lex.c list.o: list.c modflnm.o: modflnm.c parse.o: parse.c recomp.o: recomp.c rematch.o: rematch.c segment.o: segment.c sets.o: sets.c unpost.o: unpost.c utils.o: utils.c uudec.o: uudec.c unpost/makefils/os2_gcc.mkf100644 23453 0 2262 5504043736 15604 0ustar jeanpaulsystem#****************************************************************************** # Module : Makefile for UnPost utility. (EMX-GCC) # # Author : John W. M. Stevens #****************************************************************************** CC_FLAGS = -ansi -DEMX_GCC_COMPILER -DSYSTEM_OS_2 .c.o: gcc -c $(CC_FLAGS) $< all: retest unpost retest.exe: recomp.o rematch.o retest.o sets.o utils.o gcc $(CC_FLAGS) -o retest.exe retest.o recomp.o rematch.o \ sets.o utils.o unpost.exe: calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o gcc -o unpost.exe calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o calccrc.o: calccrc.c config.o: config.c decode.o: decode.c ident.o: ident.c lex.o: lex.c list.o: list.c modflnm.o: modflnm.c parse.o: parse.c recomp.o: recomp.c rematch.o: rematch.c segment.o: segment.c sets.o: sets.c unpost.o: unpost.c utils.o: utils.c uudec.o: uudec.c unpost/makefils/os2_cset.mkf100644 23453 0 2632 5504043720 16000 0ustar jeanpaulsystem#****************************************************************************** # Module : Makefile for UnPost utility. (IBM C Set++) # # Author : John W. M. Stevens # modified slightly by Kevin Vigor for IBM C Set++. # (kevin@elvis.wicat.com) #****************************************************************************** CC_FLAGS = /Sa /DSYSTEM_OS_2 /DIBM_CSET_COMPILER .c.obj: icc -c $(CC_FLAGS) $< all: retest.exe unpost.exe retest.exe: recomp.obj rematch.obj retest.obj sets.obj utils.obj link386 /NOI retest.obj recomp.obj rematch.obj \ sets.obj utils.obj, retest.exe,,,, unpost.exe: calccrc.obj config.obj decode.obj ident.obj lex.obj \ list.obj modflnm.obj parse.obj recomp.obj rematch.obj \ segment.obj sets.obj unpost.obj utils.obj uudec.obj link386 /NOI \ calccrc.obj config.obj decode.obj ident.obj lex.obj \ list.obj modflnm.obj parse.obj recomp.obj rematch.obj \ segment.obj sets.obj unpost.obj utils.obj uudec.obj, \ unpost.exe,,,, calccrc.obj: calccrc.c config.obj: config.c decode.obj: decode.c ident.obj: ident.c lex.obj: lex.c list.obj: list.c modflnm.obj: modflnm.c parse.obj: parse.c recomp.obj: recomp.c rematch.obj: rematch.c segment.obj: segment.c sets.obj: sets.c unpost.obj: unpost.c utils.obj: utils.c uudec.obj: uudec.c unpost/makefils/sgi.mkf100644 23453 0 2426 5504043750 15045 0ustar jeanpaulsystem#****************************************************************************** # Module : Makefile for UnPost utility. (SGI Silicon Graphics) # # Author : John W. M. Stevens # Modified by mdqac@mlubio5.biochemtech.uni-halle.de # (Heiko Schinke) for SGI. #****************************************************************************** CC_FLAGS = .c.o: cc -c $(CC_FLAGS) $< all: retest client unpost retest: recomp.o rematch.o retest.o sets.o utils.o cc $(CC_FLAGS) -o retest retest.o recomp.o rematch.o sets.o utils.o client: recomp.o rematch.o sets.o utils.o client.o cc $(CC_FLAGS) -o client client.o recomp.o rematch.o sets.o utils.o unpost: calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o cc -o unpost calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o calccrc.o: calccrc.c config.o: config.c decode.o: decode.c ident.o: ident.c lex.o: lex.c list.o: list.c modflnm.o: modflnm.c parse.o: parse.c recomp.o: recomp.c rematch.o: rematch.c segment.o: segment.c sets.o: sets.c unpost.o: unpost.c utils.o: utils.c uudec.o: uudec.c unpost/makefils/vax_vms.mms100644 23453 0 2246 5504043602 15761 0ustar jeanpaulsystem#****************************************************************************** # Module : Makefile for UnPost utility. (CC for VAX/VMS) # # Author : John W. M. Stevens # # Modified : Rick Dyson (dyson@IowaSP.Physics.UIowa.EDU) 18-FEB-1993 # Created VMS Description file for MMS from GCC Makefile #****************************************************************************** all : unpost.exe @ continue OBJS = calccrc.obj config.obj decode.obj ident.obj lex.obj list.obj modflnm.obj parse.obj recomp.obj rematch.obj segment.obj sets.obj unpost.obj utils.obj uudec.obj retest.exe : recomp.obj rematch.obj retest.obj sets.obj utils.obj options.opt $(LINK) $(LINKFLAGS) retest,recomp,rematch,sets,utils,options/Option client.exe : recomp.obj rematch.obj sets.obj utils.obj client.obj options.opt $(LINK) $(LINK_FLAGS) client.obj,recomp.obj,rematch.obj,sets.obj,utils.obj,options/Option unpost.exe : $(OBJS) options.opt $(LINK) $(LINKFLAGS) unpost,config,decode,ident,lex,list,modflnm,parse,recomp,rematch,segment,sets,uudec,utils,options/Option OBJS : compiler.h config.h clean : @- Purge /NoLog /NoConfirm *.* @- Delete /NoLog /NoConfirm *.obj; unpost/makefils/vax_vms.com100644 23453 0 1470 5505312606 15745 0ustar jeanpaulsystem$! Command procedure for building UnPost v2.2.0 on VMS $! This was created from running MMS on the vax_vms.mms description file. $! $ CC /NOLIST/OBJECT=CONFIG.OBJ CONFIG.C $ CC /NOLIST/OBJECT=DECODE.OBJ DECODE.C $ CC /NOLIST/OBJECT=IDENT.OBJ IDENT.C $ CC /NOLIST/OBJECT=LEX.OBJ LEX.C $ CC /NOLIST/OBJECT=LIST.OBJ LIST.C $ CC /NOLIST/OBJECT=MODFLNM.OBJ MODFLNM.C $ CC /NOLIST/OBJECT=PARSE.OBJ PARSE.C $ CC /NOLIST/OBJECT=RECOMP.OBJ RECOMP.C $ CC /NOLIST/OBJECT=REMATCH.OBJ REMATCH.C $ CC /NOLIST/OBJECT=SEGMENT.OBJ SEGMENT.C $ CC /NOLIST/OBJECT=SETS.OBJ SETS.C $ CC /NOLIST/OBJECT=UNPOST.OBJ UNPOST.C $ CC /NOLIST/OBJECT=UTILS.OBJ UTILS.C $ CC /NOLIST/OBJECT=UUDEC.OBJ UUDEC.C $ LINK /TRACE/NOMAP/EXEC=UNPOST.EXE unpost,config,decode,ident,lex,list,modflnm,parse,recomp,rematch,segment,sets,uudec,utils,options/Option $ Exit unpost/makefils/linux.mkf100644 23453 0 2307 5541424572 15426 0ustar jeanpaulsystem#****************************************************************************** # Module : Makefile for UnPost utility. (GCC on Linux) # # Author : John W. M. Stevens #****************************************************************************** CC_FLAGS = -ansi -DGCC_COMPILER .c.o: gcc -c $(CC_FLAGS) $< all: retest unpost retest: recomp.o rematch.o retest.o sets.o utils.o gcc $(CC_FLAGS) -o retest retest.o recomp.o rematch.o sets.o utils.o client: recomp.o rematch.o sets.o utils.o client.o gcc $(CC_FLAGS) -o client client.o recomp.o rematch.o sets.o utils.o unpost: calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o gcc -o unpost calccrc.o config.o decode.o ident.o lex.o \ list.o modflnm.o parse.o recomp.o rematch.o \ segment.o sets.o unpost.o utils.o uudec.o calccrc.o: calccrc.c config.o: config.c decode.o: decode.c ident.o: ident.c lex.o: lex.c list.o: list.c modflnm.o: modflnm.c parse.o: parse.c recomp.o: recomp.c rematch.o: rematch.c segment.o: segment.c sets.o: sets.c unpost.o: unpost.c utils.o: utils.c uudec.o: uudec.c unpost/unpost.c100644 23453 0 33311 5543402240 13476 0ustar jeanpaulsystem/****************************************************************************** * Module : Unpost --- Extract a binary file from a multi-part, uuencoded * USENET News posting. * * Author : John W. M. Stevens * * Notes : See the file unpost.doc for information. ******************************************************************************/ #include "compiler.h" #include "unpost.h" #include "parse.h" #include "segment.h" /*********************************** Globals *********************************/ char *Version = "UNPOST V2.3.4"; int LineNumber = 0; /* Binary switches. See file compiler.h to change default settings. */ int MsDosFileNms = MUNGE_FILE_NMS; int DumpDesc = DUMP_DESC_FILES; int SepIncomps = SEP_INCOMPLETES; /* File pointers. */ FILE *ErrFile = NULL; /* Error file. */ FILE *TextFile = NULL; /* Write non-binary to file. */ FILE *IncompFile = NULL; /* Incompletes file. */ FILE *UnPstdFile = NULL; /* Succesfully decoded files. */ /*****************************************************************************/ /*----------------------------------------------------------------------------- | Routine : ReadLine() --- Get a line from the file. | | Inputs : FlPtr - Pointer to file to read from. | InBfr - Pointer to buffer to read into. | BfrMax - Max buffer size. | | Returns : Returns EOF or OK. -----------------------------------------------------------------------------*/ int ReadLine(FILE *FlPtr, char *InBfr, int BfrMax) { register int i; extern FILE *ErrFile; /* Get a line from the file. */ if (fgets(InBfr, BfrMax, FlPtr) == NULL) { /* Check for end of file. */ if ( feof( FlPtr ) ) return( EOF ); else if ( ferror( FlPtr ) ) { fprintf(ErrFile, "%s %d : Error - reading source file.\n", __FILE__, __LINE__); exit( 1 ); } } /* Remove trailing '\n' character. * * Maybe THIS time I got it right. . . */ LineNumber++; for (i = strlen( InBfr ); i > 0 && (InBfr[i - 1] == '\n' || InBfr[i - 1] == '\r'); i-- ) ; InBfr[i] = '\0'; /* Return OK. */ return( OK ); } /*----------------------------------------------------------------------------- | Routine : ShowSynopsis() --- Show a summary of the command line | syntax. -----------------------------------------------------------------------------*/ static char *Synopsis[] = { "Options:\n", " -b[-] Break incompletes into separate files.\n", " -d[-] Dump descriptions flag.\n", " -e File for errors (default standard error).\n", " -f[-] Modify file names to be MS-DOS compatible.\n", " -h Interpret headers in source files.\n", " -i File to write incomplete binaries to.\n", " -l File to read list of files to process from.\n", " -o File to write decoded file names to.\n", " -r Set news reader type (SEGMENT begin line RE).\n", " -s Assume segments in order in file.\n", " -t File for text only segments.\n", " -u UU decoder, pure and simple.\n", " -v Print the version number and quit.\n", " -? Show this help summary.\n\n", NULL }; static void ShowSynopsis(void) { register int i; /* Show header and version number. */ printf("%s --- Extract a uuencoded binary from a multi-part posting.\n\n", Version); /* Show synopsis. */ for (i = 0; Synopsis[i]; i++) printf( Synopsis[i] ); /* Show current state of binary flags. */ printf("File Name Modifying (-f) : %-3.3s\n", (MsDosFileNms) ? "On" : "Off"); printf("Create Description Files (-d) : %-3.3s\n", (DumpDesc) ? "On" : "Off"); printf("Separate Incomplete Files (-b) : %-3.3s\n", (SepIncomps) ? "On" : "Off"); } /*----------------------------------------------------------------------------- | Routine : CmdLineParse() --- Parse the command line. | | Inputs : argc - Number of command line arguments. | argv - List of command line argument strings. | SwList - Switch list. -----------------------------------------------------------------------------*/ static int CmdLineParse(int argc, char **argv, char *SwList) { register int i; auto int RetVal; auto int t; auto FILE *FlsPtr; auto char *ArgPtr; auto char *SwPtr; auto char SwChar; auto char ModeFlag; /* Check for no arguments. */ if (argc < 2) { /* Give synopsis and quit. */ ShowSynopsis(); exit( 1 ); } /* Scan entire command line. */ ErrFile = stderr; ModeFlag = 'h'; FlsPtr = NULL; RetVal = 0; for (i = 1; i < argc; i++) { /* Get a pointer to the argument. */ ArgPtr = argv[i]; /* Is this a switch? */ if (*ArgPtr == '-') { /* Get switch character. */ if ((SwChar = *++ArgPtr) == '\0') { /* There is no character after the switch marker, * so declare an error. */ ShowSynopsis(); exit( 1 ); } else if ((SwPtr = strchr(SwList, SwChar)) == NULL) { /* Error, this is evidently an illegal switch * character. */ ShowSynopsis(); exit( 1 ); } else if (SwPtr[1] == '>') { /* Get parameter string. Parameter string can * follow immediately after the switch character, * or it can be the next command line string. */ if (*++ArgPtr == '\0') { /* Next command line parameter is switch * parameter string. */ if (i + 1 < argc) ArgPtr = argv[++i]; else { ShowSynopsis(); exit( 1 ); } } } else ArgPtr++; } else SwChar = ' '; /* Have argument processed. */ switch ( SwChar ) { case 'b': /* Set or reset flag that tells UNPOST to separate incompletes * into their own files. */ if (*ArgPtr == '-') SepIncomps = 0; else SepIncomps = 1; break; case 'c': /* Initialize the parser, using the default configuration OR * the configuration file. */ LoadCfg( ArgPtr ); break; case 'd': if (*ArgPtr == '-') DumpDesc = 0; else DumpDesc = 1; break; case 'e': /* Close a file that is already open. */ if ( ErrFile ) fclose( ErrFile ); /* Open a new error file. */ if ((ErrFile = fopen(ArgPtr, TXT_WRITE)) == NULL) { fprintf(stderr, "%s %d : Error - Could not open file '%s' ", __FILE__, __LINE__, ArgPtr); fprintf(stderr, "for output.\n"); exit( 1 ); } break; case 'f': if (*ArgPtr == '-') MsDosFileNms = 0; else MsDosFileNms = 1; break; case 'i': /* Close a file that is already open. */ if ( IncompFile ) fclose( IncompFile ); /* Open an incompletes file. */ if ((IncompFile = fopen(ArgPtr, TXT_APPEND)) == NULL) { fprintf(stderr, "%s %d : Error - Could not open file '%s' ", __FILE__, __LINE__, ArgPtr); fprintf(stderr, "for output.\n"); exit( 1 ); } break; case 'l': /* Close a file already open. */ if ( FlsPtr ) fclose( FlsPtr ); /* Open file. */ if (*ArgPtr == '-') FlsPtr = stdin; else if ((FlsPtr = fopen(ArgPtr, BIN_READ)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' ", __FILE__, __LINE__, ArgPtr); fprintf(ErrFile, "for reading.\n"); break; } /* Call multi-file shell. */ MultiFile( FlsPtr ); break; case 'o': /* Close a file already open. */ if (UnPstdFile && UnPstdFile != stdout) fclose( UnPstdFile ); /* Open file. */ if (*ArgPtr == '-') UnPstdFile = stdout; else if ((UnPstdFile = fopen(ArgPtr, TXT_APPEND)) == NULL) { fprintf(ErrFile, "%s %d : Error - could not open file '%s' ", __FILE__, __LINE__, ArgPtr); fprintf(ErrFile, "for writing.\n"); break; } break; case 'r': SetSegBegin( ArgPtr ); break; case 't': /* Close a file that is already open. */ if ( TextFile ) fclose( TextFile ); /* Open file for saving text only segments. */ if ((TextFile = fopen(ArgPtr, TXT_WRITE)) == NULL) { fprintf(stderr, "%s %d : Error - Could not open file '%s' ", __FILE__, __LINE__, ArgPtr); fprintf(stderr, "for output.\n"); exit( 1 ); } break; case 'h': case 'u': case 's': ModeFlag = SwChar; break; case 'v': printf("%s\n", Version); exit( 0 ); case ' ': /* Select mode. */ switch ( ModeFlag ) { case 'h': if ((t = Multiple( ArgPtr )) != 0 && RetVal == 0) RetVal = t; break; case 's': if ((t = Single( ArgPtr )) != 0 && RetVal == 0) RetVal = t; break; case 'u': if ((t = UUDecode( ArgPtr )) != 0 && RetVal == 0) RetVal = t; break; } break; default: ShowSynopsis(); exit( 1 ); } } return( RetVal ); } #if defined(MUNGE_FILE_NAMES_PER_FS) && defined(SYSTEM_OS_2) /*----------------------------------------------------------------------------- | Routine : IsHpfs() --- Is this an HPFS? | | Returns : Returns 0 for not a HPFS, or non zero for is. -----------------------------------------------------------------------------*/ #if defined(EMX_GCC_COMPILER) int IsHpfs(void) { auto unsigned long ulDrive; auto unsigned long ulLogical; auto char drive[3]; auto char name[16]; /* Check operating system mode. */ if (_osmode == DOS_MODE) return( 0 ); /* Get current disk drive. */ DosQueryCurrentDisk(&ulDrive, &ulLogical); /* Set up drive name string. */ drive[0] = (char) (ulDrive + '@'); drive[1] = ':'; drive[2] = '\0'; /* Get file system name string. */ if (_filesys(drive, name, 16) == -1) return( 0 ); /* Is this an HPFS? */ if (strcmp(name, "HPFS") == 0) return( 1 ); return( 0 ); } #elif defined(OS_2_MSC_COMPILER) int IsHpfs(void) { auto USHORT nDrive; auto ULONG lMap; auto BYTE bData[64]; auto BYTE bName[3]; auto USHORT cbData; /* MS-DOS does not have HPFS. */ if (_osmode == DOS_MODE) return( 0 ); /* Get the default drive. */ DosQCurDisk(&nDrive, &lMap); /* Set up the drive name. */ bName[0] = (char) (nDrive + '@'); bName[1] = ':'; bName[2] = 0; cbData = sizeof( bData ); /* Read the info, if we fail - assume non-HPFS. */ if ( DosQFSAttach(bName, 0, FSAIL_QUERYNAME, bData, &cbData, 0L) ) return( 0 ); else if (strcmp(bData + (*((USHORT *) (bData + 2)) + 7), "HPFS") == 0) return( 1 ); return( 0 ); } #endif #endif int main(int argc, char **argv) { auto int RetVal; /* If the user wants different file name munging on different * systems, set -f flag accordingly, otherwise, leave alone. */ #if defined(MUNGE_FILE_NAMES_PER_FS) && defined(SYSTEM_OS_2) MsDosFileNms = ! IsHpfs(); #endif /* Parse command line parameters. */ ParseInit(); RetVal = CmdLineParse(argc, argv, "bc>de>fhi>l>o>r>st>uv"); return( RetVal ); } unpost/unpost.h100644 23453 0 1555 5543402242 13472 0ustar jeanpaulsystem/****************************************************************************** * Module : Unpost header file. * * Author : John W. M. Stevens ******************************************************************************/ #if ! defined(UNPOST_HEADER_FILE) #define UNPOST_HEADER_FILE /* Global constants. */ #define TRUE 1 #define ERROR 1 #define MATCH 1 #define FALSE 0 #define OK 0 #define FL_NM_SZ 256 #define BFR_SIZE 512 typedef unsigned long CRC_TYPE; #if ! defined(_OS2EMX_H) && ! defined(IBM_CSET_COMPILER) typedef unsigned char BYTE; #endif /* Function prototypes. */ extern int ReadLine(FILE *FlPtr, char *InBfr, int BfrMax); extern char *StrDup(char *Str); extern int FileExists(char *FlName); extern CRC_TYPE CalcCRC(FILE *BinFlPtr); #endif unpost/utils.c100644 23453 0 10751 5543402240 13311 0ustar jeanpaulsystem/****************************************************************************** * Module : Utility Routines --- Replacement functions for compiler * library functions. This module exists to avoid having to * if def the hell out of the code for systems that, for * example, have bcopy, but not memmove. * * Author : John W. M. Stevens ******************************************************************************/ #include "compiler.h" #include "utils.h" /*----------------------------------------------------------------------------- | Routine : HexToUL() --- Convert a hexadecimal string to an unsigned | long integer. | | Inputs : Str - A pointer to the string to convert. -----------------------------------------------------------------------------*/ unsigned long HexToUL(char *Str) { auto unsigned long ULong; auto char *cp; /* Look at each character. */ ULong = 0L; for (cp = Str; *cp; cp++) { if (*cp >= '0' && *cp <= '9') ULong = (ULong << 4) + (*cp - '0'); else if (*cp >= 'a' && *cp <= 'f') ULong = (ULong << 4) + (*cp - 'a') + 10; else if (*cp >= 'A' && *cp <= 'F') ULong = (ULong << 4) + (*cp - 'A') + 10; } return( ULong ); } /*----------------------------------------------------------------------------- | Routine : StrDup() --- String duplication function. | | Inputs : Str - A pointer to the string to duplicate. -----------------------------------------------------------------------------*/ char *StrDup(char *Str) { register int StrLen; auto char *Tmp; extern FILE *ErrFile; /* Determine lenght of string to duplicate. */ StrLen = strlen( Str ) + 1; /* Allocate the memory. */ if ((Tmp = calloc(1, StrLen)) == NULL) { fprintf(ErrFile, "%s %d : Error - out of memory.\n", __FILE__, __LINE__); exit( 1 ); } /* Copy string contents in. */ strcpy(Tmp, Str); return( Tmp ); } /*----------------------------------------------------------------------------- | Routine : FileExists() --- Check to see if a file already exists. | | Inputs : FlName - Name of file. | | Returns : Returns zero for file does not exist, non-zero for it does. -----------------------------------------------------------------------------*/ int FileExists(char *FlName) { auto FILE *fp; /* Attempt to open the file as read only to determine if it exists. * Don't you wish that ANSI C had a standard library function for * this? */ if ((fp = fopen(FlName, TXT_READ)) != NULL) { /* It exists, so close it and return. */ fclose( fp ); return( 1 ); } return( 0 ); } /*----------------------------------------------------------------------------- | Routine : MemCopy() --- Copy memory. | | Inputs : Dest - Destination address. | Source - Source address. | NoBytes - Number of bytes to copy. -----------------------------------------------------------------------------*/ void MemCopy(void *Dest, void *Source, int NoBytes) { register int i; auto char *d; auto char *s; /* Copy bytes. */ for (d = (char *) Dest, s = (char *) Source, i = 0; i < NoBytes; i++) *d++ = *s++; } /*----------------------------------------------------------------------------- | Routine : MemMv() --- Move memory, taking into account possible | overlap. | | Inputs : Dest - Destination address. | Source - Source address. | NoBytes - Number of bytes to copy. -----------------------------------------------------------------------------*/ void MemMv(void *Dest, void *Source, int NoBytes) { register int i; auto char *d; auto char *s; /* Pointer conversion. */ d = (char *) Dest; s = (char *) Source; /* Check copy direction. */ if (d < s) { /* Copy up. */ for (i = 0; i < NoBytes; i++) *d++ = *s++; } else if (d > s) { /* Copy down. */ for (d += NoBytes - 1, s += NoBytes - 1, i = 0; i < NoBytes; i++) *d-- = *s--; } } unpost/nntp/ 40755 23453 0 0 5613467461 12661 5ustar jeanpaulsystemunpost/nntp/client.cfg100644 23453 0 54 5457221000 14633 0ustar jeanpaulsystemgroup alt.binaries.pictures.misc abpm.uue 0 unpost/nntp/client.doc100644 23453 0 15415 5454507202 14740 0ustar jeanpaulsystemCLIENT Name: client - Attach to an NNTP (network news transfer protocol) server, extract all unread postings to the specified newsgroups and write them to a specified file. Synopsis: client [ ] Description: CLIENT is a program that is designed to act as an assitant to UNPOST. It's primarily designed to create the files that UNPOST works on. It is very simple, and quite stupid. It starts by attempting to get the server address from the /etc/hosts file based on the server name given on the command line, then it attempts to get the NNTP foreign port number (which, according to the spec, should ALWAYS be 119, but I decided not to take any chances) and then connect to the NNTP News server. If CLIENT successfully connects to the server, it opens the configuration file and reads a line from it. These lines should look like: group Where news group name is the name of the news group that you want CLIENT to read from, file name is the name of the file you want CLIENT to write all articles to, and next unread article number is the first article number to read. Example: group alt.binaries.pictures.utilites abpu.uue 231 Which says read from group alt.binaries.pictures.utilities, write all unread articles (all articles with numbers greater than or equal to 231) to a file called abpu.uue. CLIENT has a kill capability, which is based on the UNPOST regular expression package. A kill file has the following structure: news.group.name begin /^Prefix:/ /Kill_regular_expression/ . . . /Kill_regular_expression/ end next.news.group.name begin /^Subject:/ /re:/ /request:/ end No blank lines are allowed, and only the kill regular expressions can be indented. All other lines must begin in the first column. After reading every unread article from a.b.p.u and writing them to the file abpu.uue, CLIENT will read the next line from the configuration file and start all over again. After reading all articles from all of the specified news groups, CLIENT will rewrite the configuration file to specify the next new article number and then close the connection to the News server and exit. Parameters: - Internet server name, example: news.llmt.org - Name of configuration file. - Name of file that contains regular expressions for selecting articles to kill. Standards: CLIENT follows the standard described in RFC 977. Notes: To use this program to collect all of the binaries posted to, say, the alt.binaries.misc group on a daily basis, create a configuration file that looks like: group alt.binaries.misc abm.uue 0 and is named client.cfg. Then you need to set up a script that calls client on a daily basis, using the CRON or AT facility. See your local man pages for these services. The script should contain the line: client news.llmat.org client.cfg 2> client.err Be aware that if you use AT or CRON, you may need to add path names to both the script, and the file names in the configuration file. Diagnostics: Error in writing to news server. Return = #, Error number = # CLIENT tried to write a message to the server, but there was an error. If you are C fluent, you might look in errno.h to see what the Error number means, if anything. I can't do anything about this error, sorry. Error in reading from news server. Return = #, Error number = # CLIENT tried to read a message from the server, but there was an error. If you are C fluent, you might look in errno.h to see what the Error number means, if anything. I can't do anything about this error, sorry. Error, response to ARTICLE = #. CLIENT asked for an article and got back the status # from the server. Most probably, # will be 221, 222 or 223. Error, no news group selected. Ooops. This shouldn't happen. Somehow, CLIENT thinks that it's GROUP selection command was succesful, and the server disagrees. Error, no current article selected. Same as above, CLIENT and server disagree about the success of an ARTICLE command. Warning - saw '\\n' before '\\r'. Warning - saw '.\\r' but no '\\n'. Warning - saw '.\\r' but no '\\n'. The standard says that all lines are terminated with a carriage return followed by a line feed. Either the order is wrong (LF-CR), or there is a missing line feed, or a missing carriage return. Warning - did not use all of article. The server sent the whole article, but for some reason CLIENT decided that it saw a ".\r\n" before the actual end of the article text. (".\r\n" is the end of an article, according to the standard). Error - Could not convert 'server' to a host address. Evidently, there is no server named 'server' in the hosts table. You can try the actual internet address, if you know it. Error - bogus port number 'nntp'. Couldn't find the NNTP port in the services table. Error - could not connect to news server. There are any number of reasons that you might get this message, and some of them will be given in the error message given just before this one. One reason may be that the server is limited in the number of clients it may serve at one time, and it may have refused connection because it is at quota already. Error, could not open configuration file. Couldn't find the file, couldn't read it, whatever. Error, could not open new configuration file. CLIENT opens a temporary file to write the new configuration to at the end, and for some reason, it couldn't create a new file for writing. Full disk, maybe? Error - bad configuration file line. 'configuration file line' Check the syntax of your configuration file. The line given is not correct, according to CLIENT. Error, no such news group 's'. According to the server, there is no such group as 's'. No news in group 's'. According to the server, there are no articles in news group 's'. Error, could not open file 's' for writing. CLIENT is attempting to open the file that you want the articles for this group written to, but cannot, for some reason. Bugs: None currently known, but I'm sure that will change. Author: John W. M. Stevens - jstevens@csn.org unpost/nntp/rfc977.txt100644 23453 0 150324 5457221042 14572 0ustar jeanpaulsystem Network Working Group Brian Kantor (U.C. San Diego) Request for Comments: 977 Phil Lapsley (U.C. Berkeley) February 1986 Network News Transfer Protocol A Proposed Standard for the Stream-Based Transmission of News Status of This Memo NNTP specifies a protocol for the distribution, inquiry, retrieval, and posting of news articles using a reliable stream-based transmission of news among the ARPA-Internet community. NNTP is designed so that news articles are stored in a central database allowing a subscriber to select only those items he wishes to read. Indexing, cross-referencing, and expiration of aged messages are also provided. This RFC suggests a proposed protocol for the ARPA-Internet community, and requests discussion and suggestions for improvements. Distribution of this memo is unlimited. 1. Introduction For many years, the ARPA-Internet community has supported the distribution of bulletins, information, and data in a timely fashion to thousands of participants. We collectively refer to such items of information as "news". Such news provides for the rapid dissemination of items of interest such as software bug fixes, new product reviews, technical tips, and programming pointers, as well as rapid-fire discussions of matters of concern to the working computer professional. News is very popular among its readers. There are popularly two methods of distributing such news: the Internet method of direct mailing, and the USENET news system. 1.1. Internet Mailing Lists The Internet community distributes news by the use of mailing lists. These are lists of subscriber's mailbox addresses and remailing sublists of all intended recipients. These mailing lists operate by remailing a copy of the information to be distributed to each subscriber on the mailing list. Such remailing is inefficient when a mailing list grows beyond a dozen or so people, since sending a separate copy to each of the subscribers occupies large quantities of network bandwidth, CPU resources, and significant amounts of disk storage at the destination host. There is also a significant problem in maintenance of the list itself: as subscribers move from one job to another; as new subscribers join and old ones leave; and as hosts come in and out of service. Kantor & Lapsley [Page 1] RFC 977 February 1986 Network News Transfer Protocol 1.2. The USENET News System Clearly, a worthwhile reduction of the amount of these resources used can be achieved if articles are stored in a central database on the receiving host instead of in each subscriber's mailbox. The USENET news system provides a method of doing just this. There is a central repository of the news articles in one place (customarily a spool directory of some sort), and a set of programs that allow a subscriber to select those items he wishes to read. Indexing, cross-referencing, and expiration of aged messages are also provided. 1.3. Central Storage of News For clusters of hosts connected together by fast local area networks (such as Ethernet), it makes even more sense to consolidate news distribution onto one (or a very few) hosts, and to allow access to these news articles using a server and client model. Subscribers may then request only the articles they wish to see, without having to wastefully duplicate the storage of a copy of each item on each host. 1.4. A Central News Server A way to achieve these economies is to have a central computer system that can provide news service to the other systems on the local area network. Such a server would manage the collection of news articles and index files, with each person who desires to read news bulletins doing so over the LAN. For a large cluster of computer systems, the savings in total disk space is clearly worthwhile. Also, this allows workstations with limited disk storage space to participate in the news without incoming items consuming oppressive amounts of the workstation's disk storage. We have heard rumors of somewhat successful attempts to provide centralized news service using IBIS and other shared or distributed file systems. While it is possible that such a distributed file system implementation might work well with a group of similar computers running nearly identical operating systems, such a scheme is not general enough to offer service to a wide range of client systems, especially when many diverse operating systems may be in use among a group of clients. There are few (if any) shared or networked file systems that can offer the generality of service that stream connections using Internet TCP provide, particularly when a wide range of host hardware and operating systems are considered. NNTP specifies a protocol for the distribution, inquiry, retrieval, and posting of news articles using a reliable stream (such as TCP) server-client model. NNTP is designed so that news articles need only Kantor & Lapsley [Page 2] RFC 977 February 1986 Network News Transfer Protocol be stored on one (presumably central) host, and subscribers on other hosts attached to the LAN may read news articles using stream connections to the news host. NNTP is modelled upon the news article specifications in RFC 850, which describes the USENET news system. However, NNTP makes few demands upon the structure, content, or storage of news articles, and thus we believe it easily can be adapted to other non-USENET news systems. Typically, the NNTP server runs as a background process on one host, and would accept connections from other hosts on the LAN. This works well when there are a number of small computer systems (such as workstations, with only one or at most a few users each), and a large central server. 1.5. Intermediate News Servers For clusters of machines with many users (as might be the case in a university or large industrial environment), an intermediate server might be used. This intermediate or "slave" server runs on each computer system, and is responsible for mediating news reading requests and performing local caching of recently-retrieved news articles. Typically, a client attempting to obtain news service would first attempt to connect to the news service port on the local machine. If this attempt were unsuccessful, indicating a failed server, an installation might choose to either deny news access, or to permit connection to the central "master" news server. For workstations or other small systems, direct connection to the master server would probably be the normal manner of operation. This specification does not cover the operation of slave NNTP servers. We merely suggest that slave servers are a logical addition to NNTP server usage which would enhance operation on large local area networks. 1.6. News Distribution NNTP has commands which provide a straightforward method of exchanging articles between cooperating hosts. Hosts which are well connected on a local area or other fast network and who wish to actually obtain copies of news articles for local storage might well find NNTP to be a more efficient way to distribute news than more traditional transfer methods (such as UUCP). Kantor & Lapsley [Page 3] RFC 977 February 1986 Network News Transfer Protocol In the traditional method of distributing news articles, news is propagated from host to host by flooding - that is, each host will send all its new news articles on to each host that it feeds. These hosts will then in turn send these new articles on to other hosts that they feed. Clearly, sending articles that a host already has obtained a copy of from another feed (many hosts that receive news are redundantly fed) again is a waste of time and communications resources, but for transport mechanisms that are single-transaction based rather than interactive (such as UUCP in the UNIX-world <1>), distribution time is diminished by sending all articles and having the receiving host simply discard the duplicates. This is an especially true when communications sessions are limited to once a day. Using NNTP, hosts exchanging news articles have an interactive mechanism for deciding which articles are to be transmitted. A host desiring new news, or which has new news to send, will typically contact one or more of its neighbors using NNTP. First it will inquire if any new news groups have been created on the serving host by means of the NEWGROUPS command. If so, and those are appropriate or desired (as established by local site-dependent rules), those new newsgroups can be created. The client host will then inquire as to which new articles have arrived in all or some of the newsgroups that it desires to receive, using the NEWNEWS command. It will receive a list of new articles from the server, and can request transmission of those articles that it desires and does not already have. Finally, the client can advise the server of those new articles which the client has recently received. The server will indicate those articles that it has already obtained copies of, and which articles should be sent to add to its collection. In this manner, only those articles which are not duplicates and which are desired are transferred. Kantor & Lapsley [Page 4] RFC 977 February 1986 Network News Transfer Protocol 2. The NNTP Specification 2.1. Overview The news server specified by this document uses a stream connection (such as TCP) and SMTP-like commands and responses. It is designed to accept connections from hosts, and to provide a simple interface to the news database. This server is only an interface between programs and the news databases. It does not perform any user interaction or presentation- level functions. These "user-friendly" functions are better left to the client programs, which have a better understanding of the environment in which they are operating. When used via Internet TCP, the contact port assigned for this service is 119. 2.2. Character Codes Commands and replies are composed of characters from the ASCII character set. When the transport service provides an 8-bit byte (octet) transmission channel, each 7-bit character is transmitted right justified in an octet with the high order bit cleared to zero. 2.3. Commands Commands consist of a command word, which in some cases may be followed by a parameter. Commands with parameters must separate the parameters from each other and from the command by one or more space or tab characters. Command lines must be complete with all required parameters, and may not contain more than one command. Commands and command parameters are not case sensitive. That is, a command or parameter word may be upper case, lower case, or any mixture of upper and lower case. Each command line must be terminated by a CR-LF (Carriage Return - Line Feed) pair. Command lines shall not exceed 512 characters in length, counting all characters including spaces, separators, punctuation, and the trailing CR-LF (thus there are 510 characters maximum allowed for the command and its parameters). There is no provision for continuation command lines. Kantor & Lapsley [Page 5] RFC 977 February 1986 Network News Transfer Protocol 2.4. Responses Responses are of two kinds, textual and status. 2.4.1. Text Responses Text is sent only after a numeric status response line has been sent that indicates that text will follow. Text is sent as a series of successive lines of textual matter, each terminated with CR-LF pair. A single line containing only a period (.) is sent to indicate the end of the text (i.e., the server will send a CR-LF pair at the end of the last line of text, a period, and another CR-LF pair). If the text contained a period as the first character of the text line in the original, that first period is doubled. Therefore, the client must examine the first character of each line received, and for those beginning with a period, determine either that this is the end of the text or whether to collapse the doubled period to a single one. The intention is that text messages will usually be displayed on the user's terminal whereas command/status responses will be interpreted by the client program before any possible display is done. 2.4.2. Status Responses These are status reports from the server and indicate the response to the last command received from the client. Status response lines begin with a 3 digit numeric code which is sufficient to distinguish all responses. Some of these may herald the subsequent transmission of text. The first digit of the response broadly indicates the success, failure, or progress of the previous command. 1xx - Informative message 2xx - Command ok 3xx - Command ok so far, send the rest of it. 4xx - Command was correct, but couldn't be performed for some reason. 5xx - Command unimplemented, or incorrect, or a serious program error occurred. Kantor & Lapsley [Page 6] RFC 977 February 1986 Network News Transfer Protocol The next digit in the code indicates the function response category. x0x - Connection, setup, and miscellaneous messages x1x - Newsgroup selection x2x - Article selection x3x - Distribution functions x4x - Posting x8x - Nonstandard (private implementation) extensions x9x - Debugging output The exact response codes that should be expected from each command are detailed in the description of that command. In addition, below is listed a general set of response codes that may be received at any time. Certain status responses contain parameters such as numbers and names. The number and type of such parameters is fixed for each response code to simplify interpretation of the response. Parameters are separated from the numeric response code and from each other by a single space. All numeric parameters are decimal, and may have leading zeros. All string parameters begin after the separating space, and end before the following separating space or the CR-LF pair at the end of the line. (String parameters may not, therefore, contain spaces.) All text, if any, in the response which is not a parameter of the response must follow and be separated from the last parameter by a space. Also, note that the text following a response number may vary in different implementations of the server. The 3-digit numeric code should be used to determine what response was sent. Response codes not specified in this standard may be used for any installation-specific additional commands also not specified. These should be chosen to fit the pattern of x8x specified above. (Note that debugging is provided for explicitly in the x9x response codes.) The use of unspecified response codes for standard commands is prohibited. We have provided a response pattern x9x for debugging. Since much debugging output may be classed as "informative messages", we would expect, therefore, that responses 190 through 199 would be used for various debugging outputs. There is no requirement in this specification for debugging output, but if such is provided over the connected stream, it must use these response codes. If appropriate to a specific implementation, other x9x codes may be used for debugging. (An example might be to use e.g., 290 to acknowledge a remote debugging request.) Kantor & Lapsley [Page 7] RFC 977 February 1986 Network News Transfer Protocol 2.4.3. General Responses The following is a list of general response codes that may be sent by the NNTP server. These are not specific to any one command, but may be returned as the result of a connection, a failure, or some unusual condition. In general, 1xx codes may be ignored or displayed as desired; code 200 or 201 is sent upon initial connection to the NNTP server depending upon posting permission; code 400 will be sent when the NNTP server discontinues service (by operator request, for example); and 5xx codes indicate that the command could not be performed for some unusual reason. 100 help text 190 through 199 debug output 200 server ready - posting allowed 201 server ready - no posting allowed 400 service discontinued 500 command not recognized 501 command syntax error 502 access restriction or permission denied 503 program fault - command not performed 3. Command and Response Details On the following pages are descriptions of each command recognized by the NNTP server and the responses which will be returned by those commands. Each command is shown in upper case for clarity, although case is ignored in the interpretation of commands by the NNTP server. Any parameters are shown in lower case. A parameter shown in [square brackets] is optional. For example, [GMT] indicates that the triglyph GMT may present or omitted. Every command described in this section must be implemented by all NNTP servers. Kantor & Lapsley [Page 8] RFC 977 February 1986 Network News Transfer Protocol There is no prohibition against additional commands being added; however, it is recommended that any such unspecified command begin with the letter "X" to avoid conflict with later revisions of this specification. Implementors are reminded that such additional commands may not redefine specified status response codes. Using additional unspecified responses for standard commands is also prohibited. 3.1. The ARTICLE, BODY, HEAD, and STAT commands There are two forms to the ARTICLE command (and the related BODY, HEAD, and STAT commands), each using a different method of specifying which article is to be retrieved. When the ARTICLE command is followed by a message-id in angle brackets ("<" and ">"), the first form of the command is used; when a numeric parameter or no parameter is supplied, the second form is invoked. The text of the article is returned as a textual response, as described earlier in this document. The HEAD and BODY commands are identical to the ARTICLE command except that they respectively return only the header lines or text body of the article. The STAT command is similar to the ARTICLE command except that no text is returned. When selecting by message number within a group, the STAT command serves to set the current article pointer without sending text. The returned acknowledgement response will contain the message-id, which may be of some value. Using the STAT command to select by message-id is valid but of questionable value, since a selection by message-id does NOT alter the "current article pointer". 3.1.1. ARTICLE (selection by message-id) ARTICLE Display the header, a blank line, then the body (text) of the specified article. Message-id is the message id of an article as shown in that article's header. It is anticipated that the client will obtain the message-id from a list provided by the NEWNEWS command, from references contained within another article, or from the message-id provided in the response to some other commands. Please note that the internally-maintained "current article pointer" is NOT ALTERED by this command. This is both to facilitate the presentation of articles that may be referenced within an article Kantor & Lapsley [Page 9] RFC 977 February 1986 Network News Transfer Protocol being read, and because of the semantic difficulties of determining the proper sequence and membership of an article which may have been posted to more than one newsgroup. 3.1.2. ARTICLE (selection by number) ARTICLE [nnn] Displays the header, a blank line, then the body (text) of the current or specified article. The optional parameter nnn is the numeric id of an article in the current newsgroup and must be chosen from the range of articles provided when the newsgroup was selected. If it is omitted, the current article is assumed. The internally-maintained "current article pointer" is set by this command if a valid article number is specified. [the following applies to both forms of the article command.] A response indicating the current article number, a message-id string, and that text is to follow will be returned. The message-id string returned is an identification string contained within angle brackets ("<" and ">"), which is derived from the header of the article itself. The Message-ID header line (required by RFC850) from the article must be used to supply this information. If the message-id header line is missing from the article, a single digit "0" (zero) should be supplied within the angle brackets. Since the message-id field is unique with each article, it may be used by a news reading program to skip duplicate displays of articles that have been posted more than once, or to more than one newsgroup. 3.1.3. Responses 220 n article retrieved - head and body follow (n = article number, = message-id) 221 n article retrieved - head follows 222 n article retrieved - body follows 223 n article retrieved - request text separately 412 no newsgroup has been selected 420 no current article has been selected 423 no such article number in this group 430 no such article found Kantor & Lapsley [Page 10] RFC 977 February 1986 Network News Transfer Protocol 3.2. The GROUP command 3.2.1. GROUP GROUP ggg The required parameter ggg is the name of the newsgroup to be selected (e.g. "net.news"). A list of valid newsgroups may be obtained from the LIST command. The successful selection response will return the article numbers of the first and last articles in the group, and an estimate of the number of articles on file in the group. It is not necessary that the estimate be correct, although that is helpful; it must only be equal to or larger than the actual number of articles on file. (Some implementations will actually count the number of articles on file. Others will just subtract first article number from last to get an estimate.) When a valid group is selected by means of this command, the internally maintained "current article pointer" is set to the first article in the group. If an invalid group is specified, the previously selected group and article remain selected. If an empty newsgroup is selected, the "current article pointer" is in an indeterminate state and should not be used. Note that the name of the newsgroup is not case-dependent. It must otherwise match a newsgroup obtained from the LIST command or an error will result. 3.2.2. Responses 211 n f l s group selected (n = estimated number of articles in group, f = first article number in the group, l = last article number in the group, s = name of the group.) 411 no such news group Kantor & Lapsley [Page 11] RFC 977 February 1986 Network News Transfer Protocol 3.3. The HELP command 3.3.1. HELP HELP Provides a short summary of commands that are understood by this implementation of the server. The help text will be presented as a textual response, terminated by a single period on a line by itself. 3.3.2. Responses 100 help text follows 3.4. The IHAVE command 3.4.1. IHAVE IHAVE The IHAVE command informs the server that the client has an article whose id is . If the server desires a copy of that article, it will return a response instructing the client to send the entire article. If the server does not want the article (if, for example, the server already has a copy of it), a response indicating that the article is not wanted will be returned. If transmission of the article is requested, the client should send the entire article, including header and body, in the manner specified for text transmission from the server. A response code indicating success or failure of the transferral of the article will be returned. This function differs from the POST command in that it is intended for use in transferring already-posted articles between hosts. Normally it will not be used when the client is a personal newsreading program. In particular, this function will invoke the server's news posting program with the appropriate settings (flags, options, etc) to indicate that the forthcoming article is being forwarded from another host. The server may, however, elect not to post or forward the article if after further examination of the article it deems it inappropriate to do so. The 436 or 437 error codes may be returned as appropriate to the situation. Reasons for such subsequent rejection of an article may include such Kantor & Lapsley [Page 12] RFC 977 February 1986 Network News Transfer Protocol problems as inappropriate newsgroups or distributions, disk space limitations, article lengths, garbled headers, and the like. These are typically restrictions enforced by the server host's news software and not necessarily the NNTP server itself. 3.4.2. Responses 235 article transferred ok 335 send article to be transferred. End with . 435 article not wanted - do not send it 436 transfer failed - try again later 437 article rejected - do not try again An implementation note: Because some host news posting software may not be able to decide immediately that an article is inappropriate for posting or forwarding, it is acceptable to acknowledge the successful transfer of the article and to later silently discard it. Thus it is permitted to return the 235 acknowledgement code and later discard the received article. This is not a fully satisfactory solution to the problem. Perhaps some implementations will wish to send mail to the author of the article in certain of these cases. 3.5. The LAST command 3.5.1. LAST LAST The internally maintained "current article pointer" is set to the previous article in the current newsgroup. If already positioned at the first article of the newsgroup, an error message is returned and the current article remains selected. The internally-maintained "current article pointer" is set by this command. A response indicating the current article number, and a message-id string will be returned. No text is sent in response to this command. 3.5.2. Responses 223 n a article retrieved - request text separately (n = article number, a = unique article id) Kantor & Lapsley [Page 13] RFC 977 February 1986 Network News Transfer Protocol 412 no newsgroup selected 420 no current article has been selected 422 no previous article in this group 3.6. The LIST command 3.6.1. LIST LIST Returns a list of valid newsgroups and associated information. Each newsgroup is sent as a line of text in the following format: group last first p where is the name of the newsgroup, is the number of the last known article currently in that newsgroup, is the number of the first article currently in the newsgroup, and

is either 'y' or 'n' indicating whether posting to this newsgroup is allowed ('y') or prohibited ('n'). The and fields will always be numeric. They may have leading zeros. If the field evaluates to less than the field, there are no articles currently on file in the newsgroup. Note that posting may still be prohibited to a client even though the LIST command indicates that posting is permitted to a particular newsgroup. See the POST command for an explanation of client prohibitions. The posting flag exists for each newsgroup because some newsgroups are moderated or are digests, and therefore cannot be posted to; that is, articles posted to them must be mailed to a moderator who will post them for the submitter. This is independent of the posting permission granted to a client by the NNTP server. Please note that an empty list (i.e., the text body returned by this command consists only of the terminating period) is a possible valid response, and indicates that there are currently no valid newsgroups. 3.6.2. Responses 215 list of newsgroups follows Kantor & Lapsley [Page 14] RFC 977 February 1986 Network News Transfer Protocol 3.7. The NEWGROUPS command 3.7.1. NEWGROUPS NEWGROUPS date time [GMT] [] A list of newsgroups created since will be listed in the same format as the LIST command. The date is sent as 6 digits in the format YYMMDD, where YY is the last two digits of the year, MM is the two digits of the month (with leading zero, if appropriate), and DD is the day of the month (with leading zero, if appropriate). The closest century is assumed as part of the year (i.e., 86 specifies 1986, 30 specifies 2030, 99 is 1999, 00 is 2000). Time must also be specified. It must be as 6 digits HHMMSS with HH being hours on the 24-hour clock, MM minutes 00-59, and SS seconds 00-59. The time is assumed to be in the server's timezone unless the token "GMT" appears, in which case both time and date are evaluated at the 0 meridian. The optional parameter "distributions" is a list of distribution groups, enclosed in angle brackets. If specified, the distribution portion of a new newsgroup (e.g, 'net' in 'net.wombat') will be examined for a match with the distribution categories listed, and only those new newsgroups which match will be listed. If more than one distribution group is to be listed, they must be separated by commas within the angle brackets. Please note that an empty list (i.e., the text body returned by this command consists only of the terminating period) is a possible valid response, and indicates that there are currently no new newsgroups. 3.7.2. Responses 231 list of new newsgroups follows Kantor & Lapsley [Page 15] RFC 977 February 1986 Network News Transfer Protocol 3.8. The NEWNEWS command 3.8.1. NEWNEWS NEWNEWS newsgroups date time [GMT] [] A list of message-ids of articles posted or received to the specified newsgroup since "date" will be listed. The format of the listing will be one message-id per line, as though text were being sent. A single line consisting solely of one period followed by CR-LF will terminate the list. Date and time are in the same format as the NEWGROUPS command. A newsgroup name containing a "*" (an asterisk) may be specified to broaden the article search to some or all newsgroups. The asterisk will be extended to match any part of a newsgroup name (e.g., net.micro* will match net.micro.wombat, net.micro.apple, etc). Thus if only an asterisk is given as the newsgroup name, all newsgroups will be searched for new news. (Please note that the asterisk "*" expansion is a general replacement; in particular, the specification of e.g., net.*.unix should be correctly expanded to embrace names such as net.wombat.unix and net.whocares.unix.) Conversely, if no asterisk appears in a given newsgroup name, only the specified newsgroup will be searched for new articles. Newsgroup names must be chosen from those returned in the listing of available groups. Multiple newsgroup names (including a "*") may be specified in this command, separated by a comma. No comma shall appear after the last newsgroup in the list. [Implementors are cautioned to keep the 512 character command length limit in mind.] The exclamation point ("!") may be used to negate a match. This can be used to selectively omit certain newsgroups from an otherwise larger list. For example, a newsgroups specification of "net.*,mod.*,!mod.map.*" would specify that all net. and all mod. EXCEPT mod.map. newsgroup names would be matched. If used, the exclamation point must appear as the first character of the given newsgroup name or pattern. The optional parameter "distributions" is a list of distribution groups, enclosed in angle brackets. If specified, the distribution portion of an article's newsgroup (e.g, 'net' in 'net.wombat') will be examined for a match with the distribution categories listed, and only those articles which have at least one newsgroup belonging to Kantor & Lapsley [Page 16] RFC 977 February 1986 Network News Transfer Protocol the list of distributions will be listed. If more than one distribution group is to be supplied, they must be separated by commas within the angle brackets. The use of the IHAVE, NEWNEWS, and NEWGROUPS commands to distribute news is discussed in an earlier part of this document. Please note that an empty list (i.e., the text body returned by this command consists only of the terminating period) is a possible valid response, and indicates that there is currently no new news. 3.8.2. Responses 230 list of new articles by message-id follows 3.9. The NEXT command 3.9.1. NEXT NEXT The internally maintained "current article pointer" is advanced to the next article in the current newsgroup. If no more articles remain in the current group, an error message is returned and the current article remains selected. The internally-maintained "current article pointer" is set by this command. A response indicating the current article number, and the message-id string will be returned. No text is sent in response to this command. 3.9.2. Responses 223 n a article retrieved - request text separately (n = article number, a = unique article id) 412 no newsgroup selected 420 no current article has been selected 421 no next article in this group Kantor & Lapsley [Page 17] RFC 977 February 1986 Network News Transfer Protocol 3.10. The POST command 3.10.1. POST POST If posting is allowed, response code 340 is returned to indicate that the article to be posted should be sent. Response code 440 indicates that posting is prohibited for some installation-dependent reason. If posting is permitted, the article should be presented in the format specified by RFC850, and should include all required header lines. After the article's header and body have been completely sent by the client to the server, a further response code will be returned to indicate success or failure of the posting attempt. The text forming the header and body of the message to be posted should be sent by the client using the conventions for text received from the news server: A single period (".") on a line indicates the end of the text, with lines starting with a period in the original text having that period doubled during transmission. No attempt shall be made by the server to filter characters, fold or limit lines, or otherwise process incoming text. It is our intent that the server just pass the incoming message to be posted to the server installation's news posting software, which is separate from this specification. See RFC850 for more details. Since most installations will want the client news program to allow the user to prepare his message using some sort of text editor, and transmit it to the server for posting only after it is composed, the client program should take note of the herald message that greeted it when the connection was first established. This message indicates whether postings from that client are permitted or not, and can be used to caution the user that his access is read-only if that is the case. This will prevent the user from wasting a good deal of time composing a message only to find posting of the message was denied. The method and determination of which clients and hosts may post is installation dependent and is not covered by this specification. 3.10.2. Responses 240 article posted ok 340 send article to be posted. End with . 440 posting not allowed 441 posting failed Kantor & Lapsley [Page 18] RFC 977 February 1986 Network News Transfer Protocol (for reference, one of the following codes will be sent upon initial connection; the client program should determine whether posting is generally permitted from these:) 200 server ready - posting allowed 201 server ready - no posting allowed 3.11. The QUIT command 3.11.1. QUIT QUIT The server process acknowledges the QUIT command and then closes the connection to the client. This is the preferred method for a client to indicate that it has finished all its transactions with the NNTP server. If a client simply disconnects (or the connection times out, or some other fault occurs), the server should gracefully cease its attempts to service the client. 3.11.2. Responses 205 closing connection - goodbye! 3.12. The SLAVE command 3.12.1. SLAVE SLAVE Indicates to the server that this client connection is to a slave server, rather than a user. This command is intended for use in separating connections to single users from those to subsidiary ("slave") servers. It may be used to indicate that priority should therefore be given to requests from this client, as it is presumably serving more than one person. It might also be used to determine which connections to close when system load levels are exceeded, perhaps giving preference to slave servers. The actual use this command is put to is entirely implementation dependent, and may vary from one host to another. In NNTP servers which do not give priority to slave servers, this command must nonetheless be recognized and acknowledged. 3.12.2. Responses 202 slave status noted Kantor & Lapsley [Page 19] RFC 977 February 1986 Network News Transfer Protocol 4. Sample Conversations These are samples of the conversations that might be expected with the news server in hypothetical sessions. The notation C: indicates commands sent to the news server from the client program; S: indicate responses received from the server by the client. 4.1. Example 1 - relative access with NEXT S: (listens at TCP port 119) C: (requests connection on TCP port 119) S: 200 wombatvax news server ready - posting ok (client asks for a current newsgroup list) C: LIST S: 215 list of newsgroups follows S: net.wombats 00543 00501 y S: net.unix-wizards 10125 10011 y (more information here) S: net.idiots 00100 00001 n S: . (client selects a newsgroup) C: GROUP net.unix-wizards S: 211 104 10011 10125 net.unix-wizards group selected (there are 104 articles on file, from 10011 to 10125) (client selects an article to read) C: STAT 10110 S: 223 10110 <23445@sdcsvax.ARPA> article retrieved - statistics only (article 10110 selected, its message-id is <23445@sdcsvax.ARPA>) (client examines the header) C: HEAD S: 221 10110 <23445@sdcsvax.ARPA> article retrieved - head follows (text of the header appears here) S: . (client wants to see the text body of the article) C: BODY S: 222 10110 <23445@sdcsvax.ARPA> article retrieved - body follows (body text here) S: . (client selects next article in group) Kantor & Lapsley [Page 20] RFC 977 February 1986 Network News Transfer Protocol C: NEXT S: 223 10113 <21495@nudebch.uucp> article retrieved - statistics only (article 10113 was next in group) (client finishes session) C: QUIT S: 205 goodbye. 4.2. Example 2 - absolute article access with ARTICLE S: (listens at TCP port 119) C: (requests connection on TCP port 119) S: 201 UCB-VAX netnews server ready -- no posting allowed C: GROUP msgs S: 211 103 402 504 msgs Your new group is msgs (there are 103 articles, from 402 to 504) C: ARTICLE 401 S: 423 No such article in this newsgroup C: ARTICLE 402 S: 220 402 <4105@ucbvax.ARPA> Article retrieved, text follows S: (article header and body follow) S: . C: HEAD 403 S: 221 403 <3108@mcvax.UUCP> Article retrieved, header follows S: (article header follows) S: . C: QUIT S: 205 UCB-VAX news server closing connection. Goodbye. 4.3. Example 3 - NEWGROUPS command S: (listens at TCP port 119) C: (requests connection on TCP port 119) S: 200 Imaginary Institute News Server ready (posting ok) (client asks for new newsgroups since April 3, 1985) C: NEWGROUPS 850403 020000 S: 231 New newsgroups since 03/04/85 02:00:00 follow Kantor & Lapsley [Page 21] RFC 977 February 1986 Network News Transfer Protocol S: net.music.gdead S: net.games.sources S: . C: GROUP net.music.gdead S: 211 0 1 1 net.music.gdead Newsgroup selected (there are no articles in that newsgroup, and the first and last article numbers should be ignored) C: QUIT S: 205 Imaginary Institute news server ceasing service. Bye! 4.4. Example 4 - posting a news article S: (listens at TCP port 119) C: (requests connection on TCP port 119) S: 200 BANZAIVAX news server ready, posting allowed. C: POST S: 340 Continue posting; Period on a line by itself to end C: (transmits news article in RFC850 format) C: . S: 240 Article posted successfully. C: QUIT S: 205 BANZAIVAX closing connection. Goodbye. 4.5. Example 5 - interruption due to operator request S: (listens at TCP port 119) C: (requests connection on TCP port 119) S: 201 genericvax news server ready, no posting allowed. (assume normal conversation for some time, and that a newsgroup has been selected) C: NEXT S: 223 1013 <5734@mcvax.UUCP> Article retrieved; text separate. C: HEAD C: 221 1013 <5734@mcvax.UUCP> Article retrieved; head follows. S: (sends head of article, but halfway through is interrupted by an operator request. The following then occurs, without client intervention.) Kantor & Lapsley [Page 22] RFC 977 February 1986 Network News Transfer Protocol S: (ends current line with a CR-LF pair) S: . S: 400 Connection closed by operator. Goodbye. S: (closes connection) 4.6. Example 6 - Using the news server to distribute news between systems. S: (listens at TCP port 119) C: (requests connection on TCP port 119) S: 201 Foobar NNTP server ready (no posting) (client asks for new newsgroups since 2 am, May 15, 1985) C: NEWGROUPS 850515 020000 S: 235 New newsgroups since 850515 follow S: net.fluff S: net.lint S: . (client asks for new news articles since 2 am, May 15, 1985) C: NEWNEWS * 850515 020000 S: 230 New news since 850515 020000 follows S: <1772@foo.UUCP> S: <87623@baz.UUCP> S: <17872@GOLD.CSNET> S: . (client asks for article <1772@foo.UUCP>) C: ARTICLE <1772@foo.UUCP> S: 220 <1772@foo.UUCP> All of article follows S: (sends entire message) S: . (client asks for article <87623@baz.UUCP> C: ARTICLE <87623@baz.UUCP> S: 220 <87623@baz.UUCP> All of article follows S: (sends entire message) S: . (client asks for article <17872@GOLD.CSNET> C: ARTICLE <17872@GOLD.CSNET> S: 220 <17872@GOLD.CSNET> All of article follows S: (sends entire message) S: . Kantor & Lapsley [Page 23] RFC 977 February 1986 Network News Transfer Protocol (client offers an article it has received recently) C: IHAVE <4105@ucbvax.ARPA> S: 435 Already seen that one, where you been? (client offers another article) C: IHAVE <4106@ucbvax.ARPA> S: 335 News to me! to end. C: (sends article) C: . S: 235 Article transferred successfully. Thanks. (or) S: 436 Transfer failed. (client is all through with the session) C: QUIT S: 205 Foobar NNTP server bids you farewell. 4.7. Summary of commands and responses. The following are the commands recognized and responses returned by the NNTP server. 4.7.1. Commands ARTICLE BODY GROUP HEAD HELP IHAVE LAST LIST NEWGROUPS NEWNEWS NEXT POST QUIT SLAVE STAT 4.7.2. Responses 100 help text follows 199 debug output Kantor & Lapsley [Page 24] RFC 977 February 1986 Network News Transfer Protocol 200 server ready - posting allowed 201 server ready - no posting allowed 202 slave status noted 205 closing connection - goodbye! 211 n f l s group selected 215 list of newsgroups follows 220 n article retrieved - head and body follow 221 n article retrieved - head follows 222 n article retrieved - body follows 223 n article retrieved - request text separately 230 list of new articles by message-id follows 231 list of new newsgroups follows 235 article transferred ok 240 article posted ok 335 send article to be transferred. End with . 340 send article to be posted. End with . 400 service discontinued 411 no such news group 412 no newsgroup has been selected 420 no current article has been selected 421 no next article in this group 422 no previous article in this group 423 no such article number in this group 430 no such article found 435 article not wanted - do not send it 436 transfer failed - try again later 437 article rejected - do not try again. 440 posting not allowed 441 posting failed 500 command not recognized 501 command syntax error 502 access restriction or permission denied 503 program fault - command not performed 4.8. A Brief Word about the USENET News System In the UNIX world, which traditionally has been linked by 1200 baud dial-up telephone lines, the USENET News system has evolved to handle central storage, indexing, retrieval, and distribution of news. With the exception of its underlying transport mechanism (UUCP), USENET News is an efficient means of providing news and bulletin service to subscribers on UNIX and other hosts worldwide. The USENET News Kantor & Lapsley [Page 25] RFC 977 February 1986 Network News Transfer Protocol system is discussed in detail in RFC 850. It runs on most versions of UNIX and on many other operating systems, and is customarily distributed without charge. USENET uses a spooling area on the UNIX host to store news articles, one per file. Each article consists of a series of heading text, which contain the sender's identification and organizational affiliation, timestamps, electronic mail reply paths, subject, newsgroup (subject category), and the like. A complete news article is reproduced in its entirety below. Please consult RFC 850 for more details. Relay-Version: version B 2.10.3 4.3bsd-beta 6/6/85; site sdcsvax.UUCP Posting-Version: version B 2.10.1 6/24/83 SMI; site unitek.uucp Path:sdcsvax!sdcrdcf!hplabs!qantel!ihnp4!alberta!ubc-vision!unitek !honman From: honman@unitek.uucp (Man Wong) Newsgroups: net.unix-wizards Subject: foreground -> background ? Message-ID: <167@unitek.uucp> Date: 25 Sep 85 23:51:52 GMT Date-Received: 29 Sep 85 09:54:48 GMT Reply-To: honman@unitek.UUCP (Hon-Man Wong) Distribution: net.all Organization: Unitek Technologies Corporation Lines: 12 I have a process (C program) which generates a child and waits for it to return. What I would like to do is to be able to run the child process interactively for a while before kicking itself into the background so I can return to the parent process (while the child process is RUNNING in the background). Can it be done? And if it can, how? Please reply by E-mail. Thanks in advance. Hon-Man Wong Kantor & Lapsley [Page 26] RFC 977 February 1986 Network News Transfer Protocol 5. References [1] Crocker, D., "Standard for the Format of ARPA Internet Text Messages", RFC-822, Department of Electrical Engineering, University of Delaware, August, 1982. [2] Horton, M., "Standard for Interchange of USENET Messages", RFC-850, USENET Project, June, 1983. [3] Postel, J., "Transmission Control Protocol- DARPA Internet Program Protocol Specification", RFC-793, USC/Information Sciences Institute, September, 1981. [4] Postel, J., "Simple Mail Transfer Protocol", RFC-821, USC/Information Sciences Institute, August, 1982. 6. Acknowledgements The authors wish to express their heartfelt thanks to those many people who contributed to this specification, and especially to Erik Fair and Chuq von Rospach, without whose inspiration this whole thing would not have been necessary. 7. Notes <1> UNIX is a trademark of Bell Laboratories. Kantor & Lapsley [Page 27] unpost/nntp/in.h100644 23453 0 15755 5457221012 13554 0ustar jeanpaulsystem#ifndef __netinet_in__ #define __netinet_in__ /* * Copyright (c) 1982, 1986, 1990 Regents of the University of California. * All rights reserved. * * Redistribution is only permitted until one year after the first shipment * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and * binary forms are permitted provided that: (1) source distributions retain * this entire copyright notice and comment, and (2) distributions including * binaries display the following acknowledgement: This product includes * software developed by the University of California, Berkeley and its * contributors'' in the documentation or other materials provided with the * distribution and in all advertising materials mentioning features or use * of this software. Neither the name of the University nor the names of * its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. * * @(#)in.h 7.10 (Berkeley) 6/28/90 plus MULTICAST 1.1 */ /* * Constants and structures defined by the internet system, * Per RFC 790, September 1981. */ /* * Protocols */ #define IPPROTO_IP 0 /* dummy for IP */ #define IPPROTO_ICMP 1 /* control message protocol */ #ifdef sgi /* MULTICAST */ #define IPPROTO_IGMP 2 /* group mgmt protocol */ #endif #define IPPROTO_GGP 3 /* gateway^2 (deprecated) */ #define IPPROTO_TCP 6 /* tcp */ #define IPPROTO_EGP 8 /* exterior gateway protocol */ #define IPPROTO_PUP 12 /* pup */ #define IPPROTO_UDP 17 /* user datagram protocol */ #define IPPROTO_IDP 22 /* xns idp */ #define IPPROTO_TP 29 /* tp-4 w/ class negotiation */ #ifdef sgi #define IPPROTO_XTP 36 /* XTP */ #endif #define IPPROTO_EON 80 /* ISO cnlp */ #define IPPROTO_RAW 255 /* raw IP packet */ #define IPPROTO_MAX 256 /* * Local port number conventions: * Ports < IPPORT_RESERVED are reserved for * privileged processes (e.g. root). * Ports > IPPORT_USERRESERVED are reserved * for servers, not necessarily privileged. */ #define IPPORT_RESERVED 1024 #define IPPORT_USERRESERVED 5000 /* * Internet address (a structure for historical reasons) struct in_addr { u_long s_addr; }; */ struct in_addr { union { struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b; struct { u_short s_w1,s_w2; } S_un_w; u_long S_addr; } S_un; #define s_addr S_un.S_addr /* can be used for most tcp & ip code */ #define s_host S_un.S_un_b.s_b2 /* host on imp */ #define s_net S_un.S_un_b.s_b1 /* network */ #define s_imp S_un.S_un_w.s_w2 /* imp */ #define s_impno S_un.S_un_b.s_b4 /* imp # */ #define s_lh S_un.S_un_b.s_b3 /* logical host */ }; /* * Definitions of bits in internet address integers. * On subnets, the decomposition of addresses to host and net parts * is done according to subnet mask, not the masks here. */ #define IN_CLASSA(i) (((long)(i) & 0x80000000) == 0) #define IN_CLASSA_NET 0xff000000 #define IN_CLASSA_NSHIFT 24 #define IN_CLASSA_HOST 0x00ffffff #define IN_CLASSA_MAX 128 #define IN_CLASSB(i) (((long)(i) & 0xc0000000) == 0x80000000) #define IN_CLASSB_NET 0xffff0000 #define IN_CLASSB_NSHIFT 16 #define IN_CLASSB_HOST 0x0000ffff #define IN_CLASSB_MAX 65536 #define IN_CLASSC(i) (((long)(i) & 0xe0000000) == 0xc0000000) #define IN_CLASSC_NET 0xffffff00 #define IN_CLASSC_NSHIFT 8 #define IN_CLASSC_HOST 0x000000ff #define IN_CLASSD(i) (((long)(i) & 0xf0000000) == 0xe0000000) #ifdef sgi /* MULTICAST */ #define IN_CLASSD_NET 0xf0000000 /* These ones aren't really */ #define IN_CLASSD_NSHIFT 28 /* net and host fields, but */ #define IN_CLASSD_HOST 0x0fffffff /* routing needn't know. */ #endif #define IN_MULTICAST(i) IN_CLASSD(i) #define IN_EXPERIMENTAL(i) (((long)(i) & 0xe0000000) == 0xe0000000) #define IN_BADCLASS(i) (((long)(i) & 0xf0000000) == 0xf0000000) #define INADDR_ANY (u_long)0x00000000 #define INADDR_BROADCAST (u_long)0xffffffff /* must be masked */ #ifdef sgi /* SunOS */ #define INADDR_LOOPBACK (u_long)0x7F000001 #endif #ifdef sgi /* MULTICAST */ #define INADDR_UNSPEC_GROUP (u_long)0xe0000000 /* 224.0.0.0 */ #define INADDR_ALLHOSTS_GROUP (u_long)0xe0000001 /* 224.0.0.1 */ #define INADDR_MAX_LOCAL_GROUP (u_long)0xe00000ff /* 224.0.0.255 */ #endif #ifndef _KERNEL #define INADDR_NONE 0xffffffff /* -1 return */ #endif #define IN_LOOPBACKNET 127 /* official! */ /* * Socket address, internet style. */ struct sockaddr_in { short sin_family; u_short sin_port; struct in_addr sin_addr; char sin_zero[8]; }; /* * Structure used to describe IP options. * Used to store options internally, to pass them to a process, * or to restore options retrieved earlier. * The ip_dst is used for the first-hop gateway when using a source route * (this gets put into the header proper). */ struct ip_opts { struct in_addr ip_dst; /* first hop, 0 w/o src rt */ char ip_opts[40]; /* actually variable in size */ }; /* * Options for use with [gs]etsockopt at the IP level. * First word of comment is data type; bool is stored in int. */ #define IP_OPTIONS 1 /* buf/ip_opts; set/get IP per-packet options */ #define IP_HDRINCL 7 /* int; header is included with data (raw) */ #define IP_TOS 8 /* int; IP type of service and precedence */ #define IP_TTL 9 /* int; IP time to live */ #ifdef notdef /* not implemented yet */ #define IP_RECVOPTS 10 /* bool; receive all IP options w/datagram */ #define IP_RECVRETOPTS 11 /* bool; receive IP options for response */ #define IP_RECVDSTADDR 12 /* bool; receive IP dst addr w/datagram */ #define IP_RETOPTS 13 /* ip_opts; set/get IP per-packet options */ #endif #ifdef sgi /* MULTICAST */ #define IP_MULTICAST_IF 2 /* in_addr; set/get IP multicast interface */ #define IP_MULTICAST_TTL 3 /* u_char; set/get IP multicast timetolive */ #define IP_MULTICAST_LOOP 4 /* u_char; set/get IP multicast loopback */ #define IP_ADD_MEMBERSHIP 5 /* ip_mreq; add an IP group membership */ #define IP_DROP_MEMBERSHIP 6 /* ip_mreq; drop an IP group membership */ /* End of [gs]etsockopt options */ #define IP_DEFAULT_MULTICAST_TTL 1 /* normally limit m'casts to 1 hop */ #define IP_DEFAULT_MULTICAST_LOOP 1 /* normally hear sends if a member */ #define IP_MAX_MEMBERSHIPS 20 /* per socket; must fit in one mbuf */ /* * Argument structure for IP_ADD_MEMBERSHIP and IP_DROP_MEMBERSHIP. */ struct ip_mreq { struct in_addr imr_multiaddr; /* IP multicast address of group */ struct in_addr imr_interface; /* local IP address of interface */ }; #endif /* sgi */ /* * Macros for number representation conversion. */ #define ntohl(x) (x) #define ntohs(x) (x) #define htonl(x) (x) #define htons(x) (x) #ifdef _KERNEL extern struct domain inetdomain; extern struct protosw inetsw[]; struct in_addr in_makeaddr(); u_long in_netof(), in_lnaof(); u_long inet_addr(); #endif #endif /* __netinet_in__ */ unpost/nntp/killfile.cfg100644 23453 0 104 5457221026 15174 0ustar jeanpaulsystemalt.binaries.pictures.misc begin /^Subject:/ /re:/ /request:/ end unpost/nntp/rfc850.txt100644 23453 0 123476 5516773460 14604 0ustar jeanpaulsystem RFC 850 June 1983 Standard for Interchange of USENET Messages Mark R. Horton [ This memo is distributed as an RFC only to make this information easily accessible to researchers in the ARPA community. It does not specify an Internet standard. ] 1. Introduction This document defines the standard format for interchange of Network News articles among USENET sites. It describes the format for articles themselves, and gives partial standards for transmission of news. The news transmission is not entirely standardized in order to give a good deal of flexibility to the individual hosts to choose transmission hardware and software, whether to batch news, and so on. There are five sections to this document. Section two section defines the format. Section three defines the valid control messages. Section four specifies some valid transmission methods. Section five describes the overall news propagation algorithm. 2. Article Format The primary consideration in choosing an article format is that it fit in with existing tools as well as possible. Existing tools include both implementations of mail and news. (The notesfiles system from the University of Illinois is considered a news implementation.) A standard format for mail messages has existed for many years on the ARPANET, and this format meets most of the needs of USENET. Since the ARPANET format is extensible, extensions to meet the additional needs of USENET are easily made within the ARPANET standard. Therefore, the rule is adopted that all USENET news articles must be formatted as valid ARPANET mail messages, according to the ARPANET standard RFC 822. This standard is more restrictive than the ARPANET standard, placing additional requirements on each article and forbidding use of certain ARPANET features. However, it should always be possible to use a tool expecting an ARPANET message to process a news article. In any situation where this standard conflicts with the ARPANET standard, RFC 822 should be considered correct and this standard in error. - 1 - An example message is included to illustrate the fields. Relay-Version: version B 2.10 2/13/83; site cbosgd.UUCP Posting-Version: version B 2.10 2/13/83; site eagle.UUCP Path: cbosgd!mhuxj!mhuxt!eagle!jerry From: jerry@eagle.uucp (Jerry Schwarz) Newsgroups: net.general Subject: Usenet Etiquette -- Please Read Message-ID: <642@eagle.UUCP> Date: Friday, 19-Nov-82 16:14:55 EST Followup-To: net.news Expires: Saturday, 1-Jan-83 00:00:00 EST Date-Received: Friday, 19-Nov-82 16:59:30 EST Organization: Bell Labs, Murray Hill The body of the article comes here, after a blank line. Here is an example of a message in the old format (before the existence of this standard). It is recommended that implementations also accept articles in this format to ease upward conversion. From: cbosgd!mhuxj!mhuxt!eagle!jerry (Jerry Schwarz) Newsgroups: net.general Title: Usenet Etiquette -- Please Read Article-I.D.: eagle.642 Posted: Fri Nov 19 16:14:55 1982 Received: Fri Nov 19 16:59:30 1982 Expires: Mon Jan 1 00:00:00 1990 The body of the article comes here, after a blank line. Some news systems transmit news in the "A" format, which looks like this: Aeagle.642 net.general cbosgd!mhuxj!mhuxt!eagle!jerry Fri Nov 19 16:14:55 1982 Usenet Etiquette - Please Read The body of the article comes here, with no blank line. An article consists of several header lines, followed by a blank line, followed by the body of the message. The header lines consist of a keyword, a colon, a blank, and some additional information. This is a subset of the ARPANET standard, simplified to allow simpler software to handle it. The "from" line may optionally include a full name, in the format above, or use the ARPANET angle bracket syntax. To keep the implementations simple, other formats (for example, with part of the machine address after the close parenthesis) are not allowed. The ARPANET convention of continuation header lines (beginning with a blank or tab) is allowed. - 2 - Certain headers are required, certain headers are optional. Any unrecognized headers are allowed, and will be passed through unchanged. The required headers are Relay-Version, Posting-Version, From, Date, Newsgroups, Subject, Message-ID, Path. The optional headers are Followup-To, Date-Received, Expires, Reply-To, Sender, References, Control, Distribution, Organization. 2.1 Required Headers 2.1.1 Relay-Version This header line shows the version of the program responsible for the transmission of this article over the immediate link, that is, the program that is relaying the article from the next site. For example, suppose site A sends an article to site B, and site B forwards the article to site C. The message being transmitted from A to B would have a Relay-Version header identifying the program running on A, and the message transmitted from B to C would identify the program running on B. This header can be used to interpret older headers in an upward compatible way. Relay-Version must always be the first in a message; thus, all articles meeting this standard will begin with an upper case "R". No other restrictions are placed on the order of header lines. The line contains two fields, separated by semicolons. The fields are the version and the full domain name of the site. The version should identify the system program used (e.g., "B") as well as a version number and version date. For example, the header line might contain Relay-Version: version B 2.10 2/13/83; site cbosgd.UUCP This header should not be passed on to additional sites. A relay program, when passing an article on, should include only its own Relay-Version, not the Relay-Version of some other site. (For upward compatibility with older software, if a Relay-Version is found in a header which is not the first line, it should be assumed to be moved by an older version of news and deleted.) 2.1.2 Posting-Version This header identifies the software responsible for entering this message into the network. It has the same format as Relay-Version. It will normally identify the same site as the Message-ID, unless the posting site is serving as a gateway for a message that already contains a message ID generated by mail. (While it is permissible for a gateway to use an externally generated message ID, the message ID should be checked to ensure it conforms to this standard and to RFC 822.) - 3 - 2.1.3 From The From line contains the electronic mailing address of the person who sent the message, in the ARPA internet syntax. It may optionally also contain the full name of the person, in parentheses, after the electronic address. The electronic address is the same as the entity responsible for originating the article, unless the Sender header is present, in which case the From header might not be verified. Note that in all site and domain names, upper and lower case are considered the same, thus mark@cbosgd.UUCP, mark@cbosgd.uucp, and mark@CBosgD.UUcp are all equivalent. User names may or may not be case sensitive, for example, Billy@cbosgd.UUCP might be different from BillY@cbosgd.UUCP. Programs should avoid changing the case of electronic addresses when forwarding news or mail. RFC 822 specifies that all text in parentheses is to be interpreted as a comment. It is common in ARPANET mail to place the full name of the user in a comment at the end of the From line. This standard specifies a more rigid syntax. The full name is not considered a comment, but an optional part of the header line. Either the full name is omitted, or it appears in parentheses after the electronic address of the person posting the article, or it appears before an electronic address enclosed in angle brackets. Thus, the three permissible forms are: From: mark@cbosgd.UUCP From: mark@cbosgd.UUCP (Mark Horton) From: Mark Horton Full names may contain any printing ASCII characters from space through tilde, with the exceptions that they may not contain parentheses "(" or ")", or angle brackets "<" or ">". Additional restrictions may be placed on full names by the mail standard, in particular, the characters comma ",", colon ":", and semicolon ";" are inadvisable in full names. 2.1.4 Date The Date line (formerly "Posted") is the date, in a format that must be acceptable both to the ARPANET and to the getdate routine, that the article was originally posted to the network. This date remains unchanged as the article is propagated throughout the network. One format that is acceptable to both is Weekday, DD-Mon-YY HH:MM:SS TIMEZONE Several examples of valid dates appear in the sample article above. Note in particular that ctime format: Wdy Mon DD HH:MM:SS YYYY - 4 - is not acceptable because it is not a valid ARPANET date. However, since older software still generates this format, news implementations are encouraged to accept this format and translate it into an acceptable format. The contents of the TIMEZONE field is currently subject to worldwide time zone abbreviations, including the usual American zones (PST, PDT, MST, MDT, CST, CDT, EST, EDT), the other North American zones (Bering through Newfoundland), European zones, Australian zones, and so on. Lacking a complete list at present (and unsure if an unambiguous list exists), authors of software are encouraged to keep this code flexible, and in particular not to assume that time zone names are exactly three letters long. Implementations are free to edit this field, keeping the time the same, but changing the time zone (with an appropriate adjustment to the local time shown) to a known time zone. 2.1.5 Newsgroups The Newsgroups line specifies which newsgroup or newsgroups the article belongs in. Multiple newsgroups may be specified, separated by a comma. Newsgroups specified must all be the names of existing newsgroups, as no new newsgroups will be created by simply posting to them. Wildcards (e.g., the word "all") are never allowed in a Newsgroups line. For example, a newsgroup "net.all" is illegal, although a newsgroup name "net.sport.football" is permitted. If an article is received with a Newsgroups line listing some valid newsgroups and some invalid newsgroups, a site should not remove invalid newsgroups from the list. Instead, the invalid newsgroups should be ignored. For example, suppose site A subscribes to the classes "btl.all" and "net.all", and exchanges news articles with site B, which subscribes to "net.all" but not "btl.all". Suppose A receives an article with "Newsgroups: net.micro,btl.general". This article is passed on to B because B receives net.micro, but B does not receive btl.general. A must leave the Newsgroup line unchanged. If it were to remove "btl.general", the edited header could eventually reenter the "btl.all" class, resulting in an article that is not shown to users subscribing to "btl.general". Also, followups from outside "btl.all" would not be shown to such users. - 5 - 2.1.6 Subject The Subject line (formerly "Title") tells what the article is about. It should be suggestive enough of the contents of the article to enable a reader to make a decision whether to read the article based on the subject alone. If the article is submitted in response to another article (e.g., is a "followup") the default subject should begin with the four characters "Re: " and the References line is required. (The user might wish to edit the subject of the followup, but the default should begin with "Re: ".) 2.1.7 Message-ID The Message-ID line gives the article a unique identifier. The same message ID may not be reused during the lifetime of any article with the same message ID. (It is recommended that no message ID be reused for at least two years.) Message ID's have the syntax "<" "string not containing blank or >" ">" In order to conform to RFC 822, the Message-ID must have the format "<" "unique" "@" "full domain name" ">" where "full domain name" is the full name of the host at which the article entered the network, including a domain that host is in, and unique is any string of printing ASCII characters, not including "<", ">", or "@". For example, the "unique" part could be an integer representing a sequence number for articles submitted to the network, or a short string derived from the date and time the article was created. For example, valid message ID for an article submitted from site ucbvax in domain Berkeley.ARPA would be "<4123@ucbvax.Berkeley.ARPA>". Programmers are urged not to make assumptions about the content of message ID fields from other hosts, but to treat them as unknown character strings. It is not safe, for example, to assume that a message ID will be under 14 characters, nor that it is unique in the first 14 characters. The angle brackets are considered part of the message ID. Thus, in references to the message ID, such as the ihave/sendme and cancel control messages, the angle brackets are included. White space characters (e.g., blank and tab) are not allowed in a message ID. All characters between the angle brackets must be printing ASCII characters. 2.1.8 Path This line shows the path the article took to reach the current system. When a system forwards the message, it should add its own name to the list of systems in the Path line. The names may be separated by any punctuation character or characters, thus - 6 - "cbosgd!mhuxj!mhuxt", "cbosgd, mhuxj, mhuxt", and "@cbosgd.uucp,@mhuxj.uucp,@mhuxt.uucp" and even "teklabs, zehntel, sri-unix@cca!decvax" are valid entries. (The latter path indicates a message that passed through decvax, cca, sri-unix, zehntel, and teklabs, in that order.) Additional names should be added from the left, for example, the most recently added name in the third example was "teklabs". Letters, digits, periods and hyphens are considered part of site names; other punctuation, including blanks, are considered separators. Normally, the rightmost name will be the name of the originating system. However, it is also permissible to include an extra entry on the right, which is the name of the sender. This is for upward compatibility with older system. The Path line is not used for replies, and should not be taken as a mailing address. It is intended to show the route the message travelled to reach the local site. There are several uses for this information. One is to monitor USENET routing for performance reasons. Another is to establish a path to reach new sites. Perhaps the most important is to cut down on redundant USENET traffic by failing to forward a message to a site that is known to have already received it. In particular, when site A sends an article to site B, the Path line includes "A", so that site B will not immediately send the article back to site A. The site name each site uses to identify itself should be the same as the name by which its neighbors know it, in order to make this optimization possible. A site adds its own name to the front of a path when it receives a message from another site. Thus, if a message with path A!X!Y!Z is passed from site A to site B, B will add its own name to the path when it receives the message from A, e.g., B!A!X!Y!Z. If B then passes the message on to C, the message sent to C will contain the path B!A!X!Y!Z, and when C receives it, C will change it to C!B!A!X!Y!Z. Special upward compatibility note: Since the From, Sender, and Reply-To lines are in internet format, and since many USENET sites do not yet have mailers capable of understanding internet format, it would break the reply capability to completely sever the connection between the Path header and the reply function. Thus, sites are required to continue to keep the Path line in a working reply format as much as possible, until January 1, 1984. It is recognized that the path is not always a valid reply string in older implementations, and no requirement to fix this problem is placed on implementations. However, the - 7 - existing convention of placing the site name and an "!" at the front of the path, and of starting the path with the site name, an "!", and the user name, should be maintained at least until 1984. 2.2 Optional Headers 2.2.1 Reply-To This line has the same format as From. If present, mailed replies to the author should be sent to the name given here. Otherwise, replies are mailed to the name on the From line. (This does not prevent additional copies from being sent to recipients named by the replier, or on To or Cc lines.) The full name may be optionally given, in parentheses, as in the From line. 2.2.2 Sender This field is present only if the submitter manually enters a From line. It is intended to record the entity responsible for submitting the article to the network, and should be verified by the software at the submitting site. For example, if John Smith is visiting CCA and wishes to post an article to the network, using friend Sarah Jones account, the message might read From: smith@ucbvax.uucp (John Smith) Sender: jones@cca.arpa (Sarah Jones) If a gateway program enters a mail message into the network at site sri-unix, the lines might read From: John.Doe@CMU-CS-A.ARPA Sender: network@sri-unix.ARPA The primary purpose of this field is to be able to track down articles to determine how they were entered into the network. The full name may be optionally given, in parentheses, as in the From line. 2.2.3 Followup-To This line has the same format as Newsgroups. If present, follow-up articles are to be posted to the newsgroup(s) listed here. If this line is not present, followups are posted to the newsgroup(s) listed in the Newsgroups line, except that followups to "net.general" should instead go to "net.followup". 2.2.4 Date-Received This line (formerly "Received") is in a legal USENET date format. It records the date and time that the article was first received on the local system. If this line is present in an article being transmitted from one host to another, the receiving host should ignore it and replace it with the current date. Since this field is intended for local use only, no site is required to support it. However, no site should pass this field on to another site unchanged. - 8 - 2.2.5 Expires This line, if present, is in a legal USENET date format. It specifies a suggested expiration date for the article. If not present, the local default expiration date is used. This field is intended to be used to clean up articles with a limited usefulness, or to keep important articles around for longer than usual. For example, a message announcing an upcoming seminar could have an expiration date the day after the seminar, since the message is not useful after the seminar is over. Since local sites have local policies for expiration of news (depending on available disk space, for instance), users are discouraged from providing expiration dates for articles unless there is a natural expiration date associated with the topic. System software should almost never provide a default Expires line. Leave it out and allow local policies to be used unless there is a good reason not to. 2.2.6 References This field lists the message ID's of any articles prompting the submission of this article. It is required for all follow-up articles, and forbidden when a new subject is raised. Implementations should provide a follow-up command, which allows a user to post a follow-up article. This command should generate a Subject line which is the same as the original article, except that if the original subject does not begin with "Re: " or "re: ", the four characters "Re: " are inserted before the subject. If there is no References line on the original header, the References line should contain the message ID of the original article (including the angle brackets). If the original article does have a References line, the followup article should have a References line containing the text of the original References line, a blank, and the message ID of the original article. The purpose of the References header is to allow articles to be grouped into conversations by the user interface program. This allows conversations within a newsgroup to be kept together, and potentially users might shut off entire conversations without unsubscribing to a newsgroup. User interfaces may not make use of this header, but all automatically generated followups should generate the References line for the benefit of systems that do use it, and manually generated followups (e.g. typed in well after the original article has been printed by the machine) should be encouraged to include them as well. 2.2.7 Control If an article contains a Control line, the article is a control message. Control messages are used for communication among USENET host machines, not to be read by users. Control messages are distributed by the same newsgroup mechanism as ordinary messages. The body of the Control header line is the message to the host. - 9 - For upward compatibility, messages that match the newsgroup pattern "all.all.ctl" should also be interpreted as control messages. If no Control: header is present on such messages, the subject is used as the control message. However, messages on newsgroups matching this pattern do not conform to this standard. 2.2.8 Distribution This line is used to alter the distribution scope of the message. It has the same format as the Newsgroups line. User subscriptions are still controlled by Newsgroups, but the message is sent to all systems subscribing to the newsgroups on the Distribution line instead of the Newsgroups line. Thus, a car for sale in New Jersey might have headers including Newsgroups: net.auto,net.wanted Distribution: nj.all so that it would only go to persons subscribing to net.auto or net.wanted within New Jersey. The intent of this header is to further restrict the distribution of a newsgroup, not to increase it. A local newsgroup, such as nj.crazy-eddie, will probably not be propagated by sites outside New Jersey that do not show such a newsgroup as valid. Wildcards in newsgroup names in the Distribution line are allowed. Followup articles should default to the same Distribution line as the original article, but the user can change it to a more limited one, or escalate the distribution if it was originally restricted and a more widely distributed reply is appropriate. 2.2.9 Organization The text of this line is a short phrase describing the organization to which the sender belongs, or to which the machine belongs. The intent of this line is to help identify the person posting the message, since site names are often cryptic enough to make it hard to recognize the organization by the electronic address. 3. Control Messages This section lists the control messages currently defined. The body of the Control header is the control message. Messages are a sequence of zero or more words, separated by white space (blanks or tabs). The first word is the name of the control message, remaining words are parameters to the message. The remainder of the header and the body of the message are also potential parameters; for example, the From line might suggest an address to which a response is to be mailed. - 10 - Implementors and administrators may choose to allow control messages to be automatically carried out, or to queue them for manual processing. However, manually processed messages should be dealt with promptly. 3.1 Cancel cancel If an article with the given message ID is present on the local system, the article is cancelled. This mechanism allows a user to cancel an article after the article has been distributed over the network. Only the author of the article or the local super user is allowed to use this message. The verified sender of a message is the Sender line, or if no Sender line is present, the From line. The verified sender of the cancel message must be the same as either the Sender or From field of the original message. A verified sender in the cancel message is allowed to match an unverified From in the original message. 3.2 Ihave/Sendme ihave sendme This message is part of the "ihave/sendme" protocol, which allows one site (say "A") to tell another site ("B") that a particular message has been received on A. Suppose that site A receives article "ucbvax.1234", and wishes to transmit the article to site B. A sends the control message "ihave ucbvax.1234 A" to site B (by posting it to newsgroup "to.B"). B responds with the control message "sendme ucbvax.1234 B" (on newsgroup to.A) if it has not already received the article. Upon receiving the Sendme message, A sends the article to B. This protocol can be used to cut down on redundant traffic between sites. It is optional and should be used only if the particular situation makes it worthwhile. Frequently, the outcome is that, since most original messages are short, and since there is a high overhead to start sending a new message with UUCP, it costs as much to send the Ihave as it would cost to send the article itself. One possible solution to this overhead problem is to batch requests. Several message ID's may be announced or requested in one message. If no message ID's are listed in the control message, the body of the message should be scanned for message ID's, one per line. - 11 - 3.3 Newgroup newgroup This control message creates a new newsgroup with the name given. Since no articles may be posted or forwarded until a newsgroup is created, this message is required before a newsgroup can be used. The body of the message is expected to be a short paragraph describing the intended use of the newsgroup. 3.4 Rmgroup rmgroup This message removes a newsgroup with the given name. Since the newsgroup is removed from every site on the network, this command should be used carefully by a responsible administrator. 3.5 Sendsys sendsys (no arguments) The "sys" file, listing all neighbors and which newsgroups are sent to each neighbor, will be mailed to the author of the control message (Reply-to, if present, otherwise From). This information is considered public information, and it is a requirement of membership in USENET that this information be provided on request, either automatically in response to this control message, or manually, by mailing the requested information to the author of the message. This information is used to keep the map of USENET up to date, and to determine where netnews is sent. The format of the file mailed back to the author should be the same as that of the "sys" file. This format has one line per neighboring site (plus one line for the local site), containing four colon separated fields. The first field has the site name of the neighbor, the second field has a newsgroup pattern describing the newsgroups sent to the neighbor. The third and fourth fields are not defined by this standard. A sample response: From cbosgd!mark Sun Mar 27 20:39:37 1983 Subject: response to your sendsys request To: mark@cbosgd.UUCP - 12 - Responding-System: cbosgd.UUCP cbosgd:osg,cb,btl,bell,net,fa,to,test ucbvax:net,fa,to.ucbvax:L: cbosg:net,fa,bell,btl,cb,osg,to.cbosg:F:/usr/spool/outnews/cbosg cbosgb:osg,to.cbosgb:F:/usr/spool/outnews/cbosgb sescent:net,fa,bell,btl,cb,to.sescent:F:/usr/spool/outnews/sescent npois:net,fa,bell,btl,ug,to.npois:F:/usr/spool/outnews/npois mhuxi:net,fa,bell,btl,ug,to.mhuxi:F:/usr/spool/outnews/mhuxi 3.6 Senduuname senduuname (no arguments) The "uuname" program is run, and the output is mailed to the author of the control message (Reply-to, if present, otherwise From). This program lists all uucp neighbors of the local site. This information is used to make maps of the UUCP network. The sys file is not the same as the UUCP L.sys file. The L.sys file should never be transmitted to another party without the consent of the sites whose passwords are listed therein. It is optional for a site to provide this information. Some reply should be made to the author of the control message, so that a transmission error won't be blamed. It is also permissible for a site to run the uuname program (or in some other way determine the uucp neighbors) and edit the output, either automatically or manually, before mailing the reply back to the author. The file should contain one site per line, beginning with the uucp site name. Additional information may be included, separated from the site name by a blank or tab. The phone number or password for the site should NOT be included, as the reply is considered to be in the public domain. (The uuname program will send only the site name and not the entire contents of the L.sys file, thus, phone numbers and passwords are not transmitted.) The purpose of this message is to generate and maintain UUCP mail routing maps. Thus, connections over which mail can be sent using the site!user syntax should be included, regardless of whether the link is actually a UUCP link at the physical level. If a mail router should use it, it should be included. Since all information sent in response to this message is optional, sites are free to edit the list, deleting secret or private links they do not wish to publicise. 3.7 Version version (no arguments) The name and version of the software running on the local system is to be mailed back to the author of the article (Reply-to if present, otherwise From). - 13 - 4. Transmission Methods USENET is not a physical network, but rather a logical network resting on top of several existing physical networks. These networks include, but are not limited to, UUCP, the ARPANET, an Ethernet, the BLICN network, an NSC Hyperchannel, and a Berknet. What is important is that two neighboring systems on USENET have some method to get a new article, in the format listed here, from one system to the other, and once on the receiving system, processed by the netnews software on that system. (On UNIX systems, this usually means the "rnews" program being run with the article on the standard input.) It is not a requirement that USENET sites have mail systems capable of understanding the ARPA Internet mail syntax, but it is strongly recommended. Since From, Reply-To, and Sender lines use the Internet syntax, replies will be difficult or impossible without an internet mailer. A site without an internet mailer can attempt to use the Path header line for replies, but this field is not guaranteed to be a working path for replies. In any event, any site generating or forwarding news messages must have an internet address that allows them to receive mail from sites with internet mailers, and they must include their internet address on their From line. 4.1 Remote Execution Some networks permit direct remote command execution. On these networks, news may be forwarded by spooling the rnews command with the article on the standard input. For example, if the remote system is called "remote", news would be sent over a UUCP link with the command "uux - remote!rnews", and on a Berknet, "net -mremote rnews". It is important that the article be sent via a reliable mechansim, normally involving the possibility of spooling, rather than direct real-time remote execution. This is because, if the remote system is down, a direct execution command will fail, and the article will never be delivered. If the article is spooled, it will eventually be delivered when both systems are up. 4.2 Transfer by Mail On some systems, direct remote spooled execution is not possible. However, most systems support electronic mail, and a news article can be sent as mail. One approach is to send a mail message which is identical to the news message: the mail headers are the news headers, and the mail body is the news body. By convention, this mail is sent to the user "newsmail" on the remote machine. - 14 - One problem with this method is that it may not be possible to convince the mail system that the From line of the message is valid, since the mail message was generated by a program on a system different from the source of the news article. Another problem is that error messages caused by the mail transmission would be sent to the originator of the news article, who has no control over news transmission between two cooperating hosts and does not know who to contact. Transmission error messages should be directed to a responsible contact person on the sending machine. A solution to this problem is to encapsulate the news article into a mail message, such that the entire article (headers and body) are part of the body of the mail message. The convention here is that such mail is sent to user "rnews" on the remote system. A mail message body is generated by prepending the letter "N" to each line of the news article, and then attaching whatever mail headers are convenient to generate. The N's are attached to prevent any special lines in the news article from interfering with mail transmission, and to prevent any extra lines inserted by the mailer (headers, blank lines, etc.) from becoming part of the news article. A program on the receiving machine receives mail to "rnews", extracting the article itself and invoking the "rnews" program. An example in this format might look like this: Date: Monday, 3-Jan-83 08:33:47 MST From: news@cbosgd.UUCP Subject: network news article To: rnews@npois.UUCP NRelay-Version: B 2.10 2/13/83 cbosgd.UUCP NPosting-Version: B 2.9 6/21/82 sask.UUCP NPath: cbosgd!mhuxj!harpo!utah-cs!sask!derek NFrom: derek@sask.UUCP (Derek Andrew) NNewsgroups: net.test NSubject: necessary test NMessage-ID: <176@sask.UUCP> NDate: Monday, 3-Jan-83 00:59:15 MST N NThis really is a test. If anyone out there more than 6 Nhops away would kindly confirm this note I would Nappreciate it. We suspect that our news postings Nare not getting out into the world. N Using mail solves the spooling problem, since mail must always be spooled if the destination host is down. However, it adds more overhead to the transmission process (to encapsulate and extract the article) and makes it harder for software to give different priorities to news and mail. - 15 - 4.3 Batching Since news articles are usually short, and since a large number of messages are often sent between two sites in a day, it may make sense to batch news articles. Several articles can be combined into one large article, using conventions agreed upon in advance by the two sites. One such batching scheme is described here; its use is still considered experimental. News articles are combined into a script, separated by a header of the form: ##! rnews 1234 where 1234 is the length, in bytes, of the article. Each such line is followed by an article containing the given number of bytes. (The newline at the end of each line of the article is counted as one byte, for purposes of this count, even if it is stored as CRLF.) For example, a batch of articles might look like this: #! rnews 374 Relay-Version: version B 2.10 2/13/83; site cbosgd.UUCP Posting-Version: version B 2.10 2/13/83; site eagle.UUCP Path: cbosgd!mhuxj!mhuxt!eagle!jerry From: jerry@eagle.uucp (Jerry Schwarz) Newsgroups: net.general Subject: Usenet Etiquette -- Please Read Message-ID: <642@eagle.UUCP> Date: Friday, 19-Nov-82 16:14:55 EST Here is an important message about USENET Etiquette. #! rnews 378 Relay-Version: version B 2.10 2/13/83; site cbosgd.UUCP Posting-Version: version B 2.10 2/13/83; site eagle.UUCP Path: cbosgd!mhuxj!mhuxt!eagle!jerry From: jerry@eagle.uucp (Jerry Schwarz) Newsgroups: net.followup Subject: Notes on Etiquette article Message-ID: <643@eagle.UUCP> Date: Friday, 19-Nov-82 17:24:12 EST There was something I forgot to mention in the last message. Batched news is recognized because the first character in the message is "#". The message is then passed to the unbatcher for interpretation. - 16 - 5. The News Propagation Algorithm This section describes the overall scheme of USENET and the algorithm followed by sites in propagating news to the entire network. Since all sites are affected by incorrectly formatted articles and by propagation errors, it is important for the method to be standardized. USENET is a directed graph. Each node in the graph is a host computer, each arc in the graph is a transmission path from one host to another host. Each arc is labelled with a newsgroup pattern, specifying which newsgroup classes are forwarded along that link. Most arcs are bidirectional, that is, if site A sends a class of newsgroups to site B, then site B usually sends the same class of newsgroups to site A. This bidirectionality is not, however, required. USENET is made up of many subnetworks. Each subnet has a name, such as "net" or "btl". The special subnet "net" is defined to be USENET, although the union of all subnets may be a superset of USENET (because of sites that get local newsgroup classes but do not get net.all). Each subnet is a connected graph, that is, a path exists from every node to every other node in the subnet. In addition, the entire graph is (theoretically) connected. (In practice, some political considerations have caused some sites to be unable to post articles reaching the rest of the network.) An article is posted on one machine to a list of newsgroups. That machine accepts it locally, then forwards it to all its neighbors that are interested in at least one of the newsgroups of the message. (Site A deems site B to be "interested" in a newsgroup if the newsgroup matches the pattern on the arc from A to B. This pattern is stored in a file on the A machine.) The sites receiving the incoming article examine it to make sure they really want the article, accept it locally, and then in turn forward the article to all their interest neighbors. This process continues until the entire network has seen the article. An important part of the algorithm is the prevention of loops. The above process would cause a message to loop along a cycle forever. In particular, when site A sends an article to site B, site B will send it back to site A, which will send it to site B, and so on. One solution to this is the history mechanism. Each site keeps track of all articles it has seen (by their message ID) and whenever an article comes in that it has already seen, the incoming article is discarded immediately. This solution is sufficient to prevent loops, but additional optimizations can be made to avoid sending articles to sites that will simply throw them away. - 17 - One optimization is that an article should never be sent to a machine listed in the Path line of the header. When a machine name is in the Path line, the message is known to have passed through the machine. Another optimization is that, if the article originated on site A, then site A has already seen the article. (Origination can be determined by the Posting-Version line.) Thus, if an article is posted to newsgroup "net.misc", it will match the pattern "net.all" (where "all" is a metasymbol that matches any string), and will be forwarded to all sites that subscribe to net.all (as determined by what their neighbors send them). These sites make up the "net" subnetwork. An article posted to "btl.general" will reach all sites receiving "btl.all", but will not reach sites that do not get "btl.all". In effect, the articles reaches the "btl" subnetwork. An article posted to newsgroups "net.micro,btl.general" will reach all sites subscribing to either of the two classes. - 18 - unpost/problems.doc100644 23453 0 25361 5517261552 14334 0ustar jeanpaulsystemProblem: I save a bunch of articles from (not rn) newsreader to a file called source.uue, run UNPOST on source.uue using the command line: unpost -e errors -t text -i incomp source.uue The errors file only has the following two lines in it: File ID Segments ---------------------------------------- What is wrong with UNPOST? Answer: Nothing at all. There are many different ways of getting news and that means that the header lines differ from news source to news source. By default, UNPOST assumes that each SEGMENT begins with a line that can be matched by the regular expression: /^Article[:]?/ This works for rn, and CLIENT, but does not work, for example, for nn. There are two ways to fix this. The easiest is to read the UNPOST.DOC file under the heading: Theory of Operations: and then use the -r switch (also described in UNPOST.DOC) to configure UNPOST to look for the right header line. The second way to fix this problem is to start with one of the existing configuration files (found in the cfg directory) and edit it to work for your news headers. Please read ALL of the UNPOST.DOC file before attempting this, and make heavy use of the retest program before assuming that your configuration file is correct (or that UNPOST is broken). Problem: UNPOST properly recognizes SEGMENTS that belong together but it makes a mistake in parsing the Subject: line in that the Subject: line says that there are only two segments, but UNPOST says that segment three is missing. What is wrong with UNPOST? Answer: UNPOST looks at both the Subject: line of the first article and the body of an article to find three pieces of information: 1) The binary ID string, which is used to link articles together. 2) The part number. 3) The total number of parts. UNPOST works on a last one found wins algorithm. What is most probably happening is that the Subject: line is correct and probably says something like: Subject: - filename (Part 1/2) Interesting binary file but somewhere in the body, there is signature from an Auto-Posting program that is wrong, such as: Auto-Post for Windows part 1 of 3 parts, Author I-Made-A-Mistake UNPOST's configuration tells it that the Auto-Post article body line is valid, so the Auto-Post signature over rides the Subject: line and now UNPOST thinks that this posting must have three parts. There are two ways to solve this problem: 1) Edit the configuration (in the source code or in your own configuration file) to remove the regular expression that recognizes the Auto-Post signature. 2) Edit the articles to remove the Auto-Post signature, and send a bug report to the author of Auto-Post. (Actually, UNPOST can be configured to look at ANY header line to get it's three pieces of information, but the standard is to look at the Subject: line. By writing your own configuration file, UNPOST can be configured to do amazing things. . .) Problem: I don't get my news from an NNTP news server. Instead, I get it from a news spool directory on my system. How can I use CLIENT to automatically read the news groups that I am interested in and extract binaries for me? Answer: You can't. CLIENT is specifically designed to be a client for an NNTP news reader. How ever, version 2.2.0 of UNPOST can accept a list of file names to process from either an input file or standard in. You could use this facility, awk, grep, sed and other Unix tools to create a simple utility to look into the proper news spool directory and extract binaries from there. CRON is the most important tool, however, as it is the tool that you will used to schedule jobs to be run automatically. Problem: My news server automatically strips trailing spaces at the end of lines. How come UNPOST cannot recognize and unpost uuencoded lines with truncated trailing spaces? Answer: UNPOST uses a multi-criteria algorithm for recognizing uuencoded data lines in postings. To be a uuencoded line (and be recognized as such) a line must fit one of the following categories: 1) The line must match the regular expression: /^begin[ \t]+[0-6]+[ \t]+[^ \t]+/ 2) The line must match the regular expression: /^end$/ 3) The line must be composed of only characters in the set [ -`], and it's length must be equal to: (ordinal(First character on line) - 32) / 3 * 4 + 1 OR (ordinal(First character on line) - 32) / 3 * 4 + 2 [ For purists, this isn't exactly correct, because most uuencoders put out four characters at the end of the last line, even if all four are not necessary. . . This is considered a special case that is taken care of by some finicky modulo 4 and if statement processing. ] For example, most uuencoded lines start with 'M'. The ordinal value of 'M' is 77 decimal. This means that the line must be: (77 - 32) / 3 * 4 + 1 = 61 OR (77 - 32) / 3 * 4 + 2 = 62 characters in length to be a legal uuencoded line (62 is valid because some uuencoders add a checksum at the end of each line). If trailing spaces are removed, the line length will be wrong. Problem: I'm using the -rg switch on UNPOST, and my posts have the Newsgroup: line in them, but UNPOST does not see any binaries to extract. What is wrong with UNPOST? Answer: Nothing. What is happening is that your Newsgroups: line is occuring in the header block AFTER the Subject: line. This is not a bug in your or anybody else's news system, the official standard states that no ordering is imposed on the header lines (except that a line, which seems to be obsolete now, must occur first). Since the -rg switch tells UNPOST that the Newsgroups: line is the START of an article (segment), UNPOST does not start looking for the Subject: line until after it sees the Newsgroups: line, therefore it never sees any of the information that it needs to interpret the postings. The only real solution to this problem is a configuration file specifically modified to work with your headers. Problem: I've written a configuration (or modified one of the supplied examples) file for UNPOST. I'm sure that I got it right, but UNPOST isn't working. What is wrong with UNPOST? Answer: Probably nothing. UNPOST lives and dies by it's configuration. And when you write a configuration file (or modify one) you are *programming* UNPOST. You are most likely running into the most common problem that programmers have: that of having an unrecognized bug in your work. If UNPOST isn't crashing or core dumping, the problem is almost certainly in your configuration file and the way it tells UNPOST to interpret your news source. Reread the sections on theory of operations, regular expressions and configuration files in the UNPOST documentation (UNPOST.DOC) and very carefully, slowly, use RETEST to test your configuration on one article. You'll almost certainly find your error that way. If you try and try and just cannot get it, send me your configuration file, one article and the version of UNPOST that you are using and I'll take a look at it. Problem: I get my news from a BBS that has a USENET connection. Unfortunately, my BBS system does not allow messages longer than 100 lines, so articles that are posted in 900 to 1000 line chunks are broken down into a lot of much smaller chunks when they get to me. How can I use UNPOST to get binaries from BBS messages? Answer: Simple, really. In some of the cases that I've seen, the BBS takes the original Subject: line - Subject: - file (Part 1/3) and does something like add: Subject: - file (Part 1/3) Section 4 of 30 to it. The solution is to write a configuration file that ignores the (Part 1/3) info and looks only at the Section 4 of 30 information. In those unfortunate cases where the BBS system starts numbering the sub-sections of each USENET article at 1, however, very little can be done. In effect, the result is: Part 1/3 Section 1 of 10 Section 2 of 10 . . . Section 10 of 10 Part 2/3 Section 1 of 10 Section 2 of 10 . . . Section 10 of 10 and UNPOST cannot handle this. Problem: I have a posting that UNPOST claims has no uuencode begin line. When I edit the file and look at that article, the body looks like: Ship in a bottle. BEGIN-------------------------------------PART1/3 begin 777 bay3.bmp M0DUV+ $ '8 H .@$ . ! ! 0 M @ @ (" ( " ( @( (" @ # P, M #_ #_ __\ _P /\ _P#__P ____ #Pjr^OKx-xxxxxxhxMxAx%xUI5)D8F:6* | p d E l Q 6  840JJ)JJ~JoJ#JJJJJvJJaOC G $.0!.,ڣ}{w.Uw3؋CC&8ùىuy+&>4s&>4G;sډ{+؎JW!_ҋ&>43.@ +>vG>}r@w>~r7X!r*g!r H!r@HI!r X!sn t @p&3.6s6q6o6m6kxP.VW_^ˋLF!/5![]5!_a5!ce5!gi%ʎںt!%[!%_!%c!%g!˸׋;t&?t&O2;sӃ;t&?&t&_&Wô׋;t&?t &8gr&gӃ;t&?&t&_&Wô@!ù=.PU> uFV 3]UC2V!r ^ &3Pl]UCVN !r3PO]UVv u" >u.3~u u vY^]U3PPv]UP3Pv]3PP3P{˸PP3Po[Ssـ ˀ3 } у/sЊ% } у+s2+ӊЊ%UVv |X~W6 ރ06^]UVvV^]UD^!%]U"VW~ ^$w\rWFN }~t &-G؃v+6F +6F uNN6, s:FV F _^]U3Pvvv PPaPb]U^でBF ^N V!rP]UF F u^ F . vF Fuڸ*VFRPv v RPw.Pv v nV F ] Uv v33PR^&?u^&&PsV FFPv v tV F]Vt^QЊŊYˊ%;u;U^tP?^N V!rP]˹;s8LJƇPX"A;rȠPY u&Pt3P33PRP  (PY u&&P&t3P33PR$P UVu´t ´ ´]UAV!r3P]ˊ'@'UVWFFPFJW2I_6GNu3SQRj+jPWv v V uFFP~jZY[j~~v& t<%t6GNv&<%t~3ɉNF NFF&2Ћ؀ `s=v. wNπwNĀw~+tV봃fN 릀wMFu)N;~6Fs y؃NFnu׉FasʵFT,0wF |F2uF tFNeNfY FV3҈V~6 FV~6GGvFt6GG~~ u u~u 6NRPWǘPFPSV }Vv~^67CC^F t6CC^:Z6FfN+ϋV;vV~6F~26vV~F u 6=F 6=F u6F;NvNvV~N }WQ^SR#FPFt F FP~FtV ~&=-uI+~V&=-t F tO&~~ N }N~^#F=ufou ~FxtXuN@KKn}FNFu  mK;F@t 0\FVV ~'++&<-t< t<+u&7IK0,+&6GN ~ ˰ Mv~F u 6=F6=FP*FF&FtGG&vF~%& u~P}~tF_^] \FQ   z?  ! % L  lrUVv v !YY@Pv v vv VF^]U^3ɋF3yVF~rw~v33 vYVF FtPvRvEVF]˺@!'@!.; t7ڎ>t. 8.; t. 3P. #. . . . . R3P=Î.; t.&>u&[&Ў&>u& &Q&؃>tá&&;t&. . . t!Ӝ66ӝ&. UVW. V t.; u. _^]P. 3PPq%t+3. PRXXP3ۊܱ. SP?[=t. . ډ3P3ۊܱ. SP[=t8%u. . ډSR3SPZ[=tB3Ë)ڣۉU3ҋF UVF VW. t^rAu; . t . tڎ9s;u&v3w#. _^]S.6 V.6 Vr u[SJ t7@@3ʁvv. Z.; tENj+&6&P&ю&>t&>&>ָS&S3PZU3UV F ^VW. . . t: t?r@u: &;rwӸ!BRP< SP3. _^]UVvF+6{?;6uFVF{;v+6{V6{KYYЃu Ʊ븡{£3^]UVFkr VFXw vvX u3]U3ұFV|=vVN^VFrՋVFw¡FVvv tVF]UV DF^N!r ~uP]&.6>{2&@Ň֓6uFF>}rw2rP@%+r`QI2ً݇ËCw rF< tw< t< t< u2 tB uC2I,"t"<\u<"uI Ð9Y.Cۋ+r.vV6 t3FF.6>66kom&UJ^F!rSPPX]UN CF V!rP2]UV;r PLJRY]U>^!r LJ3P]UF;rP[^tLD^!r>€u5B3ɋ!r.RPB3ɋ!FVZYrB!r;Vr w;Fr3Pw]UVF Fu^&G;Ft^&t/&?}vS~YY us^&Gt&w &w(YY^&|&GPY^&G&G&&G&t!33PRPR&wRPYY^&G^]UVF FuX^&G;Ft^&?|Q&Gu&GV;Ft&9W uy^&&GV;Fub&9W u\&G &W&G&W JH^&G&@&)7P&G &W&G&W PR&GPy;t^&Gu&OX3^]UVW~ 3ɋFVFV ^&F t4O~1^ &|&G&w &G & vv JYY=uuFV;Fu ;Vu33^&^ &Gt33VF_^]UVW36^F^&Gt vSkYYGFN uދ_^]UVW3^ F &< u ^&G@t^&gߠ< ^]P YYUVW~v NsڋVF_^]UW~N F t Is_]UF Pv vvVF]UNǩuP_~u#>t 6Kǀt3F t?PPtvv3PA }WYvvv# }~Vvv |f3PWYYFt# t#% 3RPPW tWFtttPPvv, |/t3ց RFt3Z Ћ㉗_^]UN u uV"N =!rFF % ^㉇FP]U!P$PvvF P-]U^&v SFP]UVF> ^&?}T&&G&w &G > &F &GuT>> t >> tCv vYY u/.&^&Gu&Gu ^&O^&O&to&?tv SWYY u^&G&&G&w &G > &F &Gu>> t >> tv vYY u^^&GtP33PR^&GP>> u'^&G@uPP&GP=uP> P^&GP=t^&Gu> ^]U$Pv\]UVW~~^&Gt."vv^ F &P'=u3O u^&G@u(&u&9si&?tvSYY u^&GtP33PR^&GPdWv v ^&GP ;u0m*^&|&&?u &+G&vv\YY t:Wv v ^&w&w  ^&&& ^&GtP33PR^&GPWv v ^&GP[;u{^&tRG^&} &G&w &G ^ F &&´vv^ F &Pv=uhO uWv v ^&GP;t@F_^] UVWF;r PF @=r ^t3v v vvF@=r ^@uFfNv&<t0< tSPFPv[F;u"SPPQvN^く[+_^]UVW~v^&G;Fu v>u~$u>u ~u^&?tP33PRvSd ^&Gt&w &wYY^&g&GFV&G &W&G&W t` v\I'F F u!VzYV F u?^&O2^F V &G&W &G &W&wu&O3_^]UVW~2u~ +tIs_^]UVW~ 2~VF_^]UW~3;Fu;t H_]UVW~;>r P{/F @=s3!tP33PRWL߃@uv v vWでF VFVF FuN^F&F< u ^& F^F&FrV3+Ѓ |Durv(XPPP66PWY^&Gvv;YY^&W&G^&&?)t(fP0PP66PWY^&^&&PBP u^&&P"P tHsPkP9P66^&&PtP66 PWYVFVF^&&?\u6^&&t)^&S&G[&&^&F^&U^&&PBP u^&&P"P t,^&G&7&&^&F^&&?tZ^&^& PYY^&W&G u(PPP66PWYVF^]UvvYYVF^&&P"P u^&? u ^& b^&?u*PPP66PWY/(VF^FV&G&W^&FVFVvvvvVF]U33҉FVFVvvYYVF^&&?t|^&&?|tp^&&?)td^&&?$tXVF^FV&G&W^&F Ft^FV&G&W FVFVFVFV)F Ft^FV&G&W FVFV:VF]U^&&?^u1^&VF^&vvYY^&W&GvvYYVF^&&?$u5^&VF^& ^FV&G&WFVFVVF]UvvNYYVFL^&0VF^FV&G&W^&vvYY^&W&GFVFV^&&?|tVF]U^&K v. VF^&^&G^&G^F V &G&Wvv^&w&w^&W&GFVFVD^&G&W^&G&W^F V &G&Wv v ^&w&wCVFvv^&w&w%VFvv YYVF^&^F V &G&Wvv^&w&w^&W&Gvv^&w&w^&W&Gv v ^&G&WFV^F V &G&WvvvveVF^F V &G&WFVFVVF]˩ F U>,uW^F.BPvv/^F2"Pvv/^F6Pvv/,FP&YYVF33PRvvVFVF]U^&G&WFV^&K wr. ^&w&wYY^&w&wYY^&w&wYYVF^&G&WFVvv ^&w&w (P%PP66PWYvv YYFVFVF Ft ^&?tVF] I I I K K I I I I 5 7 UVW37Ǻ ؋ tǺ ؋ u GǺ ؋PǺ X;v)W/PgP0P66PWYFǺ ؋FVFFǺ ؋;Fu;VuߋF@PPd YYVF u(APPqP66PWYvǺ vv ^^&Ǻ V^G_^]UK>.u.^ &PYP^&PYZ;t3,F F^ F &^F&:t^ &?u]UV^&v.^&w&w^ &w&7k t^&w&w`%YY^ &^ &&P^&w&w t^ &^ &&?t^ &&? t3 t^ &h^ &G&;Fu ;Vu3^ &&? t ^ &&?u3(PPP66PWY^]j=U VW^&K v.^ &G&FVFP^&w&wv v vv u5^ FV&G&FP^&w&wv v vvyFVFV3^ &&?t ^ &&? u3 G^&9 w u^^&G&WFVF Ft^&?t^&?t^&?t̋F Fu^ &^ &&?u^ &G&FVL^ FV&G&FP^&w&wv v vv t^&?tF G^&9 w^&9 v333^&w&wv v vv u^&9 w G^&9 wl^ &G&^P&G RXZ$^ &G&^P&G RXZvvv v vv F Ft^&G&WFV tF Ft ^&?t^FV&G&_^]ˈUVW{߱㋇b dt߱db YY߱LJdLJbǺ 33ۋ‰Pǻ RXZRPǺ XZG|FVFVF .^ &?u'FP^ &w&wFPvvFWFVFVFVFVFPvv FPvvMF t^&?t ^&? uF뵃~t:? Ǻ ؋߱㉇dbG|^&_&bF_^]UF ^&N #]UVW^&&?^u ^&3FF^ &F~|F^&&?\u ^&^&&?-t~u^&&t}^&&]tp^&S&G[&&=\u^&S&G[&&F@FNV^ & F9v|F^&&^&&^ & ^&&F^&^&&?t^&&?]t^&&?]u^& t,FF^ &ЋV^ &F~|^ &'^ &'_^]UFFFVFV^&?0|1^&?9(VF^P&R[Yډ^N~^&?a|7^&?f.VF^P&R[Yڃ ^N>^&?A|5^&?F,VF^P&R[Yڃ ^NF^&?t9VF]UVvv`%YY@VPd YYVF u(=PPP66PWYvvvv7%VF^]UPvvVF tvvYY3]UFVFVF V FV3^&^&FFA;N|]UVvFVFVF V FVF;Fs3^&^&FFA;|/F;Fv'HFHF3^&^&NNA;|^]Borland C++ - Copyright 1991 Borland Intl.Divide error Abnormal program termination @ %s %d : Error - Syntax is: retest.c%s rtError, could not open file '%s' for reading. Line: '%s' #%2d: '%s' :AF[().|${*?+0-9%s %d : Out of memory. recomp.c%s %d : Error - missing '}' in regular expression. recomp.c%s %d : Out of memory. recomp.c%s %d : Error - To many sub-expressions. recomp.c%s %d : Error - missing ')' in regular expression. recomp.c%s %d : Error - badly formed regular expression. recomp.c Unexpected character '%c' %s %d : Out of memory. recomp.c%s %d : Error, can not enumerate a sub expression. recomp.c%s %d : Error - illegal regular expression node type. recomp.c%s %d : Error - sub expression #%d extraction failed. rematch.c%s %d : Out of memory. rematch.c%s %d : Error - illegal regular expression node type. rematch.c%s %d : Error - out of memory. utils.crt !!!!! @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@   $8CLB````@),(((((),(((),#,*((((**#(#%(TMP.$$$(null)       print scanf : floating point formats not linked WR y\1N # $ Wjkz     |WfxyL^o !:"#$%(&W'b(=)m*0 +}d , - . /c 0 1*24345678R9{:;<= >)?@XA+%BCDEF~GH-IJKLMNOPiQR('SBT^U V!W #X#Y$Z{7%[z`%\%]&^ '_I'`-xaD bC chJdser/f ghsijkl[m_ncogpkqmrqsutwuyv{w}x}y}z~{|}~ ,4         .5 5 . 5 5 . 5 36.5 5 ..5 5 ....5 5 ..5 5 ..5 . . ... . 3 7.3 . ... /0N   : /LKSJIUHXG"F ME*,3.3236 NN"NBOO O O O Q P O O P Q W Q P O QQOO P Q W Z Q X O QOOO X Q Z [bnRSX  ] RlJkXJjJiJX.m o o  o p p o  t t  t t tt t ut  x x ttx x   x x ttx x  v     9  X33כn 33  *"*#F%P(Z+r-/09:=>?@68CWD[=GOSZ`1:CFQZcfy    .8>@&U.]2|3458;<>ABFGHILOP!S)U0X0YN[X^fa~cfgijmnpstvw/{9CPi!!?IKSX^p"(8Jz ","4#K%M(_+k.q/{0156AGORSTWXL\]&h*o0sFtPuXvfywz{~   ( 0 A d             ( ; C V ^ q w }            - 7 I K K i s     %()9*>,\0\1{5786<>ABFG(J2LRXX_]bdcfghi\lm~4:=bhj<Lq} ..W$Y%b'g+s03589:=@EFGIJ4N6O>QOTgUwV{dsvwz{$06?fr~ -"/-7/C0F1L3N6P7W:o=v>?DGJKNOP)V-WWYZ]_`def *< d!v"#%&.58:*=*>HBRCfDnNsVyYZ\]gpsrqt35=M_`d_ WSMSXKDU ]X ^" ( ~x*0   W  RJX`[]!  q "i-'/$ $1/3&7; <(?v@*oCs=D,y7F>I.8O{R0qx_ J $ ^( zq -    (  +  "! #########/$",: 38:=###3###A##.#.#.#.#.#.#.###.#. ORG"O] Q"`PPO]b### ####f######n l q##vp## #t##x##u#####t#     " #0.. 2 34 88 SQQ U OV ^^ OOO  ww =c P238W[GOSXZ`lx%*-1:FQf8@U]goty|0X9P\i!IKSX^"(8Vbnz M_k&*06?F}   w 5 7 B I K s &9<>\IJRX[]d4:=IUZ\bhjy~<q  WYbgijs|6>OS[g{$?fr -/7CNPWfiov!$)-ciu *3<dmv*Rnsy./35=M_`d__setargv____cvtfak__AHSHIFT__cleanup__checknull__terminate__restorezero_abortDGROUP@__MMODEL_atexit__dos_getfileattr__dos_setfileattr_exit__exit__cexit__c_exitN_LXLSH@F_LXLSH@LXLSH@N_PADD@F_PADD@PADD@N_PSUB@F_PSUB@PSUB@__IOERROR__DOSERROR_isatty__LONGTOA__UTOA_lseek__MKNAME__TMPNAMN_LXMUL@N_PCMP@__read__setupio_tolower_unlink__VPRINTER__stpcpy_calloc___first___last___rover_free_farfree_malloc_farmalloc__AHINCR_realloc_farrealloc__brk__sbrk_ioctl__REALCVT_setblock__chmod_close__close_eof_fclose_fflush_fgets_flushall__OPENFP__GETFP_fopen_fprintf_fseek_ftell__fgetc__Nfgetc_fgetc_fgetchar_memcpy_setmem_memset_open__open_printf__fputc_fputc_fputchar__FPUTN___read_setvbuf_strcat_strcpy_strlen___write__write__xfclose__xfflush_main_ReCompile_FreeReExpr_ReMatch_InSet_CrtSet_HexToUL_StrDup_FileExists_MemCopy_MemMvDATASEG@__Int0Vector__Int4Vector__Int5Vector__Int6Vector__C0argc__C0argv__C0environ__envLng__envseg__envSize__psp__osversion__osmajor__version__osminor_errno__StartTime___brklvl__heapbase__brklvl__heaptop__atexitcnt__ctype__exitbuf__exitfopen__exitopen__streams__nfile__openfd__fmode__notUmask__doserrno__dosErrorToSV__stklen__argc__argv__RealCvtVector__ScanTodVector_ErrFile__atexittblretest.cRETESTargvargcreg_exp_stBfrSubStrsfpReExpriREG_EXP_NODENODE_TYPESET_TYPEUINTptrdiff_twchar_tFILEfpos_tsize_tlevelflagsfdholdbsizebuffercurpistemptokenNodeTypeLeftRightMinSpanMaxSpanSubExprNodataNODE_TYPE_NOT_SETOP_ENUMOP_OROP_ANDOP_L_PARENOP_R_PARENEND_OREND_ENUMDATA_LEFT_ANCHORDATA_RIGHT_ANCHORDATA_ANYDATA_SPANDATA_STRINGDATA_SETMatchStrCSetRETEST.Crecomp.cRECOMPNewStrRootTmpBufferNodeNextPrevSubExprLinkRetLinkEndOrReGraphAnchorCatenationEnumerateUnaryEnumOpGetIntAllocRegExpNodeAlternationDecSetDecStrPostSetPostFixStrSpecSetSpecStrReInitFlagSETBYTECRC_TYPERECOMP.Crematch.cREMATCHStrLenReStrSrcStartMatchContChkPtCaseRetStrsLooptpReOpReDataReStrCmpExtSubStrsCmpCaseSubExprsSUB_EXPRCASE_CMPCASE_SENSITIVEIGN_CASEStartEndSubStrREMATCH.Csets.cSETScLastChNegateFlagSETS.Cutils.cUTILScpULongFlNameNoBytesSourceDestsdUTILS.Cunpost/msdos/unpost.exe100644 23453 0 274011 5541135512 15211 0ustar jeanpaulsystemMZx' >Pjr^O`T6&ubI.{odQE:}qfF;(j\t`E+  ncX<'tJ6#ydV9WWWsW[W0WWWWWWWWcW:WWWWWWsWLW0WWWWWWwWPW;W WWWWWpWQWCWWWWWjW\WBWWWWW2W WWWW<WW W W W W@ W W W Wd WW WI W1 W W W W W W W W@ W% W WWWWWzWWW!W W W W Wn W^ WQ WC W W W W W W W W7      DDbD:D'DDDDDDDD4DDDkDSDDDDo h a Z S L E > 7 )            s e W ; -          p b T 8 *          t f X J }}}r}L}@}}}}r}f}>}p# YvWyZr]9    X|eL2{mmTH*zA e ,  8   ]  ^6 { :    L  J4R`!    x t p X T P 8 4 0                      h D      l Z H 6 $  ,,,,\,P,,,,,<,0,,,K,?,,,,,M,A,,,,=,1,, ,w ,k ,L ,s ,X ,= , ,D @ < 0 v* } XXXXXXzX_XAX%X XXXXXXkXTX&XXXXXXXjXMX<X.XXXXXXXrXRX$XXXXXoXcX<X$X XXXXjXMXXXXXbX@XXXXXXXpXdXFX6X X X X X| XN X; X X X X Xr XI X8 X X X XXXXqXYX"XXPXDX&XXXXX X X X XS X> X X X X X0 XXXXXX*XXXvXhXCX-XXXSX=X(XXXXXXXjXMX.XXXXX}X]X6X!XXXXXX|X>XXXXXXvXPX.X"XXXXXoX_XPX7XXgU!@hG%rbVPynOC1Y0% % % % % % % % % % % % % % % % c c Yc Gc ;c c c c yc ?c     ( , , , J@0 <0 80 40 00 ,0 (0 $0 0 0 0 0 0 0 0 0 0 / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ' .0!.,ڣ}{w.Uw3؋CC&8ùىuy+꿻 &>.s&>.G;sډ{+؎JW!_ҋ &>.3.2HB+>@.vG>}r@w>~r7X!r*g@.!r H!r@HI!r X!sn t @p&3.~226s6q6o6m6kGP.VW22_^ˋLF!/5![]5!_a5!ce5!gi%ʎںt!%[!%_!%c!%g!˸׋;t&?t&O2;sӃ;t&?&t&_&Wô׋;t&?t &8gr&gӃ;t&?&t&_&Wô@!ù=.PU>+ u+FVAA+3]UC2V!r ^ &3P]UCVN !r3Pp]UVv u"++A>+u.,3~u u,,vY^]U3PPv]UP3Pv]3PP3P{˸PP3Po[Ssـ ˀ3[Ssـ ˀ3 } у/sЊ% } у+s2+ӊЊ%UVv |X~W6n.p. ރ0n.6^]UVvV^]UD^!%]U"VW~ ^$w\rWFN }~t &-G؃v+6F +6F uNN6, s:FV F _^]U3Pvvv PPaPb]U^でB.BF ^N V!rP]UF F u^ F AvF Fuڸ.VFRPv v RPw.Pv v "V F ] Uv v33PR^&?u^&&PsV FFPv v tV F]Vt^QЊŊYˊ%;u;U^B.tP?^N V!rP]˹;@.s8LJB.Ƈ,,PX,A;@.rȠ,PY u&,P,t3P33PR,P ,PY u&,P,t3P33PR,P UVu´+t ´ ´]UAV!r3P]ˊ'@'UVWFFPFJW2I_6GNu3SQRj+jPWv v V uFFP~jZY[j~~v& t<%t6GNv&<%t~3ɉNF NFF&2Ћ؀ `s.v.! wNπwNĀw~+tV봃fN 릀wMFu)N;~6Fs y؃NFnu׉FasʵFT,0wF |F2uF tFNeNfY FV3҈V~6 FV~6GGvFt6GG~~ u u~u 6NRPWǘPFPSV }Vv~^67CC^F t6CC^:Z6FfN+ϋV;vV~6F~26vV~F u 6=F 6=F u.F;NvNvV~N }WQ^SR#FPFt F FP~FtV ~&=-uI+~V&=-t F tO&~~ N }N~^#F=ufou ~FxtXuN@KKn}FNFu  mK;F@t 0\FVV ~'++&<-t< t<+u&7IK0,+&6GN ~ ˰ Mv~F u 6=F6=FP*FF&FtGG&vF~%& u~P}~tF_^] }gr+ 2 7 ` > B F m  0 UVv v YY@Pv v vv VF^]U^3ɋF3yVF~rw~v33 vYVF FtPvRvVF]˺>/C/@!'H/@!y.; t7ڎ>t. 8.; t. 3P. #. . . . . R3P=Î.; t.&>u&[&Ў&>u& &Q&؃>tá&&;t&. . . t!Ӝ66ӝ&. UVW. V t.; u. _^]P. 3PPq%t+3. PRXXP3ۊܱ. SP?[=t. . ډ3P3ۊܱ. SP[=t8%u. . ډSR3SPZ[=tB3Ë)ڣۉU3ҋF UVF VW. t^rAu; . t . tڎ9s;u&v3w#. _^]S.6 V.6 Vr u[SJ t7@@3ʁvv. Z.; tENj+&6&P&ю&>t&>&>ָS&S3PZU3UV F ^VW. . . t: t?r@u: &;rwӸ!BRP< SP3. _^]UVvF+6{?;6p/uFVF{;v+6{V6{KYYЃu Ʊp/븡{£3^]UVFkr VFXw vvX u3]U3ұFV|=vVN^VFrՋVFw¡FVvv tVF]UV DF^N!r ~uP]&v2x/z/|/.6~/>/{2&@Ň֓6uFF>}rw2rP@%+r`QI2ً݇ËCw rF< tw< t< t< u2 tB uC2I,"t"<\u<"uI ÐY.r/Cۋ+r.t/v/vV6 t3FF.6~/>/6|/6z/r/kv/ot/m&x/UJ^F!rSPPX]UVWUv+ +&Fu+t-uE&F9w/0r*t ᗇ⒗&F9w0sM|؃]_^]Uvv~YY]UN CF V!rP]UV;@.r PLJB.RY]U>^!r LJB.3Pf]UF;@.rP[^B.tLD^!r>€u5B3ɋ!r.RPB3ɋ!FVZYrB!r;Vr w;Fr3P]UVF Fu^&G;Ft^&t/&?}vS~YY us^&Gt&w &wYY^&|&GPY^&G&G&&G&t!33PRPR&wsRPoYY^&G^]UVF FuX^&G;Ft^&?|Q&Gu&GV;Ft&9W uy^&&GV;Fub&9W u\&G &W&G&W JH^&G&@&)7P&G &W&G&W PR&GP;t^&Gu&OX3^]UVW~ 3ɋFVFV ^&F t4O~1^ &|&G&w &G & vv WYY=uuFV;Fu ;Vu33^&^ &Gt33VF_^]UVW36@.^F,^&Gt vSkYYGFN uދ_^]UVW3^ F &A u ^&G@t^&gߠA^],P YYUVW~v NsڋVF_^]UW~N F t Is_]UF Pv vvVF]UNl.ǩuP~u#>n.t 6n.ǀt3F t?PPtvv3PA }WYvvv# }~Vvv |f3PWYYFt# t#% 3RPPWW tWFtttPPvv |/t3ց RFt3Z Ћ㉗B._^]UN u uV"N =!rFF % ^㉇B.FP]]U;B0}>|㋇//FV^F?2vvvvM2P,P]U$P,PvvF PB]U^&v SFP]UVFA^&?}T&&G&w &G A&F &GuT>A t >A tCv v@YY u/.&^&Gu&Gu ^&O^&O&to&?tv SYY u^&G&&G&w &G A&F &Gu>A t >A tv vYY u^^&GB.tP33PR^&GP>A u'^&G@uPV2P&GP=uPAP^&GP=t^&GuA^]U,Pv\]UVW~~^&Gt."vv^ F &P'=u3O u^&G@u(&u&9si&?tvSxYY u^&GB.tP33PR^&GPyWv v ^&GP;u0m*^&|&&?u &+G&vvYY t:Wv v ^&w&w a ^&&& ^&GB.tP33PR^&GP߃Wv v ^&GP_;u{^&tRG^&} &G&w &G ^ F &&´vv^ F &Pv=uhO uWv v ^&GP;t@F_^] UVWF;@.r PF @=r ^B.t3v v vv߃F@=r ^B.@uFfNv&<t0< tSPFPv߃[F;u"SPPQvcރ^くB.[+_^]UVW~v^&G;Fu v>Z2u~,uZ2>X2u ~,uX2^&?tP33PRvS ^&Gt&w &wYY^&g&GFV&G &W&G&W t` v\,,Y,F F u!VYV F u?^&O2^F V &G&W &G &W&wu&O3_^]UVvVv v ^&w&7h ^&7S&G[&&^] U^&(PFPv v FP*]U^&(PFPv v v ]UVW~2u~ +tIs_^]UVv^ t :t"t:t"t:t "u33FD^]UVW3~ 2ыvD&]+Î_^]UVW~ 2~VF_^]UV;B0} |ڱ㋇//FV^F\2F Ft'^&?tvvvSj2PAPvvr2PAPs ڸA]U6vvm]Uv33PR\]UW~3;Fu;t H_]XPUNt\^&?}P^&g&&=~&O S&G[&_ ю&F V^&G&W &G]UVW~;>@.r P/F @=s3!B.tP33PRW]ڃB.@uv v vWでB.F VFVF FuN^F&F< u ^& F^F&FrV3+Ѓ |Dur^3؁㋇PRVF%[3X3‰F^F;|vvPPP VF_^]U&VWP}YVF\dždždždždž^F2Pvv3)P+DYY=t2P*YY2^F2Pc YYtP@DYYPWY3F6F~3AP+DYY=u2K v.~tP@DYYPWYP+DYY=tP@DYYPWYF쉆F~tP@DYYPWYP+DYY=t:P@DYYPWYP+DYY=t\P@DYYPWYF쉆FC~t{P@DYYPWYP+DYY=tP@DYYPWYF쉆F~tP@DYYPWYP+DYY=tP@DYYPWYP+DYY=tP@DYYPWYF쉆Fp~tP@DYYPWYP+DYY= udž#udž?P@DYYPWYFlP@DYYF ,YYPvv:}VFt*P+DYY=tP@DYYPWYP+DYY=utP@DYYPWYP3PPPvv:}VF^&PFvPvvc VF_^],     XUV P}Y^F2Pvv3)P+DYY=t2P*YY2^F뿃tP@DYYPWY2Pc YYP ,YYPvv:}VFP+DYY=u4tP@DYYPWY P3PPPvv:}VF^& PFvPvvc VF^]UVvvDYYP+DYY= t/P@DYYPWYP}YVFP+DYY=tHP@DYYPWY^F2Pvv3)P+DYY=t2P*YY2^F뿃ttP@DYYPWY2Pc YYP+DYY=tP@DYYPWYP+DYY=tP@DYYPWYXP+DYY=tP@DYYPWYP+DYY=tP@DYYPWY ,YYPvv:}VFP+DYY=t'P@DYYPWYP+DYY=u u%P3PPPvv:}VF^&PFvPvvc ,DVF^]UPvvvv =uFPvv uv v kc YY t+v v 3PzPNP6%6%33Pv v VF u2v v 6)YRP>PPP6%6%몋VF9MPPP6%6%vvP6%6% YP PP6%6%D]UVv v kc YY t*v v ~P< P P6%6% E Pv v VF u;Pz PH P6%6%v v  P6%6% ^&_& u3P^&_&w&wvv t6)YRPP P Pvvvv =t`vv (FPFPvv( t6vv Pvv Pvvvv =u3P^&_&w&wvv t:6)YRPP P P6%6%vvGYYvDvv Pvv FPFPvv t tuPvvvv =u PvvvvGYY3^]UP9Pvv =u7PFP9P- ^&^&?t^&?t ^&?uY ^&?uI~tCv v vP7P6 ;Ft$P P P6%6%mK3e]U VW\^ &_ƺ&uDV.P< P P6%6%^ &w&7E P6%6% F^ &9w }^ &G& Gu?=P| PW P6%6%^ &w&7 P6%6% 뤃>%t<P P^ &w&w% 9Pv v Pvvq3P^ &_ƺ&w &wvv t-6)YRPZP P P6%6%u*9P^ &w&wvv3 VF uFPvvvv =tuvvGYY~uS^ &9w uH{P P P6%6%9P P6%6% vvGYYEX~u+^ &9w ~P P P6%6%6'~u!PS P' P6%6%F^ &9w |^ &tfvvYYVF^ &;Wu&;G tDPy P\ P6%6%vv^ &w&w  P6%6%vvGYY3__^]UVvvkc YY t*vvP P P6%6% PvvVF u;P P P6%6%vv P6%6% ^ &_& u) P^ &_&w&7VF u/^ &_&w&7Pc P, P6%6%i3P^ &_&w&wvv t6)YRPP Pl Pvvvv =t`vv (FPFPvv( t6vv Pvvꚶ Pvvvv =uvvGYY P^ &_&w&wVF u^ &_&w&7P P 3P^ &_&w&wvv tG6)YRPP P P6%6%vvGYYvvGYYDvv Pvvꚶ FPFPvv t tuPvvvv =u PvvꚶvvGYYvvGYY32^]UVW\^&_ƺ&uDV\P P P6%6%^&w&7) P6%6% &F^&9w }^&G& Gu.kP` P; P6%6%^&w&7i 뤃>%t6P{ P^&w&w% 9PvvP  P^&_ƺ&w&7VF u8^&_ƺ&w&7P P P6%6% 3P^&_ƺ&w &wvv t36)YRPP P P6%6%vv2u)9P^&w&wvv VF uFPvvvv# =tuvvGYYvvGYY>~uF^&9w u:PP P6%6%9PP6%6% e~u8^&9w ~PEPP6%6%vvGYY]A~u;PzPNP6%6%vvGYYvvGYYpvvGYYF^&9w |^&tfvvYYVF^&;Wu&;G tDPPP6%6%vv^&w&w P6%6%vvGYY3_^]UVW^ &3ƺ؋PƺX;F ~3ƺV^VFƺğ&^&:tGƺ9ҋƺ9u)ƺPvv 3)ƺ؋Fƺ؃tF3_^]UVWv 2YF ^&GHFFFFƺ^&V +ЉV~HF~|@FF;F}~t^ F &F ƺ^&G& Gta6464YYF =uivv v ƺ^&w&w2 u6464v $* ^ &ƺ^&G^ &3_^]UV,~ u. ~#u6464YY= u.6464YYF~ t~ t~ t~#t~"uFFVFV ^F&F6464YYF="t~u^&u~0|d~9^^&LJ^& VЃ^&6464YYF=0|~9~6464v$* ~u4Pv+P t uG4PPPP6%6%.@PP6%6% PWY^]UPvv44 uO6)YRP)PPP6%6%vvP6%6% PWY]U6464GYY]UvvIPPP6%6%4P.@PP6%6%PWY]UVv^&G^&;b^&G^&oFvvvVF u(-P<PP6%6%PWY^&G^&GV^؃V^^&97~.^&G^&+Pvv^F&GvPc ^&wv v vvc ^&VF^]UVvFvP YYVF u(YPcPCP6%6%PWY^&w^&GVF^]UVW^&?~y3^&HFF^&GV^؃V^vvv v ^F~HF~|@9v}~u ^&?^&7^&3_^]UN |^&933^&GVPF[]U^&G^&;b^&G^&oFvvvVF u(PPjP6%6%PWY^&G^&G^&/V^؃V^^&wv v vvc ^&VF]U3B^&?t ^&?.u]U >uFV>5PFP5FV5PFP5FV4PFP5FV4PFP5FVFVFVA^&P2YF~ t~ tFP>5P t ^F&FF^&?u^&]U VW>uFV>5PFP5FV5PFP5FV4PFP5FV4PFP5FVFVFVFV5^&P2YFFP>5P t ^F&FF^&?u^&vvYY=FVFVFVA^&P5P u^&^&FFV;Fu;VuNF^&?t^&?.tvvvv3)vvGYY=FVFVFVc^&tG^&.t=^&P4P t%^&GP4P t ^&?0uN^&^&FF^&?t^&?.tvvvv3)FVFVFVFx^&P4P t^&^&FL^&?t=^&.t3^&P4P t^&GP4P tNFF^&?t^&?.t~nvvvv3)~u9PPP6%6%P6%6%vvYY=~FVFVF^&?t ^&?.u^&?.uG^ &?tv v vv3)&3FF^&?t^&?.t|^&v v vv3)3[_^]U FVFVFVFVFF'^&^&^&?.u FVFVFF^&?u^&F Ftv v vv v v vv3)]UVVF^ &G &WFV^&^&FF^&?t^&? t^&? t ^&? u^&3>%uIvvVYYVFFP9Pvv =u>P5PP6%6%?P=P6%6% 7PFP9P- =u=PxPMP6%6%?PP6%6% .FPv7P7 vvFPP+ 3Pvvvv t46)YRPPPP6%6%PWYPvv3)^]UFP663Pvv]Uv v 663Pvv]UV3pFPƱ&w&w 3Pvv tAƱ&G&W^ &G&Ʊ&G &W^&G&1FƱ&& GtxF F FF3^]UVvv0YYFVFVkF^&? t^&? tF V FV3^&?.uF^&^&FF^&?t^&? t ^&? u^& t\^&?uFVFVF V FV)^&? t ^&? uF^&^&FF^&?u^&^]UVFF3SFPƺ^ &w&wƺ^ &w vv tƺV ^ ؉V^Fƺ^ && GuF FuT3G t=u=u-^&u P^&G^&w&7=u=^& ~0P^&G ^&w&7u^&G& Gt^&w&wAYYPc YY^&W&Go^&us^&G^&w&7YY^&G }H6^&u:^&G^&w&7YY^& ^&F^]UVWvvVYYVFPvvvv =u FFFPFPvv' tQ3Pvvvv t46)YRPPPPP6%6%PWYFPvvvv ^&^&?t^&?t ^&?t`^&t^&uiPPP6%6%P6%6%^&?uD^&7P6%6% *P6%6%^v&&G FF^&u^&uyPtPAP6%6%|P6%6%^&u0^&wP6%6% ^v&&G FF&^&u^&u^v&&G3_vvǺ ^ &w &w3Pvv t/v vvvǺ ^ &w&wvvsGǺ ^ && Guvv66Pvv t)^&&w&wc YY^&W&G ^&GVF_^]UV3^FPƺ ^ &w &w3Pvv t/vvvvƺ ^ &w&wvvFƺ ^ && GuPvvvv =uAFVFVF^&? t^&? t^&?t ^&? u*3Ҹ^]UV3F6F~vvVYYVFPv v vv =u mFPFPv v  tv v vv3)^FV&G&WvvvvFPvvvvYVF~ |~sBvvFPFPvvFPvvvvVF~|~s VF4^FV&G &W~tN^&uB[PPP6%6%v v P6%6% 8Pvvvv tPc YY^&W&G33^]UVW9u >.ue9u >uR9u >nu?9u >Nu,33 FnƱ&_Ǻ &_F&w&7AYYƱ&_Ǻ &_F&w&w ,YYFƱ&_Ǻ &_F&& Gt_Ʊ&_Ǻ &w&wAYYƱ&_Ǻ &w&7AYYƱ&_Ǻ &w &w ,YYGƱ&_Ǻ && GtƱ&w&wAYY3 FnƱ&_Ǻ &_F&w&7AYYƱ&_Ǻ &_F&w&w ,YYFƱ&_Ǻ &_F&& Gt_Ʊ&_Ǻ &w&wAYYƱ&_Ǻ &w&7AYYƱ&_Ǻ &w &w ,YYGƱ&_Ǻ && GtƱ&w &wAYYƱ&w&7AYYƱ&w&w ,YYFƱ&& Gt66AYY_^]UVWn^&P2YF.;Ft(.gN$n. 3EDZ&G & Gu.DZ&w&7 ,YY߱6&T&D GDZ&& Gu_^]egnr<HT`UVWFF؉V^^&G & Gu^&w&7 ,YY^&W&G 3^&G&WPƻ RZXFV^&w&7 ,YY^&W &G3;^&G&WPǻRZXFV^&w&7 ,YY^&W&GG^&_Ǻ&& GuF^&_ƺ && GtQ3^&G &WPƻ RZXFV^&w&7 ,YY^&W &G3;^&G&WPǻRZXFV^&w&7 ,YY^&W&GG^&_Ǻ&& GuF^&_ƺ && GtQFF&& Gt<_^]UF Ft ^&?u 'P/PP6%6%vvYY]U66 ,YY66 ,YY66 ,YY]UPP YYVF u(PnPVP6%6%PWYVF]UVW^&^&&? t^&&? t^&&? t3#^&G&7&&PǺ ZЃЋ^&&P`5P u^&^&&? t^&&? t^&&? t֋_^]UV^&G&7&&FL.;Ft.g^ &G ^ &G ^ &G ^ &G ^ &G vvYY^ &G ^ &G ^ &G ^&&?,uq^&^&&? t^&&? t^&&? t^&&?}u ^ &G .^&&P`5P tvvXYY^ &G ^&&?}t(PPwP6%6%PWY^&^]*+?{M8XmUV^&&=(u=.t=[t?^&zVF^& eVF PP YY^&W&G u(APPP6%6%PWY^&^&w&wvv5^& :^&VF^&>^5v(XPPP6%6%PWY^^5&G^5vv;YY^&W&G^&&?)t(fP<PP6%6%PWY^&^&&P5P u^&&P5P tHsPwPEP6%6%^&&PP6%6% PWYVFVF^&&?\u6^&&t)^&S&G[&&^&F^&U^&&P5P u^&&P5P t,^&G&7&&^&F^&&?tZ^&^& Pc YY^&W&G u(PPP6%6%PWYVF^]UvvYYVF^&&P5P u^&? u ^& b^&?u*PPP6%6%PWY/(VF^FV&G&W^&FVFVvvvvVF]U33҉FVFVvvYYVF^&&?t|^&&?|tp^&&?)td^&&?$tXVF^FV&G&W^&F Ft^FV&G&W FVFVFVFV)F Ft^FV&G&W FVFV:VF]U^&&?^u1^&VF^&vvYY^&W&GvvYYVF^&&?$u5^&VF^& ^FV&G&WFVFVVF]UvvNYYVFL^&0VF^FV&G&W^&vvYY^&W&GFVFV^&&?|tVF]U^&K v. VF^&^&G^&G^F V &G&Wvv^&w&w^&W&GFVFVD^&G&W^&G&W^F V &G&Wv v ^&w&wCVFvv^&w&w%VFvvAYYVF^&^F V &G&Wvv^&w&w^&W&Gvv^&w&w^&W&Gv v ^&G&WFV^F V &G&WvvvveVF^F V &G&WFVFVVF]˰% M U>8uW^F:5Pvv5^F>5Pvv5^FB`5Pvv58^5FP&YYVF33PRvvVFVF]U^&G&WFV^&K wr. ^&w&wYY^&w&wYY^&w&wYYVF^&G&WFVvv ^&w&wA(P1PP6%6%PWYvvAYYFVFVF Ft ^&?tVF] P P P R R P P P P < > UVW37Ǻ ؋6 6tǺ ؋6 6u GǺ ؋6PǺ X;6v)W/PsP<P6%6%PWYFǺ ؋66FVFFǺ ؋66;Fu;VuߋF@PP YYVF u(APP}P6%6%PWYvǺ 66vvc ^^&Ǻ V^66G_^]UK>:u.^ &P2YP^&P2YZ;t3,F F^ F &^F&:t^ &?u]UV^&v.^&w&w^ &w&7k t^&w&w*YY^ &^ &&P^&w&w t^ &^ &&?t^ &&? t3 t^ &h^ &G&;Fu ;Vu3^ &&? t ^ &&?u3(PPP6%6%PWY^]qDU VW^&K v.^ &G&FVFP^&w&wv v vv u5^ FV&G&FP^&w&wv v vvyFVFV3^ &&?t ^ &&? u3 G^&9 w u^^&G&WFVF Ft^&?t^&?t^&?t̋F Fu^ &^ &&?u^ &G&FVL^ FV&G&FP^&w&wv v vv t^&?tF G^&9 w^&9 v333^&w&wv v vv u^&9 w G^&9 wl^ &G&^P&G RXZ66$^ &G&^P&G RXZ66vvv v vv F Ft^&G&WFV tF Ft ^&?t^FV&G&_^]ˏ       UVW{߱㋇5 5t߱55AYY߱LJ5LJ5Ǻ 33ۋ6‰6Pǻ RXZ66RPǺ XZ66G|FVFVF :^ &?u'FP^ &w&wFPvvFWFVFVFVFVFPvv FPvvMF t^&?t ^&? uF뵃~t:? Ǻ ؋66߱㉇55G|^&_&5F_^]UPvvVF u*vv?PPP6%6%P9Pvv =uyFP9P tPvvvv Pkc YY t&P]POP$P6%6%MYPPVF u@P6)YRPiPvP\P6%6%vvGYYy9PYY t7PFP9P ~}GvvvP7P6 ;Ft(PPP6%6%PWYP9Pvv =thvvGYY^&G uhvvGYY3P]UV3PvvVF u*vvPPP6%6%qNvvVYYVFP9Pvv =uvvGYY3FPFP9P F~uPvvvv Pkc YY t*PP% PP6%6%/ PPVF u2P6)YRPPL P2 P6%6%FPvvvvW ~t~uvvVYYVFP9Pvv =u;P PV P6%6%vvGYYvvGYYaFPFP9P F~us~uj3Pvvvv t46)YRPP P P6%6%PWY~uvvGYY~u!P P P6%6%^&G uvvGYY^]U^ &w&7^&w&7)]U1?P Pv v  vvVYY;Vu;FuP?Pvv =u]UHVW PvvVF u*vvrP!P P6%6%3cP3PFPFP=P?Pvv VFFԋV҉FVvvc YYVF~u ~u ~ue~u_F Ft^&?t~u ~~F9FFP676 7:}7 7F Ft vvAYYl~u~t~u~tF Ft ^&?u>FFP676 7:}7 7F Ft vvAYY+FFP676 7:}7 7FVFVFPXPPFP6767l} tPF@P YYV̉F u(PD!P$!P6%6%PWYFΉFFFFFމFȋF܋VډFƉVvFP6767} 77 vvAYYv6767}VF^&G ;F}Avи P!PN!P6%6%?P!P6%6% ^&u~u;P!P!P6%6%v!P6%6% N^&G&W ;Fu;Vt9(P$"P!P6%6%v."P6%6% ^&_Fк&tCvи6Pj"P="P6%6%^&w&7t"P6%6% ^&_Fк؋FV&G&^&_Fк&G ^&_Fк؋F&G^&_Fк؋FԋV&G&W^&_Fк؋F؋V&G &W^&_Fк6 7&H&G^&G& GtvvAYYF Ft^FV&G&W^&G uvvGYYu_^]UVWP}Y77 P}Y7 7vvYYF"P6%6%"P6%6%3V6767}VF^&w ^&w&7"P6%6%B^&_Ǻ&w&w^&_Ǻ&w"P6%6%G^&9 }F7&97~f"P6%6%"PvvVF u*vvP0#P"P6%6%"3V6767}VF^&w&7:#P6%6% vvvvSW uv% %t ^&w&wT#P6%6% ^&G4^&_Ǻ&w676 7}VF^&GG^&9 }FF7&97~*% %u >%uJ39V6767}VF^&t>%u^&& Gu^&&?u>%t9PX#P^&w&7+9P]#P^&w&7% b#P9PVF u@9PP#Pe#P6%6%#P6%6%FR %%FV3^&_Ǻ& u u >%u3P^&_Ǻ&w&wvv t46)YRPP#P#P6%6%PWY^&_Ǻ&w676 7}VF^&G^&_Ǻ&G@ 7&;}^&G&WFV FFvvvvvvu G^&9 |FV;%u;%t vvGYYF7&97~% %u % %u$33P676 7}VF^&u3P^&w&wvv t46)YRP$P#P#P6%6%PWY^&uA% %t8 7&H;~ ^&W&GRP6%6%vv_ I^&u?% %t6 7&H;~ ^&W&GRP6%6%vv FF  7&97~3sV6767}VF^&G& Gt^&w&wAYY^&G& Gt^&w&wAYY^&& Gt^&w&7AYYF7&976767AYY676 7AYYvvGYYF_^]UVWP}Y77 P}Y7 7FPaYY t ~uvPPvv t#P6%6%$P6%6%3V6767}VF^&w ^&w&7;$P6%6%{^&_Ǻ&& Gt^&_Ǻ&W&ڸY$RP^&_Ǻ&w&w^&_Ǻ&wI$P6%6%G^&9 |yF7&97~*Z$P6%6%3V6767}VF^&w&7\$P6%6% vvr WYY uv% %t ^&w&wv$P6%6% ^&G4^&_Ǻ&w676 7}VF^&GG^&9 }FF7&97~1% %u >%u 3V6767}VF^&t>%u^&& Gu^&&?u>%t9Pz$P^&w&7+9P$P^&w&7% $P9PVF u@9PP$P$P6%6%$P6%6%F %%FV3^&_Ǻ& u^&_Ǻ&& Gu$P^&_Ǻ&w&7VF uR^&_Ǻ&w&7P$P$P6%6%%P6%6%F 3P^&_Ǻ&w&wvv t46)YRPP&%P%P6%6%PWY^&_Ǻ&w676 7}VF^&GP?Pvv =t\?P0%&FPFP?P( t4?P4%Pvv P?Pvv =uG^&9 |/FV;%u;%t vvGYYvvGYYF7&97~% %u33P676 7}VFm^&t[^&& GuJ8%P^&w&7VF uE^&w&7?Pe%P;%P6%6%o%P6%6%F3P^&w&wvv t46)YRPMP%P}%P6%6%PWYP?Pvv =t^?P%&FPFP?P( t6?P%P6%6% P?Pvv =u^&GvvGYYFF  7&97~3sV6767}VF^&G& Gt^&w&wAYY^&G& Gt^&w&wAYY^&& Gt^&w&7AYYF7&976767AYY676 7AYYF_^]UF ^&N #]UVW^&&?^u ^&3FF^ &F~|F^&&?\u ^&^&&?-t~u^&&t}^&&]tp^&S&G[&&=\u^&S&G[&&F@FNV^ & F9v|F^&&^&&^ & ^&&F^&^&&?t^&&?]t^&&?]u^& t,FF^ &ЋV^ &F~|^ &'^ &'_^]UVvvvv v  uE^&G tp3^&Gt(<P4&P&P6%6%PWY%v v *YYN ~^ &x t^ &x t^ &3^]UV6%6%7)P3"3ޱ%%3"YYFޱ㋇% %uڃ>%tڸ)ڸ)RPv)P3">%tڸ)ڸ)RP)P3">%tڸ)ڸ*RP)P3"^]UVW~}BPWY%%,FhFF3nƱ^&G&FV^&?-tF^&F uPWYyFPvv (VF uPWYL^&>u?F^&?u1@;F}FƱ^&G&FVjPWYFF FF .;Ft.g^&?-u%%ovvC^&?-u%%G% %t6%6%GYY*Pvv%% u=vvP3*P *P,P<*P,PPWY^&?-u%%% %t6%6%GYYI*Pvv%% u=vvPv*PL*P,P*P,PPWYAF Ft vvGYY^&?-u ^F,H*PvvVF u+vv#P*P*P6%6%*vvX% %t9%u>%,t6%6%GYY^&?-u %%,Z*Pvv%% u^&?A|5^&?F,VF^P&R[Yڃ ^NF^&?t9VF]UVvv*YY@VP YYVF u(=P+Pr+P6%6%PWYvvvv3)VF^]U+PvvVF tvvGYY3]UFVFVF V FV3^&^&FFA;N|]UVvFVFVF V FVF;Fs3^&^&FFA;|/F;Fv'HFHF3^&^&NNA;|^]UVW^&%?Fv3Pvv 3FM^&%?F^ ߊFN&~~*NF^ &A~}GF%FF;v~F_^]U39^&?~u>+t ^&^^&? | ^&?`~ B;V|¸]UVW^&? | ^&?M~ ^&?`t^&%?vv*YY^&?Mu ^&<|^&? t ^&?`u ^&`ƻ t ƻ@ƻ^&^&@;t,^&;tƻƻRZB^&^&@;t^&;tZvvW=u u3v v vv tvvYY t_^]UV^ &FPFPvv t!vvvvv ^ &^]UVWvv*YYF^&%?FF t F@ F9~v ^&`F;~^&vvvvW ^ &_^]Borland C++ - Copyright 1991 Borland Intl.Divide error Abnormal program termination HB0w,aQ mjp5c飕d2yҗ+L |~-d jHqA}mQDžӃVlkdzbeO\lcc=  n;^iLA`rqgjm Zjz  ' }Dңhi]Wbgeq6lknv+ӉZzJgo߹ﾎCՎ`~ѡ8ROggW?K6H+ L J6`zA`Ugn1yiFafo%6hRw G "/&U;( Z+j\1е,[d&c윣ju m ?6grWJz+{8 Ғ |! ӆBhn[&wowGZpj;f\ eibkaElx TN³9a&g`MGiIwn>JjѮZf @;7SŞϲG0򽽊º0S$6к)WTg#.zfJah]+o*7 Z-%s %d : Error - %s calccrc.cexpecting '{' to open ID part block.duplicate sub-expression numbers.missing sub-expression number.duplicate sub-expression numbers.missing 'number' after 'segment'.missing sub-expression number.duplicate sub-expression numbers.missing sub-expression number.duplicate sub-expression numbers.missing 'id' after 'alternate'.missing sub-expression number.duplicate sub-expression numbers.expected case sensitivity type after 'case'.Unexpected token in ID part blockexpecting '}' to close ID part block.expecting '}' to close ID prefix block.expecting '{' after ID prefix regular expression.expecting '}' to close ID block.expecting SEGMENT token.expecting regular expression source string.expecting '{' to open SEGMENT block.expecting 'header' in SEGMENT block.expecting '{' to open HEADER block.expecting 'body' in SEGMENT block.expecting '{' to open BODY block.expecting '}' to close SEGMENT block. %s %d : Error - file '%s' already exists. decode.cwb+ %s %d : Error - %s '%s' decode.c %s %d : Error - missing begin line. decode.c '%s' %s %d : Error - missing begin line. decode.c %s %d : Error - file '%s' already exists. decode.cwt %s %d : Error - Could not open description file decode.c'%s' for writing. %s %d : Error - %s decode.c%s %s %s %d : Error - %s decode.c%s %s %d : Error - Bad write to binary file. decode.c %s %d : Error - missing segment #%d. decode.c Binary ID: '%s' %s %d : Error - missing file name. decode.c Binary ID: '%s' .dsc %s %d : Error - %s decode.c %s %d : Error - Missing UU end line. decode.c '%s' %s %d : Warning - Early uuencode end line. decode.c %s %d : Error - Unexpected UU begin line. decode.c%s %d : Error - POST CRC is decode.c0x%08lx, UNPOST CRC is 0x%08lx. %s %d : Error - file '%s' already exists. decode.cwt %s %d : Error - Could not open description file decode.c'%s' for writing. rb%s %d : Error - could not open file '%s' for reading. decode.c %s %d : Error - %s decode.c%s %s rb%s %d : Error - could not open file '%s' for reading. decode.c %s %d : Error - %s decode.c%s %s %d : Error - missing segment #%d. decode.c Binary ID: '%s' %s %d : Error - missing file name. decode.c Binary ID: '%s' .dscrb%s %d : Error - could not open file '%s' for reading. decode.c %s %d : Error - %s decode.c %s %d : Error - Missing UU end line. decode.c '%s' %s %d : Warning - Early uuencode end line. decode.c %s %d : Error - Unexpected UU begin line. decode.c%s %d : Error - POST CRC is decode.c0x%08lx, UNPOST CRC is 0x%08lx.  .gif .gif# .jpg( .hsi- GIF87aGIF89aJFIFhsi1 e t0 a> nL rZ eh tv l y d o e s a r e d a e e r: oH nV dgd r e b m u t r a s t  n e m! e v= iK tY ig su g/ n g n i r e t l a t o a b c h, ir n p s t {}%s %d : Error - cannot identify string '%s' lex.cin line %d rt%s %d : Error - %s lex.c File Name: '%s' %s %d : Error - %s lex.c Line %d, word '%s' %s %d : Error - Out of memory. list.c%s %d : Error - Out of memory. list.c%s %d : Error - Out of memory. list.c    a-z0-9_.-aeiouy_-0-9a-z%s %d : Error - Could not modify file name to be modflnm.cMS-DOS conformant.   & Y      # ? \              &  0 B w f                 ^Subject:(.*)[[({]Part[_ ]*([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)^Subject:(.*)Part[_ ]*[[({]([0-9]+)[^0-9]+([0-9]+)[)\]}](.*)^Subject:(.*)Part[_ ]+([0-9]+)[^0-9]+([0-9]+)(.*)^Subject:(.*)[([{][ ]*([0-9]+)[^0-9]+([0-9]+)[ ]*[)\]}](.*)^Subject:(.*)([0-9]+)([/|]|[ ]+of[ ]+)([0-9]+)(.*)^Subject:(.*)^X-File-Name:[ ]+(.*)^X-Part:[ ]+([0-9]+)^X-Part-Total:[ ]+([0-9]+)^Uusplit-part:[ ]+([0-9]+)^Uusplit-parts:[ ]+([0-9]+)^section ([0-9]+) of uuencode [0-9]+\.[0-9]+ of file ([^ ]+)[ ]+by R.E.M.^POST V.* ([^ ]+).*\(Part ([0-9]+)/([0-9]+)\)^Subject:^X-File-Name:^X-Part:^X-Part-Total:^Uusplit-part:^Uusplit-parts:^Subject:^section [0-9]+ of uuencode [0-9]+\.[0-9]+ of file [^ ]+ by R.E.M.^POST V^(Article[:]?|X-NEWS:) ^From[:]? ^From ^Newsgroups: ^begin[ ]+([0-7]+)[ ]+([^ ]+)^end[ ]*$^POST Crc: 0x([0-9a-fA-F]+)%s %d : Warning - Unexpected end of file in segment: parse.c Segment: '%s' %s %d : Warning - No UU line after begin. parse.c Segment: '%s' %s %d : Error - %s parse.c%s %d : Error - %s parse.c%s %d : Error - Got number of segments but not parse.csegment number. Number of Segments: %d Assuming Part 1 of 1 %s %d : Error - Got segment number but not number parse.cof segments. Segment Number: %d Assuming Part 1 of 1 %s %d : Error - No begin line in first segment: parse.c Segment: '%s' %s %d : Error - Missing configuraiton file name. parse.cF M R [().|${*?+0-9%s %d : Out of memory. recomp.c%s %d : Error - missing '}' in regular expression. recomp.c%s %d : Out of memory. recomp.c%s %d : Error - To many sub-expressions. recomp.c%s %d : Error - missing ')' in regular expression. recomp.c%s %d : Error - badly formed regular expression. recomp.c Unexpected character '%c' %s %d : Out of memory. recomp.c%s %d : Error, can not enumerate a sub expression. recomp.c%s %d : Error - illegal regular expression node type. recomp.c%s %d : Error - sub expression #%d extraction failed. rematch.c%s %d : Out of memory. rematch.c%s %d : Error - illegal regular expression node type. rematch.crb%s %d : Error - could not open file '%s' for reading. segment.c%s %d : Error - file '%s' already exists. segment.cwb%s %d : Error - %s '%s' segment.c %s %d : Error - Bad write to binary file. segment.crb%s %d : Error - could not open file '%s' for reading. segment.c%s %d : Error - file '%s' already exists. segment.cwb%s %d : Error - %s '%s' segment.c%s %d : Error - Unexpected end of file. segment.c%s %d : Error - %s segment.c%s %d : Error - Unexpected UU begin line. segment.c%s rb%s %d : Error - could not open file '%s' for reading. segment.c%s %d : Error - out of memory. segment.c%s %d : Error - Segment number #%d greater than numbersegment.c of segments in: Segment: '%s' %s %d : Warning - POST CRC expected, segment.cbut missing in segment #%d. %s %d : Warning - POST CRC changed in segment.c segment #%d. %s %d : Warning - duplicate segment #%d in: segment.c Binary ID: '%s' File ID Segments ---------------------------------------- %-30.30s %d %3d %9ld rb%s %d : Error - could not open file '%s' for reading. segment.cDecoding Binary ID: '%s' %s .uue.uueat%s %d : Error - File '%s' cannot be opened segment.cfor appending. %s %d : Error - %s segment.c%s %d : Error - %s segment.cFile ID Segments ---------------------------------------- %-30.30s %d %3d %9ld %s Decoding Binary ID: '%s' %s .uue.uueat%s %d : Error - File '%s' cannot be opened segment.cfor appending. rb%s %d : Error - could not open file '%s' segment.cfor reading. %s %d : Error - %s segment.c%s %s rb%s %d : Error - could not open file '%s' segment.cfor reading. %s %d : Error - %s segment.c%s %s & =& G& & & & #' X' ' ' ( E( y( ( ( ) UNPOST V2.3.4%s %d : Error - reading source file. unpost.cOptions: -b[-] Break incompletes into separate files. -d[-] Dump descriptions flag. -e File for errors (default standard error). -f[-] Modify file names to be MS-DOS compatible. -h Interpret headers in source files. -i File to write incomplete binaries to. -l File to read list of files to process from. -o File to write decoded file names to. -r Set news reader type (SEGMENT begin line RE). -s Assume segments in order in file. -t File for text only segments. -u UU decoder, pure and simple. -v Print the version number and quit. -? Show this help summary. %s --- Extract a uuencoded binary from a multi-part posting. File Name Modifying (-f) : %-3.3s OnOffCreate Description Files (-d) : %-3.3s OnOffSeparate Incomplete Files (-b) : %-3.3s OnOffwt%s %d : Error - Could not open file '%s' unpost.cfor output. at%s %d : Error - Could not open file '%s' unpost.cfor output. rb%s %d : Error - could not open file '%s' unpost.cfor reading. at%s %d : Error - could not open file '%s' unpost.cfor writing. wt%s %d : Error - Could not open file '%s' unpost.cfor output. %s bc>de>fhi>l>o>r>st>uv%s %d : Error - out of memory. utils.crt !!!!! @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@  , ,,C,B-```@),(((((),(((),#,*((((**#(#%(TMP.$$$(null)       print scanf : floating point formats not linked D0 L0 d0 ~0 0 0 0 0 0 0 1 1 *1 >1 K1 L1 [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 "2 42 52 62 72 82 92 :2 ;2 <2 =2 >2 0Error 0Invalid function numberNo such file or directoryPath not foundToo many open filesPermission deniedBad file numberMemory arena trashedNot enough memoryInvalid memory block addressInvalid environmentInvalid formatInvalid access codeInvalid dataNo such deviceAttempted to remove current directoryNot same deviceNo more filesInvalid argumentArg list too bigExec format errorCross-device linkMath argumentResult too largeFile already existsPossible deadlockUnknown error%s: %s Unknown error%s: %s %s xRBw$ u Wjkz     Wfx4m !"#2$[%&'((I)x*2+^,-Q . / 0 1 2A3A4K5U6789:;s<=>-?\@mABCDGEFGhHfI7JKL!MNVO6PwQRS}TUVW X!Y!Z3"[N"\j"]#^$_&`&aD(bf(c(d(e)f3)g)h)i*j!*k$*l*m+n,oY,p#qGrxWswSWtvr Wu7v+DwDx,Dy@Dz}{}|l}}}~:}0+%9876(5 432 d ,c ,XX) XX5G c  c  kc  c  c  -   [ _ c g k m q u w y { } } } ~  % % % % % % % % % + + , , , , @. B. j. l. n. p. . r/ t/ / B0 v2 x2 7 9 ; = ? A      $ %()23%5)3) %7)3) 75(-.*  &3  -J I*K2 4O 5O 6L 7P8L6L 5O 4O 4O 9Q :O 6L ;L1U<U=7P>a6L :O 9Q 4O >c 8L 6L ?6L 8L >c 9Q 6L @ Ad>aB8L6L 9Q 4O 9Q :O ;L1U<U=7P>a6L:O 9Q 4O 9Q @ Ae>aB8L6L9Q FRGTVXHa\]Y   M \E{WDz<WCy`WZ} [ | |\| [ Z} ^_  ] m n o pqrBso n m  tn u u v v  lwD. 0 > L Z h v             , : H V d r            ! / = K Y g u      ~ } | { z y x+ 4 4               sBqp                u u 5 5  Z 5 5 Z  A  5 5  A           4 4 5 >5 5 7 6 ?6 7 5  7 7   7 1 <  7 < 1         7     7 >    6 1<=6    > 7      6 76        6 5>1<76    \  \  _H     ?>=0<; :M L K J I H GB Ff E D C B. AN @n        NU U N U U N U SVNU U NNU U NNNNU U NNU U NNU N N N!NN N S WNS N "NNN OPn   Z O*l,)kZ,(j,'i\,&h_,%g),$f,+m,#e1,28 1S: /S> -SB  ^5 ,n`5 .n5 0n5 o5o o o o q p 6o 76o p q 8w q p 6o qq9o76o p q 8w :z q x o q;oo7o x q :z 7{5 Brsx  } r? >_=<@x: A6 E 57?86E u 586?7>u F G G F H 8 6 6 8 H u IJ6u u KJ86\u L 1<Ju86\L QFGH    PXOXMLX 7 N7  + +  +  UV +   Y 4 J J 4 Y Z [ \ ]^_`La\ [ Z [ \ \ [     cbOd%  g   5 5 h5 i j k lmk j i i j k lmk j i    p qrs\p    p p  = 7  ts 7 =  [  7>= [   [  =ts [  H    v u w+   3 G e k C   .   4 0   }  T   X   f o  332MnY3jztD33333כnD3S3Wne3n3U^ ac/g/hYoepiqilstD OU'V-W3X9Y?\E_Mbacugjlmqrtwx{ 3?IPUX^jt$),2>H\hr  #:TYmyR  *!2'?*G-[.o2459<AB$F HIM&N;QUSUVyWajmoptz|} 2KP\fz$.:Qkw ( +-.G0X4X5|9;@AEFJMNPRVY^8j<yC{TTx~  'DPln77FHex##A J OS&\)a+x/x0238:=>@AEKL7PUU[W[\`cejknosv x){)|G~Gaqsy""HUZ`gxx 00_  ) O O m    ! ) , - / 0 & 2; 5N 6[ 7h 8m Br T{ W Y ] ^ ` a f h k l n s u' vE z] }c       ) . . W W {                " $ * * H U e         *349:<=?@[Aw?y>zDFGLM~#.3=U[agmu~!%+4:@H\`r &9>@F K ii$&*+-. 0*7,9/:>B@FCJCKgNgOP" '(2*M-M.k2u6}79;?@ABLSTV'Y'ZE^O_V`_agnlwt} 8:@Of! &(',*-.60=6?@@MA_BlC~DEFGKNQRT U'a+n3p=qJr\sit{uvwx|4Jbqsu568GJauw} *>DDbbw}   %(+.O1[2d*p+p)v478:; );_fhr7 : <Qj$%-23<@A&K(S/V3Y3[a\]bcdeoy|!*+:=X_cn,./DLOTmwz% ' PT^`+>ACDHKM#Q#RM[Y\x^xcfijknqstuvw.y0z:{=~TTrr)Vnn 2 J g o        ' * + . 3) 4= 9A <R @R A| E K L M P Q V X [ \ ^ _1 e< kU l\ mt n{ v        P S      # > C J     :bc<FHRT^`jlp05Sos  #'E"$'(,/23 ; >AB)C?DU &&DNVZag8AJMXajm     5?EG&\.d23458;<>ABFGH ILOP(S0U7X7YU[_^macfgijmnpstvw6{@JWp ((FPRZ_ew %)/?Q #)3";#R%T(f+r.x/0156AGORSTWX L\%]-h1o7sMtWu_vmy~z{~ " % / 7 H k            ' / B J ] e x ~            # 4 > P R R p z      %()@*E,c0c15786<>ABF G/J9LYX__dbkcfghi\lm~;ADioq CSx%55^$`%i'n+z03589:=@EFGI J;N=OEQVTnU~Vdsvwz{+7=Fmy .:<3@3AWM`RUXZ^dfkl3vEwUzX}o~uwsE 55Ybu44f $ ??is| %&'1456AILM,F.OJ^LmToqsqtz~168=Yanqss00JJhrx    '*-:@@^ ^!v"y#{%()+,1378 : ;! ?$ @B AY Bq C D H I J K { O P Q# Y) m1 nB qS tb uw v x y | } ~  + @ ] ]             ; N P b u z          C C X ] ` b o t         )2Pcm!%&I*S-f1f236:@CFG H2I?JQK]OxPQRS\stwyzx}~-BG^^27NNm~5?Bjq/4MPP~~'1[ d !")",.3L4V5[6g9j:j<@ABCDHJNOS$V@^K_fbh[gh.-mpstuv wx*|E}T~ch3"5-=/I0L1R3T6V7]:u=|>?DGJKNO P/V3W]YZ]_`def*25 6+729=<==[EeFiHzIzG{KNOkpqtuxyz{|*}*~LOW]akuy59CEHJNox$'08>AJ Y ww $% *'.5/N2]3f4r6:;<>@ADEHJNO6PHRRVUW[Y^Zs]|`abdefhijlnorsGMRjo "4 \!n"#%&.58 :"=">@BJC^DfNkVqYZ\]gpsrqt+-5EWX\' (--295K6[7a:r;x>y/.BCRZ[\]^abrz}#,6HR^i{ ")-4<UZ^z *\2T 5  /<S CL # 'S )\1`4 g >r ?{ \_nqy+{2zD~ro,/@R CO" #bq%gl't(}y2*,:,@-Ob $/!016+ 33%5+!$ 7 .*/9$1&3;#5(8=/=??DHAP$W CchEp t G  I ~KMROO KQHSS MZU_KWD\Yd_[e)]/_~ax1c7 e f' W h RjJ _` lb]!n p"q& riBCtIJ vS#Ux WTZzQ]L^ |Tg) i~1 ~hz 8qr '$5=O WG,M& vok=q7>8{q LIKF-W 4P W 7D }"  /S7 , S   j  X_t    r c ^     K?-m  z   D-qE    (  + ##### ##  & "-""0  3 6(:5##,#<#<#####)# #)#<##H7#8#6M?ORITQV XX\"d\f"n| "a####a#a# ###O# ###L#######L#}#"Kl"#############TP#####################  "" " # ##"################################    0T$$$$$$$~O", SXZ/###S###a##N#N#N#N#N#N#N###N#N or9"AO q"RpPo}T### ########## ^b"l rv~ "" ########################### ############ ########### ###########@## ########### "### ######     ' ) *,.,,   0 !"#$% & ' ( ) *)+1,4-.)/6, .)0818, NN IO5OJK LMSNOOPQR.O/W[ O Y[][[   _ !"#$% & ' ( ) *O+`STUVWX`abcdefg}hi     ,-           ./        !"#$% & ' ( ) *+ OPK LI5STUVWX.01`abcdPNN   R !"#$% & ' ( ) *S+T XX sqq   u !"#$% & ' ( ) *o+v ~~ Cooo   STUVWXNR I5JK LMNOPQROPK LI5./      !"#$% & ' ( ) *+       STUVWX s*:|>wL /cei 'Muw 3IX^t,2H\r #Ym*2?Goq & 24KPf. -GX|58<CTx{~ 'DPlnx<AFHe#GJOS\axU[ )qsyHZ`gx 0K_ ) O m     ; m r { ' ] c ) . U W v {  " $ * H [ e r s  <?[wyz3[agmu~%+24:@FH\`rx~  &>@FKei*,/>@C Mu}'Oglt} 8:@O *.06@ '+3= 4Jbsu,58GJS\awz} "*Dz}%+Odpv );DMV_r<j&(/3a!*+:=FOXcen./DLOTVZbjmwz%'PRT^`#WY0:=JT)XYn 4 5 J g m o }   ) ? A : < \ t { P S # C J bc )168<HT`lp05s'ab{|  U &NVZ_ags$,148AMXm ?G\dnv{7_@Wcp(PRZ_e %)/?]iu #Tfr%-17=FM%  ' ~ < > I P R z -@CEc PQY_bdk;ADP\acioq Cx%^`inpqz =EVZbn%&+Fmy 3WZ]`|3CEUXuw 5Y\_b4f$?s|',.JLTq%+18anqsy0Jr-:@{$   # ) 1     + ]   D E N P U V b k u z   ` b o t PcmS]fr 2?Q]noxG7~?BL[jq/24MP~1".LVY[gj$@Kfhq *;<Eh35=ITV]lou| '*/3io{ +.02=ez{18=LOW]k5CEHJNR[chkox$'08>AJYw'5>FN]frRU^|GMo "+4\en"Jfkq&'+-5EWX\ 9arxy,6?HR^iq{ "')-4Z\^__SETARGV____CVTFAK__AHSHIFT__CLEANUP__CHECKNULL__TERMINATE__RESTOREZERO_ABORTDGROUP@__MMODEL_ATEXIT__DOS_GETFILEATTR__DOS_SETFILEATTR_EXIT__EXIT__CEXIT__C_EXITN_LXLSH@F_LXLSH@LXLSH@N_LXURSH@F_LXURSH@LXURSH@N_PADD@F_PADD@PADD@N_PSUB@F_PSUB@PSUB@__IOERROR__DOSERROR_ISATTY__LONGTOA__UTOA_LSEEK__MKNAME__TMPNAMN_LXMUL@N_PCMP@__READ__SETUPIO_TOLOWER_UNLINK__VPRINTER__STPCPY_CALLOC___FIRST___LAST___ROVER_FREE_FARFREE_MALLOC_FARMALLOC__AHINCR_REALLOC_FARREALLOC__BRK__SBRK_IOCTL__REALCVT_SETBLOCK_ATOL_ATOI__CHMOD_CLOSE__CLOSE_EOF_FCLOSE_FFLUSH_FGETS_FLUSHALL__OPENFP__GETFP_FOPEN_FPRINTF_FREAD_FSEEK_FTELL_FWRITE__FGETC__NFGETC_FGETC_FGETCHAR_MEMCPY_SETMEM_MEMSET_OPEN__OPEN_PERROR_PRINTF__FPUTC_FPUTC_FPUTCHAR__FPUTN___READ_SETVBUF_SPRINTF_VSPRINTF_STRCAT_STRCHR_STRCMP_STRCPY__STRERROR_STRERROR_STRLEN__NUNGETC_UNGETC___WRITE__WRITE__XFCLOSE__XFFLUSH_CALCCRC_READCONFIG_DECSEG_DECODE_MULTIDECODE_IDUUFILE_LEX_OPENCFG_CLOSECFG_PARSEERR_ADDLIST_CRTLIST_SRCHLIST_LISTIDX_APPLIST_FLNMFILTER_MODIFYFLNM_MODEXTEN_GETBINFLNM_MATCHEND_MATCHBEGIN_MATCHSEGMENT_PARSE_SETSEGBEGIN_LOADCFG_PARSEINIT_RECOMPILE_FREEREEXPR_REMATCH_UUDECODE_SINGLE_MULTIPLE_MULTIFILE_INSET_CRTSET_READLINE_MAIN_HEXTOUL_STRDUP_FILEEXISTS_MEMCOPY_MEMMV_CHKUULINE_DECUULINE_DECTRUNCUULNDATASEG@__INT0VECTOR__INT4VECTOR__INT5VECTOR__INT6VECTOR__C0ARGC__C0ARGV__C0ENVIRON__ENVLNG__ENVSEG__ENVSIZE__PSP__OSVERSION__OSMAJOR__VERSION__OSMINOR_ERRNO__STARTTIME___BRKLVL__HEAPBASE__BRKLVL__HEAPTOP_VERSION_LINENUMBER_MSDOSFILENMS_DUMPDESC_SEPINCOMPS_ERRFILE_TEXTFILE_INCOMPFILE_UNPSTDFILE__ATEXITCNT__CTYPE__EXITBUF__EXITFOPEN__EXITOPEN__STREAMS__NFILE__OPENFD__FMODE__NOTUMASK__DOSERRNO__DOSERRORTOSV__STKLEN__ARGC__ARGV_SYS_ERRLIST_SYS_NERR__REALCVTVECTOR__SCANTODVECTOR_OUTBFR_INBFR_UULINE_IDLINE_SEGLINE__ATEXITTBLCALCCRC.CCALCCRCBinFlPtrBfrCrcsizeiCrcFeedBackBYTECRC_TYPEptrdiff_twchar_tFILEfpos_tsize_tlevelflagsfdholdbsizebuffercurpistemptokenCONFIG.CCONFIGreg_exp_stPartListNewParttpElementstknsymPreFixListNewIDCfgFlNmSegListNewSegParseIDsParsePartsReStrSEGMENTIDENTPART_REREG_EXP_NODENODE_TYPECASE_CMPSET_TYPEUINTLISTTOKENNoElemsTotElemsElemSzListReExpStrIDStrSegNoNoSegsAltIDStrCaseReExprCASE_SENSITIVEIGN_CASENodeTypeLeftRightMinSpanMaxSpanSubExprNodataNODE_TYPE_NOT_SETOP_ENUMOP_OROP_ANDOP_L_PARENOP_R_PARENEND_OREND_ENUMDATA_LEFT_ANCHORDATA_RIGHT_ANCHORDATA_ANYDATA_SPANDATA_STRINGDATA_SETMatchStrCSetstrnoReExprStrIdPartsHeaderBodyDECODE.CDECODEInBfrFlNameInFlPtrRetStrsOutFlPtrFlDescDescFlNameDescFileHdrEncLenUULnTypeOutLenUnpostCRCOutFlNmretMultiWriteDescWriteDescOpenBinFileFL_LISTSEGSCHK_UU_ENCIDStringSuccessPostCRCChkCRCSegsSrcFlNmSegOfsUUOfsExistsSegLstOrdUU_TYPE_NOT_SETNOT_UU_LINEIS_UU_LINEUU_SPACEUU_BEGINUU_ENDIDENT.CExtLenjFileTypesFILE_TYPESBIN_TYPESUNKNOWN_TYPEGIF87AGIF89AJFIF_JPEGHSI1_JPEGOffsetlengthstringextFileTypeLEX.CLEXkey_stWordPtrchKeyshilocmpmidbfFileNmErrStrTrieSrchT0T32T33T34T35T21T2eT2fT30T31T22T28T29T2aT2bT2cT2dT23T24T25T26T27T1eT1fT20T19T1aT1bT1cT1dT14T15T16T17T18TfT10T11T12T13TcTdTeT9TaTbT1T2T3T4T5T6T7T8PrgFlLnNowordKEYTKNScvalbranchT_NOT_FNDT_ALTERNATET_BODYT_CASET_HEADERT_IDT_IGNORET_NUMBERT_PARTT_SEGMENTT_SEGMENTST_SENSITIVET_STRINGT_TOTALT_L_BRACET_R_BRACET_DBL_QUOTET_INT_NOLIST.CInsPtElemHeadNewSizeSizeCmpFnIndexMODFLNM.CMODFLNMcpOutNameChopFlaglenExtenExtPtrOutPtrInPtrChkFlNmLenAlphaNumbersThrowStandAlphaSetNoSetThrowSetStandSetInitSetsSETPARSE.CPARSEBeginNamespRetValLnOfsLineSubStrDestPtrExtSepSegInfoPartREsIDLineIDBfrPartRecIdPtrSegLinekSegTypeSegPtrPartPtrCompCfgFreeCfgIdSearchParseIDLineGetBinIDCrcStrEndStrBeginStrCrcREEndBeginSegmentsGroupsSegsEmailSegsNnSegsRnSegsBody1Hdr1Parts10Parts8Parts7Parts6Parts5Parts4Parts3Parts1SEG_INFORECOMP.CRECOMPNewStrRootTmpBufferNodeNextPrevSubExprLinkRetLinkEndOrReGraphAnchorCatenationEnumerateUnaryEnumOpGetIntAllocRegExpNodeAlternationDecSetDecStrPostSetPostFixStrSpecSetSpecStrReInitFlagREMATCH.CREMATCHStrLenSrcStartMatchContChkPtSubStrsLoopReOpReDataReStrCmpExtSubStrsCmpCaseSubExprsSUB_EXPRStartSEGMENT.CInFlNmFile2File1NextSegNewFileFlPtrEndOfsFlsPtrInterpretFileListDumpSegCmpFlSEG_LISTCopyFlagSETS.CSETSLastChNegateFlagUNPOST.CUNPOSTBfrMaxSwListargvargcModeFlagSwCharSwPtrArgPtrtCmdLineParseShowSynopsisSynopsisUTILS.CUTILSULongfpNoBytesSourceDestsdUUDEC.CUUDECLnLenShifttmpRecLenBfrLenChkUUCharsUULnDecFixBitNetTwiddleFlagunpost/msdos/list.exe100755 23453 0 16232 5543404354 14623 0ustar jeanpaulsystemMZ >Pjru.0!.,ڣ.3؋aC&8ùى+>s>njr(>&r"G;r>t>&u;w ډ+؎JW!_ҋ3.J+>vG>r@w>r7X!r*g!r H!r@HI!r X!s t @p&3.>J666gP.VWJJ_^VW.3/&F-\ t / _^ËLF!H5!tv5!xz5!|~5!%ʎں!%t!%x!%|!%!ø׋;t&?t&O2;sӃ;t&?&t&_&Wô׋;t&?t &8gr&gӃ;t&?&t&_&Wô@!ùV.PUV^7P=YYF;v|^]U> uFJ3]UVv uJ>u-6~u uvFY^]U3PPv]UP3Pv]3PP3PøPP3PyUVv |X~W6(* ރ0(6^]UVvV^]UD^!%]U"VW~ ^$wXrSF N }~t -G؃v+F +F uNN, s:FF _^] U3Pvv PPaPj]U^でBF ^NV!rP]ú;s+LJڱƇ㉇B;rՠPY u&Pt3P3PPPY u&Pt3P3PPÊ'@'UVWFFPFFW2I_6GNu/SQRj+jPWvV uFFP~jZY[j~~v t<%t6GNv<%t~3ɉNNNFF2Ћ؀ `sv. wNЀwNŀw~+tV뵃fN 맀wMFu)N8~6Fs y؃NFou׉FbsʵFU,0wF |F3uF tFNeNfY FV3҈V~6 FV~6GGvFt6GG~~ u u~u 6NRPWǘPFPSoV }Vv~^67CC^F t6CC^:Z6FfN+ϋV;vV~6F~26vV~F u 6=F 6=F uP;NvNvV~N }WQ^SR#FPFt F FPE~FtV ~&=-uI+~V&=-t F tO&~~ N }N~^#F=ufou ~FxtXuN@KKn}FNFu  yK;F@t 0hFbV ~'++&<-t< t<+u&CIK08+&6GN+ ~ ˰ Uv~F u 6=F6=FP*FF&FtGG&v~% u~P}~tF_^]O9D m2> _e. 6>2&@Ň֓6FF>r2㴀P@%+rI2KHRQSF. PzYY^FV=t^FF/!^FV!~3҉~ 2vrrPt< t< t< t<"t"Xrt< t < t< t<"u9rt<"t < t2B룋+FtRW. PY_Zv+B(I<\t66&UFԁ;s3 ]UFV ur ;s ]UvY]UFRPYY]ú@!'@!`VW\r;,tB_^9*t#wt6, ;6*t TG, 3*,.S[;*twu?u2?t\ߋ;t>.wu|.Ë6. t|\]wÉ.__VWD tRr6%=s>*t. t 9s_;uf!397sk_^P3PP][[%t 3RPO[[XP3SPD[[=t؉*,X@[3P3SP[[=tء,G,X@X3)7@\uËSPQP[ tv VF$[^˃;w5;,uSPr[[]+)|Bˋ7كVWU^F t7 t-IЃs;r wO PeS3[]_^&6UVW~ unf9}t^=|)Eu 9E uF9E u8EE 0.E@)5PEE PEP;t EuM3_^]UVWF>DtVbYFO uF_^]UVWv<} TB 3+‹ЋD@u,L <} Iـ? uGJ uA? uGJ u_^]UVWv~ VY tGu<~ V|)FVd_DD WvvDPiu =u3_^]UVvP33PRDP5VFu=u<}tDtWP33PRDPVFu=tP3PvvDPu =u*FVFVVFV V)FVVF^]UVW~vNsF_^]U츀PPvFP:]UVv VFPYY^]UVW~F=}:] E Eu> t > tW@Y uEuEuMM}tE=t WY uʋE؉] E Eu> t> uzWY tqmEtP33PREPp> uE@uP0PEP=uPPEP=t Eu=_^]UPvYY]UVW~FFEt)W^FPYY=u3YFN uIE@u}uE;FsQ=t WY uŊEtP33PREPvvEP;FuF|=u +E W}Y t`vvu FFE EtP33PREPvvEPF;Fta\}t=/}] E vFW^FPVYY=uFN uvvEP;FtF_^]UVWv~ 9tu ~v>4uu4>2u u2<tP33PRVdDttYdDDD ~t> v:!~uWgYF uuLlFD D|~uL3_^]UVW~v;>r PF@=s3tP33PRWc@uvVWでvFFMN^FF< u FFFx+Ё|'+VPW[;tu=F+F1x~ux+ v!VxPW ;ttŋF+F_^]U^tP@^NV!rP^くXPv]VWDtVYO u_^Borland C++ - Copyright 1991 Borland Intl.Null pointer assignment Divide error Abnormal program termination %s     CB```),(((((),(((),#,*((((**#(#%((null)       print scanf : floating point formats not linked * / / / ! unpost/unpost.sum100644 23453 0 20110 5543405054 14057 0ustar jeanpaulsystemUNPOST Version 2.3.3 UNPOST is a "smart" uudecoder that is designed to extract binaries from multi-part USENET or email uuencoded binaries. Features: 1) PORTABILITY! UNPOST has been compiled and sucessfully run on MS-DOS, OS/2, Windows, Unix workstations, MacIntoshes, Amiga's and VAX/VMS systems. The code is written to be pure ANSI C, within reasonable limits. (some ANSI C capabilities are not used where they would be appropriate due to lagging compliance in most compilers. I personally check to make sure that it will compile and run on an MS-DOS box running MS-DOS 5 and Windows 3.1, using the Borland 3.1 C++ compiler, as well as a Sun (running SunOs 4.1.1 sun4c) using the gcc compiler (version 2.1). I know for a fact that the Sun cc compiler will NOT compile UNPOST succesfully. I have compiled version 2.1.0 on my Amiga, but no later version has been compiled due to the machine's untimely death. I will be testing all future versions for compilabiliy under OS/2 using the EMX GCC tools. 2) CONFIGURABILITY! UNPOST comes with a default set of rules for detecting and parsing a VERY wide range of possible Subject: line formats, but no configuration can be correct for every situation. With that in mind, UNPOST can be configured by the user by creating a text file that contains the regular expressions, etc. that UNPOST uses to recognize, parse, etc. WARNING! UNPOST depends almost ENTIRELY on the contents of it's configuration file for correct operation. Regular expressions are complex, and writing one that works the way you expect it to takes care and, most importantly, experimentation. To this end, the standard UNPOST installation creates both the UNPOST executable and a regular expression test program called RETEST. RETEST is like grep, feed it a regular expression and a file, and RETEST will tell you what it matched and the sub strings that it extracted. 3) INTELLIGENCE! UNPOST uses every trick in the book to try to guess what the poster/sender REALLY meant. Also, UNPOST is not limited to finding all of it's information on a single line, or even in the header of a posting/letter. UNPOST has succesfully extracted binaries from postings that had, as a subject line, Subject: aaaa because UNPOST recognized the signature placed into the body of the article by a auto-posting program. 4) FLEXIBILITY! UNPOST has switches that allow it to be configured to do different things for different tastes. For instance, UNPOST will intelligently sort out articles into four different classes: 1) Articles that are part of a complete and correct binary in the input file. These are sorted, concatenated, uudecoded and written out to a file name that is the same as that on the uuencode begin line. Depending on the setting of the file name switch, the file name of the binary may be modified. See below. 2) Articles that are pure text (no uuencoded data in them). If the -t switch and a file name are specified, these articles will be written out to the file for reading. If -t is not set, then these articles are just. . . ignored! Obviously, these articles should NEVER be encountered in a binaries news group, but not a single day has ever gone by that I did not see non-binary postings to binary news groups. 3) Articles that are part of incomplete postings (four parts, but only three have shown up so far), or that comprise a complete binary, but one that had an error in uudecoding, interpretation, etc. If the -i flag and a file name are specified, these articles will be written out to the file. If the -b switch is on, incompletes will be written to separate files. If both are on, those incompletes that can be guessed at as having a file name will be written to a separate file, all else will be written to the file named by the -i switch. In my experience, two types of articles end up in an incompletes file, those that have missing parts, and those that have been misinterpreted by UNPOST as belonging to a different binary than they really do. 4) Articles that are pure text that describe a posting (these are usually found only in the pictures groups). If the -d flag is set, and the binary to which they belong is correct and complete, this article, as well as the header and body up to the uuencode begin line of the first article, will be written to a file that has the same base name as the binary, but with the extension .dsc. UNPOST automatically mungles binary file names to be MS-DOS compatible (the lowest common denominator). This is switch controllable, and can be turned on or off (depending on the default setting selected by the person who compiled UNPOST). UNPOST also has two lesser modes, sorted mode and uudecode mode. In sorted mode, UNPOST assumes that the articles still have headers, and that there may be un-uuencoded lines in the middle of a uuencoded file that have to be filtered out, but it assumes that all parts are present, and that they are in order. Header information, however, is ignored. If you use the incompletes file capability of UNPOST, you will notice that it writes out the segments that it did interpret correctly in sorted order. In uudecode mode, UNPOST acts like a simple uudecoder. UUencoded files must be complete, with a begin and end line, and no un-uuencoded lines can appear between the begin and end lines. However, uudecode mode is the ONLY mode where UNPOST will accept a short line (one that was space terminated, but had the spaces chopped off) as a legal uuencoded line and properly decode it. 5) INFORMATIVE! UNPOST is a very talkative program. It detects and reports many kinds of problems, tells you what it thinks is going on, and tells you what it is doing. All this information is written to standard error, or if the -e switch and a file name are specified, written to that file. 6) NEAT TOOLS! UNPOST comes with a client program (called, wierdly enough, CLIENT) for NNTP news servers. CLIENT uses a configuration file that lists the news groups of interest, the file name to append all new articles to, and the number of the next, unread article. CLIENT can be used to call up an NNTP news server on a regular basis (I use cron, myself), get and save all unread articles from the news groups you are interested in (with a nifty new kill feature!). CLIENT, cron and UNPOST (plus a script) can be used to automatically get and decode articles from binaries news groups. Other tools include a regular expression test program to help you construct your own UNPOST configuration files (assuming that the default configuration is not working for you) and a more program that accepts a starting byte offset into a file (for debugging nasty little bugs). Changes for UNPOST Version 2.3.4 -------------------------------- 1) Bug fixes: when the -l switch was used, UNPOST would use up file descriptors 'cause I wasn't closing the part files. This has been fixed, thanks to Daniel Dissett, who found the problem and sent me a fix for it. 2) The regular expression matching code would blow up on lines that were just Subject:, nothing else (blank subject lines). This has been fixed. 3) A tool for creating lists of files has been added for those of you who are so poor that you are using vanilla MS-DOS. It's called list.exe and it can be found in the msdos directory. Source code is not included, 'cause it's so boring. Due to massive system changes, etc, I have lost some notes on new features, bug fixes, etc. If you sent me a note on a bug, or feature that you would like to see implemented, and it hasn't been addressed yet, please re-email me. Thanks. jstevens@csn.org unpost/options.opt100644 23453 0 37 5517261546 14155 0ustar jeanpaulsystemSys$Library:VAXCRTL.EXE /Share unpost/uudec.c100644 23453 0 20402 5543402240 13250 0ustar jeanpaulsystem/****************************************************************************** * Module : UUdecode --- Test for and decode a uuencoded text. * * Author : John W. M. Stevens ******************************************************************************/ #include "compiler.h" #include "unpost.h" #include "regexp.h" #include "parse.h" #include "uudec.h" #define DEC_CHAR(c) (((c) - ' ') & 0x3f) #define CHK_SUM_MASK 0x3f static int FixBitNetTwiddleFlag = 0; /*----------------------------------------------------------------------------- | Routine : UULnDec() --- UU decode a line. | | Inputs : LnLen - Length of line. | Line - Pointer to the line buffer. | Outputs : Bfr - Points to buffer for decoded output. -----------------------------------------------------------------------------*/ static int UULnDec(int LnLen, char *Line, BYTE *Bfr) { register int i; register int j; auto int RecLen; auto int tmp; auto int Shift; /* Zero out buffer. */ RecLen = DEC_CHAR( *Line ); memset(Bfr, 0, RecLen); /* Do actual line decoding. Skip first character, as it is line * length. */ for (i = 1, j = 0, Shift = 2; i <= LnLen; i++) { /* Get six bits. */ tmp = DEC_CHAR( Line[i] ); /* Put into buffer. */ Bfr[j] |= tmp << Shift; if (Shift > 2) Bfr[j - 1] |= tmp >> (8 - Shift); /* Increment byte pointer if neccesary. */ if (Shift < 6) j++; /* Adjust shift size. */ Shift = (Shift + 2) & 0x7; } /* Return size of buffer. */ return( RecLen ); } /*----------------------------------------------------------------------------- | Routine : ChkUUChars() --- Check that a line of the proper length has | the proper characters. | | Inputs : LnLen - Length of line. | Line - Pointer to the line buffer. | Outputs : Line - Pointer to the line buffer with fixes. | | Returns : Returns TRUE - This is a uuencoded line. | FALSE - This is not a uudecoded line. -----------------------------------------------------------------------------*/ static int ChkUUChars(int LnLen, char *Line) { register int i; /* Loop through line, checking that all characters are in proper * range. */ for (i = 0; i < LnLen; i++) if (Line[i] == '~' && FixBitNetTwiddleFlag) Line[i] = '^'; else if (Line[i] < ' ' || Line[i] > '`') return( NOT_UU_LINE ); /* Return that this is an encoded line. */ return( IS_UU_LINE ); } /*----------------------------------------------------------------------------- | Routine : ChkUULine() --- Check to see if this is a UUencoded line. | | Inputs : Line - Pointer to line buffer. | Outputs : RetStrs - Pointer to array of sub strings. | EncLen - Length of unencoded line in bytes. | | Returns : Returns IS_UU_LINE - This is a uuencoded line. | NOT_UU_LINE - This is not a uuencoded line. | UU_SPACE - This is a valid uuencoded empty line. | UU_BEGIN - This is a uuencode begin line. | UU_END - This is a uuencode end line. -----------------------------------------------------------------------------*/ CHK_UU_ENC ChkUULine(char *Line, char ***RetStrs, int *EncLen) { auto int RecLen; auto int BfrLen; /* Check for a character in the range of 0x20 to 0x60 inclusive. */ if ((*Line >= ' ' && *Line <= 'M') || *Line == '`') { /* Get record length. */ RecLen = DEC_CHAR( *Line ); /* Get line length. */ BfrLen = strlen( Line ); /* Calculate the line length based on the record size character. */ if (*Line == 'M') *EncLen = 60; else if (*Line == ' ' || *Line == '`') *EncLen = 0; else { /* This is a short line, so calculate the lenght that it's * record length character says it should have. * * The first calculation assumes that for any number of * bytes between 1 and 3 inclusive, that the UU encoder * always spits out four characters. */ if (RecLen % 3) *EncLen = 4 * (RecLen / 3 + 1); else *EncLen = 4 * (RecLen / 3); /* If the UU encoder spits out less than four characters * for 1 or 2 bytes, then we need a different calculation. */ if (BfrLen != *EncLen + 1 && BfrLen != *EncLen + 2) *EncLen = 4 * (RecLen / 3) + (RecLen % 3 + 1); } /* Check for short or long buffer. */ if (BfrLen != *EncLen + 1 && BfrLen != *EncLen + 2) return( NOT_UU_LINE ); /* Check for the expected UU characters. */ if (ChkUUChars(BfrLen, Line) == NOT_UU_LINE) return( NOT_UU_LINE ); /* Return one of two different flags. */ if (RecLen == 0) return( UU_SPACE ); return( IS_UU_LINE ); } else { /* Test for a begin line. */ if ( MatchBegin(Line, RetStrs) ) return( UU_BEGIN ); /* Test for end line. */ if ( MatchEnd( Line ) ) return( UU_END ); } /* This is not a UUencoded line. */ return( NOT_UU_LINE ); } /*----------------------------------------------------------------------------- | Routine : DecUULine() --- Decode a UU encoded line. | | Inputs : Line - Pointer to line buffer. | Outputs : Len - Number of bytes in the buffer. | Bfr - Points to buffer for decoded output. | | Returns : Returns IS_UU_LINE - This is a uuencoded line. | NOT_UU_LINE - This is not a uuencoded line. | UU_SPACE - This is a valid uuencoded empty line. | UU_BEGIN - This is a uuencode begin line. | UU_END - This is a uuencode end line. -----------------------------------------------------------------------------*/ CHK_UU_ENC DecUULine(char *Line, int *Len, BYTE *Bfr) { auto int EncLen; auto CHK_UU_ENC UULnType; auto char **RetStrs; /* If this is not a uuencoded line, then it cannot be decoded. * Check it first. */ *Len = 0; UULnType = ChkUULine(Line, &RetStrs, &EncLen); if (UULnType != IS_UU_LINE) return( UULnType ); /* Do actual UU decode. */ *Len = UULnDec(EncLen, Line, Bfr); /* Return the type of line this is. */ return( IS_UU_LINE ); } /*----------------------------------------------------------------------------- | Routine : DecTruncUULn() --- Decode a possibly truncated UU encoded | line. | | Inputs : Line - Pointer to line buffer. | Outputs : Len - Number of bytes in the buffer. | Bfr - Points to buffer for decoded output. -----------------------------------------------------------------------------*/ void DecTruncUULn(char *Line, int *Len, BYTE *Bfr) { register int i; auto int RecLen; auto int BfrLen; auto int EncLen; /* Get line length. */ BfrLen = strlen( Line ); /* Calculate the line length. */ RecLen = DEC_CHAR( *Line ); if (RecLen % 3) EncLen = 4 * (RecLen / 3 + 1); else EncLen = 4 * (RecLen / 3); /* If the actual line is shorter than the record length indicates * it ought to be, then pad with spaces. */ if (BfrLen <= EncLen) { /* Loop, putting spaces at end. */ for (i = BfrLen; i <= EncLen; i++) Line[i] = '`'; Line[i] = '\0'; } /* Do actual UU line decode. */ *Len = UULnDec(EncLen, Line, Bfr); } unpost/uudec.h100644 23453 0 1557 5543402242 13251 0ustar jeanpaulsystem/****************************************************************************** * Module : UU Decode header file. * * Author : John W. Stevens ******************************************************************************/ #if ! defined(UU_DECODE_HEADER) #define UU_DECODE_HEADER #include "segment.h" /* Return value for UU line checking. */ typedef enum { UU_TYPE_NOT_SET, NOT_UU_LINE, IS_UU_LINE, UU_SPACE, UU_BEGIN, UU_END } CHK_UU_ENC; /* Function prototypes. */ extern CHK_UU_ENC ChkUULine(char *Line, char ***RetStrs, int *EncLen); extern CHK_UU_ENC DecUULine(char *Line, int *Len, BYTE *Bfr); extern void DecTruncUULn(char *Line, int *Len, BYTE *Bfr); #endif unpost/unpost_Makefile100644 23453 0 2270 5613467535 15052 0ustar jeanpaulsystem#****************************************************************************** # Module : Makefile for UnPost utility. (GCC on Sun 4) # # Author : John W. M. Stevens #****************************************************************************** CC_FLAGS = -ansi -DGCC_COMPILER -funsigned-char -O2 .c.o: gcc -c $(CC_FLAGS) $< all: retest unpost client retest: recomp.o rematch.o retest.o sets.o utils.o gcc $(CC_FLAGS) -o retest retest.o recomp.o rematch.o sets.o utils.o client: recomp.o rematch.o sets.o utils.o client.o gcc $(CC_FLAGS) -o client client.o recomp.o rematch.o sets.o utils.o unpost: config.o decode.o ident.o lex.o list.o \ modflnm.o parse.o recomp.o rematch.o segment.o \ sets.o unpost.o utils.o uudec.o gcc -o unpost config.o decode.o ident.o lex.o list.o \ modflnm.o parse.o recomp.o rematch.o segment.o \ sets.o unpost.o utils.o uudec.o config.o: config.c decode.o: decode.c ident.o: ident.c lex.o: lex.c list.o: list.c modflnm.o: modflnm.c parse.o: parse.c recomp.o: recomp.c rematch.o: rematch.c segment.o: segment.c sets.o: sets.c unpost.o: unpost.c utils.o: utils.c uudec.o: uudec.c