static void jabber_logout( struct im_connection *ic ) { struct jabber_data *jd = ic->proto_data; while( jd->filetransfers ) imcb_file_canceled( ic, ( ( struct jabber_transfer *) jd->filetransfers->data )->ft, "Logging out" ); while( jd->streamhosts ) { jabber_streamhost_t *sh = jd->streamhosts->data; jd->streamhosts = g_slist_remove( jd->streamhosts, sh ); g_free( sh->jid ); g_free( sh->host ); g_free( sh ); } if( jd->fd >= 0 ) jabber_end_stream( ic ); while( ic->groupchats ) jabber_chat_free( ic->groupchats->data ); if( jd->r_inpa >= 0 ) b_event_remove( jd->r_inpa ); if( jd->w_inpa >= 0 ) b_event_remove( jd->w_inpa ); if( jd->ssl ) ssl_disconnect( jd->ssl ); if( jd->fd >= 0 ) closesocket( jd->fd ); if( jd->tx_len ) g_free( jd->txq ); if( jd->node_cache ) g_hash_table_destroy( jd->node_cache ); jabber_buddy_remove_all( ic ); xt_free( jd->xt ); g_free( jd->oauth2_access_token ); g_free( jd->away_message ); g_free( jd->username ); g_free( jd->me ); g_free( jd ); jabber_connections = g_slist_remove( jabber_connections, ic ); }
/* immed=1 makes this function pretty much equal to irc_free(), except that this one will "log". In case the connection is already broken and we shouldn't try to write to it. */ void irc_abort(irc_t *irc, int immed, char *format, ...) { char *reason = NULL; if (format != NULL) { va_list params; va_start(params, format); reason = g_strdup_vprintf(format, params); va_end(params); } if (reason) { irc_write(irc, "ERROR :Closing link: %s", reason); } ipc_to_master_str("OPERMSG :Client exiting: %s@%s [%s]\r\n", irc->user->nick ? irc->user->nick : "(NONE)", irc->user->host, reason ? : ""); g_free(reason); irc_flush(irc); if (immed) { irc_free(irc); } else { b_event_remove(irc->ping_source_id); irc->ping_source_id = b_timeout_add(1, (b_event_handler) irc_free, irc); } }
static gboolean http_canread(gpointer data, gint source, b_input_condition cond) { int nlc = 0; int pos = 0; struct PHB *phb = data; char inputline[8192]; b_event_remove(phb->inpa); while ((pos < sizeof(inputline) - 1) && (nlc != 2) && (read(source, &inputline[pos++], 1) == 1)) { if (inputline[pos - 1] == '\n') { nlc++; } else if (inputline[pos - 1] != '\r') { nlc = 0; } } inputline[pos] = '\0'; if ((memcmp(HTTP_GOODSTRING, inputline, strlen(HTTP_GOODSTRING)) == 0) || (memcmp(HTTP_GOODSTRING2, inputline, strlen(HTTP_GOODSTRING2)) == 0)) { phb->func(phb->data, source, B_EV_IO_READ); return phb_free(phb, TRUE); } return phb_free(phb, FALSE); }
void ipc_child_disable() { b_event_remove( global.listen_watch_source_id ); close( global.listen_socket ); global.listen_socket = -1; }
void ipc_master_free_one( struct bitlbee_child *c ) { GSList *l; b_event_remove( c->ipc_inpa ); closesocket( c->ipc_fd ); if( c->to_fd != -1 ) close( c->to_fd ); g_free( c->host ); g_free( c->nick ); g_free( c->realname ); g_free( c->password ); g_free( c ); child_list = g_slist_remove( child_list, c ); /* Also, if any child has a reference to this one, remove it. */ for( l = child_list; l; l = l->next ) { struct bitlbee_child *oc = l->data; if( oc->to_child == c ) ipc_master_takeover_fail( oc, FALSE ); } }
/* This one is actually pretty simple... Might get more calls if we can't write the whole request at once. */ static gboolean http_connected( gpointer data, int source, b_input_condition cond ) { struct http_request *req = data; int st; if( source < 0 ) goto error; if( req->inpa > 0 ) b_event_remove( req->inpa ); sock_make_nonblocking( req->fd ); if( req->ssl ) { st = ssl_write( req->ssl, req->request + req->bytes_written, req->request_length - req->bytes_written ); if( st < 0 ) { if( ssl_errno != SSL_AGAIN ) { ssl_disconnect( req->ssl ); goto error; } } } else { st = write( source, req->request + req->bytes_written, req->request_length - req->bytes_written ); if( st < 0 ) { if( !sockerr_again() ) { closesocket( req->fd ); goto error; } } } if( st > 0 ) req->bytes_written += st; if( req->bytes_written < req->request_length ) req->inpa = b_input_add( source, req->ssl ? ssl_getdirection( req->ssl ) : B_EV_IO_WRITE, http_connected, req ); else req->inpa = b_input_add( source, B_EV_IO_READ, http_incoming_data, req ); return FALSE; error: if( req->status_string == NULL ) req->status_string = g_strdup( "Error while writing HTTP request" ); req->func( req ); http_free( req ); return FALSE; }
/** * Logout method. Just free the twitter_data. */ static void twitter_logout(struct im_connection *ic) { struct twitter_data *td = ic->proto_data; // Set the status to logged out. ic->flags &= ~OPT_LOGGED_IN; // Remove the main_loop function from the function queue. b_event_remove(td->main_loop_id); if (td->timeline_gc) imcb_chat_free(td->timeline_gc); if (td) { http_close(td->stream); oauth_info_free(td->oauth_info); g_free(td->user); g_free(td->prefix); g_free(td->url_host); g_free(td->url_path); g_free(td->log); g_free(td); } twitter_connections = g_slist_remove(twitter_connections, ic); }
static gboolean s5_canread_again(gpointer data, gint source, b_input_condition cond) { unsigned char buf[512]; struct PHB *phb = data; b_event_remove(phb->inpa); if (read(source, buf, 10) < 10) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } if ((buf[0] != 0x05) || (buf[1] != 0x00)) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } phb->func(phb->data, source, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; }
static gboolean http_canread(gpointer data, gint source, b_input_condition cond) { int nlc = 0; int pos = 0; struct PHB *phb = data; char inputline[8192]; b_event_remove(phb->inpa); while ((pos < sizeof(inputline)-1) && (nlc != 2) && (read(source, &inputline[pos++], 1) == 1)) { if (inputline[pos - 1] == '\n') nlc++; else if (inputline[pos - 1] != '\r') nlc = 0; } inputline[pos] = '\0'; if ((memcmp(HTTP_GOODSTRING, inputline, strlen(HTTP_GOODSTRING)) == 0) || (memcmp(HTTP_GOODSTRING2, inputline, strlen(HTTP_GOODSTRING2)) == 0)) { phb->func(phb->data, source, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; }
static gboolean s5_canread(gpointer data, gint source, b_input_condition cond) { unsigned char buf[512]; struct PHB *phb = data; b_event_remove(phb->inpa); if (read(source, buf, 2) < 2) { return phb_free(phb, FALSE); } if ((buf[0] != 0x05) || (buf[1] == 0xff)) { return phb_free(phb, FALSE); } if (buf[1] == 0x02) { unsigned int i = strlen(proxyuser), j = strlen(proxypass); buf[0] = 0x01; /* version 1 */ buf[1] = i; memcpy(buf + 2, proxyuser, i); buf[2 + i] = j; memcpy(buf + 2 + i + 1, proxypass, j); if (write(source, buf, 3 + i + j) < 3 + i + j) { return phb_free(phb, FALSE); } phb->inpa = b_input_add(source, B_EV_IO_READ, s5_readauth, phb); } else { s5_sendconnect(phb, source); } return FALSE; }
static gboolean s5_readauth(gpointer data, gint source, b_input_condition cond) { unsigned char buf[512]; struct PHB *phb = data; b_event_remove(phb->inpa); if (read(source, buf, 2) < 2) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } if ((buf[0] != 0x01) || (buf[1] != 0x00)) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } s5_sendconnect(phb, source); return FALSE; }
/** * Closes the underlying #http_request. * * @param callback TRUE to execute the callback, otherwise FALSE. * * @param req The #SteamHttpReq. **/ static void steam_http_req_close(SteamHttpReq *req, gboolean callback) { g_return_if_fail(req != NULL); b_event_remove(req->toid); if ((req->err == NULL) && (req->scode == 0)) { g_set_error(&req->err, STEAM_HTTP_ERROR, STEAM_HTTP_ERROR_CLOSED, "Request closed"); } if (callback && (req->func != NULL)) req->func(req, req->data); if (req->request != NULL) { /* Prevent more than one call to request->func() */ req->request->func = steam_http_req_close_nuller; req->request->data = NULL; if (!(req->request->flags & STEAM_HTTP_CLIENT_FREED)) http_close(req->request); } req->status = NULL; req->scode = 0; req->header = NULL; req->body = NULL; req->body_size = 0; req->toid = 0; req->request = NULL; }
static gboolean gaim_io_connected(gpointer data, gint source, b_input_condition cond) { struct PHB *phb = data; socklen_t len; int error = ETIMEDOUT; len = sizeof(error); if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0 || error) { if ((phb->gai_cur = phb->gai_cur->ai_next)) { int new_fd; b_event_remove(phb->inpa); if ((new_fd = proxy_connect_none(NULL, 0, phb))) { b_event_remove(phb->inpa); closesocket(source); dup2(new_fd, source); closesocket(new_fd); phb->inpa = b_input_add(source, B_EV_IO_WRITE, gaim_io_connected, phb); return FALSE; } } freeaddrinfo(phb->gai); closesocket(source); b_event_remove(phb->inpa); phb->inpa = 0; if( phb->proxy_func ) phb->proxy_func(phb->proxy_data, -1, B_EV_IO_READ); else { phb->func(phb->data, -1, B_EV_IO_READ); g_free(phb); } return FALSE; } freeaddrinfo(phb->gai); sock_make_blocking(source); b_event_remove(phb->inpa); phb->inpa = 0; if( phb->proxy_func ) phb->proxy_func(phb->proxy_data, source, B_EV_IO_READ); else { phb->func(phb->data, source, B_EV_IO_READ); g_free(phb); } return FALSE; }
/** * Clears an enacted connection timeout. * * @param mqtt The #fb_mqtt. **/ static void fb_mqtt_timeout_clear(fb_mqtt_t *mqtt) { g_return_if_fail(mqtt != NULL); if (mqtt->tev > 0) { b_event_remove(mqtt->tev); mqtt->tev = 0; } }
static gboolean http_canwrite(gpointer data, gint source, b_input_condition cond) { char cmd[384]; struct PHB *phb = data; unsigned int len; int error = ETIMEDOUT; if (phb->inpa > 0) b_event_remove(phb->inpa); len = sizeof(error); if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } sock_make_blocking(source); g_snprintf(cmd, sizeof(cmd), "CONNECT %s:%d HTTP/1.1\r\nHost: %s:%d\r\n", phb->host, phb->port, phb->host, phb->port); if (send(source, cmd, strlen(cmd), 0) < 0) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } if (strlen(proxyuser) > 0) { char *t1, *t2; t1 = g_strdup_printf("%s:%s", proxyuser, proxypass); t2 = tobase64(t1); g_free(t1); g_snprintf(cmd, sizeof(cmd), "Proxy-Authorization: Basic %s\r\n", t2); g_free(t2); if (send(source, cmd, strlen(cmd), 0) < 0) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } } g_snprintf(cmd, sizeof(cmd), "\r\n"); if (send(source, cmd, strlen(cmd), 0) < 0) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } phb->inpa = b_input_add(source, GAIM_INPUT_READ, http_canread, phb); return FALSE; }
void discord_ws_cleanup(discord_data *dd) { if (dd->keepalive_loop_id > 0) { b_event_remove(dd->keepalive_loop_id); dd->keepalive_loop_id = 0; } if (dd->lwsctx != NULL) { lws_context_destroy(dd->lwsctx); } }
int irc_user_free( irc_t *irc, irc_user_t *iu ) { static struct im_connection *last_ic; static char *msg; if( !iu ) return 0; if( iu->bu && ( iu->bu->ic->flags & OPT_LOGGING_OUT ) && iu->bu->ic != last_ic ) { char host_prefix[] = "bitlbee."; char *s; /* Irssi recognises netsplits by quitmsgs with two hostnames, where a hostname is a "word" with one of more dots. Mangle no-dot hostnames a bit. */ if( strchr( irc->root->host, '.' ) ) *host_prefix = '\0'; last_ic = iu->bu->ic; g_free( msg ); if( !set_getbool( &irc->b->set, "simulate_netsplit" ) ) msg = g_strdup( "Account off-line" ); else if( ( s = strchr( iu->bu->ic->acc->user, '@' ) ) ) msg = g_strdup_printf( "%s%s %s", host_prefix, irc->root->host, s + 1 ); else msg = g_strdup_printf( "%s%s %s.%s", host_prefix, irc->root->host, iu->bu->ic->acc->prpl->name, irc->root->host ); } else if( !iu->bu || !( iu->bu->ic->flags & OPT_LOGGING_OUT ) ) { g_free( msg ); msg = g_strdup( "Removed" ); last_ic = NULL; } irc_user_quit( iu, msg ); irc->users = g_slist_remove( irc->users, iu ); g_hash_table_remove( irc->nick_user_hash, iu->key ); g_free( iu->nick ); if( iu->nick != iu->user ) g_free( iu->user ); if( iu->nick != iu->host ) g_free( iu->host ); if( iu->nick != iu->fullname ) g_free( iu->fullname ); g_free( iu->pastebuf ); if( iu->pastebuf_timer ) b_event_remove( iu->pastebuf_timer ); g_free( iu->key ); g_free( iu ); return 1; }
static gboolean s4_canwrite(gpointer data, gint source, b_input_condition cond) { unsigned char packet[12]; struct hostent *hp; struct PHB *phb = data; socklen_t len; int error = ETIMEDOUT; gboolean is_socks4a = (proxytype == PROXY_SOCKS4A); if (phb->inpa > 0) { b_event_remove(phb->inpa); } len = sizeof(error); if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) { return phb_free(phb, FALSE); } sock_make_blocking(source); if (!is_socks4a && !(hp = gethostbyname(phb->host))) { return phb_free(phb, FALSE); } packet[0] = 4; packet[1] = 1; packet[2] = phb->port >> 8; packet[3] = phb->port & 0xff; if (is_socks4a) { packet[4] = 0; packet[5] = 0; packet[6] = 0; packet[7] = 1; } else { packet[4] = (unsigned char) (hp->h_addr_list[0])[0]; packet[5] = (unsigned char) (hp->h_addr_list[0])[1]; packet[6] = (unsigned char) (hp->h_addr_list[0])[2]; packet[7] = (unsigned char) (hp->h_addr_list[0])[3]; } packet[8] = 0; if (write(source, packet, 9) != 9) { return phb_free(phb, FALSE); } if (is_socks4a) { size_t host_len = strlen(phb->host) + 1; /* include the \0 */ if (write(source, phb->host, host_len) != host_len) { return phb_free(phb, FALSE); } } phb->inpa = b_input_add(source, B_EV_IO_READ, s4_canread, phb); return FALSE; }
gboolean cmd_identify_finish(gpointer data, gint fd, b_input_condition cond) { char *account_on[] = { "account", "on", NULL }; irc_t *irc = data; if (set_getbool(&irc->b->set, "auto_connect")) { cmd_account(irc, account_on); } b_event_remove(irc->login_source_id); irc->login_source_id = -1; return FALSE; }
static gboolean s4_canwrite(gpointer data, gint source, b_input_condition cond) { unsigned char packet[12]; struct hostent *hp; struct PHB *phb = data; unsigned int len; int error = ETIMEDOUT; if (phb->inpa > 0) b_event_remove(phb->inpa); len = sizeof(error); if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } sock_make_blocking(source); /* XXX does socks4 not support host name lookups by the proxy? */ if (!(hp = gethostbyname(phb->host))) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } packet[0] = 4; packet[1] = 1; packet[2] = phb->port >> 8; packet[3] = phb->port & 0xff; packet[4] = (unsigned char)(hp->h_addr_list[0])[0]; packet[5] = (unsigned char)(hp->h_addr_list[0])[1]; packet[6] = (unsigned char)(hp->h_addr_list[0])[2]; packet[7] = (unsigned char)(hp->h_addr_list[0])[3]; packet[8] = 0; if (write(source, packet, 9) != 9) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } phb->inpa = b_input_add(source, GAIM_INPUT_READ, s4_canread, phb); return FALSE; }
static gboolean s4_canread(gpointer data, gint source, b_input_condition cond) { unsigned char packet[12]; struct PHB *phb = data; b_event_remove(phb->inpa); memset(packet, 0, sizeof(packet)); if (read(source, packet, 9) >= 4 && packet[1] == 90) { phb->func(phb->data, source, B_EV_IO_READ); return phb_free(phb, TRUE); } return phb_free(phb, FALSE); }
void ssl_disconnect( void *conn_ ) { struct scd *conn = conn_; if( conn->inpa != -1 ) b_event_remove( conn->inpa ); if( conn->established ) gnutls_bye( conn->session, GNUTLS_SHUT_WR ); closesocket( conn->fd ); if( conn->session ) gnutls_deinit( conn->session ); g_free( conn ); }
void ssl_disconnect(void *conn_) { struct scd *conn = conn_; if (conn->inpa != -1) { b_event_remove(conn->inpa); } if (conn->established) { SSL_shutdown(conn->ssl); } closesocket(conn->fd); ssl_conn_free(conn); }
void msn_ns_close( struct msn_handler_data *handler ) { if( handler->fd >= 0 ) { closesocket( handler->fd ); b_event_remove( handler->inpa ); } handler->fd = handler->inpa = -1; g_free( handler->rxq ); g_free( handler->cmd_text ); handler->rxlen = 0; handler->rxq = NULL; handler->cmd_text = NULL; }
int irc_channel_free(irc_channel_t *ic) { irc_t *irc; GSList *l; if (ic == NULL) { return 0; } irc = ic->irc; if (ic->flags & IRC_CHANNEL_JOINED) { irc_channel_del_user(ic, irc->user, IRC_CDU_KICK, "Cleaning up channel"); } if (ic->f->_free) { ic->f->_free(ic); } while (ic->set) { set_del(&ic->set, ic->set->key); } irc->channels = g_slist_remove(irc->channels, ic); while (ic->users) { g_free(ic->users->data); ic->users = g_slist_remove(ic->users, ic->users->data); } for (l = irc->users; l; l = l->next) { irc_user_t *iu = l->data; if (iu->last_channel == ic) { iu->last_channel = irc->default_channel; } } if (ic->pastebuf_timer) { b_event_remove(ic->pastebuf_timer); } g_free(ic->name); g_free(ic->topic); g_free(ic->topic_who); g_free(ic); return 1; }
static gssize prplcb_xfer_write( PurpleXfer *xfer, const guchar *buffer, gssize size ) { struct prpl_xfer_data *px = xfer->ui_data; gboolean st; fprintf( stderr, "xfer_write %d %d\n", size, px->buf_len ); b_event_remove( px->ready_timer ); px->ready_timer = 0; st = px->ft->write( px->ft, (char*) buffer, size ); if( st && xfer->bytes_remaining == size ) imcb_file_finished( px->ft ); return st ? size : 0; }
static gboolean s5_canread_again(gpointer data, gint source, b_input_condition cond) { unsigned char buf[512]; struct PHB *phb = data; b_event_remove(phb->inpa); if (read(source, buf, 10) < 10) { return phb_free(phb, FALSE); } if ((buf[0] != 0x05) || (buf[1] != 0x00)) { return phb_free(phb, FALSE); } phb->func(phb->data, source, B_EV_IO_READ); return phb_free(phb, TRUE); }
static void ipc_master_cmd_deaf( irc_t *data, char **cmd ) { if( global.conf->runmode == RUNMODE_DAEMON ) { b_event_remove( global.listen_watch_source_id ); close( global.listen_socket ); global.listen_socket = global.listen_watch_source_id = -1; ipc_to_children_str( "OPERMSG :Closed listening socket, waiting " "for all users to disconnect." ); } else { ipc_to_children_str( "OPERMSG :The DEAF command only works in " "normal daemon mode. Try DIE instead." ); } }
static gboolean s5_canwrite(gpointer data, gint source, b_input_condition cond) { unsigned char buf[512]; int i; struct PHB *phb = data; unsigned int len; int error = ETIMEDOUT; if (phb->inpa > 0) b_event_remove(phb->inpa); len = sizeof(error); if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } sock_make_blocking(source); i = 0; buf[0] = 0x05; /* SOCKS version 5 */ if (proxyuser[0]) { buf[1] = 0x02; /* two methods */ buf[2] = 0x00; /* no authentication */ buf[3] = 0x02; /* username/password authentication */ i = 4; } else { buf[1] = 0x01; buf[2] = 0x00; i = 3; } if (write(source, buf, i) < i) { close(source); phb->func(phb->data, -1, GAIM_INPUT_READ); g_free(phb->host); g_free(phb); return FALSE; } phb->inpa = b_input_add(source, GAIM_INPUT_READ, s5_canread, phb); return FALSE; }
static gboolean s5_readauth(gpointer data, gint source, b_input_condition cond) { unsigned char buf[512]; struct PHB *phb = data; b_event_remove(phb->inpa); if (read(source, buf, 2) < 2) { return phb_free(phb, FALSE); } if ((buf[0] != 0x01) || (buf[1] != 0x00)) { return phb_free(phb, FALSE); } s5_sendconnect(phb, source); return FALSE; }