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

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