Kolab Groupware OBS

guam.spec Changed

@@ -18,7 +18,7 @@
 %define lock_version() %{1}%{?_isa} = %(rpm -q --queryformat "%%{VERSION}" %{1})
 
 Name:               guam
-Version:            0.9.5
+Version:            0.9.9
 Release:            1%{?dist}
 Summary:            A Smart Reverse IMAP Proxy
 
@@ -26,12 +26,10 @@
 License:            GPLv3+
 URL:                https://kolab.org/about/guam
 
-Source0:            https://mirror.kolabenterprise.com/pub/releases/guam-%{version}.tar.gz
+Source0:            guam-%{version}.tar.gz
 Source100:          plesk.sys.config
 
-Patch9991:          make-it-very-easy-on-rebar3.patch
-Patch9992:          guam-priv-no-delete.patch
-Patch9993:          use_iolist_to_binary.patch
+Patch9991:          nodeps.patch
 
 BuildRequires:      erlang >= 17.4
 BuildRequires:      erlang-asn1
@@ -39,7 +37,7 @@
 BuildRequires:      erlang-compiler
 BuildRequires:      erlang-crypto
 BuildRequires:      erlang-debugger
-BuildRequires:      erlang-eimap >= 0.3.0
+BuildRequires:      erlang-eimap >= 0.4.0
 BuildRequires:      erlang-erts
 BuildRequires:      erlang-et
 BuildRequires:      erlang-goldrush >= 0.1.8
@@ -98,10 +96,6 @@
 %setup -q
 
 %patch9991 -p1
-%patch9992 -p1
-%patch9993 -p1
-
-sed -i 's/"0\.9\.0"/"%{version}"/' rebar.config
 
 %build
 
@@ -182,7 +176,7 @@
 
 %postun
 %if 0%{?with_systemd}
-%systemd_postun
+%systemd_postun %{name}.service
 %endif
 
 %if 0%{?with_systemd}
@@ -230,8 +224,20 @@
 %endif
 
 %changelog
-* Sat Mar 21 2020 hede <kolab983@der-he.de> - 0.9.5-2
-- use iolist_to_binary() to convert iolist to binary
+* Mon Dec 14 2020 Christian Mollekopf <mollekopf@kolabsys.com> - 0.9.9-1
+- Release of version 0.9.9
+
+* Mon Nov 9 2020 Christian Mollekopf <mollekopf@kolabsys.com> - 0.9.8-2
+- Fixed STARTTLS
+
+* Mon Oct 26 2020 Christian Mollekopf <mollekopf@kolabsys.com> - 0.9.8-1
+- Release of version 0.9.8
+
+* Wed Apr 15 2020 Christian Mollekopf <mollekopf@kolabsys.com> - 0.9.7-1
+- Release of version 0.9.7
+
+* Tue Mar 31 2020 Christian Mollekopf <mollekopf@kolabsys.com> - 0.9.6-1
+- Release of version 0.9.6
 
 * Thu Dec  5 2019 Jeroen van Meeuwen <vanmeeuwen@kolabsys.com> - 0.9.5-1
 - Release of version 0.9.5

guam-0.9.4-D714-for-T160184.patch Added

@@ -0,0 +1,132 @@
+diff --git a/apps/kolab_guam/src/rules/kolab_guam_rule_filter_groupware.erl b/apps/kolab_guam/src/rules/kolab_guam_rule_filter_groupware.erl
+index decbd9a..d0e7ca1 100644
+--- a/apps/kolab_guam/src/rules/kolab_guam_rule_filter_groupware.erl
++++ b/apps/kolab_guam/src/rules/kolab_guam_rule_filter_groupware.erl
+@@ -102,6 +102,7 @@ filter_folder(_State, <<>>, Acc) -> { Acc, true };
+ filter_folder(State, <<"* LIST ", Details/binary>> = Response, Acc) -> { filter_on_details(State, Response, Acc, Details), true };
+ filter_folder(State, <<"* XLIST ", Details/binary>> = Response, Acc) -> { filter_on_details(State, Response, Acc, Details), true };
+ filter_folder(State, <<"* LSUB ", Details/binary>> = Response, Acc) -> { filter_on_details(State, Response, Acc, Details), true };
++filter_folder(State, <<"* STATUS ", Details/binary>> = Response, Acc) -> { filter_on_details(State, Response, Acc, Details), true };
+ filter_folder(#state{ tag = Tag }, Response, Acc) ->
+     HasMore =
+     case byte_size(Tag) =< byte_size(Response) of
+@@ -115,25 +116,28 @@ filter_folder(#state{ tag = Tag }, Response, Acc) ->
+     { add_response(Response, Acc), HasMore }.
+ 
+ filter_on_details(#state{ blacklist = Blacklist }, Response, Acc, Details) ->
+-    %% first determine if we have a quoted item or a non-quoted item and start from there
+-    DetailsSize = byte_size(Details),
+-    { Quoted, Start } = case binary:at(Details, DetailsSize - 1) of $" -> { quoted, DetailsSize - 2 }; _ -> { unquoted, DetailsSize - 1 } end,
+-    Folder = find_folder_name(Details, Quoted, Start, Start, binary:at(Details, Start)),
+-    %io:format("COMPARING ~p ??? ~p~n", [Folder, in_blacklist(Folder, Blacklist)]),
++    %% Remove "*" and extract response command name
++    { _, Start, _ } = pop_token(Response), %% asterisk
++    { Cmd, _, _ } = pop_token(Start), %% command
++
++    %% Extract folder name
++    Suffix =
++    case Cmd =:= <<"STATUS">> of
++        true -> Details;
++        _ ->
++            { Pos, _Length } = binary:match(Details, [<<")">>], []),
++            { _Delimiter, Rest, _} = pop_token(binary:part(Details, Pos + 2, byte_size(Details) - Pos - 2)),
++            Rest
++    end,
++    { Folder, _, _ } = pop_token(list_to_binary([Suffix, <<"\r\n">>])),
++
++    %% Check the folder in blacklist
++    %% io:format("COMPARING ~p ??? ~p~n", [Folder, in_blacklist(Folder, Blacklist)]),
+     case in_blacklist(Folder, Blacklist) of
+         true -> Acc;
+         _ -> add_response(Response, Acc)
+     end.
+ 
+-find_folder_name(Details, quoted, End, Start, $") ->
+-    binary:part(Details, Start + 1, End - Start);
+-find_folder_name(Details, unquoted, End, Start, $ ) ->
+-    binary:part(Details, Start + 1, End - Start);
+-find_folder_name(Details, _Quoted, _End, 0, _) ->
+-    Details;
+-find_folder_name(Details, Quoted, End, Start, _) ->
+-    find_folder_name(Details, Quoted, End, Start - 1, binary:at(Details, Start - 1)).
+-
+ add_response(Response, <<>>) -> Response;
+ add_response(Response, Acc) -> <<Acc/binary, "\r\n", Response/binary>>.
+ 
+@@ -147,3 +151,76 @@ in_blacklist(Folder, [{ Literal, Prefix }|List]) ->
+                  _ -> in_blacklist(Folder, List)
+              end
+     end.
++
++%% pop_token from https://github.com/MainframeHQ/switchboard/blob/master/src/imap.erl (BSD Lic.)
++%% with some small changes by Aleksander Machniak <machniak@kolabsys.com>
++pop_token(Data) ->
++    pop_token(Data, none).
++
++pop_token(<<>>, State) ->
++    {none, <<>>, State};
++
++%% Consume hanging spaces
++pop_token(<<" ", Rest/binary>>, none) ->
++    pop_token(Rest, none);
++
++%% \r\n
++pop_token(<<$\r, $\n, Rest/binary>>, none) ->
++    {crlf, Rest, none};
++
++%% NIL
++pop_token(<<"NIL", Rest/binary>>, none) ->
++    {nil, Rest, none};
++
++%% ( | ) | [ | ]
++pop_token(<<$(, Rest/binary>>, none) ->
++    {'(', Rest, none};
++pop_token(<<$), Rest/binary>>, none) ->
++    {')', Rest, none};
++
++pop_token(<<$[, Rest/binary>>, none) ->
++    {'[', Rest, none};
++pop_token(<<$], Rest/binary>>, none) ->
++    {']', Rest, none};
++
++%% Atom
++pop_token(<<C, _/binary>> = Data, {atom, AtomAcc}) when
++  C =:= 32; C =:= 40; C =:= 41; C =:= $(; C =:= $); C =:= 91; C =:= 93 ->
++    {AtomAcc, Data, none};
++pop_token(<<$\r, $\n, _/binary>> = Data, {atom, AtomAcc}) ->
++    {AtomAcc, Data, none};
++pop_token(<<C, Rest/binary>>, none) when C >= 35, C < 123 ->
++    pop_token(Rest, {atom, <<C>>});
++pop_token(<<C, Rest/binary>>, {atom, AtomAcc}) when C >= 35, C < 123 ->
++    pop_token(Rest, {atom, <<AtomAcc/binary, C>>});
++
++%% Literal Strings
++pop_token(<<${, Rest/binary>>, none) ->
++    pop_token(Rest, {literal, <<>>});
++pop_token(<<$}, $\r, $\n, Rest/binary>>, {literal, ByteAcc}) ->
++    pop_token(Rest, {literal, binary_to_integer(ByteAcc), <<>>});
++pop_token(<<D, Rest/binary>>, {literal, ByteAcc}) when D >= 48, D < 58 ->
++    pop_token(Rest, {literal, <<ByteAcc/binary, D>>});
++pop_token(Binary, {literal, Bytes, LiteralAcc}) when is_integer(Bytes) ->
++    case Binary of
++        <<Literal:Bytes/binary, Rest/binary>> ->
++            {<<LiteralAcc/binary, Literal/binary>>, Rest, none};
++        _ ->
++            %% If the binary is too short, accumulate it in the state
++            pop_token(<<>>, {literal, Bytes - size(Binary), <<LiteralAcc/binary, Binary/binary>>})
++    end;
++
++%% Quoted Strings
++pop_token(<<$", Rest/binary>>, none) ->
++    pop_token(Rest, {quoted, <<>>});
++pop_token(<<$\\, C, Rest/binary>>, {quoted, Acc}) ->
++    pop_token(Rest, {quoted, <<Acc/binary, C>>});
++pop_token(<<$", Rest/binary>>, {quoted, Acc}) ->
++    {Acc, Rest, none};
++pop_token(<<$\r, $\n, _>>, {quoted, _}) ->
++    throw({error, crlf_in_quoted});
++pop_token(<<C, Rest/binary>>, {quoted, Acc}) ->
++    pop_token(Rest, {quoted, <<Acc/binary, C>>});
++
++pop_token(Binary, _) ->
++    {none, Binary, none}.

guam-priv-no-delete.patch Deleted

make-it-very-easy-on-rebar3.patch Deleted

@@ -1,31 +0,0 @@
-diff -ur guam-0.9.0.orig/apps/kolab_guam/src/kolab_guam.app.src guam-0.9.0/apps/kolab_guam/src/kolab_guam.app.src
---- guam-0.9.0.orig/apps/kolab_guam/src/kolab_guam.app.src	2016-07-29 12:30:44.000000000 +0200
-+++ guam-0.9.0/apps/kolab_guam/src/kolab_guam.app.src	2016-11-21 13:53:11.857715091 +0100
-@@ -9,8 +9,9 @@
-                   stdlib,
-                   compiler,
-                   syntax_tools,
--                  goldrush,
-+                  eimap,
-                   lager,
-+                  lager_syslog,
-                   crypto,
-                   ssl
-                  ]},
-diff -ur guam-0.9.0.orig/rebar.config guam-0.9.0/rebar.config
---- guam-0.9.0.orig/rebar.config	2016-07-29 12:30:44.000000000 +0200
-+++ guam-0.9.0/rebar.config	2016-11-21 13:52:49.191460388 +0100
-@@ -8,13 +8,6 @@
-             fail_on_warning
-             ]
- }.
--{ deps, [
--    lager,
--    { lager_syslog, "3.*", { git, "git://github.com/basho/lager_syslog.git", { tag, "3.0.1" } } },
--    { eimap, ".*", { git, "https://git.kolab.org/diffusion/EI/eimap.git", { tag, "0.3.0" } } }
--    %% pull in the proper version of meck before jobs 0.3 gets around to pulling in the wrong version
--   ]
--}.
- 
- { sub_dirs, [
-     "apps/kolab_guam"

nodeps.patch Added

use-vendorized-rebar3.patch Deleted

_link Changed

debian.changelog Changed

@@ -1,8 +1,38 @@
-guam (0.9.5-3) unstable; urgency=medium
+guam (0.9.9-1) unstable; urgency=medium
 
-  * use iolist_to_binary() to convert iolist to binary
+  * Release of version 0.9.9
 
- -- hede <kolab983@der-he.de>  Sat, 21 Mar 2020 20:50:10 +0200
+ -- Christian Mollekopf (Kolab Systems) <mollekopf@kolabsys.com>  Mon,  14 Dec 2020 09:31:31 +0200
+
+guam (0.9.8-2) unstable; urgency=medium
+
+  * Fixed STARTTLS
+
+ -- Christian Mollekopf (Kolab Systems) <mollekopf@kolabsys.com>  Mon,  9 Nov 2020 09:31:31 +0200
+
+guam (0.9.8-1) unstable; urgency=medium
+
+  * Release of version 0.9.8
+
+ -- Christian Mollekopf (Kolab Systems) <mollekopf@kolabsys.com>  Mon,  26 Oct 2020 09:31:31 +0200
+
+guam (0.9.7-3) unstable; urgency=medium
+
+  * Updated debian/postinst script
+
+ -- Daniel Hoffend <dh@dotlan.net>  Wed,  22 Apr 2020 00:46:22 +0200
+
+guam (0.9.7-1) unstable; urgency=medium
+
+  * Release of version 0.9.7
+
+ -- Christian Mollekopf (Kolab Systems) <mollekopf@kolabsys.com>  Wed,  15 Apr 2020 09:31:31 +0200
+
+guam (0.9.6-1) unstable; urgency=medium
+
+  * Release of version 0.9.6
+
+ -- Christian Mollekopf (Kolab Systems) <mollekopf@kolabsys.com>  Tue,  31 Mar 2020 09:31:31 +0200
 
 guam (0.9.5-2) unstable; urgency=medium

debian.rules Changed

debian.series Changed

debian.tar.gz/postinst Changed

@@ -7,9 +7,28 @@
             openssl dhparam -out /etc/guam/dh_2048.pem -2 2048 >/dev/null 2>&1
         fi
 
-        if [ -L "/etc/systemd/system/guam.service" ]; then
-            systemctl unmask guam || :
+        # This will only remove masks created by d-s-h on package removal.
+        deb-systemd-helper unmask 'guam.service' >/dev/null || true
+
+        # was-enabled defaults to true, so new installations run enable.
+        if deb-systemd-helper --quiet was-enabled 'guam.service'; then
+                # Enables the unit on first installation, creates new
+                # symlinks on upgrades if the unit file has changed.
+                deb-systemd-helper enable 'guam.service' >/dev/null || true
+        else
+                # Update the statefile to add new symlinks (if any), which need to be
+                # cleaned up on purge. Also remove old symlinks.
+                deb-systemd-helper update-state 'guam.service' >/dev/null || true
+        fi
+
+        # start or restart on install/updated
+        systemctl --system daemon-reload >/dev/null || true
+        if [ -n "$2" ]; then
+                _dh_action=restart
+        else
+                _dh_action=start
         fi
+        deb-systemd-invoke $_dh_action 'guam.service' >/dev/null || true
     ;;
 esac

guam-0.9.5.tar.gz/CHANGELOG.md -> guam-0.9.9.tar.gz/CHANGELOG.md Changed

guam-0.9.5.tar.gz/apps/kolab_guam/src/kolab_guam.app.src -> guam-0.9.9.tar.gz/apps/kolab_guam/src/kolab_guam.app.src Changed

guam-0.9.5.tar.gz/apps/kolab_guam/src/kolab_guam_listener.erl -> guam-0.9.9.tar.gz/apps/kolab_guam/src/kolab_guam_listener.erl Changed

guam-0.9.5.tar.gz/apps/kolab_guam/src/kolab_guam_session.erl -> guam-0.9.9.tar.gz/apps/kolab_guam/src/kolab_guam_session.erl Changed

@@ -25,10 +25,10 @@
 %% gen_server callbacks
 -export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
 
-%% state record definition
--record(state, { listen_socket, socket = undefined, super_pid, tls_config = [], client_implicit_tls = false, client_tls_active = false, server_config = [],
-                 rules_active = [], rules_deciding = [], imap_session = undefined, inflator, deflator, buffered_client_data = <<>>,
-                 current_command_split = undefined, command_split_reset_trigger = reset_for_next_client_command }).
+%% tests
+-export([ process_client_data/3 ]).
+
+-include("kolab_guam_session.hrl").
 
 %% public API
 start_link(SupervisorPID, ListenSocket, ImapConfig, ImplicitTLS, TLSConfig, Rules) -> gen_server:start_link(?MODULE, [SupervisorPID, ListenSocket, ImapConfig, ImplicitTLS, TLSConfig, Rules], []).
@@ -69,11 +69,20 @@
     %lager:debug("Socket error"),
     { stop, normal, State };
 handle_info({ tcp, Socket, Data }, #state{ client_tls_active = false } = State) ->
-    %lager:debug("Data coming in from client over TCP ~s", [Data]),
-    process_client_data(Socket, Data, State);
+    % lager:debug("Data coming in from client over TCP ~s", [Data]),
+    {Acc, NewState} = process_client_data(Socket, Data, State),
+    forward_literal_data(Acc, NewState),
+    %Required because of socket upgrade, in which case we will end up with the ssl variant here.
+    set_socket_active(NewState),
+    { noreply, NewState };
+
 handle_info({ ssl, Socket, Data }, State) ->
-    %lager:debug("Data coming in from client over SSL, ~p", [Data]),
-    process_client_data(Socket, Data, State);
+    % lager:debug("Data coming in from client over SSL, ~p", [Data]),
+    {Acc, NewState} = process_client_data(Socket, Data, State),
+    forward_literal_data(Acc, NewState),
+    ssl:setopts(Socket, [{ active, once }]),
+    { noreply, NewState };
+
 handle_info({ server_hello, ServerHello }, #state{ imap_session = ImapSession, tls_config = TLSConfig, socket = Socket, client_implicit_tls = ImplicitTLS, client_tls_active = TLSActive, deflator = Deflator } = State) ->
     CorrectedHello = correct_hello(TLSActive, ImplicitTLS, TLSConfig, ServerHello),
     ServerIdent = proplists:get_value(server_id, ServerHello, <<>>),
@@ -99,7 +108,7 @@
     %TODO: should we also support non-active rules doing imapy things here?
     { noreply, State#state{ rules_active = NewActiveRules } };
 handle_info({ imap_server_response, Data }, #state{ socket = Socket, imap_session = ImapSession, client_tls_active = TLS, deflator = Deflator, rules_active = ActiveRules } = State) ->
-    %lager:debug("FROM SERVER: ~s", [Data]),
+    lager:debug("FROM SERVER: ~p", [Data]),
     { ModifiedData, CurrentlyActiveRules } = apply_ruleset_serverside(ImapSession, Data, ActiveRules),
     relay_response(Socket, postprocess_server_data(Deflator, ModifiedData), TLS),
     NewSplitCommand = update_split_command_state(ModifiedData, State),
@@ -148,10 +157,43 @@
 update_split_command_state(_Data, _State) ->
     undefined.
 
+update_split_command_state_client(ClientDataComponents, #state{ command_split_reset_trigger = reset_for_next_client_command, current_command_split = CurrentCommandSplit }) ->
+    %If we have a currently active command (CurrentCommandSplit), then we reset only if we find a new command (and not just on any new line).
+    %This is relevant for multi-line commands such as APPEND, which follow up with a continuation which we want to avoid buffering.
+    case CurrentCommandSplit of
+        undefined -> undefined;
+        _ ->
+            case ClientDataComponents of
+                { <<>>, <<>>, <<>> } -> CurrentCommandSplit;
+                { _Tag, <<>>, <<>> } -> CurrentCommandSplit;
+                { <<>>, _Command, <<>> } -> CurrentCommandSplit;
+                { _Tag, _Command, _Data } -> undefined
+            end
+    end;
+update_split_command_state_client(_ClientDataComponents, _State) ->
+    undefined.
+
+set_socket_active(#state{ client_tls_active = true, socket = Socket}) -> ssl:setopts(Socket, [{ active, once }]);
+set_socket_active(#state{ client_tls_active = false, socket = Socket}) -> inet:setopts(Socket, [{ active, once }]).
+
 accept_client(#state{ client_implicit_tls = true, tls_config = TLSConfig, listen_socket = ListenSocket, super_pid = SupervisorPID }) ->
     AcceptSocket = accept_socket(ListenSocket, SupervisorPID),
+
+    { ok, SSLSocket } =
+    case ssl:ssl_accept(AcceptSocket, TLSConfig) of
+        { ok, Socket } ->
+            { ok, Socket };
+        {error, {tls_alert, Reason}} ->
+            lager:warning("TLS handshake failed with a tls_alert: ~p", [Reason]),
+            ok = gen_tcp:close(AcceptSocket),
+            exit(normal);
+        {error, Reason} when Reason =:= timeout; Reason =:= closed ->
+            lager:info("Socket closed or timed out during TLS handshake: ~p", [Reason]),
+            ok = gen_tcp:close(AcceptSocket),
+            exit(normal)
+    end,
+
     %% prep for the next listen
-    { ok, SSLSocket } = ssl:ssl_accept(AcceptSocket, TLSConfig),
     ok = ssl:setopts(SSLSocket, [{ active, once }, { mode, binary }]),
     % lager:info("~p All done!", [self()]),
     { ok, SSLSocket, true };
@@ -165,7 +207,14 @@
     %% start a new accepting process to replace this one, which is now in use
     supervisor:start_child(SupervisorPID, []),
     %% assert that the accept worked
-    { ok, AcceptSocket } = AcceptResult,
+    { ok, AcceptSocket } =
+    case AcceptResult of
+        { ok, Socket } ->
+            { ok, Socket };
+        {error, emfile} ->
+            lager:error("Too many files open, you may be running into a file descriptor limitation."),
+            exit(emfile)
+    end,
     AcceptSocket.
 
 close_zlib_handle(undefined) -> ok;
@@ -176,79 +225,97 @@
 close_socket(true, _TLS, Socket) -> ssl:close(Socket);
 close_socket(_ImplicitTLS, _TLS, Socket) -> gen_tcp:close(Socket).
 
-process_client_data(Socket, Data, #state{ rules_deciding = UndecidedRules, tls_config = TLSConfig, client_tls_active = TLS, rules_active = ActiveRules, socket = Socket, imap_session = ImapSession, inflator = Inflator, deflator = Deflator, server_config = ServerConfig, current_command_split = CurrentCommandSplit } = State) ->
-    %%TODO: multipacket input from clients
+
+forward_literal_data(<<>>, _State) ->
+    {};
+forward_literal_data(Data, #state{imap_session = ImapSession} = _State) ->
+    eimap:passthrough_data(ImapSession, Data).
+
+process_lines(_Socket, State, [], ContinuationBytes, Acc) ->
+    {Acc, State#state{ continuation_bytes = ContinuationBytes }};
+process_lines(Socket, State, [Line|MoreLines], 0, Acc) ->
+    { _StrippedNextLine, NextContinuationBytes } = eimap_utils:num_literal_continuation_bytes(binary:part(Line, 0, byte_size(Line)-2)),
+    {NewAcc, NewState} = process_client_line(Line, Socket, State, Acc),
+    process_lines(Socket, NewState, MoreLines, NextContinuationBytes, NewAcc);
+process_lines(Socket, State, [Line|MoreLines], ContinuationBytes, Acc) ->
+    {LiteralPartOfLine, Remainder} = split_binary(Line, min(ContinuationBytes, size(Line))),
+    Lines =
+    case Remainder of
+       <<>> -> MoreLines;
+        _ -> [Remainder|MoreLines]
+    end,
+    process_lines(Socket, State, Lines, ContinuationBytes - size(LiteralPartOfLine), <<Acc/binary, LiteralPartOfLine/binary>>).
+
+split(Lines, Data, Pattern) ->
+     case binary:match(Data, Pattern) of
+         nomatch -> {lists:reverse(Lines), Data};
+         { Start, Length } ->
+             Num = Start + Length,
+             <<Line:Num/binary, Remainder/binary>> = Data,
+             split([Line|Lines], Remainder, Pattern)
+     end.
+split(Lines, Data) ->
+    split(Lines, Data, binary:compile_pattern(<<"\r\n">>)).
+
+split_lines(Data) ->
+    split([], Data).
+
+% Client data is processed as it comes in, but split up by lines if more than one line comes in at a time.
+% The processing internally buffers data as necessary if it encounters incomplete lines.
+process_client_data(Socket, Data, #state{ inflator = Inflator, continuation_bytes = ContinuationBytes } = State) ->
     % TODO: refactor so starttls and compress commands can be made into rules
     PreprocessData = preprocess_client_data(Inflator, Data, State),
-    %lager:info("FROM CLIENT: ~s", [PreprocessData]),
-    { TLSActive, CurrentSocket, CurrentInflator, CurrentDeflator, CurrentUndecidedRules, CurrentActiveRules, DataToBuffer, SplitCommand, SplitResetTrigger } =
-    case check_for_transmission_change_commands(TLS, TLSConfig, PreprocessData, Deflator, Socket) of
+    lager:debug("FROM CLIENT: ~p", [PreprocessData]),
+
+    {Lines, NewLastPartialLine} = split_lines(PreprocessData),
+    {Acc, NewState} = process_lines(Socket, State#state{ buffered_client_data = <<>> }, Lines, ContinuationBytes, <<>>),
+    #state{ buffered_client_data = DataToBuffer, continuation_bytes = NewContinuationBytes} = NewState,
+
+    NewBuffer = <<DataToBuffer/binary, NewLastPartialLine/binary>>,
+    %If we are inside a continuation, forward up to NewContinuationBytes
+    {LiteralPartOfBuffer, NonLiteralPart} = split_binary(NewBuffer, min(NewContinuationBytes, size(NewBuffer))),
+
+    {<<Acc/binary, LiteralPartOfBuffer/binary>>, NewState#state{ buffered_client_data = NonLiteralPart, continuation_bytes = NewContinuationBytes - size(LiteralPartOfBuffer)}}.
+
+
+process_client_line(Data, Socket, #state{ rules_deciding = UndecidedRules, tls_config = TLSConfig, client_tls_active = TLS, rules_active = ActiveRules, socket = Socket, imap_session = ImapSession, deflator = Deflator, server_config = ServerConfig} = State, Acc) ->
+    ClientDataComponents = eimap_utils:split_command_into_components(Data),
+    case check_for_transmission_change_commands(TLS, TLSConfig, ClientDataComponents, Deflator, Socket) of
         { socket_upgraded, SSLSocket } ->
             %% if we have upgraded our socket, then do so to the backend if that hasn't happened auomatically
             case proplists:get_value(implicit_tls, ServerConfig, false) of
                 false -> eimap:starttls(ImapSession, undefined, undefined);
                 _ -> ok
             end,
-            { true, SSLSocket, Inflator, Deflator, UndecidedRules, ActiveRules, <<>>, undefined, undefined };
+            { Acc, State#state{ client_tls_active = true, socket = SSLSocket, buffered_client_data = <<>>, current_command_split = undefined, command_split_reset_trigger = undefined } };
         { compression, NewInflator, NewDeflator } ->
             eimap:compress(ImapSession), % TODO: make optional
-            { TLS, Socket, NewInflator, NewDeflator, UndecidedRules, ActiveRules, <<>>, undefined, undefined };
+            { Acc, State#state{ inflator = NewInflator, deflator = NewDeflator, buffered_client_data = <<>>, current_command_split = undefined, command_split_reset_trigger = undefined } };
         nochange ->
-            %%lager:debug("... now applying rules"),
-            { ModifiedData, NewSplitCommand, NewSplitResetTrigger, NewUndecidedRules, NewActiveRules, PostAction } = apply_ruleset_clientside(ImapSession, Socket, PreprocessData, CurrentCommandSplit, UndecidedRules, ActiveRules),
-            %%lager:info("The modified data is: ~s", [ModifiedData]),
-            %lager:info("The post-processed data is: ~s", [PostProcessed]),
-            BufferThisData =
+            %We  first check if we have to reset the split command before we process the new command in apply_ruleset_clientside
+            NewSplit = update_split_command_state_client(ClientDataComponents, State),
+            { ModifiedData, NewSplitCommand, NewSplitResetTrigger, NewUndecidedRules, NewActiveRules, PostAction } = apply_ruleset_clientside(ImapSession, Socket, Data, ClientDataComponents, NewSplit, UndecidedRules, ActiveRules),
+            { SendThisData, BufferThisData } =
             case PostAction of
                 perform_passthrough ->
-                    %lager:info("sending (no buffer): ~s", [ModifiedData]),
-                    eimap:passthrough_data(ImapSession, ModifiedData),
-                    <<>>;
+                    {ModifiedData, <<>>};
                 buffer_data ->
-                    % Originally Aaron uses Data here, but later on this buffer is assumed to be
-                    % already decoded, so we do have to use PreprocessData here, I think.
-                    case binary:matches(PreprocessData, <<"\r\n">>) of
-                        [] ->
-                            %lager:info("buffering: ~s", [PreprocessData]),
-                            PreprocessData;
-                        List ->
-                            {FoundPos, _} = lists:last(List),
-                            % I would like to have some binary:match for the last instead of the
-                            % first occurrence; but I'm really inexperienced in erlang so I don't
-                            % know how to solve this efficiently, so I'm using binary:matches with
-                            % using the last element only
-                            SplitPos = FoundPos + 2,
-                            eimap:passthrough_data(ImapSession, binary:part(PreprocessData, 0, SplitPos)),
-                            %lager:info("sending first part: ~s", [binary:part(PreprocessData, 0, SplitPos)] ),
-                            %lager:info("buffering second part: ~s", [binary:part(PreprocessData, SplitPos, size(PreprocessData)-SplitPos)]),
-                            binary:part(PreprocessData, SplitPos, size(PreprocessData)-SplitPos)
-                    end
+                    {<<>>, Data}
             end,
-            { TLS, Socket, Inflator, Deflator, NewUndecidedRules, NewActiveRules, BufferThisData, NewSplitCommand, NewSplitResetTrigger }
-    end,
-    set_socket_active(TLSActive, CurrentSocket),
-    %buffered_client_data is already in DataToBuffer via preprocess_client_data
-    { noreply, State#state{ rules_deciding = CurrentUndecidedRules, rules_active = CurrentActiveRules,
-                            socket = CurrentSocket, client_tls_active = TLSActive,
-                            inflator = CurrentInflator, deflator = CurrentDeflator,
-                            buffered_client_data = <<DataToBuffer/binary>>,
-                            current_command_split = SplitCommand,
-                            command_split_reset_trigger = SplitResetTrigger } }.
+            { <<Acc/binary, SendThisData/binary>>, State#state{ rules_deciding = NewUndecidedRules, rules_active = NewActiveRules, buffered_client_data = BufferThisData, current_command_split = NewSplitCommand, command_split_reset_trigger = NewSplitResetTrigger } }
+    end.
 
 preprocess_client_data(undefined, Data, #state{ buffered_client_data = Buffered }) ->
     <<Buffered/binary, Data/binary>>;
 preprocess_client_data(Z, Data, #state{ buffered_client_data = Buffered }) ->
-    Inflated = joined(zlib:inflate(Z, Data), <<>>),
+    Inflated = iolist_to_binary(zlib:inflate(Z, Data)),
     <<Buffered/binary, Inflated/binary>>.
 
 postprocess_server_data(undefined, Data) ->
     %% we aren't compressing so there is nothing to do
     Data;
 postprocess_server_data(Z, Data) ->
-    joined(zlib:deflate(Z, Data, sync), <<>>).
-
-joined([], Binary) -> Binary;
-joined([H|Rest], Binary) -> joined(Rest, <<Binary/binary, H/binary>>).
+    iolist_to_binary(zlib:deflate(Z, Data, sync)).
 
 init_rules(RuleConfig) -> init_rule(RuleConfig, []).
 init_rule([], Acc) -> Acc;
@@ -278,21 +345,17 @@
     { ModifiedData, ModifiedRuleState } = Module:apply_to_server_message(ImapSession, ServerData, RuleState),
     apply_next_rule_serverside(ImapSession, ModifiedData, [{ Module, ModifiedRuleState } | ActiveRulesAcc], ActiveRules).
 
-apply_ruleset_clientside(_ImapSession, _Socket, ClientData, _CurrentCommandSplit, [], []) ->
+apply_ruleset_clientside(_ImapSession, _Socket, ClientData, _ClientDataComponents, _CurrentCommandSplit, [], []) ->
     { ClientData, undefined, [], [], [], perform_passthrough };
-apply_ruleset_clientside(ImapSession, Socket, ClientData, CurrentCommandSplit, UndecidedRules, CurrentlyActiveRules) ->
+apply_ruleset_clientside(ImapSession, Socket, ClientData, ClientDataComponents, CurrentCommandSplit, UndecidedRules, CurrentlyActiveRules) ->
     { PostAction, SplitCommand, SplitResetTrigger } =
         case CurrentCommandSplit of
             undefined ->
-                %We first have to check whether the command is an empty line. In such a case split_command_into_components would return an empty command,
-                %even though the command is complete.
-                case ClientData of
-                    <<"\r\n">> -> { perform_passthrough, CurrentCommandSplit, reset_for_next_client_command };
-                    _ ->
-                        case eimap_utils:split_command_into_components(ClientData) of
-                            { _Tag, <<>>, <<>> } -> { buffer_data, undefined, reset_for_next_client_command };
-                            { _Tag, Command, _Data } = Split -> { perform_passthrough, Split, when_to_reset_split(Command) }
-                        end
+                case ClientDataComponents of
+                    % In case of an empty line ("\r\n") the line is complete (doesn't need to be buffered), but there is also no command or tag.
+                    { <<>>, <<>>, <<>> } -> { perform_passthrough, CurrentCommandSplit, reset_for_next_client_command };
+                    { _Tag, <<>>, <<>> } -> { buffer_data, undefined, reset_for_next_client_command };
+                    { _Tag, Command, _Data } = Split -> { perform_passthrough, Split, when_to_reset_split(Command) }
                 end;
             _ ->  { perform_passthrough, CurrentCommandSplit, reset_for_next_client_command }
         end,
@@ -333,8 +396,8 @@
     %lager:debug("Sending over TLS!"),
     ssl:send(Socket, Data).
 
-check_for_transmission_change_commands(TLS, TLSConfig, Buffer, Deflator, Socket) ->
-    {Tag, Command, _Data } = eimap_utils:split_command_into_components(Buffer),
+check_for_transmission_change_commands(TLS, TLSConfig, ClientDataComponents, Deflator, Socket) ->
+    {Tag, Command, _Data } = ClientDataComponents,
     case check_tls_state(TLS, TLSConfig, Command, Deflator, Socket, Tag) of
         nochange -> check_compress_request(Deflator, Command, Socket, TLS, Tag);
         Response -> Response
@@ -366,9 +429,6 @@
     { compression, Inflator, Deflator }.
 
 
-set_socket_active(true, Socket) -> ssl:setopts(Socket, [{ active, once }]);
-set_socket_active(_, Socket) -> inet:setopts(Socket, [{ active, once }]).
-
 -spec correct_hello(TLSActive :: true | false, ImplicitTLS :: true | false, TlSConfig :: [] | list(), ServerHello :: binary()) -> CorrectedHello :: binary().
 correct_hello(true, true, _TLSConfig, ServerResponse) ->
     % the connection is already secured, so don't advertise starttls to the client

guam-0.9.9.tar.gz/apps/kolab_guam/src/kolab_guam_session.hrl Added

guam-0.9.9.tar.gz/apps/kolab_guam/test/kolab_guam_session_SUITE.erl Added

@@ -0,0 +1,370 @@
+%% Copyright 2015 Kolab Systems AG (http://www.kolabsys.com)
+%%
+%% Christian Mollekopf (Kolab Systems) <mollekopf@kolabsystems.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/>.
+
+-module(kolab_guam_session_SUITE).
+
+% easier than exporting by name
+-compile(export_all).
+
+% required for common_test to work
+-include_lib("common_test/include/ct.hrl").
+-include("../src/kolab_guam_session.hrl").
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% common test callbacks %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Specify a list of all unit test functions
+all() -> [
+          kolab_guam_session_test_client,
+          kolab_guam_session_test_server,
+          kolab_guam_session_test_client_benchmark
+         ].
+
+% required, but can just return Config. this is a suite level setup function.
+init_per_suite(Config) ->
+        Config.
+
+% required, but can just return Config. this is a suite level tear down function.
+end_per_suite(Config) ->
+        Config.
+
+% optional, can do function level setup for all functions,
+% or for individual functions by matching on TestCase.
+init_per_testcase(_TestCase, Config) ->
+        Config.
+
+% optional, can do function level tear down for all functions,
+% or for individual functions by matching on TestCase.
+end_per_testcase(_TestCase, Config) ->
+        Config.
+
+
+kolab_guam_session_test_client(_TestConfig) ->
+    %% setup boilerplate
+    ServerConfig = kolab_guam_sup:default_imap_server_config(),
+    { ok, ImapSession } = eimap:start_link(ServerConfig),
+    { ok, Socket } = gen_tcp:listen(9964, [ { reuseaddr, true }, {active, false}, inet6 ]),
+
+    lager:start(),
+    lager:set_loglevel(lager_console_backend, debug),
+
+    ActiveRules = [{ kolab_guam_rule_filter_groupware, kolab_guam_rule_filter_groupware:new({}) }],
+
+    State = #state{
+      socket = Socket,
+      server_config = ServerConfig,
+      imap_session = ImapSession
+    },
+
+    %handle_info
+    {noreply, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = undefined,
+      command_split_reset_trigger = [] %FIXME ?
+     }} = kolab_guam_session:handle_info({tcp, Socket, <<"y1 ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\ny3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>}, State#state{ rules_deciding = [] }),
+
+    % Run without rules
+    {<<"y1 ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\ny3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = undefined,
+      command_split_reset_trigger = [] %FIXME ?
+     }} = kolab_guam_session:process_client_data(Socket, <<"y1 ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\ny3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>, State#state{ rules_deciding = [] }),
+
+
+    % Activate filtering
+    {<<"y1 ID (\"name\" \"Test\")\r\n">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = {<<"y1">>,<<"ID">>,<<"(\"name\" \"Test\")">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      rules_deciding = [],
+      rules_active = [{kolab_guam_rule_filter_groupware, _}]
+     }} = kolab_guam_session:process_client_data(Socket, <<"y1 ID (\"name\" \"Test\")\r\n">>, State#state{ rules_deciding = ActiveRules }),
+
+
+    % Append
+    {<<"y1 APPEND INBOX {30}\r\n0123">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = {<<"y1">>,<<"APPEND">>,<<"INBOX {30}">>},
+      command_split_reset_trigger = reset_for_next_client_command
+     } = IntermediateState4} = kolab_guam_session:process_client_data(Socket, <<"y1 APPEND INBOX {30}\r\n0123">>, State#state{ rules_deciding = ActiveRules }),
+
+    {<<"456789">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>, %This ensures we aren't buffering during the continuation
+      current_command_split = {<<"y1">>,<<"APPEND">>,<<"INBOX {30}">>},
+      command_split_reset_trigger = reset_for_next_client_command
+     } = IntermediateState5} = kolab_guam_session:process_client_data(Socket, <<"456789">>, IntermediateState4),
+
+    {<<"0123456789012345678">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>, %This ensures we aren't buffering during the continuation
+      current_command_split = {<<"y1">>,<<"APPEND">>,<<"INBOX {30}">>},
+      command_split_reset_trigger = reset_for_next_client_command
+     } = IntermediateState6} = kolab_guam_session:process_client_data(Socket, <<"0123456789012345678">>, IntermediateState5),
+
+    {<<"9\r\ny2 ENABLE QRESYNC\r\n">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = {<<"y2">>,<<"ENABLE">>,<<"QRESYNC">>},
+      command_split_reset_trigger = reset_for_next_client_command
+     }} = kolab_guam_session:process_client_data(Socket, <<"9\r\ny2 ENABLE QRESYNC\r\n">>, IntermediateState6),
+
+    % Append2
+    {<<"y1 APPEND INBOX {36}\r\n0123">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = {<<"y1">>,<<"APPEND">>,<<"INBOX {36}">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      continuation_bytes = 32
+     } = IntermediateState7} = kolab_guam_session:process_client_data(Socket, <<"y1 APPEND INBOX {36}\r\n0123">>, State#state{ rules_deciding = ActiveRules }),
+
+    {<<"456789\r\n0123456789\r\n0123456789">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>, %This ensures we aren't buffering during the continuation
+      current_command_split = {<<"y1">>,<<"APPEND">>,<<"INBOX {36}">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      continuation_bytes = 2
+     } = IntermediateState8} = kolab_guam_session:process_client_data(Socket, <<"456789\r\n0123456789\r\n0123456789">>, IntermediateState7),
+
+    {<<"\r\n">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>, %This ensures we aren't buffering during the continuation
+      current_command_split = {<<"y1">>,<<"APPEND">>,<<"INBOX {36}">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      continuation_bytes = 0
+     }} = kolab_guam_session:process_client_data(Socket, <<"\r\n">>, IntermediateState8),
+
+
+    % Don't activate filtering
+    {<<"y1 ID (\"name\" \"Test/KOLAB\")\r\n">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = {<<"y1">>,<<"ID">>,<<"(\"name\" \"Test/KOLAB\")">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      rules_deciding = [],
+      rules_active = []
+     }} = kolab_guam_session:process_client_data(Socket, <<"y1 ID (\"name\" \"Test/KOLAB\")\r\n">>, State#state{ rules_deciding = ActiveRules }),
+
+
+    % Lone tag in a packet. Can/Could happen with iPhone apparently. (See commit 89f9dc93757c68032ed17f42838858bdfaefa408)
+    {<<>>, #state{ buffered_client_data = <<"y1">>, rules_active = [] } = IntermediateState1} = kolab_guam_session:process_client_data(Socket, <<"y1">>, State#state{ rules_deciding = ActiveRules }),
+    {<<"y1 ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\n">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = {<<"y2">>,<<"ENABLE">>,<<"QRESYNC">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      rules_deciding = [],
+      rules_active = [{kolab_guam_rule_filter_groupware, _}]
+     }} = kolab_guam_session:process_client_data(Socket, <<" ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\n">>, IntermediateState1),
+
+
+    % Lone tag in a packet, but with a \r\n before. See guam-0.9.2-stalling-client-buffer-and-split-command-handling.patch (This triggers the odd List buffering case)
+    {<<"\r\n">>, #state{ buffered_client_data = <<"y1 ">>, rules_active = [] } = IntermediateState2} = kolab_guam_session:process_client_data(Socket, <<"\r\ny1 ">>, State#state{ rules_deciding = ActiveRules }),
+    {<<"y1 ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\n">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = {<<"y2">>,<<"ENABLE">>,<<"QRESYNC">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      rules_deciding = [],
+      rules_active = [{kolab_guam_rule_filter_groupware, _}]
+     }} = kolab_guam_session:process_client_data(Socket, <<"ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\n">>, IntermediateState2),
+
+
+    % Empty line (should be considered a complete command and should not be buffered)
+    {<<"\r\n">>, #state{ buffered_client_data = <<>>, rules_active = [] } = IntermediateState3} = kolab_guam_session:process_client_data(Socket, <<"\r\n">>, State#state{ rules_deciding = ActiveRules }),
+    {<<"y1 ID (\"name\" \"Test\")\r\n">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = {<<"y1">>,<<"ID">>,<<"(\"name\" \"Test\")">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      rules_deciding = [],
+      rules_active = [{kolab_guam_rule_filter_groupware, _}]
+     }} = kolab_guam_session:process_client_data(Socket, <<"y1 ID (\"name\" \"Test\")\r\n">>, IntermediateState3),
+
+
+    % Activate with multi-line packet
+    {<<"y1 ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\ny3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = {<<"y3">>,<<"LIST">>,<<"\"\" \"%\" RETURN (SUBSCRIBED))">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      rules_deciding = [],
+      % Make sure that we have processed y3 in here (and don't stop processing at y1)
+      rules_active = [{kolab_guam_rule_filter_groupware, {state,undefined,<<"y3">>,true,<<>>,[<<"LIST">>,<<"list">>,<<"XLIST">>,<<"xlist">>,<<"LSUB">>,<<"lsub">>]}}]
+      % rules_active = [{kolab_guam_rule_filter_groupware, _}]
+     }} = kolab_guam_session:process_client_data(Socket, <<"y1 ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\ny3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>, State#state{ rules_deciding = ActiveRules }),
+
+
+    % Test various packet splits
+    PacketsSplits = [
+        [<<"y1 ID (\"name\" \"Test\")\r\n">>, <<"y2 ENABLE QRESYNC\r\n">>, <<"y3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>],
+        [<<"y1 ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\ny3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>],
+        [<<"y1 ID (\"name\" \"Test\")">>, <<"\r\ny2">>, <<" ENABLE QRESYNC\r\ny3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>],
+        [<<"y1 ID (\"name\" \"Test\")">>, <<"\r\n">>, <<"y2 ENABLE QRESYNC\r\ny3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>],
+        [<<"y1">>, <<" ">>, <<"ID">>, <<" (\"name\" \"Test\")\r\n">>, <<"y2 ENABLE QRESYNC\r\ny3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>]
+    ],
+
+     lists:foldl(fun(Packets, _) ->
+                    try_packets(Packets, Socket, ServerConfig, State#state{ rules_deciding = ActiveRules })
+                end,
+                undefined,
+                PacketsSplits),
+
+
+    lager:info("Done").
+
+
+try_packets(Packets, Socket, ServerConfig, State) ->
+    #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      current_command_split = {<<"y3">>,<<"LIST">>,<<"\"\" \"%\" RETURN (SUBSCRIBED))">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      rules_deciding = [],
+      % Make sure that we have processed y3 in here (and don't stop processing at y1)
+      rules_active = [{kolab_guam_rule_filter_groupware, {state,undefined,<<"y3">>,true,<<>>,[<<"LIST">>,<<"list">>,<<"XLIST">>,<<"xlist">>,<<"LSUB">>,<<"lsub">>]}}]
+     } = lists:foldl(fun(Packet, _State) ->
+                        {_, NewState} = kolab_guam_session:handle_info({tcp, Socket, Packet}, _State),
+                        NewState
+                    end,
+                    State,
+                    Packets).
+
+
+kolab_guam_session_test_server(_TestConfig) ->
+    %% setup boilerplate
+    % gen_tcp:connect
+    ServerConfig = kolab_guam_sup:default_imap_server_config(),
+    { ok, ImapSession } = eimap:start_link(ServerConfig),
+    { ok, Socket } = gen_tcp:listen(9964, [ { reuseaddr, true }, {active, false}, inet6 ]),
+
+    lager:start(),
+    lager:set_loglevel(lager_console_backend, debug),
+
+    ActiveRules = [{ kolab_guam_rule_filter_groupware, kolab_guam_rule_filter_groupware:new({}) }],
+
+    State = #state{
+      socket = Socket,
+      server_config = ServerConfig,
+      imap_session = ImapSession
+    },
+
+
+    % This should trigger a metadata request
+    {noreply, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      % current_command_split = {<<"y1">>,<<"ID">>,<<"(\"name\" \"Test\")">>},
+      current_command_split = {<<"y3">>,<<"LIST">>,<<"\"\" \"%\" RETURN (SUBSCRIBED))">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      rules_deciding = [],
+      rules_active = [{kolab_guam_rule_filter_groupware, _}]
+    } = IntermediateState1} = kolab_guam_session:handle_info({tcp, Socket, <<"y1 ID (\"name\" \"Test\")\r\ny2 ENABLE QRESYNC\r\ny3 LIST \"\" \"%\" RETURN (SUBSCRIBED))\r\n">>}, State#state{ rules_deciding = ActiveRules }),
+
+
+    {noreply, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      % current_command_split = {<<"y1">>,<<"ID">>,<<"(\"name\" \"Test\")">>},
+      current_command_split = undefined,
+      command_split_reset_trigger = reset_for_next_client_command,
+      rules_deciding = [],
+      rules_active = [{kolab_guam_rule_filter_groupware, _}]
+    } = IntermediateState2} = kolab_guam_session:handle_info({imap_server_response, <<"* ID (\"name\" \"Cyrus IMAPD\")\n\ry1 OK Completed\r\n">>}, IntermediateState1),
+
+    {noreply, #state{
+      server_config = ServerConfig,
+      buffered_client_data = <<>>,
+      % current_command_split = {<<"y1">>,<<"ID">>,<<"(\"name\" \"Test\")">>},
+      command_split_reset_trigger = reset_for_next_client_command,
+      rules_deciding = [],
+      rules_active = [{kolab_guam_rule_filter_groupware, _}]
+    }} = kolab_guam_session:handle_info({imap_server_response, <<"* METADATA INBOX (/shared/vendor/kolab/folder-type \"mail\")\r\n">>}, IntermediateState2),
+
+% <<"* METADATA Archive (/shared/vendor/kolab/folder-type NIL)\r\n">
+% <<"* METADATA Calendar (/shared/vendor/kolab/folder-type \"event\")\r\n">
+% <<"EG0001 OK Completed\r\n">>
+
+    lager:info("Done").
+
+
+
+kolab_guam_session_test_client_benchmark(_TestConfig) ->
+    %% setup boilerplate
+    ServerConfig = kolab_guam_sup:default_imap_server_config(),
+    { ok, ImapSession } = eimap:start_link(ServerConfig),
+    { ok, Socket } = gen_tcp:listen(9964, [ { reuseaddr, true }, {active, false}, inet6 ]),
+
+    lager:start(),
+    lager:set_loglevel(lager_console_backend, debug),
+
+    ActiveRules = [{ kolab_guam_rule_filter_groupware, kolab_guam_rule_filter_groupware:new({}) }],
+
+    State = #state{
+      socket = Socket,
+      server_config = ServerConfig,
+      imap_session = ImapSession
+    },
+
+    Count = 70,
+    % We used to have a factor of 10 in runtime between \r\n (causing line splits), and just \n (not causing line splits)
+    Payload = <<"0123456789\r\n">>,
+    Data = list_to_binary(lists:duplicate(Count, Payload)),
+    BinaryCount = list_to_binary(integer_to_list(Count * size(Payload) + 36)),
+    ExpectedCommandSplit = {<<"y1">>, <<"APPEND">>, list_to_binary([<<"INBOX {">>, BinaryCount, <<"}">>])},
+
+    S = os:timestamp(),
+
+    % Append
+    {noreply, #state{
+      server_config = ServerConfig,
+      current_command_split = ExpectedCommandSplit,
+      command_split_reset_trigger = reset_for_next_client_command
+     } = IntermediateState4} = kolab_guam_session:handle_info({tcp, Socket, list_to_binary([<<"y1 APPEND INBOX {">>, BinaryCount, <<"}\r\n0123">>])}, State#state{ rules_deciding = ActiveRules }),
+
+    {noreply, #state{
+      server_config = ServerConfig,
+      current_command_split = ExpectedCommandSplit,
+      command_split_reset_trigger = reset_for_next_client_command
+     } = IntermediateState5} = kolab_guam_session:handle_info({tcp, Socket, <<"456789\r\n0123456789\r\n0123456789">>}, IntermediateState4),
+
+
+    {noreply, #state{
+      server_config = ServerConfig,
+      current_command_split = ExpectedCommandSplit,
+      command_split_reset_trigger = reset_for_next_client_command
+     } = IntermediateState6} = kolab_guam_session:handle_info({tcp, Socket, <<"\r\n">>}, IntermediateState5),
+
+    {noreply, #state{
+      server_config = ServerConfig,
+      current_command_split = ExpectedCommandSplit,
+      command_split_reset_trigger = reset_for_next_client_command
+     }} = kolab_guam_session:handle_info({tcp, Socket, Data}, IntermediateState6),
+
+
+    E = os:timestamp(),
+    X = timer:now_diff(E,S),
+    lager:info("Runtime: ~p usecs", [X]),
+
+
+    lager:info("Done").

guam-0.9.5.tar.gz/contrib/guam.service -> guam-0.9.9.tar.gz/contrib/guam.service Changed

guam-0.9.5.tar.gz/rebar.config -> guam-0.9.9.tar.gz/rebar.config Changed

guam-0.9.5.tar.gz/rebar3 -> guam-0.9.9.tar.gz/rebar3 Changed

guam.dsc Changed

plesk.sys.config Changed

Changes of Revision 37