home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / old / ckermit4e / ckiutl.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  13KB  |  544 lines
  1. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  2. /* |_o_o|\\ Copyright (c) 1986 The Software Distillery.  All Rights Reserved */
  3. /* |. o.| || This program may not be distributed without the permission of   */
  4. /* | .  | || the authors.                                                    */
  5. /* | o  | ||    Dave Baker     Ed Burnette  Stan Chow    Jay Denebeim        */
  6. /* |  . |//     Gordon Keener  Jack Rouse   John Toebes  Doug Walker         */
  7. /* ======          BBS:(919)-471-6436      VOICE:(919)-469-4210              */ 
  8. /*                                                                           */
  9. /* Contributed to Columbia University for inclusion in C-Kermit.             */
  10. /* Permission is granted to any individual or institution to use, copy, or   */
  11. /* redistribute this software so long as it is not sold for profit, provided */
  12. /* this copyright notice is retained.                                        */
  13. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  14.  
  15. /*  C K I U T L -- July 17, 1986
  16.  * Utility functions for C-Kermit on the Amiga
  17.  */
  18.  
  19. /*
  20.  Author: Jack Rouse, The Software Distillery
  21.  
  22.  The file status routines assume all file protection modes are real, instead
  23.  of just delete protection on files and write protection on disks.
  24. */
  25.  
  26. #include <stdio.h>
  27. #undef NULL
  28. #include "exec/types.h"
  29. #include "exec/exec.h"
  30. #include "libraries/dos.h"
  31. #include "libraries/dosextens.h"
  32. #define fh_Interact fh_Port
  33. #define fh_Process  fh_Type
  34. #define ACTION_CLOSE 1007
  35. #ifdef LAT310
  36. #include "fcntl.h"
  37. #include "signal.h"
  38. #else
  39. #include "lattice/ios1.h"    /* defines ufbs structure */
  40. #endif
  41.  
  42. /* external routine definitions */
  43. APTR AllocMem();
  44. LONG AllocSignal();
  45. struct IORequest *CheckIO();
  46. VOID CloseDevice();
  47. VOID CloseLibrary();
  48. LONG DoIO();
  49. struct MsgPort *FindPort();
  50. struct Task *FindTask();
  51. VOID FreeMem();
  52. VOID FreeSignal();
  53. struct Message *GetMsg();
  54. LONG OpenDevice();
  55. struct Library *OpenLibrary();
  56. VOID PutMsg();
  57. VOID ReplyMsg();
  58. VOID SendIO();
  59. LONG SetSignal();
  60. VOID Signal();
  61. LONG Wait();
  62. LONG WaitIO();
  63. struct Message *WaitPort();
  64.  
  65. struct IORequest *CreateExtIO();
  66. struct MsgPort *CreatePort();
  67.  
  68. VOID Close();
  69. LONG DeleteFile();
  70. LONG Execute();
  71. BPTR Input(), Output();
  72. LONG IoErr();
  73. LONG IsInteractive();
  74. BPTR Lock();
  75. BPTR Open();
  76. LONG Read();
  77. VOID UnLock();   
  78. LONG WaitForChar();
  79.  
  80. /* portable library */
  81. char *malloc();
  82.  
  83. #ifdef LAT310
  84. /* translate Unix file handle (0, 1, or 2) to AmigaDOS file handle */
  85. #define DOSFH(n) fileno(&_iob[n])
  86. /* translate Unix file handle (0, 1, or 2) to Lattice file handle */
  87. #define FILENO(n) fileno(&_iob[n])
  88. #else
  89. /* Lattice runtime externals */
  90. extern struct UFB _ufbs[];
  91. extern int Enable_Abort;
  92. #define DOSFH(n) (_ufbs[n].ufbfh)
  93. #define FILENO(n) (n)
  94. #endif
  95.  
  96. /* Amiga Kermit externals (defined in ckitio.c) */
  97. extern struct Process *CurProc;
  98. extern struct CommandLineInterface *CurCLI;
  99.  
  100. /*
  101.  * CreatePacket -- allocate and set up a AmigaDOS packet
  102.  */
  103. struct DosPacket *CreatePacket()
  104. {
  105.     register struct StandardPacket *sp;
  106.  
  107.     sp = (struct StandardPacket *)
  108.          AllocMem((LONG)sizeof(struct StandardPacket),
  109.               (LONG)MEMF_PUBLIC|MEMF_CLEAR);
  110.     if (sp == NULL) return(NULL);
  111.     sp->sp_Pkt.dp_Link = &sp->sp_Msg;
  112.     sp->sp_Msg.mn_Node.ln_Type = NT_MESSAGE;
  113.     sp->sp_Msg.mn_Node.ln_Name = (char *)&sp->sp_Pkt;
  114.     sp->sp_Msg.mn_Length = sizeof(struct DosPacket);
  115.     return(&sp->sp_Pkt);
  116. }
  117.  
  118. /*
  119.  * DeletePacket -- deallocate packet from CreatePacket()
  120.  */
  121. VOID DeletePacket(pkt)
  122. struct DosPacket *pkt;
  123. {
  124.     FreeMem(pkt->dp_Link, (LONG)sizeof(struct StandardPacket));
  125. }
  126.  
  127. /*
  128.  * system(cmd) -- execute a command
  129.  *    provides no sensible return value
  130.  */
  131. system(cmd)
  132. char *cmd;
  133. {
  134.     BPTR fh;
  135.  
  136.     fflush(stdout);
  137.     if (cmd == NULL || *cmd == '\0')
  138.     {
  139.         fh = Open("CON:0/0/640/200/Kermit CLI", (LONG)MODE_NEWFILE);
  140.         if (fh)
  141.         {
  142.             Execute("", fh, (BPTR)NULL);
  143.  
  144.             /* fix 'endcli' bug */
  145.             ((struct FileHandle *)BADDR(fh))->fh_Pos = 0;
  146.  
  147.             Close(fh);
  148.         }
  149.     }
  150.     else
  151.         Execute(cmd, (BPTR)NULL, DOSFH(1));
  152. }
  153.  
  154. /*
  155.  * getcwd -- get current working directory text
  156.  */
  157. char *getcwd(buf, len)
  158. register char *buf;
  159. int len;
  160. {
  161.     register UBYTE *dirname;
  162.  
  163.     if (CurCLI == NULL) return(NULL);
  164.     dirname = (UBYTE *)BADDR(CurCLI->cli_SetName);
  165.     if (len < *dirname + 1) return(NULL);
  166.     strncpy(buf, dirname + 1, *dirname);
  167.     buf[*dirname] = 0;
  168.     return(buf);
  169. }
  170.  
  171. /*
  172.  * update the current directory name in the CLI process structure
  173.  *
  174.  * This version generates the new name from the current name and
  175.  * the specified path, something like the CD command does.
  176.  * A much better version could be written using Parent(), Examine(),
  177.  * and VolInfo to reconstitute a name from a lock, but Parent() doesn't
  178.  * work with RAM: in V1.1.  The current implementation, like the CD
  179.  * command, has difficulty with backing up the directory tree.  For example
  180.  * { chdir("c:"); chdir("/"); } results in a dir name of "c:/".  However,
  181.  * this version shouldn't get as far out of sync as the CD command.  (The
  182.  * same sequence with the CD command puts you in the parent dir of "c:" but
  183.  * with a directory name of "c:".)
  184.  */
  185. static void update_dirname(name)
  186. register char *name;
  187. {
  188.     register UBYTE *dirname;        /* DOS directory name BSTR */
  189.     char buf[100];                /* about same size as DOS */
  190.     register char *tail;
  191.  
  192.     /* locate the DOS copy of the directory name */
  193.     if (CurCLI == NULL) return;
  194.     dirname = (UBYTE *)BADDR(CurCLI->cli_SetName);
  195.  
  196.     /* if the name is anchored (like "DF1:") simply replace the name */
  197.     if (strrchr(name, ':') != NULL)
  198.     {
  199.         *dirname = strlen(name);
  200.         strncpy(&dirname[1], name, *dirname);
  201.         return;
  202.     }
  203.  
  204.     /* name is relative to current directory, copy name to work with */
  205.     strncpy(buf, &dirname[1], *dirname);
  206.     tail = &buf[*dirname];
  207.  
  208.     /* traverse the path in the name */
  209.     while (*name)
  210.     {
  211.         /* go to parent dir? */
  212.         if (*name == '/')
  213.         {    /* remove a component from the directory path */
  214.  
  215.             /* advance past parent slash */
  216.             ++name;
  217.  
  218.             /* if at colon, can't back up */
  219.             if (tail[-1] == ':')
  220.             {
  221.                 *tail++ = '/';
  222.                 continue;
  223.             }
  224.  
  225.             /* if at slash, see if name given */
  226.             if (tail[-1] == '/')
  227.             {
  228.                 /* if no name, can't back up */
  229.                 if (tail[-2] == '/' || tail[-2] == ':')
  230.                 {
  231.                     *tail++ = '/';
  232.                     continue;
  233.                 }
  234.  
  235.                 /* remove trailing slash */
  236.                 --tail;
  237.             }
  238.  
  239.             /* remove remainder of component */
  240.             while (tail[-1] != '/' && tail[-1] != ':')
  241.                 --tail;
  242.         }
  243.         else
  244.         {    /* add component to directory path */
  245.             /* add slash if necessary to separate name */
  246.             if (tail[-1] != ':' && tail[-1] != '/')
  247.                 *tail++ = '/';
  248.  
  249.             /* add component name */
  250.             while (*name && *name != '/')
  251.                 *tail++ = *name++;
  252.  
  253.             /* add trailing slash if specified */
  254.             if (*name == '/')
  255.                 *tail++ = *name++;
  256.         }
  257.     }
  258.  
  259.     /* set BSTR to derived name */
  260.     *dirname = tail - buf;
  261.     strncpy(&dirname[1], buf, *dirname);
  262. }
  263.  
  264. /*
  265.  * change current directory
  266.  */
  267. int chdir(name)
  268. char *name;
  269. {
  270.     BPTR lock;
  271.     BPTR oldlock;
  272.     struct FileInfoBlock *fib;
  273.  
  274.     /* ignore chdir("") */
  275.     if (*name == 0) return(0);
  276.  
  277.     /* try to look at the object */ 
  278.     lock = Lock(name, (LONG)ACCESS_READ);
  279.     if (lock == NULL) return(-1);
  280.  
  281.     /* make sure the file is a directory */
  282.     fib = (struct FileInfoBlock *)malloc(sizeof(*fib));
  283.     if (fib == NULL || !Examine(lock, fib) || fib->fib_DirEntryType <= 0)
  284.     {
  285.         if (fib) free(fib);
  286.         UnLock(lock);
  287.         return(-1);
  288.     }
  289.  
  290.     /* don't need file info any more */
  291.     free(fib);
  292.  
  293.     /* change the current directory */
  294.     oldlock = CurrentDir(lock);
  295.  
  296.     /* update the DOS copy of the directory name */
  297.     update_dirname(name);
  298.  
  299.     /* unlock the previous current directory */
  300.     if (oldlock) UnLock(oldlock);
  301.  
  302.     return(0);
  303. }
  304.  
  305. #ifndef LAT310
  306. /*
  307.  * print an error message with explanation
  308.  * (no explanation currently)
  309.  */
  310. int perror(str)
  311. char *str;
  312. {
  313.     extern int errno;
  314.     LONG oserr = IoErr();
  315.  
  316.     printf("%s: errno=%d, oserr=%ld\n", str, errno, oserr);
  317. }
  318. #endif
  319.  
  320. /*
  321.  * isatty(fd) -- determine if given file is a (virtual) terminal
  322.  *    only works for fd=0, 1, or 2 (stdin, stdout, and stderr resp.)
  323.  */ 
  324. int isatty(fd)
  325. int fd;
  326. {
  327.     return(IsInteractive(DOSFH(fd)) != 0);
  328. }
  329.  
  330. /*
  331.  * readstat -- determine file's read status
  332.  *    returns -3 if file read protected
  333.  *    returns -2 if file is a directory
  334.  *    returns -1 if file doesn't exist
  335.  *    returns file size otherwise
  336.  */
  337. long readstat(name)
  338. char *name;
  339. {
  340.     BPTR lock;
  341.     struct FileInfoBlock *fib;
  342.     long size;
  343.  
  344.     /* locate the file */ 
  345.     if ((lock = Lock(name, (LONG)ACCESS_READ)) == NULL) return(-1);
  346.  
  347.     /* allocate a file info block */
  348.     if ((fib = (struct FileInfoBlock *)malloc(sizeof(*fib))) == NULL)
  349.     {    size = -1; goto exit; }
  350.  
  351.     /* make sure it's not a directory */
  352.     if (!Examine(lock, fib) || fib->fib_DirEntryType >= 0)
  353.     {    size = -2; goto exit; }
  354.  
  355.     /* make sure it's readable */
  356.     if (fib->fib_Protection & FIBF_READ)
  357.     {    size = -3; goto exit; }
  358.  
  359.     size = fib->fib_Size;
  360. exit:
  361.     if (fib) free(fib);
  362.     UnLock(lock);
  363.     return(size);
  364. }
  365.  
  366. /*
  367.  * writestat -- determines file's write status
  368.  *    returns 0 if file should be writable, -1 otherwise
  369.  *
  370.  * The following logic is used to determine if a file is writable:
  371.  *    1.  If the file exists, it must not be write or delete protected.
  372.  *        (Delete protection subsumes write protection for overwriting.)
  373.  *    2.  The parent directory must not be write protected ???
  374.  *    3.  The volume that the parent directory resides on must be
  375.  *        validated and not write protected.
  376.  */
  377. int writestat(name)
  378. register char *name;
  379. {
  380.     register char *p;
  381.     char *lastslash;
  382.     char path[100];
  383.     BPTR lock;
  384.     struct FileInfoBlock *fib;
  385.     struct InfoData *id = NULL;
  386.     int rc = -1;
  387.  
  388.     /* allocate a FileInfoBlock */
  389.     fib = (struct FileInfoBlock *)malloc(sizeof(*fib));
  390.     if (fib == NULL) goto exit;
  391.  
  392.     /* see if the file exists */
  393.     if ((lock = Lock(name, (LONG)ACCESS_READ)) != NULL)
  394.     {
  395.         /* make sure it's not a directory or write protected */
  396.         if (!Examine(lock, fib) ||
  397.             fib->fib_DirEntryType >= 0 ||
  398.             (fib->fib_Protection & (FIBF_WRITE|FIBF_DELETE)) )
  399.             goto exit;
  400.         UnLock(lock);
  401.     }
  402.  
  403.     /* strip path from name */
  404.     lastslash = NULL;
  405.     for (p = path; *p = *name; ++p, ++name)
  406.         if (*p == '/' || *p == ':')
  407.             lastslash = p;
  408.  
  409.     /* make sure the path exists */
  410.     if (lastslash)
  411.     {
  412.         lastslash[1] = 0;
  413.         lock = Lock(path, (LONG)ACCESS_READ);
  414.     }
  415.     else
  416.         lock = (CurProc->pr_CurrentDir)
  417.                ? DupLock(CurProc->pr_CurrentDir)
  418.                : NULL;
  419.  
  420.     /* make sure it is a directory that is not write protected */
  421.     if (lock == NULL || !Examine(lock, fib) ||
  422.         fib->fib_DirEntryType <= 0 ||
  423.         (fib->fib_Protection & FIBF_WRITE) )
  424.         goto exit;
  425.  
  426.     /* get device info */    
  427.     if ((id = (struct InfoData *)malloc(sizeof(*id))) == NULL) goto exit;
  428.  
  429.     /* make sure the disk is writeable */
  430.     if (Info(lock, id) && id->id_DiskState == ID_VALIDATED)
  431.         rc = 0;
  432.  
  433.     /* clean up */
  434. exit:
  435.     if (id) free(id);
  436.     if (fib) free(fib);
  437.     if (lock) UnLock(lock);
  438.         return(rc);
  439. }
  440.  
  441. /*
  442.  * pipeopen -- execute command to read output like a file
  443.  */
  444. #define PIPEHOLDER "RAM:Pipe-Holder"
  445. FILE *pipeopen(command)
  446. char *command;
  447. {
  448.     BPTR fh;
  449.  
  450.     /* create holder file */
  451.     fh = Open(PIPEHOLDER, (LONG)MODE_NEWFILE);
  452.     if (fh == NULL) return(0);
  453.  
  454.     /* execute the command */
  455.     Execute(command, (BPTR)NULL, fh);
  456.  
  457.     /* close the holder file */
  458.     Close(fh);
  459.  
  460.     /* reopen it for input */
  461.     return(fopen(PIPEHOLDER, "r"));
  462. }
  463.  
  464. /*
  465.  * pipeclose -- clean up after pipe open
  466.  */
  467. pipeclose(f)
  468. FILE *f;
  469. {
  470.     fclose(f);
  471.     DeleteFile(PIPEHOLDER);
  472. }
  473.  
  474. /*
  475.  * existobj -- return true if file system object exists
  476.  */
  477. int existobj(name)
  478. char *name;
  479. {
  480.     BPTR lock;
  481.  
  482.     if (*name == 0) return(CurProc->pr_CurrentDir != NULL);
  483.     if ((lock = Lock(name, (LONG)ACCESS_READ)) == NULL)
  484.         return(0);
  485.     UnLock(lock);
  486.     return(1);
  487. }
  488.  
  489. /* opendir handle structure */
  490. struct DirHandle {
  491.     struct FileInfoBlock fib;
  492.     BPTR lock;
  493. };
  494.  
  495. /*
  496.  * attempt to open a directory, fill in a handle structure
  497.  */
  498. struct DirHandle *opendir(name)
  499. char *name;
  500. {
  501.     BPTR lock;
  502.     struct DirHandle *dh;
  503.  
  504.     /* get lock on name ("" is current dir) */
  505.     lock = (*name != 0)        ? Lock(name, (LONG)ACCESS_READ) :
  506.            (CurProc->pr_CurrentDir) ? DupLock(CurProc->pr_CurrentDir)
  507.                     : NULL;
  508.     if (lock == NULL) return(NULL);
  509.     dh = (struct DirHandle *)malloc(sizeof(*dh));
  510.     if (dh == NULL)
  511.     {
  512.         UnLock(lock);
  513.         return(NULL);
  514.     }
  515.     if (!Examine(lock, &dh->fib) || dh->fib.fib_DirEntryType <= 0)
  516.     {
  517.         UnLock(lock);
  518.         free(dh);
  519.         return(NULL);
  520.     }
  521.     /* pass it into the caller's care */
  522.     dh->lock = lock;
  523.     return(dh);
  524. }
  525.  
  526. /*
  527.  * return name for next entry in dir
  528.  */
  529. char *readdir(dh)
  530. struct DirHandle *dh;
  531. {
  532.     return(ExNext(dh->lock, &dh->fib) ? dh->fib.fib_FileName : NULL);
  533. }
  534.  
  535. /*
  536.  * finish accessing a directory
  537.  */
  538. VOID closedir(dh)
  539. struct DirHandle *dh;
  540. {
  541.     UnLock(dh->lock);
  542.     free(dh);
  543. }
  544.