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

- Changed strncpy to strlcpy, strncat to strlcat

Browse Source 
- Added strlcpy and strlcat to SICS
- Added a driver for the POLDI power supplies
This commit is contained in:
koennecke
2010-04-13 15:08:40 +00:00
parent 9e4eabeed1
commit dec6b04fa6
49 changed files with 679 additions and 653 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
A1931.c
View File

@ -50,7 +50,7 @@ static char *A1931comm(pEVDriver pData, char *command)
/* /*
send send
*/ */
strncpy(buffer, command, 250); strlcpy(buffer, command, 250);
strcat(buffer, "\n"); strcat(buffer, "\n");
status = GPIBsend(self->gpib, self->devID, buffer, (int) strlen(buffer)); status = GPIBsend(self->gpib, self->devID, buffer, (int) strlen(buffer));
if (status < 0) { if (status < 0) {
@ -90,7 +90,7 @@ static char *A1931comm(pEVDriver pData, char *command)
error error
*/ */
self->errorCode = A1931ERROR; self->errorCode = A1931ERROR;
strncpy(self->errorBuffer, pPtr, 131); strlcpy(self->errorBuffer, pPtr, 131);
free(pPtr); free(pPtr);
return NULL; return NULL;
} }
@ -109,11 +109,11 @@ static int A1931command(pEVDriver pData, char *command, char *replyBuffer,
pReply = A1931comm(pData, command); pReply = A1931comm(pData, command);
if (pReply != NULL) { if (pReply != NULL) {
strncpy(replyBuffer, pReply, replyBufferLen); strlcpy(replyBuffer, pReply, replyBufferLen);
free(pReply); free(pReply);
return 1; return 1;
} else { } else {
strncpy(replyBuffer, self->errorBuffer, replyBufferLen); strlcpy(replyBuffer, self->errorBuffer, replyBufferLen);
return 0; return 0;
} }
} }
@ -195,7 +195,7 @@ static int A1931error(pEVDriver pData, int *iCode, char *errBuff,
*iCode = self->errorCode; *iCode = self->errorCode;
sprintf(pError, "ERROR: %s", self->errorBuffer); sprintf(pError, "ERROR: %s", self->errorBuffer);
strncpy(errBuff, pError, bufLen); strlcpy(errBuff, pError, bufLen);
return 1; return 1;
} }
@ -287,8 +287,8 @@ static int downloadFile(pA1931 self, FILE * fd)
pPtr = GPIBreadTillTerm(self->gpib, self->devID, 10); pPtr = GPIBreadTillTerm(self->gpib, self->devID, 10);
if (pPtr[0] == '#') { if (pPtr[0] == '#') {
self->errorCode = A1931ERROR; self->errorCode = A1931ERROR;
strncpy(self->errorBuffer, pPtr, 131); strlcpy(self->errorBuffer, pPtr, 131);
strncpy(self->commandLine, buffer, 131); strlcpy(self->commandLine, buffer, 131);
free(pPtr); free(pPtr);
return 0; return 0;
} }

2
autowin.c
View File

@ -130,7 +130,7 @@ static int CalcCmd(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
if(nPar < 1){ if(nPar < 1){
strcpy(hmName,"hm"); strcpy(hmName,"hm");
} else { } else {
strncpy(hmName,par[0]->value.v.text,30); strlcpy(hmName,par[0]->value.v.text,30);
} }
hm = FindCommandData(pServ->pSics, hm = FindCommandData(pServ->pSics,

20
bruker.c
View File

@ -325,41 +325,41 @@ static int BrukerError(pEVDriver pEva, int *iCode, char *pError,
*iCode = self->iLastError; *iCode = self->iLastError;
switch (*iCode) { switch (*iCode) {
case NOFUNC: case NOFUNC:
strncpy(pError, "Function not supported", iErrLen); strlcpy(pError, "Function not supported", iErrLen);
break; break;
case BADINTERN: case BADINTERN:
case BADARG: case BADARG:
strncpy(pError, strlcpy(pError,
"Programming problem, reset Controller & contact Programmer", "Programming problem, reset Controller & contact Programmer",
iErrLen); iErrLen);
break; break;
case NOTFIELD: case NOTFIELD:
strncpy(pError, "Bruker not switched to field mode", iErrLen); strlcpy(pError, "Bruker not switched to field mode", iErrLen);
break; break;
case BADRANGE: case BADRANGE:
strncpy(pError, "Requested value out of range", iErrLen); strlcpy(pError, "Requested value out of range", iErrLen);
break; break;
case NOACCESS: case NOACCESS:
strncpy(pError, "No Access, check key position at Controller", strlcpy(pError, "No Access, check key position at Controller",
iErrLen); iErrLen);
break; break;
case ERRPENDING: case ERRPENDING:
strncpy(pError, "Error condition pending in Bruker Controller", strlcpy(pError, "Error condition pending in Bruker Controller",
iErrLen); iErrLen);
break; break;
case NOPOWER: case NOPOWER:
strncpy(pError, strlcpy(pError,
"Power OFF as consequence of some error in Bruker Controller", "Power OFF as consequence of some error in Bruker Controller",
iErrLen); iErrLen);
break; break;
case NOCONN: case NOCONN:
strncpy(pError, "No Connection to Bruker Controller", iErrLen); strlcpy(pError, "No Connection to Bruker Controller", iErrLen);
break; break;
case BTIMEOUT: case BTIMEOUT:
strncpy(pError, "Timeout at serial port", iErrLen); strlcpy(pError, "Timeout at serial port", iErrLen);
break; break;
case NOPOLUNIT: case NOPOLUNIT:
strncpy(pError, strlcpy(pError,
"No polarity switching unit, try setting negative current", "No polarity switching unit, try setting negative current",
iErrLen); iErrLen);
break; break;

14
docho.c
View File

@ -371,7 +371,7 @@ static int DoChoSetPar2(pCodri self, char *parname, char *pValue)
} }
if (strstr(pReply, "error") != NULL) { if (strstr(pReply, "error") != NULL) {
pPriv->iError = CHOPERROR; pPriv->iError = CHOPERROR;
strncpy(pPriv->pError, pReply, 79); strlcpy(pPriv->pError, pReply, 79);
return 0; return 0;
} else { } else {
pPriv->iError = 0; pPriv->iError = 0;
@ -567,22 +567,22 @@ static int DoChoError(pCodri self, int *iCode, char *pError, int iLen)
*iCode = pPriv->iError; *iCode = pPriv->iError;
switch (pPriv->iError) { switch (pPriv->iError) {
case UNDRIVABLE: case UNDRIVABLE:
strncpy(pError, "Parameter is not drivable", iLen); strlcpy(pError, "Parameter is not drivable", iLen);
break; break;
case UNKNOWNPAR: case UNKNOWNPAR:
strncpy(pError, "Parameter is unknown", iLen); strlcpy(pError, "Parameter is unknown", iLen);
break; break;
case PARERROR: case PARERROR:
strncpy(pError, "Internal parameter error", iLen); strlcpy(pError, "Internal parameter error", iLen);
break; break;
case BADSYNC: case BADSYNC:
strncpy(pError, "Cannot drive slave chopper", iLen); strlcpy(pError, "Cannot drive slave chopper", iLen);
break; break;
case CHOPERROR: case CHOPERROR:
strncpy(pError, pPriv->pError, iLen); strlcpy(pError, pPriv->pError, iLen);
break; break;
case BADSTOP: case BADSTOP:
strncpy(pError, strlcpy(pError,
"User called STOP. WARNING: chopper is still untamed!", iLen); "User called STOP. WARNING: chopper is still untamed!", iLen);
break; break;
default: default:

14
dornier2.c
View File

@ -217,7 +217,7 @@ static int DornierText(pVelSelDriv self, char *pText, int iTextLen)
sprintf(pHelp, "Vaccum: %f, Accel: %f", sStatus.vacuum, sStatus.accel); sprintf(pHelp, "Vaccum: %f, Accel: %f", sStatus.vacuum, sStatus.accel);
strcat(pBueffel, pHelp); strcat(pBueffel, pHelp);
strncpy(pText, pBueffel, iTextLen); strlcpy(pText, pBueffel, iTextLen);
return 1; return 1;
} }
@ -314,23 +314,23 @@ static int DornierError(pVelSelDriv self, int *iCode,
switch (pDorn->iLastError) { switch (pDorn->iLastError) {
case HALTREQ: case HALTREQ:
strncpy(error, "Repeat command if you really want to HALT selector", strlcpy(error, "Repeat command if you really want to HALT selector",
iErrLen); iErrLen);
pDorn->haltCount++; pDorn->haltCount++;
break; break;
case STARTED: case STARTED:
strncpy(error, strlcpy(error,
"Started selector, standby and check manually when ready", "Started selector, standby and check manually when ready",
iErrLen); iErrLen);
break; break;
case INVALIDSTATUS: case INVALIDSTATUS:
strncpy(error, "Received invalid status reply", iErrLen); strlcpy(error, "Received invalid status reply", iErrLen);
break; break;
case TARGETREJECTED: case TARGETREJECTED:
strncpy(error, "VS in local mode or target out of range", iErrLen); strlcpy(error, "VS in local mode or target out of range", iErrLen);
break; break;
case NOSTATUS: case NOSTATUS:
strncpy(error, "No successfull status request after 3 tries", iErrLen); strlcpy(error, "No successfull status request after 3 tries", iErrLen);
break; break;
default: default:
getRS232Error(pDorn->iLastError, error, iErrLen); getRS232Error(pDorn->iLastError, error, iErrLen);
@ -634,7 +634,7 @@ pVelSelDriv VSCreateDornier2003(char *name, Tcl_Interp * pTcl)
free(pDorn); free(pDorn);
return NULL; return NULL;
} }
strncpy(pHost, pPtr, 131); strlcpy(pHost, pPtr, 131);
/* port number */ /* port number */
pPtr = (char *) Tcl_GetVar2(pTcl, name, "Port", TCL_GLOBAL_ONLY); pPtr = (char *) Tcl_GetVar2(pTcl, name, "Port", TCL_GLOBAL_ONLY);

276
dspcode.c
View File

@ -2,418 +2,418 @@ void slsdspCodeToText(int code, char *text, int textlen)
{ {
switch (code) { switch (code) {
case 0x0: case 0x0:
strncpy(text, "NO", textlen); strlcpy(text, "NO", textlen);
break; break;
case 0x1: case 0x1:
strncpy(text, "DEVICE_STATE_ERROR", textlen); strlcpy(text, "DEVICE_STATE_ERROR", textlen);
break; break;
case 0x2: case 0x2:
strncpy(text, "DEVICE_SUPERVISOR_DISABLED", textlen); strlcpy(text, "DEVICE_SUPERVISOR_DISABLED", textlen);
break; break;
case 0x3: case 0x3:
strncpy(text, "COMMAND_ABORT", textlen); strlcpy(text, "COMMAND_ABORT", textlen);
break; break;
case 0x4: case 0x4:
strncpy(text, "DATA_NOT_STORED", textlen); strlcpy(text, "DATA_NOT_STORED", textlen);
break; break;
case 0x5: case 0x5:
strncpy(text, "ERROR_ERASING_FLASH", textlen); strlcpy(text, "ERROR_ERASING_FLASH", textlen);
break; break;
case 0x6: case 0x6:
strncpy(text, "COMMUNICATION_BREAK", textlen); strlcpy(text, "COMMUNICATION_BREAK", textlen);
break; break;
case 0x7: case 0x7:
strncpy(text, "INTERNAL_COMMUNICATION_ERROR", textlen); strlcpy(text, "INTERNAL_COMMUNICATION_ERROR", textlen);
break; break;
case 0x8: case 0x8:
strncpy(text, "MASTER_CARD_ERROR", textlen); strlcpy(text, "MASTER_CARD_ERROR", textlen);
break; break;
case 0x9: case 0x9:
strncpy(text, "INTERNAL_BUFFER_FULL", textlen); strlcpy(text, "INTERNAL_BUFFER_FULL", textlen);
break; break;
case 0xa: case 0xa:
strncpy(text, "WRONG_SECTOR", textlen); strlcpy(text, "WRONG_SECTOR", textlen);
break; break;
case 0xb: case 0xb:
strncpy(text, "DATA_NOT_COPIED", textlen); strlcpy(text, "DATA_NOT_COPIED", textlen);
break; break;
case 0xc: case 0xc:
strncpy(text, "WRONG_DOWNLOAD_PARAMETERS", textlen); strlcpy(text, "WRONG_DOWNLOAD_PARAMETERS", textlen);
break; break;
case 0xd: case 0xd:
strncpy(text, "DEVICE_PARAMETRIZATION_ERROR", textlen); strlcpy(text, "DEVICE_PARAMETRIZATION_ERROR", textlen);
break; break;
case 0x10: case 0x10:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE", textlen); strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE", textlen);
break; break;
case 0x11: case 0x11:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_ON", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_ON", textlen);
break; break;
case 0x12: case 0x12:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_OFF", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_OFF", textlen);
break; break;
case 0x13: case 0x13:
strncpy(text, "TIMEOUT_MAIN_RELAY_ON", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_ON", textlen);
break; break;
case 0x14: case 0x14:
strncpy(text, "TIMEOUT_MAIN_RELAY_OFF", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_OFF", textlen);
break; break;
case 0x15: case 0x15:
strncpy(text, "TIMEOUT_DATA_DOWNLOAD", textlen); strlcpy(text, "TIMEOUT_DATA_DOWNLOAD", textlen);
break; break;
case 0x20: case 0x20:
strncpy(text, "INTERLOCK", textlen); strlcpy(text, "INTERLOCK", textlen);
break; break;
case 0x21: case 0x21:
strncpy(text, "MASTER_SWITCH", textlen); strlcpy(text, "MASTER_SWITCH", textlen);
break; break;
case 0x22: case 0x22:
strncpy(text, "MAGNET_INTERLOCK", textlen); strlcpy(text, "MAGNET_INTERLOCK", textlen);
break; break;
case 0x23: case 0x23:
strncpy(text, "TEMPERATURE_TRANSFORMER", textlen); strlcpy(text, "TEMPERATURE_TRANSFORMER", textlen);
break; break;
case 0x24: case 0x24:
strncpy(text, "TEMPERATURE_RECTIFIER", textlen); strlcpy(text, "TEMPERATURE_RECTIFIER", textlen);
break; break;
case 0x25: case 0x25:
strncpy(text, "TEMPERATURE_CONVERTER", textlen); strlcpy(text, "TEMPERATURE_CONVERTER", textlen);
break; break;
case 0x26: case 0x26:
strncpy(text, "CURRENT_TRANSDUCER", textlen); strlcpy(text, "CURRENT_TRANSDUCER", textlen);
break; break;
case 0x27: case 0x27:
strncpy(text, "TEMPERATURE_POLARITY_SWITCH", textlen); strlcpy(text, "TEMPERATURE_POLARITY_SWITCH", textlen);
break; break;
case 0x28: case 0x28:
strncpy(text, "POWER_SEMICONDUCTOR", textlen); strlcpy(text, "POWER_SEMICONDUCTOR", textlen);
break; break;
case 0x29: case 0x29:
strncpy(text, "MAIN_RELAY", textlen); strlcpy(text, "MAIN_RELAY", textlen);
break; break;
case 0x2a: case 0x2a:
strncpy(text, "AD_CONVERTER_CARD", textlen); strlcpy(text, "AD_CONVERTER_CARD", textlen);
break; break;
case 0x2b: case 0x2b:
strncpy(text, "POLARITY_SWITCH", textlen); strlcpy(text, "POLARITY_SWITCH", textlen);
break; break;
case 0x2c: case 0x2c:
strncpy(text, "AUXILIARY_RELAY", textlen); strlcpy(text, "AUXILIARY_RELAY", textlen);
break; break;
case 0x2d: case 0x2d:
strncpy(text, "MASTER_SWITCH_T1", textlen); strlcpy(text, "MASTER_SWITCH_T1", textlen);
break; break;
case 0x2e: case 0x2e:
strncpy(text, "MASTER_SWITCH_T2", textlen); strlcpy(text, "MASTER_SWITCH_T2", textlen);
break; break;
case 0x2f: case 0x2f:
strncpy(text, "TEMPERATURE_MAGNET", textlen); strlcpy(text, "TEMPERATURE_MAGNET", textlen);
break; break;
case 0x30: case 0x30:
strncpy(text, "WATER_MAGNET", textlen); strlcpy(text, "WATER_MAGNET", textlen);
break; break;
case 0x31: case 0x31:
strncpy(text, "WATER_RACK", textlen); strlcpy(text, "WATER_RACK", textlen);
break; break;
case 0x40: case 0x40:
strncpy(text, "LOAD_CURRENT_TOO_HIGH", textlen); strlcpy(text, "LOAD_CURRENT_TOO_HIGH", textlen);
break; break;
case 0x41: case 0x41:
strncpy(text, "DC_LINK_VOLTAGE_TOO_LOW", textlen); strlcpy(text, "DC_LINK_VOLTAGE_TOO_LOW", textlen);
break; break;
case 0x42: case 0x42:
strncpy(text, "DC_LINK_VOLTAGE_TOO_HIGH", textlen); strlcpy(text, "DC_LINK_VOLTAGE_TOO_HIGH", textlen);
break; break;
case 0x43: case 0x43:
strncpy(text, "LOAD_VOLTAGE_TOO_HIGH", textlen); strlcpy(text, "LOAD_VOLTAGE_TOO_HIGH", textlen);
break; break;
case 0x44: case 0x44:
strncpy(text, "LOAD_CURRENT_RIPPLE_TOO_HIGH", textlen); strlcpy(text, "LOAD_CURRENT_RIPPLE_TOO_HIGH", textlen);
break; break;
case 0x45: case 0x45:
strncpy(text, "DC_LINK_ISOLATION_NOT_OK", textlen); strlcpy(text, "DC_LINK_ISOLATION_NOT_OK", textlen);
break; break;
case 0x46: case 0x46:
strncpy(text, "LOAD_ISOLATION_NOT_OK", textlen); strlcpy(text, "LOAD_ISOLATION_NOT_OK", textlen);
break; break;
case 0x47: case 0x47:
strncpy(text, "LOAD_IMPEDANCE_OUT_OF_RANGE", textlen); strlcpy(text, "LOAD_IMPEDANCE_OUT_OF_RANGE", textlen);
break; break;
case 0x48: case 0x48:
strncpy(text, "SHUT_OFF_CURRENT_TOO_HIGH", textlen); strlcpy(text, "SHUT_OFF_CURRENT_TOO_HIGH", textlen);
break; break;
case 0x49: case 0x49:
strncpy(text, "LOAD_DC_CURRENT_TOO_HIGH", textlen); strlcpy(text, "LOAD_DC_CURRENT_TOO_HIGH", textlen);
break; break;
case 0x4a: case 0x4a:
strncpy(text, "CURRENT_I1A1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1A1_TOO_HIGH", textlen);
break; break;
case 0x4b: case 0x4b:
strncpy(text, "CURRENT_I1B1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1B1_TOO_HIGH", textlen);
break; break;
case 0x4c: case 0x4c:
strncpy(text, "CURRENT_I1A2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1A2_TOO_HIGH", textlen);
break; break;
case 0x4d: case 0x4d:
strncpy(text, "CURRENT_I1B2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1B2_TOO_HIGH", textlen);
break; break;
case 0x4e: case 0x4e:
strncpy(text, "CURRENT_I2A1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2A1_TOO_HIGH", textlen);
break; break;
case 0x4f: case 0x4f:
strncpy(text, "CURRENT_I2B1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2B1_TOO_HIGH", textlen);
break; break;
case 0x50: case 0x50:
strncpy(text, "CURRENT_I2A2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2A2_TOO_HIGH", textlen);
break; break;
case 0x51: case 0x51:
strncpy(text, "CURRENT_I2B2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2B2_TOO_HIGH", textlen);
break; break;
case 0x52: case 0x52:
strncpy(text, "CURRENT_I3P_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3P_TOO_HIGH", textlen);
break; break;
case 0x53: case 0x53:
strncpy(text, "CURRENT_I3N_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3N_TOO_HIGH", textlen);
break; break;
case 0x54: case 0x54:
strncpy(text, "CURRENT_IE_TOO_HIGH", textlen); strlcpy(text, "CURRENT_IE_TOO_HIGH", textlen);
break; break;
case 0x55: case 0x55:
strncpy(text, "VOLTAGE_U1A_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U1A_TOO_LOW", textlen);
break; break;
case 0x56: case 0x56:
strncpy(text, "VOLTAGE_U1B_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U1B_TOO_LOW", textlen);
break; break;
case 0x57: case 0x57:
strncpy(text, "DIFF_CURRENT_I1A1_I1A2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I1A1_I1A2_TOO_HIGH", textlen);
break; break;
case 0x58: case 0x58:
strncpy(text, "DIFF_CURRENT_I1B1_I1B2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I1B1_I1B2_TOO_HIGH", textlen);
break; break;
case 0x59: case 0x59:
strncpy(text, "DIFF_CURRENT_I2A1_I2A2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I2A1_I2A2_TOO_HIGH", textlen);
break; break;
case 0x5a: case 0x5a:
strncpy(text, "DIFF_CURRENT_I2B1_I2B2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I2B1_I2B2_TOO_HIGH", textlen);
break; break;
case 0x5b: case 0x5b:
strncpy(text, "DIFF_CURRENT_I3P_I3N_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I3P_I3N_TOO_HIGH", textlen);
break; break;
case 0x5c: case 0x5c:
strncpy(text, "CURRENT_I1A_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1A_TOO_HIGH", textlen);
break; break;
case 0x5d: case 0x5d:
strncpy(text, "CURRENT_I1B_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1B_TOO_HIGH", textlen);
break; break;
case 0x5e: case 0x5e:
strncpy(text, "CURRENT_I3A1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3A1_TOO_HIGH", textlen);
break; break;
case 0x5f: case 0x5f:
strncpy(text, "CURRENT_I3B1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3B1_TOO_HIGH", textlen);
break; break;
case 0x60: case 0x60:
strncpy(text, "CURRENT_I3A2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3A2_TOO_HIGH", textlen);
break; break;
case 0x61: case 0x61:
strncpy(text, "CURRENT_I3B2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3B2_TOO_HIGH", textlen);
break; break;
case 0x62: case 0x62:
strncpy(text, "CURRENT_I4_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I4_TOO_HIGH", textlen);
break; break;
case 0x63: case 0x63:
strncpy(text, "CURRENT_I5_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I5_TOO_HIGH", textlen);
break; break;
case 0x64: case 0x64:
strncpy(text, "DIFF_CURRENT_I3A1_I3A2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I3A1_I3A2_TOO_HIGH", textlen);
break; break;
case 0x65: case 0x65:
strncpy(text, "DIFF_CURRENT_I3B1_I3B2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I3B1_I3B2_TOO_HIGH", textlen);
break; break;
case 0x66: case 0x66:
strncpy(text, "DIFF_CURRENT_I4_I5_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I4_I5_TOO_HIGH", textlen);
break; break;
case 0x67: case 0x67:
strncpy(text, "VOLTAGE_U3A_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U3A_TOO_LOW", textlen);
break; break;
case 0x68: case 0x68:
strncpy(text, "VOLTAGE_U3B_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U3B_TOO_LOW", textlen);
break; break;
case 0x69: case 0x69:
strncpy(text, "VOLTAGE_U1_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U1_TOO_LOW", textlen);
break; break;
case 0x6a: case 0x6a:
strncpy(text, "VOLTAGE_U3A_TOO_HIGH", textlen); strlcpy(text, "VOLTAGE_U3A_TOO_HIGH", textlen);
break; break;
case 0x6b: case 0x6b:
strncpy(text, "VOLTAGE_U3B_TOO_HIGH", textlen); strlcpy(text, "VOLTAGE_U3B_TOO_HIGH", textlen);
break; break;
case 0x6c: case 0x6c:
strncpy(text, "SPEED_ERROR_TOO_HIGH", textlen); strlcpy(text, "SPEED_ERROR_TOO_HIGH", textlen);
break; break;
case 0x70: case 0x70:
strncpy(text, "MAIN_RELAY_A", textlen); strlcpy(text, "MAIN_RELAY_A", textlen);
break; break;
case 0x71: case 0x71:
strncpy(text, "MAIN_RELAY_B", textlen); strlcpy(text, "MAIN_RELAY_B", textlen);
break; break;
case 0x72: case 0x72:
strncpy(text, "POWER_SWITCH_A", textlen); strlcpy(text, "POWER_SWITCH_A", textlen);
break; break;
case 0x73: case 0x73:
strncpy(text, "POWER_SWITCH_B", textlen); strlcpy(text, "POWER_SWITCH_B", textlen);
break; break;
case 0x74: case 0x74:
strncpy(text, "MONITOR_TRAFO_A", textlen); strlcpy(text, "MONITOR_TRAFO_A", textlen);
break; break;
case 0x75: case 0x75:
strncpy(text, "MONITOR_TRAFO_B", textlen); strlcpy(text, "MONITOR_TRAFO_B", textlen);
break; break;
case 0x76: case 0x76:
strncpy(text, "TEMPERATURE_RECTIFIER_A", textlen); strlcpy(text, "TEMPERATURE_RECTIFIER_A", textlen);
break; break;
case 0x77: case 0x77:
strncpy(text, "TEMPERATURE_RECTIFIER_B", textlen); strlcpy(text, "TEMPERATURE_RECTIFIER_B", textlen);
break; break;
case 0x78: case 0x78:
strncpy(text, "TEMPERATURE_CONVERTER_A", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_A", textlen);
break; break;
case 0x79: case 0x79:
strncpy(text, "TEMPERATURE_CONVERTER_B", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_B", textlen);
break; break;
case 0x7a: case 0x7a:
strncpy(text, "TEMPERATURE_CONVERTER_A1", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_A1", textlen);
break; break;
case 0x7b: case 0x7b:
strncpy(text, "TEMPERATURE_CONVERTER_B1", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_B1", textlen);
break; break;
case 0x7c: case 0x7c:
strncpy(text, "TEMPERATURE_CONVERTER_A2", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_A2", textlen);
break; break;
case 0x7d: case 0x7d:
strncpy(text, "TEMPERATURE_CONVERTER_B2", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_B2", textlen);
break; break;
case 0x7e: case 0x7e:
strncpy(text, "TEMPERATURE_TRANSFORMER_A", textlen); strlcpy(text, "TEMPERATURE_TRANSFORMER_A", textlen);
break; break;
case 0x7f: case 0x7f:
strncpy(text, "TEMPERATURE_TRANSFORMER_B", textlen); strlcpy(text, "TEMPERATURE_TRANSFORMER_B", textlen);
break; break;
case 0x80: case 0x80:
strncpy(text, "WATER_RECTIFIER_A", textlen); strlcpy(text, "WATER_RECTIFIER_A", textlen);
break; break;
case 0x81: case 0x81:
strncpy(text, "WATER_RECTIFIER_B", textlen); strlcpy(text, "WATER_RECTIFIER_B", textlen);
break; break;
case 0x82: case 0x82:
strncpy(text, "WATER_CONVERTER_A", textlen); strlcpy(text, "WATER_CONVERTER_A", textlen);
break; break;
case 0x83: case 0x83:
strncpy(text, "WATER_CONVERTER_B", textlen); strlcpy(text, "WATER_CONVERTER_B", textlen);
break; break;
case 0x84: case 0x84:
strncpy(text, "WATER_CONVERTER_A1", textlen); strlcpy(text, "WATER_CONVERTER_A1", textlen);
break; break;
case 0x85: case 0x85:
strncpy(text, "WATER_CONVERTER_B1", textlen); strlcpy(text, "WATER_CONVERTER_B1", textlen);
break; break;
case 0x86: case 0x86:
strncpy(text, "WATER_CONVERTER_A2", textlen); strlcpy(text, "WATER_CONVERTER_A2", textlen);
break; break;
case 0x87: case 0x87:
strncpy(text, "WATER_CONVERTER_B2", textlen); strlcpy(text, "WATER_CONVERTER_B2", textlen);
break; break;
case 0x88: case 0x88:
strncpy(text, "WATER_TRANSFORMER_A", textlen); strlcpy(text, "WATER_TRANSFORMER_A", textlen);
break; break;
case 0x89: case 0x89:
strncpy(text, "WATER_TRANSFORMER_B", textlen); strlcpy(text, "WATER_TRANSFORMER_B", textlen);
break; break;
case 0x8a: case 0x8a:
strncpy(text, "DOOR_A", textlen); strlcpy(text, "DOOR_A", textlen);
break; break;
case 0x8b: case 0x8b:
strncpy(text, "DOOR_B", textlen); strlcpy(text, "DOOR_B", textlen);
break; break;
case 0x8c: case 0x8c:
strncpy(text, "DOOR_C", textlen); strlcpy(text, "DOOR_C", textlen);
break; break;
case 0x8d: case 0x8d:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A", textlen);
break; break;
case 0x8e: case 0x8e:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B", textlen);
break; break;
case 0x8f: case 0x8f:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A1", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A1", textlen);
break; break;
case 0x90: case 0x90:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B1", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B1", textlen);
break; break;
case 0x91: case 0x91:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A2", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A2", textlen);
break; break;
case 0x92: case 0x92:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B2", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B2", textlen);
break; break;
case 0x93: case 0x93:
strncpy(text, "CURRENT_TRANSDUCER_I3P", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I3P", textlen);
break; break;
case 0x94: case 0x94:
strncpy(text, "CURRENT_TRANSDUCER_I3N", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I3N", textlen);
break; break;
case 0x95: case 0x95:
strncpy(text, "MAGNET_INTERLOCK_1", textlen); strlcpy(text, "MAGNET_INTERLOCK_1", textlen);
break; break;
case 0x96: case 0x96:
strncpy(text, "MAGNET_INTERLOCK_2", textlen); strlcpy(text, "MAGNET_INTERLOCK_2", textlen);
break; break;
case 0x97: case 0x97:
strncpy(text, "VENTILATOR", textlen); strlcpy(text, "VENTILATOR", textlen);
break; break;
case 0x98: case 0x98:
strncpy(text, "EMERGENCY_SWITCH", textlen); strlcpy(text, "EMERGENCY_SWITCH", textlen);
break; break;
case 0x99: case 0x99:
strncpy(text, "CAPACITOR_DISCHARGE_A_ON", textlen); strlcpy(text, "CAPACITOR_DISCHARGE_A_ON", textlen);
break; break;
case 0x9a: case 0x9a:
strncpy(text, "CAPACITOR_DISCHARGE_B_ON", textlen); strlcpy(text, "CAPACITOR_DISCHARGE_B_ON", textlen);
break; break;
case 0x9b: case 0x9b:
strncpy(text, "CURRENT_TRANSDUCER_I4", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I4", textlen);
break; break;
case 0x9c: case 0x9c:
strncpy(text, "CURRENT_TRANSDUCER_I5", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I5", textlen);
break; break;
case 0xb0: case 0xb0:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_A", textlen); strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_A", textlen);
break; break;
case 0xb1: case 0xb1:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_B", textlen); strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_B", textlen);
break; break;
case 0xb2: case 0xb2:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_A_ON", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_A_ON", textlen);
break; break;
case 0xb3: case 0xb3:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_B_ON", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_B_ON", textlen);
break; break;
case 0xb4: case 0xb4:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_A_OFF", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_A_OFF", textlen);
break; break;
case 0xb5: case 0xb5:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_B_OFF", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_B_OFF", textlen);
break; break;
case 0xb6: case 0xb6:
strncpy(text, "TIMEOUT_MAIN_RELAY_A_ON", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_A_ON", textlen);
break; break;
case 0xb7: case 0xb7:
strncpy(text, "TIMEOUT_MAIN_RELAY_B_ON", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_B_ON", textlen);
break; break;
case 0xb8: case 0xb8:
strncpy(text, "TIMEOUT_MAIN_RELAY_A_OFF", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_A_OFF", textlen);
break; break;
case 0xb9: case 0xb9:
strncpy(text, "TIMEOUT_MAIN_RELAY_B_OFF", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_B_OFF", textlen);
break; break;
} }
} }

2
ease.c
View File

@ -760,7 +760,7 @@ static int EaseInit(SConnection * pCon, EaseBase * eab, int argc,
SCWrite(pCon, "ERROR: host name too long", eError); SCWrite(pCon, "ERROR: host name too long", eError);
return 0; return 0;
} }
strncpy(buf, argv[0], i); strlcpy(buf, argv[0], i);
buf[i] = '\0'; buf[i] = '\0';
host = buf; host = buf;
} else if (argc == 2) { /* host port syntax */ } else if (argc == 2) { /* host port syntax */

4
ecb.c
View File

@ -252,10 +252,10 @@ void ecbErrorDescription(pECB self, char *buffer, int maxBuffer)
switch (self->lastError) { switch (self->lastError) {
case ECBILLEGALFUNC: case ECBILLEGALFUNC:
strncpy(buffer, "Illegal ECB function called", maxBuffer); strlcpy(buffer, "Illegal ECB function called", maxBuffer);
return; return;
case ECBOVERFLOW: case ECBOVERFLOW:
strncpy(buffer, strlcpy(buffer,
"You tried to copy more then 64K onto the poor ECB, REFUSED!", "You tried to copy more then 64K onto the poor ECB, REFUSED!",
maxBuffer); maxBuffer);
return; return;

18
ecbcounter.c
View File

@ -435,30 +435,30 @@ static int ECBGetError(struct __COUNTER *self, int *iCode,
*iCode = self->iErrorCode; *iCode = self->iErrorCode;
switch (self->iErrorCode) { switch (self->iErrorCode) {
case COMMERROR: case COMMERROR:
strncpy(errorText, "Communication error with ECB", errlen); strlcpy(errorText, "Communication error with ECB", errlen);
break; break;
case TOMANYCOUNTS: case TOMANYCOUNTS:
strncpy(errorText, "Preset is to high!", errlen); strlcpy(errorText, "Preset is to high!", errlen);
break; break;
case NOSEND: case NOSEND:
strncpy(errorText, "Cannot send naked data to ECB", errlen); strlcpy(errorText, "Cannot send naked data to ECB", errlen);
break; break;
case UNKNOWNPAR: case UNKNOWNPAR:
strncpy(errorText, "parameter unknown", errlen); strlcpy(errorText, "parameter unknown", errlen);
break; break;
case INVALIDCOUNTER: case INVALIDCOUNTER:
strncpy(errorText, "Invalid counter number requested, 0-7 allowed", strlcpy(errorText, "Invalid counter number requested, 0-7 allowed",
errlen); errlen);
break; break;
case INVALIDPRESCALER: case INVALIDPRESCALER:
strncpy(errorText, "Invalid prescaler value, allowed 1 or 10", errlen); strlcpy(errorText, "Invalid prescaler value, allowed 1 or 10", errlen);
break; break;
case BADFREQ: case BADFREQ:
strncpy(errorText, "Bad timer frequency: 10 or 1000 allowed", errlen); strlcpy(errorText, "Bad timer frequency: 10 or 1000 allowed", errlen);
break; break;
default: default:
sprintf(pBueffel, "Unknown error code %d", self->iErrorCode); sprintf(pBueffel, "Unknown error code %d", self->iErrorCode);
strncpy(errorText, pBueffel, errlen); strlcpy(errorText, pBueffel, errlen);
break; break;
} }
return 1; return 1;
@ -580,7 +580,7 @@ static int ECBGet(struct __COUNTER *self, char *name,
static int ECBSend(struct __COUNTER *self, char *text, static int ECBSend(struct __COUNTER *self, char *text,
char *reply, int replylen) char *reply, int replylen)
{ {
strncpy(reply, "ECB does not feast on ASCII strings, refused!", strlcpy(reply, "ECB does not feast on ASCII strings, refused!",
replylen); replylen);
return OKOK; return OKOK;
} }

16
ecbdriv.c
View File

@ -880,29 +880,29 @@ static void ECBGetError(void *pData, int *iCode, char *buffer,
*iCode = self->errorCode; *iCode = self->errorCode;
switch (self->errorCode) { switch (self->errorCode) {
case COMMERROR: case COMMERROR:
strncpy(buffer, "communication problem with ECB", bufferlen); strlcpy(buffer, "communication problem with ECB", bufferlen);
break; break;
case ECBMANUELL: case ECBMANUELL:
strncpy(buffer, "ECB is in manual mode, trying to switch...", strlcpy(buffer, "ECB is in manual mode, trying to switch...",
bufferlen); bufferlen);
break; break;
case ECBINUSE: case ECBINUSE:
strncpy(buffer, "Power supply is in use", bufferlen); strlcpy(buffer, "Power supply is in use", bufferlen);
break; break;
case ECBINHIBIT: case ECBINHIBIT:
strncpy(buffer, "motor is inhibited", bufferlen); strlcpy(buffer, "motor is inhibited", bufferlen);
break; break;
case ECBRUNNING: case ECBRUNNING:
strncpy(buffer, "motor is running", bufferlen); strlcpy(buffer, "motor is running", bufferlen);
break; break;
case ECBSTART: case ECBSTART:
strncpy(buffer, "failed to start motor", bufferlen); strlcpy(buffer, "failed to start motor", bufferlen);
break; break;
case ECBLIMIT: case ECBLIMIT:
strncpy(buffer, "hit limit switch or amplifier error", bufferlen); strlcpy(buffer, "hit limit switch or amplifier error", bufferlen);
break; break;
default: default:
strncpy(buffer, "unidentified error code", bufferlen); strlcpy(buffer, "unidentified error code", bufferlen);
break; break;
} }
} }

4
el734dc.c
View File

@ -275,7 +275,7 @@ static void GetErr(void *self, int *iCode, char *buffer, int iBufLen)
EL734_ErrInfo(&pErr, &iMSR, &iOMSR, &iSS); EL734_ErrInfo(&pErr, &iMSR, &iOMSR, &iSS);
if (iMSR != 0) { if (iMSR != 0) {
EL734Error2Text(pBueffel, iMSR); EL734Error2Text(pBueffel, iMSR);
strncpy(buffer, pBueffel, (iBufLen - 1)); strlcpy(buffer, pBueffel, (iBufLen - 1));
*iCode = iMSR; *iCode = iMSR;
return; return;
} else { /* check status flag for addional errors */ } else { /* check status flag for addional errors */
@ -284,7 +284,7 @@ static void GetErr(void *self, int *iCode, char *buffer, int iBufLen)
if (iRet != 1) { /* failure on this one, this has to be handled */ if (iRet != 1) { /* failure on this one, this has to be handled */
EL734_ErrInfo(&pErr, &iMSR, &iOMSR, &iSS); EL734_ErrInfo(&pErr, &iMSR, &iOMSR, &iSS);
EL734Error2Text(pBueffel, iMSR); EL734Error2Text(pBueffel, iMSR);
strncpy(buffer, pBueffel, (iBufLen - 1)); strlcpy(buffer, pBueffel, (iBufLen - 1));
*iCode = iMSR; *iCode = iMSR;
return; return;

4
el734driv.c
View File

@ -278,7 +278,7 @@ static void GetErr(void *self, int *iCode, char *buffer, int iBufLen)
EL734_ErrInfo(&pErr, &iMSR, &iOMSR, &iSS); EL734_ErrInfo(&pErr, &iMSR, &iOMSR, &iSS);
if (iMSR != 0) { if (iMSR != 0) {
EL734Error2Text(pBueffel, iMSR); EL734Error2Text(pBueffel, iMSR);
strncpy(buffer, pBueffel, (iBufLen - 1)); strlcpy(buffer, pBueffel, (iBufLen - 1));
*iCode = iMSR; *iCode = iMSR;
return; return;
} else { /* check status flag for addional errors */ } else { /* check status flag for addional errors */
@ -287,7 +287,7 @@ static void GetErr(void *self, int *iCode, char *buffer, int iBufLen)
if (iRet != 1) { /* failure on this one, this has to be handled */ if (iRet != 1) { /* failure on this one, this has to be handled */
EL734_ErrInfo(&pErr, &iMSR, &iOMSR, &iSS); EL734_ErrInfo(&pErr, &iMSR, &iOMSR, &iSS);
EL734Error2Text(pBueffel, iMSR); EL734Error2Text(pBueffel, iMSR);
strncpy(buffer, pBueffel, (iBufLen - 1)); strlcpy(buffer, pBueffel, (iBufLen - 1));
*iCode = iMSR; *iCode = iMSR;
return; return;

32
el734hp.c
View File

@ -170,7 +170,7 @@ static int checkResponse(pEL734Driv self, char *pReply)
} else if (strstr(pReply, "*ms") != NULL) { } else if (strstr(pReply, "*ms") != NULL) {
self->errorCode = BADSTP; self->errorCode = BADSTP;
} else { } else {
strncpy(self->errorReply, pReply, 79); strlcpy(self->errorReply, pReply, 79);
self->errorCode = BADUNKNOWN; self->errorCode = BADUNKNOWN;
} }
return 0; return 0;
@ -352,52 +352,52 @@ static void EL734Error(void *pData, int *iCode, char *error, int errLen)
*iCode = self->errorCode; *iCode = self->errorCode;
switch (*iCode) { switch (*iCode) {
case BADADR: case BADADR:
strncpy(error, "Bad address", errLen); strlcpy(error, "Bad address", errLen);
break; break;
case BADBSY: case BADBSY:
strncpy(error, "Motor still busy", errLen); strlcpy(error, "Motor still busy", errLen);
break; break;
case BADCMD: case BADCMD:
strncpy(error, "Bad command", errLen); strlcpy(error, "Bad command", errLen);
break; break;
case BADLOC: case BADLOC:
strncpy(error, "Motor controller is on local", errLen); strlcpy(error, "Motor controller is on local", errLen);
break; break;
case BADPAR: case BADPAR:
strncpy(error, "Bad parameter", errLen); strlcpy(error, "Bad parameter", errLen);
break; break;
case BADRNG: case BADRNG:
strncpy(error, "Bad range", errLen); strlcpy(error, "Bad range", errLen);
break; break;
case BADUNKNOWN: case BADUNKNOWN:
snprintf(pBueffel, 131, "Unknown response: %s", self->errorReply); snprintf(pBueffel, 131, "Unknown response: %s", self->errorReply);
strncpy(error, pBueffel, errLen); strlcpy(error, pBueffel, errLen);
break; break;
case BADSTP: case BADSTP:
strncpy(error, "Motor is switched off at motor controller", errLen); strlcpy(error, "Motor is switched off at motor controller", errLen);
break; break;
case BADEMERG: case BADEMERG:
strncpy(error, "Emergency stop is engaged, please release", errLen); strlcpy(error, "Emergency stop is engaged, please release", errLen);
break; break;
case LOWLIM: case LOWLIM:
strncpy(error, "Crashed into lower limit switch", errLen); strlcpy(error, "Crashed into lower limit switch", errLen);
break; break;
case HILIM: case HILIM:
strncpy(error, "Crashed into upper limit switch", errLen); strlcpy(error, "Crashed into upper limit switch", errLen);
break; break;
case RUNFAULT: case RUNFAULT:
strncpy(error, "Run fault detected", errLen); strlcpy(error, "Run fault detected", errLen);
break; break;
case POSFAULT: case POSFAULT:
strncpy(error, "Positioning fault detected", errLen); strlcpy(error, "Positioning fault detected", errLen);
break; break;
case BADCUSHION: case BADCUSHION:
strncpy(error, "Air cushion problem", errLen); strlcpy(error, "Air cushion problem", errLen);
break; break;
case BADCOUNT: case BADCOUNT:
snprintf(pBueffel, 131, "%d RunFaults, %d PosFaults", snprintf(pBueffel, 131, "%d RunFaults, %d PosFaults",
self->runCount, self->posCount); self->runCount, self->posCount);
strncpy(error, pBueffel, errLen); strlcpy(error, pBueffel, errLen);
break; break;
default: default:
getRS232Error(*iCode, error, errLen); getRS232Error(*iCode, error, errLen);

10
el737driv.c
View File

@ -342,17 +342,17 @@ static int EL737GetError(struct __COUNTER *self, int *iCode,
char pBueffel[256]; char pBueffel[256];
if (self->iErrorCode == UNKNOWNPAR) { if (self->iErrorCode == UNKNOWNPAR) {
strncpy(error, "unknown internal parameter code", iErrLen); strlcpy(error, "unknown internal parameter code", iErrLen);
*iCode = self->iErrorCode; *iCode = self->iErrorCode;
self->iErrorCode = 0; self->iErrorCode = 0;
return 1; return 1;
} else if (self->iErrorCode == BADCOUNTER) { } else if (self->iErrorCode == BADCOUNTER) {
strncpy(error, "monitor cannot be selected", iErrLen); strlcpy(error, "monitor cannot be selected", iErrLen);
*iCode = self->iErrorCode; *iCode = self->iErrorCode;
self->iErrorCode = 0; self->iErrorCode = 0;
return 1; return 1;
} else if (self->iErrorCode == BADTRANGE) { } else if (self->iErrorCode == BADTRANGE) {
strncpy(error, "preset time out of range", iErrLen); strlcpy(error, "preset time out of range", iErrLen);
*iCode = self->iErrorCode; *iCode = self->iErrorCode;
self->iErrorCode = 0; self->iErrorCode = 0;
return 1; return 1;
@ -362,7 +362,7 @@ static int EL737GetError(struct __COUNTER *self, int *iCode,
EL737_ErrInfo(&pErr, &iC1, &iC2, &iC3); EL737_ErrInfo(&pErr, &iC1, &iC2, &iC3);
EL737Error2Text(pBueffel, iC1); EL737Error2Text(pBueffel, iC1);
strncpy(error, pBueffel, iErrLen); strlcpy(error, pBueffel, iErrLen);
*iCode = iC1; *iCode = iC1;
return 1; return 1;
} }
@ -545,7 +545,7 @@ static int EL737Send(struct __COUNTER *self, char *pText, char *pReply,
/* ensure a \r at the end of the text */ /* ensure a \r at the end of the text */
if (strlen(pText) > 254) { if (strlen(pText) > 254) {
strncpy(pReply, "Command to long", iReplyLen); strlcpy(pReply, "Command to long", iReplyLen);
return 1; return 1;
} }
strcpy(pBuffer, pText); strcpy(pBuffer, pText);

26
el737hpdriv.c
View File

@ -437,47 +437,47 @@ static int EL737GetError(struct __COUNTER *self, int *iCode,
*iCode = pPriv->errorCode; *iCode = pPriv->errorCode;
switch (pPriv->errorCode) { switch (pPriv->errorCode) {
case OFFLINE: case OFFLINE:
strncpy(pError, "EL737 is offline", errLen); strlcpy(pError, "EL737 is offline", errLen);
break; break;
case OVERFLOW: case OVERFLOW:
strncpy(pError, "EL737 reported overflow, communication problem", strlcpy(pError, "EL737 reported overflow, communication problem",
errLen); errLen);
break; break;
case BADRANGE: case BADRANGE:
strncpy(pError, "EL737 parameter is out of range", errLen); strlcpy(pError, "EL737 parameter is out of range", errLen);
break; break;
case BADTRANGE: case BADTRANGE:
strncpy(pError, "preset timer out of range", errLen); strlcpy(pError, "preset timer out of range", errLen);
break; break;
case BADCOMMAND: case BADCOMMAND:
strncpy(pError, "EL737 received unknown command or is busy", errLen); strlcpy(pError, "EL737 received unknown command or is busy", errLen);
break; break;
case BADPARAM: case BADPARAM:
strncpy(pError, "EL737 parameter is awful", errLen); strlcpy(pError, "EL737 parameter is awful", errLen);
break; break;
case NOPARAM: case NOPARAM:
strncpy(pError, "EL737 parameter missing", errLen); strlcpy(pError, "EL737 parameter missing", errLen);
break; break;
case TOMANYCOUNTS: case TOMANYCOUNTS:
strncpy(pError, "EL737 counters overflowed", errLen); strlcpy(pError, "EL737 counters overflowed", errLen);
break; break;
case SYSERROR: case SYSERROR:
strncpy(pError, "EL737 has an internal system error", errLen); strlcpy(pError, "EL737 has an internal system error", errLen);
break; break;
case BADREPLY: case BADREPLY:
snprintf(pError, errLen, "EL737 sent an unexpected reply: %s", snprintf(pError, errLen, "EL737 sent an unexpected reply: %s",
pPriv->badReply); pPriv->badReply);
break; break;
case SELECTFAIL: case SELECTFAIL:
strncpy(pError, "select system call failed, network trouble", errLen); strlcpy(pError, "select system call failed, network trouble", errLen);
break; break;
case TIMEOUT737: case TIMEOUT737:
strncpy(pError, strlcpy(pError,
"timeout or network problem while waiting for status repsonse", "timeout or network problem while waiting for status repsonse",
errLen); errLen);
break; break;
case TOMANYREADERRORS: case TOMANYREADERRORS:
strncpy(pError, "Failed more then three times to read counter box", strlcpy(pError, "Failed more then three times to read counter box",
errLen); errLen);
break; break;
default: default:
@ -672,7 +672,7 @@ pCounterDriver MakeEL737HP(SConnection * pCon, char *name,
return NULL; return NULL;
} }
port = atoi(argv[1]); port = atoi(argv[1]);
strncpy(pHost, argv[0], 131); strlcpy(pHost, argv[0], 131);
/* /*
allocate a bank worth of memory ........... allocate a bank worth of memory ...........

28
el737hpdrivsps.c
View File

@ -455,51 +455,51 @@ static int EL737SGetError(struct __COUNTER *self, int *iCode,
*iCode = pPriv->errorCode; *iCode = pPriv->errorCode;
switch (pPriv->errorCode) { switch (pPriv->errorCode) {
case OFFLINE: case OFFLINE:
strncpy(pError, "EL737 is offline", errLen); strlcpy(pError, "EL737 is offline", errLen);
break; break;
case OVERFLOW: case OVERFLOW:
strncpy(pError, "EL737 reported overflow, communication problem", strlcpy(pError, "EL737 reported overflow, communication problem",
errLen); errLen);
break; break;
case BADRANGE: case BADRANGE:
strncpy(pError, "EL737 parameter is out of range", errLen); strlcpy(pError, "EL737 parameter is out of range", errLen);
break; break;
case BADTRANGE: case BADTRANGE:
strncpy(pError, "preset timer out of range", errLen); strlcpy(pError, "preset timer out of range", errLen);
break; break;
case BADCOMMAND: case BADCOMMAND:
strncpy(pError, "EL737 received unknown command or is busy", errLen); strlcpy(pError, "EL737 received unknown command or is busy", errLen);
break; break;
case BADPARAM: case BADPARAM:
strncpy(pError, "EL737 parameter is awful", errLen); strlcpy(pError, "EL737 parameter is awful", errLen);
break; break;
case NOPARAM: case NOPARAM:
strncpy(pError, "EL737 parameter missing", errLen); strlcpy(pError, "EL737 parameter missing", errLen);
break; break;
case TOMANYCOUNTS: case TOMANYCOUNTS:
strncpy(pError, "EL737 counters overflowed", errLen); strlcpy(pError, "EL737 counters overflowed", errLen);
break; break;
case SYSERROR: case SYSERROR:
strncpy(pError, "EL737 has an internal system error", errLen); strlcpy(pError, "EL737 has an internal system error", errLen);
break; break;
case BADREPLY: case BADREPLY:
snprintf(pError, errLen, "EL737 sent an unexpected reply: %s", snprintf(pError, errLen, "EL737 sent an unexpected reply: %s",
pPriv->badReply); pPriv->badReply);
break; break;
case SELECTFAIL: case SELECTFAIL:
strncpy(pError, "select system call failed, network trouble", errLen); strlcpy(pError, "select system call failed, network trouble", errLen);
break; break;
case TIMEOUT737: case TIMEOUT737:
strncpy(pError, strlcpy(pError,
"timeout or network problem while waiting for status repsonse", "timeout or network problem while waiting for status repsonse",
errLen); errLen);
break; break;
case TOMANYREADERRORS: case TOMANYREADERRORS:
strncpy(pError, "Failed more then three times to read counter box", strlcpy(pError, "Failed more then three times to read counter box",
errLen); errLen);
break; break;
case DETOVERLOAD: case DETOVERLOAD:
strncpy(pError, "Shutter closed due to detector overload", errLen); strlcpy(pError, "Shutter closed due to detector overload", errLen);
break; break;
default: default:
getRS232Error(pPriv->errorCode, pError, errLen); getRS232Error(pPriv->errorCode, pError, errLen);
@ -689,7 +689,7 @@ pCounterDriver MakeEL737hpsps(SConnection * pCon, char *name,
return NULL; return NULL;
} }
port = atoi(argv[1]); port = atoi(argv[1]);
strncpy(pHost, argv[0], 131); strlcpy(pHost, argv[0], 131);
/* /*
allocate a bank worth of memory ........... allocate a bank worth of memory ...........

22
el737hpv2driv.c
View File

@ -99,7 +99,7 @@ static int EL737Command(pEL737hp pPriv, char *pCommand,
*/ */
if (strstr(pReply, "*") != NULL) { if (strstr(pReply, "*") != NULL) {
memset(pPriv->savedStarMessage, 0, 20); memset(pPriv->savedStarMessage, 0, 20);
strncpy(pPriv->savedStarMessage, pReply, 19); strlcpy(pPriv->savedStarMessage, pReply, 19);
pPriv->haveSavedStarMessage = 1; pPriv->haveSavedStarMessage = 1;
status = readRS232TillTerm(pPriv->controller, pReply, &savedLen); status = readRS232TillTerm(pPriv->controller, pReply, &savedLen);
if (status < 0) { if (status < 0) {
@ -332,31 +332,31 @@ static int EL737GetError(struct __COUNTER *self, int *iCode,
*iCode = pPriv->errorCode; *iCode = pPriv->errorCode;
switch (pPriv->errorCode) { switch (pPriv->errorCode) {
case OFFLINE: case OFFLINE:
strncpy(pError, "EL737 is offline", errLen); strlcpy(pError, "EL737 is offline", errLen);
break; break;
case BADRANGE: case BADRANGE:
strncpy(pError, "EL737 parameter is out of range", errLen); strlcpy(pError, "EL737 parameter is out of range", errLen);
break; break;
case BADCOMMAND: case BADCOMMAND:
strncpy(pError, "EL737 received unknown command or is busy", errLen); strlcpy(pError, "EL737 received unknown command or is busy", errLen);
break; break;
case BADPARAM: case BADPARAM:
strncpy(pError, "EL737 parameter is awful", errLen); strlcpy(pError, "EL737 parameter is awful", errLen);
break; break;
case NOPARAM: case NOPARAM:
strncpy(pError, "EL737 parameter missing", errLen); strlcpy(pError, "EL737 parameter missing", errLen);
break; break;
case TOMANYCOUNTS: case TOMANYCOUNTS:
strncpy(pError, "EL737 counters overflowed", errLen); strlcpy(pError, "EL737 counters overflowed", errLen);
break; break;
case SYSERROR: case SYSERROR:
strncpy(pError, "EL737 has an internal system error", errLen); strlcpy(pError, "EL737 has an internal system error", errLen);
break; break;
case BADREPLY: case BADREPLY:
strncpy(pError, "EL737 sent an unexpected reply", errLen); strlcpy(pError, "EL737 sent an unexpected reply", errLen);
break; break;
case SELECTFAIL: case SELECTFAIL:
strncpy(pError, "select system call failed, network trouble", errLen); strlcpy(pError, "select system call failed, network trouble", errLen);
default: default:
getRS232Error(pPriv->errorCode, pError, errLen); getRS232Error(pPriv->errorCode, pError, errLen);
} }
@ -516,7 +516,7 @@ pCounterDriver MakeEL737HPV2(SConnection * pCon, char *name,
return NULL; return NULL;
} }
port = atoi(argv[1]); port = atoi(argv[1]);
strncpy(pHost, argv[0], 131); strlcpy(pHost, argv[0], 131);
/* /*
allocate a bank worth of memory ........... allocate a bank worth of memory ...........

42
el755driv.c
View File

@ -14,6 +14,8 @@
#include <math.h> #include <math.h>
#include <assert.h> #include <assert.h>
#include <fortify.h> #include <fortify.h>
#include <strlutil.h>
#include <conman.h> #include <conman.h>
#include <servlog.h> #include <servlog.h>
#include <fortify.h> #include <fortify.h>
@ -102,65 +104,65 @@ static int EL755Error(pEVDriver self, int *iCode, char *error, int iErrLen)
EL755_ErrInfo(&pPtr, iCode, &i1, &i2); EL755_ErrInfo(&pPtr, iCode, &i1, &i2);
switch (*iCode) { switch (*iCode) {
case CAPSIZED: case CAPSIZED:
strncpy(error, "Powersupply has capsized, try lower current", iErrLen); strlcpy(error, "Powersupply has capsized, try lower current", iErrLen);
break; break;
case EL755__TURNED_OFF: case EL755__TURNED_OFF:
strncpy(error, "EL755__TURNED_OF", iErrLen); strlcpy(error, "EL755__TURNED_OF", iErrLen);
break; break;
case EL755__TOO_MANY: case EL755__TOO_MANY:
strncpy(error, "EL755__TO_MANY", iErrLen); strlcpy(error, "EL755__TO_MANY", iErrLen);
break; break;
case EL755__TOO_LARGE: case EL755__TOO_LARGE:
strncpy(error, "EL755__TOO_LARGE", iErrLen); strlcpy(error, "EL755__TOO_LARGE", iErrLen);
break; break;
case EL755__OVFLOW: case EL755__OVFLOW:
strncpy(error, "EL755_OVFLOW", iErrLen); strlcpy(error, "EL755_OVFLOW", iErrLen);
break; break;
case EL755__OUT_OF_RANGE: case EL755__OUT_OF_RANGE:
strncpy(error, "EL755_OUT_OF_RANGE", iErrLen); strlcpy(error, "EL755_OUT_OF_RANGE", iErrLen);
break; break;
case EL755__OFFLINE: case EL755__OFFLINE:
strncpy(error, "EL755_OFFLINE", iErrLen); strlcpy(error, "EL755_OFFLINE", iErrLen);
break; break;
case EL755__NO_SOCKET: case EL755__NO_SOCKET:
strncpy(error, "EL755__NO_SOCKET", iErrLen); strlcpy(error, "EL755__NO_SOCKET", iErrLen);
break; break;
case EL755__NOT_OPEN: case EL755__NOT_OPEN:
strncpy(error, "EL755__NOT_OPEN", iErrLen); strlcpy(error, "EL755__NOT_OPEN", iErrLen);
break; break;
case EL755__FORCED_CLOSED: case EL755__FORCED_CLOSED:
strncpy(error, "EL755__FORCED_CLOSED", iErrLen); strlcpy(error, "EL755__FORCED_CLOSED", iErrLen);
break; break;
case EL755__BAD_TMO: case EL755__BAD_TMO:
strncpy(error, "EL755__BAD_TMO", iErrLen); strlcpy(error, "EL755__BAD_TMO", iErrLen);
break; break;
case EL755__BAD_SOCKET: case EL755__BAD_SOCKET:
strncpy(error, "EL755__BAD_SOCKET", iErrLen); strlcpy(error, "EL755__BAD_SOCKET", iErrLen);
break; break;
case EL755__BAD_PAR: case EL755__BAD_PAR:
strncpy(error, "EL755__BAD_PAR", iErrLen); strlcpy(error, "EL755__BAD_PAR", iErrLen);
break; break;
case EL755__BAD_OFL: case EL755__BAD_OFL:
strncpy(error, "EL755__BAD_OFL", iErrLen); strlcpy(error, "EL755__BAD_OFL", iErrLen);
break; break;
case EL755__BAD_MALLOC: case EL755__BAD_MALLOC:
strncpy(error, "EL755__BAD_MALLOC", iErrLen); strlcpy(error, "EL755__BAD_MALLOC", iErrLen);
break; break;
case EL755__BAD_ILLG: case EL755__BAD_ILLG:
strncpy(error, "EL755__BAD_ILLG", iErrLen); strlcpy(error, "EL755__BAD_ILLG", iErrLen);
break; break;
case EL755__BAD_DEV: case EL755__BAD_DEV:
strncpy(error, "EL755__BAD_DEV", iErrLen); strlcpy(error, "EL755__BAD_DEV", iErrLen);
break; break;
case EL755__BAD_CMD: case EL755__BAD_CMD:
strncpy(error, "EL755__BAD_CMD", iErrLen); strlcpy(error, "EL755__BAD_CMD", iErrLen);
break; break;
case EL755__BAD_ASYNSRV: case EL755__BAD_ASYNSRV:
strncpy(error, "EL755__BAD_ASYNSRV", iErrLen); strlcpy(error, "EL755__BAD_ASYNSRV", iErrLen);
break; break;
default: default:
sprintf(pBueffel, "Unknown error %d found", *iCode); sprintf(pBueffel, "Unknown error %d found", *iCode);
strncpy(error, pBueffel, iErrLen); strlcpy(error, pBueffel, iErrLen);
break; break;
} }

11
eurodriv.c
View File

@ -21,6 +21,7 @@
#include <conman.h> #include <conman.h>
#include <servlog.h> #include <servlog.h>
#include <fortify.h> #include <fortify.h>
#include <strlutil.h>
#include "evdriver.h" #include "evdriver.h"
#include "hardsup/el734_def.h" #include "hardsup/el734_def.h"
@ -197,16 +198,16 @@ static int EuroError(pEVDriver self, int *iCode, char *error, int iErrLen)
*iCode = pMe->iLastError; *iCode = pMe->iLastError;
switch (pMe->iLastError) { switch (pMe->iLastError) {
case INVALIDANSWER: case INVALIDANSWER:
strncpy(error, "Unexpected reply from Eurotherm", iErrLen); strlcpy(error, "Unexpected reply from Eurotherm", iErrLen);
break; break;
case INVALIDNUMBER: case INVALIDNUMBER:
strncpy(error, "No number in Eurotherm answer", iErrLen); strlcpy(error, "No number in Eurotherm answer", iErrLen);
break; break;
case ERRNAK: case ERRNAK:
strncpy(error, "Eurothem did NOT acknowledge command", iErrLen); strlcpy(error, "Eurothem did NOT acknowledge command", iErrLen);
break; break;
case NOSEND: case NOSEND:
strncpy(error, strlcpy(error,
"Eurotherm has a bizarre protocoll, sending things is very STUPID", "Eurotherm has a bizarre protocoll, sending things is very STUPID",
iErrLen); iErrLen);
break; break;
@ -228,7 +229,7 @@ static int EuroSend(pEVDriver self, char *pCommand, char *pReply, int iLen)
assert(pMe); assert(pMe);
pMe->iLastError = NOSEND; pMe->iLastError = NOSEND;
strncpy(pReply, "ERROR: Eurotherm does not support send functionality", strlcpy(pReply, "ERROR: Eurotherm does not support send functionality",
iLen); iLen);
return 0; return 0;
} }

2
haakedriv.c
View File

@ -113,7 +113,7 @@ int HaakeHandler(void *object)
if (strcmp(eab->ans, eab->version) == 0) { if (strcmp(eab->ans, eab->version) == 0) {
/* we are still connected with the same device */ /* we are still connected with the same device */
} else if (*eab->version == '\0') { } else if (*eab->version == '\0') {
strncat(eab->version, eab->ans, sizeof(eab->version) - 1); strlcat(eab->version, eab->ans, sizeof(eab->version) - 1);
} else { /* version (and therefore device) changed */ } else { /* version (and therefore device) changed */
eab->errCode = EASE_DEV_CHANGED; eab->errCode = EASE_DEV_CHANGED;
eab->state = EASE_idle; eab->state = EASE_idle;

4
itc4driv.c
View File

@ -46,7 +46,7 @@
#include <conman.h> #include <conman.h>
#include <servlog.h> #include <servlog.h>
#include <fortify.h> #include <fortify.h>
#include <strlutil.h>
#include "evdriver.h" #include "evdriver.h"
#include "hardsup/itc4util.h" #include "hardsup/itc4util.h"
#include "hardsup/el734_def.h" #include "hardsup/el734_def.h"
@ -123,7 +123,7 @@ static int ITC4Error(pEVDriver self, int *iCode, char *error, int iErrLen)
*iCode = pMe->iLastError; *iCode = pMe->iLastError;
if (pMe->iLastError == SHITTYVALUE) { if (pMe->iLastError == SHITTYVALUE) {
strncpy(error, "Invalid temperature returned form ITC4, check sensor", strlcpy(error, "Invalid temperature returned form ITC4, check sensor",
iErrLen); iErrLen);
} else { } else {
ITC4_ErrorTxt(&pMe->pData, pMe->iLastError, error, iErrLen); ITC4_ErrorTxt(&pMe->pData, pMe->iLastError, error, iErrLen);

38
julcho.c
View File

@ -219,9 +219,9 @@ static pHdbCallback MakeJulChoSetCallback(pJulCho driv, char *command,
return NULL; return NULL;
} }
cbData->pDriv = driv; cbData->pDriv = driv;
strncpy(cbData->comCode, command, 9); strlcpy(cbData->comCode, command, 9);
strncpy(cbData->prefix, prefix, 9); strlcpy(cbData->prefix, prefix, 9);
strncpy(cbData->postfix, postfix, 9); strlcpy(cbData->postfix, postfix, 9);
hdbCB->next = NULL; hdbCB->next = NULL;
hdbCB->previous = NULL; hdbCB->previous = NULL;
hdbCB->killFunc = free; hdbCB->killFunc = free;
@ -570,50 +570,50 @@ static void JulChoErrorcodeToString(int code, char *pError, int iLen)
{ {
switch (code) { switch (code) {
case FRAMEERROR: case FRAMEERROR:
strncpy(pError, "Frame error", iLen); strlcpy(pError, "Frame error", iLen);
break; break;
case CKERROR: case CKERROR:
strncpy(pError, "Checksum error", iLen); strlcpy(pError, "Checksum error", iLen);
break; break;
case BADCOMMAND: case BADCOMMAND:
strncpy(pError, "Bad Command", iLen); strlcpy(pError, "Bad Command", iLen);
break; break;
case WRONGNOPAR: case WRONGNOPAR:
strncpy(pError, "Wrong number of parameters", iLen); strlcpy(pError, "Wrong number of parameters", iLen);
break; break;
case ILLPAR: case ILLPAR:
strncpy(pError, "Illegal parameter", iLen); strlcpy(pError, "Illegal parameter", iLen);
break; break;
case PARRANGE: case PARRANGE:
strncpy(pError, "Parameter out of range", iLen); strlcpy(pError, "Parameter out of range", iLen);
break; break;
case BADERR: case BADERR:
strncpy(pError, "Controller error not recognised", iLen); strlcpy(pError, "Controller error not recognised", iLen);
break; break;
case BADREPLY: case BADREPLY:
strncpy(pError, "Unexpected reply", iLen); strlcpy(pError, "Unexpected reply", iLen);
break; break;
case NOTPAR: case NOTPAR:
strncpy(pError, "Unsupported parameter", iLen); strlcpy(pError, "Unsupported parameter", iLen);
break; break;
case BADTEXT: case BADTEXT:
strncpy(pError, "Failed to convert text to number", iLen); strlcpy(pError, "Failed to convert text to number", iLen);
break; break;
case ROPAR: case ROPAR:
strncpy(pError, "Read only Parameter", iLen); strlcpy(pError, "Read only Parameter", iLen);
break; break;
case NOMEM: case NOMEM:
strncpy(pError, "Out of memory formatting parameter", iLen); strlcpy(pError, "Out of memory formatting parameter", iLen);
break; break;
case HALT: case HALT:
strncpy(pError, "User requested HALT; choppers status undefined ", strlcpy(pError, "User requested HALT; choppers status undefined ",
iLen); iLen);
break; break;
case SICSCBRANGE: case SICSCBRANGE:
strncpy(pError, "Parameter value out of range", iLen); strlcpy(pError, "Parameter value out of range", iLen);
break; break;
case SICSCBRO: case SICSCBRO:
strncpy(pError, "Parameter is READ-ONLY", iLen); strlcpy(pError, "Parameter is READ-ONLY", iLen);
break; break;
default: default:
getRS232Error(code, pError, iLen); getRS232Error(code, pError, iLen);
@ -1109,7 +1109,7 @@ static int JulChoGetPar(pCodri pDriv, char *parname,
self->errorCode = NOMEM; self->errorCode = NOMEM;
return 0; return 0;
} }
strncpy(pBuffer, GetCharArray(val), iBufLen); strlcpy(pBuffer, GetCharArray(val), iBufLen);
DeleteDynString(val); DeleteDynString(val);
return 1; return 1;
} }

2
linadriv.c
View File

@ -72,7 +72,7 @@ int LinaHandler(void *object)
if (strcmp(eab->ans, eab->version) == 0) { if (strcmp(eab->ans, eab->version) == 0) {
/* we are still connected with the same device */ /* we are still connected with the same device */
} else if (*eab->version == '\0' && strcmp(eab->ans, "7265") == 0) { } else if (*eab->version == '\0' && strcmp(eab->ans, "7265") == 0) {
strncat(eab->version, eab->ans, sizeof(eab->version) - 1); strlcat(eab->version, eab->ans, sizeof(eab->version) - 1);
} else { /* version (and therefore device) changed */ } else { /* version (and therefore device) changed */
eab->errCode = EASE_DEV_CHANGED; eab->errCode = EASE_DEV_CHANGED;
eab->state = EASE_idle; eab->state = EASE_idle;

6
lmd200.c
View File

@ -120,7 +120,7 @@ static int countTokens(char *lineBuffer)
memset(myBuffer, 0, BUFLEN); memset(myBuffer, 0, BUFLEN);
strncpy(myBuffer, lineBuffer,BUFLEN); strlcpy(myBuffer, lineBuffer,BUFLEN);
pPtr = myBuffer; pPtr = myBuffer;
pPtr = stptok(pPtr, token, 60, " \r\n"); pPtr = stptok(pPtr, token, 60, " \r\n");
while (pPtr != NULL) { while (pPtr != NULL) {
@ -178,7 +178,7 @@ static int LMD200Callback(int handle, void *userData)
pEnd = strchr(pPtr,(int)'\r'); pEnd = strchr(pPtr,(int)'\r');
while(pEnd != NULL){ while(pEnd != NULL){
*pEnd = '\0'; *pEnd = '\0';
strncpy(priv->lineBuffer,pPtr,BUFLEN); strlcpy(priv->lineBuffer,pPtr,BUFLEN);
interpretLine(self,priv); interpretLine(self,priv);
ANETreadConsume(priv->asChannel,(pEnd - pPtr)+1); ANETreadConsume(priv->asChannel,(pEnd - pPtr)+1);
pPtr = ANETreadPtr(priv->asChannel,&length); pPtr = ANETreadPtr(priv->asChannel,&length);
@ -216,7 +216,7 @@ int MakeLMD200(SConnection * pCon, SicsInterp * pSics, void *pData,
} }
priv = (pLMD200) malloc(sizeof(LMD200)); priv = (pLMD200) malloc(sizeof(LMD200));
memset(priv, 0, sizeof(LMD200)); memset(priv, 0, sizeof(LMD200));
strncpy(priv->host, argv[2], 256); strlcpy(priv->host, argv[2], 256);
priv->port = atoi(argv[3]); priv->port = atoi(argv[3]);
priv->asChannel = ANETconnect(priv->host, priv->port); priv->asChannel = ANETconnect(priv->host, priv->port);
if (priv->asChannel < 0) { if (priv->asChannel < 0) {

2
lscsupport.c
View File

@ -47,7 +47,7 @@ int LscHandler(void *object)
if (strcmp(eab->ans, eab->version) == 0) { if (strcmp(eab->ans, eab->version) == 0) {
/* we are still connected with the same device */ /* we are still connected with the same device */
} else if (*eab->version == '\0') { } else if (*eab->version == '\0') {
strncat(eab->version, eab->ans, sizeof(eab->version) - 1); strlcat(eab->version, eab->ans, sizeof(eab->version) - 1);
} else { /* version (and therefore device) changed */ } else { /* version (and therefore device) changed */
eab->errCode = EASE_DEV_CHANGED; eab->errCode = EASE_DEV_CHANGED;
eab->state = EASE_idle; eab->state = EASE_idle;

10
ltc11.c
View File

@ -313,21 +313,21 @@ static int LTC11Error(pEVDriver pEva, int *iCode, char *pError,
*iCode = self->iLastError; *iCode = self->iLastError;
switch (*iCode) { switch (*iCode) {
case NOCONN: case NOCONN:
strncpy(pError, "No Connection to Bruker Controller", iErrLen); strlcpy(pError, "No Connection to Bruker Controller", iErrLen);
break; break;
case MISERABLE: case MISERABLE:
case BADSTATE: case BADSTATE:
strncpy(pError, "The LTC-11 is in a very bad state", iErrLen); strlcpy(pError, "The LTC-11 is in a very bad state", iErrLen);
break; break;
case BADANSWER: case BADANSWER:
strncpy(pError, "The LTC-11 returned a bad reply", iErrLen); strlcpy(pError, "The LTC-11 returned a bad reply", iErrLen);
break; break;
case BADCONFIRM: case BADCONFIRM:
strncpy(pError, "The LTC-11 did not accept the new set point", strlcpy(pError, "The LTC-11 did not accept the new set point",
iErrLen); iErrLen);
break; break;
case TIMEOUT: case TIMEOUT:
strncpy(pError, "Timeout receiving data from LTC-11", iErrLen); strlcpy(pError, "Timeout receiving data from LTC-11", iErrLen);
break; break;
default: default:
SerialError(*iCode, pError, iErrLen); SerialError(*iCode, pError, iErrLen);

2
make_gen
View File

@ -9,7 +9,7 @@
.tc.c: .tc.c:
tjxp $*.tc $*.c tjxp $*.tc $*.c
OBJ=psi.o buffer.o ruli.o sps.o pimotor.o \ OBJ=psi.o buffer.o ruli.o sps.o pimotor.o charbychar.o\
pipiezo.o sanswave.o faverage.o fetchwrite.o\ pipiezo.o sanswave.o faverage.o fetchwrite.o\
amorstat.o tasinit.o ptasdrive.o tasutil.o tasscan.o swmotor.o \ amorstat.o tasinit.o ptasdrive.o tasutil.o tasscan.o swmotor.o \
polterwrite.o ecb.o frame.o el734driv.o el734dc.o ecbdriv.o \ polterwrite.o ecb.o frame.o el734driv.o el734dc.o ecbdriv.o \

2
oicom.c
View File

@ -47,7 +47,7 @@ int OiHandler(Eve * eve)
if (strcmp(eve->ans, eve->version) == 0) { if (strcmp(eve->ans, eve->version) == 0) {
/* we are still connected with the same device */ /* we are still connected with the same device */
} else if (*eve->version == '\0') { } else if (*eve->version == '\0') {
strncat(eve->version, eve->ans, sizeof(eve->version) - 1); strlcat(eve->version, eve->ans, sizeof(eve->version) - 1);
} else { /* version (and therefore device) changed */ } else { /* version (and therefore device) changed */
eve->errCode = EVE_DEV_CHANGED; eve->errCode = EVE_DEV_CHANGED;
eve->state = idleState; eve->state = idleState;

2
oxinst.c
View File

@ -90,7 +90,7 @@ int OxiHandler(void *object)
if (strcmp(eab->ans, eab->version) == 0) { if (strcmp(eab->ans, eab->version) == 0) {
/* we are still connected with the same device */ /* we are still connected with the same device */
} else if (*eab->version == '\0') { } else if (*eab->version == '\0') {
strncat(eab->version, eab->ans, sizeof(eab->version) - 1); strlcat(eab->version, eab->ans, sizeof(eab->version) - 1);
} else { /* version (and therefore device) changed */ } else { /* version (and therefore device) changed */
eab->errCode = EASE_DEV_CHANGED; eab->errCode = EASE_DEV_CHANGED;
eab->state = EASE_idle; eab->state = EASE_idle;

4
pimotor.c
View File

@ -138,11 +138,11 @@ static void PIError(void *pData, int *iCode, char *pError, int iErrLen)
*iCode = self->iLastError; *iCode = self->iLastError;
if (*iCode == PITMO) { if (*iCode == PITMO) {
strncpy(pError, "Timeout at serial line", iErrLen); strlcpy(pError, "Timeout at serial line", iErrLen);
return; return;
} }
if (*iCode == PICOMERR) { if (*iCode == PICOMERR) {
strncpy(pError, "C-804 Command Error", iErrLen); strlcpy(pError, "C-804 Command Error", iErrLen);
return; return;
} }

4
pipiezo.c
View File

@ -132,11 +132,11 @@ static void PIError(void *pData, int *iCode, char *pError, int iErrLen)
*iCode = self->iLastError; *iCode = self->iLastError;
if (*iCode == PITMO) { if (*iCode == PITMO) {
strncpy(pError, "Timeout at serial line", iErrLen); strlcpy(pError, "Timeout at serial line", iErrLen);
return; return;
} }
if (*iCode == PICOMERR) { if (*iCode == PICOMERR) {
strncpy(pError, "E-255 Command Error", iErrLen); strlcpy(pError, "E-255 Command Error", iErrLen);
return; return;
} }

2
polterwrite.c
View File

@ -711,7 +711,7 @@ int PolterInstall(SConnection * pCon, SicsInterp * pSics,
KillPolterdi(pNew); KillPolterdi(pNew);
return 0; return 0;
} }
strncpy(comCon.deviceID, "internal", SCDEVIDLEN); strlcpy(comCon.deviceID, "internal", SCDEVIDLEN);
RegisterCallback(pCall, COUNTSTART, Countstartcallback, pNew, NULL); RegisterCallback(pCall, COUNTSTART, Countstartcallback, pNew, NULL);
RegisterCallback(pCall, COUNTEND, Countendcallback, pNew, NULL); RegisterCallback(pCall, COUNTEND, Countendcallback, pNew, NULL);

1
psi.c
View File

@ -70,6 +70,7 @@ void SiteInit(void)
INIT(AddTermProtocoll); INIT(AddTermProtocoll);
INIT(AddPhytronProtocoll); INIT(AddPhytronProtocoll);
INIT(AddSLSEchoProtocoll); INIT(AddSLSEchoProtocoll);
INIT(AddCharByCharProtocoll);
} }

22
sanscook.c
View File

@ -363,7 +363,7 @@ static int CookerGetPar(pCodri self, char *parname,
} }
} }
strncpy(pBuffer, pBueffel, iLen); strlcpy(pBuffer, pBueffel, iLen);
return 1; return 1;
} }
@ -393,7 +393,7 @@ static int CookerGetPar(pCodri self, char *parname,
return 0; return 0;
} }
sprintf(pBueffel, "%f", fVal); sprintf(pBueffel, "%f", fVal);
strncpy(pBuffer, pBueffel, iLen); strlcpy(pBuffer, pBueffel, iLen);
return 1; return 1;
} }
@ -446,31 +446,31 @@ static int CookerError(pCodri self, int *iCode, char *pError, int iLen)
*iCode = pPriv->iError; *iCode = pPriv->iError;
switch (pPriv->iError) { switch (pPriv->iError) {
case NOTINIT: case NOTINIT:
strncpy(pError, "ERROR: NOT Initialized!", iLen); strlcpy(pError, "ERROR: NOT Initialized!", iLen);
break; break;
case POWEROFF: case POWEROFF:
strncpy(pError, "ERROR: Power is OFF", iLen); strlcpy(pError, "ERROR: Power is OFF", iLen);
break; break;
case LOWRANGE: case LOWRANGE:
strncpy(pError, "ERROR: Lower limit violated", iLen); strlcpy(pError, "ERROR: Lower limit violated", iLen);
break; break;
case HIGHRANGE: case HIGHRANGE:
strncpy(pError, "ERROR: Upper limit violated", iLen); strlcpy(pError, "ERROR: Upper limit violated", iLen);
break; break;
case CONTIMEOUT: case CONTIMEOUT:
strncpy(pError, "ERROR: Internal controller timeout ", iLen); strlcpy(pError, "ERROR: Internal controller timeout ", iLen);
break; break;
case BADCOMMAND: case BADCOMMAND:
strncpy(pError, "ERROR: Controller did not understand command", iLen); strlcpy(pError, "ERROR: Controller did not understand command", iLen);
break; break;
case BADINPUT: case BADINPUT:
strncpy(pError, "A bad parameter was entered", iLen); strlcpy(pError, "A bad parameter was entered", iLen);
break; break;
case MOTERROR: case MOTERROR:
strncpy(pError, "ERROR: Iternal motor error in controller", iLen); strlcpy(pError, "ERROR: Iternal motor error in controller", iLen);
break; break;
case CONBUSY: case CONBUSY:
strncpy(pError, "ERROR: Controller is busy", iLen); strlcpy(pError, "ERROR: Controller is busy", iLen);
break; break;
default: default:
SerialError(pPriv->iError, pError, iLen); SerialError(pPriv->iError, pError, iLen);

2
sanslirebin.c
View File

@ -229,7 +229,7 @@ int MakeSansliRebin(SConnection * pCon, SicsInterp * pSics, void *pData,
eError); eError);
return 0; return 0;
} }
strncpy(correctionFilePath, argv[1], 512); strlcpy(correctionFilePath, argv[1], 512);
AddCommand(pSics, "sanslirebin", SansliRebin, NULL, NULL); AddCommand(pSics, "sanslirebin", SansliRebin, NULL, NULL);
SCSendOK(pCon); SCSendOK(pCon);
return 1; return 1;

2
sanswave.c
View File

@ -109,7 +109,7 @@ static int SWLimits(void *pData, float fVal, char *error, int iErrLen)
/* get tilt */ /* get tilt */
iRet = SWGetTilt(self->pSelector, &fTilt); iRet = SWGetTilt(self->pSelector, &fTilt);
if (!iRet) { if (!iRet) {
strncpy(error, "Failed to obtain tilt angle", iErrLen); strlcpy(error, "Failed to obtain tilt angle", iErrLen);
return 0; return 0;
} }

2
sinqhmdriv.c
View File

@ -60,7 +60,7 @@ static void PrintHMError(char *text, SConnection * pCon)
char pBueffel[1064]; char pBueffel[1064];
strcpy(pBueffel, "ERROR: Histogram Memory --> "); strcpy(pBueffel, "ERROR: Histogram Memory --> ");
strncat(pBueffel, text,1024); strlcat(pBueffel, text,1024);
SCWrite(pCon, pBueffel, eError); SCWrite(pCon, pBueffel, eError);
} }

22
sinqhttp.c
View File

@ -108,12 +108,12 @@ static int sinqHttpCheckResponse(pSinqHttp self)
} }
if (strstr(pPtr, "ERROR") != NULL) { if (strstr(pPtr, "ERROR") != NULL) {
memset(self->hmError, 0, 512 * sizeof(char)); memset(self->hmError, 0, 512 * sizeof(char));
strncpy(self->hmError, pPtr, len); strlcpy(self->hmError, pPtr, len);
self->errorCode = HTTPERROR; self->errorCode = HTTPERROR;
return 0; return 0;
} else if (strstr(pPtr, "Authentication Error") != NULL) { } else if (strstr(pPtr, "Authentication Error") != NULL) {
memset(self->hmError, 0, 512 * sizeof(char)); memset(self->hmError, 0, 512 * sizeof(char));
strncpy(self->hmError, pPtr, len); strlcpy(self->hmError, pPtr, len);
self->errorCode = BADAUTH; self->errorCode = BADAUTH;
return 0; return 0;
} }
@ -141,7 +141,7 @@ static int sinqHttpGet(pSinqHttp self, char *request)
httpStatus = ghttp_process(self->syncRequest); httpStatus = ghttp_process(self->syncRequest);
} }
if (httpStatus != ghttp_done) { if (httpStatus != ghttp_done) {
strncpy(self->hmError, "Reconnect", 511); strlcpy(self->hmError, "Reconnect", 511);
self->errorCode = SERVERERROR; self->errorCode = SERVERERROR;
return 0; return 0;
} else { } else {
@ -362,7 +362,7 @@ static int readStatus(pHistDriver pDriv)
pPtr = ghttp_get_body(self->syncRequest); pPtr = ghttp_get_body(self->syncRequest);
if (pPtr == NULL) { if (pPtr == NULL) {
strncpy(self->hmError, "No body in status response", 131); strlcpy(self->hmError, "No body in status response", 131);
self->errorCode = NOBODY; self->errorCode = NOBODY;
return 0; return 0;
} }
@ -415,7 +415,7 @@ static int SinqHttpStatus(pHistDriver self, SConnection * pCon)
ghttp_prepare(pPriv->syncRequest); ghttp_prepare(pPriv->syncRequest);
httpStatus = ghttp_process(pPriv->syncRequest); httpStatus = ghttp_process(pPriv->syncRequest);
if (httpStatus != ghttp_done) { if (httpStatus != ghttp_done) {
strncpy(pPriv->hmError, "Reconnect", 511); strlcpy(pPriv->hmError, "Reconnect", 511);
pPriv->errorCode = SERVERERROR; pPriv->errorCode = SERVERERROR;
pPriv->asyncRunning = 0; pPriv->asyncRunning = 0;
return HWFault; return HWFault;
@ -440,7 +440,7 @@ static int SinqHttpStatus(pHistDriver self, SConnection * pCon)
if (StringDictGet(self->pOption, "daq", daqStatus, 20) != 1) { if (StringDictGet(self->pOption, "daq", daqStatus, 20) != 1) {
pPriv->errorCode = BADSTATUS; pPriv->errorCode = BADSTATUS;
strncpy(pPriv->hmError, "ERROR: status does not contain DAQ field", strlcpy(pPriv->hmError, "ERROR: status does not contain DAQ field",
511); 511);
return HWFault; return HWFault;
} }
@ -468,7 +468,7 @@ static int SinqHttpError(pHistDriver self, int *code,
pPriv = (pSinqHttp) self->pPriv; pPriv = (pSinqHttp) self->pPriv;
assert(pPriv != NULL); assert(pPriv != NULL);
strncpy(error, pPriv->hmError, errLen); strlcpy(error, pPriv->hmError, errLen);
*code = pPriv->errorCode; *code = pPriv->errorCode;
return 1; return 1;
} }
@ -561,7 +561,7 @@ static int SinqHttpGetHistogram(pHistDriver self, SConnection * pCon,
len = ghttp_get_body_len(pPriv->syncRequest); len = ghttp_get_body_len(pPriv->syncRequest);
if (len < (end - start) * sizeof(int)) { if (len < (end - start) * sizeof(int)) {
pPriv->errorCode = BODYSHORT; pPriv->errorCode = BODYSHORT;
strncpy(pPriv->hmError, "Not enough data received from HM", 511); strlcpy(pPriv->hmError, "Not enough data received from HM", 511);
return HWFault; return HWFault;
} }
hmdata = (HistInt *) ghttp_get_body(pPriv->syncRequest); hmdata = (HistInt *) ghttp_get_body(pPriv->syncRequest);
@ -600,14 +600,14 @@ static HistInt *SinqHttpSubSample(pHistDriver self, SConnection * pCon,
len = ghttp_get_body_len(pPriv->syncRequest); len = ghttp_get_body_len(pPriv->syncRequest);
if (len <= 0) { if (len <= 0) {
strncpy(pPriv->hmError, "ERROR: no data returned from subsampling", strlcpy(pPriv->hmError, "ERROR: no data returned from subsampling",
511); 511);
pPriv->errorCode = BADSUBSAMPLE; pPriv->errorCode = BADSUBSAMPLE;
return NULL; return NULL;
} }
resultdata = malloc(len + 4); resultdata = malloc(len + 4);
if (resultdata == NULL) { if (resultdata == NULL) {
strncpy(pPriv->hmError, strlcpy(pPriv->hmError,
"ERROR: failed to allocate buffer for subsampling results", "ERROR: failed to allocate buffer for subsampling results",
511); 511);
pPriv->errorCode = HMNOMEMORY; pPriv->errorCode = HMNOMEMORY;
@ -632,7 +632,7 @@ static int SinqHttpSetHistogram(pHistDriver self, SConnection * pCon,
assert(pPriv != NULL); assert(pPriv != NULL);
pPriv->errorCode = NOTIMPLEMENTED; pPriv->errorCode = NOTIMPLEMENTED;
strncpy(pPriv->hmError, "Not implemented", 511); strlcpy(pPriv->hmError, "Not implemented", 511);
return HWFault; return HWFault;
} }

21
slsecho.c
View File

@ -15,6 +15,9 @@
* with mode being either r or w and convertflag being one of * with mode being either r or w and convertflag being one of
* none,read,write * none,read,write
* *
* There is an endianness issue here: swapDataBytes may or not be
* required according to the platform used.
*
* Created on: Mar 18, 2010 * Created on: Mar 18, 2010
* Author: Mark Koennecke * Author: Mark Koennecke
*/ */
@ -95,7 +98,18 @@ static double DSPfloat2double(ULONG input)
} }
return output; return output;
} }
/*----------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static void swapDataBytes(char *pMessage)
{
char tmp[4];
memcpy(tmp,pMessage+4,4);
pMessage[4] = tmp[3];
pMessage[5] = tmp[2];
pMessage[6] = tmp[1];
pMessage[7] = tmp[0];
}
/*-------------------------------------------------------------------------*/
static int EchoPack(Ascon *a) static int EchoPack(Ascon *a)
{ {
pSLSEcho echo = NULL; pSLSEcho echo = NULL;
@ -161,6 +175,7 @@ static int EchoPack(Ascon *a)
val = double2DSPfloat(dval); val = double2DSPfloat(dval);
} }
memcpy(pMessage+4,&val,4); memcpy(pMessage+4,&val,4);
swapDataBytes(pMessage);
/* printf("Sending code: 0x%x, val = %d\n", code, val); */ /* printf("Sending code: 0x%x, val = %d\n", code, val); */
return 1; return 1;
@ -170,7 +185,8 @@ static int EchoUnpack(Ascon *a)
{ {
pSLSEcho echo = a->private; pSLSEcho echo = a->private;
char *pMessage = NULL, printbuf[30]; char *pMessage = NULL, printbuf[30];
int code, val; int val;
unsigned char code = 0;
double dval; double dval;
@ -182,6 +198,7 @@ static int EchoUnpack(Ascon *a)
DynStringConcat(a->rdBuffer,printbuf); DynStringConcat(a->rdBuffer,printbuf);
DynStringConcatChar(a->rdBuffer,':'); DynStringConcatChar(a->rdBuffer,':');
swapDataBytes(pMessage);
memcpy(&val,pMessage+4, 4); memcpy(&val,pMessage+4, 4);
dval = (double)val; dval = (double)val;

293
slsmagnet.c
View File

@ -39,6 +39,7 @@
#include <conman.h> #include <conman.h>
#include <servlog.h> #include <servlog.h>
#include <fortify.h> #include <fortify.h>
#include <strlutil.h>
#include "evdriver.h" #include "evdriver.h"
#include <network.h> #include <network.h>
@ -296,418 +297,418 @@ static void slsdspCodeToText(int code, char *text, int textlen)
{ {
switch (code) { switch (code) {
case 0x0: case 0x0:
strncpy(text, "NO", textlen); strlcpy(text, "NO", textlen);
break; break;
case 0x1: case 0x1:
strncpy(text, "DEVICE_STATE_ERROR", textlen); strlcpy(text, "DEVICE_STATE_ERROR", textlen);
break; break;
case 0x2: case 0x2:
strncpy(text, "DEVICE_SUPERVISOR_DISABLED", textlen); strlcpy(text, "DEVICE_SUPERVISOR_DISABLED", textlen);
break; break;
case 0x3: case 0x3:
strncpy(text, "COMMAND_ABORT", textlen); strlcpy(text, "COMMAND_ABORT", textlen);
break; break;
case 0x4: case 0x4:
strncpy(text, "DATA_NOT_STORED", textlen); strlcpy(text, "DATA_NOT_STORED", textlen);
break; break;
case 0x5: case 0x5:
strncpy(text, "ERROR_ERASING_FLASH", textlen); strlcpy(text, "ERROR_ERASING_FLASH", textlen);
break; break;
case 0x6: case 0x6:
strncpy(text, "COMMUNICATION_BREAK", textlen); strlcpy(text, "COMMUNICATION_BREAK", textlen);
break; break;
case 0x7: case 0x7:
strncpy(text, "INTERNAL_COMMUNICATION_ERROR", textlen); strlcpy(text, "INTERNAL_COMMUNICATION_ERROR", textlen);
break; break;
case 0x8: case 0x8:
strncpy(text, "MASTER_CARD_ERROR", textlen); strlcpy(text, "MASTER_CARD_ERROR", textlen);
break; break;
case 0x9: case 0x9:
strncpy(text, "INTERNAL_BUFFER_FULL", textlen); strlcpy(text, "INTERNAL_BUFFER_FULL", textlen);
break; break;
case 0xa: case 0xa:
strncpy(text, "WRONG_SECTOR", textlen); strlcpy(text, "WRONG_SECTOR", textlen);
break; break;
case 0xb: case 0xb:
strncpy(text, "DATA_NOT_COPIED", textlen); strlcpy(text, "DATA_NOT_COPIED", textlen);
break; break;
case 0xc: case 0xc:
strncpy(text, "WRONG_DOWNLOAD_PARAMETERS", textlen); strlcpy(text, "WRONG_DOWNLOAD_PARAMETERS", textlen);
break; break;
case 0xd: case 0xd:
strncpy(text, "DEVICE_PARAMETRIZATION_ERROR", textlen); strlcpy(text, "DEVICE_PARAMETRIZATION_ERROR", textlen);
break; break;
case 0x10: case 0x10:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE", textlen); strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE", textlen);
break; break;
case 0x11: case 0x11:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_ON", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_ON", textlen);
break; break;
case 0x12: case 0x12:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_OFF", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_OFF", textlen);
break; break;
case 0x13: case 0x13:
strncpy(text, "TIMEOUT_MAIN_RELAY_ON", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_ON", textlen);
break; break;
case 0x14: case 0x14:
strncpy(text, "TIMEOUT_MAIN_RELAY_OFF", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_OFF", textlen);
break; break;
case 0x15: case 0x15:
strncpy(text, "TIMEOUT_DATA_DOWNLOAD", textlen); strlcpy(text, "TIMEOUT_DATA_DOWNLOAD", textlen);
break; break;
case 0x20: case 0x20:
strncpy(text, "INTERLOCK", textlen); strlcpy(text, "INTERLOCK", textlen);
break; break;
case 0x21: case 0x21:
strncpy(text, "MASTER_SWITCH", textlen); strlcpy(text, "MASTER_SWITCH", textlen);
break; break;
case 0x22: case 0x22:
strncpy(text, "MAGNET_INTERLOCK", textlen); strlcpy(text, "MAGNET_INTERLOCK", textlen);
break; break;
case 0x23: case 0x23:
strncpy(text, "TEMPERATURE_TRANSFORMER", textlen); strlcpy(text, "TEMPERATURE_TRANSFORMER", textlen);
break; break;
case 0x24: case 0x24:
strncpy(text, "TEMPERATURE_RECTIFIER", textlen); strlcpy(text, "TEMPERATURE_RECTIFIER", textlen);
break; break;
case 0x25: case 0x25:
strncpy(text, "TEMPERATURE_CONVERTER", textlen); strlcpy(text, "TEMPERATURE_CONVERTER", textlen);
break; break;
case 0x26: case 0x26:
strncpy(text, "CURRENT_TRANSDUCER", textlen); strlcpy(text, "CURRENT_TRANSDUCER", textlen);
break; break;
case 0x27: case 0x27:
strncpy(text, "TEMPERATURE_POLARITY_SWITCH", textlen); strlcpy(text, "TEMPERATURE_POLARITY_SWITCH", textlen);
break; break;
case 0x28: case 0x28:
strncpy(text, "POWER_SEMICONDUCTOR", textlen); strlcpy(text, "POWER_SEMICONDUCTOR", textlen);
break; break;
case 0x29: case 0x29:
strncpy(text, "MAIN_RELAY", textlen); strlcpy(text, "MAIN_RELAY", textlen);
break; break;
case 0x2a: case 0x2a:
strncpy(text, "AD_CONVERTER_CARD", textlen); strlcpy(text, "AD_CONVERTER_CARD", textlen);
break; break;
case 0x2b: case 0x2b:
strncpy(text, "POLARITY_SWITCH", textlen); strlcpy(text, "POLARITY_SWITCH", textlen);
break; break;
case 0x2c: case 0x2c:
strncpy(text, "AUXILIARY_RELAY", textlen); strlcpy(text, "AUXILIARY_RELAY", textlen);
break; break;
case 0x2d: case 0x2d:
strncpy(text, "MASTER_SWITCH_T1", textlen); strlcpy(text, "MASTER_SWITCH_T1", textlen);
break; break;
case 0x2e: case 0x2e:
strncpy(text, "MASTER_SWITCH_T2", textlen); strlcpy(text, "MASTER_SWITCH_T2", textlen);
break; break;
case 0x2f: case 0x2f:
strncpy(text, "TEMPERATURE_MAGNET", textlen); strlcpy(text, "TEMPERATURE_MAGNET", textlen);
break; break;
case 0x30: case 0x30:
strncpy(text, "WATER_MAGNET", textlen); strlcpy(text, "WATER_MAGNET", textlen);
break; break;
case 0x31: case 0x31:
strncpy(text, "WATER_RACK", textlen); strlcpy(text, "WATER_RACK", textlen);
break; break;
case 0x40: case 0x40:
strncpy(text, "LOAD_CURRENT_TOO_HIGH", textlen); strlcpy(text, "LOAD_CURRENT_TOO_HIGH", textlen);
break; break;
case 0x41: case 0x41:
strncpy(text, "DC_LINK_VOLTAGE_TOO_LOW", textlen); strlcpy(text, "DC_LINK_VOLTAGE_TOO_LOW", textlen);
break; break;
case 0x42: case 0x42:
strncpy(text, "DC_LINK_VOLTAGE_TOO_HIGH", textlen); strlcpy(text, "DC_LINK_VOLTAGE_TOO_HIGH", textlen);
break; break;
case 0x43: case 0x43:
strncpy(text, "LOAD_VOLTAGE_TOO_HIGH", textlen); strlcpy(text, "LOAD_VOLTAGE_TOO_HIGH", textlen);
break; break;
case 0x44: case 0x44:
strncpy(text, "LOAD_CURRENT_RIPPLE_TOO_HIGH", textlen); strlcpy(text, "LOAD_CURRENT_RIPPLE_TOO_HIGH", textlen);
break; break;
case 0x45: case 0x45:
strncpy(text, "DC_LINK_ISOLATION_NOT_OK", textlen); strlcpy(text, "DC_LINK_ISOLATION_NOT_OK", textlen);
break; break;
case 0x46: case 0x46:
strncpy(text, "LOAD_ISOLATION_NOT_OK", textlen); strlcpy(text, "LOAD_ISOLATION_NOT_OK", textlen);
break; break;
case 0x47: case 0x47:
strncpy(text, "LOAD_IMPEDANCE_OUT_OF_RANGE", textlen); strlcpy(text, "LOAD_IMPEDANCE_OUT_OF_RANGE", textlen);
break; break;
case 0x48: case 0x48:
strncpy(text, "SHUT_OFF_CURRENT_TOO_HIGH", textlen); strlcpy(text, "SHUT_OFF_CURRENT_TOO_HIGH", textlen);
break; break;
case 0x49: case 0x49:
strncpy(text, "LOAD_DC_CURRENT_TOO_HIGH", textlen); strlcpy(text, "LOAD_DC_CURRENT_TOO_HIGH", textlen);
break; break;
case 0x4a: case 0x4a:
strncpy(text, "CURRENT_I1A1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1A1_TOO_HIGH", textlen);
break; break;
case 0x4b: case 0x4b:
strncpy(text, "CURRENT_I1B1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1B1_TOO_HIGH", textlen);
break; break;
case 0x4c: case 0x4c:
strncpy(text, "CURRENT_I1A2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1A2_TOO_HIGH", textlen);
break; break;
case 0x4d: case 0x4d:
strncpy(text, "CURRENT_I1B2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1B2_TOO_HIGH", textlen);
break; break;
case 0x4e: case 0x4e:
strncpy(text, "CURRENT_I2A1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2A1_TOO_HIGH", textlen);
break; break;
case 0x4f: case 0x4f:
strncpy(text, "CURRENT_I2B1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2B1_TOO_HIGH", textlen);
break; break;
case 0x50: case 0x50:
strncpy(text, "CURRENT_I2A2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2A2_TOO_HIGH", textlen);
break; break;
case 0x51: case 0x51:
strncpy(text, "CURRENT_I2B2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2B2_TOO_HIGH", textlen);
break; break;
case 0x52: case 0x52:
strncpy(text, "CURRENT_I3P_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3P_TOO_HIGH", textlen);
break; break;
case 0x53: case 0x53:
strncpy(text, "CURRENT_I3N_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3N_TOO_HIGH", textlen);
break; break;
case 0x54: case 0x54:
strncpy(text, "CURRENT_IE_TOO_HIGH", textlen); strlcpy(text, "CURRENT_IE_TOO_HIGH", textlen);
break; break;
case 0x55: case 0x55:
strncpy(text, "VOLTAGE_U1A_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U1A_TOO_LOW", textlen);
break; break;
case 0x56: case 0x56:
strncpy(text, "VOLTAGE_U1B_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U1B_TOO_LOW", textlen);
break; break;
case 0x57: case 0x57:
strncpy(text, "DIFF_CURRENT_I1A1_I1A2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I1A1_I1A2_TOO_HIGH", textlen);
break; break;
case 0x58: case 0x58:
strncpy(text, "DIFF_CURRENT_I1B1_I1B2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I1B1_I1B2_TOO_HIGH", textlen);
break; break;
case 0x59: case 0x59:
strncpy(text, "DIFF_CURRENT_I2A1_I2A2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I2A1_I2A2_TOO_HIGH", textlen);
break; break;
case 0x5a: case 0x5a:
strncpy(text, "DIFF_CURRENT_I2B1_I2B2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I2B1_I2B2_TOO_HIGH", textlen);
break; break;
case 0x5b: case 0x5b:
strncpy(text, "DIFF_CURRENT_I3P_I3N_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I3P_I3N_TOO_HIGH", textlen);
break; break;
case 0x5c: case 0x5c:
strncpy(text, "CURRENT_I1A_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1A_TOO_HIGH", textlen);
break; break;
case 0x5d: case 0x5d:
strncpy(text, "CURRENT_I1B_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1B_TOO_HIGH", textlen);
break; break;
case 0x5e: case 0x5e:
strncpy(text, "CURRENT_I3A1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3A1_TOO_HIGH", textlen);
break; break;
case 0x5f: case 0x5f:
strncpy(text, "CURRENT_I3B1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3B1_TOO_HIGH", textlen);
break; break;
case 0x60: case 0x60:
strncpy(text, "CURRENT_I3A2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3A2_TOO_HIGH", textlen);
break; break;
case 0x61: case 0x61:
strncpy(text, "CURRENT_I3B2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3B2_TOO_HIGH", textlen);
break; break;
case 0x62: case 0x62:
strncpy(text, "CURRENT_I4_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I4_TOO_HIGH", textlen);
break; break;
case 0x63: case 0x63:
strncpy(text, "CURRENT_I5_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I5_TOO_HIGH", textlen);
break; break;
case 0x64: case 0x64:
strncpy(text, "DIFF_CURRENT_I3A1_I3A2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I3A1_I3A2_TOO_HIGH", textlen);
break; break;
case 0x65: case 0x65:
strncpy(text, "DIFF_CURRENT_I3B1_I3B2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I3B1_I3B2_TOO_HIGH", textlen);
break; break;
case 0x66: case 0x66:
strncpy(text, "DIFF_CURRENT_I4_I5_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I4_I5_TOO_HIGH", textlen);
break; break;
case 0x67: case 0x67:
strncpy(text, "VOLTAGE_U3A_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U3A_TOO_LOW", textlen);
break; break;
case 0x68: case 0x68:
strncpy(text, "VOLTAGE_U3B_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U3B_TOO_LOW", textlen);
break; break;
case 0x69: case 0x69:
strncpy(text, "VOLTAGE_U1_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U1_TOO_LOW", textlen);
break; break;
case 0x6a: case 0x6a:
strncpy(text, "VOLTAGE_U3A_TOO_HIGH", textlen); strlcpy(text, "VOLTAGE_U3A_TOO_HIGH", textlen);
break; break;
case 0x6b: case 0x6b:
strncpy(text, "VOLTAGE_U3B_TOO_HIGH", textlen); strlcpy(text, "VOLTAGE_U3B_TOO_HIGH", textlen);
break; break;
case 0x6c: case 0x6c:
strncpy(text, "SPEED_ERROR_TOO_HIGH", textlen); strlcpy(text, "SPEED_ERROR_TOO_HIGH", textlen);
break; break;
case 0x70: case 0x70:
strncpy(text, "MAIN_RELAY_A", textlen); strlcpy(text, "MAIN_RELAY_A", textlen);
break; break;
case 0x71: case 0x71:
strncpy(text, "MAIN_RELAY_B", textlen); strlcpy(text, "MAIN_RELAY_B", textlen);
break; break;
case 0x72: case 0x72:
strncpy(text, "POWER_SWITCH_A", textlen); strlcpy(text, "POWER_SWITCH_A", textlen);
break; break;
case 0x73: case 0x73:
strncpy(text, "POWER_SWITCH_B", textlen); strlcpy(text, "POWER_SWITCH_B", textlen);
break; break;
case 0x74: case 0x74:
strncpy(text, "MONITOR_TRAFO_A", textlen); strlcpy(text, "MONITOR_TRAFO_A", textlen);
break; break;
case 0x75: case 0x75:
strncpy(text, "MONITOR_TRAFO_B", textlen); strlcpy(text, "MONITOR_TRAFO_B", textlen);
break; break;
case 0x76: case 0x76:
strncpy(text, "TEMPERATURE_RECTIFIER_A", textlen); strlcpy(text, "TEMPERATURE_RECTIFIER_A", textlen);
break; break;
case 0x77: case 0x77:
strncpy(text, "TEMPERATURE_RECTIFIER_B", textlen); strlcpy(text, "TEMPERATURE_RECTIFIER_B", textlen);
break; break;
case 0x78: case 0x78:
strncpy(text, "TEMPERATURE_CONVERTER_A", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_A", textlen);
break; break;
case 0x79: case 0x79:
strncpy(text, "TEMPERATURE_CONVERTER_B", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_B", textlen);
break; break;
case 0x7a: case 0x7a:
strncpy(text, "TEMPERATURE_CONVERTER_A1", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_A1", textlen);
break; break;
case 0x7b: case 0x7b:
strncpy(text, "TEMPERATURE_CONVERTER_B1", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_B1", textlen);
break; break;
case 0x7c: case 0x7c:
strncpy(text, "TEMPERATURE_CONVERTER_A2", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_A2", textlen);
break; break;
case 0x7d: case 0x7d:
strncpy(text, "TEMPERATURE_CONVERTER_B2", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_B2", textlen);
break; break;
case 0x7e: case 0x7e:
strncpy(text, "TEMPERATURE_TRANSFORMER_A", textlen); strlcpy(text, "TEMPERATURE_TRANSFORMER_A", textlen);
break; break;
case 0x7f: case 0x7f:
strncpy(text, "TEMPERATURE_TRANSFORMER_B", textlen); strlcpy(text, "TEMPERATURE_TRANSFORMER_B", textlen);
break; break;
case 0x80: case 0x80:
strncpy(text, "WATER_RECTIFIER_A", textlen); strlcpy(text, "WATER_RECTIFIER_A", textlen);
break; break;
case 0x81: case 0x81:
strncpy(text, "WATER_RECTIFIER_B", textlen); strlcpy(text, "WATER_RECTIFIER_B", textlen);
break; break;
case 0x82: case 0x82:
strncpy(text, "WATER_CONVERTER_A", textlen); strlcpy(text, "WATER_CONVERTER_A", textlen);
break; break;
case 0x83: case 0x83:
strncpy(text, "WATER_CONVERTER_B", textlen); strlcpy(text, "WATER_CONVERTER_B", textlen);
break; break;
case 0x84: case 0x84:
strncpy(text, "WATER_CONVERTER_A1", textlen); strlcpy(text, "WATER_CONVERTER_A1", textlen);
break; break;
case 0x85: case 0x85:
strncpy(text, "WATER_CONVERTER_B1", textlen); strlcpy(text, "WATER_CONVERTER_B1", textlen);
break; break;
case 0x86: case 0x86:
strncpy(text, "WATER_CONVERTER_A2", textlen); strlcpy(text, "WATER_CONVERTER_A2", textlen);
break; break;
case 0x87: case 0x87:
strncpy(text, "WATER_CONVERTER_B2", textlen); strlcpy(text, "WATER_CONVERTER_B2", textlen);
break; break;
case 0x88: case 0x88:
strncpy(text, "WATER_TRANSFORMER_A", textlen); strlcpy(text, "WATER_TRANSFORMER_A", textlen);
break; break;
case 0x89: case 0x89:
strncpy(text, "WATER_TRANSFORMER_B", textlen); strlcpy(text, "WATER_TRANSFORMER_B", textlen);
break; break;
case 0x8a: case 0x8a:
strncpy(text, "DOOR_A", textlen); strlcpy(text, "DOOR_A", textlen);
break; break;
case 0x8b: case 0x8b:
strncpy(text, "DOOR_B", textlen); strlcpy(text, "DOOR_B", textlen);
break; break;
case 0x8c: case 0x8c:
strncpy(text, "DOOR_C", textlen); strlcpy(text, "DOOR_C", textlen);
break; break;
case 0x8d: case 0x8d:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A", textlen);
break; break;
case 0x8e: case 0x8e:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B", textlen);
break; break;
case 0x8f: case 0x8f:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A1", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A1", textlen);
break; break;
case 0x90: case 0x90:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B1", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B1", textlen);
break; break;
case 0x91: case 0x91:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A2", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A2", textlen);
break; break;
case 0x92: case 0x92:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B2", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B2", textlen);
break; break;
case 0x93: case 0x93:
strncpy(text, "CURRENT_TRANSDUCER_I3P", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I3P", textlen);
break; break;
case 0x94: case 0x94:
strncpy(text, "CURRENT_TRANSDUCER_I3N", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I3N", textlen);
break; break;
case 0x95: case 0x95:
strncpy(text, "MAGNET_INTERLOCK_1", textlen); strlcpy(text, "MAGNET_INTERLOCK_1", textlen);
break; break;
case 0x96: case 0x96:
strncpy(text, "MAGNET_INTERLOCK_2", textlen); strlcpy(text, "MAGNET_INTERLOCK_2", textlen);
break; break;
case 0x97: case 0x97:
strncpy(text, "VENTILATOR", textlen); strlcpy(text, "VENTILATOR", textlen);
break; break;
case 0x98: case 0x98:
strncpy(text, "EMERGENCY_SWITCH", textlen); strlcpy(text, "EMERGENCY_SWITCH", textlen);
break; break;
case 0x99: case 0x99:
strncpy(text, "CAPACITOR_DISCHARGE_A_ON", textlen); strlcpy(text, "CAPACITOR_DISCHARGE_A_ON", textlen);
break; break;
case 0x9a: case 0x9a:
strncpy(text, "CAPACITOR_DISCHARGE_B_ON", textlen); strlcpy(text, "CAPACITOR_DISCHARGE_B_ON", textlen);
break; break;
case 0x9b: case 0x9b:
strncpy(text, "CURRENT_TRANSDUCER_I4", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I4", textlen);
break; break;
case 0x9c: case 0x9c:
strncpy(text, "CURRENT_TRANSDUCER_I5", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I5", textlen);
break; break;
case 0xb0: case 0xb0:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_A", textlen); strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_A", textlen);
break; break;
case 0xb1: case 0xb1:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_B", textlen); strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_B", textlen);
break; break;
case 0xb2: case 0xb2:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_A_ON", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_A_ON", textlen);
break; break;
case 0xb3: case 0xb3:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_B_ON", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_B_ON", textlen);
break; break;
case 0xb4: case 0xb4:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_A_OFF", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_A_OFF", textlen);
break; break;
case 0xb5: case 0xb5:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_B_OFF", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_B_OFF", textlen);
break; break;
case 0xb6: case 0xb6:
strncpy(text, "TIMEOUT_MAIN_RELAY_A_ON", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_A_ON", textlen);
break; break;
case 0xb7: case 0xb7:
strncpy(text, "TIMEOUT_MAIN_RELAY_B_ON", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_B_ON", textlen);
break; break;
case 0xb8: case 0xb8:
strncpy(text, "TIMEOUT_MAIN_RELAY_A_OFF", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_A_OFF", textlen);
break; break;
case 0xb9: case 0xb9:
strncpy(text, "TIMEOUT_MAIN_RELAY_B_OFF", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_B_OFF", textlen);
break; break;
} }
} }
@ -733,19 +734,19 @@ static int SLSError(pEVDriver self, int *iCode, char *error, int iErrLen)
switch (*iCode) { switch (*iCode) {
case BADECHO: case BADECHO:
strncpy(error, "message sent and reply did not match", iErrLen); strlcpy(error, "message sent and reply did not match", iErrLen);
break; break;
case NOTCONNECTED: case NOTCONNECTED:
strncpy(error, "Not connected to device", iErrLen); strlcpy(error, "Not connected to device", iErrLen);
break; break;
case TIMEOUT: case TIMEOUT:
strncpy(error, "Timeout waiting for response", iErrLen); strlcpy(error, "Timeout waiting for response", iErrLen);
break; break;
case BADHIGHLIM: case BADHIGHLIM:
strncpy(error, "Device internal upper limit violated", iErrLen); strlcpy(error, "Device internal upper limit violated", iErrLen);
break; break;
case BADLOWLIM: case BADLOWLIM:
strncpy(error, "Device internal lower limit violated", iErrLen); strlcpy(error, "Device internal lower limit violated", iErrLen);
break; break;
default: default:
getRS232Error(*iCode, error, iErrLen); getRS232Error(*iCode, error, iErrLen);
@ -782,7 +783,7 @@ static int SLSSend(pEVDriver self, char *pCommand, char *pReply, int iLen)
SLSError(self, &ival, pReply, iLen); SLSError(self, &ival, pReply, iLen);
return 0; return 0;
} else { } else {
strncpy(pReply, "Done", iLen); strlcpy(pReply, "Done", iLen);
return 1; return 1;
} }
} else if (strcmp(pCommand, "on") == 0) { } else if (strcmp(pCommand, "on") == 0) {
@ -797,11 +798,11 @@ static int SLSSend(pEVDriver self, char *pCommand, char *pReply, int iLen)
SLSError(self, &ival, pReply, iLen); SLSError(self, &ival, pReply, iLen);
return 0; return 0;
} else { } else {
strncpy(pReply, "Done", iLen); strlcpy(pReply, "Done", iLen);
return 1; return 1;
} }
} else { } else {
strncpy(pReply, "SLSMagnet only understands on or off on send", iLen); strlcpy(pReply, "SLSMagnet only understands on or off on send", iLen);
return 0; return 0;
} }

284
slsvme.c
View File

@ -74,7 +74,7 @@ static int communicateSLS(pSLSDriv self, char *command,
self->iError = atoi(trim(text)); self->iError = atoi(trim(text));
/* read error description */ /* read error description */
pPtr = stptok(pPtr, text, 80, ":"); pPtr = stptok(pPtr, text, 80, ":");
strncpy(self->errorText, text, 80); strlcpy(self->errorText, text, 80);
return DEVERR; return DEVERR;
} }
return 1; return 1;
@ -96,418 +96,418 @@ static void slsdspCodeToText(int code, char *text, int textlen)
{ {
switch (code) { switch (code) {
case 0x0: case 0x0:
strncpy(text, "NO", textlen); strlcpy(text, "NO", textlen);
break; break;
case 0x1: case 0x1:
strncpy(text, "DEVICE_STATE_ERROR", textlen); strlcpy(text, "DEVICE_STATE_ERROR", textlen);
break; break;
case 0x2: case 0x2:
strncpy(text, "DEVICE_SUPERVISOR_DISABLED", textlen); strlcpy(text, "DEVICE_SUPERVISOR_DISABLED", textlen);
break; break;
case 0x3: case 0x3:
strncpy(text, "COMMAND_ABORT", textlen); strlcpy(text, "COMMAND_ABORT", textlen);
break; break;
case 0x4: case 0x4:
strncpy(text, "DATA_NOT_STORED", textlen); strlcpy(text, "DATA_NOT_STORED", textlen);
break; break;
case 0x5: case 0x5:
strncpy(text, "ERROR_ERASING_FLASH", textlen); strlcpy(text, "ERROR_ERASING_FLASH", textlen);
break; break;
case 0x6: case 0x6:
strncpy(text, "COMMUNICATION_BREAK", textlen); strlcpy(text, "COMMUNICATION_BREAK", textlen);
break; break;
case 0x7: case 0x7:
strncpy(text, "INTERNAL_COMMUNICATION_ERROR", textlen); strlcpy(text, "INTERNAL_COMMUNICATION_ERROR", textlen);
break; break;
case 0x8: case 0x8:
strncpy(text, "MASTER_CARD_ERROR", textlen); strlcpy(text, "MASTER_CARD_ERROR", textlen);
break; break;
case 0x9: case 0x9:
strncpy(text, "INTERNAL_BUFFER_FULL", textlen); strlcpy(text, "INTERNAL_BUFFER_FULL", textlen);
break; break;
case 0xa: case 0xa:
strncpy(text, "WRONG_SECTOR", textlen); strlcpy(text, "WRONG_SECTOR", textlen);
break; break;
case 0xb: case 0xb:
strncpy(text, "DATA_NOT_COPIED", textlen); strlcpy(text, "DATA_NOT_COPIED", textlen);
break; break;
case 0xc: case 0xc:
strncpy(text, "WRONG_DOWNLOAD_PARAMETERS", textlen); strlcpy(text, "WRONG_DOWNLOAD_PARAMETERS", textlen);
break; break;
case 0xd: case 0xd:
strncpy(text, "DEVICE_PARAMETRIZATION_ERROR", textlen); strlcpy(text, "DEVICE_PARAMETRIZATION_ERROR", textlen);
break; break;
case 0x10: case 0x10:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE", textlen); strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE", textlen);
break; break;
case 0x11: case 0x11:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_ON", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_ON", textlen);
break; break;
case 0x12: case 0x12:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_OFF", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_OFF", textlen);
break; break;
case 0x13: case 0x13:
strncpy(text, "TIMEOUT_MAIN_RELAY_ON", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_ON", textlen);
break; break;
case 0x14: case 0x14:
strncpy(text, "TIMEOUT_MAIN_RELAY_OFF", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_OFF", textlen);
break; break;
case 0x15: case 0x15:
strncpy(text, "TIMEOUT_DATA_DOWNLOAD", textlen); strlcpy(text, "TIMEOUT_DATA_DOWNLOAD", textlen);
break; break;
case 0x20: case 0x20:
strncpy(text, "INTERLOCK", textlen); strlcpy(text, "INTERLOCK", textlen);
break; break;
case 0x21: case 0x21:
strncpy(text, "MASTER_SWITCH", textlen); strlcpy(text, "MASTER_SWITCH", textlen);
break; break;
case 0x22: case 0x22:
strncpy(text, "MAGNET_INTERLOCK", textlen); strlcpy(text, "MAGNET_INTERLOCK", textlen);
break; break;
case 0x23: case 0x23:
strncpy(text, "TEMPERATURE_TRANSFORMER", textlen); strlcpy(text, "TEMPERATURE_TRANSFORMER", textlen);
break; break;
case 0x24: case 0x24:
strncpy(text, "TEMPERATURE_RECTIFIER", textlen); strlcpy(text, "TEMPERATURE_RECTIFIER", textlen);
break; break;
case 0x25: case 0x25:
strncpy(text, "TEMPERATURE_CONVERTER", textlen); strlcpy(text, "TEMPERATURE_CONVERTER", textlen);
break; break;
case 0x26: case 0x26:
strncpy(text, "CURRENT_TRANSDUCER", textlen); strlcpy(text, "CURRENT_TRANSDUCER", textlen);
break; break;
case 0x27: case 0x27:
strncpy(text, "TEMPERATURE_POLARITY_SWITCH", textlen); strlcpy(text, "TEMPERATURE_POLARITY_SWITCH", textlen);
break; break;
case 0x28: case 0x28:
strncpy(text, "POWER_SEMICONDUCTOR", textlen); strlcpy(text, "POWER_SEMICONDUCTOR", textlen);
break; break;
case 0x29: case 0x29:
strncpy(text, "MAIN_RELAY", textlen); strlcpy(text, "MAIN_RELAY", textlen);
break; break;
case 0x2a: case 0x2a:
strncpy(text, "AD_CONVERTER_CARD", textlen); strlcpy(text, "AD_CONVERTER_CARD", textlen);
break; break;
case 0x2b: case 0x2b:
strncpy(text, "POLARITY_SWITCH", textlen); strlcpy(text, "POLARITY_SWITCH", textlen);
break; break;
case 0x2c: case 0x2c:
strncpy(text, "AUXILIARY_RELAY", textlen); strlcpy(text, "AUXILIARY_RELAY", textlen);
break; break;
case 0x2d: case 0x2d:
strncpy(text, "MASTER_SWITCH_T1", textlen); strlcpy(text, "MASTER_SWITCH_T1", textlen);
break; break;
case 0x2e: case 0x2e:
strncpy(text, "MASTER_SWITCH_T2", textlen); strlcpy(text, "MASTER_SWITCH_T2", textlen);
break; break;
case 0x2f: case 0x2f:
strncpy(text, "TEMPERATURE_MAGNET", textlen); strlcpy(text, "TEMPERATURE_MAGNET", textlen);
break; break;
case 0x30: case 0x30:
strncpy(text, "WATER_MAGNET", textlen); strlcpy(text, "WATER_MAGNET", textlen);
break; break;
case 0x31: case 0x31:
strncpy(text, "WATER_RACK", textlen); strlcpy(text, "WATER_RACK", textlen);
break; break;
case 0x40: case 0x40:
strncpy(text, "LOAD_CURRENT_TOO_HIGH", textlen); strlcpy(text, "LOAD_CURRENT_TOO_HIGH", textlen);
break; break;
case 0x41: case 0x41:
strncpy(text, "DC_LINK_VOLTAGE_TOO_LOW", textlen); strlcpy(text, "DC_LINK_VOLTAGE_TOO_LOW", textlen);
break; break;
case 0x42: case 0x42:
strncpy(text, "DC_LINK_VOLTAGE_TOO_HIGH", textlen); strlcpy(text, "DC_LINK_VOLTAGE_TOO_HIGH", textlen);
break; break;
case 0x43: case 0x43:
strncpy(text, "LOAD_VOLTAGE_TOO_HIGH", textlen); strlcpy(text, "LOAD_VOLTAGE_TOO_HIGH", textlen);
break; break;
case 0x44: case 0x44:
strncpy(text, "LOAD_CURRENT_RIPPLE_TOO_HIGH", textlen); strlcpy(text, "LOAD_CURRENT_RIPPLE_TOO_HIGH", textlen);
break; break;
case 0x45: case 0x45:
strncpy(text, "DC_LINK_ISOLATION_NOT_OK", textlen); strlcpy(text, "DC_LINK_ISOLATION_NOT_OK", textlen);
break; break;
case 0x46: case 0x46:
strncpy(text, "LOAD_ISOLATION_NOT_OK", textlen); strlcpy(text, "LOAD_ISOLATION_NOT_OK", textlen);
break; break;
case 0x47: case 0x47:
strncpy(text, "LOAD_IMPEDANCE_OUT_OF_RANGE", textlen); strlcpy(text, "LOAD_IMPEDANCE_OUT_OF_RANGE", textlen);
break; break;
case 0x48: case 0x48:
strncpy(text, "SHUT_OFF_CURRENT_TOO_HIGH", textlen); strlcpy(text, "SHUT_OFF_CURRENT_TOO_HIGH", textlen);
break; break;
case 0x49: case 0x49:
strncpy(text, "LOAD_DC_CURRENT_TOO_HIGH", textlen); strlcpy(text, "LOAD_DC_CURRENT_TOO_HIGH", textlen);
break; break;
case 0x4a: case 0x4a:
strncpy(text, "CURRENT_I1A1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1A1_TOO_HIGH", textlen);
break; break;
case 0x4b: case 0x4b:
strncpy(text, "CURRENT_I1B1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1B1_TOO_HIGH", textlen);
break; break;
case 0x4c: case 0x4c:
strncpy(text, "CURRENT_I1A2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1A2_TOO_HIGH", textlen);
break; break;
case 0x4d: case 0x4d:
strncpy(text, "CURRENT_I1B2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1B2_TOO_HIGH", textlen);
break; break;
case 0x4e: case 0x4e:
strncpy(text, "CURRENT_I2A1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2A1_TOO_HIGH", textlen);
break; break;
case 0x4f: case 0x4f:
strncpy(text, "CURRENT_I2B1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2B1_TOO_HIGH", textlen);
break; break;
case 0x50: case 0x50:
strncpy(text, "CURRENT_I2A2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2A2_TOO_HIGH", textlen);
break; break;
case 0x51: case 0x51:
strncpy(text, "CURRENT_I2B2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I2B2_TOO_HIGH", textlen);
break; break;
case 0x52: case 0x52:
strncpy(text, "CURRENT_I3P_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3P_TOO_HIGH", textlen);
break; break;
case 0x53: case 0x53:
strncpy(text, "CURRENT_I3N_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3N_TOO_HIGH", textlen);
break; break;
case 0x54: case 0x54:
strncpy(text, "CURRENT_IE_TOO_HIGH", textlen); strlcpy(text, "CURRENT_IE_TOO_HIGH", textlen);
break; break;
case 0x55: case 0x55:
strncpy(text, "VOLTAGE_U1A_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U1A_TOO_LOW", textlen);
break; break;
case 0x56: case 0x56:
strncpy(text, "VOLTAGE_U1B_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U1B_TOO_LOW", textlen);
break; break;
case 0x57: case 0x57:
strncpy(text, "DIFF_CURRENT_I1A1_I1A2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I1A1_I1A2_TOO_HIGH", textlen);
break; break;
case 0x58: case 0x58:
strncpy(text, "DIFF_CURRENT_I1B1_I1B2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I1B1_I1B2_TOO_HIGH", textlen);
break; break;
case 0x59: case 0x59:
strncpy(text, "DIFF_CURRENT_I2A1_I2A2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I2A1_I2A2_TOO_HIGH", textlen);
break; break;
case 0x5a: case 0x5a:
strncpy(text, "DIFF_CURRENT_I2B1_I2B2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I2B1_I2B2_TOO_HIGH", textlen);
break; break;
case 0x5b: case 0x5b:
strncpy(text, "DIFF_CURRENT_I3P_I3N_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I3P_I3N_TOO_HIGH", textlen);
break; break;
case 0x5c: case 0x5c:
strncpy(text, "CURRENT_I1A_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1A_TOO_HIGH", textlen);
break; break;
case 0x5d: case 0x5d:
strncpy(text, "CURRENT_I1B_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I1B_TOO_HIGH", textlen);
break; break;
case 0x5e: case 0x5e:
strncpy(text, "CURRENT_I3A1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3A1_TOO_HIGH", textlen);
break; break;
case 0x5f: case 0x5f:
strncpy(text, "CURRENT_I3B1_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3B1_TOO_HIGH", textlen);
break; break;
case 0x60: case 0x60:
strncpy(text, "CURRENT_I3A2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3A2_TOO_HIGH", textlen);
break; break;
case 0x61: case 0x61:
strncpy(text, "CURRENT_I3B2_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I3B2_TOO_HIGH", textlen);
break; break;
case 0x62: case 0x62:
strncpy(text, "CURRENT_I4_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I4_TOO_HIGH", textlen);
break; break;
case 0x63: case 0x63:
strncpy(text, "CURRENT_I5_TOO_HIGH", textlen); strlcpy(text, "CURRENT_I5_TOO_HIGH", textlen);
break; break;
case 0x64: case 0x64:
strncpy(text, "DIFF_CURRENT_I3A1_I3A2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I3A1_I3A2_TOO_HIGH", textlen);
break; break;
case 0x65: case 0x65:
strncpy(text, "DIFF_CURRENT_I3B1_I3B2_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I3B1_I3B2_TOO_HIGH", textlen);
break; break;
case 0x66: case 0x66:
strncpy(text, "DIFF_CURRENT_I4_I5_TOO_HIGH", textlen); strlcpy(text, "DIFF_CURRENT_I4_I5_TOO_HIGH", textlen);
break; break;
case 0x67: case 0x67:
strncpy(text, "VOLTAGE_U3A_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U3A_TOO_LOW", textlen);
break; break;
case 0x68: case 0x68:
strncpy(text, "VOLTAGE_U3B_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U3B_TOO_LOW", textlen);
break; break;
case 0x69: case 0x69:
strncpy(text, "VOLTAGE_U1_TOO_LOW", textlen); strlcpy(text, "VOLTAGE_U1_TOO_LOW", textlen);
break; break;
case 0x6a: case 0x6a:
strncpy(text, "VOLTAGE_U3A_TOO_HIGH", textlen); strlcpy(text, "VOLTAGE_U3A_TOO_HIGH", textlen);
break; break;
case 0x6b: case 0x6b:
strncpy(text, "VOLTAGE_U3B_TOO_HIGH", textlen); strlcpy(text, "VOLTAGE_U3B_TOO_HIGH", textlen);
break; break;
case 0x6c: case 0x6c:
strncpy(text, "SPEED_ERROR_TOO_HIGH", textlen); strlcpy(text, "SPEED_ERROR_TOO_HIGH", textlen);
break; break;
case 0x70: case 0x70:
strncpy(text, "MAIN_RELAY_A", textlen); strlcpy(text, "MAIN_RELAY_A", textlen);
break; break;
case 0x71: case 0x71:
strncpy(text, "MAIN_RELAY_B", textlen); strlcpy(text, "MAIN_RELAY_B", textlen);
break; break;
case 0x72: case 0x72:
strncpy(text, "POWER_SWITCH_A", textlen); strlcpy(text, "POWER_SWITCH_A", textlen);
break; break;
case 0x73: case 0x73:
strncpy(text, "POWER_SWITCH_B", textlen); strlcpy(text, "POWER_SWITCH_B", textlen);
break; break;
case 0x74: case 0x74:
strncpy(text, "MONITOR_TRAFO_A", textlen); strlcpy(text, "MONITOR_TRAFO_A", textlen);
break; break;
case 0x75: case 0x75:
strncpy(text, "MONITOR_TRAFO_B", textlen); strlcpy(text, "MONITOR_TRAFO_B", textlen);
break; break;
case 0x76: case 0x76:
strncpy(text, "TEMPERATURE_RECTIFIER_A", textlen); strlcpy(text, "TEMPERATURE_RECTIFIER_A", textlen);
break; break;
case 0x77: case 0x77:
strncpy(text, "TEMPERATURE_RECTIFIER_B", textlen); strlcpy(text, "TEMPERATURE_RECTIFIER_B", textlen);
break; break;
case 0x78: case 0x78:
strncpy(text, "TEMPERATURE_CONVERTER_A", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_A", textlen);
break; break;
case 0x79: case 0x79:
strncpy(text, "TEMPERATURE_CONVERTER_B", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_B", textlen);
break; break;
case 0x7a: case 0x7a:
strncpy(text, "TEMPERATURE_CONVERTER_A1", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_A1", textlen);
break; break;
case 0x7b: case 0x7b:
strncpy(text, "TEMPERATURE_CONVERTER_B1", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_B1", textlen);
break; break;
case 0x7c: case 0x7c:
strncpy(text, "TEMPERATURE_CONVERTER_A2", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_A2", textlen);
break; break;
case 0x7d: case 0x7d:
strncpy(text, "TEMPERATURE_CONVERTER_B2", textlen); strlcpy(text, "TEMPERATURE_CONVERTER_B2", textlen);
break; break;
case 0x7e: case 0x7e:
strncpy(text, "TEMPERATURE_TRANSFORMER_A", textlen); strlcpy(text, "TEMPERATURE_TRANSFORMER_A", textlen);
break; break;
case 0x7f: case 0x7f:
strncpy(text, "TEMPERATURE_TRANSFORMER_B", textlen); strlcpy(text, "TEMPERATURE_TRANSFORMER_B", textlen);
break; break;
case 0x80: case 0x80:
strncpy(text, "WATER_RECTIFIER_A", textlen); strlcpy(text, "WATER_RECTIFIER_A", textlen);
break; break;
case 0x81: case 0x81:
strncpy(text, "WATER_RECTIFIER_B", textlen); strlcpy(text, "WATER_RECTIFIER_B", textlen);
break; break;
case 0x82: case 0x82:
strncpy(text, "WATER_CONVERTER_A", textlen); strlcpy(text, "WATER_CONVERTER_A", textlen);
break; break;
case 0x83: case 0x83:
strncpy(text, "WATER_CONVERTER_B", textlen); strlcpy(text, "WATER_CONVERTER_B", textlen);
break; break;
case 0x84: case 0x84:
strncpy(text, "WATER_CONVERTER_A1", textlen); strlcpy(text, "WATER_CONVERTER_A1", textlen);
break; break;
case 0x85: case 0x85:
strncpy(text, "WATER_CONVERTER_B1", textlen); strlcpy(text, "WATER_CONVERTER_B1", textlen);
break; break;
case 0x86: case 0x86:
strncpy(text, "WATER_CONVERTER_A2", textlen); strlcpy(text, "WATER_CONVERTER_A2", textlen);
break; break;
case 0x87: case 0x87:
strncpy(text, "WATER_CONVERTER_B2", textlen); strlcpy(text, "WATER_CONVERTER_B2", textlen);
break; break;
case 0x88: case 0x88:
strncpy(text, "WATER_TRANSFORMER_A", textlen); strlcpy(text, "WATER_TRANSFORMER_A", textlen);
break; break;
case 0x89: case 0x89:
strncpy(text, "WATER_TRANSFORMER_B", textlen); strlcpy(text, "WATER_TRANSFORMER_B", textlen);
break; break;
case 0x8a: case 0x8a:
strncpy(text, "DOOR_A", textlen); strlcpy(text, "DOOR_A", textlen);
break; break;
case 0x8b: case 0x8b:
strncpy(text, "DOOR_B", textlen); strlcpy(text, "DOOR_B", textlen);
break; break;
case 0x8c: case 0x8c:
strncpy(text, "DOOR_C", textlen); strlcpy(text, "DOOR_C", textlen);
break; break;
case 0x8d: case 0x8d:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A", textlen);
break; break;
case 0x8e: case 0x8e:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B", textlen);
break; break;
case 0x8f: case 0x8f:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A1", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A1", textlen);
break; break;
case 0x90: case 0x90:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B1", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B1", textlen);
break; break;
case 0x91: case 0x91:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A2", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A2", textlen);
break; break;
case 0x92: case 0x92:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B2", textlen); strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B2", textlen);
break; break;
case 0x93: case 0x93:
strncpy(text, "CURRENT_TRANSDUCER_I3P", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I3P", textlen);
break; break;
case 0x94: case 0x94:
strncpy(text, "CURRENT_TRANSDUCER_I3N", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I3N", textlen);
break; break;
case 0x95: case 0x95:
strncpy(text, "MAGNET_INTERLOCK_1", textlen); strlcpy(text, "MAGNET_INTERLOCK_1", textlen);
break; break;
case 0x96: case 0x96:
strncpy(text, "MAGNET_INTERLOCK_2", textlen); strlcpy(text, "MAGNET_INTERLOCK_2", textlen);
break; break;
case 0x97: case 0x97:
strncpy(text, "VENTILATOR", textlen); strlcpy(text, "VENTILATOR", textlen);
break; break;
case 0x98: case 0x98:
strncpy(text, "EMERGENCY_SWITCH", textlen); strlcpy(text, "EMERGENCY_SWITCH", textlen);
break; break;
case 0x99: case 0x99:
strncpy(text, "CAPACITOR_DISCHARGE_A_ON", textlen); strlcpy(text, "CAPACITOR_DISCHARGE_A_ON", textlen);
break; break;
case 0x9a: case 0x9a:
strncpy(text, "CAPACITOR_DISCHARGE_B_ON", textlen); strlcpy(text, "CAPACITOR_DISCHARGE_B_ON", textlen);
break; break;
case 0x9b: case 0x9b:
strncpy(text, "CURRENT_TRANSDUCER_I4", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I4", textlen);
break; break;
case 0x9c: case 0x9c:
strncpy(text, "CURRENT_TRANSDUCER_I5", textlen); strlcpy(text, "CURRENT_TRANSDUCER_I5", textlen);
break; break;
case 0xb0: case 0xb0:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_A", textlen); strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_A", textlen);
break; break;
case 0xb1: case 0xb1:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_B", textlen); strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_B", textlen);
break; break;
case 0xb2: case 0xb2:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_A_ON", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_A_ON", textlen);
break; break;
case 0xb3: case 0xb3:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_B_ON", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_B_ON", textlen);
break; break;
case 0xb4: case 0xb4:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_A_OFF", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_A_OFF", textlen);
break; break;
case 0xb5: case 0xb5:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_B_OFF", textlen); strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_B_OFF", textlen);
break; break;
case 0xb6: case 0xb6:
strncpy(text, "TIMEOUT_MAIN_RELAY_A_ON", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_A_ON", textlen);
break; break;
case 0xb7: case 0xb7:
strncpy(text, "TIMEOUT_MAIN_RELAY_B_ON", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_B_ON", textlen);
break; break;
case 0xb8: case 0xb8:
strncpy(text, "TIMEOUT_MAIN_RELAY_A_OFF", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_A_OFF", textlen);
break; break;
case 0xb9: case 0xb9:
strncpy(text, "TIMEOUT_MAIN_RELAY_B_OFF", textlen); strlcpy(text, "TIMEOUT_MAIN_RELAY_B_OFF", textlen);
break; break;
} }
} }
@ -611,11 +611,11 @@ static int SLSError(pEVDriver self, int *iCode, char *error, int iErrLen)
*iCode = pMe->iError; *iCode = pMe->iError;
if (pMe->iError == DEVERROR) { if (pMe->iError == DEVERROR) {
strncpy(error, pMe->errorText, iErrLen); strlcpy(error, pMe->errorText, iErrLen);
return 1; return 1;
} }
if (pMe->iError < -2000 || (pMe->iError >= 70 && pMe->iError < 83)) { if (pMe->iError < -2000 || (pMe->iError >= 70 && pMe->iError < 83)) {
strncpy(error, pMe->errorText, iErrLen); strlcpy(error, pMe->errorText, iErrLen);
return 1; return 1;
} }
@ -640,7 +640,7 @@ static int SLSSend(pEVDriver self, char *pCommand, char *pReply, int iLen)
} else if (strcmp(pCommand, "on") == 0) { } else if (strcmp(pCommand, "on") == 0) {
snprintf(command, 40, "w %d on\n", pMe->iNum); snprintf(command, 40, "w %d on\n", pMe->iNum);
} else { } else {
strncpy(command, pCommand, 40); strlcpy(command, pCommand, 40);
} }
iRet = communicateSLS(pMe, command, pReply, iLen); iRet = communicateSLS(pMe, command, pReply, iLen);
if (iRet < 0) { if (iRet < 0) {

6
sps.c
View File

@ -257,6 +257,10 @@ static int SPSBitPattern(pSPS self, SConnection *pCon)
unsigned char byte; unsigned char byte;
pDynString result = NULL; pDynString result = NULL;
if(self->iMode){
SCWrite(pCon,"00000 0001000 00001000 00010000", eValue);
return 1;
}
/* send an R command down to the SPS */ /* send an R command down to the SPS */
iRet = SPSCommand(self, "R", pBueffel, 255); iRet = SPSCommand(self, "R", pBueffel, 255);
if (!iRet) { if (!iRet) {
@ -446,7 +450,7 @@ int SPSGetADC(pSPS self, int iWhich, int *iValue)
pPtr++; pPtr++;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
pPtr++; /* skip whitespace */ pPtr++; /* skip whitespace */
strncpy(pNum, pPtr, 5); strlcpy(pNum, pPtr, 5);
pNum[5] = '\0'; pNum[5] = '\0';
pPtr += 5; pPtr += 5;
iADC[i] = atoi(pNum); iADC[i] = atoi(pNum);

2
swmotor.c
View File

@ -150,7 +150,7 @@ static long SWSetValue(void *pData, SConnection * pCon, float fVal)
sprintf(pCommand, "%s %d", self->switchFunc, self->myNumber); sprintf(pCommand, "%s %d", self->switchFunc, self->myNumber);
pTcl = (Tcl_Interp *) pServ->pSics->pTcl; pTcl = (Tcl_Interp *) pServ->pSics->pTcl;
status = Tcl_Eval(pTcl, pCommand); status = Tcl_Eval(pTcl, pCommand);
strncpy(pError, pTcl->result, 131); strlcpy(pError, pTcl->result, 131);
if (status != TCL_OK || strstr(pError, "OK") == NULL) { if (status != TCL_OK || strstr(pError, "OK") == NULL) {
sprintf(pCommand, "ERROR: %s while switching motor", pError); sprintf(pCommand, "ERROR: %s while switching motor", pError);
SCWrite(pCon, pCommand, eError); SCWrite(pCon, pCommand, eError);

2
swmotor2.c
View File

@ -155,7 +155,7 @@ static long SWSetValue(void *pData, SConnection * pCon, float fVal)
sprintf(pCommand, "%s %d", self->switchFunc, self->myNumber); sprintf(pCommand, "%s %d", self->switchFunc, self->myNumber);
pTcl = (Tcl_Interp *) pServ->pSics->pTcl; pTcl = (Tcl_Interp *) pServ->pSics->pTcl;
status = Tcl_Eval(pTcl, pCommand); status = Tcl_Eval(pTcl, pCommand);
strncpy(pError, pTcl->result, 131); strlcpy(pError, pTcl->result, 131);
if (status != TCL_OK || strstr(pError, "OK") == NULL) { if (status != TCL_OK || strstr(pError, "OK") == NULL) {
sprintf(pCommand, "ERROR: %s while switching motor", pError); sprintf(pCommand, "ERROR: %s while switching motor", pError);
SCWrite(pCon, pCommand, eError); SCWrite(pCon, pCommand, eError);

10
tabledrive.c
View File

@ -57,11 +57,11 @@ static int TableDriveCheckLimits(void *pData, float fVal, char *error,
tdMotor moti; tdMotor moti;
if (self == NULL || self->motorTable < 0) { if (self == NULL || self->motorTable < 0) {
strncpy(error, "Path Table Not Defined!", 25); strlcpy(error, "Path Table Not Defined!", 25);
return 0; return 0;
} }
if (fVal < 1. || fVal > self->tableLength) { if (fVal < 1. || fVal > self->tableLength) {
strncpy(error, "Out of Range", 25); strlcpy(error, "Out of Range", 25);
return 0; return 0;
} }
return 1; return 1;
@ -537,7 +537,7 @@ static int startASDS(pTableDrive self, SConnection * pCon, int target)
status = LLDnodePtr2First(self->motorTable); status = LLDnodePtr2First(self->motorTable);
while (status != 0) { while (status != 0) {
LLDnodeDataTo(self->motorTable, &moti); LLDnodeDataTo(self->motorTable, &moti);
strncpy(name, moti.motorName, 131); strlcpy(name, moti.motorName, 131);
strtolower(name); strtolower(name);
if (strstr(name, "ds") != NULL || strstr(name, "as") != NULL) { if (strstr(name, "ds") != NULL || strstr(name, "as") != NULL) {
if (target == ASDSTO0) { if (target == ASDSTO0) {
@ -570,7 +570,7 @@ static int startOthers(pTableDrive self, SConnection * pCon)
status = LLDnodePtr2First(self->motorTable); status = LLDnodePtr2First(self->motorTable);
while (status != 0) { while (status != 0) {
LLDnodeDataTo(self->motorTable, &moti); LLDnodeDataTo(self->motorTable, &moti);
strncpy(name, moti.motorName, 131); strlcpy(name, moti.motorName, 131);
strtolower(name); strtolower(name);
if (strstr(name, "ds") == NULL && strstr(name, "as") == NULL) { if (strstr(name, "ds") == NULL && strstr(name, "as") == NULL) {
targetValue = findTarget(moti, self->targetPosition); targetValue = findTarget(moti, self->targetPosition);
@ -929,7 +929,7 @@ int TableDriveAction(SConnection * pCon, SicsInterp * pSics, void *pData,
if (!SCMatchRights(pCon, usMugger)) { if (!SCMatchRights(pCon, usMugger)) {
return 0; return 0;
} }
strncpy(self->orientMotor, argv[2], 80); strlcpy(self->orientMotor, argv[2], 80);
self->oriInvalid = 1; self->oriInvalid = 1;
SCSendOK(pCon); SCSendOK(pCon);
return 1; return 1;

6
tasscan.c
View File

@ -70,7 +70,7 @@ static void strcenter(char *str, char *target, int iLength)
catch the error if target is to long catch the error if target is to long
*/ */
if (strlen(str) >= iLength) { if (strlen(str) >= iLength) {
strncpy(target, str, iLength); strlcpy(target, str, iLength);
} }
iPtr = (iLength - strlen(str)) / 2; iPtr = (iLength - strlen(str)) / 2;
@ -230,7 +230,7 @@ static int TASHeader(pScanData self)
DynarGet(self->pScanVar, i, &pPtr); DynarGet(self->pScanVar, i, &pPtr);
pVar = (pVarEntry) pPtr; pVar = (pVarEntry) pPtr;
if (pVar) { if (pVar) {
strncpy(pWork2, ScanVarName(pVar), 59); strlcpy(pWork2, ScanVarName(pVar), 59);
strtoupper(pWork2); strtoupper(pWork2);
sprintf(pWork, "D%s=%8.4f, ", pWork2, ScanVarStep(pVar)); sprintf(pWork, "D%s=%8.4f, ", pWork2, ScanVarStep(pVar));
strcat(pBueffel, pWork); strcat(pBueffel, pWork);
@ -411,7 +411,7 @@ static int TASHeader(pScanData self)
pVar = (pVarEntry) pPtr; pVar = (pVarEntry) pPtr;
if (pVar) { if (pVar) {
strcat(pBueffel, "F9.4,1X,"); strcat(pBueffel, "F9.4,1X,");
strncpy(pWork2, pVar->Name, 59); strlcpy(pWork2, pVar->Name, 59);
strtoupper(pWork2); strtoupper(pWork2);
strcenter(pWork2, pTen, 11); strcenter(pWork2, pTen, 11);
strcat(pHeader, pTen); strcat(pHeader, pTen);

6
tdchm.c
View File

@ -325,17 +325,17 @@ static int TDCGetError(pHistDriver self, int *iCode, char *perror,
*iCode = tdc->errorCode; *iCode = tdc->errorCode;
switch (tdc->errorCode) { switch (tdc->errorCode) {
case COMMERROR: case COMMERROR:
strncpy(perror, "Communication problem with TDC", iErrlen); strlcpy(perror, "Communication problem with TDC", iErrlen);
break; break;
case MAXEXCEEDED: case MAXEXCEEDED:
strncpy(perror, "Requested to many channels for read", iErrlen); strlcpy(perror, "Requested to many channels for read", iErrlen);
break; break;
default: default:
if (tdc->counter != NULL) { if (tdc->counter != NULL) {
tdc->counter->pDriv->GetError(tdc->counter->pDriv, tdc->counter->pDriv->GetError(tdc->counter->pDriv,
iCode, perror, iErrlen); iCode, perror, iErrlen);
} else { } else {
strncpy(perror, "Undefined error code", iErrlen); strlcpy(perror, "Undefined error code", iErrlen);
} }
break; break;
} }

2
velodorn.c
View File

@ -334,7 +334,7 @@ int DornierSend(void **pData, char *pCommand, char *pReply, int iRepLen)
if (*pPtr == '\0') { /* no command */ if (*pPtr == '\0') { /* no command */
return NOCOMMAND; return NOCOMMAND;
} }
strncpy(pOldCom, pPtr, 3); strlcpy(pOldCom, pPtr, 3);
iRet = SerialWriteRead(pData, pCommand, pReply, iRepLen); iRet = SerialWriteRead(pData, pCommand, pReply, iRepLen);
/* /*

10
velodornier.c
View File

@ -197,16 +197,16 @@ static int DornierError(pVelSelDriv self, int *iCode, char *error,
switch (pDorn->iLastError) { switch (pDorn->iLastError) {
case NOCOMMAND: case NOCOMMAND:
strncpy(error, "No command was specified, internal error", iErrLen); strlcpy(error, "No command was specified, internal error", iErrLen);
break; break;
case ECHOMISSING: case ECHOMISSING:
strncpy(error, "No echo received, may be busy", iErrLen); strlcpy(error, "No echo received, may be busy", iErrLen);
break; break;
case BADANALYSIS: case BADANALYSIS:
strncpy(error, "Error analysing status messge", iErrLen); strlcpy(error, "Error analysing status messge", iErrLen);
break; break;
case STARTTIMEOUT: case STARTTIMEOUT:
strncpy(error, "Velocity Selector failed to start", iErrLen); strlcpy(error, "Velocity Selector failed to start", iErrLen);
break; break;
default: default:
SerialError(pDorn->iLastError, error, iErrLen); SerialError(pDorn->iLastError, error, iErrLen);
@ -407,7 +407,7 @@ static int DornierText(pVelSelDriv self, char *pText, int iTextLen)
sprintf(pHelp, "Vaccum: %f, Accel: %f", sStatus.vacuum, sStatus.accel); sprintf(pHelp, "Vaccum: %f, Accel: %f", sStatus.vacuum, sStatus.accel);
strcat(pBueffel, pHelp); strcat(pBueffel, pHelp);
strncpy(pText, pBueffel, iTextLen); strlcpy(pText, pBueffel, iTextLen);
return 1; return 1;
} }