Initial import.

util.c

@@ -0,0 +1,270 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2016-2017 XMRig       <support@xmrig.com>
+ *
+ *
+ *   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, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+#include "util.h"
+#include "elist.h"
+#include "utils/applog.h"
+
+
+struct tq_ent {
+    void *data;
+    struct list_head q_node;
+};
+
+
+struct thread_q {
+    struct list_head q;
+    bool frozen;
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+};
+
+
+json_t *json_decode(const char *s)
+{
+    json_error_t err;
+    json_t *val = json_loads(s, 0, &err);
+
+    if (!val) {
+        applog(LOG_ERR, "JSON decode failed(%d): %s", err.line, err.text);
+    }
+
+    return val;
+}
+
+
+/**
+ * @brief bin2hex
+ * @param p
+ * @param len
+ * @return
+ */
+char *bin2hex(const unsigned char *p, size_t len)
+{
+    char *s = malloc((len * 2) + 1);
+    if (!s) {
+        return NULL;
+    }
+
+    for (int i = 0; i < len; i++) {
+        sprintf(s + (i * 2), "%02x", (unsigned int) p[i]);
+    }
+
+    return s;
+}
+
+
+/**
+ * @brief hex2bin
+ * @param p
+ * @param hexstr
+ * @param len
+ * @return
+ */
+bool hex2bin(unsigned char *p, const char *hexstr, size_t len)
+{
+    char hex_byte[3];
+    char *ep;
+
+    hex_byte[2] = '\0';
+
+    while (*hexstr && len) {
+        if (!hexstr[1]) {
+            applog(LOG_ERR, "hex2bin str truncated");
+            return false;
+        }
+
+        hex_byte[0] = hexstr[0];
+        hex_byte[1] = hexstr[1];
+        *p = (unsigned char) strtol(hex_byte, &ep, 16);
+        if (*ep) {
+            applog(LOG_ERR, "hex2bin failed on '%s'", hex_byte);
+            return false;
+        }
+
+        p++;
+        hexstr += 2;
+        len--;
+    }
+
+    return (len == 0 && *hexstr == 0) ? true : false;
+}
+
+
+/**
+ * @brief tq_new
+ * @return
+ */
+struct thread_q *tq_new(void)
+{
+    struct thread_q *tq;
+
+    tq = calloc(1, sizeof(*tq));
+    if (!tq)
+        return NULL;
+
+    INIT_LIST_HEAD(&tq->q);
+    pthread_mutex_init(&tq->mutex, NULL);
+    pthread_cond_init(&tq->cond, NULL);
+
+    return tq;
+}
+
+
+/**
+ * @brief tq_free
+ * @param tq
+ */
+void tq_free(struct thread_q *tq)
+{
+    struct tq_ent *ent, *iter;
+
+    if (!tq)
+        return;
+
+    list_for_each_entry_safe(ent, iter, &tq->q, q_node) {
+        list_del(&ent->q_node);
+        free(ent);
+    }
+
+    pthread_cond_destroy(&tq->cond);
+    pthread_mutex_destroy(&tq->mutex);
+
+    memset(tq, 0, sizeof(*tq)); /* poison */
+    free(tq);
+}
+
+
+/**
+ * @brief tq_freezethaw
+ * @param tq
+ * @param frozen
+ */
+static void tq_freezethaw(struct thread_q *tq, bool frozen)
+{
+    pthread_mutex_lock(&tq->mutex);
+
+    tq->frozen = frozen;
+
+    pthread_cond_signal(&tq->cond);
+    pthread_mutex_unlock(&tq->mutex);
+}
+
+
+/**
+ * @brief tq_freeze
+ * @param tq
+ */
+void tq_freeze(struct thread_q *tq)
+{
+    tq_freezethaw(tq, true);
+}
+
+
+/**
+ * @brief tq_thaw
+ * @param tq
+ */
+void tq_thaw(struct thread_q *tq)
+{
+    tq_freezethaw(tq, false);
+}
+
+
+/**
+ * @brief tq_push
+ * @param tq
+ * @param data
+ * @return
+ */
+bool tq_push(struct thread_q *tq, void *data)
+{
+    struct tq_ent *ent;
+    bool rc = true;
+
+    ent = calloc(1, sizeof(*ent));
+    if (!ent)
+        return false;
+
+    ent->data = data;
+    INIT_LIST_HEAD(&ent->q_node);
+
+    pthread_mutex_lock(&tq->mutex);
+
+    if (!tq->frozen) {
+        list_add_tail(&ent->q_node, &tq->q);
+    } else {
+        free(ent);
+        rc = false;
+    }
+
+    pthread_cond_signal(&tq->cond);
+    pthread_mutex_unlock(&tq->mutex);
+
+    return rc;
+}
+
+
+/**
+ * @brief tq_pop
+ * @param tq
+ * @param abstime
+ * @return
+ */
+void *tq_pop(struct thread_q *tq, const struct timespec *abstime)
+{
+    struct tq_ent *ent;
+    void *rval = NULL;
+    int rc;
+
+    pthread_mutex_lock(&tq->mutex);
+
+    if (!list_empty(&tq->q))
+        goto pop;
+
+    if (abstime)
+        rc = pthread_cond_timedwait(&tq->cond, &tq->mutex, abstime);
+    else
+        rc = pthread_cond_wait(&tq->cond, &tq->mutex);
+    if (rc)
+        goto out;
+    if (list_empty(&tq->q))
+        goto out;
+
+pop:
+    ent = list_entry(tq->q.next, struct tq_ent, q_node);
+    rval = ent->data;
+
+    list_del(&ent->q_node);
+    free(ent);
+
+out:
+    pthread_mutex_unlock(&tq->mutex);
+    return rval;
+}