zynk/irssi
2
0
Fork 0
mirror of https://github.com/irssi/irssi.git synced 2026-08-22 18:12:12 +02:00
Code Issues Projects Releases Packages Wiki Activity

Change coding style

Browse source 
Based on original patch by hawken93 <hawken@thehawken.org> 3 Oct 2014
This commit is contained in:
Bob Mottram 2016-04-14 12:21:37 +01:00
commit 4a8a6cfcbf
14 changed files with 301 additions and 169 deletions
Download patch file Download diff file Expand all files Collapse all files

5
TODO
View file

@ -1,3 +1,8 @@
- New proxy code crashes if an invalid proxy_type setting is used
- Remove old socks code
- Lots of warnings at least when using socks5
- Clean up coding style
19:36 [IRCNet] [muzzy] more bugs in irssi, apparently the new version: foo splits out,
bar joins, bar changes his nick to foo, foo splits again ->
Glib warning "is already in split list (how?)" .. :)

2
src/core/network-openssl.c
View file

@ -565,7 +565,7 @@ static GIOChannel *irssi_ssl_get_iochannel(GIOChannel *handle, int port, SERVER_
return gchan;
}
GIOChannel *net_connect_proxy_ssl(struct network_proxy const *proxy, char const *host, int port,
GIOChannel *net_connect_proxy_ssl(const struct network_proxy *proxy, const char *host, int port,
IPADDR *ip, IPADDR *my_ip, SERVER_REC *server)
{
GIOChannel *handle, *ssl_handle;

66
src/core/network-proxy-http.c
View file

@ -25,10 +25,9 @@
#include "network.h"
#include "network-proxy-priv.h"
static void
network_proxy_http_destroy(struct network_proxy *proxy)
static void network_proxy_http_destroy(struct network_proxy *proxy)
{
struct _network_proxy_http *self = container_of(proxy, struct _network_proxy_http, proxy);
struct _network_proxy_http *self = container_of(proxy, struct _network_proxy_http, proxy);
g_free((void *)self->password);
_network_proxy_destroy(proxy);
@ -39,8 +38,8 @@ network_proxy_http_destroy(struct network_proxy *proxy)
static struct network_proxy *
network_proxy_http_clone(struct network_proxy const *proxy)
{
struct _network_proxy_http *self = container_of(proxy, struct _network_proxy_http, proxy);
struct _network_proxy_http *res;
struct _network_proxy_http *self = container_of(proxy, struct _network_proxy_http, proxy);
struct _network_proxy_http *res;
res = g_malloc0(sizeof *res);
@ -49,18 +48,18 @@ network_proxy_http_clone(struct network_proxy const *proxy)
return &res->proxy;
}
static bool
send_connect(struct _network_proxy_http *proxy, GIOChannel *ch, char const *address, uint16_t port)
static bool send_connect(struct _network_proxy_http *proxy, GIOChannel *ch,
char const *address, uint16_t port)
{
char port_str[6];
char port_str[6];
(void)proxy;
sprintf(port_str, "%u", port);
if (!_network_proxy_send_all(ch, "CONNECT ", -1) ||
!_network_proxy_send_all(ch, address, -1) ||
!_network_proxy_send_all(ch, ":", -1) ||
!_network_proxy_send_all(ch, port_str, -1) ||
!_network_proxy_send_all(ch, address, -1) ||
!_network_proxy_send_all(ch, ":", -1) ||
!_network_proxy_send_all(ch, port_str, -1) ||
!_network_proxy_send_all(ch, " HTTP/1.0\r\n\r\n", -1) ||
!_network_proxy_flush(ch))
return false;
@ -68,16 +67,15 @@ send_connect(struct _network_proxy_http *proxy, GIOChannel *ch, char const *addr
return true;
}
static int
read_response(struct _network_proxy_http *proxy, GIOChannel *ch)
static int read_response(struct _network_proxy_http *proxy, GIOChannel *ch)
{
GIOStatus status;
GString line = { .str = NULL };
gsize term_pos;
GError *err = NULL;
int state = 0;
int rc = 0;
gchar *resp = NULL;
GIOStatus status;
GString line = { .str = NULL };
gsize term_pos;
GError *err = NULL;
int state = 0;
int rc = 0;
gchar *resp = NULL;
(void)proxy;
for (;;) {
@ -97,7 +95,7 @@ read_response(struct _network_proxy_http *proxy, GIOChannel *ch)
if (state==0) {
if (g_str_has_prefix(line.str, "HTTP/1.0 ")) {
resp = g_strndup(line.str+9, line.len-9-2);
rc = g_ascii_strtoull(resp, NULL, 10);
rc = g_ascii_strtoull(resp, NULL, 10);
} else {
g_warning("unexpected HTTP response: '%s'", line.str);
goto err;
@ -125,16 +123,15 @@ err:
return -1;
}
static GIOChannel *
network_proxy_http_connect(struct network_proxy const *proxy, IPADDR const *hint_ip,
char const *address, int port)
static GIOChannel *network_proxy_http_connect(struct network_proxy const *proxy, IPADDR const *hint_ip,
char const *address, int port)
{
struct _network_proxy_http *self = container_of(proxy, struct _network_proxy_http, proxy);
GIOChannel *ch;
GIOFlags old_flags;
GError *err = NULL;
gchar const *line_term;
gint line_term_sz;
struct _network_proxy_http *self = container_of(proxy, struct _network_proxy_http, proxy);
GIOChannel *ch;
GIOFlags old_flags;
GError *err = NULL;
gchar const *line_term;
gint line_term_sz;
if (hint_ip)
ch = net_connect_ip(hint_ip, self->proxy.port, NULL);
@ -175,19 +172,18 @@ err:
}
struct network_proxy *
_network_proxy_http_create(void)
struct network_proxy *_network_proxy_http_create(void)
{
struct _network_proxy_http *res;
struct _network_proxy_http *res;
res = g_malloc0(sizeof *res);
_network_proxy_create(&res->proxy);
res->password = g_strdup(settings_get_str("proxy_password"));
res->password = g_strdup(settings_get_str("proxy_password"));
res->proxy.destroy = network_proxy_http_destroy;
res->proxy.connect = network_proxy_http_connect;
res->proxy.clone = network_proxy_http_clone;
res->proxy.clone = network_proxy_http_clone;
return &res->proxy;
}

6
src/core/network-proxy-http.h
View file

@ -20,10 +20,10 @@
#include "network-proxy.h"
struct _network_proxy_http {
struct network_proxy proxy;
char const *password;
struct network_proxy proxy;
char const *password;
};
struct network_proxy * _network_proxy_http_create(void);
struct network_proxy *_network_proxy_http_create(void);
#endif /* H_IRSSI_SRC_CORE_PROXY_HTTP_H */

46
src/core/network-proxy-priv.h
View file

@ -26,38 +26,34 @@
(type *)( (char *)__mptr - offsetof(type,member) );})
inline static void
_network_proxy_create(struct network_proxy *dst)
inline static void _network_proxy_create(struct network_proxy *dst)
{
dst->port = settings_get_int("proxy_port");
dst->host = g_strdup(settings_get_str("proxy_address"));
dst->port = settings_get_int("proxy_port");
dst->host = g_strdup(settings_get_str("proxy_address"));
}
inline static void
_network_proxy_clone(struct network_proxy *dst, struct network_proxy const *src)
inline static void _network_proxy_clone(struct network_proxy *dst, struct network_proxy const *src)
{
dst->host = g_strdup(src->host);
dst->port = src->port;
dst->host = g_strdup(src->host);
dst->port = src->port;
dst->destroy = src->destroy;
dst->connect = src->connect;
dst->clone = src->clone;
dst->clone = src->clone;
}
inline static void
_network_proxy_destroy(struct network_proxy *proxy)
inline static void _network_proxy_destroy(struct network_proxy *proxy)
{
g_free((void *)proxy->host);
}
inline static bool
_network_proxy_send_all(GIOChannel *ch, void const *buf, ssize_t len)
inline static bool _network_proxy_send_all(GIOChannel *ch, void const *buf, ssize_t len)
{
GError *err = NULL;
gsize written;
GIOStatus status;
GError *err = NULL;
gsize written;
GIOStatus status;
while ((status=g_io_channel_write_chars(ch, buf, len, &written,
&err))==G_IO_STATUS_AGAIN)
@ -74,15 +70,14 @@ _network_proxy_send_all(GIOChannel *ch, void const *buf, ssize_t len)
return false;
}
inline static bool
_network_proxy_recv_all(GIOChannel *ch, void *buf_v, size_t len)
inline static bool _network_proxy_recv_all(GIOChannel *ch, void *buf_v, size_t len)
{
GError *err = NULL;
gchar *buf = buf_v;
GError *err = NULL;
gchar *buf = buf_v;
while (len>0) {
GIOStatus status;
gsize l;
GIOStatus status;
gsize l;
status = g_io_channel_read_chars(ch, buf, len, &l, &err);
if (status==G_IO_STATUS_AGAIN)
@ -105,11 +100,10 @@ _network_proxy_recv_all(GIOChannel *ch, void *buf_v, size_t len)
return false;
}
inline static bool
_network_proxy_flush(GIOChannel *ch)
inline static bool _network_proxy_flush(GIOChannel *ch)
{
GError *err = NULL;
GIOStatus status;
GError *err = NULL;
GIOStatus status;
while ((status=g_io_channel_flush(ch, &err))==G_IO_STATUS_AGAIN)
continue;

128
src/core/network-proxy-simple.c Normal file
View file

@ -0,0 +1,128 @@
/*
network-proxy-simple.c : irssi
Copyright (C) 2008 Enrico Scholz <enrico.scholz@informatik.tu-chemnitz.de>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 and/or 3 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "module.h"
#include "network-proxy-simple.h"
#include "network-proxy-priv.h"
#include "network.h"
static void network_proxy_simple_destroy(struct network_proxy *proxy)
{
struct network_proxy_simple *self = (struct network_proxy_simple *)proxy->privdata;
g_free(self->password);
g_free(self->string_after);
g_free(self->string);
g_free(self);
_network_proxy_destroy(proxy);
// We are responsible for the whole proxy struct
g_free(proxy);
}
static struct network_proxy *network_proxy_simple_clone(const struct network_proxy *proxy)
{
struct network_proxy_simple *self = (struct network_proxy_simple *)proxy->privdata;
struct network_proxy *res;
struct network_proxy_simple *newself;
// First make and set the parent struct
res = g_malloc0(sizeof(struct network_proxy));
_network_proxy_clone(res, proxy);
// Then allocate and set the private data
newself = g_malloc0(sizeof(struct network_proxy_simple));
res->privdata = (void *)newself;
newself->string = g_strdup(self->string);
newself->string_after = g_strdup(self->string_after);
newself->password = g_strdup(self->password);
return res;
}
static GIOChannel *network_proxy_simple_connect(const struct network_proxy *proxy,
const IPADDR *hint_ip, char const *address, int port)
{
if (hint_ip)
return net_connect_ip(hint_ip, proxy->port, NULL);
else
return net_connect(proxy->host, proxy->port, NULL);
}
static void network_proxy_simple_send_string(const struct network_proxy *proxy,
const struct network_proxy_send_string_info *info)
{
struct network_proxy_simple *self = (struct network_proxy_simple *)proxy->privdata;
char *cmd;
if (self->password && self->password[0]) {
cmd = g_strdup_printf("PASS %s", self->password);
info->func(info->obj, cmd);
g_free(cmd);
}
if (self->string && self->string[0]) {
cmd = g_strdup_printf(self->string, info->host, info->port);
info->func(info->obj, cmd);
g_free(cmd);
}
}
static void network_proxy_simple_send_string_after(const struct network_proxy *proxy,
const struct network_proxy_send_string_info *info)
{
struct network_proxy_simple *self = (struct network_proxy_simple *)proxy->privdata;
char *cmd;
if (self->string_after && self->string_after[0]) {
cmd = g_strdup_printf(self->string_after, info->host, info->port);
info->func(info->obj, cmd);
g_free(cmd);
}
}
struct network_proxy *network_proxy_simple_create(void)
{
struct network_proxy *proxy;
struct network_proxy_simple *self;
proxy = g_malloc0(sizeof(struct network_proxy));
// assume it could reset every variable to a known state
_network_proxy_create(proxy);
self = g_malloc0(sizeof(struct network_proxy_simple));
proxy->privdata = (void *)self;
self->string = g_strdup(settings_get_str("proxy_string"));
self->string_after = g_strdup(settings_get_str("proxy_string_after"));
self->password = g_strdup(settings_get_str("proxy_password"));
proxy->destroy = network_proxy_simple_destroy;
proxy->connect = network_proxy_simple_connect;
proxy->clone = network_proxy_simple_clone;
proxy->send_string = network_proxy_simple_send_string;
proxy->send_string_after = network_proxy_simple_send_string_after;
return proxy;
}

14
src/core/network-proxy-simple.h Normal file
View file

@ -0,0 +1,14 @@
#ifndef H_IRSSI_SRC_CORE_PROXY_SIMPLE_H
#define H_IRSSI_SRC_CORE_PROXY_SIMPLE_H
#include "network-proxy.h"
struct network_proxy_simple {
char *string_after;
char *string;
char *password;
};
struct network_proxy *network_proxy_simple_create(void);
#endif

141
src/core/network-proxy-socks5.c
View file

@ -26,45 +26,44 @@
/* RFC 1928 */
struct client_greeting
{
uint8_t ver;
uint8_t nmethods;
uint8_t methods[];
uint8_t ver;
uint8_t nmethods;
uint8_t methods[];
} __attribute__((__packed__));
struct server_greeting
{
uint8_t ver;
uint8_t method;
uint8_t ver;
uint8_t method;
} __attribute__((__packed__));
struct server_response_plain
{
uint8_t ver;
uint8_t status;
uint8_t ver;
uint8_t status;
} __attribute__((__packed__));
struct client_request
{
uint8_t ver;
uint8_t cmd;
uint8_t rsv;
uint8_t atyp;
uint8_t dst[];
uint8_t ver;
uint8_t cmd;
uint8_t rsv;
uint8_t atyp;
uint8_t dst[];
} __attribute__((__packed__));
struct server_response
{
uint8_t ver;
uint8_t rep;
uint8_t res;
uint8_t atyp;
uint8_t bnd[];
uint8_t ver;
uint8_t rep;
uint8_t res;
uint8_t atyp;
uint8_t bnd[];
} __attribute__((__packed__));
static void
network_proxy_socks5_destroy(struct network_proxy *proxy)
static void network_proxy_socks5_destroy(struct network_proxy *proxy)
{
struct _network_proxy_socks5 *self = container_of(proxy, struct _network_proxy_socks5, proxy);
struct _network_proxy_socks5 *self = container_of(proxy, struct _network_proxy_socks5, proxy);
g_free((void *)self->password);
g_free((void *)self->username);
@ -72,11 +71,10 @@ network_proxy_socks5_destroy(struct network_proxy *proxy)
g_free(self);
}
static struct network_proxy *
network_proxy_socks5_clone(struct network_proxy const *proxy)
static struct network_proxy *network_proxy_socks5_clone(struct network_proxy const *proxy)
{
struct _network_proxy_socks5 *self = container_of(proxy, struct _network_proxy_socks5, proxy);
struct _network_proxy_socks5 *res;
struct _network_proxy_socks5 *self = container_of(proxy, struct _network_proxy_socks5, proxy);
struct _network_proxy_socks5 *res;
res = g_malloc0(sizeof *res);
@ -86,8 +84,7 @@ network_proxy_socks5_clone(struct network_proxy const *proxy)
return &res->proxy;
}
static bool
socks5_connect_unauthorized(GIOChannel *ch)
static bool socks5_connect_unauthorized(GIOChannel *ch)
{
/* nothing to do here */
(void)ch;
@ -95,12 +92,11 @@ socks5_connect_unauthorized(GIOChannel *ch)
}
/* TODO: test this method! */
static bool
socks5_connect_plain(struct _network_proxy_socks5 const *proxy, GIOChannel *ch)
static bool socks5_connect_plain(struct _network_proxy_socks5 const *proxy, GIOChannel *ch)
{
uint8_t ver = 0x01;
uint8_t ulen = strlen(proxy->username);
uint8_t plen = proxy->password ? strlen(proxy->password) : 0;
uint8_t ver = 0x01;
uint8_t ulen = strlen(proxy->username);
uint8_t plen = proxy->password ? strlen(proxy->password) : 0;
struct server_response_plain resp;
if (ulen==0 ||
@ -126,30 +122,29 @@ socks5_connect_plain(struct _network_proxy_socks5 const *proxy, GIOChannel *ch)
return true;
}
static bool
socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
char const *address, uint16_t port)
static bool socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
char const *address, uint16_t port)
{
bool rc;
bool rc;
struct server_greeting s_greeting;
struct server_response s_response;
struct server_greeting s_greeting;
struct server_response s_response;
/* Phase 1: exchange greeting */
{
struct client_greeting c_greeting = {
struct client_greeting c_greeting = {
.ver = 0x05,
.nmethods = proxy->username && proxy->username[0] ? 2 : 1
};
/* HACK: order is important because it depends upon
* c_greeting.nmethods */
char const methods[] = {
0x00, /* no authentication */
0x02 /* username/password */
char const methods[] = {
0x00, /* no authentication */
0x02 /* username/password */
};
if (!_network_proxy_send_all(ch, &c_greeting, sizeof c_greeting) ||
!_network_proxy_send_all(ch, methods, c_greeting.nmethods) ||
!_network_proxy_send_all(ch, methods, c_greeting.nmethods) ||
!_network_proxy_flush(ch) ||
!_network_proxy_recv_all(ch, &s_greeting, sizeof s_greeting))
goto err;
@ -178,21 +173,21 @@ socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
/* Phase 3: connection request */
{
struct client_request c_request = {
.ver = 0x05,
.cmd = 0x01, /* CONNECT */
.atyp = 0x03, /* domain name */
.ver = 0x05,
.cmd = 0x01, /* CONNECT */
.atyp = 0x03, /* domain name */
};
uint8_t address_len = strlen(address);
uint16_t dst_port = htons(port);
uint16_t bnd_port;
char bnd_address[257];
uint8_t address_len = strlen(address);
uint16_t dst_port = htons(port);
uint16_t bnd_port;
char bnd_address[257];
if (!_network_proxy_send_all(ch, &c_request, sizeof c_request) ||
if (!_network_proxy_send_all(ch, &c_request, sizeof c_request) ||
!_network_proxy_send_all(ch, &address_len, sizeof address_len) ||
!_network_proxy_send_all(ch, address, address_len) ||
!_network_proxy_send_all(ch, &dst_port, sizeof dst_port) ||
!_network_proxy_send_all(ch, address, address_len) ||
!_network_proxy_send_all(ch, &dst_port, sizeof dst_port) ||
!_network_proxy_flush(ch) ||
!_network_proxy_recv_all(ch, &s_response, sizeof s_response))
!_network_proxy_recv_all(ch, &s_response, sizeof s_response))
goto err;
if (s_response.ver != 0x05) {
@ -212,7 +207,7 @@ socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
case 0x06: g_warning("SOCKS5: TTL expired"); break;
case 0x07: g_warning("SOCKS5: Command not supported"); break;
case 0x08: g_warning("SOCKS5: Address type not supported"); break;
default: g_warning("SOCKS5: unknown error %#04x", s_response.rep); break;
default: g_warning("SOCKS5: unknown error %#04x", s_response.rep); break;
}
if (!rc)
@ -221,7 +216,7 @@ socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
switch(s_response.atyp) {
case 0x01: {
struct in_addr ip;
if (!_network_proxy_recv_all(ch, &ip, sizeof ip) ||
if (!_network_proxy_recv_all(ch, &ip, sizeof ip) ||
!inet_ntop(AF_INET, &ip, bnd_address, sizeof bnd_address))
rc = false;
break;
@ -229,14 +224,14 @@ socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
case 0x04: {
struct in6_addr ip;
if (!_network_proxy_recv_all(ch, &ip, sizeof ip) ||
if (!_network_proxy_recv_all(ch, &ip, sizeof ip) ||
!inet_ntop(AF_INET6, &ip, bnd_address, sizeof bnd_address))
rc = false;
break;
}
case 0x03: {
uint8_t tmp;
uint8_t tmp;
if (!_network_proxy_recv_all(ch, &tmp, sizeof tmp) ||
tmp==0 ||
!_network_proxy_recv_all(ch, &bnd_address, tmp))
@ -267,17 +262,16 @@ err:
}
static GIOChannel *
network_proxy_socks5_connect(struct network_proxy const *proxy, IPADDR const *hint_ip,
char const *address, int port)
static GIOChannel *network_proxy_socks5_connect(struct network_proxy const *proxy, IPADDR const *hint_ip,
char const *address, int port)
{
struct _network_proxy_socks5 *self = container_of(proxy, struct _network_proxy_socks5, proxy);
GIOChannel *ch;
struct _network_proxy_socks5 *self = container_of(proxy, struct _network_proxy_socks5, proxy);
GIOChannel *ch;
GIOFlags old_flags;
gchar const *old_enc;
gboolean old_buf;
GError *err = NULL;
GIOFlags old_flags;
gchar const *old_enc;
gboolean old_buf;
GError *err = NULL;
if (hint_ip)
ch = net_connect_ip(hint_ip, self->proxy.port, NULL);
@ -287,9 +281,9 @@ network_proxy_socks5_connect(struct network_proxy const *proxy, IPADDR const *hi
if (!ch)
return NULL;
old_enc = g_io_channel_get_encoding(ch);
old_enc = g_io_channel_get_encoding(ch);
old_flags = g_io_channel_get_flags(ch);
old_buf = g_io_channel_get_buffered(ch);
old_buf = g_io_channel_get_buffered(ch);
if (g_io_channel_set_encoding(ch, NULL, &err)!=G_IO_STATUS_NORMAL ||
g_io_channel_set_flags(ch, old_flags & ~G_IO_FLAG_NONBLOCK, &err)!=G_IO_STATUS_NORMAL)
@ -319,20 +313,19 @@ err:
return NULL;
}
struct network_proxy *
_network_proxy_socks5_create(void)
struct network_proxy *_network_proxy_socks5_create(void)
{
struct _network_proxy_socks5 *res;
struct _network_proxy_socks5 *res;
res = g_malloc0(sizeof *res);
_network_proxy_create(&res->proxy);
res->username = g_strdup(settings_get_str("proxy_username"));
res->password = g_strdup(settings_get_str("proxy_password"));
res->username = g_strdup(settings_get_str("proxy_username"));
res->password = g_strdup(settings_get_str("proxy_password"));
res->proxy.destroy = network_proxy_socks5_destroy;
res->proxy.connect = network_proxy_socks5_connect;
res->proxy.clone = network_proxy_socks5_clone;
res->proxy.clone = network_proxy_socks5_clone;
return &res->proxy;
}

8
src/core/network-proxy-socks5.h
View file

@ -20,12 +20,12 @@
#include "network-proxy.h"
struct _network_proxy_socks5 {
struct network_proxy proxy;
struct network_proxy proxy;
char const *username;
char const *password;
char const *username;
char const *password;
};
struct network_proxy * _network_proxy_socks5_create(void);
struct network_proxy *_network_proxy_socks5_create(void);
#endif /* H_IRSSI_SRC_CORE_PROXY_SOCKS5_H */

28
src/core/network-proxy.h
View file

@ -24,20 +24,20 @@
* class */
struct network_proxy_send_string_info
{
char const *host; /* hostname of the IRC server */
uint16_t port; /* portnumber of the IRC server */
char const *host; /* hostname of the IRC server */
uint16_t port; /* portnumber of the IRC server */
/* function which is used to send string; usually irc_send_cmd_now() */
void (*func)(void *obj, char const *);
void (*func)(void *obj, char const *);
/* object for func */
void *obj;
void *obj;
};
struct network_proxy {
/* destroys the network_proxy structure which must not be used anymore
* after; this memberfunction is mandatory */
void (*destroy)(struct network_proxy *);
void (*destroy)(struct network_proxy *);
/* connects through the proxy; this memberfunction is mandatory
*
@ -46,36 +46,36 @@ struct network_proxy {
* \arg address the hostname where proxy shall connect to
* \arg port port address where proxy shall connect to
*/
GIOChannel * (*connect)(struct network_proxy const *, IPADDR const *hint_ip,
GIOChannel *(*connect)(struct network_proxy const *, IPADDR const *hint_ip,
char const *address, int port);
/* clones the given network_proxy object; this memberfunction is
* mandatory */
struct network_proxy * (*clone)(struct network_proxy const *);
struct network_proxy * (*clone)(struct network_proxy const *);
/* sends a string after connection has been established but before IRC
* authentication begins; this memberfunction is optional
*/
void (*send_string)(struct network_proxy const *,
struct network_proxy_send_string_info const *);
void (*send_string)(struct network_proxy const *,
struct network_proxy_send_string_info const *);
/* sends a string after connection IRC authentication suceeded; this
* memberfunction is optional
*/
void (*send_string_after)(struct network_proxy const *,
struct network_proxy_send_string_info const *);
void (*send_string_after)(struct network_proxy const *,
struct network_proxy_send_string_info const *);
/* hostname of proxy host */
char const *host;
char const *host;
/* portnumber of proxy */
int port;
int port;
};
/* factory method to create a proxy object based upon value of 'type' */
struct network_proxy * network_proxy_create(char const *type);
struct network_proxy *network_proxy_create(char const *type);
#endif /* H_IRSSI_SRC_CORE_PROXY_H */

4
src/core/network.c
View file

@ -198,8 +198,8 @@ GIOChannel *net_connect_ip(IPADDR *ip, int port, IPADDR *my_ip)
}
/* Connect to socket */
GIOChannel *net_connect_proxy(struct network_proxy const *proxy,
char const *host, int port, IPADDR *ip, IPADDR *my_ip)
GIOChannel *net_connect_proxy(const struct network_proxy *proxy,
const char *host, int port, IPADDR *ip, IPADDR *my_ip)
{
if (proxy)
return proxy->connect(proxy, ip, host, port);

10
src/core/network.h
View file

@ -20,8 +20,8 @@
#endif
struct _IPADDR {
unsigned short family;
struct in6_addr ip;
unsigned short family;
struct in6_addr ip;
};
/* maxmimum string length of IP address */
@ -40,12 +40,14 @@ int net_ip_compare(IPADDR *ip1, IPADDR *ip2);
/* Connect to socket */
GIOChannel *net_connect(const char *addr, int port, IPADDR *my_ip);
/* Connect to socket with ip address and SSL*/
GIOChannel *net_connect_proxy_ssl(struct network_proxy const *proxy, char const *host, int port, IPADDR *ip, IPADDR *my_ip, SERVER_REC *server);
GIOChannel *net_connect_proxy_ssl(const struct network_proxy *proxy, const char c*host, int port,
IPADDR *ip, IPADDR *my_ip, SERVER_REC *server);
int irssi_ssl_handshake(GIOChannel *handle);
/* Connect to socket with ip address */
GIOChannel *net_connect_ip(IPADDR *ip, int port, IPADDR *my_ip);
GIOChannel *net_connect_proxy(struct network_proxy const *proxy, char const *host, int port, IPADDR *ip, IPADDR *my_ip);
GIOChannel *net_connect_proxy(const struct network_proxy *proxy, const char *host, int port,
IPADDR *ip, IPADDR *my_ip);
/* Connect to named UNIX socket */
GIOChannel *net_connect_unix(const char *path);
/* Disconnect socket */

2
src/core/server-connect-rec.h
View file

@ -5,7 +5,7 @@ int chat_type; /* chat_protocol_lookup(xx) */
int refcount;
struct network_proxy *proxy;
struct network_proxy *proxy;
unsigned short family; /* 0 = don't care, AF_INET or AF_INET6 */
char *tag; /* try to keep this tag when connected to server */

10
src/irc/core/irc-servers.c
View file

@ -215,11 +215,11 @@ static void server_init(IRC_SERVER_REC *server)
char *address, *ptr, *username, *cmd;
GTimeVal now;
struct network_proxy_send_string_info const send_info = {
.host = server->connrec->address,
.port = server->connrec->port,
.func = irc_send_cmd_now_wrapper,
.obj = server
const struct network_proxy_send_string_info send_info = {
.host = server->connrec->address,
.port = server->connrec->port,
.func = irc_send_cmd_now_wrapper,
.obj = server
};
g_return_if_fail(server != NULL);