void rexxyesno(struct RexxMsg *mess)
{
char foo[2],ja,nej,def,*pek;
pek=hittaefter(mess->rm_Args[0]);
if(!pek[0]) {
ja='j'; nej='n'; def=1;
} else {
ja=pek[0];
pek=hittaefter(pek);
if(!pek[0]) {
nej='n'; def=1;
} else {
nej=pek[0];
pek=hittaefter(pek);
if(!pek[0]) def=1;
else def=pek[0]-'0';
}
}
foo[0]=jaellernej(ja,nej,def)+'0';
foo[1]=0;
if(carrierdropped()) {
mess->rm_Result1=100;
return;
}
mess->rm_Result1=0;
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(foo,1)))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
}
LONG rxsupp_null(struct Library *RexxSupportBase, struct RexxMsg *msg, UBYTE **argstring)
{
void *ptr = NULL;
*argstring = CreateArgstring((UBYTE *)&ptr, sizeof(void *));
return 0;
}
void rexxrecbinfile(struct RexxMsg *mess) {
char buf[1024];
struct TransferFiles *tf;
Servermem->action[nodnr] = UPLOAD;
Servermem->varmote[nodnr] = 0;
Servermem->vilkastr[nodnr] = NULL;
if(recbinfile(hittaefter(mess->rm_Args[0]))) strcpy(buf,"0");
else
{
buf[0] = NULL;
for(tf=(struct TransferFiles *)tf_list.mlh_Head;tf->node.mln_Succ;tf=(struct TransferFiles *)tf->node.mln_Succ)
{
strcat(buf,FilePart(tf->Filnamn));
strcat(buf,(char *)" ");
}
buf[strlen(buf)-1] = NULL;
}
while(tf=(struct TransferFiles *)RemHead((struct List *)&tf_list))
FreeMem(tf,sizeof(struct TransferFiles));
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(buf,strlen(buf))))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
}
LONG rxsupp_delay(struct Library *RexxSupportBase, struct RexxMsg *msg, UBYTE **argstring)
{
int pos, len;
char *arg = ARG1(msg);
len = strlen(arg);
if (len == 0)
{
*argstring = NULL;
return ERR10_018;
}
for (pos = 0; pos < len; pos++)
{
if (!isdigit(arg[pos]))
{
*argstring = NULL;
return ERR10_018;
}
}
Delay(atoi(arg));
*argstring = CreateArgstring("0", 1);
return RC_OK;
}
void rxchglatestinfo(struct RexxMsg *mess) {
char *what,retstr[15];
int ammount,retval;
what = hittaefter(mess->rm_Args[0]);
ammount = atoi(hittaefter(what));
switch(what[0]) {
case 'r' : case 'R' :
retval = Statstr.read += ammount;
break;
case 'w' : case 'W' :
retval = Statstr.write += ammount;
break;
case 'd' : case 'D' :
retval = Statstr.dl += ammount;
break;
case 'u' : case 'U' :
retval = Statstr.ul += ammount;
break;
default:
retval = -1;
}
sprintf(retstr,"%d",retval);
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(retstr,strlen(retstr))))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
mess->rm_Result1=0;
}
void whichmeet(struct RexxMsg *mess) {
char buf[5];
sprintf(buf,"%d",mote2);
mess->rm_Result1=0;
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(buf,strlen(buf))))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
}
/**
* Set the result variable.
*
* @param rxmsg the message defining the ARexx context.
* @param string the contents of the result
*/
static void arexx_set_result(struct RexxMsg *rxmsg, CONST_STRPTR string)
{
if (!string) string = "";
if (rxmsg->rm_Action & (1L << RXFB_RESULT))
{
if (rxmsg->rm_Result2) DeleteArgstring((STRPTR)rxmsg->rm_Result2);
rxmsg->rm_Result2 = (LONG)CreateArgstring( string,strlen(string));
}
}
LONG rxsupp_rename(struct Library *RexxSupportBase, struct RexxMsg *msg, UBYTE **argstring)
{
BOOL ok;
ok = Rename(ARG1(msg), ARG2(msg));
*argstring = CreateArgstring(ok ? "1" : "0", 1);
return RC_OK;
}
// Allocate an ARexx message, and set arguments and stem values automatically
struct RexxMsg *LIBFUNC L_BuildRexxMsgEx(
REG(a0, struct MsgPort *port),
REG(a1, UBYTE *extension),
REG(d0, UBYTE *host),
REG(a2, struct TagItem *tags))
{
struct RexxMsg *msg;
struct TagItem *tag,*tstate;
char *varname=0;
// Create message
if (!(msg=L_CreateRexxMsgEx(port,extension,host)))
return 0;
// Go through tags
tstate=tags;
while ((tag=NextTagItem(&tstate)))
{
// Argument string?
if (tag->ti_Tag>=RexxTag_Arg0 &&
tag->ti_Tag<=RexxTag_Arg15)
{
short arg;
// Get argument number
arg=tag->ti_Tag-RexxTag_Arg0;
// Create argument string
msg->rm_Args[arg]=CreateArgstring((CONST STRPTR)tag->ti_Data,strlen((char *)tag->ti_Data)+1);
}
// Variable name?
else
if (tag->ti_Tag==RexxTag_VarName)
{
// Store pointer to variable name
varname=(char *)tag->ti_Data;
}
// Variable value?
else
if (tag->ti_Tag==RexxTag_VarValue)
{
// Got valid name pointer?
if (varname)
{
// Set value
L_SetRexxVarEx(msg,varname,(char *)tag->ti_Data,-1);
varname=0;
}
}
}
// Return message
return msg;
}
void rexxchkbuffer(struct RexxMsg *mess) {
char foo[5];
sprintf(foo,"%d",checkcharbuffer());
mess->rm_Result1=0;
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(foo,strlen(foo))))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
}
int commonsendrexx(int komnr,int hasarg) {
char rexxCmd[1081];
struct RexxMsg *nikrexxmess, *mess;
sendrexxrc = -5;
if(!hasarg) {
sprintf(rexxCmd, "NiKom:rexx/ExtKom%d %d %d", komnr, nodnr, inloggad);
} else {
sprintf(rexxCmd, "NiKom:rexx/ExtKom%d %d %d %s", komnr, nodnr, inloggad, argument);
}
if(!(nikrexxmess = (struct RexxMsg *) CreateRexxMsg(
rexxport, "nik", rexxport->mp_Node.ln_Name))) {
LogEvent(SYSTEM_LOG, ERROR, "Couldn't allocate a RexxMsg.");
return -5;
}
if(!(nikrexxmess->rm_Args[0] =
(STRPTR)CreateArgstring(rexxCmd,strlen(rexxCmd)))) {
DeleteRexxMsg(nikrexxmess);
LogEvent(SYSTEM_LOG, ERROR, "Couldn't allocate a rexx ArgString.");
return -5;
}
nikrexxmess->rm_Action = RXCOMM | RXFB_TOKEN;
if(!SafePutToPort((struct Message *)nikrexxmess, "REXX")) {
LogEvent(SYSTEM_LOG, ERROR, "Can't launch ARexx script, REXX port not found.");
return -5;
}
for(;;) {
mess = (struct RexxMsg *)WaitPort(rexxport);
while(mess = (struct RexxMsg *)GetMsg(rexxport)) {
if(mess->rm_Node.mn_Node.ln_Type == NT_REPLYMSG) {
DeleteArgstring(nikrexxmess->rm_Args[0]);
if(nikrexxmess->rm_Result1) {
LogEvent(SYSTEM_LOG, WARN, "Error return code %d from ARexx script: '%s'",
nikrexxmess->rm_Result1, rexxCmd);
SendString("\r\n\nError executing ARexx script.\r\n\n");
}
DeleteRexxMsg(nikrexxmess);
if(!rxlinecount) {
rxlinecount=TRUE;
radcnt = 0;
}
return sendrexxrc;
}
handleRexxCommand(mess->rm_Args[0], mess);
ReplyMsg((struct Message *)mess);
}
}
if(carrierdropped()) return(-8);
return(sendrexxrc);
}
void rxedit(struct RexxMsg *mess) {
int editret,cnt,len;
char *filnamn,retstr[2];
BPTR fh;
struct EditLine *el;
nu_skrivs=ANNAT;
filnamn=hittaefter(mess->rm_Args[0]);
if(!filnamn[0]) {
mess->rm_Result1=5;
mess->rm_Result2=NULL;
return;
}
/* puttekn("\r\n\n",-1); Detta måste nu fixas i ARexx-programmet
istället */
if((editret=edittext(filnamn))==1) {
mess->rm_Result1=100;
mess->rm_Result2=NULL;
return;
} else if(editret==0) {
if(!(fh=Open(filnamn,MODE_NEWFILE))) {
sprintf(outbuffer,"\r\n\nKunde inte öppna %s för skrivning!\r\n");
puttekn(outbuffer,-1);
mess->rm_Result1=5;
mess->rm_Result2=NULL;
return;
}
cnt=0;
for(el=(struct EditLine *)edit_list.mlh_Head;el->line_node.mln_Succ;el=(struct EditLine *)el->line_node.mln_Succ) {
len=strlen(el->text);
el->text[len]='\n';
if(Write(fh,el->text,len+1)==-1) {
sprintf(outbuffer,"\r\n\nFel vid skrivandet av %s!\r\n",filnamn);
puttekn(outbuffer,-1);
Close(fh);
mess->rm_Result1=5;
mess->rm_Result2=NULL;
return;
}
cnt++;
}
Close(fh);
freeeditlist();
}
mess->rm_Result1=0;
retstr[0]= editret ? '0' : '1';
retstr[1]=0;
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(retstr,1)))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
}
void rexxgetstring(struct RexxMsg *tempmess) {
char *rexxargs1,*rexxargs2;
char defaultstring[257];
int ra1=0,ra2=0;
defaultstring[0] = NULL;
rexxargs1=hittaefter(tempmess->rm_Args[0]);
if(rexxargs1[0])
{
ra2=EKO;
if(!(ra1=atoi(rexxargs1))) ra1=50;
rexxargs2=hittaefter(rexxargs1);
if(rexxargs2[0] && !strncmp(rexxargs2,"NOECHO",6)) ra2=EJEKO;
else
{
if(rexxargs2[0])
{
if(!strncmp(rexxargs2,"STARECHO",8))
ra2 = STAREKO;
else
strcpy(defaultstring,rexxargs2);
}
}
}
else
{
ra1=50;
ra2=EKO;
}
if(defaultstring[0] != NULL)
{
if(getstring(ra2,ra1,defaultstring))
{
tempmess->rm_Result1=100;
tempmess->rm_Result2=NULL;
return;
}
}
else
{
if(getstring(ra2,ra1,NULL)) {
tempmess->rm_Result1=100;
tempmess->rm_Result2=NULL;
return;
}
}
tempmess->rm_Result1=0;
if(tempmess->rm_Action & 1L<<RXFB_RESULT) {
if(!(tempmess->rm_Result2=(long)CreateArgstring(inmat,strlen(inmat))))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
}
void rexxsendstring(struct RexxMsg *mess) {
char *str,ret,retstr[2];
str=hittaefter(mess->rm_Args[0]);
ret=puttekn(str,-1);
if(ret) retstr[0]='1';
else retstr[0]='0';
retstr[1]=0;
mess->rm_Result1=0;
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(retstr,1)))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
}
void rxextratime(struct RexxMsg *mess) {
char buf[10],*arg=hittaefter(mess->rm_Args[0]);
if(!strcmp(arg,"GET")) {
sprintf(buf,"%d",extratime);
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(buf,strlen(buf))))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
} else {
extratime=atoi(arg);
mess->rm_Result2=NULL;
}
mess->rm_Result1=0;
}
void senastread(struct RexxMsg *tempmess) {
char tempstr[20];
tempmess->rm_Result1=0;
if(senast_text_typ!=BREV && senast_text_typ!=TEXT) {
tempmess->rm_Result2=NULL;
return;
}
if(senast_text_typ==BREV) sprintf(tempstr,"B %d %d",senast_brev_anv,senast_brev_nr);
else sprintf(tempstr,"T %d %d",senast_text_nr,senast_text_mote);
if(tempmess->rm_Action & 1L<<RXFB_RESULT) {
if(!(tempmess->rm_Result2=(long)CreateArgstring(tempstr,strlen(tempstr))))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
}
void rxgettime(struct RexxMsg *mess) {
long tidgrans,tidkvar,tid;
char buf[10];
if(Servermem->cfg.maxtid[Servermem->inne[nodnr].status]) {
time(&tid);
tidgrans=60*(Servermem->cfg.maxtid[Servermem->inne[nodnr].status])+extratime;
tidkvar=tidgrans-(tid-logintime);
} else tidkvar=0;
sprintf(buf,"%d",tidkvar);
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(buf,strlen(buf))))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
mess->rm_Result1=0;
}
void rexxgettekn(struct RexxMsg *mess) {
UBYTE foo[2];
foo[0]=gettekn();
foo[1]=0;
if(foo[0]==10 && carrierdropped()) {
mess->rm_Result1=100;
mess->rm_Result2=NULL;
} else {
mess->rm_Result1=0;
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(foo,1)))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
}
}
/*
* This function will send a string to ARexx...
*
* The default host port will be that of your task...
*
* If you set StringFile to TRUE, it will set that bit for the message...
*
* Returns TRUE if it send the message, FALSE if it did not...
*/
short SendARexxMsg(AREXXCONTEXT RexxContext,char *RString,
short StringFile)
{
register struct MsgPort *RexxPort;
register struct RexxMsg *rmsg;
register short flag=FALSE;
if (RexxContext) if (RString)
{
if (rmsg=CreateRexxMsg(RexxContext->ARexxPort,
RexxContext->Extension,
RexxContext->PortName))
{
rmsg->rm_Action=RXCOMM | (StringFile ?
(1L << RXFB_STRING):0);
if (rmsg->rm_Args[0]=CreateArgstring(RString,
(LONG)strlen(RString)))
{
/*
* We need to find the RexxPort and this needs
* to be done in a Forbid()
*/
Forbid();
if (RexxPort=FindPort(RXSDIR))
{
/*
* We found the port, so put the
* message to ARexx...
*/
PutMsg(RexxPort,(struct Message *)rmsg);
RexxContext->Outstanding+=1;
flag=TRUE;
}
else
{
/*
* No port, so clean up...
*/
DeleteArgstring(rmsg->rm_Args[0]);
DeleteRexxMsg(rmsg);
}
Permit();
}
else DeleteRexxMsg(rmsg);
}
}
return(flag);
}
void rxgetnumber(struct RexxMsg *mess)
{
int minvarde, maxvarde, defaultvarde, returvarde;
char retstr[15];
char *pek1 = NULL, *pek2 = NULL, *pek3 = NULL;
pek1=hittaefter(mess->rm_Args[0]);
if(pek1)
pek2=hittaefter(pek1);
if(pek2)
pek3=hittaefter(pek2);
if(pek1[0] && !pek2[0])
{
defaultvarde = atoi(pek1);
returvarde = getnumber(0, 0, &defaultvarde);
}
else if(pek1[0] && pek2[0])
{
minvarde = atoi(pek1);
maxvarde = atoi(pek2);
if(pek3[0])
{
defaultvarde = atoi(pek3);
returvarde = getnumber(&minvarde, &maxvarde, &defaultvarde);
}
else
{
returvarde = getnumber(&minvarde, &maxvarde, 0);
}
}
else
{
returvarde = getnumber(0, 0, 0);
}
sprintf(retstr,"%d",returvarde);
if(mess->rm_Action & 1L<<RXFB_RESULT)
{
if(!(mess->rm_Result2=(long)CreateArgstring(retstr,strlen(retstr))))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
mess->rm_Result1=0;
}
void rexxsendbinfile(struct RexxMsg *mess) {
char buf[257],*pek,filtemp[257],tmp[3];
int i,quote;
struct TransferFiles *tf;
mess->rm_Result1=0;
pek=hittaefter(mess->rm_Args[0]);
NewList((struct List *)&tf_list);
while(pek[0]!=NULL && mess->rm_Result1!=20) {
filtemp[0]=NULL;
i=0; quote=0;
while(pek[0]==' ' && pek[0]!=NULL) pek++;
if(pek[0]=='"') { quote=1; pek++; }
if(!pek[0]) break;
while(((pek[0]!='"' && quote) || (pek[0]!=' ' && !quote)) && pek[0]!=NULL) {
filtemp[i++]=pek[0];
pek++;
}
if(pek[0]=='"') pek++;
filtemp[i]=NULL;
if(!(tf=(struct TransferFiles *)AllocMem(sizeof(struct TransferFiles),MEMF_CLEAR))) {
mess->rm_Result1=20;
mess->rm_Result2=NULL;
} else {
strcpy(tf->path,filtemp);
tf->filpek=NULL;
AddTail((struct List *)&tf_list,(struct Node *)tf);
}
}
sendbinfile();
buf[0] = NULL;
for(tf=(struct TransferFiles *)tf_list.mlh_Head;tf->node.mln_Succ;tf=(struct TransferFiles *)tf->node.mln_Succ)
{
sprintf(tmp,"%d ",tf->sucess);
strcat(buf,tmp);
}
buf[strlen(buf)-1] = NULL;
while(tf=(struct TransferFiles *)RemHead((struct List *)&tf_list))
FreeMem(tf,sizeof(struct TransferFiles));
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(buf,strlen(buf))))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
}
void rexx_handle_events (void)
{
struct RexxMsg *msg;
while ((msg = (struct RexxMsg*)GetMsg (ARexxPort))) {
if (!(msg->rm_Action & RXCOMM)) {
write_log ("Unknown action '%08X' recieved!\n",
msg->rm_Action);
continue;
}
msg->rm_Result1 = process_cmd (msg->rm_Args[0]);
msg->rm_Result2 = 0;
if (msg->rm_Action & RXFF_RESULT) {
int len = strlen (RESULT); /* holger: trick for powerup */
msg->rm_Result2 = (LONG)CreateArgstring (RESULT,len);
}
ReplyMsg ((void*)msg);
}
}
/*************
* FUNCTION: ReplyRexxCommand
* VERSION: 0.1 08.03.1995
* DESCRIPTION: Sends a RexxMsg back to the rexx server, can include
* result codes
* INPUT: RexxMessage
* Primary primary result
* Secondary secondary result
* Result result string
* OUTPUT: none
* HISTORY: DATE NAME COMMENT
* 08.03.95 ah first release
*************/
VOID ReplyRexxCommand(struct RexxMsg *RexxMessage,LONG Primary,LONG Secondary,STRPTR Result)
{
/* Valid pointer given? */
if(RexxMessage && RexxMessage->rm_Node.mn_Node.ln_Type == NT_MESSAGE)
{
/* No secondary result and results wanted? */
if(Secondary == NULL && (RexxMessage->rm_Action & RXFF_RESULT))
{
/* Build result string... */
if(Result)
Secondary = (LONG)CreateArgstring((char *)Result,strlen((char *)Result));
}
/* Set both results... */
RexxMessage->rm_Result1 = Primary;
RexxMessage->rm_Result2 = Secondary;
/* ...and reply the message. */
ReplyMsg((struct Message *)RexxMessage);
}
}
/*************
* FUNCTION: SendRexxCommand
* VERSION: 0.1 08.03.1995
* DESCRIPTION: Sends a command to the rexx server, requires pointers
* to the MsgPort of the calling Host and the command string.
* File extension and host name are optional and may be
* NULL
* INPUT: HostPort
* CommandString
* FileExtension
* HostName
* OUTPUT: TRUE: sucessfull, else false
* HISTORY: DATE NAME COMMENT
* 08.03.95 ah first release
*************/
LONG SendRexxCommand(struct MsgPort *HostPort,STRPTR CommandString,STRPTR FileExtension,STRPTR HostName)
{
struct MsgPort *RexxPort = (struct MsgPort *)FindPort(RXSDIR);
struct RexxMsg *HostMessage;
/* Valid pointers given? */
if(CommandString && HostPort && RexxPort)
{
/* No special host name given? Take the MsgPort name. */
if(!HostName)
HostName = (STRPTR)HostPort->mp_Node.ln_Name;
/* No file name extension? Take the default. */
if(!FileExtension)
FileExtension = (STRPTR)"rexx";
/* Create the message. */
HostMessage = CreateRexxMsg((struct MsgPort *)HostPort,(char *)FileExtension,(char *)HostName);
if(HostMessage)
{
/* Add the command. */
HostMessage->rm_Args[0] = CreateArgstring((char *)CommandString,strlen((char *)CommandString));
if(HostMessage->rm_Args[0])
{
/* This is a command, not a function. */
HostMessage->rm_Action = RXCOMM;
/* Release it... */
PutMsg(RexxPort,(struct Message*)HostMessage);
/* Successful action. */
return(TRUE);
}
DeleteRexxMsg(HostMessage);
}
}
return(FALSE);
}
void rxsendrawfile(struct RexxMsg *mess) {
BPTR fh;
int antal;
char retstr[2] = "x", *filnamn = hittaefter(mess->rm_Args[0]);
if(!(fh = Open(filnamn,MODE_OLDFILE))) {
sprintf(outbuffer,"\n\n\rKan inte öppna filen %s\n\r",filnamn);
puttekn(outbuffer,-1);
retstr[0]='0';
} else {
while(antal = Read(fh,outbuffer,99)) {
if(antal == -1) break;
outbuffer[antal] = 0;
putstring(outbuffer,-1,0);
}
Close(fh);
retstr[0] = '1';
}
if(mess->rm_Action & 1L<<RXFB_RESULT) {
if(!(mess->rm_Result2=(long)CreateArgstring(retstr,1)))
puttekn("\r\n\nKunde inte allokera en Argstring!\r\n\n",-1);
}
mess->rm_Result1=0;
}
static BOOL localSendRexxMsg(struct MsgPort *reply, STRPTR rxport, STRPTR rxcmd)
{
BOOL success = FALSE;
struct RexxMsg *rxmsg;
ENTER();
if((rxmsg = CreateRexxMsg(reply, NULL, NULL)) != NULL)
{
rxmsg->rm_Action = RXCOMM|RXFF_STRING|RXFF_NOIO;
if((rxmsg->rm_Args[0] = (IPTR)CreateArgstring(rxcmd,strlen(rxcmd))) != 0)
{
struct MsgPort *port;
Forbid();
if((port = FindPort(rxport)) != NULL)
{
PutMsg(port, (struct Message *)rxmsg);
success = TRUE;
}
Permit();
if(success == FALSE)
DeleteArgstring((APTR)rxmsg->rm_Args[0]);
}
if(success == FALSE)
DeleteRexxMsg(rxmsg);
}
RETURN(success);
return success;
}
/*
* Use this to return a ARexx message...
*
* If you wish to return something, it must be in the RString.
* If you wish to return an Error, it must be in the Error.
* If there is an error, the RString is ignored.
*/
void ReplyARexxMsg(AREXXCONTEXT RexxContext,struct RexxMsg *rmsg,
char *RString,LONG Error)
{
if (RexxContext) if (rmsg) if (rmsg!=REXX_RETURN_ERROR)
{
rmsg->rm_Result2=0;
if (!(rmsg->rm_Result1=Error))
{
/*
* if you did not have an error we return the string
*/
if (rmsg->rm_Action & (1L << RXFB_RESULT)) if (RString)
{
rmsg->rm_Result2=(LONG)CreateArgstring(RString,
(LONG)strlen(RString));
}
}
/*
* Reply the message to ARexx...
*/
ReplyMsg((struct Message *)rmsg);
}
}
/* send a message to an AREXX port.
*/
static int ADDRESS (const char *hostname, const char *cmd)
{
struct MsgPort *RexxPort,
*ReplyPort;
struct RexxMsg *HostMsg,
*answer;
int result = RC_WARN;
if (!stricmp (hostname, "COMMAND"))
return SystemTagList(cmd,NULL);
if ((RexxPort = (void *)FindPort (hostname))) {
if ((ReplyPort = (void *)CreateMsgPort ())) {
if ((HostMsg = CreateRexxMsg (ReplyPort, NULL, hostname))) {
unsigned int len = strlen (cmd); /* holger: trick for powerup */
if ((HostMsg->rm_Args[0] = CreateArgstring ((char *)cmd, len))) {
HostMsg->rm_Action = RXCOMM | RXFF_RESULT;
PutMsg (RexxPort, (void*)HostMsg);
WaitPort (ReplyPort);
while (!(answer = (void *)GetMsg (ReplyPort)));
result = answer->rm_Result1;
if (result == RC_OK) {
if (answer->rm_Result2) {
strncpy (RESULT,(char *)answer->rm_Result2, RESULT_LEN);
DeleteArgstring ((char *)answer->rm_Result2);
} else RESULT[0] = '\0';
}
DeleteArgstring (HostMsg->rm_Args[0]);
} else strcpy (RESULT, "Can't create argstring!");
DeleteRexxMsg (HostMsg);
} else strcpy (RESULT, "Can't create rexx message!");
DeleteMsgPort (ReplyPort);
} else strcpy (RESULT, "Can't alloc reply port!");
} else sprintf (RESULT, "Port \"%s\" not found!", hostname);
return result;
}
int commonsendrexx(int komnr,int hasarg) {
char macronamn[1081],*rexxargs1;
int going = TRUE;
struct RexxMsg *nikrexxmess,*tempmess;
struct MsgPort *rexxmastport;
sendrexxrc=-5;
if(!hasarg)
sprintf(macronamn,"NiKom:rexx/ExtKom%d %d %d",komnr,nodnr,inloggad);
else
sprintf(macronamn,"NiKom:rexx/ExtKom%d %d %d %s",komnr,nodnr,inloggad,argument);
if(!(nikrexxmess=(struct RexxMsg *)CreateRexxMsg(rexxport,"nik",rexxport->mp_Node.ln_Name))) {
puttekn("\r\n\nKunde inte allokera ett RexxMsg!\r\n\n",-1);
return(-5);
}
if(!(nikrexxmess->rm_Args[0]=(STRPTR)CreateArgstring(macronamn,strlen(macronamn)))) {
DeleteRexxMsg(nikrexxmess);
puttekn("\r\n\nKunde inte allokera en ArgString1\r\n\n",-1);
return(-5);
}
nikrexxmess->rm_Action=RXCOMM | RXFB_TOKEN;
Forbid();
if(!(rexxmastport=(struct MsgPort *)FindPort("REXX"))) {
Permit();
puttekn("\r\n\nRexxMast är inte igång!\r\n\n",-1);
return(-5);
}
PutMsg(rexxmastport,(struct Message *)nikrexxmess);
Permit();
while(going) {
tempmess = (struct RexxMsg *)WaitPort(rexxport);
if(!tempmess) printf("*** Something's fishy around here... ***\n");
while(tempmess=(struct RexxMsg *)GetMsg(rexxport)) {
if(tempmess->rm_Node.mn_Node.ln_Type==NT_REPLYMSG) {
DeleteArgstring(nikrexxmess->rm_Args[0]);
if(nikrexxmess->rm_Result1) {
sprintf(outbuffer,"\r\n\nRexx: Return-code %d\r\n\n",nikrexxmess->rm_Result1);
puttekn(outbuffer,-1);
}
DeleteRexxMsg(nikrexxmess);
if(!rxlinecount)
{
rxlinecount=TRUE;
radcnt = 0;
}
return(sendrexxrc);
}
if(!strnicmp(tempmess->rm_Args[0],"sendstring",10)) rexxsendstring(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"sendserstring",13)) rexxsendserstring(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"getstring",9)) rexxgetstring(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"sendtextfile",12)) sendfile(rexxargs1=hittaefter(tempmess->rm_Args[0]));
else if(!strnicmp(tempmess->rm_Args[0],"showtext",8)) rxvisatext(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"showletter",10)) rexxvisabrev(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"lasttext",8)) senastread(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"nikcommand",10)) kommando(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"niknrcommand",12)) niknrcommand(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"edit",4)) rxedit(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"sendbinfile",11)) rexxsendbinfile(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"recbinfile",10)) rexxrecbinfile(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"getchar",7)) rexxgettekn(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"chkbuffer",9)) rexxchkbuffer(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"yesno",5)) rexxyesno(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"whicharea",9)) whicharea(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"whichmeet",9)) whichmeet(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"logout",6)) rxlogout(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"runfifo",7)) rxrunfifo(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"runrawfifo",10)) rxrunrawfifo(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"entermeet",9)) rxentermeet(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"setlinecount",12)) rxsetlinecount(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"extratime",9)) rxextratime(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"gettime",7)) rxgettime(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"sendchar",8)) rxsendchar(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"sendserchar",11)) rxsendserchar(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"setnodeaction",13)) rxsetnodeaction(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"sendrawfile",11)) rxsendrawfile(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"changelatestinfo",16)) rxchglatestinfo(tempmess);
else if(!strnicmp(tempmess->rm_Args[0],"getnumber",9)) rxgetnumber(tempmess);
else {
sprintf(outbuffer,"\r\n\nKan inte hantera: %s\r\n",tempmess->rm_Args[0]);
puttekn(outbuffer,-1);
tempmess->rm_Result1=5;
tempmess->rm_Result2=NULL;
}
ReplyMsg((struct Message *)tempmess);
}
}
if(carrierdropped()) return(-8);
return(sendrexxrc);
}
LONG SendRexxCommand(CONST_STRPTR port, CONST_STRPTR Cmd, STRPTR Result, LONG ResultSize)
{
struct MsgPort *RexxPort;
struct MsgPort *ReplyPort = &((struct Process *)FindTask(NULL))->pr_MsgPort;
struct Library *RexxSysBase;
#ifdef __AMIGAOS4__
struct RexxSysIFace *IRexxSys;
#else
void *IRexxSys;
#endif
int rc;
*Result = '\0';
if ((RexxSysBase = OpenLibraryInterface("rexxsyslib.library", 36L, &IRexxSys)))
{
Forbid();
if ((RexxPort = FindPort(port)))
{
struct RexxMsg *rexxMsg, *Answer;
if ((rexxMsg = CreateRexxMsg(ReplyPort, NULL, NULL)))
{
if ((rexxMsg->rm_Args[0] = (STRPTR)CreateArgstring(Cmd, strlen(Cmd))))
{
rexxMsg->rm_Action = RXCOMM | RXFF_RESULT;
PutMsg(RexxPort, &rexxMsg->rm_Node);
Permit();
do
{
WaitPort(ReplyPort);
Answer = (struct RexxMsg *)GetMsg(ReplyPort);
} while (Answer == NULL);
if ((rc = (Answer->rm_Result1 == RETURN_OK)))
{
if (Answer->rm_Result2)
{
strncpy(Result, (STRPTR)Answer->rm_Result2, ResultSize);
DeleteArgstring((STRPTR)Answer->rm_Result2);
}
}
DeleteArgstring((STRPTR)ARG0(Answer));
DeleteRexxMsg(Answer);
CloseLibraryInterface(RexxSysBase,IRexxSys);
return rc;
} else
{
DeleteRexxMsg(rexxMsg);
}
}
}
Permit();
CloseLibraryInterface(RexxSysBase,IRexxSys);
}
return 0;
}
