home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume1 / 8708 / 22 < prev    next >
Encoding:
Internet Message Format  |  1990-07-13  |  56.3 KB
  1. From: Stuart.Lynne@van-bc.UUCP (Stuart Lynne)
  2. Newsgroups: comp.sources.misc
  3. Subject: uupc.ami.8.6
  4. Message-ID: <4200@ncoast.UUCP>
  5. Date: 17 Aug 87 01:17:48 GMT
  6. Sender: allbery@ncoast.UUCP
  7. Lines: 2679
  8. Approved: allbery@ncoast.UUCP
  9. X-Archive: comp.sources.misc/8708/22
  10.  
  11. >From uucp Wed Aug 12 02:30 PDT 1987
  12. >From slynne  Wed Aug 12 02:30:19 1987 remote from slmac
  13. Received: by van-bc.uucp (smail2.3)
  14.     id AA17514; 12 Aug 87 02:30:19 PDT (Wed)
  15. Received: by slmac.vnet.van-bc.uucp (pcmail) Wed Aug 12 02:35:17 1987
  16. Date: Wed Aug 12 02:35:17 1987
  17. From: Stuart Lynne - test a mac <slynne@slmac.vnet.van-bc.uucp>
  18. Message-ID: <146@slmac.vnet.van-bc.uucp>
  19. To: sl@van-bc
  20. Subject: shar/uupc.ami.8.6
  21.  
  22. #! /bin/sh
  23. # This is a shell archive, meaning:
  24. # 1. Remove everything above the #! /bin/sh line.
  25. # 2. Save the resulting text in a file.
  26. # 3. Execute the file with /bin/sh (not csh) to create the files:
  27. #    amiga/README.Amiga
  28. #    amiga/Makefile.ami
  29. #    amiga/Makefile
  30. #    amiga/chdir.c
  31. #    amiga/genv.c
  32. #    amiga/genv.dyna
  33. #    amiga/genv.h
  34. #    amiga/getcwd.c
  35. #    amiga/host.c
  36. #    amiga/host.h
  37. #    amiga/mkdir.c
  38. #    amiga/mlib.c
  39. #    amiga/ndir.c
  40. #    amiga/ndir.h
  41. #    amiga/SerialIO.c
  42. #    amiga/sio.c
  43. #    amiga/sleep.c
  44. #    amiga/Timer.c
  45. #    amiga/ulib.c
  46. # This archive created: Wed Aug 12 02:03:37 1987
  47. # By:    Stuart Lynne - test a mac ()
  48. export PATH; PATH=/bin:$PATH
  49. if test -f 'amiga/README.Amiga'
  50. then
  51.        echo shar: will not over-write existing file "'amiga/README.Amiga'"
  52. else
  53. cat << \SHAR_EOF > 'amiga/README.Amiga'
  54. README.Amiga             July 29, 1987        Jeff Lydiatt
  55.  
  56. This directory contains all the support code for the dcp serial
  57. I/O  routines,  the  directory  manipulation  support,  code to
  58. support  a  portable version of the unix getenv() function, and
  59. the  startup  code  for  both  uupc  and  mail.   Here is a brief
  60. description of the files:
  61.  
  62. Directory of PCMail:PCMail/AMIGA
  63.  
  64.   makefile    - compiles support modules for this directory.
  65.   Makefile.ami - makefile for uupc directory
  66.   genv.h    - header file for genv.c
  67.   host.h    - includes for uupc and mail programs.
  68.   ndir.h    - Amiga version of unix directory structures.
  69.   SerialIO.c    - very low level serial I/O device support.
  70.   Timer.c    - provides low level timer device support.
  71.   chdir.c    - chdir( path), makes "path" the current directory. 
  72.   genv.c    - reads the profile, provides getenv() function.
  73.   genv.dyna    - more flexible version of the above, but gurus!
  74.   getcwd.c    - return the path name of the current directory.
  75.   host.c    - prologue and epilogue for both uupc and mail. 
  76.   mkdir.c    - code for mkdir() to make a directory.  
  77.   mlib.c    - not sure: not used by anything I can see.
  78.   ndir.c    - defines opendir(), readdir(), and closedir(). 
  79.   sio.c        - defines SIOInit(), SIOSpeed(), SIOInBuffer(),
  80.           SIOClose(), SIOWrite(), SIORead()
  81.   sleep.c    - implements sleep( seconds ); 
  82.   ulib.c    - implements dcp routines swrite(), sread(), openline(),
  83.           closeline(), rnews(), and shell().
  84.  
  85.  
  86. You  should first compile all the all the files in this directory
  87. using  the  makefile supplied.  Not all files need to be compiled
  88. here.   Some  of  the  object  modules need to be in the primary,
  89. portable-file  directory  and  will  be  included  as needed from
  90. there.
  91.  
  92. BUGS:
  93.  
  94. This  version  has  been  compiled  and tested under Manx Aztec C
  95. v3.40a  with patch 3 installed.  I have been using it extensively
  96. over  the  past couple of weeks with minor problems.  There is an
  97. occasional guru that I can't seem to trace down, so beware.
  98.  
  99. There  seems to be a problem if the functions contained in genv.c
  100. uses  malloc  to  support  environment  variables.   The genv.bac
  101. version  contains  a  slightly  out of date version that would be
  102. much nicer to use if someone can find the problem.
  103.  
  104. If you have any questions, please contact me:
  105.  
  106.    jlydiatt@jlami.van-bc.UUCP   (Jeff Lydiatt)
  107.    {ihnp4!albera!ubc-vision,uunet}!van-bc!jlami!jlydiattSHAR_EOF
  108. cat << \SHAR_EOF > amiga/makefile
  109. MakeThemAll:    getcwd.o chdir.o mkdir.o ndir.o sio.o Timer.o SerialIO.o \
  110.         sleep.o genv.o
  111.  
  112. genv.o:    genv.h
  113.  
  114.  
  115. SHAR_EOF
  116. chmod +x 'amiga/README.Amiga'
  117. fi # end of overwriting check
  118. if test -f 'amiga/Makefile.ami'
  119. then
  120.        echo shar: will not over-write existing file "'amiga/Makefile.ami'"
  121. else
  122. cat << \SHAR_EOF > 'amiga/Makefile.ami'
  123. #        Makefile for uu/dcp with Amiga Aztec C
  124. #
  125. #        Jeff Lydiatt
  126. #        June/87
  127. #        Modeled after Stuart Lynne's for the Mac.
  128. #
  129.  
  130.  
  131. .c.o:
  132.     cc $(CFLAGS) $*.c
  133.  
  134. LFLAGS= -lc
  135. CFLAGS=
  136. AMILIB=    local/getcwd.o local/chdir.o local/mkdir.o local/ndir.o\
  137.     local/genv.o
  138.  
  139. SIOLIB=    local/sio.o local/Timer.o local/SerialIO.o local/sleep.o
  140.  
  141.  
  142. OFILES= dcp.o dcpsys.o dcpxfer.o dcpgpkt.o rmail.o lib.o
  143.  
  144.  
  145. all:     uupc mail
  146.     echo uupc & mail done
  147.  
  148. #
  149. # .o dependicies
  150. #
  151. dcp.o: dcp.c dcp.h local/host.h
  152. dcpsys.o: dcpsys.c dcp.h local/host.h
  153. dcpxfer.o: dcpxfer.c dcp.h local/host.h
  154. dcpgpkt.o: dcpgpkt.c dcp.h local/host.h
  155. lib.o: lib.c local/host.h
  156. lmail.o: pcmail.c lmail.c local/host.h
  157. mailhost.o: local/host.c local/host.h
  158. mail.o: local/host.h
  159. mlib.o: local/mlib.c local/host.h
  160. ulib.o: local/ulib.c local/host.h
  161. uuhost.o: local/host.c local/host.h
  162.  
  163. #
  164. # mail
  165. #
  166. mail: lmail.o mailhost.o mail.o mlib.o lib.o Makefile
  167.     ln mailhost.o mail.o lmail.o mlib.o lib.o $(AMILIB) $(LFLAGS) -o mail
  168.  
  169. #
  170. # uupc
  171. #
  172. uupc:    uuhost.o $(OFILES) ulib.o $(AMILIB) $(SIOLIB) Makefile
  173.     ln uuhost.o $(OFILES) ulib.o $(AMILIB) $(SIOLIB) $(LFLAGS) -o uupc
  174.  
  175. #
  176. # simple shar constructing
  177. #
  178. SDCP     = README.Install README.DCP \
  179.         dcp.c dcp.h dcpgpkt.c dcpsys.c dcpxfer.c
  180. SUU    = README.UU Makefile.ami Makefile.mac \
  181.     host.h ndir.h lib.c lmail.c mail.c mailhost.c mlib.c \
  182.     pcmail.c rmail.c ulib.c uuhost.c systems profile
  183. SMAC    = mac/README.MAC \
  184.     mac/host.c mac/host.h mac/mlib.c mac/ulib.c mac/profile
  185.  
  186. AMI    = amiga/README.Amiga amiga/makefile\
  187.     amiga/genv.h amiga/host.h amiga/ndir.h \
  188.     amiga/SerialIO.c amiga/Timer.c amiga/chdir.c amiga/genv.c \
  189.     amiga/genv.dyna amiga/getcwd.c amiga/host.c amiga/mkdir.c \
  190.     amiga/mlib.c amiga/ndir.c amiga/sio.c amiga/sleep.c amiga/ulib.c
  191.          
  192. #
  193. # Note: Manx's makefile seems to have a bug that forbids indirection
  194. #    such as "shar >lib a.c  b.c c.c"
  195. #    however "make >lib" seems to work fine if you edit out the
  196. #    commands make echos as it proceeds through the makefile.
  197. #
  198. #    Try make >uulib/dcp shardcp for example.
  199. #
  200. shardcp:
  201.     shar  $(SDCP)
  202. sharuu:
  203.     shar $(SUU)
  204. sharami:
  205.     shar $(AMI)
  206.  
  207.  
  208. SHAR_EOF
  209. chmod +x 'amiga/Makefile.ami'
  210. fi # end of overwriting check
  211. if test -f 'amiga/Makefile'
  212. then
  213.        echo shar: will not over-write existing file "'amiga/Makefile'"
  214. else
  215. cat << \SHAR_EOF > 'amiga/Makefile'
  216. MakeThemAll:    getcwd.o chdir.o mkdir.o ndir.o sio.o Timer.o SerialIO.o \
  217.         sleep.o genv.o
  218.  
  219. genv.o:    genv.h
  220.  
  221. SHAR_EOF
  222. fi # end of overwriting check
  223. if test -f 'amiga/chdir.c'
  224. then
  225.        echo shar: will not over-write existing file "'amiga/chdir.c'"
  226. else
  227. cat << \SHAR_EOF > 'amiga/chdir.c'
  228. #include <libraries/dos.h>
  229. #include <exec/memory.h>
  230. #include <functions.h>
  231.  
  232. #ifdef TEST
  233. #include <stdio.h>
  234. #endif
  235.  
  236. #ifndef NULL
  237. #define NULL 0L
  238. #endif
  239.  
  240.  
  241. /*------------------------------------------------------------------*/
  242. /*    chdir(path): make path the current directory. Return Ok/Not */
  243. /*------------------------------------------------------------------*/
  244.  
  245. int chdir( path )
  246. char *path;
  247. {
  248.     register struct Lock *lock;
  249.     struct Lock *oldLock;
  250. #ifdef TEST
  251.     fprintf( stderr, "Changing to directory \"%s\"\n\n", path );
  252. #endif    
  253.  
  254.     lock = Lock( path, ACCESS_READ );
  255.     if ( lock == 0L )
  256.        return (int)IoErr();
  257.     oldLock = CurrentDir( lock );
  258.     if ( oldLock )
  259.        UnLock( oldLock );
  260.     return 0;
  261. }
  262.  
  263.  
  264. #ifdef TEST
  265. main()
  266. {
  267.     char command[108];
  268.     FILE *f;
  269.  
  270.     gets( command );
  271.     fprintf( stderr, "%d\n", chdir( command ));
  272.  
  273.     if (f = fopen("abc", "r"))
  274.       {
  275.        fprintf( stderr, "Opened Ok!\n");
  276.        fclose( f );
  277.       }
  278.     else
  279.        fprintf( stderr, "Can't open abc\n");
  280.  
  281.     exit(NULL);
  282. }
  283.  
  284. #endif
  285.  
  286.  
  287.  
  288. SHAR_EOF
  289. fi # end of overwriting check
  290. if test -f 'amiga/genv.c'
  291. then
  292.        echo shar: will not over-write existing file "'amiga/genv.c'"
  293. else
  294. cat << \SHAR_EOF > 'amiga/genv.c'
  295. /*         genv.c
  296.  
  297.  
  298.  
  299.         copyright (C) 1987 Jeff Lydiatt
  300.  
  301.         Copying and use of this program are controlled by the terms of the
  302.         Free Software Foundations GNU Emacs General Public License.
  303.  
  304.  
  305.         version        0.1        09 July 87
  306.  
  307.  
  308.  
  309. */
  310.  
  311. #include <stdio.h>
  312.  
  313. #include "genv.h"
  314.  
  315.      /* Environment variables are in file "PROFILE" */
  316. #define PROFILE ":usr/lib/uucp/profile"
  317.  
  318. #define SAME    0
  319. #define MAXLINE 255
  320.  
  321. #define DMAILBOX    "mailbox"
  322. #define    DNAME        "noname"
  323. #define    DDOMAIN        "pc.uucp"
  324. #define    DMAILDIR    ":usr/spool/mail"
  325. #define DHOME        ":usr/noname"
  326. #define    DCONFDIR    ":usr/lib/uucp"
  327. #define    DSPOOLDIR    ":usr/spool/uucp"
  328. #define DLOGDIR        ":usr/spool/uucp"
  329. #define DPUBDIR        ":usr/spool/uucppublic"
  330. #define DNEWSDIR    ":usr/spool/rnews"
  331. #define DTEMPDIR    "RAM:T"
  332. #define    DMAILSERVICE    "host"
  333. #define    DNODENAME    "noname"
  334. #define    DDEVICE        "CON:"
  335. #define    DSPEED        "1200"
  336.  
  337. #define    TFILENAME    "tmpfile"
  338. #define    FILENAME     "%s/%s"
  339.  
  340. #include <stdio.h>
  341. #include <ctype.h>
  342.  
  343. struct environment
  344.   {
  345.      char name[16];
  346.      char value[64];
  347.  
  348.   };
  349. typedef struct environment ENV;
  350.  
  351. static ENV profile[]=
  352.   {
  353.     MAILBOX,     "",
  354.     NAME,        "",
  355.     DOMAIN,        "",
  356.     MAILDIR,    "",
  357.     HOME,        "",
  358.     CONFDIR,    "",
  359.     SPOOLDIR,    "",
  360.     LOGDIR,        "",
  361.     PUBDIR,        "",
  362.     NEWSDIR2,    "",
  363.     TEMPDIR,    "",
  364.     MAILSERVICE,    "",
  365.     NODENAME,    "",
  366.     DEVICE,        "",
  367.     SPEED,        "",
  368.     "",        "",
  369.   };    
  370. char    *name = NULL;
  371. char    *mailbox = NULL;
  372. char    *home = NULL;
  373. char    *domain = NULL;
  374. char    *maildir = NULL;
  375. char    *confdir = NULL;
  376. char     *spooldir = NULL;
  377. char    *logdir = NULL;
  378. char    *pubdir = NULL;
  379. char    *mailserv = NULL;
  380. char    *nodename = NULL;
  381. char    *device = NULL;
  382. char    *speed = NULL;
  383. char    *tempdir = NULL;
  384. char    *newsdir = NULL;
  385.  
  386. /*--------------------------------------------------------------*/
  387. /*    getone: get next character file f.  f already open    */
  388. /*--------------------------------------------------------------*/
  389.  
  390. static int getone( f )
  391. FILE *f;
  392. {
  393.    char c, line[256];
  394.    static int pos = 0;
  395.    static int len = 0;
  396.  
  397.    if ( ++pos > len || line[pos] == '\0' ) 
  398.      {
  399.     if ( fgets( line, 255, f ) == NULL )
  400.        return EOF;
  401.     pos = 0;
  402.     len = strlen( line );
  403.      }
  404.  
  405.    c = line[pos];
  406.    return c;
  407.    
  408. }
  409.  
  410. /*--------------------------------------------------------------*/
  411. /*    getsym: get next symbol from file f.  f already open    */
  412. /*--------------------------------------------------------------*/
  413.  
  414. #define ID    1001
  415. #define DELIM    1002
  416. #define STR    1003
  417. #define EOL    1004
  418. #define OTHER    1005
  419. #define UNKNOWN -1000
  420.  
  421. static int getsym( f, sym )
  422. FILE *f;
  423. char *sym;
  424. {
  425.    /* Simple non reentrant, non reuseable get next symbol from file f */
  426.    /* Valid symbols are:
  427.         Type    Symbol Returned    Comment
  428.  
  429.     ID    <identifier>    any valid c identifier.
  430.         DELIM    '='        an equal sign.
  431.     STR    a string    anything between "" or ''.
  432.     EOL    '\n'        a newline.
  433.     EOF            the end of file character.
  434.     OTHER   a character    anything else.
  435.     
  436.     Comments begin with # and are delimited by an end of line
  437.    */
  438.  
  439.    static int lastchar = UNKNOWN; /* Unknown */
  440.    int c, delim;
  441.  
  442.    /* strip leading white space */
  443.  
  444.    if ( lastchar != UNKNOWN )
  445.       c = lastchar;
  446.    else
  447.       c = getone( f );
  448.  
  449.    while ( c == ' ' || c == '\t' )
  450.       c = getone( f );
  451.    lastchar = UNKNOWN;
  452.  
  453.   /* Comments are '#' delimited by EOL character */
  454.  
  455.    if ( c == '#' )
  456.       while ( c != '\n' && c != EOF )
  457.      c = getone( f );
  458.  
  459.    if ( c == EOF )        /* End of file? */
  460.       return EOF;
  461.  
  462.    if ( c == '\n' )        /* End of Line? */
  463.      {
  464.     strcpy( sym, "\n" );
  465.     return EOL;
  466.      }
  467.  
  468.    if ( c == '=' )        /* Delimiter '='? */
  469.      {
  470.     strcpy( sym, "=" );
  471.     return DELIM;
  472.      } 
  473.  
  474.    if ( c == '\"' || c == '\'' )/* String ? */
  475.      {
  476.     delim = c;
  477.     while ( (c = getone( f )) != delim && c != EOF && c != '\n' )
  478.        *sym++ = c;
  479.     *sym = '\0';
  480.     c = getone( f );
  481.     return STR;
  482.      }
  483.  
  484.    if ( isalpha( c ) )        /* Identifier ? */
  485.      {
  486.     *sym++ = c;
  487.     while ( ( c = getone( f )) == '_' || isalnum(c) )
  488.       *sym++ = c;
  489.     *sym = '\0';
  490.     lastchar = c;
  491.     return ID;
  492.      }
  493.  
  494.    *sym++ = c;
  495.    *sym = '\0';
  496.    return OTHER;
  497.  
  498. }
  499.     
  500.  
  501. /*--------------------------------------------------------------*/
  502. /*    setenv: insert an environment variable into my list    */
  503. /*--------------------------------------------------------------*/
  504.  
  505. static void setenv( var, value )
  506. char *var;
  507. char *value;
  508. {
  509.     register ENV *p;
  510.  
  511.     for ( p = &profile[0];
  512.           *(p->name) != '\0';
  513.           ++p ) 
  514.       {
  515.          if ( strcmp( p->name, var ) == SAME )
  516.         {
  517.  
  518.              strcpy( p->name, var );
  519.            strcpy( p->value, value);
  520.            break;
  521.         }
  522.        }
  523. }
  524.  
  525. /*--------------------------------------------------------------*/
  526. /*    getenv: get pointer to value of environment variable    */
  527. /*--------------------------------------------------------------*/
  528.  
  529. static char *getenv( var )
  530. char *var;
  531. {
  532.     register ENV *p;
  533.  
  534.     for ( p = &profile[0];
  535.           *(p->name) != '\0';
  536.           ++p )
  537.       {
  538.          if ( strcmp( p->name, var ) == SAME )
  539.             if ( *p->value != '\0' )
  540.            return p->value;
  541.         else
  542.            break;
  543.       }
  544.     return NULL;
  545. }
  546.  
  547. /*--------------------------------------------------------------*/
  548. /*    readenv: read environment from a file.             */
  549. /*--------------------------------------------------------------*/
  550.  
  551. static void readenv()
  552. {
  553.    FILE *f;
  554.    int symval;
  555.    char name[MAXLINE+1], value[MAXLINE+1];
  556.  
  557.    fprintf( stderr, "Opening profile\n");
  558.    if ( (f = fopen( PROFILE, "r" )) == NULL )
  559.      {
  560.     fprintf( stderr, "Can't open profile file \"%s\"\n",
  561.     PROFILE );
  562.     exit( NULL );
  563.      }
  564.  
  565.     /* File is layed out as follows:
  566.  
  567.     <environment variable> '=' <ID> | <STRING> # comment....
  568.  
  569.      */
  570.  
  571.     while ( (symval = getsym( f, name )) != EOF )
  572.       {
  573.     /* Skip over any comment lines */
  574.  
  575.     while ( symval == EOL )
  576.        symval = getsym( f, name );
  577.     if ( symval == EOF )
  578.        break;
  579.  
  580.     if ( symval != ID )
  581.       {
  582.          fprintf( stderr, "Bad environment variable name %s\n", name );
  583.          exit( NULL );
  584.       }
  585.  
  586.     if ( (symval = getsym( f, value )) != DELIM )
  587.       {
  588.          fprintf( stderr, "Missing '=' in environment file\n" );
  589.          exit( NULL );
  590.       }
  591.  
  592.     if ( (symval = getsym( f, value )) != ID && symval != STR )
  593.       {
  594.          fprintf( stderr, "missing value in environment file\n");
  595.          exit( NULL );
  596.       }
  597.  
  598.     setenv( name, value );
  599.       }
  600.     fclose( f );
  601.  
  602. }
  603.  
  604. /*--------------------------------------------------------------*/
  605. /*    exitenv: free that memory when done!            */
  606. /*--------------------------------------------------------------*/
  607.  
  608. void exitenv()
  609. {
  610. }
  611.  
  612. static void genv(thename, envname, dflt)
  613. char **thename;
  614. char *envname;
  615. char *dflt;
  616. {
  617.     if ((*thename = getenv( envname )) == NULL) {
  618.         fprintf( stderr, "genv: %s not found, using %s\n", envname, dflt );
  619.         *thename = dflt;
  620.     }
  621.     /* fprintf( stderr, "genv: %s \"%s\"\n", envname, *thename ); /**/
  622. }
  623.  
  624. void loadenv()
  625. {
  626.  
  627.     readenv();    /* read the profile from a file */ 
  628.  
  629.     /* get environment var's */
  630.     genv( &name, NAME, DNAME );
  631.     genv( &mailbox, MAILBOX, DMAILBOX );
  632.     genv( &home, HOME, DHOME );
  633.     genv( &domain, DOMAIN, DDOMAIN );
  634.     genv( &maildir, MAILDIR, DMAILDIR );
  635.     genv( &confdir, CONFDIR, DCONFDIR );
  636.     genv( &spooldir, SPOOLDIR, DSPOOLDIR );
  637.     genv( &logdir, LOGDIR, DLOGDIR );
  638.     genv( &pubdir, PUBDIR, DPUBDIR );
  639.     genv( &mailserv, MAILSERVICE, DMAILSERVICE );
  640.     genv( &nodename, NODENAME, DNODENAME );
  641.     genv( &device, DEVICE, DDEVICE );
  642.     genv( &speed, SPEED, DSPEED );
  643.     genv( &tempdir, TEMPDIR, DTEMPDIR );
  644.     genv( &newsdir, NEWSDIR2, DNEWSDIR );
  645. }
  646.  
  647. void mkfilename( filename, dirname, name )
  648. char * filename;
  649. char * dirname;
  650. char * name;
  651. {
  652.     sprintf( filename, FILENAME, dirname, name );    
  653.     fprintf( stderr, "New filename %s\n", filename );  /**/    
  654. }
  655.  
  656.  
  657. #ifdef TEST
  658. main()
  659. {
  660.     register ENV *p;
  661.  
  662.     loadenv();
  663.  
  664.     for ( p = &profile[0];
  665.           *(p->name) != '\0';
  666.           ++p)
  667.  
  668.         fprintf( stderr, "name=\"%s\", value=\"%s\"\n",
  669.              p->name, p->value);
  670. } 
  671.  
  672. #endif
  673.  
  674.  
  675.  
  676. SHAR_EOF
  677. fi # end of overwriting check
  678. if test -f 'amiga/genv.dyna'
  679. then
  680.        echo shar: will not over-write existing file "'amiga/genv.dyna'"
  681. else
  682. cat << \SHAR_EOF > 'amiga/genv.dyna'
  683. /*         genv.c
  684.  
  685.  
  686.  
  687.         copyright (C) 1987 Jeff Lydiatt
  688.  
  689.         Copying and use of this program are controlled by the terms of the
  690.         Free Software Foundations GNU Emacs General Public License.
  691.  
  692.  
  693.         version        0.1        10 July 87
  694.  
  695.  
  696.  
  697. */
  698.  
  699. #include <stdio.h>
  700.  
  701. #include "genv.h"
  702.  
  703.      /* Environment variables are in file "PROFILE" */
  704. #define PROFILE ":usr/lib/uucp/profile"
  705.  
  706. #define SAME    0
  707. #define MAXLINE 255
  708.  
  709. #define DMAILBOX    "mailbox"
  710. #define    DNAME        "noname"
  711. #define    DDOMAIN        "pc.uucp"
  712. #define    DMAILDIR    ":usr/spool/mail"
  713. #define DHOME        ":usr/noname"
  714. #define    DCONFDIR    ":usr/lib/uucp"
  715. #define    DSPOOLDIR    ":usr/spool/uucp"
  716. #define DLOGDIR        ":usr/spool/uucp"
  717. #define DPUBDIR        ":usr/spool/uucppublic"
  718. #define DNEWSSDIR    ":usr/spool/rnews"
  719. #define DTEMPDIR    "RAM:T"
  720. #define    DMAILSERVICE    "host"
  721. #define    DNODENAME    "noname"
  722. #define    DDEVICE        "CON:"
  723. #define    DSPEED        "1200"
  724.  
  725. #define    TFILENAME    "tmpfile"
  726. #define    FILENAME     "%s/%s"
  727.  
  728. #include <stdio.h>
  729. #include <ctype.h>
  730.  
  731. char    *name = NULL;
  732. char    *mailbox = NULL;
  733. char    *home = NULL;
  734. char    *domain = NULL;
  735. char    *maildir = NULL;
  736. char    *confdir = NULL;
  737. char     *spooldir = NULL;
  738. char    *logdir = NULL;
  739. char    *pubdir = NULL;
  740. char    *mailserv = NULL;
  741. char    *nodename = NULL;
  742. char    *device = NULL;
  743. char    *speed = NULL;
  744. char    *tempdir = NULL;
  745.  
  746. /*--------------------------------------------------------------*/
  747. /*    getone: get next character file f.  f already open    */
  748. /*--------------------------------------------------------------*/
  749.  
  750. static int getone( f )
  751. FILE *f;
  752. {
  753.    char c, line[256];
  754.    static int pos = 0;
  755.    static int len = 0;
  756.  
  757.    if ( ++pos > len || line[pos] == '\0' ) 
  758.      {
  759.     if ( fgets( line, 255, f ) == NULL )
  760.        return EOF;
  761.     pos = 0;
  762.     len = strlen( line );
  763.      }
  764.  
  765.    c = line[pos];
  766.    return c;
  767.    
  768. }
  769.  
  770. /*--------------------------------------------------------------*/
  771. /*    getsym: get next symbol from file f.  f already open    */
  772. /*--------------------------------------------------------------*/
  773.  
  774. #define ID    1001
  775. #define DELIM    1002
  776. #define STR    1003
  777. #define EOL    1004
  778. #define OTHER    1005
  779. #define UNKNOWN -1000
  780.  
  781. static int getsym( f, sym )
  782. FILE *f;
  783. char *sym;
  784. {
  785.    /* Simple non reentrant, non reuseable get next symbol from file f */
  786.    /* Valid symbols are:
  787.         Type    Symbol Returned    Comment
  788.  
  789.     ID    <identifier>    any valid c identifier.
  790.         DELIM    '='        an equal sign.
  791.     STR    a string    anything between "" or ''.
  792.     EOL    '\n'        a newline.
  793.     EOF            the end of file character.
  794.     OTHER   a character    anything else.
  795.     
  796.     Comments begin with # and are delimited by an end of line
  797.    */
  798.  
  799.    static int lastchar = UNKNOWN;
  800.    int c, delim;
  801.  
  802.    /* strip leading white space */
  803.  
  804.    if ( lastchar != UNKNOWN )
  805.       c = lastchar;
  806.    else
  807.       c = getone( f );
  808.  
  809.    while ( c == ' ' || c == '\t' )
  810.       c = getone( f );
  811.    lastchar = UNKNOWN;
  812.  
  813.   /* Comments are '#' delimited by EOL character */
  814.  
  815.    if ( c == '#' )
  816.       while ( c != '\n' && c != EOF )
  817.      c = getone( f );
  818.  
  819.    if ( c == EOF )        /* End of file? */
  820.       return EOF;
  821.  
  822.    if ( c == '\n' )        /* End of Line? */
  823.      {
  824.     strcpy( sym, "\n" );
  825.     return EOL;
  826.      }
  827.  
  828.    if ( c == '=' )        /* Delimiter '='? */
  829.      {
  830.     strcpy( sym, "=" );
  831.     return DELIM;
  832.      } 
  833.  
  834.    if ( c == '\"' || c == '\'' )/* String ? */
  835.      {
  836.     delim = c;
  837.     while ( (c = getone( f )) != delim && c != EOF && c != '\n' )
  838.        *sym++ = c;
  839.     *sym = '\0';
  840.     c = getone( f );
  841.     return STR;
  842.      }
  843.  
  844.    if ( isalpha( c ) )        /* Identifier ? */
  845.      {
  846.     *sym++ = c;
  847.     while ( ( c = getone( f )) == '_' || isalnum(c) )
  848.       *sym++ = c;
  849.     *sym = '\0';
  850.     lastchar = c;
  851.     return ID;
  852.      }
  853.  
  854.    *sym++ = c;
  855.    *sym = '\0';
  856.    return OTHER;
  857.  
  858. }
  859.     
  860. /*--------------------------------------------------------------*/
  861. /*    xmalloc: Just alloc with die on allocation failure    */
  862. /*--------------------------------------------------------------*/
  863. static char *xmalloc( size )
  864. unsigned int size;
  865. {
  866.     char *malloc();
  867.     register char *p;
  868.  
  869.  
  870.     if ( (p = malloc( size )) != NULL )
  871.        return p;
  872.  
  873.     fprintf( stderr, "Genv.c: Can't allocated %u bytes\n", size );
  874.     exit( NULL );
  875. }
  876.  
  877. /*--------------------------------------------------------------*/
  878. /*    setenv: insert an environment variable into my list    */
  879. /*--------------------------------------------------------------*/
  880.  
  881. struct environment
  882.    {
  883.     struct environment *next;
  884.     char *name;
  885.     char *value;
  886.    };
  887.  
  888. typedef struct environment ENV;
  889.  
  890. static ENV *envList = NULL;
  891.  
  892. static void setenv( var, value )
  893. char *var;
  894. char *value;
  895. {
  896.     register ENV *envframe;
  897.  
  898.     envframe = (ENV *) xmalloc( sizeof( ENV ));
  899.     envframe->name  = xmalloc( strlen(var)+1 );
  900.     envframe->value = xmalloc( strlen(value)+1 );
  901.     envframe->next  = envList;
  902.     envList        = envframe;
  903.     
  904.     strcpy( envframe->name, var );
  905.     strcpy( envframe->value, value);
  906. }
  907.  
  908. /*--------------------------------------------------------------*/
  909. /*    getenv: get pointer to value of environment variable    */
  910. /*--------------------------------------------------------------*/
  911.  
  912. static char *getenv( var )
  913. char *var;
  914. {
  915.     register ENV *list;
  916.  
  917.     for ( list = envList;
  918.           list != (ENV *)NULL;
  919.           list = list->next )
  920.        if ( strcmp( var, list->name ) == SAME )
  921.         return list->value;
  922.  
  923.     return NULL;
  924. }
  925.  
  926. /*--------------------------------------------------------------*/
  927. /*    readenv: read environment from a file.             */
  928. /*--------------------------------------------------------------*/
  929.  
  930. static void readenv()
  931. {
  932.    FILE *f;
  933.    int symval;
  934.    char name[MAXLINE+1], value[MAXLINE+1];
  935.  
  936.    if ( (f = fopen( PROFILE, "r" )) == NULL )
  937.      {
  938.     fprintf( stderr, "Can't open profile file \"%s\"\n",
  939.     PROFILE );
  940.     exit( NULL );
  941.      }
  942.  
  943.     /* File is layed out as follows:
  944.  
  945.     <environment variable> '=' <ID> | <STRING> # comment....
  946.  
  947.      */
  948.  
  949.     while ( (symval = getsym( f, name )) != EOF )
  950.       {
  951.     /* Skip over any comment lines */
  952.  
  953.     while ( symval == EOL )
  954.        symval = getsym( f, name );
  955.     if ( symval == EOF )
  956.        break;
  957.  
  958.     if ( symval != ID )
  959.       {
  960.          fprintf( stderr, "Bad environment variable name %s\n", name );
  961.          exit( NULL );
  962.       }
  963.  
  964.     if ( (symval = getsym( f, value )) != DELIM )
  965.       {
  966.          fprintf( stderr, "Missing '=' in environment file\n" );
  967.          exit( NULL );
  968.       }
  969.  
  970.     if ( (symval = getsym( f, value )) != ID && symval != STR )
  971.       {
  972.          fprintf( stderr, "missing value in environment file\n");
  973.          exit( NULL );
  974.       }
  975.  
  976.     setenv( name, value );
  977.       }
  978.     fclose( f );
  979.  
  980. }
  981.  
  982. /*--------------------------------------------------------------*/
  983. /*    exitenv: free that memory when done!            */
  984. /*--------------------------------------------------------------*/
  985.  
  986. void exitenv()
  987. {
  988.     register ENV *p, *q;    
  989.  
  990.     for ( p = envList; p != NULL; p = q )
  991.       {
  992.         free( p->name );
  993.         free( p->value);
  994.         q = p->next;
  995.         free( p );
  996.       }
  997.     envList = NULL;
  998. }
  999.  
  1000. static void genv(thename, envname, dflt)
  1001. char **thename;
  1002. char *envname;
  1003. char *dflt;
  1004. {
  1005.     if ((*thename = getenv( envname )) == NULL) {
  1006.         fprintf( stderr, "genv: %s not found, using %s\n", envname, dflt );
  1007.         *thename = dflt;
  1008.     }
  1009.     /* fprintf( stderr, "genv: %s \"%s\"\n", envname, *thename ); /**/
  1010. }
  1011.  
  1012. void loadenv()
  1013. {
  1014.  
  1015.     readenv();    /* read the profile from a file */ 
  1016.  
  1017.     /* get environment var's */
  1018.     genv( &name, NAME, DNAME );
  1019.     genv( &mailbox, MAILBOX, DMAILBOX );
  1020.     genv( &home, HOME, DHOME );
  1021.     genv( &domain, DOMAIN, DDOMAIN );
  1022.     genv( &maildir, MAILDIR, DMAILDIR );
  1023.     genv( &confdir, CONFDIR, DCONFDIR );
  1024.     genv( &spooldir, SPOOLDIR, DSPOOLDIR );
  1025.     genv( &logdir, LOGDIR, DLOGDIR );
  1026.     genv( &pubdir, PUBDIR, DPUBDIR );
  1027.     genv( &mailserv, MAILSERVICE, DMAILSERVICE );
  1028.     genv( &nodename, NODENAME, DNODENAME );
  1029.     genv( &device, DEVICE, DDEVICE );
  1030.     genv( &speed, SPEED, DSPEED );
  1031.     genv( &tempdir, TEMPDIR, DTEMPDIR );
  1032. }
  1033.  
  1034. void mkfilename( filename, dirname, name )
  1035. char * filename;
  1036. char * dirname;
  1037. char * name;
  1038. {
  1039.     sprintf( filename, FILENAME, dirname, name );    
  1040.     fprintf( stderr, "New filename %s\n", filename );  /**/    
  1041. }
  1042.  
  1043.  
  1044. #ifdef TEST
  1045. main()
  1046. {
  1047.     register ENV *p;    
  1048.  
  1049.     loadenv();
  1050.  
  1051.     for ( p = envList; p != NULL; p = p->next )
  1052.       fprintf( stderr, "Name=\"%s\" value=\"%s\"\n", 
  1053.            p->name, p->value );
  1054.     
  1055. }
  1056. #endif
  1057.  
  1058.  
  1059.  
  1060. SHAR_EOF
  1061. fi # end of overwriting check
  1062. if test -f 'amiga/genv.h'
  1063. then
  1064.        echo shar: will not over-write existing file "'amiga/genv.h'"
  1065. else
  1066. cat << \SHAR_EOF > 'amiga/genv.h'
  1067. /*    genv.c
  1068.  
  1069.  
  1070.  
  1071.     copyright (C) 1987 Stuart Lynne
  1072.  
  1073.     Copying and use of this program are controlled by the terms of the
  1074.     Free Software Foundations GNU Emacs General Public License.
  1075.  
  1076.  
  1077.     version        0.1        March 31/1987
  1078.  
  1079.     
  1080.  
  1081. environment variables
  1082.  
  1083.     The following evironment variables are defined:
  1084.  
  1085.     MAILBOX        current user's mailbox,     "sl"
  1086.     NAME        current user's name,         "Stuart Lynne"
  1087.     DOMAIN        domain of this machine,     "mac.van-bc.can"
  1088.     MAILDIR        where mail is kept,        "/usr/mail"
  1089.     CONFDIR        where config data is  kept,    "/usr/lib/uucp"
  1090.     SPOOLDIR    where spooled files are     "/usr/spool/uucp"
  1091.     LOGDIR        where log file are placed    "/usr/spool/uucp"
  1092.     PUBDIR        public spool directory        "/usr/spool/uucppublic"
  1093.     NEWSDIR        news directory            "/usr/spool/news"
  1094.     TEMPDIR        where temp files are created    "/tmp"
  1095.     HOME        where uses private files are    "/usr/sl"
  1096.     MAILSERVICE    who do we send remote mail    "van-bc"
  1097.     NODENAME    what is our local nodename    "slmac"
  1098.     DEVICE        what is the default device    ".a"
  1099.     SPEED        what is the default speed    "1200"
  1100.  
  1101. */
  1102.  
  1103.  
  1104. #define    MAILBOX        "MAILBOX"
  1105. #define    NAME        "NAME"
  1106. #define    DOMAIN        "DOMAIN"
  1107. #define    MAILDIR        "MAILDIR"
  1108. #define HOME        "HOME"
  1109.  
  1110. #define    CONFDIR        "CONFDIR"
  1111. #define SPOOLDIR    "SPOOLDIR"
  1112. #define LOGDIR        "LOGDIR"
  1113. #define    PUBDIR        "PUBDIR"
  1114. #define NEWSDIR2    "NEWSDIR"
  1115. #define TEMPDIR        "TEMPDIR"
  1116. #define    MAILSERVICE    "MAILSERVICE"
  1117.  
  1118. #define NODENAME    "NODENAME"
  1119. #define    DEVICE        "DEVICE"
  1120. #define    SPEED        "SPEED"
  1121.  
  1122. extern char    *mailbox;
  1123. extern char    *name;
  1124. extern char    *domain;
  1125. extern char    *maildir;
  1126. extern char    *home;
  1127.  
  1128. extern char    *confdir;
  1129. extern char    *spooldir;
  1130. extern char    *logdir;
  1131. extern char    *pubdir;
  1132. extern char    *tempdir;
  1133. extern char    *mailserv;
  1134.  
  1135. extern char    *nodename;
  1136. extern char    *device;
  1137. extern char    *speed;
  1138. extern char    *newsdir;
  1139.  
  1140. void loadenv();
  1141. void mkfilename();
  1142.  
  1143.  
  1144.  
  1145. SHAR_EOF
  1146. fi # end of overwriting check
  1147. if test -f 'amiga/getcwd.c'
  1148. then
  1149.        echo shar: will not over-write existing file "'amiga/getcwd.c'"
  1150. else
  1151. cat << \SHAR_EOF > 'amiga/getcwd.c'
  1152.  
  1153. #include <libraries/dos.h>
  1154. #include <exec/memory.h>
  1155. #include <functions.h>
  1156.  
  1157. #ifdef TEST
  1158. #include <stdio.h>
  1159. #endif
  1160.  
  1161. #ifndef NULL
  1162. #define NULL 0L
  1163. #endif
  1164.  
  1165. char * malloc();
  1166.  
  1167. /*--------------------------------------------------------------*/
  1168. /*    GetCurrentPath: get full path of the current directory    */
  1169. /*--------------------------------------------------------------*/
  1170.  
  1171. static void GetCurrentPath( path )
  1172. register char *path;
  1173. {
  1174.  
  1175.     char s1[ 108 ];
  1176.     char *name;
  1177.     register struct Lock *locka, *lockb;
  1178.         register struct FileInfoBlock *fib;
  1179.  
  1180.     fib = (struct FileInfoBlock *)AllocMem(
  1181.           (long)sizeof(struct FileInfoBlock), MEMF_CHIP | MEMF_CLEAR);
  1182.     if ( fib == 0L )
  1183.        {
  1184. #ifdef TEST
  1185.          fprintf( stderr, "GetCurrentPath: Oops - Memory allocation failed\n");
  1186. #endif
  1187.          *path = '\0';
  1188.          return;
  1189.        }
  1190.     
  1191.     locka = Lock("", ACCESS_READ );
  1192.     *path = s1[0] = '\0';
  1193.  
  1194.     while ( locka != NULL )
  1195.       {
  1196.         Examine( locka, fib );
  1197.         name = fib->fib_FileName;
  1198.         if ( *name == '\0' )
  1199.         strcpy( path, "RAM" ); /* Patch for Ram disk bug */
  1200.         else
  1201.         strcpy( path, name );
  1202.         lockb = ParentDir( locka );
  1203.         UnLock( locka );
  1204.         
  1205.         if ( lockb == NULL )
  1206.             strcat( path, ":");
  1207.         else if ( s1[0] != '\0' )
  1208.         strcat( path, "/");
  1209.         strcat( path, s1 );
  1210.         strcpy( s1, path );
  1211.         locka = lockb;
  1212.       }
  1213.  
  1214.     FreeMem( fib, (long)sizeof(struct FileInfoBlock) );
  1215. }
  1216.  
  1217. /*--------------------------------------------------------------*/
  1218. /*    getcwd: return the path name of the current directory    */
  1219. /*--------------------------------------------------------------*/
  1220.  
  1221. char *getcwd( path, size )
  1222. char *path;
  1223. int size;
  1224. {
  1225.     if ( path == (char *)NULL )
  1226.        {
  1227.          if ( (path = malloc(108)) == NULL)
  1228.         {
  1229. #ifdef TEST
  1230.            fprintf( stderr, "getcwd: malloc failed to get 108 bytes\n");
  1231. #endif
  1232.            return NULL;
  1233.         }
  1234.        }
  1235.     GetCurrentPath( path );
  1236.     return path;
  1237. }
  1238.  
  1239. #ifdef TEST
  1240. main()
  1241. {
  1242.  
  1243.     fprintf( stderr, "%s\n", getcwd( NULL, 0 ));
  1244. }
  1245.  
  1246. #endif
  1247.  
  1248.  
  1249.  
  1250. SHAR_EOF
  1251. fi # end of overwriting check
  1252. if test -f 'amiga/host.c'
  1253. then
  1254.        echo shar: will not over-write existing file "'amiga/host.c'"
  1255. else
  1256. cat << \SHAR_EOF > 'amiga/host.c'
  1257. /*        host.c
  1258.  
  1259.         Amiga host 
  1260.  
  1261. */
  1262.  
  1263. #include <stdio.h>
  1264. #include "host.h"
  1265.  
  1266. #include <ctype.h>
  1267. #include <setjmp.h>
  1268. #include <errno.h>
  1269.  
  1270. static char *curdir;
  1271. char * getcwd();
  1272. int chdir();
  1273. int    debuglevel;        /* debuglevelging level */
  1274.  
  1275. jmp_buf    dcpexit;
  1276.  
  1277. main( argc, argv )
  1278. int    argc;
  1279. char *argv[];
  1280. {
  1281.  
  1282.     /* Amiga specific prolog */
  1283.  
  1284.     loadenv();
  1285.     curdir = getcwd( NULL, 0 );
  1286.  
  1287. #ifdef CWDSPOOL
  1288.     chdir( spooldir );
  1289. #endif
  1290.  
  1291.     /* setup longjmp for error exit's */
  1292.     if ( setjmp( dcpexit ) == 0 ) {
  1293.  
  1294.         MAIN( argc, argv );
  1295.  
  1296.     }
  1297.  
  1298.     /* Amiga specific epilog */
  1299.  
  1300.     exitenv();
  1301.     chdir( curdir );
  1302.     exit( NULL );
  1303.  
  1304. }
  1305.  
  1306.  
  1307. /* canonical name conversio routines
  1308.  
  1309.     inportpath    canonical -> host
  1310.     exportpath    host -> canonical
  1311.  
  1312.     host        your local pathname format
  1313.     canonical    unix style
  1314. */
  1315.  
  1316. importpath( host, canon )
  1317. char * host;
  1318. char * canon;
  1319. {
  1320.         register char *s;
  1321.  
  1322.     strcpy( host, canon );
  1323.  
  1324.         if ( *host == '/' )
  1325.       *host = ':';
  1326. }
  1327.  
  1328. exportpath( canon, host )
  1329. char * host;
  1330. char * canon;
  1331. {
  1332.     strcpy( canon, host );
  1333.     if ( *canon == ':' )
  1334.        *canon = '/';
  1335. }
  1336.  
  1337.  
  1338.  
  1339.  
  1340.  
  1341. SHAR_EOF
  1342. fi # end of overwriting check
  1343. if test -f 'amiga/host.h'
  1344. then
  1345.        echo shar: will not over-write existing file "'amiga/host.h'"
  1346. else
  1347. cat << \SHAR_EOF > 'amiga/host.h'
  1348.  /*        Amiga.h
  1349.  
  1350.         Amiga version
  1351.  
  1352. */
  1353.  
  1354. #include <time.h>
  1355. #include <errno.h>
  1356. #include <ctype.h>
  1357.  
  1358. #define AMIGA   1
  1359. #define SAME     0
  1360. #define    FALSE    0
  1361. #define    TRUE    1
  1362.  
  1363. #define    TFILENAME    "tmpfile.%.7d"
  1364. #define    SFILENAME    "SEQF"
  1365.  
  1366. #define SEPCHAR        '/'    /* path separater character        */
  1367. #define SIGFILE        ".signature"    /* file containing signature    */
  1368. #define COPYFILE    "mail.sent"    /* copy of sent mail    */
  1369.  
  1370. #define HOSTINIT        /* name of function used to initialize    */
  1371.  
  1372. #define FILEMODE(f)
  1373.  
  1374. #define    CALLFILE    "C.%s"
  1375. #define    XQTFILE        "X.%s"
  1376.  
  1377. #include "local/genv.h"
  1378.  
  1379. extern    char * fgets();
  1380. extern    char * index();
  1381.  
  1382. extern     int    debuglevel;                  /* debuglevelging level */
  1383.  
  1384.  
  1385.  
  1386.  
  1387. SHAR_EOF
  1388. fi # end of overwriting check
  1389. if test -f 'amiga/mkdir.c'
  1390. then
  1391.        echo shar: will not over-write existing file "'amiga/mkdir.c'"
  1392. else
  1393. cat << \SHAR_EOF > 'amiga/mkdir.c'
  1394. #include <libraries/dos.h>
  1395. #include <exec/memory.h>
  1396. #include <functions.h>
  1397.  
  1398. #ifdef TEST
  1399. #include <stdio.h>
  1400. #endif
  1401.  
  1402. #ifndef NULL
  1403. #define NULL 0L
  1404. #endif
  1405.  
  1406.  
  1407. /*--------------------------------------------------------------*/
  1408. /*    mkdir(name): make a directory with the given name.    */
  1409. /*--------------------------------------------------------------*/
  1410.  
  1411. int mkdir( name )
  1412. char *name;
  1413. {
  1414.     register struct Lock *lock;
  1415.  
  1416. #ifdef TEST
  1417.     fprintf( stderr, "mkdir: %s\n", name );
  1418. #endif
  1419.     lock = CreateDir( name );
  1420.     if ( !lock )
  1421.        return (int)IoErr();
  1422.     else 
  1423.        UnLock( lock );
  1424.     return 0;
  1425. }
  1426.  
  1427. #ifdef TEST
  1428. main()
  1429. {
  1430.     char command[100];
  1431.  
  1432.     gets( command );
  1433.     fprintf( stderr, "%d\n", mkdir( command ));
  1434. }
  1435.  
  1436. #endif
  1437.  
  1438.  
  1439.  
  1440. SHAR_EOF
  1441. fi # end of overwriting check
  1442. if test -f 'amiga/mlib.c'
  1443. then
  1444.        echo shar: will not over-write existing file "'amiga/mlib.c'"
  1445. else
  1446. cat << \SHAR_EOF > 'amiga/mlib.c'
  1447. /*        lib.c
  1448.  
  1449.  
  1450.         Amiga library
  1451.         
  1452.  
  1453.     Things to do in uu host
  1454.  
  1455.         serial I/O
  1456.         
  1457.         directory stuff
  1458.             opendir, readdir, closedir
  1459.  
  1460.         prolog and epilog
  1461.  
  1462.         system call
  1463.  
  1464. */
  1465.  
  1466. #include <stdio.h>
  1467. #include "host.h"
  1468. #include <sgtty.h>
  1469.  
  1470. int get_one()
  1471. {
  1472.     char c;
  1473.     
  1474.     struct sgttyb stty, sttyo;
  1475.     ioctl( 0, TIOCGETP, &stty );
  1476.     sttyo = stty;
  1477.     stty.sg_flags |= RAW;
  1478. /*    stty.sg_flags &= ~ ECHO; */
  1479.     ioctl( 0, TIOCSETP, &stty );
  1480.  
  1481.     c = fgetc( stdin );
  1482.     ioctl( 0, TIOCSETP, &sttyo );
  1483.  
  1484.     return( c );
  1485. }
  1486.  
  1487.  
  1488.  
  1489.  
  1490.  
  1491. SHAR_EOF
  1492. fi # end of overwriting check
  1493. if test -f 'amiga/ndir.c'
  1494. then
  1495.        echo shar: will not over-write existing file "'amiga/ndir.c'"
  1496. else
  1497. cat << \SHAR_EOF > 'amiga/ndir.c'
  1498. #include "ndir.h"
  1499. #include <exec/memory.h>
  1500. #include <functions.h>
  1501.  
  1502. #ifdef TEST
  1503. #include <stdio.h>
  1504. #endif
  1505.  
  1506. /*
  1507.  * support for Berkeley directory reading routine on a V7 file system
  1508.  */
  1509.  
  1510. extern char *malloc();
  1511.  
  1512. /*
  1513.  * open a directory.
  1514.  */
  1515.  
  1516. DIR *
  1517. opendir(name)
  1518. char *name;
  1519. {
  1520.     register DIR *dirp;
  1521.     struct Lock  *lock;
  1522.  
  1523. #ifdef TEST
  1524.     fprintf( stderr, "opendir: Opening \"%s\"\n", name );
  1525. #endif
  1526.     if ( ( lock = Lock( name, ACCESS_READ )) == NULL )
  1527.       {
  1528. #ifdef TEST
  1529.         fprintf( stderr, "opendir: Can't open.\n" );
  1530. #endif
  1531.         return NULL;
  1532.       }
  1533.  
  1534.     if ( (dirp = (DIR *)malloc(sizeof(DIR))) == NULL )
  1535.       {
  1536. #ifdef TEST
  1537.         fprintf( stderr, "opendir: couldn't malloc %d\n",sizeof(DIR));
  1538. #endif
  1539.         UnLock( lock );
  1540.         return NULL;
  1541.       }
  1542.     if ( !Examine( lock, &dirp->fib) )
  1543.       {
  1544. #ifdef TEST
  1545.          fprintf( stderr, "opendir: Couldn't Examine directory\n" );
  1546. #endif
  1547.          free( dirp );
  1548.          UnLock( lock );
  1549.       }
  1550.  
  1551.     dirp->lock = lock;
  1552. #ifdef TEST
  1553.     fprintf( stderr, "opendir: Sucessful\n" );
  1554. #endif
  1555.  
  1556.     return dirp;
  1557. }
  1558.  
  1559.  
  1560. /*
  1561.  * get next entry in a directory.
  1562.  */
  1563. struct direct *
  1564. readdir(dirp)
  1565. register DIR *dirp;
  1566. {
  1567.     static struct direct dir;
  1568.  
  1569.     while ( ExNext( dirp->lock, &dirp->fib ) )
  1570.        {
  1571.         if ( dirp->fib.fib_DirEntryType <= 0 )
  1572.           {
  1573.             dir.d_ino = 0;
  1574.             strcpy( dir.d_name, dirp->fib.fib_FileName );
  1575. #ifdef TEST
  1576.             fprintf( stderr, "readdir: OK \"%s\"\n",  dir.d_name);
  1577. #endif
  1578.             dir.d_namlen = strlen(dir.d_name);
  1579.             dir.d_reclen = DIRSIZ(&dir);
  1580.             return (&dir);
  1581.           }
  1582.         }
  1583.  
  1584. #ifdef TEST
  1585.     fprintf( stderr, "readdir: No More Entries.\n" );
  1586. #endif
  1587.     strcpy( dir.d_name, "" );
  1588.     return NULL;
  1589.  
  1590. }
  1591.  
  1592. /*
  1593.  * close a directory.
  1594.  */
  1595. void
  1596. closedir(dirp)
  1597. register DIR *dirp;
  1598. {
  1599.  
  1600.     UnLock( dirp->lock );
  1601.     free((char *)dirp);
  1602. }
  1603.  
  1604.  
  1605. #ifdef TEST
  1606. #include <errno.h>
  1607.  
  1608. main()
  1609. {
  1610.     char command[100];
  1611.  
  1612.     struct DIR *dirp;
  1613.     struct direct *dp;
  1614.     
  1615.     while(gets(command) != NULL) {
  1616.  
  1617.         fprintf( stderr, "test: %s\n", command );
  1618.  
  1619.         if ((dirp = opendir( command )) == NULL ) {
  1620.             fprintf( stderr, "couldn't open dir %s\n", command );
  1621.         }
  1622.         else
  1623.            {
  1624.             while ((dp = readdir(dirp)) != NULL) 
  1625.                 fprintf( stderr, "%s", dp->d_name );
  1626.         
  1627.             closedir( dirp );
  1628.            }    
  1629.     }
  1630. }
  1631. #endif
  1632.  
  1633.  
  1634. SHAR_EOF
  1635. fi # end of overwriting check
  1636. if test -f 'amiga/ndir.h'
  1637. then
  1638.        echo shar: will not over-write existing file "'amiga/ndir.h'"
  1639. else
  1640. cat << \SHAR_EOF > 'amiga/ndir.h'
  1641. /* @(#)ndir.h    1.4    4/16/85 */
  1642. #include <libraries/dos.h>
  1643. #ifndef DEV_BSIZE
  1644. #define    DEV_BSIZE    512
  1645. #endif
  1646. #define DIRBLKSIZ    DEV_BSIZE
  1647. #define    MAXNAMLEN    255
  1648.  
  1649. struct    direct {
  1650.     long    d_ino;            /* inode number of entry */
  1651.     short    d_reclen;        /* length of this record */ 
  1652.     short    d_namlen;        /* length of string in d_name */
  1653.     char    d_name[MAXNAMLEN + 1];    /* name must be no longer than this */
  1654. };
  1655.  
  1656. /*
  1657.  * The DIRSIZ macro gives the minimum record length which will hold
  1658.  * the directory entry.  This requires the amount of space in struct direct
  1659.  * without the d_name field, plus enough space for the name with a terminating
  1660.  * null byte (dp->d_namlen+1), rounded up to a 4 byte boundary.
  1661.  */
  1662.  
  1663. #ifdef DIRSIZ
  1664. #undef DIRSIZ
  1665. #endif /* DIRSIZ */
  1666. #define DIRSIZ(dp) \
  1667.     ((sizeof (struct direct) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3))
  1668.  
  1669. /*
  1670.  * Definitions for library routines operating on directories.
  1671.  */
  1672. /*
  1673. typedef struct _dirdesc {
  1674.     int    dd_fd;
  1675.     long    dd_loc;
  1676.     long    dd_size;
  1677.     char    dd_buf[DIRBLKSIZ];
  1678. } DIR;
  1679. */
  1680. typedef struct _dirdesc {
  1681.     struct Lock    *lock;
  1682.     struct FileInfoBlock fib;
  1683. } DIR;
  1684. #ifndef NULL
  1685. #define NULL 0L
  1686. #endif
  1687. extern    DIR *opendir();
  1688. extern    struct direct *readdir();
  1689. extern    void closedir();
  1690.  
  1691.  
  1692. SHAR_EOF
  1693. fi # end of overwriting check
  1694. if test -f 'amiga/SerialIO.c'
  1695. then
  1696.        echo shar: will not over-write existing file "'amiga/SerialIO.c'"
  1697. else
  1698. cat << \SHAR_EOF > 'amiga/SerialIO.c'
  1699. /*--------------------------------------------------------------*/
  1700. /*    SerialIO.c: Amiga Serial I/O Device Routines        */
  1701. /*      Created: June 1986 by J.A. Lydiatt            */
  1702. /*                                */
  1703. /*    Note:                            */
  1704. /*      A Task may only open the serial port once.        */
  1705. /*--------------------------------------------------------------*/
  1706.  
  1707. #include <exec/types.h>
  1708. #include <exec/memory.h>
  1709. #include <stdio.h>
  1710. #include <devices/serial.h>
  1711. #include <functions.h>
  1712.  
  1713. /* Allowable Mode Values */
  1714. #define MODEHALF    0
  1715. #define MODEFULL    1
  1716. #define MODEECHO    2
  1717.  
  1718. /* Default starting values */
  1719. #define STARTBAUD   1200  /* default baud rate */
  1720. #define STARTMODE   MODEFULL
  1721. #define SERFLAGS    (SERF_SHARED | SERF_XDISABLED)
  1722. #define CTLCHAR     0x11130501    
  1723.  
  1724. static int Mode = STARTMODE;
  1725. static int amClosing = FALSE;
  1726.  
  1727. /* declarations for the serial stuff */
  1728. static struct IOExtSer *Read_Request = NULL;
  1729. static UBYTE rs_in[2];
  1730. static struct IOExtSer *Write_Request = NULL;
  1731. static UBYTE rs_out[2];
  1732.  
  1733. /* stack to save Serial Port flags */
  1734. #define MAXSTACK 10
  1735. static int stackSize = 0;
  1736. static int   modeStack[ MAXSTACK ];
  1737. static UBYTE flagStack[ MAXSTACK ];
  1738.  
  1739.  
  1740. /*------------------------------------------------------------*/
  1741. /*  GetSerialSigBit: return Read_Request's Signal Bit          */
  1742. /*------------------------------------------------------------*/
  1743.  
  1744. int GetSerialSigBit()
  1745. {
  1746.    return Read_Request->IOSer.io_Message.mn_ReplyPort->mp_SigBit;
  1747. }
  1748.  
  1749. /*------------------------------------------------------------*/
  1750. /*  CheckSerIO : return TRUE if serial port has a character   */
  1751. /*------------------------------------------------------------*/
  1752.  
  1753. BOOL CheckSerIO()
  1754. {
  1755.    return (BOOL)( CheckIO( Read_Request ) != NULL);
  1756. }
  1757.  
  1758. /*------------------------------------------------------------*/
  1759. /*      FlushSerIO: Flush the receive buffer              */
  1760. /*------------------------------------------------------------*/
  1761.  
  1762. void FlushSerIO()
  1763. {
  1764.    register struct IOExtSer *r = Read_Request;
  1765.  
  1766.    AbortIO( r );                 /* abort it */
  1767.    AbortIO( Write_Request );
  1768.  
  1769.    r->IOSer.io_Command = CMD_FLUSH;
  1770.    DoIO( r );                       /* flush all IO requests */
  1771.    r->IOSer.io_Command = CMD_CLEAR;
  1772.    DoIO( r);                       /* flush receive buffer  */
  1773.  
  1774.    if ( !amClosing )
  1775.      {
  1776.         Read_Request->IOSer.io_Command = CMD_READ;
  1777.         BeginIO( r );           /* start receive request */
  1778.      }
  1779. }
  1780.  
  1781.  
  1782. /*------------------------------------------------------------*/
  1783. /*  PushSerState: save current io flags                       */
  1784. /*------------------------------------------------------------*/
  1785. void PushSerState()
  1786. {
  1787.    register struct IOExtSer *r = Read_Request; 
  1788.  
  1789.    if ( stackSize < MAXSTACK )
  1790.      {
  1791.         /* Save the current Mode */
  1792.         modeStack[ stackSize ] = Mode;
  1793.         
  1794.     /* Get the current flags */
  1795.     AbortIO( r );
  1796.     flagStack[ stackSize++ ] = r->io_SerFlags;
  1797.     BeginIO( r );
  1798.      }
  1799. }
  1800.  
  1801. /*------------------------------------------------------------*/
  1802. /*  PullSerState: restore last saved flag state              */
  1803. /*------------------------------------------------------------*/
  1804. void PullSerState()
  1805. {
  1806.    register struct IOExtSer *r = Read_Request; 
  1807.  
  1808.    if ( stackSize > 0 )
  1809.      {
  1810.     /* Reset the Mode */
  1811.     Mode = modeStack[ --stackSize ];
  1812.  
  1813.     /* Set the old flags */
  1814.     AbortIO( r );
  1815.     r->io_SerFlags = flagStack[ stackSize ];
  1816.     r->IOSer.io_Command = SDCMD_SETPARAMS;
  1817.     DoIO( r );
  1818.     r->IOSer.io_Command = CMD_READ;
  1819.     BeginIO( r );
  1820.      }
  1821. }
  1822. /*-------------------------------------------------------------*/
  1823. /*           CloseSerialIO: Close the serial port              */
  1824. /*-------------------------------------------------------------*/
  1825. void CloseSerialIO()
  1826. {
  1827.    register struct IOExtSer *r = Read_Request;
  1828.    register struct IOExtSer *w = Write_Request;
  1829.  
  1830.    if ( r != NULL )
  1831.      {
  1832.     amClosing = TRUE;
  1833.     CloseDevice( r );
  1834.     DeletePort( r->IOSer.io_Message.mn_ReplyPort );
  1835.     FreeMem( r, (long)sizeof( struct IOExtSer ) );
  1836.     Read_Request = NULL;
  1837.       }
  1838.  
  1839.     if ( w != NULL )
  1840.       {
  1841.     CloseDevice( w );
  1842.     DeletePort( w->IOSer.io_Message.mn_ReplyPort );
  1843.     FreeMem( w, (long)sizeof( struct IOExtSer ) );
  1844.     Write_Request = NULL;
  1845.       }
  1846. }
  1847. /*-------------------------------------------------------------*/
  1848. /* InitSerialIO: Open serial IO - return read Port           */
  1849. /*-------------------------------------------------------------*/    
  1850. struct IOExtSer *InitSerialIO()
  1851. {
  1852.    register struct IOExtSer *r, *w;
  1853.  
  1854.    if ( Read_Request != NULL )
  1855.       {
  1856.     fprintf( stderr, "Error: Serial Port already open for read.\n");
  1857.     return NULL;
  1858.       }
  1859.    r = (struct IOExtSer *) AllocMem( (long)sizeof(struct IOExtSer),
  1860.      (long)(MEMF_PUBLIC|MEMF_CLEAR));
  1861.    if (r == NULL)
  1862.     return NULL;
  1863.  
  1864.    Read_Request = r;
  1865.    r->io_SerFlags = SERFLAGS;
  1866.    r->io_CtlChar  = CTLCHAR;
  1867.    r->IOSer.io_Message.mn_ReplyPort = CreatePort("Read_RS",NULL);
  1868.    if(OpenDevice(SERIALNAME,NULL,r,NULL))
  1869.       {
  1870.      fprintf( stderr, "Can't open Read device\n");
  1871.     goto q4;
  1872.       }
  1873.  
  1874.    r->io_Baud = STARTBAUD;
  1875.    r->io_ReadLen = 8;
  1876.    r->io_WriteLen = 8;
  1877.    r->IOSer.io_Command = SDCMD_SETPARAMS;
  1878.    DoIO(r);
  1879.    r->IOSer.io_Command = CMD_READ;
  1880.    r->IOSer.io_Length = 1;
  1881.    r->IOSer.io_Data = (APTR)&rs_in[0];
  1882.  
  1883.  
  1884.    if ( Write_Request != NULL )
  1885.       {
  1886.     fprintf( stderr, "Error: Serial Port already open for writing.\n");
  1887.     goto q3;
  1888.       }
  1889.    w = (struct IOExtSer *)AllocMem( (long)sizeof( struct IOExtSer ),
  1890.       (long)MEMF_PUBLIC|MEMF_CLEAR);
  1891.    if (w == NULL) goto q3;
  1892.  
  1893.    Write_Request = w;
  1894.    w->io_SerFlags = SERFLAGS;
  1895.    w->io_CtlChar  = CTLCHAR;
  1896.    w->IOSer.io_Message.mn_ReplyPort = CreatePort("Write_RS",NULL);
  1897.    if(OpenDevice(SERIALNAME,NULL,w,NULL))
  1898.       {
  1899.     fprintf( stderr, "Can't open Write device\n");
  1900.     goto q1;
  1901.       }
  1902.    w->io_Baud = STARTBAUD;
  1903.    w->io_ReadLen = 8;
  1904.    w->io_WriteLen = 8;
  1905.    w->IOSer.io_Command = SDCMD_SETPARAMS;
  1906.    DoIO(w);
  1907.  
  1908.    w->IOSer.io_Command = CMD_WRITE;
  1909.    w->IOSer.io_Length = 1;
  1910.    w->IOSer.io_Data = (APTR)&rs_out[0];
  1911.  
  1912.    BeginIO( r );
  1913.    stackSize = 0;
  1914.  
  1915.    return r;
  1916.  
  1917. q1:   DeletePort( w->IOSer.io_Message.mn_ReplyPort );
  1918. q2:   FreeMem( w, (long)sizeof( *w) );
  1919. q3:   CloseDevice( r );
  1920. q4:   DeletePort( r->IOSer.io_Message.mn_ReplyPort );
  1921. q5:   FreeMem( r, (long)sizeof( *r) );
  1922.  
  1923.    return NULL;
  1924. }
  1925.  
  1926. /*----------------------------------------------------------*/
  1927. /*         SetXonMode: set Xon On or Off                    */
  1928. /*----------------------------------------------------------*/
  1929.  
  1930. void SetXonMode( status )
  1931. BOOL status;
  1932. {
  1933.  
  1934.    register UBYTE flags;
  1935.    register struct IOExtSer *r = Read_Request; 
  1936.  
  1937.    /* Get the current flags */
  1938.    AbortIO( r );
  1939.    flags = r->io_SerFlags;
  1940.  
  1941.    if ( status )
  1942.       flags &= ~(SERF_XDISABLED);
  1943.    else
  1944.       flags |= SERF_XDISABLED; 
  1945.    r->io_SerFlags = flags;
  1946.    r->IOSer.io_Command = SDCMD_SETPARAMS;
  1947.    DoIO( r );
  1948.    r->IOSer.io_Command = CMD_READ;
  1949.    BeginIO( r );
  1950. }
  1951.  
  1952. /*----------------------------------------------------------*/
  1953. /*         SetSerBaud: set Serial Baud Rate                 */
  1954. /*----------------------------------------------------------*/
  1955.  
  1956. void SetSerBaud( baud )
  1957. int baud;
  1958. {
  1959.    register struct IOExtSer *r = Read_Request; 
  1960.  
  1961.    /* Get the current flags */
  1962.    AbortIO( r );
  1963.    r->io_Baud = baud;
  1964.    r->IOSer.io_Command = SDCMD_SETPARAMS;
  1965.    DoIO( r );
  1966.    r->IOSer.io_Command = CMD_READ;
  1967.    BeginIO( r );
  1968. }
  1969.  
  1970. /*----------------------------------------------------------*/
  1971. /*         SetSerMode: set the Serial Mode            */
  1972. /*----------------------------------------------------------*/
  1973.  
  1974. void SetSerMode( mode )
  1975. int mode;
  1976. {
  1977.    Mode = mode;
  1978. }
  1979.  
  1980. /*----------------------------------------------------------*/
  1981. /*   SerIOWrite: Write a byte out the serial port (no echo) */
  1982. /*----------------------------------------------------------*/
  1983.  
  1984. void SerIOWrite( c )
  1985. register UBYTE c;
  1986. {
  1987.   *rs_out = c;
  1988.   DoIO( Write_Request );
  1989. }
  1990.  
  1991. /*----------------------------------------------------------*/
  1992. /* SerIORead: read a byte from the serial port (no echo)    */
  1993. /*----------------------------------------------------------*/
  1994.  
  1995. UBYTE SerIORead()
  1996. {
  1997.    register struct IOExtSer *r = Read_Request;
  1998.    register UBYTE c;
  1999.  
  2000.    WaitIO( r );
  2001.    c = *rs_in;
  2002.    BeginIO( r );
  2003.    return c;
  2004. }
  2005.  
  2006.  
  2007. SHAR_EOF
  2008. fi # end of overwriting check
  2009. if test -f 'amiga/sio.c'
  2010. then
  2011.        echo shar: will not over-write existing file "'amiga/sio.c'"
  2012. else
  2013. cat << \SHAR_EOF > 'amiga/sio.c'
  2014. /*------------------------------------------------------------------*/
  2015. /*    Sio.c:  Serial I/O for Amiga Version of PCMail            */
  2016. /*    Created: 27Jun87 by J.A. Lydiatt                */
  2017. /*                                    */
  2018. /* Exports the following routines required by PCMail:            */
  2019. /*  SIOInit():        Initialize Serial Port                */
  2020. /*  SIOClose():        Close and free Serial Port resources        */
  2021. /*  SIOSpeed():        Set bps                        */
  2022. /*  SIORead():        read characters from serial port        */
  2023. /*  SIOWrite():        write characters to serial port            */
  2024. /*  SIOInBuffer():    Set Buffer size for read & writes.        */
  2025. /*  SIOOutBuffer():    (Has no effect in Amiga Version)        */
  2026. /*------------------------------------------------------------------*/
  2027.  
  2028. #include <stdio.h>
  2029. #ifndef TRUE
  2030. #define TRUE -1
  2031. #define FALSE 0
  2032. #endif
  2033.  
  2034. /*--- Timer Function Declarations --- */
  2035.  
  2036. extern void CloseTimer();    /* Return Timer's resources to the System */
  2037. extern int  OpenTimer();     /* Returns True if Timer Device Opened OK */ 
  2038. extern void StartTimer();    /* (long)seconds, (long)microseconds      */
  2039. extern int  TimerExpired();     /* Returns True if Timer interval expired */
  2040.  
  2041. /*--- SerialIO Function Declarations --- */
  2042.  
  2043. extern struct EOExtSer *InitSerialIO(); /* problems? return NULL      */
  2044. extern void CloseSerialIO();        /* Return SerialIO resources      */
  2045. extern int  CheckSerIO();        /* TRUE if character available    */
  2046. extern char SerIORead();        /* Returns a Char from serial port*/
  2047. extern void SerIOWrite();         /* Writes one byte to serial port */ 
  2048. extern void SetSerBaud();        /* (int)baud - set baud rate      */
  2049.  
  2050. /*--------------------------------------------------------------*/
  2051. /*     getspeed/getbaud: check for valid baud parameters    */
  2052. /*--------------------------------------------------------------*/
  2053.  
  2054. static struct {
  2055.     unsigned baudr;
  2056.     int speedcode;
  2057.  
  2058. } speeds[] = {
  2059.     300,    300,
  2060.     1200,    1200,
  2061.     2400,    2400,
  2062.     4800,    4800,
  2063.     9600,    9600,
  2064.     19200, 19200,
  2065.     0,
  2066. };
  2067.  
  2068. static unsigned getspeed(code)
  2069. {
  2070.     register n;
  2071.  
  2072.     for (n=0; speeds[n].baudr; ++n)
  2073.         if (speeds[n].speedcode == code)
  2074.             return speeds[n].baudr;
  2075.     return 0;
  2076. }
  2077.  
  2078.  
  2079. static unsigned getbaud(code)
  2080. char *code;
  2081. {
  2082.     register n;
  2083.     register int Baudrate;
  2084.     
  2085.     Baudrate = atoi(code);
  2086.     
  2087.     for (n=0; speeds[n].baudr; ++n)
  2088.         if (speeds[n].baudr == Baudrate)
  2089.             return speeds[n].speedcode;
  2090.     return 0;
  2091. }
  2092.  
  2093. /*--------------------------------------------------------------*/
  2094. /*    SIOInit: initialize serial I/O                */
  2095. /*--------------------------------------------------------------*/
  2096.  
  2097.  
  2098. SIOInit ( whichport, speed )
  2099. char * whichport;
  2100. char * speed;
  2101. {
  2102.     unsigned int baud;
  2103.     extern void SetXonMode();
  2104.  
  2105.     /*  fprintf( stderr, "sioinit %s %s\n", whichport, speed ); /* */
  2106.  
  2107.     if ( InitSerialIO() == NULL ) {
  2108.         fprintf( stderr, "Can't open Serial Port\n" );
  2109.         return( -1 );
  2110.     }
  2111.  
  2112.      if ( baud = getbaud( speed ) )
  2113.     SetSerBaud( baud );
  2114.  
  2115.      if ( !OpenTimer() )
  2116.     {
  2117.        CloseSerialIO();
  2118.        fprintf( stderr, "Can't open the Timer Device\n" );
  2119.        return -1;
  2120.         }
  2121.  
  2122.      SetXonMode( (int)FALSE );
  2123.      return( 0 );
  2124. }
  2125.  
  2126. /*--------------------------------------------------------------*/
  2127. /*    SIOSpeed:  set the serial Baud rate             */
  2128. /*--------------------------------------------------------------*/
  2129.  
  2130. SIOSpeed( speed )
  2131. char *speed;
  2132. {
  2133.     unsigned int baud;
  2134.  
  2135.     if ( baud = getbaud( speed ) )
  2136.     SetSerBaud( baud );
  2137. }
  2138.  
  2139. /*--------------------------------------------------------------*/
  2140. /*    SIOInBuffer/ SIOOutBuffer:    Set Buffer Size.    */
  2141. /*--------------------------------------------------------------*/
  2142.  
  2143. SIOInBuffer ( buf, size )
  2144. char * buf;
  2145. int size;
  2146. {
  2147. }
  2148.  
  2149. SIOOutBuffer ( buf, size )
  2150. char * buf;
  2151. int size;
  2152. {
  2153. }
  2154.  
  2155. /*--------------------------------------------------------------*/
  2156. /*    SIOClose:    Close Serial port.            */
  2157. /*--------------------------------------------------------------*/
  2158.  
  2159. SIOClose ( dtr )
  2160. {
  2161.    CloseSerialIO();
  2162.    CloseTimer();
  2163. }
  2164.  
  2165. /*--------------------------------------------------------------*/
  2166. /*    SIOWrite: send count characters to serial port        */
  2167. /*--------------------------------------------------------------*/
  2168.  
  2169. SIOWrite ( buf, count )
  2170. register char * buf;
  2171. int count;
  2172. {
  2173.     register int nsent;
  2174.  
  2175.     nsent = count;
  2176.     while ( nsent-- )
  2177.        SerIOWrite( *buf++ );
  2178.  
  2179.     return count;
  2180. }
  2181.  
  2182. /*--------------------------------------------------------------*/
  2183. /*    SIORead: read mincount <= #characters <= maxcount    */
  2184. /*    return  # of characters read, or -1 if timed out after    */
  2185. /*    after tenths / 10 seconds.                */
  2186. /*--------------------------------------------------------------*/
  2187.  
  2188.  
  2189. int SIORead ( buf, mincount, maxcount, tenths )
  2190. register char *buf;
  2191. int    mincount;
  2192. int    maxcount;
  2193. int    tenths; /* timeout is in tenth's of seconds */
  2194. {
  2195.         /* A bit of a Kludge to get the project started */
  2196.  
  2197.     long seconds, microSeconds;
  2198.     unsigned long waitMask;
  2199.     int  timerON ;
  2200.     register int received;
  2201.  
  2202.     /* fprintf (stderr, "Read  m= %d T= %ld", maxcount, Ticks  );/**/
  2203.  
  2204.  
  2205.  
  2206.     if ( tenths == 0 )
  2207.        {
  2208.         if ( !CheckSerIO() )
  2209.            return -1;
  2210.         tenths = 10;
  2211.        }
  2212.         seconds = tenths / 10;
  2213.     microSeconds = ((long)(tenths) - seconds * 10L) * 100000L;
  2214.         
  2215.     received = 0;
  2216.     waitMask = (1L << GetSerialSigBit()) | (1L << GetTimerSigBit() ); 
  2217.     timerON = FALSE;
  2218.     do
  2219.       {
  2220.          if ( CheckSerIO() )
  2221.             {
  2222.                 *buf = SerIORead();
  2223.            ++buf;
  2224.            ++received;
  2225.            if ( mincount <= received && received <= maxcount )
  2226.               return received;
  2227.         }
  2228.          if ( !timerON )
  2229.         {
  2230.            StartTimer( seconds, microSeconds );
  2231.            timerON = TRUE;
  2232.         }
  2233.          Wait( waitMask );
  2234.  
  2235.       }    while ( !TimerExpired() );
  2236.  
  2237.     return -1;
  2238. }
  2239.  
  2240.  
  2241. SHAR_EOF
  2242. fi # end of overwriting check
  2243. if test -f 'amiga/sleep.c'
  2244. then
  2245.        echo shar: will not over-write existing file "'amiga/sleep.c'"
  2246. else
  2247. cat << \SHAR_EOF > 'amiga/sleep.c'
  2248. /*--------------------------------------------------------------*/
  2249. /* sleep.c:    Implement sleep( seconds ) on the Amiga.    */
  2250. /*--------------------------------------------------------------*/
  2251.  
  2252. void sleep( seconds )
  2253. unsigned int seconds;
  2254. {
  2255.      if ( seconds > 0 )
  2256.     Delay( (long)( seconds * 50L ));
  2257. }
  2258.  
  2259. SHAR_EOF
  2260. fi # end of overwriting check
  2261. if test -f 'amiga/Timer.c'
  2262. then
  2263.        echo shar: will not over-write existing file "'amiga/Timer.c'"
  2264. else
  2265. cat << \SHAR_EOF > 'amiga/Timer.c'
  2266. /*  
  2267.  *  Timer.c: Functions to invoke the Amiga timer:
  2268.  *  
  2269.  *  External Functions:
  2270.  *
  2271.  *  OpenTimer, CloseTimer, StartTimer, TimerExpired, GetTimerSigBit
  2272.  * 
  2273.  *  Maintenance Notes:
  2274.  *   05Jul86  - Created by Jeff Lydiatt, Vancouver, Canada.
  2275.  */
  2276.  
  2277. #include <exec/types.h>
  2278. #include <exec/nodes.h>
  2279. #include <exec/lists.h>
  2280. #include <exec/ports.h>
  2281. #include <exec/tasks.h>
  2282. #include <exec/io.h>
  2283. #include <devices/timer.h>
  2284. #include <functions.h>
  2285.  
  2286. static struct timerequest TimerIO;
  2287. static struct MsgPort    *TimerPort = NULL;
  2288. static BOOL timerON;
  2289. static BOOL timerExpired;
  2290.  
  2291. /*-------------------------------------------------------------*/
  2292. /*    OpenTimer: return TRUE if timer opened OK           */
  2293. /*-------------------------------------------------------------*/
  2294.  
  2295. BOOL OpenTimer()
  2296. {
  2297.    register struct timerequest *t = &TimerIO;
  2298.    register struct MsgPort *port;
  2299.  
  2300.    timerON = FALSE;
  2301.    timerExpired = TRUE;
  2302.    if ( TimerPort != NULL )
  2303.       return TRUE;
  2304.  
  2305.    if ( (port = CreatePort("Timer Port", 0L)) == NULL )
  2306.       return FALSE;
  2307.    else
  2308.       TimerPort = port;
  2309.  
  2310.    if (OpenDevice(TIMERNAME, UNIT_VBLANK, t, 0L) != 0)
  2311.      {
  2312.     DeletePort( port );
  2313.     TimerPort = NULL;
  2314.     return FALSE;
  2315.      }
  2316.  
  2317.    return TRUE;
  2318. }
  2319.  
  2320. /*-------------------------------------------------------------*/
  2321. /*    CloseTimer: All Done with the timer.               */
  2322. /*-------------------------------------------------------------*/
  2323.  
  2324. void CloseTimer()
  2325. {
  2326.    register struct timerequest *t = &TimerIO;
  2327.  
  2328.    if ( timerON )
  2329.       AbortIO( t );
  2330.  
  2331.    CloseDevice( t );
  2332.    DeletePort( TimerPort );
  2333.    TimerPort = NULL;
  2334. }
  2335.  
  2336. /*-------------------------------------------------------------*/
  2337. /*    GetTimerSigBit: return Timer signal bit               */
  2338. /*-------------------------------------------------------------*/
  2339.  
  2340. int GetTimerSigBit()
  2341. {
  2342.    return TimerPort->mp_SigBit;
  2343. }
  2344.  
  2345. /*-------------------------------------------------------------*/
  2346. /*    StartTimer: launch the timer.                   */
  2347. /*-------------------------------------------------------------*/
  2348.  
  2349. void StartTimer(seconds, micros)
  2350. ULONG seconds, micros;
  2351. {
  2352.    register struct timerequest *t = &TimerIO;
  2353.  
  2354.    if ( timerON )
  2355.      {
  2356.     AbortIO( t );
  2357.     (void) GetMsg( TimerPort );
  2358.     timerON = FALSE;
  2359.         timerExpired = TRUE;
  2360.      }
  2361.  
  2362.    t->tr_time.tv_secs = seconds;
  2363.    t->tr_time.tv_micro = micros;
  2364.    t->tr_node.io_Command = TR_ADDREQUEST;
  2365.    t->tr_node.io_Flags = IOF_QUICK;
  2366.    t->tr_node.io_Error = 0;
  2367.    t->tr_node.io_Message.mn_ReplyPort = TimerPort;
  2368.    SendIO( t );
  2369.    timerExpired = FALSE;
  2370.    timerON = TRUE;
  2371. }
  2372.  
  2373. /*-------------------------------------------------------------*/
  2374. /*    TimerExpired: returns TRUE if timer expired.           */
  2375. /*-------------------------------------------------------------*/
  2376.  
  2377. BOOL TimerExpired()
  2378. {
  2379.    if ( timerON && ( CheckIO( &TimerIO.tr_node ) == NULL) )
  2380.       return FALSE;
  2381.  
  2382.    (void)GetMsg( TimerPort );
  2383.    timerExpired = TRUE;
  2384.    timerON = FALSE;
  2385.  
  2386.    return timerExpired;
  2387. }
  2388.  
  2389.  
  2390. SHAR_EOF
  2391. fi # end of overwriting check
  2392. if test -f 'amiga/ulib.c'
  2393. then
  2394.        echo shar: will not over-write existing file "'amiga/ulib.c'"
  2395. else
  2396. cat << \SHAR_EOF > 'amiga/ulib.c'
  2397. /*        ulib.c
  2398.  
  2399.  
  2400.         Amiga library
  2401.         
  2402.  
  2403.     Things to do in uu host
  2404.  
  2405.         serial I/O
  2406.         
  2407.         directory stuff
  2408.             opendir, readdir, closedir
  2409.  
  2410.         prolog and epilog
  2411.  
  2412.         system call
  2413.  
  2414. */
  2415.  
  2416. #include <stdio.h>
  2417. #include "host.h"
  2418. #include <sgtty.h>
  2419.  
  2420. /**/
  2421. /*
  2422.  *
  2423.  *      login (for slave in PC mode)
  2424.  * Real dumb login handshake
  2425. */
  2426. login()
  2427. {
  2428.     char    logmsg[132];
  2429. #ifdef PC
  2430. lretry:
  2431.     msgtime = 9999;
  2432.     rmsg(logmsg, 0); /* wait for a <CR> or <NL> */
  2433.     msgtime = 2 * MSGTIME;
  2434.     wmsg("Username:", 0);
  2435.     rmsg(logmsg, 0);
  2436.     printmsg( 0, "Username = %s", logmsg );
  2437.     wmsg("Password:", 0);
  2438.     rmsg(logmsg, 0);
  2439.     printmsg( 14, "Password = %s", logmsg );
  2440.     if (strcmp(logmsg, "uucp") != 0) 
  2441.         goto lretry;
  2442. #endif
  2443.     return('I');
  2444. }
  2445.  
  2446.  
  2447. char inbuf[BUFSIZ];
  2448. char outbuf[BUFSIZ];
  2449.  
  2450. swrite(data, num)
  2451. int    num;
  2452. char    *data;
  2453. {
  2454.  
  2455.     int test;
  2456.     unsigned char * cp;
  2457.  
  2458.     if (debuglevel > 14)
  2459.         fputc( '{', stderr );
  2460.     if (debuglevel > 14) {
  2461.         test = num;
  2462.         cp = data;
  2463.         while (test--)
  2464.             fprintf( stderr, isprint(*cp)? "{%c}":"{%02x}", *cp++ );
  2465.     }
  2466.     test = SIOWrite( data, num );
  2467.     if (debuglevel > 14)
  2468.         fputc( '}', stderr );
  2469.     return( test );
  2470.  
  2471. }
  2472.  
  2473. /* non-blocking read essential to "g" protocol */
  2474. /* see "dcpgpkt.c" for description */
  2475. /* This all changes in a mtask systems. Requests for */
  2476. /* I/O should get qued and an event flag given. Then the */
  2477. /* requesting process (e.g.gmachine()) waits for the event */
  2478. /* flag to fire processing either a read or a write. */
  2479. /* Could be implemented on VAX/VMS or DG but not MS-DOS */
  2480. sread(buf, num, timeout)
  2481. char    *buf;
  2482. int    num, timeout;
  2483. {
  2484. /*
  2485.     return( SIORead( buf, num, num, timeout*10 ) );
  2486. */
  2487.     int count;
  2488.     int test;
  2489.     unsigned char * cp;
  2490.  
  2491.     if (debuglevel > 13)
  2492.         fputc( '[', stderr );
  2493.     printmsg( 15, "sread: num: %d  timeout: %d", num, timeout );
  2494.         
  2495.     count = SIORead( buf, num, num, timeout*10 );
  2496.     printmsg( 15, "sread: read: %d ", count );
  2497.  
  2498.     if (debuglevel > 13 && count > 0) {
  2499.         test = count;
  2500.         cp = buf;
  2501.         while (test--)
  2502.             fprintf( stderr, isprint(*cp)? "[%c]":"[%02x]", *cp++ );
  2503.     }
  2504.         
  2505.     if (debuglevel > 13)
  2506.         fputc( ']', stderr );
  2507.     return( count );    
  2508.     
  2509. }
  2510.  
  2511.  
  2512.  
  2513. openline(name, baud)
  2514. char    *name, *baud;
  2515. {
  2516.  
  2517.     printmsg( 3, "openline: name: \"%s\"  baud: \"%s\"", name, baud );
  2518.     if ( SIOInit( name, baud ) )
  2519.        return -1;
  2520.     SIOInBuffer( inbuf, BUFSIZ );
  2521.     SIOOutBuffer( outbuf, BUFSIZ );
  2522.     return( 0 );
  2523. }
  2524.  
  2525.  
  2526. closeline()
  2527. {
  2528.     SIOClose( 1 );
  2529. }
  2530.  
  2531.  
  2532. nodot(string)
  2533. {
  2534. }
  2535.  
  2536.  
  2537.  
  2538. notimp( argc, argv )
  2539. char *argv[];
  2540. {
  2541.     /*debuglevelMsg("\Pcheck argc (08) and argv (0a) ");*/
  2542.     fprintf( stderr, "shell: %s not implemented\n", *argv );
  2543. }
  2544.  
  2545. /*------------------------------------------------------------------*/
  2546. /*    RNews:    my private rnews!                    */
  2547. /*------------------------------------------------------------------*/
  2548. static void RNews( inname )
  2549. char *inname;
  2550. {
  2551.     extern    char *newsdir;
  2552.     register struct tm    *thetm;
  2553.     long    tloc;
  2554.     char    filename[132];
  2555.     char    format[128];
  2556.     FILE     *f, *fin;
  2557.     FILE    *FOPEN();
  2558.     char    buf[BUFSIZ];
  2559.     
  2560.     static int count = 0;
  2561.     int    len;
  2562.     
  2563.     /* inname is of form "D.jlamiBCnnnn".  Pick off the nnnn. */
  2564.     len = strlen( inname ) - 1;
  2565.     while ( len >= 0 )
  2566.       {
  2567.         if ( '0' <= inname[len] && inname[len] <= '9' )
  2568.            --len;
  2569.         else
  2570.            break;
  2571.        }
  2572.  
  2573.     sprintf( filename, "%s/%s", newsdir, &inname[len+1] );
  2574.     if ( (f = FOPEN( filename, "r" )) != NULL )
  2575.        {
  2576.         /* Already exists, so make a timestamped one. */
  2577.         fclose( f );    
  2578.         tloc = time( (long *)NULL );
  2579.         thetm = localtime( &tloc );
  2580.  
  2581.         sprintf( filename, "%s/%02d%02d%02d%02d%02d%02d.%03d",
  2582.             newsdir,
  2583.             thetm->tm_year % 100, thetm->tm_mon,
  2584.             thetm->tm_mday, thetm->tm_hour,
  2585.             thetm->tm_min,  thetm->tm_sec,  count
  2586.             );
  2587.         ++count;
  2588.        }
  2589.     
  2590.     if ( TRUE /*debuglevel > 5*/ )
  2591.         fprintf( stderr, "rnews: %s\n", filename );
  2592.     
  2593.     if ( (f = FOPEN( filename, "w" )) == (FILE *)NULL ) {
  2594.         fprintf( stderr, "rnews: can't open %s\n", filename );
  2595.         return;
  2596.     }
  2597.  
  2598.     if ( (fin = FOPEN( inname, "r" )) == NULL )
  2599.       {
  2600.         fprintf( stderr, "rnews: Couldn't open %s\n", inname );
  2601.         fclose( f );
  2602.         return;
  2603.       }
  2604.     
  2605.     while ( fgets( buf, BUFSIZ, fin ) != (char *)NULL ) 
  2606.         fputs( buf, f );
  2607.  
  2608.     fclose( f );
  2609.     fclose( fin );
  2610. }
  2611.  
  2612.  
  2613.  
  2614. /*         shell
  2615.  
  2616.  
  2617. */
  2618.  
  2619. char * getcwd();
  2620.  
  2621. shell( command, inname, outname, errname )
  2622. char * command;
  2623. char * inname;
  2624. char * outname;
  2625. {
  2626.  
  2627.     char    * argvec[50];
  2628.  
  2629.     int rmail();
  2630.     int rnews();
  2631.     
  2632.     int     argcp;
  2633.  
  2634.     char **argvp;
  2635.     char args;
  2636.     
  2637.  
  2638.     int    (*proto)();
  2639.     
  2640.     argcp = 0;
  2641.  
  2642.     argcp = getargs( command, argvec );
  2643.  
  2644.     argvp = argvec;
  2645.     args = argcp;
  2646.  
  2647.     if ( debuglevel > 5 ) {
  2648.         while ( args ) 
  2649.             fprintf( stderr, "arg: %d  %s\n", args--, *argvp++ );
  2650.         argvp = argvec;
  2651.         args = argcp;
  2652.     }
  2653.     /* */
  2654.     
  2655.     proto = notimp;
  2656.  
  2657.     if ( strcmp( *argvp, "rmail" ) == SAME )
  2658.         proto = rmail;
  2659.  
  2660.     else if ( strcmp( *argvp, "rnews" ) == SAME ) {
  2661.         /* proto = rnews; */
  2662.         RNews( inname );
  2663.         return; 
  2664.     }
  2665.         
  2666.     if ( *inname != '\0' ) {
  2667.         fprintf( stderr, "reopening stdin as %s\n", inname );
  2668.         fprintf( stderr, "curdir: %s\n", getcwd(NULL, 0)); /* */
  2669.         if ( freopen( inname, "r", stdin ) == NULL ) 
  2670.             fprintf( stderr, "Couldn't open %s, %d\n", inname, errno );
  2671.     }
  2672.     (proto)( argcp, argvp );
  2673.  
  2674.     freopen( "con:", "r", stdin );
  2675.  
  2676. }
  2677.  
  2678.  
  2679.  
  2680.  
  2681.  
  2682.  
  2683. SHAR_EOF
  2684. fi # end of overwriting check
  2685. #    End of shell archive
  2686. exit 0
  2687.  
  2688. --
  2689. {ubc-vision,uunet}!van-bc!sl                Stuart.Lynne@van-bc.uucp
  2690.