Return to uaeexe.c CVS log

Up to [UNIX Amiga Emulator] / uae / src

Annotation of uae/src/uaeexe.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *  uaeexe.c - UAE remote cli
                      3:  *
                      4:  *  (c) 1997 by Samuel Devulder
                      5:  */
                      6: 
                      7: #include "sysconfig.h"
                      8: #include "sysdeps.h"
                      9: 
                     10: #include "config.h"
                     11: #include "options.h"
                     12: #include "uae.h"
                     13: #include "memory.h"
                     14: #include "custom.h"
                     15: #include "readcpu.h"
                     16: #include "newcpu.h"
                     17: #include "autoconf.h"
                     18: #include "uaeexe.h"
                     19: 
                     20: static struct uae_xcmd *first = NULL;
                     21: static struct uae_xcmd *last  = NULL;
                     22: static char running = 0;
                     23: static uae_u32 uaeexe_server(void);
                     24: 
                     25: /*
                     26:  * Install the server
                     27:  */
                     28: void uaeexe_install(void)
                     29: {
                     30:     uaecptr loop;
                     31: 
                     32:     loop = here ();
                     33:     org(UAEEXE_ORG);
                     34:     calltrap (deftrap (uaeexe_server));
                     35:     dw(RTS);
                     36:     org(loop);
                     37: }
                     38: 
                     39: /*
                     40:  * Send command to the remote cli.
                     41:  *
                     42:  * To use this, just call uaeexe("command") and the command will be
                     43:  * executed by the remote cli (provided you've started it in the
                     44:  * s:user-startup for example). Be sure to add "run" if you want
                     45:  * to launch the command asynchronously. Please note also that the
                     46:  * remote cli works better if you've got the fifo-handler installed.
                     47:  */
                     48: int uaeexe(char *cmd)
                     49: {
                     50:     struct uae_xcmd *nw;
                     51: 
                     52:     if (!running)
                     53:        goto NORUN;
                     54: 
                     55:     nw = (struct uae_xcmd *)malloc (sizeof *nw);
                     56:     if (!nw)
                     57:        goto NOMEM;
                     58:     nw->cmd = (char *)malloc (strlen (cmd) + 1);
                     59:     if (!nw->cmd) {
                     60:        free (nw);
                     61:        goto NOMEM;
                     62:     }
                     63: 
                     64:     strcpy (nw->cmd, cmd);
                     65:     nw->prev = last;
                     66:     nw->next = NULL;
                     67: 
                     68:     if(!first) first  = nw;
                     69:     if(last) {
                     70:            last->next = nw;
                     71:            last       = nw;
                     72:     } else last       = nw;
                     73: 
                     74:     return UAEEXE_OK;
                     75:   NOMEM:
                     76:     return UAEEXE_NOMEM;
                     77:   NORUN:
                     78:     write_log("Remote cli is not running.\n");
                     79:     return UAEEXE_NOTRUNNING;
                     80: }
                     81: 
                     82: /*
                     83:  * returns next command to be executed
                     84:  */
                     85: static char *get_cmd(void)
                     86: {
                     87:     struct uae_xcmd *cmd;
                     88:     char *s;
                     89: 
                     90:     if(!first) return NULL;
                     91:     s = first->cmd; 
                     92:     cmd = first; first = first->next;
                     93:     if(!first) last = NULL;
                     94:     free(cmd);
                     95:     return s;
                     96: }
                     97: 
                     98: /*
                     99:  * helper function
                    100:  */
                    101: #define ARG(x) (get_long (m68k_areg (regs, 7) + 4*(x+1)))
                    102: static uae_u32 uaeexe_server(void)
                    103: {
                    104:     int len;
                    105:     char *cmd;
                    106:     char *dst;
                    107: 
                    108:     if(ARG(0) && !running) {
                    109:         running = 1;
                    110:         write_log("Remote CLI started.\n");
                    111:     }
                    112: 
                    113:     cmd = get_cmd(); if(!cmd) return 0;
                    114:     if(!ARG(0)) {running = 0;return 0;}
                    115: 
                    116:     dst = (char *)get_real_address(ARG(0));
                    117:     len = ARG(1);
                    118:     strncpy(dst,cmd,len);
                    119:     printf("Sending '%s' to remote cli\n",cmd); /**/
                    120:     free(cmd);
                    121:     return ARG(0);
                    122: }
                    123: 
                    124: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.