Removed PCRE dependency when linking to libutils

cf-upgrade refused to link to libutils without -lcrypto and -lpcre. The
PCRE dependency has been removed in this patch, OpenSSL dependency is
still TODO though.

cf-agent/match_scope.c

@@ -26,7 +26,9 @@
 
 #include <matching.h>
 #include <eval_context.h>
-#include <string_lib.h>
+#include <string_lib.h>                                   /* StringFromLong */
+#include <regex.h>                                        /* CompileRegex */
+
 
 /* Sets variables */
 static int RegExMatchSubString(EvalContext *ctx, pcre *rx, const char *teststring, int *start, int *end)

cf-serverd/server_access.h

@@ -7,8 +7,9 @@
 
 #include <platform.h>
 
-#include <map.h>                                          /* StringMap */
-#include "strlist.h"                                      /* StrList */
+#include <map.h>                                         /* StringMap */
+#include <regex.h>                                       /* StringMatchFull */
+#include "strlist.h"                                     /* StrList */
 
 
 /**

cf-serverd/server_classic.c

@@ -8,6 +8,7 @@
 #include <net.h>                      /* ReceiveTransaction,SendTransaction */
 #include <signals.h>
 #include <string_lib.h>                               /* ToLowerStrInplace */
+#include <regex.h>                                    /* StringMatchFull */
 #include <lastseen.h>                                 /* LastSaw1 */
 #include <files_hashes.h>                             /* HashString */
 #include <crypto.h>                                   /* HavePublicKey */

cf-serverd/server_common.c

@@ -30,6 +30,7 @@ static const int CF_NOSIZE = -1;
 
 #include <item_lib.h>                                 /* ItemList2CSV_bound */
 #include <string_lib.h>                               /* ToLower */
+#include <regex.h>                                    /* StringMatchFull */
 #include <crypto.h>                                   /* EncryptString */
 #include <files_names.h>
 #include <files_interfaces.h>

cf-serverd/server_tls.c

@@ -37,7 +37,7 @@
 #include <tls_generic.h>              /* TLSSend */
 #include <cf-serverd-enterprise-stubs.h>
 #include <connection_info.h>
-#include <string_lib.h>                                  /* StringMatchFull */
+#include <regex.h>                                       /* StringMatchFull */
 #include <known_dirs.h>
 #include <file_lib.h>                                           /* IsDirReal */
 

libenv/sysinfo.c

@@ -37,6 +37,7 @@
 #include <systype.h>
 #include <unix.h>
 #include <string_lib.h>
+#include <regex.h>                                       /* StringMatchFull */
 #include <misc_lib.h>
 #include <file_lib.h>
 #include <rlist.h>

libenv/unix_iface.c

@@ -30,6 +30,7 @@
 #include <misc_lib.h>
 #include <communication.h>
 #include <string_lib.h>
+#include <regex.h>                                       /* StringMatchFull */
 
 #ifdef HAVE_SYS_JAIL_H
 # include <sys/jail.h>

libpromises/class.c

@@ -2,9 +2,11 @@
 
 #include <rb-tree.h>
 #include <alloc.h>
-#include <string_lib.h>
+#include <string_lib.h> /* StringHash,StringConcatenate */
+#include <regex.h>      /* CompileRegex,StringMatchFullWithPrecompiledRegex */
 #include <files_names.h>
 
+
 struct ClassTable_
 {
     RBTree *classes;

libpromises/evalfunction.c

@@ -44,6 +44,7 @@
 #include <hashes.h>
 #include <unix.h>
 #include <string_lib.h>
+#include <regex.h>          /* CompileRegex,StringMatchWithPrecompiledRegex */
 #include <net.h>                                           /* SocketConnect */
 #include <communication.h>
 #include <classic.h>                                    /* SendSocketStream */

libpromises/item_lib.c

@@ -28,7 +28,7 @@
 #include <addr_lib.h>
 #include <matching.h>
 #include <misc_lib.h>
-#include <string_lib.h>
+#include <regex.h> /* StringMatchFull,CompileRegex,StringMatchWithPrecompiledRegex */
 #include <file_lib.h>
 #include <files_interfaces.h>
 

libpromises/matching.c

@@ -32,7 +32,7 @@
 #include <scope.h>
 #include <misc_lib.h>
 #include <rlist.h>
-#include <string_lib.h>
+#include <regex.h>                          /* CompileRegex,StringMatchFull */
 
 /* Pure, non-thread-safe */
 static char *FirstBackReference(pcre *rx, const char *teststring)

libpromises/processes_select.c

@@ -24,13 +24,15 @@
 
 #include <processes_select.h>
 
+#include <string.h>
+
 #include <eval_context.h>
 #include <files_names.h>
 #include <conversion.h>
 #include <matching.h>
 #include <systype.h>
-#include <string_lib.h>
-#include <string.h>
+#include <string_lib.h>                                         /* Chop */
+#include <regex.h> /* CompileRegex,StringMatchWithPrecompiledRegex,StringMatchFull */
 #include <item_lib.h>
 #include <pipes.h>
 #include <files_interfaces.h>

libpromises/rlist.c

@@ -30,7 +30,8 @@
 #include <matching.h>
 #include <scope.h>
 #include <fncall.h>
-#include <string_lib.h>
+#include <string_lib.h>                                       /* StringHash */
+#include <regex.h>          /* StringMatchWithPrecompiledRegex,CompileRegex */
 #include <mutex.h>
 #include <misc_lib.h>
 #include <assoc.h>

libpromises/syntax.c

@@ -33,7 +33,8 @@
 #include <matching.h>
 #include <scope.h>
 #include <fncall.h>
-#include <string_lib.h>
+#include <string_lib.h>                                  /* IsStrIn */
+#include <regex.h>                                       /* StringMatchFull */
 #include <misc_lib.h>
 #include <rlist.h>
 #include <vars.h>

libpromises/verify_classes.c

@@ -33,7 +33,8 @@
 #include <promises.h>
 #include <conversion.h>
 #include <logic_expressions.h>
-#include <string_lib.h>
+#include <string_lib.h>                                  /* StringHash */
+#include <regex.h>                                       /* StringMatchFull */
 
 
 static int EvalClassExpression(EvalContext *ctx, Constraint *cp, const Promise *pp);

libpromises/verify_vars.c

@@ -26,7 +26,7 @@
 
 #include <actuator.h>
 #include <attributes.h>
-#include <string_lib.h>
+#include <regex.h>      /* CompileRegex,StringMatchFullWithPrecompiledRegex */
 #include <buffer.h>
 #include <misc_lib.h>
 #include <fncall.h>

libutils/Makefile.am

@@ -44,6 +44,7 @@ libutils_la_SOURCES = \
 	hash.c hash.h \
 	queue.c queue.h \
 	ring_buffer.c ring_buffer.h \
+	regex.c regex.h \
 	printsize.h
 
 if !NT

libutils/json.c

@@ -28,6 +28,7 @@
 #include <string_lib.h>
 #include <file_lib.h>
 #include <printsize.h>
+#include <regex.h>
 
 #include <json.h>
 

libutils/regex.c

@@ -0,0 +1,203 @@
+/*
+   Copyright (C) CFEngine AS
+
+   This file is part of CFEngine 3 - written and maintained by CFEngine AS.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 3.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
+
+  To the extent this program is licensed as part of the Enterprise
+  versions of CFEngine, the applicable Commercial Open Source License
+  (COSL) may apply to this file if you as a licensee so wish it. See
+  included file COSL.txt.
+*/
+
+
+#include <platform.h>
+#include <regex.h>
+
+#include <alloc.h>
+#include <logging.h>
+#include <string_lib.h>
+
+
+#define STRING_MATCH_OVECCOUNT 30
+#define NULL_OR_EMPTY(str) ((str == NULL) || (str[0] == '\0'))
+
+
+pcre *CompileRegex(const char *regex)
+{
+    const char *errorstr;
+    int erroffset;
+
+    pcre *rx = pcre_compile(regex, PCRE_MULTILINE | PCRE_DOTALL,
+                            &errorstr, &erroffset, NULL);
+
+    if (!rx)
+    {
+        Log(LOG_LEVEL_ERR,
+            "Regular expression error: pcre_compile() '%s' in expression '%s' (offset: %d)",
+            errorstr, regex, erroffset);
+    }
+
+    return rx;
+}
+
+bool StringMatchWithPrecompiledRegex(pcre *regex, const char *str, int *start, int *end)
+{
+    assert(regex);
+    assert(str);
+
+    int ovector[STRING_MATCH_OVECCOUNT] = { 0 };
+    int result = pcre_exec(regex, NULL, str, strlen(str),
+                           0, 0, ovector, STRING_MATCH_OVECCOUNT);
+
+    if (result)
+    {
+        if (start)
+        {
+            *start = ovector[0];
+        }
+        if (end)
+        {
+            *end = ovector[1];
+        }
+    }
+    else
+    {
+        if (start)
+        {
+            *start = 0;
+        }
+        if (end)
+        {
+            *end = 0;
+        }
+    }
+
+    return result >= 0;
+}
+
+bool StringMatch(const char *regex, const char *str, int *start, int *end)
+{
+    pcre *pattern = CompileRegex(regex);
+
+    if (pattern == NULL)
+    {
+        return false;
+    }
+
+    bool ret = StringMatchWithPrecompiledRegex(pattern, str, start, end);
+
+    pcre_free(pattern);
+    return ret;
+
+}
+
+bool StringMatchFull(const char *regex, const char *str)
+{
+    pcre *pattern = CompileRegex(regex);
+
+    if (pattern == NULL)
+    {
+        return false;
+    }
+
+    bool ret = StringMatchFullWithPrecompiledRegex(pattern, str);
+
+    pcre_free(pattern);
+    return ret;
+}
+
+bool StringMatchFullWithPrecompiledRegex(pcre *pattern, const char *str)
+{
+    int start = 0, end = 0;
+
+    if (StringMatchWithPrecompiledRegex(pattern, str, &start, &end))
+    {
+        return (start == 0) && (end == strlen(str));
+    }
+    else
+    {
+        return false;
+    }
+}
+
+Seq *StringMatchCaptures(const char *regex, const char *str)
+{
+    assert(regex);
+    assert(str);
+
+    pcre *pattern = NULL;
+    {
+        const char *errorstr;
+        int erroffset;
+        pattern = pcre_compile(regex, PCRE_MULTILINE | PCRE_DOTALL,
+                               &errorstr, &erroffset, NULL);
+    }
+    assert(pattern);
+
+    if (pattern == NULL)
+    {
+        return NULL;
+    }
+
+    int captures;
+    int res = pcre_fullinfo(pattern, NULL, PCRE_INFO_CAPTURECOUNT, &captures);
+    if (res != 0)
+    {
+        pcre_free(pattern);
+        return NULL;
+    }
+
+    int *ovector = xmalloc(sizeof(int) * (captures + 1) * 3);
+
+    int result = pcre_exec(pattern, NULL, str, strlen(str),
+                           0, 0, ovector, (captures + 1) * 3);
+
+    if (result <= 0)
+    {
+        free(ovector);
+        pcre_free(pattern);
+        return NULL;
+    }
+
+    Seq *ret = SeqNew(captures + 1, free);
+    for (int i = 0; i <= captures; ++i)
+    {
+        SeqAppend(ret, xstrndup(str + ovector[2*i],
+                                ovector[2*i + 1] - ovector[2 * i]));
+    }
+    free(ovector);
+    pcre_free(pattern);
+    return ret;
+}
+
+bool CompareStringOrRegex(const char *value, const char *compareTo, bool regex)
+{
+    if (regex)
+    {
+        if (!NULL_OR_EMPTY(compareTo) && !StringMatchFull(compareTo, value))
+        {
+            return false;
+        }
+    }
+    else
+    {
+        if (!NULL_OR_EMPTY(compareTo)  && strcmp(compareTo, value) != 0)
+        {
+            return false;
+        }
+    }
+    return true;
+}