These samples demonstrate how to do a few things with the Meanwhile

library. Some of these are also tools which can be used to help in

debugging and obtaining protocol information.

Examples

========

 socket.c

Compile with `./build socket`. This is the simplest possible

client. All it does is connect and authenticate to a host (specified

on the command line). Most of the code is dedicated to performing I/O.

 sendmessage.c

Compile with `./build sendmessage`. Expands upon socket.c to send a

message via the IM service after login, then immediately logs off and

exits.

 echo.c  (forthcoming)

Compile with `./build echo`. This extends on the socket example above,

but introduces the use of the IM service. All incoming messages will

be echo'd verbatim back at whomever sends them. Can anger co-workers.

 pipe.c  (forthcoming)

Compile with `./build pipe`. Extending upon the echo example, but is

slightly more amusing and can be possibly useful for scripting. Will

output all incoming IM messages to stdout. Listens on stdin and will

write each line from stdin back to anyone who sent us a message

(responding in order received)

Since this application uses stdout, glib logging is smothered.

 blist_storage.c  (forthcoming)

Compile with `./build blist_storage`. An example of the Storage

service and buddy list parser. Operates in two modes, up and down. In

up mode, this sample will read a buddy list file on stdin, check it

for validity, then upload it to the storage service. In down mode,

this sample will fetch the buddy list from the storage service and

write it to stdout.

Since this application uses stdout, glib logging is smothered.

Utilities

=========

 redirect_server.c

Compile with `./build redirect_server`. Acts as a redirecting sametime

server; any client attempting to connect to the socket this utility

listens on will be instructed to redirect its connection to an

alternative host (which is specified on the command line). Useful for

ensuring client code can handle redirects correctly when there's no

real redirecting server to test against.

 nocipher_proxy.c

Compile with `./build nocipher_proxy`. Acts as a sametime server

proxy, passing messages between a real client and server. However, it

will intercept and mangle channel creation messages to ensure that

they will not be used with encryption. This will cause many clients to

fail in strange places (where they demand encryption), but is useful

for getting some messages from a service in the clear. Will print all

messages in hex pairs to stdout using the hexdump utility. This may be

more useful than using ethereal, as it will actually group its output

by message rather than by receipt from the TCP stream.

 login_server.c

Compile with `./build login_server`. Acts as a sametime server; any

client attempting to connect to the socket this utility listens on

will be able to complete handshaking and send a login message. The

tool then analyzes the authentication method and data and prints the

decrypted data to stdout. This was useful for reverse-engineering the

RC2/128 auth method (and determining what one of the guint32 fields of

the handshake ack was for). Probably not very useful for anything

else.

 logging_proxy.c

Compile with `./build logging_proxy`. Acts as a sametime server proxy,

passing messages between a real client and server. However, it will

intercept and mangle channel data in order to obtain the unencrypted

data. This should be invisible to both the client and the server. Will

print all messages in hex pairs to stdout using the hexdump utility,

and will print decrypted contents of encrypted channel messages

separately. This is certainly more useful than using ethereal, as it

groups its output by message as well as provides an unencrypted view

of otherwise obscured service protocols.