home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / walnut-creek-CDROM / DEMON / ZMSOURCE.ARC / ZMP16.LBR / ZMP.CY / ZMP.CY
Text File  |  1993-12-18  |  10KB  |  408 lines
  1. /*************************************************************************/
  2. /*                                     */
  3. /*        ZMP - A ZMODEM Program for CP/M                 */
  4. /*                                     */
  5. /*    Developed from H. Maney's Heath-specific HMODEM             */
  6. /*        by Ron Murray and Lindsay Allen                 */
  7. /*                                     */
  8. /*************************************************************************/
  9. /*                                     */
  10. /* See separate file zmp-hist.doc for details of modification history     */
  11. /*                                     */
  12. /*************************************************************************/
  13. /*                                                                       */
  14. /*  This source code may be distributed freely without restriction       */
  15. /*  for the express purpose of promoting the use of the ZMODEM           */
  16. /*  file transfer protocol.  Programmers are requested to include        */
  17. /*  credit (in the source code) to the developers for any code           */
  18. /*  incorporated from this program.                                      */
  19. /*                                                                       */
  20. /*  This program was inspired by lmodem.c written by David D. Clark      */
  21. /*  in the November 83 issue of Byte.  Although it bears no resemblance  */
  22. /*  to David's program, I can credit him with sparking my interest in    */
  23. /*  modem programs written in C.                                         */
  24. /*                                 - Hal Maney                           */
  25. /*                                                                       */
  26. /*************************************************************************/
  27. /*                                                                       */
  28. /*  The following files comprise ZMP:                     */
  29. /*                                                                       */
  30. /*    zmp.h            the header file                                  */
  31. /*    zmp.c             the main program Pt.1                            */
  32. /*    zmp2.c            The main program Pt.2                 */
  33. /*    zmterm.c        Terminal overlay                 */
  34. /*    zmterm2.c            "                     */
  35. /*    zmconfig.c        Configuration overlay                 */
  36. /*    zminit.c        Initialisation overlay                 */
  37. /*    zmxfer.c +>>    File transfer overlay (with the next 3)         */
  38. /*    zmxfer2.c        Chuck Forsberg's sz.c modified for cp/m          */
  39. /*    zmxfer3.c                "                 */
  40. /*    zmxfer4.c         Chuck Forsberg's rz.c modified for cp/m          */
  41. /*    zmxfer5.c                "                 */
  42. /*    zzm.c        Chuck Forsberg's zm.c modified for cp/m          */
  43. /*    zzm2.c                "                 */
  44. /*    zmovl.mac        Sample user-dependent overlay source         */
  45. /*    zmodem.h          zmodem header file                               */
  46. /*    zmconfig.c        configuration overlay                            */
  47. /*    zconfig.h         configuration overlay header                     */
  48. /*                                                                       */
  49. /*************************************************************************/
  50.  
  51. #define  MAIN
  52.  
  53. #include "zmp.h"
  54.  
  55. #ifdef   AZTEC_C
  56. #include "libc.h"
  57. #else
  58. #include <stdio.h>
  59. #endif
  60.  
  61. #ifdef HI_TECH_C
  62. #include <signal.h>
  63. #endif
  64.  
  65. char *malloc();
  66.  
  67. main()
  68. {
  69.     static int termcmd;
  70.     short *p, *getvars();
  71.  
  72. #ifdef HI_TECH_C
  73.     signal(SIGINT,SIG_IGN);        /* Ignore control-c's */
  74. #endif
  75.  
  76. #ifdef AZTEC_C
  77.     settop(MAXOVLY);        /* Set top of memory */
  78. #endif
  79.  
  80.     Invokdrive = bdos(GETCUR,NULL) + 'A';
  81.     Invokuser = getuid();
  82.     p = getvars();
  83.     Overdrive = *p++;    /* get du: for overlays etc */
  84.     Overuser = *p++;
  85.  
  86.     if (!Overdrive) {    /* use Invokdrive if zero */
  87.         Overdrive = Invokdrive;
  88.         Overuser = Invokuser;
  89.     }
  90.     strcpy(Pathname,Initovly);
  91.     addu(Pathname,Overdrive,Overuser);
  92.     ovloader(Pathname);        /* Do initialisation */
  93.     Message[0] = '\0';        /* no messages */
  94.  
  95.    /************** the main loop ************************/
  96.  
  97.    while (TRUE) {
  98.     printf("\nWait..");
  99.     strcpy(Pathname,Termovly);
  100.     addu(Pathname,Overdrive,Overuser);
  101.     termcmd = ovloader(Pathname);    /* Load and execute the TERM overlay */
  102.     printf("\nLoading overlay...\n");
  103.     switch(termcmd) {
  104.  
  105.     case RECEIVE:
  106.     case SEND:
  107.         strcpy(Pathname,Xferovly);
  108.         addu(Pathname,Overdrive,Overuser);
  109.         ovloader(Pathname,termcmd);
  110.         putchar('\007');    /* tell user it's finished */
  111.         mswait(300);
  112.         putchar('\007');
  113.         break;
  114.  
  115. #ifdef HOSTON
  116.             case HOST:
  117.                keep(Lastlog);    /* This will need modifying */
  118.                QuitFlag = FALSE;
  119.                Inhost = TRUE;    /* if host mode is enabled */
  120.                while (!QuitFlag)
  121.                   dohost();
  122.                Inhost = FALSE;
  123.                flush();
  124.                cls();
  125.                startcapture();
  126.                break;
  127. #endif
  128.  
  129.     case CONFIG:
  130.         strcpy(Pathname,Configovly);
  131.         addu(Pathname,Overdrive,Overuser);
  132.         ovloader(Pathname);
  133.         break;
  134.  
  135.     case USER:
  136.         addu(Pathname, Overdrive, Overuser);    /* Pathname has name */
  137.         ovloader(Pathname);    /* execute it */
  138.         break;
  139.  
  140.     default:
  141.         printf("Fatal error in %s.OVR\n",Termovly);
  142.         exit(0);
  143.         break;
  144.             }                            /* end of switch*/
  145.    }    /* end of while */
  146. }  /* end of main */
  147.  
  148.  
  149. char *
  150. grabmem(sizep)         /* grab all available memory */
  151. unsigned *sizep;       /* place to store how much we got */
  152. {
  153.     static char *p,*q;
  154.     static unsigned size;
  155.  
  156.     q = malloc(BUFSIZ + 10);    /* Make sure we have enough for disk i/o */
  157.     size = BUFSTART + 10;        /* allow some overrun */
  158.     while ((p = malloc(size)) == (char *) MEMORY_FULL) {
  159.         size -= 1024;
  160.         if ((size - 10) < 2048) {
  161.             size = 0;
  162.             break;
  163.         }
  164.     }
  165.  
  166. #ifdef DEBUG
  167.     printf("\ngrabmem = %x %d\n",p,size);
  168. #endif
  169.  
  170.     *sizep = size - 10;        /* don't mention the overrun */
  171.     free(q);            /* Free disk i/o space */
  172.     return p;
  173. }
  174.  
  175. getpathname(string)
  176. char *string;
  177. {
  178.     static int c;
  179.  
  180.     printf("\nEnter file name%s:  ",string);
  181.     if (!(c=getline(Pathname,PATHLEN)))
  182.         return 0;
  183.     return linetolist();
  184. }
  185.  
  186. linetolist()   /* expand and put Pathnames in Pathlist, return count */
  187. {
  188.     static char *p;
  189.     static int count;
  190.     static char **tempalloc;
  191.  
  192. #ifdef DEBUG
  193.     static int i;
  194. #endif
  195.  
  196.     tempalloc = Pathlist = (char **) malloc(510);
  197.     if (allocerror(tempalloc))
  198.         return 0;
  199.  
  200. #ifdef   DEBUG
  201.     printf("Pathlist = %x\n",Pathlist);
  202. #endif
  203.  
  204.     count = 0;
  205.     Pathlist[count++] = Pathname;
  206.     for (p=Pathname; *p; p++) {         /* break up into substrings */
  207.         if (*p == ' ') {
  208.             *p = '\0';
  209.             while (*++p == ' ');         /* dump extra spaces */
  210.             Pathlist[count++] = p;
  211.         }
  212.     }
  213.  
  214. #ifdef   DEBUG
  215.     printf("\nbefore command\n");
  216.     for (i=0; i < count; i++)
  217.         printf("%d %s\n",i,Pathlist[i]);
  218. #endif
  219.  
  220.     command(&count,&Pathlist);
  221.  
  222. #ifdef   DEBUG
  223.     printf("\nafter command\n");
  224.     for (i=0; i < count; i++)
  225.         printf("%d %s\n",i,Pathlist[i]);
  226. #endif
  227.  
  228.     free(tempalloc);
  229.     return count;
  230. }
  231.  
  232. freepath(n)
  233. int n;
  234. {
  235.     if (n) {
  236.         while (n)
  237.             free(Pathlist[--n]);
  238.         free(Pathlist);
  239.     }
  240. }
  241.  
  242. reset(drive,user)
  243. unsigned drive;
  244. int user;
  245. {
  246.     drive = toupper(drive);
  247.     if (isalpha(drive) && drive <= Maxdrive && user >= 0 && user <= 15) {
  248.         Currdrive = drive;
  249.         bdos(RESET,NULL);
  250.         bdos(SELDSK,(Currdrive-'A')&0xff);
  251.         Curruser = user;
  252.         setuid(user);
  253.     }
  254. }
  255.  
  256. addu(filename,drive,user)
  257. char *filename;
  258. int drive,user;
  259. {
  260.     if (!isin(filename,":") && user >= 0 && user <= 15) {
  261.         strcpy(Buf,filename);
  262.         filename[0] = (char)drive;
  263.         sprintf(filename+1,"%d",user);
  264.         sprintf((user < 10) ? filename+2 : filename+3,":%s",Buf);
  265.     }
  266. }
  267.  
  268. deldrive(filename)
  269. char *filename;
  270. {
  271.     char *i, *index();
  272.  
  273.     if ((i = index(filename,':')) != (char *) NULL)
  274.         strcpy(filename,i+1);
  275. }
  276.  
  277. dio()          /* direct console port inp when bdos is too slow */
  278. {
  279.     return bios(2 + 1);
  280. }
  281.  
  282. chrin()        /* Direct console input which repeats character */
  283. {
  284.     return bdos(CONIN);
  285. }
  286.  
  287. getch()
  288. {
  289.    return bdos(DIRCTIO,INPUT);
  290. }
  291.  
  292. flush()
  293. {
  294.     while(bdos(GCS,NULL))          /*clear type-ahead buffer*/
  295.         bdos(CONIN,NULL);
  296.     getch();           /*and anything else*/
  297. }
  298.  
  299. purgeline()
  300. {
  301.     while (minprdy())              /*while there are characters...*/
  302.         mcharinp();             /*gobble them*/
  303. }
  304.  
  305. openerror(chan,fname,test)
  306. int chan,test;
  307. char *fname;
  308. {
  309.     int result;
  310.  
  311.     if (result = (chan == test)) {
  312.         printf("\n\nERROR - Cannot open %s\n\n",fname);
  313.         wait(3);
  314.     }
  315.     return result;
  316. }
  317.  
  318. wrerror(fname)
  319. char *fname;
  320. {
  321.     printf("\n\nERROR - Cannot write to %s\n\n",fname);
  322.     wait(3);
  323. }
  324.  
  325. allocerror(p)
  326. char *p;
  327. {
  328.     static int status;
  329.  
  330.     if (status = (p == (char *) MEMORY_FULL))
  331.         perror("Memory allocation failure");
  332.     return status;   
  333. }
  334.  
  335. perror(string)
  336. char *string;
  337. {
  338.     printf("\007\nERROR - %s\n\n",string);
  339.     wait(3);
  340. }
  341.  
  342. kbwait(seconds)
  343. unsigned seconds;
  344. {
  345.     static unsigned t;
  346.     static int c;
  347.  
  348.     t = seconds * 10;
  349.     while(!(c=getch()) && (t--))
  350.     MSWAIT(100);
  351.     return ((c & 0xff) == ESC);
  352. }
  353.  
  354. readstr(p,t)
  355. char *p;
  356. int t;
  357. {
  358.     static int c;
  359.  
  360.     t *= 10;                /* convert to tenths */
  361.     flush();
  362.     while (((c=readline(t)) != CR) && (c != TIMEOUT)) {
  363.         if (c != LF)
  364.             *p++ = c;
  365.     }
  366.     *p = 0;
  367.     return c;
  368. }
  369.  
  370. isin(received,expected)
  371. char *received, *expected;
  372. {  
  373.     return (stindex(received,expected) != -1);
  374. }
  375.  
  376. report(row,string)
  377. int row;
  378. char *string;
  379. {
  380.     LOCATE(row,RPTPOS);
  381.     printf(string);
  382. }
  383.  
  384. mstrout(string,echo)
  385. char *string;
  386. int echo;             /* echo flag means send to screen also */
  387. {
  388.     static char c;
  389.  
  390.     while (c = *string++) {
  391.         if ((c == RET) || (c == '\n')) {      /* RET is a ! */
  392.             mcharout(CR);
  393.             mcharout(LF);
  394.             c = '\n';
  395.         }
  396.         else if (c == WAITASEC)
  397.             wait(1);
  398.         else
  399.             mcharout(c);
  400.         if (echo)
  401.             putchar(c);
  402.     }
  403.     MSWAIT(100);      /* wait 100 ms */
  404.     purgeline();
  405. }
  406.  
  407. /*            End of MAIN module File 1            */
  408.