Style and cruft
authorArt Cancro <ajc@citadel.org>
Fri, 16 Feb 2018 17:09:48 +0000 (12:09 -0500)
committerArt Cancro <ajc@citadel.org>
Fri, 16 Feb 2018 17:09:48 +0000 (12:09 -0500)
libcitadel/lib/json.c
libcitadel/lib/tools.c

index 63fcbdc..b166745 100644 (file)
@@ -1,8 +1,7 @@
-/**
- * \defgroup Subst Variable substitution type stuff
- * \ingroup CitadelConfig
+/*
+ * JSON data type and serializer for Citadel
  *
- * Copyright (c) 1987-2011 by the citadel.org team
+ * Copyright (c) 1987-2018 by the citadel.org team
  *
  * This program is open source software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,8 +18,6 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 
-/*@{*/
-
 #include "sysdep.h"
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
-
 #include "libcitadel.h"
 
-
 #define JSON_STRING 0
 #define JSON_NUM 1
 #define JSON_NULL 2
@@ -41,7 +36,8 @@
 #define JSON_ARRAY 4
 #define JSON_OBJECT 7
 
-struct JsonValue {
+struct JsonValue
+{
        int Type;
        StrBuf *Name;
        StrBuf *Value;
@@ -58,6 +54,7 @@ void DeleteJSONValue(void *vJsonValue)
        free(Val);
 }
 
+
 JsonValue *NewJsonObject(const char *Key, long keylen)
 {
        JsonValue *Ret;
@@ -66,11 +63,14 @@ JsonValue *NewJsonObject(const char *Key, long keylen)
        memset(Ret, 0, sizeof(JsonValue));
        Ret->Type = JSON_OBJECT;
        if (Key != NULL)
+       {
                Ret->Name = NewStrBufPlain(Key, keylen);
+       }
        Ret->SubValues = NewHash(1, NULL);
        return Ret;
 }
 
+
 JsonValue *NewJsonArray(const char *Key, long keylen)
 {
        JsonValue *Ret;
@@ -79,7 +79,9 @@ JsonValue *NewJsonArray(const char *Key, long keylen)
        memset(Ret, 0, sizeof(JsonValue));
        Ret->Type = JSON_ARRAY;
        if (Key != NULL)
+       {
                Ret->Name = NewStrBufPlain(Key, keylen);
+       }
        Ret->SubValues = NewHash(1, lFlathash);
        return Ret;
 }
@@ -93,14 +95,15 @@ JsonValue *NewJsonNumber(const char *Key, long keylen, long Number)
        memset(Ret, 0, sizeof(JsonValue));
        Ret->Type = JSON_NUM;
        if (Key != NULL)
+       {
                Ret->Name = NewStrBufPlain(Key, keylen);
+       }
        Ret->Value = NewStrBufPlain(NULL, 64);
        StrBufPrintf(Ret->Value, "%ld", Number);
        return Ret;
 }
 
 
-
 JsonValue *NewJsonBigNumber(const char *Key, long keylen, double Number)
 {
        JsonValue *Ret;
@@ -109,12 +112,15 @@ JsonValue *NewJsonBigNumber(const char *Key, long keylen, double Number)
        memset(Ret, 0, sizeof(JsonValue));
        Ret->Type = JSON_NUM;
        if (Key != NULL)
+       {
                Ret->Name = NewStrBufPlain(Key, keylen);
+       }
        Ret->Value = NewStrBufPlain(NULL, 128);
        StrBufPrintf(Ret->Value, "%f", Number);
        return Ret;
 }
 
+
 JsonValue *NewJsonString(const char *Key, long keylen, StrBuf *CopyMe)
 {
        JsonValue *Ret;
@@ -123,11 +129,14 @@ JsonValue *NewJsonString(const char *Key, long keylen, StrBuf *CopyMe)
        memset(Ret, 0, sizeof(JsonValue));
        Ret->Type = JSON_STRING;
        if (Key != NULL)
+       {
                Ret->Name = NewStrBufPlain(Key, keylen);
+       }
        Ret->Value = NewStrBufDup(CopyMe);
        return Ret;
 }
 
+
 JsonValue *NewJsonPlainString(const char *Key, long keylen, const char *CopyMe, long len)
 {
        JsonValue *Ret;
@@ -136,11 +145,14 @@ JsonValue *NewJsonPlainString(const char *Key, long keylen, const char *CopyMe,
        memset(Ret, 0, sizeof(JsonValue));
        Ret->Type = JSON_STRING;
        if (Key != NULL)
+       {
                Ret->Name = NewStrBufPlain(Key, keylen);
+       }
        Ret->Value = NewStrBufPlain(CopyMe, len);
        return Ret;
 }
 
+
 JsonValue *NewJsonNull(const char *Key, long keylen)
 {
        JsonValue *Ret;
@@ -149,11 +161,14 @@ JsonValue *NewJsonNull(const char *Key, long keylen)
        memset(Ret, 0, sizeof(JsonValue));
        Ret->Type = JSON_NULL;
        if (Key != NULL)
+       {
                Ret->Name = NewStrBufPlain(Key, keylen);
+       }
        Ret->Value = NewStrBufPlain(HKEY("nulll"));
        return Ret;
 }
 
+
 JsonValue *NewJsonBool(const char *Key, long keylen, int value)
 {
        JsonValue *Ret;
@@ -162,36 +177,43 @@ JsonValue *NewJsonBool(const char *Key, long keylen, int value)
        memset(Ret, 0, sizeof(JsonValue));
        Ret->Type = JSON_BOOL;
        if (Key != NULL)
+       {
                Ret->Name = NewStrBufPlain(Key, keylen);
-       if (value)
+       }
+       if (value) {
                Ret->Value = NewStrBufPlain(HKEY("true"));
+       }
        else
+       {
                Ret->Value = NewStrBufPlain(HKEY("false"));
+       }
        return Ret;
 }
 
+
 void JsonArrayAppend(JsonValue *Array, JsonValue *Val)
 {
        long n;
        if (Array->Type != JSON_ARRAY)
-               return; /* todo assert! */
+       {
+               return;
+       }
 
        n = GetCount(Array->SubValues);
        Put(Array->SubValues, LKEY(n), Val, DeleteJSONValue);
 }
 
+
 void JsonObjectAppend(JsonValue *Array, JsonValue *Val)
 {
        if ((Array->Type != JSON_OBJECT) || (Val->Name == NULL))
-               return; /* todo assert! */
-
+       {
+               return;
+       }
        Put(Array->SubValues, SKEY(Val->Name), Val, DeleteJSONValue);
 }
 
 
-
-
-
 void SerializeJson(StrBuf *Target, JsonValue *Val, int FreeVal)
 {
        void *vValue, *vPrevious;
@@ -201,7 +223,8 @@ void SerializeJson(StrBuf *Target, JsonValue *Val, int FreeVal)
        long keylen;
 
 
-       switch (Val->Type) {
+       switch (Val->Type)
+       {
        case JSON_STRING:
                StrBufAppendBufPlain(Target, HKEY("\""), 0);
                StrECMAEscAppend(Target, Val->Value, NULL);
@@ -220,13 +243,12 @@ void SerializeJson(StrBuf *Target, JsonValue *Val, int FreeVal)
                vPrevious = NULL;
                StrBufAppendBufPlain(Target, HKEY("["), 0);
                It = GetNewHashPos(Val->SubValues, 0);
-               while (GetNextHashPos(Val->SubValues, 
-                                     It,
-                                     &keylen, &Key, 
-                                     &vValue)){
+               while (GetNextHashPos(Val->SubValues, It, &keylen, &Key, &vValue))
+               {
                        if (vPrevious != NULL) 
+                       {
                                StrBufAppendBufPlain(Target, HKEY(","), 0);
-
+                       }
                        SubVal = (JsonValue*) vValue;
                        SerializeJson(Target, SubVal, 0);
                        vPrevious = vValue;
@@ -238,13 +260,12 @@ void SerializeJson(StrBuf *Target, JsonValue *Val, int FreeVal)
                vPrevious = NULL;
                StrBufAppendBufPlain(Target, HKEY("{"), 0);
                It = GetNewHashPos(Val->SubValues, 0);
-               while (GetNextHashPos(Val->SubValues, 
-                                     It,
-                                     &keylen, &Key, 
-                                     &vValue)){
+               while (GetNextHashPos(Val->SubValues, It, &keylen, &Key, &vValue))
+               {
                        SubVal = (JsonValue*) vValue;
 
-                       if (vPrevious != NULL) {
+                       if (vPrevious != NULL)
+                       {
                                StrBufAppendBufPlain(Target, HKEY(","), 0);
                        }
                        StrBufAppendBufPlain(Target, HKEY("\""), 0);
@@ -258,9 +279,8 @@ void SerializeJson(StrBuf *Target, JsonValue *Val, int FreeVal)
                DeleteHashPos(&It);
                break;
        }
-       if(FreeVal) {
+       if (FreeVal)
+       {
                DeleteJSONValue(Val);
        }
 }
-
-
index c93758e..b50cd66 100644 (file)
@@ -65,7 +65,8 @@ int safestrncpy(char *dest, const char *src, size_t n)
 {
        int i = 0;
 
-       if (dest == NULL || src == NULL) {
+       if (dest == NULL || src == NULL)
+       {
                fprintf(stderr, "safestrncpy: NULL argument\n");
                abort();
        }
@@ -80,7 +81,6 @@ int safestrncpy(char *dest, const char *src, size_t n)
 }
 
 
-
 /*
  * num_tokens()  -  discover number of parameters/tokens in a string
  */
@@ -89,12 +89,15 @@ int num_tokens(const char *source, char tok)
        int count = 1;
        const char *ptr = source;
 
-       if (source == NULL) {
+       if (source == NULL)
+       {
                return (0);
        }
 
-       while (*ptr != '\0') {
-               if (*ptr++ == tok) {
+       while (*ptr != '\0')
+       {
+               if (*ptr++ == tok)
+               {
                        ++count;
                }
        }
@@ -102,8 +105,6 @@ int num_tokens(const char *source, char tok)
        return (count);
 }
 
-//extern void cit_backtrace(void);
-
 
 /*
  * extract_token() - a string tokenizer
@@ -117,88 +118,45 @@ long extract_token(char *dest, const char *source, int parmnum, char separator,
 
        s = source;
 
-       if (dest == NULL) {
+       if (dest == NULL)
+       {
                return(-1);
        }
 
-       //cit_backtrace();
-       //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
        dest[0] = 0;
 
-       if (s == NULL) {
+       if (s == NULL)
+       {
                return(-1);
        }
        
        maxlen--;
 
-       while (*s) {
-               if (*s == separator) {
+       while (*s)
+       {
+               if (*s == separator)
+               {
                        ++current_token;
                }
-               if ( (current_token == parmnum) && 
-                    (*s != separator) && 
-                    (len < maxlen) ) {
+               if ( (current_token == parmnum) && (*s != separator) && (len < maxlen) )
+               {
                        dest[len] = *s;
                        ++len;
                }
-               else if ((current_token > parmnum) || (len >= maxlen)) {
+               else if ((current_token > parmnum) || (len >= maxlen))
+               {
                        break;
                }
                ++s;
        }
 
        dest[len] = '\0';
-       if (current_token < parmnum) {
-               //lprintf (CTDL_DEBUG,"test <!: %s\n", dest);
+       if (current_token < parmnum)
+       {
                return(-1);
        }
-       //lprintf (CTDL_DEBUG,"test <: %d; %s\n", len, dest);
        return(len);
 }
-//*/
-
-
-/*
- * extract_token() - a string tokenizer
- * /
-long extract_token(char *dest, const char *source, int parmnum, char separator, int maxlen)
-{
-       char *d;                // dest
-       const char *s;          // source
-       int count = 0;
-       int len = 0;
-
-       
-       //cit_backtrace();
-       //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
-       strcpy(dest, "");
-
-       //  Locate desired parameter 
-       s = source;
-       while (count < parmnum) {
-               //  End of string, bail!
-               if (!*s) {
-                       s = NULL;
-                       break;
-               }
-               if (*s == separator) {
-                       count++;
-               }
-               s++;
-       }
-       if (!s) {
-               //lprintf (CTDL_DEBUG,"test <!: %s\n", dest);
-               return -1;              // Parameter not found
-       }
-       
-       for (d = dest; *s && *s != separator && ++len<maxlen; s++, d++) {
-               *d = *s;
-       }
-       *d = 0;
-       //lprintf (CTDL_DEBUG,"test <: %d; %s\n", len, dest);
-       return 0;
-}
-*/
 
 
 /*
@@ -211,13 +169,15 @@ void remove_token(char *source, int parmnum, char separator)
 
        /* Find desired parameter */
        d = source;
-       while (count < parmnum) {
+       while (count < parmnum)
+       {
                /* End of string, bail! */
                if (!*d) {
                        d = NULL;
                        break;
                }
-               if (*d == separator) {
+               if (*d == separator)
+               {
                        count++;
                }
                d++;
@@ -226,7 +186,8 @@ void remove_token(char *source, int parmnum, char separator)
 
        /* Find next parameter */
        s = d;
-       while (*s && *s != separator) {
+       while (*s && *s != separator)
+       {
                s++;
        }
 
@@ -237,12 +198,6 @@ void remove_token(char *source, int parmnum, char separator)
                *d = 0;
        else
                *--d = 0;
-       /*
-       while (*s) {
-               *d++ = *s++;
-       }
-       *d = 0;
-       */
 }
 
 
@@ -259,6 +214,7 @@ int extract_int(const char *source, int parmnum)
                return 0;
 }
 
+
 /*
  * extract_long()  -  extract an long parm w/o supplying a buffer
  */
@@ -286,10 +242,10 @@ unsigned long extract_unsigned_long(const char *source, int parmnum)
                return 0;
 }
 
+
 size_t CtdlEncodeBase64(char *dest, const char *source, size_t sourcelen, int linebreaks)
 {
-       // linebreaks at 70 are ugly for base64, since 3 bytes in makes 4 bytes out
-       int breaklength = 68;
+       int breaklength = 68;   // must be a multiple of 4
        int readlength = 3 * breaklength / 4;
 
        int destoffset;
@@ -405,6 +361,7 @@ void StripSlashes(char *Dir, int TrailingSlash)
 
 }
 
+
 /*
  * Strip leading and trailing spaces from a string
  */
@@ -439,11 +396,11 @@ size_t striplt(char *buf) {
 }
 
 
-/**
- * \brief check for the presence of a character within a string (returns count)
- * \param st the string to examine
- * \param ch the char to search
- * \return the number of times ch appears in st
+/*
+ * check for the presence of a character within a string (returns count)
+ * st  the string to examine
+ * ch  the char to search
+ * returns the number of times ch appears in st
  */
 int haschar(const char *st, int ch)
 {
@@ -465,7 +422,8 @@ int haschar(const char *st, int ch)
  * Determine whether the specified message number is contained within the
  * specified sequence set.
  */
-int is_msg_in_sequence_set(const char *mset, long msgnum) {
+int is_msg_in_sequence_set(const char *mset, long msgnum)
+{
        int num_sets;
        int s;
        char setstr[128], lostr[128], histr[128];
@@ -476,13 +434,16 @@ int is_msg_in_sequence_set(const char *mset, long msgnum) {
                extract_token(setstr, mset, s, ',', sizeof setstr);
 
                extract_token(lostr, setstr, 0, ':', sizeof lostr);
-               if (num_tokens(setstr, ':') >= 2) {
+               if (num_tokens(setstr, ':') >= 2)
+               {
                        extract_token(histr, setstr, 1, ':', sizeof histr);
-                       if (!strcmp(histr, "*")) {
+                       if (!strcmp(histr, "*"))
+                       {
                                snprintf(histr, sizeof histr, "%ld", LONG_MAX);
                        }
                } 
-               else {
+               else
+               {
                        strcpy(histr, lostr);
                }
                lo = atol(lostr);
@@ -494,18 +455,18 @@ int is_msg_in_sequence_set(const char *mset, long msgnum) {
        return(0);
 }
 
-/** 
- * \brief Utility function to "readline" from memory
- * \param start Location in memory from which we are reading.
- * \param buf the buffer to place the string in.
- * \param maxlen Size of string buffer
- * \return Pointer to the source memory right after we stopped reading.
+/* 
+ * Utility function to "readline" from memory
+ * start       Location in memory from which we are reading.
+ * buf         the buffer to place the string in.
+ * maxlen      Size of string buffer
+ * returns pointer to the source memory right after we stopped reading.
  */
 char *memreadline(char *start, char *buf, int maxlen)
 {
        char ch;
        char *ptr;
-       int len = 0;            /**< tally our own length to avoid strlen() delays */
+       int len = 0;            /* tally our own length to avoid strlen() delays */
 
        ptr = start;
 
@@ -522,28 +483,31 @@ char *memreadline(char *start, char *buf, int maxlen)
 }
 
 
-/*
- * \brief Utility function to "readline" from memory
- * \param start Location in memory from which we are reading.
- * \param buf the buffer to place the string in.
- * \param maxlen Size of string buffer
- * \param retlen the length of the returned string
- * \return Pointer to the source memory right after we stopped reading.
+/*
+ * Utility function to "readline" from memory
+ * start       Location in memory from which we are reading.
+ * buf         the buffer to place the string in.
+ * maxlen      Size of string buffer
+ * retlen      the length of the returned string
+ * returns a pointer to the source memory right after we stopped reading.
  */
 char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen)
 {
        char ch;
        char *ptr;
-       int len = 0;            /**< tally our own length to avoid strlen() delays */
+       int len = 0;            /* tally our own length to avoid strlen() delays */
 
        ptr = start;
 
-       while (1) {
+       while (1)
+       {
                ch = *ptr++;
-               if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
+               if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10))
+               {
                        buf[len++] = ch;
                }
-               if ((ch == 10) || (ch == 0)) {
+               if ((ch == 10) || (ch == 0))
+               {
                        buf[len] = 0;
                        *retlen = len;
                        return ptr;