Protokół Gadu-Gadu

© Copyright 2001-2011 Autorzy


Spis treści

  1. Protokół Gadu-Gadu
    1.1.  Format pakietów i konwencje
    1.2.  Zanim się połączymy
    1.3.  Logowanie się
    1.4.  Zmiana stanu
    1.5.  Ludzie przychodzą, ludzie odchodzą
    1.6.  Wysyłanie wiadomości
    1.7.  Otrzymywanie wiadomości
    1.8.  Powiadomienie o pisaniu ("pisak")
    1.9.  Multilogowanie
    1.10.  Ping, pong
    1.11.  Rozłączenie
    1.12.  Wiadomości systemowe
    1.13.  Wiadomości GG_XML_ACTION
    1.14.  Katalog publiczny
    1.15.  Lista kontaktów
    1.16.  Indeks pakietów
  2. Usługi HTTP
    2.1.  Format danych
    2.2.  Tokeny
    2.3.  Rejestracja konta
    2.4.  Usunięcie konta
    2.5.  Zmiana hasła
    2.6.  Przypomnienie hasła pocztą
  3. Połączenia między klientami
    3.1.  Identyfikator połączenia
    3.2.  Przesyłanie plików
    3.3.  Połączenie bezpośrednie
    3.4.  Połączenie przez serwer
    3.5.  Rozmowy głosowe
  4. Autorzy

Informacje wstępne

Opis protokołu używanego przez Gadu-Gadu bazuje na doświadczeniach przeprowadzonych przez autorów oraz informacjach nadsyłanych przez użytkowników. Żaden klient Gadu-Gadu nie został skrzywdzony podczas badań. Reverse-engineering opierał się głównie na analizie pakietów przesyłanych między klientem a serwerem.

Najnowsza wersja opisu protokołu znajduje się pod adresem http://libgadu.net/protocol/.


1. Protokół Gadu-Gadu

1.1. Format pakietów i konwencje

Podobnie jak coraz większa ilość komunikatorów, Gadu-Gadu korzysta z protokołu TCP/IP. Każdy pakiet zawiera na początku dwa stałe pola:

struct gg_header {
	int type;	/* typ pakietu */
	int length;	/* długość reszty pakietu */
};

Wszystkie zmienne liczbowe są zgodne z kolejnością bajtów maszyn Intela, czyli Little-Endian. Wszystkie teksty są kodowane przy użyciu zestawu znaków UTF-8, chyba że zaznaczono inaczej. Linie kończą się znakami \r\n.

Przy opisie struktur, założono, że char ma rozmiar 1 bajtu, short 2 bajtów, int 4 bajtów, long long 8 bajtów, wszystkie bez znaku. Używając architektur innych niż i386, należy zwrócić szczególną uwagę na rozmiar typów zmiennych i kolejność bajtów. Poza tym, większość dostępnych obecnie kompilatorów domyślnie wyrównuje zmienne do rozmiaru słowa danej architektury, więc należy wyłączyć tą funkcję. W przypadku gcc będzie to __attribute__ ((packed)) zaraz za deklaracją każdej struktury, a dla Microsoft Visual C++ powinno pomóc:

#pragma pack(push, 1)

/* deklaracje */

#pragma pack(pop)

Pola, których znaczenie jest nieznane, lub nie do końca jasne, oznaczono przedrostkiem unknown.


1.2. Zanim się połączymy

Żeby wiedzieć, z jakim serwerem mamy się połączyć, należy za pomocą HTTP połączyć się z appmsg.gadu-gadu.pl i wysłać:

GET /appsvc/appmsg_ver8.asp?fmnumber=NUMER&fmt=FORMAT&lastmsg=WIADOMOŚĆ&version=WERSJA HTTP/1.1
Connection: Keep-Alive
Host: appmsg.gadu-gadu.pl

Gdzie:

Na postawione w ten sposób zapytanie, serwer może odpowiedzieć w następujący sposób:

HTTP/1.0 200 OK
Connection: close

0 0 91.197.13.78:8074 91.197.13.78

Pierwsze pole jest numerem wiadomości systemowej, a trzecie i czwarte podają nam namiary na właściwy serwer. Jeśli serwer jest niedostępny, zamiast adresu IP jest zwracany tekst „notoperating”. Jeżeli połączenie z portem 8074 nie powiedzie się z jakichś powodów, można się łączyć na port 443.

Jeśli pierwsza liczba jest różna od zera, zaraz po nagłówku znajduje się wiadomość systemowa w wybranym formacie, lub jeśli linia zaczyna się od znaku „@”, adres strony, którą należy otworzyć w przeglądarce.

GET /appsvc/appmsg3.asp?fmnumber=NUMER&version=WERSJA&fmt=FORMAT&lastmsg=WIADOMOŚĆ
Host: appmsg.gadu-gadu.pl
User-Agent: PRZEGLĄDARKA
Pragma: no-cache

1.3. Logowanie się

Po połączeniu się portem 8074 lub 443 serwera Gadu-Gadu, otrzymujemy pakiet typu 0x0001, który na potrzeby tego dokumentu nazwiemy:

#define GG_WELCOME 0x0001

Reszta pakietu zawiera ziarno — wartość, którą razem z hasłem przekazuje się do funkcji skrótu:

struct gg_welcome {
	int seed;	/* ziarno */
};

Kiedy mamy już tą wartość możemy odesłać pakiet logowania:

#define GG_LOGIN80 0x0031

struct gg_login80 {
        int uin;              /* numer Gadu-Gadu */
        char language[2];     /* język: "pl" */
        char hash_type;       /* rodzaj funkcji skrótu hasła */
        char hash[64];        /* skrót hasła dopełniony \0 */
        int status;           /* początkowy status połączenia */
        int flags;            /* początkowe flagi połączenia */
        int features;         /* opcje protokołu (0x00000367)*/
        int local_ip;         /* lokalny adres połączeń bezpośrednich (nieużywany) */
        short local_port;     /* lokalny port połączeń bezpośrednich (nieużywany) */
        int external_ip;      /* zewnętrzny adres (nieużywany) */
        short external_port;  /* zewnętrzny port (nieużywany) */
        char image_size;      /* maksymalny rozmiar grafiki w KB */
        char unknown1;        /* 0x64 */
        int version_len;      /* długość ciągu z wersją (0x23) */
        char version[];       /* "Gadu-Gadu Client build 10.0.0.10450" (bez \0) */
        int description_size; /* rozmiar opisu */
        char description[];   /* opis (nie musi wystąpić, bez \0) */
};

Pola określające adresy i port są pozostałościami po poprzednich wersjach protokołów i w obecnej wersji zawierają zera.

Pole features jest mapą bitową informującą serwer, które z funkcji protokołu obsługujemy. Do minimalnej zgodności z protokołem Nowego Gadu-Gadu niezbędna jest co najmniej wartość 0x00000007.

BitWartośćZnaczenie
00x00000001Rodzaj pakietu informującego o zmianie stanu kontaktów (patrz bit 2)
0GG_STATUS77, GG_NOTIFY_REPLY77
1GG_STATUS80BETA, GG_NOTIFY_REPLY80BETA
10x00000002Rodzaj pakietu z otrzymają wiadomością
0GG_RECV_MSG
1GG_RECV_MSG80
20x00000004Rodzaj pakietu informującego o zmianie stanu kontaktów (patrz bit 0)
0 — wybrany przez bit 0
1GG_STATUS80, GG_NOTIFY_REPLY80
40x00000010Klient obsługuje statusy "nie przeszkadzać" i "poGGadaj ze mną"
50x00000020Klient obsługuje statusy graficzne i GG_STATUS_DESCR_MASK (patrz Zmiana stanu)
60x00000040Znaczenie nie jest znane, ale klient otrzyma w przypadku błędnego hasła pakiet GG_LOGIN80_FAILED zamiast GG_LOGIN_FAILED
70x00000100Znaczenie nie jest znane, ale jest używane przez nowe klienty
90x00000200Klient obsługuje dodatkowe informacje o liście kontaktów
100x00000400Klient wysyła potwierdzenia odebrania wiadomości
130x00002000Klient obsługuje powiadomienia o pisaniu
130x00004000Klient obsługuje multilogowanie

Skrót hasła można liczyć na dwa sposoby:

#define GG_LOGIN_HASH_GG32 0x01
#define GG_LOGIN_HASH_SHA1 0x02

Pierwszy, nieużywany już algorytm (GG_LOGIN_HASH_GG32) został wymyślony na potrzeby Gadu-Gadu i zwraca 32-bitową wartość dla danego ziarna i hasła. Jego implementacja w języku C wygląda następująco:

int gg_login_hash(unsigned char *password, unsigned int seed)
{
	unsigned int x, y, z;

	y = seed;

	for (x = 0; *password; password++) {
		x = (x & 0xffffff00) | *password;
		y ^= x;
		y += x;
		x <<= 8;
		y ^= x;
		x <<= 8;
		y -= x;
		x <<= 8;
		y ^= x;

		z = y & 0x1f;
		y = (y << z) | (y >> (32 - z));
	}

	return y;
}

Ze względu na niewielki zakres wartości wyjściowych, istnieje prawdopodobieństwo, że inne hasło przy odpowiednim ziarnie da taki sam wynik. Z tego powodu zalecane jest używane algorytmu SHA-1, którego implementacje są dostępne dla większości współczesnych systemów operacyjnych. Skrót SHA-1 należy obliczyć z połączenia hasła (bez \0) i binarnej reprezentacji ziarna. Przykładowy kod może wyglądać w następujący sposób:

char *gg_sha_hash(char *password, unsigned int seed)
{
	SHA1_CTX ctx;
	static char result[20];
	  
	SHA1_Init(&ctx);  
	SHA1_Update(&ctx, password, strlen(password));
	SHA1_Update(&ctx, &seed, sizeof(seed));
	SHA1_Final(result, &ctx);

	return result;
}

Jeśli autoryzacja się powiedzie, dostaniemy w odpowiedzi pakiet:

#define GG_LOGIN80_OK 0x0035

struct gg_login80_ok {
	int unknown1;	/* 01 00 00 00 */
};

W przypadku błędu autoryzacji otrzymamy pakiet:

#define GG_LOGIN80_FAILED 0x0043

struct gg_login80_failed {
	int unknown1;	/* 01 00 00 00 */
};

Starsze wersje oraz klienty z otrzymywały pusty pakiet:

#define GG_LOGIN_FAILED 0x0009

1.4. Zmiana stanu

Gadu-Gadu przewiduje kilka stanów klienta, które zmieniamy pakietem typu:

#define GG_NEW_STATUS80 0x0038

struct gg_new_status80 {
	int status;		/* nowy status */
	int flags;              /* nowe flagi */
	int description_size;   /* rozmiar opisu */
	char description[];	/* opis (nie musi wystąpić, bez \0) */
};

Możliwe stany to:

EtykietaWartośćZnaczenie
GG_STATUS_NOT_AVAIL0x0001Niedostępny
GG_STATUS_NOT_AVAIL_DESCR0x0015Niedostępny (z opisem)
GG_STATUS_FFC0x0017PoGGadaj ze mną
GG_STATUS_FFC_DESCR0x0018PoGGadaj ze mną (z opisem)
GG_STATUS_AVAIL0x0002Dostępny
GG_STATUS_AVAIL_DESCR0x0004Dostępny (z opisem)
GG_STATUS_BUSY0x0003Zajęty
GG_STATUS_BUSY_DESCR0x0005Zajęty (z opisem)
GG_STATUS_DND0x0021Nie przeszkadzać
GG_STATUS_DND_DESCR0x0022Nie przeszkadzać (z opisem)
GG_STATUS_INVISIBLE0x0014Niewidoczny
GG_STATUS_INVISIBLE_DESCR0x0016Niewidoczny (z opisem)
GG_STATUS_BLOCKED0x0006Zablokowany
GG_STATUS_IMAGE_MASK0x0100Maska bitowa oznaczająca ustawiony opis graficzny (tylko odbierane)
GG_STATUS_ADAPT_STATUS_MASK0x0400 Maska bitowa informująca serwer, że jeśli istnieje już inne połączenie na tym numerze to nasze ma przyjać jego stan (podany przez nas zostanie zignorowany). Jeśli połączenia innego nie ma, to ustawiany jest stan podany przez nas.
GG_STATUS_DESCR_MASK0x4000Maska bitowa oznaczająca ustawiony opis
GG_STATUS_FRIENDS_MASK0x8000Maska bitowa oznaczająca tryb tylko dla przyjaciół

Możliwe flagi to:

BitWartośćZnaczenie
00x00000001 Prawdopodobnie połączenia audio
10x00000002Klient obsługuje wideorozmowy
200x00100000Klient mobilny (ikona telefonu komórkowego)
230x00800000Klient chce otrzymywać linki od nieznajomych

Jeśli klient obsługuje statusy graficzne, to statusy opisowe będą dodatkowo określane przez dodanie flagi GG_STATUS_DESCR_MASK. Dotyczy to zarówno statusów wysyłanych, jak i odbieranych z serwera.

Należy pamiętać, żeby przed rozłączeniem się z serwerem należy zmienić stan na GG_STATUS_NOT_AVAIL lub GG_STATUS_NOT_AVAIL_DESCR. Jeśli ma być widoczny tylko dla przyjaciół, należy dodać GG_STATUS_FRIENDS_MASK do normalnej wartości stanu.

Maksymalna długość opisu wynosi 255 bajtów, jednak należy pamiętać że znak w UTF-8 czasami zajmuje więcej niż 1 bajt.


1.5. Ludzie przychodzą, ludzie odchodzą

Zaraz po zalogowaniu możemy wysłać serwerowi naszą listę kontaktów, żeby dowiedzieć się, czy są w danej chwili dostępni. Lista kontaktów jest dzielona na pakiety po 400 wpisów. Pierwsze wpisy są typu GG_NOTIFY_FIRST, a ostatni typu GG_NOTIFY_LAST, żeby serwer wiedział, kiedy kończymy. Jeśli lista kontaktów jest mniejsza niż 400 wpisów, wysyłamy oczywiście tylko GG_NOTIFY_LAST. Pakiety te zawierają struktury gg_notify:

#define GG_NOTIFY_FIRST 0x000f
#define GG_NOTIFY_LAST 0x0010
	
struct gg_notify {
	int uin;	/* numer Gadu-Gadu kontaktu */
	char type;	/* rodzaj użytkownika */
};

Gdzie pole type jest mapą bitową następujących wartości:

EtykietaWartośćZnaczenie
GG_USER_BUDDY0x01Każdy użytkownik dodany do listy kontaktów
GG_USER_FRIEND0x02Użytkownik, dla którego jesteśmy widoczni w trybie „tylko dla przyjaciół”
GG_USER_BLOCKED0x04Użytkownik, którego wiadomości nie chcemy otrzymywać

Jednak dla zachowania starego nazewnictwa stałych można używać najczęściej spotykane wartości to:

EtykietaWartośćZnaczenie
GG_USER_OFFLINE0x01Użytkownik, dla którego będziemy niedostępni, ale mamy go w liście kontaktów
GG_USER_NORMAL0x03Zwykły użytkownik dodany do listy kontaktów
GG_USER_BLOCKED0x04Użytkownik, którego wiadomości nie chcemy otrzymywać

Jeśli nie mamy nikogo na liście wysyłamy następujący pakiet o zerowej długości:

#define GG_LIST_EMPTY 0x0012

Jeśli ktoś jest, serwer odpowie pakietem GG_NOTIFY_REPLY80 zawierającym jedną lub więcej struktur gg_notify_reply80:

#define GG_NOTIFY_REPLY80 0x0037
	
struct gg_notify_reply80 {
	int uin;		/* numer Gadu-Gadu kontaktu */
	int status;		/* status */
	int features;		/* opcje protokołu (patrz GG_LOGIN80) */
	int remote_ip;		/* adres IP bezpośrednich połączeń (nieużywane) */
	short remote_port;	/* port bezpośrednich połączeń (nieużywane) */
	char image_size;	/* maksymalny rozmiar obrazków w KB */
	char unknown1;		/* 0x00 */
	int flags;		/* flagi połączenia (patrz GG_LOGIN80) */
	int description_size;	/* rozmiar opisu */
	char description[];	/* opis (nie musi wystąpić, bez \0) */
};

Zdarzają się też inne „nietypowe” wartości, ale ich znaczenie nie jest jeszcze do końca znane.

Aby dodać do listy kontaktów numer w trakcie połączenia, należy wysłać niżej opisany pakiet. Jego format jest identyczny jak GG_NOTIFY_*, z tą różnicą, że zawiera jeden numer.

#define GG_ADD_NOTIFY 0x000d
	
struct gg_add_notify {
	int uin;	/* numerek */
	char type;	/* rodzaj użytkownika */
};

Poniższy pakiet usuwa z listy kontaktów:

#define GG_REMOVE_NOTIFY 0x000e
	
struct gg_remove_notify {
	int uin;	/* numerek */
	char type;	/* rodzaj użytkownika */
};

Należy zwrócić uwagę, że pakiety GG_ADD_NOTIFY i GG_REMOVE_NOTIFY dodają i usuwają flagi będące mapą bitową. Aby zmienić status użytkownika z normalnego na blokowanego, należy najpierw usunąć rodzaj GG_USER_NORMAL, a następnie dodać rodzaj GG_USER_BLOCKED.

Jeśli ktoś opuści Gadu-Gadu lub zmieni stan, otrzymamy poniższy pakiet, którego struktura jest identyczna z GG_NOTIFY_REPLY80.

#define GG_STATUS80 0x0036

1.5.1 Dodatkowe informacje o kontaktach

Jeśli podczas logowania klient wyśle w polu features maskę bitową 0x00000200, to będzie otrzymywał od serwera pakiety typu GG_USER_DATA o następującej strukturze:

#define GG_USER_DATA 0x0044

struct gg_user_data {
	int type;	/* typ */
	int num;	/* liczba struktur gg_user_data_user */
};

struct gg_user_data_user {
	int uin;	/* numer użytkownika */
	int num;	/* liczba struktur gg_user_data_attr */
};

struct gg_user_data_attr {
	int name_size;	/* długość nazwy atrybutu */
	char name[];	/* nazwa atrybutu (bez znaku \0) */
	int type;	/* typ atrybutu */
	int value_size;	/* długość wartości atrybutu */
	char value[];	/* wartość atrybutu (bez znaku \0) */
};

1.6. Wysyłanie wiadomości

Wiadomości wysyła się następującym typem pakietu:

#define GG_SEND_MSG80 0x002d

struct gg_send_msg80 {
	int recipient;		/* numer odbiorcy */
	int seq;		/* numer sekwencyjny */
	int class;		/* klasa wiadomości */
	int offset_plain;	/* położenie treści czystym tekstem */
	int offset_attributes;	/* położenie atrybutów */
	char html_message[];	/* treść w formacie HTML (zakończona \0) */
	char plain_message[];	/* treść czystym tekstem (zakończona \0) */
	char attributes[];	/* atrybuty wiadomości */
};

Numer sekwencyjny w poprzednich wersjach protokołu był losową liczbą pozwalającą przypisać potwierdzenie do wiadomości. Obecnie jest znacznikiem czasu w postaci uniksowej (liczba sekund od 1 stycznia 1970r. UTC).

Klasa wiadomości jest mapą bitową (domyślna wartość to 0x08):

EtykietaWartośćZnaczenie
GG_CLASS_QUEUED0x0001Bit ustawiany wyłącznie przy odbiorze wiadomości, gdy wiadomość została wcześniej zakolejkowania z powodu nieobecności
GG_CLASS_MSG0x0004Wiadomość ma się pojawić w osobnym okienku (nieużywane)
GG_CLASS_CHAT0x0008Wiadomość jest częścią toczącej się rozmowy i zostanie wyświetlona w istniejącym okienku
GG_CLASS_CTCP0x0010Wiadomość jest przeznaczona dla klienta Gadu-Gadu i nie powinna być wyświetlona użytkownikowi (nieużywane)
GG_CLASS_ACK0x0020Klient nie życzy sobie potwierdzenia wiadomości

Długość treści wiadomości nie powinna przekraczać 2000 znaków. Oryginalny klient zezwala na wysłanie do 1989 znaków. Treść w formacie HTML jest kodowana UTF-8. Treść zapisana czystym tekstem jest kodowana zestawem znaków CP1250. W obu przypadkach, mimo domyślnych atrybutów tekstu, oryginalny klient dodaje blok atrybutów tekstu. Dla HTML wygląda to następująco:

<span style="color:#000000; font-family:'MS Shell Dlg 2'; font-size:9pt; ">Test</span>

Dla czystego tekstu dodawane są informacje o tym, że tekst ma kolor czarny:

BajtyOpis
0x02Flaga formatowania tekstu
0x06 0x00Długość bloku formatowania wynosi 6 bajtów
0x00 0x00Atrybut tekstu od pozycji 0
0x08Tekst kolorowy
0x00 0x00 0x00Kolor czarny

1.6.1. Konferencje

Podczas konferencji ta sama wiadomość jest wysyłana do wszystkich odbiorców, a do sekcji atrybutów dołączana jest lista pozostałych uczestników konferencji. Dla przykładu, jeśli w konferencji biorą udział Ala, Bartek, Celina i Darek, to osoba Ala wysyła wysyła do Bartka wiadomość z listą zawierającą numery Celiny i Darka, do Celiny z numerami Bartka i Darka, a do Darka z numerami Bartka i Celiny. Lista pozostałych uczestników konferencji jest przekazywana za pomocą struktury:

struct gg_msg_recipients {
	char flag;		/* 0x01 */
	int count;		/* liczba odbiorców */
	int recipients[];	/* lista odbiorców */
};

Na przykład, by wysłać wysłać do do dwóch osób, należy wysłać pakiet z wiadomością o treści:

BajtyOpis
0x01Flaga wiadomości konferencyjnej
0x02 0x00 0x00 0x00Liczba pozostałych uczestników
0xXX 0xXX 0xXX 0xXXNumer uczestnika #2
0xYY 0xYY 0xYY 0xYYNumer uczestnika #3

1.6.2. Formatowanie tekstu

Dla protokołu Nowego Gadu-Gadu natywnym formatem jest HTML, ale blok atrybutów również jest przesyłany dla zachowania kompatybilności ze starszymi klientami.

1.6.2.1. Format HTML

Każdy fragment tekstu o spójnych atrybutach jest zawarty w jednym znaczniku <span>, nawet jeśli są to atrybuty domyślne. Dla przykładu, wiadomość o treści „Test” wysłana bez zmiany atrybutów tekstu przedstawia się następująco:

<span style="color:#000000; font-family:'MS Shell Dlg 2'; font-size:9pt; ">Test</span>

Oryginalny klient korzysta z następujących znaczników HTML:

Źródło obrazka obrazka jest połączeniem heksadecymalnego zapisu (małymi literami) sumy kontrolnej CRC32 oraz rozmiaru dopełnionego do czterech bajtów. Dla obrazka o sumie kontrolnej 0x45fb2e46 i rozmiarze 16568 bajtów źródłem będzie 45fb2e46000040b8.

Przykładowa wiadomość wykorzystująca wszystkie dostępne znaczniki oraz obrazek:

<span style="background-color:#00ff00; color:#000000; font-family:'MS Shell Dlg 2'; font-size:9pt; "><b><i><u>Wiadomość<br>testowa</u></i></b><img name="45fb2e46000040b8"></span>

1.6.2.2. Czysty tekst z atrybutami

Możliwe jest również dodawanie do wiadomości różnych atrybutów tekstu, jak pogrubienie czy kolory. Niezbędne jest dołączenie do wiadomości następującej struktury:

struct gg_msg_richtext {
	char flag;	/* 0x02 */
	short length;	/* długość dalszej części */
};

Dalsza część pakietu zawiera odpowiednią ilość struktur o łącznej długości określonej polem length:

struct gg_msg_richtext_format {
	short position;	/* pozycja atrybutu w tekście */
	char font;	/* atrybuty czcionki */
	char rgb[3];	/* kolor czcionki (nie musi wystąpić) */
	struct gg_msg_richtext_image image; /* obrazek (nie musi wystąpić) */
};

Każda z tych struktur określa kawałek tekstu począwszy od znaku określonego przez pole position (liczone od zera) aż do następnego wpisu lub końca tekstu. Pole font jest mapą bitową i kolejne bity mają następujące znaczenie:

EtykietaWartośćZnaczenie
GG_FONT_BOLD0x01Pogrubiony tekst
GG_FONT_ITALIC0x02Kursywa
GG_FONT_UNDERLINE0x04Podkreślenie
GG_FONT_COLOR0x08Kolorowy tekst. Tylko w tym wypadku struktura gg_msg_richtext_format zawiera pole rgb[] będące opisem trzech składowych koloru, kolejno czerwonej, zielonej i niebieskiej.
GG_FONT_IMAGE0x80Obrazek. Tylko w tym wypadku struktura gg_msg_richtext_format zawiera pole image.

Jeśli wiadomość zawiera obrazek, przesyłana jest jego suma kontrolna CRC32 i rozmiar. Dzięki temu nie trzeba za każdym razem wysyłać każdego obrazka — klienty je zachowują. Struktura gg_msg_richtext_image opisująca obrazek umieszczony w wiadomości wygląda następująco:

struct gg_msg_richtext_image {
	char length;	/* długość opisu obrazka (0x09) */
	char type;	/* rodzaj opisu obrazka (0x01) */
	int size;	/* rozmiar obrazka */
	int crc32;	/* suma kontrolna obrazka */
};

Przykładowo, by przesłać tekst „ala ma kota”, należy dołączyć do wiadomości następującą sekwencję bajtów:

BajtyOpis
0x02Flaga formatowania tekstu
0x06 0x00Długość bloku formatowania wynosi 6 bajtów
0x04 0x00Atrybut tekstu od pozycji 4
0x01Tekst pogrubiony
0x06 0x00Atrybut tekstu od pozycji 6
0x00Tekst normalny

W przypadku gdy wiadomość zawiera zarówno informacje o uczestnikach konferencji, jaki i o formatowaniu, najpierw informacje o konferencji powinny znajdować się przed formatowaniem.

Jeśli obrazek jest przesyłany w wiadomości bez tekstu, jej treść zapisana czystym tekstem powinna zawierać znak niełamliwej spacji (kod 160 w kodowaniu CP1250). W innym przypadku nowsze klienty (np. Nowe Gadu-Gadu) nie wyświetlą obrazka. Wiadomość w formacie HTML może zawierać wyłącznie znacznik <img>.

1.6.3. Przesyłanie obrazków

Gdy klient nie posiada w pamięci podręcznej obrazka o podanych parametrach, wysyła pustą wiadomość o klasie GG_CLASS_MSG z dołączoną strukturą gg_msg_image_request:

struct gg_msg_image_request {
	char flag;	/* 0x04 */
	int size;	/* rozmiar */
	int crc32;	/* suma kontrolna */
};

Przykładowa treść wiadomości z prośbą o wysłanie obrazka o długości 10000 bajtów i sumie kontrolnej 0x12345678 to:

BajtyOpis
0x04Flaga pobrania obrazka
0x10 0x27 0x00 0x00Rozmiar obrazka w bajtach
0x78 0x56 0x34 0x12Suma kontrolna

W odpowiedzi, drugi klient wysyła obrazek za pomocą wiadomości o zerowej długości (należy pamiętać o kończącym bajcie o wartości 0x00) z dołączoną strukturą gg_msg_image_reply:

struct gg_msg_image_reply {
	char flag;      	/* 0x05 lub 0x06 */
	int size;       	/* rozmiar */
	int crc32;      	/* suma kontrolna */
	char filename[];	/* nazwa pliku (nie musi wystąpić) */
	char image[];		/* zawartość obrazka (nie musi wystąpić) */
};

Jeśli długość struktury gg_msg_image_reply jest dłuższa niż 1909 bajtów, treść obrazka jest dzielona na kilka pakietów nie przekraczających 1909 bajtów. Pierwszy pakiet ma pole flag równe 0x05 i ma wypełnione pole filename, a w kolejnych pole flag jest równe 0x06 i pole filename w ogóle nie występuje (nawet bajt zakończenia ciągu znaków).

Jeśli otrzymamy pakiet bez pola filename oraz image, oznacza to, że klient nie posiada żądanego obrazka.

1.6.4. Potwierdzenie

Serwer po otrzymaniu wiadomości odsyła potwierdzenie, które przy okazji mówi nam, czy wiadomość dotarła do odbiorcy czy została zakolejkowana z powodu nieobecności. Otrzymujemy je w postaci pakietu:

#define GG_SEND_MSG_ACK 0x0005
	
struct gg_send_msg_ack {
	int status;	/* stan wiadomości */
	int recipient;	/* numer odbiorcy */
	int seq;	/* numer sekwencyjny */
};

Numer sekwencyjny i numer adresata są takie same jak podczas wysyłania, a stan wiadomości może być jednym z następujących:

EtykietaWartośćZnaczenie
GG_ACK_BLOCKED0x0001Wiadomości nie przesłano (zdarza się przy wiadomościach zawierających adresy internetowe blokowanych przez serwer GG gdy odbiorca nie ma nas na liście)
GG_ACK_DELIVERED0x0002Wiadomość dostarczono
GG_ACK_QUEUED0x0003Wiadomość zakolejkowano
GG_ACK_MBOXFULL0x0004Wiadomości nie dostarczono. Skrzynka odbiorcza na serwerze jest pełna (20 wiadomości maks). Występuje tylko w trybie offline
GG_ACK_NOT_DELIVERED0x0006Wiadomości nie dostarczono. Odpowiedź ta występuje tylko w przypadku wiadomości klasy GG_CLASS_CTCP

1.7. Otrzymywanie wiadomości

Wiadomości serwer przysyła za pomocą pakietu:

#define GG_RECV_MSG80 0x002e

struct gg_recv_msg80 {
	int sender;		/* numer nadawcy */
	int seq;		/* numer sekwencyjny */
	int time;		/* czas nadania */
	int class;		/* klasa wiadomości */
	int offset_plain;	/* położenie treści czystym tekstem */
	int offset_attributes;	/* położenie atrybutów */
	char html_message[];	/* treść w formacie HTML (zakończona \0) */
	char plain_message[];	/* treść czystym tekstem (zakończona \0) */
	char attributes[];	/* atrybuty wiadomości */
};

Czas nadania jest zapisany w postaci UTC, jako ilości sekund od 1 stycznia 1970r.

W przypadku pakietów „konferencyjnych” na końcu pakietu doklejona jest struktura identyczna z gg_msg_recipients zawierająca pozostałych rozmówców.

1.7.1. Potwierdzenie

Jeśli podczas logowania klient wyśle w polu features maskę bitową 0x00000400, to zobowiązuje się wysłać potwierdzenie po każdej odebranej wiadomości. Wysyła je w postaci pakietu:

#define GG_RECV_MSG_ACK 0x0046
	
struct gg_recv_msg_ack {
	int seq;	/* numer sekwencyjny ostatnio odebranej wiadomości */
};

1.8. Powiadomienie o pisaniu ("pisak")

Jeśli podczas logowania klient wyśle w polu features maskę bitową 0x00002000, to może wtedy informować drugą stronę o tym czy piszemy wiadomość (oraz odbierać informacje czy druga strona coś pisze). Powiadomienia wysyłamy/otrzymujemy tym samym pakietem:

#define GG_TYPING_NOTIFY 0x0059

struct gg_typing_notify {
	short type;	/* typ powiadomienia */
	int uin;	/* do/od kogo wysyłamy/odebraliśmy */
};

Gdzie pole typ może przyjmować następujące stałe wartości:

#define GG_TYPING_NOTIFY_TYPE_START	0x0001	/* rozpoczelismy pisanie */
#define GG_TYPING_NOTIFY_TYPE_STOP	0x0000	/* pozbyliśmy się wiadomości */

Jeśli otrzymamy w polu type inną wartość, oznacza ona długość wpisanego przez drugą stronę w pole wysyłki tekstu.


1.9. Multilogowanie

Czyli wiele klientów, z różnych miejsc — na jednym numerze. Co prawda do samego zalogowania się na dany numer wiele razy, wcale nie są potrzebne specjalne modyfikacje. To jeśli chcemy obsługiwać synchronziację wysyłanych wiadomości — obsługa dodatkowych pakietów będzie nam potrzebna. Aby otrzymywać pakiety związane z tą funkcją w polu features przy logowaniu dodajemy flagę 0x00004000.

1.9.1. Synchronizacja wiadomości

Jeśli z innego klienta zostanie wysłana wiadomośc (z naszego numeru) to otrzymamy pakiet:

#define GG_RECV_OWN_MSG 0x005A

O takiej strukturze jak gg_recv_msg80.

1.9.2. Informacje o innych połączeniach

Jeśli na nasz numer zaloguje się inny klient, lub kiedy my się logujemy, a inny klient jest już zalogowany to dostaniemy pakiet:

#define GG_MULTILOGON_INFO 0x005B

struct gg_multilogon_info {
	int count;	/* ilość zalogowanych klientów / struktur gg_multilogon_item w tym pakiecie */
	struct gg_multilogon_item items[];
};

struct gg_multilogon_item {
	int login_ip;		/* IP z jakiego zalogowany jest dany klient */
	int flags;		/* to co podał w "flags" przy logowaniu */
	int features;		/* to co podał w "features" przy logowaniu */
	int logon_time;		/* kiedy zdalny klient się zalogował na nasz numerek */
	long long conn_id;	/* identyfikator polaczenia */
	int unknown;		/* nie wiemy co to, zawsze zero */
	int client_name_size;	/* rozmiar nazwy klieta uzytego po drugiej stronie */
	char client_name[];	/* nazwa klienta uzywanego w tym polaczeniu */
};

1.9.3. Dostosowanie stanu

Protokół GG udostępnia możliwość dostosowania stanu „nowo-połaczonego” klienta do tego jaki mają ustawione już zalogowane na naszym numerze komunikatory. W tym celu w pakiecie gg_login80 w polu „status” dodajemy flagę 0x0400. Jeśli to zrobimy, w momencie gdy łączymy się na numer na którym jest już obecny inny klient, stan który podajemy w pakiecie logowania zostanie przez serwer zignorowany. W takiej sytuacji powinnismy zaprezentować użytkownikowi stan przysłany do nas pakietem GG_NOTIFY_REPLY80 gdzie „uin” będzie zawierał nasz numer.

W wypadku kiedy „inny” klient zmieni stan naszego numeru także dostaniemy GG_NOTIFY_REPLY80 z naszym nowym stanem.

1.9.4. Rozłączenie zdalnego klienta

W razie kiedy chcemy rozłączyć którąś z sesji (podanych w GG_MULTILOGON_INFO), wysyłamy pakiet:

#define GG_MULTILOGON_DISCONNECT 0x0062

struct gg_multilogon_disconnect {
	long long conn_id; /* id połączenia dostarczone w gg_multilogon_info */
};

1.10. Ping, pong

Od czasu do czasu klient wysyła pakiet do serwera, by oznajmić, że połączenie jeszcze jest utrzymywane. Jeśli serwer nie dostanie takiego pakietu w przeciągu 5 minut, zrywa połączenie. To, czy klient dostaje odpowiedź zmienia się z wersji na wersję, więc najlepiej nie polegać na tym.

#define GG_PING 0x0008

#define GG_PONG 0x0007

1.11. Rozłączenie

Jeśli serwer zechce nas rozłączyć, wyśle wcześniej pusty pakiet:

#define GG_DISCONNECTING 0x000b

Ma to miejsce, gdy próbowano zbyt wiele razy połączyć się z nieprawidłowym hasłem (wtedy pakiet zostanie wysłany w odpowiedzi na GG_LOGIN70), lub gdy równocześnie połączy się drugi klient z tym samym numerem (nowe połączenie ma wyższy priorytet).

W pewnych wersjach protokołu (prawdopodobnie od 0x29 do okolic Nowego Gadu-Gadu), po wysłaniu pakietu zmieniającego status na niedostępny, serwer przysyła pakiet:

#define GG_DISCONNECT_ACK 0x000d

Jest to potwierdzenie, że serwer odebrał pakiet zmiany stanu i klient może zakończyć połączenie mając pewność, że zostanie ustawiony żądany opis. Klient przedstawiający się jako Gadu-Gadu 10 takiego pakietu już nie dostaje — serwer sam zrywa połączenie po zmianie stanu na niedostępny.


1.12. Wiadomości systemowe

Od wersji 7.7 serwer może wysyłać nam wiadomości systemowe przy pomocy pakietu:

#define GG_XML_EVENT 0x0027

Wiadomość systemowa zawiera kod XML zakodowany w UTF-8 z informacjami dotyczącymi np. przedłużenia konta w mobilnym GG, czy nowej wiadomości na poczcie głosowej. Przykładowy kod:

<?xml version="1.0" encoding="utf-8"?>
<event xmlns:ev="www.gadu-gadu.pl/Event/1.0" id="" type="realtime" creation_time="1194732873" ttl="60">
  <ev:actions>
    <ev:showMessage>
      <ev:text>Wejdź na stronę EKG</ev:text>

      <ev:executeHtml url="ekg.chmurka.net" />
   </ev:showMessage>
  </ev:actions>
</event>

1.13. Wiadomości GG_XML_ACTION

#define GG_XML_ACTION 0x002c

1.13.1 Wiadomości GGLive

Opisać usługi http://life.gadu-gadu.pl/
Logowanie OAuth: /login?oauth_consumer_key=UIN&oauth_nonce=....&oauth_signature=...&oauth_signature_method=HMAC-SHA1&oauth_timestamp=...&oauth_token=....&oauth_version=1.0
Wysyłanie: POST /send/message/?USER_IS_AUTHENTICATED=1&uin=UIN&token=TOKEN
message=Testowa+wiadomo%C5%9B%C4%87&send=Wy%C5%9Blij

Przykładowa otrzymana wiadomość:

<events>
  <event id="13106118792229117994">
  <type>1</type>
  <sender>7496195</sender>
  <time>1243461221</time>
  <bodyXML>
    <serviceID>lifestreaming</serviceID>
    <msg><![CDATA[Testowa wiadomość]]></msg>
    <link isLogin="0"></link>
    <creationTime>1243461221</creationTime>
  </bodyXML>
 </event>
</events>

1.13.2 Zmiana avatara przez znajomego

Przykładowa informacja:

<events>
  <event id="13095886332244853765">
    <type>28</type>
    <sender>3732</sender>
    <time>1245843651</time>
    <body></body>
    <bodyXML>
      <smallAvatar>http://media6.mojageneracja.pl/oiytwyurtp/avatar/ueuivsp.jpg</smallAvatar>
    </bodyXML>
  </event>
</events>

1.13.3 Nowy wpis na blogu znajomego

Przykładowa informacja:

<events>
  <event id="13095868082578904423">
    <type>7</type>
    <sender>3732</sender>
    <time>1245847900</time>
    <bodyXML>
      <serviceID>MG</serviceID>
      <msg><![CDATA[Doda\u0139, wpis do bloga]]></msg>
      <link isLogin="1">http://www.mojageneracja.pl/7233258/blog/4877775414a42215b91fd7/0</link>
      <creationTime>1245847900</creationTime>
    </bodyXML>
 </event>
</events>

1.13.4 Opisy graficzne

Serwer Gadu-Gadu po kupnie opisu graficznego na stronie GaduDodatki przesyła nam pakiet GG_XML_EVENT:

Przykładowy opis graficzny: Krol Popu

<?xml version="1.0" encoding="utf-8" ?>
<activeUserbarEventList>
  <activeUserbarEvent>
     <userbarId>Krol Popu</userbarId>
     <beginTime>2009-07-06T12:30:43+02:00</beginTime>
     <expireTime>2009-08-05T12:30:43+02:00</expireTime>
     <userbarOwner>7496195</userbarOwner>
     <userbarBuyer>7496195</userbarBuyer>
   </activeUserbarEvent>
</activeUserbarEventList>

Użytkownik powinien zostać zapytany czy chce ustawić ten opis i jeśli tak, to wysyłany jest pakiet GG_NEW_STATUS80.

Przykładowe ustawienie opisu graficznego: Krol Popu

struct gg_new_status80 krol_popu = { 
	.status           = GG_STATUS_DESCR_MASK | GG_STATUS_IMAGE_MASK | status;
	.flags            = 0x03;
	.description_size = 9;
	.description      = "Krol Popu";
};

Gdy użytkownik ma ustawiony opis graficzny (flaga GG_STATUS_IMAGE_MASK) możemy pobrać archiwum spod adresu http://www.gadudodatki.pl/userbar/get/id/

Dla przykładowego Króla Popu jest to adres http://www.gadudodatki.pl/userbar/get/id/Krol%20Popu


1.14. Katalog publiczny

Nowe Gadu-Gadu korzysta z OAutha do odczytu oraz zmian danych w katalogu, API opisane jest na: http://dev.gadu-gadu.pl/api/pages/gaduapi.html

Nowe Gadu-Gadu korzysta z wyszukiwarki dostępnej na: http://ipubdir.gadu-gadu.pl/ngg/
Starsza wersja: http://ipubdir.gadu-gadu.pl

Od wersji 5.0.2 zmieniono sposób dostępu do katalogu publicznego — stał się częścią sesji, zamiast osobnej sesji HTTP. Aby obsługiwać wyszukiwanie osób, odczytywanie własnych informacji lub ich modyfikację należy użyć następującego typu pakietu:

#define GG_PUBDIR50_REQUEST 0x0014
	
struct gg_pubdir50 {
	char type;
	int seq;
	char request[];
};

Pole type oznacza rodzaj zapytania:

#define GG_PUBDIR50_WRITE 0x01
#define GG_PUBDIR50_READ 0x02
#define GG_PUBDIR50_SEARCH 0x03

Pole seq jest numerem sekwencyjnym zapytania, różnym od zera, zwracanym również w wyniku. Oryginalny klient tworzy go na podstawie aktualnego czasu. request zawiera parametry zapytania. Ilość jest dowolna. Każdy parametr jest postaci "nazwa\0wartość\0", tzn. nazwa od wartości są oddzielone znakiem o kodzie 0, podobnie jak kolejne parametry od siebie. Możliwe parametry zapytania to:

EtykietaWartośćZnaczenie
GG_PUBDIR50_UINFmNumberNumer szukanej osoby
GG_PUBDIR50_FIRSTNAMEfirstnameImię
GG_PUBDIR50_LASTNAMElastnameNazwisko
GG_PUBDIR50_NICKNAMEnicknamePseudonim
GG_PUBDIR50_BIRTHYEARbirthyearRok urodzenia. Jeśli chcemy szukać osób z danego przedziału, podajemy rok początkowy i końcowy, oddzielone spacją. Na przykład „1980 1985”.
GG_PUBDIR50_CITYcityMiejscowość
GG_PUBDIR50_GENDERgenderPłeć. Jeśli szukamy kobiet, ma wartość „1” (stała GG_PUBDIR50_GENDER_FEMALE). Jeśli mężczyzn, ma wartość „2” (stała GG_PUBDIR50_GENDER_MALE). W przypadku pobierania lub ustawiania informacji o sobie stałe mają odwrócone znaczenia (stałe GG_PUBDIR50_GENDER_SET_FEMALE i GG_PUBDIR50_GENDER_SET_MALE)
GG_PUBDIR50_ACTIVEActiveOnlyJeśli szukamy tylko dostępnych osób, ma mieć wartość „1” (stała GG_PUBDIR50_ACTIVE_TRUE).
GG_PUBDIR50_FAMILYNAMEfamilynameNazwisko panieńskie. Ma znaczenie tylko przy ustawianiu własnych danych.
GG_PUBDIR50_FAMILYCITYfamilycityMiejscowość pochodzenia. Ma znaczenie tylko przy ustawianiu własnych danych.
GG_PUBDIR50_STARTfmstartNumer, od którego rozpocząć wyszukiwanie. Ma znaczenie, gdy kontynuujemy wyszukiwanie.

Treść przykładowego zapytania (pomijając pola type i seq) znajduje się poniżej. Szukano dostępnych kobiet o imieniu Ewa z Warszawy. Znaki o kodzie 0 zastąpiono kropkami.

firstname.Ewa.city.Warszawa.gender.1.ActiveOnly.1.

Wynik zapytania zostanie zwrócony za pomocą pakietu:

#define GG_PUBDIR50_REPLY 0x000e
	
struct gg_pubdir50_reply {
	char type;
	int seq;
	char reply[];
};

Pole type poza wartościami takimi jak przy pakiecie typu GG_PUBDIR50_REQUEST może przyjąć jeszcze wartość oznaczającą odpowiedź wyszukiwania:

#define GG_PUBDIR50_SEARCH_REPLY 0x05

Wyniki są zbudowane identycznie jak w przypadku zapytań, z tą różnicą, że kolejne osoby oddzielane pustym polem: "parametr\0wartość\0\0parametr\0wartość\0".

EtykietaWartośćZnaczenie
GG_PUBDIR50_STATUSFmStatusStan szukanej osoby
 nextstartPole występujące w ostatnim wyniku, określające, od jakiego numeru należy rozpocząć wyszukiwanie, by otrzymać kolejną porcję danych. Podaje się go w zapytaniu jako parametr „start”.

Przykładowy wynik zawierający dwie znalezione osoby:

FmNumber.12345.FmStatus.1.firstname.Adam.nickname.Janek.birthyear.1979.city.Wzdów
..FmNumber.3141592.FmStatus.5.firstname.Ewa.nickname.Ewcia.birthyear.1982.city.Gd
dańsk..nextstart.0.

Wyszukiwanie nie zwraca nazwisk i płci znalezionych osób.


1.15. Lista kontaktów

Sprawdzić czy wszystkie #define dalej są potrzebne

Od wersji 6.0 lista kontaktów na serwerze stała częścią sesji, zamiast osobnej sesji HTTP. Aby wysłać lub pobrać listę kontaktów z serwera należy użyć pakietu:

#define GG_USERLIST100_REQUEST 0x0040
	
struct gg_userlist100_request {
	char type;		/* rodzaj zapytania */
	int version;		/* numer ostatniej znanej wersji listy kontaktów bądź 0 */
	char format_type;	/* rodzaj formatu listy kontaktów */
	char unknown1;		/* zawsze 0x01 */
	char request[];		/* treść (nie musi wystąpić) */
};

Pole type oznacza rodzaj zapytania:

#define GG_USERLIST100_PUT 0x00		/* eksport listy */
#define GG_USERLIST100_GET 0x02		/* import listy */

Pole format_type oznacza typ formatu listy kontaktów:

#define GG_USERLIST100_FORMAT_TYPE_NONE 0x00        /* brak treści listy kontaktów */
#define GG_USERLIST100_FORMAT_TYPE_GG70 0x01        /* format listy kontaktów zgodny z Gadu-Gadu 7.0 */
#define GG_USERLIST100_FORMAT_TYPE_GG100 0x02       /* format listy kontaktów zgodny z Gadu-Gadu 10.0 */

Typ GG_USERLIST100_FORMAT_TYPE_NONE ma sens wyłącznie w przypadku importu listy kontaktów. Po jego użyciu serwer wysyła odpowiedź zawierającą numer wersji listy kontaktów, ale bez samej listy kontaktów. Oryginalny klient jednak w ogóle nie wykorzystuje tego sposobu.

W przypadku eksportu listy kontaktów, pole request, o ile zdefiniowano typ jako GG_USERLIST100_FORMAT_TYPE_GG100, zawiera dokument XML opisany na stronie http://dev.gadu-gadu.pl/api/pages/formaty_plikow.html. Zawartość tego pola musi być skompresowana algorytmem Deflate. Wolnodostępna implementacja algorytmu, używana również przez oryginalnego klienta, znajduje się w biblotece zlib. Oryginalny klient używa najwyższego stopnia kompresji.

Na zapytania dotyczące listy kontaktów serwer odpowiada pakietem:

#define GG_USERLIST100_REPLY 0x0041
	
struct gg_userlist100_reply {
	char type;		/* rodzaj odpowiedzi */
	int version;		/* numer wersji listy kontaktów aktualnie przechowywanej przez serwer */
	char format_type;	/* rodzaj przesyłanego typu formatu listy kontaktów */
	char unknown1;		/* zawsze 0x01 */
	char reply[];		/* treść (nie musi wystąpić) */
};

Pole type oznacza rodzaj odpowiedzi:

#define GG_USERLIST100_REPLY_LIST 0x00       /* w odpowiedzi znajduje się aktualna lista kontaktów na serwerze */
#define GG_USERLIST100_REPLY_UPTODATE 0x01   /* komunikat o tym, że lista kontaktów jest już zsynchronizowana */
#define GG_USERLIST100_REPLY_ACK 0x10        /* potwierdzenie odebrania nowej wersji listy kontaktów */
#define GG_USERLIST100_REPLY_REJECT 0x12     /* odmowa przyjęcia nowej wersji listy kontaktów z powodu
                                                niezgodności numeru wersji listy kontaktów */

W przypadku importu w polu request niekoniecznie musi znajdować się lista kontaktów w takiej samej postaci, w jakiej ją umieszczono. Serwer stara się utrzymywać obie wersje listy kontaktów (tzn. GG_USERLIST100_FORMAT_TYPE_GG70 oraz GG_USERLIST100_FORMAT_TYPE_GG100) w zgodności, dlatego po wysłaniu jednej z nich serwer automatycznie modyfikuje drugą. W przypadku wysłania listy kontaktów w formacie niezgodnym z zadeklarowanym w polu format_type, serwer usunie istniejącą listę kontaktów, ale nie zachowa przesyłanej i zostanie na nim pusta lista.

Aby usunąć listę kontaktów z serwera oryginalny klient wysyła spację jako listę kontaktów czego wynikiem jest pole request o zawartości:

78 da 53 00 00 00 21 00 21

W celu sprawnej synchronizacji listy kontaktów między różnymi instalacjami klienta sieci, serwer wersjonuje listę kontaktów i pozwala ją nadpisać tylko w przypadku, gdy zadeklarujemy znajomość jej ostatniej wersji. Serwer w pakiecie GG_USERLIST100_REPLY w polu version zawsze przesyła numer ostatniej znanej mu wersji listy kontaktów, przy czym w przypadku GG_USERLIST100_REPLY_ACK jest to nowo zaakceptowana przed chwilą wysłana wersja. Wysyłając listę kontaktów, należy w polu version umieścić numer ostatniej znanej wersji listy kontaktów. Zostanie ona zaakceptowana tylko jeśli jest to również ostatnia znana serwerowi wersja. W przypadku importu listy przesyłany numer wersji nie ma znaczenia, a oryginalny klient wysyła tu 0.

W czasie istnienia sesji po każdej zmianie listy kontaktów na serwerze, również jeśli została ona dokonana w obrębie innej sesji mulilogowania, serwer wysyła informacje o nowej wersji za pomocą pakietu:

#define GG_USERLIST100_VERSION 0x005c
	
struct gg_userlist100_version {
	int version;		/* numer wersji listy kontaktów */
};

Należy zwrócić uwagę na fakt, że pakiet z informacją o nowej wersji listy kontaktów może przyjść przed pakietem GG_USERLIST100_REPLY z informacją o akceptacji listy kontaktów.


1.16. Indeks pakietów

Pakiety wysyłane:

WartośćEtykietaZnaczenie
0x0002GG_NEW_STATUSZmiana stanu przed GG 8.0
0x0007GG_PONGPong
0x0008GG_PINGPing
0x000bGG_SEND_MSGWysłanie wiadomości przed GG 8.0
0x000cGG_LOGINLogowanie przed GG 6.0
0x000dGG_ADD_NOTIFYDodanie do listy kontaktów
0x000eGG_REMOVE_NOTIFYUsunięcie z listy kontaktów
0x000fGG_NOTIFY_FIRSTPoczątkowy fragment listy kontaktów większej niż 400 wpisów
0x0010GG_NOTIFY_LASTOstatni fragment listy kontaktów
0x0012GG_LIST_EMPTYLista kontaktów jest pusta
0x0013GG_LOGIN_EXTLogowanie przed GG 6.0
0x0014GG_PUBDIR50_REQUESTZapytanie katalogu publicznego
0x0015GG_LOGIN60Logowanie przed GG 7.7
0x0016GG_USERLIST_REQUESTZapytanie listy kontaktów na serwerze przed Nowym Gadu-Gadu
0x0019GG_LOGIN70Logowanie przed GG 8.0
0x001fGG_DCC7_INFO
0x0020GG_DCC7_NEWInformacje o chęci nawiązania połączenia DCC
0x0021GG_DCC7_ACCEPTZaakceptowanie połączenia DCC
0x0022GG_DCC7_REJECTOdrzucenie połączenia DCC
0x0023GG_DCC7_ID_REQUEST
0x0024GG_DCC7_DUNNO1
0x0025GG_DCC7_ABORT
0x0028GG_NEW_STATUS80BETAZmiana stanu przed Nowym Gadu-Gadu
0x0029GG_LOGIN80BETALogowanie przed Nowym Gadu-Gadu
0x002dGG_SEND_MSG80Wysłanie wiadomości
0x002fGG_USERLIST_REQUEST80Zapytanie listy kontaktów na serwerze przed Gadu-Gadu 10
0x0031GG_LOGIN80Logowanie
0x0038GG_NEW_STATUS80Zmiana stanu
0x0040GG_USERLIST100_REQUESTZapytanie listy kontaktów na serwerze
0x0046GG_RECV_MSG_ACKPotwierdzenie odebrania wiadomości przez klienta
0x0059GG_TYPING_NOTIFYPowiadomienie o pisaniu
0x0062GG_OWN_DISCONNECTRozłączenie zdalnego klienta

Pakiety odbierane:

WartośćEtykietaZnaczenie
0x0001GG_WELCOMELiczba do wyznaczenie hashu hasła
0x0002GG_STATUSZmiana stanu przed GG 6.0
0x0003GG_LOGIN_OKLogowanie powiodło się przed Nowym Gadu-Gadu
0x0005GG_SEND_MSG_ACKPotwierdzenie wiadomości
0x0007GG_PONGPong
0x0008GG_PINGPing
0x0009GG_LOGIN_FAILEDLogowanie nie powiodło się
0x000aGG_RECV_MSGPrzychodząca wiadomość przed GG 8.0
0x000bGG_DISCONNECTINGZerwanie połączenia
0x000cGG_NOTIFY_REPLYStan listy kontaktów przed GG 6.0
0x000dGG_DISCONNECT_ACKZerwanie połączenia po zmianie stanu na niedostępny
0x000eGG_PUBDIR50_REPLYOdpowiedź katalogu publicznego
0x000fGG_STATUS60Zmiana stanu przed GG 7.7
0x0010GG_USERLIST_REPLYOdpowiedź listy kontaktów na serwerze przed nowym Gadu-Gadu
0x0011GG_NOTIFY_REPLY60Stan listy kontaktów przed GG 7.7
0x0014GG_NEED_EMAILLogowanie powiodło się, ale powinniśmy uzupełnić adres e-mail w katalogu publicznym
0x0016GG_LOGIN_HASH_TYPE_INVALIDDany rodzaj hashowania hasła jest nieobsługiwany przez serwer
0x0017GG_STATUS77Zmiana stanu przed GG 8.0
0x0018GG_NOTIFY_REPLY77Stan listy kontaktów przed GG 8.0
0x001fGG_DCC7_INFO
0x0020GG_DCC7_NEWInformacje o chęci nawiązania połączenia DCC
0x0021GG_DCC7_ACCEPTZaakceptowanie połączenia DCC
0x0022GG_DCC7_REJECTOdrzucenie połączenia DCC
0x0023GG_DCC7_ID_REPLY
0x0025GG_DCC7_ABORTED
0x0027GG_XML_EVENTOdebrano wiadomość systemową
0x002aGG_STATUS80BETAZmiana stanu przed Nowym Gadu-Gadu
0x002bGG_NOTIFY_REPLY80BETAStan listy kontaktów przed Nowym Gadu-Gadu
0x002cGG_XML_ACTION
0x002eGG_RECV_MSG80Przychodząca wiadomość
0x0030GG_USERLIST_REPLY80Odpowiedź listy kontaktów na serwerze przed Gadu-Gadu 10
0x0035GG_LOGIN_OK80Logowanie powiodło się
0x0036GG_STATUS80Zmiana stanu
0x0037GG_NOTIFY_REPLY80Stan listy kontaktów
0x0041GG_USERLIST100_REPLYOdpowiedź listy kontaktów na serwerze
0x0044GG_USER_DATADodatkowe informacje o liście kontaktów
0x0059GG_TYPING_NOTIFYPowiadomienie o pisaniu
0x005AGG_OWN_MESSAGEWłasne wiadomości z innych klientów
0x005BGG_OWN_RESOURCE_INFOInformacje o innych połączeniach na naszym numerze
0x005CGG_USERLIST100_VERSIONInformacje o nowej wersji listy kontaktów

2. Usługi HTTP

2.1. Format danych

Komunikacja z appmsg.gadu-gadu.pl metodą GET HTTP/1.0 została opisana w poprzednim rozdziale, pozostałe pakiety używają POST dla HTTP/1.0, a w odpowiedzi 1.1. Mają one postać:

POST ŚCIEŻKA HTTP/1.0
Host: HOST
Content-Type: application/x-www-form-urlencoded
User-Agent: AGENT
Content-Length: DŁUGOŚĆ
Pragma: no-cache

DANE

Gdzie AGENT to nazwa przeglądarki (na przykład Mozilla/4.0 (compatible; MSIE 5.0; Windows 98) lub inne, wymienione w rozdziale 1.2), DŁUGOŚĆ to długość bloku DANE w znakach.

Jeśli będzie mowa o wysyłaniu danych do serwera, to chodzi o cały powyższy pakiet, opisane zostaną tylko: HOST, ŚCIEŻKA i DANE. Pakiet jest wysyłany na port 80. Gdy mowa o wysyłaniu pól zapytania, mowa o DANE o wartości:

pole1=wartość1&pole2=wartość2&...

Pamiętaj o zmianie kodowania na CP1250 i zakodowaniu danych do postaci URL (na przykład funkcją typu urlencode).

Odpowiedzi serwera na powyższe zapytania mają mniej więcej postać:

HTTP/1.1 200 OK
Server: Microsoft-IIS/5.0
Date: Mon, 01 Jul 2002 22:30:31 GMT
Connection: Keep-Alive
Content-Length: DŁUGOŚĆ
Content-Type: text/html
Set-Cookie: COOKIE
Cache-control: private

ODPOWIEDŹ

Nagłówki nie są dla nas ważne. Można zauważyć tylko to, że czasami serwer ustawia COOKIE np. „ASPSESSIONIDQQGGGLJC=CAEKMBGDJCFBEOKCELEFCNKH; path=/”. Pisząc dalej, że serwer „odpowie wartością” mowa tylko o polu ODPOWIEDŹ. Kodowanie znaków w odpowiedzi to CP1250.


2.2. Tokeny

Prawdopodobnie ze względu na nadużycia i wykorzystywanie automatów rejestrujących do polowań na „złote numery GG”, wprowadzono konieczność autoryzacji za pomocą tokenu. Każda operacja zaczyna się od pobrania tokenu z serwera, wyświetlenia użytkownikowi, odczytaniu jego wartości i wysłania zapytania z identyfikatorem i wartością tokenu. Pobranie tokenu wygląda następująco:

Pole nagłówkaWartość
HOSTregister.gadu-gadu.pl
ŚCIEŻKA/appsvc/regtoken.asp

Nie są wysyłane żadne parametry. Przykład:

GET /appsvc/regtoken.asp HTTP/1.1
Connection: Keep-Alive
Host: register.gadu-gadu.pl

Serwer w odpowiedzi odeśle:

SZEROKOŚĆ WYSOKOŚĆ DŁUGOŚĆ
IDENTYFIKATOR
ŚCIEŻKA

Gdzie SZEROKOŚĆ i WYSOKOŚĆ opisują wymiary obrazka z wartością tokenu, DŁUGOŚĆ mówi ile znaków zawiera token, IDENTYFIKATOR jest identyfikatorem tokenu (tylko do niego pasuje wartość tokenu), a ŚCIEŻKA to ścieżka do skryptu zwracającego obrazek z wartością tokenu. Przykładowa odpowiedź:

115 30 6
e05622e7fcc844b3d582671e0458f0b1
http://register.gadu-gadu.pl/regRndPictNew.php

Możemy teraz pobrać metodą GET z podanej ścieżki obrazek z tokenem, doklejając do ścieżki parametr tokenid o wartości będącej identyfikatorem uzyskanym przed chwilą. Adres obrazka z wartością tokenu dla powyższego przykładu to:

http://register.gadu-gadu.pl/regRndPictNew.php?tokenid=e05622e7fcc844b3d582671e0458f0b1

Pobrany obrazek (w tej chwili jest w formacie GIF, ale prawdopodobnie może się to zmienić na dowolny format obsługiwany domyślnie przez system Windows) najlepiej wyświetlić użytkownikowi, prosząc o podanie wartości na nim przedstawionej. Będzie ona niezbędna do przeprowadzenia kolejnych operacji.


2.3. Rejestracja konta

Pole nagłówkaWartość
HOSTregister.gadu-gadu.pl
ŚCIEŻKA/appsvc/fmregister3.asp

Wysyłamy poleZnaczenie
pwdhasło dla nowego numeru
emaile-mail na który będzie przesyłane przypomnienie hasła
tokenididentyfikator tokenu
tokenvalwartość tokenu
codehash liczony z pól email i pwd. Algorytmu szukaj w źródłach libgadu w lib/common.c

Przykład:

POST /fmregister.php HTTP/1.1
Host: register.gadu-gadu.pl
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/4.7 [en] (Win98; I)
Content-Length: 99
Pragma: no-cache
		
code=283395733&email=abc@xyz.pl&pwd=sekret&tokenid=e05622e7fcc844b3d582671e0458f0b1&tokenval=SEKYCA

Jeśli wszystko przebiegło poprawnie, serwer odpowie:

reg_success:UIN

Gdzie UIN to nowy numer, który właśnie otrzymaliśmy.

Jeśli został podany nieprawidłowy token, serwer odpowie:

bad_tokenval

W przypadku zbyt długiego hasła, serwer odpowie:

error3 

Jeśli podano niepoprawny adres e-mail, odpowiedź serwera jest pusta.


2.4. Usunięcie konta

Nowe Gadu-Gadu zaprasza użytkownika na stronę https://deleteaccount.messenger.gadu-gadu.pl na której użytkownik może usunąć swoje konto.


2.5. Zmiana hasła

Pole nagłówkaWartość
HOSTregister.gadu-gadu.pl
ŚCIEŻKA/fmregister.php

Wysyłamy poleZnaczenie
fmnumbernumer
fmpwdstare hasło
pwdnowe hasło
emailnowe adres e-email
tokenididentyfikator tokenu
tokenvalwartość tokenu
codehash liczony z pól pwd i email

Jeśli wszystko przebiegło poprawnie, serwer odpowie:

reg_success:UIN

W przypadku nieprawidłowego starego hasła, serwer odpowie:

not authenticated

W przypadku zbyt długiego nowego hasła, serwer odpowie:

error1

2.6. Przypomnienie hasła pocztą

Pole nagłówkaWartość
HOSTregister.gadu-gadu.pl
ŚCIEŻKA/fmsendpwd.php

Wysyłamy poleZnaczenie
useridnumer
tokenididentyfikator tokenu
tokenvalwartość tokenu
codehash liczony z pola userid

Jeśli się udało, serwer odpowie:

pwdsend_success

3. Połączenia między klientami

3.1. Identyfikator połączenia

Połączenia bezpośrednie pozwalają przesyłać pliki lub prowadzić rozmowy głosowe bez pośrednictwa serwera. Początkowe wersje Gadu-Gadu potrafiły przesyłać bezpośrednio również wiadomości tekstowe, ale funkcjonalność ta została zarzucona.

Dla każdego połączenia musimy zdobyć od serwera 8 bajtowy identyfikator. Aby pobrać identyfikator należy użyć pakietu:

#define GG_DCC7_ID_REQUEST 0x0023

struct gg_dcc7_id_request {
	int type;		/* rodzaj transmisji */
};

Pole type oznacza rodzaj transmisji:

#define GG_DCC7_TYPE_VOICE 0x00000001	/* rozmowa głosowa (już nieużywane) */
#define GG_DCC7_TYPE_FILE 0x00000004	/* przesyłanie plików */

Na co serwer odpowie:

#define GG_DCC7_ID_REPLY 0x0023

struct gg_dcc7_id_reply {
	int type;	/* rodzaj transmisji */
	long long id;	/* przyznany identyfikator */
};

3.2. Przesyłanie plików

Aby powiadomić odbiorcę o chęci przesłania pliku, należy wysłać do serwera następujący pakiet:

#define GG_DCC7_NEW 0x0020

struct gg_dcc7_new {
	long long id;		/* identyfikator połączenia */
	int uin_from;		/* numer nadawcy */
	int uin_to;		/* numer odbiorcy */
	int type;		/* rodzaj transmisji */
	char filename[255];	/* nazwa pliku */
	long long size;		/* rozmiar pliku */
	char hash[20];		/* hash SHA1 (już nieużywane 00 00 00) */
};

Odbiorca po otrzymaniu tego samego pakietu GG_DCC7_NEW, może zaakceptować plik wysyłając pakiet:

#define GG_DCC7_ACCEPT 0x0021

struct gg_dcc7_accept {
	int uin;		/* numer przyjmującego połączenie */
	long long id;		/* identyfikator połączenia */
	long long offset;	/* offset przy wznawianiu transmisji */
};

Jeśli plik został już częściowo odebrany i chcemy wznowić przesyłanie, w polu offset wystarczy podać ile bajtów już mamy, a odebrane dane dopisać na końcu pliku.

Jeśli odbiorca chce odrzucić plik, wysyła pakiet:

#define GG_DCC7_REJECT 0x0022

struct gg_dcc7_reject {
	int uin;	/* numer odrzucającego połączenie */
	long long id;	/* identyfikator połączenia */
	int reason;	/* powód rozłączenia */
};

Dla pola reason znane są wartości:

#define GG_DCC7_REJECT_BUSY	0x00000001	/* połączenie bezpośrednie już trwa, nie umiem
						   obsłużyć więcej */
#define GG_DCC7_REJECT_USER	0x00000002	/* użytkownik odrzucił połączenie */
#define GG_DCC7_REJECT_HIDDEN	0x00000003	/* użytkownik ojest ukryty i nie możesz  
						   mu wysłać pliku*/
#define GG_DCC7_REJECT_VERSION	0x00000006	/* druga strona ma wersję klienta nieobsługującą
						   połączeń bezpośrednich tego typu */

Przed akceptacją pliku przez odbiorcę, nadawca może przerwać żądanie wysyłając pakiet:

#define GG_DCC7_ABORT 0x0025

struct gg_dcc7_abort {
	long long id;		/* identyfikator połączenia */
	int uin_from;		/* numer nadawcy */
	int uin_to;		/* numer odbiorcy */
};

Odbiorca w takim przypadku otrzyma pakiet:

#define GG_DCC7_ABORTED 0x0025

struct gg_dcc7_aborted {
	long long id;		/* identyfikator połączenia */
};

3.3. Połączenie bezpośrednie

Po zaakceptowaniu pliku, obie strony zaczynają nasłuchiwać na losowo wybranym porcie z zakresu 4096..32767 i wysyłają pakiet GG_DCC7_INFO z informacjami potrzebnymi do połączenia.

#define GG_DCC7_INFO 0x001f

struct gg_dcc7_info {
	int uin;		/* numer nadawcy */
	int type;		/* sposób połączenia */
	long long id;		/* identyfikator połączenia */
	char info[32];		/* informacje o połączeniu */
	char cookie[32];	/* losowa informacja */
};

Pole type określa sposób połączenia:

#define GG_DCC7_TYPE_P2P    0x00000001	/* połączenie bezpośrednie */
#define GG_DCC7_TYPE_SERVER 0x00000002	/* połączenie przez serwer */

Pole info zawiera tekstową reprezentację adresu IP, spację i numer portu. Pole cookie jest tekstową reprezentacją liczby wyznaczanej w następujący sposób:

// Gadu-Gadu 8.x i późniejsze
int cookie = adres + port * rand();

// Gadu-Gadu 7.x
int cookie = 0x7FFF * rand() + rand();

Adres do obliczeń jest zapisany w sieciowej kolejności bajtów (np. wynik funkcji inet_addr()), port w lokalnej.

Przykładowa zawartość pól info i cookie:

0000   31 30 2e 30 2e 30 2e 32 20 32 32 35 36 33 00 00  10.0.0.2 22563..
0010   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0020   31 37 36 34 36 38 34 38 34 00 00 00 00 00 00 00  176468484.......
0030   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

Po udanym połączeniu na podany adres, wysyłamy pakiet powitalny:

struct gg_dcc7_welcome_p2p {
	long long id;	/* identyfikator połączenia */
};

Druga strona powinna odpowiedzieć tym samym. Teraz już możemy albo wysyłać albo odbierać plik.


3.4. Połączenie przez serwer

Obie strony połączenia łączą się również z relay.gadu-gadu.pl:80 aby uzyskać listę serwerów które mogą pośredniczyć w wymianie plików. Struktura żądania:

#define GG_DCC7_RELAY_REQUEST 0x0a

struct gg_dcc7_relay_req {
	int type;	/* 0x0a */
	int len;	/* długość całego pakietu */
	long long id;	/* identyfikator połączenia */
	short req_type;	/* typ żądania (patrz niżej) */
	char family	/* 0x02, prawdopodobnie rodzina adresów (AF_INET=2) */
	char unknown;   /* 0x00 */
};

Gdzie req_type może przyjąć wartości:

#define GG_DCC7_RELAY_TYPE_PROXY    0x01 /* adresy proxy, na które sie łączyć */
#define GG_DCC7_RELAY_TYPE_SERVER   0x08 /* adres serwera, na który spytać o proxy */

Serwer odpowiada:

#define GG_DCC7_RELAY_REPLY 0x0b

struct gg_dcc7_relay_reply {
	int type;	/* 0x0b */
	int len;	/* długość całego pakietu */
	int count;	/* prawdopodobnie ilość pośredniczących serwerów */
	struct {
		int ip;		/* adres ip serwera */
		short port;	/* port serwera */
		char family;	/* prawdopodobnie rodzina adresów (AF_INET=2) */
	} proxies[];
};

Pobieranie IP serwera(ów) pośredniczących w Gadu-Gadu 10.x następuje przed i po wysłaniu GG_DCC7_INFO wg schematu:

Może się zdarzyć, że żaden z serwerów nie odpowie na pierwsze żądanie, wtedy jako adres drugiego żądania bierzemy znowu relay.gadu-gadu.pl.

Po uzyskaniu adresu serwera pośredniczącego należy wysłać pakiet GG_DCC7_INFO (opisany wcześniej) z polem type równym GG_DCC7_TYPE_SERVER i polem info w postaci:

GGidCHrand

Gdzie id to tekstowa reprezentacja identyfikatora połączenia, a rand to losowa wartość z zakresu 0..9999. Gadu-Gadu 7.x zamiast CH mogło wysłać również SH.

Pole cookie pozostaje puste.

Przykładowa zawartość pól info i cookie:

0000   47 47 31 31 30 32 30 38 38 36 30 38 34 33 39 31  GG11020886084391
0010   43 48 36 39 36 32 00 00 00 00 00 00 00 00 00 00  CH6962..........
0020   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0030   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

Po połączeniu do serwera pośredniczącego wysyłamy pakiet powitalny:

struct gg_dcc7_welcome_server {
	int welcome;	/* 0xc0debabe */
	long long id;	/* identyfikator połączenia */
};

Serwer powinien odpowiedzieć tym samym. Teraz już możemy albo wysyłać albo odbierać plik.


3.4. Rozmowy głosowe

Połączenia głosowe są realizowane za pomocą protokołu SIP.


4. Autorzy

Lista autorów tego tekstu znajduje się poniżej. Ich adresy e-mail nie służą do zadawania pytań o podstawy programowania albo jak się połączyć z serwerem i co zrobić dalej. Jeśli masz pytania dotyczące protokołu, napisz na listę dyskusyjną libgadu-devel.