detect/keywords: dynamic version part of doc URL

diff --git a/src/counters.c b/src/counters.c
index e292b07db3151dd206dcc0ddcc1c172384d00029..a9ff3c405ba9d1dcb839395a7b5ab90fd467dada 100644 (file)
--- a/src/counters.c
+++ b/src/counters.c
@@ -247,7 +247,7 @@ static void StatsInitCtxPreOutput(void)
         if (gstats == NULL) {
             SCLogWarning(SC_ERR_STATS_LOG_GENERIC, "global stats config is missing. "
                     "Stats enabled through legacy stats.log. "
-                    "See %s%s/configuration/suricata-yaml.html#stats", DOC_URL, DOC_VERSION);
+                    "See %s/configuration/suricata-yaml.html#stats", GetDocURL());
         }
 
         const char *interval = ConfNodeLookupChildValue(stats, "interval");

diff --git a/src/detect-app-layer-event.c b/src/detect-app-layer-event.c
index f1a690d4852824c8cdbce978869ce165420845d3..e6700f063eddaf974e706b2a97a49742a879bf6c 100644 (file)
--- a/src/detect-app-layer-event.c
+++ b/src/detect-app-layer-event.c
@@ -67,7 +67,7 @@ void DetectAppLayerEventRegister(void)
 {
     sigmatch_table[DETECT_AL_APP_LAYER_EVENT].name = "app-layer-event";
     sigmatch_table[DETECT_AL_APP_LAYER_EVENT].desc = "match on events generated by the App Layer Parsers and the protocol detection engine";
-    sigmatch_table[DETECT_AL_APP_LAYER_EVENT].url = DOC_URL DOC_VERSION "/rules/app-layer.html#app-layer-event";
+    sigmatch_table[DETECT_AL_APP_LAYER_EVENT].url = "/rules/app-layer.html#app-layer-event";
     sigmatch_table[DETECT_AL_APP_LAYER_EVENT].Match =
         DetectAppLayerEventPktMatch;
     sigmatch_table[DETECT_AL_APP_LAYER_EVENT].Setup = DetectAppLayerEventSetupP1;

diff --git a/src/detect-app-layer-protocol.c b/src/detect-app-layer-protocol.c
index f03847243eca869582b41e933aa00c0bd7efe21f..86b7f51b60f7269fc57ca875aeb4e59fd02bd8c4 100644 (file)
--- a/src/detect-app-layer-protocol.c
+++ b/src/detect-app-layer-protocol.c
@@ -259,7 +259,7 @@ void DetectAppLayerProtocolRegister(void)
 {
     sigmatch_table[DETECT_AL_APP_LAYER_PROTOCOL].name = "app-layer-protocol";
     sigmatch_table[DETECT_AL_APP_LAYER_PROTOCOL].desc = "match on the detected app-layer protocol";
-    sigmatch_table[DETECT_AL_APP_LAYER_PROTOCOL].url = DOC_URL DOC_VERSION "/rules/app-layer.html#app-layer-protocol";
+    sigmatch_table[DETECT_AL_APP_LAYER_PROTOCOL].url = "/rules/app-layer.html#app-layer-protocol";
     sigmatch_table[DETECT_AL_APP_LAYER_PROTOCOL].Match =
         DetectAppLayerProtocolPacketMatch;
     sigmatch_table[DETECT_AL_APP_LAYER_PROTOCOL].Setup =

diff --git a/src/detect-base64-data.c b/src/detect-base64-data.c
index 3c130adbb1f89db20f02f7ce6807ff874de5b1c4..e12d0d06524e94a2fa6cdb5be6ecbaf811cb63f8 100644 (file)
--- a/src/detect-base64-data.c
+++ b/src/detect-base64-data.c
@@ -33,7 +33,7 @@ void DetectBase64DataRegister(void)
     sigmatch_table[DETECT_BASE64_DATA].desc =
         "Content match base64 decoded data.";
     sigmatch_table[DETECT_BASE64_DATA].url =
-        DOC_URL DOC_VERSION "/rules/base64-keywords.html#base64-data";
+        "/rules/base64-keywords.html#base64-data";
     sigmatch_table[DETECT_BASE64_DATA].Setup = DetectBase64DataSetup;
     sigmatch_table[DETECT_BASE64_DATA].RegisterTests =
         DetectBase64DataRegisterTests;

diff --git a/src/detect-base64-decode.c b/src/detect-base64-decode.c
index 8581b118bdefbe369449b84c094c5d703ba6590d..480b755777e3012140ae499c82b0a34cc90ec051 100644 (file)
--- a/src/detect-base64-decode.c
+++ b/src/detect-base64-decode.c
@@ -42,7 +42,7 @@ void DetectBase64DecodeRegister(void)
     sigmatch_table[DETECT_BASE64_DECODE].desc =
         "Decodes base64 encoded data.";
     sigmatch_table[DETECT_BASE64_DECODE].url =
-        DOC_URL DOC_VERSION "/rules/base64-keywords.html#base64-decode";
+        "/rules/base64-keywords.html#base64-decode";
     sigmatch_table[DETECT_BASE64_DECODE].Setup = DetectBase64DecodeSetup;
     sigmatch_table[DETECT_BASE64_DECODE].Free = DetectBase64DecodeFree;
     sigmatch_table[DETECT_BASE64_DECODE].RegisterTests =

diff --git a/src/detect-bsize.c b/src/detect-bsize.c
index 3abe883b02a5edd0eb3a8c8482d6478b353eaa8e..d3908514592c7bc270cf344f2f03e2abb17a7ad2 100644 (file)
--- a/src/detect-bsize.c
+++ b/src/detect-bsize.c
@@ -51,7 +51,7 @@ void DetectBsizeRegister(void)
 {
     sigmatch_table[DETECT_BSIZE].name = "bsize";
     sigmatch_table[DETECT_BSIZE].desc = "match on the length of a buffer";
-    sigmatch_table[DETECT_BSIZE].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#bsize";
+    sigmatch_table[DETECT_BSIZE].url = "/rules/payload-keywords.html#bsize";
     sigmatch_table[DETECT_BSIZE].Match = NULL;
     sigmatch_table[DETECT_BSIZE].Setup = DetectBsizeSetup;
     sigmatch_table[DETECT_BSIZE].Free = DetectBsizeFree;

diff --git a/src/detect-bypass.c b/src/detect-bypass.c
index 8a37b3ba7042b8d28b682871160bc780401d7633..5f38517f2cc6f3413806d0b78dbc9ae792fec96c 100644 (file)
--- a/src/detect-bypass.c
+++ b/src/detect-bypass.c
@@ -62,7 +62,7 @@ void DetectBypassRegister(void)
 {
     sigmatch_table[DETECT_BYPASS].name = "bypass";
     sigmatch_table[DETECT_BYPASS].desc = "call the bypass callback when the match of a sig is complete";
-    sigmatch_table[DETECT_BYPASS].url = DOC_URL DOC_VERSION "/rules/bypass-keyword.html";
+    sigmatch_table[DETECT_BYPASS].url = "/rules/bypass-keyword.html";
     sigmatch_table[DETECT_BYPASS].Match = DetectBypassMatch;
     sigmatch_table[DETECT_BYPASS].Setup = DetectBypassSetup;
     sigmatch_table[DETECT_BYPASS].Free  = NULL;

diff --git a/src/detect-byte-extract.c b/src/detect-byte-extract.c
index caef34f3cbde55dfdaff0bc7823af8a27f84b4f0..8305c226b51df8e1b7d65634511486453d4c8754 100644 (file)
--- a/src/detect-byte-extract.c
+++ b/src/detect-byte-extract.c
@@ -99,7 +99,7 @@ void DetectByteExtractRegister(void)
 {
     sigmatch_table[DETECT_BYTE_EXTRACT].name = "byte_extract";
     sigmatch_table[DETECT_BYTE_EXTRACT].desc = "extract <num of bytes> at a particular <offset> and store it in <var_name>";
-    sigmatch_table[DETECT_BYTE_EXTRACT].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#byte-extract";
+    sigmatch_table[DETECT_BYTE_EXTRACT].url = "/rules/payload-keywords.html#byte-extract";
     sigmatch_table[DETECT_BYTE_EXTRACT].Match = NULL;
     sigmatch_table[DETECT_BYTE_EXTRACT].Setup = DetectByteExtractSetup;
     sigmatch_table[DETECT_BYTE_EXTRACT].Free = DetectByteExtractFree;

diff --git a/src/detect-bytejump.c b/src/detect-bytejump.c
index 64e7e8dac21b0bf61dccf928c5a6b023bc2884c9..8a8b5e4b7d0c72576acb8dff52b9a73c8a0d0ef3 100644 (file)
--- a/src/detect-bytejump.c
+++ b/src/detect-bytejump.c
@@ -70,7 +70,7 @@ void DetectBytejumpRegister (void)
 {
     sigmatch_table[DETECT_BYTEJUMP].name = "byte_jump";
     sigmatch_table[DETECT_BYTEJUMP].desc = "allow the ability to select a <num of bytes> from an <offset> and move the detection pointer to that position";
-    sigmatch_table[DETECT_BYTEJUMP].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#byte-jump";
+    sigmatch_table[DETECT_BYTEJUMP].url = "/rules/payload-keywords.html#byte-jump";
     sigmatch_table[DETECT_BYTEJUMP].Match = DetectBytejumpMatch;
     sigmatch_table[DETECT_BYTEJUMP].Setup = DetectBytejumpSetup;
     sigmatch_table[DETECT_BYTEJUMP].Free  = DetectBytejumpFree;

diff --git a/src/detect-bytetest.c b/src/detect-bytetest.c
index 0ca8ce6884434877e9f7420a89b3de73d868db3d..feb7f9b0862bdc95a813c19c6b28a32114a6ad44 100644 (file)
--- a/src/detect-bytetest.c
+++ b/src/detect-bytetest.c
@@ -77,7 +77,7 @@ void DetectBytetestRegister (void)
 {
     sigmatch_table[DETECT_BYTETEST].name = "byte_test";
     sigmatch_table[DETECT_BYTETEST].desc = "extract <num of bytes> and perform an operation selected with <operator> against the value in <test value> at a particular <offset>";
-    sigmatch_table[DETECT_BYTETEST].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#byte-test";
+    sigmatch_table[DETECT_BYTETEST].url = "/rules/payload-keywords.html#byte-test";
     sigmatch_table[DETECT_BYTETEST].Match = DetectBytetestMatch;
     sigmatch_table[DETECT_BYTETEST].Setup = DetectBytetestSetup;
     sigmatch_table[DETECT_BYTETEST].Free  = DetectBytetestFree;

diff --git a/src/detect-cipservice.c b/src/detect-cipservice.c
index f719f969d629ba7ca846bfa4d8d2b0520df195bf..712a7d8ae31514ccd58257fbfdfddeb9dc6f17bf 100644 (file)
--- a/src/detect-cipservice.c
+++ b/src/detect-cipservice.c
@@ -52,7 +52,7 @@ void DetectCipServiceRegister(void)
     SCEnter();
     sigmatch_table[DETECT_CIPSERVICE].name = "cip_service"; //rule keyword
     sigmatch_table[DETECT_CIPSERVICE].desc = "match on CIP Service";
-    sigmatch_table[DETECT_CIPSERVICE].url = DOC_URL DOC_VERSION "/rules/enip-keyword.html#enip-cip-keywords";
+    sigmatch_table[DETECT_CIPSERVICE].url = "/rules/enip-keyword.html#enip-cip-keywords";
     sigmatch_table[DETECT_CIPSERVICE].Match = NULL;
     sigmatch_table[DETECT_CIPSERVICE].Setup = DetectCipServiceSetup;
     sigmatch_table[DETECT_CIPSERVICE].Free = DetectCipServiceFree;
@@ -307,7 +307,7 @@ void DetectEnipCommandRegister(void)
     sigmatch_table[DETECT_ENIPCOMMAND].name = "enip_command"; //rule keyword
     sigmatch_table[DETECT_ENIPCOMMAND].desc
             = "rules for detecting EtherNet/IP command";
-    sigmatch_table[DETECT_ENIPCOMMAND].url = DOC_URL DOC_VERSION "/rules/enip-keyword.html#enip-cip-keywords";
+    sigmatch_table[DETECT_ENIPCOMMAND].url = "/rules/enip-keyword.html#enip-cip-keywords";
     sigmatch_table[DETECT_ENIPCOMMAND].Match = NULL;
     sigmatch_table[DETECT_ENIPCOMMAND].Setup = DetectEnipCommandSetup;
     sigmatch_table[DETECT_ENIPCOMMAND].Free = DetectEnipCommandFree;

diff --git a/src/detect-classtype.c b/src/detect-classtype.c
index 20a66623e973e380954fb5175afd04018aa635b6..24a2c9ad512af857cc3ee311288f668cfce4902e 100644 (file)
--- a/src/detect-classtype.c
+++ b/src/detect-classtype.c
@@ -50,7 +50,7 @@ void DetectClasstypeRegister(void)
 {
     sigmatch_table[DETECT_CLASSTYPE].name = "classtype";
     sigmatch_table[DETECT_CLASSTYPE].desc = "information about the classification of rules and alerts";
-    sigmatch_table[DETECT_CLASSTYPE].url = DOC_URL DOC_VERSION "/rules/meta.html#classtype";
+    sigmatch_table[DETECT_CLASSTYPE].url = "/rules/meta.html#classtype";
     sigmatch_table[DETECT_CLASSTYPE].Setup = DetectClasstypeSetup;
     sigmatch_table[DETECT_CLASSTYPE].RegisterTests = DetectClasstypeRegisterTests;
 

diff --git a/src/detect-content.c b/src/detect-content.c
index ddba6569d12d7b4405998bdc18037bfee2ec5ac3..7ab5ba6e12b64e2acca87d16b7dca94075fc8293 100644 (file)
--- a/src/detect-content.c
+++ b/src/detect-content.c
@@ -56,7 +56,7 @@ void DetectContentRegister (void)
 {
     sigmatch_table[DETECT_CONTENT].name = "content";
     sigmatch_table[DETECT_CONTENT].desc = "match on payload content";
-    sigmatch_table[DETECT_CONTENT].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#content";
+    sigmatch_table[DETECT_CONTENT].url = "/rules/payload-keywords.html#content";
     sigmatch_table[DETECT_CONTENT].Match = NULL;
     sigmatch_table[DETECT_CONTENT].Setup = DetectContentSetup;
     sigmatch_table[DETECT_CONTENT].Free  = DetectContentFree;

diff --git a/src/detect-datarep.c b/src/detect-datarep.c
index 6ee3ee21210f452f816548aeb59ef85c7622d513..d4802e0cfb7cd3129b1c38169eb64edf85ffa992 100644 (file)
--- a/src/detect-datarep.c
+++ b/src/detect-datarep.c
@@ -51,7 +51,7 @@ void DetectDatarepRegister (void)
 {
     sigmatch_table[DETECT_DATAREP].name = "datarep";
     sigmatch_table[DETECT_DATAREP].desc = "operate on datasets (experimental)";
-    sigmatch_table[DETECT_DATAREP].url = DOC_URL DOC_VERSION "/rules/dataset-keywords.html#datarep";
+    sigmatch_table[DETECT_DATAREP].url = "/rules/dataset-keywords.html#datarep";
     sigmatch_table[DETECT_DATAREP].Setup = DetectDatarepSetup;
     sigmatch_table[DETECT_DATAREP].Free  = DetectDatarepFree;
 

diff --git a/src/detect-dataset.c b/src/detect-dataset.c
index 3123a531248dcf6c37b8d89d73ae9576f3dcd694..ea0a1b0d19a910d4c40583dca4c5b890f6c42b8c 100644 (file)
--- a/src/detect-dataset.c
+++ b/src/detect-dataset.c
@@ -50,7 +50,7 @@ void DetectDatasetRegister (void)
 {
     sigmatch_table[DETECT_DATASET].name = "dataset";
     sigmatch_table[DETECT_DATASET].desc = "match sticky buffer against datasets (experimental)";
-    sigmatch_table[DETECT_DATASET].url = DOC_URL DOC_VERSION "/rules/dataset-keywords.html#dataset";
+    sigmatch_table[DETECT_DATASET].url = "/rules/dataset-keywords.html#dataset";
     sigmatch_table[DETECT_DATASET].Setup = DetectDatasetSetup;
     sigmatch_table[DETECT_DATASET].Free  = DetectDatasetFree;
 

diff --git a/src/detect-depth.c b/src/detect-depth.c
index 30eee56cffbdd472dbc59d7bfaea2df7984f5a7e..9f30d31c5f8ed72de2745f7f75db9d6f848ca54e 100644 (file)
--- a/src/detect-depth.c
+++ b/src/detect-depth.c
@@ -48,7 +48,7 @@ void DetectDepthRegister (void)
 {
     sigmatch_table[DETECT_DEPTH].name = "depth";
     sigmatch_table[DETECT_DEPTH].desc = "designate how many bytes from the beginning of the payload will be checked";
-    sigmatch_table[DETECT_DEPTH].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#depth";
+    sigmatch_table[DETECT_DEPTH].url = "/rules/payload-keywords.html#depth";
     sigmatch_table[DETECT_DEPTH].Match = NULL;
     sigmatch_table[DETECT_DEPTH].Setup = DetectDepthSetup;
     sigmatch_table[DETECT_DEPTH].Free  = NULL;
@@ -56,7 +56,7 @@ void DetectDepthRegister (void)
 
     sigmatch_table[DETECT_STARTS_WITH].name = "startswith";
     sigmatch_table[DETECT_STARTS_WITH].desc = "pattern must be at the start of a buffer (same as 'depth:<pattern len>')";
-    sigmatch_table[DETECT_STARTS_WITH].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#startswith";
+    sigmatch_table[DETECT_STARTS_WITH].url = "/rules/payload-keywords.html#startswith";
     sigmatch_table[DETECT_STARTS_WITH].Setup = DetectStartsWithSetup;
     sigmatch_table[DETECT_STARTS_WITH].flags |= SIGMATCH_NOOPT;
 }

diff --git a/src/detect-detection-filter.c b/src/detect-detection-filter.c
index 5ceb9e85a41185ec22607d47557d72faa7457994..85c6439f6fa3f2db3f459157719b52f6b86d1b43 100644 (file)
--- a/src/detect-detection-filter.c
+++ b/src/detect-detection-filter.c
@@ -63,7 +63,7 @@ void DetectDetectionFilterRegister (void)
 {
     sigmatch_table[DETECT_DETECTION_FILTER].name = "detection_filter";
     sigmatch_table[DETECT_DETECTION_FILTER].desc = "alert on every match after a threshold has been reached";
-    sigmatch_table[DETECT_DETECTION_FILTER].url = DOC_URL DOC_VERSION "/rules/thresholding.html#detection-filter";
+    sigmatch_table[DETECT_DETECTION_FILTER].url = "/rules/thresholding.html#detection-filter";
     sigmatch_table[DETECT_DETECTION_FILTER].Match = DetectDetectionFilterMatch;
     sigmatch_table[DETECT_DETECTION_FILTER].Setup = DetectDetectionFilterSetup;
     sigmatch_table[DETECT_DETECTION_FILTER].Free = DetectDetectionFilterFree;

diff --git a/src/detect-distance.c b/src/detect-distance.c
index bc711c03fcdfc85304bc33d69e6e37a4c7400754..c1334b4b961fa30c94e9deaf0548cfbea82e91ff 100644 (file)
--- a/src/detect-distance.c
+++ b/src/detect-distance.c
@@ -54,7 +54,7 @@ void DetectDistanceRegister(void)
 {
     sigmatch_table[DETECT_DISTANCE].name = "distance";
     sigmatch_table[DETECT_DISTANCE].desc = "indicates a relation between this content keyword and the content preceding it";
-    sigmatch_table[DETECT_DISTANCE].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#distance";
+    sigmatch_table[DETECT_DISTANCE].url = "/rules/payload-keywords.html#distance";
     sigmatch_table[DETECT_DISTANCE].Match = NULL;
     sigmatch_table[DETECT_DISTANCE].Setup = DetectDistanceSetup;
     sigmatch_table[DETECT_DISTANCE].Free  = NULL;

diff --git a/src/detect-dnp3.c b/src/detect-dnp3.c
index f3f229dad11840c6f2eec8195a3a7c8f2027146b..4ec6b548846548c9d734f17371e567fd202a82d8 100644 (file)
--- a/src/detect-dnp3.c
+++ b/src/detect-dnp3.c
@@ -493,7 +493,7 @@ static void DetectDNP3FuncRegister(void)
     sigmatch_table[DETECT_AL_DNP3FUNC].name          = "dnp3_func";
     sigmatch_table[DETECT_AL_DNP3FUNC].alias         = "dnp3.func";
     sigmatch_table[DETECT_AL_DNP3FUNC].desc          = "match on the application function code found in DNP3 request and responses";
-    sigmatch_table[DETECT_AL_DNP3FUNC].url           = DOC_URL DOC_VERSION "/rules/dnp3-keywords.html#dnp3-func";
+    sigmatch_table[DETECT_AL_DNP3FUNC].url           = "/rules/dnp3-keywords.html#dnp3-func";
     sigmatch_table[DETECT_AL_DNP3FUNC].Match         = NULL;
     sigmatch_table[DETECT_AL_DNP3FUNC].AppLayerTxMatch = DetectDNP3FuncMatch;
     sigmatch_table[DETECT_AL_DNP3FUNC].Setup         = DetectDNP3FuncSetup;
@@ -511,7 +511,7 @@ static void DetectDNP3IndRegister(void)
     sigmatch_table[DETECT_AL_DNP3IND].name          = "dnp3_ind";
     sigmatch_table[DETECT_AL_DNP3IND].alias         = "dnp3.ind";
     sigmatch_table[DETECT_AL_DNP3IND].desc          = "match on the DNP3 internal indicator flags in the response application header";
-    sigmatch_table[DETECT_AL_DNP3IND].url           = DOC_URL DOC_VERSION "/rules/dnp3-keywords.html#dnp3-ind";
+    sigmatch_table[DETECT_AL_DNP3IND].url           = "/rules/dnp3-keywords.html#dnp3-ind";
     sigmatch_table[DETECT_AL_DNP3IND].Match         = NULL;
     sigmatch_table[DETECT_AL_DNP3IND].AppLayerTxMatch = DetectDNP3IndMatch;
     sigmatch_table[DETECT_AL_DNP3IND].Setup         = DetectDNP3IndSetup;
@@ -529,7 +529,7 @@ static void DetectDNP3ObjRegister(void)
     sigmatch_table[DETECT_AL_DNP3OBJ].name          = "dnp3_obj";
     sigmatch_table[DETECT_AL_DNP3OBJ].alias         = "dnp3.obj";
     sigmatch_table[DETECT_AL_DNP3OBJ].desc          = "match on the DNP3 application data objects";
-    sigmatch_table[DETECT_AL_DNP3OBJ].url           = DOC_URL DOC_VERSION "/rules/dnp3-keywords.html#dnp3-obj";
+    sigmatch_table[DETECT_AL_DNP3OBJ].url           = "/rules/dnp3-keywords.html#dnp3-obj";
     sigmatch_table[DETECT_AL_DNP3OBJ].Match         = NULL;
     sigmatch_table[DETECT_AL_DNP3OBJ].AppLayerTxMatch = DetectDNP3ObjMatch;
     sigmatch_table[DETECT_AL_DNP3OBJ].Setup         = DetectDNP3ObjSetup;
@@ -559,7 +559,7 @@ static void DetectDNP3DataRegister(void)
     sigmatch_table[DETECT_AL_DNP3DATA].name          = "dnp3.data";
     sigmatch_table[DETECT_AL_DNP3DATA].alias         = "dnp3_data";
     sigmatch_table[DETECT_AL_DNP3DATA].desc          = "make the following content options to match on the re-assembled application buffer";
-    sigmatch_table[DETECT_AL_DNP3DATA].url           = DOC_URL DOC_VERSION "/rules/dnp3-keywords.html#dnp3-data";
+    sigmatch_table[DETECT_AL_DNP3DATA].url           = "/rules/dnp3-keywords.html#dnp3-data";
     sigmatch_table[DETECT_AL_DNP3DATA].Setup         = DetectDNP3DataSetup;
     sigmatch_table[DETECT_AL_DNP3DATA].RegisterTests =
         DetectDNP3DataRegisterTests;

diff --git a/src/detect-dns-query.c b/src/detect-dns-query.c
index f5853d8228132a83161f3f438ab47dfa11f99dbf..86291ac4fcee749ec81782754b67d6814c51eda0 100644 (file)
--- a/src/detect-dns-query.c
+++ b/src/detect-dns-query.c
@@ -208,7 +208,7 @@ void DetectDnsQueryRegister (void)
     sigmatch_table[DETECT_AL_DNS_QUERY].name = "dns.query";
     sigmatch_table[DETECT_AL_DNS_QUERY].alias = "dns_query";
     sigmatch_table[DETECT_AL_DNS_QUERY].desc = "sticky buffer to match DNS query-buffer";
-    sigmatch_table[DETECT_AL_DNS_QUERY].url = DOC_URL DOC_VERSION "/rules/dns-keywords.html#dns-query";
+    sigmatch_table[DETECT_AL_DNS_QUERY].url = "/rules/dns-keywords.html#dns-query";
     sigmatch_table[DETECT_AL_DNS_QUERY].Setup = DetectDnsQuerySetup;
     sigmatch_table[DETECT_AL_DNS_QUERY].RegisterTests = DetectDnsQueryRegisterTests;
     sigmatch_table[DETECT_AL_DNS_QUERY].flags |= SIGMATCH_NOOPT;

diff --git a/src/detect-dsize.c b/src/detect-dsize.c
index b0b125f5f1e35cea2e1d686b02db217b0980a78f..69f0577bbc97a9e2a1e39b5eab6dac6ba2adcee0 100644 (file)
--- a/src/detect-dsize.c
+++ b/src/detect-dsize.c
@@ -65,7 +65,7 @@ void DetectDsizeRegister (void)
 {
     sigmatch_table[DETECT_DSIZE].name = "dsize";
     sigmatch_table[DETECT_DSIZE].desc = "match on the size of the packet payload";
-    sigmatch_table[DETECT_DSIZE].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#dsize";
+    sigmatch_table[DETECT_DSIZE].url = "/rules/payload-keywords.html#dsize";
     sigmatch_table[DETECT_DSIZE].Match = DetectDsizeMatch;
     sigmatch_table[DETECT_DSIZE].Setup = DetectDsizeSetup;
     sigmatch_table[DETECT_DSIZE].Free  = DetectDsizeFree;

diff --git a/src/detect-engine-register.c b/src/detect-engine-register.c
index 5830a8566c756a53836d6ba9572a1dd446605c6a..f855353f078e7028489d9ea0827560b5e9fb495d 100644 (file)
--- a/src/detect-engine-register.c
+++ b/src/detect-engine-register.c
@@ -315,7 +315,7 @@ static void SigMultilinePrint(int i, const char *prefix)
     printf("%sFeatures: ", prefix);
     PrintFeatureList(&sigmatch_table[i], ',');
     if (sigmatch_table[i].url) {
-        printf("\n%sDocumentation: %s", prefix, sigmatch_table[i].url);
+        printf("\n%sDocumentation: %s%s", prefix, GetDocURL(), sigmatch_table[i].url);
     }
     if (sigmatch_table[i].alternative) {
         printf("\n%sReplaced by: %s", prefix, sigmatch_table[sigmatch_table[i].alternative].name);
@@ -363,7 +363,7 @@ void SigTableList(const char *keyword)
                 PrintFeatureList(&sigmatch_table[i], ':');
                 printf(";");
                 if (sigmatch_table[i].url) {
-                    printf("%s", sigmatch_table[i].url);
+                    printf("%s%s", GetDocURL(), sigmatch_table[i].url);
                 }
                 printf(";");
                 printf("\n");

diff --git a/src/detect-fast-pattern.c b/src/detect-fast-pattern.c
index da34a0653aca7b50849c29f57e28634a584ac23f..96286c0fec826d22c12fd51cb8c1e4e9948f5411 100644 (file)
--- a/src/detect-fast-pattern.c
+++ b/src/detect-fast-pattern.c
@@ -165,7 +165,7 @@ void DetectFastPatternRegister(void)
 {
     sigmatch_table[DETECT_FAST_PATTERN].name = "fast_pattern";
     sigmatch_table[DETECT_FAST_PATTERN].desc = "force using preceding content in the multi pattern matcher";
-    sigmatch_table[DETECT_FAST_PATTERN].url = DOC_URL DOC_VERSION "/rules/prefilter-keywords.html#fast-pattern";
+    sigmatch_table[DETECT_FAST_PATTERN].url = "/rules/prefilter-keywords.html#fast-pattern";
     sigmatch_table[DETECT_FAST_PATTERN].Match = NULL;
     sigmatch_table[DETECT_FAST_PATTERN].Setup = DetectFastPatternSetup;
     sigmatch_table[DETECT_FAST_PATTERN].Free  = NULL;

diff --git a/src/detect-file-data.c b/src/detect-file-data.c
index 2e8d68534011de2a99d865b9a0d1db409742029f..beb3974840dd9a339d4079efbd3c2901ed3886b1 100644 (file)
--- a/src/detect-file-data.c
+++ b/src/detect-file-data.c
@@ -83,7 +83,7 @@ void DetectFiledataRegister(void)
     sigmatch_table[DETECT_FILE_DATA].name = "file.data";
     sigmatch_table[DETECT_FILE_DATA].alias = "file_data";
     sigmatch_table[DETECT_FILE_DATA].desc = "make content keywords match on file data";
-    sigmatch_table[DETECT_FILE_DATA].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#file-data";
+    sigmatch_table[DETECT_FILE_DATA].url = "/rules/http-keywords.html#file-data";
     sigmatch_table[DETECT_FILE_DATA].Setup = DetectFiledataSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_FILE_DATA].RegisterTests = DetectFiledataRegisterTests;

diff --git a/src/detect-fileext.c b/src/detect-fileext.c
index fcc25d4de9c855cdcb76f95ef4126fab76567323..ae116ec47bf6bbf0be8d4c22f3c88891acc85750 100644 (file)
--- a/src/detect-fileext.c
+++ b/src/detect-fileext.c
@@ -65,7 +65,7 @@ void DetectFileextRegister(void)
 {
     sigmatch_table[DETECT_FILEEXT].name = "fileext";
     sigmatch_table[DETECT_FILEEXT].desc = "match on the extension of a file name";
-    sigmatch_table[DETECT_FILEEXT].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#fileext";
+    sigmatch_table[DETECT_FILEEXT].url = "/rules/file-keywords.html#fileext";
     sigmatch_table[DETECT_FILEEXT].FileMatch = DetectFileextMatch;
     sigmatch_table[DETECT_FILEEXT].Setup = DetectFileextSetup;
     sigmatch_table[DETECT_FILEEXT].Free  = DetectFileextFree;

diff --git a/src/detect-filemagic.c b/src/detect-filemagic.c
index e03dcee3bf09fdcfe61116b9a1fdf8a890606336..529ae19cec71c57e7872e99769fe94b83c48282e 100644 (file)
--- a/src/detect-filemagic.c
+++ b/src/detect-filemagic.c
@@ -71,7 +71,7 @@ void DetectFilemagicRegister(void)
 {
     sigmatch_table[DETECT_FILEMAGIC].name = "filemagic";
     sigmatch_table[DETECT_FILEMAGIC].desc = "match on the information libmagic returns about a file";
-    sigmatch_table[DETECT_FILEMAGIC].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#filemagic";
+    sigmatch_table[DETECT_FILEMAGIC].url = "/rules/file-keywords.html#filemagic";
     sigmatch_table[DETECT_FILEMAGIC].Setup = DetectFilemagicSetupNoSupport;
     sigmatch_table[DETECT_FILEMAGIC].flags = SIGMATCH_QUOTES_MANDATORY|SIGMATCH_HANDLE_NEGATION;
 }
@@ -106,7 +106,7 @@ void DetectFilemagicRegister(void)
 {
     sigmatch_table[DETECT_FILEMAGIC].name = "filemagic";
     sigmatch_table[DETECT_FILEMAGIC].desc = "match on the information libmagic returns about a file";
-    sigmatch_table[DETECT_FILEMAGIC].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#filemagic";
+    sigmatch_table[DETECT_FILEMAGIC].url = "/rules/file-keywords.html#filemagic";
     sigmatch_table[DETECT_FILEMAGIC].FileMatch = DetectFilemagicMatch;
     sigmatch_table[DETECT_FILEMAGIC].Setup = DetectFilemagicSetup;
     sigmatch_table[DETECT_FILEMAGIC].Free  = DetectFilemagicFree;
@@ -116,7 +116,7 @@ void DetectFilemagicRegister(void)
 
     sigmatch_table[DETECT_FILE_MAGIC].name = "file.magic";
     sigmatch_table[DETECT_FILE_MAGIC].desc = "sticky buffer to match on the file magic";
-    sigmatch_table[DETECT_FILE_MAGIC].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#filemagic";
+    sigmatch_table[DETECT_FILE_MAGIC].url = "/rules/file-keywords.html#filemagic";
     sigmatch_table[DETECT_FILE_MAGIC].Setup = DetectFilemagicSetupSticky;
     sigmatch_table[DETECT_FILE_MAGIC].flags = SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-filemd5.c b/src/detect-filemd5.c
index 8134290abf7bd217bb03166d0d9269cce1b6412a..cd629698a1253125388613697049eaf957f694c4 100644 (file)
--- a/src/detect-filemd5.c
+++ b/src/detect-filemd5.c
@@ -69,7 +69,7 @@ void DetectFileMd5Register(void)
 {
     sigmatch_table[DETECT_FILEMD5].name = "filemd5";
     sigmatch_table[DETECT_FILEMD5].desc = "match file MD5 against list of MD5 checksums";
-    sigmatch_table[DETECT_FILEMD5].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#filemd5";
+    sigmatch_table[DETECT_FILEMD5].url = "/rules/file-keywords.html#filemd5";
     sigmatch_table[DETECT_FILEMD5].FileMatch = DetectFileHashMatch;
     sigmatch_table[DETECT_FILEMD5].Setup = DetectFileMd5Setup;
     sigmatch_table[DETECT_FILEMD5].Free  = DetectFileHashFree;

diff --git a/src/detect-filename.c b/src/detect-filename.c
index 189f81a9ca02a3b51b56818bfdbe9f12574cc1a1..fd2d9a1f73f58e74dfa51b7982e3a47425b6d864 100644 (file)
--- a/src/detect-filename.c
+++ b/src/detect-filename.c
@@ -79,7 +79,7 @@ void DetectFilenameRegister(void)
 {
     sigmatch_table[DETECT_FILENAME].name = "filename";
     sigmatch_table[DETECT_FILENAME].desc = "match on the file name";
-    sigmatch_table[DETECT_FILENAME].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#filename";
+    sigmatch_table[DETECT_FILENAME].url = "/rules/file-keywords.html#filename";
     sigmatch_table[DETECT_FILENAME].FileMatch = DetectFilenameMatch;
     sigmatch_table[DETECT_FILENAME].Setup = DetectFilenameSetup;
     sigmatch_table[DETECT_FILENAME].Free  = DetectFilenameFree;
@@ -89,7 +89,7 @@ void DetectFilenameRegister(void)
 
     sigmatch_table[DETECT_FILE_NAME].name = "file.name";
     sigmatch_table[DETECT_FILE_NAME].desc = "sticky buffer to match on the file name";
-    sigmatch_table[DETECT_FILE_NAME].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#filename";
+    sigmatch_table[DETECT_FILE_NAME].url = "/rules/file-keywords.html#filename";
     sigmatch_table[DETECT_FILE_NAME].Setup = DetectFilenameSetupSticky;
     sigmatch_table[DETECT_FILE_NAME].flags = SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-filesha1.c b/src/detect-filesha1.c
index feb2b908b4abe4a6a41a2c8bfe47c0be5d315e4b..beac4209e67f0993d2cf42f54655bab772ef9ae0 100644 (file)
--- a/src/detect-filesha1.c
+++ b/src/detect-filesha1.c
@@ -69,7 +69,7 @@ void DetectFileSha1Register(void)
 {
     sigmatch_table[DETECT_FILESHA1].name = "filesha1";
     sigmatch_table[DETECT_FILESHA1].desc = "match file SHA-1 against list of SHA-1 checksums";
-    sigmatch_table[DETECT_FILESHA1].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#filesha1";
+    sigmatch_table[DETECT_FILESHA1].url = "/rules/file-keywords.html#filesha1";
     sigmatch_table[DETECT_FILESHA1].FileMatch = DetectFileHashMatch;
     sigmatch_table[DETECT_FILESHA1].Setup = DetectFileSha1Setup;
     sigmatch_table[DETECT_FILESHA1].Free  = DetectFileHashFree;

diff --git a/src/detect-filesha256.c b/src/detect-filesha256.c
index 9fd068fe4ea19a522883bc234a46f8d59899d28c..1157b8d9ab613458f93c87831b3381b89577dc06 100644 (file)
--- a/src/detect-filesha256.c
+++ b/src/detect-filesha256.c
@@ -69,7 +69,7 @@ void DetectFileSha256Register(void)
 {
     sigmatch_table[DETECT_FILESHA256].name = "filesha256";
     sigmatch_table[DETECT_FILESHA256].desc = "match file SHA-256 against list of SHA-256 checksums";
-    sigmatch_table[DETECT_FILESHA256].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#filesha256";
+    sigmatch_table[DETECT_FILESHA256].url = "/rules/file-keywords.html#filesha256";
     sigmatch_table[DETECT_FILESHA256].FileMatch = DetectFileHashMatch;
     sigmatch_table[DETECT_FILESHA256].Setup = DetectFileSha256Setup;
     sigmatch_table[DETECT_FILESHA256].Free  = DetectFileHashFree;

diff --git a/src/detect-filesize.c b/src/detect-filesize.c
index e1ba7c58df0e8152b0814f407bf8ed4edf064263..50a9145d46ff07e8123e8e5647e0bd90f4c96f32 100644 (file)
--- a/src/detect-filesize.c
+++ b/src/detect-filesize.c
@@ -64,7 +64,7 @@ void DetectFilesizeRegister(void)
 {
     sigmatch_table[DETECT_FILESIZE].name = "filesize";
     sigmatch_table[DETECT_FILESIZE].desc = "match on the size of the file as it is being transferred";
-    sigmatch_table[DETECT_FILESIZE].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#filesize";
+    sigmatch_table[DETECT_FILESIZE].url = "/rules/file-keywords.html#filesize";
     sigmatch_table[DETECT_FILESIZE].FileMatch = DetectFilesizeMatch;
     sigmatch_table[DETECT_FILESIZE].Setup = DetectFilesizeSetup;
     sigmatch_table[DETECT_FILESIZE].Free = DetectFilesizeFree;

diff --git a/src/detect-filestore.c b/src/detect-filestore.c
index 93271de5c816745158b457c94dc19aca83f4bb7b..47d2ac0b2061d99d8c4463aa490e8f698014a372 100644 (file)
--- a/src/detect-filestore.c
+++ b/src/detect-filestore.c
@@ -77,7 +77,7 @@ void DetectFilestoreRegister(void)
 {
     sigmatch_table[DETECT_FILESTORE].name = "filestore";
     sigmatch_table[DETECT_FILESTORE].desc = "stores files to disk if the rule matched";
-    sigmatch_table[DETECT_FILESTORE].url = DOC_URL DOC_VERSION "/rules/file-keywords.html#filestore";
+    sigmatch_table[DETECT_FILESTORE].url = "/rules/file-keywords.html#filestore";
     sigmatch_table[DETECT_FILESTORE].FileMatch = DetectFilestoreMatch;
     sigmatch_table[DETECT_FILESTORE].Setup = DetectFilestoreSetup;
     sigmatch_table[DETECT_FILESTORE].Free  = DetectFilestoreFree;

diff --git a/src/detect-flow.c b/src/detect-flow.c
index a0cb7b6b5521c9f597a0f7f1037170f2a53d75c6..306c8db007a8cd155ef06406e0de1bab12fb489c 100644 (file)
--- a/src/detect-flow.c
+++ b/src/detect-flow.c
@@ -64,7 +64,7 @@ void DetectFlowRegister (void)
 {
     sigmatch_table[DETECT_FLOW].name = "flow";
     sigmatch_table[DETECT_FLOW].desc = "match on direction and state of the flow";
-    sigmatch_table[DETECT_FLOW].url = DOC_URL DOC_VERSION "/rules/flow-keywords.html#flow";
+    sigmatch_table[DETECT_FLOW].url = "/rules/flow-keywords.html#flow";
     sigmatch_table[DETECT_FLOW].Match = DetectFlowMatch;
     sigmatch_table[DETECT_FLOW].Setup = DetectFlowSetup;
     sigmatch_table[DETECT_FLOW].Free  = DetectFlowFree;

diff --git a/src/detect-flowbits.c b/src/detect-flowbits.c
index c1dca111d21fc0e90ca3dbb15fd9524242251e8b..2d77ba90be5a60d6f9edf33a48bbeca3aa4062bc 100644 (file)
--- a/src/detect-flowbits.c
+++ b/src/detect-flowbits.c
@@ -61,7 +61,7 @@ void DetectFlowbitsRegister (void)
 {
     sigmatch_table[DETECT_FLOWBITS].name = "flowbits";
     sigmatch_table[DETECT_FLOWBITS].desc = "operate on flow flag";
-    sigmatch_table[DETECT_FLOWBITS].url = DOC_URL DOC_VERSION "/rules/flow-keywords.html#flowbits";
+    sigmatch_table[DETECT_FLOWBITS].url = "/rules/flow-keywords.html#flowbits";
     sigmatch_table[DETECT_FLOWBITS].Match = DetectFlowbitMatch;
     sigmatch_table[DETECT_FLOWBITS].Setup = DetectFlowbitSetup;
     sigmatch_table[DETECT_FLOWBITS].Free  = DetectFlowbitFree;

diff --git a/src/detect-flowint.c b/src/detect-flowint.c
index 00a66585de50580b2a4b46f5a5d7249152504213..62ec3de151a8043c72c9bf83cfb6eef84a6df65a 100644 (file)
--- a/src/detect-flowint.c
+++ b/src/detect-flowint.c
@@ -62,7 +62,7 @@ void DetectFlowintRegister(void)
 {
     sigmatch_table[DETECT_FLOWINT].name = "flowint";
     sigmatch_table[DETECT_FLOWINT].desc = "operate on a per-flow integer";
-    sigmatch_table[DETECT_FLOWINT].url = DOC_URL DOC_VERSION "/rules/flow-keywords.html#flowint";
+    sigmatch_table[DETECT_FLOWINT].url = "/rules/flow-keywords.html#flowint";
     sigmatch_table[DETECT_FLOWINT].Match = DetectFlowintMatch;
     sigmatch_table[DETECT_FLOWINT].Setup = DetectFlowintSetup;
     sigmatch_table[DETECT_FLOWINT].Free = DetectFlowintFree;

diff --git a/src/detect-fragbits.c b/src/detect-fragbits.c
index 0c47488e7a39644f27c18691f2370057f61aa933..632a1298c1bef99c3919b07dc621f64f61dd2ba2 100644 (file)
--- a/src/detect-fragbits.c
+++ b/src/detect-fragbits.c
@@ -83,7 +83,7 @@ void DetectFragBitsRegister (void)
 {
     sigmatch_table[DETECT_FRAGBITS].name = "fragbits";
     sigmatch_table[DETECT_FRAGBITS].desc = "check if the fragmentation and reserved bits are set in the IP header";
-    sigmatch_table[DETECT_FRAGBITS].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#fragbits-ip-fragmentation";
+    sigmatch_table[DETECT_FRAGBITS].url = "/rules/header-keywords.html#fragbits-ip-fragmentation";
     sigmatch_table[DETECT_FRAGBITS].Match = DetectFragBitsMatch;
     sigmatch_table[DETECT_FRAGBITS].Setup = DetectFragBitsSetup;
     sigmatch_table[DETECT_FRAGBITS].Free  = DetectFragBitsFree;

diff --git a/src/detect-fragoffset.c b/src/detect-fragoffset.c
index 2528cf481f0036a4197ae01f16d5ba051ac18987..ffb46c88a7e0f2b183e018fbb413f911cf4a13ce 100644 (file)
--- a/src/detect-fragoffset.c
+++ b/src/detect-fragoffset.c
@@ -59,7 +59,7 @@ void DetectFragOffsetRegister (void)
 {
     sigmatch_table[DETECT_FRAGOFFSET].name = "fragoffset";
     sigmatch_table[DETECT_FRAGOFFSET].desc = "match on specific decimal values of the IP fragment offset field";
-    sigmatch_table[DETECT_FRAGOFFSET].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#fragoffset";
+    sigmatch_table[DETECT_FRAGOFFSET].url = "/rules/header-keywords.html#fragoffset";
     sigmatch_table[DETECT_FRAGOFFSET].Match = DetectFragOffsetMatch;
     sigmatch_table[DETECT_FRAGOFFSET].Setup = DetectFragOffsetSetup;
     sigmatch_table[DETECT_FRAGOFFSET].Free = DetectFragOffsetFree;

diff --git a/src/detect-ftpbounce.c b/src/detect-ftpbounce.c
index 71000992e2ffc213bb192638ee93727f269ece8a..d489580d74ae8c3d2173401ca49e873756cbf056 100644 (file)
--- a/src/detect-ftpbounce.c
+++ b/src/detect-ftpbounce.c
@@ -72,7 +72,7 @@ void DetectFtpbounceRegister(void)
     sigmatch_table[DETECT_FTPBOUNCE].Setup = DetectFtpbounceSetup;
     sigmatch_table[DETECT_FTPBOUNCE].AppLayerTxMatch = DetectFtpbounceALMatch;
     sigmatch_table[DETECT_FTPBOUNCE].RegisterTests = DetectFtpbounceRegisterTests;
-    sigmatch_table[DETECT_FTPBOUNCE].url = DOC_URL DOC_VERSION "/rules/ftp-keywords.html#ftpbounce";
+    sigmatch_table[DETECT_FTPBOUNCE].url = "/rules/ftp-keywords.html#ftpbounce";
     sigmatch_table[DETECT_FTPBOUNCE].flags = SIGMATCH_NOOPT;
 
     g_ftp_request_list_id = DetectBufferTypeRegister("ftp_request");

diff --git a/src/detect-ftpdata.c b/src/detect-ftpdata.c
index 6c71883bbc2255ec00b7bfa5135356b0f4a8228a..33834278c0c4be1ab45506e564b4b45ac1c073bb 100644 (file)
--- a/src/detect-ftpdata.c
+++ b/src/detect-ftpdata.c
@@ -64,7 +64,7 @@ void DetectFtpdataRegister(void) {
     sigmatch_table[DETECT_FTPDATA].name = "ftpdata_command";
     /* description: listed in "suricata --list-keywords=all" */
     sigmatch_table[DETECT_FTPDATA].desc = "match FTP command triggering a FTP data channel";
-    sigmatch_table[DETECT_FTPDATA].url = DOC_URL DOC_VERSION "/rules/ftp-keywords.html#ftpdata-command";
+    sigmatch_table[DETECT_FTPDATA].url = "/rules/ftp-keywords.html#ftpdata-command";
     sigmatch_table[DETECT_FTPDATA].AppLayerTxMatch = DetectFtpdataMatch;
     /* setup function is called during signature parsing, when the ftpcommand
      * keyword is encountered in the rule */

diff --git a/src/detect-geoip.c b/src/detect-geoip.c
index f25aff657bcc062448e1e038fb7148ce463c3417..b7a1fefea0c07c11640073f27a0d9fff9bfd3cec 100644 (file)
--- a/src/detect-geoip.c
+++ b/src/detect-geoip.c
@@ -56,7 +56,7 @@ void DetectGeoipRegister(void)
 {
     sigmatch_table[DETECT_GEOIP].name = "geoip";
     sigmatch_table[DETECT_GEOIP].desc = "match on the source, destination or source and destination IP addresses of network traffic, and to see to which country it belongs";
-    sigmatch_table[DETECT_GEOIP].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#geoip";
+    sigmatch_table[DETECT_GEOIP].url = "/rules/header-keywords.html#geoip";
     sigmatch_table[DETECT_GEOIP].Setup = DetectGeoipSetupNoSupport;
     sigmatch_table[DETECT_GEOIP].Free = NULL;
     sigmatch_table[DETECT_GEOIP].RegisterTests = NULL;
@@ -79,7 +79,7 @@ static void DetectGeoipDataFree(DetectEngineCtx *, void *);
 void DetectGeoipRegister(void)
 {
     sigmatch_table[DETECT_GEOIP].name = "geoip";
-    sigmatch_table[DETECT_GEOIP].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#geoip";
+    sigmatch_table[DETECT_GEOIP].url = "/rules/header-keywords.html#geoip";
     sigmatch_table[DETECT_GEOIP].desc = "keyword to match on country of src and or dst IP";
     sigmatch_table[DETECT_GEOIP].Match = DetectGeoipMatch;
     sigmatch_table[DETECT_GEOIP].Setup = DetectGeoipSetup;

diff --git a/src/detect-gid.c b/src/detect-gid.c
index 9dca6836859268868fdf663daec6f3e623184583..684dfed3c7b0184b9e4917604cd53d4e3f7e0163 100644 (file)
--- a/src/detect-gid.c
+++ b/src/detect-gid.c
@@ -46,7 +46,7 @@ void DetectGidRegister (void)
 {
     sigmatch_table[DETECT_GID].name = "gid";
     sigmatch_table[DETECT_GID].desc = "give different groups of signatures another id value";
-    sigmatch_table[DETECT_GID].url = DOC_URL DOC_VERSION "/rules/meta.html#gid-group-id";
+    sigmatch_table[DETECT_GID].url = "/rules/meta.html#gid-group-id";
     sigmatch_table[DETECT_GID].Match = NULL;
     sigmatch_table[DETECT_GID].Setup = DetectGidSetup;
     sigmatch_table[DETECT_GID].Free  = NULL;

diff --git a/src/detect-hostbits.c b/src/detect-hostbits.c
index 382e3022b76608b10015056285a39e4d5eae42b4..fa20c4f74b414902bcd23ca34223f40a6b30f7fe 100644 (file)
--- a/src/detect-hostbits.c
+++ b/src/detect-hostbits.c
@@ -77,7 +77,7 @@ void DetectHostbitsRegister (void)
 {
     sigmatch_table[DETECT_HOSTBITS].name = "hostbits";
     sigmatch_table[DETECT_HOSTBITS].desc = "operate on host flag";
-//    sigmatch_table[DETECT_HOSTBITS].url = DOC_URL DOC_VERSION "/rules/flow-keywords.html#flowbits";
+//    sigmatch_table[DETECT_HOSTBITS].url = "/rules/flow-keywords.html#flowbits";
     sigmatch_table[DETECT_HOSTBITS].Match = DetectHostbitMatch;
     sigmatch_table[DETECT_HOSTBITS].Setup = DetectHostbitSetup;
     sigmatch_table[DETECT_HOSTBITS].Free  = DetectHostbitFree;

diff --git a/src/detect-http-client-body.c b/src/detect-http-client-body.c
index 15a0e13269a089e3845f5b4e9e09e1c0a3347ecc..1894c0e0ea4d5c484b3903654e529adf029153e3 100644 (file)
--- a/src/detect-http-client-body.c
+++ b/src/detect-http-client-body.c
@@ -81,7 +81,7 @@ void DetectHttpClientBodyRegister(void)
     /* http_client_body content modifier */
     sigmatch_table[DETECT_AL_HTTP_CLIENT_BODY].name = "http_client_body";
     sigmatch_table[DETECT_AL_HTTP_CLIENT_BODY].desc = "content modifier to match only on HTTP request-body";
-    sigmatch_table[DETECT_AL_HTTP_CLIENT_BODY].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-client-body";
+    sigmatch_table[DETECT_AL_HTTP_CLIENT_BODY].url = "/rules/http-keywords.html#http-client-body";
     sigmatch_table[DETECT_AL_HTTP_CLIENT_BODY].Setup = DetectHttpClientBodySetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_HTTP_CLIENT_BODY].RegisterTests = DetectHttpClientBodyRegisterTests;
@@ -93,7 +93,7 @@ void DetectHttpClientBodyRegister(void)
     /* http.request_body sticky buffer */
     sigmatch_table[DETECT_HTTP_REQUEST_BODY].name = "http.request_body";
     sigmatch_table[DETECT_HTTP_REQUEST_BODY].desc = "sticky buffer to match the HTTP request body buffer";
-    sigmatch_table[DETECT_HTTP_REQUEST_BODY].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-client-body";
+    sigmatch_table[DETECT_HTTP_REQUEST_BODY].url = "/rules/http-keywords.html#http-client-body";
     sigmatch_table[DETECT_HTTP_REQUEST_BODY].Setup = DetectHttpClientBodySetupSticky;
     sigmatch_table[DETECT_HTTP_REQUEST_BODY].flags |= SIGMATCH_NOOPT;
     sigmatch_table[DETECT_HTTP_REQUEST_BODY].flags |= SIGMATCH_INFO_STICKY_BUFFER;

diff --git a/src/detect-http-cookie.c b/src/detect-http-cookie.c
index 2256f2e6fec4cbfde80c8b293dee87c068acdfc3..74fc9f98a44f79cef89c073cb088959e44325a9f 100644 (file)
--- a/src/detect-http-cookie.c
+++ b/src/detect-http-cookie.c
@@ -85,7 +85,7 @@ void DetectHttpCookieRegister(void)
     /* http_cookie content modifier */
     sigmatch_table[DETECT_AL_HTTP_COOKIE].name = "http_cookie";
     sigmatch_table[DETECT_AL_HTTP_COOKIE].desc = "content modifier to match only on the HTTP cookie-buffer";
-    sigmatch_table[DETECT_AL_HTTP_COOKIE].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-cookie";
+    sigmatch_table[DETECT_AL_HTTP_COOKIE].url = "/rules/http-keywords.html#http-cookie";
     sigmatch_table[DETECT_AL_HTTP_COOKIE].Setup = DetectHttpCookieSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_HTTP_COOKIE].RegisterTests = DetectHttpCookieRegisterTests;
@@ -97,7 +97,7 @@ void DetectHttpCookieRegister(void)
     /* http.cookie sticky buffer */
     sigmatch_table[DETECT_HTTP_COOKIE].name = "http.cookie";
     sigmatch_table[DETECT_HTTP_COOKIE].desc = "sticky buffer to match on the HTTP Cookie/Set-Cookie buffers";
-    sigmatch_table[DETECT_HTTP_COOKIE].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-cookie";
+    sigmatch_table[DETECT_HTTP_COOKIE].url = "/rules/http-keywords.html#http-cookie";
     sigmatch_table[DETECT_HTTP_COOKIE].Setup = DetectHttpCookieSetupSticky;
     sigmatch_table[DETECT_HTTP_COOKIE].flags |= SIGMATCH_NOOPT;
     sigmatch_table[DETECT_HTTP_COOKIE].flags |= SIGMATCH_INFO_STICKY_BUFFER;

diff --git a/src/detect-http-header-names.c b/src/detect-http-header-names.c
index f05df8a2817120b03bc7f6f9f5d3186908fb5217..dde59f959755abf1558591d792df54b5c74b2376 100644 (file)
--- a/src/detect-http-header-names.c
+++ b/src/detect-http-header-names.c
@@ -393,7 +393,7 @@ void DetectHttpHeaderNamesRegister(void)
     sigmatch_table[DETECT_AL_HTTP_HEADER_NAMES].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_HTTP_HEADER_NAMES].alias = KEYWORD_NAME_LEGACY;
     sigmatch_table[DETECT_AL_HTTP_HEADER_NAMES].desc = BUFFER_NAME " sticky buffer";
-    sigmatch_table[DETECT_AL_HTTP_HEADER_NAMES].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_HTTP_HEADER_NAMES].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_HTTP_HEADER_NAMES].Setup = DetectHttpHeaderNamesSetup;
 
     sigmatch_table[DETECT_AL_HTTP_HEADER_NAMES].flags |= SIGMATCH_NOOPT | SIGMATCH_INFO_STICKY_BUFFER;

diff --git a/src/detect-http-header.c b/src/detect-http-header.c
index e22f5592ad50242b2048419e22a0ad89d639a857..e2b1904ede9c89ebc3ed9f836b709be7fdd8cf86 100644 (file)
--- a/src/detect-http-header.c
+++ b/src/detect-http-header.c
@@ -408,7 +408,7 @@ void DetectHttpHeaderRegister(void)
     /* http_header content modifier */
     sigmatch_table[DETECT_AL_HTTP_HEADER].name = "http_header";
     sigmatch_table[DETECT_AL_HTTP_HEADER].desc = "content modifier to match only on the HTTP header-buffer";
-    sigmatch_table[DETECT_AL_HTTP_HEADER].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-header-and-http-raw-header";
+    sigmatch_table[DETECT_AL_HTTP_HEADER].url = "/rules/http-keywords.html#http-header-and-http-raw-header";
     sigmatch_table[DETECT_AL_HTTP_HEADER].Setup = DetectHttpHeaderSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_HTTP_HEADER].RegisterTests = DetectHttpHeaderRegisterTests;
@@ -420,7 +420,7 @@ void DetectHttpHeaderRegister(void)
     /* http.header sticky buffer */
     sigmatch_table[DETECT_HTTP_HEADER].name = "http.header";
     sigmatch_table[DETECT_HTTP_HEADER].desc = "sticky buffer to match on the normalized HTTP header-buffer";
-    sigmatch_table[DETECT_HTTP_HEADER].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-header-and-http-raw-header";
+    sigmatch_table[DETECT_HTTP_HEADER].url = "/rules/http-keywords.html#http-header-and-http-raw-header";
     sigmatch_table[DETECT_HTTP_HEADER].Setup = DetectHttpHeaderSetupSticky;
     sigmatch_table[DETECT_HTTP_HEADER].flags |= SIGMATCH_NOOPT;
     sigmatch_table[DETECT_HTTP_HEADER].flags |= SIGMATCH_INFO_STICKY_BUFFER;

diff --git a/src/detect-http-headers-stub.h b/src/detect-http-headers-stub.h
index fb1f0b15c80082f14a081fa7a6ef64e2e2aff839..07e18e7aae6b4eb086a7b79b1b00974d9077b6e2 100644 (file)
--- a/src/detect-http-headers-stub.h
+++ b/src/detect-http-headers-stub.h
@@ -142,7 +142,7 @@ static void DetectHttpHeadersRegisterStub(void)
     sigmatch_table[KEYWORD_ID].alias = KEYWORD_NAME_LEGACY;
 #endif
     sigmatch_table[KEYWORD_ID].desc = KEYWORD_NAME " sticky buffer for the " BUFFER_DESC;
-    sigmatch_table[KEYWORD_ID].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[KEYWORD_ID].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[KEYWORD_ID].Setup = DetectHttpHeadersSetupSticky;
     sigmatch_table[KEYWORD_ID].flags |= SIGMATCH_NOOPT | SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-http-host.c b/src/detect-http-host.c
index 3b74206066d85479a32f888bc6fd20bb8e5420c7..fdf47641feb0a1e869520f1f1d09bfcbcdd5c992 100644 (file)
--- a/src/detect-http-host.c
+++ b/src/detect-http-host.c
@@ -84,7 +84,7 @@ void DetectHttpHHRegister(void)
     /* http_host content modifier */
     sigmatch_table[DETECT_AL_HTTP_HOST].name = "http_host";
     sigmatch_table[DETECT_AL_HTTP_HOST].desc = "content modifier to match on the HTTP hostname";
-    sigmatch_table[DETECT_AL_HTTP_HOST].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-host-and-http-raw-host";
+    sigmatch_table[DETECT_AL_HTTP_HOST].url = "/rules/http-keywords.html#http-host-and-http-raw-host";
     sigmatch_table[DETECT_AL_HTTP_HOST].Setup = DetectHttpHHSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_HTTP_HOST].RegisterTests = DetectHttpHHRegisterTests;
@@ -95,7 +95,7 @@ void DetectHttpHHRegister(void)
     /* http.host sticky buffer */
     sigmatch_table[DETECT_HTTP_HOST].name = "http.host";
     sigmatch_table[DETECT_HTTP_HOST].desc = "sticky buffer to match on the HTTP Host buffer";
-    sigmatch_table[DETECT_HTTP_HOST].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-host-and-http-raw-host";
+    sigmatch_table[DETECT_HTTP_HOST].url = "/rules/http-keywords.html#http-host-and-http-raw-host";
     sigmatch_table[DETECT_HTTP_HOST].Setup = DetectHttpHostSetup;
     sigmatch_table[DETECT_HTTP_HOST].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 
@@ -118,7 +118,7 @@ void DetectHttpHHRegister(void)
     /* http_raw_host content modifier */
     sigmatch_table[DETECT_AL_HTTP_RAW_HOST].name = "http_raw_host";
     sigmatch_table[DETECT_AL_HTTP_RAW_HOST].desc = "content modifier to match on the HTTP host header or the raw hostname from the HTTP uri";
-    sigmatch_table[DETECT_AL_HTTP_RAW_HOST].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-host-and-http-raw-host";
+    sigmatch_table[DETECT_AL_HTTP_RAW_HOST].url = "/rules/http-keywords.html#http-host-and-http-raw-host";
     sigmatch_table[DETECT_AL_HTTP_RAW_HOST].Setup = DetectHttpHRHSetup;
     sigmatch_table[DETECT_AL_HTTP_RAW_HOST].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_CONTENT_MODIFIER;
     sigmatch_table[DETECT_AL_HTTP_RAW_HOST].alternative = DETECT_HTTP_HOST_RAW;
@@ -126,7 +126,7 @@ void DetectHttpHHRegister(void)
     /* http.host sticky buffer */
     sigmatch_table[DETECT_HTTP_HOST_RAW].name = "http.host.raw";
     sigmatch_table[DETECT_HTTP_HOST_RAW].desc = "sticky buffer to match on the HTTP host header or the raw hostname from the HTTP uri";
-    sigmatch_table[DETECT_HTTP_HOST_RAW].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-host-and-http-raw-host";
+    sigmatch_table[DETECT_HTTP_HOST_RAW].url = "/rules/http-keywords.html#http-host-and-http-raw-host";
     sigmatch_table[DETECT_HTTP_HOST_RAW].Setup = DetectHttpHostRawSetupSticky;
     sigmatch_table[DETECT_HTTP_HOST_RAW].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-http-method.c b/src/detect-http-method.c
index d787dc50ce0d248e6d895bacc63516d46b9e1874..9d185cedc0a86cd6123ee1bd438596fc6c0cdd0f 100644 (file)
--- a/src/detect-http-method.c
+++ b/src/detect-http-method.c
@@ -79,7 +79,7 @@ void DetectHttpMethodRegister(void)
     /* http_method content modifier */
     sigmatch_table[DETECT_AL_HTTP_METHOD].name = "http_method";
     sigmatch_table[DETECT_AL_HTTP_METHOD].desc = "content modifier to match only on the HTTP method-buffer";
-    sigmatch_table[DETECT_AL_HTTP_METHOD].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-method";
+    sigmatch_table[DETECT_AL_HTTP_METHOD].url = "/rules/http-keywords.html#http-method";
     sigmatch_table[DETECT_AL_HTTP_METHOD].Match = NULL;
     sigmatch_table[DETECT_AL_HTTP_METHOD].Setup = DetectHttpMethodSetup;
 #ifdef UNITTESTS
@@ -91,7 +91,7 @@ void DetectHttpMethodRegister(void)
     /* http.method sticky buffer */
     sigmatch_table[DETECT_HTTP_METHOD].name = "http.method";
     sigmatch_table[DETECT_HTTP_METHOD].desc = "sticky buffer to match specifically and only on the HTTP method buffer";
-    sigmatch_table[DETECT_HTTP_METHOD].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-method";
+    sigmatch_table[DETECT_HTTP_METHOD].url = "/rules/http-keywords.html#http-method";
     sigmatch_table[DETECT_HTTP_METHOD].Setup = DetectHttpMethodSetupSticky;
     sigmatch_table[DETECT_HTTP_METHOD].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-http-protocol.c b/src/detect-http-protocol.c
index b9c200286c2b84ef9cd58ad65d34835feeec5f57..1cae37e2d79f52c5470b70be1253d9f88e4f68c4 100644 (file)
--- a/src/detect-http-protocol.c
+++ b/src/detect-http-protocol.c
@@ -124,7 +124,7 @@ void DetectHttpProtocolRegister(void)
     sigmatch_table[DETECT_AL_HTTP_PROTOCOL].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_HTTP_PROTOCOL].alias = KEYWORD_NAME_LEGACY;
     sigmatch_table[DETECT_AL_HTTP_PROTOCOL].desc = BUFFER_NAME " sticky buffer";
-    sigmatch_table[DETECT_AL_HTTP_PROTOCOL].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_HTTP_PROTOCOL].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_HTTP_PROTOCOL].Setup = DetectHttpProtocolSetup;
     sigmatch_table[DETECT_AL_HTTP_PROTOCOL].flags |= SIGMATCH_INFO_STICKY_BUFFER | SIGMATCH_NOOPT;
 

diff --git a/src/detect-http-raw-header.c b/src/detect-http-raw-header.c
index 9e2e20cdc0e0213b32c59e65bf4b47f350ccc9af..45ceee2886817509ca3b4db3819312945fd46d9b 100644 (file)
--- a/src/detect-http-raw-header.c
+++ b/src/detect-http-raw-header.c
@@ -78,7 +78,7 @@ void DetectHttpRawHeaderRegister(void)
     /* http_raw_header content modifier */
     sigmatch_table[DETECT_AL_HTTP_RAW_HEADER].name = "http_raw_header";
     sigmatch_table[DETECT_AL_HTTP_RAW_HEADER].desc = "content modifier to match the raw HTTP header buffer";
-    sigmatch_table[DETECT_AL_HTTP_RAW_HEADER].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-header-and-http-raw-header";
+    sigmatch_table[DETECT_AL_HTTP_RAW_HEADER].url = "/rules/http-keywords.html#http-header-and-http-raw-header";
     sigmatch_table[DETECT_AL_HTTP_RAW_HEADER].Setup = DetectHttpRawHeaderSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_HTTP_RAW_HEADER].RegisterTests = DetectHttpRawHeaderRegisterTests;
@@ -89,7 +89,7 @@ void DetectHttpRawHeaderRegister(void)
     /* http.header.raw sticky buffer */
     sigmatch_table[DETECT_HTTP_RAW_HEADER].name = "http.header.raw";
     sigmatch_table[DETECT_HTTP_RAW_HEADER].desc = "sticky buffer to match the raw HTTP header buffer";
-    sigmatch_table[DETECT_HTTP_RAW_HEADER].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-header-and-http-raw-header";
+    sigmatch_table[DETECT_HTTP_RAW_HEADER].url = "/rules/http-keywords.html#http-header-and-http-raw-header";
     sigmatch_table[DETECT_HTTP_RAW_HEADER].Setup = DetectHttpRawHeaderSetupSticky;
     sigmatch_table[DETECT_HTTP_RAW_HEADER].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-http-request-line.c b/src/detect-http-request-line.c
index 08ec1e0cb8f004bae4d13c7e49d0c4f73633e6f2..101aa4a95041bd787d6ea45f68e8050e11981456 100644 (file)
--- a/src/detect-http-request-line.c
+++ b/src/detect-http-request-line.c
@@ -76,7 +76,7 @@ void DetectHttpRequestLineRegister(void)
     sigmatch_table[DETECT_AL_HTTP_REQUEST_LINE].name = "http.request_line";
     sigmatch_table[DETECT_AL_HTTP_REQUEST_LINE].alias = "http_request_line";
     sigmatch_table[DETECT_AL_HTTP_REQUEST_LINE].desc = "sticky buffer to match on the HTTP request line";
-    sigmatch_table[DETECT_AL_HTTP_REQUEST_LINE].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-request-line";
+    sigmatch_table[DETECT_AL_HTTP_REQUEST_LINE].url = "/rules/http-keywords.html#http-request-line";
     sigmatch_table[DETECT_AL_HTTP_REQUEST_LINE].Match = NULL;
     sigmatch_table[DETECT_AL_HTTP_REQUEST_LINE].Setup = DetectHttpRequestLineSetup;
     sigmatch_table[DETECT_AL_HTTP_REQUEST_LINE].RegisterTests = DetectHttpRequestLineRegisterTests;

diff --git a/src/detect-http-response-line.c b/src/detect-http-response-line.c
index 06e12df9b56a1bce6d2f80d17b933ee76f2cf0e0..4fe43da52c9e5451702532b01e5a4c4d70d0fc33 100644 (file)
--- a/src/detect-http-response-line.c
+++ b/src/detect-http-response-line.c
@@ -76,7 +76,7 @@ void DetectHttpResponseLineRegister(void)
     sigmatch_table[DETECT_AL_HTTP_RESPONSE_LINE].name = "http.response_line";
     sigmatch_table[DETECT_AL_HTTP_RESPONSE_LINE].alias = "http_response_line";
     sigmatch_table[DETECT_AL_HTTP_RESPONSE_LINE].desc = "content modifier to match only on the HTTP response line";
-    sigmatch_table[DETECT_AL_HTTP_RESPONSE_LINE].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-response-line";
+    sigmatch_table[DETECT_AL_HTTP_RESPONSE_LINE].url = "/rules/http-keywords.html#http-response-line";
     sigmatch_table[DETECT_AL_HTTP_RESPONSE_LINE].Setup = DetectHttpResponseLineSetup;
     sigmatch_table[DETECT_AL_HTTP_RESPONSE_LINE].RegisterTests = DetectHttpResponseLineRegisterTests;
 

diff --git a/src/detect-http-server-body.c b/src/detect-http-server-body.c
index bae9a11a70c7eb3b159c72416a5097393b757ddf..8c330cdee819ebcd33af4c8d337ac645fc9b57cf 100644 (file)
--- a/src/detect-http-server-body.c
+++ b/src/detect-http-server-body.c
@@ -74,7 +74,7 @@ void DetectHttpServerBodyRegister(void)
     /* http_server_body content modifier */
     sigmatch_table[DETECT_AL_HTTP_SERVER_BODY].name = "http_server_body";
     sigmatch_table[DETECT_AL_HTTP_SERVER_BODY].desc = "content modifier to match on the HTTP response-body";
-    sigmatch_table[DETECT_AL_HTTP_SERVER_BODY].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-server-body";
+    sigmatch_table[DETECT_AL_HTTP_SERVER_BODY].url = "/rules/http-keywords.html#http-server-body";
     sigmatch_table[DETECT_AL_HTTP_SERVER_BODY].Setup = DetectHttpServerBodySetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_HTTP_SERVER_BODY].RegisterTests = DetectHttpServerBodyRegisterTests;
@@ -86,7 +86,7 @@ void DetectHttpServerBodyRegister(void)
     /* http.request_body sticky buffer */
     sigmatch_table[DETECT_HTTP_RESPONSE_BODY].name = "http.response_body";
     sigmatch_table[DETECT_HTTP_RESPONSE_BODY].desc = "sticky buffer to match the HTTP response body buffer";
-    sigmatch_table[DETECT_HTTP_RESPONSE_BODY].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-server-body";
+    sigmatch_table[DETECT_HTTP_RESPONSE_BODY].url = "/rules/http-keywords.html#http-server-body";
     sigmatch_table[DETECT_HTTP_RESPONSE_BODY].Setup = DetectHttpServerBodySetupSticky;
     sigmatch_table[DETECT_HTTP_RESPONSE_BODY].flags |= SIGMATCH_NOOPT;
     sigmatch_table[DETECT_HTTP_RESPONSE_BODY].flags |= SIGMATCH_INFO_STICKY_BUFFER;

diff --git a/src/detect-http-start.c b/src/detect-http-start.c
index b1042a0583a7de960d20b00e6ee56558d6cb4253..4e6decc03ff895c1cb8151a5f0e82bfe547c880b 100644 (file)
--- a/src/detect-http-start.c
+++ b/src/detect-http-start.c
@@ -377,7 +377,7 @@ void DetectHttpStartRegister(void)
     sigmatch_table[DETECT_AL_HTTP_START].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_HTTP_START].alias = KEYWORD_NAME_LEGACY;
     sigmatch_table[DETECT_AL_HTTP_START].desc = BUFFER_NAME " sticky buffer";
-    sigmatch_table[DETECT_AL_HTTP_START].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_HTTP_START].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_HTTP_START].Setup = DetectHttpStartSetup;
     sigmatch_table[DETECT_AL_HTTP_START].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-http-stat-code.c b/src/detect-http-stat-code.c
index 240c54fa02295bebeeb39300d992c31f7c5f07a8..22433a6b8e47bf2e296d4741c7ae7577948864b5 100644 (file)
--- a/src/detect-http-stat-code.c
+++ b/src/detect-http-stat-code.c
@@ -81,7 +81,7 @@ void DetectHttpStatCodeRegister (void)
     /* http_stat_code content modifier */
     sigmatch_table[DETECT_AL_HTTP_STAT_CODE].name = "http_stat_code";
     sigmatch_table[DETECT_AL_HTTP_STAT_CODE].desc = "content modifier to match only on HTTP stat-code-buffer";
-    sigmatch_table[DETECT_AL_HTTP_STAT_CODE].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-stat-code";
+    sigmatch_table[DETECT_AL_HTTP_STAT_CODE].url = "/rules/http-keywords.html#http-stat-code";
     sigmatch_table[DETECT_AL_HTTP_STAT_CODE].Setup = DetectHttpStatCodeSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_HTTP_STAT_CODE].RegisterTests = DetectHttpStatCodeRegisterTests;
@@ -92,7 +92,7 @@ void DetectHttpStatCodeRegister (void)
     /* http.stat_code content modifier */
     sigmatch_table[DETECT_HTTP_STAT_CODE].name = "http.stat_code";
     sigmatch_table[DETECT_HTTP_STAT_CODE].desc = "sticky buffer to match only on HTTP stat-code-buffer";
-    sigmatch_table[DETECT_HTTP_STAT_CODE].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-stat-code";
+    sigmatch_table[DETECT_HTTP_STAT_CODE].url = "/rules/http-keywords.html#http-stat-code";
     sigmatch_table[DETECT_HTTP_STAT_CODE].Setup = DetectHttpStatCodeSetupSticky;
     sigmatch_table[DETECT_HTTP_STAT_CODE].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-http-stat-msg.c b/src/detect-http-stat-msg.c
index 6fb5356887330b21e832cf3a397e911b9e04a16d..c59f9c267182a94edb90f1707d81a45ba1c6b22e 100644 (file)
--- a/src/detect-http-stat-msg.c
+++ b/src/detect-http-stat-msg.c
@@ -81,7 +81,7 @@ void DetectHttpStatMsgRegister (void)
     /* http_stat_msg content modifier */
     sigmatch_table[DETECT_AL_HTTP_STAT_MSG].name = "http_stat_msg";
     sigmatch_table[DETECT_AL_HTTP_STAT_MSG].desc = "content modifier to match on HTTP stat-msg-buffer";
-    sigmatch_table[DETECT_AL_HTTP_STAT_MSG].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-stat-msg";
+    sigmatch_table[DETECT_AL_HTTP_STAT_MSG].url = "/rules/http-keywords.html#http-stat-msg";
     sigmatch_table[DETECT_AL_HTTP_STAT_MSG].Setup = DetectHttpStatMsgSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_HTTP_STAT_MSG].RegisterTests = DetectHttpStatMsgRegisterTests;
@@ -92,7 +92,7 @@ void DetectHttpStatMsgRegister (void)
     /* http.stat_msg sticky buffer */
     sigmatch_table[DETECT_HTTP_STAT_MSG].name = "http.stat_msg";
     sigmatch_table[DETECT_HTTP_STAT_MSG].desc = "sticky buffer to match on the HTTP response status message";
-    sigmatch_table[DETECT_HTTP_STAT_MSG].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-stat-msg";
+    sigmatch_table[DETECT_HTTP_STAT_MSG].url = "/rules/http-keywords.html#http-stat-msg";
     sigmatch_table[DETECT_HTTP_STAT_MSG].Setup = DetectHttpStatMsgSetupSticky;
     sigmatch_table[DETECT_HTTP_STAT_MSG].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-http-ua.c b/src/detect-http-ua.c
index 7772c65351a000016f8df6ca6f640a3e4602d329..a4d9f39ccff771026fe812826e4dfad34f516713 100644 (file)
--- a/src/detect-http-ua.c
+++ b/src/detect-http-ua.c
@@ -78,7 +78,7 @@ void DetectHttpUARegister(void)
     /* http_user_agent content modifier */
     sigmatch_table[DETECT_AL_HTTP_USER_AGENT].name = "http_user_agent";
     sigmatch_table[DETECT_AL_HTTP_USER_AGENT].desc = "content modifier to match only on the HTTP User-Agent header";
-    sigmatch_table[DETECT_AL_HTTP_USER_AGENT].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-user-agent";
+    sigmatch_table[DETECT_AL_HTTP_USER_AGENT].url = "/rules/http-keywords.html#http-user-agent";
     sigmatch_table[DETECT_AL_HTTP_USER_AGENT].Setup = DetectHttpUASetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_HTTP_USER_AGENT].RegisterTests = DetectHttpUARegisterTests;
@@ -90,7 +90,7 @@ void DetectHttpUARegister(void)
     /* http.user_agent sticky buffer */
     sigmatch_table[DETECT_HTTP_UA].name = "http.user_agent";
     sigmatch_table[DETECT_HTTP_UA].desc = "sticky buffer to match specifically and only on the HTTP User Agent buffer";
-    sigmatch_table[DETECT_HTTP_UA].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-user-agent";
+    sigmatch_table[DETECT_HTTP_UA].url = "/rules/http-keywords.html#http-user-agent";
     sigmatch_table[DETECT_HTTP_UA].Setup = DetectHttpUserAgentSetup;
     sigmatch_table[DETECT_HTTP_UA].flags |= SIGMATCH_NOOPT;
     sigmatch_table[DETECT_HTTP_UA].flags |= SIGMATCH_INFO_STICKY_BUFFER;

diff --git a/src/detect-http-uri.c b/src/detect-http-uri.c
index ace5d0300a0838efc521a27b6f62b7464ce85d34..cd002dd0cff7bb5a9243bf154d21ed8054fccbfd 100644 (file)
--- a/src/detect-http-uri.c
+++ b/src/detect-http-uri.c
@@ -90,7 +90,7 @@ void DetectHttpUriRegister (void)
     /* http_uri content modifier */
     sigmatch_table[DETECT_AL_HTTP_URI].name = "http_uri";
     sigmatch_table[DETECT_AL_HTTP_URI].desc = "content modifier to match specifically and only on the HTTP uri-buffer";
-    sigmatch_table[DETECT_AL_HTTP_URI].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-uri-and-http-raw-uri";
+    sigmatch_table[DETECT_AL_HTTP_URI].url = "/rules/http-keywords.html#http-uri-and-http-raw-uri";
     sigmatch_table[DETECT_AL_HTTP_URI].Setup = DetectHttpUriSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_HTTP_URI].RegisterTests = DetectHttpUriRegisterTests;
@@ -102,7 +102,7 @@ void DetectHttpUriRegister (void)
     sigmatch_table[DETECT_HTTP_URI].name = "http.uri";
     sigmatch_table[DETECT_HTTP_URI].alias = "http.uri.normalized";
     sigmatch_table[DETECT_HTTP_URI].desc = "sticky buffer to match specifically and only on the normalized HTTP URI buffer";
-    sigmatch_table[DETECT_HTTP_URI].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-uri-and-http-raw-uri";
+    sigmatch_table[DETECT_HTTP_URI].url = "/rules/http-keywords.html#http-uri-and-http-raw-uri";
     sigmatch_table[DETECT_HTTP_URI].Setup = DetectHttpUriSetupSticky;
     sigmatch_table[DETECT_HTTP_URI].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 
@@ -128,7 +128,7 @@ void DetectHttpUriRegister (void)
     /* http_raw_uri content modifier */
     sigmatch_table[DETECT_AL_HTTP_RAW_URI].name = "http_raw_uri";
     sigmatch_table[DETECT_AL_HTTP_RAW_URI].desc = "content modifier to match on the raw HTTP uri";
-    sigmatch_table[DETECT_AL_HTTP_RAW_URI].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http_uri-and-http_raw-uri";
+    sigmatch_table[DETECT_AL_HTTP_RAW_URI].url = "/rules/http-keywords.html#http_uri-and-http_raw-uri";
     sigmatch_table[DETECT_AL_HTTP_RAW_URI].Setup = DetectHttpRawUriSetup;
     sigmatch_table[DETECT_AL_HTTP_RAW_URI].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_CONTENT_MODIFIER;
     sigmatch_table[DETECT_AL_HTTP_RAW_URI].alternative = DETECT_HTTP_URI_RAW;
@@ -136,7 +136,7 @@ void DetectHttpUriRegister (void)
     /* http.uri.raw sticky buffer */
     sigmatch_table[DETECT_HTTP_URI_RAW].name = "http.uri.raw";
     sigmatch_table[DETECT_HTTP_URI_RAW].desc = "sticky buffer to match specifically and only on the raw HTTP URI buffer";
-    sigmatch_table[DETECT_HTTP_URI_RAW].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#http-uri-and-http-raw-uri";
+    sigmatch_table[DETECT_HTTP_URI_RAW].url = "/rules/http-keywords.html#http-uri-and-http-raw-uri";
     sigmatch_table[DETECT_HTTP_URI_RAW].Setup = DetectHttpRawUriSetupSticky;
     sigmatch_table[DETECT_HTTP_URI_RAW].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-icmp-id.c b/src/detect-icmp-id.c
index 4d3c0ad67732e2f0a4daead538a558536d651de2..11ea25483ee6b6add88db8a7b8c92c42f6137c7d 100644 (file)
--- a/src/detect-icmp-id.c
+++ b/src/detect-icmp-id.c
@@ -57,7 +57,7 @@ void DetectIcmpIdRegister (void)
 {
     sigmatch_table[DETECT_ICMP_ID].name = "icmp_id";
     sigmatch_table[DETECT_ICMP_ID].desc = "check for a ICMP ID";
-    sigmatch_table[DETECT_ICMP_ID].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#icmp-id";
+    sigmatch_table[DETECT_ICMP_ID].url = "/rules/header-keywords.html#icmp-id";
     sigmatch_table[DETECT_ICMP_ID].Match = DetectIcmpIdMatch;
     sigmatch_table[DETECT_ICMP_ID].Setup = DetectIcmpIdSetup;
     sigmatch_table[DETECT_ICMP_ID].Free = DetectIcmpIdFree;

diff --git a/src/detect-icmp-seq.c b/src/detect-icmp-seq.c
index 4f85fadaaa267ccfd77eb565b6a775e0012a72b2..06ae82895314fc486995f1ace1f6fcedf68fc4b4 100644 (file)
--- a/src/detect-icmp-seq.c
+++ b/src/detect-icmp-seq.c
@@ -57,7 +57,7 @@ void DetectIcmpSeqRegister (void)
 {
     sigmatch_table[DETECT_ICMP_SEQ].name = "icmp_seq";
     sigmatch_table[DETECT_ICMP_SEQ].desc = "check for a ICMP sequence number";
-    sigmatch_table[DETECT_ICMP_SEQ].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#icmp-seq";
+    sigmatch_table[DETECT_ICMP_SEQ].url = "/rules/header-keywords.html#icmp-seq";
     sigmatch_table[DETECT_ICMP_SEQ].Match = DetectIcmpSeqMatch;
     sigmatch_table[DETECT_ICMP_SEQ].Setup = DetectIcmpSeqSetup;
     sigmatch_table[DETECT_ICMP_SEQ].Free = DetectIcmpSeqFree;

diff --git a/src/detect-icmpv6-mtu.c b/src/detect-icmpv6-mtu.c
index cf48ee217b3ae5a09a40cc11dc5d8b68187c8fd1..340b4f4280bff579bb288c07aa06c5d2e6963452 100644 (file)
--- a/src/detect-icmpv6-mtu.c
+++ b/src/detect-icmpv6-mtu.c
@@ -49,7 +49,7 @@ void DetectICMPv6mtuRegister(void)
 {
     sigmatch_table[DETECT_ICMPV6MTU].name = "icmpv6.mtu";
     sigmatch_table[DETECT_ICMPV6MTU].desc = "match on ICMPv6 MTU field";
-    sigmatch_table[DETECT_ICMPV6MTU].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#icmpv6mtu";
+    sigmatch_table[DETECT_ICMPV6MTU].url = "/rules/header-keywords.html#icmpv6mtu";
     sigmatch_table[DETECT_ICMPV6MTU].Match = DetectICMPv6mtuMatch;
     sigmatch_table[DETECT_ICMPV6MTU].Setup = DetectICMPv6mtuSetup;
     sigmatch_table[DETECT_ICMPV6MTU].Free = DetectICMPv6mtuFree;

diff --git a/src/detect-icmpv6hdr.c b/src/detect-icmpv6hdr.c
index b169c870ce187608f3f5f747fa8aca1e7310e2ea..f8dbf7f6cefee4286d577ea707898c1abf75caac 100644 (file)
--- a/src/detect-icmpv6hdr.c
+++ b/src/detect-icmpv6hdr.c
@@ -51,7 +51,7 @@ void DetectICMPv6hdrRegister(void)
 {
     sigmatch_table[DETECT_ICMPV6HDR].name = "icmpv6.hdr";
     sigmatch_table[DETECT_ICMPV6HDR].desc = "sticky buffer to match on the ICMP V6 header";
-    sigmatch_table[DETECT_ICMPV6HDR].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#icmpv6hdr";
+    sigmatch_table[DETECT_ICMPV6HDR].url = "/rules/header-keywords.html#icmpv6hdr";
     sigmatch_table[DETECT_ICMPV6HDR].Setup = DetectICMPv6hdrSetup;
     sigmatch_table[DETECT_ICMPV6HDR].flags |= SIGMATCH_NOOPT | SIGMATCH_INFO_STICKY_BUFFER;
 #ifdef UNITTESTS

diff --git a/src/detect-icode.c b/src/detect-icode.c
index 228fc47a35af6683b022eda54d9ea0aa2a1c63a7..f174997a30626d9c9764619eb28919d47ae614ee 100644 (file)
--- a/src/detect-icode.c
+++ b/src/detect-icode.c
@@ -61,7 +61,7 @@ void DetectICodeRegister (void)
 {
     sigmatch_table[DETECT_ICODE].name = "icode";
     sigmatch_table[DETECT_ICODE].desc = "match on specific ICMP id-value";
-    sigmatch_table[DETECT_ICODE].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#icode";
+    sigmatch_table[DETECT_ICODE].url = "/rules/header-keywords.html#icode";
     sigmatch_table[DETECT_ICODE].Match = DetectICodeMatch;
     sigmatch_table[DETECT_ICODE].Setup = DetectICodeSetup;
     sigmatch_table[DETECT_ICODE].Free = DetectICodeFree;

diff --git a/src/detect-id.c b/src/detect-id.c
index 56368668a3b73fdf4522f8839366f29a6e205aae..a9d2d1ce1b2e463c117bd8903b783f2654c89721 100644 (file)
--- a/src/detect-id.c
+++ b/src/detect-id.c
@@ -65,7 +65,7 @@ void DetectIdRegister (void)
 {
     sigmatch_table[DETECT_ID].name = "id";
     sigmatch_table[DETECT_ID].desc = "match on a specific IP ID value";
-    sigmatch_table[DETECT_ID].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#id";
+    sigmatch_table[DETECT_ID].url = "/rules/header-keywords.html#id";
     sigmatch_table[DETECT_ID].Match = DetectIdMatch;
     sigmatch_table[DETECT_ID].Setup = DetectIdSetup;
     sigmatch_table[DETECT_ID].Free  = DetectIdFree;

diff --git a/src/detect-ipopts.c b/src/detect-ipopts.c
index e71e51585541bf14e32052312c116fc9b5b3fb15..7d0282f83e0a3ed55f10b9d4ce49a6f70cd21e63 100644 (file)
--- a/src/detect-ipopts.c
+++ b/src/detect-ipopts.c
@@ -55,7 +55,7 @@ void DetectIpOptsRegister (void)
 {
     sigmatch_table[DETECT_IPOPTS].name = "ipopts";
     sigmatch_table[DETECT_IPOPTS].desc = "check if a specific IP option is set";
-    sigmatch_table[DETECT_IPOPTS].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#ipopts";
+    sigmatch_table[DETECT_IPOPTS].url = "/rules/header-keywords.html#ipopts";
     sigmatch_table[DETECT_IPOPTS].Match = DetectIpOptsMatch;
     sigmatch_table[DETECT_IPOPTS].Setup = DetectIpOptsSetup;
     sigmatch_table[DETECT_IPOPTS].Free  = DetectIpOptsFree;

diff --git a/src/detect-ipproto.c b/src/detect-ipproto.c
index 3442ce9ccb930d91fde386ad4b00735dc45f5fbb..ea0373e67fa157a2c20c6935d85cff0351f2b0b6 100644 (file)
--- a/src/detect-ipproto.c
+++ b/src/detect-ipproto.c
@@ -58,7 +58,7 @@ void DetectIPProtoRegister(void)
 {
     sigmatch_table[DETECT_IPPROTO].name = "ip_proto";
     sigmatch_table[DETECT_IPPROTO].desc = "match on the IP protocol in the packet-header";
-    sigmatch_table[DETECT_IPPROTO].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#ip-proto";
+    sigmatch_table[DETECT_IPPROTO].url = "/rules/header-keywords.html#ip-proto";
     sigmatch_table[DETECT_IPPROTO].Match = NULL;
     sigmatch_table[DETECT_IPPROTO].Setup = DetectIPProtoSetup;
     sigmatch_table[DETECT_IPPROTO].Free  = DetectIPProtoFree;

diff --git a/src/detect-iprep.c b/src/detect-iprep.c
index 8f58045e4cabab541c56ba6f0cfc681b5483f209..27616c5be0d85d5a3989aaa3d27d598d31213b55 100644 (file)
--- a/src/detect-iprep.c
+++ b/src/detect-iprep.c
@@ -61,7 +61,7 @@ void DetectIPRepRegister (void)
 {
     sigmatch_table[DETECT_IPREP].name = "iprep";
     sigmatch_table[DETECT_IPREP].desc = "match on the IP reputation information for a host";
-    sigmatch_table[DETECT_IPREP].url = DOC_URL DOC_VERSION "/rules/ip-reputation-rules.html#iprep";
+    sigmatch_table[DETECT_IPREP].url = "/rules/ip-reputation-rules.html#iprep";
     sigmatch_table[DETECT_IPREP].Match = DetectIPRepMatch;
     sigmatch_table[DETECT_IPREP].Setup = DetectIPRepSetup;
     sigmatch_table[DETECT_IPREP].Free  = DetectIPRepFree;

diff --git a/src/detect-ipv4hdr.c b/src/detect-ipv4hdr.c
index e5583d886cab31cec950777c9b3f01c7571d7d80..f963cd1a4876d1806460176e8204ed0426d20bd2 100644 (file)
--- a/src/detect-ipv4hdr.c
+++ b/src/detect-ipv4hdr.c
@@ -51,7 +51,7 @@ void DetectIpv4hdrRegister(void)
 {
     sigmatch_table[DETECT_IPV4HDR].name = "ipv4.hdr";
     sigmatch_table[DETECT_IPV4HDR].desc = "sticky buffer to match on the IPV4 header";
-    sigmatch_table[DETECT_IPV4HDR].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#ipv4hdr";
+    sigmatch_table[DETECT_IPV4HDR].url = "/rules/header-keywords.html#ipv4hdr";
     sigmatch_table[DETECT_IPV4HDR].Setup = DetectIpv4hdrSetup;
     sigmatch_table[DETECT_IPV4HDR].flags |= SIGMATCH_NOOPT | SIGMATCH_INFO_STICKY_BUFFER;
 #ifdef UNITTESTS

diff --git a/src/detect-ipv6hdr.c b/src/detect-ipv6hdr.c
index 250b6e730f7d69d43cd6d25996c53a81f277dca4..8accf9a958e81ea55609a426c0d7134ecbfb9116 100644 (file)
--- a/src/detect-ipv6hdr.c
+++ b/src/detect-ipv6hdr.c
@@ -51,7 +51,7 @@ void DetectIpv6hdrRegister(void)
 {
     sigmatch_table[DETECT_IPV6HDR].name = "ipv6.hdr";
     sigmatch_table[DETECT_IPV6HDR].desc = "sticky buffer to match on the IPV6 header";
-    sigmatch_table[DETECT_IPV6HDR].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#ipv6hdr";
+    sigmatch_table[DETECT_IPV6HDR].url = "/rules/header-keywords.html#ipv6hdr";
     sigmatch_table[DETECT_IPV6HDR].Setup = DetectIpv6hdrSetup;
     sigmatch_table[DETECT_IPV6HDR].flags |= SIGMATCH_NOOPT | SIGMATCH_INFO_STICKY_BUFFER;
 #ifdef UNITTESTS

diff --git a/src/detect-isdataat.c b/src/detect-isdataat.c
index 5319866ff79ee9027ddffac62e66dd36489f6927..093588d35592633831d97bf9a58153751610552b 100644 (file)
--- a/src/detect-isdataat.c
+++ b/src/detect-isdataat.c
@@ -67,7 +67,7 @@ void DetectIsdataatRegister(void)
 {
     sigmatch_table[DETECT_ISDATAAT].name = "isdataat";
     sigmatch_table[DETECT_ISDATAAT].desc = "check if there is still data at a specific part of the payload";
-    sigmatch_table[DETECT_ISDATAAT].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#isdataat";
+    sigmatch_table[DETECT_ISDATAAT].url = "/rules/payload-keywords.html#isdataat";
     /* match is handled in DetectEngineContentInspection() */
     sigmatch_table[DETECT_ISDATAAT].Match = NULL;
     sigmatch_table[DETECT_ISDATAAT].Setup = DetectIsdataatSetup;
@@ -76,7 +76,7 @@ void DetectIsdataatRegister(void)
 
     sigmatch_table[DETECT_ENDS_WITH].name = "endswith";
     sigmatch_table[DETECT_ENDS_WITH].desc = "make sure the previous content matches exactly at the end of the buffer";
-    sigmatch_table[DETECT_ENDS_WITH].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#endswith";
+    sigmatch_table[DETECT_ENDS_WITH].url = "/rules/payload-keywords.html#endswith";
     sigmatch_table[DETECT_ENDS_WITH].Setup = DetectEndsWithSetup;
     sigmatch_table[DETECT_ENDS_WITH].flags = SIGMATCH_NOOPT;
 

diff --git a/src/detect-itype.c b/src/detect-itype.c
index 4171562a930bf731eaa71a125a8533c782333987..4e059cc18ea98822052ec4b1f98777865abeabfe 100644 (file)
--- a/src/detect-itype.c
+++ b/src/detect-itype.c
@@ -61,7 +61,7 @@ void DetectITypeRegister (void)
 {
     sigmatch_table[DETECT_ITYPE].name = "itype";
     sigmatch_table[DETECT_ITYPE].desc = "match on a specific ICMP type";
-    sigmatch_table[DETECT_ITYPE].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#itype";
+    sigmatch_table[DETECT_ITYPE].url = "/rules/header-keywords.html#itype";
     sigmatch_table[DETECT_ITYPE].Match = DetectITypeMatch;
     sigmatch_table[DETECT_ITYPE].Setup = DetectITypeSetup;
     sigmatch_table[DETECT_ITYPE].Free = DetectITypeFree;

diff --git a/src/detect-krb5-cname.c b/src/detect-krb5-cname.c
index 519e4f2945648a8798cafe794c5cc178c5984993..251baa0d01967813033d8f286e3628ee268a2bec 100644 (file)
--- a/src/detect-krb5-cname.c
+++ b/src/detect-krb5-cname.c
@@ -193,7 +193,7 @@ void DetectKrb5CNameRegister(void)
 {
     sigmatch_table[DETECT_AL_KRB5_CNAME].name = "krb5.cname";
     sigmatch_table[DETECT_AL_KRB5_CNAME].alias = "krb5_cname";
-    sigmatch_table[DETECT_AL_KRB5_CNAME].url = DOC_URL DOC_VERSION "/rules/kerberos-keywords.html#krb5-cname";
+    sigmatch_table[DETECT_AL_KRB5_CNAME].url = "/rules/kerberos-keywords.html#krb5-cname";
     sigmatch_table[DETECT_AL_KRB5_CNAME].Setup = DetectKrb5CNameSetup;
     sigmatch_table[DETECT_AL_KRB5_CNAME].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
     sigmatch_table[DETECT_AL_KRB5_CNAME].desc = "sticky buffer to match on Kerberos 5 client name";

diff --git a/src/detect-krb5-errcode.c b/src/detect-krb5-errcode.c
index 27a3040a87e60ca49e0f3b1116850ec83b4c951e..16bd2571524b5d2f082f924142b285c03156330f 100644 (file)
--- a/src/detect-krb5-errcode.c
+++ b/src/detect-krb5-errcode.c
@@ -62,7 +62,7 @@ static int g_krb5_err_code_list_id = 0;
 void DetectKrb5ErrCodeRegister(void) {
     sigmatch_table[DETECT_AL_KRB5_ERRCODE].name = "krb5_err_code";
     sigmatch_table[DETECT_AL_KRB5_ERRCODE].desc = "match Kerberos 5 error code";
-    sigmatch_table[DETECT_AL_KRB5_ERRCODE].url = DOC_URL DOC_VERSION "/rules/kerberos-keywords.html#krb5-err-code";
+    sigmatch_table[DETECT_AL_KRB5_ERRCODE].url = "/rules/kerberos-keywords.html#krb5-err-code";
     sigmatch_table[DETECT_AL_KRB5_ERRCODE].Match = NULL;
     sigmatch_table[DETECT_AL_KRB5_ERRCODE].AppLayerTxMatch = DetectKrb5ErrCodeMatch;
     sigmatch_table[DETECT_AL_KRB5_ERRCODE].Setup = DetectKrb5ErrCodeSetup;

diff --git a/src/detect-krb5-msgtype.c b/src/detect-krb5-msgtype.c
index 47af1241c85d7e9796333afcd51ef56d145dcf67..e10ad3abca51844988201f0a7110eef078e14688 100644 (file)
--- a/src/detect-krb5-msgtype.c
+++ b/src/detect-krb5-msgtype.c
@@ -62,7 +62,7 @@ static int g_krb5_msg_type_list_id = 0;
 void DetectKrb5MsgTypeRegister(void) {
     sigmatch_table[DETECT_AL_KRB5_MSGTYPE].name = "krb5_msg_type";
     sigmatch_table[DETECT_AL_KRB5_MSGTYPE].desc = "match Kerberos 5 message type";
-    sigmatch_table[DETECT_AL_KRB5_MSGTYPE].url = DOC_URL DOC_VERSION "/rules/kerberos-keywords.html#krb5-msg-type";
+    sigmatch_table[DETECT_AL_KRB5_MSGTYPE].url = "/rules/kerberos-keywords.html#krb5-msg-type";
     sigmatch_table[DETECT_AL_KRB5_MSGTYPE].Match = NULL;
     sigmatch_table[DETECT_AL_KRB5_MSGTYPE].AppLayerTxMatch = DetectKrb5MsgTypeMatch;
     sigmatch_table[DETECT_AL_KRB5_MSGTYPE].Setup = DetectKrb5MsgTypeSetup;

diff --git a/src/detect-krb5-sname.c b/src/detect-krb5-sname.c
index bd05823b27392ebe05e6d372d7d73aa4b66cce11..e4d86346004a196281af7885cc7e7d4e24cc50ea 100644 (file)
--- a/src/detect-krb5-sname.c
+++ b/src/detect-krb5-sname.c
@@ -193,7 +193,7 @@ void DetectKrb5SNameRegister(void)
 {
     sigmatch_table[DETECT_AL_KRB5_SNAME].name = "krb5.sname";
     sigmatch_table[DETECT_AL_KRB5_SNAME].alias = "krb5_sname";
-    sigmatch_table[DETECT_AL_KRB5_SNAME].url = DOC_URL DOC_VERSION "/rules/kerberos-keywords.html#krb5-sname";
+    sigmatch_table[DETECT_AL_KRB5_SNAME].url = "/rules/kerberos-keywords.html#krb5-sname";
     sigmatch_table[DETECT_AL_KRB5_SNAME].Setup = DetectKrb5SNameSetup;
     sigmatch_table[DETECT_AL_KRB5_SNAME].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
     sigmatch_table[DETECT_AL_KRB5_SNAME].desc = "sticky buffer to match on Kerberos 5 server name";

diff --git a/src/detect-lua.c b/src/detect-lua.c
index 9942e657a0c82c5b6896e1663071c401bb0c67dd..93b071a47667367092f9cbc3a158f65e4cef69d3 100644 (file)
--- a/src/detect-lua.c
+++ b/src/detect-lua.c
@@ -76,7 +76,7 @@ void DetectLuaRegister(void)
     sigmatch_table[DETECT_LUA].name = "lua";
     sigmatch_table[DETECT_LUA].alias = "luajit";
     sigmatch_table[DETECT_LUA].desc = "support for lua scripting";
-    sigmatch_table[DETECT_LUA].url = DOC_URL DOC_VERSION "/rules/rule-lua-scripting.html";
+    sigmatch_table[DETECT_LUA].url = "/rules/rule-lua-scripting.html";
     sigmatch_table[DETECT_LUA].Setup = DetectLuaSetupNoSupport;
     sigmatch_table[DETECT_LUA].Free  = NULL;
     sigmatch_table[DETECT_LUA].RegisterTests = NULL;
@@ -115,7 +115,7 @@ void DetectLuaRegister(void)
     sigmatch_table[DETECT_LUA].name = "lua";
     sigmatch_table[DETECT_LUA].alias = "luajit";
     sigmatch_table[DETECT_LUA].desc = "match via a lua script";
-    sigmatch_table[DETECT_LUA].url = DOC_URL DOC_VERSION "/rules/rule-lua-scripting.html";
+    sigmatch_table[DETECT_LUA].url = "/rules/rule-lua-scripting.html";
     sigmatch_table[DETECT_LUA].Match = DetectLuaMatch;
     sigmatch_table[DETECT_LUA].AppLayerTxMatch = DetectLuaAppTxMatch;
     sigmatch_table[DETECT_LUA].Setup = DetectLuaSetup;

diff --git a/src/detect-metadata.c b/src/detect-metadata.c
index 7dd1f82adfc3c1d2108204a285cf33abde9efdc7..cceff6163bf6c32bab8a7450165097d8ca35e468 100644 (file)
--- a/src/detect-metadata.c
+++ b/src/detect-metadata.c
@@ -41,7 +41,7 @@ void DetectMetadataRegister (void)
 {
     sigmatch_table[DETECT_METADATA].name = "metadata";
     sigmatch_table[DETECT_METADATA].desc = "used for logging";
-    sigmatch_table[DETECT_METADATA].url = DOC_URL DOC_VERSION "/rules/meta.html#metadata";
+    sigmatch_table[DETECT_METADATA].url = "/rules/meta.html#metadata";
     sigmatch_table[DETECT_METADATA].Match = NULL;
     sigmatch_table[DETECT_METADATA].Setup = DetectMetadataSetup;
     sigmatch_table[DETECT_METADATA].Free  = NULL;

diff --git a/src/detect-modbus.c b/src/detect-modbus.c
index 45a608a03533592f14a4b75e3f6fc9a7e47fbf2f..f9beb4126a3ed8330099eb3d8bdc9c3a012cd0d6 100644 (file)
--- a/src/detect-modbus.c
+++ b/src/detect-modbus.c
@@ -512,7 +512,7 @@ void DetectModbusRegister(void)
     SCEnter();
     sigmatch_table[DETECT_AL_MODBUS].name          = "modbus";
     sigmatch_table[DETECT_AL_MODBUS].desc          = "match on various properties of Modbus requests";
-    sigmatch_table[DETECT_AL_MODBUS].url           = DOC_URL DOC_VERSION "/rules/modbus-keyword.html#modbus-keyword";
+    sigmatch_table[DETECT_AL_MODBUS].url           = "/rules/modbus-keyword.html#modbus-keyword";
     sigmatch_table[DETECT_AL_MODBUS].Match         = NULL;
     sigmatch_table[DETECT_AL_MODBUS].Setup         = DetectModbusSetup;
     sigmatch_table[DETECT_AL_MODBUS].Free          = DetectModbusFree;

diff --git a/src/detect-msg.c b/src/detect-msg.c
index 22b660928f6b2d193deae53e47ee0993e607dfb7..a8b9ac1174debeb468c7c5ccf5f55d0c789704ff 100644 (file)
--- a/src/detect-msg.c
+++ b/src/detect-msg.c
@@ -41,7 +41,7 @@ void DetectMsgRegister (void)
 {
     sigmatch_table[DETECT_MSG].name = "msg";
     sigmatch_table[DETECT_MSG].desc = "information about the rule and the possible alert";
-    sigmatch_table[DETECT_MSG].url = DOC_URL DOC_VERSION "/rules/meta.html#msg-message";
+    sigmatch_table[DETECT_MSG].url = "/rules/meta.html#msg-message";
     sigmatch_table[DETECT_MSG].Match = NULL;
     sigmatch_table[DETECT_MSG].Setup = DetectMsgSetup;
     sigmatch_table[DETECT_MSG].Free = NULL;

diff --git a/src/detect-nfs-procedure.c b/src/detect-nfs-procedure.c
index d3f4674c0b84dfff1d0cb7385ec63b5fd2603458..0778318c33c1faadcbcddc585cdf4910dbc362a0 100644 (file)
--- a/src/detect-nfs-procedure.c
+++ b/src/detect-nfs-procedure.c
@@ -90,7 +90,7 @@ void DetectNfsProcedureRegister (void)
 {
     sigmatch_table[DETECT_AL_NFS_PROCEDURE].name = "nfs_procedure";
     sigmatch_table[DETECT_AL_NFS_PROCEDURE].desc = "match NFS procedure";
-    sigmatch_table[DETECT_AL_NFS_PROCEDURE].url = DOC_URL DOC_VERSION "/rules/nfs-keywords.html#procedure";
+    sigmatch_table[DETECT_AL_NFS_PROCEDURE].url = "/rules/nfs-keywords.html#procedure";
     sigmatch_table[DETECT_AL_NFS_PROCEDURE].Match = NULL;
     sigmatch_table[DETECT_AL_NFS_PROCEDURE].AppLayerTxMatch = DetectNfsProcedureMatch;
     sigmatch_table[DETECT_AL_NFS_PROCEDURE].Setup = DetectNfsProcedureSetup;

diff --git a/src/detect-nfs-version.c b/src/detect-nfs-version.c
index 7946efcf0d5404a1be5af5e87ad075ff6b841db9..95cac98d8caee940fbff90f3154cc3bf93c3ee1d 100644 (file)
--- a/src/detect-nfs-version.c
+++ b/src/detect-nfs-version.c
@@ -91,7 +91,7 @@ void DetectNfsVersionRegister (void)
     sigmatch_table[DETECT_AL_NFS_VERSION].name = "nfs.version";
     sigmatch_table[DETECT_AL_NFS_VERSION].alias = "nfs_version";
     sigmatch_table[DETECT_AL_NFS_VERSION].desc = "match NFS version";
-    sigmatch_table[DETECT_AL_NFS_VERSION].url = DOC_URL DOC_VERSION "/rules/nfs-keywords.html#version";
+    sigmatch_table[DETECT_AL_NFS_VERSION].url = "/rules/nfs-keywords.html#version";
     sigmatch_table[DETECT_AL_NFS_VERSION].AppLayerTxMatch = DetectNfsVersionMatch;
     sigmatch_table[DETECT_AL_NFS_VERSION].Setup = DetectNfsVersionSetup;
     sigmatch_table[DETECT_AL_NFS_VERSION].Free = DetectNfsVersionFree;

diff --git a/src/detect-noalert.c b/src/detect-noalert.c
index 6556687c1c57c97a8af6d69108bf1a7cd45e0077..5625af79ab3ccafd11df1c11d99fa34266a70d02 100644 (file)
--- a/src/detect-noalert.c
+++ b/src/detect-noalert.c
@@ -34,7 +34,7 @@ void DetectNoalertRegister (void)
 {
     sigmatch_table[DETECT_NOALERT].name = "noalert";
     sigmatch_table[DETECT_NOALERT].desc = "no alert will be generated by the rule";
-    sigmatch_table[DETECT_NOALERT].url = DOC_URL DOC_VERSION "/rules/flow-keywords.html";
+    sigmatch_table[DETECT_NOALERT].url = "/rules/flow-keywords.html";
     sigmatch_table[DETECT_NOALERT].Match = NULL;
     sigmatch_table[DETECT_NOALERT].Setup = DetectNoalertSetup;
     sigmatch_table[DETECT_NOALERT].Free  = NULL;

diff --git a/src/detect-nocase.c b/src/detect-nocase.c
index 6e2eec9a0efa044e9f4c6cb8d39fc47989751ff4..fe094c0f5b6c4f28d5afa199229ee21bfba646b0 100644 (file)
--- a/src/detect-nocase.c
+++ b/src/detect-nocase.c
@@ -39,7 +39,7 @@ void DetectNocaseRegister(void)
 {
     sigmatch_table[DETECT_NOCASE].name = "nocase";
     sigmatch_table[DETECT_NOCASE].desc = "modify content match to be case insensitive";
-    sigmatch_table[DETECT_NOCASE].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#nocase";
+    sigmatch_table[DETECT_NOCASE].url = "/rules/payload-keywords.html#nocase";
     sigmatch_table[DETECT_NOCASE].Match = NULL;
     sigmatch_table[DETECT_NOCASE].Setup = DetectNocaseSetup;
     sigmatch_table[DETECT_NOCASE].Free  = NULL;

diff --git a/src/detect-offset.c b/src/detect-offset.c
index 8d2c6b051d7a79f17762525add1e0243c9b86039..b26c5c2108fd21809508df5edfa3e7e906ca401c 100644 (file)
--- a/src/detect-offset.c
+++ b/src/detect-offset.c
@@ -46,7 +46,7 @@ void DetectOffsetRegister (void)
 {
     sigmatch_table[DETECT_OFFSET].name = "offset";
     sigmatch_table[DETECT_OFFSET].desc = "designate from which byte in the payload will be checked to find a match";
-    sigmatch_table[DETECT_OFFSET].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#offset";
+    sigmatch_table[DETECT_OFFSET].url = "/rules/payload-keywords.html#offset";
     sigmatch_table[DETECT_OFFSET].Match = NULL;
     sigmatch_table[DETECT_OFFSET].Setup = DetectOffsetSetup;
     sigmatch_table[DETECT_OFFSET].Free  = NULL;

diff --git a/src/detect-pcre.c b/src/detect-pcre.c
index 550c743a4c5f8e071102dfc7023261fdb34866b8..5f8ff6c79bc8816d2d546e5c2adff45fa9424f0e 100644 (file)
--- a/src/detect-pcre.c
+++ b/src/detect-pcre.c
@@ -114,7 +114,7 @@ void DetectPcreRegister (void)
 {
     sigmatch_table[DETECT_PCRE].name = "pcre";
     sigmatch_table[DETECT_PCRE].desc = "match on regular expression";
-    sigmatch_table[DETECT_PCRE].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#pcre-perl-compatible-regular-expressions";
+    sigmatch_table[DETECT_PCRE].url = "/rules/payload-keywords.html#pcre-perl-compatible-regular-expressions";
     sigmatch_table[DETECT_PCRE].Match = NULL;
     sigmatch_table[DETECT_PCRE].Setup = DetectPcreSetup;
     sigmatch_table[DETECT_PCRE].Free  = DetectPcreFree;

diff --git a/src/detect-prefilter.c b/src/detect-prefilter.c
index ba0020d4ed1cbbf09498ad4a9951e3db7e687f81..b311b19153d76b3414a99334b2f1880fc2b09ec8 100644 (file)
--- a/src/detect-prefilter.c
+++ b/src/detect-prefilter.c
@@ -38,7 +38,7 @@ void DetectPrefilterRegister(void)
 {
     sigmatch_table[DETECT_PREFILTER].name = "prefilter";
     sigmatch_table[DETECT_PREFILTER].desc = "force a condition to be used as prefilter";
-    sigmatch_table[DETECT_PREFILTER].url = DOC_URL DOC_VERSION "/rules/prefilter-keywords.html#prefilter";
+    sigmatch_table[DETECT_PREFILTER].url = "/rules/prefilter-keywords.html#prefilter";
     sigmatch_table[DETECT_PREFILTER].Match = NULL;
     sigmatch_table[DETECT_PREFILTER].Setup = DetectPrefilterSetup;
     sigmatch_table[DETECT_PREFILTER].Free  = NULL;

diff --git a/src/detect-priority.c b/src/detect-priority.c
index 612dc692e43f5527a4f7da0a075cdcdf54ba0747..c39b880e1182b7da897fff630d1f8d724ba9838e 100644 (file)
--- a/src/detect-priority.c
+++ b/src/detect-priority.c
@@ -48,7 +48,7 @@ void DetectPriorityRegister (void)
 {
     sigmatch_table[DETECT_PRIORITY].name = "priority";
     sigmatch_table[DETECT_PRIORITY].desc = "rules with a higher priority will be examined first";
-    sigmatch_table[DETECT_PRIORITY].url = DOC_URL DOC_VERSION "/rules/meta.html#priority";
+    sigmatch_table[DETECT_PRIORITY].url = "/rules/meta.html#priority";
     sigmatch_table[DETECT_PRIORITY].Setup = DetectPrioritySetup;
     sigmatch_table[DETECT_PRIORITY].RegisterTests = SCPriorityRegisterTests;
 

diff --git a/src/detect-reference.c b/src/detect-reference.c
index 87ff66de25731b889eb61780e11584fe6e9ab342..2a4c132c7a39d9eed529aabe97b3affa7582f07d 100644 (file)
--- a/src/detect-reference.c
+++ b/src/detect-reference.c
@@ -59,7 +59,7 @@ void DetectReferenceRegister(void)
 {
     sigmatch_table[DETECT_REFERENCE].name = "reference";
     sigmatch_table[DETECT_REFERENCE].desc = "direct to places where information about the rule can be found";
-    sigmatch_table[DETECT_REFERENCE].url = DOC_URL DOC_VERSION "/rules/meta.html#reference";
+    sigmatch_table[DETECT_REFERENCE].url = "/rules/meta.html#reference";
     sigmatch_table[DETECT_REFERENCE].Setup = DetectReferenceSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_REFERENCE].RegisterTests = ReferenceRegisterTests;

diff --git a/src/detect-replace.c b/src/detect-replace.c
index bb092218308249f623f98e2f7dd7a2b0ca080ee4..3e36fee6882fc4fb756f6032ca55f427777790f8 100644 (file)
--- a/src/detect-replace.c
+++ b/src/detect-replace.c
@@ -69,7 +69,7 @@ void DetectReplaceRegister (void)
 {
     sigmatch_table[DETECT_REPLACE].name = "replace";
     sigmatch_table[DETECT_REPLACE].desc = "only to be used in IPS-mode. Change the following content into another";
-    sigmatch_table[DETECT_REPLACE].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#replace";
+    sigmatch_table[DETECT_REPLACE].url = "/rules/payload-keywords.html#replace";
     sigmatch_table[DETECT_REPLACE].Match = DetectReplacePostMatch;
     sigmatch_table[DETECT_REPLACE].Setup = DetectReplaceSetup;
     sigmatch_table[DETECT_REPLACE].Free  = NULL;

diff --git a/src/detect-rev.c b/src/detect-rev.c
index faa066393f45778abfed3cc611f2dd9a69679def..8f5da5cf41b5277606f5672ea874c49c8274c96e 100644 (file)
--- a/src/detect-rev.c
+++ b/src/detect-rev.c
@@ -35,7 +35,7 @@ void DetectRevRegister (void)
 {
     sigmatch_table[DETECT_REV].name = "rev";
     sigmatch_table[DETECT_REV].desc = "set version of the rule";
-    sigmatch_table[DETECT_REV].url = DOC_URL DOC_VERSION "/rules/meta.html#rev-revision";
+    sigmatch_table[DETECT_REV].url = "/rules/meta.html#rev-revision";
     sigmatch_table[DETECT_REV].Match = NULL;
     sigmatch_table[DETECT_REV].Setup = DetectRevSetup;
     sigmatch_table[DETECT_REV].Free  = NULL;

diff --git a/src/detect-rfb-name.c b/src/detect-rfb-name.c
index 440cb12336fbaac841626b7591b4a5798b6d3101..d46819fd32a064acf7aae74fbb761b51c70c79d0 100644 (file)
--- a/src/detect-rfb-name.c
+++ b/src/detect-rfb-name.c
@@ -92,7 +92,7 @@ static InspectionBuffer *GetData(DetectEngineThreadCtx *det_ctx,
 void DetectRfbNameRegister(void)
 {
     sigmatch_table[DETECT_AL_RFB_NAME].name = KEYWORD_NAME;
-    sigmatch_table[DETECT_AL_RFB_NAME].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC
+    sigmatch_table[DETECT_AL_RFB_NAME].url = "/rules/" KEYWORD_DOC
     sigmatch_table[DETECT_AL_RFB_NAME].desc = "sticky buffer to match on the RFB desktop name";
     sigmatch_table[DETECT_AL_RFB_NAME].Setup = DetectRfbNameSetup;
     sigmatch_table[DETECT_AL_RFB_NAME].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;

diff --git a/src/detect-rfb-secresult.c b/src/detect-rfb-secresult.c
index 512052f0f066775ac057b5ad928b273454ca656b..1f4dd00952607c6ac7a8b4676b235d367233bc18 100644 (file)
--- a/src/detect-rfb-secresult.c
+++ b/src/detect-rfb-secresult.c
@@ -62,7 +62,7 @@ void DetectRfbSecresultRegister (void)
 {
     sigmatch_table[DETECT_AL_RFB_SECRESULT].name = "rfb.secresult";
     sigmatch_table[DETECT_AL_RFB_SECRESULT].desc = "match RFB security result";
-    sigmatch_table[DETECT_AL_RFB_SECRESULT].url = DOC_URL DOC_VERSION "/rules/rfb-keywords.html#rfb-secresult";
+    sigmatch_table[DETECT_AL_RFB_SECRESULT].url = "/rules/rfb-keywords.html#rfb-secresult";
     sigmatch_table[DETECT_AL_RFB_SECRESULT].AppLayerTxMatch = DetectRfbSecresultMatch;
     sigmatch_table[DETECT_AL_RFB_SECRESULT].Setup = DetectRfbSecresultSetup;
     sigmatch_table[DETECT_AL_RFB_SECRESULT].Free  = DetectRfbSecresultFree;

diff --git a/src/detect-rfb-sectype.c b/src/detect-rfb-sectype.c
index ce1d23f3b869714fd104520bc6047d3b8234de4c..caeaa2a0f1acb453e56d03311036a568159cdc28 100644 (file)
--- a/src/detect-rfb-sectype.c
+++ b/src/detect-rfb-sectype.c
@@ -73,7 +73,7 @@ void DetectRfbSectypeRegister (void)
 {
     sigmatch_table[DETECT_AL_RFB_SECTYPE].name = "rfb.sectype";
     sigmatch_table[DETECT_AL_RFB_SECTYPE].desc = "match RFB security type";
-    sigmatch_table[DETECT_AL_RFB_SECTYPE].url = DOC_URL DOC_VERSION "/rules/rfb-keywords.html#rfb-sectype";
+    sigmatch_table[DETECT_AL_RFB_SECTYPE].url = "/rules/rfb-keywords.html#rfb-sectype";
     sigmatch_table[DETECT_AL_RFB_SECTYPE].AppLayerTxMatch = DetectRfbSectypeMatch;
     sigmatch_table[DETECT_AL_RFB_SECTYPE].Setup = DetectRfbSectypeSetup;
     sigmatch_table[DETECT_AL_RFB_SECTYPE].Free = DetectRfbSectypeFree;

diff --git a/src/detect-rpc.c b/src/detect-rpc.c
index 267673fa87ec4f4fa9dd5b7ada025a70ad7af247..5d1226c89504a97dbb1f555444a0e953115fccfc 100644 (file)
--- a/src/detect-rpc.c
+++ b/src/detect-rpc.c
@@ -60,7 +60,7 @@ void DetectRpcRegister (void)
 {
     sigmatch_table[DETECT_RPC].name = "rpc";
     sigmatch_table[DETECT_RPC].desc = "match RPC procedure numbers and RPC version";
-    sigmatch_table[DETECT_RPC].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#rpc";
+    sigmatch_table[DETECT_RPC].url = "/rules/payload-keywords.html#rpc";
     sigmatch_table[DETECT_RPC].Match = DetectRpcMatch;
     sigmatch_table[DETECT_RPC].Setup = DetectRpcSetup;
     sigmatch_table[DETECT_RPC].Free  = DetectRpcFree;

diff --git a/src/detect-sameip.c b/src/detect-sameip.c
index 61d7d32c2f3249df0f5106f307179e069ab83200..ca83429933b40f25d72f047cb7307abf96cadcff 100644 (file)
--- a/src/detect-sameip.c
+++ b/src/detect-sameip.c
@@ -50,7 +50,7 @@ void DetectSameipRegister(void)
 {
     sigmatch_table[DETECT_SAMEIP].name = "sameip";
     sigmatch_table[DETECT_SAMEIP].desc = "check if the IP address of the source is the same as the IP address of the destination";
-    sigmatch_table[DETECT_SAMEIP].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#sameip";
+    sigmatch_table[DETECT_SAMEIP].url = "/rules/header-keywords.html#sameip";
     sigmatch_table[DETECT_SAMEIP].Match = DetectSameipMatch;
     sigmatch_table[DETECT_SAMEIP].Setup = DetectSameipSetup;
     sigmatch_table[DETECT_SAMEIP].Free = NULL;

diff --git a/src/detect-sid.c b/src/detect-sid.c
index 2421f993e2f9749c0d8efde97f279088b78e428a..94dedc8f0a6bfb8e4888a0fcd7693b9a93b930a2 100644 (file)
--- a/src/detect-sid.c
+++ b/src/detect-sid.c
@@ -39,7 +39,7 @@ void DetectSidRegister (void)
 {
     sigmatch_table[DETECT_SID].name = "sid";
     sigmatch_table[DETECT_SID].desc = "set rule ID";
-    sigmatch_table[DETECT_SID].url = DOC_URL DOC_VERSION "/rules/meta.html#sid-signature-id";
+    sigmatch_table[DETECT_SID].url = "/rules/meta.html#sid-signature-id";
     sigmatch_table[DETECT_SID].Match = NULL;
     sigmatch_table[DETECT_SID].Setup = DetectSidSetup;
     sigmatch_table[DETECT_SID].Free = NULL;

diff --git a/src/detect-sip-method.c b/src/detect-sip-method.c
index fc054e3bded485611e1e4d505a6e9e756513dd8d..477f96138761ae70b6e5be58969ebe472d95cbdf 100644 (file)
--- a/src/detect-sip-method.c
+++ b/src/detect-sip-method.c
@@ -127,7 +127,7 @@ void DetectSipMethodRegister(void)
     /* sip.method sticky buffer */
     sigmatch_table[DETECT_AL_SIP_METHOD].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_SIP_METHOD].desc = "sticky buffer to match on the SIP method buffer";
-    sigmatch_table[DETECT_AL_SIP_METHOD].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_SIP_METHOD].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_SIP_METHOD].Setup = DetectSipMethodSetup;
     sigmatch_table[DETECT_AL_SIP_METHOD].flags |= SIGMATCH_NOOPT;
 

diff --git a/src/detect-sip-protocol.c b/src/detect-sip-protocol.c
index 839261ff4e6f6f7eb21506a69b1999b632753f78..e8e4de72f0efb09bf292478e4a788f79dbc4dc26 100644 (file)
--- a/src/detect-sip-protocol.c
+++ b/src/detect-sip-protocol.c
@@ -97,7 +97,7 @@ void DetectSipProtocolRegister(void)
     /* sip.protocol sticky buffer */
     sigmatch_table[DETECT_AL_SIP_PROTOCOL].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_SIP_PROTOCOL].desc = "sticky buffer to match on the SIP protocol";
-    sigmatch_table[DETECT_AL_SIP_PROTOCOL].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_SIP_PROTOCOL].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_SIP_PROTOCOL].Setup = DetectSipProtocolSetup;
     sigmatch_table[DETECT_AL_SIP_PROTOCOL].flags |= SIGMATCH_NOOPT;
 

diff --git a/src/detect-sip-request-line.c b/src/detect-sip-request-line.c
index af1c446a0093e2c5b41bbfaa963bc9b31fceeb8a..9341f2b604691f92d30b6ccddf3130784b1e935f 100644 (file)
--- a/src/detect-sip-request-line.c
+++ b/src/detect-sip-request-line.c
@@ -97,7 +97,7 @@ void DetectSipRequestLineRegister(void)
     /* sip.request_line sticky buffer */
     sigmatch_table[DETECT_AL_SIP_REQUEST_LINE].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_SIP_REQUEST_LINE].desc = "sticky buffer to match on the SIP request line";
-    sigmatch_table[DETECT_AL_SIP_REQUEST_LINE].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_SIP_REQUEST_LINE].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_SIP_REQUEST_LINE].Setup = DetectSipRequestLineSetup;
     sigmatch_table[DETECT_AL_SIP_REQUEST_LINE].flags |= SIGMATCH_NOOPT;
 

diff --git a/src/detect-sip-response-line.c b/src/detect-sip-response-line.c
index dabcf3e28568ac1c93d849126999fad6f1c78b27..a6aaeb3795b41f1c5486cd0c406cb652204975fa 100644 (file)
--- a/src/detect-sip-response-line.c
+++ b/src/detect-sip-response-line.c
@@ -97,7 +97,7 @@ void DetectSipResponseLineRegister(void)
     /* sip.response_line sticky buffer */
     sigmatch_table[DETECT_AL_SIP_RESPONSE_LINE].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_SIP_RESPONSE_LINE].desc = "sticky buffer to match on the SIP response line";
-    sigmatch_table[DETECT_AL_SIP_RESPONSE_LINE].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_SIP_RESPONSE_LINE].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_SIP_RESPONSE_LINE].Setup = DetectSipResponseLineSetup;
     sigmatch_table[DETECT_AL_SIP_RESPONSE_LINE].flags |= SIGMATCH_NOOPT;
 

diff --git a/src/detect-sip-stat-code.c b/src/detect-sip-stat-code.c
index f06f67635b4f0ee1b0c5ae1e4812ed782465ea88..b98e520217f8b63bc791f1ebe241b56c9ef98ebf 100644 (file)
--- a/src/detect-sip-stat-code.c
+++ b/src/detect-sip-stat-code.c
@@ -100,7 +100,7 @@ void DetectSipStatCodeRegister (void)
     /* sip.stat_code sticky buffer */
     sigmatch_table[DETECT_AL_SIP_STAT_CODE].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_SIP_STAT_CODE].desc = "sticky buffer to match on the SIP status code";
-    sigmatch_table[DETECT_AL_SIP_STAT_CODE].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_SIP_STAT_CODE].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_SIP_STAT_CODE].Setup = DetectSipStatCodeSetup;
     sigmatch_table[DETECT_AL_SIP_STAT_CODE].flags |= SIGMATCH_NOOPT;
 

diff --git a/src/detect-sip-stat-msg.c b/src/detect-sip-stat-msg.c
index c2d39af7554a8f3c69170442c2118d1925af1528..c29851b9e0f212d8ac10e55f05ac761ff617332d 100644 (file)
--- a/src/detect-sip-stat-msg.c
+++ b/src/detect-sip-stat-msg.c
@@ -100,7 +100,7 @@ void DetectSipStatMsgRegister (void)
     /* sip.stat_msg sticky buffer */
     sigmatch_table[DETECT_AL_SIP_STAT_MSG].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_SIP_STAT_MSG].desc = "sticky buffer to match on the SIP status message";
-    sigmatch_table[DETECT_AL_SIP_STAT_MSG].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_SIP_STAT_MSG].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_SIP_STAT_MSG].Setup = DetectSipStatMsgSetup;
     sigmatch_table[DETECT_AL_SIP_STAT_MSG].flags |= SIGMATCH_NOOPT;
 

diff --git a/src/detect-sip-uri.c b/src/detect-sip-uri.c
index 8aeb335608885d39f064960c9647ca5c799f54a8..074e8e43e8d856384cdeccaf73ee9515fb8ac073 100644 (file)
--- a/src/detect-sip-uri.c
+++ b/src/detect-sip-uri.c
@@ -109,7 +109,7 @@ void DetectSipUriRegister(void)
 {
     sigmatch_table[DETECT_AL_SIP_URI].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_SIP_URI].desc = "sticky buffer to match on the SIP URI";
-    sigmatch_table[DETECT_AL_SIP_URI].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_SIP_URI].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_SIP_URI].Setup = DetectSipUriSetup;
     sigmatch_table[DETECT_AL_SIP_URI].flags |= SIGMATCH_NOOPT;
 

diff --git a/src/detect-snmp-community.c b/src/detect-snmp-community.c
index 7e2efd8a8b9d4fc9dc436e23e3e9c75e97ae4848..6769d7d4b4a6ad495cd9638500d05ec0f514fdb7 100644 (file)
--- a/src/detect-snmp-community.c
+++ b/src/detect-snmp-community.c
@@ -57,7 +57,7 @@ void DetectSNMPCommunityRegister(void)
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_SNMP_COMMUNITY].RegisterTests = DetectSNMPCommunityRegisterTests;
 #endif
-    sigmatch_table[DETECT_AL_SNMP_COMMUNITY].url = DOC_URL DOC_VERSION "/rules/snmp-keywords.html#snmp-community";
+    sigmatch_table[DETECT_AL_SNMP_COMMUNITY].url = "/rules/snmp-keywords.html#snmp-community";
 
     sigmatch_table[DETECT_AL_SNMP_COMMUNITY].flags |= SIGMATCH_NOOPT|SIGMATCH_INFO_STICKY_BUFFER;
 

diff --git a/src/detect-snmp-pdu_type.c b/src/detect-snmp-pdu_type.c
index b62851026a3374e9a0856c6fdcc0535850b03415..680e330b6e92dc7c5e7c76e2b2979a30fc56bdac 100644 (file)
--- a/src/detect-snmp-pdu_type.c
+++ b/src/detect-snmp-pdu_type.c
@@ -63,7 +63,7 @@ void DetectSNMPPduTypeRegister(void)
 {
     sigmatch_table[DETECT_AL_SNMP_PDU_TYPE].name = "snmp.pdu_type";
     sigmatch_table[DETECT_AL_SNMP_PDU_TYPE].desc = "match SNMP PDU type";
-    sigmatch_table[DETECT_AL_SNMP_PDU_TYPE].url = DOC_URL DOC_VERSION "/rules/snmp-keywords.html#snmp-pdu-type";
+    sigmatch_table[DETECT_AL_SNMP_PDU_TYPE].url = "/rules/snmp-keywords.html#snmp-pdu-type";
     sigmatch_table[DETECT_AL_SNMP_PDU_TYPE].Match = NULL;
     sigmatch_table[DETECT_AL_SNMP_PDU_TYPE].AppLayerTxMatch = DetectSNMPPduTypeMatch;
     sigmatch_table[DETECT_AL_SNMP_PDU_TYPE].Setup = DetectSNMPPduTypeSetup;

diff --git a/src/detect-snmp-version.c b/src/detect-snmp-version.c
index 4672fe350593ad53128d43f24c2f382a0fa9bb92..67cbf3147bfe304d52e200406ab514153a420d3f 100644 (file)
--- a/src/detect-snmp-version.c
+++ b/src/detect-snmp-version.c
@@ -75,7 +75,7 @@ void DetectSNMPVersionRegister (void)
 {
     sigmatch_table[DETECT_AL_SNMP_VERSION].name = "snmp.version";
     sigmatch_table[DETECT_AL_SNMP_VERSION].desc = "match SNMP version";
-    sigmatch_table[DETECT_AL_SNMP_VERSION].url = DOC_URL DOC_VERSION "/rules/snmp-keywords.html#snmp-version";
+    sigmatch_table[DETECT_AL_SNMP_VERSION].url = "/rules/snmp-keywords.html#snmp-version";
     sigmatch_table[DETECT_AL_SNMP_VERSION].Match = NULL;
     sigmatch_table[DETECT_AL_SNMP_VERSION].AppLayerTxMatch = DetectSNMPVersionMatch;
     sigmatch_table[DETECT_AL_SNMP_VERSION].Setup = DetectSNMPVersionSetup;

diff --git a/src/detect-ssh-proto-version.c b/src/detect-ssh-proto-version.c
index f455200ddf6b6a120869d1c0db07446833384222..f9d8ae5728e5e1a2858d03bca32a6f55843aef18 100644 (file)
--- a/src/detect-ssh-proto-version.c
+++ b/src/detect-ssh-proto-version.c
@@ -76,7 +76,7 @@ void DetectSshVersionRegister(void)
 {
     sigmatch_table[DETECT_AL_SSH_PROTOVERSION].name = "ssh.protoversion";
     sigmatch_table[DETECT_AL_SSH_PROTOVERSION].desc = "match SSH protocol version";
-    sigmatch_table[DETECT_AL_SSH_PROTOVERSION].url = DOC_URL DOC_VERSION "/rules/ssh-keywords.html#ssh-protoversion";
+    sigmatch_table[DETECT_AL_SSH_PROTOVERSION].url = "/rules/ssh-keywords.html#ssh-protoversion";
     sigmatch_table[DETECT_AL_SSH_PROTOVERSION].AppLayerTxMatch = DetectSshVersionMatch;
     sigmatch_table[DETECT_AL_SSH_PROTOVERSION].Setup = DetectSshVersionSetup;
     sigmatch_table[DETECT_AL_SSH_PROTOVERSION].Free  = DetectSshVersionFree;

diff --git a/src/detect-ssh-proto.c b/src/detect-ssh-proto.c
index 7db5503b48d11fc581c05b128aa6310f9545516f..2f0de667fc407e1b04a20e5df4de572ad0bcf09c 100644 (file)
--- a/src/detect-ssh-proto.c
+++ b/src/detect-ssh-proto.c
@@ -106,7 +106,7 @@ void DetectSshProtocolRegister(void)
     sigmatch_table[DETECT_AL_SSH_PROTOCOL].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_SSH_PROTOCOL].alias = KEYWORD_NAME_LEGACY;
     sigmatch_table[DETECT_AL_SSH_PROTOCOL].desc = BUFFER_NAME " sticky buffer";
-    sigmatch_table[DETECT_AL_SSH_PROTOCOL].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_SSH_PROTOCOL].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_SSH_PROTOCOL].Setup = DetectSshProtocolSetup;
     sigmatch_table[DETECT_AL_SSH_PROTOCOL].flags |= SIGMATCH_INFO_STICKY_BUFFER | SIGMATCH_NOOPT;
 

diff --git a/src/detect-ssh-software-version.c b/src/detect-ssh-software-version.c
index e41873e48c842160c69aa917eb9a200342967260..d5736e84099f789808a20e48830df9677948efcb 100644 (file)
--- a/src/detect-ssh-software-version.c
+++ b/src/detect-ssh-software-version.c
@@ -90,7 +90,7 @@ void DetectSshSoftwareVersionRegister(void)
 {
     sigmatch_table[DETECT_AL_SSH_SOFTWAREVERSION].name = "ssh.softwareversion";
     sigmatch_table[DETECT_AL_SSH_SOFTWAREVERSION].desc = "match SSH software string";
-    sigmatch_table[DETECT_AL_SSH_SOFTWAREVERSION].url = DOC_URL DOC_VERSION "/rules/ssh-keywords.html#ssh-softwareversion";
+    sigmatch_table[DETECT_AL_SSH_SOFTWAREVERSION].url = "/rules/ssh-keywords.html#ssh-softwareversion";
     sigmatch_table[DETECT_AL_SSH_SOFTWAREVERSION].AppLayerTxMatch = DetectSshSoftwareVersionMatch;
     sigmatch_table[DETECT_AL_SSH_SOFTWAREVERSION].Setup = DetectSshSoftwareVersionSetup;
     sigmatch_table[DETECT_AL_SSH_SOFTWAREVERSION].Free  = DetectSshSoftwareVersionFree;

diff --git a/src/detect-ssh-software.c b/src/detect-ssh-software.c
index bd1ed1c045d06085421cde59f1d2c691daba410d..4d1b8d9eb16d51ab9efab4b9a55b056b51ece368 100644 (file)
--- a/src/detect-ssh-software.c
+++ b/src/detect-ssh-software.c
@@ -107,7 +107,7 @@ void DetectSshSoftwareRegister(void)
     sigmatch_table[DETECT_AL_SSH_SOFTWARE].name = KEYWORD_NAME;
     sigmatch_table[DETECT_AL_SSH_SOFTWARE].alias = KEYWORD_NAME_LEGACY;
     sigmatch_table[DETECT_AL_SSH_SOFTWARE].desc = BUFFER_NAME " sticky buffer";
-    sigmatch_table[DETECT_AL_SSH_SOFTWARE].url = DOC_URL DOC_VERSION "/rules/" KEYWORD_DOC;
+    sigmatch_table[DETECT_AL_SSH_SOFTWARE].url = "/rules/" KEYWORD_DOC;
     sigmatch_table[DETECT_AL_SSH_SOFTWARE].Setup = DetectSshSoftwareSetup;
     sigmatch_table[DETECT_AL_SSH_SOFTWARE].flags |= SIGMATCH_INFO_STICKY_BUFFER | SIGMATCH_NOOPT;
 

diff --git a/src/detect-ssl-state.c b/src/detect-ssl-state.c
index 927b9084eef4a2bf4cffe6c79a9299c17e992980..5fd5b225c48850e490405061bd5e079c7c14a466 100644 (file)
--- a/src/detect-ssl-state.c
+++ b/src/detect-ssl-state.c
@@ -81,7 +81,7 @@ void DetectSslStateRegister(void)
 {
     sigmatch_table[DETECT_AL_SSL_STATE].name = "ssl_state";
     sigmatch_table[DETECT_AL_SSL_STATE].desc = "match the state of the SSL connection";
-    sigmatch_table[DETECT_AL_SSL_STATE].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#ssl-state";
+    sigmatch_table[DETECT_AL_SSL_STATE].url = "/rules/tls-keywords.html#ssl-state";
     sigmatch_table[DETECT_AL_SSL_STATE].AppLayerTxMatch = DetectSslStateMatch;
     sigmatch_table[DETECT_AL_SSL_STATE].Setup = DetectSslStateSetup;
     sigmatch_table[DETECT_AL_SSL_STATE].Free  = DetectSslStateFree;

diff --git a/src/detect-ssl-version.c b/src/detect-ssl-version.c
index 325043b3ca1bc1bcb109259f00b32450bd069e15..2f64332f4f814d7613565e58b1b3a01bcfb965b9 100644 (file)
--- a/src/detect-ssl-version.c
+++ b/src/detect-ssl-version.c
@@ -76,7 +76,7 @@ void DetectSslVersionRegister(void)
 {
     sigmatch_table[DETECT_AL_SSL_VERSION].name = "ssl_version";
     sigmatch_table[DETECT_AL_SSL_VERSION].desc = "match version of SSL/TLS record";
-    sigmatch_table[DETECT_AL_SSL_VERSION].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#ssl-version";
+    sigmatch_table[DETECT_AL_SSL_VERSION].url = "/rules/tls-keywords.html#ssl-version";
     sigmatch_table[DETECT_AL_SSL_VERSION].AppLayerTxMatch = DetectSslVersionMatch;
     sigmatch_table[DETECT_AL_SSL_VERSION].Setup = DetectSslVersionSetup;
     sigmatch_table[DETECT_AL_SSL_VERSION].Free  = DetectSslVersionFree;

diff --git a/src/detect-stream_size.c b/src/detect-stream_size.c
index c226d381e2760a20bf42cb516a2cce907625d173..476a3aca19fdb2701d7b43ce0c07b3c551009481 100644 (file)
--- a/src/detect-stream_size.c
+++ b/src/detect-stream_size.c
@@ -57,7 +57,7 @@ void DetectStreamSizeRegister(void)
 {
     sigmatch_table[DETECT_STREAM_SIZE].name = "stream_size";
     sigmatch_table[DETECT_STREAM_SIZE].desc = "match on amount of bytes of a stream";
-    sigmatch_table[DETECT_STREAM_SIZE].url = DOC_URL DOC_VERSION "/rules/flow-keywords.html#stream-size";
+    sigmatch_table[DETECT_STREAM_SIZE].url = "/rules/flow-keywords.html#stream-size";
     sigmatch_table[DETECT_STREAM_SIZE].Match = DetectStreamSizeMatch;
     sigmatch_table[DETECT_STREAM_SIZE].Setup = DetectStreamSizeSetup;
     sigmatch_table[DETECT_STREAM_SIZE].Free = DetectStreamSizeFree;

diff --git a/src/detect-target.c b/src/detect-target.c
index ec049bce69910c39c502362114793de412d37c53..52680a351b802fe5b2e6c586b39e8a06c918d71c 100644 (file)
--- a/src/detect-target.c
+++ b/src/detect-target.c
@@ -52,7 +52,7 @@ void DetectTargetRegister(void) {
     /* description: listed in "suricata --list-keywords=all" */
     sigmatch_table[DETECT_TARGET].desc = "indicate to output module which side is the target of the attack";
     /* link to further documentation of the keyword. Normally on the Suricata redmine/wiki */
-    sigmatch_table[DETECT_TARGET].url =  DOC_URL DOC_VERSION "/rules/meta.html#target";
+    sigmatch_table[DETECT_TARGET].url =  "/rules/meta.html#target";
     /* match function is called when the signature is inspected on a packet */
     sigmatch_table[DETECT_TARGET].Match = NULL;
     /* setup function is called during signature parsing, when the target

diff --git a/src/detect-tcp-ack.c b/src/detect-tcp-ack.c
index 6e8bde515fb08051f3875ed2168fa31089fef41e..31680b154380d5f889216b165a74cf40aa9eaac1 100644 (file)
--- a/src/detect-tcp-ack.c
+++ b/src/detect-tcp-ack.c
@@ -56,7 +56,7 @@ void DetectAckRegister(void)
     sigmatch_table[DETECT_ACK].name = "tcp.ack";
     sigmatch_table[DETECT_ACK].alias = "ack";
     sigmatch_table[DETECT_ACK].desc = "check for a specific TCP acknowledgement number";
-    sigmatch_table[DETECT_ACK].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#ack";
+    sigmatch_table[DETECT_ACK].url = "/rules/header-keywords.html#ack";
     sigmatch_table[DETECT_ACK].Match = DetectAckMatch;
     sigmatch_table[DETECT_ACK].Setup = DetectAckSetup;
     sigmatch_table[DETECT_ACK].Free = DetectAckFree;

diff --git a/src/detect-tcp-flags.c b/src/detect-tcp-flags.c
index a61fca62f0745cc173b4d2bac7dfbdc496b9e6dd..c35d1c79a2ab8d7756350ce2ae2010fdf947eab2 100644 (file)
--- a/src/detect-tcp-flags.c
+++ b/src/detect-tcp-flags.c
@@ -74,7 +74,7 @@ void DetectFlagsRegister (void)
     sigmatch_table[DETECT_FLAGS].name = "tcp.flags";
     sigmatch_table[DETECT_FLAGS].alias = "flags";
     sigmatch_table[DETECT_FLAGS].desc = "detect which flags are set in the TCP header";
-    sigmatch_table[DETECT_FLAGS].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#tcp-flags";
+    sigmatch_table[DETECT_FLAGS].url = "/rules/header-keywords.html#tcp-flags";
     sigmatch_table[DETECT_FLAGS].Match = DetectFlagsMatch;
     sigmatch_table[DETECT_FLAGS].Setup = DetectFlagsSetup;
     sigmatch_table[DETECT_FLAGS].Free  = DetectFlagsFree;

diff --git a/src/detect-tcp-seq.c b/src/detect-tcp-seq.c
index f654b72822b9cf8004169913accd92431589666a..f364afd99c5ab7e710b7874c029895dc93e7d6d8 100644 (file)
--- a/src/detect-tcp-seq.c
+++ b/src/detect-tcp-seq.c
@@ -53,7 +53,7 @@ void DetectSeqRegister(void)
     sigmatch_table[DETECT_SEQ].name = "tcp.seq";
     sigmatch_table[DETECT_SEQ].alias = "seq";
     sigmatch_table[DETECT_SEQ].desc = "check for a specific TCP sequence number";
-    sigmatch_table[DETECT_SEQ].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#seq";
+    sigmatch_table[DETECT_SEQ].url = "/rules/header-keywords.html#seq";
     sigmatch_table[DETECT_SEQ].Match = DetectSeqMatch;
     sigmatch_table[DETECT_SEQ].Setup = DetectSeqSetup;
     sigmatch_table[DETECT_SEQ].Free = DetectSeqFree;

diff --git a/src/detect-tcp-window.c b/src/detect-tcp-window.c
index 55366075603b9968d31488edd5e960e4754c473b..f45bdb83443737b27ff53f69b874bd23ac0e405a 100644 (file)
--- a/src/detect-tcp-window.c
+++ b/src/detect-tcp-window.c
@@ -60,7 +60,7 @@ void DetectWindowRegister (void)
     sigmatch_table[DETECT_WINDOW].name = "tcp.window";
     sigmatch_table[DETECT_WINDOW].alias = "window";
     sigmatch_table[DETECT_WINDOW].desc = "check for a specific TCP window size";
-    sigmatch_table[DETECT_WINDOW].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#window";
+    sigmatch_table[DETECT_WINDOW].url = "/rules/header-keywords.html#window";
     sigmatch_table[DETECT_WINDOW].Match = DetectWindowMatch;
     sigmatch_table[DETECT_WINDOW].Setup = DetectWindowSetup;
     sigmatch_table[DETECT_WINDOW].Free  = DetectWindowFree;

diff --git a/src/detect-tcphdr.c b/src/detect-tcphdr.c
index 5d4295710415cf4cafa479a5dead425d3e6a22b9..30a3c828fd74020e970b482998ccb48c2390f683 100644 (file)
--- a/src/detect-tcphdr.c
+++ b/src/detect-tcphdr.c
@@ -51,7 +51,7 @@ void DetectTcphdrRegister(void)
 {
     sigmatch_table[DETECT_TCPHDR].name = "tcp.hdr";
     sigmatch_table[DETECT_TCPHDR].desc = "sticky buffer to match on the TCP header";
-    sigmatch_table[DETECT_TCPHDR].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#tcphdr";
+    sigmatch_table[DETECT_TCPHDR].url = "/rules/header-keywords.html#tcphdr";
     sigmatch_table[DETECT_TCPHDR].Setup = DetectTcphdrSetup;
     sigmatch_table[DETECT_TCPHDR].flags |= SIGMATCH_NOOPT | SIGMATCH_INFO_STICKY_BUFFER;
 #ifdef UNITTESTS

diff --git a/src/detect-tcpmss.c b/src/detect-tcpmss.c
index 980da85053c20a5e088bba08d358bc6d725791d1..6e28dca05f6702c69a766e3afffe2588986a7d12 100644 (file)
--- a/src/detect-tcpmss.c
+++ b/src/detect-tcpmss.c
@@ -56,7 +56,7 @@ void DetectTcpmssRegister(void)
 {
     sigmatch_table[DETECT_TCPMSS].name = "tcp.mss";
     sigmatch_table[DETECT_TCPMSS].desc = "match on TCP MSS option field";
-    sigmatch_table[DETECT_TCPMSS].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#tcpmss";
+    sigmatch_table[DETECT_TCPMSS].url = "/rules/header-keywords.html#tcpmss";
     sigmatch_table[DETECT_TCPMSS].Match = DetectTcpmssMatch;
     sigmatch_table[DETECT_TCPMSS].Setup = DetectTcpmssSetup;
     sigmatch_table[DETECT_TCPMSS].Free = DetectTcpmssFree;

diff --git a/src/detect-template2.c b/src/detect-template2.c
index 215b370eb516d7b0246f51efddcaf007c45c5dca..eef205a569965792008512027bdf463c6a6489dd 100644 (file)
--- a/src/detect-template2.c
+++ b/src/detect-template2.c
@@ -56,7 +56,7 @@ void DetectTemplate2Register(void)
 {
     sigmatch_table[DETECT_TEMPLATE2].name = "template2";
     sigmatch_table[DETECT_TEMPLATE2].desc = "TODO describe the keyword";
-    sigmatch_table[DETECT_TEMPLATE2].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#template2";
+    sigmatch_table[DETECT_TEMPLATE2].url = "/rules/header-keywords.html#template2";
     sigmatch_table[DETECT_TEMPLATE2].Match = DetectTemplate2Match;
     sigmatch_table[DETECT_TEMPLATE2].Setup = DetectTemplate2Setup;
     sigmatch_table[DETECT_TEMPLATE2].Free = DetectTemplate2Free;

diff --git a/src/detect-threshold.c b/src/detect-threshold.c
index 3af137b2d717c918c920cb32359aff611e57f7d8..1398fb7d01cd34e40f6207f41bd3279d94e74b11 100644 (file)
--- a/src/detect-threshold.c
+++ b/src/detect-threshold.c
@@ -76,7 +76,7 @@ void DetectThresholdRegister(void)
 {
     sigmatch_table[DETECT_THRESHOLD].name = "threshold";
     sigmatch_table[DETECT_THRESHOLD].desc = "control the rule's alert frequency";
-    sigmatch_table[DETECT_THRESHOLD].url = DOC_URL DOC_VERSION "/rules/thresholding.html#threshold";
+    sigmatch_table[DETECT_THRESHOLD].url = "/rules/thresholding.html#threshold";
     sigmatch_table[DETECT_THRESHOLD].Match = DetectThresholdMatch;
     sigmatch_table[DETECT_THRESHOLD].Setup = DetectThresholdSetup;
     sigmatch_table[DETECT_THRESHOLD].Free  = DetectThresholdFree;

diff --git a/src/detect-tls-cert-fingerprint.c b/src/detect-tls-cert-fingerprint.c
index e923b5a75cef22cfe9ca4a9ba6423a4cef9a5c1a..7bb827bc7553fc1103635de15c6de7b5a10b5a2a 100644 (file)
--- a/src/detect-tls-cert-fingerprint.c
+++ b/src/detect-tls-cert-fingerprint.c
@@ -76,7 +76,7 @@ void DetectTlsFingerprintRegister(void)
     sigmatch_table[DETECT_AL_TLS_CERT_FINGERPRINT].name = "tls.cert_fingerprint";
     sigmatch_table[DETECT_AL_TLS_CERT_FINGERPRINT].alias = "tls_cert_fingerprint";
     sigmatch_table[DETECT_AL_TLS_CERT_FINGERPRINT].desc = "match on the TLS cert fingerprint buffer";
-    sigmatch_table[DETECT_AL_TLS_CERT_FINGERPRINT].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-cert-fingerprint";
+    sigmatch_table[DETECT_AL_TLS_CERT_FINGERPRINT].url = "/rules/tls-keywords.html#tls-cert-fingerprint";
     sigmatch_table[DETECT_AL_TLS_CERT_FINGERPRINT].Setup = DetectTlsFingerprintSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_TLS_CERT_FINGERPRINT].RegisterTests = DetectTlsFingerprintRegisterTests;

diff --git a/src/detect-tls-cert-issuer.c b/src/detect-tls-cert-issuer.c
index b2c3bec678d4baddb8c5baa42d91fccda07a8d49..18591661dd5848d6c57aecaf3b0e7e415f47d484 100644 (file)
--- a/src/detect-tls-cert-issuer.c
+++ b/src/detect-tls-cert-issuer.c
@@ -72,7 +72,7 @@ void DetectTlsIssuerRegister(void)
     sigmatch_table[DETECT_AL_TLS_CERT_ISSUER].name = "tls.cert_issuer";
     sigmatch_table[DETECT_AL_TLS_CERT_ISSUER].alias = "tls_cert_issuer";
     sigmatch_table[DETECT_AL_TLS_CERT_ISSUER].desc = "content modifier to match specifically and only on the TLS cert issuer buffer";
-    sigmatch_table[DETECT_AL_TLS_CERT_ISSUER].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-cert-issuer";
+    sigmatch_table[DETECT_AL_TLS_CERT_ISSUER].url = "/rules/tls-keywords.html#tls-cert-issuer";
     sigmatch_table[DETECT_AL_TLS_CERT_ISSUER].Setup = DetectTlsIssuerSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_TLS_CERT_ISSUER].RegisterTests = DetectTlsIssuerRegisterTests;

diff --git a/src/detect-tls-cert-serial.c b/src/detect-tls-cert-serial.c
index 4c9cccfee162c21daaa8bfcaae53311cd1a2fe87..ce0950b32104fbc23816ecca705d6cf81380b77d 100644 (file)
--- a/src/detect-tls-cert-serial.c
+++ b/src/detect-tls-cert-serial.c
@@ -76,7 +76,7 @@ void DetectTlsSerialRegister(void)
     sigmatch_table[DETECT_AL_TLS_CERT_SERIAL].name = "tls.cert_serial";
     sigmatch_table[DETECT_AL_TLS_CERT_SERIAL].alias = "tls_cert_serial";
     sigmatch_table[DETECT_AL_TLS_CERT_SERIAL].desc = "content modifier to match the TLS cert serial buffer";
-    sigmatch_table[DETECT_AL_TLS_CERT_SERIAL].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-cert-serial";
+    sigmatch_table[DETECT_AL_TLS_CERT_SERIAL].url = "/rules/tls-keywords.html#tls-cert-serial";
     sigmatch_table[DETECT_AL_TLS_CERT_SERIAL].Setup = DetectTlsSerialSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_TLS_CERT_SERIAL].RegisterTests = DetectTlsSerialRegisterTests;

diff --git a/src/detect-tls-cert-subject.c b/src/detect-tls-cert-subject.c
index 1e05d5c363da9304db248d1bbb3798dacee73f82..d22a686cbe94444e99b06d8a401e52d68152f2f2 100644 (file)
--- a/src/detect-tls-cert-subject.c
+++ b/src/detect-tls-cert-subject.c
@@ -72,7 +72,7 @@ void DetectTlsSubjectRegister(void)
     sigmatch_table[DETECT_AL_TLS_CERT_SUBJECT].name = "tls.cert_subject";
     sigmatch_table[DETECT_AL_TLS_CERT_SUBJECT].alias = "tls_cert_subject";
     sigmatch_table[DETECT_AL_TLS_CERT_SUBJECT].desc = "content modifier to match specifically and only on the TLS cert subject buffer";
-    sigmatch_table[DETECT_AL_TLS_CERT_SUBJECT].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-cert-subject";
+    sigmatch_table[DETECT_AL_TLS_CERT_SUBJECT].url = "/rules/tls-keywords.html#tls-cert-subject";
     sigmatch_table[DETECT_AL_TLS_CERT_SUBJECT].Setup = DetectTlsSubjectSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_TLS_CERT_SUBJECT].RegisterTests = DetectTlsSubjectRegisterTests;

diff --git a/src/detect-tls-cert-validity.c b/src/detect-tls-cert-validity.c
index e4d9d00b4091587288830fcbc659d46e70b0fca6..8d64db9a4870131fcda472d383b1f4239fdd0287 100644 (file)
--- a/src/detect-tls-cert-validity.c
+++ b/src/detect-tls-cert-validity.c
@@ -88,7 +88,7 @@ void DetectTlsValidityRegister (void)
 {
     sigmatch_table[DETECT_AL_TLS_NOTBEFORE].name = "tls_cert_notbefore";
     sigmatch_table[DETECT_AL_TLS_NOTBEFORE].desc = "match TLS certificate notBefore field";
-    sigmatch_table[DETECT_AL_TLS_NOTBEFORE].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-cert-notbefore";
+    sigmatch_table[DETECT_AL_TLS_NOTBEFORE].url = "/rules/tls-keywords.html#tls-cert-notbefore";
     sigmatch_table[DETECT_AL_TLS_NOTBEFORE].AppLayerTxMatch = DetectTlsValidityMatch;
     sigmatch_table[DETECT_AL_TLS_NOTBEFORE].Setup = DetectTlsNotBeforeSetup;
     sigmatch_table[DETECT_AL_TLS_NOTBEFORE].Free = DetectTlsValidityFree;
@@ -98,7 +98,7 @@ void DetectTlsValidityRegister (void)
 
     sigmatch_table[DETECT_AL_TLS_NOTAFTER].name = "tls_cert_notafter";
     sigmatch_table[DETECT_AL_TLS_NOTAFTER].desc = "match TLS certificate notAfter field";
-    sigmatch_table[DETECT_AL_TLS_NOTAFTER].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-cert-notafter";
+    sigmatch_table[DETECT_AL_TLS_NOTAFTER].url = "/rules/tls-keywords.html#tls-cert-notafter";
     sigmatch_table[DETECT_AL_TLS_NOTAFTER].AppLayerTxMatch = DetectTlsValidityMatch;
     sigmatch_table[DETECT_AL_TLS_NOTAFTER].Setup = DetectTlsNotAfterSetup;
     sigmatch_table[DETECT_AL_TLS_NOTAFTER].Free = DetectTlsValidityFree;
@@ -108,7 +108,7 @@ void DetectTlsValidityRegister (void)
 
     sigmatch_table[DETECT_AL_TLS_EXPIRED].name = "tls_cert_expired";
     sigmatch_table[DETECT_AL_TLS_EXPIRED].desc = "match expired TLS certificates";
-    sigmatch_table[DETECT_AL_TLS_EXPIRED].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-cert-expired";
+    sigmatch_table[DETECT_AL_TLS_EXPIRED].url = "/rules/tls-keywords.html#tls-cert-expired";
     sigmatch_table[DETECT_AL_TLS_EXPIRED].AppLayerTxMatch = DetectTlsValidityMatch;
     sigmatch_table[DETECT_AL_TLS_EXPIRED].Setup = DetectTlsExpiredSetup;
     sigmatch_table[DETECT_AL_TLS_EXPIRED].Free = DetectTlsValidityFree;
@@ -119,7 +119,7 @@ void DetectTlsValidityRegister (void)
 
     sigmatch_table[DETECT_AL_TLS_VALID].name = "tls_cert_valid";
     sigmatch_table[DETECT_AL_TLS_VALID].desc = "match valid TLS certificates";
-    sigmatch_table[DETECT_AL_TLS_VALID].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-cert-valid";
+    sigmatch_table[DETECT_AL_TLS_VALID].url = "/rules/tls-keywords.html#tls-cert-valid";
     sigmatch_table[DETECT_AL_TLS_VALID].AppLayerTxMatch = DetectTlsValidityMatch;
     sigmatch_table[DETECT_AL_TLS_VALID].Setup = DetectTlsValidSetup;
     sigmatch_table[DETECT_AL_TLS_VALID].Free = DetectTlsValidityFree;

diff --git a/src/detect-tls-certs.c b/src/detect-tls-certs.c
index 09f7d7bc9fdda515fee7a8f199b0808e7d094176..01244d1657b572450f00893a718bc89198fb08de 100644 (file)
--- a/src/detect-tls-certs.c
+++ b/src/detect-tls-certs.c
@@ -88,7 +88,7 @@ void DetectTlsCertsRegister(void)
 {
     sigmatch_table[DETECT_AL_TLS_CERTS].name = "tls.certs";
     sigmatch_table[DETECT_AL_TLS_CERTS].desc = "content modifier to match the TLS certificate sticky buffer";
-    sigmatch_table[DETECT_AL_TLS_CERTS].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-certs";
+    sigmatch_table[DETECT_AL_TLS_CERTS].url = "/rules/tls-keywords.html#tls-certs";
     sigmatch_table[DETECT_AL_TLS_CERTS].Setup = DetectTlsCertsSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_TLS_CERTS].RegisterTests = DetectTlsCertsRegisterTests;

diff --git a/src/detect-tls-ja3-hash.c b/src/detect-tls-ja3-hash.c
index 57a79ef6e51c759c43cafa01f36688d59618362a..03787ce2cc09439c60775b5aa9a5d08595c82627 100644 (file)
--- a/src/detect-tls-ja3-hash.c
+++ b/src/detect-tls-ja3-hash.c
@@ -80,7 +80,7 @@ void DetectTlsJa3HashRegister(void)
     sigmatch_table[DETECT_AL_TLS_JA3_HASH].name = "ja3.hash";
     sigmatch_table[DETECT_AL_TLS_JA3_HASH].alias = "ja3_hash";
     sigmatch_table[DETECT_AL_TLS_JA3_HASH].desc = "content modifier to match the JA3 hash buffer";
-    sigmatch_table[DETECT_AL_TLS_JA3_HASH].url = DOC_URL DOC_VERSION "/rules/ja3-keywords.html#ja3-hash";
+    sigmatch_table[DETECT_AL_TLS_JA3_HASH].url = "/rules/ja3-keywords.html#ja3-hash";
     sigmatch_table[DETECT_AL_TLS_JA3_HASH].Setup = DetectTlsJa3HashSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_TLS_JA3_HASH].RegisterTests = DetectTlsJa3HashRegisterTests;

diff --git a/src/detect-tls-ja3-string.c b/src/detect-tls-ja3-string.c
index 199e6e80e847e4673149d2c2c95f05faed74bdf7..6869ea960458a87d76a8d680ab8f3234df489d87 100644 (file)
--- a/src/detect-tls-ja3-string.c
+++ b/src/detect-tls-ja3-string.c
@@ -76,7 +76,7 @@ void DetectTlsJa3StringRegister(void)
     sigmatch_table[DETECT_AL_TLS_JA3_STRING].name = "ja3.string";
     sigmatch_table[DETECT_AL_TLS_JA3_STRING].alias = "ja3_string";
     sigmatch_table[DETECT_AL_TLS_JA3_STRING].desc = "content modifier to match the JA3 string buffer";
-    sigmatch_table[DETECT_AL_TLS_JA3_STRING].url = DOC_URL DOC_VERSION "/rules/ja3-keywords.html#ja3-string";
+    sigmatch_table[DETECT_AL_TLS_JA3_STRING].url = "/rules/ja3-keywords.html#ja3-string";
     sigmatch_table[DETECT_AL_TLS_JA3_STRING].Setup = DetectTlsJa3StringSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_TLS_JA3_STRING].RegisterTests = DetectTlsJa3StringRegisterTests;

diff --git a/src/detect-tls-ja3s-hash.c b/src/detect-tls-ja3s-hash.c
index d7f97a23297a6bb74135959a92f036a84e7a43d8..d8acf0344c44c1bf7184a03f6fc0cafff4a9510c 100644 (file)
--- a/src/detect-tls-ja3s-hash.c
+++ b/src/detect-tls-ja3s-hash.c
@@ -79,7 +79,7 @@ void DetectTlsJa3SHashRegister(void)
 {
     sigmatch_table[DETECT_AL_TLS_JA3S_HASH].name = "ja3s.hash";
     sigmatch_table[DETECT_AL_TLS_JA3S_HASH].desc = "content modifier to match the JA3S hash sticky buffer";
-    sigmatch_table[DETECT_AL_TLS_JA3S_HASH].url = DOC_URL DOC_VERSION "/rules/ja3-keywords.html#ja3s-hash";
+    sigmatch_table[DETECT_AL_TLS_JA3S_HASH].url = "/rules/ja3-keywords.html#ja3s-hash";
     sigmatch_table[DETECT_AL_TLS_JA3S_HASH].Setup = DetectTlsJa3SHashSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_TLS_JA3S_HASH].RegisterTests = DetectTlsJa3SHashRegisterTests;

diff --git a/src/detect-tls-ja3s-string.c b/src/detect-tls-ja3s-string.c
index 74af16234d0bcdf9f84442d29e4de7b54ef77bab..ea4c9aa5e48b2d4144a65f74602c9a7ab8aa4169 100644 (file)
--- a/src/detect-tls-ja3s-string.c
+++ b/src/detect-tls-ja3s-string.c
@@ -75,7 +75,7 @@ void DetectTlsJa3SStringRegister(void)
 {
     sigmatch_table[DETECT_AL_TLS_JA3S_STRING].name = "ja3s.string";
     sigmatch_table[DETECT_AL_TLS_JA3S_STRING].desc = "content modifier to match the JA3S string sticky buffer";
-    sigmatch_table[DETECT_AL_TLS_JA3S_STRING].url = DOC_URL DOC_VERSION "/rules/ja3-keywords.html#ja3s-string";
+    sigmatch_table[DETECT_AL_TLS_JA3S_STRING].url = "/rules/ja3-keywords.html#ja3s-string";
     sigmatch_table[DETECT_AL_TLS_JA3S_STRING].Setup = DetectTlsJa3SStringSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_TLS_JA3S_STRING].RegisterTests = DetectTlsJa3SStringRegisterTests;

diff --git a/src/detect-tls-sni.c b/src/detect-tls-sni.c
index e5ea416d4bdeec656f07a3d94c6ee4b2bf18659d..0fe36c020871ece671ed52b08500447d974f27c9 100644 (file)
--- a/src/detect-tls-sni.c
+++ b/src/detect-tls-sni.c
@@ -72,7 +72,7 @@ void DetectTlsSniRegister(void)
     sigmatch_table[DETECT_AL_TLS_SNI].name = "tls.sni";
     sigmatch_table[DETECT_AL_TLS_SNI].alias = "tls_sni";
     sigmatch_table[DETECT_AL_TLS_SNI].desc = "content modifier to match specifically and only on the TLS SNI buffer";
-    sigmatch_table[DETECT_AL_TLS_SNI].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-sni";
+    sigmatch_table[DETECT_AL_TLS_SNI].url = "/rules/tls-keywords.html#tls-sni";
     sigmatch_table[DETECT_AL_TLS_SNI].Setup = DetectTlsSniSetup;
 #ifdef UNITTESTS
     sigmatch_table[DETECT_AL_TLS_SNI].RegisterTests = DetectTlsSniRegisterTests;

diff --git a/src/detect-tls-version.c b/src/detect-tls-version.c
index 721a12d670424ed0666dd55cec6c0d347c8cda9e..eddef6d4b7d0f2e66e5b23f8349f54d0fc9f3043 100644 (file)
--- a/src/detect-tls-version.c
+++ b/src/detect-tls-version.c
@@ -75,7 +75,7 @@ void DetectTlsVersionRegister (void)
 {
     sigmatch_table[DETECT_AL_TLS_VERSION].name = "tls.version";
     sigmatch_table[DETECT_AL_TLS_VERSION].desc = "match on TLS/SSL version";
-    sigmatch_table[DETECT_AL_TLS_VERSION].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-version";
+    sigmatch_table[DETECT_AL_TLS_VERSION].url = "/rules/tls-keywords.html#tls-version";
     sigmatch_table[DETECT_AL_TLS_VERSION].AppLayerTxMatch = DetectTlsVersionMatch;
     sigmatch_table[DETECT_AL_TLS_VERSION].Setup = DetectTlsVersionSetup;
     sigmatch_table[DETECT_AL_TLS_VERSION].Free  = DetectTlsVersionFree;

diff --git a/src/detect-tls.c b/src/detect-tls.c
index 2c816bd4c1ff09b3e02b8db7dacf6c7ca93bb01c..0ce262f89b06598d181c9c5216615eeb4fe65031 100644 (file)
--- a/src/detect-tls.c
+++ b/src/detect-tls.c
@@ -114,7 +114,7 @@ void DetectTlsRegister (void)
 {
     sigmatch_table[DETECT_AL_TLS_SUBJECT].name = "tls.subject";
     sigmatch_table[DETECT_AL_TLS_SUBJECT].desc = "match TLS/SSL certificate Subject field";
-    sigmatch_table[DETECT_AL_TLS_SUBJECT].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-subject";
+    sigmatch_table[DETECT_AL_TLS_SUBJECT].url = "/rules/tls-keywords.html#tls-subject";
     sigmatch_table[DETECT_AL_TLS_SUBJECT].AppLayerTxMatch = DetectTlsSubjectMatch;
     sigmatch_table[DETECT_AL_TLS_SUBJECT].Setup = DetectTlsSubjectSetup;
     sigmatch_table[DETECT_AL_TLS_SUBJECT].Free  = DetectTlsSubjectFree;
@@ -124,7 +124,7 @@ void DetectTlsRegister (void)
 
     sigmatch_table[DETECT_AL_TLS_ISSUERDN].name = "tls.issuerdn";
     sigmatch_table[DETECT_AL_TLS_ISSUERDN].desc = "match TLS/SSL certificate IssuerDN field";
-    sigmatch_table[DETECT_AL_TLS_ISSUERDN].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-issuerdn";
+    sigmatch_table[DETECT_AL_TLS_ISSUERDN].url = "/rules/tls-keywords.html#tls-issuerdn";
     sigmatch_table[DETECT_AL_TLS_ISSUERDN].AppLayerTxMatch = DetectTlsIssuerDNMatch;
     sigmatch_table[DETECT_AL_TLS_ISSUERDN].Setup = DetectTlsIssuerDNSetup;
     sigmatch_table[DETECT_AL_TLS_ISSUERDN].Free  = DetectTlsIssuerDNFree;
@@ -134,7 +134,7 @@ void DetectTlsRegister (void)
 
     sigmatch_table[DETECT_AL_TLS_FINGERPRINT].name = "tls.fingerprint";
     sigmatch_table[DETECT_AL_TLS_FINGERPRINT].desc = "match TLS/SSL certificate SHA1 fingerprint";
-    sigmatch_table[DETECT_AL_TLS_FINGERPRINT].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-fingerprint";
+    sigmatch_table[DETECT_AL_TLS_FINGERPRINT].url = "/rules/tls-keywords.html#tls-fingerprint";
     sigmatch_table[DETECT_AL_TLS_FINGERPRINT].AppLayerTxMatch = DetectTlsFingerprintMatch;
     sigmatch_table[DETECT_AL_TLS_FINGERPRINT].Setup = DetectTlsFingerprintSetup;
     sigmatch_table[DETECT_AL_TLS_FINGERPRINT].Free  = DetectTlsFingerprintFree;
@@ -145,7 +145,7 @@ void DetectTlsRegister (void)
     sigmatch_table[DETECT_AL_TLS_STORE].name = "tls_store";
     sigmatch_table[DETECT_AL_TLS_STORE].alias = "tls.store";
     sigmatch_table[DETECT_AL_TLS_STORE].desc = "store TLS/SSL certificate on disk";
-    sigmatch_table[DETECT_AL_TLS_STORE].url = DOC_URL DOC_VERSION "/rules/tls-keywords.html#tls-store";
+    sigmatch_table[DETECT_AL_TLS_STORE].url = "/rules/tls-keywords.html#tls-store";
     sigmatch_table[DETECT_AL_TLS_STORE].Match = DetectTlsStorePostMatch;
     sigmatch_table[DETECT_AL_TLS_STORE].Setup = DetectTlsStoreSetup;
     sigmatch_table[DETECT_AL_TLS_STORE].Free  = NULL;

diff --git a/src/detect-tos.c b/src/detect-tos.c
index e9c8e0667d4ff9da7c3c9b9fb620860788789525..746c6cce63db734ce98e8dc1fd72c5e5c7ce394e 100644 (file)
--- a/src/detect-tos.c
+++ b/src/detect-tos.c
@@ -70,7 +70,7 @@ void DetectTosRegister(void)
     sigmatch_table[DETECT_TOS].flags =
         (SIGMATCH_QUOTES_OPTIONAL|SIGMATCH_HANDLE_NEGATION);
     sigmatch_table[DETECT_TOS].url =
-        DOC_URL DOC_VERSION "/rules/header-keywords.html#tos";
+        "/rules/header-keywords.html#tos";
 
     DetectSetupParseRegexes(PARSE_REGEX, &parse_regex);
 }

diff --git a/src/detect-transform-compress-whitespace.c b/src/detect-transform-compress-whitespace.c
index ada53cb5b8fae4aba2a732f911296ad30d8e3e68..5b54c00b304f2c6b5ea5b207d40b6db9075a908c 100644 (file)
--- a/src/detect-transform-compress-whitespace.c
+++ b/src/detect-transform-compress-whitespace.c
@@ -46,7 +46,7 @@ void DetectTransformCompressWhitespaceRegister(void)
         "modify buffer to compress consecutive whitespace characters "
         "into a single one before inspection";
     sigmatch_table[DETECT_TRANSFORM_COMPRESS_WHITESPACE].url =
-        DOC_URL DOC_VERSION "/rules/transforms.html#compress-whitespace";
+        "/rules/transforms.html#compress-whitespace";
     sigmatch_table[DETECT_TRANSFORM_COMPRESS_WHITESPACE].Transform =
         TransformCompressWhitespace;
     sigmatch_table[DETECT_TRANSFORM_COMPRESS_WHITESPACE].Setup =

diff --git a/src/detect-transform-dotprefix.c b/src/detect-transform-dotprefix.c
index 070dfade7f2d7942aaf6d72c021af9f5c2903e84..3c18b19a92839a73813982e037f81453064c8a75 100644 (file)
--- a/src/detect-transform-dotprefix.c
+++ b/src/detect-transform-dotprefix.c
@@ -47,7 +47,7 @@ void DetectTransformDotPrefixRegister(void)
     sigmatch_table[DETECT_TRANSFORM_DOTPREFIX].desc =
         "modify buffer to extract the dotprefix";
     sigmatch_table[DETECT_TRANSFORM_DOTPREFIX].url =
-        DOC_URL DOC_VERSION "/rules/transforms.html#dotprefix";
+        "/rules/transforms.html#dotprefix";
     sigmatch_table[DETECT_TRANSFORM_DOTPREFIX].Transform = TransformDotPrefix;
     sigmatch_table[DETECT_TRANSFORM_DOTPREFIX].Setup = DetectTransformDotPrefixSetup;
     sigmatch_table[DETECT_TRANSFORM_DOTPREFIX].RegisterTests =

diff --git a/src/detect-transform-md5.c b/src/detect-transform-md5.c
index 10989eb27fd690838f1b2057d8ce9216bda0f608..78d99f8615e55afb2898a056356f8ff52e3b3bf1 100644 (file)
--- a/src/detect-transform-md5.c
+++ b/src/detect-transform-md5.c
@@ -46,7 +46,7 @@ void DetectTransformMd5Register(void)
     sigmatch_table[DETECT_TRANSFORM_MD5].desc =
         "convert to md5 hash of the buffer";
     sigmatch_table[DETECT_TRANSFORM_MD5].url =
-        DOC_URL DOC_VERSION "/rules/transforms.html#to-md5";
+        "/rules/transforms.html#to-md5";
     sigmatch_table[DETECT_TRANSFORM_MD5].Setup =
         DetectTransformToMd5Setup;
 #ifdef HAVE_NSS

diff --git a/src/detect-transform-sha1.c b/src/detect-transform-sha1.c
index 7a3a929d982054fb8bccc9016626c7cc95661428..2d7fde92971bd72867a8e71e69f16cec25dd5680 100644 (file)
--- a/src/detect-transform-sha1.c
+++ b/src/detect-transform-sha1.c
@@ -46,7 +46,7 @@ void DetectTransformSha1Register(void)
     sigmatch_table[DETECT_TRANSFORM_SHA1].desc =
         "convert to sha1 hash of the buffer";
     sigmatch_table[DETECT_TRANSFORM_SHA1].url =
-        DOC_URL DOC_VERSION "/rules/transforms.html#to-sha1";
+        "/rules/transforms.html#to-sha1";
     sigmatch_table[DETECT_TRANSFORM_SHA1].Setup =
         DetectTransformToSha1Setup;
 #ifdef HAVE_NSS

diff --git a/src/detect-transform-sha256.c b/src/detect-transform-sha256.c
index 5187f8f74ddccff39720d5a4326414cd10afa975..9ab67556257cc953e82ad77e23afe73c5bd4448e 100644 (file)
--- a/src/detect-transform-sha256.c
+++ b/src/detect-transform-sha256.c
@@ -46,7 +46,7 @@ void DetectTransformSha256Register(void)
     sigmatch_table[DETECT_TRANSFORM_SHA256].desc =
         "convert to sha256 hash of the buffer";
     sigmatch_table[DETECT_TRANSFORM_SHA256].url =
-        DOC_URL DOC_VERSION "/rules/transforms.html#to-sha256";
+        "/rules/transforms.html#to-sha256";
     sigmatch_table[DETECT_TRANSFORM_SHA256].Setup =
         DetectTransformToSha256Setup;
 #ifdef HAVE_NSS

diff --git a/src/detect-transform-strip-whitespace.c b/src/detect-transform-strip-whitespace.c
index c7184d85a15b4d4ce205a8db80e8e4e3a8da9d4c..9b444f9c2bb78fa836d39c1306e16e81b8da7370 100644 (file)
--- a/src/detect-transform-strip-whitespace.c
+++ b/src/detect-transform-strip-whitespace.c
@@ -45,7 +45,7 @@ void DetectTransformStripWhitespaceRegister(void)
     sigmatch_table[DETECT_TRANSFORM_STRIP_WHITESPACE].desc =
         "modify buffer to strip whitespace before inspection";
     sigmatch_table[DETECT_TRANSFORM_STRIP_WHITESPACE].url =
-        DOC_URL DOC_VERSION "/rules/transforms.html#strip-whitespace";
+        "/rules/transforms.html#strip-whitespace";
     sigmatch_table[DETECT_TRANSFORM_STRIP_WHITESPACE].Transform =
         TransformStripWhitespace;
     sigmatch_table[DETECT_TRANSFORM_STRIP_WHITESPACE].Setup =

diff --git a/src/detect-ttl.c b/src/detect-ttl.c
index 02d04831711706a33cdf48a20d8b3b56d7e707b5..488abc77a7d00eb81eb5d3630b37378c4f9f4578 100644 (file)
--- a/src/detect-ttl.c
+++ b/src/detect-ttl.c
@@ -60,7 +60,7 @@ void DetectTtlRegister(void)
 {
     sigmatch_table[DETECT_TTL].name = "ttl";
     sigmatch_table[DETECT_TTL].desc = "check for a specific IP time-to-live value";
-    sigmatch_table[DETECT_TTL].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#ttl";
+    sigmatch_table[DETECT_TTL].url = "/rules/header-keywords.html#ttl";
     sigmatch_table[DETECT_TTL].Match = DetectTtlMatch;
     sigmatch_table[DETECT_TTL].Setup = DetectTtlSetup;
     sigmatch_table[DETECT_TTL].Free = DetectTtlFree;

diff --git a/src/detect-udphdr.c b/src/detect-udphdr.c
index 9059510b211f93730dc8494b998fc573a52670c1..6054193f96640f0a63029b927edd2f6186b48aec 100644 (file)
--- a/src/detect-udphdr.c
+++ b/src/detect-udphdr.c
@@ -50,7 +50,7 @@ void DetectUdphdrRegister(void)
 {
     sigmatch_table[DETECT_UDPHDR].name = "udp.hdr";
     sigmatch_table[DETECT_UDPHDR].desc = "sticky buffer to match on the UDP header";
-    sigmatch_table[DETECT_UDPHDR].url = DOC_URL DOC_VERSION "/rules/header-keywords.html#udphdr";
+    sigmatch_table[DETECT_UDPHDR].url = "/rules/header-keywords.html#udphdr";
     sigmatch_table[DETECT_UDPHDR].Setup = DetectUdphdrSetup;
     sigmatch_table[DETECT_UDPHDR].flags |= SIGMATCH_NOOPT | SIGMATCH_INFO_STICKY_BUFFER;
 #ifdef UNITTESTS

diff --git a/src/detect-uricontent.c b/src/detect-uricontent.c
index 7c495fab2b390f09c1e69bbb83c09ee68ff984d1..26ff2370c8522284b0f39ace505d4407553a5d23 100644 (file)
--- a/src/detect-uricontent.c
+++ b/src/detect-uricontent.c
@@ -69,7 +69,7 @@ void DetectUricontentRegister (void)
 {
     sigmatch_table[DETECT_URICONTENT].name = "uricontent";
     sigmatch_table[DETECT_URICONTENT].desc = "legacy keyword to match on the request URI buffer";
-    sigmatch_table[DETECT_URICONTENT].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#uricontent";
+    sigmatch_table[DETECT_URICONTENT].url = "/rules/http-keywords.html#uricontent";
     sigmatch_table[DETECT_URICONTENT].Match = NULL;
     sigmatch_table[DETECT_URICONTENT].Setup = DetectUricontentSetup;
     sigmatch_table[DETECT_URICONTENT].Free  = DetectUricontentFree;

diff --git a/src/detect-urilen.c b/src/detect-urilen.c
index 6b1c4e8a04fcb9ba7da6887546bdb2522f7689e3..1e6bc05568c82ed04da953d60e0d091c8df272d0 100644 (file)
--- a/src/detect-urilen.c
+++ b/src/detect-urilen.c
@@ -65,7 +65,7 @@ void DetectUrilenRegister(void)
 {
     sigmatch_table[DETECT_AL_URILEN].name = "urilen";
     sigmatch_table[DETECT_AL_URILEN].desc = "match on the length of the HTTP uri";
-    sigmatch_table[DETECT_AL_URILEN].url = DOC_URL DOC_VERSION "/rules/http-keywords.html#urilen";
+    sigmatch_table[DETECT_AL_URILEN].url = "/rules/http-keywords.html#urilen";
     sigmatch_table[DETECT_AL_URILEN].Match = NULL;
     sigmatch_table[DETECT_AL_URILEN].Setup = DetectUrilenSetup;
     sigmatch_table[DETECT_AL_URILEN].Free = DetectUrilenFree;

diff --git a/src/detect-within.c b/src/detect-within.c
index 4eb2eab53d153a70beb82d24766ed044b211b643..05adf06d520ec54ecfe684b69199f521b8989cd0 100644 (file)
--- a/src/detect-within.c
+++ b/src/detect-within.c
@@ -52,7 +52,7 @@ void DetectWithinRegister(void)
 {
     sigmatch_table[DETECT_WITHIN].name = "within";
     sigmatch_table[DETECT_WITHIN].desc = "indicate that this content match has to be within a certain distance of the previous content keyword match";
-    sigmatch_table[DETECT_WITHIN].url = DOC_URL DOC_VERSION "/rules/payload-keywords.html#within";
+    sigmatch_table[DETECT_WITHIN].url = "/rules/payload-keywords.html#within";
     sigmatch_table[DETECT_WITHIN].Match = NULL;
     sigmatch_table[DETECT_WITHIN].Setup = DetectWithinSetup;
     sigmatch_table[DETECT_WITHIN].Free  = NULL;

diff --git a/src/detect-xbits.c b/src/detect-xbits.c
index 4487388975e81362523405eef422acc399ff058a..31b0a6b69764c120d8cc8a4bbae4ee178e104a82 100644 (file)
--- a/src/detect-xbits.c
+++ b/src/detect-xbits.c
@@ -66,7 +66,7 @@ void DetectXbitsRegister (void)
 {
     sigmatch_table[DETECT_XBITS].name = "xbits";
     sigmatch_table[DETECT_XBITS].desc = "operate on bits";
-    sigmatch_table[DETECT_XBITS].url = DOC_URL DOC_VERSION "/rules/xbits.html";
+    sigmatch_table[DETECT_XBITS].url = "/rules/xbits.html";
     sigmatch_table[DETECT_XBITS].Match = DetectXbitMatch;
     sigmatch_table[DETECT_XBITS].Setup = DetectXbitSetup;
     sigmatch_table[DETECT_XBITS].Free  = DetectXbitFree;

diff --git a/src/output-json-stats.c b/src/output-json-stats.c
index cc5a59b57e14a3ce56f111a4fcd4b63c8f315801..666ec1763b048177015baa858fce280e4f183bd5 100644 (file)
--- a/src/output-json-stats.c
+++ b/src/output-json-stats.c
@@ -385,7 +385,7 @@ static OutputInitResult OutputStatsLogInit(ConfNode *conf)
     if (!StatsEnabled()) {
         SCLogError(SC_ERR_STATS_LOG_GENERIC,
                 "stats.json: stats are disabled globally: set stats.enabled to true. "
-                "See %s%s/configuration/suricata-yaml.html#stats", DOC_URL, DOC_VERSION);
+                "See %s/configuration/suricata-yaml.html#stats", GetDocURL());
         return result;
     }
 
@@ -464,7 +464,7 @@ static OutputInitResult OutputStatsLogInitSub(ConfNode *conf, OutputCtx *parent_
     if (!StatsEnabled()) {
         SCLogError(SC_ERR_STATS_LOG_GENERIC,
                 "eve.stats: stats are disabled globally: set stats.enabled to true. "
-                "See %s%s/configuration/suricata-yaml.html#stats", DOC_URL, DOC_VERSION);
+                "See %s/configuration/suricata-yaml.html#stats", GetDocURL());
         return result;
     }
 

diff --git a/src/suricata.c b/src/suricata.c
index f2376be305440ff99b06d2a5703c59fd7c9db345..60d421df2d90c5594e8bee1b7da93ce94a65a742 100644 (file)
--- a/src/suricata.c
+++ b/src/suricata.c
@@ -1019,6 +1019,15 @@ static void SCInstanceInit(SCInstance *suri, const char *progname)
 #endif
 }
 
+const char *GetDocURL(void)
+{
+    const char *prog_ver = GetProgramVersion();
+    if (strstr(prog_ver, "RELEASE") != NULL) {
+        return DOC_URL "suricata-" PROG_VER;
+    }
+    return DOC_URL "latest";
+}
+
 /** \brief get string with program version
  *
  *  Get the program version as passed to us from AC_INIT

diff --git a/src/suricata.h b/src/suricata.h
index 1b4111610b5de42be816ed6afeff60341224786e..3aa2406afc8e400c0f9b073d233a851a1b117d25 100644 (file)
--- a/src/suricata.h
+++ b/src/suricata.h
@@ -84,12 +84,7 @@
 #define DEFAULT_PID_FILENAME DEFAULT_PID_DIR DEFAULT_PID_BASENAME
 
 #define DOC_URL "https://suricata.readthedocs.io/en/"
-
-#if defined RELEASE
-#define DOC_VERSION "suricata-" PROG_VER
-#else
-#define DOC_VERSION "latest"
-#endif
+const char *GetDocURL(void);
 
 /* runtime engine control flags */
 #define SURICATA_STOP    (1 << 0)   /**< gracefully stop the engine: process all