void GaduProtocol::disconnectedCleanup()
{
Protocol::disconnectedCleanup();
if (PingTimer)
{
PingTimer->stop();
delete PingTimer;
PingTimer = 0;
}
if (SocketNotifiers)
{
SocketNotifiers->watchFor(0); // stop watching
SocketNotifiers->deleteLater();
SocketNotifiers = 0;
}
if (GaduSession)
{
gg_free_session(GaduSession);
GaduSession = 0;
}
CurrentMultilogonService->removeAllSessions();
}
void
gnomegadu_gadugadu_disconnect ()
{
GtkComboBox *combobox = GTK_COMBO_BOX (glade_xml_get_widget (gladexml, "StatusComboBox"));
if (gnomegadu_gadugadu_session)
{
gg_logoff (gnomegadu_gadugadu_session);
gg_free_session (gnomegadu_gadugadu_session);
}
gnomegadu_gadugadu_session = NULL;
gnomegadu_protocol_is_connected = FALSE;
if (gnomegadu_watch_protocol)
g_source_remove (gnomegadu_watch_protocol);
if (gnomegadu_source_chan)
g_io_channel_unref (gnomegadu_source_chan);
g_object_set_data (G_OBJECT (combobox), "dont_change_status", (gpointer) TRUE);
gtk_combo_box_set_active (combobox, 3);
g_object_set_data (G_OBJECT (combobox), "dont_change_status", (gpointer) FALSE);
gnomegadu_userlist_cleanup_model_status ();
}
/* destroys Session object */
static int session_destroy(Session *s){
GList *it;
g_message(L_("Deleting session for '%s'"),s->jid);
if (s->ping_timeout_func) g_source_remove(s->ping_timeout_func);
if (s->timeout_func) g_source_remove(s->timeout_func);
if (s->ping_timer) g_timer_destroy(s->ping_timer);
session_remove_g_source(s);
while(s->resources) resource_remove((Resource *)s->resources->data,0);
if (s->ggs){
if (s->connected){
debug("gg_logoff(%p)",s->ggs);
gg_logoff(s->ggs);
}
gg_free_session(s->ggs);
s->ggs=NULL;
}
if (s->connected && s->s && s->jid){
for(it=g_list_first(s->user->contacts);it;it=g_list_next(it)){
Contact *c=(Contact *)it->data;
if (!GG_S_NA(c->status) && c->status!=-1){
char *ujid;
ujid=jid_build_full(c->uin);
presence_send(s->s,ujid,s->user->jid,0,NULL,NULL,0);
g_free(ujid);
}
}
}
if (s->query) xmlnode_free(s->query);
if (s->user) user_unref(s->user);
g_free(s->gg_status_descr);
g_free(s);
return 0;
}
void GGWrapper::processLoginEvent(ggLoginEvent &event)
{
struct gg_login_params p;
memset(&p,0,sizeof(gg_login_params));
p.uin = event.uin;
p.password = const_cast<char *>(event.pass.c_str());
p.async = 0;
p.protocol_features = GG_FEATURE_ALL | GG_FEATURE_MSG77 | GG_FEATURE_MULTILOGON;
p.tls = GG_SSL_ENABLED;
p.encoding = GG_ENCODING_UTF8;
if((mpSession = gg_login(&p)) && gg_notify(mpSession,NULL,0) != -1)
{
mOwnerUin = p.uin;
eventSignal().emit(spEvent(new LoginResultEvent(true,event.uin)));
if ( -1 != gg_userlist100_request(mpSession,GG_USERLIST100_GET,0,GG_USERLIST100_FORMAT_TYPE_GG100,0))
{
Logger::log("Succesfully requested userlist..?");
}
}
else
{
eventSignal().emit(spEvent(new LoginResultEvent(false)));
gg_free_session(mpSession);
mpSession = 0;
}
}
void
GaduSession::destroySession()
{
if ( session_ ) {
destroyNotifiers();
gg_free_session( session_ );
session_ = 0;
}
}
static int session_try_login(Session *s){
struct gg_login_params login_params;
GgServer *serv;
g_message(N_("Trying to log in on server %u for %s"),
g_list_position(gg_servers, s->current_server), s->jid);
if (s->ping_timeout_func) g_source_remove(s->ping_timeout_func);
s->ping_timeout_func=NULL;
if (s->timeout_func) g_source_remove(s->timeout_func);
s->timeout_func=NULL;
if (s->ping_timer) g_timer_destroy(s->ping_timer);
s->ping_timer=NULL;
if (s->ggs) {
gg_free_session(s->ggs);
s->ggs=NULL;
}
session_remove_g_source(s);
memset(&login_params,0,sizeof(login_params));
login_params.uin=s->user->uin;
login_params.password=string_to_gg(s->user->password);
login_params.async=1;
login_params.last_sysmsg=s->user->last_sys_msg;
login_params.protocol_version=GG_DEFAULT_PROTOCOL_VERSION;
login_params.protocol_features=GG_FEATURE_ALL;
login_params.client_version=GG_DEFAULT_CLIENT_VERSION;
login_params.encoding = GG_ENCODING_UTF8;
login_params.status=GG_STATUS_INVISIBLE;
if(s->user->status)
login_params.status_descr=s->user->status;
serv=(GgServer*)s->current_server->data;
if(serv->port!=1){
login_params.server_addr=serv->addr.s_addr;
login_params.server_port=serv->port;
}
#ifdef __GG_LIBGADU_HAVE_OPENSSL
debug(N_("Turning TLS %s"), serv->tls?"on":"off");
login_params.tls=serv->tls;
#endif
s->ggs=gg_login(&login_params);
if (!s->ggs){
g_free(s);
return 1;
}
session_setup_g_source(s);
s->timeout_func=g_timeout_add(conn_timeout*1000,session_timeout,s);
return FALSE;
}
GGWrapper::~GGWrapper()
{
delete mpEventSignal;
mWorkerThread.interrupt();
mWorkerThread.join();
if(mpSession)
{
gg_logoff(mpSession);
gg_free_session(mpSession);
}
delete mpQueue;
}
void GaduProtocol::login()
{
// TODO: create some kind of cleanup method
if (GaduSession)
{
gg_free_session(GaduSession);
GaduSession = 0;
// here was return... do not re-add it ;)
}
if (SocketNotifiers)
{
SocketNotifiers->deleteLater();
SocketNotifiers = 0;
}
auto accountData = GaduAccountData{account()};
if (0 == accountData.uin())
{
connectionClosed();
return;
}
GaduProxyHelper::setupProxy(
account().useDefaultProxy() ? m_networkProxyManager->defaultProxy() : account().proxy());
setupLoginParams();
m_lastSentStatus = loginStatus();
GaduSession = gg_login(&GaduLoginParams);
cleanUpLoginParams();
if (!GaduSession)
{
// gadu session can be null if DNS failed, we can try IP after that
connectionError();
return;
}
SocketNotifiers = new GaduProtocolSocketNotifiers(account(), this);
SocketNotifiers->setGaduIMTokenService(CurrentImTokenService);
SocketNotifiers->setGaduUserDataService(CurrentUserDataService);
connectSocketNotifiersToServices();
SocketNotifiers->watchFor(GaduSession);
}
int main(int argc, char **argv)
{
struct gg_session *gs;
struct gg_login_params glp;
struct gg_dcc7 *gd = NULL;
time_t ping = 0, last = 0;
int once = 0;
if (argc != 2)
usage(argv[0]);
/* strtol() ? */
if (!(argv[1][0] >= '0' && argv[1][0] <= '9'))
usage(argv[0]);
if (atoi(argv[1]) >= TEST_MODE_LAST)
usage(argv[0]);
test_mode = atoi(argv[1]);
signal(SIGPIPE, SIG_IGN);
gg_debug_file = stdout;
gg_debug_level = ~0;
if (config_read() == -1 || config_peer == 0) {
perror("config");
exit(1);
}
memset(&glp, 0, sizeof(glp));
glp.uin = config_uin;
glp.password = config_password;
glp.async = 1;
glp.status = GG_STATUS_AVAIL;
#if 0
glp.client_addr = config_ip;
glp.client_port = config_port;
#endif
glp.protocol_version = 0x2a;
glp.has_audio = 1;
glp.last_sysmsg = -1;
gg_dcc_ip = config_ip;
debug("Connecting...\n");
if (!(gs = gg_login(&glp))) {
perror("gg_login");
exit(1);
}
for (;;) {
fd_set rds, wds;
struct timeval tv;
time_t now;
int res, maxfd = -1;
FD_ZERO(&rds);
FD_ZERO(&wds);
tv.tv_sec = 1;
tv.tv_usec = 0;
maxfd = gs->fd;
if ((gs->check & GG_CHECK_READ))
FD_SET(gs->fd, &rds);
if ((gs->check & GG_CHECK_WRITE))
FD_SET(gs->fd, &wds);
if (gd && gd->fd != -1) {
if (gd->fd > maxfd)
maxfd = gd->fd;
if ((gd->check & GG_CHECK_READ))
FD_SET(gd->fd, &rds);
if ((gd->check & GG_CHECK_WRITE))
FD_SET(gd->fd, &wds);
}
if (voice_fd != -1) {
FD_SET(voice_fd, &rds);
if (voice_fd > maxfd)
maxfd = voice_fd;
}
if ((res = select(maxfd + 1, &rds, &wds, NULL, &tv)) == -1) {
if (errno == EINTR)
continue;
perror("select");
exit(1);
}
now = time(NULL);
if (last != now) {
if (gs->timeout != -1 && gs->timeout-- == 0 && !gs->soft_timeout) {
debug("Timeout\n");
exit(1);
}
/* vvvv XXX */
if (gd && gd->timeout && gd->timeout != -1 && gd->timeout-- == 0 && !gd->soft_timeout) {
debug("Timeout\n");
exit(1);
}
last = now;
}
if (gs->state == GG_STATE_CONNECTED && ping && now - ping > 60) {
ping = now;
gg_ping(gs);
}
if (FD_ISSET(gs->fd, &rds) || FD_ISSET(gs->fd, &wds) || (gs->timeout == 0 && gs->soft_timeout)) {
struct gg_event *ge;
uin_t uin;
int status;
if (!(ge = gg_watch_fd(gs))) {
debug("Connection broken\n");
exit(1);
}
switch (ge->type) {
case GG_EVENT_CONN_SUCCESS:
debug("Connected\n");
connected = 1;
gg_notify(gs, &config_peer, 1);
ping = time(NULL);
break;
case GG_EVENT_CONN_FAILED:
debug("Connection failed\n");
exit(1);
case GG_EVENT_NONE:
break;
case GG_EVENT_MSG:
debug("Message from %d: %s\n", ge->event.msg.sender, ge->event.msg.message);
break;
case GG_EVENT_DISCONNECT:
debug("Forced to disconnect\n");
exit(1);
case GG_EVENT_NOTIFY60:
uin = ge->event.notify60[0].uin;
status = ge->event.notify60[0].status;
/* fall-through */
case GG_EVENT_STATUS60:
if (ge->type == GG_EVENT_STATUS60) {
uin = ge->event.status60.uin;
status = ge->event.status60.status;
}
if (!once && uin == config_peer && (GG_S_A(status) ||
GG_S_B(status)) && test_mode == TEST_MODE_SEND)
{
debug("Sending voice request...\n");
if (voice_open_ext("/dev/dsp", 8000, 16, 2, EKG_CODEC_GSM) == -1) {
printf("voice_open_ext('/dev/dsp', "
"8000, 16, 2, CODEC_GSM) failed\n");
exit(1);
}
printf("+OK\n");
gd = gg_dcc7_voice_chat(gs, config_peer, 0x00);
if (!gd) {
perror("gg_dcc7_voice_chat");
exit(1);
}
once = 1;
}
gg_change_status(gs, GG_STATUS_AVAIL); /* XXX, libgadu sobie nie radzi */
break;
case GG_EVENT_DCC7_NEW:
debug("Incoming direct connection\n");
if (test_mode == TEST_MODE_RECEIVE) {
gd = ge->event.dcc7_new;
if (voice_open_ext("/dev/dsp", 8000, 16, 2, EKG_CODEC_GSM) == -1) {
printf("voice_open_ext('/dev/dsp', "
"8000, 16, 2, CODEC_GSM) failed\n");
exit(1);
}
printf("+OK\n");
gg_dcc7_accept_voice(gd, 0x00);
}
break;
case GG_EVENT_DCC7_ERROR:
debug("Direct connection error\n");
exit(1);
case GG_EVENT_DCC7_ACCEPT:
debug("Accepted\n");
break;
case GG_EVENT_DCC7_REJECT:
debug("Rejected\n");
exit(1);
default:
debug("Unsupported event %d\n", ge->type);
break;
}
gg_event_free(ge);
}
if (gd && gd->fd != -1 && (FD_ISSET(gd->fd, &rds) ||
FD_ISSET(gd->fd, &wds) || (gd->timeout == 0 && gd->soft_timeout)))
{
struct gg_event *ge;
if (!(ge = gg_dcc7_watch_fd(gd))) {
debug("Direct connection broken\n");
exit(1);
}
switch (ge->type) {
case GG_EVENT_DCC7_ERROR:
debug("Direct connection error\n");
exit(1);
case GG_EVENT_DCC7_CONNECTED:
debug("Direct connection established\n");
break;
case GG_EVENT_DCC7_DONE:
debug("Finished");
gg_event_free(ge);
gg_dcc7_free(gd);
gg_free_session(gs);
config_free();
exit(1);
case GG_EVENT_DCC7_VOICE_DATA:
gg_debug(GG_DEBUG_MISC,
"## GG_EVENT_DCC7_VOICE_DATA [%u]\n",
ge->event.dcc7_voice_data.length);
printf("## GG_EVENT_DCC7_VOICE_DATA [%u]\n",
ge->event.dcc7_voice_data.length);
if (voice_fd == -1) {
printf("voice_fd == -1\n");
exit(1);
}
if (ge->event.dcc7_voice_data.length == GG_DCC7_VOICE_FRAME_GSM_LENGTH)
voice_play(ge->event.dcc7_voice_data.data,
ge->event.dcc7_voice_data.length, EKG_CODEC_GSM);
else if (ge->event.dcc7_voice_data.length == GG_DCC7_VOICE_FRAME_SPEEX_LENGTH)
voice_play(ge->event.dcc7_voice_data.data,
ge->event.dcc7_voice_data.length, EKG_CODEC_SPEEX);
else if (ge->event.dcc7_voice_data.length == GG_DCC7_VOICE_FRAME_MELP_LENGTH)
voice_play(ge->event.dcc7_voice_data.data,
ge->event.dcc7_voice_data.length, EKG_CODEC_MELP);
break;
case GG_EVENT_NONE:
break;
default:
debug("Unsupported event %d\n", ge->type);
break;
}
gg_event_free(ge);
}
if (voice_fd != -1 && FD_ISSET(voice_fd, &rds)) {
char buf[GG_DCC_VOICE_FRAME_LENGTH]; /* dłuższy z buforów */
int length = GG_DCC_VOICE_FRAME_LENGTH;
if (gd) {
if (gd->state == GG_STATE_READING_VOICE_DATA) {
/* XXX, implementowac speex */
length = GG_DCC7_VOICE_FRAME_GSM_LENGTH;
voice_record(buf, length, EKG_CODEC_GSM);
if (1)
gg_dcc7_voice_send(gd, buf, length);
else {
/* ten pakiet mamy wysylac co 1s */
gg_dcc7_voice_mic_off(gd);
}
} else
voice_record(buf, length, EKG_CODEC_NONE);
} else
voice_record(buf, length, EKG_CODEC_NONE);
}
}
if (gg_debug_file != stdout) /* w sumie stdout, tez moglibysmy zamknac.. czemu nie. */
fclose(gg_debug_file);
return 0;
}
int main(void)
{
struct gg_login_params p;
struct gg_session *sess;
struct timeval tv;
struct gg_event *e;
fd_set rd, wd;
time_t last = 0, now;
int ret;
#ifdef _WIN32
gg_win32_init_network();
#endif
gg_debug_level = ~0;
memset(&p, 0, sizeof(p));
p.uin = 123456;
p.password = "******";
p.async = 1;
sess = gg_login(&p);
if (!sess) {
printf("gg_login failed.\n");
return 1;
}
for (;;) {
FD_ZERO(&rd);
FD_ZERO(&wd);
if ((sess->check & GG_CHECK_READ))
FD_SET(sess->fd, &rd);
if ((sess->check & GG_CHECK_WRITE))
FD_SET(sess->fd, &wd);
tv.tv_sec = 1;
tv.tv_usec = 0;
ret = select(sess->fd + 1, &rd, &wd, NULL, &tv);
if (ret == -1) {
perror("select");
return 1;
}
now = time(NULL);
if (now != last) {
if (sess->timeout != -1 && sess->timeout-- == 0 &&
!sess->soft_timeout)
{
printf("Przekroczenie czasu operacji.\n");
gg_free_session(sess);
return 1;
}
}
if (sess && (FD_ISSET(sess->fd, &rd) ||
FD_ISSET(sess->fd, &wd) ||
(sess->timeout == 0 && sess->soft_timeout)))
{
if (!(e = gg_watch_fd(sess))) {
printf("Połączenie zerwane.\n");
gg_free_session(sess);
return 1;
}
if (e->type == GG_EVENT_CONN_SUCCESS) {
printf("Połączono z serwerem.\n");
gg_free_event(e);
gg_logoff(sess);
gg_free_session(sess);
return 0;
}
if (e->type == GG_EVENT_CONN_FAILED) {
printf("Błąd połączenia.\n");
gg_free_event(e);
gg_logoff(sess);
gg_free_session(sess);
return 1;
}
gg_free_event(e);
}
}
return 1;
}
int main(int argc, char **argv)
{
struct gg_login_params glp;
struct gg_session *gs;
time_t last = 0;
int hide_sysmsg = 0;
int ch;
gg_debug_level = 255;
memset(&glp, 0, sizeof(glp));
glp.async = 1;
config_read();
while ((ch = getopt(argc, argv, "DShHLs:p:l:y")) != -1) {
switch (ch) {
case 'D':
gg_debug_level = 0;
break;
case 'S':
glp.async = 0;
break;
case 'L':
glp.tls = 1;
break;
case 's':
free(config_server);
config_server = strdup(optarg);
break;
case 'p':
free(config_proxy);
config_proxy = strdup(optarg);
break;
case 'H':
gg_proxy_http_only = 1;
break;
case 'l':
glp.last_sysmsg = atoi(optarg);
break;
case 'h':
usage(argv[0]);
return 0;
case 'y':
hide_sysmsg = 1;
break;
default:
usage(argv[0]);
return 1;
}
}
if (argc - optind >= 1) {
config_uin = atoi(argv[optind]);
optind++;
if (argc - optind >= 1) {
free(config_password);
config_password = strdup(argv[optind]);
}
}
if (config_uin == 0 || config_password == NULL) {
usage(argv[0]);
return 1;
}
if (config_server != NULL) {
char *host;
int port;
parse_address(config_server, &host, &port);
glp.server_addr = inet_addr(host);
glp.server_port = port;
free(host);
}
if (config_proxy != NULL) {
char *host;
int port;
parse_address(optarg, &host, &port);
gg_proxy_enabled = 1;
gg_proxy_host = host;
gg_proxy_port = port;
free(config_proxy);
}
glp.uin = config_uin;
glp.password = config_password;
signal(SIGINT, sigint);
gs = gg_login(&glp);
if (gs == NULL) {
perror("gg_login");
free(gg_proxy_host);
return 1;
}
for (;;) {
struct timeval tv;
fd_set rd, wd;
int ret, fd, check;
time_t now;
if (disconnect_flag) {
gg_change_status(gs, GG_STATUS_NOT_AVAIL);
disconnect_flag = 0;
}
FD_ZERO(&rd);
FD_ZERO(&wd);
fd = gs->fd;
check = gs->check;
if ((check & GG_CHECK_READ))
FD_SET(fd, &rd);
if ((check & GG_CHECK_WRITE))
FD_SET(fd, &wd);
tv.tv_sec = 1;
tv.tv_usec = 0;
ret = select(fd + 1, &rd, &wd, NULL, &tv);
if (ret == -1) {
if (errno == EINTR)
continue;
perror("select");
break;
}
now = time(NULL);
if (now != last) {
if (gs->timeout != -1 && gs->timeout-- == 0 && !gs->soft_timeout) {
printf("Timeout!\n");
break;
}
}
if (gs != NULL && (FD_ISSET(fd, &rd) || FD_ISSET(fd, &wd) || (gs->timeout == 0 && gs->soft_timeout))) {
struct gg_event *ge;
ge = gg_watch_fd(gs);
if (ge == NULL) {
printf("Connection broken!\n");
break;
}
if (ge->type == GG_EVENT_CONN_SUCCESS) {
printf("Connected (press Ctrl-C to disconnect)\n");
gg_notify(gs, NULL, 0);
}
if (ge->type == GG_EVENT_CONN_FAILED) {
printf("Connection failed!\n");
gg_event_free(ge);
break;
}
if (ge->type == GG_EVENT_DISCONNECT_ACK) {
printf("Connection closed\n");
gg_event_free(ge);
break;
}
if (ge->type == GG_EVENT_MSG) {
if (ge->event.msg.sender != 0 || !hide_sysmsg)
printf("Received message from %d:\n- plain text: %s\n- html: %s\n", ge->event.msg.sender, ge->event.msg.message, ge->event.msg.xhtml_message);
}
gg_event_free(ge);
}
}
free(gg_proxy_host);
gg_free_session(gs);
config_free();
return 0;
}
static int test_set_get(void)
{
struct gg_session *gs;
struct gg_http *gh;
struct gg_login_params glp;
memset(&glp, 0, sizeof(glp));
glp.uin = 1;
glp.password = "";
glp.resolver = 0;
glp.async = 1;
/* Test globalnych ustawień */
if (gg_global_get_resolver() != GG_RESOLVER_DEFAULT) {
printf("Expected global default resolver #1\n");
return 0;
}
#ifdef GG_CONFIG_HAVE_FORK
printf("Setting global fork resolver\n");
gg_global_set_resolver(GG_RESOLVER_FORK);
if (gg_global_get_resolver() != GG_RESOLVER_FORK) {
printf("Expected global fork resolver\n");
return 0;
}
#endif
#ifdef GG_CONFIG_HAVE_PTHREAD
printf("Setting global pthread resolver\n");
gg_global_set_resolver(GG_RESOLVER_PTHREAD);
if (gg_global_get_resolver() != GG_RESOLVER_PTHREAD) {
printf("Expected global thread resolver\n");
return 0;
}
#endif
#ifdef _WIN32
printf("Setting global win32 resolver\n");
gg_global_set_resolver(GG_RESOLVER_WIN32);
if (gg_global_get_resolver() != GG_RESOLVER_WIN32) {
printf("Expected global win32 resolver\n");
return 0;
}
#endif
printf("Setting global custom resolver\n");
gg_global_set_custom_resolver(dummy_start, dummy_cleanup);
if (gg_global_get_resolver() != GG_RESOLVER_CUSTOM) {
printf("Expected global custom resolver\n");
return 0;
}
printf("Setting global default resolver\n");
gg_global_set_resolver(GG_RESOLVER_DEFAULT);
if (gg_global_get_resolver() != GG_RESOLVER_DEFAULT) {
printf("Expected global default resolver #2\n");
return 0;
}
/* Test lokalnych ustawień -- domyślny */
printf("Testing local default resolver\n");
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_FORK &&
gg_session_get_resolver(gs) != GG_RESOLVER_PTHREAD &&
gg_session_get_resolver(gs) != GG_RESOLVER_WIN32)
{
printf("Expected local fork, pthread or win32 resolver\n");
return 0;
}
gg_free_session(gs);
/* Testy globalnego default + lokalne */
printf("Testing global default fork\n");
gg_global_set_resolver(GG_RESOLVER_DEFAULT);
#ifdef GG_CONFIG_HAVE_FORK
/* Test lokalnych ustawień -- fork */
printf("Testing local fork resolver\n");
glp.resolver = GG_RESOLVER_FORK;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_FORK) {
printf("Expected local fork resolver\n");
return 0;
}
gg_free_session(gs);
#endif
#ifdef GG_CONFIG_HAVE_PTHREAD
/* Test lokalnych ustawień -- pthread */
printf("Testing local pthread resolver\n");
glp.resolver = GG_RESOLVER_PTHREAD;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_PTHREAD) {
printf("Expected local pthread resolver\n");
return 0;
}
gg_free_session(gs);
#endif
#ifdef _WIN32
/* Test lokalnych ustawień -- win32 */
printf("Testing local win32 resolver\n");
glp.resolver = GG_RESOLVER_WIN32;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_WIN32) {
printf("Expected local win32 resolver\n");
return 0;
}
gg_free_session(gs);
#endif
#ifdef GG_CONFIG_HAVE_FORK
/* Testy globalnego fork + lokalne */
printf("Setting global fork resolver\n");
gg_global_set_resolver(GG_RESOLVER_FORK);
/* Test globalnych ustawień + lokalne */
printf("Testing local default resolver\n");
glp.resolver = GG_RESOLVER_DEFAULT;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_FORK) {
printf("Expected local fork resolver\n");
return 0;
}
gg_free_session(gs);
/* Test globalnych ustawień + lokalne */
printf("Testing local fork resolver\n");
glp.resolver = GG_RESOLVER_FORK;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_FORK) {
printf("Expected local fork resolver\n");
return 0;
}
gg_free_session(gs);
#ifdef GG_CONFIG_HAVE_PTHREAD
/* Test globalnych ustawień + lokalne */
printf("Testing local pthread resolver\n");
glp.resolver = GG_RESOLVER_PTHREAD;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_PTHREAD) {
printf("Expected local fork resolver\n");
return 0;
}
gg_free_session(gs);
#endif /* GG_CONFIG_HAVE_PTHREAD */
#endif /* GG_CONFIG_HAVE_FORK */
#ifdef GG_CONFIG_HAVE_PTHREAD
/* Testy globalnego pthread + lokalne */
printf("Setting global pthread resolver\n");
gg_global_set_resolver(GG_RESOLVER_PTHREAD);
/* Test globalnych ustawień + lokalne */
printf("Testing local default resolver\n");
glp.resolver = GG_RESOLVER_DEFAULT;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_PTHREAD) {
printf("Expected local pthread resolver\n");
return 0;
}
gg_free_session(gs);
#ifdef GG_CONFIG_HAVE_FORK
/* Test globalnych ustawień + lokalne */
printf("Testing local fork resolver\n");
glp.resolver = GG_RESOLVER_FORK;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_FORK) {
printf("Expected local fork resolver\n");
return 0;
}
gg_free_session(gs);
#endif
/* Test globalnych ustawień + lokalne */
printf("Testing local pthread resolver\n");
glp.resolver = GG_RESOLVER_PTHREAD;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_PTHREAD) {
printf("Expected local fork resolver\n");
return 0;
}
gg_free_session(gs);
#ifdef _WIN32
/* Test globalnych ustawień + lokalne */
printf("Testing local win32 resolver\n");
glp.resolver = GG_RESOLVER_WIN32;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_WIN32) {
printf("Expected local win32 resolver\n");
return 0;
}
gg_free_session(gs);
#endif
#endif /* GG_CONFIG_HAVE_PTHREAD */
/* Testy globalnego custom + lokalne */
printf("Setting global custom resolver\n");
gg_global_set_custom_resolver(dummy_start, dummy_cleanup);
/* Test globalnych ustawień + lokalne */
printf("Testing local default resolver\n");
glp.resolver = GG_RESOLVER_DEFAULT;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_CUSTOM) {
printf("Expected local custom resolver\n");
return 0;
}
gg_free_session(gs);
#ifdef GG_CONFIG_HAVE_FORK
/* Test globalnych ustawień + lokalne */
printf("Testing local fork resolver\n");
glp.resolver = GG_RESOLVER_FORK;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_FORK) {
printf("Expected local fork resolver\n");
return 0;
}
gg_free_session(gs);
#endif
#ifdef GG_CONFIG_HAVE_PTHREAD
/* Test globalnych ustawień + lokalne */
printf("Testing local pthread resolver\n");
glp.resolver = GG_RESOLVER_PTHREAD;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (gg_session_get_resolver(gs) != GG_RESOLVER_PTHREAD) {
printf("Expected local fork resolver\n");
return 0;
}
gg_free_session(gs);
#endif
/* Test HTTP */
printf("Testing global default resolver in HTTP\n");
gg_global_set_resolver(GG_RESOLVER_DEFAULT);
gh = gg_http_connect("test", 80, 1, "GET", "/test", "");
if (gh == NULL)
return 0;
if (gg_http_get_resolver(gh) != GG_RESOLVER_FORK &&
gg_http_get_resolver(gh) != GG_RESOLVER_PTHREAD &&
gg_http_get_resolver(gh) != GG_RESOLVER_WIN32)
{
printf("Expected local fork, pthread or win32 resolver\n");
return 0;
}
gg_http_free(gh);
#ifdef GG_CONFIG_HAVE_FORK
/* Test HTTP */
printf("Testing global fork resolver in HTTP\n");
gg_global_set_resolver(GG_RESOLVER_FORK);
gh = gg_http_connect("test", 80, 1, "GET", "/test", "");
if (gh == NULL)
return 0;
if (gg_http_get_resolver(gh) != GG_RESOLVER_FORK) {
printf("Expected local fork resolver\n");
return 0;
}
gg_http_free(gh);
#endif
#ifdef GG_CONFIG_HAVE_PTHREAD
/* Test HTTP */
printf("Testing global pthread resolver in HTTP\n");
gg_global_set_resolver(GG_RESOLVER_PTHREAD);
gh = gg_http_connect("test", 80, 1, "GET", "/test", "");
if (gh == NULL)
return 0;
if (gg_http_get_resolver(gh) != GG_RESOLVER_PTHREAD) {
printf("Expected local pthread resolver\n");
return 0;
}
gg_http_free(gh);
#endif
/* Test HTTP */
printf("Testing global custom resolver in HTTP\n");
gg_global_set_custom_resolver(dummy_start, dummy_cleanup);
gh = gg_http_connect("test", 80, 1, "GET", "/test", "");
if (gh == NULL)
return 0;
if (gg_http_get_resolver(gh) != GG_RESOLVER_CUSTOM) {
printf("Expected local custom resolver\n");
return 0;
}
gg_http_free(gh);
/* Czyścimy po sobie */
printf("Cleaning up after resolver tests...\n");
gg_global_set_resolver(GG_RESOLVER_DEFAULT);
return 1;
}
static int test(int resolver, int delay)
{
struct gg_session *gs;
struct gg_login_params glp;
int loops = 0;
delay_flag = delay;
connect_flag = 0;
memset(&glp, 0, sizeof(glp));
glp.uin = 1;
glp.password = "";
glp.resolver = resolver;
glp.async = 1;
gs = gg_login(&glp);
if (gs == NULL)
return 0;
if (!delay_flag) {
for (loops = 0; loops < 5; loops++) {
struct gg_event *ge;
struct timeval tv;
fd_set fds;
FD_ZERO(&fds);
FD_SET(gs->fd, &fds);
tv.tv_sec = 1;
tv.tv_usec = 0;
if (select(gs->fd + 1, &fds, NULL, NULL, &tv) == -1) {
if (errno == EAGAIN)
continue;
gg_free_session(gs);
return 0;
}
ge = gg_watch_fd(gs);
if (ge == NULL) {
gg_free_session(gs);
return 0;
}
if (ge->type == GG_EVENT_CONN_FAILED) {
gg_event_free(ge);
gg_free_session(gs);
return 0;
}
if (gs->hub_addr != 0 && gs->hub_addr != inet_addr(LOCALHOST)) {
struct in_addr hub_addr;
hub_addr.s_addr = gs->hub_addr;
printf("gethostbyname hook failed %s != %s\n",
LOCALHOST, inet_ntoa(hub_addr));
gg_event_free(ge);
gg_free_session(gs);
return 0;
}
gg_event_free(ge);
if (connect_flag == 1)
break;
}
} else {
sleep(1);
}
gg_free_session(gs);
if (loops == 5) {
printf("timeout\n");
return 0;
}
return 1;
}
void reload(GLOBAL *g, struct ggnotify_module *n)
{
QueryHandle *res, *result;
char *message = 0;
int i, j;
double balance;
struct gg_session *sess;
struct gg_login_params p;
memset(&p, 0, sizeof(p));
p.uin = n->uin;
p.password = n->passwd;
// Najpierw po³±czmy siê z serwerem GG
if( !(sess = gg_login(&p)) )
{
syslog(LOG_ERR, "[%s/ggnotify] Unable to connect to Gadu-Gadu server.", n->base.instance);
gg_free_session(sess);
}
else
{
#ifdef DEBUG1
syslog(LOG_INFO, "DEBUG: [%s/ggnotify] Connected to Gadu-Gadu server.",n->base.instance);
#endif
res = g->db_query(g->conn,
"SELECT customers.id AS id, pin, name, lastname, "
"SUM(cash.value) AS balance, imessengers.uid AS im "
"FROM customers "
"LEFT JOIN imessengers ON customers.id = imessengers.customerid "
"LEFT JOIN cash ON customers.id = cash.customerid "
"WHERE deleted = 0 AND imessengers.type = 0 "
"GROUP BY customers.id, imessengers.uid, pin, name, lastname");
if( g->db_nrows(res) )
{
for(i=0; i<g->db_nrows(res); i++)
{
if( atoi(g->db_get_data(res,i,"im")) )
{
balance = atof(g->db_get_data(res,i,"balance"));
if( balance < n->limit )
{
message = load_file(n->ggtemplate);
if( message )
{
if( strstr(message, "%last_10_in_a_table") )
{
char *date, *value, *comment, *last_ten, *temp, *temp2;
last_ten = strdup("");
result = g->db_pquery(g->conn, "SELECT value, comment, time FROM cash WHERE customerid = ? ORDER BY time DESC LIMIT 10", g->db_get_data(res,i,"id"));
for(j=0; j<g->db_nrows(result); j++)
{
date = utoc(atof(g->db_get_data(result,j,"time")));
value = g->db_get_data(result,j,"value");
comment = g->db_get_data(result,j,"comment");
temp = (char *) malloc(strlen(date)+strlen(value)+strlen(comment)+12);
sprintf(temp, "%s\t | %s\t\t | %s\n", date, value, comment);
temp2 = g->str_concat(last_ten, temp);
free(last_ten);
last_ten = strdup(temp2);
free(temp2);
free(temp);
free(date);
}
g->str_replace(&message, "%last_10_in_a_table", last_ten);
g->db_free(&result);
free(last_ten);
}
g->str_replace(&message, "%saldo", g->db_get_data(res,i,"balance"));
g->str_replace(&message, "%B", g->db_get_data(res,i,"balance"));
g->str_replace(&message, "%b", balance < 0 ? ftoa(balance * -1) : g->db_get_data(res,i,"balance"));
g->str_replace(&message, "%pin", g->db_get_data(res,i,"pin"));
g->str_replace(&message, "%name", g->db_get_data(res,i,"name"));
g->str_replace(&message, "%lastname", g->db_get_data(res,i,"lastname"));
// Konwersja na windows
g->str_replace(&message, "\n", "\n\r");
g->str_replace(&message, "\xA1", "\xA5");
g->str_replace(&message, "\xA6", "\x8C");
g->str_replace(&message, "\xAC", "\x8F");
g->str_replace(&message, "\xB1", "\xB9");
g->str_replace(&message, "\xB6", "\x9C");
g->str_replace(&message, "\xBC", "\x9F");
if( n->debuguin )
{
if (gg_send_message(sess, GG_CLASS_MSG, n->debuguin, message ) == -1)
{
syslog(LOG_INFO, "DEBUG: [%s/ggnotify] Connection broken..",n->base.instance);
gg_free_session(sess);
}
} else {
if (gg_send_message(sess, GG_CLASS_MSG, atoi(g->db_get_data(res,i,"im")), message) == -1)
{
syslog(LOG_INFO, "DEBUG: [%s/ggnotify] Connection broken..",n->base.instance);
gg_free_session(sess);
}
}
free(message);
}
}
}
}
} else
syslog(LOG_ERR, "[%s/ggnotify] Unable to read database", n->base.instance);
g->db_free(&res);
gg_logoff(sess);
gg_free_session(sess);
#ifdef DEBUG1
syslog(LOG_INFO, "DEBUG: [%s/ggnotify] reloaded",n->base.instance);
#endif
}
free(n->passwd);
free(n->ggtemplate);
}
int main()
{
struct gg_login_params p;
struct gg_session *sess;
struct timeval tv;
struct gg_event *e;
fd_set rd, wd;
int ret;
gg_debug_level = ~0;
memset(&p, 0, sizeof(p));
p.uin = 123456;
p.password = "******";
p.async = 1;
sess = gg_login(&p);
for (;;) {
FD_ZERO(&rd);
FD_ZERO(&wd);
if ((sess->check & GG_CHECK_READ))
FD_SET(sess->fd, &rd);
if ((sess->check & GG_CHECK_WRITE))
FD_SET(sess->fd, &wd);
tv.tv_sec = 10;
tv.tv_usec = 0;
ret = select(sess->fd + 1, &rd, &wd, NULL, &tv);
if (!ret) {
printf("timeout! wypad!\n");
return 1;
} else {
if (sess && (FD_ISSET(sess->fd, &rd) || FD_ISSET(sess->fd, &wd))) {
if (!(e = gg_watch_fd(sess))) {
printf("zerfauo pouontshenie!\n");
return 1;
}
if (e->type == GG_EVENT_CONN_SUCCESS) {
printf("po³±czy³em siê\n");
gg_free_event(e);
gg_logoff(sess);
gg_free_session(sess);
return 1;
}
if (e->type == GG_EVENT_CONN_FAILED) {
printf("errrror\n");
gg_free_event(e);
gg_logoff(sess);
gg_free_session(sess);
return 1;
}
gg_free_event(e);
}
}
}
return -1;
}
int main(int argc, char **argv)
{
struct gg_session *gs;
struct gg_login_params glp;
struct gg_dcc7 *gd = NULL;
time_t ping = 0, last = 0;
int fds[2] = { -1, -1 };
if (argc != 2 || atoi(argv[1]) >= TEST_MODE_LAST) {
fprintf(stderr, "usage: %s <mode>\n"
"\n"
"mode: 0 - send file\n"
" 1 - send file, simulate NAT\n"
" 2 - receive file\n"
" 3 - receive file, simulate NAT\n"
" 4 - receive file, resume at the end\n"
"\n", argv[0]);
exit(1);
}
test_mode = atoi(argv[1]);
if (config_read() == -1 || config_peer == 0) {
perror("config");
exit(1);
}
#ifdef _WIN32
gg_win32_init_network();
gg_win32_hook(connect, my_connect, &connect_hook);
#else
signal(SIGPIPE, SIG_IGN);
#endif
gg_debug_file = stdout;
gg_debug_level = ~0;
if (!config_file && socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) == -1) {
perror("pipe");
exit(1);
}
memset(&glp, 0, sizeof(glp));
glp.uin = config_uin;
glp.password = config_password;
glp.async = 1;
glp.client_addr = config_ip;
glp.client_port = config_port;
glp.protocol_version = GG_PROTOCOL_VERSION_100;
if (config_dir && (test_mode == TEST_MODE_RECEIVE ||
test_mode == TEST_MODE_RECEIVE_NAT ||
test_mode == TEST_MODE_RECEIVE_RESUME))
{
if (chdir(config_dir) == -1) {
perror("chdir");
exit(1);
}
}
debug("Connecting...\n");
if (!(gs = gg_login(&glp))) {
perror("gg_login");
exit(1);
}
for (;;) {
fd_set rds, wds;
struct timeval tv;
time_t now;
int res, maxfd = -1;
FD_ZERO(&rds);
FD_ZERO(&wds);
tv.tv_sec = 1;
tv.tv_usec = 0;
maxfd = gs->fd;
if ((gs->check & GG_CHECK_READ))
FD_SET(gs->fd, &rds);
if ((gs->check & GG_CHECK_WRITE))
FD_SET(gs->fd, &wds);
if (gd && gd->fd != -1) {
if (gd->fd > maxfd)
maxfd = gd->fd;
if ((gd->check & GG_CHECK_READ))
FD_SET(gd->fd, &rds);
if ((gd->check & GG_CHECK_WRITE))
FD_SET(gd->fd, &wds);
}
if (fds[1] != -1) {
if (fds[1] > maxfd)
maxfd = fds[1];
FD_SET(fds[1], &wds);
}
if ((res = select(maxfd + 1, &rds, &wds, NULL, &tv)) == -1) {
if (errno == EINTR)
continue;
perror("select");
exit(1);
}
now = time(NULL);
if (last != now) {
if (gs->timeout != -1 && gs->timeout-- == 0 && !gs->soft_timeout) {
debug("Timeout\n");
exit(1);
}
if (gd && gd->timeout != -1 && gd->timeout-- == 0 && !gd->soft_timeout) {
debug("Timeout\n");
exit(1);
}
last = now;
}
if (gs->state == GG_STATE_CONNECTED && ping && now - ping > 60) {
ping = now;
gg_ping(gs);
}
if (FD_ISSET(gs->fd, &rds) || FD_ISSET(gs->fd, &wds) || (gs->timeout == 0 && gs->soft_timeout)) {
struct gg_event *ge;
uin_t uin;
int status;
if (!(ge = gg_watch_fd(gs))) {
debug("Connection broken\n");
exit(1);
}
switch (ge->type) {
case GG_EVENT_CONN_SUCCESS:
debug("Connected\n");
connected = 1;
gg_notify(gs, &config_peer, 1);
if (test_mode == TEST_MODE_RECEIVE_NAT)
gs->client_addr = INADDR_NONE;
ping = time(NULL);
break;
case GG_EVENT_CONN_FAILED:
debug("Connection failed\n");
exit(1);
case GG_EVENT_MSG:
debug("Message from %d: %s\n", ge->event.msg.sender, ge->event.msg.message);
break;
case GG_EVENT_DISCONNECT:
debug("Forced to disconnect\n");
exit(1);
case GG_EVENT_USER_DATA:
debug("User data\n");
break;
case GG_EVENT_NOTIFY60:
uin = ge->event.notify60[0].uin;
status = ge->event.notify60[0].status;
/* fall-through */
case GG_EVENT_STATUS60:
if (ge->type == GG_EVENT_STATUS60) {
uin = ge->event.status60.uin;
status = ge->event.status60.status;
}
if (uin == config_peer &&
(GG_S_A(status) || GG_S_B(status)) &&
(test_mode == TEST_MODE_SEND || test_mode == TEST_MODE_SEND_NAT))
{
debug("Sending file...\n");
if (config_file) {
gd = gg_dcc7_send_file(gs, config_peer,
config_file, NULL, NULL);
} else {
gd = gg_dcc7_send_file_fd(gs, config_peer, fds[0],
config_size, "test.bin", "DummySHA1HashOfAAAAA");
}
if (!gd) {
perror("gg_dcc7_send_file");
exit(1);
}
}
break;
case GG_EVENT_DCC7_NEW:
debug("Incoming direct connection\n");
if (test_mode == TEST_MODE_RECEIVE ||
test_mode == TEST_MODE_RECEIVE_NAT ||
test_mode == TEST_MODE_RECEIVE_RESUME)
{
gd = ge->event.dcc7_new;
if (config_dir) {
gd->file_fd = open((char*) gd->filename,
O_WRONLY | O_CREAT, 0600);
#if 0
lseek(gd->file_fd, gd->size, SEEK_SET);
#endif
} else
gd->file_fd = open("/dev/null", O_WRONLY);
if (gd->file_fd == -1) {
perror("open");
exit(1);
}
if (test_mode != TEST_MODE_RECEIVE_RESUME)
gg_dcc7_accept(gd, 0);
else
gg_dcc7_accept(gd, gd->size);
}
break;
case GG_EVENT_DCC7_ERROR:
debug("Direct connection error\n");
exit(1);
case GG_EVENT_DCC7_ACCEPT:
debug("Accepted\n");
break;
case GG_EVENT_DCC7_REJECT:
debug("Rejected\n");
exit(1);
case GG_EVENT_DCC7_PENDING:
debug("Pending\n");
break;
case GG_EVENT_NONE:
break;
default:
debug("Unsupported event %d\n", ge->type);
break;
}
gg_event_free(ge);
}
if (gd && gd->fd != -1 && (FD_ISSET(gd->fd, &rds) ||
FD_ISSET(gd->fd, &wds) || (gd->timeout == 0 && gd->soft_timeout)))
{
struct gg_event *ge;
if (!(ge = gg_dcc7_watch_fd(gd))) {
debug("Direct connection broken\n");
exit(1);
}
switch (ge->type) {
case GG_EVENT_DCC7_ERROR:
debug("Direct connection error\n");
exit(1);
case GG_EVENT_DCC7_CONNECTED:
debug("Direct connection established\n");
break;
case GG_EVENT_DCC7_DONE:
debug("Finished");
gg_event_free(ge);
gg_dcc7_free(gd);
gg_free_session(gs);
config_free();
exit(1);
case GG_EVENT_NONE:
break;
default:
debug("Unsupported event %d\n", ge->type);
break;
}
gg_event_free(ge);
}
if (fds[1] != -1 && FD_ISSET(fds[1], &wds)) {
char buf[4096];
memset(buf, 'A', sizeof(buf));
if (write(fds[1], buf, sizeof(buf)) < 1) {
perror("write");
exit(1);
}
}
}
return 0;
}
int main(int argc, char **argv)
{
// Do po³±czenia
struct gg_session *sess;
struct gg_event *e;
struct gg_login_params p;
list_t searches = NULL;
char *last_search_first_name = NULL;
char *last_search_last_name = NULL;
char *last_search_nickname = NULL;
uin_t last_search_uin = 0;
gg_pubdir50_t res;
// Do wyszukiwania
char *user;
gg_pubdir50_t req;
int i, all = 0;
if (argc < 4) {
fprintf(stderr, "Usage: %s <my_uid> <my_password> <params>\n\n", argv[0]);
fprintf(stderr, "Parameters:\n");
fprintf(stderr, " -f <val> (--first) - first name\n");
fprintf(stderr, " -l <val> (--last) - last name\n");
fprintf(stderr, " -n <val> (--nickname) - nickname\n");
fprintf(stderr, " -c <val> (--city) - city\n");
fprintf(stderr, " -u <val> (--uin) - user ID\n");
fprintf(stderr, " -F (--female) - search females only\n");
fprintf(stderr, " -M (--male) - search males only\n");
fprintf(stderr, " -a (--active) - search on-line users only\n");
fprintf(stderr, " -b <val> (--born) - year of birth\n");
fprintf(stderr, " -s <val> (--start) - search offset\n");
fprintf(stderr, " -A (--all) - show all\n");
return 1;
}
// Poziom debugowania
gg_debug_level = 5;
memset(&p, 0, sizeof(p));
p.uin = atoi(argv[1]);
p.password = argv[2];
// Po³±czenie
if (!(sess = gg_login(&p))) {
printf("Connection failed: %s\n", strerror(errno));
gg_free_session(sess);
return 1;
}
printf("Po³±czono.\n");
// Wyszukiwanie
if (!sess || sess->state != GG_STATE_CONNECTED) {
printf("not_connected\n");
return 1;
}
argv = argv + 3;
// próba odpalenia trybu szukania konkretnego usera
user = strdup(argv[0]);
// Konwersja do CP
for (i = 0; argv[i]; i++) {
iso_to_cp(argv[i]);
}
// Zapytanie
if (!(req = gg_pubdir50_new(GG_PUBDIR50_SEARCH))) {
printf("\n");
return 1;
}
// wyszukiwanie UIN
if (argv[0] && argv[0][0] != '-') {
uin_t uin = get_uin(user);
if (!uin) {
printf("User not found (%s)\n", user);
return 1;
}
gg_pubdir50_add(req, GG_PUBDIR50_UIN, itoa(uin));
i = 1;
} else {
i = 0;
}
free(user);
// Parsowanie argumentów
for (; argv[i]; i++) {
char *arg = argv[i];
if (match_arg(arg, 'f', "first", 2) && argv[i + 1]) {
gg_pubdir50_add(req, GG_PUBDIR50_FIRSTNAME, argv[++i]);
continue;
}
if (match_arg(arg, 'l', "last", 2) && argv[i + 1]) {
gg_pubdir50_add(req, GG_PUBDIR50_LASTNAME, argv[++i]);
continue;
}
if (match_arg(arg, 'n', "nickname", 2) && argv[i + 1]) {
gg_pubdir50_add(req, GG_PUBDIR50_NICKNAME, argv[++i]);
continue;
}
if (match_arg(arg, 'c', "city", 2) && argv[i + 1]) {
gg_pubdir50_add(req, GG_PUBDIR50_CITY, argv[++i]);
continue;
}
if (match_arg(arg, 'u', "uin", 2) && argv[i + 1]) {
gg_pubdir50_add(req, GG_PUBDIR50_UIN, itoa(get_uin(argv[++i])));
continue;
}
if (match_arg(arg, 's', "start", 3) && argv[i + 1]) {
gg_pubdir50_add(req, GG_PUBDIR50_START, argv[++i]);
continue;
}
if (match_arg(arg, 'F', "female", 2)) {
gg_pubdir50_add(req, GG_PUBDIR50_GENDER, GG_PUBDIR50_GENDER_FEMALE);
continue;
}
if (match_arg(arg, 'M', "male", 2)) {
gg_pubdir50_add(req, GG_PUBDIR50_GENDER, GG_PUBDIR50_GENDER_MALE);
continue;
}
if (match_arg(arg, 'a', "active", 2)) {
gg_pubdir50_add(req, GG_PUBDIR50_ACTIVE, GG_PUBDIR50_ACTIVE_TRUE);
continue;
}
if (match_arg(arg, 'b', "born", 2) && argv[i + 1]) {
char *foo = strchr(argv[++i], ':');
if (foo)
*foo = ' ';
gg_pubdir50_add(req, GG_PUBDIR50_BIRTHYEAR, argv[i]);
continue;
}
if (match_arg(arg, 'A', "all", 3)) {
if (!gg_pubdir50_get(req, 0, GG_PUBDIR50_START))
gg_pubdir50_add(req, GG_PUBDIR50_START, "0");
all = 1;
continue;
}
printf("invalid_params\n");
gg_pubdir50_free(req);
return 1;
}
// Wywo³anie wyszukiwania
if (!gg_pubdir50(sess, req)) {
printf("Search failed\n");
return 1;
}
// Dodanie wyniku wyszykiwania do listy
if (all) {
list_add(&searches, req, 0);
} else {
gg_pubdir50_free(req);
}
// Pêtla czekaj±ca na wynik wyszukiwania
while (1) {
if (!(e = gg_watch_fd(sess))) {
printf("Connection interrupted: %s\n", strerror(errno));
gg_logoff(sess);
gg_free_session(sess);
return 1;
}
if (e->type == GG_EVENT_PUBDIR50_SEARCH_REPLY) {
printf("Received results!\n");
res = e->event.pubdir50;
all = i = 0;
int count, all = 0;
list_t l;
uin_t last_uin = 0;
if ((count = gg_pubdir50_count(res)) < 1) {
printf("search_not_found\n");
return 1;
}
gg_debug(GG_DEBUG_MISC, "handle_search50, count = %d\n", gg_pubdir50_count(res));
for (l = searches; l; l = l->next) {
gg_pubdir50_t req = l->data;
if (gg_pubdir50_seq(req) == gg_pubdir50_seq(res)) {
all = 1;
break;
}
}
for (i = 0; i < count; i++) {
const char *__fmnumber = gg_pubdir50_get(res, i, "fmnumber");
const char *uin = (__fmnumber) ? __fmnumber : "?";
const char *__firstname = gg_pubdir50_get(res, i, "firstname");
char *firstname = strdup((__firstname) ? __firstname : "");
const char *__lastname = gg_pubdir50_get(res, i, "lastname");
char *lastname = strdup((__lastname) ? __lastname : "");
const char *__nickname = gg_pubdir50_get(res, i, "nickname");
char *nickname = strdup((__nickname) ? __nickname : "");
const char *__fmstatus = gg_pubdir50_get(res, i, "fmstatus");
int status = (__fmstatus) ? atoi(__fmstatus) : GG_STATUS_NOT_AVAIL;
const char *__birthyear = gg_pubdir50_get(res, i, "birthyear");
const char *birthyear = (__birthyear && strcmp(__birthyear, "0")) ? __birthyear : "-";
const char *__city = gg_pubdir50_get(res, i, "city");
char *city = strdup((__city) ? __city : "");
char *name, *active;
const char *target = NULL;
cp_to_iso(firstname);
cp_to_iso(lastname);
cp_to_iso(nickname);
cp_to_iso(city);
if (count == 1 && !all) {
free(last_search_first_name);
free(last_search_last_name);
free(last_search_nickname);
last_search_first_name = strdup(firstname);
last_search_last_name = strdup(lastname);
last_search_nickname = strdup(nickname);
last_search_uin = atoi(uin);
}
name = saprintf("%s %s", firstname, lastname);
switch (status & 0x7f) {
case GG_STATUS_AVAIL:
case GG_STATUS_AVAIL_DESCR:
active = strdup("Avail");
break;
case GG_STATUS_BUSY:
case GG_STATUS_BUSY_DESCR:
active = strdup("Busy");
break;
case GG_STATUS_INVISIBLE:
case GG_STATUS_INVISIBLE_DESCR:
active = strdup("Invis");
break;
default:
active = strdup("Inact");
}
printf("UIN\t: %s\n", uin);
printf("Name\t: %s\n", name);
printf("Nick\t: %s\n", nickname);
printf("City\t: %s\n", city);
printf("Birth\t: %s\n", birthyear);
printf("Active\t: %s\n\n", active);
free(name);
free(active);
free(firstname);
free(lastname);
free(nickname);
free(city);
last_uin = atoi(uin);
}
/* je¶li mieli¶my ,,/find --all'', szukamy dalej */
for (l = searches; l; l = l->next) {
gg_pubdir50_t req = l->data;
uin_t next;
if (gg_pubdir50_seq(req) != gg_pubdir50_seq(res))
continue;
/* nie ma dalszych? to dziêkujemy */
if (!(next = gg_pubdir50_next(res)) || !sess || next < last_uin) {
list_remove(&searches, req, 0);
gg_pubdir50_free(req);
break;
}
gg_pubdir50_add(req, GG_PUBDIR50_START, itoa(next));
gg_pubdir50(sess, req);
break;
}
gg_free_event(e);
break;
}
gg_free_event(e);
}
gg_logoff(sess);
gg_free_session(sess);
return 0;
}
