1.1. Zaczynamy.

Bibliotekę libtlen można wykorzystać w programach pisanych w C oraz C++. Należy tylko dołączać plik nagłówkowy biblioteki jak na przykładzie poniżej

    #include <libtlen/libtlen.h>
    

oraz linkować z biblioteką tlen, np:

    gcc -g -Wall -O2 -ltlen main.c -o main
    

Wszystkie funkcje oraz nazwy struktur z biblioteki dostępne dla programisty mają przedrostek tlen_, natomiast stałe zdefiniowane przedrostek TLEN_. Przed połączeniem z serwerem należy zadeklarować wskaźnik na strukturę tlen_session. W tej strukturze przechowywane są informacje o danej sesji. Jeśli chcemy, aby biblioteka wypisywała informacje o wykonywanych operacjach (np. łączenie z serwerem, autoryzacja) uruchamiamy funkcję

    tlen_setdebug(1);
    

Teraz można przejść do logowania. Dostępne są dwie funkcje: tlen_login oraz tlen_login_nb. Obie wymagają podania dwóch parametrów, odpowiednio loginu i hasła w postaci 'const char *'. Różnią się tym, że pierwsza z nich blokuje program zanim połączy się z serwerem, druga natomiast łączy się z serwerem w oddzielnym procesie, dzięki czemu program nie jest blokowany i przechodzi do obsługi zdarzeń (o tym później). Obie funkcję zwracają wskaźnik na strukturę tlen_session, który należy zachować (będzie potrzebny we wszystkich dalej opisanych funkcjach), lub NULL jeśli logowanie nie powiodło się. Po wywołaniu jednej z tych funkcji przechodzimy do obsługi zdarzeń.

1.2. Zdarzenia.

O wszystkich zdarzeniach (nowa wiadomość, zmiana statusu kogoś z listy użytkowników, itp) program jest powiadamiany za pomocą eventów, których nazwy mają przedrostek TLEN_EVENT_. Poniżej opiszę poszczególne eventy, a potem pokażę przykładową pętlę obsługującą je.

    tlen_presence(sesja,TLEN_STATUS_AVAILABLE,"Dostępny");
    

1.3. Połączmy się.

Załóżmy, że mamy już zadeklarowany w programie wskaźnik na strukturę tlen_session, czyli "struct tlen_session *sesja". Aby pobrać z kolejki zdarzenie potrzebujemy następujących zmiennych:

  fd_set rd, wr;            // obserwowane deskryptory socketów
  struct tlen_event *event; // wskaźnik na zdarzenie
  struct timeval tv;        // czas blokowania programu przez select
  

Inicjalizujemy te zmienne:

  tv.tv_sec = 0;
  tv.tv_usec = 1; // jeśli brak danych to funkcja select nie blokuje programu
  FD_ZERO (&rd);
  FD_ZERO (&wr);
  if ((sesja->check & TLEN_CHECK_READ)) // jeśli czytamy dane
    FD_SET (sesja->fd, &rd);
  if ((sesja->check & TLEN_CHECK_WRITE)) // jeśli wysyłamy dane
    FD_SET (sesja->fd, &wr);
  

Sprawdzamy obecność danych:

  if (select (sesja->fd + 1, &rd, &wr, NULL, &tv) == -1)
  {
    perror("select"); // błąd z deskryptorem?
    exit(1); //wychodzimy z programu
  }
  

Pobieramy zdarzenie:

  if (sesja && (FD_ISSET (sesja->fd, &rd) || FD_ISSET (sesja->fd,
  &wr)))
  {
    tlen_watch_fd (sesja);
    while ((event=tlen_getevent(sesja))!=NULL)
    {
      switch (event->type)
      {
        case TLEN_EVENT_NOWGETID:
        //...
      }
      tlen_freeevent(event); //zwalniamy pamięć
    }
  

Tu zaczyna się obsługa zdarzeń, o której była mowa wcześniej. Powyższy kod należy umieścic w funkcji, którą wywołujemy np. co sekundę. Ponadto aby serwer nie zerwał połączenia należy co jedną minutę wywoływać funkcję "tlen_ping(sesja)". Podczas działania programu sprawdzamy pole "error" w strukturze tlen_session, jeśli jest różne od zera, ponownie łączymy się z serwerem.

2.1. Tagi z parametrami katalogu publicznego

Parametry wyszukiwania:

• <first> imię </first>

• <last> nazwisko </last>

• <nick> nick </nick>

• <email> email </email>

• <c> miasto </c>

• <s> płeć </s> (TLEN_PUBDIR_GENDER_)

• <d> minimalny wiek </d>

• <u> maksymalny wiek </u>

• <r> poszukuję </r> (TLEN_PUBDIR_LOOK_)

• <g> rozmowa głosowa </g> (TLEN_PUBDIR_VOICE_)

• <j> zawód </j> (TLEN_PUBDIR_JOB_)

• <m> stan </m> (TLEN_STATUS_)

• <p> plany </p> (TLEN_PUBDIR_PLANS_)

• <e> szkoła </e>

• <i> identyfikator </i>

Parametry naszych danych z katalogu publicznego są takie same jak wyszkiwaniu z róznicami:

• <v> widoczność naszego stanu </v>

• <d>, <u> zastąpione przez <b> - rok urodzenia

W naszych danych nie ma pola <i> !

2.2. Odczyt danych z katalogu publicznego

Aby odczytać nasze dane z katalogu publicznego, wysyłamy zapytanie:

    <iq type="get" id="tr" to="tuba"><query xmlns="jabber:iq:register"></query></iq>
    

Serwer zwróci nam:

    <iq type="result" id="tr" to="id@tlen.pl/t" from="tuba"><query xmlns="jabber:iq:register"><item>parametry</item></query></iq>
    

parametry to tagi, które musimy parsować

2.3. Zmiana naszych danych w katalogu publicznym

Aby zmienić nasze dane w katalogu publicznym, wysyłamy zapytanie:

    <iq type="set" id="tr" to="tuba"><query xmlns="jabber:iq:register">parametry</query></iq>
    

gdzie parametry to tagi (takie samej jak przy odbiorze danych). Jeżeli wszystko poszło prawidłowo i nasze dane zostały uaktualnione, serwer zwróci potwierdzenie w postaci

    <iq type="result" id="tw" to="id@tlen.pl/t" from="tuba"><query xmlns="jabber:iq:register"></query></iq>
    

2.4. Wyszukiwanie

    <iq type="get" id="src" to="tuba"><query xmlns="jabber:iq:search">tutaj to czego szukamy</query></iq>
    

    <iq type="result" id="src" to="id/@tlen.pl/t" from="tuba" n="1"><query xmlns="jabber:iq:search">
	<item jid="jakistamid@tlen.pl">parametry</item>
	<item jid="jakistamid@tlen.pl">parametry</item>	
    </query></iq>
    

3.1. auth.c

Opis funkcji zawartych w pliku auth.c

3.2. events.c

Opis funkcji zawartych w pliku events.c

3.3. expat.c

Opis funkcji zawartych w pliku expat.c

3.4. groupchat.c

Opis funkcji zawartych w pliku groupchat.c

3.5. hashtable.c

Opis funkcji zawartych w pliku hashtable.c

3.6. hub.c

Opis funkcji zawartych w pliku hub.c

3.7. libtlen.c

Opis funkcji zawartych w pliku libtlen.c

3.8. message.c

Opis funkcji zawartych w pliku message.c

3.9. pool.c

Opis funkcji zawartych w pliku pool.c

3.10. pubdir.c

Opis funkcji zawartych w pliku pubdir.c

3.11. rate.c

Opis funkcji zawartych w pliku rate.c

3.12. roster.c

Opis funkcji zawartych w pliku roster.c

3.13. snprintf.c

Opis funkcji zawartych w pliku snprintf.c

3.14. sockets.c

Opis funkcji zawartych w pliku sockets.c

3.15. str.c

Opis funkcji zawartych w pliku str.c

3.16. testclient.c

Opis funkcji zawartych w pliku testclient.c

3.17. utils.c

Opis funkcji zawartych w pliku utils.c

3.18. xmlnode.c

Opis funkcji zawartych w pliku xmlnode.c

3.19. xmlparse.c

Opis funkcji zawartych w pliku xmlparse.c

3.20. xmlrole.c

Opis funkcji zawartych w pliku xmlrole.c

3.21. xmltok.c

Opis funkcji zawartych w pliku xmltok.c

3.22. xmltok_impl.c

Opis funkcji zawartych w pliku xmltok_impl.c

3.23. xmltok_ns.c

Opis funkcji zawartych w pliku xmltok_ns.c

4.1. examples/sendmsg.c

Omówienie programu examples/sendmsg.c

Po więcej informacji zajżyj do rozdziału o lib/testclient.c, gdyż podstawa dokumentacji na nim się opiera.

#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/select.h> #include <sys/time.h> #include <sys/types.h> #include <signal.h>

Inkludujemy nagłówek libtlen

#include "libtlen.h" int main (int argc, char **argv) {

Deklarujemy strukturę sesji

struct tlen_session *sesja; struct tlen_event *event; struct timeval tv; tlen_setdebug(0); if (argc==5) {

Inicjujemy sesję

sesja = tlen_init();

Ustawiamy użytkownika i hasło z parametru programu

tlen_set_auth(sesja,argv[1],argv[2]);

Łączenie z hubem ma przebiegać jako nieblokowalne

tlen_set_hub_blocking(sesja,0);

Okej, łączymy

tlen_login(sesja); } else { printf("Usage: %s login password user message\n",argv[0]); return 1; } // tutaj jest obserwowany socket while ((!sesja->error)) { fd_set rd, wr; int retval; tv.tv_sec = 60; tv.tv_usec = 0; FD_ZERO (&rd); FD_ZERO (&wr);

Ustawiamy opcje monitorowania deskryptorów

if ((sesja->check & TLEN_CHECK_READ)) FD_SET (sesja->fd, &rd); if ((sesja->check & TLEN_CHECK_WRITE)) FD_SET (sesja->fd, &wr); if ((retval = select (sesja->fd + 1, &rd, &wr, NULL, &tv) == -1)) { perror ("select"); } else if (sesja && (FD_ISSET (sesja->fd, &rd) || FD_ISSET (sesja->fd, &wr))) {

Sprawdzamy co się zmieniło na gnieździe

tlen_watch_fd (sesja);

Pętla obsługi zdarzeń

while ((event=tlen_getevent(sesja))!=NULL) { switch (event->type) {

Połączony! Pobieramy id.

case TLEN_EVENT_NOWGETID: { tlen_getid(sesja); break; }

Logujemy się

case TLEN_EVENT_GOTID: { tlen_authorize(sesja); break; }

Udało się - pobieramy książkę adresową

case TLEN_EVENT_AUTHORIZED: { tlen_getroster(sesja); break; }

Ups - coś nie wyszło. Wychodzimy

case TLEN_EVENT_UNAUTHORIZED: { exit(0); break; }

Książka adresowa się odebrała (nie obsługujemy poszczególnych elementów, bo nie ma po co. Możemy więc wysłać wiadomość (TLEN_MESSAGE, nie TLEN_CHAT), a następnie się rozłączyć

case TLEN_EVENT_ENDROSTER: { tlen_sendmsg(sesja,argv[3],argv[4],TLEN_MESSAGE); tlen_presence_disconnect (sesja); tlen_freesession (sesja); break; } }

Zwalniamy zdarzenie

tlen_freeevent(event); } } return 0; }

4.2. lib/testclient.c

Omówienie programu lib/testclient.c

Ostatnia aktualizacja: - $Id: libtlen.html,v 1.25 2003/04/04 19:14:19 mati Exp $

#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/select.h> #include <sys/time.h> #include <sys/types.h> #include <signal.h>

Dołączamy nagłówek libtlen.h w którym zawarte są wszystkie informacje o zdarzeniach, funkcjach, strukturach itp. Bez tego ani rusz!

#include "libtlen.h"

Zmienna służąca do zamknięcia klienta - obsługiwana w handlerze dla wciśnięcia CTRL+C

int terminate=0;

Zmienna klienta informująca kiedy był ostatni ping do serwera - w tym przypadku potrzebna, żeby pingać tylko co 60 sekund.

int last_ping_time;

Wewnętrzny handler klienta ustawiający zmienną na 1 - wywoływany podczas CTRL+C

void termhandler(int sig) { terminate=1; }

Głowna funkcja programu - tutaj będzie miąchanie z tlenem

int main (int argc, char **argv) {

Definiujemy strukturę typu tlen_session opisującą wszystko co z naszym tlenowym połączeniem związane. Przechowuje ona gniazda, zdarzenia i inne potrzebne rzeczy

struct tlen_session *sesja;

Struktura typu tlen_event służy do przechowywania informacji o zdarzeniach - do niej będą pobierane zdarzenia w głównej pętli tlenowej.

struct tlen_event *event;

Struktura nie związana z libtlen - potrzebna przy takim a nie innym rozwiązaniu monitorowania gniazda - określa timeout.

struct timeval tv;

Łączymy SIGINT (Ctrl+C) z naszym handlerem (termhandler), pozwoli to na poprawne zamknięcie połączenia - tzn. jego obsłużenie, zamiast twardego wyjścia z programu

signal(SIGINT,termhandler);

Funkcja biblioteki, pozwalająca na sterowanie informacjami dodatkowymi (debug). Ustawiając jej parametr 1 włączamy debugowanie, od tej pory biblioteka będzie wypluwała na stderr wszystkie informacje pomocnicze.

tlen_setdebug(1);

Sprawdzamy, czy liczba parametrów przekazanych do programu jest równa 2 - użytkownik i hasło (+1, gdyż pierwszym z nich jest sama nazwa programu, której my nie przekazujemy).

if (argc==3) {

Inicjujemy sesję przy użyciu funkcji tlen_init()

sesja = tlen_init();

Przy użyciu funkcji tlen_set_auth() przekazujemy do biblioteki nazwę użytkownika i hasło

tlen_set_auth(sesja,argv[1],argv[2]);

Funkcja tlen_set_hub_blocking() ustawia, czy proces łączenia z HUBem ma być synchroniczny, czy asynchroniczny (blokowalny/nieblokowalny) - ustawiamy asynchroniczność.

tlen_set_hub_blocking(sesja,0);

tlen_login() inicjuje połączenie z serwerem Tlenu. Najpierw łączy się z hubem, następnie pobiera adres serwera i się z nim łączy. Pobranie ID oraz autoryzacja następują automagicznie.

tlen_login(sesja); } else { printf("Usage: %s login password\n",argv[0]); return 1; }

Punkt kulminacyjny klienta - główna pętla obsługi zdarzeń

while ((!terminate)&&(!sesja->error)) {

zmienne potrzebne do poprawnego sterowania obserwacją gniazda

fd_set rd, wr; int retval;

Ustawiamy timeout dla serwera na 60 sekund

tv.tv_sec = 60; tv.tv_usec = 0;

Zerujemy deskryptory

FD_ZERO (&rd); FD_ZERO (&wr);

Wchodzi kawałek obsługi biblioteki - jeżeli libtlen prosi nas o monitorowanie kanału przychodzącego, to ustawiamy RD, zaś jeżeli kanału wychodzącego to WR. Kanał wychodzący przede wszystkim sprawdza, czy gniazdo nadaje się już do zapisy, czyli czy jesteśmy już połączeni

if ((sesja->check & TLEN_CHECK_READ)) FD_SET (sesja->fd, &rd); if ((sesja->check & TLEN_CHECK_WRITE)) FD_SET (sesja->fd, &wr);

Funkcja select - systemowa, nie związana z biblioteką, obserwuje deskryptor połączenia z serwerem - gniazdo znajduje się w strukturze sesji - jako sesja->fd

if ((retval = select (sesja->fd + 1, &rd, &wr, NULL, &tv) == -1)) { perror ("select"); terminate = 1; }

Znaleziono coś w gnieździe! Obsługujemy zdarzenia.

else if (sesja && (FD_ISSET (sesja->fd, &rd) || FD_ISSET (sesja->fd, &wr))) {

Funkcja biblioteki - tlen_watch_fd() - sprawdza, co się zmieniło na gnieździe, odczytuje dane, a następnie uzupełnia zdarzenia, które dalej będziemy obsługiwać.

tlen_watch_fd (sesja);

W pętli pobieramy zdarzenia poprzez tlen_getevent do struktury typu tlen_event (którą zadeklarowaliśmy na początku programu). Pętla obsługi zdarzeń wykonuje się tak długo, aż wszystkie czekające zdarzenia zostaną obsłużone

while ((event=tlen_getevent(sesja))!=NULL) {

Przełącznikiem switch sprawdzamy typ zdarzenia

switch (event->type) {

Dostaliśmy informację, że logowanie się powiodło, możemy więc pobrać z serwera książkę adresową - funkcja tlen_getroster()

case TLEN_EVENT_AUTHORIZED: { tlen_getroster(sesja); break; }

Po wywołaniu tlen_getroster będziemy po kolei dostawać zdarzenia typu TLEN_EVENT_GOTROSTERITEM informujące o pobraniu danych jednego użytkownika. W tym programie wypisujemy je jedynie na ekran. Dane użytkownika zawarte są w strukturze typu tlen_user. Przy każdym zdarzeniu, w którym otrzymujemy jakieś dane, do struktury tlen_event dodawana jest struktura danego zdarzenia - w tym wypadku książki adresowej.

case TLEN_EVENT_GOTROSTERITEM: { printf("Got user: %s\n",event->roster->jid); break; }

Otrzymaliśmy całą książkę adresową - informuje o tym zdarzenie ENDROSTER. Skoro tak, to powinnismy wysłać informację o swojej dostępności. Służy do tego funkcja tlen_presence pobierająca informacje o stanie - TLEN_STATUS_* oraz nasz status opisowy - jeżeli żaden wstawiamy "" lub NULL.

case TLEN_EVENT_ENDROSTER: { printf("Roster received\n"); tlen_presence(sesja,TLEN_STATUS_AVAILABLE,"Dostępny"); break; }

Jednym z najtrudniejszych elementów protokołu tlenu/jabbera są subskrybcje. Jest to system pozwalający na kontrolę naszej znajomości. Generalnie - nikt nie będzie widział naszego stanu, jeżeli nie wyrazimy na to zgody, tak samo nikt nie doda nas do książki adresowej jeżeli nie wyrazimy na to zgody. Zdarzenie TLEN_EVENT_SUBSCRIBE mówi nam, że ktoś prosi o zgodę na autoryzację. Identyfikator danej osoby znajduje się w polu event->subscribe->jid. Jeżeli zgadzamy się - tutaj zawsze się zgadzamy, nie jest zaimplementowana obsługa niezgadzania sie ;) - to akceptujemy prośbę funkcją tlen_accept_subscribe, no i żeby być fair prosimy użytkownika o subskrybcję, żeby też mieć go w książce - tlen_request_subscribe.

case TLEN_EVENT_SUBSCRIBE: { tlen_accept_subscribe(sesja,event->subscribe->jid); tlen_request_subscribe(sesja,event->subscribe->jid); break; }

"Ktoś" zgodził się abyśmy go dodali do swojej książki - a więc to robimy, funkcja tlen_addcontact.

case TLEN_EVENT_SUBSCRIBED: { tlen_addcontact(sesja,"nazwa",event->subscribe->jid,"grupa"); break; }

BUU - ktoś chce nas usunąć ze swojej książki - więć prosi abyśmy my również go usuęli - zgadzamy się na to poprzez tlen_accept_unsubscribe, i żeby dobić wszystkich formalności prosimy o to samo - tlen_request_unsubscribe.

case TLEN_EVENT_UNSUBSCRIBE: { tlen_accept_unsubscribe(sesja,event->subscribe->jid); tlen_request_unsubscribe(sesja,event->subscribe->jid); break; }

"Ktoś" nas właśnie pomyślnie usunął, więc my też usuwamy - tlen_removecontact

case TLEN_EVENT_UNSUBSCRIBED: { tlen_removecontact(sesja,event->subscribe->jid); break; }

Oho - przyszła wiadomość! Dane wiadomości są w strukturze event->message, podstawowymi są body - treść, oraz from - od kogo, a na szarym końcu type - typ (TLEN_CHAT albo TLEN_MESSAGE). Nasz prosty klient obsługuje wiadomości w sposób bardzo prowizoryczny, np. zmienia stan, odpowiada pingiem, i inne takie pierdoły. Generalnie nie pojawia się tu na razie nic ważnego - do czasu...

case TLEN_EVENT_MESSAGE: { if (strcmp(event->message->body,"exit")==0) { terminate=1; tlen_sendmsg(sesja,event->message->from,"exiting...",TLEN_CHAT); } if (strcmp(event->message->body,"available")==0) { tlen_presence(sesja,TLEN_STATUS_AVAILABLE,"available"); tlen_sendmsg(sesja,event->message->from,"status changed to available", TLEN_CHAT); } if (strcmp(event->message->body,"away")==0) { tlen_presence(sesja,TLEN_STATUS_AWAY,"away"); tlen_sendmsg(sesja,event->message->from,"status changed to away", TLEN_CHAT); } if (strcmp(event->message->body,"chatty")==0) { tlen_presence(sesja,TLEN_STATUS_CHATTY,"away"); tlen_sendmsg(sesja,event->message->from,"status changed to chatty", TLEN_CHAT); } if (strcmp(event->message->body,"xa")==0) { tlen_presence(sesja,TLEN_STATUS_EXT_AWAY,"away"); tlen_sendmsg(sesja,event->message->from,"status changed to xa", TLEN_CHAT); } if (strcmp(event->message->body,"dnd")==0) { tlen_presence(sesja,TLEN_STATUS_DND,"away"); tlen_sendmsg(sesja,event->message->from,"status changed to dnd", TLEN_CHAT); } if (strcmp(event->message->body,"invisible")==0) { tlen_presence(sesja,TLEN_STATUS_INVISIBLE,"away"); tlen_sendmsg(sesja,event->message->from,"status changed to invisible", TLEN_CHAT); } if (strcmp(event->message->body,"ping")==0) { tlen_sendmsg(sesja,event->message->from,"pong", TLEN_CHAT); }

Jeżeli wyślemy klientowi wiadomość pubdir, wyśle on prośbę o swoje dane z katalogu publicznego - tlen_get_pubdir()

if (strcmp(event->message->body,"pubdir")==0) { tlen_get_pubdir(sesja); } if (strcmp(event->message->body,"groupchat")==0) { tlen_groupchat_init(sesja,event->message->from); }

Jeżeli wyślemy do testclienta wiadomość o treści search, klient rozpocznie proces wyszukiwania w katalogu publicznym. W tym celu inicjowana jest struktura tlen_pubdir, przy użyciu funkcji tlen_new_pubdir(), a następnie wypełniane są jej pola. Tutaj akutat wykonujemy odpowiednik windowsowej "wizytówki" - tzn. wyszukujemy po identyfikatorze tlenu. Gdy wyślemy zamówienie poprzez tlen_search, zwalniamy strukturę funkcją tlen_free_pubdir().

if (strcmp(event->message->body,"search")==0) { struct tlen_pubdir *sercz = tlen_new_pubdir(); sercz->id = "matijozef"; // tutaj sobie wpiszcie jaki wam sie podoba tlen_search(sesja,sercz); tlen_free_pubdir(sercz); }

Analogicznie - tutaj obsługiwana jest prośba o zmianę naszych danych w katalogu. Również inicjujemy strukturę tlen_pubdir, uzupełniamy jej pola, a następnie funkcją tlen_change_pubdir wysyłamy do serwera nowe dane. Na koniec zwalniamy strukturę poprzez tlen_free_pubdir()

if (strcmp(event->message->body,"pubdir_change")==0) { struct tlen_pubdir *pub = tlen_new_pubdir(); pub->firstname = "matijozef"; // tutaj sobie wpiszcie jaki wam sie podoba pub->lastname = "krzysztoffelix"; tlen_change_pubdir(sesja,pub); tlen_free_pubdir(pub); } break; }

Ktoś zmienił stan - np. na niedostępny, zajęty, lub zmienił stan opisowy Aktualnie nie jest to u nas obsługiwane :) Dane oczywiście zawarte są w event->presence.

case TLEN_EVENT_PRESENCE: { break; }

Zintegrowany system kont na o2.pl / tlen.pl jest połączony z serwerem tlenu. Tak więc możemy otrzymać informację o nowej poczcie - tutaj właśnie tak się dzieje. Informacje o tym są wysyłane na ekran - dane zaś znajdziemy w polu event->newmail

case TLEN_EVENT_NEWMAIL: { printf("Masz nową pocztę od %s o temacie %s!\n",event->newmail->from, event->newmail->subject); break; }

Na razie jeszcze nie mamy w testcliencie obsługi wyszukiwania, więć program poinformuje nas jedynie o tym, że wyszukiwanie skończył. Obsługa jednak jest analogiczna do książki adresowej - GOTSEARCHITEM a na końcu ENDSEARCH.

case TLEN_EVENT_ENDSEARCH: { printf("Wyszukiwanie zakończone!\n"); break; }

Serwer tlenu pomyślnie zwrócił nam swoje dane, znajdziemy je w event->pubdir.

case TLEN_EVENT_PUBDIR_GOTDATA: { printf("Odebralem swoje dane!\n"); break; }

"Pusty" event. Dostajemy informacje o tym, że nasze dane się ładnie zmieniły.

case TLEN_EVENT_PUBDIR_GOTUPDATEOK: { printf("Zmienilem swoje dane!\n"); break; } } tlen_freeevent(event); }

Co 60 sekund musimy pingać, zapewnia nam to prosty trick z funkcją time.

if (time(NULL)-last_ping_time>60) { tlen_ping (sesja); last_ping_time = time(NULL); } }

obsluga m.in bledu autoryzacji

if(sesja->error) { printf("Error occured while talking to server!\n"); exit(1); }

Jeżeli dostaliśmy CTRL+C to wychodzimy i zamykamy połączenie z serwerem.

if (terminate) printf("SIGINT received, exiting...\n");

Wysyłamy zamknięcie połączenia poprzez stan TLEN_STATUS_UNAVAILABLE.

tlen_presence(sesja, TLEN_STATUS_UNAVAILABLE, "");

A na koniec zwalniamy pamięć po sesji.

tlen_freesession (sesja); return 0; }