From dec6b04fa616db05af3704e5dc3f18eb7402ceb8 Mon Sep 17 00:00:00 2001 From: koennecke Date: Tue, 13 Apr 2010 15:08:40 +0000 Subject: [PATCH] - Changed strncpy to strlcpy, strncat to strlcat - Added strlcpy and strlcat to SICS - Added a driver for the POLDI power supplies --- A1931.c | 14 +-- autowin.c | 2 +- bruker.c | 20 ++-- docho.c | 14 +-- dornier2.c | 14 +-- dspcode.c | 276 ++++++++++++++++++++++---------------------- ease.c | 2 +- ecb.c | 4 +- ecbcounter.c | 18 +-- ecbdriv.c | 16 +-- el734dc.c | 4 +- el734driv.c | 4 +- el734hp.c | 32 +++--- el737driv.c | 10 +- el737hpdriv.c | 26 ++--- el737hpdrivsps.c | 28 ++--- el737hpv2driv.c | 22 ++-- el755driv.c | 42 +++---- eurodriv.c | 11 +- haakedriv.c | 2 +- itc4driv.c | 4 +- julcho.c | 38 +++--- linadriv.c | 2 +- lmd200.c | 6 +- lscsupport.c | 2 +- ltc11.c | 10 +- make_gen | 2 +- oicom.c | 2 +- oxinst.c | 2 +- pimotor.c | 4 +- pipiezo.c | 4 +- polterwrite.c | 2 +- psi.c | 1 + sanscook.c | 22 ++-- sanslirebin.c | 2 +- sanswave.c | 2 +- sinqhmdriv.c | 2 +- sinqhttp.c | 22 ++-- slsecho.c | 21 +++- slsmagnet.c | 293 ++++++++++++++++++++++++----------------------- slsvme.c | 284 ++++++++++++++++++++++----------------------- sps.c | 6 +- swmotor.c | 2 +- swmotor2.c | 2 +- tabledrive.c | 10 +- tasscan.c | 6 +- tdchm.c | 6 +- velodorn.c | 2 +- velodornier.c | 10 +- 49 files changed, 679 insertions(+), 653 deletions(-) diff --git a/A1931.c b/A1931.c index f80204a..c174359 100644 --- a/A1931.c +++ b/A1931.c @@ -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; } diff --git a/autowin.c b/autowin.c index f60ced8..0b8ae94 100644 --- a/autowin.c +++ b/autowin.c @@ -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, diff --git a/bruker.c b/bruker.c index a9c8dcd..a7b0d2a 100644 --- a/bruker.c +++ b/bruker.c @@ -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; diff --git a/docho.c b/docho.c index 0915eae..ba64ce5 100644 --- a/docho.c +++ b/docho.c @@ -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: diff --git a/dornier2.c b/dornier2.c index 815486b..71881a3 100644 --- a/dornier2.c +++ b/dornier2.c @@ -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); diff --git a/dspcode.c b/dspcode.c index 80ecf32..288c3b2 100644 --- a/dspcode.c +++ b/dspcode.c @@ -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; } } diff --git a/ease.c b/ease.c index 89528f2..649507a 100644 --- a/ease.c +++ b/ease.c @@ -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 */ diff --git a/ecb.c b/ecb.c index 454e01f..4815b28 100644 --- a/ecb.c +++ b/ecb.c @@ -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; diff --git a/ecbcounter.c b/ecbcounter.c index be28580..560d01b 100644 --- a/ecbcounter.c +++ b/ecbcounter.c @@ -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; } diff --git a/ecbdriv.c b/ecbdriv.c index 9ce527f..15b0119 100644 --- a/ecbdriv.c +++ b/ecbdriv.c @@ -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; } } diff --git a/el734dc.c b/el734dc.c index 9d5aac0..9bd404a 100644 --- a/el734dc.c +++ b/el734dc.c @@ -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; diff --git a/el734driv.c b/el734driv.c index 885133f..422bf8b 100644 --- a/el734driv.c +++ b/el734driv.c @@ -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; diff --git a/el734hp.c b/el734hp.c index 5f8020c..d3083d5 100644 --- a/el734hp.c +++ b/el734hp.c @@ -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); diff --git a/el737driv.c b/el737driv.c index 446b17d..5306695 100644 --- a/el737driv.c +++ b/el737driv.c @@ -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); diff --git a/el737hpdriv.c b/el737hpdriv.c index 1ed52b2..e360a62 100644 --- a/el737hpdriv.c +++ b/el737hpdriv.c @@ -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 ........... diff --git a/el737hpdrivsps.c b/el737hpdrivsps.c index b867b6b..218d504 100644 --- a/el737hpdrivsps.c +++ b/el737hpdrivsps.c @@ -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 ........... diff --git a/el737hpv2driv.c b/el737hpv2driv.c index 0c05aea..741536e 100644 --- a/el737hpv2driv.c +++ b/el737hpv2driv.c @@ -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 ........... diff --git a/el755driv.c b/el755driv.c index 7172459..5fe9394 100644 --- a/el755driv.c +++ b/el755driv.c @@ -14,6 +14,8 @@ #include #include #include +#include + #include #include #include @@ -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; } diff --git a/eurodriv.c b/eurodriv.c index 9b7a80b..955be10 100644 --- a/eurodriv.c +++ b/eurodriv.c @@ -21,6 +21,7 @@ #include #include #include +#include #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; } diff --git a/haakedriv.c b/haakedriv.c index 877ffeb..e38ebfe 100644 --- a/haakedriv.c +++ b/haakedriv.c @@ -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; diff --git a/itc4driv.c b/itc4driv.c index e4a4c14..a99005a 100644 --- a/itc4driv.c +++ b/itc4driv.c @@ -46,7 +46,7 @@ #include #include #include - +#include #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); diff --git a/julcho.c b/julcho.c index 9bf8ffd..673f9ab 100644 --- a/julcho.c +++ b/julcho.c @@ -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; } diff --git a/linadriv.c b/linadriv.c index 8009022..65502fd 100644 --- a/linadriv.c +++ b/linadriv.c @@ -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; diff --git a/lmd200.c b/lmd200.c index c038d68..afc329e 100644 --- a/lmd200.c +++ b/lmd200.c @@ -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) { diff --git a/lscsupport.c b/lscsupport.c index a80cafe..b12f044 100644 --- a/lscsupport.c +++ b/lscsupport.c @@ -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; diff --git a/ltc11.c b/ltc11.c index c53d18f..60fbd11 100644 --- a/ltc11.c +++ b/ltc11.c @@ -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); diff --git a/make_gen b/make_gen index a8cb126..a2f4a24 100644 --- a/make_gen +++ b/make_gen @@ -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 \ diff --git a/oicom.c b/oicom.c index c7eaf9d..cdc3026 100644 --- a/oicom.c +++ b/oicom.c @@ -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; diff --git a/oxinst.c b/oxinst.c index 1940b64..df96a1a 100644 --- a/oxinst.c +++ b/oxinst.c @@ -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; diff --git a/pimotor.c b/pimotor.c index c572827..41e9041 100644 --- a/pimotor.c +++ b/pimotor.c @@ -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; } diff --git a/pipiezo.c b/pipiezo.c index 13e4697..77efd9c 100644 --- a/pipiezo.c +++ b/pipiezo.c @@ -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; } diff --git a/polterwrite.c b/polterwrite.c index 3cf9801..b7a34cf 100644 --- a/polterwrite.c +++ b/polterwrite.c @@ -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); diff --git a/psi.c b/psi.c index e3d5d98..55cbe4e 100644 --- a/psi.c +++ b/psi.c @@ -70,6 +70,7 @@ void SiteInit(void) INIT(AddTermProtocoll); INIT(AddPhytronProtocoll); INIT(AddSLSEchoProtocoll); + INIT(AddCharByCharProtocoll); } diff --git a/sanscook.c b/sanscook.c index 0ec8c80..4cbaca5 100644 --- a/sanscook.c +++ b/sanscook.c @@ -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); diff --git a/sanslirebin.c b/sanslirebin.c index 9878f89..7b090fa 100644 --- a/sanslirebin.c +++ b/sanslirebin.c @@ -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; diff --git a/sanswave.c b/sanswave.c index 8f21efb..cac80ba 100644 --- a/sanswave.c +++ b/sanswave.c @@ -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; } diff --git a/sinqhmdriv.c b/sinqhmdriv.c index cbb7123..d28fa1a 100644 --- a/sinqhmdriv.c +++ b/sinqhmdriv.c @@ -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); } diff --git a/sinqhttp.c b/sinqhttp.c index 0d52dd8..df2ba4c 100644 --- a/sinqhttp.c +++ b/sinqhttp.c @@ -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; } diff --git a/slsecho.c b/slsecho.c index 7752b83..3557f38 100644 --- a/slsecho.c +++ b/slsecho.c @@ -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; diff --git a/slsmagnet.c b/slsmagnet.c index 2509122..0528efc 100644 --- a/slsmagnet.c +++ b/slsmagnet.c @@ -39,6 +39,7 @@ #include #include #include +#include #include "evdriver.h" #include @@ -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; } diff --git a/slsvme.c b/slsvme.c index 73315e1..becdbe5 100644 --- a/slsvme.c +++ b/slsvme.c @@ -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) { diff --git a/sps.c b/sps.c index 8c82ed3..d03bcd3 100644 --- a/sps.c +++ b/sps.c @@ -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); diff --git a/swmotor.c b/swmotor.c index 524c65e..5446228 100644 --- a/swmotor.c +++ b/swmotor.c @@ -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); diff --git a/swmotor2.c b/swmotor2.c index ea63a61..813c039 100644 --- a/swmotor2.c +++ b/swmotor2.c @@ -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); diff --git a/tabledrive.c b/tabledrive.c index 8f08981..d6329fc 100644 --- a/tabledrive.c +++ b/tabledrive.c @@ -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; diff --git a/tasscan.c b/tasscan.c index 6a09716..f62ded4 100644 --- a/tasscan.c +++ b/tasscan.c @@ -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); diff --git a/tdchm.c b/tdchm.c index 4154a01..fb48c73 100644 --- a/tdchm.c +++ b/tdchm.c @@ -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; } diff --git a/velodorn.c b/velodorn.c index 40b742a..7c6e6b0 100644 --- a/velodorn.c +++ b/velodorn.c @@ -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); /* diff --git a/velodornier.c b/velodornier.c index 28bc895..1f485f3 100644 --- a/velodornier.c +++ b/velodornier.c @@ -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; }