1 /* $Id$ */ 2 3 /* 4 * (C) Copyright 2001-2009 Wojtek Kaniewski <wojtekka@irc.pl> 5 * Robert J. Woźny <speedy@ziew.org> 6 * Arkadiusz Miśkiewicz <arekm@pld-linux.org> 7 * Tomasz Chiliński <chilek@chilan.com> 8 * Piotr Wysocki <wysek@linux.bydg.org> 9 * Dawid Jarosz <dawjar@poczta.onet.pl> 10 * Jakub Zawadzki <darkjames@darkjames.ath.cx> 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU Lesser General Public License Version 14 * 2.1 as published by the Free Software Foundation. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU Lesser General Public License for more details. 20 * 21 * You should have received a copy of the GNU Lesser General Public 22 * License along with this program; if not, write to the Free Software 23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, 24 * USA. 25 */ 26 27 /** 28 * \file libgadu.h 29 * 30 * \brief Główny plik nagłówkowy biblioteki 31 */ 32 33 #ifndef LIBGADU_LIBGADU_H 34 #define LIBGADU_LIBGADU_H 35 36 #ifdef _WIN32 37 #pragma pack(push, 1) 38 #endif 39 40 #ifdef __cplusplus 41 extern "C" { 42 #endif 43 44 #include <sys/types.h> 45 #include <stdio.h> 46 #include <stdarg.h> 47 48 /** \cond ignore */ 49 50 /* Defined if libgadu was compiled for bigendian machine. */ 51 #undef GG_CONFIG_BIGENDIAN 52 53 /* Defined if this machine has gethostbyname_r(). */ 54 #undef GG_CONFIG_HAVE_GETHOSTBYNAME_R 55 56 /* Defined if libgadu was compiled and linked with fork support. */ 57 #undef GG_CONFIG_HAVE_FORK 58 59 /* Defined if libgadu was compiled and linked with pthread support. */ 60 #undef GG_CONFIG_HAVE_PTHREAD 61 62 /* Defined if pthread resolver is the default one. */ 63 #undef GG_CONFIG_PTHREAD_DEFAULT 64 65 /* Defined if this machine has C99-compiliant vsnprintf(). */ 66 #undef GG_CONFIG_HAVE_C99_VSNPRINTF 67 68 /* Defined if this machine has va_copy(). */ 69 #undef GG_CONFIG_HAVE_VA_COPY 70 71 /* Defined if this machine has __va_copy(). */ 72 #undef GG_CONFIG_HAVE___VA_COPY 73 74 /* Defined if this machine supports long long. */ 75 #undef GG_CONFIG_HAVE_LONG_LONG 76 77 /* Defined if libgadu was compiled and linked with GnuTLS support. */ 78 #undef GG_CONFIG_HAVE_GNUTLS 79 80 /* Defined if libgadu was compiled and linked with OpenSSL support. */ 81 #undef GG_CONFIG_HAVE_OPENSSL 82 83 /* Defined if libgadu was compiled and linked with zlib support. */ 84 #undef GG_CONFIG_HAVE_ZLIB 85 86 /* Defined if uintX_t types are defined in <stdint.h>. */ 87 #undef GG_CONFIG_HAVE_STDINT_H 88 89 /* Defined if uintX_t types are defined in <inttypes.h>. */ 90 #undef GG_CONFIG_HAVE_INTTYPES_H 91 92 /* Defined if uintX_t types are defined in <sys/inttypes.h>. */ 93 #undef GG_CONFIG_HAVE_SYS_INTTYPES_H 94 95 /* Defined if uintX_t types are defined in <sys/int_types.h>. */ 96 #undef GG_CONFIG_HAVE_SYS_INT_TYPES_H 97 98 /* Defined if uintX_t types are defined in <sys/types.h>. */ 99 #undef GG_CONFIG_HAVE_SYS_TYPES_H 100 101 /* Defined if this machine has uint64_t. */ 102 #undef GG_CONFIG_HAVE_UINT64_T 103 104 /* Defined if libgadu is GPL compliant (was not linked with OpenSSL or any 105 other non-GPL compliant library support). */ 106 #undef GG_CONFIG_IS_GPL_COMPLIANT 107 108 #include "config.h" 109 110 #ifdef GG_CONFIG_HAVE_OPENSSL 111 #include <openssl/ssl.h> 112 #endif 113 114 #ifdef GG_CONFIG_HAVE_STDINT_H 115 #include <stdint.h> 116 #else 117 # ifdef GG_CONFIG_HAVE_INTTYPES_H 118 # include <inttypes.h> 119 # else 120 # ifdef GG_CONFIG_HAVE_SYS_INTTYPES_H 121 # include <sys/inttypes.h> 122 # else 123 # ifdef GG_CONFIG_HAVE_SYS_INT_TYPES_H 124 # include <sys/int_types.h> 125 # else 126 # ifdef GG_CONFIG_HAVE_SYS_TYPES_H 127 # include <sys/types.h> 128 # else 129 130 /* ISO C 9X: 7.18 Integer types <stdint.h> */ 131 132 typedef unsigned char uint8_t; 133 typedef unsigned short uint16_t; 134 typedef unsigned int uint32_t; 135 136 # endif 137 # endif 138 # endif 139 # endif 140 #endif 141 142 #ifndef GG_CONFIG_HAVE_UINT64_T 143 typedef unsigned long long uint64_t; 144 #endif 145 146 #ifdef _MSC_VER 147 #include <BaseTsd.h> 148 typedef SSIZE_T ssize_t; 149 #endif 150 151 #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)) 152 # define GG_GNUC_PRINTF(format_idx, arg_idx) \ 153 __attribute__((format (printf, (format_idx), (arg_idx)))) 154 #else 155 # define GG_GNUC_PRINTF(format_idx, arg_idx) 156 #endif 157 158 /** \endcond */ 159 160 /** 161 * Numer Gadu-Gadu. 162 */ 163 typedef uint32_t uin_t; 164 165 /** 166 * Identyfikator połączenia bezpośredniego Gadu-Gadu 7.x. 167 */ 168 typedef struct { 169 uint8_t id[8]; 170 } gg_dcc7_id_t; 171 172 /** 173 * Identyfikator sesji multilogowania. 174 */ 175 typedef struct { 176 uint8_t id[8]; 177 } gg_multilogon_id_t; 178 179 /** 180 * Makro deklarujące pola wspólne dla struktur sesji. 181 */ 182 #define gg_common_head(x) \ 183 int fd; /**< Obserwowany deskryptor */ \ 184 int check; /**< Informacja o żądaniu odczytu/zapisu (patrz \ref gg_check_t) */ \ 185 int state; /**< Aktualny stan połączenia (patrz \ref gg_state_t) */ \ 186 int error; /**< Kod błędu dla \c GG_STATE_ERROR (patrz \ref gg_error_t) */ \ 187 int type; /**< Rodzaj sesji (patrz \ref gg_session_t) */ \ 188 int id; /**< Identyfikator sesji */ \ 189 int timeout; /**< Czas pozostały do zakończenia stanu */ \ 190 int (*callback)(x*); /**< Funkcja zwrotna */ \ 191 void (*destroy)(x*); /**< Funkcja zwalniania zasobów */ 192 193 /** 194 * Struktura wspólna dla wszystkich sesji i połączeń. Pozwala na proste 195 * rzutowanie niezależne od rodzaju połączenia. 196 */ 197 struct gg_common { 198 gg_common_head(struct gg_common) 199 }; 200 201 struct gg_image_queue; 202 203 struct gg_dcc7; 204 205 struct gg_dcc7_relay; 206 207 struct gg_session_private; 208 209 /** 210 * Sposób rozwiązywania nazw serwerów. 211 */ 212 typedef enum { 213 GG_RESOLVER_DEFAULT = 0, /**< Domyślny sposób rozwiązywania nazw (jeden z poniższych) */ 214 GG_RESOLVER_FORK, /**< Rozwiązywanie nazw bazujące na procesach */ 215 GG_RESOLVER_PTHREAD, /**< Rozwiązywanie nazw bazujące na wątkach */ 216 GG_RESOLVER_CUSTOM, /**< Funkcje rozwiązywania nazw dostarczone przed aplikację */ 217 GG_RESOLVER_WIN32, /**< Rozwiązywanie nazw bazujące na wątkach Win32 */ 218 GG_RESOLVER_INVALID = -1 /**< Nieprawidłowy sposób rozwiązywania nazw (wynik \c gg_session_get_resolver) */ 219 } gg_resolver_t; 220 221 /** 222 * Rodzaj kodowania znaków. 223 */ 224 typedef enum { 225 GG_ENCODING_CP1250 = 0, /**< Kodowanie CP1250 */ 226 GG_ENCODING_UTF8, /**< Kodowanie UTF-8 */ 227 GG_ENCODING_INVALID = -1 /**< Nieprawidłowe kodowanie */ 228 } gg_encoding_t; 229 230 /** 231 * Stopień kompatybilności ze starymi wersjami API. 232 */ 233 typedef enum { 234 GG_COMPAT_LEGACY = 0, /**< Całkowita kompatybilność (nie wyłącza żadnych funkcji) */ 235 GG_COMPAT_1_12_0 = 1 /**< Wyłącza: dostarczanie eventów GG_EVENT_ACK, stary format konferencji */ 236 } gg_compat_t; 237 238 /** 239 * Flaga połączenia szyfrowanego. 240 * 241 * \ingroup login 242 */ 243 typedef enum { 244 GG_SSL_DISABLED = 0, /**< Połączenie SSL wyłączone */ 245 GG_SSL_ENABLED, /**< Połączenie SSL włączone gdy dostępne. Błędny certyfikat serwera nie powoduje odrzucenia połączenia. */ 246 GG_SSL_REQUIRED /**< Połączenie SSL wymagane. Błędny certyfikat serwera powoduje odrzucenie połączenia. */ 247 } gg_ssl_t; 248 249 /** 250 * Sesja Gadu-Gadu. 251 * 252 * Tworzona przez funkcję \c gg_login(), zwalniana przez \c gg_free_session(). 253 * 254 * \ingroup login 255 */ 256 struct gg_session { 257 gg_common_head(struct gg_session) 258 259 int async; /**< Flaga połączenia asynchronicznego */ 260 int pid; /**< Numer procesu rozwiązującego nazwę serwera */ 261 int port; /**< Port serwera */ 262 int seq; /**< Numer sekwencyjny ostatniej wiadomości */ 263 int last_pong; /**< Czas otrzymania ostatniej ramki utrzymaniowej */ 264 int last_event; /**< Czas otrzymania ostatniego pakietu */ 265 266 struct gg_event *event; /**< Zdarzenie po wywołaniu \c callback */ 267 268 uint32_t proxy_addr; /**< Adres serwera pośredniczącego */ 269 uint16_t proxy_port; /**< Port serwera pośredniczącego */ 270 271 uint32_t hub_addr; /**< Adres huba po rozwiązaniu nazwy */ 272 uint32_t server_addr; /**< Adres serwera otrzymany od huba */ 273 274 uint32_t client_addr; /**< Adres gniazda dla połączeń bezpośrednich */ 275 uint16_t client_port; /**< Port gniazda dla połączeń bezpośrednich */ 276 277 uint32_t external_addr; /**< Publiczny adres dla połączeń bezpośrednich */ 278 uint16_t external_port; /**< Publiczny port dla połączeń bezpośrednich */ 279 280 uin_t uin; /**< Własny numer Gadu-Gadu */ 281 char *password; /**< Hasło (zwalniane po użyciu) */ 282 283 int initial_status; /**< Początkowy status */ 284 int status; /**< Aktualny status */ 285 286 char *recv_buf; /**< Bufor na odbierane pakiety. Wskaźnik zawsze maksymalnie wyrównany, tak jak w wyniku działania \c malloc(). */ 287 int recv_done; /**< Liczba wczytanych bajtów pakietu */ 288 int recv_left; /**< Liczba pozostałych do wczytania bajtów pakietu */ 289 290 int protocol_version; /**< Wersja protokołu (bez flag) */ 291 char *client_version; /**< Wersja klienta */ 292 int last_sysmsg; /**< Numer ostatniej wiadomości systemowej */ 293 294 char *initial_descr; /**< Początkowy opis statusu */ 295 296 void *resolver; /**< Dane prywatne procesu lub wątku rozwiązującego nazwę serwera */ 297 298 #ifndef DOXYGEN 299 char *header_buf; /**< Bufor na początek nagłówka pakietu (nieaktualne) */ 300 unsigned int header_done; /**< Liczba wczytanych bajtów nagłówka pakietu (nieaktualne) */ 301 #endif 302 303 #ifdef GG_CONFIG_HAVE_OPENSSL 304 SSL *ssl; /**< Struktura TLS */ 305 SSL_CTX *ssl_ctx; /**< Kontekst sesji TLS */ 306 #else 307 void *ssl; /**< Struktura TLS */ 308 void *ssl_ctx; /**< Kontekst sesji TLS */ 309 #endif 310 311 int image_size; /**< Maksymalny rozmiar obsługiwanych obrazków w KiB */ 312 313 char *userlist_reply; /**< Bufor z odbieraną listą kontaktów */ 314 315 int userlist_blocks; /**< Liczba części listy kontaktów */ 316 317 struct gg_image_queue *images; /**< Lista wczytywanych obrazków */ 318 319 int hash_type; /**< Rodzaj funkcji skrótu hasła (\c GG_LOGIN_HASH_GG32 lub \c GG_LOGIN_HASH_SHA1) */ 320 321 char *send_buf; /**< Bufor z danymi do wysłania */ 322 int send_left; /**< Liczba bajtów do wysłania */ 323 324 struct gg_dcc7 *dcc7_list; /**< Lista połączeń bezpośrednich skojarzonych z sesją */ 325 326 int soft_timeout; /**< Flaga mówiąca, że po przekroczeniu \c timeout należy wywołać \c gg_watch_fd() */ 327 328 int protocol_flags; /**< Flagi protokołu */ 329 330 gg_encoding_t encoding; /**< Rodzaj kodowania znaków */ 331 332 gg_resolver_t resolver_type; /**< Sposób rozwiązywania nazw serwerów */ 333 int (*resolver_start)(int *fd, void **private_data, const char *hostname); /**< Funkcja rozpoczynająca rozwiązywanie nazwy */ 334 void (*resolver_cleanup)(void **private_data, int force); /**< Funkcja zwalniająca zasoby po rozwiązaniu nazwy */ 335 336 int protocol_features; /**< Opcje protokołu */ 337 int status_flags; /**< Flagi statusu */ 338 int recv_msg_count; /**< Liczba odebranych wiadomości */ 339 340 const char *resolver_host; /**< Nazwa do rozwiązania */ 341 struct in_addr *resolver_result; /**< Wynik rozwiązywania nazwy */ 342 unsigned int resolver_index; /**< Indeks aktualnie obsługiwanego wyniku rozwiązywania nazwy */ 343 unsigned int resolver_count; /**< Liczba wyników rozwiązywania nazwy */ 344 345 uint16_t connect_port[2]; /**< Lista portów do połączenia */ 346 unsigned int connect_index; /**< Indeks aktualnie obsługiwanego portu */ 347 348 char *connect_host; /**< Adres serwera Gadu-Gadu, z którym się łączymy */ 349 gg_ssl_t ssl_flag; /**< Flaga połączenia szyfrowanego */ 350 351 struct gg_session_private *private_data; /**< Prywatne dane sesji, nie udostępnione w API */ 352 }; 353 354 /** 355 * Połączenie HTTP. 356 * 357 * Tworzone przez \c gg_http_connect(), zwalniane przez \c gg_http_free(). 358 * 359 * \ingroup http 360 */ 361 struct gg_http { 362 gg_common_head(struct gg_http) 363 364 int async; /**< Flaga połączenia asynchronicznego */ 365 int pid; /**< Identyfikator procesu rozwiązującego nazwę serwera */ 366 int port; /**< Port */ 367 368 char *query; /**< Zapytanie HTTP */ 369 char *header; /**< Odebrany nagłówek */ 370 int header_size; /**< Rozmiar wczytanego nagłówka */ 371 char *body; /**< Odebrana strona */ 372 unsigned int body_size; /**< Rozmiar strony */ 373 374 void *data; /**< Dane prywatne usługi HTTP */ 375 376 char *user_data; /**< Dane prywatne użytkownika (nie są zwalniane) */ 377 378 void *resolver; /**< Dane prywatne procesu lub wątku rozwiązującego nazwę */ 379 380 unsigned int body_done; /**< Liczba odebranych bajtów strony */ 381 382 gg_resolver_t resolver_type; /**< Sposób rozwiązywania nazw serwerów */ 383 int (*resolver_start)(int *fd, void **private_data, const char *hostname); /**< Funkcja rozpoczynająca rozwiązywanie nazwy */ 384 void (*resolver_cleanup)(void **private_data, int force); /**< Funkcja zwalniająca zasoby po rozwiązaniu nazwy */ 385 }; 386 387 /** \cond ignore */ 388 389 #ifdef __GNUC__ 390 #define GG_PACKED __attribute__ ((packed)) 391 #ifndef GG_IGNORE_DEPRECATED 392 #define GG_DEPRECATED __attribute__ ((deprecated)) 393 #else 394 #define GG_DEPRECATED 395 #endif 396 #else 397 #define GG_PACKED 398 #define GG_DEPRECATED 399 #endif 400 401 /** \endcond */ 402 403 #define GG_MAX_PATH 276 /**< Maksymalny rozmiar nazwy pliku w strukturze \c gg_file_info */ 404 405 /** 406 * Odpowiednik struktury WIN32_FIND_DATA z API WIN32. 407 * 408 * Wykorzystywana przy połączeniach bezpośrednich do wersji Gadu-Gadu 6.x. 409 */ 410 struct gg_file_info { 411 uint32_t mode; /**< dwFileAttributes */ 412 uint32_t ctime[2]; /**< ftCreationTime */ 413 uint32_t atime[2]; /**< ftLastAccessTime */ 414 uint32_t mtime[2]; /**< ftLastWriteTime */ 415 uint32_t size_hi; /**< nFileSizeHigh */ 416 uint32_t size; /**< nFileSizeLow */ 417 uint32_t reserved0; /**< dwReserved0 */ 418 uint32_t reserved1; /**< dwReserved1 */ 419 unsigned char filename[GG_MAX_PATH - 14]; /**< cFileName */ 420 unsigned char short_filename[14]; /**< cAlternateFileName */ 421 } /** \cond ignore */ GG_PACKED /** \endcond */; 422 423 /** 424 * Połączenie bezpośrednie do wersji Gadu-Gadu 6.x. 425 * 426 * Tworzone przez \c gg_dcc_socket_create(), \c gg_dcc_get_file(), 427 * \c gg_dcc_send_file() lub \c gg_dcc_voice_chat(), zwalniane przez 428 * \c gg_dcc_free(). 429 * 430 * \ingroup dcc6 431 */ 432 struct gg_dcc { 433 gg_common_head(struct gg_dcc) 434 435 struct gg_event *event; /**< Zdarzenie po wywołaniu \c callback */ 436 437 int active; /**< Flaga połączenia aktywnego (nieużywana) */ 438 int port; /**< Port gniazda nasłuchującego */ 439 uin_t uin; /**< Własny numer Gadu-Gadu */ 440 uin_t peer_uin; /**< Numer Gadu-Gadu drugiej strony połączenia */ 441 int file_fd; /**< deskryptor pliku */ 442 unsigned int offset; /**< Położenie w pliku */ 443 unsigned int chunk_size; 444 /**< Rozmiar kawałka pliku */ 445 unsigned int chunk_offset; 446 /**< Położenie w aktualnym kawałku pliku */ 447 struct gg_file_info file_info; 448 /**< Informacje o pliku */ 449 int established; /**< Flaga ustanowienia połączenia */ 450 char *voice_buf; /**< Bufor na pakiet połączenia głosowego */ 451 int incoming; /**< Flaga połączenia przychodzącego */ 452 char *chunk_buf; /**< Bufor na fragment danych */ 453 uint32_t remote_addr; /**< Adres drugiej strony */ 454 uint16_t remote_port; /**< Port drugiej strony */ 455 }; 456 457 #define GG_DCC7_HASH_LEN 20 /**< Maksymalny rozmiar skrótu pliku w połączeniach bezpośrenich */ 458 #define GG_DCC7_FILENAME_LEN 255 /**< Maksymalny rozmiar nazwy pliku w połączeniach bezpośrednich */ 459 #define GG_DCC7_INFO_LEN 32 /**< Maksymalny rozmiar informacji o połączeniach bezpośrednich */ 460 #define GG_DCC7_INFO_HASH_LEN 32 /**< Maksymalny rozmiar skrótu ip informacji o połączeniach bezpośrednich */ 461 462 /** 463 * Połączenie bezpośrednie od wersji Gadu-Gadu 7.x. 464 * 465 * \ingroup dcc7 466 */ 467 struct gg_dcc7 { 468 gg_common_head(struct gg_dcc7) 469 470 gg_dcc7_id_t cid; /**< Identyfikator połączenia */ 471 472 struct gg_event *event; /**< Struktura zdarzenia */ 473 474 uin_t uin; /**< Własny numer Gadu-Gadu */ 475 uin_t peer_uin; /**< Numer Gadu-Gadu drugiej strony połączenia */ 476 477 int file_fd; /**< Deskryptor przesyłanego pliku */ 478 unsigned int offset; /**< Aktualne położenie w przesyłanym pliku */ 479 unsigned int size; /**< Rozmiar przesyłanego pliku */ 480 unsigned char filename[GG_DCC7_FILENAME_LEN + 1]; 481 /**< Nazwa przesyłanego pliku */ 482 unsigned char hash[GG_DCC7_HASH_LEN]; 483 /**< Skrót SHA1 przesyłanego pliku */ 484 485 int dcc_type; /**< Rodzaj połączenia bezpośredniego */ 486 int established; /**< Flaga ustanowienia połączenia */ 487 int incoming; /**< Flaga połączenia przychodzącego */ 488 int reverse; /**< Flaga połączenia zwrotnego */ 489 490 uint32_t local_addr; /**< Adres lokalny */ 491 uint16_t local_port; /**< Port lokalny */ 492 493 uint32_t remote_addr; /**< Adres drugiej strony */ 494 uint16_t remote_port; /**< Port drugiej strony */ 495 496 struct gg_session *sess; 497 /**< Sesja do której przypisano połączenie */ 498 struct gg_dcc7 *next; /**< Następne połączenie w liście */ 499 500 int soft_timeout; /**< Flaga mówiąca, że po przekroczeniu \c timeout należy wywołać \c gg_dcc7_watch_fd() */ 501 int seek; /**< Flaga mówiąca, że można zmieniać położenie w wysyłanym pliku */ 502 503 void *resolver; /**< Dane prywatne procesu lub wątku rozwiązującego nazwę serwera */ 504 505 int relay; /**< Flaga mówiąca, że laczymy sie przez serwer */ 506 int relay_index; /**< Numer serwera pośredniczącego, do którego się łączymy */ 507 int relay_count; /**< Rozmiar listy serwerów pośredniczących */ 508 struct gg_dcc7_relay *relay_list; /**< Lista serwerów pośredniczących */ 509 }; 510 511 /** 512 * Rodzaj sesji. 513 */ 514 enum gg_session_t { 515 GG_SESSION_GG = 1, /**< Połączenie z serwerem Gadu-Gadu */ 516 GG_SESSION_HTTP, /**< Połączenie HTTP */ 517 GG_SESSION_SEARCH, /**< Wyszukiwanie w katalogu publicznym (nieaktualne) */ 518 GG_SESSION_REGISTER, /**< Rejestracja nowego konta */ 519 GG_SESSION_REMIND, /**< Przypominanie hasła */ 520 GG_SESSION_PASSWD, /**< Zmiana hasła */ 521 GG_SESSION_CHANGE, /**< Zmiana informacji w katalogu publicznym (nieaktualne) */ 522 GG_SESSION_DCC, /**< Połączenie bezpośrednie (do wersji 6.x) */ 523 GG_SESSION_DCC_SOCKET, /**< Gniazdo nasłuchujące (do wersji 6.x) */ 524 GG_SESSION_DCC_SEND, /**< Wysyłanie pliku (do wersji 6.x) */ 525 GG_SESSION_DCC_GET, /**< Odbieranie pliku (do wersji 6.x) */ 526 GG_SESSION_DCC_VOICE, /**< Rozmowa głosowa (do wersji 6.x) */ 527 GG_SESSION_USERLIST_GET, /**< Import listy kontaktów z serwera (nieaktualne) */ 528 GG_SESSION_USERLIST_PUT, /**< Eksport listy kontaktów do serwera (nieaktualne) */ 529 GG_SESSION_UNREGISTER, /**< Usuwanie konta */ 530 GG_SESSION_USERLIST_REMOVE, /**< Usuwanie listy kontaktów z serwera (nieaktualne) */ 531 GG_SESSION_TOKEN, /**< Pobieranie tokenu */ 532 GG_SESSION_DCC7_SOCKET, /**< Gniazdo nasłuchujące (od wersji 7.x) */ 533 GG_SESSION_DCC7_SEND, /**< Wysyłanie pliku (od wersji 7.x) */ 534 GG_SESSION_DCC7_GET, /**< Odbieranie pliku (od wersji 7.x) */ 535 GG_SESSION_DCC7_VOICE, /**< Rozmowa głosowa (od wersji 7.x) */ 536 537 GG_SESSION_USER0 = 256, /**< Rodzaj zadeklarowany dla użytkownika */ 538 GG_SESSION_USER1, /**< Rodzaj zadeklarowany dla użytkownika */ 539 GG_SESSION_USER2, /**< Rodzaj zadeklarowany dla użytkownika */ 540 GG_SESSION_USER3, /**< Rodzaj zadeklarowany dla użytkownika */ 541 GG_SESSION_USER4, /**< Rodzaj zadeklarowany dla użytkownika */ 542 GG_SESSION_USER5, /**< Rodzaj zadeklarowany dla użytkownika */ 543 GG_SESSION_USER6, /**< Rodzaj zadeklarowany dla użytkownika */ 544 GG_SESSION_USER7 /**< Rodzaj zadeklarowany dla użytkownika */ 545 }; 546 547 /** 548 * Aktualny stan sesji. 549 */ 550 enum gg_state_t { 551 /* wspólne */ 552 GG_STATE_IDLE = 0, /**< Nie dzieje się nic */ 553 GG_STATE_RESOLVING, /**< Oczekiwanie na rozwiązanie nazwy serwera */ 554 GG_STATE_CONNECTING, /**< Oczekiwanie na połączenie */ 555 GG_STATE_READING_DATA, /**< Oczekiwanie na dane */ 556 GG_STATE_ERROR, /**< Kod błędu w polu \c error */ 557 558 /* gg_session */ 559 GG_STATE_CONNECTING_HUB, /**< Oczekiwanie na połączenie z hubem */ 560 GG_STATE_CONNECTING_GG, /**< Oczekiwanie na połączenie z serwerem */ 561 GG_STATE_READING_KEY, /**< Oczekiwanie na klucz */ 562 GG_STATE_READING_REPLY, /**< Oczekiwanie na odpowiedź serwera */ 563 GG_STATE_CONNECTED, /**< Połączono z serwerem */ 564 565 /* gg_http */ 566 GG_STATE_SENDING_QUERY, /**< Wysłano zapytanie HTTP */ 567 GG_STATE_READING_HEADER, /**< Oczekiwanie na nagłówek HTTP */ 568 GG_STATE_PARSING, /**< Przetwarzanie danych */ 569 GG_STATE_DONE, /**< Połączenie zakończone */ 570 571 /* gg_dcc */ 572 GG_STATE_LISTENING, /* czeka na połączenia */ 573 GG_STATE_READING_UIN_1, /* czeka na uin peera */ 574 GG_STATE_READING_UIN_2, /* czeka na swój uin */ 575 GG_STATE_SENDING_ACK, /* wysyła potwierdzenie dcc */ 576 GG_STATE_READING_ACK, /* czeka na potwierdzenie dcc */ 577 GG_STATE_READING_REQUEST, /* czeka na komendę */ 578 GG_STATE_SENDING_REQUEST, /* wysyła komendę */ 579 GG_STATE_SENDING_FILE_INFO, /* wysyła informacje o pliku */ 580 GG_STATE_READING_PRE_FILE_INFO, /* czeka na pakiet przed file_info */ 581 GG_STATE_READING_FILE_INFO, /* czeka na informacje o pliku */ 582 GG_STATE_SENDING_FILE_ACK, /* wysyła potwierdzenie pliku */ 583 GG_STATE_READING_FILE_ACK, /* czeka na potwierdzenie pliku */ 584 GG_STATE_SENDING_FILE_HEADER, /* wysyła nagłówek pliku */ 585 GG_STATE_READING_FILE_HEADER, /* czeka na nagłówek */ 586 GG_STATE_GETTING_FILE, /* odbiera plik */ 587 GG_STATE_SENDING_FILE, /* wysyła plik */ 588 GG_STATE_READING_VOICE_ACK, /* czeka na potwierdzenie voip */ 589 GG_STATE_READING_VOICE_HEADER, /* czeka na rodzaj bloku voip */ 590 GG_STATE_READING_VOICE_SIZE, /* czeka na rozmiar bloku voip */ 591 GG_STATE_READING_VOICE_DATA, /* czeka na dane voip */ 592 GG_STATE_SENDING_VOICE_ACK, /* wysyła potwierdzenie voip */ 593 GG_STATE_SENDING_VOICE_REQUEST, /* wysyła żądanie voip */ 594 GG_STATE_READING_TYPE, /* czeka na typ połączenia */ 595 596 /* nowe. bez sensu jest to API. */ 597 GG_STATE_TLS_NEGOTIATION, /**< Negocjacja połączenia szyfrowanego */ 598 599 GG_STATE_REQUESTING_ID, /**< Oczekiwanie na nadanie identyfikatora połączenia bezpośredniego */ 600 GG_STATE_WAITING_FOR_ACCEPT, /**< Oczekiwanie na potwierdzenie lub odrzucenie połączenia bezpośredniego */ 601 GG_STATE_WAITING_FOR_INFO, /**< Oczekiwanie na informacje o połączeniu bezpośrednim */ 602 603 GG_STATE_READING_ID, /**< Odebranie identyfikatora połączenia bezpośredniego */ 604 GG_STATE_SENDING_ID, /**< Wysłano identyfikator połączenia bezpośredniego */ 605 GG_STATE_RESOLVING_GG, /**< Oczekiwanie na rozwiązanie nazwy serwera Gadu-Gadu */ 606 607 GG_STATE_RESOLVING_RELAY, /**< Oczekiwanie na rozwiązanie nazwy serwera pośredniczącego */ 608 GG_STATE_CONNECTING_RELAY, /**< Oczekiwanie na połączenie z serwerem pośredniczącym */ 609 GG_STATE_READING_RELAY, /**< Odbieranie danych */ 610 611 GG_STATE_DISCONNECTING, /**< Oczekiwanie na potwierdzenie rozłączenia */ 612 613 GG_STATE_CONNECT_HUB, /**< Nawiązanie połączenia z hubem */ 614 GG_STATE_CONNECT_PROXY_HUB, 615 GG_STATE_CONNECT_GG, /**< Nawiązanie połączenia z serwerem */ 616 GG_STATE_CONNECT_PROXY_GG, 617 GG_STATE_CONNECTING_PROXY_HUB, 618 GG_STATE_CONNECTING_PROXY_GG, 619 GG_STATE_RESOLVE_HUB_SYNC, 620 GG_STATE_RESOLVE_HUB_ASYNC, 621 GG_STATE_RESOLVE_PROXY_HUB_SYNC, 622 GG_STATE_RESOLVE_PROXY_HUB_ASYNC, 623 GG_STATE_RESOLVE_PROXY_GG_SYNC, 624 GG_STATE_RESOLVE_PROXY_GG_ASYNC, 625 GG_STATE_RESOLVE_GG_SYNC, 626 GG_STATE_RESOLVE_GG_ASYNC, 627 GG_STATE_RESOLVING_HUB, 628 GG_STATE_RESOLVING_PROXY_HUB, 629 GG_STATE_RESOLVING_PROXY_GG, 630 GG_STATE_SEND_HUB, 631 GG_STATE_SEND_PROXY_HUB, 632 GG_STATE_SEND_PROXY_GG, 633 GG_STATE_SENDING_HUB, 634 GG_STATE_SENDING_PROXY_HUB, 635 GG_STATE_SENDING_PROXY_GG, 636 GG_STATE_READING_HUB, 637 GG_STATE_READING_PROXY_HUB, 638 GG_STATE_READING_PROXY_GG, 639 }; 640 641 /** 642 * Informacja o tym, czy biblioteka chce zapisywać i/lub czytać 643 * z deskryptora. Maska bitowa. 644 * 645 * \ingroup events 646 */ 647 enum gg_check_t { 648 GG_CHECK_NONE = 0, /**< Nie sprawdzaj niczego */ 649 GG_CHECK_WRITE = 1, /**< Sprawdź możliwość zapisu */ 650 GG_CHECK_READ = 2 /**< Sprawdź możliwość odczytu */ 651 }; 652 653 /** 654 * Metody nawiązywania połączeń TCP/TLS. 655 * 656 * \ingroup socketmanager 657 */ 658 typedef enum { 659 GG_SOCKET_MANAGER_TYPE_INTERNAL = 0, /**< Wewnętrzna obsługa gniazd (domyślne). */ 660 GG_SOCKET_MANAGER_TYPE_TCP, /**< Dostarczona przez aplikację - tylko obsługa TCP. */ 661 GG_SOCKET_MANAGER_TYPE_TLS /**< Dostarczona przez aplikację - obsługa zarówno TCP, jak i TLS. */ 662 } gg_socket_manager_type_t; 663 664 /** 665 * Funkcja dostarczona przez aplikację, tworząca nowe gniazdo TCP/TLS. 666 * 667 * Po nawiązaniu połączenia aplikacja musi wywołać gg_socket_manager_connected. 668 * Jeżeli połączenie jest asynchroniczne, wywołanie musi nastąpić po wyjściu z 669 * kontekstu tej funkcji. Dla połączeń synchronicznych z kolei, musi nastąpić 670 * jeszcze przed wyjściem z kontekstu. 671 * 672 * \param cb_data Dane prywatne aplikacji 673 * \param host Nazwa hosta 674 * \param port Numer portu 675 * \param is_tls Flaga określająca, czy ma zostać nawiązane połączenie TLS 676 * \param is_async Flaga określająca połączenie asynchroniczne (patrz szczegóły powyżej) 677 * \param priv Dane prywatne biblioteki libgadu (do przekazania do gg_socket_manager_connected) 678 * 679 * \return Uchwyt gniazda 680 * 681 * \ingroup socketmanager 682 */ 683 typedef void* (*gg_socket_manager_connect_cb_t)(void *cb_data, const char *host, int port, int is_tls, int is_async, void *priv); 684 685 /** 686 * Niszczy gniazdo i zwalnia wszystkie powiązane z nim zasoby. 687 * 688 * \param cb_data Dane prywatne aplikacji 689 * \param handle Uchwyt gniazda 690 * 691 * \ingroup socketmanager 692 */ 693 typedef void (*gg_socket_manager_close_cb_t)(void *cb_data, void *handle); 694 695 /** 696 * Odbiera z gniazda dane binarne. 697 * 698 * Funkcja powinna zajmować się obsługą TLS, jeżeli gniazdo jest w takim trybie. 699 * 700 * \param cb_data Dane prywatne aplikacji 701 * \param handle Uchwyt gniazda 702 * \param buffer Bufor do zapisu danych 703 * \param bufsize Rozmiar bufora 704 * 705 * \return Ilość zapisanych danych, lub -1 (oraz ustawiony errno) w przypadku niepowodzenia 706 * 707 * \ingroup socketmanager 708 */ 709 typedef ssize_t (*gg_socket_manager_read_cb_t)(void *cb_data, void *handle, unsigned char *buffer, size_t bufsize); 710 711 /** 712 * Wysyła przez gniazdo dane binarne. 713 * 714 * Funkcja powinna zajmować się obsługą TLS, jeżeli gniazdo jest w takim trybie. 715 * 716 * \param cb_data Dane prywatne aplikacji 717 * \param handle Uchwyt gniazda 718 * \param data Dane do wysłania 719 * \param length Rozmiar danych 720 * 721 * \return Ilość wysłanych danych, lub -1 (oraz ustawiony errno) w przypadku niepowodzenia 722 * 723 * \ingroup socketmanager 724 */ 725 typedef ssize_t (*gg_socket_manager_write_cb_t)(void *cb_data, void *handle, const unsigned char *data, size_t length); 726 727 /** 728 * Struktura opisująca funkcje zarządzające gniazdami, jeżeli aplikacja sama je 729 * obsługuje. 730 * 731 * \ingroup socketmanager 732 */ 733 typedef struct { 734 void *cb_data; /**< Dane prywatne aplikacji */ 735 gg_socket_manager_connect_cb_t connect_cb; /**< Funkcja tworząca nowe gniazdo */ 736 gg_socket_manager_close_cb_t close_cb; /**< Funkcja niszcząca gniazdo */ 737 gg_socket_manager_read_cb_t read_cb; /**< Funkcja odczytująca dane z gniazda */ 738 gg_socket_manager_write_cb_t write_cb; /**< Funkcja wysyłająca dane przez gniazdo */ 739 #ifndef DOXYGEN 740 void *reserved1; 741 void *reserved2; 742 void *reserved3; 743 void *reserved4; 744 #endif 745 } gg_socket_manager_t; 746 747 int gg_socket_manager_connected(void *handle, void *priv, int fd); 748 749 /** 750 * Parametry połączenia z serwerem Gadu-Gadu. Parametry zostały przeniesione 751 * do struktury, by uniknąć zmian API po rozszerzeniu protokołu i dodaniu 752 * kolejnych opcji połączenia. Część parametrów, które nie są już aktualne 753 * lub nie mają znaczenia, została usunięta z dokumentacji. 754 * 755 * \ingroup login 756 */ 757 struct gg_login_params { 758 uin_t uin; /**< Numer Gadu-Gadu */ 759 char *password; /**< Hasło */ 760 int async; /**< Flaga asynchronicznego połączenia (domyślnie nie) */ 761 int status; /**< Początkowy status użytkownika (domyślnie \c GG_STATUS_AVAIL) */ 762 char *status_descr; /**< Początkowy opis użytkownika (domyślnie brak) */ 763 uint32_t server_addr; /**< Adres serwera Gadu-Gadu (domyślnie pobierany automatycznie) */ 764 uint16_t server_port; /**< Port serwera Gadu-Gadu (domyślnie pobierany automatycznie) */ 765 uint32_t client_addr; /**< Adres połączeń bezpośrednich (domyślnie dobierany automatycznie) */ 766 uint16_t client_port; /**< Port połączeń bezpośrednich (domyślnie dobierany automatycznie) */ 767 int protocol_version; /**< Wersja protokołu wysyłana do serwera (domyślnie najnowsza obsługiwana) */ 768 char *client_version; /**< Wersja klienta wysyłana do serwera (domyślnie najnowsza znana) */ 769 int has_audio; /**< Flaga obsługi połączeń głosowych */ 770 int last_sysmsg; /**< Numer ostatnio odebranej wiadomości systemowej */ 771 uint32_t external_addr; /**< Adres publiczny dla połączeń bezpośrednich (domyślnie dobierany automatycznie) */ 772 uint16_t external_port; /**< Port publiczny dla połączeń bezpośrednich (domyślnie dobierany automatycznie) */ 773 int tls; /**< Flaga połączenia szyfrowanego (patrz \ref gg_ssl_t) */ 774 int image_size; /**< Maksymalny rozmiar obsługiwanych obrazków w kilobajtach */ 775 #ifndef DOXYGEN 776 int era_omnix; /**< Flaga udawania klienta Era Omnix (nieaktualna) */ 777 #endif 778 int hash_type; /**< Rodzaj skrótu hasła (\c GG_LOGIN_HASH_GG32 lub \c GG_LOGIN_HASH_SHA1, domyślnie SHA1) */ 779 gg_encoding_t encoding; /**< Rodzaj kodowania używanego w sesji (domyślnie CP1250) */ 780 gg_resolver_t resolver; /**< Sposób rozwiązywania nazw (patrz \ref build-resolver) */ 781 int protocol_features; /**< Opcje protokołu (flagi GG_FEATURE_*). */ 782 int status_flags; /**< Flagi statusu (flagi GG_STATUS_FLAG_*, patrz \ref status). */ 783 784 unsigned int struct_size; /**< Rozmiar struktury. To pole powinno być inicjowane wartością sizeof(struct gg_login_params) - w przeciwnym przypadku pola za nim nie będą obsługiwane. Pozwala na rozszerzanie struktury bez łamania ABI. */ 785 786 gg_compat_t compatibility; /**< Stopień kompatybilności ze starym API. */ 787 788 char *connect_host; /**< Nazwa hosta (oraz opcjonalnie port, podany po dwukropku) serwera Gadu-Gadu (domyślnie pobierany automatycznie) (patrz pole struct_size). */ 789 790 gg_socket_manager_type_t socket_manager_type; /**< Wybrana metoda nawiązywania połączeń TCP/TLS (domyślnie wewnętrzna) */ 791 gg_socket_manager_t socket_manager; /**< Jeżeli wybrano metodę zewnętrzną - konfiguracja jej */ 792 793 char **host_white_list; /**< Lista zakończona wskaźnikiem NULL, domen akceptowanych w odpowiedziach od huba (domyślnie wszystkie do tej pory znane). Używane tylko przy GG_SSL_REQUIRED. Pusta lista wyłącza sprawdzanie. */ 794 }; 795 796 #ifdef GG_CONFIG_IS_GPL_COMPLIANT 797 int gg_is_gpl_compliant(void); 798 #endif 799 struct gg_session *gg_login(const struct gg_login_params *p); 800 void gg_free_session(struct gg_session *sess); 801 void gg_logoff(struct gg_session *sess); 802 int gg_change_status(struct gg_session *sess, int status); 803 int gg_change_status_descr(struct gg_session *sess, int status, const char *descr); 804 int gg_change_status_descr_time(struct gg_session *sess, int status, const char *descr, int time); 805 int gg_change_status_flags(struct gg_session *sess, int flags); 806 int gg_send_message(struct gg_session *sess, int msgclass, uin_t recipient, const unsigned char *message); 807 int gg_send_message_richtext(struct gg_session *sess, int msgclass, uin_t recipient, const unsigned char *message, const unsigned char *format, int formatlen); 808 int gg_send_message_html(struct gg_session *sess, int msgclass, uin_t recipient, const unsigned char *html_message); 809 int gg_send_message_confer(struct gg_session *sess, int msgclass, int recipients_count, uin_t *recipients, const unsigned char *message); 810 int gg_send_message_confer_richtext(struct gg_session *sess, int msgclass, int recipients_count, uin_t *recipients, const unsigned char *message, const unsigned char *format, int formatlen); 811 int gg_send_message_confer_html(struct gg_session *sess, int msgclass, int recipients_count, uin_t *recipients, const unsigned char *html_message); 812 int gg_send_message_ctcp(struct gg_session *sess, int msgclass, uin_t recipient, const unsigned char *message, int message_len); 813 int gg_ping(struct gg_session *sess); 814 int gg_userlist_request(struct gg_session *sess, char type, const char *request); 815 int gg_userlist100_request(struct gg_session *sess, char type, unsigned int version, char format_type, const char *request); 816 int gg_image_request(struct gg_session *sess, uin_t recipient, int size, uint32_t crc32); 817 int gg_image_reply(struct gg_session *sess, uin_t recipient, const char *filename, const char *image, int size); 818 int gg_typing_notification(struct gg_session *sess, uin_t recipient, int length); 819 820 uint32_t gg_crc32(uint32_t crc, const unsigned char *buf, int len); 821 822 int gg_session_set_resolver(struct gg_session *gs, gg_resolver_t type); 823 gg_resolver_t gg_session_get_resolver(struct gg_session *gs); 824 int gg_session_set_custom_resolver(struct gg_session *gs, int (*resolver_start)(int*, void**, const char*), void (*resolver_cleanup)(void**, int)); 825 826 int gg_http_set_resolver(struct gg_http *gh, gg_resolver_t type); 827 gg_resolver_t gg_http_get_resolver(struct gg_http *gh); 828 int gg_http_set_custom_resolver(struct gg_http *gh, int (*resolver_start)(int*, void**, const char*), void (*resolver_cleanup)(void**, int)); 829 830 int gg_global_set_resolver(gg_resolver_t type); 831 gg_resolver_t gg_global_get_resolver(void); 832 int gg_global_set_custom_resolver(int (*resolver_start)(int*, void**, const char*), void (*resolver_cleanup)(void**, int)); 833 834 int gg_multilogon_disconnect(struct gg_session *gs, gg_multilogon_id_t conn_id); 835 836 int gg_chat_create(struct gg_session *gs); 837 int gg_chat_invite(struct gg_session *gs, uint64_t id, uin_t *participants, unsigned int participants_count); 838 int gg_chat_leave(struct gg_session *gs, uint64_t id); 839 int gg_chat_send_message(struct gg_session *gs, uint64_t id, const char *message, int is_html); 840 841 /** 842 * Rodzaj zdarzenia. 843 * 844 * \ingroup events 845 */ 846 enum gg_event_t { 847 GG_EVENT_NONE = 0, /**< Nie wydarzyło się nic wartego uwagi */ 848 GG_EVENT_MSG, /**< \brief Otrzymano wiadomość. Przekazuje również wiadomości systemowe od numeru 0. */ 849 GG_EVENT_NOTIFY, /**< \brief Informacja o statusach osób z listy kontaktów (przed 6.0). Zdarzenie należy obsługiwać, jeśli planuje się używać protokołu w wersji starszej niż domyślna. Ostatni element tablicy zawiera uin równy 0, a pozostałe pola są niezainicjowane. */ 850 GG_EVENT_NOTIFY_DESCR, /**< \brief Informacja o statusie opisowym osoby z listy kontaktów (przed 6.0). Zdarzenie należy obsługiwać, jeśli planuje się używać protokołu w wersji starszej niż domyślna. */ 851 GG_EVENT_STATUS, /**< \brief Zmiana statusu osoby z listy kontaktów (przed 6.0). Zdarzenie należy obsługiwać, jeśli planuje się używać protokołu w wersji starszej niż domyślna. */ 852 GG_EVENT_ACK, /**< Potwierdzenie doręczenia wiadomości */ 853 GG_EVENT_PONG, /**< \brief Utrzymanie połączenia. Obecnie serwer nie wysyła już do klienta ramek utrzymania połączenia, polega wyłącznie na wysyłaniu ramek przez klienta. */ 854 GG_EVENT_CONN_FAILED, /**< \brief Nie udało się połączyć */ 855 GG_EVENT_CONN_SUCCESS, /**< \brief Połączono z serwerem. Pierwszą rzeczą, jaką należy zrobić jest wysłanie listy kontaktów. */ 856 GG_EVENT_DISCONNECT, /**< \brief Serwer zrywa połączenie. Zdarza się, gdy równolegle do serwera podłączy się druga sesja i trzeba zerwać połączenie z pierwszą. */ 857 858 GG_EVENT_DCC_NEW, /**< Nowe połączenie bezpośrednie (6.x) */ 859 GG_EVENT_DCC_ERROR, /**< Błąd połączenia bezpośredniego (6.x) */ 860 GG_EVENT_DCC_DONE, /**< Zakończono połączenie bezpośrednie (6.x) */ 861 GG_EVENT_DCC_CLIENT_ACCEPT, /**< Moment akceptacji klienta w połączeniu bezpośrednim (6.x) */ 862 GG_EVENT_DCC_CALLBACK, /**< Zwrotne połączenie bezpośrednie (6.x) */ 863 GG_EVENT_DCC_NEED_FILE_INFO, /**< Należy wypełnić \c file_info dla połączenia bezpośredniego (6.x) */ 864 GG_EVENT_DCC_NEED_FILE_ACK, /**< Czeka na potwierdzenie pliku w połączeniu bezpośrednim (6.x) */ 865 GG_EVENT_DCC_NEED_VOICE_ACK, /**< Czeka na potwierdzenie rozmowy w połączeniu bezpośrednim (6.x) */ 866 GG_EVENT_DCC_VOICE_DATA, /**< Dane bezpośredniego połączenia głosowego (6.x) */ 867 868 GG_EVENT_PUBDIR50_SEARCH_REPLY, /**< Odpowiedź katalogu publicznego */ 869 GG_EVENT_PUBDIR50_READ, /**< Odczytano własne dane z katalogu publicznego */ 870 GG_EVENT_PUBDIR50_WRITE, /**< Zmieniono własne dane w katalogu publicznym */ 871 872 GG_EVENT_STATUS60, /**< Zmiana statusu osoby z listy kontaktów */ 873 GG_EVENT_NOTIFY60, /**< Informacja o statusach osób z listy kontaktów. Ostatni element tablicy zawiera uin równy 0, a pozostałe pola są niezainicjowane. */ 874 GG_EVENT_USERLIST, /**< Wynik importu lub eksportu listy kontaktów */ 875 GG_EVENT_IMAGE_REQUEST, /**< Żądanie przesłania obrazka z wiadomości */ 876 GG_EVENT_IMAGE_REPLY, /**< Przysłano obrazek z wiadomości */ 877 GG_EVENT_DCC_ACK, /**< Potwierdzenie transmisji w połączeniu bezpośrednim (6.x) */ 878 879 GG_EVENT_DCC7_NEW, /**< Nowe połączenie bezpośrednie (7.x) */ 880 GG_EVENT_DCC7_ACCEPT, /**< Zaakceptowano połączenie bezpośrednie (7.x), nowy deskryptor */ 881 GG_EVENT_DCC7_REJECT, /**< Odrzucono połączenie bezpośrednie (7.x) */ 882 GG_EVENT_DCC7_CONNECTED, /**< Zestawiono połączenie bezpośrednie (7.x), nowy deskryptor */ 883 GG_EVENT_DCC7_ERROR, /**< Błąd połączenia bezpośredniego (7.x) */ 884 GG_EVENT_DCC7_DONE, /**< Zakończono połączenie bezpośrednie (7.x) */ 885 GG_EVENT_DCC7_PENDING, /**< Trwa próba połączenia bezpośredniego (7.x), nowy deskryptor */ 886 887 GG_EVENT_XML_EVENT, /**< Otrzymano komunikat systemowy (7.7) */ 888 GG_EVENT_DISCONNECT_ACK, /**< \brief Potwierdzenie zakończenia sesji. Informuje o tym, że zmiana stanu na niedostępny z opisem dotarła do serwera i można zakończyć połączenie TCP. */ 889 GG_EVENT_TYPING_NOTIFICATION, /**< Powiadomienie o pisaniu */ 890 GG_EVENT_USER_DATA, /**< Informacja o kontaktach */ 891 GG_EVENT_MULTILOGON_MSG, /**< Wiadomość wysłana z innej sesji multilogowania */ 892 GG_EVENT_MULTILOGON_INFO, /**< Informacja o innych sesjach multilogowania */ 893 894 GG_EVENT_USERLIST100_VERSION, /**< Otrzymano numer wersji listy kontaktów na serwerze (10.0) */ 895 GG_EVENT_USERLIST100_REPLY, /**< Wynik importu lub eksportu listy kontaktów (10.0) */ 896 897 GG_EVENT_IMTOKEN, /**< Otrzymano ciąg IMTOKEN (11.0) */ 898 GG_EVENT_PONG110, /**< \brief Utrzymanie połączenia (11.0). Może służyć do synchronizacji czasu z serwerem. */ 899 GG_EVENT_JSON_EVENT, /**< Otrzymano komunikat systemowy (11.0) */ 900 GG_EVENT_ACK110, /**< Potwierdzenie wysłania wiadomości (11.0) */ 901 902 GG_EVENT_CHAT_INFO, /**< Otrzymano informację o konferencji (11.0). */ 903 GG_EVENT_CHAT_INFO_GOT_ALL, /**< \brief Informacje o wszystkich konferencjach zostały już wysłane (11.0). Otrzymywany po ostatnim pakiecie \c GG_EVENT_CHAT_INFO */ 904 GG_EVENT_CHAT_INFO_UPDATE, /**< \brief Aktualizacja informacji o konferencji (11.0). Dodanie, usunięcie jednego z uczestników. */ 905 GG_EVENT_CHAT_CREATED, /**< Potwierdzenie utworzenia konferencji (11.0) */ 906 GG_EVENT_CHAT_INVITE_ACK, /**< Potwierdzenie wysłania zaproszenia do konferencji (11.0) */ 907 }; 908 909 #define GG_EVENT_SEARCH50_REPLY GG_EVENT_PUBDIR50_SEARCH_REPLY 910 911 /** 912 * Powód nieudanego połączenia. 913 */ 914 enum gg_failure_t { 915 GG_FAILURE_RESOLVING = 1, /**< Nie znaleziono serwera */ 916 GG_FAILURE_CONNECTING, /**< Błąd połączenia */ 917 GG_FAILURE_INVALID, /**< Serwer zwrócił nieprawidłowe dane */ 918 GG_FAILURE_READING, /**< Zerwano połączenie podczas odczytu */ 919 GG_FAILURE_WRITING, /**< Zerwano połączenie podczas zapisu */ 920 GG_FAILURE_PASSWORD, /**< Nieprawidłowe hasło */ 921 GG_FAILURE_404, /**< Nieużywane */ 922 GG_FAILURE_TLS, /**< Błąd negocjacji szyfrowanego połączenia */ 923 GG_FAILURE_NEED_EMAIL, /**< Serwer rozłączył nas z prośbą o zmianę adresu e-mail */ 924 GG_FAILURE_INTRUDER, /**< Zbyt wiele prób połączenia z nieprawidłowym hasłem */ 925 GG_FAILURE_UNAVAILABLE, /**< Serwery są wyłączone */ 926 GG_FAILURE_PROXY, /**< Błąd serwera pośredniczącego */ 927 GG_FAILURE_HUB, /**< Błąd połączenia z hubem */ 928 GG_FAILURE_INTERNAL, /**< Błąd wewnętrzny */ 929 }; 930 931 /** 932 * Kod błędu danej operacji. 933 * 934 * Nie zawiera przesadnie szczegółowych informacji o powodach błędów, by nie 935 * komplikować ich obsługi. Jeśli wymagana jest większa dokładność, należy 936 * sprawdzić zawartość zmiennej systemowej \c errno. 937 */ 938 enum gg_error_t { 939 GG_ERROR_RESOLVING = 1, /**< Nie znaleziono hosta */ 940 GG_ERROR_CONNECTING, /**< Błąd połączenia */ 941 GG_ERROR_READING, /**< Błąd odczytu/odbierania */ 942 GG_ERROR_WRITING, /**< Błąd zapisu/wysyłania */ 943 944 GG_ERROR_DCC_HANDSHAKE, /**< Błąd negocjacji */ 945 GG_ERROR_DCC_FILE, /**< Błąd odczytu/zapisu pliku */ 946 GG_ERROR_DCC_EOF, /**< Przedwczesny koniec pliku */ 947 GG_ERROR_DCC_NET, /**< Błąd wysyłania/odbierania */ 948 GG_ERROR_DCC_REFUSED, /**< Połączenie odrzucone */ 949 950 GG_ERROR_DCC7_HANDSHAKE, /**< Błąd negocjacji */ 951 GG_ERROR_DCC7_FILE, /**< Błąd odczytu/zapisu pliku */ 952 GG_ERROR_DCC7_EOF, /**< Przedwczesny koniec pliku */ 953 GG_ERROR_DCC7_NET, /**< Błąd wysyłania/odbierania */ 954 GG_ERROR_DCC7_REFUSED, /**< Połączenie odrzucone */ 955 GG_ERROR_DCC7_RELAY, /**< Problem z serwerem pośredniczącym */ 956 }; 957 958 /** 959 * Pole zapytania lub odpowiedzi katalogu publicznego. 960 */ 961 struct gg_pubdir50_entry { 962 int num; /**< Numer wyniku */ 963 char *field; /**< Nazwa pola */ 964 char *value; /**< Wartość pola */ 965 } /* GG_DEPRECATED */; 966 967 /** 968 * Zapytanie lub odpowiedź katalogu publicznego. 969 * 970 * Patrz \c gg_pubdir50_t. 971 */ 972 struct gg_pubdir50_s { 973 int count; /**< Liczba wyników odpowiedzi */ 974 uin_t next; /**< Numer początkowy następnego zapytania */ 975 int type; /**< Rodzaj zapytania */ 976 uint32_t seq; /**< Numer sekwencyjny */ 977 struct gg_pubdir50_entry *entries; /**< Pola zapytania lub odpowiedzi */ 978 int entries_count; /**< Liczba pól */ 979 } /* GG_DEPRECATED */; 980 981 /** 982 * Zapytanie lub odpowiedź katalogu publicznego. 983 * 984 * Do pól nie należy się odwoływać bezpośrednio -- wszystkie niezbędne 985 * informacje są dostępne za pomocą funkcji \c gg_pubdir50_* 986 */ 987 typedef struct gg_pubdir50_s *gg_pubdir50_t; 988 989 /** 990 * Opis zdarzeń \c GG_EVENT_MSG i \c GG_EVENT_MULTILOGON_MSG. 991 */ 992 struct gg_event_msg { 993 uin_t sender; /**< Numer nadawcy/odbiorcy */ 994 int msgclass; /**< Klasa wiadomości */ 995 #ifndef _WIN32 996 time_t time; /**< Czas nadania */ 997 #else 998 uint32_t time; /**< Czas nadania */ 999 #endif 1000 unsigned char *message; /**< Treść wiadomości */ 1001 1002 int recipients_count; /**< Liczba odbiorców konferencji */ 1003 uin_t *recipients; /**< Odbiorcy konferencji */ 1004 1005 int formats_length; /**< Długość informacji o formatowaniu tekstu */ 1006 void *formats; /**< Informacje o formatowaniu tekstu */ 1007 uint32_t seq; /**< Numer sekwencyjny wiadomości */ 1008 1009 char *xhtml_message; /**< Treść wiadomości w formacie XHTML */ 1010 1011 uint64_t chat_id; /**< Identyfikator konferencji lub 0, jeżeli jest to zwykła wiadomość (11.0) */ 1012 uint64_t flags; /**< Flagi wiadomości (11.0) */ 1013 }; 1014 1015 /** 1016 * Opis zdarzenia \c GG_EVENT_NOTIFY_DESCR. 1017 */ 1018 struct gg_event_notify_descr { 1019 struct gg_notify_reply *notify; /**< Informacje o liście kontaktów */ 1020 char *descr; /**< Opis status */ 1021 }; 1022 1023 /** 1024 * Opis zdarzenia \c GG_EVENT_STATUS. 1025 */ 1026 struct gg_event_status { 1027 uin_t uin; /**< Numer Gadu-Gadu */ 1028 uint32_t status; /**< Nowy status */ 1029 char *descr; /**< Opis */ 1030 }; 1031 1032 /** 1033 * Opis zdarzenia \c GG_EVENT_STATUS60. 1034 */ 1035 struct gg_event_status60 { 1036 uin_t uin; /**< Numer Gadu-Gadu */ 1037 int status; /**< Nowy status */ 1038 uint32_t remote_ip; /**< Adres IP dla połączeń bezpośrednich */ 1039 uint16_t remote_port; /**< Port dla połączeń bezpośrednich */ 1040 int version; /**< Wersja protokołu */ 1041 int image_size; /**< Maksymalny rozmiar obsługiwanych obrazków w KiB */ 1042 char *descr; /**< Opis statusu */ 1043 #ifndef _WIN32 1044 time_t time; /**< Czas powrotu */ 1045 #else 1046 uint32_t time; /**< Czas powrotu */ 1047 #endif 1048 }; 1049 1050 /** 1051 * Opis zdarzenia \c GG_EVENT_NOTIFY_REPLY60. 1052 */ 1053 struct gg_event_notify60 { 1054 uin_t uin; /**< Numer Gadu-Gadu. W ostatnim elemencie jest równy 0, a pozostałe pola są niezainicjowane. */ 1055 int status; /**< Nowy status */ 1056 uint32_t remote_ip; /**< Adres IP dla połączeń bezpośrednich */ 1057 uint16_t remote_port; /**< Port dla połączeń bezpośrednich */ 1058 int version; /**< Wersja protokołu */ 1059 int image_size; /**< Maksymalny rozmiar obsługiwanych obrazków w KiB */ 1060 char *descr; /**< Opis statusu */ 1061 #ifndef _WIN32 1062 time_t time; /**< Czas powrotu */ 1063 #else 1064 uint32_t time; /**< Czas powrotu */ 1065 #endif 1066 }; 1067 1068 /** 1069 * Opis zdarzenia \c GG_EVENT_ACK. 1070 */ 1071 struct gg_event_ack { 1072 uin_t recipient; /**< Numer odbiorcy */ 1073 int status; /**< Status doręczenia */ 1074 int seq; /**< Numer sekwencyjny wiadomości */ 1075 }; 1076 1077 /** 1078 * Opis zdarzenia \c GG_EVENT_ACK110. 1079 */ 1080 struct gg_event_ack110 { 1081 uint8_t msg_type; /**< Rodzaj wiadomości (0x01 - zwykła, 0x02 - konferencja) */ 1082 uint32_t seq; /**< Numer sekwencyjny */ 1083 uint32_t time; /**< Czas zdarzenia */ 1084 }; 1085 1086 /** 1087 * Opis zdarzenia \c GG_EVENT_USERLIST. 1088 */ 1089 struct gg_event_userlist { 1090 char type; /**< Rodzaj odpowiedzi */ 1091 char *reply; /**< Treść odpowiedzi */ 1092 }; 1093 1094 /** 1095 * Opis zdarzenia \c GG_EVENT_DCC_VOICE_DATA. 1096 */ 1097 struct gg_event_dcc_voice_data { 1098 uint8_t *data; /**< Dane dźwiękowe */ 1099 int length; /**< Rozmiar danych dźwiękowych */ 1100 }; 1101 1102 /** 1103 * Opis zdarzenia \c GG_EVENT_IMAGE_REQUEST. 1104 */ 1105 struct gg_event_image_request { 1106 uin_t sender; /**< Nadawca żądania */ 1107 uint32_t size; /**< Rozmiar obrazka */ 1108 uint32_t crc32; /**< Suma kontrolna CRC32 */ 1109 }; 1110 1111 /** 1112 * Opis zdarzenia \c GG_EVENT_IMAGE_REPLY. 1113 */ 1114 struct gg_event_image_reply { 1115 uin_t sender; /**< Nadawca obrazka */ 1116 uint32_t size; /**< Rozmiar obrazka */ 1117 uint32_t crc32; /**< Suma kontrolna CRC32 */ 1118 char *filename; /**< Nazwa pliku */ 1119 char *image; /**< Bufor z obrazkiem */ 1120 }; 1121 1122 /** 1123 * Opis zdarzenia \c GG_EVENT_XML_EVENT. 1124 */ 1125 struct gg_event_xml_event { 1126 char *data; /**< Bufor z komunikatem */ 1127 }; 1128 1129 /** 1130 * Opis zdarzenia \c GG_EVENT_JSON_EVENT. 1131 */ 1132 struct gg_event_json_event { 1133 char *data; /**< Bufor z komunikatem */ 1134 char *type; /**< Bufor z typem komunikatu */ 1135 }; 1136 1137 /** 1138 * Opis zdarzenia \c GG_EVENT_DCC7_CONNECTED. 1139 */ 1140 struct gg_event_dcc7_connected { 1141 struct gg_dcc7 *dcc7; /**< Struktura połączenia */ 1142 }; 1143 1144 /** 1145 * Opis zdarzenia \c GG_EVENT_DCC7_PENDING. 1146 */ 1147 struct gg_event_dcc7_pending { 1148 struct gg_dcc7 *dcc7; /**< Struktura połączenia */ 1149 }; 1150 1151 /** 1152 * Opis zdarzenia \c GG_EVENT_DCC7_REJECT. 1153 */ 1154 struct gg_event_dcc7_reject { 1155 struct gg_dcc7 *dcc7; /**< Struktura połączenia */ 1156 int reason; /**< powód odrzucenia */ 1157 }; 1158 1159 /** 1160 * Opis zdarzenia \c GG_EVENT_DCC7_ACCEPT. 1161 */ 1162 struct gg_event_dcc7_accept { 1163 struct gg_dcc7 *dcc7; /**< Struktura połączenia */ 1164 int type; /**< Sposób połączenia (P2P, przez serwer) */ 1165 uint32_t remote_ip; /**< Adres zdalnego klienta */ 1166 uint16_t remote_port; /**< Port zdalnego klienta */ 1167 }; 1168 1169 /** 1170 * Opis zdarzenia \c GG_EVENT_DCC7_DONE. 1171 */ 1172 struct gg_event_dcc7_done { 1173 struct gg_dcc7 *dcc7; /**< Struktura połączenia */ 1174 }; 1175 1176 /** 1177 * Opis zdarzenia \c GG_EVENT_TYPING_NOTIFICATION. 1178 */ 1179 struct gg_event_typing_notification { 1180 uin_t uin; /**< Numer rozmówcy */ 1181 int length; /**< Długość tekstu */ 1182 }; 1183 1184 /** 1185 * Atrybut użytkownika. 1186 */ 1187 struct gg_event_user_data_attr { 1188 int type; /**< Typ atrybutu */ 1189 char *key; /**< Klucz */ 1190 char *value; /**< Wartość */ 1191 }; 1192 1193 /** 1194 * Struktura opisująca kontakt w zdarzeniu GG_EVENT_USER_DATA. 1195 */ 1196 struct gg_event_user_data_user { 1197 uin_t uin; /**< Numer kontaktu */ 1198 size_t attr_count; /**< Liczba atrybutów */ 1199 struct gg_event_user_data_attr *attrs; /**< Lista atrybutów */ 1200 }; 1201 1202 /** 1203 * Opis zdarzenia \c GG_EVENT_USER_DATA. 1204 */ 1205 struct gg_event_user_data { 1206 int type; /**< Rodzaj informacji o kontaktach */ 1207 size_t user_count; /**< Liczba kontaktów */ 1208 struct gg_event_user_data_user *users; /**< Lista kontaktów */ 1209 }; 1210 1211 /** 1212 * Struktura opisująca sesję multilogowania. 1213 */ 1214 struct gg_multilogon_session { 1215 gg_multilogon_id_t id; /**< Identyfikator sesji */ 1216 char *name; /**< Nazwa sesji (podana w \c gg_login_params.client_version) */ 1217 uint32_t remote_addr; /**< Adres sesji */ 1218 int status_flags; /**< Flagi statusu sesji */ 1219 int protocol_features; /**< Opcje protokolu sesji */ 1220 #ifndef _WIN32 1221 time_t logon_time; /**< Czas zalogowania */ 1222 #else 1223 uint32_t logon_time; /**< Czas zalogowania */ 1224 #endif 1225 }; 1226 1227 /** 1228 * Opis zdarzenia \c GG_EVENT_MULTILOGON_INFO. 1229 */ 1230 struct gg_event_multilogon_info { 1231 int count; /**< Liczba sesji */ 1232 struct gg_multilogon_session *sessions; /** Lista sesji */ 1233 }; 1234 1235 /** 1236 * Opis zdarzenia \c GG_EVENT_USERLIST100_VERSION. 1237 */ 1238 struct gg_event_userlist100_version { 1239 uint32_t version; /**< Numer wersji listy kontaktów na serwerze */ 1240 }; 1241 1242 /** 1243 * Opis zdarzenia \c GG_EVENT_USERLIST100_REPLY. 1244 */ 1245 struct gg_event_userlist100_reply { 1246 char type; /**< Rodzaj odpowiedzi */ 1247 uint32_t version; /**< Aktualna wersja listy kontaktów na serwerze */ 1248 char format_type; /**< Typ formatu listy kontaktów (żądany w \c gg_userlist100_request.format_type) */ 1249 char *reply; /**< Treść listy kontaktów w przesyłanej wersji i formacie */ 1250 }; 1251 1252 /** 1253 * Opis zdarzenia \c GG_EVENT_IMTOKEN. 1254 */ 1255 struct gg_event_imtoken { 1256 char *imtoken; /**< Wartość IMTOKEN */ 1257 }; 1258 1259 /** 1260 * Opis zdarzenia \c GG_EVENT_PONG110. 1261 */ 1262 struct gg_event_pong110 { 1263 #ifndef _WIN32 1264 time_t time; /**< Aktualny czas na serwerze */ 1265 #else 1266 uint32_t time; /**< Aktualny czas na serwerze */ 1267 #endif 1268 }; 1269 1270 /** 1271 * Opis zdarzenia \c GG_EVENT_CHAT_INFO. 1272 */ 1273 struct gg_event_chat_info { 1274 uint64_t id; /**< Identyfikator konferencji */ 1275 uint32_t version; /**< Wersja informacji o konferencji */ 1276 uint32_t participants_count; /**< Ilość uczestników */ 1277 uin_t *participants; /**< Lista uczestników */ 1278 }; 1279 1280 /** 1281 * Opis zdarzenia \c GG_EVENT_CHAT_INFO_UPDATE. 1282 */ 1283 struct gg_event_chat_info_update { 1284 uint64_t id; /**< Identyfikator konferencji */ 1285 uint32_t type; /**< Typ aktualizacji (\c GG_CHAT_INFO_UPDATE_*) */ 1286 uin_t participant; /**< Uczestnik, którego dotyczy aktualizacja */ 1287 uin_t inviter; /**< Uczestnik inicjujący aktualizację (zapraszający) */ 1288 uint32_t version; /**< Wersja informacji o konferencji */ 1289 uint32_t time; /**< Czas zdarzenia */ 1290 }; 1291 1292 /** 1293 * Opis zdarzenia \c GG_EVENT_CHAT_CREATED. 1294 */ 1295 struct gg_event_chat_created { 1296 uint64_t id; /**< Identyfikator konferencji */ 1297 uint32_t seq; /**< Numer sekwencyjny */ 1298 }; 1299 1300 /** 1301 * Opis zdarzenia \c GG_EVENT_CHAT_INVITE_ACK. 1302 */ 1303 struct gg_event_chat_invite_ack { 1304 uint64_t id; /**< Identyfikator konferencji */ 1305 uint32_t seq; /**< Numer sekwencyjny */ 1306 }; 1307 1308 /** 1309 * Unia wszystkich zdarzeń zwracanych przez funkcje \c gg_watch_fd(), 1310 * \c gg_dcc_watch_fd() i \c gg_dcc7_watch_fd(). 1311 * 1312 * \ingroup events 1313 */ 1314 union gg_event_union { 1315 enum gg_failure_t failure; /**< Błąd połączenia (\c GG_EVENT_CONN_FAILED) */ 1316 struct gg_notify_reply *notify; /**< Zmiana statusu kontaktów (\c GG_EVENT_NOTIFY) */ 1317 struct gg_event_notify_descr notify_descr; /**< Zmiana statusu kontaktów (\c GG_EVENT_NOTIFY_DESCR) */ 1318 struct gg_event_status status; /**< Zmiana statusu kontaktów (\c GG_EVENT_STATUS) */ 1319 struct gg_event_status60 status60; /**< Zmiana statusu kontaktów (\c GG_EVENT_STATUS60) */ 1320 struct gg_event_notify60 *notify60; /**< Zmiana statusu kontaktów (\c GG_EVENT_NOTIFY60) */ 1321 struct gg_event_msg msg; /**< Otrzymano wiadomość (\c GG_EVENT_MSG) */ 1322 struct gg_event_ack ack; /**< Potwierdzenie wiadomości (\c GG_EVENT_ACK) */ 1323 struct gg_event_ack110 ack110; /**< Potwierdzenie wysłania wiadomości (11.0) (\c GG_EVENT_ACK110) */ 1324 struct gg_event_image_request image_request; /**< Żądanie wysłania obrazka (\c GG_EVENT_IMAGE_REQUEST) */ 1325 struct gg_event_image_reply image_reply; /**< Odpowiedź z obrazkiem (\c GG_EVENT_IMAGE_REPLY) */ 1326 struct gg_event_userlist userlist; /**< Odpowiedź listy kontaktów (\c GG_EVENT_USERLIST) */ 1327 gg_pubdir50_t pubdir50; /**< Odpowiedź katalogu publicznego (\c GG_EVENT_PUBDIR50_*) */ 1328 struct gg_event_xml_event xml_event; /**< Zdarzenie systemowe (\c GG_EVENT_XML_EVENT) */ 1329 struct gg_event_json_event json_event; /**< Zdarzenie systemowe (\c GG_EVENT_JSON_EVENT) */ 1330 struct gg_dcc *dcc_new; /**< Nowe połączenie bezpośrednie (\c GG_EVENT_DCC_NEW) */ 1331 enum gg_error_t dcc_error; /**< Błąd połączenia bezpośredniego (\c GG_EVENT_DCC_ERROR) */ 1332 struct gg_event_dcc_voice_data dcc_voice_data; /**< Dane połączenia głosowego (\c GG_EVENT_DCC_VOICE_DATA) */ 1333 struct gg_dcc7 *dcc7_new; /**< Nowe połączenie bezpośrednie (\c GG_EVENT_DCC7_NEW) */ 1334 enum gg_error_t dcc7_error; /**< Błąd połączenia bezpośredniego (\c GG_EVENT_DCC7_ERROR) */ 1335 struct gg_event_dcc7_connected dcc7_connected; /**< Informacja o zestawieniu połączenia bezpośredniego (\c GG_EVENT_DCC7_CONNECTED) */ 1336 struct gg_event_dcc7_pending dcc7_pending; /**< Trwa próba połączenia bezpośredniego (\c GG_EVENT_DCC7_PENDING) */ 1337 struct gg_event_dcc7_reject dcc7_reject; /**< Odrzucono połączenia bezpośredniego (\c GG_EVENT_DCC7_REJECT) */ 1338 struct gg_event_dcc7_accept dcc7_accept; /**< Zaakceptowano połączenie bezpośrednie (\c GG_EVENT_DCC7_ACCEPT) */ 1339 struct gg_event_dcc7_done dcc7_done; /**< Zakończono połączenie bezpośrednie (\c GG_EVENT_DCC7_DONE) */ 1340 struct gg_event_typing_notification typing_notification; /**< Powiadomienie o pisaniu */ 1341 struct gg_event_user_data user_data; /**< Informacje o kontaktach */ 1342 struct gg_event_msg multilogon_msg; /**< Inna sesja wysłała wiadomość (\c GG_EVENT_MULTILOGON_MSG) */ 1343 struct gg_event_multilogon_info multilogon_info; /**< Informacja o innych sesjach multilogowania (\c GG_EVENT_MULTILOGON_INFO) */ 1344 struct gg_event_userlist100_version userlist100_version; /**< Informacja o numerze wersji listy kontaktów na serwerze (\c GG_EVENT_USERLIST100_VERSION) */ 1345 struct gg_event_userlist100_reply userlist100_reply; /**< Odpowiedź listy kontaktów (10.0) (\c GG_EVENT_USERLIST100_REPLY) */ 1346 struct gg_event_imtoken imtoken; /**< Ciąg IMTOKEN (11.0) (\c GG_EVENT_IMTOKEN) */ 1347 struct gg_event_pong110 pong110; /**< Utrzymanie połączenia (11.0) (\c GG_EVENT_PONG110) */ 1348 struct gg_event_chat_info chat_info; /**< Informacje o konferencji (11.0) (\c GG_EVENT_CHAT_INFO) */ 1349 struct gg_event_chat_info_update chat_info_update; /**< Aktualizacja informacji o konferencji (11.0) (\c GG_EVENT_CHAT_INFO_UPDATE) */ 1350 struct gg_event_chat_created chat_created; /**< Potwierdzenie utworzenia konferencji (11.0) (\c GG_EVENT_CHAT_CREATED) */ 1351 struct gg_event_chat_invite_ack chat_invite_ack; /**< Potwierdzenie wysłania zaproszenia do konferencji (11.0) (\c GG_EVENT_CHAT_INVITE_ACK) */ 1352 }; 1353 1354 /** 1355 * Opis zdarzenia. 1356 * 1357 * Zwracany przez funkcje \c gg_watch_fd(), \c gg_dcc_watch_fd() 1358 * i \c gg_dcc7_watch_fd(). Po przeanalizowaniu należy zwolnić 1359 * za pomocą \c gg_event_free(). 1360 * 1361 * \ingroup events 1362 */ 1363 struct gg_event { 1364 int type; /**< Rodzaj zdarzenia */ 1365 union gg_event_union event; /**< Informacja o zdarzeniu */ 1366 }; 1367 1368 struct gg_event *gg_watch_fd(struct gg_session *sess); 1369 void gg_event_free(struct gg_event *e); 1370 1371 int gg_notify_ex(struct gg_session *sess, uin_t *userlist, char *types, int count); 1372 int gg_notify(struct gg_session *sess, uin_t *userlist, int count); 1373 int gg_add_notify_ex(struct gg_session *sess, uin_t uin, char type); 1374 int gg_add_notify(struct gg_session *sess, uin_t uin); 1375 int gg_remove_notify_ex(struct gg_session *sess, uin_t uin, char type); 1376 int gg_remove_notify(struct gg_session *sess, uin_t uin); 1377 1378 struct gg_http *gg_http_connect(const char *hostname, int port, int async, const char *method, const char *path, const char *header); 1379 int gg_http_watch_fd(struct gg_http *h); 1380 void gg_http_stop(struct gg_http *h); 1381 void gg_http_free(struct gg_http *h); 1382 1383 uint32_t gg_pubdir50(struct gg_session *sess, gg_pubdir50_t req); 1384 gg_pubdir50_t gg_pubdir50_new(int type); 1385 int gg_pubdir50_add(gg_pubdir50_t req, const char *field, const char *value); 1386 int gg_pubdir50_seq_set(gg_pubdir50_t req, uint32_t seq); 1387 const char *gg_pubdir50_get(gg_pubdir50_t res, int num, const char *field); 1388 int gg_pubdir50_type(gg_pubdir50_t res); 1389 int gg_pubdir50_count(gg_pubdir50_t res); 1390 uin_t gg_pubdir50_next(gg_pubdir50_t res); 1391 uint32_t gg_pubdir50_seq(gg_pubdir50_t res); 1392 void gg_pubdir50_free(gg_pubdir50_t res); 1393 1394 #ifndef DOXYGEN 1395 1396 #define GG_PUBDIR50_UIN "FmNumber" 1397 #define GG_PUBDIR50_STATUS "FmStatus" 1398 #define GG_PUBDIR50_FIRSTNAME "firstname" 1399 #define GG_PUBDIR50_LASTNAME "lastname" 1400 #define GG_PUBDIR50_NICKNAME "nickname" 1401 #define GG_PUBDIR50_BIRTHYEAR "birthyear" 1402 #define GG_PUBDIR50_CITY "city" 1403 #define GG_PUBDIR50_GENDER "gender" 1404 #define GG_PUBDIR50_GENDER_FEMALE "1" 1405 #define GG_PUBDIR50_GENDER_MALE "2" 1406 #define GG_PUBDIR50_GENDER_SET_FEMALE "2" 1407 #define GG_PUBDIR50_GENDER_SET_MALE "1" 1408 #define GG_PUBDIR50_ACTIVE "ActiveOnly" 1409 #define GG_PUBDIR50_ACTIVE_TRUE "1" 1410 #define GG_PUBDIR50_START "fmstart" 1411 #define GG_PUBDIR50_FAMILYNAME "familyname" 1412 #define GG_PUBDIR50_FAMILYCITY "familycity" 1413 1414 #else 1415 1416 /** 1417 * \ingroup pubdir50 1418 * 1419 * Rodzaj pola zapytania. 1420 */ 1421 enum { 1422 GG_PUBDIR50_UIN, /**< Numer Gadu-Gadu */ 1423 GG_PUBDIR50_STATUS, /**< Status (tylko wynik wyszukiwania) */ 1424 GG_PUBDIR50_FIRSTNAME, /**< Imię */ 1425 GG_PUBDIR50_LASTNAME, /**< Nazwisko */ 1426 GG_PUBDIR50_NICKNAME, /**< Pseudonim */ 1427 GG_PUBDIR50_BIRTHYEAR, /**< Rok urodzenia lub przedział lat oddzielony spacją */ 1428 GG_PUBDIR50_CITY, /**< Miejscowość */ 1429 GG_PUBDIR50_GENDER, /**< Płeć */ 1430 GG_PUBDIR50_ACTIVE, /**< Osoba dostępna (tylko wyszukiwanie) */ 1431 GG_PUBDIR50_START, /**< Numer początkowy wyszukiwania (tylko wyszukiwanie) */ 1432 GG_PUBDIR50_FAMILYNAME, /**< Nazwisko rodowe (tylko wysyłanie informacji o sobie) */ 1433 GG_PUBDIR50_FAMILYCITY, /**< Miejscowość pochodzenia (tylko wysyłanie informacji o sobie) */ 1434 }; 1435 1436 /** 1437 * \ingroup pubdir50 1438 * 1439 * Wartość pola GG_PUBDIR50_GENDER przy wyszukiwaniu. Brak pola oznacza dowolną płeć. 1440 */ 1441 enum { 1442 GG_PUBDIR50_GENDER_FEMALE, /**< Kobieta */ 1443 GG_PUBDIR50_GENDER_MALE, /**< Mężczyzna */ 1444 }; 1445 1446 /** 1447 * \ingroup pubdir50 1448 * 1449 * Wartość pola GG_PUBDIR50_GENDER przy wysyłaniu informacji o sobie. 1450 */ 1451 enum { 1452 GG_PUBDIR50_GENDER_SET_FEMALE, /**< Kobieta */ 1453 GG_PUBDIR50_GENDER_SET_MALE, /**< Mężczyzna */ 1454 }; 1455 1456 /** 1457 * \ingroup pubdir50 1458 * 1459 * Wartość pola GG_PUBDIR50_ACTIVE. 1460 */ 1461 enum { 1462 GG_PUBDIR50_ACTIVE_TRUE, /**< Wyszukaj tylko osoby dostępne */ 1463 }; 1464 1465 #endif /* DOXYGEN */ 1466 1467 /** 1468 * Powód błędu operacji na katalogu publicznym. 1469 * 1470 * \ingroup http 1471 */ 1472 typedef enum { 1473 GG_PUBDIR_ERROR_NONE = 0, /**< Brak błędu */ 1474 GG_PUBDIR_ERROR_OTHER, /**< Nieznany błąd */ 1475 GG_PUBDIR_ERROR_TOKEN, /**< Błędny token */ 1476 GG_PUBDIR_ERROR_OLD_PASSWORD, /**< Niepoprawne stare hasło */ 1477 GG_PUBDIR_ERROR_NEW_PASSWORD, /**< Niepoprawne nowe hasło */ 1478 } gg_pubdir_error_t; 1479 1480 /** 1481 * Wynik operacji na katalogu publicznym. 1482 * 1483 * \ingroup http 1484 */ 1485 struct gg_pubdir { 1486 int success; /**< Flaga powodzenia operacji */ 1487 uin_t uin; /**< Otrzymany numer lub 0 w przypadku błędu */ 1488 gg_pubdir_error_t error; /**< Powód błędu */ 1489 }; 1490 1491 int gg_pubdir_watch_fd(struct gg_http *f); 1492 void gg_pubdir_free(struct gg_http *f); 1493 1494 /** 1495 * Token autoryzacji niektórych operacji HTTP. 1496 * 1497 * \ingroup token 1498 */ 1499 struct gg_token { 1500 int width; /**< Szerokość obrazka */ 1501 int height; /**< Wysokość obrazka */ 1502 int length; /**< Liczba znaków w tokenie */ 1503 char *tokenid; /**< Identyfikator tokenu */ 1504 }; 1505 1506 struct gg_http *gg_token(int async); 1507 int gg_token_watch_fd(struct gg_http *h); 1508 void gg_token_free(struct gg_http *h); 1509 1510 struct gg_http *gg_register3(const char *email, const char *password, const char *tokenid, const char *tokenval, int async); 1511 #ifndef DOXYGEN 1512 #define gg_register_watch_fd gg_pubdir_watch_fd 1513 #define gg_register_free gg_pubdir_free 1514 #endif 1515 1516 struct gg_http *gg_unregister3(uin_t uin, const char *password, const char *tokenid, const char *tokenval, int async); 1517 #ifndef DOXYGEN 1518 #define gg_unregister_watch_fd gg_pubdir_watch_fd 1519 #define gg_unregister_free gg_pubdir_free 1520 #endif 1521 1522 struct gg_http *gg_remind_passwd3(uin_t uin, const char *email, const char *tokenid, const char *tokenval, int async); 1523 #ifndef DOXYGEN 1524 #define gg_remind_passwd_watch_fd gg_pubdir_watch_fd 1525 #define gg_remind_passwd_free gg_pubdir_free 1526 #endif 1527 1528 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); 1529 #ifndef DOXYGEN 1530 #define gg_change_passwd_watch_fd gg_pubdir_watch_fd 1531 #define gg_change_passwd_free gg_pubdir_free 1532 #endif 1533 1534 extern int gg_dcc_port; 1535 extern unsigned long gg_dcc_ip; 1536 1537 int gg_dcc_request(struct gg_session *sess, uin_t uin); 1538 1539 struct gg_dcc *gg_dcc_send_file(uint32_t ip, uint16_t port, uin_t my_uin, uin_t peer_uin); 1540 struct gg_dcc *gg_dcc_get_file(uint32_t ip, uint16_t port, uin_t my_uin, uin_t peer_uin); 1541 struct gg_dcc *gg_dcc_voice_chat(uint32_t ip, uint16_t port, uin_t my_uin, uin_t peer_uin); 1542 void gg_dcc_set_type(struct gg_dcc *d, int type); 1543 int gg_dcc_fill_file_info(struct gg_dcc *d, const char *filename); 1544 int gg_dcc_fill_file_info2(struct gg_dcc *d, const char *filename, const char *local_filename); 1545 int gg_dcc_voice_send(struct gg_dcc *d, char *buf, int length); 1546 1547 #define GG_DCC_VOICE_FRAME_LENGTH 195 /**< Rozmiar pakietu głosowego przed wersją Gadu-Gadu 5.0.5 */ 1548 #define GG_DCC_VOICE_FRAME_LENGTH_505 326 /**< Rozmiar pakietu głosowego od wersji Gadu-Gadu 5.0.5 */ 1549 1550 struct gg_dcc *gg_dcc_socket_create(uin_t uin, uint16_t port); 1551 #ifndef DOXYGEN 1552 #define gg_dcc_socket_free gg_dcc_free 1553 #define gg_dcc_socket_watch_fd gg_dcc_watch_fd 1554 #endif 1555 1556 struct gg_event *gg_dcc_watch_fd(struct gg_dcc *d); 1557 1558 void gg_dcc_free(struct gg_dcc *c); 1559 1560 struct gg_event *gg_dcc7_watch_fd(struct gg_dcc7 *d); 1561 struct gg_dcc7 *gg_dcc7_send_file(struct gg_session *sess, uin_t rcpt, const char *filename, const char *filename1250, const char *hash); 1562 struct gg_dcc7 *gg_dcc7_send_file_fd(struct gg_session *sess, uin_t rcpt, int fd, size_t size, const char *filename1250, const char *hash); 1563 int gg_dcc7_accept(struct gg_dcc7 *dcc, unsigned int offset); 1564 int gg_dcc7_reject(struct gg_dcc7 *dcc, int reason); 1565 void gg_dcc7_free(struct gg_dcc7 *d); 1566 1567 extern int gg_debug_level; 1568 1569 extern void (*gg_debug_handler)(int level, const char *format, va_list ap); 1570 extern void (*gg_debug_handler_session)(struct gg_session *sess, int level, const char *format, va_list ap); 1571 1572 extern FILE *gg_debug_file; 1573 1574 /** 1575 * \ingroup debug 1576 * @{ 1577 */ 1578 #define GG_DEBUG_NET 1 /**< Rejestracja zdarzeń związanych z siecią */ 1579 #define GG_DEBUG_TRAFFIC 2 /**< Rejestracja ruchu sieciowego */ 1580 #define GG_DEBUG_DUMP 4 /**< Rejestracja zawartości pakietów */ 1581 #define GG_DEBUG_FUNCTION 8 /**< Rejestracja wywołań funkcji */ 1582 #define GG_DEBUG_MISC 16 /**< Rejestracja różnych informacji */ 1583 #define GG_DEBUG_VERBOSE 32 /**< Rejestracja informacji szczegółowych */ 1584 #define GG_DEBUG_WARNING 64 /**< Rejestracja ostrzeżeń */ 1585 #define GG_DEBUG_ERROR 128 /**< Rejestracja błędów krytycznych */ 1586 /** @} */ 1587 1588 const char *gg_debug_state(enum gg_state_t state); 1589 const char *gg_debug_event(enum gg_event_t event); 1590 1591 #ifdef GG_DEBUG_DISABLE 1592 #define gg_debug(...) do { } while (0) 1593 #define gg_debug_session(...) do { } while (0) 1594 #else 1595 void gg_debug(int level, const char *format, ...) GG_GNUC_PRINTF(2, 3); 1596 void gg_debug_session(struct gg_session *sess, int level, const char *format, ...) GG_GNUC_PRINTF(3, 4); 1597 #endif 1598 1599 const char *gg_libgadu_version(void); 1600 1601 /** 1602 * Lista funkcji biblioteki, które zależą od zewnętrznych bibliotek. 1603 * 1604 * \ingroup version 1605 */ 1606 typedef enum { 1607 GG_LIBGADU_FEATURE_SSL, /**< Biblioteka obsługuje połączenia szyfrowane */ 1608 GG_LIBGADU_FEATURE_PTHREAD, /**< Biblioteka obsługuje rozwiązywanie nazw za pomocą wątków */ 1609 GG_LIBGADU_FEATURE_USERLIST100, /**< Biblioteka obsługuje listę kontaktów zgodną z Gadu-Gadu 10 */ 1610 } gg_libgadu_feature_t; 1611 1612 int gg_libgadu_check_feature(gg_libgadu_feature_t feature); 1613 1614 extern int gg_proxy_enabled; 1615 extern char *gg_proxy_host; 1616 extern int gg_proxy_port; 1617 extern char *gg_proxy_username; 1618 extern char *gg_proxy_password; 1619 extern int gg_proxy_http_only; 1620 1621 extern unsigned long gg_local_ip; 1622 1623 #define GG_LOGIN_HASH_GG32 0x01 /**< Algorytm Gadu-Gadu */ 1624 #define GG_LOGIN_HASH_SHA1 0x02 /**< Algorytm SHA1 */ 1625 1626 #ifndef DOXYGEN 1627 1628 #define GG_PUBDIR50_WRITE 0x01 1629 #define GG_PUBDIR50_READ 0x02 1630 #define GG_PUBDIR50_SEARCH 0x03 1631 #define GG_PUBDIR50_SEARCH_REQUEST GG_PUBDIR50_SEARCH 1632 #define GG_PUBDIR50_SEARCH_REPLY 0x05 1633 1634 #else 1635 1636 /** 1637 * \ingroup pubdir50 1638 * 1639 * Rodzaj zapytania lub odpowiedzi katalogu publicznego. 1640 */ 1641 enum { 1642 GG_PUBDIR50_WRITE, /**< Wysłanie do serwera informacji o sobie */ 1643 GG_PUBDIR50_READ, /**< Pobranie z serwera informacji o sobie */ 1644 GG_PUBDIR50_SEARCH, /**< Wyszukiwanie w katalogu publicznym */ 1645 GG_PUBDIR50_SEARCH_REPLY, /**< Wynik wyszukiwania w katalogu publicznym */ 1646 }; 1647 1648 #endif /* DOXYGEN */ 1649 1650 /** \cond obsolete */ 1651 1652 #define gg_free_event gg_event_free 1653 #define gg_free_http gg_http_free 1654 #define gg_free_pubdir gg_pubdir_free 1655 #define gg_free_register gg_pubdir_free 1656 #define gg_free_remind_passwd gg_pubdir_free 1657 #define gg_free_dcc gg_dcc_free 1658 #define gg_free_change_passwd gg_pubdir_free 1659 1660 struct gg_search_request { 1661 int active; 1662 unsigned int start; 1663 char *nickname; 1664 char *first_name; 1665 char *last_name; 1666 char *city; 1667 int gender; 1668 int min_birth; 1669 int max_birth; 1670 char *email; 1671 char *phone; 1672 uin_t uin; 1673 } /* GG_DEPRECATED */; 1674 1675 struct gg_search { 1676 int count; 1677 struct gg_search_result *results; 1678 } GG_DEPRECATED; 1679 1680 struct gg_search_result { 1681 uin_t uin; 1682 char *first_name; 1683 char *last_name; 1684 char *nickname; 1685 int born; 1686 int gender; 1687 char *city; 1688 int active; 1689 } GG_DEPRECATED; 1690 1691 #define GG_GENDER_NONE 0 1692 #define GG_GENDER_FEMALE 1 1693 #define GG_GENDER_MALE 2 1694 1695 struct gg_http *gg_search(const struct gg_search_request *r, int async) GG_DEPRECATED; 1696 int gg_search_watch_fd(struct gg_http *f) GG_DEPRECATED; 1697 void gg_free_search(struct gg_http *f) GG_DEPRECATED; 1698 #define gg_search_free gg_free_search 1699 1700 const struct gg_search_request *gg_search_request_mode_0(char *nickname, char *first_name, char *last_name, char *city, int gender, int min_birth, int max_birth, int active, int start) GG_DEPRECATED; 1701 const struct gg_search_request *gg_search_request_mode_1(char *email, int active, int start) GG_DEPRECATED; 1702 const struct gg_search_request *gg_search_request_mode_2(char *phone, int active, int start) GG_DEPRECATED; 1703 const struct gg_search_request *gg_search_request_mode_3(uin_t uin, int active, int start) GG_DEPRECATED; 1704 void gg_search_request_free(struct gg_search_request *r) GG_DEPRECATED; 1705 1706 struct gg_http *gg_register(const char *email, const char *password, int async) GG_DEPRECATED; 1707 struct gg_http *gg_register2(const char *email, const char *password, const char *qa, int async) GG_DEPRECATED; 1708 1709 struct gg_http *gg_unregister(uin_t uin, const char *password, const char *email, int async) GG_DEPRECATED; 1710 struct gg_http *gg_unregister2(uin_t uin, const char *password, const char *qa, int async) GG_DEPRECATED; 1711 1712 struct gg_http *gg_remind_passwd(uin_t uin, int async) GG_DEPRECATED; 1713 struct gg_http *gg_remind_passwd2(uin_t uin, const char *tokenid, const char *tokenval, int async) GG_DEPRECATED; 1714 1715 struct gg_http *gg_change_passwd(uin_t uin, const char *passwd, const char *newpasswd, const char *newemail, int async) GG_DEPRECATED; 1716 struct gg_http *gg_change_passwd2(uin_t uin, const char *passwd, const char *newpasswd, const char *email, const char *newemail, int async) GG_DEPRECATED; 1717 struct gg_http *gg_change_passwd3(uin_t uin, const char *passwd, const char *newpasswd, const char *qa, int async) GG_DEPRECATED; 1718 1719 struct gg_change_info_request { 1720 char *first_name; 1721 char *last_name; 1722 char *nickname; 1723 char *email; 1724 int born; 1725 int gender; 1726 char *city; 1727 } /* GG_DEPRECATED */; 1728 1729 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) GG_DEPRECATED; 1730 void gg_change_info_request_free(struct gg_change_info_request *r) GG_DEPRECATED; 1731 1732 struct gg_http *gg_change_info(uin_t uin, const char *passwd, const struct gg_change_info_request *request, int async) GG_DEPRECATED; 1733 #define gg_change_pubdir_watch_fd gg_pubdir_watch_fd 1734 #define gg_change_pubdir_free gg_pubdir_free 1735 #define gg_free_change_pubdir gg_pubdir_free 1736 1737 struct gg_http *gg_userlist_get(uin_t uin, const char *password, int async) GG_DEPRECATED; 1738 int gg_userlist_get_watch_fd(struct gg_http *f) GG_DEPRECATED; 1739 void gg_userlist_get_free(struct gg_http *f) GG_DEPRECATED; 1740 1741 struct gg_http *gg_userlist_put(uin_t uin, const char *password, const char *contacts, int async) GG_DEPRECATED; 1742 int gg_userlist_put_watch_fd(struct gg_http *f) GG_DEPRECATED; 1743 void gg_userlist_put_free(struct gg_http *f) GG_DEPRECATED; 1744 1745 struct gg_http *gg_userlist_remove(uin_t uin, const char *password, int async) GG_DEPRECATED; 1746 int gg_userlist_remove_watch_fd(struct gg_http *f) GG_DEPRECATED; 1747 void gg_userlist_remove_free(struct gg_http *f) GG_DEPRECATED; 1748 1749 int gg_pubdir50_handle_reply(struct gg_event *e, const char *packet, int length) GG_DEPRECATED; 1750 1751 /** \endcond */ 1752 1753 int gg_file_hash_sha1(int fd, uint8_t *result) GG_DEPRECATED; 1754 1755 char *gg_saprintf(const char *format, ...) GG_GNUC_PRINTF(1, 2) GG_DEPRECATED; 1756 char *gg_vsaprintf(const char *format, va_list ap) GG_DEPRECATED; 1757 1758 #define gg_alloc_sprintf gg_saprintf 1759 1760 char *gg_get_line(char **ptr) GG_DEPRECATED; 1761 1762 int gg_connect(void *addr, int port, int async) GG_DEPRECATED; 1763 struct in_addr *gg_gethostbyname(const char *hostname) GG_DEPRECATED; 1764 char *gg_read_line(int sock, char *buf, int length) GG_DEPRECATED; 1765 void gg_chomp(char *line) GG_DEPRECATED; 1766 char *gg_urlencode(const char *str) GG_DEPRECATED; 1767 int gg_http_hash(const char *format, ...) GG_DEPRECATED; 1768 void gg_http_free_fields(struct gg_http *h) GG_DEPRECATED; 1769 int gg_read(struct gg_session *sess, char *buf, int length) GG_DEPRECATED; 1770 int gg_write(struct gg_session *sess, const char *buf, int length) GG_DEPRECATED; 1771 void *gg_recv_packet(struct gg_session *sess) GG_DEPRECATED; 1772 int gg_send_packet(struct gg_session *sess, int type, ...) GG_DEPRECATED; 1773 unsigned int gg_login_hash(const unsigned char *password, unsigned int seed) GG_DEPRECATED; 1774 void gg_login_hash_sha1(const char *password, uint32_t seed, uint8_t *result) GG_DEPRECATED; 1775 uint32_t gg_fix32(uint32_t x); 1776 uint16_t gg_fix16(uint16_t x); 1777 #define fix16 gg_fix16 1778 #define fix32 gg_fix32 1779 char *gg_proxy_auth(void) GG_DEPRECATED; 1780 char *gg_base64_encode(const char *buf) GG_DEPRECATED; 1781 char *gg_base64_decode(const char *buf) GG_DEPRECATED; 1782 int gg_image_queue_remove(struct gg_session *s, struct gg_image_queue *q, int freeq) GG_DEPRECATED; 1783 1784 /** 1785 * Kolejka odbieranych obrazków. 1786 */ 1787 struct gg_image_queue { 1788 uin_t sender; /**< Nadawca obrazka */ 1789 uint32_t size; /**< Rozmiar obrazka */ 1790 uint32_t crc32; /**< Suma kontrolna CRC32 */ 1791 char *filename; /**< Nazwa pliku */ 1792 char *image; /**< Bufor z odebranymi danymi */ 1793 uint32_t done; /**< Rozmiar odebranych danych */ 1794 1795 struct gg_image_queue *next; /**< Kolejny element listy */ 1796 1797 uint32_t packet_type; /**< \brief Rodzaj odbieranych pakietów. W niektórych przypadkach (przy multilogowaniu) serwer wysyła nam dwie kopie obrazka jako dwa różne typy pakietów */ 1798 } GG_DEPRECATED; 1799 1800 int gg_dcc7_handle_id(struct gg_session *sess, struct gg_event *e, const void *payload, int len) GG_DEPRECATED; 1801 int gg_dcc7_handle_new(struct gg_session *sess, struct gg_event *e, const void *payload, int len) GG_DEPRECATED; 1802 int gg_dcc7_handle_info(struct gg_session *sess, struct gg_event *e, const void *payload, int len) GG_DEPRECATED; 1803 int gg_dcc7_handle_accept(struct gg_session *sess, struct gg_event *e, const void *payload, int len) GG_DEPRECATED; 1804 int gg_dcc7_handle_reject(struct gg_session *sess, struct gg_event *e, const void *payload, int len) GG_DEPRECATED; 1805 1806 #define GG_APPMSG_HOST "appmsg.gadu-gadu.pl" 1807 #define GG_APPMSG_PORT 80 1808 #define GG_PUBDIR_HOST "pubdir.gadu-gadu.pl" 1809 #define GG_PUBDIR_PORT 80 1810 #define GG_REGISTER_HOST "register.gadu-gadu.pl" 1811 #define GG_REGISTER_PORT 80 1812 #define GG_REMIND_HOST "retr.gadu-gadu.pl" 1813 #define GG_REMIND_PORT 80 1814 #define GG_RELAY_HOST "relay.gadu-gadu.pl" 1815 #define GG_RELAY_PORT 80 1816 1817 #define GG_DEFAULT_PORT 8074 1818 #define GG_HTTPS_PORT 443 1819 #define GG_HTTP_USERAGENT "Mozilla/4.7 [en] (Win98; I)" 1820 1821 #define GG_PROTOCOL_VERSION_100 0x2e 1822 #define GG_PROTOCOL_VERSION_110 0x40 1823 1824 /* GG_DEPRECATED */ 1825 #define GG_DEFAULT_CLIENT_VERSION "-" 1826 1827 #define GG_DEFAULT_PROTOCOL_VERSION GG_PROTOCOL_VERSION_110 1828 #define GG_DEFAULT_TIMEOUT 30 1829 #define GG_HAS_AUDIO_MASK 0x40000000 1830 #define GG_HAS_AUDIO7_MASK 0x20000000 1831 #define GG_ERA_OMNIX_MASK 0x04000000 1832 #undef GG_LIBGADU_VERSION 1833 1834 #ifndef DOXYGEN 1835 1836 #define GG_FEATURE_MSG77 0x0001 1837 #define GG_FEATURE_STATUS77 0x0002 1838 #define GG_FEATURE_UNKNOWN_4 0x0004 1839 #define GG_FEATURE_UNKNOWN_8 0x0008 1840 #define GG_FEATURE_DND_FFC 0x0010 1841 #define GG_FEATURE_IMAGE_DESCR 0x0020 1842 #define GG_FEATURE_UNKNOWN_40 0x0040 1843 #define GG_FEATURE_UNKNOWN_80 0x0080 1844 #define GG_FEATURE_UNKNOWN_100 0x0100 1845 #define GG_FEATURE_USER_DATA 0x0200 1846 #define GG_FEATURE_MSG_ACK 0x0400 1847 #define GG_FEATURE_UNKNOWN_800 0x0800 1848 #define GG_FEATURE_UNKNOWN_1000 0x1000 1849 #define GG_FEATURE_TYPING_NOTIFICATION 0x2000 1850 #define GG_FEATURE_MULTILOGON 0x4000 1851 1852 /* Poniższe makra zostały zachowane dla zgodności API */ 1853 #define GG_FEATURE_MSG80 0 1854 #define GG_FEATURE_STATUS80 0 1855 #define GG_FEATURE_STATUS80BETA 0 1856 1857 #define GG_FEATURE_ALL (GG_FEATURE_MSG80 | GG_FEATURE_STATUS80 | GG_FEATURE_DND_FFC | GG_FEATURE_IMAGE_DESCR | GG_FEATURE_UNKNOWN_100 | GG_FEATURE_USER_DATA | GG_FEATURE_MSG_ACK | GG_FEATURE_TYPING_NOTIFICATION) 1858 1859 #else 1860 1861 /** 1862 * \ingroup login 1863 * 1864 * Flagi opcji protokołu. 1865 */ 1866 enum { 1867 GG_FEATURE_MSG77, /**< Klient życzy sobie otrzymywać wiadomości zgodnie z protokołem 7.7 */ 1868 GG_FEATURE_STATUS77, /**< Klient życzy sobie otrzymywać zmiany stanu zgodnie z protokołem 7.7 */ 1869 GG_FEATURE_DND_FFC, /**< Klient obsługuje statusy "nie przeszkadzać" i "poGGadaj ze mną" */ 1870 GG_FEATURE_IMAGE_DESCR, /**< Klient obsługuje opisy graficzne oraz flagę \c GG_STATUS80_DESCR_MASK */ 1871 }; 1872 1873 1874 #endif 1875 1876 #define GG_DEFAULT_DCC_PORT 1550 1877 1878 struct gg_header { 1879 uint32_t type; /* typ pakietu */ 1880 uint32_t length; /* długość reszty pakietu */ 1881 } GG_PACKED; 1882 1883 #define GG_WELCOME 0x0001 1884 #define GG_NEED_EMAIL 0x0014 1885 1886 struct gg_welcome { 1887 uint32_t key; /* klucz szyfrowania hasła */ 1888 } GG_PACKED; 1889 1890 #define GG_LOGIN 0x000c 1891 1892 struct gg_login { 1893 uint32_t uin; /* mój numerek */ 1894 uint32_t hash; /* hash hasła */ 1895 uint32_t status; /* status na dzień dobry */ 1896 uint32_t version; /* moja wersja klienta */ 1897 uint32_t local_ip; /* mój adres ip */ 1898 uint16_t local_port; /* port, na którym słucham */ 1899 } GG_PACKED; 1900 1901 #define GG_LOGIN_EXT 0x0013 1902 1903 struct gg_login_ext { 1904 uint32_t uin; /* mój numerek */ 1905 uint32_t hash; /* hash hasła */ 1906 uint32_t status; /* status na dzień dobry */ 1907 uint32_t version; /* moja wersja klienta */ 1908 uint32_t local_ip; /* mój adres ip */ 1909 uint16_t local_port; /* port, na którym słucham */ 1910 uint32_t external_ip; /* zewnętrzny adres ip */ 1911 uint16_t external_port; /* zewnętrzny port */ 1912 } GG_PACKED; 1913 1914 #define GG_LOGIN60 0x0015 1915 1916 struct gg_login60 { 1917 uint32_t uin; /* mój numerek */ 1918 uint32_t hash; /* hash hasła */ 1919 uint32_t status; /* status na dzień dobry */ 1920 uint32_t version; /* moja wersja klienta */ 1921 uint8_t dunno1; /* 0x00 */ 1922 uint32_t local_ip; /* mój adres ip */ 1923 uint16_t local_port; /* port, na którym słucham */ 1924 uint32_t external_ip; /* zewnętrzny adres ip */ 1925 uint16_t external_port; /* zewnętrzny port */ 1926 uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */ 1927 uint8_t dunno2; /* 0xbe */ 1928 } GG_PACKED; 1929 1930 #define GG_LOGIN70 0x0019 1931 1932 struct gg_login70 { 1933 uint32_t uin; /* mój numerek */ 1934 uint8_t hash_type; /* rodzaj hashowania hasła */ 1935 uint8_t hash[64]; /* hash hasła dopełniony zerami */ 1936 uint32_t status; /* status na dzień dobry */ 1937 uint32_t version; /* moja wersja klienta */ 1938 uint8_t dunno1; /* 0x00 */ 1939 uint32_t local_ip; /* mój adres ip */ 1940 uint16_t local_port; /* port, na którym słucham */ 1941 uint32_t external_ip; /* zewnętrzny adres ip (???) */ 1942 uint16_t external_port; /* zewnętrzny port (???) */ 1943 uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */ 1944 uint8_t dunno2; /* 0xbe */ 1945 } GG_PACKED; 1946 1947 #define GG_LOGIN_OK 0x0003 1948 1949 #define GG_LOGIN_FAILED 0x0009 1950 1951 #define GG_PUBDIR50_REQUEST 0x0014 1952 1953 struct gg_pubdir50_request { 1954 uint8_t type; /* GG_PUBDIR50_* */ 1955 uint32_t seq; /* czas wysłania zapytania */ 1956 } GG_PACKED; 1957 1958 #define GG_PUBDIR50_REPLY 0x000e 1959 1960 struct gg_pubdir50_reply { 1961 uint8_t type; /* GG_PUBDIR50_* */ 1962 uint32_t seq; /* czas wysłania zapytania */ 1963 } GG_PACKED; 1964 1965 #define GG_NEW_STATUS 0x0002 1966 1967 #ifndef DOXYGEN 1968 1969 #define GG_STATUS_NOT_AVAIL 0x0001 1970 #define GG_STATUS_NOT_AVAIL_DESCR 0x0015 1971 #define GG_STATUS_FFC 0x0017 1972 #define GG_STATUS_FFC_DESCR 0x0018 1973 #define GG_STATUS_AVAIL 0x0002 1974 #define GG_STATUS_AVAIL_DESCR 0x0004 1975 #define GG_STATUS_BUSY 0x0003 1976 #define GG_STATUS_BUSY_DESCR 0x0005 1977 #define GG_STATUS_DND 0x0021 1978 #define GG_STATUS_DND_DESCR 0x0022 1979 #define GG_STATUS_INVISIBLE 0x0014 1980 #define GG_STATUS_INVISIBLE_DESCR 0x0016 1981 #define GG_STATUS_BLOCKED 0x0006 1982 1983 #define GG_STATUS_GGPLUS 0x0020 1984 #define GG_STATUS_NOT_SET 0x0023 1985 #define GG_STATUS_UNKNOWN 0x0025 1986 1987 #define GG_STATUS_IMAGE_MASK 0x0100 1988 #define GG_STATUS_DESCR_MASK 0x4000 1989 #define GG_STATUS_FRIENDS_MASK 0x8000 1990 1991 #define GG_STATUS_FLAG_UNKNOWN 0x00000001 1992 #define GG_STATUS_FLAG_VIDEO 0x00000002 1993 #define GG_STATUS_FLAG_INHERIT 0x00000020 1994 #define GG_STATUS_FLAG_MOBILE 0x00100000 1995 #define GG_STATUS_FLAG_SPAM 0x00800000 1996 1997 #else 1998 1999 /** 2000 * Rodzaje statusów użytkownika. 2001 * 2002 * \ingroup status 2003 */ 2004 enum { 2005 GG_STATUS_NOT_AVAIL, /**< Niedostępny */ 2006 GG_STATUS_NOT_AVAIL_DESCR, /**< Niedostępny z opisem */ 2007 GG_STATUS_FFC, /**< PoGGadaj ze mną */ 2008 GG_STATUS_FFC_DESCR, /**< PoGGadaj ze mną z opisem */ 2009 GG_STATUS_AVAIL, /**< Dostępny */ 2010 GG_STATUS_AVAIL_DESCR, /**< Dostępny z opisem */ 2011 GG_STATUS_BUSY, /**< Zajęty */ 2012 GG_STATUS_BUSY_DESCR, /**< Zajęty z opisem */ 2013 GG_STATUS_DND, /**< Nie przeszkadzać */ 2014 GG_STATUS_DND_DESCR, /**< Nie przeszakdzać z opisem */ 2015 GG_STATUS_INVISIBLE, /**< Niewidoczny (tylko własny status) */ 2016 GG_STATUS_INVISIBLE_DESCR, /**< Niewidoczny z opisem (tylko własny status) */ 2017 GG_STATUS_BLOCKED, /**< Zablokowany (tylko status innych) */ 2018 GG_STATUS_GGPLUS, /**< Status "Korzystam z GG Plus" */ 2019 GG_STATUS_NOT_SET, /**< Status nie ustawiony (przy logowaniu się do sieci) */ 2020 GG_STATUS_IMAGE_MASK, /**< Flaga bitowa oznaczająca opis graficzny (tylko jeśli wybrano \c GG_FEATURE_IMAGE_DESCR) */ 2021 GG_STATUS_DESCR_MASK, /**< Flaga bitowa oznaczająca status z opisem (tylko jeśli wybrano \c GG_FEATURE_IMAGE_DESCR) */ 2022 GG_STATUS_FRIENDS_MASK, /**< Flaga bitowa dostępności tylko dla znajomych */ 2023 }; 2024 2025 /** 2026 * Rodzaje statusów użytkownika. Mapa bitowa. 2027 * 2028 * \ingroup status 2029 */ 2030 enum { 2031 GG_STATUS_FLAG_UNKNOWN, /**< Przeznaczenie nieznane, ale występuje zawsze */ 2032 GG_STATUS_FLAG_VIDEO, /**< Klient obsługuje wideorozmowy */ 2033 GG_STATUS_FLAG_INHERIT, /**< Synchronizacja statusu do innych klientów (przy logowaniu się do sieci) */ 2034 GG_STATUS_FLAG_MOBILE, /**< Klient mobilny (ikona telefonu komórkowego) */ 2035 GG_STATUS_FLAG_SPAM, /**< Klient chce otrzymywać linki od nieznajomych */ 2036 }; 2037 2038 #endif /* DOXYGEN */ 2039 2040 /** 2041 * \ingroup status 2042 * 2043 * Flaga bitowa dostepnosci informujaca ze mozemy voipowac 2044 */ 2045 2046 #define GG_STATUS_VOICE_MASK 0x20000 /**< czy ma wlaczone audio (7.7) */ 2047 2048 /** 2049 * \ingroup status 2050 * 2051 * Maksymalna długośc opisu. 2052 */ 2053 #define GG_STATUS_DESCR_MAXSIZE 255 2054 #define GG_STATUS_DESCR_MAXSIZE_PRE_8_0 70 2055 2056 #define GG_STATUS_MASK 0xff 2057 2058 /* GG_S_F() tryb tylko dla znajomych */ 2059 #define GG_S_F(x) (((x) & GG_STATUS_FRIENDS_MASK) != 0) 2060 2061 /* GG_S() stan bez uwzględnienia dodatkowych flag */ 2062 #define GG_S(x) ((x) & GG_STATUS_MASK) 2063 2064 2065 /* GG_S_FF() chętny do rozmowy */ 2066 #define GG_S_FF(x) (GG_S(x) == GG_STATUS_FFC || GG_S(x) == GG_STATUS_FFC_DESCR) 2067 2068 /* GG_S_AV() dostępny */ 2069 #define GG_S_AV(x) (GG_S(x) == GG_STATUS_AVAIL || GG_S(x) == GG_STATUS_AVAIL_DESCR) 2070 2071 /* GG_S_AW() zaraz wracam */ 2072 #define GG_S_AW(x) (GG_S(x) == GG_STATUS_BUSY || GG_S(x) == GG_STATUS_BUSY_DESCR) 2073 2074 /* GG_S_DD() nie przeszkadzać */ 2075 #define GG_S_DD(x) (GG_S(x) == GG_STATUS_DND || GG_S(x) == GG_STATUS_DND_DESCR) 2076 2077 /* GG_S_NA() niedostępny */ 2078 #define GG_S_NA(x) (GG_S(x) == GG_STATUS_NOT_AVAIL || GG_S(x) == GG_STATUS_NOT_AVAIL_DESCR) 2079 2080 /* GG_S_I() niewidoczny */ 2081 #define GG_S_I(x) (GG_S(x) == GG_STATUS_INVISIBLE || GG_S(x) == GG_STATUS_INVISIBLE_DESCR) 2082 2083 2084 /* GG_S_A() dostępny lub chętny do rozmowy */ 2085 #define GG_S_A(x) (GG_S_FF(x) || GG_S_AV(x)) 2086 2087 /* GG_S_B() zajęty lub nie przeszkadzać */ 2088 #define GG_S_B(x) (GG_S_AW(x) || GG_S_DD(x)) 2089 2090 2091 /* GG_S_D() stan opisowy */ 2092 #define GG_S_D(x) (GG_S(x) == GG_STATUS_NOT_AVAIL_DESCR || \ 2093 GG_S(x) == GG_STATUS_FFC_DESCR || \ 2094 GG_S(x) == GG_STATUS_AVAIL_DESCR || \ 2095 GG_S(x) == GG_STATUS_BUSY_DESCR || \ 2096 GG_S(x) == GG_STATUS_DND_DESCR || \ 2097 GG_S(x) == GG_STATUS_INVISIBLE_DESCR) 2098 2099 /* GG_S_BL() blokowany lub blokujący */ 2100 #define GG_S_BL(x) (GG_S(x) == GG_STATUS_BLOCKED) 2101 2102 /** 2103 * Zmiana statusu (pakiet \c GG_NEW_STATUS i \c GG_NEW_STATUS80BETA) 2104 */ 2105 struct gg_new_status { 2106 uint32_t status; /**< Nowy status */ 2107 } GG_PACKED; 2108 2109 #define GG_NOTIFY_FIRST 0x000f 2110 #define GG_NOTIFY_LAST 0x0010 2111 2112 #define GG_NOTIFY 0x0010 2113 2114 struct gg_notify { 2115 uint32_t uin; /* numerek danej osoby */ 2116 uint8_t dunno1; /* rodzaj wpisu w liście */ 2117 } GG_PACKED; 2118 2119 #ifndef DOXYGEN 2120 2121 #define GG_USER_OFFLINE 0x01 2122 #define GG_USER_NORMAL 0x03 2123 #define GG_USER_BLOCKED 0x04 2124 2125 #else 2126 2127 /** 2128 * \ingroup contacts 2129 * 2130 * Rodzaj kontaktu. 2131 */ 2132 enum { 2133 GG_USER_NORMAL, /**< Zwykły kontakt */ 2134 GG_USER_BLOCKED, /**< Zablokowany */ 2135 GG_USER_OFFLINE, /**< Niewidoczny dla kontaktu */ 2136 }; 2137 2138 #endif /* DOXYGEN */ 2139 2140 #define GG_LIST_EMPTY 0x0012 2141 2142 #define GG_NOTIFY_REPLY 0x000c /* tak, to samo co GG_LOGIN */ 2143 2144 struct gg_notify_reply { 2145 uint32_t uin; /* numerek */ 2146 uint32_t status; /* status danej osoby */ 2147 uint32_t remote_ip; /* adres ip delikwenta */ 2148 uint16_t remote_port; /* port, na którym słucha klient */ 2149 uint32_t version; /* wersja klienta */ 2150 uint16_t dunno2; /* znowu port? */ 2151 } GG_PACKED; 2152 2153 #define GG_NOTIFY_REPLY60 0x0011 2154 2155 struct gg_notify_reply60 { 2156 uint32_t uin; /* numerek plus flagi w MSB */ 2157 uint8_t status; /* status danej osoby */ 2158 uint32_t remote_ip; /* adres ip delikwenta */ 2159 uint16_t remote_port; /* port, na którym słucha klient */ 2160 uint8_t version; /* wersja klienta */ 2161 uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */ 2162 uint8_t dunno1; /* 0x00 */ 2163 } GG_PACKED; 2164 2165 #define GG_STATUS60 0x000f 2166 2167 struct gg_status60 { 2168 uint32_t uin; /* numerek plus flagi w MSB */ 2169 uint8_t status; /* status danej osoby */ 2170 uint32_t remote_ip; /* adres ip delikwenta */ 2171 uint16_t remote_port; /* port, na którym słucha klient */ 2172 uint8_t version; /* wersja klienta */ 2173 uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */ 2174 uint8_t dunno1; /* 0x00 */ 2175 } GG_PACKED; 2176 2177 #define GG_NOTIFY_REPLY77 0x0018 2178 2179 struct gg_notify_reply77 { 2180 uint32_t uin; /* numerek plus flagi w MSB */ 2181 uint8_t status; /* status danej osoby */ 2182 uint32_t remote_ip; /* adres ip delikwenta */ 2183 uint16_t remote_port; /* port, na którym słucha klient */ 2184 uint8_t version; /* wersja klienta */ 2185 uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */ 2186 uint8_t dunno1; /* 0x00 */ 2187 uint32_t dunno2; /* ? */ 2188 } GG_PACKED; 2189 2190 #define GG_STATUS77 0x0017 2191 2192 struct gg_status77 { 2193 uint32_t uin; /* numerek plus flagi w MSB */ 2194 uint8_t status; /* status danej osoby */ 2195 uint32_t remote_ip; /* adres ip delikwenta */ 2196 uint16_t remote_port; /* port, na którym słucha klient */ 2197 uint8_t version; /* wersja klienta */ 2198 uint8_t image_size; /* maksymalny rozmiar grafiki w KiB */ 2199 uint8_t dunno1; /* 0x00 */ 2200 uint32_t dunno2; /* ? */ 2201 } GG_PACKED; 2202 2203 #define GG_ADD_NOTIFY 0x000d 2204 #define GG_REMOVE_NOTIFY 0x000e 2205 2206 struct gg_add_remove { 2207 uint32_t uin; /* numerek */ 2208 uint8_t dunno1; /* bitmapa */ 2209 } GG_PACKED; 2210 2211 #define GG_STATUS 0x0002 2212 2213 struct gg_status { 2214 uint32_t uin; /* numerek */ 2215 uint32_t status; /* nowy stan */ 2216 } GG_PACKED; 2217 2218 #define GG_SEND_MSG 0x000b 2219 2220 #ifndef DOXYGEN 2221 2222 #define GG_CLASS_QUEUED 0x0001 2223 #define GG_CLASS_OFFLINE GG_CLASS_QUEUED 2224 #define GG_CLASS_MSG 0x0004 2225 #define GG_CLASS_CHAT 0x0008 2226 #define GG_CLASS_CTCP 0x0010 2227 #define GG_CLASS_ACK 0x0020 2228 #define GG_CLASS_EXT GG_CLASS_ACK /**< Dla kompatybilności wstecz */ 2229 2230 #else 2231 2232 /** 2233 * Klasy wiadomości. Wartości są maskami bitowymi, które w większości 2234 * przypadków można łączyć (połączenie \c GG_CLASS_MSG i \c GG_CLASS_CHAT 2235 * nie ma sensu). 2236 * 2237 * \ingroup messages 2238 */ 2239 enum { 2240 GG_CLASS_MSG, /**< Wiadomość ma pojawić się w osobnym oknie */ 2241 GG_CLASS_CHAT, /**< Wiadomość ma pojawić się w oknie rozmowy */ 2242 GG_CLASS_CTCP, /**< Wiadomość przeznaczona dla klienta Gadu-Gadu */ 2243 GG_CLASS_ACK, /**< Klient nie życzy sobie potwierdzenia */ 2244 GG_CLASS_QUEUED, /**< Wiadomość zakolejkowana na serwerze (tylko przy odbieraniu) */ 2245 }; 2246 2247 #endif /* DOXYGEN */ 2248 2249 /** 2250 * Maksymalna długość wiadomości. 2251 * 2252 * \ingroup messages 2253 */ 2254 #define GG_MSG_MAXSIZE 1989 2255 2256 struct gg_send_msg { 2257 uint32_t recipient; 2258 uint32_t seq; 2259 uint32_t msgclass; 2260 } GG_PACKED; 2261 2262 struct gg_msg_richtext { 2263 uint8_t flag; 2264 uint16_t length; 2265 } GG_PACKED; 2266 2267 /** 2268 * Struktura opisująca formatowanie tekstu. W zależności od wartości pola 2269 * \c font, zaraz za tą strukturą może wystąpić \c gg_msg_richtext_color 2270 * lub \c gg_msg_richtext_image. 2271 * 2272 * \ingroup messages 2273 */ 2274 struct gg_msg_richtext_format { 2275 uint16_t position; /**< Początkowy znak formatowania (liczony od 0) */ 2276 uint8_t font; /**< Atrybuty formatowania */ 2277 } GG_PACKED; 2278 2279 #ifndef DOXYGEN 2280 2281 #define GG_FONT_BOLD 0x01 2282 #define GG_FONT_ITALIC 0x02 2283 #define GG_FONT_UNDERLINE 0x04 2284 #define GG_FONT_COLOR 0x08 2285 #define GG_FONT_IMAGE 0x80 2286 2287 #else 2288 2289 /** 2290 * Atrybuty formatowania wiadomości. 2291 * 2292 * \ingroup messages 2293 */ 2294 enum { 2295 GG_FONT_BOLD, 2296 GG_FONT_ITALIC, 2297 GG_FONT_UNDERLINE, 2298 GG_FONT_COLOR, 2299 GG_FONT_IMAGE 2300 }; 2301 2302 #endif /* DOXYGEN */ 2303 2304 /** 2305 * Struktura opisującą kolor tekstu dla atrybutu \c GG_FONT_COLOR. 2306 * 2307 * \ingroup messages 2308 */ 2309 struct gg_msg_richtext_color { 2310 uint8_t red; /**< Składowa czerwona koloru */ 2311 uint8_t green; /**< Składowa zielona koloru */ 2312 uint8_t blue; /**< Składowa niebieska koloru */ 2313 } GG_PACKED; 2314 2315 /** 2316 * Strukturya opisująca obrazek wstawiony do wiadomości dla atrubutu 2317 * \c GG_FONT_IMAGE. 2318 * 2319 * \ingroup messages 2320 */ 2321 struct gg_msg_richtext_image { 2322 uint16_t unknown1; /**< Nieznane pole o wartości 0x0109 */ 2323 uint32_t size; /**< Rozmiar obrazka */ 2324 uint32_t crc32; /**< Suma kontrolna CRC32 obrazka */ 2325 } GG_PACKED; 2326 2327 struct gg_msg_recipients { 2328 uint8_t flag; 2329 uint32_t count; 2330 } GG_PACKED; 2331 2332 struct gg_msg_image_request { 2333 uint8_t flag; 2334 uint32_t size; 2335 uint32_t crc32; 2336 } GG_PACKED; 2337 2338 struct gg_msg_image_reply { 2339 uint8_t flag; 2340 uint32_t size; 2341 uint32_t crc32; 2342 /* char filename[]; */ 2343 /* char image[]; */ 2344 } GG_PACKED; 2345 2346 #define GG_SEND_MSG_ACK 0x0005 2347 2348 #ifndef DOXYGEN 2349 2350 #define GG_ACK_BLOCKED 0x0001 2351 #define GG_ACK_DELIVERED 0x0002 2352 #define GG_ACK_QUEUED 0x0003 2353 #define GG_ACK_MBOXFULL 0x0004 2354 #define GG_ACK_NOT_DELIVERED 0x0006 2355 2356 #else 2357 2358 /** 2359 * Status doręczenia wiadomości. 2360 * 2361 * \ingroup messages 2362 */ 2363 enum 2364 { 2365 GG_ACK_DELIVERED, /**< Wiadomość dostarczono. */ 2366 GG_ACK_QUEUED, /**< Wiadomość zakolejkowano z powodu niedostępności odbiorcy. */ 2367 GG_ACK_BLOCKED, /**< Wiadomość zablokowana przez serwer (spam, świąteczne ograniczenia itd.) */ 2368 GG_ACK_MBOXFULL, /**< Wiadomości nie dostarczono z powodu zapełnionej kolejki wiadomości odbiorcy. */ 2369 GG_ACK_NOT_DELIVERED /**< Wiadomości nie dostarczono (tylko dla \c GG_CLASS_CTCP). */ 2370 }; 2371 2372 #endif /* DOXYGEN */ 2373 2374 struct gg_send_msg_ack { 2375 uint32_t status; 2376 uint32_t recipient; 2377 uint32_t seq; 2378 } GG_PACKED; 2379 2380 #define GG_RECV_MSG 0x000a 2381 2382 struct gg_recv_msg { 2383 uint32_t sender; 2384 uint32_t seq; 2385 uint32_t time; 2386 uint32_t msgclass; 2387 } GG_PACKED; 2388 2389 #define GG_PING 0x0008 2390 2391 #define GG_PONG 0x0007 2392 2393 #define GG_DISCONNECTING 0x000b 2394 2395 #define GG_USERLIST_REQUEST 0x0016 2396 2397 #define GG_XML_EVENT 0x0027 2398 2399 #ifndef DOXYGEN 2400 2401 #define GG_USERLIST_PUT 0x00 2402 #define GG_USERLIST_PUT_MORE 0x01 2403 #define GG_USERLIST_GET 0x02 2404 2405 #else 2406 2407 /** 2408 * \ingroup importexport 2409 * 2410 * Rodzaj zapytania. 2411 */ 2412 enum { 2413 GG_USERLIST_PUT, /**< Eksport listy kontaktów. */ 2414 GG_USERLIST_GET, /**< Import listy kontaktów. */ 2415 }; 2416 2417 #endif /* DOXYGEN */ 2418 2419 struct gg_userlist_request { 2420 uint8_t type; 2421 } GG_PACKED; 2422 2423 #define GG_USERLIST_REPLY 0x0010 2424 2425 #ifndef DOXYGEN 2426 2427 #define GG_USERLIST_PUT_REPLY 0x00 2428 #define GG_USERLIST_PUT_MORE_REPLY 0x02 2429 #define GG_USERLIST_GET_REPLY 0x06 2430 #define GG_USERLIST_GET_MORE_REPLY 0x04 2431 2432 #else 2433 2434 /** 2435 * \ingroup importexport 2436 * 2437 * Rodzaj odpowiedzi. 2438 */ 2439 enum { 2440 GG_USERLIST_PUT_REPLY, /**< Wyeksportowano listy kontaktów. */ 2441 GG_USERLIST_GET_REPLY, /**< Zaimportowano listę kontaktów. */ 2442 }; 2443 2444 #endif /* DOXYGEN */ 2445 2446 struct gg_userlist_reply { 2447 uint8_t type; 2448 } GG_PACKED; 2449 2450 #ifndef DOXYGEN 2451 2452 #define GG_USERLIST100_PUT 0x00 2453 #define GG_USERLIST100_GET 0x02 2454 2455 #else 2456 2457 /** 2458 * \ingroup importexport 2459 * 2460 * Rodzaj zapytania (10.0). 2461 */ 2462 enum { 2463 GG_USERLIST100_PUT, /**< Eksport listy kontaktów. */ 2464 GG_USERLIST100_GET, /**< Import listy kontaktów. */ 2465 }; 2466 2467 #endif /* DOXYGEN */ 2468 2469 #ifndef DOXYGEN 2470 2471 #define GG_USERLIST100_FORMAT_TYPE_NONE 0x00 2472 #define GG_USERLIST100_FORMAT_TYPE_GG70 0x01 2473 #define GG_USERLIST100_FORMAT_TYPE_GG100 0x02 2474 2475 #else 2476 2477 /** 2478 * \ingroup importexport 2479 * 2480 * Typ formatu listy kontaktów (10.0). 2481 */ 2482 enum { 2483 GG_USERLIST100_FORMAT_TYPE_NONE, /**< Brak treści listy kontaktów. */ 2484 GG_USERLIST100_FORMAT_TYPE_GG70, /**< Format listy kontaktów zgodny z Gadu-Gadu 7.0. */ 2485 GG_USERLIST100_FORMAT_TYPE_GG100, /**< Format listy kontaktów zgodny z Gadu-Gadu 10.0. */ 2486 }; 2487 2488 #endif /* DOXYGEN */ 2489 2490 #ifndef DOXYGEN 2491 2492 #define GG_USERLIST100_REPLY_LIST 0x00 2493 #define GG_USERLIST100_REPLY_UPTODATE 0x01 2494 #define GG_USERLIST100_REPLY_ACK 0x10 2495 #define GG_USERLIST100_REPLY_REJECT 0x12 2496 2497 #else 2498 2499 /** 2500 * \ingroup importexport 2501 * 2502 * Typ odpowiedzi listy kontaktów (10.0). 2503 */ 2504 enum { 2505 GG_USERLIST100_REPLY_LIST, /**< W odpowiedzi znajduje się aktualna lista kontaktów na serwerze. */ 2506 GG_USERLIST100_REPLY_UPTODATE, /**< Komunikat o tym, że lista kontaktów jest już zsynchronizowana. */ 2507 GG_USERLIST100_REPLY_ACK, /**< Potwierdzenie odebrania nowej wersji listy kontaktów. W polu \c gg_userlist100_reply.version znajduje się numer nowej wersji listy kontaktów. */ 2508 GG_USERLIST100_REPLY_REJECT, /**< Odmowa przyjęcia nowej wersji listy kontaktów. W polu \c gg_userlist100_reply.version znajduje się numer wersji listy kontaktów aktualnie przechowywanej przez serwer. */ 2509 }; 2510 2511 #endif /* DOXYGEN */ 2512 2513 struct gg_dcc_tiny_packet { 2514 uint8_t type; /* rodzaj pakietu */ 2515 } GG_PACKED; 2516 2517 struct gg_dcc_small_packet { 2518 uint32_t type; /* rodzaj pakietu */ 2519 } GG_PACKED; 2520 2521 struct gg_dcc_big_packet { 2522 uint32_t type; /* rodzaj pakietu */ 2523 uint32_t dunno1; /* niewiadoma */ 2524 uint32_t dunno2; /* niewiadoma */ 2525 } GG_PACKED; 2526 2527 /* 2528 * póki co, nie znamy dokładnie protokołu. nie wiemy, co czemu odpowiada. 2529 * nazwy są niepoważne i tymczasowe. 2530 */ 2531 #define GG_DCC_WANT_FILE 0x0003 /* peer chce plik */ 2532 #define GG_DCC_HAVE_FILE 0x0001 /* więc mu damy */ 2533 #define GG_DCC_HAVE_FILEINFO 0x0003 /* niech ma informacje o pliku */ 2534 #define GG_DCC_GIMME_FILE 0x0006 /* peer jest pewny */ 2535 #define GG_DCC_CATCH_FILE 0x0002 /* wysyłamy plik */ 2536 2537 #define GG_DCC_FILEATTR_READONLY 0x0020 2538 2539 #define GG_DCC_TIMEOUT_SEND 1800 /* 30 minut */ 2540 #define GG_DCC_TIMEOUT_GET 1800 /* 30 minut */ 2541 #define GG_DCC_TIMEOUT_FILE_ACK 300 /* 5 minut */ 2542 #define GG_DCC_TIMEOUT_VOICE_ACK 300 /* 5 minut */ 2543 2544 #define GG_DCC7_INFO 0x1f 2545 2546 struct gg_dcc7_info { 2547 uint32_t uin; /* numer nadawcy */ 2548 uint32_t type; /* sposób połączenia */ 2549 gg_dcc7_id_t id; /* identyfikator połączenia */ 2550 char info[GG_DCC7_INFO_LEN]; /* informacje o połączeniu "ip port" */ 2551 char hash[GG_DCC7_INFO_HASH_LEN];/* skrót "ip" */ 2552 } GG_PACKED; 2553 2554 #define GG_DCC7_NEW 0x20 2555 2556 struct gg_dcc7_new { 2557 gg_dcc7_id_t id; /* identyfikator połączenia */ 2558 uint32_t uin_from; /* numer nadawcy */ 2559 uint32_t uin_to; /* numer odbiorcy */ 2560 uint32_t type; /* rodzaj transmisji */ 2561 unsigned char filename[GG_DCC7_FILENAME_LEN]; /* nazwa pliku */ 2562 uint32_t size; /* rozmiar pliku */ 2563 uint32_t size_hi; /* rozmiar pliku (starsze bajty) */ 2564 unsigned char hash[GG_DCC7_HASH_LEN]; /* hash SHA1 */ 2565 } GG_PACKED; 2566 2567 #define GG_DCC7_ACCEPT 0x21 2568 2569 struct gg_dcc7_accept { 2570 uint32_t uin; /* numer przyjmującego połączenie */ 2571 gg_dcc7_id_t id; /* identyfikator połączenia */ 2572 uint32_t offset; /* offset przy wznawianiu transmisji */ 2573 uint32_t dunno1; /* 0x00000000 */ 2574 } GG_PACKED; 2575 2576 /* XXX API */ 2577 #define GG_DCC7_TYPE_P2P 0x00000001 /**< Połączenie bezpośrednie */ 2578 #define GG_DCC7_TYPE_SERVER 0x00000002 /**< Połączenie przez serwer */ 2579 2580 #define GG_DCC7_REJECT 0x22 2581 2582 struct gg_dcc7_reject { 2583 uint32_t uin; /**< Numer odrzucającego połączenie */ 2584 gg_dcc7_id_t id; /**< Identyfikator połączenia */ 2585 uint32_t reason; /**< Powód rozłączenia */ 2586 } GG_PACKED; 2587 2588 /* XXX API */ 2589 #define GG_DCC7_REJECT_BUSY 0x00000001 /**< Połączenie bezpośrednie już trwa, nie umiem obsłużyć więcej */ 2590 #define GG_DCC7_REJECT_USER 0x00000002 /**< Użytkownik odrzucił połączenie */ 2591 #define GG_DCC7_REJECT_VERSION 0x00000006 /**< Druga strona ma wersję klienta nieobsługującą połączeń bezpośrednich tego typu */ 2592 2593 #define GG_DCC7_ID_REQUEST 0x23 2594 2595 struct gg_dcc7_id_request { 2596 uint32_t type; /**< Rodzaj tranmisji */ 2597 } GG_PACKED; 2598 2599 /* XXX API */ 2600 #define GG_DCC7_TYPE_VOICE 0x00000001 /**< Transmisja głosu */ 2601 #define GG_DCC7_TYPE_FILE 0x00000004 /**< transmisja pliku */ 2602 2603 #define GG_DCC7_ID_REPLY 0x23 2604 2605 struct gg_dcc7_id_reply { 2606 uint32_t type; /** Rodzaj transmisji */ 2607 gg_dcc7_id_t id; /** Przyznany identyfikator */ 2608 } GG_PACKED; 2609 2610 #define GG_DCC7_DUNNO1 0x24 2611 2612 #define GG_DCC7_TIMEOUT_CONNECT 10 /* 10 sekund */ 2613 #define GG_DCC7_TIMEOUT_SEND 1800 /* 30 minut */ 2614 #define GG_DCC7_TIMEOUT_GET 1800 /* 30 minut */ 2615 #define GG_DCC7_TIMEOUT_FILE_ACK 300 /* 5 minut */ 2616 #define GG_DCC7_TIMEOUT_VOICE_ACK 300 /* 5 minut */ 2617 2618 #define GG_CHAT_INFO_UPDATE_ENTERED 0x01 2619 #define GG_CHAT_INFO_UPDATE_EXITED 0x03 2620 2621 #ifdef __cplusplus 2622 } 2623 #endif 2624 2625 #ifdef _WIN32 2626 #pragma pack(pop) 2627 #endif 2628 2629 #endif /* LIBGADU_LIBGADU_H */ 2630 2631 /* 2632 * Local variables: 2633 * c-indentation-style: k&r 2634 * c-basic-offset: 8 2635 * indent-tabs-mode: notnil 2636 * End: 2637 * 2638 * vim: shiftwidth=8: 2639 */ 2640