Renaming errors (naming conventions)

remotes/origin/master-1.0.x
Pablo Rincon 17 years ago committed by Victor Julien
parent 8f618b2121
commit ad2c136e8f

@ -165,12 +165,12 @@ static int HTPHandleRequestData(Flow *f, void *htp_state,
} else {
if (hstate->connp->last_error != NULL) {
SCLogError(SC_ALPARSER_ERR, "Error in parsing HTTP client request: "
SCLogError(SC_ERR_ALPARSER_ERR, "Error in parsing HTTP client request: "
"[%"PRId32"] [%s] [%"PRId32"] %s", hstate->connp->last_error->level,
hstate->connp->last_error->file, hstate->connp->last_error->line,
hstate->connp->last_error->msg);
} else {
SCLogError(SC_ALPARSER_ERR, "Error in parsing HTTP client request");
SCLogError(SC_ERR_ALPARSER_ERR, "Error in parsing HTTP client request");
}
}
hstate->flags |= HTP_FLAG_STATE_ERROR;
@ -228,12 +228,12 @@ static int HTPHandleResponseData(Flow *f, void *htp_state,
} else {
if (hstate->connp->last_error != NULL) {
SCLogError(SC_ALPARSER_ERR, "Error in parsing HTTP server response: "
SCLogError(SC_ERR_ALPARSER_ERR, "Error in parsing HTTP server response: "
"[%"PRId32"] [%s] [%"PRId32"] %s", hstate->connp->last_error->level,
hstate->connp->last_error->file, hstate->connp->last_error->line,
hstate->connp->last_error->msg);
} else {
SCLogError(SC_ALPARSER_ERR, "Error in parsing HTTP server response");
SCLogError(SC_ERR_ALPARSER_ERR, "Error in parsing HTTP server response");
}
}
hstate->flags = HTP_FLAG_STATE_ERROR;

@ -176,7 +176,7 @@ int AlpParseFieldBySize(AppLayerParserResult *output, AppLayerParserState *pstat
if (pstate->store_len == 0) {
int r = AlpStoreField(output, field_idx, input, size, /* static mem */0);
if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "Failed to store field value");
SCLogError(SC_ERR_ALPARSER_ERR, "Failed to store field value");
SCReturnInt(-1);
}
(*offset) += size;
@ -197,7 +197,7 @@ int AlpParseFieldBySize(AppLayerParserResult *output, AppLayerParserState *pstat
int r = AlpStoreField(output, field_idx, pstate->store,
pstate->store_len, /* alloc mem */1);
if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "Failed to store field value");
SCLogError(SC_ERR_ALPARSER_ERR, "Failed to store field value");
SCReturnInt(-1);
}
@ -230,7 +230,7 @@ int AlpParseFieldByEOF(AppLayerParserResult *output, AppLayerParserState *pstate
int r = AlpStoreField(output, field_idx, input, input_len, 0);
if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "Failed to store field value");
SCLogError(SC_ERR_ALPARSER_ERR, "Failed to store field value");
SCReturnInt(-1);
}
@ -263,7 +263,7 @@ int AlpParseFieldByEOF(AppLayerParserResult *output, AppLayerParserState *pstate
int r = AlpStoreField(output, field_idx, pstate->store, pstate->store_len, 1);
if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "Failed to store field value");
SCLogError(SC_ERR_ALPARSER_ERR, "Failed to store field value");
SCReturnInt(-1);
}
@ -312,7 +312,7 @@ int AlpParseFieldByDelimiter(AppLayerParserResult *output, AppLayerParserState *
int r = AlpStoreField(output, field_idx, input, len, 0);
if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "Failed to store field value");
SCLogError(SC_ERR_ALPARSER_ERR, "Failed to store field value");
SCReturnInt(-1);
}
(*offset) += (len + delim_len);
@ -354,7 +354,7 @@ int AlpParseFieldByDelimiter(AppLayerParserResult *output, AppLayerParserState *
int r = AlpStoreField(output, field_idx, pstate->store,
pstate->store_len, 1);
if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "Failed to store field value");
SCLogError(SC_ERR_ALPARSER_ERR, "Failed to store field value");
SCReturnInt(-1);
}
pstate->store = NULL;
@ -390,7 +390,7 @@ int AlpParseFieldByDelimiter(AppLayerParserResult *output, AppLayerParserState *
int r = AlpStoreField(output, field_idx,
pstate->store, len, 1);
if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "Failed to store "
SCLogError(SC_ERR_ALPARSER_ERR, "Failed to store "
"field value");
SCReturnInt(-1);
}
@ -437,7 +437,7 @@ int AlpParseFieldByDelimiter(AppLayerParserResult *output, AppLayerParserState *
uint32_t len = ptr - pstate->store;
int r = AlpStoreField(output, field_idx, pstate->store, len, 1);
if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "Failed to store field value");
SCLogError(SC_ERR_ALPARSER_ERR, "Failed to store field value");
SCReturnInt(-1);
}
pstate->store = NULL;
@ -829,7 +829,7 @@ error:
inet_ntop(AF_INET, (const void*)&f->dst.addr_data32[0], dst,
sizeof (dst));
SCLogError(SC_ALPARSER_ERR, "Error occured in parsing \"%s\" app layer "
SCLogError(SC_ERR_ALPARSER_ERR, "Error occured in parsing \"%s\" app layer "
"protocol, using network protocol %"PRIu8", source IP "
"address %s, destination IP address %s, src port %"PRIu16" and "
"dst port %"PRIu16"", al_proto_table[ssn->alproto].name,
@ -844,7 +844,7 @@ error:
inet_ntop(AF_INET6, (const void*)&f->dst.addr_data32, dst6,
sizeof (dst6));
SCLogError(SC_ALPARSER_ERR, "Error occured in parsing \"%s\" app layer "
SCLogError(SC_ERR_ALPARSER_ERR, "Error occured in parsing \"%s\" app layer "
"protocol, using network protocol %"PRIu8", source IPv6 "
"address %s, destination IPv6 address %s, src port %"PRIu16" and "
"dst port %"PRIu16"", al_proto_table[ssn->alproto].name,

@ -185,7 +185,7 @@ static int TLSParseClientRecord(Flow *f, void *tls_state, AppLayerParserState *p
pstate->parse_field = 0;
SCReturnInt(0);
} else if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "AlpParseFieldBySize failed, "
SCLogError(SC_ERR_ALPARSER_ERR, "AlpParseFieldBySize failed, "
"r %d", r);
SCReturnInt(-1);
}
@ -204,7 +204,7 @@ static int TLSParseClientRecord(Flow *f, void *tls_state, AppLayerParserState *p
pstate->parse_field = 1;
SCReturnInt(0);
} else if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "AlpParseFieldBySize failed, "
SCLogError(SC_ERR_ALPARSER_ERR, "AlpParseFieldBySize failed, "
"r %d", r);
SCReturnInt(-1);
}
@ -224,7 +224,7 @@ static int TLSParseClientRecord(Flow *f, void *tls_state, AppLayerParserState *p
pstate->parse_field = 2;
SCReturnInt(0);
} else if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "AlpParseFieldBySize failed, "
SCLogError(SC_ERR_ALPARSER_ERR, "AlpParseFieldBySize failed, "
"r %d", r);
SCReturnInt(-1);
}
@ -310,7 +310,7 @@ static int TLSParseServerRecord(Flow *f, void *tls_state, AppLayerParserState *p
pstate->parse_field = 0;
SCReturnInt(0);
} else if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "AlpParseFieldBySize failed, "
SCLogError(SC_ERR_ALPARSER_ERR, "AlpParseFieldBySize failed, "
"r %d", r);
SCReturnInt(-1);
}
@ -328,7 +328,7 @@ static int TLSParseServerRecord(Flow *f, void *tls_state, AppLayerParserState *p
pstate->parse_field = 1;
SCReturnInt(0);
} else if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "AlpParseFieldBySize failed, "
SCLogError(SC_ERR_ALPARSER_ERR, "AlpParseFieldBySize failed, "
"r %d", r);
SCReturnInt(-1);
}
@ -347,7 +347,7 @@ static int TLSParseServerRecord(Flow *f, void *tls_state, AppLayerParserState *p
pstate->parse_field = 2;
SCReturnInt(0);
} else if (r == -1) {
SCLogError(SC_ALPARSER_ERR, "AlpParseFieldBySize failed, "
SCLogError(SC_ERR_ALPARSER_ERR, "AlpParseFieldBySize failed, "
"r %d", r);
SCReturnInt(-1);
}

@ -47,7 +47,7 @@ static char *SCPerfGetLogFilename(void)
if (snprintf(log_filename, PATH_MAX, "%s/%s", log_dir,
SC_PERF_DEFAULT_LOG_FILENAME) < 0) {
SCLogError(SC_SPRINTF_ERROR, "Sprintf Error");
SCLogError(SC_ERR_SPRINTF_ERROR, "Sprintf Error");
free(log_filename);
return NULL;
}
@ -94,7 +94,7 @@ static void SCPerfInitOPCtx(void)
/* init the lock used by SCPerfClubTMInst */
if (SCMutexInit(&sc_perf_op_ctx->pctmi_lock, NULL) != 0) {
SCLogError(SC_INITIALIZATION_ERROR, "error initializing pctmi mutex");
SCLogError(SC_ERR_INITIALIZATION_ERROR, "error initializing pctmi mutex");
exit(EXIT_FAILURE);
}
@ -271,7 +271,7 @@ static int SCPerfParseTBCounterInterval(SCPerfCounter *pc, char *interval)
ret = pcre_exec(regex, regex_study, interval, strlen(interval), 0, 0, ov, 30);
if (ret < 0) {
SCLogWarning(SC_INVALID_ARGUMENTS, "Invalid Timebased interval");
SCLogWarning(SC_ERR_INVALID_ARGUMENTS, "Invalid Timebased interval");
goto error;
}
@ -403,7 +403,7 @@ static uint16_t SCPerfRegisterQualifiedCounter(char *cname, char *tm_name,
/* (SC_PERF_TYPE_MAX - 1) because we haven't implemented SC_PERF_TYPE_STR */
if ((type >= (SC_PERF_TYPE_MAX - 1)) || (type < 0)) {
SCLogError(SC_INVALID_ARGUMENTS, "Counters of type %" PRId32 " can't "
SCLogError(SC_ERR_INVALID_ARGUMENTS, "Counters of type %" PRId32 " can't "
"be registered", type);
return 0;
}
@ -842,7 +842,7 @@ void SCPerfSpawnThreads(void)
exit(EXIT_FAILURE);
}
if (TmThreadSpawn(tv_wakeup) != 0) {
SCLogError(SC_THREAD_SPAWN_FAILED, "TmThreadSpawn failed for "
SCLogError(SC_ERR_THREAD_SPAWN_FAILED, "TmThreadSpawn failed for "
"SCPerfWakeupThread");
exit(EXIT_FAILURE);
}
@ -856,7 +856,7 @@ void SCPerfSpawnThreads(void)
exit(EXIT_FAILURE);
}
if (TmThreadSpawn(tv_mgmt) != 0) {
SCLogError(SC_THREAD_SPAWN_FAILED, "TmThreadSpawn failed for "
SCLogError(SC_ERR_THREAD_SPAWN_FAILED, "TmThreadSpawn failed for "
"SCPerfWakeupThread");
exit(EXIT_FAILURE);
}

@ -440,12 +440,12 @@ DefragContextNew(void)
}
else {
if (timeout < TIMEOUT_MIN) {
SCLogError(SC_INVALID_ARGUMENT,
SCLogError(SC_ERR_INVALID_ARGUMENT,
"defrag: Timeout less than minimum allowed value.");
exit(EXIT_FAILURE);
}
else if (timeout > TIMEOUT_MAX) {
SCLogError(SC_INVALID_ARGUMENT,
SCLogError(SC_ERR_INVALID_ARGUMENT,
"defrag: Tiemout greater than maximum allowed value.");
exit(EXIT_FAILURE);
}
@ -780,7 +780,7 @@ DefragInsertFrag(ThreadVars *tv, DefragContext *dc, DefragTracker *tracker,
}
else {
/* Abort - should not happen. */
SCLogWarning(SC_INVALID_ARGUMENT, "Invalid address family, aborting.");
SCLogWarning(SC_ERR_INVALID_ARGUMENT, "Invalid address family, aborting.");
return NULL;
}

@ -51,7 +51,7 @@ void DetectBytetestRegister (void) {
parse_regex = pcre_compile(PARSE_REGEX, opts, &eb, &eo, NULL);
if(parse_regex == NULL)
{
SCLogError(SC_PCRE_COMPILE_FAILED, "pcre compile of \"%s\" failed at "
SCLogError(SC_ERR_PCRE_COMPILE_FAILED, "pcre compile of \"%s\" failed at "
"offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
goto error;
}
@ -59,7 +59,7 @@ void DetectBytetestRegister (void) {
parse_regex_study = pcre_study(parse_regex, 0, &eb);
if(eb != NULL)
{
SCLogError(SC_PCRE_STUDY_FAILED, "pcre study failed: %s", eb);
SCLogError(SC_ERR_PCRE_STUDY_FAILED, "pcre study failed: %s", eb);
goto error;
}
return;
@ -125,7 +125,7 @@ int DetectBytetestMatch(ThreadVars *t, DetectEngineThreadCtx *det_ctx,
SCLogDebug("No Numeric value");
return 0;
} else {
SCLogError(SC_INVALID_NUM_BYTES, "Error extracting %d "
SCLogError(SC_ERR_INVALID_NUM_BYTES, "Error extracting %d "
"bytes of string data: %d", data->nbytes, extbytes);
return -1;
}
@ -139,7 +139,7 @@ int DetectBytetestMatch(ThreadVars *t, DetectEngineThreadCtx *det_ctx,
BYTE_LITTLE_ENDIAN : BYTE_BIG_ENDIAN;
extbytes = ByteExtractUint64(&val, endianness, data->nbytes, ptr);
if (extbytes != data->nbytes) {
SCLogError(SC_INVALID_NUM_BYTES, "Error extracting %d bytes "
SCLogError(SC_ERR_INVALID_NUM_BYTES, "Error extracting %d bytes "
"of numeric data: %d\n", data->nbytes, extbytes);
return -1;
}
@ -210,7 +210,7 @@ DetectBytetestData *DetectBytetestParse(char *optstr)
ret = pcre_exec(parse_regex, parse_regex_study, optstr,
strlen(optstr), 0, 0, ov, MAX_SUBSTRINGS);
if (ret < 6 || ret > 10) {
SCLogError(SC_PCRE_PARSE_FAILED, "parse error, ret %" PRId32
SCLogError(SC_ERR_PCRE_PARSE_FAILED, "parse error, ret %" PRId32
", string %s", ret, optstr);
goto error;
}
@ -218,7 +218,7 @@ DetectBytetestData *DetectBytetestParse(char *optstr)
res = pcre_get_substring((char *)optstr, ov, MAX_SUBSTRINGS,
i + 1, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed "
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed "
"for arg %d", i + 1);
goto error;
}

@ -107,7 +107,7 @@ static inline DetectDceIfaceData *DetectDceIfaceArgParse(const char *arg)
/* retrieve the iface uuid string. iface uuid is a compulsion in the keyword */
res = pcre_get_substring(arg, ov, MAX_SUBSTRINGS, 1, &pcre_sub_str);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
goto error;
}
@ -140,7 +140,7 @@ static inline DetectDceIfaceData *DetectDceIfaceArgParse(const char *arg)
* validations of the version number, wrt. the operator */
res = pcre_get_substring(arg, ov, MAX_SUBSTRINGS, 3, &pcre_sub_str);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
goto error;
}
@ -158,7 +158,7 @@ static inline DetectDceIfaceData *DetectDceIfaceArgParse(const char *arg)
/* now let us handle the operator supplied with the version number */
res = pcre_get_substring(arg, ov, MAX_SUBSTRINGS, 2, &pcre_sub_str);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
goto error;
}

@ -125,7 +125,7 @@ static inline DetectDceOpnumData *DetectDceOpnumArgParse(const char *arg)
res = pcre_get_substring(arg, ov, MAX_SUBSTRINGS, 0, &pcre_sub_str);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
goto error;
}

@ -45,7 +45,7 @@ int DetectDepthSetup (DetectEngineCtx *de_ctx, Signature *s, SigMatch *m, char *
DetectContentData *cd = (DetectContentData *)pm->ctx;
if (cd == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "invalid argument");
SCLogError(SC_ERR_INVALID_ARGUMENT, "invalid argument");
if (dubbed) free(str);
return -1;
}

@ -45,14 +45,14 @@ void DetectDsizeRegister (void) {
parse_regex = pcre_compile(PARSE_REGEX, opts, &eb, &eo, NULL);
if(parse_regex == NULL)
{
SCLogError(SC_PCRE_COMPILE_FAILED,"pcre compile of \"%s\" failed at offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
SCLogError(SC_ERR_PCRE_COMPILE_FAILED,"pcre compile of \"%s\" failed at offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
goto error;
}
parse_regex_study = pcre_study(parse_regex, 0, &eb);
if(eb != NULL)
{
SCLogError(SC_PCRE_STUDY_FAILED,"pcre study failed: %s", eb);
SCLogError(SC_ERR_PCRE_STUDY_FAILED,"pcre study failed: %s", eb);
goto error;
}
return;
@ -113,7 +113,7 @@ DetectDsizeData *DetectDsizeParse (char *rawstr)
ret = pcre_exec(parse_regex, parse_regex_study, rawstr, strlen(rawstr), 0, 0, ov, MAX_SUBSTRINGS);
if (ret < 3 || ret > 5) {
SCLogError(SC_PCRE_MATCH_FAILED,"Parse error %s", rawstr);
SCLogError(SC_ERR_PCRE_MATCH_FAILED,"Parse error %s", rawstr);
goto error;
}
@ -121,7 +121,7 @@ DetectDsizeData *DetectDsizeParse (char *rawstr)
res = pcre_get_substring((char *)rawstr, ov, MAX_SUBSTRINGS, 1, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
goto error;
}
mode = (char *)str_ptr;
@ -129,7 +129,7 @@ DetectDsizeData *DetectDsizeParse (char *rawstr)
res = pcre_get_substring((char *)rawstr, ov, MAX_SUBSTRINGS, 2, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
goto error;
}
value1 = (char *)str_ptr;
@ -137,7 +137,7 @@ DetectDsizeData *DetectDsizeParse (char *rawstr)
res = pcre_get_substring((char *)rawstr, ov, MAX_SUBSTRINGS, 3, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
goto error;
}
range = (char *)str_ptr;
@ -145,7 +145,7 @@ DetectDsizeData *DetectDsizeParse (char *rawstr)
res = pcre_get_substring((char *)rawstr, ov, MAX_SUBSTRINGS, 4, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
goto error;
}
value2 = (char *)str_ptr;
@ -165,7 +165,7 @@ DetectDsizeData *DetectDsizeParse (char *rawstr)
if (strcmp("<>", range) == 0) {
if (strlen(mode) != 0) {
SCLogError(SC_INVALID_ARGUMENT,"Range specified but mode also set");
SCLogError(SC_ERR_INVALID_ARGUMENT,"Range specified but mode also set");
goto error;
}
dd->mode = DETECTDSIZE_RA;
@ -173,24 +173,24 @@ DetectDsizeData *DetectDsizeParse (char *rawstr)
/** set the first dsize value */
if(ByteExtractStringUint16(&dd->dsize,10,strlen(value1),value1) <= 0){
SCLogError(SC_INVALID_ARGUMENT,"Invalid size value1:\"%s\"",value1);
SCLogError(SC_ERR_INVALID_ARGUMENT,"Invalid size value1:\"%s\"",value1);
goto error;
}
/** set the second dsize value if specified */
if (strlen(value2) > 0) {
if (dd->mode != DETECTDSIZE_RA) {
SCLogError(SC_INVALID_ARGUMENT,"Multiple dsize values specified but mode is not range");
SCLogError(SC_ERR_INVALID_ARGUMENT,"Multiple dsize values specified but mode is not range");
goto error;
}
if(ByteExtractStringUint16(&dd->dsize2,10,strlen(value2),value2) <= 0){
SCLogError(SC_INVALID_ARGUMENT,"Invalid size value2:\"%s\"",value2);
SCLogError(SC_ERR_INVALID_ARGUMENT,"Invalid size value2:\"%s\"",value2);
goto error;
}
if (dd->dsize2 <= dd->dsize){
SCLogError(SC_INVALID_ARGUMENT,"dsize2:%"PRIu16" <= dsize:%"PRIu16"",dd->dsize2,dd->dsize);
SCLogError(SC_ERR_INVALID_ARGUMENT,"dsize2:%"PRIu16" <= dsize:%"PRIu16"",dd->dsize2,dd->dsize);
goto error;
}
}
@ -233,7 +233,7 @@ int DetectDsizeSetup (DetectEngineCtx *de_ctx, Signature *s, SigMatch *m, char *
dd = DetectDsizeParse(rawstr);
if (dd == NULL) {
SCLogError(SC_INVALID_ARGUMENT,"Parsing \'%s\' failed", rawstr);
SCLogError(SC_ERR_INVALID_ARGUMENT,"Parsing \'%s\' failed", rawstr);
goto error;
}

@ -904,7 +904,7 @@ static int DetectPortParseInsertString(DetectPort **head, char *s) {
/** parse the address */
ad = PortParse(s);
if (ad == NULL) {
SCLogError(SC_INVALID_ARGUMENT,"PortParse error \"%s\"",s);
SCLogError(SC_ERR_INVALID_ARGUMENT,"PortParse error \"%s\"",s);
goto error;
}
@ -950,7 +950,7 @@ static int DetectPortParseInsertString(DetectPort **head, char *s) {
return 0;
error:
SCLogError(SC_PORT_PARSE_INSERT_STRING_ERR,"DetectPortParseInsertString error");
SCLogError(SC_ERR_PORT_PARSE_INSERT_STRING_ERR,"DetectPortParseInsertString error");
if (ad != NULL)
DetectPortCleanupList(ad);
if (ad_any != NULL)
@ -1003,7 +1003,7 @@ static int DetectPortParseDo(DetectPort **head, DetectPort **nhead, char *s,
range = 1;
if (range == 1 && s[u] == '!') {
SCLogError(SC_NEGATED_VALUE_IN_PORT_RANGE,"Can't have a negated value in a range.");
SCLogError(SC_ERR_NEGATED_VALUE_IN_PORT_RANGE,"Can't have a negated value in a range.");
return -1;
} else if (!o_set && s[u] == '!') {
SCLogDebug("negation encountered");
@ -1173,7 +1173,7 @@ int DetectPortParseMergeNotPorts(DetectPort **head, DetectPort **nhead) {
/** check if the full port space is negated */
if (DetectPortIsCompletePortSpace(*nhead) == 1) {
SCLogError(SC_COMPLETE_PORT_SPACE_NEGATED,"Complete port space is negated");
SCLogError(SC_ERR_COMPLETE_PORT_SPACE_NEGATED,"Complete port space is negated");
goto error;
}
@ -1242,7 +1242,7 @@ int DetectPortParseMergeNotPorts(DetectPort **head, DetectPort **nhead) {
}
if (*head == NULL) {
SCLogError(SC_NO_PORTS_LEFT_AFTER_MERGE,"no ports left after merging ports with negated ports");
SCLogError(SC_ERR_NO_PORTS_LEFT_AFTER_MERGE,"no ports left after merging ports with negated ports");
goto error;
}

@ -48,7 +48,7 @@ int DetectFastPatternSetup(DetectEngineCtx *de_ctx, Signature *s, SigMatch *m,
char *null_str)
{
if (null_str != NULL && strcmp(null_str, "") != 0) {
SCLogError(SC_INVALID_ARGUMENT, "DetectFastPatternSetup: fast_pattern "
SCLogError(SC_ERR_INVALID_ARGUMENT, "DetectFastPatternSetup: fast_pattern "
"shouldn't be supplied with a value");
return -1;
}

@ -43,13 +43,13 @@ void DetectFragOffsetRegister (void) {
parse_regex = pcre_compile(PARSE_REGEX, opts, &eb, &eo, NULL);
if (parse_regex == NULL) {
SCLogError(SC_PCRE_COMPILE_FAILED,"pcre compile of \"%s\" failed at offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
SCLogError(SC_ERR_PCRE_COMPILE_FAILED,"pcre compile of \"%s\" failed at offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
goto error;
}
parse_regex_study = pcre_study(parse_regex, 0, &eb);
if (eb != NULL) {
SCLogError(SC_PCRE_STUDY_FAILED,"pcre study failed: %s", eb);
SCLogError(SC_ERR_PCRE_STUDY_FAILED,"pcre study failed: %s", eb);
goto error;
}
return;
@ -121,14 +121,14 @@ DetectFragOffsetData *DetectFragOffsetParse (char *fragoffsetstr) {
ret = pcre_exec(parse_regex, parse_regex_study, fragoffsetstr, strlen(fragoffsetstr), 0, 0, ov, MAX_SUBSTRINGS);
if (ret < 1 || ret > 4) {
SCLogError(SC_PCRE_MATCH_FAILED,"Parse error %s", fragoffsetstr);
SCLogError(SC_ERR_PCRE_MATCH_FAILED,"Parse error %s", fragoffsetstr);
goto error;
}
for (i = 1; i < ret; i++) {
res = pcre_get_substring((char *)fragoffsetstr, ov, MAX_SUBSTRINGS, i, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
goto error;
}
substr[i-1] = (char *)str_ptr;

@ -145,7 +145,7 @@ int DetectHttpCookieSetup (DetectEngineCtx *de_ctx, Signature *s, SigMatch *m,
SigMatch *sm = NULL;
if (str != NULL && strcmp(str, "") != 0) {
SCLogError(SC_INVALID_ARGUMENT, "http_cookie shouldn't be supplied with"
SCLogError(SC_ERR_INVALID_ARGUMENT, "http_cookie shouldn't be supplied with"
" an argument");
return -1;
}

@ -134,7 +134,7 @@ int DetectHttpMethodSetup(DetectEngineCtx *de_ctx, Signature *s,
bstr *method;
if ((str != NULL) && (strcmp(str, "") != 0)) {
SCLogError(SC_INVALID_ARGUMENT,
SCLogError(SC_ERR_INVALID_ARGUMENT,
"http_method does not take an argument");
SCReturnInt(-1);
}

@ -127,7 +127,7 @@ DetectIcmpIdData *DetectIcmpIdParse (char *icmpidstr) {
ret = pcre_exec(parse_regex, parse_regex_study, icmpidstr, strlen(icmpidstr), 0, 0, ov, MAX_SUBSTRINGS);
if (ret < 1 || ret > 4) {
SCLogError(SC_PCRE_MATCH_FAILED, "Parse error %s", icmpidstr);
SCLogError(SC_ERR_PCRE_MATCH_FAILED, "Parse error %s", icmpidstr);
goto error;
}
@ -136,7 +136,7 @@ DetectIcmpIdData *DetectIcmpIdParse (char *icmpidstr) {
for (i = 1; i < ret; i++) {
res = pcre_get_substring((char *)icmpidstr, ov, MAX_SUBSTRINGS, i, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
goto error;
}
substr[i-1] = (char *)str_ptr;
@ -151,12 +151,12 @@ DetectIcmpIdData *DetectIcmpIdParse (char *icmpidstr) {
if (strlen(substr[0]) != 0) {
if (substr[2] == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Missing close quote in input");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Missing close quote in input");
goto error;
}
} else {
if (substr[2] != NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Missing open quote in input");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Missing open quote in input");
goto error;
}
}

@ -41,13 +41,13 @@ void DetectIcmpSeqRegister (void) {
parse_regex = pcre_compile(PARSE_REGEX, opts, &eb, &eo, NULL);
if (parse_regex == NULL) {
SCLogError(SC_PCRE_COMPILE_FAILED,"pcre compile of \"%s\" failed at offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
SCLogError(SC_ERR_PCRE_COMPILE_FAILED,"pcre compile of \"%s\" failed at offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
goto error;
}
parse_regex_study = pcre_study(parse_regex, 0, &eb);
if (eb != NULL) {
SCLogError(SC_PCRE_STUDY_FAILED,"pcre study failed: %s", eb);
SCLogError(SC_ERR_PCRE_STUDY_FAILED,"pcre study failed: %s", eb);
goto error;
}
return;
@ -126,14 +126,14 @@ DetectIcmpSeqData *DetectIcmpSeqParse (char *icmpseqstr) {
ret = pcre_exec(parse_regex, parse_regex_study, icmpseqstr, strlen(icmpseqstr), 0, 0, ov, MAX_SUBSTRINGS);
if (ret < 1 || ret > 4) {
SCLogError(SC_PCRE_MATCH_FAILED,"Parse error %s", icmpseqstr);
SCLogError(SC_ERR_PCRE_MATCH_FAILED,"Parse error %s", icmpseqstr);
goto error;
}
for (i = 1; i < ret; i++) {
res = pcre_get_substring((char *)icmpseqstr, ov, MAX_SUBSTRINGS, i, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED,"pcre_get_substring failed");
goto error;
}
substr[i-1] = (char *)str_ptr;

@ -49,14 +49,14 @@ void DetectICodeRegister (void) {
parse_regex = pcre_compile(PARSE_REGEX, opts, &eb, &eo, NULL);
if(parse_regex == NULL)
{
SCLogError(SC_PCRE_COMPILE_FAILED, "pcre compile of \"%s\" failed at offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
SCLogError(SC_ERR_PCRE_COMPILE_FAILED, "pcre compile of \"%s\" failed at offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
goto error;
}
parse_regex_study = pcre_study(parse_regex, 0, &eb);
if(eb != NULL)
{
SCLogError(SC_PCRE_COMPILE_FAILED, "pcre study failed: %s", eb);
SCLogError(SC_ERR_PCRE_COMPILE_FAILED, "pcre study failed: %s", eb);
goto error;
}
return;
@ -125,7 +125,7 @@ DetectICodeData *DetectICodeParse(char *icodestr) {
ret = pcre_exec(parse_regex, parse_regex_study, icodestr, strlen(icodestr), 0, 0, ov, MAX_SUBSTRINGS);
if (ret < 1 || ret > 4) {
SCLogError(SC_PCRE_MATCH_FAILED, "DetectICodeParse: parse error");
SCLogError(SC_ERR_PCRE_MATCH_FAILED, "DetectICodeParse: parse error");
goto error;
}
@ -134,7 +134,7 @@ DetectICodeData *DetectICodeParse(char *icodestr) {
for (i = 1; i < ret; i++) {
res = pcre_get_substring((char *)icodestr, ov, MAX_SUBSTRINGS, i, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "DetectICodeParse: pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "DetectICodeParse: pcre_get_substring failed");
goto error;
}
args[i-1] = (char *)str_ptr;

@ -49,14 +49,14 @@ void DetectITypeRegister (void) {
parse_regex = pcre_compile(PARSE_REGEX, opts, &eb, &eo, NULL);
if(parse_regex == NULL)
{
SCLogError(SC_PCRE_COMPILE_FAILED, "pcre compile of \"%s\" failed at offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
SCLogError(SC_ERR_PCRE_COMPILE_FAILED, "pcre compile of \"%s\" failed at offset %" PRId32 ": %s", PARSE_REGEX, eo, eb);
goto error;
}
parse_regex_study = pcre_study(parse_regex, 0, &eb);
if(eb != NULL)
{
SCLogError(SC_PCRE_COMPILE_FAILED, "pcre study failed: %s", eb);
SCLogError(SC_ERR_PCRE_COMPILE_FAILED, "pcre study failed: %s", eb);
goto error;
}
return;
@ -125,7 +125,7 @@ DetectITypeData *DetectITypeParse(char *itypestr) {
ret = pcre_exec(parse_regex, parse_regex_study, itypestr, strlen(itypestr), 0, 0, ov, MAX_SUBSTRINGS);
if (ret < 1 || ret > 4) {
SCLogError(SC_PCRE_MATCH_FAILED, "DetectITypeParse: parse error");
SCLogError(SC_ERR_PCRE_MATCH_FAILED, "DetectITypeParse: parse error");
goto error;
}
@ -134,7 +134,7 @@ DetectITypeData *DetectITypeParse(char *itypestr) {
for (i = 1; i < ret; i++) {
res = pcre_get_substring((char *)itypestr, ov, MAX_SUBSTRINGS, i, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "DetectITypeParse: pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "DetectITypeParse: pcre_get_substring failed");
goto error;
}
args[i-1] = (char *)str_ptr;

@ -48,7 +48,7 @@ int DetectOffsetSetup (DetectEngineCtx *de_ctx, Signature *s, SigMatch *m, char
DetectContentData *cd = (DetectContentData *)pm->ctx;
if (cd == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "invalid argument");
SCLogError(SC_ERR_INVALID_ARGUMENT, "invalid argument");
if (dubbed) free(str);
return -1;
}

@ -250,7 +250,7 @@ int SigParseOptions(DetectEngineCtx *de_ctx, Signature *s, SigMatch *m, char *op
/* Call option parsing */
st = SigTableGet((char *)arr[0]);
if (st == NULL) {
SCLogError(SC_RULE_KEYWORD_UNKNOWN, "unknown rule keyword '%s'.", (char *)arr[0]);
SCLogError(SC_ERR_RULE_KEYWORD_UNKNOWN, "unknown rule keyword '%s'.", (char *)arr[0]);
goto error;
}

@ -196,7 +196,7 @@ DetectRpcData *DetectRpcParse (char *rpcstr)
switch (i) {
case 0:
if (ByteExtractStringUint32(&rd->program, 10, strlen(args[i]), args[i]) <= 0) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid size specified for the rpc program:\"%s\"", args[i]);
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid size specified for the rpc program:\"%s\"", args[i]);
goto error;
}
rd->flags |= DETECT_RPC_CHECK_PROGRAM;
@ -204,7 +204,7 @@ DetectRpcData *DetectRpcParse (char *rpcstr)
case 1:
if (args[i][0] != '*') {
if (ByteExtractStringUint32(&rd->program_version, 10, strlen(args[i]), args[i]) <= 0) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid size specified for the rpc version:\"%s\"", args[i]);
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid size specified for the rpc version:\"%s\"", args[i]);
goto error;
}
rd->flags |= DETECT_RPC_CHECK_VERSION;
@ -213,7 +213,7 @@ DetectRpcData *DetectRpcParse (char *rpcstr)
case 2:
if (args[i][0] != '*') {
if (ByteExtractStringUint32(&rd->procedure, 10, strlen(args[i]), args[i]) <= 0) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid size specified for the rpc procedure:\"%s\"", args[i]);
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid size specified for the rpc procedure:\"%s\"", args[i]);
goto error;
}
rd->flags |= DETECT_RPC_CHECK_PROCEDURE;

@ -149,14 +149,14 @@ DetectUrilenData *DetectUrilenParse (char *urilenstr)
ret = pcre_exec(parse_regex, parse_regex_study, urilenstr, strlen(urilenstr),
0, 0, ov, MAX_SUBSTRINGS);
if (ret < 3 || ret > 5) {
SCLogError(SC_PCRE_PARSE_FAILED, "parse error, ret %" PRId32 "", ret);
SCLogError(SC_ERR_PCRE_PARSE_FAILED, "parse error, ret %" PRId32 "", ret);
goto error;
}
const char *str_ptr;
res = pcre_get_substring((char *)urilenstr, ov, MAX_SUBSTRINGS, 1, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
goto error;
}
arg1 = (char *) str_ptr;
@ -164,7 +164,7 @@ DetectUrilenData *DetectUrilenParse (char *urilenstr)
res = pcre_get_substring((char *)urilenstr, ov, MAX_SUBSTRINGS, 2, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
goto error;
}
arg2 = (char *) str_ptr;
@ -172,7 +172,7 @@ DetectUrilenData *DetectUrilenParse (char *urilenstr)
res = pcre_get_substring((char *)urilenstr, ov, MAX_SUBSTRINGS, 3, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
goto error;
}
arg3 = (char *) str_ptr;
@ -180,7 +180,7 @@ DetectUrilenData *DetectUrilenParse (char *urilenstr)
res = pcre_get_substring((char *)urilenstr, ov, MAX_SUBSTRINGS, 4, &str_ptr);
if (res < 0) {
SCLogError(SC_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
SCLogError(SC_ERR_PCRE_GET_SUBSTRING_FAILED, "pcre_get_substring failed");
goto error;
}
arg4 = (char *) str_ptr;
@ -200,7 +200,7 @@ DetectUrilenData *DetectUrilenParse (char *urilenstr)
if (strcmp("<>", arg3) == 0) {
if (strlen(arg1) != 0) {
SCLogError(SC_INVALID_ARGUMENT,"Range specified but mode also set");
SCLogError(SC_ERR_INVALID_ARGUMENT,"Range specified but mode also set");
goto error;
}
urilend->mode = DETECT_URILEN_RA;
@ -208,26 +208,26 @@ DetectUrilenData *DetectUrilenParse (char *urilenstr)
/** set the first urilen value */
if(ByteExtractStringUint16(&urilend->urilen1,10,strlen(arg2),arg2) <= 0){
SCLogError(SC_INVALID_ARGUMENT,"Invalid size :\"%s\"",arg2);
SCLogError(SC_ERR_INVALID_ARGUMENT,"Invalid size :\"%s\"",arg2);
goto error;
}
/** set the second urilen value if specified */
if (strlen(arg4) > 0) {
if (urilend->mode != DETECT_URILEN_RA) {
SCLogError(SC_INVALID_ARGUMENT,"Multiple urilen values specified"
SCLogError(SC_ERR_INVALID_ARGUMENT,"Multiple urilen values specified"
" but mode is not range");
goto error;
}
if(ByteExtractStringUint16(&urilend->urilen2,10,strlen(arg4),arg4) <= 0)
{
SCLogError(SC_INVALID_ARGUMENT,"Invalid size :\"%s\"",arg4);
SCLogError(SC_ERR_INVALID_ARGUMENT,"Invalid size :\"%s\"",arg4);
goto error;
}
if (urilend->urilen2 <= urilend->urilen1){
SCLogError(SC_INVALID_ARGUMENT,"urilen2:%"PRIu16" <= urilen:"
SCLogError(SC_ERR_INVALID_ARGUMENT,"urilen2:%"PRIu16" <= urilen:"
"%"PRIu16"",urilend->urilen2,urilend->urilen1);
goto error;
}

@ -234,7 +234,7 @@ int DetectLoadSigFile(DetectEngineCtx *de_ctx, char *sig_file, int *sigs_tot) {
int lineno = 0, multiline = 0;
if (sig_file == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "ERROR opening rule file null.");
SCLogError(SC_ERR_INVALID_ARGUMENT, "ERROR opening rule file null.");
return -1;
}

@ -209,7 +209,7 @@ Reputation *SCReputationClone(Reputation *orig)
{
Reputation *rep = NULL;
if (orig == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid arguments");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid arguments");
return NULL;
}
@ -249,13 +249,13 @@ Reputation *SCReputationAddIPV4Data(uint8_t *ipv4addr, int netmask_value, Reputa
struct in_addr *ipv4_addr = (struct in_addr *) ipv4addr;
if (ipv4_addr == NULL || rep_data == NULL || rep_ctx == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid arguments");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid arguments");
return NULL;
}
/* If the reputation tree is not initialized yet */
if (rep_ctx->reputationIPV4_tree == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Reputation trees not initialized");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Reputation trees not initialized");
return NULL;
}
@ -268,7 +268,7 @@ Reputation *SCReputationAddIPV4Data(uint8_t *ipv4addr, int netmask_value, Reputa
} else {
if (netmask_value < 0 || netmask_value > 31) {
SCLogError(SC_INVALID_IP_NETBLOCK, "Invalid IPV4 Netblock");
SCLogError(SC_ERR_INVALID_IP_NETBLOCK, "Invalid IPV4 Netblock");
return NULL;
}
@ -519,13 +519,13 @@ Reputation *SCReputationAddIPV6Data(uint8_t *ipv6addr, int netmask_value, Reputa
struct in_addr *ipv6_addr = (struct in_addr *) ipv6addr;
if (ipv6_addr == NULL || rep_data == NULL || rep_ctx == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid arguments");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid arguments");
return NULL;
}
/* If the reputation tree is not initialized yet */
if (rep_ctx->reputationIPV6_tree == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Reputation trees not initialized");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Reputation trees not initialized");
return NULL;
}
@ -538,7 +538,7 @@ Reputation *SCReputationAddIPV6Data(uint8_t *ipv6addr, int netmask_value, Reputa
} else {
if (netmask_value < 0 || netmask_value > 127) {
SCLogError(SC_INVALID_IP_NETBLOCK, "Invalid IPV6 Netblock");
SCLogError(SC_ERR_INVALID_IP_NETBLOCK, "Invalid IPV6 Netblock");
return NULL;
}
@ -570,13 +570,13 @@ Reputation *SCReputationUpdateIPV4Data(uint8_t *ipv4addr, ReputationTransaction
Reputation *actual_rep;
if (ipv4_addr == NULL || rtx == NULL || rep_ctx == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid arguments");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid arguments");
return NULL;
}
/* If the reputation tree is not initialized yet */
if (rep_ctx->reputationIPV4_tree == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Reputation trees not initialized");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Reputation trees not initialized");
return NULL;
}
@ -629,13 +629,13 @@ Reputation *SCReputationUpdateIPV6Data(uint8_t *ipv6addr, ReputationTransaction
Reputation *actual_rep;
if (ipv6_addr == NULL || rtx == NULL || rep_ctx == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid arguments");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid arguments");
return NULL;
}
/* If the reputation tree is not initialized yet */
if (rep_ctx->reputationIPV6_tree == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Reputation trees not initialized");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Reputation trees not initialized");
return NULL;
}

@ -72,7 +72,7 @@ void RunModeInitializeOutputs(void)
OutputModule *module = OutputGetModuleByConfName(output->val);
if (module == NULL) {
SCLogWarning(SC_INVALID_ARGUMENT,
SCLogWarning(SC_ERR_INVALID_ARGUMENT,
"No output module named %s, ignoring", output->val);
continue;
}
@ -80,7 +80,7 @@ void RunModeInitializeOutputs(void)
output_config = ConfNodeLookupChild(output, module->conf_name);
if (output_config == NULL) {
/* Shouldn't happen. */
SCLogError(SC_INVALID_ARGUMENT,
SCLogError(SC_ERR_INVALID_ARGUMENT,
"Failed to lookup configuration child node: fast");
exit(1);
}
@ -95,7 +95,7 @@ void RunModeInitializeOutputs(void)
}
tm_module = TmModuleGetByName(module->name);
if (tm_module == NULL) {
SCLogError(SC_INVALID_ARGUMENT,
SCLogError(SC_ERR_INVALID_ARGUMENT,
"TmModuleGetByName for %s failed", module->name);
exit(EXIT_FAILURE);
}

@ -148,7 +148,7 @@ void NFQSetupPkt (Packet *p, void *data)
/* Will not be able to copy data ! Set length to 0
* to trigger an error in packet decoding.
* This is unlikely to happen */
SCLogWarning(SC_INVALID_ARGUMENTS, "NFQ sent too big packet");
SCLogWarning(SC_ERR_INVALID_ARGUMENTS, "NFQ sent too big packet");
p->pktlen = 0;
} else {
memcpy(p->pkt, pktdata, ret);
@ -200,7 +200,7 @@ TmEcode NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_m
SCLogDebug("opening library handle");
nfq_t->h = nfq_open();
if (!nfq_t->h) {
SCLogError(SC_NFQ_OPEN, "nfq_open() failed");
SCLogError(SC_ERR_NFQ_OPEN, "nfq_open() failed");
return TM_ECODE_FAILED;
}
@ -210,21 +210,21 @@ TmEcode NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_m
* run. Ignoring the error seems to have no bad effects. */
SCLogDebug("unbinding existing nf_queue handler for AF_INET (if any)");
if (nfq_unbind_pf(nfq_t->h, AF_INET) < 0) {
SCLogWarning(SC_NFQ_UNBIND, "nfq_unbind_pf() for AF_INET failed");
SCLogWarning(SC_ERR_NFQ_UNBIND, "nfq_unbind_pf() for AF_INET failed");
}
if (nfq_unbind_pf(nfq_t->h, AF_INET6) < 0) {
SCLogWarning(SC_NFQ_UNBIND, "nfq_unbind_pf() for AF_INET6 failed");
SCLogWarning(SC_ERR_NFQ_UNBIND, "nfq_unbind_pf() for AF_INET6 failed");
}
nfq_g.unbind = 1;
SCLogDebug("binding nfnetlink_queue as nf_queue handler for AF_INET and AF_INET6");
if (nfq_bind_pf(nfq_t->h, AF_INET) < 0) {
SCLogError(SC_NFQ_BIND, "nfq_bind_pf() for AF_INET failed");
SCLogError(SC_ERR_NFQ_BIND, "nfq_bind_pf() for AF_INET failed");
return TM_ECODE_FAILED;
}
if (nfq_bind_pf(nfq_t->h, AF_INET6) < 0) {
SCLogError(SC_NFQ_BIND, "nfq_bind_pf() for AF_INET6 failed");
SCLogError(SC_ERR_NFQ_BIND, "nfq_bind_pf() for AF_INET6 failed");
return TM_ECODE_FAILED;
}
}
@ -236,7 +236,7 @@ TmEcode NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_m
nfq_t->qh = nfq_create_queue(nfq_t->h, nfq_t->queue_num, &NFQCallBack, (void *)nfq_t);
if (nfq_t->qh == NULL)
{
SCLogError(SC_NFQ_CREATE_QUEUE, "nfq_create_queue failed");
SCLogError(SC_ERR_NFQ_CREATE_QUEUE, "nfq_create_queue failed");
return TM_ECODE_FAILED;
}
@ -245,7 +245,7 @@ TmEcode NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_m
/* 05DC = 1500 */
//if (nfq_set_mode(nfq_t->qh, NFQNL_COPY_PACKET, 0x05DC) < 0) {
if (nfq_set_mode(nfq_t->qh, NFQNL_COPY_PACKET, 0xFFFF) < 0) {
SCLogError(SC_NFQ_SET_MODE, "can't set packet_copy mode");
SCLogError(SC_ERR_NFQ_SET_MODE, "can't set packet_copy mode");
return TM_ECODE_FAILED;
}
@ -257,7 +257,7 @@ TmEcode NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_m
/* non-fatal if it fails */
if (nfq_set_queue_maxlen(nfq_t->qh, queue_maxlen) < 0) {
SCLogWarning(SC_NFQ_MAXLEN, "can't set queue maxlen: your kernel probably "
SCLogWarning(SC_ERR_NFQ_MAXLEN, "can't set queue maxlen: your kernel probably "
"doesn't support setting the queue length");
}
}
@ -275,7 +275,7 @@ TmEcode NFQInitThread(NFQThreadVars *nfq_t, uint16_t queue_num, uint32_t queue_m
tv.tv_usec = 0;
if(setsockopt(nfq_t->fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) == -1) {
SCLogWarning(SC_NFQ_SETSOCKOPT, "can't set socket timeout: %s", strerror(errno));
SCLogWarning(SC_ERR_NFQ_SETSOCKOPT, "can't set socket timeout: %s", strerror(errno));
}
SCLogDebug("nfq_t->h %p, nfq_t->nh %p, nfq_t->qh %p, nfq_t->fd %" PRId32 "",
@ -302,14 +302,14 @@ TmEcode ReceiveNFQThreadInit(ThreadVars *tv, void *initdata, void **data) {
if ((ByteExtractStringUint16(&queue_num, 10, strlen((char *)initdata),
(char *)initdata)) < 0)
{
SCLogError(SC_INVALID_ARGUMENT, "specified queue number %s is not "
SCLogError(SC_ERR_INVALID_ARGUMENT, "specified queue number %s is not "
"valid", (char *)initdata);
exit(EXIT_FAILURE);
}
int r = NFQInitThread(ntv, queue_num, NFQ_DFT_QUEUE_LEN);
if (r < 0) {
SCLogError(SC_NFQ_THREAD_INIT, "nfq thread failed to initialize");
SCLogError(SC_ERR_NFQ_THREAD_INIT, "nfq thread failed to initialize");
SCMutexUnlock(&nfq_init_lock);
exit(EXIT_FAILURE);
@ -359,7 +359,7 @@ void NFQRecvPkt(NFQThreadVars *t) {
#endif /* COUNTERS */
}
} else if(rv == 0) {
SCLogWarning(SC_NFQ_RECV, "recv got returncode 0");
SCLogWarning(SC_ERR_NFQ_RECV, "recv got returncode 0");
} else {
#ifdef DBG_PERF
if (rv > t->dbg_maxreadsize)
@ -373,7 +373,7 @@ void NFQRecvPkt(NFQThreadVars *t) {
SCMutexUnlock(&t->mutex_qh);
if (ret != 0) {
SCLogWarning(SC_NFQ_HANDLE_PKT, "nfq_handle_packet error %" PRId32 "", ret);
SCLogWarning(SC_ERR_NFQ_HANDLE_PKT, "nfq_handle_packet error %" PRId32 "", ret);
}
}
}
@ -436,7 +436,7 @@ void NFQSetVerdict(NFQThreadVars *t, Packet *p) {
SCMutexUnlock(&t->mutex_qh);
if (ret < 0) {
SCLogWarning(SC_NFQ_SET_VERDICT, "nfq_set_verdict of %p failed %" PRId32 "", p, ret);
SCLogWarning(SC_ERR_NFQ_SET_VERDICT, "nfq_set_verdict of %p failed %" PRId32 "", p, ret);
}
}

@ -799,7 +799,7 @@ int main(int argc, char **argv)
/* Wait till all the threads have been initialized */
if (TmThreadWaitOnThreadInit() == TM_ECODE_FAILED) {
SCLogError(SC_INITIALIZATION_ERROR, "Engine initialization failed, "
SCLogError(SC_ERR_INITIALIZATION_ERROR, "Engine initialization failed, "
"aborting...");
exit(EXIT_FAILURE);
}

@ -77,7 +77,7 @@ typedef struct TmVarSlot_ {
inline int TmThreadsCheckFlag(ThreadVars *tv, uint8_t flag) {
int r;
if (SCSpinLock(&tv->flags_spinlock) != 0) {
SCLogError(SC_SPINLOCK_ERROR,"spin lock errno=%d",errno);
SCLogError(SC_ERR_SPINLOCK_ERROR,"spin lock errno=%d",errno);
return 0;
}
@ -88,7 +88,7 @@ inline int TmThreadsCheckFlag(ThreadVars *tv, uint8_t flag) {
inline void TmThreadsSetFlag(ThreadVars *tv, uint8_t flag) {
if (SCSpinLock(&tv->flags_spinlock) != 0) {
SCLogError(SC_SPINLOCK_ERROR,"spin lock errno=%d",errno);
SCLogError(SC_ERR_SPINLOCK_ERROR,"spin lock errno=%d",errno);
return;
}
@ -98,7 +98,7 @@ inline void TmThreadsSetFlag(ThreadVars *tv, uint8_t flag) {
inline void TmThreadsUnsetFlag(ThreadVars *tv, uint8_t flag) {
if (SCSpinLock(&tv->flags_spinlock) != 0) {
SCLogError(SC_SPINLOCK_ERROR,"spin lock errno=%d",errno);
SCLogError(SC_ERR_SPINLOCK_ERROR,"spin lock errno=%d",errno);
return;
}

@ -128,10 +128,10 @@ int ByteExtractString(uint64_t *res, int base, uint16_t len, const char *str)
*res = strtoull(ptr, &endptr, base);
if (errno == ERANGE) {
SCLogError(SC_NUMERIC_VALUE_ERANGE, "Numeric value out of range");
SCLogError(SC_ERR_NUMERIC_VALUE_ERANGE, "Numeric value out of range");
return -1;
} else if (endptr == str) {
SCLogError(SC_INVALID_NUMERIC_VALUE, "Invalid numeric value");
SCLogError(SC_ERR_INVALID_NUMERIC_VALUE, "Invalid numeric value");
return -1;
/* If there is no numeric value in the given string then strtoull(), makes
endptr equals to ptr and return 0 as result */
@ -170,7 +170,7 @@ inline int ByteExtractStringUint32(uint32_t *res, int base, uint16_t len, const
*res = (uint32_t)i64;
if ((uint64_t)(*res) != i64) {
SCLogError(SC_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
SCLogError(SC_ERR_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
"(%" PRIx64 " != %" PRIx64 ")", (uint64_t)(*res), i64);
return -1;
}
@ -191,7 +191,7 @@ inline int ByteExtractStringUint16(uint16_t *res, int base, uint16_t len, const
*res = (uint16_t)i64;
if ((uint64_t)(*res) != i64) {
SCLogError(SC_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
SCLogError(SC_ERR_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
"(%" PRIx64 " != %" PRIx64 ")", (uint64_t)(*res), i64);
return -1;
}
@ -212,7 +212,7 @@ inline int ByteExtractStringUint8(uint8_t *res, int base, uint16_t len, const ch
*res = (uint8_t)i64;
if ((uint64_t)(*res) != i64) {
SCLogError(SC_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
SCLogError(SC_ERR_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
"(%" PRIx64 " != %" PRIx64 ")", (uint64_t)(*res), i64);
return -1;
}
@ -250,10 +250,10 @@ int ByteExtractStringSigned(int64_t *res, int base, uint16_t len, const char *st
*res = strtoll(ptr, &endptr, base);
if (errno == ERANGE) {
SCLogError(SC_NUMERIC_VALUE_ERANGE, "Numeric value out of range");
SCLogError(SC_ERR_NUMERIC_VALUE_ERANGE, "Numeric value out of range");
return -1;
} else if (endptr == str) {
SCLogError(SC_INVALID_NUMERIC_VALUE, "Invalid numeric value");
SCLogError(SC_ERR_INVALID_NUMERIC_VALUE, "Invalid numeric value");
return -1;
}
/* This will interfere with some rules that do not know the length
@ -289,7 +289,7 @@ inline int ByteExtractStringInt32(int32_t *res, int base, uint16_t len, const ch
*res = (int32_t)i64;
if ((int64_t)(*res) != i64) {
SCLogError(SC_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
SCLogError(SC_ERR_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
"(%" PRIx64 " != %" PRIx64 ")\n", (int64_t)(*res), i64);
return -1;
}
@ -310,7 +310,7 @@ inline int ByteExtractStringInt16(int16_t *res, int base, uint16_t len, const ch
*res = (int16_t)i64;
if ((int64_t)(*res) != i64) {
SCLogError(SC_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
SCLogError(SC_ERR_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
"(%" PRIx64 " != %" PRIx64 ")\n", (int64_t)(*res), i64);
return -1;
}
@ -331,7 +331,7 @@ inline int ByteExtractStringInt8(int8_t *res, int base, uint16_t len, const char
*res = (int8_t)i64;
if ((int64_t)(*res) != i64) {
SCLogError(SC_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
SCLogError(SC_ERR_NUMERIC_VALUE_ERANGE, "Numeric value out of range "
"(%" PRIx64 " != %" PRIx64 ")\n", (int64_t)(*res), i64);
return -1;
}

@ -87,10 +87,10 @@ int CheckValidDaemonModes (int daemon, int mode) {
if (daemon) {
switch (mode) {
case MODE_PCAP_FILE:
SCLogError(SC_INVALID_RUNMODE, "ERROR: pcap offline mode cannot run as daemon");
SCLogError(SC_ERR_INVALID_RUNMODE, "ERROR: pcap offline mode cannot run as daemon");
return 0;
case MODE_UNITTEST:
SCLogError(SC_INVALID_RUNMODE, "ERROR: unittests cannot run as daemon");
SCLogError(SC_ERR_INVALID_RUNMODE, "ERROR: unittests cannot run as daemon");
return 0;
default:
SCLogDebug("Allowed mode");

@ -278,19 +278,19 @@ SCError SCLogMessage(SCLogLevel log_level, char **msg, const char *file,
printf("Logging module not initialized. Call SCLogInitLogModule(), "
"before using the logging API\n");
#endif
return SC_LOG_MODULE_NOT_INIT;
return SC_ERR_LOG_MODULE_NOT_INIT;
}
if (sc_log_fg_filters_present == 1) {
if (SCLogMatchFGFilterWL(file, function, line) != 1)
return SC_LOG_FG_FILTER_MATCH_FAILED;
return SC_ERR_LOG_FG_FILTER_MATCH_FAILED;
if (SCLogMatchFGFilterBL(file, function, line) != 1)
return SC_LOG_FG_FILTER_MATCH_FAILED;
return SC_ERR_LOG_FG_FILTER_MATCH_FAILED;
}
if (sc_log_fd_filters_present == 1 && SCLogMatchFDFilter(function) != 1)
return SC_LOG_FG_FILTER_MATCH_FAILED;
return SC_ERR_LOG_FG_FILTER_MATCH_FAILED;
while ( (temp_fmt = index(temp_fmt, SC_LOG_FMT_PREFIX)) ) {
if ((temp - *msg) > SC_LOG_MAX_LOG_MSG_LEN) {
@ -423,7 +423,7 @@ SCError SCLogMessage(SCLogLevel log_level, char **msg, const char *file,
return SC_OK;
error:
return SC_SPRINTF_ERROR;
return SC_ERR_SPRINTF_ERROR;
}
/**
@ -1026,7 +1026,7 @@ void SCLogLoadConfig(void)
sc_lid->global_log_level =
SCMapEnumNameToValue(default_log_level_s, sc_log_level_map);
if (sc_lid->global_log_level == -1) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid default log level: %s",
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid default log level: %s",
default_log_level_s);
exit(EXIT_FAILURE);
}
@ -1060,7 +1060,7 @@ void SCLogLoadConfig(void)
if (level_s != NULL) {
level = SCMapEnumNameToValue(level_s, sc_log_level_map);
if (level == -1) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid log level: %s",
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid log level: %s",
level_s);
exit(EXIT_FAILURE);
}
@ -1086,7 +1086,7 @@ void SCLogLoadConfig(void)
facility = SCMapEnumNameToValue(facility_s,
sc_syslog_facility_map);
if (facility == -1) {
SCLogError(SC_INVALID_ARGUMENT,
SCLogError(SC_ERR_INVALID_ARGUMENT,
"Invalid syslog facility: %s", facility_s);
exit(EXIT_FAILURE);
}
@ -1096,7 +1096,7 @@ void SCLogLoadConfig(void)
op_iface_ctx = SCLogInitSyslogOPIface(facility, format, level);
}
else {
SCLogWarning(SC_INVALID_ARGUMENT, "Invalid logging method: %s, "
SCLogWarning(SC_ERR_INVALID_ARGUMENT, "Invalid logging method: %s, "
"ignoring", output->name);
}
if (op_iface_ctx != NULL) {

@ -18,42 +18,42 @@ const char * SCErrorToString(SCError err)
switch (err) {
CASE_CODE (SC_OK);
CASE_CODE (SC_ERR_MEM_ALLOC);
CASE_CODE (SC_PCRE_MATCH_FAILED);
CASE_CODE (SC_PCRE_GET_SUBSTRING_FAILED);
CASE_CODE (SC_PCRE_COMPILE_FAILED);
CASE_CODE (SC_PCRE_STUDY_FAILED);
CASE_CODE (SC_PCRE_PARSE_FAILED);
CASE_CODE (SC_LOG_MODULE_NOT_INIT);
CASE_CODE (SC_LOG_FG_FILTER_MATCH_FAILED);
CASE_CODE (SC_ERR_PCRE_MATCH_FAILED);
CASE_CODE (SC_ERR_PCRE_GET_SUBSTRING_FAILED);
CASE_CODE (SC_ERR_PCRE_COMPILE_FAILED);
CASE_CODE (SC_ERR_PCRE_STUDY_FAILED);
CASE_CODE (SC_ERR_PCRE_PARSE_FAILED);
CASE_CODE (SC_ERR_LOG_MODULE_NOT_INIT);
CASE_CODE (SC_ERR_LOG_FG_FILTER_MATCH_FAILED);
CASE_CODE (SC_ERR_INVALID_SIGNATURE);
CASE_CODE (SC_ERR_OPENING_FILE);
CASE_CODE (SC_ERR_OPENING_RULE_FILE);
CASE_CODE (SC_ERR_NO_RULES);
CASE_CODE (SC_ERR_NO_RULES_LOADED);
CASE_CODE (SC_COUNTER_EXCEEDED);
CASE_CODE (SC_INVALID_CHECKSUM);
CASE_CODE (SC_SPRINTF_ERROR);
CASE_CODE (SC_INVALID_ARGUMENT);
CASE_CODE (SC_SPINLOCK_ERROR);
CASE_CODE (SC_INVALID_ENUM_MAP);
CASE_CODE (SC_INVALID_IP_NETBLOCK);
CASE_CODE (SC_INVALID_IPV4_ADDR);
CASE_CODE (SC_INVALID_IPV6_ADDR);
CASE_CODE (SC_INVALID_RUNMODE);
CASE_CODE (SC_COMPLETE_PORT_SPACE_NEGATED);
CASE_CODE (SC_NO_PORTS_LEFT_AFTER_MERGE);
CASE_CODE (SC_NEGATED_VALUE_IN_PORT_RANGE);
CASE_CODE (SC_PORT_PARSE_INSERT_STRING_ERR);
CASE_CODE (SC_UNREACHABLE_CODE_REACHED);
CASE_CODE (SC_INVALID_NUMERIC_VALUE);
CASE_CODE (SC_NUMERIC_VALUE_ERANGE);
CASE_CODE (SC_INVALID_NUM_BYTES);
CASE_CODE (SC_ERR_COUNTER_EXCEEDED);
CASE_CODE (SC_ERR_INVALID_CHECKSUM);
CASE_CODE (SC_ERR_SPRINTF_ERROR);
CASE_CODE (SC_ERR_INVALID_ARGUMENT);
CASE_CODE (SC_ERR_SPINLOCK_ERROR);
CASE_CODE (SC_ERR_INVALID_ENUM_MAP);
CASE_CODE (SC_ERR_INVALID_IP_NETBLOCK);
CASE_CODE (SC_ERR_INVALID_IPV4_ADDR);
CASE_CODE (SC_ERR_INVALID_IPV6_ADDR);
CASE_CODE (SC_ERR_INVALID_RUNMODE);
CASE_CODE (SC_ERR_COMPLETE_PORT_SPACE_NEGATED);
CASE_CODE (SC_ERR_NO_PORTS_LEFT_AFTER_MERGE);
CASE_CODE (SC_ERR_NEGATED_VALUE_IN_PORT_RANGE);
CASE_CODE (SC_ERR_PORT_PARSE_INSERT_STRING_ERR);
CASE_CODE (SC_ERR_UNREACHABLE_CODE_REACHED);
CASE_CODE (SC_ERR_INVALID_NUMERIC_VALUE);
CASE_CODE (SC_ERR_NUMERIC_VALUE_ERANGE);
CASE_CODE (SC_ERR_INVALID_NUM_BYTES);
CASE_CODE (SC_ERR_ARG_LEN_LONG);
CASE_CODE (SC_ALPARSER_ERR);
CASE_CODE (SC_ERR_ALPARSER_ERR);
CASE_CODE (SC_ERR_POOL_EMPTY);
CASE_CODE (SC_ERR_REASSEMBLY_FAILED);
CASE_CODE (SC_ERR_POOL_INIT_FAILED);
CASE_CODE (SC_UNIMPLEMENTED);
CASE_CODE (SC_ERR_UNIMPLEMENTED);
CASE_CODE (SC_ERR_FAST_LOG_GENERIC_ERROR);
CASE_CODE (SC_ERR_DEBUG_LOG_GENERIC_ERROR);
CASE_CODE (SC_ERR_UNIFIED_LOG_GENERIC_ERROR);
@ -64,7 +64,7 @@ const char * SCErrorToString(SCError err)
CASE_CODE (SC_ERR_FOPEN);
CASE_CODE (SC_ERR_THRESHOLD_HASH_ADD);
CASE_CODE (SC_ERR_UNDEFINED_VAR);
CASE_CODE (SC_RULE_KEYWORD_UNKNOWN);
CASE_CODE (SC_ERR_RULE_KEYWORD_UNKNOWN);
CASE_CODE (SC_ERR_FLAGS_MODIFIER);
CASE_CODE (SC_ERR_DISTANCE_MISSING_CONTENT);
CASE_CODE (SC_ERR_WITHIN_MISSING_CONTENT);

@ -13,60 +13,60 @@
typedef enum {
SC_OK,
SC_ERR_MEM_ALLOC,
SC_PCRE_MATCH_FAILED,
SC_PCRE_GET_SUBSTRING_FAILED,
SC_PCRE_COMPILE_FAILED,
SC_PCRE_STUDY_FAILED,
SC_PCRE_PARSE_FAILED,
SC_LOG_MODULE_NOT_INIT,
SC_LOG_FG_FILTER_MATCH_FAILED,
SC_COUNTER_EXCEEDED,
SC_INVALID_CHECKSUM,
SC_SPRINTF_ERROR,
SC_INVALID_ARGUMENT,
SC_SPINLOCK_ERROR,
SC_INVALID_ENUM_MAP,
SC_INVALID_IP_NETBLOCK,
SC_INVALID_IPV4_ADDR,
SC_INVALID_IPV6_ADDR,
SC_INVALID_RUNMODE,
SC_ERR_PCRE_MATCH_FAILED,
SC_ERR_PCRE_GET_SUBSTRING_FAILED,
SC_ERR_PCRE_COMPILE_FAILED,
SC_ERR_PCRE_STUDY_FAILED,
SC_ERR_PCRE_PARSE_FAILED,
SC_ERR_LOG_MODULE_NOT_INIT,
SC_ERR_LOG_FG_FILTER_MATCH_FAILED,
SC_ERR_COUNTER_EXCEEDED,
SC_ERR_INVALID_CHECKSUM,
SC_ERR_SPRINTF_ERROR,
SC_ERR_INVALID_ARGUMENT,
SC_ERR_SPINLOCK_ERROR,
SC_ERR_INVALID_ENUM_MAP,
SC_ERR_INVALID_IP_NETBLOCK,
SC_ERR_INVALID_IPV4_ADDR,
SC_ERR_INVALID_IPV6_ADDR,
SC_ERR_INVALID_RUNMODE,
SC_ERR_INVALID_SIGNATURE,
SC_ERR_OPENING_FILE,
SC_ERR_OPENING_RULE_FILE,
SC_ERR_NO_RULES,
SC_ERR_NO_RULES_LOADED,
SC_ERR_FOPEN,
SC_INITIALIZATION_ERROR,
SC_THREAD_SPAWN_FAILED,
SC_ERR_INITIALIZATION_ERROR,
SC_ERR_THREAD_SPAWN_FAILED,
SC_ERR_SYSCALL,
SC_ERR_SYSCONF,
SC_INVALID_ARGUMENTS,
SC_ERR_INVALID_ARGUMENTS,
SC_ERR_THREAD_CREATE_ERROR,
SC_ERR_PERF_STATS_NOT_INIT,
SC_COMPLETE_PORT_SPACE_NEGATED,
SC_NO_PORTS_LEFT_AFTER_MERGE,
SC_NEGATED_VALUE_IN_PORT_RANGE,
SC_PORT_PARSE_INSERT_STRING_ERR,
SC_UNREACHABLE_CODE_REACHED,
SC_ALPARSER_ERR,
SC_INVALID_NUMERIC_VALUE,
SC_NUMERIC_VALUE_ERANGE,
SC_INVALID_NUM_BYTES,
SC_ERR_COMPLETE_PORT_SPACE_NEGATED,
SC_ERR_NO_PORTS_LEFT_AFTER_MERGE,
SC_ERR_NEGATED_VALUE_IN_PORT_RANGE,
SC_ERR_PORT_PARSE_INSERT_STRING_ERR,
SC_ERR_UNREACHABLE_CODE_REACHED,
SC_ERR_ALPARSER_ERR,
SC_ERR_INVALID_NUMERIC_VALUE,
SC_ERR_NUMERIC_VALUE_ERANGE,
SC_ERR_INVALID_NUM_BYTES,
SC_ERR_ARG_LEN_LONG,
SC_ERR_POOL_EMPTY,
SC_ERR_REASSEMBLY_FAILED,
SC_ERR_POOL_INIT_FAILED,
SC_NFQ_OPEN,
SC_NFQ_BIND,
SC_NFQ_UNBIND,
SC_NFQ_MAXLEN,
SC_NFQ_CREATE_QUEUE,
SC_NFQ_SET_MODE,
SC_NFQ_SETSOCKOPT,
SC_NFQ_RECV,
SC_NFQ_HANDLE_PKT,
SC_NFQ_SET_VERDICT,
SC_NFQ_THREAD_INIT,
SC_ERR_NFQ_OPEN,
SC_ERR_NFQ_BIND,
SC_ERR_NFQ_UNBIND,
SC_ERR_NFQ_MAXLEN,
SC_ERR_NFQ_CREATE_QUEUE,
SC_ERR_NFQ_SET_MODE,
SC_ERR_NFQ_SETSOCKOPT,
SC_ERR_NFQ_RECV,
SC_ERR_NFQ_HANDLE_PKT,
SC_ERR_NFQ_SET_VERDICT,
SC_ERR_NFQ_THREAD_INIT,
SC_ERR_IPFW_NOSUPPORT,
SC_ERR_IPFW_BIND,
SC_ERR_IPFW_SOCK,
@ -76,7 +76,7 @@ typedef enum {
SC_WARN_IPFW_SETSOCKOPT,
SC_WARN_IPFW_UNBIND,
SC_ERR_DAEMON,
SC_UNIMPLEMENTED,
SC_ERR_UNIMPLEMENTED,
SC_ERR_ADDRESS_ENGINE_GENERIC_ERROR,
SC_ERR_FAST_LOG_GENERIC_ERROR,
SC_ERR_DEBUG_LOG_GENERIC_ERROR,
@ -87,7 +87,7 @@ typedef enum {
SC_ERR_FWRITE,
SC_ERR_THRESHOLD_HASH_ADD,
SC_ERR_UNDEFINED_VAR,
SC_RULE_KEYWORD_UNKNOWN,
SC_ERR_RULE_KEYWORD_UNKNOWN,
SC_ERR_FLAGS_MODIFIER,
SC_ERR_DISTANCE_MISSING_CONTENT,
SC_ERR_WITHIN_MISSING_CONTENT,
@ -100,11 +100,11 @@ typedef enum {
SC_ERR_LOGDIR_CONFIG,
SC_ERR_LOGDIR_CMDLINE,
SC_ERR_MISSING_CONFIG_PARAM,
SC_RADIX_TREE_GENERIC_ERROR,
SC_ERR_RADIX_TREE_GENERIC_ERROR,
SC_ERR_MISSING_QUOTE,
SC_ERR_MUTEX,
SC_REPUTATION_INVALID_OPERATION,
SC_REPUTATION_INVALID_TYPE,
SC_ERR_REPUTATION_INVALID_OPERATION,
SC_ERR_REPUTATION_INVALID_TYPE,
SC_ERR_UNKNOWN_PROTOCOL,
SC_ERR_UNKNOWN_RUN_MODE,
SC_ERR_MULTIPLE_RUN_MODE,

@ -110,7 +110,7 @@ static void *SCHInfoAllocUserDataOSPolicy(const char *host_os)
/* the host os flavour that has to be sent as user data */
if ( (*user_data = SCMapEnumNameToValue(host_os, sc_hinfo_os_policy_map)) == -1) {
SCLogError(SC_INVALID_ENUM_MAP, "Invalid enum map inside "
SCLogError(SC_ERR_INVALID_ENUM_MAP, "Invalid enum map inside "
"SCHInfoAddHostOSInfo()");
free(user_data);
return NULL;
@ -188,7 +188,7 @@ int SCHInfoAddHostOSInfo(char *host_os, char *host_os_ip_range, int is_ipv4)
char recursive = FALSE;
if (host_os == NULL || host_os_ip_range == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid arguments");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid arguments");
return -1;
}
@ -198,7 +198,7 @@ int SCHInfoAddHostOSInfo(char *host_os, char *host_os_ip_range, int is_ipv4)
/* the host os flavour that has to be sent as user data */
if ( (user_data = SCHInfoAllocUserDataOSPolicy(host_os)) == NULL) {
SCLogError(SC_INVALID_ENUM_MAP, "Invalid enum map inside");
SCLogError(SC_ERR_INVALID_ENUM_MAP, "Invalid enum map inside");
return -1;
}
@ -232,7 +232,7 @@ int SCHInfoAddHostOSInfo(char *host_os, char *host_os_ip_range, int is_ipv4)
if (index(ip_str, ':') == NULL) {
/* if we are here, we have an IPV4 address */
if ( (ipv4_addr = SCHInfoValidateIPV4Address(ip_str)) == NULL) {
SCLogError(SC_INVALID_IPV4_ADDR, "Invalid IPV4 address");
SCLogError(SC_ERR_INVALID_IPV4_ADDR, "Invalid IPV4 address");
return -1;
}
@ -242,7 +242,7 @@ int SCHInfoAddHostOSInfo(char *host_os, char *host_os_ip_range, int is_ipv4)
} else {
netmask_value = atoi(netmask_str);
if (netmask_value < 0 || netmask_value > 32) {
SCLogError(SC_INVALID_IP_NETBLOCK, "Invalid IPV4 Netblock");
SCLogError(SC_ERR_INVALID_IP_NETBLOCK, "Invalid IPV4 Netblock");
free(ipv4_addr);
return -1;
}
@ -254,7 +254,7 @@ int SCHInfoAddHostOSInfo(char *host_os, char *host_os_ip_range, int is_ipv4)
} else {
/* if we are here, we have an IPV6 address */
if ( (ipv6_addr = SCHInfoValidateIPV6Address(ip_str)) == NULL) {
SCLogError(SC_INVALID_IPV6_ADDR, "Invalid IPV6 address inside");
SCLogError(SC_ERR_INVALID_IPV6_ADDR, "Invalid IPV6 address inside");
return -1;
}
@ -264,7 +264,7 @@ int SCHInfoAddHostOSInfo(char *host_os, char *host_os_ip_range, int is_ipv4)
} else {
netmask_value = atoi(netmask_str);
if (netmask_value < 0 || netmask_value > 128) {
SCLogError(SC_INVALID_IP_NETBLOCK, "Invalid IPV6 Netblock");
SCLogError(SC_ERR_INVALID_IP_NETBLOCK, "Invalid IPV6 Netblock");
free(ipv6_addr);
return -1;
}
@ -301,7 +301,7 @@ int SCHInfoGetHostOSFlavour(char *ip_addr_str)
if (index(ip_addr_str, ':') != NULL) {
if ( (ipv6_addr = SCHInfoValidateIPV6Address(ip_addr_str)) == NULL) {
SCLogError(SC_INVALID_IPV4_ADDR, "Invalid IPV4 address");
SCLogError(SC_ERR_INVALID_IPV4_ADDR, "Invalid IPV4 address");
return -1;
}
@ -311,7 +311,7 @@ int SCHInfoGetHostOSFlavour(char *ip_addr_str)
return *((int *)node->prefix->user_data_result);
} else {
if ( (ipv4_addr = SCHInfoValidateIPV4Address(ip_addr_str)) == NULL) {
SCLogError(SC_INVALID_IPV4_ADDR, "Invalid IPV4 address");
SCLogError(SC_ERR_INVALID_IPV4_ADDR, "Invalid IPV4 address");
return -1;
}

@ -161,7 +161,7 @@ static void SCRadixAppendToSCRadixUserDataList(SCRadixUserData *new,
SCRadixUserData *prev = NULL;
if (new == NULL || list == NULL) {
SCLogError(SC_INVALID_ARGUMENTS, "new or list supplied as NULL");
SCLogError(SC_ERR_INVALID_ARGUMENTS, "new or list supplied as NULL");
exit(EXIT_FAILURE);
}
@ -206,13 +206,13 @@ static SCRadixPrefix *SCRadixCreatePrefix(uint8_t *key_stream,
SCRadixPrefix *prefix = NULL;
if ((key_bitlen % 8 != 0) || key_bitlen == 0) {
SCLogError(SC_INVALID_ARGUMENT, "Invalid argument bitlen - %d",
SCLogError(SC_ERR_INVALID_ARGUMENT, "Invalid argument bitlen - %d",
key_bitlen);
return NULL;
}
if (key_stream == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Argument \"stream\" NULL");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Argument \"stream\" NULL");
return NULL;
}
@ -249,7 +249,7 @@ static void SCRadixAddNetmaskUserDataToPrefix(SCRadixPrefix *prefix,
void *user)
{
if (prefix == NULL || user == NULL) {
SCLogError(SC_INVALID_ARGUMENTS, "prefix or user NULL");
SCLogError(SC_ERR_INVALID_ARGUMENTS, "prefix or user NULL");
exit(EXIT_FAILURE);
}
@ -273,7 +273,7 @@ static void SCRadixRemoveNetmaskUserDataFromPrefix(SCRadixPrefix *prefix,
SCRadixUserData *temp = NULL, *prev = NULL;
if (prefix == NULL) {
SCLogError(SC_INVALID_ARGUMENTS, "prefix NULL");
SCLogError(SC_ERR_INVALID_ARGUMENTS, "prefix NULL");
exit(EXIT_FAILURE);
}
@ -310,7 +310,7 @@ static int SCRadixPrefixContainNetmask(SCRadixPrefix *prefix, uint8_t netmask)
SCRadixUserData *user_data = NULL;
if (prefix == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "prefix is NULL");
SCLogError(SC_ERR_INVALID_ARGUMENT, "prefix is NULL");
goto no_match;
}
@ -338,7 +338,7 @@ static int SCRadixPrefixNetmaskCount(SCRadixPrefix *prefix)
uint32_t count = 0;
if (prefix == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "prefix is NULL");
SCLogError(SC_ERR_INVALID_ARGUMENT, "prefix is NULL");
return 0;
}
@ -374,7 +374,7 @@ static int SCRadixPrefixContainNetmaskAndSetUserData(SCRadixPrefix *prefix,
SCRadixUserData *user_data = NULL;
if (prefix == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "prefix is NULL");
SCLogError(SC_ERR_INVALID_ARGUMENT, "prefix is NULL");
goto no_match;
}
@ -575,12 +575,12 @@ static SCRadixNode *SCRadixAddKey(uint8_t *key_stream, uint16_t key_bitlen,
if ( (prefix = SCRadixCreatePrefix(key_stream, key_bitlen, user,
netmask)) == NULL) {
SCLogError(SC_RADIX_TREE_GENERIC_ERROR, "Error creating prefix");
SCLogError(SC_ERR_RADIX_TREE_GENERIC_ERROR, "Error creating prefix");
return NULL;
}
if (tree == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Argument \"tree\" NULL");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Argument \"tree\" NULL");
return NULL;
}
@ -969,7 +969,7 @@ static void SCRadixTransferNetmasksBWNodes(SCRadixNode *dest, SCRadixNode *src)
int i = 0, j = 0;
if (src == NULL || dest == NULL) {
SCLogError(SC_INVALID_ARGUMENTS, "src or dest NULL");
SCLogError(SC_ERR_INVALID_ARGUMENTS, "src or dest NULL");
return;
}
@ -1006,7 +1006,7 @@ static void SCRadixRemoveNetblockEntry(SCRadixNode *node, uint8_t netmask)
int i = 0;
if (node == NULL) {
SCLogError(SC_INVALID_ARGUMENTS, "Invalid argument. Node is NULL");
SCLogError(SC_ERR_INVALID_ARGUMENTS, "Invalid argument. Node is NULL");
return;
}

@ -130,7 +130,7 @@ Packet **UTHBuildPacketArrayFromEth(uint8_t *raw_eth[], int *pktsize, int numpkt
DecodeThreadVars dtv;
ThreadVars th_v;
if (raw_eth == NULL || pktsize == NULL || numpkts <= 0) {
SCLogError(SC_INVALID_ARGUMENT, "The arrays cant be null, and the number"
SCLogError(SC_ERR_INVALID_ARGUMENT, "The arrays cant be null, and the number"
" of packets should be grater thatn zero");
return NULL;
}
@ -293,7 +293,7 @@ int UTHGenericTest(Packet **pkt, int numpkts, char *sigs[], uint32_t sids[], uin
int result = 0;
if (pkt == NULL || sigs == NULL || numpkts == 0
|| sids == NULL || results == NULL || numsigs == 0) {
SCLogError(SC_INVALID_ARGUMENT, "Arguments invalid, that the pointer/arrays are not NULL, and the number of signatures and packets is > 0");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Arguments invalid, that the pointer/arrays are not NULL, and the number of signatures and packets is > 0");
goto end;
}
DetectEngineCtx *de_ctx = DetectEngineCtxInit();
@ -331,7 +331,7 @@ end:
*/
int UTHCheckPacketMatchResults(Packet *p, uint32_t sids[], uint32_t results[], int numsids) {
if (p == NULL || sids == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Arguments invalid, check if the packet is NULL, and if the array contain sids is set");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Arguments invalid, check if the packet is NULL, and if the array contain sids is set");
return 0;
}
int i = 0;
@ -360,7 +360,7 @@ int UTHCheckPacketMatchResults(Packet *p, uint32_t sids[], uint32_t results[], i
*/
int UTHAppendSigs(DetectEngineCtx *de_ctx, char *sigs[], int numsigs) {
if (de_ctx == NULL || numsigs <= 0 || sigs == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Arguments invalid, check if sigs or de_ctx are NULL, and if the array contain sigs");
SCLogError(SC_ERR_INVALID_ARGUMENT, "Arguments invalid, check if sigs or de_ctx are NULL, and if the array contain sigs");
return 0;
}
//SCLogDebug("Adding %d signatures for the current unittest", numsigs);
@ -370,13 +370,13 @@ int UTHAppendSigs(DetectEngineCtx *de_ctx, char *sigs[], int numsigs) {
for ( ; i < numsigs; i++) {
if (sigs[i] == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Check the signature"
SCLogError(SC_ERR_INVALID_ARGUMENT, "Check the signature"
" at position %d", i);
return 0;
}
s = DetectEngineAppendSig(de_ctx, sigs[i]);
if (s == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "Check the signature at"
SCLogError(SC_ERR_INVALID_ARGUMENT, "Check the signature at"
" position %d (%s)", i, sigs[i]);
return 0;
}
@ -400,7 +400,7 @@ int UTHMatchPacketsWithResults(DetectEngineCtx *de_ctx, Packet **p, int num_pack
int result = 0;
if (de_ctx == NULL || p == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "packet or de_ctx was null");
SCLogError(SC_ERR_INVALID_ARGUMENT, "packet or de_ctx was null");
result = 0;
goto end;
}
@ -449,7 +449,7 @@ int UTHMatchPackets(DetectEngineCtx *de_ctx, Packet **p, int num_packets) {
int result = 1;
if (de_ctx == NULL || p == NULL) {
SCLogError(SC_INVALID_ARGUMENT, "packet or de_ctx was null");
SCLogError(SC_ERR_INVALID_ARGUMENT, "packet or de_ctx was null");
result = 0;
goto end;
}

Loading…
Cancel
Save