Changeset 537d9b9 for lib

Timestamp:

2016-11-20T08:40:36Z (8 years ago)

Author:

dequis <dx@…>

Children:

3f44e43

Parents:

ba52ac5 (diff), 9f03c47 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge master up to commit '9f03c47' into parson

Location:

lib

Files:

• http_client.c (modified) (1 diff)
• misc.c (modified) (3 diffs)
• misc.h (modified) (1 diff)
• proxy.c (modified) (5 diffs)
• sha1.c (modified) (3 diffs)
• ssl_gnutls.c (modified) (2 diffs)
• ssl_openssl.c (modified) (1 diff)

lib/http_client.c

@@ -95 +95 @@
         request = g_strdup_printf("GET %s HTTP/1.0\r\n"
                                   "Host: %s\r\n"
-                                  "User-Agent: BitlBee " BITLBEE_VERSION " " ARCH "/" CPU "\r\n"
+                                  "User-Agent: BitlBee " BITLBEE_VERSION "\r\n"
                                   "\r\n", url->file, url->host);
 

lib/misc.c

@@ -549 +549 @@
 }
 
-/* Word wrapping. Yes, I know this isn't UTF-8 clean. I'm willing to take the risk. */
 char *word_wrap(const char *msg, int line_len)
 {
@@ -582 +581 @@
                 }
                 if (i == 0) {
-                        g_string_append_len(ret, msg, line_len);
+                        const char *end;
+                        size_t len;
+
+                        g_utf8_validate(msg, line_len, &end);
+
+                        len = (end != msg) ? end - msg : line_len;
+
+                        g_string_append_len(ret, msg, len);
                         g_string_append_c(ret, '\n');
-                        msg += line_len;
+                        msg += len;
                 }
         }
@@ -787 +793 @@
         return string;
 }
+
+/* Returns a string that is exactly 'char_len' utf8 characters long (not bytes),
+ * padded to the right with spaces or truncated with the 'ellipsis' parameter
+ * if specified (can be NULL).
+ * Returns a newly allocated string, or NULL on invalid parameters. */
+char *str_pad_and_truncate(const char *string, long char_len, const char *ellipsis)
+{
+        size_t string_len = strlen(string);
+        size_t ellipsis_len = (ellipsis) ? strlen(ellipsis) : 0;
+        long orig_len = g_utf8_strlen(string, -1);
+
+        g_return_val_if_fail(char_len > ellipsis_len, NULL);
+
+        if (orig_len > char_len) {
+                char *ret = g_malloc(string_len + 1);
+                g_utf8_strncpy(ret, string, char_len - ellipsis_len);
+                if (ellipsis) {
+                        g_strlcat(ret, ellipsis, string_len);
+                }
+                return ret;
+        } else if (orig_len < char_len) {
+                return g_strdup_printf("%s%*s", string, (int) (char_len - orig_len), "");
+        } else {
+                return g_strdup(string);
+        }
+}

lib/misc.h

@@ -151 +151 @@
 G_MODULE_EXPORT gboolean parse_int64(char *string, int base, guint64 *number);
 G_MODULE_EXPORT char *str_reject_chars(char *string, const char *reject, char replacement);
+G_MODULE_EXPORT char *str_pad_and_truncate(const char *string, long char_len, const char *ellipsis);
 
 #endif

lib/proxy.c

@@ -87 +87 @@
 }
 
+/* calls phb->func safely by ensuring that the phb struct doesn't exist in the
+ * case that proxy_disconnect() is called down there */
+static gboolean phb_connected(struct PHB *phb, gint source)
+{
+        /* save func and data here */
+        b_event_handler func = phb->func;
+        gpointer data = phb->data;
+
+        /* free the struct so that it can't be freed by the callback */
+        phb_free(phb, TRUE);
+
+        /* if any proxy_disconnect() call happens here, it will use the
+         * fd (still open), look it up in the hash table, get NULL, and
+         * proceed to close the fd and do nothing else */
+        func(data, source, B_EV_IO_READ);
+
+        return FALSE;
+}
+
 static gboolean proxy_connected(gpointer data, gint source, b_input_condition cond)
 {
@@ -125 +144 @@
                 phb->proxy_func(phb->proxy_data, source, B_EV_IO_READ);
         } else {
-                phb->func(phb->data, source, B_EV_IO_READ);
-                phb_free(phb, TRUE);
+                phb_connected(phb, source);
         }
 
@@ -222 +240 @@
         if ((memcmp(HTTP_GOODSTRING, inputline, strlen(HTTP_GOODSTRING)) == 0) ||
             (memcmp(HTTP_GOODSTRING2, inputline, strlen(HTTP_GOODSTRING2)) == 0)) {
-                phb->func(phb->data, source, B_EV_IO_READ);
-                return phb_free(phb, TRUE);
+                return phb_connected(phb, source);
         }
 
@@ -295 +312 @@
         memset(packet, 0, sizeof(packet));
         if (read(source, packet, 9) >= 4 && packet[1] == 90) {
-                phb->func(phb->data, source, B_EV_IO_READ);
-                return phb_free(phb, TRUE);
+                return phb_connected(phb, source);
         }
 
@@ -384 +400 @@
         }
 
-        phb->func(phb->data, source, B_EV_IO_READ);
-        return phb_free(phb, TRUE);
+        return phb_connected(phb, source);
 }
 

lib/sha1.c

@@ -24 +24 @@
 #define HMAC_BLOCK_SIZE 64
 
-/* BitlBee addition: */
-void sha1_hmac(const char *key_, size_t key_len, const char *payload, size_t payload_len, guint8 digest[SHA1_HASH_SIZE])
+void b_hmac(GChecksumType checksum_type, const char *key_, size_t key_len,
+            const char *payload, size_t payload_len, guint8 **digest)
 {
-        sha1_state_t sha1;
-        guint8 hash[SHA1_HASH_SIZE];
+        GChecksum *checksum;
+        size_t hash_len;
+        guint8 *hash;
         guint8 key[HMAC_BLOCK_SIZE + 1];
         int i;
+
+        hash_len = g_checksum_type_get_length(checksum_type);
+
+        if (hash_len == (size_t) -1) {
+                return;
+        }
+
+        hash = g_malloc(hash_len);
 
         if (key_len == 0) {
@@ -43 +52 @@
         memset(key, 0, HMAC_BLOCK_SIZE + 1);
         if (key_len > HMAC_BLOCK_SIZE) {
-                sha1_init(&sha1);
-                sha1_append(&sha1, (guint8 *) key_, key_len);
-                sha1_finish(&sha1, key);
+                checksum = g_checksum_new(checksum_type);
+                g_checksum_update(checksum, (guint8 *) key_, key_len);
+                g_checksum_get_digest(checksum, key, &hash_len);
+                g_checksum_free(checksum);
         } else {
                 memcpy(key, key_, key_len);
@@ -51 +61 @@
 
         /* Inner part: H(K XOR 0x36, text) */
-        sha1_init(&sha1);
+        checksum = g_checksum_new(checksum_type);
         for (i = 0; i < HMAC_BLOCK_SIZE; i++) {
                 key[i] ^= 0x36;
         }
-        sha1_append(&sha1, key, HMAC_BLOCK_SIZE);
-        sha1_append(&sha1, (const guint8 *) payload, payload_len);
-        sha1_finish(&sha1, hash);
+        g_checksum_update(checksum, key, HMAC_BLOCK_SIZE);
+        g_checksum_update(checksum, (const guint8 *) payload, payload_len);
+        g_checksum_get_digest(checksum, hash, &hash_len);
+        g_checksum_free(checksum);
 
         /* Final result: H(K XOR 0x5C, inner stuff) */
-        sha1_init(&sha1);
+        checksum = g_checksum_new(checksum_type);
         for (i = 0; i < HMAC_BLOCK_SIZE; i++) {
                 key[i] ^= 0x36 ^ 0x5c;
         }
-        sha1_append(&sha1, key, HMAC_BLOCK_SIZE);
-        sha1_append(&sha1, hash, SHA1_HASH_SIZE);
-        sha1_finish(&sha1, digest);
+        g_checksum_update(checksum, key, HMAC_BLOCK_SIZE);
+        g_checksum_update(checksum, hash, hash_len);
+        g_checksum_get_digest(checksum, *digest, &hash_len);
+        g_checksum_free(checksum);
+
+        g_free(hash);
 }
+
+void sha1_hmac(const char *key_, size_t key_len, const char *payload, size_t payload_len, guint8 digest[SHA1_HASH_SIZE])
+{
+        b_hmac(G_CHECKSUM_SHA1, key_, key_len, payload, payload_len, &digest);
+}
+
 
 /* I think this follows the scheme described on:

lib/ssl_gnutls.c

@@ -42 +42 @@
 #include <limits.h>
 
-#if defined(ULONG_MAX) && ULONG_MAX > 4294967295UL
-#define GNUTLS_STUPID_CAST (long)
-#else
-#define GNUTLS_STUPID_CAST (int)
-#endif
-
 #define SSLDEBUG 0
 
@@ -335 +329 @@
 
         sock_make_nonblocking(conn->fd);
-        gnutls_transport_set_ptr(conn->session, (gnutls_transport_ptr_t) GNUTLS_STUPID_CAST conn->fd);
+        gnutls_transport_set_ptr(conn->session, (gnutls_transport_ptr_t) (long) conn->fd);
 
         ssl_cache_resume(conn);

lib/ssl_openssl.c

@@ -67 +67 @@
         SSL_library_init();
 
-        meth = TLSv1_client_method();
+        meth = SSLv23_client_method();
         ssl_ctx = SSL_CTX_new(meth);
+        SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
 
         initialized = TRUE;