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

2
autowin.c
View File

@ -130,7 +130,7 @@ static int CalcCmd(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
if(nPar < 1){
strcpy(hmName,"hm");
} else {
strncpy(hmName,par[0]->value.v.text,30);
strlcpy(hmName,par[0]->value.v.text,30);
}
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;
switch (*iCode) {
case NOFUNC:
strncpy(pError, "Function not supported", iErrLen);
strlcpy(pError, "Function not supported", iErrLen);
break;
case BADINTERN:
case BADARG:
strncpy(pError,
strlcpy(pError,
"Programming problem, reset Controller & contact Programmer",
iErrLen);
break;
case NOTFIELD:
strncpy(pError, "Bruker not switched to field mode", iErrLen);
strlcpy(pError, "Bruker not switched to field mode", iErrLen);
break;
case BADRANGE:
strncpy(pError, "Requested value out of range", iErrLen);
strlcpy(pError, "Requested value out of range", iErrLen);
break;
case NOACCESS:
strncpy(pError, "No Access, check key position at Controller",
strlcpy(pError, "No Access, check key position at Controller",
iErrLen);
break;
case ERRPENDING:
strncpy(pError, "Error condition pending in Bruker Controller",
strlcpy(pError, "Error condition pending in Bruker Controller",
iErrLen);
break;
case NOPOWER:
strncpy(pError,
strlcpy(pError,
"Power OFF as consequence of some error in Bruker Controller",
iErrLen);
break;
case NOCONN:
strncpy(pError, "No Connection to Bruker Controller", iErrLen);
strlcpy(pError, "No Connection to Bruker Controller", iErrLen);
break;
case BTIMEOUT:
strncpy(pError, "Timeout at serial port", iErrLen);
strlcpy(pError, "Timeout at serial port", iErrLen);
break;
case NOPOLUNIT:
strncpy(pError,
strlcpy(pError,
"No polarity switching unit, try setting negative current",
iErrLen);
break;

14
docho.c
View File

@ -371,7 +371,7 @@ static int DoChoSetPar2(pCodri self, char *parname, char *pValue)
}
if (strstr(pReply, "error") != NULL) {
pPriv->iError = CHOPERROR;
strncpy(pPriv->pError, pReply, 79);
strlcpy(pPriv->pError, pReply, 79);
return 0;
} else {
pPriv->iError = 0;
@ -567,22 +567,22 @@ static int DoChoError(pCodri self, int *iCode, char *pError, int iLen)
*iCode = pPriv->iError;
switch (pPriv->iError) {
case UNDRIVABLE:
strncpy(pError, "Parameter is not drivable", iLen);
strlcpy(pError, "Parameter is not drivable", iLen);
break;
case UNKNOWNPAR:
strncpy(pError, "Parameter is unknown", iLen);
strlcpy(pError, "Parameter is unknown", iLen);
break;
case PARERROR:
strncpy(pError, "Internal parameter error", iLen);
strlcpy(pError, "Internal parameter error", iLen);
break;
case BADSYNC:
strncpy(pError, "Cannot drive slave chopper", iLen);
strlcpy(pError, "Cannot drive slave chopper", iLen);
break;
case CHOPERROR:
strncpy(pError, pPriv->pError, iLen);
strlcpy(pError, pPriv->pError, iLen);
break;
case BADSTOP:
strncpy(pError,
strlcpy(pError,
"User called STOP. WARNING: chopper is still untamed!", iLen);
break;
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);
strcat(pBueffel, pHelp);
strncpy(pText, pBueffel, iTextLen);
strlcpy(pText, pBueffel, iTextLen);
return 1;
}
@ -314,23 +314,23 @@ static int DornierError(pVelSelDriv self, int *iCode,
switch (pDorn->iLastError) {
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);
pDorn->haltCount++;
break;
case STARTED:
strncpy(error,
strlcpy(error,
"Started selector, standby and check manually when ready",
iErrLen);
break;
case INVALIDSTATUS:
strncpy(error, "Received invalid status reply", iErrLen);
strlcpy(error, "Received invalid status reply", iErrLen);
break;
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;
case NOSTATUS:
strncpy(error, "No successfull status request after 3 tries", iErrLen);
strlcpy(error, "No successfull status request after 3 tries", iErrLen);
break;
default:
getRS232Error(pDorn->iLastError, error, iErrLen);
@ -634,7 +634,7 @@ pVelSelDriv VSCreateDornier2003(char *name, Tcl_Interp * pTcl)
free(pDorn);
return NULL;
}
strncpy(pHost, pPtr, 131);
strlcpy(pHost, pPtr, 131);
/* port number */
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) {
case 0x0:
strncpy(text, "NO", textlen);
strlcpy(text, "NO", textlen);
break;
case 0x1:
strncpy(text, "DEVICE_STATE_ERROR", textlen);
strlcpy(text, "DEVICE_STATE_ERROR", textlen);
break;
case 0x2:
strncpy(text, "DEVICE_SUPERVISOR_DISABLED", textlen);
strlcpy(text, "DEVICE_SUPERVISOR_DISABLED", textlen);
break;
case 0x3:
strncpy(text, "COMMAND_ABORT", textlen);
strlcpy(text, "COMMAND_ABORT", textlen);
break;
case 0x4:
strncpy(text, "DATA_NOT_STORED", textlen);
strlcpy(text, "DATA_NOT_STORED", textlen);
break;
case 0x5:
strncpy(text, "ERROR_ERASING_FLASH", textlen);
strlcpy(text, "ERROR_ERASING_FLASH", textlen);
break;
case 0x6:
strncpy(text, "COMMUNICATION_BREAK", textlen);
strlcpy(text, "COMMUNICATION_BREAK", textlen);
break;
case 0x7:
strncpy(text, "INTERNAL_COMMUNICATION_ERROR", textlen);
strlcpy(text, "INTERNAL_COMMUNICATION_ERROR", textlen);
break;
case 0x8:
strncpy(text, "MASTER_CARD_ERROR", textlen);
strlcpy(text, "MASTER_CARD_ERROR", textlen);
break;
case 0x9:
strncpy(text, "INTERNAL_BUFFER_FULL", textlen);
strlcpy(text, "INTERNAL_BUFFER_FULL", textlen);
break;
case 0xa:
strncpy(text, "WRONG_SECTOR", textlen);
strlcpy(text, "WRONG_SECTOR", textlen);
break;
case 0xb:
strncpy(text, "DATA_NOT_COPIED", textlen);
strlcpy(text, "DATA_NOT_COPIED", textlen);
break;
case 0xc:
strncpy(text, "WRONG_DOWNLOAD_PARAMETERS", textlen);
strlcpy(text, "WRONG_DOWNLOAD_PARAMETERS", textlen);
break;
case 0xd:
strncpy(text, "DEVICE_PARAMETRIZATION_ERROR", textlen);
strlcpy(text, "DEVICE_PARAMETRIZATION_ERROR", textlen);
break;
case 0x10:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE", textlen);
strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE", textlen);
break;
case 0x11:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_ON", textlen);
strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_ON", textlen);
break;
case 0x12:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_OFF", textlen);
strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_OFF", textlen);
break;
case 0x13:
strncpy(text, "TIMEOUT_MAIN_RELAY_ON", textlen);
strlcpy(text, "TIMEOUT_MAIN_RELAY_ON", textlen);
break;
case 0x14:
strncpy(text, "TIMEOUT_MAIN_RELAY_OFF", textlen);
strlcpy(text, "TIMEOUT_MAIN_RELAY_OFF", textlen);
break;
case 0x15:
strncpy(text, "TIMEOUT_DATA_DOWNLOAD", textlen);
strlcpy(text, "TIMEOUT_DATA_DOWNLOAD", textlen);
break;
case 0x20:
strncpy(text, "INTERLOCK", textlen);
strlcpy(text, "INTERLOCK", textlen);
break;
case 0x21:
strncpy(text, "MASTER_SWITCH", textlen);
strlcpy(text, "MASTER_SWITCH", textlen);
break;
case 0x22:
strncpy(text, "MAGNET_INTERLOCK", textlen);
strlcpy(text, "MAGNET_INTERLOCK", textlen);
break;
case 0x23:
strncpy(text, "TEMPERATURE_TRANSFORMER", textlen);
strlcpy(text, "TEMPERATURE_TRANSFORMER", textlen);
break;
case 0x24:
strncpy(text, "TEMPERATURE_RECTIFIER", textlen);
strlcpy(text, "TEMPERATURE_RECTIFIER", textlen);
break;
case 0x25:
strncpy(text, "TEMPERATURE_CONVERTER", textlen);
strlcpy(text, "TEMPERATURE_CONVERTER", textlen);
break;
case 0x26:
strncpy(text, "CURRENT_TRANSDUCER", textlen);
strlcpy(text, "CURRENT_TRANSDUCER", textlen);
break;
case 0x27:
strncpy(text, "TEMPERATURE_POLARITY_SWITCH", textlen);
strlcpy(text, "TEMPERATURE_POLARITY_SWITCH", textlen);
break;
case 0x28:
strncpy(text, "POWER_SEMICONDUCTOR", textlen);
strlcpy(text, "POWER_SEMICONDUCTOR", textlen);
break;
case 0x29:
strncpy(text, "MAIN_RELAY", textlen);
strlcpy(text, "MAIN_RELAY", textlen);
break;
case 0x2a:
strncpy(text, "AD_CONVERTER_CARD", textlen);
strlcpy(text, "AD_CONVERTER_CARD", textlen);
break;
case 0x2b:
strncpy(text, "POLARITY_SWITCH", textlen);
strlcpy(text, "POLARITY_SWITCH", textlen);
break;
case 0x2c:
strncpy(text, "AUXILIARY_RELAY", textlen);
strlcpy(text, "AUXILIARY_RELAY", textlen);
break;
case 0x2d:
strncpy(text, "MASTER_SWITCH_T1", textlen);
strlcpy(text, "MASTER_SWITCH_T1", textlen);
break;
case 0x2e:
strncpy(text, "MASTER_SWITCH_T2", textlen);
strlcpy(text, "MASTER_SWITCH_T2", textlen);
break;
case 0x2f:
strncpy(text, "TEMPERATURE_MAGNET", textlen);
strlcpy(text, "TEMPERATURE_MAGNET", textlen);
break;
case 0x30:
strncpy(text, "WATER_MAGNET", textlen);
strlcpy(text, "WATER_MAGNET", textlen);
break;
case 0x31:
strncpy(text, "WATER_RACK", textlen);
strlcpy(text, "WATER_RACK", textlen);
break;
case 0x40:
strncpy(text, "LOAD_CURRENT_TOO_HIGH", textlen);
strlcpy(text, "LOAD_CURRENT_TOO_HIGH", textlen);
break;
case 0x41:
strncpy(text, "DC_LINK_VOLTAGE_TOO_LOW", textlen);
strlcpy(text, "DC_LINK_VOLTAGE_TOO_LOW", textlen);
break;
case 0x42:
strncpy(text, "DC_LINK_VOLTAGE_TOO_HIGH", textlen);
strlcpy(text, "DC_LINK_VOLTAGE_TOO_HIGH", textlen);
break;
case 0x43:
strncpy(text, "LOAD_VOLTAGE_TOO_HIGH", textlen);
strlcpy(text, "LOAD_VOLTAGE_TOO_HIGH", textlen);
break;
case 0x44:
strncpy(text, "LOAD_CURRENT_RIPPLE_TOO_HIGH", textlen);
strlcpy(text, "LOAD_CURRENT_RIPPLE_TOO_HIGH", textlen);
break;
case 0x45:
strncpy(text, "DC_LINK_ISOLATION_NOT_OK", textlen);
strlcpy(text, "DC_LINK_ISOLATION_NOT_OK", textlen);
break;
case 0x46:
strncpy(text, "LOAD_ISOLATION_NOT_OK", textlen);
strlcpy(text, "LOAD_ISOLATION_NOT_OK", textlen);
break;
case 0x47:
strncpy(text, "LOAD_IMPEDANCE_OUT_OF_RANGE", textlen);
strlcpy(text, "LOAD_IMPEDANCE_OUT_OF_RANGE", textlen);
break;
case 0x48:
strncpy(text, "SHUT_OFF_CURRENT_TOO_HIGH", textlen);
strlcpy(text, "SHUT_OFF_CURRENT_TOO_HIGH", textlen);
break;
case 0x49:
strncpy(text, "LOAD_DC_CURRENT_TOO_HIGH", textlen);
strlcpy(text, "LOAD_DC_CURRENT_TOO_HIGH", textlen);
break;
case 0x4a:
strncpy(text, "CURRENT_I1A1_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I1A1_TOO_HIGH", textlen);
break;
case 0x4b:
strncpy(text, "CURRENT_I1B1_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I1B1_TOO_HIGH", textlen);
break;
case 0x4c:
strncpy(text, "CURRENT_I1A2_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I1A2_TOO_HIGH", textlen);
break;
case 0x4d:
strncpy(text, "CURRENT_I1B2_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I1B2_TOO_HIGH", textlen);
break;
case 0x4e:
strncpy(text, "CURRENT_I2A1_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I2A1_TOO_HIGH", textlen);
break;
case 0x4f:
strncpy(text, "CURRENT_I2B1_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I2B1_TOO_HIGH", textlen);
break;
case 0x50:
strncpy(text, "CURRENT_I2A2_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I2A2_TOO_HIGH", textlen);
break;
case 0x51:
strncpy(text, "CURRENT_I2B2_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I2B2_TOO_HIGH", textlen);
break;
case 0x52:
strncpy(text, "CURRENT_I3P_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I3P_TOO_HIGH", textlen);
break;
case 0x53:
strncpy(text, "CURRENT_I3N_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I3N_TOO_HIGH", textlen);
break;
case 0x54:
strncpy(text, "CURRENT_IE_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_IE_TOO_HIGH", textlen);
break;
case 0x55:
strncpy(text, "VOLTAGE_U1A_TOO_LOW", textlen);
strlcpy(text, "VOLTAGE_U1A_TOO_LOW", textlen);
break;
case 0x56:
strncpy(text, "VOLTAGE_U1B_TOO_LOW", textlen);
strlcpy(text, "VOLTAGE_U1B_TOO_LOW", textlen);
break;
case 0x57:
strncpy(text, "DIFF_CURRENT_I1A1_I1A2_TOO_HIGH", textlen);
strlcpy(text, "DIFF_CURRENT_I1A1_I1A2_TOO_HIGH", textlen);
break;
case 0x58:
strncpy(text, "DIFF_CURRENT_I1B1_I1B2_TOO_HIGH", textlen);
strlcpy(text, "DIFF_CURRENT_I1B1_I1B2_TOO_HIGH", textlen);
break;
case 0x59:
strncpy(text, "DIFF_CURRENT_I2A1_I2A2_TOO_HIGH", textlen);
strlcpy(text, "DIFF_CURRENT_I2A1_I2A2_TOO_HIGH", textlen);
break;
case 0x5a:
strncpy(text, "DIFF_CURRENT_I2B1_I2B2_TOO_HIGH", textlen);
strlcpy(text, "DIFF_CURRENT_I2B1_I2B2_TOO_HIGH", textlen);
break;
case 0x5b:
strncpy(text, "DIFF_CURRENT_I3P_I3N_TOO_HIGH", textlen);
strlcpy(text, "DIFF_CURRENT_I3P_I3N_TOO_HIGH", textlen);
break;
case 0x5c:
strncpy(text, "CURRENT_I1A_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I1A_TOO_HIGH", textlen);
break;
case 0x5d:
strncpy(text, "CURRENT_I1B_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I1B_TOO_HIGH", textlen);
break;
case 0x5e:
strncpy(text, "CURRENT_I3A1_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I3A1_TOO_HIGH", textlen);
break;
case 0x5f:
strncpy(text, "CURRENT_I3B1_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I3B1_TOO_HIGH", textlen);
break;
case 0x60:
strncpy(text, "CURRENT_I3A2_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I3A2_TOO_HIGH", textlen);
break;
case 0x61:
strncpy(text, "CURRENT_I3B2_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I3B2_TOO_HIGH", textlen);
break;
case 0x62:
strncpy(text, "CURRENT_I4_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I4_TOO_HIGH", textlen);
break;
case 0x63:
strncpy(text, "CURRENT_I5_TOO_HIGH", textlen);
strlcpy(text, "CURRENT_I5_TOO_HIGH", textlen);
break;
case 0x64:
strncpy(text, "DIFF_CURRENT_I3A1_I3A2_TOO_HIGH", textlen);
strlcpy(text, "DIFF_CURRENT_I3A1_I3A2_TOO_HIGH", textlen);
break;
case 0x65:
strncpy(text, "DIFF_CURRENT_I3B1_I3B2_TOO_HIGH", textlen);
strlcpy(text, "DIFF_CURRENT_I3B1_I3B2_TOO_HIGH", textlen);
break;
case 0x66:
strncpy(text, "DIFF_CURRENT_I4_I5_TOO_HIGH", textlen);
strlcpy(text, "DIFF_CURRENT_I4_I5_TOO_HIGH", textlen);
break;
case 0x67:
strncpy(text, "VOLTAGE_U3A_TOO_LOW", textlen);
strlcpy(text, "VOLTAGE_U3A_TOO_LOW", textlen);
break;
case 0x68:
strncpy(text, "VOLTAGE_U3B_TOO_LOW", textlen);
strlcpy(text, "VOLTAGE_U3B_TOO_LOW", textlen);
break;
case 0x69:
strncpy(text, "VOLTAGE_U1_TOO_LOW", textlen);
strlcpy(text, "VOLTAGE_U1_TOO_LOW", textlen);
break;
case 0x6a:
strncpy(text, "VOLTAGE_U3A_TOO_HIGH", textlen);
strlcpy(text, "VOLTAGE_U3A_TOO_HIGH", textlen);
break;
case 0x6b:
strncpy(text, "VOLTAGE_U3B_TOO_HIGH", textlen);
strlcpy(text, "VOLTAGE_U3B_TOO_HIGH", textlen);
break;
case 0x6c:
strncpy(text, "SPEED_ERROR_TOO_HIGH", textlen);
strlcpy(text, "SPEED_ERROR_TOO_HIGH", textlen);
break;
case 0x70:
strncpy(text, "MAIN_RELAY_A", textlen);
strlcpy(text, "MAIN_RELAY_A", textlen);
break;
case 0x71:
strncpy(text, "MAIN_RELAY_B", textlen);
strlcpy(text, "MAIN_RELAY_B", textlen);
break;
case 0x72:
strncpy(text, "POWER_SWITCH_A", textlen);
strlcpy(text, "POWER_SWITCH_A", textlen);
break;
case 0x73:
strncpy(text, "POWER_SWITCH_B", textlen);
strlcpy(text, "POWER_SWITCH_B", textlen);
break;
case 0x74:
strncpy(text, "MONITOR_TRAFO_A", textlen);
strlcpy(text, "MONITOR_TRAFO_A", textlen);
break;
case 0x75:
strncpy(text, "MONITOR_TRAFO_B", textlen);
strlcpy(text, "MONITOR_TRAFO_B", textlen);
break;
case 0x76:
strncpy(text, "TEMPERATURE_RECTIFIER_A", textlen);
strlcpy(text, "TEMPERATURE_RECTIFIER_A", textlen);
break;
case 0x77:
strncpy(text, "TEMPERATURE_RECTIFIER_B", textlen);
strlcpy(text, "TEMPERATURE_RECTIFIER_B", textlen);
break;
case 0x78:
strncpy(text, "TEMPERATURE_CONVERTER_A", textlen);
strlcpy(text, "TEMPERATURE_CONVERTER_A", textlen);
break;
case 0x79:
strncpy(text, "TEMPERATURE_CONVERTER_B", textlen);
strlcpy(text, "TEMPERATURE_CONVERTER_B", textlen);
break;
case 0x7a:
strncpy(text, "TEMPERATURE_CONVERTER_A1", textlen);
strlcpy(text, "TEMPERATURE_CONVERTER_A1", textlen);
break;
case 0x7b:
strncpy(text, "TEMPERATURE_CONVERTER_B1", textlen);
strlcpy(text, "TEMPERATURE_CONVERTER_B1", textlen);
break;
case 0x7c:
strncpy(text, "TEMPERATURE_CONVERTER_A2", textlen);
strlcpy(text, "TEMPERATURE_CONVERTER_A2", textlen);
break;
case 0x7d:
strncpy(text, "TEMPERATURE_CONVERTER_B2", textlen);
strlcpy(text, "TEMPERATURE_CONVERTER_B2", textlen);
break;
case 0x7e:
strncpy(text, "TEMPERATURE_TRANSFORMER_A", textlen);
strlcpy(text, "TEMPERATURE_TRANSFORMER_A", textlen);
break;
case 0x7f:
strncpy(text, "TEMPERATURE_TRANSFORMER_B", textlen);
strlcpy(text, "TEMPERATURE_TRANSFORMER_B", textlen);
break;
case 0x80:
strncpy(text, "WATER_RECTIFIER_A", textlen);
strlcpy(text, "WATER_RECTIFIER_A", textlen);
break;
case 0x81:
strncpy(text, "WATER_RECTIFIER_B", textlen);
strlcpy(text, "WATER_RECTIFIER_B", textlen);
break;
case 0x82:
strncpy(text, "WATER_CONVERTER_A", textlen);
strlcpy(text, "WATER_CONVERTER_A", textlen);
break;
case 0x83:
strncpy(text, "WATER_CONVERTER_B", textlen);
strlcpy(text, "WATER_CONVERTER_B", textlen);
break;
case 0x84:
strncpy(text, "WATER_CONVERTER_A1", textlen);
strlcpy(text, "WATER_CONVERTER_A1", textlen);
break;
case 0x85:
strncpy(text, "WATER_CONVERTER_B1", textlen);
strlcpy(text, "WATER_CONVERTER_B1", textlen);
break;
case 0x86:
strncpy(text, "WATER_CONVERTER_A2", textlen);
strlcpy(text, "WATER_CONVERTER_A2", textlen);
break;
case 0x87:
strncpy(text, "WATER_CONVERTER_B2", textlen);
strlcpy(text, "WATER_CONVERTER_B2", textlen);
break;
case 0x88:
strncpy(text, "WATER_TRANSFORMER_A", textlen);
strlcpy(text, "WATER_TRANSFORMER_A", textlen);
break;
case 0x89:
strncpy(text, "WATER_TRANSFORMER_B", textlen);
strlcpy(text, "WATER_TRANSFORMER_B", textlen);
break;
case 0x8a:
strncpy(text, "DOOR_A", textlen);
strlcpy(text, "DOOR_A", textlen);
break;
case 0x8b:
strncpy(text, "DOOR_B", textlen);
strlcpy(text, "DOOR_B", textlen);
break;
case 0x8c:
strncpy(text, "DOOR_C", textlen);
strlcpy(text, "DOOR_C", textlen);
break;
case 0x8d:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A", textlen);
strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A", textlen);
break;
case 0x8e:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B", textlen);
strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B", textlen);
break;
case 0x8f:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A1", textlen);
strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A1", textlen);
break;
case 0x90:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B1", textlen);
strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B1", textlen);
break;
case 0x91:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A2", textlen);
strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_A2", textlen);
break;
case 0x92:
strncpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B2", textlen);
strlcpy(text, "POWER_SEMICONDUCTOR_CONVERTER_B2", textlen);
break;
case 0x93:
strncpy(text, "CURRENT_TRANSDUCER_I3P", textlen);
strlcpy(text, "CURRENT_TRANSDUCER_I3P", textlen);
break;
case 0x94:
strncpy(text, "CURRENT_TRANSDUCER_I3N", textlen);
strlcpy(text, "CURRENT_TRANSDUCER_I3N", textlen);
break;
case 0x95:
strncpy(text, "MAGNET_INTERLOCK_1", textlen);
strlcpy(text, "MAGNET_INTERLOCK_1", textlen);
break;
case 0x96:
strncpy(text, "MAGNET_INTERLOCK_2", textlen);
strlcpy(text, "MAGNET_INTERLOCK_2", textlen);
break;
case 0x97:
strncpy(text, "VENTILATOR", textlen);
strlcpy(text, "VENTILATOR", textlen);
break;
case 0x98:
strncpy(text, "EMERGENCY_SWITCH", textlen);
strlcpy(text, "EMERGENCY_SWITCH", textlen);
break;
case 0x99:
strncpy(text, "CAPACITOR_DISCHARGE_A_ON", textlen);
strlcpy(text, "CAPACITOR_DISCHARGE_A_ON", textlen);
break;
case 0x9a:
strncpy(text, "CAPACITOR_DISCHARGE_B_ON", textlen);
strlcpy(text, "CAPACITOR_DISCHARGE_B_ON", textlen);
break;
case 0x9b:
strncpy(text, "CURRENT_TRANSDUCER_I4", textlen);
strlcpy(text, "CURRENT_TRANSDUCER_I4", textlen);
break;
case 0x9c:
strncpy(text, "CURRENT_TRANSDUCER_I5", textlen);
strlcpy(text, "CURRENT_TRANSDUCER_I5", textlen);
break;
case 0xb0:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_A", textlen);
strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_A", textlen);
break;
case 0xb1:
strncpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_B", textlen);
strlcpy(text, "TIMEOUT_DC_LINK_VOLTAGE_PART_B", textlen);
break;
case 0xb2:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_A_ON", textlen);
strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_A_ON", textlen);
break;
case 0xb3:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_B_ON", textlen);
strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_B_ON", textlen);
break;
case 0xb4:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_A_OFF", textlen);
strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_A_OFF", textlen);
break;
case 0xb5:
strncpy(text, "TIMEOUT_AUXILIARY_RELAY_B_OFF", textlen);
strlcpy(text, "TIMEOUT_AUXILIARY_RELAY_B_OFF", textlen);
break;
case 0xb6:
strncpy(text, "TIMEOUT_MAIN_RELAY_A_ON", textlen);
strlcpy(text, "TIMEOUT_MAIN_RELAY_A_ON", textlen);
break;
case 0xb7:
strncpy(text, "TIMEOUT_MAIN_RELAY_B_ON", textlen);
strlcpy(text, "TIMEOUT_MAIN_RELAY_B_ON", textlen);
break;
case 0xb8:
strncpy(text, "TIMEOUT_MAIN_RELAY_A_OFF", textlen);
strlcpy(text, "TIMEOUT_MAIN_RELAY_A_OFF", textlen);
break;
case 0xb9:
strncpy(text, "TIMEOUT_MAIN_RELAY_B_OFF", textlen);
strlcpy(text, "TIMEOUT_MAIN_RELAY_B_OFF", textlen);
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);
return 0;
}
strncpy(buf, argv[0], i);
strlcpy(buf, argv[0], i);
buf[i] = '\0';
host = buf;
} 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) {
case ECBILLEGALFUNC:
strncpy(buffer, "Illegal ECB function called", maxBuffer);
strlcpy(buffer, "Illegal ECB function called", maxBuffer);
return;
case ECBOVERFLOW:
strncpy(buffer,
strlcpy(buffer,
"You tried to copy more then 64K onto the poor ECB, REFUSED!",
maxBuffer);
return;

18
ecbcounter.c
View File

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

16
ecbdriv.c
View File

@ -880,29 +880,29 @@ static void ECBGetError(void *pData, int *iCode, char *buffer,
*iCode = self->errorCode;
switch (self->errorCode) {
case COMMERROR:
strncpy(buffer, "communication problem with ECB", bufferlen);
strlcpy(buffer, "communication problem with ECB", bufferlen);
break;
case ECBMANUELL:
strncpy(buffer, "ECB is in manual mode, trying to switch...",
strlcpy(buffer, "ECB is in manual mode, trying to switch...",
bufferlen);
break;
case ECBINUSE:
strncpy(buffer, "Power supply is in use", bufferlen);
strlcpy(buffer, "Power supply is in use", bufferlen);
break;
case ECBINHIBIT:
strncpy(buffer, "motor is inhibited", bufferlen);
strlcpy(buffer, "motor is inhibited", bufferlen);
break;
case ECBRUNNING:
strncpy(buffer, "motor is running", bufferlen);
strlcpy(buffer, "motor is running", bufferlen);
break;
case ECBSTART:
strncpy(buffer, "failed to start motor", bufferlen);
strlcpy(buffer, "failed to start motor", bufferlen);
break;
case ECBLIMIT:
strncpy(buffer, "hit limit switch or amplifier error", bufferlen);
strlcpy(buffer, "hit limit switch or amplifier error", bufferlen);
break;
default:
strncpy(buffer, "unidentified error code", bufferlen);
strlcpy(buffer, "unidentified error code", bufferlen);
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);
if (iMSR != 0) {
EL734Error2Text(pBueffel, iMSR);
strncpy(buffer, pBueffel, (iBufLen - 1));
strlcpy(buffer, pBueffel, (iBufLen - 1));
*iCode = iMSR;
return;
} 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 */
EL734_ErrInfo(&pErr, &iMSR, &iOMSR, &iSS);
EL734Error2Text(pBueffel, iMSR);
strncpy(buffer, pBueffel, (iBufLen - 1));
strlcpy(buffer, pBueffel, (iBufLen - 1));
*iCode = iMSR;
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);
if (iMSR != 0) {
EL734Error2Text(pBueffel, iMSR);
strncpy(buffer, pBueffel, (iBufLen - 1));
strlcpy(buffer, pBueffel, (iBufLen - 1));
*iCode = iMSR;
return;
} 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 */
EL734_ErrInfo(&pErr, &iMSR, &iOMSR, &iSS);
EL734Error2Text(pBueffel, iMSR);
strncpy(buffer, pBueffel, (iBufLen - 1));
strlcpy(buffer, pBueffel, (iBufLen - 1));
*iCode = iMSR;
return;

32
el734hp.c
View File

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

10
el737driv.c
View File

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

26
el737hpdriv.c
View File

@ -437,47 +437,47 @@ static int EL737GetError(struct __COUNTER *self, int *iCode,
*iCode = pPriv->errorCode;
switch (pPriv->errorCode) {
case OFFLINE:
strncpy(pError, "EL737 is offline", errLen);
strlcpy(pError, "EL737 is offline", errLen);
break;
case OVERFLOW:
strncpy(pError, "EL737 reported overflow, communication problem",
strlcpy(pError, "EL737 reported overflow, communication problem",
errLen);
break;
case BADRANGE:
strncpy(pError, "EL737 parameter is out of range", errLen);
strlcpy(pError, "EL737 parameter is out of range", errLen);
break;
case BADTRANGE:
strncpy(pError, "preset timer out of range", errLen);
strlcpy(pError, "preset timer out of range", errLen);
break;
case BADCOMMAND:
strncpy(pError, "EL737 received unknown command or is busy", errLen);
strlcpy(pError, "EL737 received unknown command or is busy", errLen);
break;
case BADPARAM:
strncpy(pError, "EL737 parameter is awful", errLen);
strlcpy(pError, "EL737 parameter is awful", errLen);
break;
case NOPARAM:
strncpy(pError, "EL737 parameter missing", errLen);
strlcpy(pError, "EL737 parameter missing", errLen);
break;
case TOMANYCOUNTS:
strncpy(pError, "EL737 counters overflowed", errLen);
strlcpy(pError, "EL737 counters overflowed", errLen);
break;
case SYSERROR:
strncpy(pError, "EL737 has an internal system error", errLen);
strlcpy(pError, "EL737 has an internal system error", errLen);
break;
case BADREPLY:
snprintf(pError, errLen, "EL737 sent an unexpected reply: %s",
pPriv->badReply);
break;
case SELECTFAIL:
strncpy(pError, "select system call failed, network trouble", errLen);
strlcpy(pError, "select system call failed, network trouble", errLen);
break;
case TIMEOUT737:
strncpy(pError,
strlcpy(pError,
"timeout or network problem while waiting for status repsonse",
errLen);
break;
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);
break;
default:
@ -672,7 +672,7 @@ pCounterDriver MakeEL737HP(SConnection * pCon, char *name,
return NULL;
}
port = atoi(argv[1]);
strncpy(pHost, argv[0], 131);
strlcpy(pHost, argv[0], 131);
/*
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;
switch (pPriv->errorCode) {
case OFFLINE:
strncpy(pError, "EL737 is offline", errLen);
strlcpy(pError, "EL737 is offline", errLen);
break;
case OVERFLOW:
strncpy(pError, "EL737 reported overflow, communication problem",
strlcpy(pError, "EL737 reported overflow, communication problem",
errLen);
break;
case BADRANGE:
strncpy(pError, "EL737 parameter is out of range", errLen);
strlcpy(pError, "EL737 parameter is out of range", errLen);
break;
case BADTRANGE:
strncpy(pError, "preset timer out of range", errLen);
strlcpy(pError, "preset timer out of range", errLen);
break;
case BADCOMMAND:
strncpy(pError, "EL737 received unknown command or is busy", errLen);
strlcpy(pError, "EL737 received unknown command or is busy", errLen);
break;
case BADPARAM:
strncpy(pError, "EL737 parameter is awful", errLen);
strlcpy(pError, "EL737 parameter is awful", errLen);
break;
case NOPARAM:
strncpy(pError, "EL737 parameter missing", errLen);
strlcpy(pError, "EL737 parameter missing", errLen);
break;
case TOMANYCOUNTS:
strncpy(pError, "EL737 counters overflowed", errLen);
strlcpy(pError, "EL737 counters overflowed", errLen);
break;
case SYSERROR:
strncpy(pError, "EL737 has an internal system error", errLen);
strlcpy(pError, "EL737 has an internal system error", errLen);
break;
case BADREPLY:
snprintf(pError, errLen, "EL737 sent an unexpected reply: %s",
pPriv->badReply);
break;
case SELECTFAIL:
strncpy(pError, "select system call failed, network trouble", errLen);
strlcpy(pError, "select system call failed, network trouble", errLen);
break;
case TIMEOUT737:
strncpy(pError,
strlcpy(pError,
"timeout or network problem while waiting for status repsonse",
errLen);
break;
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);
break;
case DETOVERLOAD:
strncpy(pError, "Shutter closed due to detector overload", errLen);
strlcpy(pError, "Shutter closed due to detector overload", errLen);
break;
default:
getRS232Error(pPriv->errorCode, pError, errLen);
@ -689,7 +689,7 @@ pCounterDriver MakeEL737hpsps(SConnection * pCon, char *name,
return NULL;
}
port = atoi(argv[1]);
strncpy(pHost, argv[0], 131);
strlcpy(pHost, argv[0], 131);
/*
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) {
memset(pPriv->savedStarMessage, 0, 20);
strncpy(pPriv->savedStarMessage, pReply, 19);
strlcpy(pPriv->savedStarMessage, pReply, 19);
pPriv->haveSavedStarMessage = 1;
status = readRS232TillTerm(pPriv->controller, pReply, &savedLen);
if (status < 0) {
@ -332,31 +332,31 @@ static int EL737GetError(struct __COUNTER *self, int *iCode,
*iCode = pPriv->errorCode;
switch (pPriv->errorCode) {
case OFFLINE:
strncpy(pError, "EL737 is offline", errLen);
strlcpy(pError, "EL737 is offline", errLen);
break;
case BADRANGE:
strncpy(pError, "EL737 parameter is out of range", errLen);
strlcpy(pError, "EL737 parameter is out of range", errLen);
break;
case BADCOMMAND:
strncpy(pError, "EL737 received unknown command or is busy", errLen);
strlcpy(pError, "EL737 received unknown command or is busy", errLen);
break;
case BADPARAM:
strncpy(pError, "EL737 parameter is awful", errLen);
strlcpy(pError, "EL737 parameter is awful", errLen);
break;
case NOPARAM:
strncpy(pError, "EL737 parameter missing", errLen);
strlcpy(pError, "EL737 parameter missing", errLen);
break;
case TOMANYCOUNTS:
strncpy(pError, "EL737 counters overflowed", errLen);
strlcpy(pError, "EL737 counters overflowed", errLen);
break;
case SYSERROR:
strncpy(pError, "EL737 has an internal system error", errLen);
strlcpy(pError, "EL737 has an internal system error", errLen);
break;
case BADREPLY:
strncpy(pError, "EL737 sent an unexpected reply", errLen);
strlcpy(pError, "EL737 sent an unexpected reply", errLen);
break;
case SELECTFAIL:
strncpy(pError, "select system call failed, network trouble", errLen);
strlcpy(pError, "select system call failed, network trouble", errLen);
default:
getRS232Error(pPriv->errorCode, pError, errLen);
}
@ -516,7 +516,7 @@ pCounterDriver MakeEL737HPV2(SConnection * pCon, char *name,
return NULL;
}
port = atoi(argv[1]);
strncpy(pHost, argv[0], 131);
strlcpy(pHost, argv[0], 131);
/*
allocate a bank worth of memory ...........

42
el755driv.c
View File

@ -14,6 +14,8 @@
#include <math.h>
#include <assert.h>
#include <fortify.h>
#include <strlutil.h>
#include <conman.h>
#include <servlog.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);
switch (*iCode) {
case CAPSIZED:
strncpy(error, "Powersupply has capsized, try lower current", iErrLen);
strlcpy(error, "Powersupply has capsized, try lower current", iErrLen);
break;
case EL755__TURNED_OFF:
strncpy(error, "EL755__TURNED_OF", iErrLen);
strlcpy(error, "EL755__TURNED_OF", iErrLen);
break;
case EL755__TOO_MANY:
strncpy(error, "EL755__TO_MANY", iErrLen);
strlcpy(error, "EL755__TO_MANY", iErrLen);
break;
case EL755__TOO_LARGE:
strncpy(error, "EL755__TOO_LARGE", iErrLen);
strlcpy(error, "EL755__TOO_LARGE", iErrLen);
break;
case EL755__OVFLOW:
strncpy(error, "EL755_OVFLOW", iErrLen);
strlcpy(error, "EL755_OVFLOW", iErrLen);
break;
case EL755__OUT_OF_RANGE:
strncpy(error, "EL755_OUT_OF_RANGE", iErrLen);
strlcpy(error, "EL755_OUT_OF_RANGE", iErrLen);
break;
case EL755__OFFLINE:
strncpy(error, "EL755_OFFLINE", iErrLen);
strlcpy(error, "EL755_OFFLINE", iErrLen);
break;
case EL755__NO_SOCKET:
strncpy(error, "EL755__NO_SOCKET", iErrLen);
strlcpy(error, "EL755__NO_SOCKET", iErrLen);
break;
case EL755__NOT_OPEN:
strncpy(error, "EL755__NOT_OPEN", iErrLen);
strlcpy(error, "EL755__NOT_OPEN", iErrLen);
break;
case EL755__FORCED_CLOSED:
strncpy(error, "EL755__FORCED_CLOSED", iErrLen);
strlcpy(error, "EL755__FORCED_CLOSED", iErrLen);
break;
case EL755__BAD_TMO:
strncpy(error, "EL755__BAD_TMO", iErrLen);
strlcpy(error, "EL755__BAD_TMO", iErrLen);
break;
case EL755__BAD_SOCKET:
strncpy(error, "EL755__BAD_SOCKET", iErrLen);
strlcpy(error, "EL755__BAD_SOCKET", iErrLen);
break;
case EL755__BAD_PAR:
strncpy(error, "EL755__BAD_PAR", iErrLen);
strlcpy(error, "EL755__BAD_PAR", iErrLen);
break;
case EL755__BAD_OFL:
strncpy(error, "EL755__BAD_OFL", iErrLen);
strlcpy(error, "EL755__BAD_OFL", iErrLen);
break;
case EL755__BAD_MALLOC:
strncpy(error, "EL755__BAD_MALLOC", iErrLen);
strlcpy(error, "EL755__BAD_MALLOC", iErrLen);
break;
case EL755__BAD_ILLG:
strncpy(error, "EL755__BAD_ILLG", iErrLen);
strlcpy(error, "EL755__BAD_ILLG", iErrLen);
break;
case EL755__BAD_DEV:
strncpy(error, "EL755__BAD_DEV", iErrLen);
strlcpy(error, "EL755__BAD_DEV", iErrLen);
break;
case EL755__BAD_CMD:
strncpy(error, "EL755__BAD_CMD", iErrLen);
strlcpy(error, "EL755__BAD_CMD", iErrLen);
break;
case EL755__BAD_ASYNSRV:
strncpy(error, "EL755__BAD_ASYNSRV", iErrLen);
strlcpy(error, "EL755__BAD_ASYNSRV", iErrLen);
break;
default:
sprintf(pBueffel, "Unknown error %d found", *iCode);
strncpy(error, pBueffel, iErrLen);
strlcpy(error, pBueffel, iErrLen);
break;
}

11
eurodriv.c
View File

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

2
haakedriv.c
View File

@ -113,7 +113,7 @@ int HaakeHandler(void *object)
if (strcmp(eab->ans, eab->version) == 0) {
/* we are still connected with the same device */
} 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 */
eab->errCode = EASE_DEV_CHANGED;
eab->state = EASE_idle;

4
itc4driv.c
View File

@ -46,7 +46,7 @@
#include <conman.h>
#include <servlog.h>
#include <fortify.h>
#include <strlutil.h>
#include "evdriver.h"
#include "hardsup/itc4util.h"
#include "hardsup/el734_def.h"
@ -123,7 +123,7 @@ static int ITC4Error(pEVDriver self, int *iCode, char *error, int iErrLen)
*iCode = pMe->iLastError;
if (pMe->iLastError == SHITTYVALUE) {
strncpy(error, "Invalid temperature returned form ITC4, check sensor",
strlcpy(error, "Invalid temperature returned form ITC4, check sensor",
iErrLen);
} else {
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;
}
cbData->pDriv = driv;
strncpy(cbData->comCode, command, 9);
strncpy(cbData->prefix, prefix, 9);
strncpy(cbData->postfix, postfix, 9);
strlcpy(cbData->comCode, command, 9);
strlcpy(cbData->prefix, prefix, 9);
strlcpy(cbData->postfix, postfix, 9);
hdbCB->next = NULL;
hdbCB->previous = NULL;
hdbCB->killFunc = free;
@ -570,50 +570,50 @@ static void JulChoErrorcodeToString(int code, char *pError, int iLen)
{
switch (code) {
case FRAMEERROR:
strncpy(pError, "Frame error", iLen);
strlcpy(pError, "Frame error", iLen);
break;
case CKERROR:
strncpy(pError, "Checksum error", iLen);
strlcpy(pError, "Checksum error", iLen);
break;
case BADCOMMAND:
strncpy(pError, "Bad Command", iLen);
strlcpy(pError, "Bad Command", iLen);
break;
case WRONGNOPAR:
strncpy(pError, "Wrong number of parameters", iLen);
strlcpy(pError, "Wrong number of parameters", iLen);
break;
case ILLPAR:
strncpy(pError, "Illegal parameter", iLen);
strlcpy(pError, "Illegal parameter", iLen);
break;
case PARRANGE:
strncpy(pError, "Parameter out of range", iLen);
strlcpy(pError, "Parameter out of range", iLen);
break;
case BADERR:
strncpy(pError, "Controller error not recognised", iLen);
strlcpy(pError, "Controller error not recognised", iLen);
break;
case BADREPLY:
strncpy(pError, "Unexpected reply", iLen);
strlcpy(pError, "Unexpected reply", iLen);
break;
case NOTPAR:
strncpy(pError, "Unsupported parameter", iLen);
strlcpy(pError, "Unsupported parameter", iLen);
break;
case BADTEXT:
strncpy(pError, "Failed to convert text to number", iLen);
strlcpy(pError, "Failed to convert text to number", iLen);
break;
case ROPAR:
strncpy(pError, "Read only Parameter", iLen);
strlcpy(pError, "Read only Parameter", iLen);
break;
case NOMEM:
strncpy(pError, "Out of memory formatting parameter", iLen);
strlcpy(pError, "Out of memory formatting parameter", iLen);
break;
case HALT:
strncpy(pError, "User requested HALT; choppers status undefined ",
strlcpy(pError, "User requested HALT; choppers status undefined ",
iLen);
break;
case SICSCBRANGE:
strncpy(pError, "Parameter value out of range", iLen);
strlcpy(pError, "Parameter value out of range", iLen);
break;
case SICSCBRO:
strncpy(pError, "Parameter is READ-ONLY", iLen);
strlcpy(pError, "Parameter is READ-ONLY", iLen);
break;
default:
getRS232Error(code, pError, iLen);
@ -1109,7 +1109,7 @@ static int JulChoGetPar(pCodri pDriv, char *parname,
self->errorCode = NOMEM;
return 0;
}
strncpy(pBuffer, GetCharArray(val), iBufLen);
strlcpy(pBuffer, GetCharArray(val), iBufLen);
DeleteDynString(val);
return 1;
}

2
linadriv.c
View File

@ -72,7 +72,7 @@ int LinaHandler(void *object)
if (strcmp(eab->ans, eab->version) == 0) {
/* we are still connected with the same device */
} 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 */
eab->errCode = EASE_DEV_CHANGED;
eab->state = EASE_idle;

6
lmd200.c
View File

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

2
lscsupport.c
View File

@ -47,7 +47,7 @@ int LscHandler(void *object)
if (strcmp(eab->ans, eab->version) == 0) {
/* we are still connected with the same device */
} 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 */
eab->errCode = EASE_DEV_CHANGED;
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;
switch (*iCode) {
case NOCONN:
strncpy(pError, "No Connection to Bruker Controller", iErrLen);
strlcpy(pError, "No Connection to Bruker Controller", iErrLen);
break;
case MISERABLE:
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;
case BADANSWER:
strncpy(pError, "The LTC-11 returned a bad reply", iErrLen);
strlcpy(pError, "The LTC-11 returned a bad reply", iErrLen);
break;
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);
break;
case TIMEOUT:
strncpy(pError, "Timeout receiving data from LTC-11", iErrLen);
strlcpy(pError, "Timeout receiving data from LTC-11", iErrLen);
break;
default:
SerialError(*iCode, pError, iErrLen);

2
make_gen
View File

@ -9,7 +9,7 @@
.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\
amorstat.o tasinit.o ptasdrive.o tasutil.o tasscan.o swmotor.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) {
/* we are still connected with the same device */
} 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 */
eve->errCode = EVE_DEV_CHANGED;
eve->state = idleState;

2
oxinst.c
View File

@ -90,7 +90,7 @@ int OxiHandler(void *object)
if (strcmp(eab->ans, eab->version) == 0) {
/* we are still connected with the same device */
} 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 */
eab->errCode = EASE_DEV_CHANGED;
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;
if (*iCode == PITMO) {
strncpy(pError, "Timeout at serial line", iErrLen);
strlcpy(pError, "Timeout at serial line", iErrLen);
return;
}
if (*iCode == PICOMERR) {
strncpy(pError, "C-804 Command Error", iErrLen);
strlcpy(pError, "C-804 Command Error", iErrLen);
return;
}

4
pipiezo.c
View File

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

2
polterwrite.c
View File

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

1
psi.c
View File

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

2
sanslirebin.c
View File

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

2
sanswave.c
View File

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

2
sinqhmdriv.c
View File

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

22
sinqhttp.c
View File

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

21
slsecho.c
View File

@ -15,6 +15,9 @@
* with mode being either r or w and convertflag being one of
* 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
* Author: Mark Koennecke
*/
@ -95,7 +98,18 @@ static double DSPfloat2double(ULONG input)
}
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)
{
pSLSEcho echo = NULL;
@ -161,6 +175,7 @@ static int EchoPack(Ascon *a)
val = double2DSPfloat(dval);
}
memcpy(pMessage+4,&val,4);
swapDataBytes(pMessage);
/* printf("Sending code: 0x%x, val = %d\n", code, val); */
return 1;
@ -170,7 +185,8 @@ static int EchoUnpack(Ascon *a)
{
pSLSEcho echo = a->private;
char *pMessage = NULL, printbuf[30];
int code, val;
int val;
unsigned char code = 0;
double dval;
@ -182,6 +198,7 @@ static int EchoUnpack(Ascon *a)
DynStringConcat(a->rdBuffer,printbuf);
DynStringConcatChar(a->rdBuffer,':');
swapDataBytes(pMessage);
memcpy(&val,pMessage+4, 4);
dval = (double)val;

293
slsmagnet.c
View File

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

284
slsvme.c
View File

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

6
sps.c
View File

@ -257,6 +257,10 @@ static int SPSBitPattern(pSPS self, SConnection *pCon)
unsigned char byte;
pDynString result = NULL;
if(self->iMode){
SCWrite(pCon,"00000 0001000 00001000 00010000", eValue);
return 1;
}
/* send an R command down to the SPS */
iRet = SPSCommand(self, "R", pBueffel, 255);
if (!iRet) {
@ -446,7 +450,7 @@ int SPSGetADC(pSPS self, int iWhich, int *iValue)
pPtr++;
for (i = 0; i < 8; i++) {
pPtr++; /* skip whitespace */
strncpy(pNum, pPtr, 5);
strlcpy(pNum, pPtr, 5);
pNum[5] = '\0';
pPtr += 5;
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);
pTcl = (Tcl_Interp *) pServ->pSics->pTcl;
status = Tcl_Eval(pTcl, pCommand);
strncpy(pError, pTcl->result, 131);
strlcpy(pError, pTcl->result, 131);
if (status != TCL_OK || strstr(pError, "OK") == NULL) {
sprintf(pCommand, "ERROR: %s while switching motor", pError);
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);
pTcl = (Tcl_Interp *) pServ->pSics->pTcl;
status = Tcl_Eval(pTcl, pCommand);
strncpy(pError, pTcl->result, 131);
strlcpy(pError, pTcl->result, 131);
if (status != TCL_OK || strstr(pError, "OK") == NULL) {
sprintf(pCommand, "ERROR: %s while switching motor", pError);
SCWrite(pCon, pCommand, eError);

10
tabledrive.c
View File

@ -57,11 +57,11 @@ static int TableDriveCheckLimits(void *pData, float fVal, char *error,
tdMotor moti;
if (self == NULL || self->motorTable < 0) {
strncpy(error, "Path Table Not Defined!", 25);
strlcpy(error, "Path Table Not Defined!", 25);
return 0;
}
if (fVal < 1. || fVal > self->tableLength) {
strncpy(error, "Out of Range", 25);
strlcpy(error, "Out of Range", 25);
return 0;
}
return 1;
@ -537,7 +537,7 @@ static int startASDS(pTableDrive self, SConnection * pCon, int target)
status = LLDnodePtr2First(self->motorTable);
while (status != 0) {
LLDnodeDataTo(self->motorTable, &moti);
strncpy(name, moti.motorName, 131);
strlcpy(name, moti.motorName, 131);
strtolower(name);
if (strstr(name, "ds") != NULL || strstr(name, "as") != NULL) {
if (target == ASDSTO0) {
@ -570,7 +570,7 @@ static int startOthers(pTableDrive self, SConnection * pCon)
status = LLDnodePtr2First(self->motorTable);
while (status != 0) {
LLDnodeDataTo(self->motorTable, &moti);
strncpy(name, moti.motorName, 131);
strlcpy(name, moti.motorName, 131);
strtolower(name);
if (strstr(name, "ds") == NULL && strstr(name, "as") == NULL) {
targetValue = findTarget(moti, self->targetPosition);
@ -929,7 +929,7 @@ int TableDriveAction(SConnection * pCon, SicsInterp * pSics, void *pData,
if (!SCMatchRights(pCon, usMugger)) {
return 0;
}
strncpy(self->orientMotor, argv[2], 80);
strlcpy(self->orientMotor, argv[2], 80);
self->oriInvalid = 1;
SCSendOK(pCon);
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
*/
if (strlen(str) >= iLength) {
strncpy(target, str, iLength);
strlcpy(target, str, iLength);
}
iPtr = (iLength - strlen(str)) / 2;
@ -230,7 +230,7 @@ static int TASHeader(pScanData self)
DynarGet(self->pScanVar, i, &pPtr);
pVar = (pVarEntry) pPtr;
if (pVar) {
strncpy(pWork2, ScanVarName(pVar), 59);
strlcpy(pWork2, ScanVarName(pVar), 59);
strtoupper(pWork2);
sprintf(pWork, "D%s=%8.4f, ", pWork2, ScanVarStep(pVar));
strcat(pBueffel, pWork);
@ -411,7 +411,7 @@ static int TASHeader(pScanData self)
pVar = (pVarEntry) pPtr;
if (pVar) {
strcat(pBueffel, "F9.4,1X,");
strncpy(pWork2, pVar->Name, 59);
strlcpy(pWork2, pVar->Name, 59);
strtoupper(pWork2);
strcenter(pWork2, pTen, 11);
strcat(pHeader, pTen);

6
tdchm.c
View File

@ -325,17 +325,17 @@ static int TDCGetError(pHistDriver self, int *iCode, char *perror,
*iCode = tdc->errorCode;
switch (tdc->errorCode) {
case COMMERROR:
strncpy(perror, "Communication problem with TDC", iErrlen);
strlcpy(perror, "Communication problem with TDC", iErrlen);
break;
case MAXEXCEEDED:
strncpy(perror, "Requested to many channels for read", iErrlen);
strlcpy(perror, "Requested to many channels for read", iErrlen);
break;
default:
if (tdc->counter != NULL) {
tdc->counter->pDriv->GetError(tdc->counter->pDriv,
iCode, perror, iErrlen);
} else {
strncpy(perror, "Undefined error code", iErrlen);
strlcpy(perror, "Undefined error code", iErrlen);
}
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 */
return NOCOMMAND;
}
strncpy(pOldCom, pPtr, 3);
strlcpy(pOldCom, pPtr, 3);
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) {
case NOCOMMAND:
strncpy(error, "No command was specified, internal error", iErrLen);
strlcpy(error, "No command was specified, internal error", iErrLen);
break;
case ECHOMISSING:
strncpy(error, "No echo received, may be busy", iErrLen);
strlcpy(error, "No echo received, may be busy", iErrLen);
break;
case BADANALYSIS:
strncpy(error, "Error analysing status messge", iErrLen);
strlcpy(error, "Error analysing status messge", iErrLen);
break;
case STARTTIMEOUT:
strncpy(error, "Velocity Selector failed to start", iErrLen);
strlcpy(error, "Velocity Selector failed to start", iErrLen);
break;
default:
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);
strcat(pBueffel, pHelp);
strncpy(pText, pBueffel, iTextLen);
strlcpy(pText, pBueffel, iTextLen);
return 1;
}