Fix serializing of hyperscan regexps

src/hs_helper.c

 	struct hs_helper_ctx *ctx = worker->ctx;
 	GError *err = NULL;
 	struct rspamd_srv_command srv_cmd;
+	gint ncompiled;
 
 	ctx->ev_base = rspamd_prepare_worker (worker,
 			"hs_helper",
 		msg_warn ("cannot cleanup cache dir '%s'", ctx->hs_dir);
 	}
 
-	if (!rspamd_re_cache_compile_hyperscan (ctx->cfg->re_cache,
+	if ((ncompiled = rspamd_re_cache_compile_hyperscan (ctx->cfg->re_cache,
 			ctx->hs_dir,
-			&err)) {
+			&err)) == -1) {
 		msg_err ("failed to compile re cache: %e", err);
 		g_error_free (err);
 
 		exit (EXIT_SUCCESS);
 	}
 
+	msg_info ("compiled %d regular expressions to the hyperscan tree",
+			ncompiled);
+
 	event_base_loop (ctx->ev_base, 0);
 	rspamd_worker_block_signals ();
 

src/libserver/re_cache.c

 	return ret;
 }
 
-gboolean
+gint
 rspamd_re_cache_compile_hyperscan (struct rspamd_re_cache *cache,
 		const char *cache_dir,
 		GError **err)
 
 #ifndef WITH_HYPERSCAN
 	g_set_error (err, rspamd_re_cache_quark (), EINVAL, "hyperscan is disabled");
-	return FALSE;
+	return -1;
 #else
 	GHashTableIter it, cit;
 	gpointer k, v;
 	guint *hs_flags = NULL;
 	const gchar **hs_pats = NULL;
 	gchar *hs_serialized;
-	gsize serialized_len;
+	gsize serialized_len, total = 0;
+	struct iovec iov[3];
 
 	g_hash_table_iter_init (&it, cache->re_classes);
 
 		if (fd == -1) {
 			g_set_error (err, rspamd_re_cache_quark (), errno, "cannot open file "
 					"%s: %s", path, strerror (errno));
-			return FALSE;
+			return -1;
 		}
 
 		g_hash_table_iter_init (&cit, re_class->re);
 				close (fd);
 				hs_free_compile_error (hs_errors);
 
-				return FALSE;
+				return -1;
 			}
 
 			g_free (hs_flags);
-			g_free (hs_ids);
 			g_free (hs_pats);
 
 			if (hs_serialize_database (test_db, &hs_serialized,
 						re_class->hash);
 
 				close (fd);
+				g_free (hs_ids);
 				hs_free_database (test_db);
 
-				return FALSE;
+				return -1;
 			}
 
 			hs_free_database (test_db);
 
-			if (write (fd, hs_serialized, serialized_len) != (gssize)serialized_len) {
+			/* Write N, then all ID's and then the compiled structure */
+			iov[0].iov_base = &n;
+			iov[0].iov_len = sizeof (n);
+			iov[1].iov_base = hs_ids;
+			iov[1].iov_len = sizeof (*hs_ids) * n;
+			iov[2].iov_base = hs_serialized;
+			iov[2].iov_len = serialized_len;
+
+			if (writev (fd, iov, 3) !=
+					(gssize)serialized_len + sizeof (n) + sizeof (*hs_ids) * n) {
 				g_set_error (err,
 						rspamd_re_cache_quark (),
 						errno,
 						"cannot serialize tree of regexp to %s: %s",
 						path, strerror (errno));
 				close (fd);
+				g_free (hs_ids);
 				g_free (hs_serialized);
 
-				return FALSE;
+				return -1;
 			}
 
+			total += n;
+
 			g_free (hs_serialized);
+			g_free (hs_ids);
 		}
 
 		close (fd);
 	}
 
-	return TRUE;
+	return total;
 #endif
 }

src/libserver/re_cache.h

 /**
  * Compile expressions to the hyperscan tree and store in the `cache_dir`
  */
-gboolean rspamd_re_cache_compile_hyperscan (struct rspamd_re_cache *cache,
+gint rspamd_re_cache_compile_hyperscan (struct rspamd_re_cache *cache,
 		const char *cache_dir,
 		GError **err);