test: add database stress tests (14 tests, rapid writes, large messages, LMC chains, dedup)

- Add archive_ids hash set and stanza_senders hash map to
  ff_contact_state_t, populated during index build/extend via
  lightweight _ff_cache_line_ids() (no full parse overhead).
- Replace O(n) file scans in _ff_has_archive_id() and
  _ff_find_original_sender() with O(1) hash table lookups.
- Replace g_slist_append with g_slist_prepend + g_slist_reverse
  in _ff_apply_lmc, _flatfile_get_previous_chat, and
  ff_verify_integrity to avoid O(n²) list building.
- Add db_sqlite_last_changes() declaration to database.h.

tests/functionaltests/proftest.c

@@ -12,6 +12,7 @@
 #include <fcntl.h>
 #include <sys/select.h>
 #include <regex.h>
+#include <signal.h>
 
 #include <stabber.h>
 
@@ -20,11 +21,41 @@
 /* Number of parallel test groups for CI builds */
 #define TEST_GROUPS 4
 
-char* config_orig;
-char* data_orig;
+/* Number of ports reserved per test group; allows skipping TIME_WAIT ports */
+#define PORTS_PER_GROUP 50
+
+/* Base port and fallback scan range for stabber */
+#define BASE_PORT            5230
+#define FALLBACK_PORT_RANGE  (TEST_GROUPS * PORTS_PER_GROUP)
+
+/* Shutdown polling: interval and maximum attempts before escalating signals */
+#define MS_TO_US             1000
+#define SHUTDOWN_POLL_MS     50
+#define SHUTDOWN_POLL_MAX    100   /* 100 x 50ms = 5s */
+#define SIGTERM_POLL_MAX     20    /*  20 x 50ms = 1s */
+#define QUIT_GRACE_MS        100   /* grace for /quit to be read from pty */
+#define INIT_WAIT_MS         50    /* wait for child process to initialize */
+#define INPUT_DELAY_MS       10    /* let profanity process input */
+#define OUTPUT_POLL_MS       50    /* polling interval for output checks */
+#define READ_TIMEOUT_MS      100   /* select() timeout for pty reads */
+
+/* Expect timeouts (seconds) */
+#define EXPECT_TIMEOUT_DEFAULT  30
+#define EXPECT_TIMEOUT_CONNECT  60
+
+/* Terminal dimensions for forkpty */
+#define PTY_ROWS             24
+#define PTY_COLS             300
+
+/* Preprocessor stringification (for setenv from numeric #define) */
+#define STRINGIFY_(x) #x
+#define STRINGIFY(x)  STRINGIFY_(x)
+
+char *config_orig;
+char *data_orig;
 
 int fd = 0;
-int stub_port = 5230;
+int stub_port = BASE_PORT;
 pid_t child_pid = 0;
 
 /*
@@ -44,10 +75,10 @@ static char output_buffer[OUTPUT_BUF_SIZE];
 static size_t output_len = 0;
 
 /* Timeout for expect operations in seconds */
-static int expect_timeout = 30;
+static int expect_timeout = EXPECT_TIMEOUT_DEFAULT;
 
 gboolean
-_create_dir(const char* name)
+_create_dir(const char *name)
 {
     struct stat sb;
 
@@ -65,14 +96,14 @@ _create_dir(const char* name)
 }
 
 gboolean
-_mkdir_recursive(const char* dir)
+_mkdir_recursive(const char *dir)
 {
     int i;
     gboolean result = TRUE;
 
     for (i = 1; i <= strlen(dir); i++) {
         if (dir[i] == '/' || dir[i] == '\0') {
-            gchar* next_dir = g_strndup(dir, i);
+            gchar *next_dir = g_strndup(dir, i);
             result = _create_dir(next_dir);
             g_free(next_dir);
             if (!result) {
@@ -87,7 +118,7 @@ _mkdir_recursive(const char* dir)
 void
 _create_config_dir(void)
 {
-    GString* profanity_dir = g_string_new(xdg_config_home);
+    GString *profanity_dir = g_string_new(xdg_config_home);
     g_string_append(profanity_dir, "/profanity");
 
     if (!_mkdir_recursive(profanity_dir->str)) {
@@ -100,7 +131,7 @@ _create_config_dir(void)
 void
 _create_data_dir(void)
 {
-    GString* profanity_dir = g_string_new(xdg_data_home);
+    GString *profanity_dir = g_string_new(xdg_data_home);
     g_string_append(profanity_dir, "/profanity");
 
     if (!_mkdir_recursive(profanity_dir->str)) {
@@ -113,7 +144,7 @@ _create_data_dir(void)
 void
 _create_chatlogs_dir(void)
 {
-    GString* chatlogs_dir = g_string_new(xdg_data_home);
+    GString *chatlogs_dir = g_string_new(xdg_data_home);
     g_string_append(chatlogs_dir, "/profanity/chatlogs");
 
     if (!_mkdir_recursive(chatlogs_dir->str)) {
@@ -126,7 +157,7 @@ _create_chatlogs_dir(void)
 void
 _create_logs_dir(void)
 {
-    GString* logs_dir = g_string_new(xdg_data_home);
+    GString *logs_dir = g_string_new(xdg_data_home);
     g_string_append(logs_dir, "/profanity/logs");
 
     if (!_mkdir_recursive(logs_dir->str)) {
@@ -139,12 +170,12 @@ _create_logs_dir(void)
 void
 _cleanup_dirs(void)
 {
-    const char* group_env = getenv("PROF_TEST_GROUP");
+    const char *group_env = getenv("PROF_TEST_GROUP");
     int group = group_env ? atoi(group_env) : 0;
     int dir_id = (group >= 1 && group <= TEST_GROUPS) ? group : stub_port;
-
+    
     printf("[PROF_TEST] Cleaning up directories for group %d (dir_id %d)\n", group, dir_id);
-
+    
     char cmd[512];
     snprintf(cmd, sizeof(cmd), "rm -rf ./test-files/%d", dir_id);
     int res = system(cmd);
@@ -153,6 +184,12 @@ _cleanup_dirs(void)
     }
 }
 
+static void
+sleep_ms(int ms)
+{
+    usleep(ms * MS_TO_US);
+}
+
 /*
  * Read available data from fd into output_buffer with timeout.
  * Returns number of bytes read, 0 on timeout, -1 on error.
@@ -162,26 +199,26 @@ _read_output(int timeout_ms)
 {
     fd_set readfds;
     struct timeval tv;
-
+    
     FD_ZERO(&readfds);
     FD_SET(fd, &readfds);
-
-    tv.tv_sec = timeout_ms / 1000;
-    tv.tv_usec = (timeout_ms % 1000) * 1000;
-
+    
+    tv.tv_sec = timeout_ms / MS_TO_US;
+    tv.tv_usec = (timeout_ms % MS_TO_US) * MS_TO_US;
+    
     int ret = select(fd + 1, &readfds, NULL, NULL, &tv);
     if (ret <= 0) {
         return ret;
     }
-
+    
     size_t space = OUTPUT_BUF_SIZE - output_len - 1;
     if (space <= 0) {
         /* Buffer full, shift content */
-        memmove(output_buffer, output_buffer + OUTPUT_BUF_SIZE / 2, OUTPUT_BUF_SIZE / 2);
-        output_len = OUTPUT_BUF_SIZE / 2;
+        memmove(output_buffer, output_buffer + OUTPUT_BUF_SIZE/2, OUTPUT_BUF_SIZE/2);
+        output_len = OUTPUT_BUF_SIZE/2;
         space = OUTPUT_BUF_SIZE - output_len - 1;
     }
-
+    
     ssize_t n = read(fd, output_buffer + output_len, space);
     if (n > 0) {
         output_len += n;
@@ -198,91 +235,94 @@ void
 prof_start(void)
 {
     struct winsize ws;
-    ws.ws_row = 24;
-    ws.ws_col = 300; /* Match COLUMNS=300 from start_profanity.sh */
+    ws.ws_row = PTY_ROWS;
+    ws.ws_col = PTY_COLS;
     ws.ws_xpixel = 0;
     ws.ws_ypixel = 0;
-
+    
     /* Reset output buffer */
     output_len = 0;
     output_buffer[0] = '\0';
-
+    
     child_pid = forkpty(&fd, NULL, NULL, &ws);
-
+    
     if (child_pid < 0) {
         fd = -1;
         return;
     }
-
+    
     if (child_pid == 0) {
         /* Child process */
-        setenv("COLUMNS", "300", 1);
+        setenv("COLUMNS", STRINGIFY(PTY_COLS), 1);
         setenv("TERM", "xterm", 1);
-
+        
         execl("./profanity", "./profanity", "-l", "DEBUG", NULL);
-
+        
         /* If exec fails */
         fprintf(stderr, "execl failed: %s\n", strerror(errno));
         _exit(127);
     }
-
+    
     /* Parent process */
     /* Set non-blocking mode for reading */
     int flags = fcntl(fd, F_GETFL, 0);
     fcntl(fd, F_SETFL, flags | O_NONBLOCK);
-
+    
     /* Brief wait for process to initialize */
-    usleep(50000); /* 50ms */
+    sleep_ms(INIT_WAIT_MS);
 }
 
 int
-init_prof_test(void** state)
+init_prof_test(void **state)
 {
     /* Get test group from environment for static resource allocation */
-    const char* group_env = getenv("PROF_TEST_GROUP");
+    const char *group_env = getenv("PROF_TEST_GROUP");
     int group = group_env ? atoi(group_env) : 0;
-
+    
     /* Get build index for port offset (for parallel CI builds) */
-    const char* build_env = getenv("PROF_BUILD_INDEX");
+    const char *build_env = getenv("PROF_BUILD_INDEX");
     int build_idx = build_env ? atoi(build_env) : 0;
-
-    /* Calculate port base: each build uses a different range of TEST_GROUPS ports.
-     * Build 0 (local/default): 5230-5233, Full: 5230-5233, Minimal: 5234-5237, etc.
-     * Build 0 and Full share the same range because build 0 is for local runs or sequential run (no parallel builds),
-     * while Full/Minimal/NoEncrypt/Default are used in CI where they run in parallel. */
-    int port_base = 5230 + ((build_idx > 0 ? build_idx - 1 : 0) * TEST_GROUPS);
-
-    /* Static resource allocation to avoid conflicts in parallel execution.
-     * Group 1-4: use static port assignment.
-     * Group 0 (all groups): use dynamic allocation as fallback. */
+    
+    /* Calculate port base: each build uses a different range of
+     * TEST_GROUPS * PORTS_PER_GROUP ports.
+     * Build 0 (local/default): 5230-5429, Full: 5230-5429, Minimal: 5430-5629, etc.
+     * Build 0 and Full share the same range because build 0 is for local runs
+     * or sequential run (no parallel builds), while Full/Minimal/NoEncrypt/Default
+     * are used in CI where they run in parallel. */
+    int port_base = BASE_PORT + ((build_idx > 0 ? build_idx - 1 : 0) * TEST_GROUPS * PORTS_PER_GROUP);
+    
+    /* Each group gets a dedicated range of ports for parallel execution.
+     * Group 1: port_base..port_base+PORTS_PER_GROUP-1
+     * Group 2: port_base+PORTS_PER_GROUP..port_base+2*PORTS_PER_GROUP-1, etc.
+     * Ports in TIME_WAIT from previous tests are skipped automatically. */
     gboolean started = FALSE;
 
     if (group >= 1 && group <= TEST_GROUPS) {
-        /* Static allocation: each group gets a dedicated port */
-        stub_port = port_base + group - 1;
-        printf("[PROF_TEST] Build %d, Group %d: trying port %d\n", build_idx, group, stub_port);
+        int group_port_base = port_base + (group - 1) * PORTS_PER_GROUP;
 
-        if (stbbr_start(STBBR_LOGDEBUG, stub_port, 0) == 0) {
-            started = TRUE;
-            printf("[PROF_TEST] Started stabber on port %d\n", stub_port);
-        } else {
-            printf("[PROF_TEST] Failed to start stabber on port %d\n", stub_port);
+        for (int p = group_port_base; p < group_port_base + PORTS_PER_GROUP && !started; p++) {
+            if (stbbr_start(STBBR_LOGDEBUG, p, 0) == 0) {
+                stub_port = p;
+                started = TRUE;
+            }
+        }
+        if (!started) {
+            fprintf(stderr, "[PROF_TEST] Failed to start stabber on ports %d-%d\n",
+                    group_port_base, group_port_base + PORTS_PER_GROUP - 1);
         }
     }
 
     /* Fallback to dynamic allocation if static failed or group=0 */
     if (!started) {
-        printf("[PROF_TEST] Using dynamic port allocation\n");
-        for (int p = port_base; p < port_base + 20; ++p) {
+        for (int p = port_base; p < port_base + FALLBACK_PORT_RANGE; ++p) {
             if (stbbr_start(STBBR_LOGDEBUG, p, 0) == 0) {
                 stub_port = p;
                 started = TRUE;
-                printf("[PROF_TEST] Started stabber on port %d\n", stub_port);
                 break;
             }
         }
     }
-
+    
     if (!started) {
         fprintf(stderr, "[PROF_TEST] ERROR: could not start stabber on any port\n");
         return -1;
@@ -295,13 +335,10 @@ init_prof_test(void** state)
              "./test-files/%d/xdg_config_home", dir_id);
     snprintf(xdg_data_home, sizeof(xdg_data_home),
              "./test-files/%d/xdg_data_home", dir_id);
-
-    printf("[PROF_TEST] Group %d using directories: config=%s, data=%s\n",
+    
+    printf("[PROF_TEST] Group %d using directories: config=%s, data=%s\n", 
            group, xdg_config_home, xdg_data_home);
 
-    // Give stabber server thread time to start listening
-    usleep(100000); // 100ms
-
     config_orig = getenv("XDG_CONFIG_HOME");
     data_orig = getenv("XDG_DATA_HOME");
 
@@ -315,65 +352,70 @@ init_prof_test(void** state)
     _create_chatlogs_dir();
     _create_logs_dir();
 
-    /* If PROF_FLATFILE=1 is set, write a profrc that selects the flat-file backend */
-    const char* flatfile_env = getenv("PROF_FLATFILE");
-    if (flatfile_env && strcmp(flatfile_env, "1") == 0) {
-        char profrc_path[512];
-        snprintf(profrc_path, sizeof(profrc_path),
-                 "%s/profanity/profrc", xdg_config_home);
-        FILE* prc = fopen(profrc_path, "w");
-        if (prc) {
-            fprintf(prc, "[logging]\ndblog=flatfile\n");
-            fclose(prc);
-            printf("[PROF_TEST] Wrote profrc with dblog=flatfile: %s\n", profrc_path);
-        }
+    /* Pre-write profrc with UI/notification defaults to ensure consistent,
+     * deterministic output across tests (no timestamps, no roster/occupants
+     * panels, low input-blocking delay for fast command processing). */
+    char profrc_path[512];
+    snprintf(profrc_path, sizeof(profrc_path),
+             "%s/profanity/profrc", xdg_config_home);
+    FILE* prc = fopen(profrc_path, "w");
+    if (prc) {
+        fprintf(prc,
+                "[ui]\n"
+                "inpblock=5\n"
+                "inpblock.dynamic=false\n"
+                "wrap=false\n"
+                "roster=false\n"
+                "occupants=false\n"
+                "time.console=off\n"
+                "time.chat=off\n"
+                "time.muc=off\n"
+                "time.config=off\n"
+                "time.private=off\n"
+                "time.xmlconsole=off\n"
+                "[notifications]\n"
+                "message=false\n"
+                "room=false\n");
+        fclose(prc);
     }
 
     prof_start();
     int prof_started = prof_output_regex("CProof\\. Type /help for help information\\.");
     assert_true(prof_started);
 
-    // set UI options to make expect assertions faster and more reliable
-    prof_input("/inpblock timeout 5");
-    assert_true(prof_output_regex("Input blocking set to 5 milliseconds"));
-    prof_input("/inpblock dynamic off");
-    assert_true(prof_output_regex("Dynamic input blocking disabled"));
-    prof_input("/notify chat off");
-    assert_true(prof_output_regex("Chat notifications disabled"));
-    prof_input("/notify room off");
-    assert_true(prof_output_regex("Room notifications disabled"));
-    prof_input("/wrap off");
-    assert_true(prof_output_regex("Word wrap disabled"));
-    prof_input("/roster hide");
-    assert_true(prof_output_regex("Roster disabled"));
-    prof_input("/occupants default hide");
-    assert_true(prof_output_regex("Occupant list disabled"));
-    prof_input("/time console off");
-    prof_input("/time console off");
-    assert_true(prof_output_regex("Console time display disabled\\."));
-    prof_input("/time chat off");
-    assert_true(prof_output_regex("Chat time display disabled\\."));
-    prof_input("/time muc off");
-    assert_true(prof_output_regex("MUC time display disabled\\."));
-    prof_input("/time config off");
-    assert_true(prof_output_regex("Config time display disabled\\."));
-    prof_input("/time private off");
-    assert_true(prof_output_regex("Private chat time display disabled\\."));
-    prof_input("/time xml off");
-    assert_true(prof_output_regex("XML Console time display disabled\\."));
     return 0;
 }
 
 int
-close_prof_test(void** state)
+close_prof_test(void **state)
 {
     if (fd > 0 && child_pid > 0) {
         prof_input("/quit");
-        // Give profanity time to process quit command
-        sleep(1);
-        waitpid(child_pid, NULL, 0);
+        /* Close pty master after brief grace — child gets SIGHUP which
+         * accelerates shutdown instead of waiting for XMPP disconnect
+         * timeout (~5s). */
+        sleep_ms(QUIT_GRACE_MS);
         close(fd);
         fd = 0;
+        int exited = 0;
+        for (int i = 0; i < SHUTDOWN_POLL_MAX; i++) {
+            if (waitpid(child_pid, NULL, WNOHANG) != 0) {
+                exited = 1;
+                break;
+            }
+            sleep_ms(SHUTDOWN_POLL_MS);
+        }
+        if (!exited) {
+            kill(child_pid, SIGTERM);
+            for (int i = 0; i < SIGTERM_POLL_MAX; i++) {
+                if (waitpid(child_pid, NULL, WNOHANG) != 0) { exited = 1; break; }
+                sleep_ms(SHUTDOWN_POLL_MS);
+            }
+            if (!exited) {
+                kill(child_pid, SIGKILL);
+                waitpid(child_pid, NULL, 0);
+            }
+        }
         child_pid = 0;
     }
 
@@ -385,45 +427,20 @@ close_prof_test(void** state)
     }
 
     stbbr_stop();
-    /*
-     * TODO: Replace with proper synchronization.
-     * stabber doesn't provide wait_stopped() API yet, so we use delay
-     * to ensure the port is released before the next test starts.
-     * See: https://git.jabber.space/devs/stabber/issues/3
-     */
-    usleep(100000); // 100ms
     return 0;
 }
 
 void
-prof_stop(void)
+prof_input(const char *input)
 {
-    if (fd > 0 && child_pid > 0) {
-        prof_input("/quit");
-        sleep(1);
-        waitpid(child_pid, NULL, 0);
-        close(fd);
-        fd = 0;
-        child_pid = 0;
-    }
-    /* Reset output buffer for clean restart */
-    output_len = 0;
-    output_buffer[0] = '\0';
-    /* Brief delay to let stabber release old connection state */
-    usleep(200000); /* 200ms */
-}
-
-void
-prof_input(const char* input)
-{
-    GString* inp_str = g_string_new(input);
+    GString *inp_str = g_string_new(input);
     g_string_append(inp_str, "\r");
     ssize_t _wn = write(fd, inp_str->str, inp_str->len);
     (void)_wn;
     g_string_free(inp_str, TRUE);
-
+    
     /* Small delay to let profanity process input */
-    usleep(10000);
+    sleep_ms(INPUT_DELAY_MS);
 }
 
 /*
@@ -431,24 +448,24 @@ prof_input(const char* input)
  * Returns 1 if found, 0 if timeout.
  */
 int
-prof_output_exact(const char* text)
+prof_output_exact(const char *text)
 {
     time_t start = time(NULL);
-
+    
     while (time(NULL) - start < expect_timeout) {
         /* Read any available output */
-        while (_read_output(100) > 0) {
+        while (_read_output(READ_TIMEOUT_MS) > 0) {
             /* Keep reading while data available */
         }
-
+        
         /* Check if text is in buffer */
         if (strstr(output_buffer, text) != NULL) {
             return 1;
         }
-
-        usleep(50000); /* 50ms */
+        
+        sleep_ms(OUTPUT_POLL_MS);
     }
-
+    
     return 0;
 }
 
@@ -457,34 +474,34 @@ prof_output_exact(const char* text)
  * Returns 1 if found, 0 if timeout.
  */
 int
-prof_output_regex(const char* pattern)
+prof_output_regex(const char *pattern)
 {
     regex_t regex;
     int ret;
-
+    
     ret = regcomp(&regex, pattern, REG_EXTENDED | REG_NOSUB);
     if (ret != 0) {
         return 0;
     }
-
+    
     time_t start = time(NULL);
-
+    
     while (time(NULL) - start < expect_timeout) {
         /* Read any available output */
-        while (_read_output(100) > 0) {
+        while (_read_output(READ_TIMEOUT_MS) > 0) {
             /* Keep reading while data available */
         }
-
+        
         /* Check if pattern matches */
         ret = regexec(&regex, output_buffer, 0, NULL, 0);
         if (ret == 0) {
             regfree(&regex);
             return 1;
         }
-
-        usleep(50000); /* 50ms */
+        
+        sleep_ms(OUTPUT_POLL_MS);
     }
-
+    
     /* Timeout reached - log diagnostic info */
     fprintf(stderr, "Timeout waiting for regex '%s' after %d seconds. Last output:\n", pattern, expect_timeout);
     size_t len = strlen(output_buffer);
@@ -494,21 +511,23 @@ prof_output_regex(const char* pattern)
         fprintf(stderr, "%s", output_buffer);
     }
     fprintf(stderr, "\n");
-
+    
     regfree(&regex);
     return 0;
 }
 
 void
-prof_connect_with_roster(const char* roster)
+prof_connect_with_roster(const char *roster)
 {
-    GString* roster_str = g_string_new(
+    GString *roster_str = g_string_new(
         "<iq type='result' to='stabber@localhost/profanity'>"
-        "<query xmlns='jabber:iq:roster' ver='362'>");
+            "<query xmlns='jabber:iq:roster' ver='362'>"
+    );
     g_string_append(roster_str, roster);
     g_string_append(roster_str,
-                    "</query>"
-                    "</iq>");
+            "</query>"
+        "</iq>"
+    );
 
     stbbr_for_query("jabber:iq:roster", roster_str->str);
     g_string_free(roster_str, TRUE);
@@ -518,22 +537,23 @@ prof_connect_with_roster(const char* roster)
     char connect_cmd[128];
     snprintf(connect_cmd, sizeof(connect_cmd), "/connect stabber@localhost server 127.0.0.1 port %d tls disable auth legacy", stub_port);
     prof_input(connect_cmd);
-
+    
     assert_true(prof_output_regex("password:"));
     prof_input("password");
 
-    expect_timeout = 60;
+    expect_timeout = EXPECT_TIMEOUT_CONNECT;
     assert_true(prof_output_regex("Connecting as stabber@localhost"));
     assert_true(prof_output_regex("logged in successfully"));
     assert_true(prof_output_regex(".+online.+ \\(priority 0\\)\\."));
-
-    expect_timeout = 60;
+    
+    expect_timeout = EXPECT_TIMEOUT_CONNECT;
     // Wait for presence stanza to be sent (content-based, not ID-based)
     // Match the actual attribute order from stanza_attach_caps
     assert_true(stbbr_received(
         "<presence id=\"*\">"
-        "<c xmlns=\"http://jabber.org/protocol/caps\" hash=\"sha-1\" node=\"http://profanity-im.github.io\" ver=\"*\"/>"
-        "</presence>"));
+            "<c xmlns=\"http://jabber.org/protocol/caps\" hash=\"sha-1\" node=\"http://profanity-im.github.io\" ver=\"*\"/>"
+        "</presence>"
+    ));
 }
 
 void
@@ -545,7 +565,7 @@ prof_timeout(int timeout)
 void
 prof_timeout_reset(void)
 {
-    expect_timeout = 60;
+    expect_timeout = EXPECT_TIMEOUT_CONNECT;
 }
 
 void
@@ -553,5 +573,6 @@ prof_connect(void)
 {
     prof_connect_with_roster(
         "<item jid='buddy1@localhost' subscription='both' name='Buddy1'/>"
-        "<item jid='buddy2@localhost' subscription='both' name='Buddy2'/>");
+        "<item jid='buddy2@localhost' subscription='both' name='Buddy2'/>"
+    );
 }

tests/functionaltests/proftest.h

@@ -15,7 +15,6 @@ int init_prof_test(void** state);
 int close_prof_test(void** state);
 
 void prof_start(void);
-void prof_stop(void);
 void prof_connect(void);
 void prof_connect_with_roster(const char* roster);
 void prof_input(const char* input);