linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'conclean' into rhel7

Browse Source 
Conflicts:
	SCinter.c
	telnet.c
This commit is contained in:
koennecke
2017-04-03 11:44:35 +02:00
parent c61036c6cc 6c1059b307
commit c780ad9cae
23 changed files with 306 additions and 930 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
SCinter.c
View File

@ -334,14 +334,14 @@ int InterpExecute(SicsInterp * self, SConnection * pCon, char *pText)
self->eOut = eValue;
Tcl_ResetResult((Tcl_Interp *) self->pTcl);
MacroPush(pCon);
pCon->conStatus = 0;
SCSetConStatus(pCon,0);
old = StatisticsBegin(pCommand->stat);
iRet = pCommand->OFunc(pCon, self, pCommand->pData, argc, argv);
StatisticsEnd(old);
/* If a task is registered with the dev exec then conStatus is HWBusy */
if (pCon->conStatus != HWBusy) {
if (SCGetConStatus(pCon) != HWBusy) {
/*comCon = SCGetContext(pCon); */
if (0 != strcmp("contextdo", pCon->deviceID))
if (0 != strcmp("contextdo", SCGetDeviceID(pCon)))
SCWrite(pCon, "", eFinish);
}
MacroPop();

2
anticollider.c
View File

@ -60,7 +60,7 @@ static int ReplacementCheckStatus(void *pData, SConnection * pCon)
myCollider->isDirty = 0;
StartDevice(pServ->pExecutor,
"anticollider", myCollider->pDes, myCollider,
pCon,pCon->runLevel, 77.77);
pCon,SCGetRunLevel(pCon), 77.77);
return HWIdle;
} else {
return HWIdle;

338
conman.c
View File

@ -45,6 +45,11 @@
substantially revised for asynchronous I/O
Mark Koennecke, January 2009
Removed old cruft including SCStore. Added accessor functions to make the
connection object more private
Mark Koennecke, October 2016
-----------------------------------------------------------------------------*/
#include "fortify.h"
#include <stdlib.h>
@ -115,14 +120,6 @@ static long lastIdent = 0;
/*------------- sending connection (prevent double write when listening) ----*/
static SConnection *sendingConnection = NULL;
static int sendingSockHandle = 0;
/*------------- storing connection and context for later use ----*/
struct SCStore {
SConnection *pCon;
long ident;
int inMacro;
long macroStack;
commandContext cc;
};
/*
* This will return the value of a SICS int variable called "sicsdebug"
@ -168,11 +165,6 @@ static void FreeConnection(SConnection * pCon)
free(pCon);
}
/*------------------------------------------------------------------------*/
void KillFreeConnections()
{
}
/*---------------------------------------------------------------------------*/
SConnection *GetSendingConnection(void)
{
@ -550,47 +542,6 @@ static int HasNL(char *buffer)
#define TXT 0
#define LF 1
int TelnetWrite(mkChannel * pSock, char *pBuffer)
{
char *pStart = NULL, *pPtr;
int iCount, iState;
int iRet = 1;
pStart = pBuffer;
pPtr = pStart;
iState = TXT;
iCount = 0;
while (*pPtr != '\0') {
switch (iState) {
case TXT:
if ((*pPtr == '\r') || (*pPtr == '\n')) {
iState = LF;
iRet = NETWrite(pSock, pStart, iCount);
iRet = NETWrite(pSock, "\r\n", 2);
iCount = 0;
} else {
iCount++;
}
break;
case LF:
if ((*pPtr != '\r') && (*pPtr != '\n')) {
pStart = pPtr;
iCount = 1;
iState = TXT;
} else {
/* do nothing */
}
break;
}
pPtr++;
}
if (iCount > 0) {
iRet = NETWrite(pSock, pStart, iCount);
iRet = NETWrite(pSock, "\r\n", 2);
}
return iRet;
}
/*-----------------------------------------------------------*/
int TelnetWriteANET(int sockHandle, char *pBuffer)
{
@ -2331,117 +2282,6 @@ int SCActive(SConnection * self)
}
return 0;
}
/*--------------------------------------------------------------------------*/
SCStore *SCSave(SConnection * pCon, SCStore * oldStore)
{
commandContext cc;
if (oldStore == NULL) {
oldStore = calloc(1, sizeof(*oldStore));
assert(oldStore);
}
oldStore->pCon = pCon;
if (pCon) {
oldStore->ident = pCon->ident;
oldStore->inMacro = pCon->iMacro;
oldStore->cc = SCGetContext(pCon);
oldStore->macroStack = 0;
}
return oldStore;
}
/*--------------------------------------------------------------------------*/
SConnection *SCLoad(SCStore * conStore)
{
SConnection *pCon = NULL;
commandContext old;
if (conStore) {
pCon = conStore->pCon;
}
if (pCon) {
if (conStore->ident != pCon->ident) {
conStore->pCon = NULL; /* connection is dead */
pCon = NULL;
}
}
if (pCon) {
return pCon;
}
return pServ->dummyCon;
}
/*--------------------------------------------------------------------------*/
SConnection *SCStorePush(SCStore * conStore)
{
SConnection *pCon;
pCon = SCLoad(conStore);
/* push macro flag on stack */
conStore->macroStack <<= 1;
conStore->macroStack |= (pCon->iMacro != 0);
SCsetMacro(pCon, conStore->inMacro);
SCPushContext2(pCon, conStore->cc);
return pCon;
}
/*--------------------------------------------------------------------------*/
void SCStorePop(SCStore * conStore)
{
SConnection *pCon;
pCon = SCLoad(conStore);
SCPopContext(pCon);
/* pop macro flag from stack
SCsetMacro(pCon,conStore->macroStack);
*/
SCsetMacro(pCon, (conStore->macroStack & 1));
conStore->macroStack >>= 1;
}
/*--------------------------------------------------------------------------*/
int SCStoreConnected(SCStore * conStore)
{
return (conStore &&
conStore->pCon && conStore->pCon->ident == conStore->ident);
}
/*--------------------------------------------------------------------------*/
void SCStoreFree(SCStore * conStore)
{
free(conStore);
}
/* --------------------------------------------------------------------------*/
long SCTagContext(SConnection * self, char *tagName)
{
commandContext a;
if (NULL == self)
return -1;
a = SCGetContext(self);
strlcpy(a.deviceID, tagName, SCDEVIDLEN);
/*
SCGetContext will already have advanced the stack pointer to the
last position
*/
LLDnodeDataTo(self->contextStack, &a);
return 1;
}
/* --------------------------------------------------------------------------*/
long SCAdvanceContext(SConnection * self, char *tagName)
{
if (NULL == self)
return -1;
self->iCmdCtr++;
if (999999 < self->iCmdCtr) {
self->iCmdCtr = 0;
}
return SCPushContext(self, self->iCmdCtr, tagName);
}
/*------------------------------------------------------------------------*/
int SCVerifyConnection(SConnection * self)
{
@ -2501,3 +2341,171 @@ int SCPopContext(SConnection * pCon)
}
return 1;
}
/*--------------------------------------------------------*/
int SCGetRunLevel(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return pCon->runLevel;
}
/*--------------------------------------------------------*/
long SCGetIdent(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return pCon->ident;
}
/*--------------------------------------------------------*/
int SCGetSicsError(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return pCon->sicsError;
}
/*--------------------------------------------------------*/
int SCGetTransID(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return pCon->transID;
}
/*--------------------------------------------------------*/
int SCGetProtocolID(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return pCon->iProtocolID;
}
/*--------------------------------------------------------*/
int SCGetSockHandle(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return pCon->sockHandle;
}
/*--------------------------------------------------------*/
int SCGetConStatus(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return pCon->conStatus;
}
/*--------------------------------------------------------*/
char *SCGetDeviceID(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return pCon->deviceID;
}
/*-------------------------------------------------------*/
int SCGetEnd(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return pCon->iEnd;
}
/*-------------------------------------------------------*/
void SCSetConStatus(SConnection *pCon, int conStatus)
{
if (!VerifyConnection(pCon)) {
return;
}
pCon->conStatus = conStatus;
}
/*-------------------------------------------------------*/
void SCSetEventType(SConnection *pCon, int eventType)
{
if (!VerifyConnection(pCon)) {
return;
}
pCon->conEventType = eventType;
}
/*-------------------------------------------------------*/
void SCSetSicsError(SConnection *pCon, int sicsError)
{
if (!VerifyConnection(pCon)) {
return;
}
pCon->sicsError = sicsError;
}
/*-------------------------------------------------------*/
void SCSetProtocolID(SConnection *pCon, int id)
{
if (!VerifyConnection(pCon)) {
return;
}
pCon->iProtocolID = id;
}
/*--------------------------------------------------------*/
void SCCostaLock(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return;
}
CostaLock(pCon->pStack);
}
/*---------------------------------------------------------*/
void SCCostaUnLock(SConnection *pCon){
if (!VerifyConnection(pCon)) {
return;
}
CostaUnlock(pCon->pStack);
}
/*---------------------------------------------------------*/
int SCCostaLocked(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return CostaLocked(pCon->pStack);
}
/*----------------------------------------------------------*/
int SCCostaTop(SConnection *pCon, char *command)
{
if (!VerifyConnection(pCon)) {
return 0;
}
return CostaTop(pCon->pStack, command);
}
/*----------------------------------------------------------*/
void SCSetGrab(SConnection *pCon, int iGrab)
{
if (!VerifyConnection(pCon)) {
return;
}
pCon->iGrab = iGrab;
}
/*------------------------------------------------------------*/
void SCSetEnd(SConnection *pCon, int val)
{
if (!VerifyConnection(pCon)) {
return;
}
pCon->iEnd = val;
}
/*------------------------------------------------------------*/
void SCSetTelnet(SConnection *pCon, int val)
{
if (!VerifyConnection(pCon)) {
return;
}
pCon->iTelnet = val;
}
/*------------------------------------------------------------*/
void SCClose(SConnection *pCon)
{
if (!VerifyConnection(pCon)) {
return;
}
ANETclose(pCon->sockHandle);
pCon->iEnd = 1;
}

46
conman.h
View File

@ -85,6 +85,7 @@ SConnection *SCfindMaster(SConnection * pCon);
int SCisConnected(SConnection * pCon);
int VerifyConnection(SConnection * pCon);
int SCVerifyConnection(SConnection * self);
void SCClose(SConnection *pCon);
/*------------------------------- tasking --------------------------------*/
int SCTaskFunction(void *pCon);
void SCSignalFunction(void *pCon, int iSignal, void *pSigData);
@ -139,6 +140,23 @@ int SCMatchRights(SConnection * pCon, int iCode);
int SCGetOutClass(SConnection * self);
int SCGetGrab(SConnection * pCon);
int SCActive(SConnection * pCon);
int SCGetRunLevel(SConnection *pCon);
long SCGetIdent(SConnection *pCon);
int SCGetSicsError(SConnection *pCon);
int SCGetTransID(SConnection *pCon);
int SCGetProtocolID(SConnection *pCon);
int SCGetSockHandle(SConnection *pCon);
int SCGetConStatus(SConnection *pCon);
char *SCGetDeviceID(SConnection *pCon);
int SCGetEnd(SConnection *pCon);
/************************* connection parameter change **********************/
void SCSetConStatus(SConnection *pCon, int conStatus);
void SCSetEventType(SConnection *pCon, int eventType);
void SCSetSicsError(SConnection *pCon, int sicsError);
void SCSetProtocolID(SConnection *pCon, int proID);
void SCSetGrab(SConnection *pCon, int iGrab);
void SCSetEnd(SConnection *pCon, int val);
void SCSetTelnet(SConnection *pCon, int val);
/* **************************** Invocation ******************************** */
int SCInvoke(SConnection * self, SicsInterp * pInter, char *pCommand);
@ -165,28 +183,6 @@ int SCPushContext(SConnection * pCon, int ID, char *deviceID);
int SCPushContext2(SConnection * pCon, commandContext cc);
int SCPopContext(SConnection * pCon);
commandContext SCGetContext(SConnection * pCon);
/******************************** Store ************************************/
typedef struct SCStore SCStore;
SCStore *SCSave(SConnection * pCon, SCStore * oldStore);
/* save a connection and its context for later use. */
SConnection *SCLoad(SCStore * conStore);
/* check con and return SConnection if still valid or a dummy connection otherwise. */
SConnection *SCStorePush(SCStore * conStore);
/* load connection and push stored context. Must be paired with an SCStorePop command */
void SCStorePop(SCStore * conStore);
/* pop context */
int SCStoreConnected(SCStore * conStore);
/* check if a stored connection is not closed */
void SCStoreFree(SCStore * conStore);
/* free an SCStore */
void KillFreeConnections(void);
/************************* CallBack *********************************** */
int SCRegister(SConnection * pCon, SicsInterp * pSics,
void *pInter, long lID);
@ -202,4 +198,10 @@ int SCUnregisterID(SConnection * pCon, long ID);
* returns -1 if no ID can be found.
*/
long SCgetCallbackID(SConnection * pCon, void *pData);
/*************************** command stack handling **********************/
void SCCostaLock(SConnection *pCon);
void SCCostaUnLock(SConnection *pCon);
int SCCostaLocked(SConnection *pCon);
int SCCostaTop(SConnection *pCon, char *command);
#endif

4
devexec.c
View File

@ -256,7 +256,7 @@ int StartDevice(pExeList self, char *name, pObjectDescriptor pDes,
/* may we? */
if (self->pOwner != NULL) {
if (pCon->ident != self->pOwner->ident) {
if (SCGetIdent(pCon) != SCGetIdent(self->pOwner)) {
/* this hack helps on rita2, when using the sendsics script
which opens a client for every command */
if (overwriteOwner < 0) {
@ -329,7 +329,7 @@ int StartDevice(pExeList self, char *name, pObjectDescriptor pDes,
DevExecSignal,
NULL, self,TASK_PRIO_HIGH);
}
pCon->conStatus = HWBusy;
SCSetConStatus(pCon,HWBusy);
return 1;
} else {
snprintf(pBueffel,131, "ERROR: cannot start device %s", name);

4
evcontroller.c
View File

@ -835,7 +835,7 @@ int EVCDrive(pEVControl self, SConnection * pCon, float fVal)
/* start executing */
iRet = StartDevice(GetExecutor(), self->pName, self->pDes,
self, pCon, pCon->runLevel, fVal);
self, pCon, SCGetRunLevel(pCon), fVal);
if (!iRet) {
snprintf(pBueffel,255, "ERROR: Failure to start %s", self->pName);
SCWrite(pCon, pBueffel, eError);
@ -1022,7 +1022,7 @@ static int EVCallBack(int iEvent, void *pEventData, void *pUserData)
}
if (iEvent == VALUECHANGE && pCon != NULL) {
pCon->conEventType = POSITION;
SCSetEventType(pCon,POSITION);
SCWrite(pCon, pBuf, eEvent);
return 1;
}

4
exebuf.c
View File

@ -304,7 +304,7 @@ int exeBufProcess(pExeBuf self, SicsInterp * pSics,
Log(INFO,"com","%s:batch:%s", ConID(pCon), cmd);
status = Tcl_Eval(pTcl, cmd);
if (status != TCL_OK) {
if (pCon->sicsError == 0) {
if (SCGetSicsError(pCon) == 0) {
/*
Tcl Error
*/
@ -314,7 +314,7 @@ int exeBufProcess(pExeBuf self, SicsInterp * pSics,
}
} else {
SCWrite(pCon, pTcl->result, eError);
pCon->sicsError = 0;
SCSetSicsError(pCon,0);
}
SCWrite(pCon, "ERROR: above error was in block:", eError);
SCWrite(pCon, cmd, eError);

16
interface.c
View File

@ -255,8 +255,8 @@ static int DriveTaskFunc(void *data)
ExeInterest(pServ->pExecutor,taskData->name, "finished with problem");
}
traceSys("drive","DriveTask %s finished with state %d", taskData->name,status);
if(taskData->pCon->transID > 100000) {
SCPrintf(taskData->pCon,eLog,"TASKEND %d", taskData->pCon->transID);
if(SCGetTransID(taskData->pCon) > 100000) {
SCPrintf(taskData->pCon,eLog,"TASKEND %d", SCGetTransID(taskData->pCon));
}
return 0;
}
@ -288,8 +288,8 @@ long StartDriveTask(void *obj, SConnection *pCon, char *name, float fTarget)
ExeInterest(pServ->pExecutor,name,"started");
DevexecLog("START",name);
InvokeNewTarget(pServ->pExecutor,name,fTarget);
if(pCon->transID > 100000) {
SCPrintf(pCon,eLog,"TASKSTART %d", pCon->transID);
if(SCGetTransID(pCon) > 100000) {
SCPrintf(pCon,eLog,"TASKSTART %d", SCGetTransID(pCon));
}
taskData->id = DRIVEID;
@ -415,8 +415,8 @@ static int CountTaskFunc(void *data)
ExeInterest(pServ->pExecutor,taskData->name, "finished with problem");
}
traceSys("count","CountTask %s finished with state %d", taskData->name,status);
if(taskData->pCon->transID > 100000) {
SCPrintf(taskData->pCon,eLog,"TASKEND %d", taskData->pCon->transID);
if(SCGetTransID(taskData->pCon) > 100000) {
SCPrintf(taskData->pCon,eLog,"TASKEND %d", SCGetTransID(taskData->pCon));
}
return 0;
}
@ -443,8 +443,8 @@ long StartCountTask(void *obj, SConnection *pCon, char *name)
}
ExeInterest(pServ->pExecutor,name,"started");
DevexecLog("START",name);
if(pCon->transID > 100000) {
SCPrintf(pCon,eLog,"TASKSTART %d", pCon->transID);
if(SCGetTransID(pCon) > 100000) {
SCPrintf(pCon,eLog,"TASKSTART %d", SCGetTransID(pCon));
}
taskData->id = COUNTID;

4
macro.c
View File

@ -171,7 +171,7 @@ static int SicsUnknownProc(ClientData pData, Tcl_Interp * pInter,
}
/* invoke */
pCon->sicsError = 0;
SCSetSicsError(pCon,0);
iMacro = SCinMacro(pCon);
SCsetMacro(pCon, 1);
old = StatisticsBegin(pCommand->stat);
@ -202,7 +202,7 @@ static int SicsUnknownProc(ClientData pData, Tcl_Interp * pInter,
return TCL_OK;
} else {
Tcl_SetVar(pInter, SICSERROR, "yes", TCL_GLOBAL_ONLY);
pCon->sicsError = 1;
SCSetSicsError(pCon,1);
return TCL_ERROR;
}
}

2
motor.c
View File

@ -1227,7 +1227,7 @@ static int EndScriptCallback(int iEvent, void *pEvent, void *pUser)
pMotInfo pMoti = (pMotInfo) pUserData;
SConnection *pCon = (SConnection*) context;
if (VerifyConnection(pCon) && VerifyConnection(pMoti->pCon)) {
if (pMoti->pCon->ident == pCon->ident)
if (SCGetIdent(pMoti->pCon) == SCGetIdent(pCon))
return 0;
}
return 1;

2
motreg.c
View File

@ -118,7 +118,7 @@ int StartRegMot(pMotReg self, SConnection * pCon, float fValue)
pDriv->SetValue = self->originalSetValue;
ret = StartDevice(pServ->pExecutor, self->motorName,
FindDescriptor(self->motorData),
self->motorData, pCon, pCon->runLevel, fValue);
self->motorData, pCon, SCGetRunLevel(pCon), fValue);
/*
snprintf(pBueffel,sizeof(pBueffel)-1,"anticollision started %s to %f",self->motorName,
fValue);

505
nread.c
View File

@ -194,439 +194,6 @@ int NetReadRemove(pNetRead self, mkChannel * pSock)
}
return 0;
}
/*-------------------------------------------------------------------------*/
static int NetReadAccept(pNetRead self, mkChannel * pSock)
{
mkChannel *pNew = NULL;
char pBuffer[1064];
int iRet;
SConnection *pRes = NULL;
char *pUser = NULL, *pPasswd = NULL;
time_t target;
if (!VerifyChannel(pSock)) {
return 0;
}
/* check for new connection */
pNew = NETAccept(pSock, 0);
if (pNew) {
/* create connection object */
/* TODO
pRes = SCreateConnection(self->pMain->pSics,pNew,3);
*/
if (!pRes) {
Log(ERROR,"sys","%s","Failure to allocate new Connection");
NETClosePort(pNew);
free(pNew);
return 0;
} else {
/* register the connection and create a task for it here */
NetReadRegister(self, pNew, command, pRes);
TaskRegisterN(self->pMain->pTasker, "NetReadAccept",
SCTaskFunction,
SCSignalFunction, SCDeleteConnection, pRes, TASK_PRIO_LOW);
SCSendOK(pRes);
return 1;
}
} else {
return 0;
}
}
/*--------------------------------------------------------------------------*/
#define COLLECT 0
#define SKIPTERM 1
/*------------------------------------------------------------------------*/
static int NetReadRead(pNetRead self, pNetItem pItem)
{
char *pPtr, *pEnd, *pBufEnd;
char pBuffer[1024], pMuell[20];
char pBueffel[80];
int i, iInt, iRet, iStat, state;
/* read first */
memset(pBuffer, 0, 1024);
iRet = NETRead(pItem->pCon->pSock, pBuffer, 1022, 0);
if (iRet < 0) { /* EOF */
pItem->pCon->iEnd = 1;
NetReadRemove(self, pItem->pCon->pSock);
return 0;
} else if (iRet == 0) { /* should not happen */
return 1;
}
/* iRet is now the number of bytes read. Now we check for command
interrupts */
pPtr = strstr(pBuffer, "INT1712");
if (pPtr) {
sscanf(pPtr, "%s %d", pMuell, &iInt);
if (SCMatchRights(pItem->pCon, usUser)) {
TaskSignal(self->pMain->pTasker, SICSINT, &iInt);
Log(ERROR,"com","sock%03.3d:INTERRUPT", pItem->pCon->pSock->sockid);
if (iInt == eEndServer) {
TaskStop(self->pMain->pTasker);
}
} else {
SCWrite(pItem->pCon,
"ERROR: insufficient privilege to invoke Interrupt", eError);
}
return 0;
}
/* split into command lines
and put into fifo
*/
pBufEnd = pBuffer + iRet;
pPtr = pBuffer;
pEnd = pBuffer;
state = COLLECT;
while (pEnd < pBufEnd) {
switch (state) {
case COLLECT:
if ((*pEnd != '\r') && (*pEnd != '\n')) {
pEnd++;
} else {
/* there is a string between pPtr and pEnd */
*pEnd = '\0';
/* do we have something in hold ? */
if (strlen(pItem->pHold) > 0) {
strlcat(pItem->pHold, pPtr, 511);
/* DFC locking for protocol zero only */
if (pItem->pCon->iProtocolID == PROTSICS &&
CostaLocked(pItem->pCon->pStack))
iStat = 0;
else
iStat = CostaTop(pItem->pCon->pStack, pItem->pHold);
if (!iStat) {
SCWrite(pItem->pCon, "ERROR: Busy", eError);
}
pItem->pHold[0] = '\0';
} else {
/* no, normal command */
/* DFC locking for protocol zero only */
if (pItem->pCon->iProtocolID == PROTSICS &&
CostaLocked(pItem->pCon->pStack))
iStat = 0;
else
iStat = CostaTop(pItem->pCon->pStack, pPtr);
if (!iStat) {
SCWrite(pItem->pCon, "ERROR: Busy", eError);
}
}
pPtr = pEnd + 1;
pEnd = pPtr;
state = SKIPTERM;
}
break;
case SKIPTERM:
if ((*pEnd != '\r') && (*pEnd != '\n')) {
state = COLLECT;
pPtr = pEnd;
} else {
pEnd++;
pPtr = pEnd;
}
break;
}
}
/* when we are here we may still have an incomplete command pending */
if (pEnd != pPtr && strlen(pPtr) > 0) {
strlcpy(pItem->pHold, pPtr, 511);
}
return 1;
}
/*-------------------------- telnet protocoll code -------------------------*/
static int TelnetAccept(pNetRead self, mkChannel * pSock)
{
mkChannel *pNew = NULL;
char pBuffer[1064];
int iRet;
SConnection *pRes = NULL;
pTelTask pTel = NULL;
if (!VerifyChannel(pSock)) {
return 0;
}
/* check for new connection */
pNew = NETAccept(pSock, 0);
if (pNew) {
/* create connection object */
/* TODO
pRes = SCreateConnection(self->pMain->pSics,pNew,usSpy);
*/
if (!pRes) {
Log(ERROR,"sys","%s","Failure to allocate new Connection");
NETClosePort(pNew);
free(pNew);
return 0;
} else {
/* Create a task object for the telnet connection */
pTel = CreateTelnet(pRes);
if (!pTel) {
Log(ERROR,"sys","%s","Failure to allocate new Telnet Task Object");
SCDeleteConnection(pRes);
return 0;
}
/* register connection and task */
pRes->iTelnet = 1;
NetReadRegister(self, pNew, tcommand, pRes);
TaskRegisterN(self->pMain->pTasker," TelnetAccept",
TelnetTask, TelnetSignal, DeleteTelnet, pTel, TASK_PRIO_LOW);
return 1;
}
} else {
return 0;
}
}
/*------------------------------------------------------------------------
Telnet is fully described in RFC-854. This implementation is very simple.
It just supports the NVT and no options. Implementation is via a state
machine with the state tStatus in the pItem structure. This is necessary
as single characters may be sent by telnet clients.
-------------------------------------------------------------------------*/
/* Telnet codes */
#define SE 240
#define NOP 241
#define DM 242 /* data mark */
#define BRK 243
#define IP 244
#define AO 245
#define AYT 246
#define EC 247
#define EL 248
#define GA 249
#define SB 250
#define WILL 251
#define WONT 252
#define DO 253
#define DONT 254
#define IAC 255
#define EOR 239
/*-----------------------------------------------------------------------*/
static int TelnetReply(pNetItem pItem, char code, char cChar)
{
char pReply[3];
pReply[0] = IAC;
pReply[1] = code;
pReply[2] = cChar;
NETWrite(pItem->pCon->pSock, pReply, 3);
return 1;
}
/*------------------------------------------------------------------------*/
static int TelnetRead(pNetRead self, pNetItem pItem)
{
char pBuffer[1024], pMuell[20], pError[256];
int i, iStat, iInt, iRet;
int cChar;
char *pPtr = NULL;
SConnection *pOwner = NULL;
/* read first */
memset(pBuffer, 0, 1023);
iRet = NETRead(pItem->pCon->pSock, pBuffer, 1022, 0);
if (iRet < 0) { /* EOF */
pItem->pCon->iEnd = 1;
NetReadRemove(self, pItem->pCon->pSock);
return 0;
} else if (iRet == 0) { /* should not happen */
return 1;
}
/* iRet is now the number of bytes read. Now we check for command
interrupts */
pPtr = strstr(pBuffer, "INT1712");
if (pPtr) {
sscanf(pPtr, "%s %d", pMuell, &iInt);
if (SCMatchRights(pItem->pCon, usUser)) {
/* owners may kill own tasks, otherwise manager
privilege is required.
*/
pOwner = GetExeOwner(pServ->pExecutor);
if (pOwner) {
if (pOwner != pItem->pCon) {
if (!SCMatchRights(pItem->pCon, usMugger)) {
SCWrite(pItem->pCon,
"ERROR: Insufficient privilege to stop other people's experiments",
eError);
return 1;
}
}
}
TaskSignal(self->pMain->pTasker, SICSINT, &iInt);
Log(ERROR,"com","%s:interrupt: %d", ConID(pItem->pCon),iInt);
if (iInt == eEndServer) {
TaskStop(self->pMain->pTasker);
}
} else {
SCWrite(pItem->pCon,
"ERROR: insufficient privilege to invoke Interrupt", eError);
}
return 1;
}
/* do telnet analysis of the data buffer */
for (i = 0; i < iRet; i++) {
cChar = (int) pBuffer[i];
#ifdef TELNETDEBUG
if ((cChar > 48) && (cChar < 128)) {
printf("char: %c\n", cChar);
} else {
printf("Control: %d\n", cChar);
}
#endif
/* Telnet status switching */
switch (pItem->tStatus) {
case tData:
switch (cChar) {
case IAC:
pItem->tStatus = tIAC;
break;
case '\r':
case '\n':
/* DFC locking for protocol zero only */
if (pItem->pCon->iProtocolID == PROTSICS &&
CostaLocked(pItem->pCon->pStack))
iStat = 0;
else
iStat = CostaTop(pItem->pCon->pStack, pItem->pHold);
/* printf("%s\n",pItem->pHold); */
if (!iStat) {
SCWrite(pItem->pCon, "ERROR: Busy", eError);
}
memset(pItem->pHold, 0, 511);
pItem->iEOD = 0;
pItem->tStatus = tCR;
break;
case (char) 8: /* backspace */
pItem->iEOD--;
if (pItem->iEOD < 0) {
pItem->iEOD = 0;
}
break;
case (char) 0: /* ignore 0 character sent as end of text */
break;
default:
pItem->pHold[pItem->iEOD] = cChar;
pItem->iEOD++;
break;
} /* end of tData case */
break;
case tCR: /* ignore the second character after a newline.
Telnet gives you two characters for newline
*/
pItem->tStatus = tData;
break;
case tIAC:
switch (cChar) {
case IAC:
pItem->tStatus = tData;
break;
case WILL:
pItem->tStatus = tWill;
break;
case WONT:
pItem->tStatus = tWont;
break;
case DONT:
pItem->tStatus = tDont;
break;
case DO:
pItem->tStatus = tDo;
break;
case EOR:
pItem->tStatus = tData;
break;
case SB:
pItem->tStatus = tSB;
break;
case EC:
pItem->iEOD--;
if (pItem->iEOD < 0) {
pItem->iEOD = 0;
}
pItem->tStatus = tData;
break;
case EL:
memset(pItem->pHold, 0, 511);
pItem->iEOD = 0;
pItem->tStatus = tData;
break;
case IP:
SCSetInterrupt(pItem->pCon, eAbortBatch);
pItem->tStatus = tData;
break;
default:
pItem->tStatus = tData;
break;
} /* end of tIAC */
break;
case tWill: /* we do not do options! */
TelnetReply(pItem, DONT, cChar);
pItem->tStatus = tData;
break;
case tWont: /* we do not do options! A Wont is sent by the client
if it cannot do a option we requested it to have. As
we do not try to force options, this should not happen
*/
pItem->tStatus = tData;
break;
case tDo: /* we do not do options! */
TelnetReply(pItem, WONT, cChar);
pItem->tStatus = tData;
break;
case tDont: /* we do not do options! A Dont is sent by the client
if it cannot do a option we requested it to have. As
we do not try to force options, this should not happen
*/
pItem->tStatus = tData;
break;
case tSB: /* as we do not have options, we cannot have suboption
negotaitions. Something is seriously wrong when
we are here. It is a protocoll error. However, we
ignore it silently. tSB marks the start of the
subnegotiation. The current character must be the
option code we are dealing with.
*/
pItem->tStatus = tSE;
break;
case tSE:
/* now we are in the suboption parameter. Normally data
should be copied to a suboption string buffer here
until SE.
*/
switch (cChar) {
case IAC:
break;
case SE:
pItem->tStatus = tData;
/* suboption interpretation would go here */
break;
default:
/* copy data to suboption buffer */
break;
}
break;
default:
/* There is something wrong here! */
snprintf(pError,sizeof(pError)-1, "ERROR: bad telnet code %d", cChar);
Log(ERROR,"sys","%s",pError);
pItem->tStatus = tData;
break;
}
}
return 1;
}
/*---------------------------------------------------------------------------*/
static int NetReadUDP(pNetRead self, pNetItem pItem)
{
@ -708,13 +275,6 @@ int NetReaderTask(void *pData)
GetCharArray(self->conList));
}
/*
* This costs a surprising amount of CPU-time, in a test 10%!
* This is why it has been commented away
snprintf(num, sizeof num, "%d", conCount);
IFSetOption(pSICSOptions, "ConnectionCount", num);
IFSetOption(pSICSOptions, "ConMask", GetCharArray(self->conList));
*/
/* the select itself */
tmo.tv_usec = self->iReadTimeout;
@ -731,29 +291,6 @@ int NetReaderTask(void *pData)
LLDnodeDataTo(self->iList, &NItem);
if (FD_ISSET(NItem.pSock->sockid, &lMask)) { /* data */
switch (NItem.eType) {
/* lists have been changed after accept, return */
case naccept:
NetReadAccept(self, NItem.pSock);
return 1;
break;
case taccept:
TelnetAccept(self, NItem.pSock);
return 1;
break;
case command:
iStatus = NetReadRead(self, &NItem);
if (iStatus == 0) { /* there was an eof */
/* do not continue, list is messy */
return 1;
}
break;
case tcommand:
iStatus = TelnetRead(self, &NItem);
if (iStatus == 0) { /* there was an eof */
/* do not continue, list is messy */
return 1;
}
break;
case udp:
NetReadUDP(self, &NItem);
break;
@ -1048,6 +585,10 @@ static int testAndInvokeInterrupt(pCommandCBData self, int handle)
}
return 0;
}
/*----------------------------------------------------------------------------------*/
#define COLLECT 0
#define SKIPTERM 1
/*----------------------------------------------------------------------------------*/
static int CommandDataCB(int handle, void *userData)
@ -1067,10 +608,10 @@ static int CommandDataCB(int handle, void *userData)
if (pPtr[i] == '\r' || pPtr[i] == '\n') {
self->state = SKIPTERM;
if (!testAndInvokeInterrupt(self, handle)) {
if (self->pCon->iProtocolID == PROTSICS && CostaLocked(self->pCon->pStack))
if (SCGetProtocolID(self->pCon) == PROTSICS && SCCostaLocked(self->pCon))
status = 0;
else
status = CostaTop(self->pCon->pStack, GetCharArray(self->command));
status = SCCostaTop(self->pCon, GetCharArray(self->command));
if (!status) {
SCWrite(self->pCon, "ERROR: Busy", eError);
}
@ -1114,7 +655,7 @@ static int CommandAcceptCB(int handle, void *userData)
}
usData->pCon = pCon;
usData->state = COLLECT;
snprintf(buffer,sizeof(buffer),"con%ld", pCon->ident);
snprintf(buffer,sizeof(buffer),"con%ld", SCGetIdent(pCon));
TaskRegisterN(pServ->pTasker,
buffer,
SCTaskFunction,
@ -1123,6 +664,30 @@ static int CommandAcceptCB(int handle, void *userData)
SCSendOK(pCon);
return 1;
}
/*------------------------------------------------------------------------
Telnet is fully described in RFC-854. This implementation is very simple.
It just supports the NVT and no options. Implementation is via a state
machine with the state tStatus in the pItem structure. This is necessary
as single characters may be sent by telnet clients.
-------------------------------------------------------------------------*/
/* Telnet codes */
#define SE 240
#define NOP 241
#define DM 242 /* data mark */
#define BRK 243
#define IP 244
#define AO 245
#define AYT 246
#define EC 247
#define EL 248
#define GA 249
#define SB 250
#define WILL 251
#define WONT 252
#define DO 253
#define DONT 254
#define IAC 255
#define EOR 239
/*-----------------------------------------------------------------------*/
static int ANETTelnetReply(int sockHandle, char code, char cChar)
@ -1171,10 +736,10 @@ static int ANETTelnetProcess(int handle, void *usData)
case '\r':
case '\n':
if (!testAndInvokeInterrupt(self, handle)) {
if (self->pCon->iProtocolID == PROTSICS && CostaLocked(self->pCon->pStack))
if (SCGetProtocolID(self->pCon) == PROTSICS && SCCostaLocked(self->pCon))
status = 0;
else
status = CostaTop(self->pCon->pStack, GetCharArray(self->command));
status = SCCostaTop(self->pCon, GetCharArray(self->command));
if (!status) {
SCWrite(self->pCon, "ERROR: Busy", eError);
}
@ -1329,8 +894,8 @@ static int TelnetAcceptCB(int handle, void *userData)
return 0;
}
/* register connection and task */
pCon->iTelnet = 1;
snprintf(buffer,sizeof(buffer),"con%ld", pCon->ident);
SCSetTelnet(pCon,1);
snprintf(buffer,sizeof(buffer),"con%ld", SCGetIdent(pCon));
TaskRegisterN(pServ->pTasker,
buffer,
TelnetTask, TelnetSignal, DeleteTelnet, pTel, TASK_PRIO_LOW);

12
nserver.c
View File

@ -201,17 +201,6 @@ int InitServer(char *file, pServer * pServ)
IFDeleteOptions(pSICSOptions);
return 0;
}
/*
self->pServerPort = NETOpenPort(iPort);
if(!self->pServerPort)
{
printf("Cannot open Server Socket\n");
DeleteInterp(self->pSics);
IFDeleteOptions(pSICSOptions);
return 0;
}
NetReadRegister(pReader, self->pServerPort, naccept, NULL);
*/
NetReadInstallANETPort(pReader, naccept, iPort);
/* the device executor */
@ -361,7 +350,6 @@ void StopServer(pServer self)
*/
killTclDrivable();
KillFreeConnections();
killSICSHipadaba();

33
protocol.c
View File

@ -306,8 +306,8 @@ static int ProtocolSet(SConnection * pCon, Protocol * pPro, char *pProName)
SCSetWriteFunc(pCon, pPro->defaultWriter);
break;
}
pCon->iProtocolID = proID;
pMaster->iProtocolID = proID;
SCSetProtocolID(pCon,proID);
SCSetProtocolID(pMaster,proID);
SCSendOK(pCon);
return 1;
}
@ -322,7 +322,7 @@ int ProtocolGet(SConnection * pCon, void *pData, char *pProName, int len)
}
if (pData == NULL) {
pCon->iProtocolID = 0;
SCSetProtocolID(pCon,0);
return 1;
}
@ -330,12 +330,12 @@ int ProtocolGet(SConnection * pCon, void *pData, char *pProName, int len)
if (0 == pPro->isDefaultSet) {
pPro->defaultWriter = SCGetWriteFunc(pCon);
pPro->isDefaultSet = 1;
pCon->iProtocolID = 0;
SCSetProtocolID(pCon,0);
}
strlcpy(pProName, pPro->pProList[pCon->iProtocolID], len);
strlcpy(pProName, pPro->pProList[SCGetProtocolID(pCon)], len);
return 1;
#if 0
Index = pCon->iProtocolID;
Index = SCGetProtocolID(pCon);
/* check list of protocols for valid name */
switch (Index) {
@ -448,7 +448,7 @@ static int InitDefaultProtocol(SConnection * pCon, Protocol * pPro)
if (0 == pPro->isDefaultSet) {
pPro->defaultWriter = SCGetWriteFunc(pCon);
pPro->isDefaultSet = 1;
pCon->iProtocolID = PROTSICS;
SCSetProtocolID(pCon,PROTSICS);
}
return pPro->isDefaultSet;
}
@ -498,7 +498,7 @@ struct json_object *mkJSON_Object(SConnection * pCon, char *pBuffer,
}
/* field 1: connID */
json_object_object_add(msg_json, "con",
json_object_new_int(pCon->ident));
json_object_new_int(SCGetIdent(pCon)));
/* field 2: taskID */
json_object_object_add(msg_json, "trans", json_object_new_int(taskID));
/* deviceID */
@ -565,11 +565,7 @@ int SCWriteJSON_String(SConnection * pCon, char *pBuffer, int iOut)
return 1;
/* log it for any case */
if (pCon->pSock) {
iRet = pCon->pSock->sockid;
} else {
iRet = 0;
}
iRet = SCGetSockHandle(pCon);
/* write to commandlog if user or manager privilege */
if (SCGetRights(pCon) <= usUser && !SCinMacro(pCon)) {
@ -627,13 +623,13 @@ char *GetProtocolName(SConnection * pCon)
InitDefaultProtocol(pCon, pPro);
/* check list of protocols for valid name */
switch (pCon->iProtocolID) {
switch (SCGetProtocolID(pCon)) {
case PROTSICS: /* default = psi_sics */
case PROTNORM: /* normal (connection start default) */
case PROTCODE: /* outcodes */
case PROTJSON: /* json */
case PROTACT: /* act */
return strdup(pPro->pProList[pCon->iProtocolID]);
return strdup(pPro->pProList[SCGetProtocolID(pCon)]);
break;
default:
return strdup("invalid");
@ -644,17 +640,14 @@ char *GetProtocolName(SConnection * pCon)
/*----------------------------------*/
int GetProtocolID(SConnection * pCon)
{
if (NULL != pCon) {
return pCon->iProtocolID;
}
return -1;
return SCGetProtocolID(pCon);
}
/*---------------------------------------------------------------------------*/
writeFunc GetProtocolWriteFunc(SConnection * pCon)
{
if (pCon != NULL) {
switch (pCon->iProtocolID) {
switch (SCGetProtocolID(pCon)) {
case PROTCODE: /* outcodes */
return SCWriteWithOutcode;
break;

2
proxy.c
View File

@ -294,7 +294,7 @@ static hdbCallbackReturn ProxyCallback(pHdb node, void *userData,
GetHdbProperty(node, "proxy", proxyDev, 80);
status = StartDevice(pServ->pExecutor, proxyDev,
self->pDes, self, pCon,
pCon->runLevel, (float) set->v->v.doubleValue);
SCGetRunLevel(pCon), (float) set->v->v.doubleValue);
if (status == 1) {
return hdbContinue;
} else {

8
scan.c
View File

@ -1308,7 +1308,7 @@ static int ScanUUInterest(int iEvent, void *pEventData, void *pUser)
assert(self);
assert(pCon);
/*
printf("ScanUUInterest called for pCon = %p handle %d\n", pCon, pCon->sockHandle);
printf("ScanUUInterest called for pCon = %p handle %d\n", pCon, SCGetSockHandle(pCon));
*/
if (!SCisConnected(pCon)) {
return -1;
@ -1812,7 +1812,7 @@ int ScanWrapper(SConnection * pCon, SicsInterp * pSics, void *pData,
/*-------- interest */
else if (strcmp(argv[1], "interest") == 0) {
/*
printf("Registering scan callbacks on handle %d\n", pCon->sockHandle);
printf("Registering scan callbacks on handle %d\n", SCGetSockHandle(pCon));
*/
lID = RegisterCallback(self->pCall, SCANSTART, ScanInterest,
SCCopyConnection(pCon), SCDeleteConnection);
@ -1826,7 +1826,7 @@ int ScanWrapper(SConnection * pCon, SicsInterp * pSics, void *pData,
/*-------- interest */
else if (strcmp(argv[1], "dyninterest") == 0) {
/*
printf("Registering scanDyn callbacks on handle %d\n", pCon->sockHandle);
printf("Registering scanDyn callbacks on handle %d\n", SCGetSockHandle(pCon));
*/
lID = RegisterCallback(self->pCall, SCANSTART, ScanDynInterest,
SCCopyConnection(pCon), SCDeleteConnection);
@ -1841,7 +1841,7 @@ int ScanWrapper(SConnection * pCon, SicsInterp * pSics, void *pData,
else if (strcmp(argv[1], "uuinterest") == 0) {
/*
printf("Registering scanUU callbacks on handle %d, con = %p\n",
conSave->sockHandle, conSave);
SCGetSockHandle(conSave), conSave);
*/
lID = RegisterCallback(self->pCall, SCANSTART, ScanUUInterest,
SCCopyConnection(pCon), SCDeleteConnection);

8
selector.c
View File

@ -614,13 +614,13 @@ int MonoRun(pSicsSelector self, SConnection * pCon, float fWaveLength)
/* start each motor in turn */
iRet = StartDevice(GetExecutor(), self->pTheta->name,
self->pTheta->pDescriptor,
self->pTheta, pCon, pCon->runLevel, sNeu.fTheta);
self->pTheta, pCon, SCGetRunLevel(pCon), sNeu.fTheta);
if (!iRet) {
return 0;
}
iRet = StartDevice(GetExecutor(), self->pTwoTheta->name,
self->pTwoTheta->pDescriptor,
self->pTwoTheta, pCon, pCon->runLevel, sNeu.fTwoTheta);
self->pTwoTheta, pCon, SCGetRunLevel(pCon), sNeu.fTwoTheta);
if (!iRet) {
return 0;
}
@ -630,7 +630,7 @@ int MonoRun(pSicsSelector self, SConnection * pCon, float fWaveLength)
if (self->pBend1) {
iRet = StartDevice(GetExecutor(), self->pBend1->name,
self->pBend1->pDescriptor,
self->pBend1, pCon, pCon->runLevel, sNeu.fVert);
self->pBend1, pCon, SCGetRunLevel(pCon), sNeu.fVert);
if (!iRet) {
return 0;
}
@ -639,7 +639,7 @@ int MonoRun(pSicsSelector self, SConnection * pCon, float fWaveLength)
if (self->pBend2) {
iRet = StartDevice(GetExecutor(), self->pBend2->name,
self->pBend2->pDescriptor,
self->pBend2, pCon, pCon->runLevel, sNeu.fHor);
self->pBend2, pCon, SCGetRunLevel(pCon), sNeu.fHor);
if (!iRet) {
return 0;
}

8
sicshipadaba.c
View File

@ -316,7 +316,7 @@ static hdbCallbackReturn SICSDriveCallback(pHdb node, void *userData,
userData, pCon, RUNDRIVE, (float) v.v.doubleValue);
} else {
status = StartDevice(pServ->pExecutor, node->name, dum->pDescriptor,
userData, pCon, pCon->runLevel, (float) v.v.doubleValue);
userData, pCon, SCGetRunLevel(pCon), (float) v.v.doubleValue);
}
if (status == 1) {
return hdbContinue;
@ -617,7 +617,7 @@ static hdbCallbackReturn SICSNotifyCallback(pHdb node, void *userData,
}
if ((cmm = GetKillPtrMessage(message)) != NULL) {
tstCon = cmm->pPtr;
if (tstCon != NULL && tstCon->ident == cbInfo->pCon->ident) {
if (tstCon != NULL && SCGetIdent(tstCon) == SCGetIdent(cbInfo->pCon)) {
return hdbKill;
} else {
return hdbContinue;
@ -769,7 +769,7 @@ static hdbCallbackReturn TreeChangeCallback(pHdb node, void *userData,
}
if ((cmm = GetKillPtrMessage(message)) != NULL) {
tstCon = cmm->pPtr;
if (tstCon != NULL && tstCon->ident == cbInfo->pCon->ident) {
if (tstCon != NULL && SCGetIdent(tstCon) == SCGetIdent(cbInfo->pCon)) {
return hdbKill;
} else {
return hdbContinue;
@ -2769,7 +2769,7 @@ static int BinReadHdbNode(SConnection *pCon, SicsInterp *pSics,
return 0;
}
if(data != NULL){
ANETwrite(pCon->sockHandle,data,(val.arrayLength+2)*sizeof(int));
ANETwrite(SCGetSockHandle(pCon),data,(val.arrayLength+2)*sizeof(int));
free(data);
}

2
statemon.c
View File

@ -305,7 +305,7 @@ int StateMonFactory(SConnection * pCon, SicsInterp * pSics, void *pData,
SConnection *pKon = (SConnection*) pUserData;
SConnection *pCon = (SConnection*) context;
if (VerifyConnection(pCon) && VerifyConnection(pKon)) {
if (pCon->ident == pKon->ident)
if (SCGetIdent(pCon) == SCGetIdent(pKon))
return 0;
}
return 1;

66
status.c
View File

@ -118,14 +118,6 @@ void KillStatus(void *pData)
/*--------------------------------------------------------------------------*/
void SetStatus(Status eNew)
{
/* if (!fixed) {
if (eCode == eNew) {
return;
}
eCode = eNew;
InvokeCallBack(pCall, VALUECHANGE, NULL);
}
*/
/*
This now only manages the userWait status
*/
@ -141,12 +133,7 @@ void SetStatus(Status eNew)
/*----------------------------------------------------------------------*/
void SetStatusFixed(Status eNew)
{
// if (eCode == eNew) {
// return;
// }
// eCode = eNew;
// InvokeCallBack(pCall, VALUECHANGE, NULL);
// fixed = 1;
/* pass */
}
/*----------------------------------------------------------------------*/
@ -309,57 +296,6 @@ int ResetStatus(SConnection * pCon, SicsInterp * pSics, void *pData,
return 1;
}
/* ===================== Control Connection Management ====================*/
static SConnection *pOwner = NULL;
void SetControl(SConnection * pCon)
{
pOwner = pCon;
}
/*--------------------------------------------------------------------------*/
int IsControl(SConnection * pCon)
{
if (pCon == pOwner) {
return 1;
} else {
return 0;
}
}
/*--------------------------------------------------------------------------*/
SConnection *GetControl(void)
{
return pOwner;
}
/*--------------------------------------------------------------------------*/
int RedirectControl(SConnection * pCon, SicsInterp * pSics, void *pData,
int argc, char *argv[])
{
assert(pCon);
assert(pSics);
/* check user Rights */
if (!SCMatchRights(pCon, usUser)) {
SCWrite(pCon,
"You have NO, I repeat NO, Privilege to grab a control connection",
eError);
return 0;
}
/* check if the connection is dead at all */
if (pCon->sockHandle < 0) {
SCWrite(pCon,
"GOTCHA!!! Control still lives! You CANNOT grab it! FUCK OFF",
eError);
return 0;
}
/* now the wizardry */
pOwner->sockHandle = pCon->sockHandle;
return 1;
}
/*----------------------------------------------------------------------------
Message pipe based new status calculation code
------------------------------------------------------------------------------*/

4
statusfile.c
View File

@ -370,13 +370,13 @@ int RestoreStatus(SConnection * pCon, SicsInterp * pSics, void *pData,
LLDdeleteBlob(self->errList);
self->errList = LLDstringCreate();
iRights = SCGetRights(pCon);
pCon->iUserRights = usInternal;
SCSetRights(pCon,usInternal);
oldWrite = SCGetWriteFunc(pCon);
SCSetWriteFunc(pCon, SCNotWrite);
iRet = exeBufProcessErrList(buffi, pSics, pCon, self->errList);
restoreOccurred = 1;
SCSetWriteFunc(pCon, oldWrite);
pCon->iUserRights = iRights;
SCSetRights(pCon,iRights);
exeBufDelete(buffi);
/*
if we do not override parameterChange here, the backup file

156
telnet.c
View File

@ -13,6 +13,8 @@
#include "passwd.h"
#include "telnet.h"
#include "fortify.h"
#include "asynnet.h"
#include "conman.h"
#define LOGINWAIT 300
/* 300 == 5 minutes to wait for valid username password */
/*-------------------------------------------------------------------------*/
@ -96,114 +98,7 @@ static void SendGA(SConnection * pCon)
pReply[0] = (char) 255;
pReply[1] = (char) 249;
NETWrite(pCon->pSock, pReply, 2);
}
/*--------------------------------------------------------------------------*/
int TelnetTaskOld(void *pData)
{
pTelTask self = NULL;
char *pPtr = NULL;
char *pLogin = NULL;
char *pUser = NULL, *pPasswd = NULL;
char pBuffer[512], pHost[131];
int iRet;
time_t shit;
self = (pTelTask) pData;
assert(self);
if (self->pCon->iEnd) {
if (SCActive(self->pCon)) {
return 1;
} else {
return 0;
}
}
/* pop and execute */
iRet = CostaPop(self->pCon->pStack, &pPtr);
if (iRet) {
if (pPtr) {
if (self->iLogin) { /* handle normal command */
/* check for logoff */
if (strstr(pPtr, "logoff") != NULL) {
NetReadRemove(pServ->pReader, self->pCon->pSock);
free(pPtr);
self->pCon->iEnd = 1;
return 0;
}
/* invoke command */
CostaLock(self->pCon->pStack);
SCInvoke(self->pCon, pServ->pSics, pPtr);
CostaUnlock(self->pCon->pStack);
SendGA(self->pCon);
free(pPtr);
} else { /* handle login messages */
pLogin = strstr(pPtr, self->pLoginWord);
if (!pLogin) {
SCWrite(self->pCon,
"------------------- Get Lost -------------------",
eError);
if (time(&shit) > self->tStart + LOGINWAIT) {
SCWrite(self->pCon,
"I cannot stand your login attempts anymore!", eError);
NetReadRemove(pServ->pReader, self->pCon->pSock);
self->pCon->iEnd = 1;
free(pPtr);
return 0;
}
free(pPtr);
return 1;
} else { /* check username / password */
pLogin += strlen(self->pLoginWord);
pUser = strtok(pLogin, " \t");
pPasswd = strtok(NULL, " \t\r\n");
iRet = IsValidUser(pUser, pPasswd);
if (iRet < 0) {
snprintf(pBuffer,sizeof(pBuffer)-1, "SYSTEM ATTACK by %s / %s", pUser, pPasswd);
Log(FATAL,"sys","%s",pBuffer);
SCWrite(self->pCon,
"I do not know you, I do not let you in", eError);
SendGA(self->pCon);
free(pPtr);
return 1;
} else {
NETInfo(self->pCon->pSock, pHost, 131);
snprintf(pBuffer,sizeof(pBuffer)-1, "Accepted connection on socket %d from %s",
self->pCon->pSock->sockid, pHost);
Log(INFO,"com",pBuffer);
SendWelcome(self->pCon);
SCSetRights(self->pCon, iRet);
self->iLogin = 1;
SendGA(self->pCon);
free(pPtr);
return 1;
}
}
}
}
}
/* check for no commands but timeout on telnet */
if (!self->iLogin && (time(&shit) > self->tStart + LOGINWAIT)) {
self->pCon->iEnd = 1;
NetReadRemove(pServ->pReader, self->pCon->pSock);
return 0;
}
/* check for end */
if (self->pCon->iEnd) {
if (SCActive(self->pCon)) {
return 1;
} else {
return 0;
}
}
return 1;
ANETwrite(SCGetSockHandle(pCon), pReply, 2);
}
/*--------------------------------------------------------------------------*/
@ -220,7 +115,7 @@ int TelnetTask(void *pData)
self = (pTelTask) pData;
assert(self);
if (self->pCon->iEnd) {
if (SCGetEnd(self->pCon)) {
if (SCActive(self->pCon)) {
return 1;
} else {
@ -230,22 +125,20 @@ int TelnetTask(void *pData)
}
/* pop and execute */
iRet = CostaPop(self->pCon->pStack, &pPtr);
iRet = SCCostaTop(self->pCon,pPtr);
if (iRet) {
if (pPtr) {
if (self->iLogin) { /* handle normal command */
/* check for logoff */
if (strstr(pPtr, "logoff") != NULL) {
Log(INFO,"sys","Handle %d logging off", self->pCon->sockHandle);
ANETclose(self->pCon->sockHandle);
SCClose(self->pCon);
free(pPtr);
self->pCon->iEnd = 1;
return 0;
}
/* invoke command */
CostaLock(self->pCon->pStack);
SCCostaLock(self->pCon);
SCInvoke(self->pCon, pServ->pSics, pPtr);
CostaUnlock(self->pCon->pStack);
SCCostaUnLock(self->pCon);
SendGA(self->pCon);
free(pPtr);
} else { /* handle login messages */
@ -258,8 +151,7 @@ int TelnetTask(void *pData)
if (time(&shit) > self->tStart + LOGINWAIT) {
SCWrite(self->pCon,
"I cannot stand your login attempts anymore!", eError);
ANETclose(self->pCon->sockHandle);
self->pCon->iEnd = 1;
SCClose(self->pCon);
free(pPtr);
return 0;
}
@ -281,8 +173,13 @@ int TelnetTask(void *pData)
return 1;
} else {
snprintf(pBuffer,sizeof(pBuffer)-1, "Accepted telnet connection on handle %d",
<<<<<<< HEAD
self->pCon->sockHandle);
Log(INFO,"sys","%s",pBuffer);
=======
SCGetSockHandle(self->pCon));
Log(INFO,"com","%s",pBuffer);
>>>>>>> conclean
SendWelcome(self->pCon);
SCSetRights(self->pCon, iRet);
self->iLogin = 1;
@ -296,14 +193,14 @@ int TelnetTask(void *pData)
}
/* check for no commands but timeout on telnet */
if (!self->iLogin && (time(&shit) > self->tStart + LOGINWAIT)) {
self->pCon->iEnd = 1;
ANETclose(self->pCon->sockHandle);
SCSetEnd(self->pCon,1);
SCClose(self->pCon);
return 0;
}
/* check for end */
if (self->pCon->iEnd) {
if (SCGetEnd(self->pCon)) {
if (SCActive(self->pCon)) {
return 1;
} else {
@ -328,7 +225,7 @@ void TelnetSignal(void *pData, int iSignal, void *pSigData)
iInt = (int *) pSigData;
SCSetInterrupt(self->pCon, *iInt);
if (*iInt == eEndServer) {
self->pCon->iEnd = 1;
SCSetEnd(self->pCon,1);
}
} else if (iSignal == SICSBROADCAST) {
pPtr = (char *) pSigData;
@ -336,9 +233,9 @@ void TelnetSignal(void *pData, int iSignal, void *pSigData)
SCWrite(self->pCon, pPtr, eWarning);
}
} else if (iSignal == TOKENRELEASE) {
self->pCon->iGrab = 0;
SCSetGrab(self->pCon,0);
} else if (iSignal == TOKENGRAB) {
self->pCon->iGrab = 1;
SCSetGrab(self->pCon,1);
}
}
@ -359,18 +256,6 @@ void InstallTelnet(void)
return;
}
i = sscanf(pPtr, "%d", &iPort);
/*
if(i > 0)
{
pTelnet = NETOpenPort(iPort);
}
if(pTelnet)
{
NetReadRegister(pServ->pReader,pTelnet, taccept, NULL);
}
*/
/* when we have a port have the NetReader listen and handle it */
NetReadInstallANETPort(pServ->pReader, taccept, iPort);
}
@ -380,7 +265,6 @@ void KillTelnet(void)
{
if (pTelnet) {
NETClosePort(pTelnet);
/* NetReadRemove(pServ->pReader,pTelnet); */
free(pTelnet);
pTelnet = NULL;
}

4
token.c
View File

@ -94,11 +94,11 @@ int TokenWrapper(SConnection * pCon, SicsInterp * pSics, void *pData,
/* we can do it */
iToken = 1;
TaskSignal(pServ->pTasker, TOKENGRAB, NULL);
pCon->iGrab = 0; /* to enable us to do commands */
SCSetGrab(pCon,0); /* to enable us to do commands */
SCSendOK(pCon);
return 1;
} else if (strcmp(argv[1], "release") == 0) {
if (pCon->iGrab != 0) {
if (SCGetGrab(pCon) != 0) {
SCWrite(pCon,
"ERROR: you cannot release somebody elses control token!",
eError);