libgadu.h   libgadu.h 
/* include/libgadu.h. Generated from libgadu.h.in by configure. */ /* include/libgadu.h. Generated from libgadu.h.in by configure. */
/* $Id$ */ /* $Id$ */
/* /*
* (C) Copyright 2001-2003 Wojtek Kaniewski <wojtekka@irc.pl> * (C) Copyright 2001-2003 Wojtek Kaniewski <wojtekka@irc.pl>
* Robert J. Wo * Robert J. Woźny <speedy@ziew.org>
* Arkadiusz Mi * Arkadiusz Miśkiewicz <arekm@pld-linux.org>
* Tomasz Chili * Tomasz Chiliński <chilek@chilan.com>
* Piotr Wysocki <wysek@linux.bydg.org> * Piotr Wysocki <wysek@linux.bydg.org>
* Dawid Jarosz <dawjar@poczta.onet.pl> * Dawid Jarosz <dawjar@poczta.onet.pl>
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License Version * it under the terms of the GNU Lesser General Public License Version
* 2.1 as published by the Free Software Foundation. * 2.1 as published by the Free Software Foundation.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details. * GNU Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software * License along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
* USA. * USA.
*/ */
/**
* \file libgadu.h
*
* \brief Główny plik nagłówkowy biblioteki
*/
#ifndef __GG_LIBGADU_H #ifndef __GG_LIBGADU_H
#define __GG_LIBGADU_H #define __GG_LIBGADU_H
#ifdef __cplusplus #ifdef __cplusplus
#ifdef _WIN32 #ifdef _WIN32
#pragma pack(push, 1) #pragma pack(push, 1)
#endif #endif
extern "C" { extern "C" {
#endif #endif
#include <sys/types.h> #include <sys/types.h>
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
/** \cond ignore */
/* Defined if libgadu was compiled for bigendian machine. */ /* Defined if libgadu was compiled for bigendian machine. */
/* #undef GG_CONFIG_BIGENDIAN */ /* #undef GG_CONFIG_BIGENDIAN */
/* Defined if this machine has gethostbyname_r(). */ /* Defined if this machine has gethostbyname_r(). */
#define GG_CONFIG_HAVE_GETHOSTBYNAME_R /**/ #define GG_CONFIG_HAVE_GETHOSTBYNAME_R /**/
/* Defined if libgadu was compiled and linked with pthread support. */ /* Defined if libgadu was compiled and linked with pthread support. */
/* #undef GG_CONFIG_HAVE_PTHREAD */ /* #undef GG_CONFIG_HAVE_PTHREAD */
/* Defined if this machine has C99-compiliant vsnprintf(). */ /* Defined if this machine has C99-compiliant vsnprintf(). */
skipping to change at line 124 skipping to change at line 132
#endif #endif
#endif /* __AC_STDINT_H */ #endif /* __AC_STDINT_H */
# endif # endif
# endif # endif
# endif # endif
# endif # endif
#endif #endif
/* /** \endcond */
* typedef uin_t
* /**
* typ reprezentuj * Numer Gadu-Gadu.
*/ */
typedef uint32_t uin_t; typedef uint32_t uin_t;
/* /**
* og * Identyfikator połączenia bezpośredniego Gadu-Gadu 7.x.
*/ */
#define gg_common_head(x) \ typedef struct {
int fd; /* podgl uint8_t id[8];
int check; /* sprawdzamy zapis czy odczyt */ \ } gg_dcc7_id_t;
int state; /* aktualny stan maszynki */ \
int error; /* kod b
int type; /* rodzaj sesji */ \
int id; /* identyfikator */ \
int timeout; /* sugerowany timeout w sekundach */ \
int (*callback)(x*); /* callback przy zmianach */ \
void (*destroy)(x*); /* funkcja niszczenia */
/**
* Makro deklarujące pola wspólne dla struktur sesji.
*/
#define gg_common_head(x) \
int fd; /**< Obserwowany deskryptor */ \
int check; /**< Informacja o żądaniu odczytu/zapisu (pa
trz \c gg_check_t) */ \
int state; /**< Aktualny stan połączenia (patrz \c gg_s
tate_t) */ \
int error; /**< Kod błędu dla \c GG_STATE_ERROR (patrz
\c gg_error_t) */ \
int type; /**< Rodzaj sesji (patrz \c gg_session_t) */
\
int id; /**< Identyfikator sesji */ \
int timeout; /**< Czas pozostały do zakończenia stanu */
\
int (*callback)(x*); /**< Funkcja zwrotna */ \
void (*destroy)(x*); /**< Funkcja zwalniania zasobów */
/**
* Struktura wspólna dla wszystkich sesji i połączeń. Pozwala na proste
* rzutowanie niezależne od rodzaju połączenia.
*/
struct gg_common { struct gg_common {
gg_common_head(struct gg_common) gg_common_head(struct gg_common)
}; };
struct gg_image_queue; struct gg_image_queue;
/* struct gg_dcc7;
* struct gg_session
/**
* Sesja Gadu-Gadu.
*
* Tworzona przez funkcję \c gg_login(), zwalniana przez \c gg_free_session
().
* *
* struktura opisuj * \ingroup login
* przez gg_free_session().
*/ */
struct gg_session { struct gg_session {
gg_common_head(struct gg_session) gg_common_head(struct gg_session)
int async; /* czy po int async; /**< Flaga połączenia asynchronicznego */
int pid; /* pid procesu resolvera */ int pid; /**< Numer procesu rozwiązującego nazwę serw
int port; /* port, z kt era */
int seq; /* numer sekwencyjny ostatniej wiadomo int port; /**< Port serwera */
int last_pong; /* czas otrzymania ostatniego ping/pong */ int seq; /**< Numer sekwencyjny ostatniej wiadomości
int last_event; /* czas otrzymania ostatniego pakietu */ */
int last_pong; /**< Czas otrzymania ostatniej ramki utrzyma
niowej */
int last_event; /**< Czas otrzymania ostatniego pakietu */
struct gg_event *event; /* zdarzenie po ->callback() */ struct gg_event *event; /**< Zdarzenie po wywołaniu \c callback */
uint32_t proxy_addr; /* adres proxy, keszowany */ uint32_t proxy_addr; /**< Adres serwera pośredniczącego */
uint16_t proxy_port; /* port proxy */ uint16_t proxy_port; /**< Port serwera pośredniczącego */
uint32_t hub_addr; /* adres huba po resolvni uint32_t hub_addr; /**< Adres huba po rozwiązaniu nazwy */
uint32_t server_addr; /* adres serwera, od huba */ uint32_t server_addr; /**< Adres serwera otrzymany od huba */
uint32_t client_addr; /* adres klienta */ uint32_t client_addr; /**< Adres gniazda dla połączeń bezpośrednic
uint16_t client_port; /* port, na kt h do wersji Gadu-Gadu 6.x */
uint16_t client_port; /**< Port gniazda dla połączeń bezpośrednich
do wersji Gadu-Gadu 6.x */
uint32_t external_addr; /* adres zewnetrzny klienta */ uint32_t external_addr; /**< Publiczny adres dla połączeń bezpośredn
uint16_t external_port; /* port zewnetrzny klienta */ ich do wersji Gadu-Gadu 6.x */
uint16_t external_port; /**< Publiczny port dla połączeń bezpośredni
ch do wersji Gadu-Gadu 6.x */
uin_t uin; /* numerek klienta */ uin_t uin; /**< Własny numer Gadu-Gadu */
char *password; /* i jego has char *password; /**< Hasło (zwalniane po użyciu) */
int initial_status; /* pocz int initial_status; /**< Początkowy status */
int status; /* aktualny stan klienta */ int status; /**< Aktualny status */
char *recv_buf; /* bufor na otrzymywane pakiety */ char *recv_buf; /**< Bufor na odbierany pakiety */
int recv_done; /* ile ju int recv_done; /**< Liczba wczytanych bajtów pakietu */
int recv_left; /* i ile jeszcze trzeba wczyta int recv_left; /**< Liczba pozostałych do wczytania bajtów
pakietu */
int protocol_version; /* wersja u int protocol_version; /**< Wersja protokołu */
char *client_version; /* wersja u char *client_version; /**< Wersja klienta */
int last_sysmsg; /* ostatnia wiadomo int last_sysmsg; /**< Numer ostatniej wiadomości systemowej *
/
char *initial_descr; /* pocz char *initial_descr; /**< Początkowy opis statusu */
void *resolver; /* wska void *resolver; /**< Dane prywatne procesu lub wątku rozwiąz ującego nazwę serwera */
char *header_buf; /* bufor na pocz char *header_buf; /**< Bufor na początek nagłówka pakietu */
unsigned int header_done;/* ile ju unsigned int header_done; /**< Liczba wczytanych bajtów nagłów
ka pakietu */
#ifdef GG_CONFIG_HAVE_OPENSSL #ifdef GG_CONFIG_HAVE_OPENSSL
SSL *ssl; /* sesja TLS */ SSL *ssl; /**< Struktura TLS */
SSL_CTX *ssl_ctx; /* kontekst sesji? */ SSL_CTX *ssl_ctx; /**< Kontekst sesji TLS */
#else #else
void *ssl; /* zachowujemy ABI */ void *ssl; /**< Struktura TLS */
void *ssl_ctx; void *ssl_ctx; /**< Kontekst sesji TLS */
#endif #endif
int image_size; /* maksymalny rozmiar obrazk int image_size; /**< Maksymalny rozmiar obsługiwanych obrazk ów w KiB */
char *userlist_reply; /* fragment odpowiedzi listy kontakt char *userlist_reply; /**< Bufor z odbieraną listą kontaktów */
int userlist_blocks; /* na ile kawa int userlist_blocks; /**< Liczba części listy kontaktów */
struct gg_image_queue *images; /* aktualnie wczytywane obrazki */ struct gg_image_queue *images; /**< Lista wczytywanych obrazków */
int hash_type; /**< Rodzaj funkcji skrótu hasła */
char *send_buf; /**< Bufor z danymi do wysłania */
int send_left; /**< Liczba bajtów do wysłania */
struct gg_dcc7 *dcc7_list; /**< Lista połączeń bezpośrednich sk
ojarzonych z sesją */
int soft_timeout; /**< Flaga mówiąca, że po przekroczeniu \c t
imeout należy wywołać \c gg_watch_fd() */
}; };
/* /**
* struct gg_http * Połączenie HTTP.
* *
* og * Tworzone przez \c gg_http_connect(), zwalniane przez \c gg_http_free().
* przez gg_http_connect(), zwalniana przez gg_http_free(). *
* \ingroup http
*/ */
struct gg_http { struct gg_http {
gg_common_head(struct gg_http) gg_common_head(struct gg_http)
int async; /* czy po int async; /**< Flaga połączenia asynchronicznego */
int pid; /* pid procesu resolvera */ int pid; /**< Identyfikator procesu rozwiązującego na
int port; /* port, z kt zwę serwera */
int port; /**< Port */
char *query; /* bufor zapytania http */ char *query; /**< Zapytanie HTTP */
char *header; /* bufor nag char *header; /**< Odebrany nagłówek */
int header_size; /* rozmiar wczytanego nag int header_size; /**< Rozmiar wczytanego nagłówka */
char *body; /* bufor otrzymanych informacji */ char *body; /**< Odebrana strona */
unsigned int body_size; /* oczekiwana ilo unsigned int body_size; /**< Rozmiar strony */
void *data; /* dane danej operacji http */ void *data; /**< Dane prywatne usługi HTTP */
char *user_data; /* dane u char *user_data; /**< Dane prywatne użytkownika (nie są zwaln iane) */
void *resolver; /* wska void *resolver; /**< Dane prywatne procesu lub wątku rozwiąz ującego nazwę */
unsigned int body_done; /* ile ju unsigned int body_done; /**< Liczba odebranych bajtów strony */
}; };
/** \cond ignore */
#ifdef __GNUC__ #ifdef __GNUC__
#define GG_PACKED __attribute__ ((packed)) #define GG_PACKED __attribute__ ((packed))
#else #else
#define GG_PACKED #define GG_PACKED
#endif #endif
#define GG_MAX_PATH 276 /** \endcond */
/* #define GG_MAX_PATH 276 /**< Maksymalny rozmiar nazwy pliku
* struct gg_file_info w strukturze \c gg_file_info */
/**
* Odpowiednik struktury WIN32_FIND_DATA z API WIN32.
* *
* odpowiednik windowsowej struktury WIN32_FIND_DATA niezb * Wykorzystywana przy połączeniach bezpośrednich do wersji Gadu-Gadu 6.x.
* wysy
*/ */
struct gg_file_info { struct gg_file_info {
uint32_t mode; /* dwFileAttributes */ uint32_t mode; /**< dwFileAttributes */
uint32_t ctime[2]; /* ftCreationTime */ uint32_t ctime[2]; /**< ftCreationTime */
uint32_t atime[2]; /* ftLastAccessTime */ uint32_t atime[2]; /**< ftLastAccessTime */
uint32_t mtime[2]; /* ftLastWriteTime */ uint32_t mtime[2]; /**< ftLastWriteTime */
uint32_t size_hi; /* nFileSizeHigh */ uint32_t size_hi; /**< nFileSizeHigh */
uint32_t size; /* nFileSizeLow */ uint32_t size; /**< nFileSizeLow */
uint32_t reserved0; /* dwReserved0 */ uint32_t reserved0; /**< dwReserved0 */
uint32_t reserved1; /* dwReserved1 */ uint32_t reserved1; /**< dwReserved1 */
unsigned char filename[GG_MAX_PATH - 14]; /* cFileName */ unsigned char filename[GG_MAX_PATH - 14]; /**< cFileName */
unsigned char short_filename[14]; /* cAlternateFileNam unsigned char short_filename[14]; /**< cAlternateFileN
e */ ame */
} GG_PACKED; } /** \cond ignore */ GG_PACKED /** \endcond */;
/* /**
* struct gg_dcc * Połączenie bezpośrednie do wersji Gadu-Gadu 6.x.
*
* Tworzone przez \c gg_dcc_socket_create(), \c gg_dcc_get_file(),
* \c gg_dcc_send_file() lub \c gg_dcc_voice_chat(), zwalniane przez
* \c gg_dcc_free().
* *
* struktura opisuj * \ingroup dcc6
* tworzona przez gg_dcc_socket_create(), zwalniana przez gg_dcc_free().
*/ */
struct gg_dcc { struct gg_dcc {
gg_common_head(struct gg_dcc) gg_common_head(struct gg_dcc)
struct gg_event *event; /* opis zdarzenia */ struct gg_event *event; /**< Zdarzenie po wywołaniu \c callback */
int active; /* czy to my si int active; /**< Flaga połączenia aktywnego (nieużywana)
int port; /* port, na kt */
uin_t uin; /* uin klienta */ int port; /**< Port gniazda nasłuchującego */
uin_t peer_uin; /* uin drugiej strony */ uin_t uin; /**< Własny numer Gadu-Gadu */
int file_fd; /* deskryptor pliku */ uin_t peer_uin; /**< Numer Gadu-Gadu drugiej strony połączen
unsigned int offset; /* offset w pliku */ ia */
unsigned int chunk_size;/* rozmiar kawa int file_fd; /**< deskryptor pliku */
unsigned int chunk_offset;/* offset w aktualnym kawa unsigned int offset; /**< Położenie w pliku */
unsigned int chunk_size;
/**< Rozmiar kawałka pliku */
unsigned int chunk_offset;
/**< Położenie w aktualnym kawałku pliku */
struct gg_file_info file_info; struct gg_file_info file_info;
/* informacje o pliku */ /**< Informacje o pliku */
int established; /* po int established; /**< Flaga ustanowienia połączenia */
char *voice_buf; /* bufor na pakiet po char *voice_buf; /**< Bufor na pakiet połączenia głosowego */
int incoming; /* po int incoming; /**< Flaga połączenia przychodzącego */
char *chunk_buf; /* bufor na kawa char *chunk_buf; /**< Bufor na fragment danych */
uint32_t remote_addr; /* adres drugiej strony */ uint32_t remote_addr; /**< Adres drugiej strony */
uint16_t remote_port; /* port drugiej strony */ uint16_t remote_port; /**< Port drugiej strony */
}; };
/* #define GG_DCC7_HASH_LEN 20 /**< Maksymalny rozmiar skrótu pliku
* enum gg_session_t w połączeniach bezpośrenich */
#define GG_DCC7_FILENAME_LEN 255 /**< Maksymalny rozmiar nazwy pliku
w połączeniach bezpośrednich */
#define GG_DCC7_INFO_LEN 64 /**< Maksymalny rozmiar informacji o
połączeniach bezpośrednich */
/**
* Połączenie bezpośrednie od wersji Gadu-Gadu 7.x.
* *
* rodzaje sesji. * \ingroup dcc7
*/
struct gg_dcc7 {
gg_common_head(struct gg_dcc7)
gg_dcc7_id_t cid; /**< Identyfikator połączenia */
struct gg_event *event; /**< Struktura zdarzenia */
uin_t uin; /**< Własny numer Gadu-Gadu */
uin_t peer_uin; /**< Numer Gadu-Gadu drugiej strony połączen
ia */
int file_fd; /**< Deskryptor przesyłanego pliku */
unsigned int offset; /**< Aktualne położenie w przesyłanym pliku
*/
unsigned int size; /**< Rozmiar przesyłanego pliku */
unsigned char filename[GG_DCC7_FILENAME_LEN + 1];
/**< Nazwa przesyłanego pliku */
unsigned char hash[GG_DCC7_HASH_LEN];
/**< Skrót SHA1 przesyłanego pliku */
int dcc_type; /**< Rodzaj połączenia bezpośredniego */
int established; /**< Flaga ustanowienia połączenia */
int incoming; /**< Flaga połączenia przychodzącego */
int reverse; /**< Flaga połączenia zwrotnego */
uint32_t local_addr; /**< Adres lokalny */
uint16_t local_port; /**< Port lokalny */
uint32_t remote_addr; /**< Adres drugiej strony */
uint16_t remote_port; /**< Port drugiej strony */
struct gg_session *sess;
/**< Sesja do której przypisano połączenie *
/
struct gg_dcc7 *next; /**< Następne połączenie w liście */
int soft_timeout; /**< Flaga mówiąca, że po przekroczeniu \c t
imeout należy wywołać \c gg_dcc7_watch_fd() */
int seek; /**< Flaga mówiąca, że można zmieniać położe
nie w wysyłanym pliku */
};
/**
* Rodzaj sesji.
*/ */
enum gg_session_t { enum gg_session_t {
GG_SESSION_GG = 1, /* po GG_SESSION_GG = 1, /**< Połączenie z serwerem Gadu-Gadu */
GG_SESSION_HTTP, /* og GG_SESSION_HTTP, /**< Połączenie HTTP */
GG_SESSION_SEARCH, /* szukanie */ GG_SESSION_SEARCH, /**< Wyszukiwanie w katalogu publicznym (nie
GG_SESSION_REGISTER, /* rejestrowanie */ aktualne) */
GG_SESSION_REMIND, /* przypominanie has GG_SESSION_REGISTER, /**< Rejestracja nowego konta */
GG_SESSION_PASSWD, /* zmiana has GG_SESSION_REMIND, /**< Przypominanie hasła */
GG_SESSION_CHANGE, /* zmiana informacji o sobie */ GG_SESSION_PASSWD, /**< Zmiana hasła */
GG_SESSION_DCC, /* og GG_SESSION_CHANGE, /**< Zmiana informacji w katalogu publicznym
GG_SESSION_DCC_SOCKET, /* nas (nieaktualne) */
GG_SESSION_DCC_SEND, /* wysy GG_SESSION_DCC, /**< Połączenie bezpośrednie (do wersji 6.x)
GG_SESSION_DCC_GET, /* odbieranie pliku */ */
GG_SESSION_DCC_VOICE, /* rozmowa g GG_SESSION_DCC_SOCKET, /**< Gniazdo nasłuchujące (do wersji 6.x) */
GG_SESSION_USERLIST_GET, /* pobieranie userlisty */ GG_SESSION_DCC_SEND, /**< Wysyłanie pliku (do wersji 6.x) */
GG_SESSION_USERLIST_PUT, /* wysy GG_SESSION_DCC_GET, /**< Odbieranie pliku (do wersji 6.x) */
GG_SESSION_UNREGISTER, /* usuwanie konta */ GG_SESSION_DCC_VOICE, /**< Rozmowa głosowa (do wersji 6.x) */
GG_SESSION_USERLIST_REMOVE, /* usuwanie userlisty */ GG_SESSION_USERLIST_GET, /**< Import listy kontaktów z serwer
GG_SESSION_TOKEN, /* pobieranie tokenu */ a (nieaktualne) */
GG_SESSION_USERLIST_PUT, /**< Eksport listy kontaktów do serw
GG_SESSION_USER0 = 256, /* zdefiniowana dla u era (nieaktualne) */
GG_SESSION_USER1, /* j.w. */ GG_SESSION_UNREGISTER, /**< Usuwanie konta */
GG_SESSION_USER2, /* j.w. */ GG_SESSION_USERLIST_REMOVE, /**< Usuwanie listy kontaktów z serw
GG_SESSION_USER3, /* j.w. */ era (nieaktualne) */
GG_SESSION_USER4, /* j.w. */ GG_SESSION_TOKEN, /**< Pobieranie tokenu */
GG_SESSION_USER5, /* j.w. */ GG_SESSION_DCC7_SOCKET, /**< Gniazdo nasłuchujące (od wersji 7.x) */
GG_SESSION_USER6, /* j.w. */ GG_SESSION_DCC7_SEND, /**< Wysyłanie pliku (od wersji 7.x) */
GG_SESSION_USER7 /* j.w. */ GG_SESSION_DCC7_GET, /**< Odbieranie pliku (od wersji 7.x) */
GG_SESSION_DCC7_VOICE, /**< Rozmowa głosowa (od wersji 7.x) */
GG_SESSION_USER0 = 256, /**< Rodzaj zadeklarowany dla użytkownika */
GG_SESSION_USER1, /**< Rodzaj zadeklarowany dla użytkownika */
GG_SESSION_USER2, /**< Rodzaj zadeklarowany dla użytkownika */
GG_SESSION_USER3, /**< Rodzaj zadeklarowany dla użytkownika */
GG_SESSION_USER4, /**< Rodzaj zadeklarowany dla użytkownika */
GG_SESSION_USER5, /**< Rodzaj zadeklarowany dla użytkownika */
GG_SESSION_USER6, /**< Rodzaj zadeklarowany dla użytkownika */
GG_SESSION_USER7 /**< Rodzaj zadeklarowany dla użytkownika */
}; };
/* /**
* enum gg_state_t * Aktualny stan sesji.
*
* opisuje stan asynchronicznej maszyny.
*/ */
enum gg_state_t { enum gg_state_t {
/* wsp /* wspólne */
GG_STATE_IDLE = 0, /* nie powinno wyst GG_STATE_IDLE = 0, /**< Nie dzieje się nic */
GG_STATE_RESOLVING, /* wywo GG_STATE_RESOLVING, /**< Oczekiwanie na rozwiązanie nazw
GG_STATE_CONNECTING, /* wywo y serwera */
GG_STATE_READING_DATA, /* czeka na dane http */ GG_STATE_CONNECTING, /**< Oczekiwanie na połączenie */
GG_STATE_ERROR, /* wyst GG_STATE_READING_DATA, /**< Oczekiwanie na dane */
GG_STATE_ERROR, /**< Kod błędu w polu \c error */
/* gg_session */
GG_STATE_CONNECTING_HUB, /* wywo /* gg_session */
GG_STATE_CONNECTING_GG, /* wywo GG_STATE_CONNECTING_HUB, /**< Oczekiwanie na połączenie z hub
GG_STATE_READING_KEY, /* czeka na klucz */ em */
GG_STATE_READING_REPLY, /* czeka na odpowied GG_STATE_CONNECTING_GG, /**< Oczekiwanie na połączenie z ser
GG_STATE_CONNECTED, /* po werem */
GG_STATE_READING_KEY, /**< Oczekiwanie na klucz */
/* gg_http */ GG_STATE_READING_REPLY, /**< Oczekiwanie na odpowiedź serwer
GG_STATE_SENDING_QUERY, /* wysy a */
GG_STATE_READING_HEADER, /* czeka na nag GG_STATE_CONNECTED, /**< Połączono z serwerem */
GG_STATE_PARSING, /* przetwarza dane */
GG_STATE_DONE, /* sko /* gg_http */
GG_STATE_SENDING_QUERY, /**< Wysłano zapytanie HTTP */
GG_STATE_READING_HEADER, /**< Oczekiwanie na nagłówek HTTP */
GG_STATE_PARSING, /**< Przetwarzanie danych */
GG_STATE_DONE, /**< Połączenie zakończone */
/* gg_dcc */ /* gg_dcc */
GG_STATE_LISTENING, /* czeka na po GG_STATE_LISTENING, /* czeka na połączenia */
GG_STATE_READING_UIN_1, /* czeka na uin peera */ GG_STATE_READING_UIN_1, /* czeka na uin peera */
GG_STATE_READING_UIN_2, /* czeka na sw GG_STATE_READING_UIN_2, /* czeka na swój uin */
GG_STATE_SENDING_ACK, /* wysy GG_STATE_SENDING_ACK, /* wysyła potwierdzenie dcc */
GG_STATE_READING_ACK, /* czeka na potwierdzenie dcc */ GG_STATE_READING_ACK, /* czeka na potwierdzenie dcc */
GG_STATE_READING_REQUEST, /* czeka na komend GG_STATE_READING_REQUEST, /* czeka na komendę */
GG_STATE_SENDING_REQUEST, /* wysy GG_STATE_SENDING_REQUEST, /* wysyła komendę */
GG_STATE_SENDING_FILE_INFO, /* wysy GG_STATE_SENDING_FILE_INFO, /* wysyła informacje o pliku */
GG_STATE_READING_PRE_FILE_INFO, /* czeka na pakiet przed file_info * / GG_STATE_READING_PRE_FILE_INFO, /* czeka na pakiet przed file_info * /
GG_STATE_READING_FILE_INFO, /* czeka na informacje o pliku */ GG_STATE_READING_FILE_INFO, /* czeka na informacje o pliku */
GG_STATE_SENDING_FILE_ACK, /* wysy GG_STATE_SENDING_FILE_ACK, /* wysyła potwierdzenie pliku */
GG_STATE_READING_FILE_ACK, /* czeka na potwierdzenie pliku */ GG_STATE_READING_FILE_ACK, /* czeka na potwierdzenie pliku */
GG_STATE_SENDING_FILE_HEADER, /* wysy GG_STATE_SENDING_FILE_HEADER, /* wysyła nagłówek pliku */
GG_STATE_READING_FILE_HEADER, /* czeka na nag GG_STATE_READING_FILE_HEADER, /* czeka na nagłówek */
GG_STATE_GETTING_FILE, /* odbiera plik */ GG_STATE_GETTING_FILE, /* odbiera plik */
GG_STATE_SENDING_FILE, /* wysy GG_STATE_SENDING_FILE, /* wysyła plik */
GG_STATE_READING_VOICE_ACK, /* czeka na potwierdzenie voip */ GG_STATE_READING_VOICE_ACK, /* czeka na potwierdzenie voip */
GG_STATE_READING_VOICE_HEADER, /* czeka na rodzaj bloku voip */ GG_STATE_READING_VOICE_HEADER, /* czeka na rodzaj bloku voip */
GG_STATE_READING_VOICE_SIZE, /* czeka na rozmiar bloku voip */ GG_STATE_READING_VOICE_SIZE, /* czeka na rozmiar bloku voip */
GG_STATE_READING_VOICE_DATA, /* czeka na dane voip */ GG_STATE_READING_VOICE_DATA, /* czeka na dane voip */
GG_STATE_SENDING_VOICE_ACK, /* wysy GG_STATE_SENDING_VOICE_ACK, /* wysyła potwierdzenie voip */
GG_STATE_SENDING_VOICE_REQUEST, /* wysy GG_STATE_SENDING_VOICE_REQUEST, /* wysyła żądanie voip */
GG_STATE_READING_TYPE, /* czeka na typ po GG_STATE_READING_TYPE, /* czeka na typ połączenia */
/* nowe. bez sensu jest to API. */ /* nowe. bez sensu jest to API. */
GG_STATE_TLS_NEGOTIATION /* negocjuje po GG_STATE_TLS_NEGOTIATION, /**< Negocjacja połączenia szyfrowan
ego */
GG_STATE_REQUESTING_ID, /**< Oczekiwanie na nadanie identyfi
katora połączenia bezpośredniego */
GG_STATE_WAITING_FOR_ACCEPT, /**< Oczekiwanie na potwierdzenie lu
b odrzucenie połączenia bezpośredniego */
GG_STATE_WAITING_FOR_INFO, /**< Oczekiwanie na informacje o poł
ączeniu bezpośrednim */
GG_STATE_READING_ID, /**< Odebranie identyfikatora połącz
enia bezpośredniego */
GG_STATE_SENDING_ID /**< Wysłano identyfikatora połączen
ia bezpośredniego */
}; };
/* /**
* enum gg_check_t * Informacja o tym, czy biblioteka chce zapisywać i/lub czytać
* z deskryptora. Maska bitowa.
* *
* informuje, co proces klienta powinien sprawdzi * \ingroup events
* po
*/ */
enum gg_check_t { enum gg_check_t {
GG_CHECK_NONE = 0, /* nic. nie powinno wyst GG_CHECK_NONE = 0, /**< Nie sprawdzaj niczego */
GG_CHECK_WRITE = 1, /* sprawdzamy mo GG_CHECK_WRITE = 1, /**< Sprawdź możliwość zapisu */
GG_CHECK_READ = 2 /* sprawdzamy mo GG_CHECK_READ = 2 /**< Sprawdź możliwość odczytu */
}; };
/* /**
* struct gg_login_params * Parametry połączenia z serwerem Gadu-Gadu. Parametry zostały przeniesion
e
* do struktury, by uniknąć zmian API po rozszerzeniu protokołu i dodaniu
* kolejnych opcji połączenia. Część parametrów, które nie są już aktualne
* lub nie mają znaczenia, została usunięta z dokumentacji.
* *
* parametry gg_login(). przeniesiono do struktury, * \ingroup login
* z ci
*/ */
struct gg_login_params { struct gg_login_params {
uin_t uin; /* numerek */ uin_t uin; /**< Numer Gadu-Gadu */
char *password; /* has char *password; /**< Hasło */
int async; /* asynchroniczne sockety? */ int async; /**< Flaga asynchronicznego połączen
int status; /* pocz ia (domyślnie nie) */
char *status_descr; /* opis statusu */ int status; /**< Początkowy status użytkownika (
uint32_t server_addr; /* adres serwera gg */ domyślnie \c GG_STATUS_AVAIL) */
uint16_t server_port; /* port serwera gg */ char *status_descr; /**< Początkowy opis użytkownika (do
uint32_t client_addr; /* adres dcc klienta */ myślnie brak) */
uint16_t client_port; /* port dcc klienta */ uint32_t server_addr; /**< Adres serwera Gadu-Gadu (domyśl
int protocol_version; /* wersja protoko nie pobierany automatycznie) */
char *client_version; /* wersja klienta */ uint16_t server_port; /**< Port serwera Gadu-Gadu (domyśln
int has_audio; /* czy ma d ie pobierany automatycznie) */
int last_sysmsg; /* ostatnia wiadomo #ifndef DOXYGEN
uint32_t external_addr; /* adres widziany na zewnatrz */ uint32_t client_addr; /**< Adres połączeń bezpośrednich (n
uint16_t external_port; /* port widziany na zewnatrz */ ieaktualne) */
int tls; /* czy uint16_t client_port; /**< Port połączeń bezpośrednich (ni
int image_size; /* maksymalny rozmiar obrazka w KiB eaktualne) */
*/ #endif
int era_omnix; /* czy udawa int protocol_version; /**< Wersja protokołu wysyłana do se
rwera (domyślnie najnowsza obsługiwana) */
char dummy[6 * sizeof(int)]; /* miejsce na kolejnych 6 zmiennych, char *client_version; /**< Wersja klienta wysyłana do serw
* era (domyślnie najnowsza znana) */
* zmienia int has_audio; /**< Flaga obsługi połączeń głosowyc
h */
int last_sysmsg; /**< Numer ostatnio odebranej wiadom
ości systemowej */
uint32_t external_addr; /**< Adres publiczny dla połączeń be
zpośrednich (6.x) */
uint16_t external_port; /**< Port publiczny dla połączeń bez
pośrednich (6.x) */
#ifndef DOXYGEN
int tls; /**< Flaga połączenia szyfrowanego (
nieaktualna) */
#endif
int image_size; /**< Maksymalny rozmiar obsługiwanyc
h obrazków w kilobajtach */
#ifndef DOXYGEN
int era_omnix; /**< Flaga udawania klienta Era Omni
x (nieaktualna) */
#endif
int hash_type; /**< Rodzaj skrótu hasła (domyślnie
SHA1) */
#ifndef DOXYGEN
char dummy[5 * sizeof(int)]; /**< \internal Miejsce na kilka kole
jnych
parametrów, żeby wraz z dodawaniem
kolejnych
parametrów nie zmieniał się rozmia
r struktury */
#endif
}; };
struct gg_session *gg_login(const struct gg_login_params *p); struct gg_session *gg_login(const struct gg_login_params *p);
void gg_free_session(struct gg_session *sess); void gg_free_session(struct gg_session *sess);
void gg_logoff(struct gg_session *sess); void gg_logoff(struct gg_session *sess);
int gg_change_status(struct gg_session *sess, int status); int gg_change_status(struct gg_session *sess, int status);
int gg_change_status_descr(struct gg_session *sess, int status, const char *descr); int gg_change_status_descr(struct gg_session *sess, int status, const char *descr);
int gg_change_status_descr_time(struct gg_session *sess, int status, const char *descr, int time); int gg_change_status_descr_time(struct gg_session *sess, int status, const char *descr, int time);
int gg_send_message(struct gg_session *sess, int msgclass, uin_t recipient, const unsigned char *message); int gg_send_message(struct gg_session *sess, int msgclass, uin_t recipient, const unsigned char *message);
int gg_send_message_richtext(struct gg_session *sess, int msgclass, uin_t r ecipient, const unsigned char *message, const unsigned char *format, int fo rmatlen); int gg_send_message_richtext(struct gg_session *sess, int msgclass, uin_t r ecipient, const unsigned char *message, const unsigned char *format, int fo rmatlen);
int gg_send_message_confer(struct gg_session *sess, int msgclass, int recip ients_count, uin_t *recipients, const unsigned char *message); int gg_send_message_confer(struct gg_session *sess, int msgclass, int recip ients_count, uin_t *recipients, const unsigned char *message);
int gg_send_message_confer_richtext(struct gg_session *sess, int msgclass, int recipients_count, uin_t *recipients, const unsigned char *message, cons t unsigned char *format, int formatlen); int gg_send_message_confer_richtext(struct gg_session *sess, int msgclass, int recipients_count, uin_t *recipients, const unsigned char *message, cons t unsigned char *format, int formatlen);
int gg_send_message_ctcp(struct gg_session *sess, int msgclass, uin_t recip ient, const unsigned char *message, int message_len); int gg_send_message_ctcp(struct gg_session *sess, int msgclass, uin_t recip ient, const unsigned char *message, int message_len);
int gg_ping(struct gg_session *sess); int gg_ping(struct gg_session *sess);
int gg_userlist_request(struct gg_session *sess, char type, const char *req uest); int gg_userlist_request(struct gg_session *sess, char type, const char *req uest);
int gg_image_request(struct gg_session *sess, uin_t recipient, int size, ui nt32_t crc32); int gg_image_request(struct gg_session *sess, uin_t recipient, int size, ui nt32_t crc32);
int gg_image_reply(struct gg_session *sess, uin_t recipient, const char *fi lename, const char *image, int size); int gg_image_reply(struct gg_session *sess, uin_t recipient, const char *fi lename, const char *image, int size);
uint32_t gg_crc32(uint32_t crc, const unsigned char *buf, int len); uint32_t gg_crc32(uint32_t crc, const unsigned char *buf, int len);
struct gg_image_queue { /**
uin_t sender; /* nadawca obrazka */ * Rodzaj zdarzenia.
uint32_t size; /* rozmiar */
uint32_t crc32; /* suma kontrolna */
char *filename; /* nazwa pliku */
char *image; /* bufor z obrazem */
uint32_t done; /* ile ju
struct gg_image_queue *next; /* nast
};
/*
* enum gg_event_t
* *
* rodzaje zdarze * \ingroup events
*/ */
enum gg_event_t { enum gg_event_t {
GG_EVENT_NONE = 0, /* nic si GG_EVENT_NONE = 0, /**< Nie wydarzyło się nic wartego u
GG_EVENT_MSG, /* otrzymano wiadomo wagi */
GG_EVENT_NOTIFY, /* kto GG_EVENT_MSG, /**< \brief Otrzymano wiadomość. Prz
GG_EVENT_NOTIFY_DESCR, /* kto ekazuje również wiadomości systemowe od numeru 0. */
GG_EVENT_STATUS, /* kto GG_EVENT_NOTIFY, /**< \brief Informacja o statusach o
GG_EVENT_ACK, /* potwierdzenie wys sób z listy kontaktów (przed 6.0). Zdarzenie należy obsługiwać, jeśli planu
GG_EVENT_PONG, /* pakiet pong */ je się używać protokołu w wersji starszej niż domyślna. */
GG_EVENT_CONN_FAILED, /* po GG_EVENT_NOTIFY_DESCR, /**< \brief Informacja o statusie op
GG_EVENT_CONN_SUCCESS, /* po isowym osoby z listy kontaktów (przed 6.0). Zdarzenie należy obsługiwać, je
GG_EVENT_DISCONNECT, /* serwer zrywa po śli planuje się używać protokołu w wersji starszej niż domyślna. */
GG_EVENT_STATUS, /**< \brief Zmiana statusu osoby z l
GG_EVENT_DCC_NEW, /* nowe po isty kontaktów (przed 6.0). Zdarzenie należy obsługiwać, jeśli planuje się
GG_EVENT_DCC_ERROR, /* b używać protokołu w wersji starszej niż domyślna. */
GG_EVENT_DCC_DONE, /* zako GG_EVENT_ACK, /**< Potwierdzenie doręczenia wiadom
GG_EVENT_DCC_CLIENT_ACCEPT, /* moment akceptacji klienta */ ości */
GG_EVENT_DCC_CALLBACK, /* klient si GG_EVENT_PONG, /**< \brief Utrzymanie połączenia. O
GG_EVENT_DCC_NEED_FILE_INFO, /* nale becnie serwer nie wysyła już do klienta ramek utrzymania połączenia, polega
GG_EVENT_DCC_NEED_FILE_ACK, /* czeka na potwierdzenie pliku */ wyłącznie na wysyłaniu ramek przez klienta. */
GG_EVENT_DCC_NEED_VOICE_ACK, /* czeka na potwierdzenie rozmowy */ GG_EVENT_CONN_FAILED, /**< \brief Nie udało się połączyć *
GG_EVENT_DCC_VOICE_DATA, /* ramka danych rozmowy g /
GG_EVENT_CONN_SUCCESS, /**< \brief Połączono z serwerem. Pi
GG_EVENT_PUBDIR50_SEARCH_REPLY, /* odpowiedz wyszukiwania */ erwszą rzeczą, jaką należy zrobić jest wysłanie listy kontaktów. */
GG_EVENT_PUBDIR50_READ, /* odczytano w GG_EVENT_DISCONNECT, /**< \brief Serwer zrywa połączenie.
GG_EVENT_PUBDIR50_WRITE, /* wpisano w Zdarza się, gdy równolegle do serwera podłączy się druga sesja i trzeba ze
rwać połączenie z pierwszą. */
GG_EVENT_STATUS60, /* kto
GG_EVENT_NOTIFY60, /* kto GG_EVENT_DCC_NEW, /**< Nowe połączenie bezpośrednie (6
GG_EVENT_USERLIST, /* odpowied .x) */
GG_EVENT_IMAGE_REQUEST, /* pro GG_EVENT_DCC_ERROR, /**< Błąd połączenia bezpośredniego
GG_EVENT_IMAGE_REPLY, /* podes (6.x) */
GG_EVENT_DCC_ACK /* potwierdzenie transmisji */ GG_EVENT_DCC_DONE, /**< Zakończono połączenie bezpośred
nie (6.x) */
GG_EVENT_DCC_CLIENT_ACCEPT, /**< Moment akceptacji klienta w poł
ączeniu bezpośrednim (6.x) */
GG_EVENT_DCC_CALLBACK, /**< Zwrotne połączenie bezpośrednie
(6.x) */
GG_EVENT_DCC_NEED_FILE_INFO, /**< Należy wypełnić \c file_info dl
a połączenia bezpośredniego (6.x) */
GG_EVENT_DCC_NEED_FILE_ACK, /**< Czeka na potwierdzenie pliku w
połączeniu bezpośrednim (6.x) */
GG_EVENT_DCC_NEED_VOICE_ACK, /**< Czeka na potwierdzenie rozmowy
w połączeniu bezpośrednim (6.x) */
GG_EVENT_DCC_VOICE_DATA, /**< Dane bezpośredniego połączenia
głosowego (6.x) */
GG_EVENT_PUBDIR50_SEARCH_REPLY, /**< Odpowiedź katalogu publicznego
*/
GG_EVENT_PUBDIR50_READ, /**< Odczytano własne dane z katalog
u publicznego */
GG_EVENT_PUBDIR50_WRITE, /**< Zmieniono własne dane w katalog
u publicznym */
GG_EVENT_STATUS60, /**< Zmiana statusu osoby z listy ko
ntaktów */
GG_EVENT_NOTIFY60, /**< Informacja o statusach osób z l
isty kontaktów */
GG_EVENT_USERLIST, /**< Wynik importu lub eksportu list
y kontaktów */
GG_EVENT_IMAGE_REQUEST, /**< Żądanie przesłania obrazka z wi
adommości */
GG_EVENT_IMAGE_REPLY, /**< Przysłano obrazek z wiadomości
*/
GG_EVENT_DCC_ACK, /**< Potwierdzenie transmisji w połą
czeniu bezpośrednim (6.x) */
GG_EVENT_DCC7_NEW, /**< Nowe połączenie bezpośrednie (7
.x) */
GG_EVENT_DCC7_ACCEPT, /**< Zaakceptowano połączenie bezpoś
rednie (7.x), nowy deskryptor */
GG_EVENT_DCC7_REJECT, /**< Odrzucono połączenie bezpośredn
ie (7.x) */
GG_EVENT_DCC7_CONNECTED, /**< Zestawiono połączenie bezpośred
nie (7.x), nowy deskryptor */
GG_EVENT_DCC7_ERROR, /**< Błąd połączenia bezpośredniego
(7.x) */
GG_EVENT_DCC7_DONE, /**< Zakończono połączenie bezpośred
nie (7.x) */
GG_EVENT_DCC7_PENDING, /**< Trwa próba połączenia bezpośred
niego (7.x), nowy deskryptor */
GG_EVENT_XML_EVENT /**< Otrzymano komunikat systemowy (
7.7) */
}; };
#define GG_EVENT_SEARCH50_REPLY GG_EVENT_PUBDIR50_SEARCH_REPLY #define GG_EVENT_SEARCH50_REPLY GG_EVENT_PUBDIR50_SEARCH_REPLY
/* /**
* enum gg_failure_t * Powód nieudanego połączenia.
*
* okre
*/ */
enum gg_failure_t { enum gg_failure_t {
GG_FAILURE_RESOLVING = 1, /* nie znaleziono serwera */ GG_FAILURE_RESOLVING = 1, /**< Nie znaleziono serwera */
GG_FAILURE_CONNECTING, /* nie mo GG_FAILURE_CONNECTING, /**< Błąd połączenia */
GG_FAILURE_INVALID, /* serwer zwr GG_FAILURE_INVALID, /**< Serwer zwrócił nieprawidłowe da
GG_FAILURE_READING, /* zerwano po ne */
GG_FAILURE_WRITING, /* zerwano po GG_FAILURE_READING, /**< Zerwano połączenie podczas odcz
GG_FAILURE_PASSWORD, /* nieprawid ytu */
GG_FAILURE_404, /* XXX nieu GG_FAILURE_WRITING, /**< Zerwano połączenie podczas zapi
GG_FAILURE_TLS, /* b su */
GG_FAILURE_NEED_EMAIL, /* serwer roz GG_FAILURE_PASSWORD, /**< Nieprawidłowe hasło */
GG_FAILURE_INTRUDER, /* za du GG_FAILURE_404, /**< Nieużywane */
GG_FAILURE_UNAVAILABLE /* serwery s GG_FAILURE_TLS, /**< Błąd negocjacji szyfrowanego po
łączenia */
GG_FAILURE_NEED_EMAIL, /**< Serwer rozłączył nas z prośbą o
zmianę adresu e-mail */
GG_FAILURE_INTRUDER, /**< Zbyt wiele prób połączenia z ni
eprawidłowym hasłem */
GG_FAILURE_UNAVAILABLE /**< Serwery są wyłączone */
}; };
/* /**
* enum gg_error_t * Kod błędu danej operacji.
* *
* okre * Nie zawiera przesadnie szczegółowych informacji o powodach błędów, by ni
* przesadnie szczeg e
* obs * komplikować ich obsługi. Jeśli wymagana jest większa dokładność, należy
* zawarto * sprawdzić zawartość zmiennej systemowej \c errno.
*/ */
enum gg_error_t { enum gg_error_t {
GG_ERROR_RESOLVING = 1, /* b GG_ERROR_RESOLVING = 1, /**< Nie znaleziono hosta */
GG_ERROR_CONNECTING, /* b GG_ERROR_CONNECTING, /**< Błąd połączenia */
GG_ERROR_READING, /* b GG_ERROR_READING, /**< Błąd odczytu/odbierania */
GG_ERROR_WRITING, /* b GG_ERROR_WRITING, /**< Błąd zapisu/wysyłania */
GG_ERROR_DCC_HANDSHAKE, /* b GG_ERROR_DCC_HANDSHAKE, /**< Błąd negocjacji */
GG_ERROR_DCC_FILE, /* b GG_ERROR_DCC_FILE, /**< Błąd odczytu/zapisu pliku */
GG_ERROR_DCC_EOF, /* plik si GG_ERROR_DCC_EOF, /**< Przedwczesny koniec pliku */
GG_ERROR_DCC_NET, /* b GG_ERROR_DCC_NET, /**< Błąd wysyłania/odbierania */
GG_ERROR_DCC_REFUSED /* po GG_ERROR_DCC_REFUSED, /**< Połączenie odrzucone */
GG_ERROR_DCC7_HANDSHAKE, /**< Błąd negocjacji */
GG_ERROR_DCC7_FILE, /**< Błąd odczytu/zapisu pliku */
GG_ERROR_DCC7_EOF, /**< Przedwczesny koniec pliku */
GG_ERROR_DCC7_NET, /**< Błąd wysyłania/odbierania */
GG_ERROR_DCC7_REFUSED /**< Połączenie odrzucone */
}; };
/* /**
* struktury dotycz * Pole zapytania lub odpowiedzi katalogu publicznego.
* ODWO
*/ */
struct gg_pubdir50_entry { struct gg_pubdir50_entry {
int num; int num; /**< Numer wyniku */
char *field; char *field; /**< Nazwa pola */
char *value; char *value; /**< Wartość pola */
}; };
/**
* Zapytanie lub odpowiedź katalogu publicznego.
*
* Patrz \c gg_pubdir50_t.
*/
struct gg_pubdir50_s { struct gg_pubdir50_s {
int count; int count; /**< Liczba wyników odpowiedzi */
uin_t next; uin_t next; /**< Numer początkowy następnego zapytania */
int type; int type; /**< Rodzaj zapytania */
uint32_t seq; uint32_t seq; /**< Numer sekwencyjny */
struct gg_pubdir50_entry *entries; struct gg_pubdir50_entry *entries; /**< Pola zapytania lub odpo
int entries_count; wiedzi */
int entries_count; /**< Liczba pól */
}; };
/* /**
* typedef gg_pubdir_50_t * Zapytanie lub odpowiedź katalogu publicznego.
* *
* typ opisuj * Do pól nie należy się odwoływać bezpośrednio -- wszystkie niezbędne
* z protoko * informacje są dostępne za pomocą funkcji \c gg_pubdir50_*
* p
*/ */
typedef struct gg_pubdir50_s *gg_pubdir50_t; typedef struct gg_pubdir50_s *gg_pubdir50_t;
/* /**
* struct gg_event * Opis zdarzenia \c GG_EVENT_MSG.
*
* struktura opisuj
* z gg_dcc_watch_fd()
*/ */
struct gg_event { struct gg_event_msg {
int type; /* rodzaj zdarzenia -- gg_event_t */ uin_t sender; /**< Numer nadawcy */
union { /* @event */ int msgclass; /**< Klasa wiadomości */
struct gg_notify_reply *notify; /* informacje o li time_t time; /**< Czas nadania */
unsigned char *message; /**< Treść wiadomości */
enum gg_failure_t failure; /* b
int recipients_count; /**< Liczba odbiorców konferencji */
struct gg_dcc *dcc_new; /* nowe po uin_t *recipients; /**< Odbiorcy konferencji */
int dcc_error; /* b int formats_length; /**< Długość informacji o formatowaniu tekst
u */
gg_pubdir50_t pubdir50; /* wynik operacji zwi void *formats; /**< Informacje o formatowaniu tekstu */
uint32_t seq; /**< Numer sekwencyjny wiadomości */
struct { /* @msg odebrano wiadomo
uin_t sender; /* numer nadawcy */
int msgclass; /* klasa wiadomo
time_t time; /* czas nadania */
unsigned char *message; /* tre
int recipients_count; /* ilo
uin_t *recipients; /* odbiorcy konferencji */
int formats_length; /* d
void *formats; /* informacje o formatowaniu
tekstu */
} msg;
struct { /* @notify_descr informacje
o li
struct gg_notify_reply *notify; /* informacje o li
char *descr; /* opis stanu */
} notify_descr;
struct { /* @status zmiana stanu -- G
G_EVENT_STATUS */
uin_t uin; /* numer */
uint32_t status; /* nowy stan */
char *descr; /* opis stanu */
} status;
struct { /* @status60 zmiana stanu --
GG_EVENT_STATUS60 */
uin_t uin; /* numer */
int status; /* nowy stan */
uint32_t remote_ip; /* adres ip */
uint16_t remote_port; /* port */
int version; /* wersja klienta */
int image_size; /* maksymalny rozmiar grafiki w KiB
*/
char *descr; /* opis stanu */
time_t time; /* czas powrotu */
} status60;
struct { /* @notify60 informacja o li
uin_t uin; /* numer */
int status; /* stan */
uint32_t remote_ip; /* adres ip */
uint16_t remote_port; /* port */
int version; /* wersja klienta */
int image_size; /* maksymalny rozmiar grafiki w KiB
*/
char *descr; /* opis stanu */
time_t time; /* czas powrotu */
} *notify60;
struct { /* @ack potwierdzenie wiadom
o
uin_t recipient; /* numer odbiorcy */
int status; /* stan dor
int seq; /* numer sekwencyjny wiadomo
} ack;
struct { /* @dcc_voice_data otrzymano
dane d
uint8_t *data; /* dane d
int length; /* ilo
} dcc_voice_data;
struct { /* @userlist odpowied
char type; /* rodzaj odpowiedzi */
char *reply; /* tre
} userlist;
struct { /* @image_request pro
uin_t sender; /* nadawca pro
uint32_t size; /* rozmiar obrazka */
uint32_t crc32; /* suma kontrolna */
} image_request;
struct { /* @image_reply odpowied
uin_t sender; /* nadawca odpowiedzi */
uint32_t size; /* rozmiar obrazka */
uint32_t crc32; /* suma kontrolna */
char *filename; /* nazwa pliku */
char *image; /* bufor z obrazkiem */
} image_reply;
} event;
}; };
struct gg_event *gg_watch_fd(struct gg_session *sess); /**
void gg_event_free(struct gg_event *e); * Opis zdarzenia \c GG_EVENT_NOTIFY_DESCR.
#define gg_free_event gg_event_free */
struct gg_event_notify_descr {
struct gg_notify_reply *notify; /**< Informacje o liście kontaktów *
/
char *descr; /**< Opis status */
};
/* /**
* funkcje obs * Opis zdarzenia \c GG_EVENT_STATUS.
*/ */
int gg_notify_ex(struct gg_session *sess, uin_t *userlist, char *types, int struct gg_event_status {
count); uin_t uin; /**< Numer Gadu-Gadu */
int gg_notify(struct gg_session *sess, uin_t *userlist, int count); uint32_t status; /**< Nowy status */
int gg_add_notify_ex(struct gg_session *sess, uin_t uin, char type); char *descr; /**< Opis */
int gg_add_notify(struct gg_session *sess, uin_t uin); };
int gg_remove_notify_ex(struct gg_session *sess, uin_t uin, char type);
int gg_remove_notify(struct gg_session *sess, uin_t uin);
/* /**
* funkcje obs * Opis zdarzenia \c GG_EVENT_STATUS60.
*/ */
struct gg_http *gg_http_connect(const char *hostname, int port, int async, struct gg_event_status60 {
const char *method, const char *path, const char *header); uin_t uin; /**< Numer Gadu-Gadu */
int gg_http_watch_fd(struct gg_http *h); int status; /**< Nowy status */
void gg_http_stop(struct gg_http *h); uint32_t remote_ip; /**< Adres IP dla połączeń bezpośrednich */
void gg_http_free(struct gg_http *h); uint16_t remote_port; /**< Port dla połączeń bezpośrednich */
void gg_http_free_fields(struct gg_http *h); int version; /**< Wersja protokołu */
#define gg_free_http gg_http_free int image_size; /**< Maksymalny rozmiar obsługiwanych obrazk
ów w KiB */
char *descr; /**< Opis statusu */
time_t time; /**< Czas powrotu */
};
/* /**
* struktury opisuj * Opis zdarzenia \c GG_EVENT_NOTIFY_REPLY60.
* zast
*/ */
struct gg_search_request { struct gg_event_notify60 {
int active; uin_t uin; /**< Numer Gadu-Gadu */
unsigned int start; int status; /**< Nowy status */
char *nickname; uint32_t remote_ip; /**< Adres IP dla połączeń bezpośrednich */
char *first_name; uint16_t remote_port; /**< Port dla połączeń bezpośrednich */
char *last_name; int version; /**< Wersja protokołu */
char *city; int image_size; /**< Maksymalny rozmiar obsługiwanych obrazk
int gender; ów w KiB */
int min_birth; char *descr; /**< Opis statusu */
int max_birth; time_t time; /**< Czas powrotu */
char *email;
char *phone;
uin_t uin;
}; };
struct gg_search { /**
int count; * Opis zdarzenia \c GG_EVENT_ACK.
struct gg_search_result *results; */
struct gg_event_ack {
uin_t recipient; /**< Numer odbiorcy */
int status; /**< Status doręczenia */
int seq; /**< Numer sekwencyjny wiadomości */
}; };
struct gg_search_result { /**
uin_t uin; * Opis zdarzenia \c GG_EVENT_USERLIST.
char *first_name; */
char *last_name; struct gg_event_userlist {
char *nickname; char type; /**< Rodzaj odpowiedzi */
int born; char *reply; /**< Treść odpowiedzi */
int gender;
char *city;
int active;
}; };
#define GG_GENDER_NONE 0 /**
#define GG_GENDER_FEMALE 1 * Opis zdarzenia \c GG_EVENT_DCC_VOICE_DATA.
#define GG_GENDER_MALE 2 */
struct gg_event_dcc_voice_data {
uint8_t *data; /**< Dane dźwiękowe */
int length; /**< Rozmiar danych dźwiękowych */
};
/* /**
* funkcje wyszukiwania. * Opis zdarzenia \c GG_EVENT_IMAGE_REQUEST.
*/ */
struct gg_http *gg_search(const struct gg_search_request *r, int async); struct gg_event_image_request {
int gg_search_watch_fd(struct gg_http *f); uin_t sender; /**< Nadawca żądania */
void gg_free_search(struct gg_http *f); uint32_t size; /**< Rozmiar obrazka */
#define gg_search_free gg_free_search uint32_t crc32; /**< Suma kontrolna CRC32 */
};
const struct gg_search_request *gg_search_request_mode_0(char *nickname, ch /**
ar *first_name, char *last_name, char *city, int gender, int min_birth, int * Opis zdarzenia \c GG_EVENT_IMAGE_REPLY.
max_birth, int active, int start); */
const struct gg_search_request *gg_search_request_mode_1(char *email, int a struct gg_event_image_reply {
ctive, int start); uin_t sender; /**< Nadawca obrazka */
const struct gg_search_request *gg_search_request_mode_2(char *phone, int a uint32_t size; /**< Rozmiar obrazka */
ctive, int start); uint32_t crc32; /**< Suma kontrolna CRC32 */
const struct gg_search_request *gg_search_request_mode_3(uin_t uin, int act char *filename; /**< Nazwa pliku */
ive, int start); char *image; /**< Bufor z obrazkiem */
void gg_search_request_free(struct gg_search_request *r); };
/* /**
* funkcje obs * Opis zdarzenia \c GG_EVENT_XML_EVENT.
* zachowuj */
* w protokole. struct gg_event_xml_event {
char *data; /**< Bufor z komunikatem */
};
/**
* Opis zdarzenia \c GG_EVENT_DCC7_CONNECTED.
*/
struct gg_event_dcc7_connected {
struct gg_dcc7 *dcc7; /**< Struktura połączenia */
// XXX czy coś się przyda?
};
/**
* Opis zdarzenia \c GG_EVENT_DCC7_REJECT.
*/
struct gg_event_dcc7_reject {
struct gg_dcc7 *dcc7; /**< Struktura połączenia */
int reason; /**< powód odrzucenia */
};
/**
* Opis zdarzenia \c GG_EVENT_DCC7_ACCEPT.
*/
struct gg_event_dcc7_accept {
struct gg_dcc7 *dcc7; /**< Struktura połączenia */
int type; /**< Sposób połączenia (P2P, przez serwer) *
/
uint32_t remote_ip; /**< Adres zdalnego klienta */
uint16_t remote_port; /**< Port zdalnego klienta */
};
/**
* Unia wszystkich zdarzeń zwracanych przez funkcje \c gg_watch_fd(),
* \c gg_dcc_watch_fd() i \c gg_dcc7_watch_fd().
*
* \ingroup events
*/
union gg_event_union {
enum gg_failure_t failure; /**< Błąd połączenia (\c GG_EVENT_CO
NN_FAILED) */
struct gg_notify_reply *notify; /**< Zmiana statusu kontaktów (\c GG
_EVENT_NOTIFY) */
struct gg_event_notify_descr notify_descr; /**< Zmiana statusu
kontaktów (\c GG_EVENT_NOTIFY_DESCR) */
struct gg_event_status status; /**< Zmiana statusu kontaktów (\c GG
_EVENT_STATUS) */
struct gg_event_status60 status60; /**< Zmiana statusu kontaktó
w (\c GG_EVENT_STATUS60) */
struct gg_event_notify60 *notify60; /**< Zmiana statusu kontaktó
w (\c GG_EVENT_NOTIFY60) */
struct gg_event_msg msg; /**< Otrzymano wiadomość (\c GG_EVEN
T_MSG) */
struct gg_event_ack ack; /**< Potwierdzenie wiadomości (\c GG
_EVENT_ACK) */
struct gg_event_image_request image_request; /**< Żądanie wysłani
a obrazka (\c GG_EVENT_IMAGE_REQUEST) */
struct gg_event_image_reply image_reply; /**< Odpowiedź z obr
azkiem (\c GG_EVENT_IMAGE_REPLY) */
struct gg_event_userlist userlist; /**< Odpowiedź listy kontakt
ów (\c GG_EVENT_USERLIST) */
gg_pubdir50_t pubdir50; /**< Odpowiedź katalogu publicznego (\c GG_E
VENT_PUBDIR50_*) */
struct gg_event_xml_event xml_event; /**< Zdarzenie systemowe (\c
GG_EVENT_XML_EVENT) */
struct gg_dcc *dcc_new; /**< Nowe połączenie bezpośrednie (\c GG_EVE
NT_DCC_NEW) */
enum gg_error_t dcc_error; /**< Błąd połączenia bezpośredniego
(\c GG_EVENT_DCC_ERROR) */
struct gg_event_dcc_voice_data dcc_voice_data; /**< Dane połączenia
głosowego (\c GG_EVENT_DCC_VOICE_DATA) */
struct gg_dcc7 *dcc7_new; /**< Nowe połączenie bezpośrednie (\
c GG_EVENT_DCC7_NEW) */
enum gg_error_t dcc7_error; /**< Błąd połączenia bezpośredniego
(\c GG_EVENT_DCC7_ERROR) */
struct gg_event_dcc7_connected dcc7_connected; /**< Informacja o ze
stawieniu połączenia bezpośredniego (\c GG_EVENT_DCC7_CONNECTED) */
struct gg_event_dcc7_reject dcc7_reject; /**< Odrzucono połąc
zenia bezpośredniego (\c GG_EVENT_DCC7_REJECT) */
struct gg_event_dcc7_accept dcc7_accept; /**< Zaakceptowano p
ołączenie bezpośrednie (\c GG_EVENT_DCC7_ACCEPT) */
};
/**
* Opis zdarzenia.
*
* Zwracany przez funkcje \c gg_watch_fd(), \c gg_dcc_watch_fd()
* i \c gg_dcc7_watch_fd(). Po przeanalizowaniu należy zwolnić
* za pomocą \c gg_event_free().
* *
* NIE NALE * \ingroup events
*/ */
struct gg_event {
int type; /**< Rodzaj zdarzenia */
union gg_event_union event; /**< Informacja o zdarzeniu */
};
struct gg_event *gg_watch_fd(struct gg_session *sess);
void gg_event_free(struct gg_event *e);
int gg_notify_ex(struct gg_session *sess, uin_t *userlist, char *types, int
count);
int gg_notify(struct gg_session *sess, uin_t *userlist, int count);
int gg_add_notify_ex(struct gg_session *sess, uin_t uin, char type);
int gg_add_notify(struct gg_session *sess, uin_t uin);
int gg_remove_notify_ex(struct gg_session *sess, uin_t uin, char type);
int gg_remove_notify(struct gg_session *sess, uin_t uin);
struct gg_http *gg_http_connect(const char *hostname, int port, int async,
const char *method, const char *path, const char *header);
int gg_http_watch_fd(struct gg_http *h);
void gg_http_stop(struct gg_http *h);
void gg_http_free(struct gg_http *h);
uint32_t gg_pubdir50(struct gg_session *sess, gg_pubdir50_t req); uint32_t gg_pubdir50(struct gg_session *sess, gg_pubdir50_t req);
gg_pubdir50_t gg_pubdir50_new(int type); gg_pubdir50_t gg_pubdir50_new(int type);
int gg_pubdir50_add(gg_pubdir50_t req, const char *field, const char *value ); int gg_pubdir50_add(gg_pubdir50_t req, const char *field, const char *value );
int gg_pubdir50_seq_set(gg_pubdir50_t req, uint32_t seq); int gg_pubdir50_seq_set(gg_pubdir50_t req, uint32_t seq);
const char *gg_pubdir50_get(gg_pubdir50_t res, int num, const char *field); const char *gg_pubdir50_get(gg_pubdir50_t res, int num, const char *field);
int gg_pubdir50_type(gg_pubdir50_t res); int gg_pubdir50_type(gg_pubdir50_t res);
int gg_pubdir50_count(gg_pubdir50_t res); int gg_pubdir50_count(gg_pubdir50_t res);
uin_t gg_pubdir50_next(gg_pubdir50_t res); uin_t gg_pubdir50_next(gg_pubdir50_t res);
uint32_t gg_pubdir50_seq(gg_pubdir50_t res); uint32_t gg_pubdir50_seq(gg_pubdir50_t res);
void gg_pubdir50_free(gg_pubdir50_t res); void gg_pubdir50_free(gg_pubdir50_t res);
#ifndef DOXYGEN
#define GG_PUBDIR50_UIN "FmNumber" #define GG_PUBDIR50_UIN "FmNumber"
#define GG_PUBDIR50_STATUS "FmStatus" #define GG_PUBDIR50_STATUS "FmStatus"
#define GG_PUBDIR50_FIRSTNAME "firstname" #define GG_PUBDIR50_FIRSTNAME "firstname"
#define GG_PUBDIR50_LASTNAME "lastname" #define GG_PUBDIR50_LASTNAME "lastname"
#define GG_PUBDIR50_NICKNAME "nickname" #define GG_PUBDIR50_NICKNAME "nickname"
#define GG_PUBDIR50_BIRTHYEAR "birthyear" #define GG_PUBDIR50_BIRTHYEAR "birthyear"
#define GG_PUBDIR50_CITY "city" #define GG_PUBDIR50_CITY "city"
#define GG_PUBDIR50_GENDER "gender" #define GG_PUBDIR50_GENDER "gender"
#define GG_PUBDIR50_GENDER_FEMALE "1" #define GG_PUBDIR50_GENDER_FEMALE "1"
#define GG_PUBDIR50_GENDER_MALE "2" #define GG_PUBDIR50_GENDER_MALE "2"
#define GG_PUBDIR50_GENDER_SET_FEMALE "2" #define GG_PUBDIR50_GENDER_SET_FEMALE "2"
#define GG_PUBDIR50_GENDER_SET_MALE "1" #define GG_PUBDIR50_GENDER_SET_MALE "1"
#define GG_PUBDIR50_ACTIVE "ActiveOnly" #define GG_PUBDIR50_ACTIVE "ActiveOnly"
#define GG_PUBDIR50_ACTIVE_TRUE "1" #define GG_PUBDIR50_ACTIVE_TRUE "1"
#define GG_PUBDIR50_START "fmstart" #define GG_PUBDIR50_START "fmstart"
#define GG_PUBDIR50_FAMILYNAME "familyname" #define GG_PUBDIR50_FAMILYNAME "familyname"
#define GG_PUBDIR50_FAMILYCITY "familycity" #define GG_PUBDIR50_FAMILYCITY "familycity"
int gg_pubdir50_handle_reply(struct gg_event *e, const char *packet, int le #else
ngth);
/**
* \ingroup pubdir50
*
* Rodzaj pola zapytania.
*/
enum {
GG_PUBDIR50_UIN, /**< Numer Gadu-Gadu */
GG_PUBDIR50_STATUS, /**< Status */
GG_PUBDIR50_FIRSTNAME, /**< Imię */
GG_PUBDIR50_LASTNAME, /**< Nazwisko */
GG_PUBDIR50_NICKNAME, /**< Pseudonim */
GG_PUBDIR50_BIRTHYEAR, /**< Rok urodzenia lub przedział lat oddziel
ony spacją */
GG_PUBDIR50_CITY, /**< Miejscowość */
GG_PUBDIR50_GENDER, /**< Płeć */
GG_PUBDIR50_ACTIVE, /**< Osoba dostępna (tylko wyszukiwanie) */
GG_PUBDIR50_START, /**< Numer początkowy wyszukiwania (tylko wy
szukiwanie) */
GG_PUBDIR50_FAMILYNAME, /**< Nazwisko rodowe (tylko wysyłanie inform
acji o sobie) */
GG_PUBDIR50_FAMILYCITY, /**< Miejscowość pochodzenia (tylko wysyłani
e informacji o sobie) */
};
/**
* \ingroup pubdir50
*
* Wartość pola GG_PUBDIR50_GENDER przy wyszukiwaniu. Brak pola oznacza dow
olną płeć.
*/
enum {
GG_PUBDIR50_GENDER_FEMALE, /**< Kobieta */
GG_PUBDIR50_GENDER_MAIL, /**< Mężczyzna */
};
/**
* \ingroup pubdir50
*
* Wartość pola GG_PUBDIR50_GENDER przy wysyłaniu informacji o sobie.
*/
enum {
GG_PUBDIR50_GENDER_SET_FEMALE, /**< Kobieta */
GG_PUBDIR50_GENDER_SET_MAIL, /**< Mężczyzna */
};
/**
* \ingroup pubdir50
*
* Wartość pola GG_PUBDIR50_ACTIVE.
*/
enum {
GG_PUBDIR50_ACTIVE_TRUE, /**< Wyszukaj tylko osoby dostępne *
/
};
#endif /* DOXYGEN */
/**
* Wynik operacji na katalogu publicznym.
*
* \ingroup http
*/
struct gg_pubdir {
int success; /**< Flaga powodzenia operacji */
uin_t uin; /**< Otrzymany numer lub 0 w przypadku błędu
*/
};
int gg_pubdir_watch_fd(struct gg_http *f);
void gg_pubdir_free(struct gg_http *f);
/**
* Token autoryzacji niektórych operacji HTTP.
*
* \ingroup token
*/
struct gg_token {
int width; /**< Szerokość obrazka */
int height; /**< Wysokość obrazka */
int length; /**< Liczba znaków w tokenie */
char *tokenid; /**< Identyfikator tokenu */
};
struct gg_http *gg_token(int async);
int gg_token_watch_fd(struct gg_http *h);
void gg_token_free(struct gg_http *h);
struct gg_http *gg_register3(const char *email, const char *password, const
char *tokenid, const char *tokenval, int async);
#ifndef DOXYGEN
#define gg_register_watch_fd gg_pubdir_watch_fd
#define gg_register_free gg_pubdir_free
#endif
struct gg_http *gg_unregister3(uin_t uin, const char *password, const char
*tokenid, const char *tokenval, int async);
#ifndef DOXYGEN
#define gg_unregister_watch_fd gg_pubdir_watch_fd
#define gg_unregister_free gg_pubdir_free
#endif
struct gg_http *gg_remind_passwd3(uin_t uin, const char *email, const char
*tokenid, const char *tokenval, int async);
#ifndef DOXYGEN
#define gg_remind_passwd_watch_fd gg_pubdir_watch_fd
#define gg_remind_passwd_free gg_pubdir_free
#endif
struct gg_http *gg_change_passwd4(uin_t uin, const char *email, const char
*passwd, const char *newpasswd, const char *tokenid, const char *tokenval,
int async);
#ifndef DOXYGEN
#define gg_change_passwd_watch_fd gg_pubdir_watch_fd
#define gg_change_passwd_free gg_pubdir_free
#endif
extern int gg_dcc_port;
extern unsigned long gg_dcc_ip;
int gg_dcc_request(struct gg_session *sess, uin_t uin);
struct gg_dcc *gg_dcc_send_file(uint32_t ip, uint16_t port, uin_t my_uin, u
in_t peer_uin);
struct gg_dcc *gg_dcc_get_file(uint32_t ip, uint16_t port, uin_t my_uin, ui
n_t peer_uin);
struct gg_dcc *gg_dcc_voice_chat(uint32_t ip, uint16_t port, uin_t my_uin,
uin_t peer_uin);
void gg_dcc_set_type(struct gg_dcc *d, int type);
int gg_dcc_fill_file_info(struct gg_dcc *d, const char *filename);
int gg_dcc_fill_file_info2(struct gg_dcc *d, const char *filename, const ch
ar *local_filename);
int gg_dcc_voice_send(struct gg_dcc *d, char *buf, int length);
#define GG_DCC_VOICE_FRAME_LENGTH 195 /**< Rozmiar pakietu głosowe
go przed wersją Gadu-Gadu 5.0.5 */
#define GG_DCC_VOICE_FRAME_LENGTH_505 326 /**< Rozmiar pakietu głosowe
go od wersji Gadu-Gadu 5.0.5 */
struct gg_dcc *gg_dcc_socket_create(uin_t uin, uint16_t port);
#ifndef DOXYGEN
#define gg_dcc_socket_free gg_dcc_free
#define gg_dcc_socket_watch_fd gg_dcc_watch_fd
#endif
struct gg_event *gg_dcc_watch_fd(struct gg_dcc *d);
void gg_dcc_free(struct gg_dcc *c);
struct gg_event *gg_dcc7_watch_fd(struct gg_dcc7 *d);
struct gg_dcc7 *gg_dcc7_send_file(struct gg_session *sess, uin_t rcpt, cons
t char *filename, const char *filename1250, const char *hash);
struct gg_dcc7 *gg_dcc7_send_file_fd(struct gg_session *sess, uin_t rcpt, i
nt fd, size_t size, const char *filename1250, const char *hash);
int gg_dcc7_accept(struct gg_dcc7 *dcc, unsigned int offset);
int gg_dcc7_reject(struct gg_dcc7 *dcc, int reason);
void gg_dcc7_free(struct gg_dcc7 *d);
extern int gg_debug_level;
extern void (*gg_debug_handler)(int level, const char *format, va_list ap);
extern void (*gg_debug_handler_session)(struct gg_session *sess, int level,
const char *format, va_list ap);
extern FILE *gg_debug_file;
/**
* \ingroup debug
* @{
*/
#define GG_DEBUG_NET 1 /**< Rejestracja zdarzeń związanych z siecią
*/
#define GG_DEBUG_TRAFFIC 2 /**< Rejestracja ruchu sieciowego */
#define GG_DEBUG_DUMP 4 /**< Rejestracja zawartości pakietów
*/
#define GG_DEBUG_FUNCTION 8 /**< Rejestracja wywołań funkcji */
#define GG_DEBUG_MISC 16 /**< Rejestracja różnych informacji */
/** @} */
#ifdef GG_DEBUG_DISABLE
#define gg_debug(x, y...) do { } while(0)
#define gg_debug_session(z, x, y...) do { } while(0)
#else
void gg_debug(int level, const char *format, ...);
void gg_debug_session(struct gg_session *sess, int level, const char *forma
t, ...);
#endif
const char *gg_libgadu_version(void);
extern int gg_proxy_enabled;
extern char *gg_proxy_host;
extern int gg_proxy_port;
extern char *gg_proxy_username;
extern char *gg_proxy_password;
extern int gg_proxy_http_only;
extern unsigned long gg_local_ip;
#define GG_LOGIN_HASH_GG32 0x01 /**< Algorytm Gadu-Gadu */
#define GG_LOGIN_HASH_SHA1 0x02 /**< Algorytm SHA1 */
#ifndef DOXYGEN
#define GG_PUBDIR50_WRITE 0x01
#define GG_PUBDIR50_READ 0x02
#define GG_PUBDIR50_SEARCH 0x03
#define GG_PUBDIR50_SEARCH_REQUEST GG_PUBDIR50_SEARCH
#define GG_PUBDIR50_SEARCH_REPLY 0x05
#else
/**
* \ingroup pubdir50
*
* Rodzaj zapytania lub odpowiedzi katalogu publicznego.
*/
enum {
GG_PUBDIR50_WRITE, /**< Wysłanie do serwera informacji o sobie
*/
GG_PUBDIR50_READ, /**< Pobranie z serwera informacji o sobie *
/
GG_PUBDIR50_SEARCH, /**< Wyszukiwanie w katalogu publicznym */
GG_PUBDIR50_SEARCH_REPLY, /**< Wynik wyszukiwania w katalogu p
ublicznym */
};
#endif /* DOXYGEN */
/** \cond obsolete */
#define gg_free_event gg_event_free
#define gg_free_http gg_http_free
#define gg_free_pubdir gg_pubdir_free
#define gg_free_register gg_pubdir_free
#define gg_free_remind_passwd gg_pubdir_free
#define gg_free_dcc gg_dcc_free
#define gg_free_change_passwd gg_pubdir_free
struct gg_search_request {
int active;
unsigned int start;
char *nickname;
char *first_name;
char *last_name;
char *city;
int gender;
int min_birth;
int max_birth;
char *email;
char *phone;
uin_t uin;
};
struct gg_search {
int count;
struct gg_search_result *results;
};
/* struct gg_search_result {
* struct gg_pubdir uin_t uin;
* char *first_name;
* operacje na katalogu publicznym. char *last_name;
*/ char *nickname;
struct gg_pubdir { int born;
int success; /* czy si int gender;
uin_t uin; /* otrzymany numerek. 0 je char *city;
int active;
}; };
/* og #define GG_GENDER_NONE 0
int gg_pubdir_watch_fd(struct gg_http *f); #define GG_GENDER_FEMALE 1
void gg_pubdir_free(struct gg_http *f); #define GG_GENDER_MALE 2
#define gg_free_pubdir gg_pubdir_free
struct gg_token { struct gg_http *gg_search(const struct gg_search_request *r, int async);
int width; /* szeroko int gg_search_watch_fd(struct gg_http *f);
int height; /* wysoko void gg_free_search(struct gg_http *f);
int length; /* ilo #define gg_search_free gg_free_search
char *tokenid; /* id tokenu */
};
/* funkcje dotycz const struct gg_search_request *gg_search_request_mode_0(char *nickname, ch
struct gg_http *gg_token(int async); ar *first_name, char *last_name, char *city, int gender, int min_birth, int
int gg_token_watch_fd(struct gg_http *h); max_birth, int active, int start);
void gg_token_free(struct gg_http *h); const struct gg_search_request *gg_search_request_mode_1(char *email, int a
ctive, int start);
const struct gg_search_request *gg_search_request_mode_2(char *phone, int a
ctive, int start);
const struct gg_search_request *gg_search_request_mode_3(uin_t uin, int act
ive, int start);
void gg_search_request_free(struct gg_search_request *r);
/* rejestracja nowego numerka */
struct gg_http *gg_register(const char *email, const char *password, int as ync); struct gg_http *gg_register(const char *email, const char *password, int as ync);
struct gg_http *gg_register2(const char *email, const char *password, const char *qa, int async); struct gg_http *gg_register2(const char *email, const char *password, const char *qa, int async);
struct gg_http *gg_register3(const char *email, const char *password, const
char *tokenid, const char *tokenval, int async);
#define gg_register_watch_fd gg_pubdir_watch_fd
#define gg_register_free gg_pubdir_free
#define gg_free_register gg_pubdir_free
struct gg_http *gg_unregister(uin_t uin, const char *password, const char * email, int async); struct gg_http *gg_unregister(uin_t uin, const char *password, const char * email, int async);
struct gg_http *gg_unregister2(uin_t uin, const char *password, const char *qa, int async); struct gg_http *gg_unregister2(uin_t uin, const char *password, const char *qa, int async);
struct gg_http *gg_unregister3(uin_t uin, const char *password, const char
*tokenid, const char *tokenval, int async);
#define gg_unregister_watch_fd gg_pubdir_watch_fd
#define gg_unregister_free gg_pubdir_free
/* przypomnienie has
struct gg_http *gg_remind_passwd(uin_t uin, int async); struct gg_http *gg_remind_passwd(uin_t uin, int async);
struct gg_http *gg_remind_passwd2(uin_t uin, const char *tokenid, const cha r *tokenval, int async); struct gg_http *gg_remind_passwd2(uin_t uin, const char *tokenid, const cha r *tokenval, int async);
struct gg_http *gg_remind_passwd3(uin_t uin, const char *email, const char
*tokenid, const char *tokenval, int async);
#define gg_remind_passwd_watch_fd gg_pubdir_watch_fd
#define gg_remind_passwd_free gg_pubdir_free
#define gg_free_remind_passwd gg_pubdir_free
/* zmiana has
struct gg_http *gg_change_passwd(uin_t uin, const char *passwd, const char *newpasswd, const char *newemail, int async); struct gg_http *gg_change_passwd(uin_t uin, const char *passwd, const char *newpasswd, const char *newemail, int async);
struct gg_http *gg_change_passwd2(uin_t uin, const char *passwd, const char *newpasswd, const char *email, const char *newemail, int async); struct gg_http *gg_change_passwd2(uin_t uin, const char *passwd, const char *newpasswd, const char *email, const char *newemail, int async);
struct gg_http *gg_change_passwd3(uin_t uin, const char *passwd, const char *newpasswd, const char *qa, int async); struct gg_http *gg_change_passwd3(uin_t uin, const char *passwd, const char *newpasswd, const char *qa, int async);
struct gg_http *gg_change_passwd4(uin_t uin, const char *email, const char
*passwd, const char *newpasswd, const char *tokenid, const char *tokenval,
int async);
#define gg_change_passwd_free gg_pubdir_free
#define gg_free_change_passwd gg_pubdir_free
/*
* struct gg_change_info_request
*
* opis
*/
struct gg_change_info_request { struct gg_change_info_request {
char *first_name; /* imi char *first_name;
char *last_name; /* nazwisko */ char *last_name;
char *nickname; /* pseudonim */ char *nickname;
char *email; /* email */ char *email;
int born; /* rok urodzenia */ int born;
int gender; /* p int gender;
char *city; /* miasto */ char *city;
}; };
struct gg_change_info_request *gg_change_info_request_new(const char *first _name, const char *last_name, const char *nickname, const char *email, int born, int gender, const char *city); struct gg_change_info_request *gg_change_info_request_new(const char *first _name, const char *last_name, const char *nickname, const char *email, int born, int gender, const char *city);
void gg_change_info_request_free(struct gg_change_info_request *r); void gg_change_info_request_free(struct gg_change_info_request *r);
struct gg_http *gg_change_info(uin_t uin, const char *passwd, const struct gg_change_info_request *request, int async); struct gg_http *gg_change_info(uin_t uin, const char *passwd, const struct gg_change_info_request *request, int async);
#define gg_change_pubdir_watch_fd gg_pubdir_watch_fd #define gg_change_pubdir_watch_fd gg_pubdir_watch_fd
#define gg_change_pubdir_free gg_pubdir_free #define gg_change_pubdir_free gg_pubdir_free
#define gg_free_change_pubdir gg_pubdir_free #define gg_free_change_pubdir gg_pubdir_free
/*
* funkcje dotycz
*/
struct gg_http *gg_userlist_get(uin_t uin, const char *password, int async) ; struct gg_http *gg_userlist_get(uin_t uin, const char *password, int async) ;
int gg_userlist_get_watch_fd(struct gg_http *f); int gg_userlist_get_watch_fd(struct gg_http *f);
void gg_userlist_get_free(struct gg_http *f); void gg_userlist_get_free(struct gg_http *f);
struct gg_http *gg_userlist_put(uin_t uin, const char *password, const char *contacts, int async); struct gg_http *gg_userlist_put(uin_t uin, const char *password, const char *contacts, int async);
int gg_userlist_put_watch_fd(struct gg_http *f); int gg_userlist_put_watch_fd(struct gg_http *f);
void gg_userlist_put_free(struct gg_http *f); void gg_userlist_put_free(struct gg_http *f);
struct gg_http *gg_userlist_remove(uin_t uin, const char *password, int asy nc); struct gg_http *gg_userlist_remove(uin_t uin, const char *password, int asy nc);
int gg_userlist_remove_watch_fd(struct gg_http *f); int gg_userlist_remove_watch_fd(struct gg_http *f);
void gg_userlist_remove_free(struct gg_http *f); void gg_userlist_remove_free(struct gg_http *f);
/* /** \endcond */
* funkcje dotycz
*/
extern int gg_dcc_port; /* port, na kt
extern unsigned long gg_dcc_ip; /* adres, na kt
int gg_dcc_request(struct gg_session *sess, uin_t uin);
struct gg_dcc *gg_dcc_send_file(uint32_t ip, uint16_t port, uin_t my_uin, u
in_t peer_uin);
struct gg_dcc *gg_dcc_get_file(uint32_t ip, uint16_t port, uin_t my_uin, ui
n_t peer_uin);
struct gg_dcc *gg_dcc_voice_chat(uint32_t ip, uint16_t port, uin_t my_uin,
uin_t peer_uin);
void gg_dcc_set_type(struct gg_dcc *d, int type);
int gg_dcc_fill_file_info(struct gg_dcc *d, const char *filename);
int gg_dcc_fill_file_info2(struct gg_dcc *d, const char *filename, const ch
ar *local_filename);
int gg_dcc_voice_send(struct gg_dcc *d, char *buf, int length);
#define GG_DCC_VOICE_FRAME_LENGTH 195
#define GG_DCC_VOICE_FRAME_LENGTH_505 326
struct gg_dcc *gg_dcc_socket_create(uin_t uin, uint16_t port);
#define gg_dcc_socket_free gg_free_dcc
#define gg_dcc_socket_watch_fd gg_dcc_watch_fd
struct gg_event *gg_dcc_watch_fd(struct gg_dcc *d);
void gg_dcc_free(struct gg_dcc *c);
#define gg_free_dcc gg_dcc_free
/*
* je
* niestety w miar
* si
*/
extern int gg_debug_level; /* poziom debugowania. mapa bitowa sta
/*
* mo
* nieoficjalne, nieudokumentowane, mo
* zainteresowany, niech da zna
*/
extern void (*gg_debug_handler)(int level, const char *format, va_list ap);
extern void (*gg_debug_handler_session)(struct gg_session *sess, int level,
const char *format, va_list ap);
/*
* mo
*/
extern FILE *gg_debug_file;
#define GG_DEBUG_NET 1
#define GG_DEBUG_TRAFFIC 2
#define GG_DEBUG_DUMP 4
#define GG_DEBUG_FUNCTION 8
#define GG_DEBUG_MISC 16
#ifdef GG_DEBUG_DISABLE
#define gg_debug(x, y...) do { } while(0)
#define gg_debug_session(z, x, y...) do { } while(0)
#else
void gg_debug(int level, const char *format, ...);
void gg_debug_session(struct gg_session *sess, int level, const char *forma
t, ...);
#endif
const char *gg_libgadu_version(void);
/* int gg_pubdir50_handle_reply(struct gg_event *e, const char *packet, int le
* konfiguracja http proxy. ngth);
*/
extern int gg_proxy_enabled; /* w
extern char *gg_proxy_host; /* okre
extern int gg_proxy_port; /* okre
extern char *gg_proxy_username; /* okre
extern char *gg_proxy_password; /* okre
extern int gg_proxy_http_only; /* w
/* int gg_file_hash_sha1(int fd, uint8_t *result);
* adres, z kt
* u
*/
extern unsigned long gg_local_ip;
/*
* ------------------------------------------------------------------------
-
* poni
* powinien ich w og
* procedurami wy
* tego pliku.
* ------------------------------------------------------------------------
-
*/
#ifdef GG_CONFIG_HAVE_PTHREAD #ifdef GG_CONFIG_HAVE_PTHREAD
int gg_resolve_pthread(int *fd, void **resolver, const char *hostname); int gg_resolve_pthread(int *fd, void **resolver, const char *hostname);
void gg_resolve_pthread_cleanup(void *resolver, int kill); void gg_resolve_pthread_cleanup(void *resolver, int kill);
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
int gg_thread_socket(int thread_id, int socket); int gg_thread_socket(int thread_id, int socket);
#endif #endif
skipping to change at line 997 skipping to change at line 1250
#define gg_alloc_sprintf gg_saprintf #define gg_alloc_sprintf gg_saprintf
char *gg_get_line(char **ptr); char *gg_get_line(char **ptr);
int gg_connect(void *addr, int port, int async); int gg_connect(void *addr, int port, int async);
struct in_addr *gg_gethostbyname(const char *hostname); struct in_addr *gg_gethostbyname(const char *hostname);
char *gg_read_line(int sock, char *buf, int length); char *gg_read_line(int sock, char *buf, int length);
void gg_chomp(char *line); void gg_chomp(char *line);
char *gg_urlencode(const char *str); char *gg_urlencode(const char *str);
int gg_http_hash(const char *format, ...); int gg_http_hash(const char *format, ...);
void gg_http_free_fields(struct gg_http *h);
int gg_read(struct gg_session *sess, char *buf, int length); int gg_read(struct gg_session *sess, char *buf, int length);
int gg_write(struct gg_session *sess, const char *buf, int length); int gg_write(struct gg_session *sess, const char *buf, int length);
void *gg_recv_packet(struct gg_session *sess); void *gg_recv_packet(struct gg_session *sess);
int gg_send_packet(struct gg_session *sess, int type, ...); int gg_send_packet(struct gg_session *sess, int type, ...);
unsigned int gg_login_hash(const unsigned char *password, unsigned int seed ); unsigned int gg_login_hash(const unsigned char *password, unsigned int seed );
void gg_login_hash_sha1(const char *password, uint32_t seed, uint8_t *resul t);
uint32_t gg_fix32(uint32_t x); uint32_t gg_fix32(uint32_t x);
uint16_t gg_fix16(uint16_t x); uint16_t gg_fix16(uint16_t x);
#define fix16 gg_fix16 #define fix16 gg_fix16
#define fix32 gg_fix32 #define fix32 gg_fix32
char *gg_proxy_auth(void); char *gg_proxy_auth(void);
char *gg_base64_encode(const char *buf); char *gg_base64_encode(const char *buf);
char *gg_base64_decode(const char *buf); char *gg_base64_decode(const char *buf);
int gg_image_queue_remove(struct gg_session *s, struct gg_image_queue *q, i nt freeq); int gg_image_queue_remove(struct gg_session *s, struct gg_image_queue *q, i nt freeq);
/**
* Kolejka odbieranych obrazków.
*/
struct gg_image_queue {
uin_t sender; /**< Nadawca obrazka */
uint32_t size; /**< Rozmiar obrazka */
uint32_t crc32; /**< Suma kontrolna CRC32 */
char *filename; /**< Nazwa pliku */
char *image; /**< Bufor z odebranymi danymi */
uint32_t done; /**< Rozmiar odebranych danych */
struct gg_image_queue *next; /**< Kolejny element listy */
};
int gg_dcc7_handle_id(struct gg_session *sess, struct gg_event *e, void *pa
yload, int len);
int gg_dcc7_handle_new(struct gg_session *sess, struct gg_event *e, void *p
ayload, int len);
int gg_dcc7_handle_info(struct gg_session *sess, struct gg_event *e, void *
payload, int len);
int gg_dcc7_handle_accept(struct gg_session *sess, struct gg_event *e, void
*payload, int len);
int gg_dcc7_handle_reject(struct gg_session *sess, struct gg_event *e, void
*payload, int len);
#define GG_APPMSG_HOST "appmsg.gadu-gadu.pl" #define GG_APPMSG_HOST "appmsg.gadu-gadu.pl"
#define GG_APPMSG_PORT 80 #define GG_APPMSG_PORT 80
#define GG_PUBDIR_HOST "pubdir.gadu-gadu.pl" #define GG_PUBDIR_HOST "pubdir.gadu-gadu.pl"
#define GG_PUBDIR_PORT 80 #define GG_PUBDIR_PORT 80
#define GG_REGISTER_HOST "register.gadu-gadu.pl" #define GG_REGISTER_HOST "register.gadu-gadu.pl"
#define GG_REGISTER_PORT 80 #define GG_REGISTER_PORT 80
#define GG_REMIND_HOST "retr.gadu-gadu.pl" #define GG_REMIND_HOST "retr.gadu-gadu.pl"
#define GG_REMIND_PORT 80 #define GG_REMIND_PORT 80
#define GG_DEFAULT_PORT 8074 #define GG_DEFAULT_PORT 8074
#define GG_HTTPS_PORT 443 #define GG_HTTPS_PORT 443
#define GG_HTTP_USERAGENT "Mozilla/4.7 [en] (Win98; I)" #define GG_HTTP_USERAGENT "Mozilla/4.7 [en] (Win98; I)"
#define GG_DEFAULT_CLIENT_VERSION "6, 1, 0, 158" #define GG_DEFAULT_CLIENT_VERSION "7, 7, 0, 3351"
#define GG_DEFAULT_PROTOCOL_VERSION 0x24 #define GG_DEFAULT_PROTOCOL_VERSION 0x2a
#define GG_DEFAULT_TIMEOUT 30 #define GG_DEFAULT_TIMEOUT 30
#define GG_HAS_AUDIO_MASK 0x40000000 #define GG_HAS_AUDIO_MASK 0x40000000
#define GG_HAS_AUDIO7_MASK 0x20000000
#define GG_ERA_OMNIX_MASK 0x04000000 #define GG_ERA_OMNIX_MASK 0x04000000
#define GG_LIBGADU_VERSION "CVS" #define GG_LIBGADU_VERSION "1.8.0"
#define GG_DEFAULT_DCC_PORT 1550 #define GG_DEFAULT_DCC_PORT 1550
struct gg_header { struct gg_header {
uint32_t type; /* typ pakietu */ uint32_t type; /* typ pakietu */
uint32_t length; /* d uint32_t length; /* długość reszty pakietu */
} GG_PACKED; } GG_PACKED;
#define GG_WELCOME 0x0001 #define GG_WELCOME 0x0001
#define GG_NEED_EMAIL 0x0014 #define GG_NEED_EMAIL 0x0014
struct gg_welcome { struct gg_welcome {
uint32_t key; /* klucz szyfrowania has uint32_t key; /* klucz szyfrowania hasła */
} GG_PACKED; } GG_PACKED;
#define GG_LOGIN 0x000c #define GG_LOGIN 0x000c
struct gg_login { struct gg_login {
uint32_t uin; /* m uint32_t uin; /* mój numerek */
uint32_t hash; /* hash has uint32_t hash; /* hash hasła */
uint32_t status; /* status na dzie uint32_t status; /* status na dzień dobry */
uint32_t version; /* moja wersja klienta */ uint32_t version; /* moja wersja klienta */
uint32_t local_ip; /* m uint32_t local_ip; /* mój adres ip */
uint16_t local_port; /* port, na kt uint16_t local_port; /* port, na którym słucham */
} GG_PACKED; } GG_PACKED;
#define GG_LOGIN_EXT 0x0013 #define GG_LOGIN_EXT 0x0013
struct gg_login_ext { struct gg_login_ext {
uint32_t uin; /* m uint32_t uin; /* mój numerek */
uint32_t hash; /* hash has uint32_t hash; /* hash hasła */
uint32_t status; /* status na dzie uint32_t status; /* status na dzień dobry */
uint32_t version; /* moja wersja klienta */ uint32_t version; /* moja wersja klienta */
uint32_t local_ip; /* m uint32_t local_ip; /* mój adres ip */
uint16_t local_port; /* port, na kt uint16_t local_port; /* port, na którym słucham */
uint32_t external_ip; /* zewn uint32_t external_ip; /* zewnętrzny adres ip */
uint16_t external_port; /* zewn uint16_t external_port; /* zewnętrzny port */
} GG_PACKED; } GG_PACKED;
#define GG_LOGIN60 0x0015 #define GG_LOGIN60 0x0015
struct gg_login60 { struct gg_login60 {
uint32_t uin; /* m uint32_t uin; /* mój numerek */
uint32_t hash; /* hash has uint32_t hash; /* hash hasła */
uint32_t status; /* status na dzie uint32_t status; /* status na dzień dobry */
uint32_t version; /* moja wersja klienta */
uint8_t dunno1; /* 0x00 */
uint32_t local_ip; /* mój adres ip */
uint16_t local_port; /* port, na którym słucham */
uint32_t external_ip; /* zewnętrzny adres ip */
uint16_t external_port; /* zewnętrzny port */
uint8_t image_size; /* maksymalny rozmiar grafiki w KiB
*/
uint8_t dunno2; /* 0xbe */
} GG_PACKED;
#define GG_LOGIN70 0x19
struct gg_login70 {
uint32_t uin; /* mój numerek */
uint8_t hash_type; /* rodzaj hashowania hasła */
uint8_t hash[64]; /* hash hasła dopełniony zerami */
uint32_t status; /* status na dzień dobry */
uint32_t version; /* moja wersja klienta */ uint32_t version; /* moja wersja klienta */
uint8_t dunno1; /* 0x00 */ uint8_t dunno1; /* 0x00 */
uint32_t local_ip; /* m uint32_t local_ip; /* mój adres ip */
uint16_t local_port; /* port, na kt uint16_t local_port; /* port, na którym słucham */
uint32_t external_ip; /* zewn uint32_t external_ip; /* zewnętrzny adres ip (???) */
uint16_t external_port; /* zewn uint16_t external_port; /* zewnętrzny port (???) */
uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */ uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */
uint8_t dunno2; /* 0xbe */ uint8_t dunno2; /* 0xbe */
} GG_PACKED; } GG_PACKED;
#define GG_LOGIN_OK 0x0003 #define GG_LOGIN_OK 0x0003
#define GG_LOGIN_FAILED 0x0009 #define GG_LOGIN_FAILED 0x0009
#define GG_PUBDIR50_REQUEST 0x0014 #define GG_PUBDIR50_REQUEST 0x0014
#define GG_PUBDIR50_WRITE 0x01
#define GG_PUBDIR50_READ 0x02
#define GG_PUBDIR50_SEARCH 0x03
#define GG_PUBDIR50_SEARCH_REQUEST GG_PUBDIR50_SEARCH
#define GG_PUBDIR50_SEARCH_REPLY 0x05
struct gg_pubdir50_request { struct gg_pubdir50_request {
uint8_t type; /* GG_PUBDIR50_* */ uint8_t type; /* GG_PUBDIR50_* */
uint32_t seq; /* czas wys uint32_t seq; /* czas wysłania zapytania */
} GG_PACKED; } GG_PACKED;
#define GG_PUBDIR50_REPLY 0x000e #define GG_PUBDIR50_REPLY 0x000e
struct gg_pubdir50_reply { struct gg_pubdir50_reply {
uint8_t type; /* GG_PUBDIR50_* */ uint8_t type; /* GG_PUBDIR50_* */
uint32_t seq; /* czas wys uint32_t seq; /* czas wysłania zapytania */
} GG_PACKED; } GG_PACKED;
#define GG_NEW_STATUS 0x0002 #define GG_NEW_STATUS 0x0002
#define GG_STATUS_NOT_AVAIL 0x0001 /* niedost #ifndef DOXYGEN
#define GG_STATUS_NOT_AVAIL_DESCR 0x0015 /* niedost
#define GG_STATUS_AVAIL 0x0002 /* dost
#define GG_STATUS_AVAIL_DESCR 0x0004 /* dost
#define GG_STATUS_BUSY 0x0003 /* zaj
#define GG_STATUS_BUSY_DESCR 0x0005 /* zaj
#define GG_STATUS_INVISIBLE 0x0014 /* niewidoczny (4.6) */
#define GG_STATUS_INVISIBLE_DESCR 0x0016 /* niewidoczny z opisem (4.9
) */
#define GG_STATUS_BLOCKED 0x0006 /* zablokowany */
#define GG_STATUS_FRIENDS_MASK 0x8000 /* tylko dla znajomych (4.6) #define GG_STATUS_NOT_AVAIL 0x0001
*/ #define GG_STATUS_NOT_AVAIL_DESCR 0x0015
#define GG_STATUS_AVAIL 0x0002
#define GG_STATUS_AVAIL_DESCR 0x0004
#define GG_STATUS_BUSY 0x0003
#define GG_STATUS_BUSY_DESCR 0x0005
#define GG_STATUS_INVISIBLE 0x0014
#define GG_STATUS_INVISIBLE_DESCR 0x0016
#define GG_STATUS_BLOCKED 0x0006
#define GG_STATUS_DESCR_MAXSIZE 70 #define GG_STATUS_FRIENDS_MASK 0x8000
/* #else
* makra do
/**
* Rodzaje statusów użytkownika.
*
* \ingroup status
*/
enum {
GG_STATUS_NOT_AVAIL, /**< Niedostępny */
GG_STATUS_NOT_AVAIL_DESCR, /**< Niedostępny z opisem */
GG_STATUS_AVAIL, /**< Dostępny */
GG_STATUS_AVAIL_DESCR, /**< Dostępny z opisem */
GG_STATUS_BUSY, /**< Zajęty */
GG_STATUS_BUSY_DESCR, /**< Zajęty z opisem */
GG_STATUS_INVISIBLE, /**< Niewidoczny (tylko własny statu
s) */
GG_STATUS_INVISIBLE_DESCR, /**< Niewidoczny z opisem (tylko wła
sny status) */
GG_STATUS_BLOCKED, /**< Zablokowany (tylko status innyc
h) */
GG_STATUS_FRIENDS_MASK, /**< Flaga bitowa dostępności tylko
dla znajomych */
};
#endif /* DOXYGEN */
/**
* \ingroup status
*
* Maksymalna długośc opisu.
*/ */
#define GG_STATUS_DESCR_MAXSIZE 70
/* GG_S_F() tryb tylko dla znajomych */ /* GG_S_F() tryb tylko dla znajomych */
#define GG_S_F(x) (((x) & GG_STATUS_FRIENDS_MASK) != 0) #define GG_S_F(x) (((x) & GG_STATUS_FRIENDS_MASK) != 0)
/* GG_S() stan bez uwzgl /* GG_S() stan bez uwzględnienia trybu tylko dla znajomych */
#define GG_S(x) ((x) & ~GG_STATUS_FRIENDS_MASK) #define GG_S(x) ((x) & ~GG_STATUS_FRIENDS_MASK)
/* GG_S_A() dost /* GG_S_A() dostępny */
#define GG_S_A(x) (GG_S(x) == GG_STATUS_AVAIL || GG_S(x) == GG_STATUS_AVAIL _DESCR) #define GG_S_A(x) (GG_S(x) == GG_STATUS_AVAIL || GG_S(x) == GG_STATUS_AVAIL _DESCR)
/* GG_S_NA() niedost /* GG_S_NA() niedostępny */
#define GG_S_NA(x) (GG_S(x) == GG_STATUS_NOT_AVAIL || GG_S(x) == GG_STATUS_ NOT_AVAIL_DESCR) #define GG_S_NA(x) (GG_S(x) == GG_STATUS_NOT_AVAIL || GG_S(x) == GG_STATUS_ NOT_AVAIL_DESCR)
/* GG_S_B() zaj /* GG_S_B() zajęty */
#define GG_S_B(x) (GG_S(x) == GG_STATUS_BUSY || GG_S(x) == GG_STATUS_BUSY_D ESCR) #define GG_S_B(x) (GG_S(x) == GG_STATUS_BUSY || GG_S(x) == GG_STATUS_BUSY_D ESCR)
/* GG_S_I() niewidoczny */ /* GG_S_I() niewidoczny */
#define GG_S_I(x) (GG_S(x) == GG_STATUS_INVISIBLE || GG_S(x) == GG_STATUS_I NVISIBLE_DESCR) #define GG_S_I(x) (GG_S(x) == GG_STATUS_INVISIBLE || GG_S(x) == GG_STATUS_I NVISIBLE_DESCR)
/* GG_S_D() stan opisowy */ /* GG_S_D() stan opisowy */
#define GG_S_D(x) (GG_S(x) == GG_STATUS_NOT_AVAIL_DESCR || GG_S(x) == GG_ST ATUS_AVAIL_DESCR || GG_S(x) == GG_STATUS_BUSY_DESCR || GG_S(x) == GG_STATUS _INVISIBLE_DESCR) #define GG_S_D(x) (GG_S(x) == GG_STATUS_NOT_AVAIL_DESCR || GG_S(x) == GG_ST ATUS_AVAIL_DESCR || GG_S(x) == GG_STATUS_BUSY_DESCR || GG_S(x) == GG_STATUS _INVISIBLE_DESCR)
/* GG_S_BL() blokowany lub blokuj /* GG_S_BL() blokowany lub blokujący */
#define GG_S_BL(x) (GG_S(x) == GG_STATUS_BLOCKED) #define GG_S_BL(x) (GG_S(x) == GG_STATUS_BLOCKED)
/**
* Zmiana statusu (pakiet \c GG_NEW_STATUS)
*/
struct gg_new_status { struct gg_new_status {
uint32_t status; /* na jaki zmieni uint32_t status; /**< Nowy status */
} GG_PACKED; } GG_PACKED;
#define GG_NOTIFY_FIRST 0x000f #define GG_NOTIFY_FIRST 0x000f
#define GG_NOTIFY_LAST 0x0010 #define GG_NOTIFY_LAST 0x0010
#define GG_NOTIFY 0x0010 #define GG_NOTIFY 0x0010
struct gg_notify { struct gg_notify {
uint32_t uin; /* numerek danej osoby */ uint32_t uin; /* numerek danej osoby */
uint8_t dunno1; /* rodzaj wpisu w li uint8_t dunno1; /* rodzaj wpisu w liście */
} GG_PACKED; } GG_PACKED;
#define GG_USER_OFFLINE 0x01 /* b #ifndef DOXYGEN
#define GG_USER_NORMAL 0x03 /* zwyk
#define GG_USER_BLOCKED 0x04 /* zablokowany u #define GG_USER_OFFLINE 0x01
#define GG_USER_NORMAL 0x03
#define GG_USER_BLOCKED 0x04
#else
/**
* \ingroup contacts
*
* Rodzaj kontaktu.
*/
enum {
GG_USER_NORMAL, /**< Zwykły kontakt */
GG_USER_BLOCKED, /**< Zablokowany */
GG_USER_OFFLINE, /**< Niewidoczny dla kontaktu */
};
#endif /* DOXYGEN */
#define GG_LIST_EMPTY 0x0012 #define GG_LIST_EMPTY 0x0012
#define GG_NOTIFY_REPLY 0x000c /* tak, to samo co GG_LOGIN */ #define GG_NOTIFY_REPLY 0x000c /* tak, to samo co GG_LOGIN */
struct gg_notify_reply { struct gg_notify_reply {
uint32_t uin; /* numerek */ uint32_t uin; /* numerek */
uint32_t status; /* status danej osoby */ uint32_t status; /* status danej osoby */
uint32_t remote_ip; /* adres ip delikwenta */ uint32_t remote_ip; /* adres ip delikwenta */
uint16_t remote_port; /* port, na kt uint16_t remote_port; /* port, na którym słucha klient */
uint32_t version; /* wersja klienta */ uint32_t version; /* wersja klienta */
uint16_t dunno2; /* znowu port? */ uint16_t dunno2; /* znowu port? */
} GG_PACKED; } GG_PACKED;
#define GG_NOTIFY_REPLY60 0x0011 #define GG_NOTIFY_REPLY60 0x0011
struct gg_notify_reply60 { struct gg_notify_reply60 {
uint32_t uin; /* numerek plus flagi w MSB */ uint32_t uin; /* numerek plus flagi w MSB */
uint8_t status; /* status danej osoby */ uint8_t status; /* status danej osoby */
uint32_t remote_ip; /* adres ip delikwenta */ uint32_t remote_ip; /* adres ip delikwenta */
uint16_t remote_port; /* port, na kt uint16_t remote_port; /* port, na którym słucha klient */
uint8_t version; /* wersja klienta */ uint8_t version; /* wersja klienta */
uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */ uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */
uint8_t dunno1; /* 0x00 */ uint8_t dunno1; /* 0x00 */
} GG_PACKED; } GG_PACKED;
#define GG_STATUS60 0x000f #define GG_STATUS60 0x000f
struct gg_status60 { struct gg_status60 {
uint32_t uin; /* numerek plus flagi w MSB */ uint32_t uin; /* numerek plus flagi w MSB */
uint8_t status; /* status danej osoby */ uint8_t status; /* status danej osoby */
uint32_t remote_ip; /* adres ip delikwenta */ uint32_t remote_ip; /* adres ip delikwenta */
uint16_t remote_port; /* port, na kt uint16_t remote_port; /* port, na którym słucha klient */
uint8_t version; /* wersja klienta */
uint8_t image_size; /* maksymalny rozmiar grafiki w KiB
*/
uint8_t dunno1; /* 0x00 */
} GG_PACKED;
#define GG_NOTIFY_REPLY77 0x0018
struct gg_notify_reply77 {
uint32_t uin; /* numerek plus flagi w MSB */
uint8_t status; /* status danej osoby */
uint32_t remote_ip; /* adres ip delikwenta */
uint16_t remote_port; /* port, na którym słucha klient */
uint8_t version; /* wersja klienta */
uint8_t image_size; /* maksymalny rozmiar grafiki w KiB
*/
uint8_t dunno1; /* 0x00 */
uint32_t dunno2; /* ? */
} GG_PACKED;
#define GG_STATUS77 0x0017
struct gg_status77 {
uint32_t uin; /* numerek plus flagi w MSB */
uint8_t status; /* status danej osoby */
uint32_t remote_ip; /* adres ip delikwenta */
uint16_t remote_port; /* port, na którym słucha klient */
uint8_t version; /* wersja klienta */ uint8_t version; /* wersja klienta */
uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */ uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */
uint8_t dunno1; /* 0x00 */ uint8_t dunno1; /* 0x00 */
uint32_t dunno2; /* ? */
} GG_PACKED; } GG_PACKED;
#define GG_ADD_NOTIFY 0x000d #define GG_ADD_NOTIFY 0x000d
#define GG_REMOVE_NOTIFY 0x000e #define GG_REMOVE_NOTIFY 0x000e
struct gg_add_remove { struct gg_add_remove {
uint32_t uin; /* numerek */ uint32_t uin; /* numerek */
uint8_t dunno1; /* bitmapa */ uint8_t dunno1; /* bitmapa */
} GG_PACKED; } GG_PACKED;
#define GG_STATUS 0x0002 #define GG_STATUS 0x0002
struct gg_status { struct gg_status {
uint32_t uin; /* numerek */ uint32_t uin; /* numerek */
uint32_t status; /* nowy stan */ uint32_t status; /* nowy stan */
} GG_PACKED; } GG_PACKED;
#define GG_SEND_MSG 0x000b #define GG_SEND_MSG 0x000b
#ifndef DOXYGEN
#define GG_CLASS_QUEUED 0x0001 #define GG_CLASS_QUEUED 0x0001
#define GG_CLASS_OFFLINE GG_CLASS_QUEUED #define GG_CLASS_OFFLINE GG_CLASS_QUEUED
#define GG_CLASS_MSG 0x0004 #define GG_CLASS_MSG 0x0004
#define GG_CLASS_CHAT 0x0008 #define GG_CLASS_CHAT 0x0008
#define GG_CLASS_CTCP 0x0010 #define GG_CLASS_CTCP 0x0010
#define GG_CLASS_ACK 0x0020 #define GG_CLASS_ACK 0x0020
#define GG_CLASS_EXT GG_CLASS_ACK /* kompatybilno #define GG_CLASS_EXT GG_CLASS_ACK /**< Dla kompatybilności wstecz */
#else
#define GG_MSG_MAXSIZE 2000 /**
* Klasy wiadomości. Wartości są maskami bitowymi, które w większości
* przypadków można łączyć (połączenie \c GG_CLASS_MSG i \c GG_CLASS_CHAT
* nie ma sensu).
*
* \ingroup messages
*/
enum {
GG_CLASS_MSG, /**< Wiadomość ma pojawić się w osobnym okni
e */
GG_CLASS_CHAT, /**< Wiadomość ma pojawić się w oknie rozmow
y */
GG_CLASS_CTCP, /**< Wiadomość przeznaczona dla klienta Gadu
-Gadu */
GG_CLASS_ACK, /**< Klient nie życzy sobie potwierdzenia */
GG_CLASS_QUEUED, /**< Wiadomość zakolejkowana na serwerze (ty
lko przy odbieraniu) */
};
#endif /* DOXYGEN */
/**
* Maksymalna długość wiadomości.
*
* \ingroup messages
*/
#define GG_MSG_MAXSIZE 1989
struct gg_send_msg { struct gg_send_msg {
uint32_t recipient; uint32_t recipient;
uint32_t seq; uint32_t seq;
uint32_t msgclass; uint32_t msgclass;
} GG_PACKED; } GG_PACKED;
struct gg_msg_richtext { struct gg_msg_richtext {
uint8_t flag; uint8_t flag;
uint16_t length; uint16_t length;
} GG_PACKED; } GG_PACKED;
/**
* Struktura opisująca formatowanie tekstu. W zależności od wartości pola
* \c font, zaraz za tą strukturą może wystąpić \c gg_msg_richtext_color
* lub \c gg_msg_richtext_image.
*
* \ingroup messages
*/
struct gg_msg_richtext_format { struct gg_msg_richtext_format {
uint16_t position; uint16_t position; /**< Początkowy znak formatowania (liczony o
uint8_t font; d 0) */
uint8_t font; /**< Atrybuty formatowania */
} GG_PACKED; } GG_PACKED;
struct gg_msg_richtext_image { #ifndef DOXYGEN
uint16_t unknown1;
uint32_t size;
uint32_t crc32;
} GG_PACKED;
#define GG_FONT_BOLD 0x01 #define GG_FONT_BOLD 0x01
#define GG_FONT_ITALIC 0x02 #define GG_FONT_ITALIC 0x02
#define GG_FONT_UNDERLINE 0x04 #define GG_FONT_UNDERLINE 0x04
#define GG_FONT_COLOR 0x08 #define GG_FONT_COLOR 0x08
#define GG_FONT_IMAGE 0x80 #define GG_FONT_IMAGE 0x80
#else
/**
* Atrybuty formatowania wiadomości.
*
* \ingroup messages
*/
enum {
GG_FONT_BOLD,
GG_FONT_ITALIC,
GG_FONT_UNDERLINE,
GG_FONT_COLOR,
GG_FONT_IMAGE
};
#endif /* DOXYGEN */
/**
* Struktura opisującą kolor tekstu dla atrybutu \c GG_FONT_COLOR.
*
* \ingroup messages
*/
struct gg_msg_richtext_color { struct gg_msg_richtext_color {
uint8_t red; uint8_t red; /**< Składowa czerwona koloru */
uint8_t green; uint8_t green; /**< Składowa zielona koloru */
uint8_t blue; uint8_t blue; /**< Składowa niebieska koloru */
} GG_PACKED;
/**
* Strukturya opisująca obrazek wstawiony do wiadomości dla atrubutu
* \c GG_FONT_IMAGE.
*
* \ingroup messages
*/
struct gg_msg_richtext_image {
uint16_t unknown1; /**< Nieznane pole o wartości 0x0109 */
uint32_t size; /**< Rozmiar obrazka */
uint32_t crc32; /**< Suma kontrolna CRC32 obrazka */
} GG_PACKED; } GG_PACKED;
struct gg_msg_recipients { struct gg_msg_recipients {
uint8_t flag; uint8_t flag;
uint32_t count; uint32_t count;
} GG_PACKED; } GG_PACKED;
struct gg_msg_image_request { struct gg_msg_image_request {
uint8_t flag; uint8_t flag;
uint32_t size; uint32_t size;
skipping to change at line 1290 skipping to change at line 1711
struct gg_msg_image_reply { struct gg_msg_image_reply {
uint8_t flag; uint8_t flag;
uint32_t size; uint32_t size;
uint32_t crc32; uint32_t crc32;
/* char filename[]; */ /* char filename[]; */
/* char image[]; */ /* char image[]; */
} GG_PACKED; } GG_PACKED;
#define GG_SEND_MSG_ACK 0x0005 #define GG_SEND_MSG_ACK 0x0005
#ifndef DOXYGEN
#define GG_ACK_BLOCKED 0x0001 #define GG_ACK_BLOCKED 0x0001
#define GG_ACK_DELIVERED 0x0002 #define GG_ACK_DELIVERED 0x0002
#define GG_ACK_QUEUED 0x0003 #define GG_ACK_QUEUED 0x0003
#define GG_ACK_MBOXFULL 0x0004 #define GG_ACK_MBOXFULL 0x0004
#define GG_ACK_NOT_DELIVERED 0x0006 #define GG_ACK_NOT_DELIVERED 0x0006
#else
/**
* Status doręczenia wiadomości.
*
* \ingroup messages
*/
enum
{
GG_ACK_DELIVERED, /**< Wiadomość dostarczono. */
GG_ACK_QUEUED, /**< Wiadomość zakolejkowano z powodu niedos
tępności odbiorcy. */
GG_ACK_BLOCKED, /**< Wiadomość zablokowana przez serwer (spa
m, świąteczne ograniczenia itd.) */
GG_ACK_MBOXFULL, /**< Wiadomości nie dostarczono z powodu zap
ełnionej kolejki wiadomości odbiorcy. */
GG_ACK_NOT_DELIVERED /**< Wiadomości nie dostarczono (tylko dla \
c GG_CLASS_CTCP). */
};
#endif /* DOXYGEN */
struct gg_send_msg_ack { struct gg_send_msg_ack {
uint32_t status; uint32_t status;
uint32_t recipient; uint32_t recipient;
uint32_t seq; uint32_t seq;
} GG_PACKED; } GG_PACKED;
#define GG_RECV_MSG 0x000a #define GG_RECV_MSG 0x000a
struct gg_recv_msg { struct gg_recv_msg {
uint32_t sender; uint32_t sender;
skipping to change at line 1319 skipping to change at line 1760
} GG_PACKED; } GG_PACKED;
#define GG_PING 0x0008 #define GG_PING 0x0008
#define GG_PONG 0x0007 #define GG_PONG 0x0007
#define GG_DISCONNECTING 0x000b #define GG_DISCONNECTING 0x000b
#define GG_USERLIST_REQUEST 0x0016 #define GG_USERLIST_REQUEST 0x0016
#define GG_XML_EVENT 0x0027
#ifndef DOXYGEN
#define GG_USERLIST_PUT 0x00 #define GG_USERLIST_PUT 0x00
#define GG_USERLIST_PUT_MORE 0x01 #define GG_USERLIST_PUT_MORE 0x01
#define GG_USERLIST_GET 0x02 #define GG_USERLIST_GET 0x02
#else
/**
* \ingroup importexport
*
* Rodzaj zapytania.
*/
enum {
GG_USERLIST_PUT, /**< Eksport listy kontaktów. */
GG_USERLIST_GET, /**< Import listy kontaktów. */
};
#endif /* DOXYGEN */
struct gg_userlist_request { struct gg_userlist_request {
uint8_t type; uint8_t type;
} GG_PACKED; } GG_PACKED;
#define GG_USERLIST_REPLY 0x0010 #define GG_USERLIST_REPLY 0x0010
#ifndef DOXYGEN
#define GG_USERLIST_PUT_REPLY 0x00 #define GG_USERLIST_PUT_REPLY 0x00
#define GG_USERLIST_PUT_MORE_REPLY 0x02 #define GG_USERLIST_PUT_MORE_REPLY 0x02
#define GG_USERLIST_GET_REPLY 0x06 #define GG_USERLIST_GET_REPLY 0x06
#define GG_USERLIST_GET_MORE_REPLY 0x04 #define GG_USERLIST_GET_MORE_REPLY 0x04
#else
/**
* \ingroup importexport
*
* Rodzaj odpowiedzi.
*/
enum {
GG_USERLIST_PUT_REPLY, /**< Wyeksportowano listy kontaktów. */
GG_USERLIST_GET_REPLY, /**< Zaimportowano listę kontaktów. */
};
#endif /* DOXYGEN */
struct gg_userlist_reply { struct gg_userlist_reply {
uint8_t type; uint8_t type;
} GG_PACKED; } GG_PACKED;
/*
* pakiety, sta
*/
struct gg_dcc_tiny_packet { struct gg_dcc_tiny_packet {
uint8_t type; /* rodzaj pakietu */ uint8_t type; /* rodzaj pakietu */
} GG_PACKED; } GG_PACKED;
struct gg_dcc_small_packet { struct gg_dcc_small_packet {
uint32_t type; /* rodzaj pakietu */ uint32_t type; /* rodzaj pakietu */
} GG_PACKED; } GG_PACKED;
struct gg_dcc_big_packet { struct gg_dcc_big_packet {
uint32_t type; /* rodzaj pakietu */ uint32_t type; /* rodzaj pakietu */
uint32_t dunno1; /* niewiadoma */ uint32_t dunno1; /* niewiadoma */
uint32_t dunno2; /* niewiadoma */ uint32_t dunno2; /* niewiadoma */
} GG_PACKED; } GG_PACKED;
/* /*
* p * póki co, nie znamy dokładnie protokołu. nie wiemy, co czemu odpowiada.
* nazwy s * nazwy są niepoważne i tymczasowe.
*/ */
#define GG_DCC_WANT_FILE 0x0003 /* peer chce plik */ #define GG_DCC_WANT_FILE 0x0003 /* peer chce plik */
#define GG_DCC_HAVE_FILE 0x0001 /* wi #define GG_DCC_HAVE_FILE 0x0001 /* więc mu damy */
#define GG_DCC_HAVE_FILEINFO 0x0003 /* niech ma informacje o pliku */ #define GG_DCC_HAVE_FILEINFO 0x0003 /* niech ma informacje o pliku */
#define GG_DCC_GIMME_FILE 0x0006 /* peer jest pewny */ #define GG_DCC_GIMME_FILE 0x0006 /* peer jest pewny */
#define GG_DCC_CATCH_FILE 0x0002 /* wysy #define GG_DCC_CATCH_FILE 0x0002 /* wysyłamy plik */
#define GG_DCC_FILEATTR_READONLY 0x0020 #define GG_DCC_FILEATTR_READONLY 0x0020
#define GG_DCC_TIMEOUT_SEND 1800 /* 30 minut */ #define GG_DCC_TIMEOUT_SEND 1800 /* 30 minut */
#define GG_DCC_TIMEOUT_GET 1800 /* 30 minut */ #define GG_DCC_TIMEOUT_GET 1800 /* 30 minut */
#define GG_DCC_TIMEOUT_FILE_ACK 300 /* 5 minut */ #define GG_DCC_TIMEOUT_FILE_ACK 300 /* 5 minut */
#define GG_DCC_TIMEOUT_VOICE_ACK 300 /* 5 minut */ #define GG_DCC_TIMEOUT_VOICE_ACK 300 /* 5 minut */
#define GG_DCC7_INFO 0x1f
struct gg_dcc7_info {
uint32_t uin; /* numer nadawcy */
uint32_t type; /* sposób połączenia */
gg_dcc7_id_t id; /* identyfikator połączenia */
char info[GG_DCC7_INFO_LEN]; /* informacje o połączeniu "ip port"
*/
} GG_PACKED;
#define GG_DCC7_NEW 0x20
struct gg_dcc7_new {
gg_dcc7_id_t id; /* identyfikator połączenia */
uint32_t uin_from; /* numer nadawcy */
uint32_t uin_to; /* numer odbiorcy */
uint32_t type; /* rodzaj transmisji */
unsigned char filename[GG_DCC7_FILENAME_LEN]; /* nazwa pliku */
uint32_t size; /* rozmiar pliku */
uint32_t dunno1; /* 0x00000000 */
unsigned char hash[GG_DCC7_HASH_LEN]; /* hash SHA1 */
} GG_PACKED;
#define GG_DCC7_ACCEPT 0x21
struct gg_dcc7_accept {
uint32_t uin; /* numer przyjmującego połączenie */
gg_dcc7_id_t id; /* identyfikator połączenia */
uint32_t offset; /* offset przy wznawianiu transmisji
*/
uint32_t dunno1; /* 0x00000000 */
} GG_PACKED;
// XXX API
#define GG_DCC7_TYPE_P2P 0x00000001 /**< Połączenie bezpośrednie */
#define GG_DCC7_TYPE_SERVER 0x00000002 /**< Połączenie przez serwer */
#define GG_DCC7_REJECT 0x22
struct gg_dcc7_reject {
uint32_t uin; /**< Numer odrzucającego połączenie
*/
gg_dcc7_id_t id; /**< Identyfikator połączenia */
uint32_t reason; /**< Powód rozłączenia */
} GG_PACKED;
// XXX API
#define GG_DCC7_REJECT_BUSY 0x00000001 /**< Połączenie bezpośrednie już trw
a, nie umiem obsłużyć więcej */
#define GG_DCC7_REJECT_USER 0x00000002 /**< Użytkownik odrzucił połączenie
*/
#define GG_DCC7_REJECT_VERSION 0x00000006 /**< Druga strona ma wersję
klienta nieobsługującą połączeń bezpośrednich tego typu */
#define GG_DCC7_ID_REQUEST 0x23
struct gg_dcc7_id_request {
uint32_t type; /**< Rodzaj tranmisji */
} GG_PACKED;
// XXX API
#define GG_DCC7_TYPE_VOICE 0x00000001 /**< Transmisja głosu */
#define GG_DCC7_TYPE_FILE 0x00000004 /**< transmisja pliku */
#define GG_DCC7_ID_REPLY 0x23
struct gg_dcc7_id_reply {
uint32_t type; /** Rodzaj transmisji */
gg_dcc7_id_t id; /** Przyznany identyfikator */
} GG_PACKED;
#define GG_DCC7_DUNNO1 0x24
struct gg_dcc7_dunno1 {
// XXX
} GG_PACKED;
#define GG_DCC7_TIMEOUT_CONNECT 10 /* 10 sekund */
#define GG_DCC7_TIMEOUT_SEND 1800 /* 30 minut */
#define GG_DCC7_TIMEOUT_GET 1800 /* 30 minut */
#define GG_DCC7_TIMEOUT_FILE_ACK 300 /* 5 minut */
#define GG_DCC7_TIMEOUT_VOICE_ACK 300 /* 5 minut */
#ifdef __cplusplus #ifdef __cplusplus
} }
#ifdef _WIN32 #ifdef _WIN32
#pragma pack(pop) #pragma pack(pop)
#endif #endif
#endif #endif
#endif /* __GG_LIBGADU_H */ #endif /* __GG_LIBGADU_H */
/* /*
 End of changes. 170 change blocks. 
716 lines changed or deleted 1436 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/