int
main (int argc, char *argv[])
{
int i;
int ret;
// BEGIN NEW CODE
server *fake_serv;
GIOChannel *channel;
session *sess;
// END NEW CODE
#ifdef WIN32
HRESULT coinit_result;
#endif
srand ((unsigned int) time (NULL)); /* CL: do this only once! */
/* We must check for the config dir parameter, otherwise load_config() will behave incorrectly.
* load_config() must come before fe_args() because fe_args() calls gtk_init() which needs to
* know the language which is set in the config. The code below is copy-pasted from fe_args()
* for the most part. */
if (argc >= 2)
{
for (i = 1; i < argc; i++)
{
if ((strcmp (argv[i], "-d") == 0 || strcmp (argv[i], "--cfgdir") == 0)
&& i + 1 < argc)
{
xdir = g_strdup (argv[i + 1]);
}
else if (strncmp (argv[i], "--cfgdir=", 9) == 0)
{
xdir = g_strdup (argv[i] + 9);
}
if (xdir != NULL)
{
if (xdir[strlen (xdir) - 1] == G_DIR_SEPARATOR)
{
xdir[strlen (xdir) - 1] = 0;
}
break;
}
}
}
#if ! GLIB_CHECK_VERSION (2, 36, 0)
// RFM: Don't think we hit this
g_type_init ();
#endif
if (check_config_dir () == 0)
{
if (load_config () != 0)
load_default_config ();
} else
{
/* this is probably the first run */
load_default_config ();
make_config_dirs ();
make_dcc_dirs ();
}
/* we MUST do this after load_config () AND before fe_init (thus gtk_init) otherwise it will fail */
// RFM: Does nothing on *NIX
set_locale ();
// RFM: Parses some command line crap. Not important
ret = fe_args (argc, argv);
if (ret != -1)
return ret;
#ifdef USE_DBUS
hexchat_remote ();
#endif
#ifdef USE_LIBPROXY
// RFM: Not using
libproxy_factory = px_proxy_factory_new();
#endif
#ifdef WIN32
coinit_result = CoInitializeEx (NULL, COINIT_APARTMENTTHREADED);
if (SUCCEEDED (coinit_result))
{
CoInitializeSecurity (NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL);
}
#endif
// RFM: Inits some fe-text stuff
fe_init ();
// RFM: Pretty sure this just allows us to save chats...
/* This is done here because cfgfiles.c is too early in
* the startup process to use gtk functions. */
if (g_access (get_xdir (), W_OK) != 0)
{
char buf[2048];
g_snprintf (buf, sizeof(buf),
_("You do not have write access to %s. Nothing from this session can be saved."),
get_xdir ());
fe_message (buf, FE_MSG_ERROR);
}
// RFM: Checks if root on *NIX
#ifndef WIN32
#ifndef __EMX__
/* OS/2 uses UID 0 all the time */
if (getuid () == 0)
fe_message (_("* Running IRC as root is stupid! You should\n"
" create a User Account and use that to login.\n"), FE_MSG_WARN|FE_MSG_WAIT);
#endif
#endif /* !WIN32 */
// RFM: Loads a bunch of configure options
xchat_init ();
// BEGIN NEW CODE
fake_serv = server_new();
fake_serv->sok = STDIN_FILENO;
// fake_serv->pos = 0; //???
sess = session_new(fake_serv, "fake_sess", SESS_CHANNEL, 0);
fake_serv->server_session = sess;
fake_serv->front_session = sess;
channel = g_io_channel_unix_new(STDIN_FILENO);
g_io_add_watch(channel, G_IO_IN, (GIOFunc)server_read, fake_serv);
//g_io_add_watch(channel, G_IO_IN, (GIOFunc)io_callback, fake_serv);
g_io_channel_unref(channel);
// END NEW CODE
fe_main ();
#ifdef WIN32
if (SUCCEEDED (coinit_result))
{
CoUninitialize ();
}
#endif
#ifdef USE_LIBPROXY
px_proxy_factory_free(libproxy_factory);
#endif
#ifdef WIN32
WSACleanup ();
#endif
return 0;
}
int
main (int argc, char *argv[])
{
int i;
int ret;
srand (time (0)); /* CL: do this only once! */
/* We must check for the config dir parameter, otherwise load_config() will behave incorrectly.
* load_config() must come before fe_args() because fe_args() calls gtk_init() which needs to
* know the language which is set in the config. The code below is copy-pasted from fe_args()
* for the most part. */
if (argc >= 2)
{
for (i = 1; i < argc; i++)
{
if ((strcmp (argv[i], "-d") == 0 || strcmp (argv[i], "--cfgdir") == 0)
&& i + 1 < argc)
{
xdir = strdup (argv[i + 1]);
}
else if (strncmp (argv[i], "--cfgdir=", 9) == 0)
{
xdir = strdup (argv[i] + 9);
}
if (xdir != NULL)
{
if (xdir[strlen (xdir) - 1] == G_DIR_SEPARATOR)
{
xdir[strlen (xdir) - 1] = 0;
}
break;
}
}
}
#if ! GLIB_CHECK_VERSION (2, 36, 0)
g_type_init ();
#endif
if (check_config_dir () == 0)
{
if (load_config () != 0)
load_default_config ();
} else
{
/* this is probably the first run */
load_default_config ();
make_config_dirs ();
make_dcc_dirs ();
}
/* we MUST do this after load_config () AND before fe_init (thus gtk_init) otherwise it will fail */
set_locale ();
#ifdef SOCKS
SOCKSinit (argv[0]);
#endif
ret = fe_args (argc, argv);
if (ret != -1)
return ret;
#ifdef USE_DBUS
hexchat_remote ();
#endif
#ifdef USE_LIBPROXY
libproxy_factory = px_proxy_factory_new();
#endif
fe_init ();
/* This is done here because cfgfiles.c is too early in
* the startup process to use gtk functions. */
if (g_access (get_xdir (), W_OK) != 0)
{
char buf[2048];
g_snprintf (buf, sizeof(buf),
_("You do not have write access to %s. Nothing from this session can be saved."),
get_xdir ());
fe_message (buf, FE_MSG_ERROR);
}
#ifndef WIN32
#ifndef __EMX__
/* OS/2 uses UID 0 all the time */
if (getuid () == 0)
fe_message (_("* Running IRC as root is stupid! You should\n"
" create a User Account and use that to login.\n"), FE_MSG_WARN|FE_MSG_WAIT);
#endif
#endif /* !WIN32 */
xchat_init ();
fe_main ();
#ifdef USE_LIBPROXY
px_proxy_factory_free(libproxy_factory);
#endif
#ifdef WIN32
WSACleanup ();
#endif
return 0;
}
int trg_client_populate_with_settings(TrgClient * tc)
{
TrgClientPrivate *priv = tc->priv;
TrgPrefs *prefs = priv->prefs;
gint port;
gchar *host, *path;
#ifdef HAVE_LIBPROXY
pxProxyFactory *pf = NULL;
#endif
g_mutex_lock(&priv->configMutex);
trg_prefs_set_connection(prefs, trg_prefs_get_profile(prefs));
g_free(priv->url);
priv->url = NULL;
g_free(priv->username);
priv->username = NULL;
g_free(priv->password);
priv->password = NULL;
port =
trg_prefs_get_int(prefs, TRG_PREFS_KEY_PORT, TRG_PREFS_CONNECTION);
host = trg_prefs_get_string(prefs, TRG_PREFS_KEY_HOSTNAME,
TRG_PREFS_CONNECTION);
path = trg_prefs_get_string(prefs, TRG_PREFS_KEY_RPC_URL_PATH, TRG_PREFS_CONNECTION);
if (!host || strlen(host) < 1) {
g_free(host);
g_mutex_unlock(&priv->configMutex);
return TRG_NO_HOSTNAME_SET;
}
#ifndef CURL_NO_SSL
priv->ssl = trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SSL,
TRG_PREFS_CONNECTION);
priv->ssl_validate = trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SSL_VALIDATE,
TRG_PREFS_CONNECTION);
#else
priv->ssl = FALSE;
#endif
priv->url = g_strdup_printf("%s://%s:%d%s",
priv->ssl ? HTTPS_URI_PREFIX :
HTTP_URI_PREFIX, host, port, path);
g_free(host);
g_free(path);
priv->username = trg_prefs_get_string(prefs, TRG_PREFS_KEY_USERNAME,
TRG_PREFS_CONNECTION);
priv->password = trg_prefs_get_string(prefs, TRG_PREFS_KEY_PASSWORD,
TRG_PREFS_CONNECTION);
g_free(priv->proxy);
priv->proxy = NULL;
#ifdef HAVE_LIBPROXY
if ((pf = px_proxy_factory_new())) {
char **proxies = px_proxy_factory_get_proxies(pf, priv->url);
int i;
for (i = 0; proxies[i]; i++) {
if (g_str_has_prefix(proxies[i], HTTP_URI_PREFIX)
|| g_str_has_prefix(proxies[i], HTTPS_URI_PREFIX)) {
g_free(priv->proxy);
priv->proxy = proxies[i];
} else {
g_free(proxies[i]);
}
}
g_free(proxies);
px_proxy_factory_free(pf);
}
#endif
priv->configSerial++;
g_mutex_unlock(&priv->configMutex);
return 0;
}
void ne_session_system_proxy(ne_session *sess, unsigned int flags)
{
#ifdef HAVE_LIBPROXY
pxProxyFactory *pxf = px_proxy_factory_new();
struct host_info *hi, **lasthi;
char *url, **proxies;
ne_uri uri;
unsigned n;
free_proxies(sess);
/* Create URI for session to pass off to libproxy */
memset(&uri, 0, sizeof uri);
ne_fill_server_uri(sess, &uri);
uri.path = "/"; /* make valid URI structure. */
url = ne_uri_unparse(&uri);
uri.path = NULL;
/* Get list of pseudo-URIs from libproxy: */
proxies = px_proxy_factory_get_proxies(pxf, url);
for (n = 0, lasthi = &sess->proxies; proxies[n]; n++) {
enum proxy_type ptype;
ne_uri_free(&uri);
NE_DEBUG(NE_DBG_HTTP, "sess: libproxy #%u=%s\n",
n, proxies[n]);
if (ne_uri_parse(proxies[n], &uri))
continue;
if (!uri.scheme) continue;
if (ne_strcasecmp(uri.scheme, "http") == 0)
ptype = PROXY_HTTP;
else if (ne_strcasecmp(uri.scheme, "socks") == 0)
ptype = PROXY_SOCKS;
else if (ne_strcasecmp(uri.scheme, "direct") == 0)
ptype = PROXY_NONE;
else
continue;
/* Hostname/port required for http/socks schemes. */
if (ptype != PROXY_NONE && !(uri.host && uri.port))
continue;
/* Do nothing if libproxy returned only a single "direct://"
* entry -- a single "direct" (noop) proxy is equivalent to
* having none. */
if (n == 0 && proxies[1] == NULL && ptype == PROXY_NONE)
break;
NE_DEBUG(NE_DBG_HTTP, "sess: Got proxy %s://%s:%d\n",
uri.scheme, uri.host ? uri.host : "(none)",
uri.port);
hi = *lasthi = ne_calloc(sizeof *hi);
if (ptype == PROXY_NONE) {
/* A "direct" URI requires an attempt to connect directly to
* the origin server, so dup the server details. */
set_hostinfo(hi, ptype, sess->server.hostname,
sess->server.port);
}
else {
/* SOCKS/HTTP proxy. */
set_hostinfo(hi, ptype, uri.host, uri.port);
if (ptype == PROXY_HTTP)
sess->any_proxy_http = 1;
else if (ptype == PROXY_SOCKS)
sess->socks_ver = NE_SOCK_SOCKSV5;
}
lasthi = &hi->next;
}
/* Free up the proxies array: */
for (n = 0; proxies[n]; n++)
free(proxies[n]);
free(proxies[n]);
ne_free(url);
ne_uri_free(&uri);
px_proxy_factory_free(pxf);
#endif
}
int main(int argc, char **argv)
{
struct openconnect_info *vpninfo;
char *urlpath = NULL;
char *proxy = getenv("https_proxy");
char *vpnc_script = NULL, *ifname = NULL;
const struct oc_ip_info *ip_info;
int autoproxy = 0;
int opt;
char *pidfile = NULL;
int use_dtls = 1;
FILE *fp = NULL;
char *config_arg;
char *token_str = NULL;
oc_token_mode_t token_mode = OC_TOKEN_MODE_NONE;
int reconnect_timeout = 300;
int ret;
#ifndef _WIN32
struct sigaction sa;
struct utsname utsbuf;
uid_t uid = getuid();
int use_syslog = 0;
int script_tun = 0;
#endif
#ifdef ENABLE_NLS
bindtextdomain("openconnect", LOCALEDIR);
setlocale(LC_ALL, "");
#endif
if (strcmp(openconnect_version_str, openconnect_binary_version)) {
fprintf(stderr, _("WARNING: This version of openconnect is %s but\n"
" the libopenconnect library is %s\n"),
openconnect_binary_version, openconnect_version_str);
}
openconnect_init_ssl();
vpninfo = openconnect_vpninfo_new((char *)"Open AnyConnect VPN Agent",
validate_peer_cert, NULL, process_auth_form_cb, write_progress, NULL);
if (!vpninfo) {
fprintf(stderr, _("Failed to allocate vpninfo structure\n"));
exit(1);
}
vpninfo->cbdata = vpninfo;
#ifdef _WIN32
set_default_vpncscript();
#else
if (!uname(&utsbuf)) {
free(vpninfo->localname);
vpninfo->localname = xstrdup(utsbuf.nodename);
}
#endif
while ((opt = next_option(argc, argv, &config_arg))) {
if (opt < 0)
break;
switch (opt) {
case OPT_CONFIGFILE:
if (config_file) {
fprintf(stderr, _("Cannot use 'config' option inside config file\n"));
exit(1);
}
config_file = fopen(config_arg, "r");
if (!config_file) {
fprintf(stderr, _("Cannot open config file '%s': %s\n"),
config_arg, strerror(errno));
exit(1);
}
config_line_num = 1;
/* The next option will come from the file... */
break;
case OPT_CAFILE:
openconnect_set_cafile(vpninfo, xstrdup(config_arg));
break;
case OPT_PIDFILE:
pidfile = keep_config_arg();
break;
case OPT_PFS:
openconnect_set_pfs(vpninfo, 1);
break;
case OPT_SERVERCERT:
openconnect_set_server_cert_sha1(vpninfo, xstrdup(config_arg));
break;
case OPT_NO_DTLS:
use_dtls = 0;
break;
case OPT_COOKIEONLY:
cookieonly = 1;
break;
case OPT_PRINTCOOKIE:
cookieonly = 2;
break;
case OPT_AUTHENTICATE:
cookieonly = 3;
break;
case OPT_COOKIE_ON_STDIN:
read_stdin(&vpninfo->cookie, 0);
/* If the cookie is empty, ignore it */
if (!*vpninfo->cookie)
vpninfo->cookie = NULL;
break;
case OPT_PASSWORD_ON_STDIN:
read_stdin(&password, 0);
break;
case OPT_NO_PASSWD:
vpninfo->nopasswd = 1;
break;
case OPT_NO_XMLPOST:
openconnect_set_xmlpost(vpninfo, 0);
break;
case OPT_NON_INTER:
non_inter = 1;
break;
case OPT_RECONNECT_TIMEOUT:
reconnect_timeout = atoi(config_arg);
break;
case OPT_DTLS_CIPHERS:
vpninfo->dtls_ciphers = keep_config_arg();
break;
case OPT_AUTHGROUP:
authgroup = keep_config_arg();
break;
#ifndef _WIN32
case 'b':
background = 1;
break;
#endif
case 'C':
vpninfo->cookie = strdup(config_arg);
break;
case 'c':
vpninfo->cert = strdup(config_arg);
break;
case 'e':
vpninfo->cert_expire_warning = 86400 * atoi(config_arg);
break;
case 'k':
vpninfo->sslkey = strdup(config_arg);
break;
case 'd':
vpninfo->deflate = 1;
break;
case 'D':
vpninfo->deflate = 0;
break;
case 'g':
free(urlpath);
urlpath = strdup(config_arg);
break;
case 'h':
usage();
case 'i':
ifname = xstrdup(config_arg);
break;
#ifndef _WIN32
case 'l':
use_syslog = 1;
break;
#endif
case 'm': {
int mtu = atol(config_arg);
if (mtu < 576) {
fprintf(stderr, _("MTU %d too small\n"), mtu);
mtu = 576;
}
openconnect_set_reqmtu(vpninfo, mtu);
break;
}
case OPT_BASEMTU:
vpninfo->basemtu = atol(config_arg);
if (vpninfo->basemtu < 576) {
fprintf(stderr, _("MTU %d too small\n"), vpninfo->basemtu);
vpninfo->basemtu = 576;
}
break;
case 'p':
vpninfo->cert_password = strdup(config_arg);
break;
case 'P':
proxy = keep_config_arg();
autoproxy = 0;
break;
case OPT_PROXY_AUTH:
openconnect_set_proxy_auth(vpninfo, xstrdup(config_arg));
break;
case OPT_NO_PROXY:
autoproxy = 0;
proxy = NULL;
break;
case OPT_LIBPROXY:
autoproxy = 1;
proxy = NULL;
break;
case OPT_NO_HTTP_KEEPALIVE:
fprintf(stderr,
_("Disabling all HTTP connection re-use due to --no-http-keepalive option.\n"
"If this helps, please report to <*****@*****.**>.\n"));
vpninfo->no_http_keepalive = 1;
break;
case OPT_NO_CERT_CHECK:
nocertcheck = 1;
break;
case 's':
vpnc_script = xstrdup(config_arg);
break;
#ifndef _WIN32
case 'S':
script_tun = 1;
break;
#endif
case 'u':
free(username);
username = strdup(config_arg);
break;
#ifndef _WIN32
case 'U': {
char *strend;
uid = strtol(config_arg, &strend, 0);
if (strend[0]) {
struct passwd *pw = getpwnam(config_arg);
if (!pw) {
fprintf(stderr, _("Invalid user \"%s\"\n"),
config_arg);
exit(1);
}
uid = pw->pw_uid;
}
break;
}
case OPT_CSD_USER: {
char *strend;
vpninfo->uid_csd = strtol(config_arg, &strend, 0);
if (strend[0]) {
struct passwd *pw = getpwnam(config_arg);
if (!pw) {
fprintf(stderr, _("Invalid user \"%s\"\n"),
config_arg);
exit(1);
}
vpninfo->uid_csd = pw->pw_uid;
}
vpninfo->uid_csd_given = 1;
break;
}
case OPT_CSD_WRAPPER:
vpninfo->csd_wrapper = keep_config_arg();
break;
#endif
case OPT_DISABLE_IPV6:
vpninfo->disable_ipv6 = 1;
break;
case 'Q':
vpninfo->max_qlen = atol(config_arg);
if (!vpninfo->max_qlen) {
fprintf(stderr, _("Queue length zero not permitted; using 1\n"));
vpninfo->max_qlen = 1;
}
break;
case 'q':
verbose = PRG_ERR;
break;
case OPT_DUMP_HTTP:
vpninfo->dump_http_traffic = 1;
break;
case 'v':
verbose++;
break;
case 'V':
printf(_("OpenConnect version %s\n"), openconnect_version_str);
print_build_opts();
exit(0);
case 'x':
vpninfo->xmlconfig = keep_config_arg();
vpninfo->write_new_config = write_new_config;
break;
case OPT_KEY_PASSWORD_FROM_FSID:
do_passphrase_from_fsid = 1;
break;
case OPT_USERAGENT:
free(vpninfo->useragent);
vpninfo->useragent = strdup(config_arg);
break;
case OPT_FORCE_DPD:
openconnect_set_dpd(vpninfo, atoi(config_arg));
break;
case OPT_DTLS_LOCAL_PORT:
vpninfo->dtls_local_port = atoi(config_arg);
break;
case OPT_TOKEN_MODE:
if (strcasecmp(config_arg, "rsa") == 0) {
token_mode = OC_TOKEN_MODE_STOKEN;
} else if (strcasecmp(config_arg, "totp") == 0) {
token_mode = OC_TOKEN_MODE_TOTP;
} else if (strcasecmp(config_arg, "hotp") == 0) {
token_mode = OC_TOKEN_MODE_HOTP;
} else {
fprintf(stderr, _("Invalid software token mode \"%s\"\n"),
config_arg);
exit(1);
}
break;
case OPT_TOKEN_SECRET:
token_str = keep_config_arg();
break;
case OPT_OS:
if (openconnect_set_reported_os(vpninfo, config_arg)) {
fprintf(stderr, _("Invalid OS identity \"%s\"\n"),
config_arg);
exit(1);
}
if (!strcmp(config_arg, "android") || !strcmp(config_arg, "apple-ios")) {
/* generic defaults */
openconnect_set_mobile_info(vpninfo,
xstrdup("1.0"),
xstrdup(config_arg),
xstrdup("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"));
}
break;
case OPT_TIMESTAMP:
timestamp = 1;
break;
default:
usage();
}
}
if (optind < argc - 1) {
fprintf(stderr, _("Too many arguments on command line\n"));
usage();
} else if (optind > argc - 1) {
fprintf(stderr, _("No server specified\n"));
usage();
}
if (!vpninfo->sslkey)
vpninfo->sslkey = vpninfo->cert;
if (vpninfo->dump_http_traffic && verbose < PRG_DEBUG)
verbose = PRG_DEBUG;
vpninfo->progress = write_progress;
if (autoproxy) {
#ifdef LIBPROXY_HDR
vpninfo->proxy_factory = px_proxy_factory_new();
#else
fprintf(stderr, _("This version of openconnect was built without libproxy support\n"));
exit(1);
#endif
}
if (token_mode != OC_TOKEN_MODE_NONE)
init_token(vpninfo, token_mode, token_str);
if (proxy && openconnect_set_http_proxy(vpninfo, strdup(proxy)))
exit(1);
#ifndef _WIN32
if (use_syslog) {
#ifndef __ANDROID__
openlog("openconnect", LOG_PID, LOG_DAEMON);
#endif
vpninfo->progress = syslog_progress;
}
#endif /* !_WIN32 */
sig_cmd_fd = openconnect_setup_cmd_pipe(vpninfo);
if (sig_cmd_fd < 0) {
fprintf(stderr, _("Error opening cmd pipe\n"));
exit(1);
}
#ifndef _WIN32
memset(&sa, 0, sizeof(sa));
sa.sa_handler = handle_signal;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGHUP, &sa, NULL);
sigaction(SIGUSR2, &sa, NULL);
#endif /* !_WIN32 */
if (vpninfo->sslkey && do_passphrase_from_fsid)
openconnect_passphrase_from_fsid(vpninfo);
if (config_lookup_host(vpninfo, argv[optind]))
exit(1);
if (!vpninfo->hostname) {
char *url = strdup(argv[optind]);
if (openconnect_parse_url(vpninfo, url))
exit(1);
free(url);
}
/* Historically, the path in the URL superseded the one in the
* --usergroup argument, just because of the order in which they
* were processed. Preserve that behaviour. */
if (urlpath && !vpninfo->urlpath) {
vpninfo->urlpath = urlpath;
urlpath = NULL;
}
free(urlpath);
#ifdef SSL_UI
set_openssl_ui();
#endif
if (!vpninfo->cookie && openconnect_obtain_cookie(vpninfo)) {
if (vpninfo->csd_scriptname) {
unlink(vpninfo->csd_scriptname);
vpninfo->csd_scriptname = NULL;
}
fprintf(stderr, _("Failed to obtain WebVPN cookie\n"));
exit(1);
}
if (cookieonly == 3) {
/* --authenticate */
printf("COOKIE='%s'\n", vpninfo->cookie);
printf("HOST='%s'\n", openconnect_get_hostname(vpninfo));
if (vpninfo->peer_cert) {
char buf[41] = {0, };
openconnect_get_cert_sha1(vpninfo, vpninfo->peer_cert, buf);
printf("FINGERPRINT='%s'\n", buf);
}
openconnect_vpninfo_free(vpninfo);
exit(0);
} else if (cookieonly) {
printf("%s\n", vpninfo->cookie);
if (cookieonly == 1) {
/* We use cookieonly=2 for 'print it and continue' */
openconnect_vpninfo_free(vpninfo);
exit(0);
}
}
if (openconnect_make_cstp_connection(vpninfo)) {
fprintf(stderr, _("Creating SSL connection failed\n"));
openconnect_vpninfo_free(vpninfo);
exit(1);
}
if (!vpnc_script)
vpnc_script = xstrdup(default_vpncscript);
#ifndef _WIN32
if (script_tun) {
if (openconnect_setup_tun_script(vpninfo, vpnc_script)) {
fprintf(stderr, _("Set up tun script failed\n"));
openconnect_vpninfo_free(vpninfo);
exit(1);
}
} else
#endif
if (openconnect_setup_tun_device(vpninfo, vpnc_script, ifname)) {
fprintf(stderr, _("Set up tun device failed\n"));
openconnect_vpninfo_free(vpninfo);
exit(1);
}
#ifndef _WIN32
if (uid != getuid()) {
if (setuid(uid)) {
fprintf(stderr, _("Failed to set uid %ld\n"),
(long)uid);
openconnect_vpninfo_free(vpninfo);
exit(1);
}
}
#endif
if (use_dtls && openconnect_setup_dtls(vpninfo, 60))
fprintf(stderr, _("Set up DTLS failed; using SSL instead\n"));
openconnect_get_ip_info(vpninfo, &ip_info, NULL, NULL);
vpn_progress(vpninfo, PRG_INFO,
_("Connected %s as %s%s%s, using %s\n"), openconnect_get_ifname(vpninfo),
ip_info->addr?:"",
(ip_info->netmask6 && ip_info->addr) ? " + " : "",
ip_info->netmask6 ? : "",
(vpninfo->dtls_state != DTLS_CONNECTED) ?
(vpninfo->deflate ? "SSL + deflate" : "SSL")
: "DTLS");
if (!vpninfo->vpnc_script) {
vpn_progress(vpninfo, PRG_INFO,
_("No --script argument provided; DNS and routing are not configured\n"));
vpn_progress(vpninfo, PRG_INFO,
_("See http://www.infradead.org/openconnect/vpnc-script.html\n"));
}
#ifndef _WIN32
if (background) {
int pid;
/* Open the pidfile before forking, so we can report errors
more sanely. It's *possible* that we'll fail to write to
it, but very unlikely. */
if (pidfile != NULL) {
fp = fopen(pidfile, "w");
if (!fp) {
fprintf(stderr, _("Failed to open '%s' for write: %s\n"),
pidfile, strerror(errno));
openconnect_vpninfo_free(vpninfo);
exit(1);
}
}
if ((pid = fork())) {
if (fp) {
fprintf(fp, "%d\n", pid);
fclose(fp);
}
vpn_progress(vpninfo, PRG_INFO,
_("Continuing in background; pid %d\n"),
pid);
openconnect_vpninfo_free(vpninfo);
exit(0);
}
if (fp)
fclose(fp);
}
#endif
while (1) {
ret = openconnect_mainloop(vpninfo, reconnect_timeout, RECONNECT_INTERVAL_MIN);
if (ret)
break;
vpn_progress(vpninfo, PRG_INFO, _("User requested reconnect\n"));
}
if (fp)
unlink(pidfile);
switch (ret) {
case -EPERM:
vpn_progress(vpninfo, PRG_ERR, _("Cookie was rejected on reconnection; exiting.\n"));
ret = 2;
break;
case -EPIPE:
vpn_progress(vpninfo, PRG_ERR, _("Session terminated by server; exiting.\n"));
ret = 1;
break;
case -EINTR:
vpn_progress(vpninfo, PRG_INFO, _("User canceled (SIGINT); exiting.\n"));
ret = 0;
break;
case -ECONNABORTED:
vpn_progress(vpninfo, PRG_INFO, _("User detached from session (SIGHUP); exiting.\n"));
ret = 0;
break;
default:
vpn_progress(vpninfo, PRG_ERR, _("Unknown error; exiting.\n"));
ret = 1;
break;
}
openconnect_vpninfo_free(vpninfo);
exit(ret);
}
static void
g_libproxy_resolver_init (GLibProxyResolver *resolver)
{
resolver->factory = px_proxy_factory_new ();
}
static void
update_proxy_settings (void)
{
char *mode, *http_proxy, *https_proxy = NULL, *no_proxy = NULL;
GSList *ignore;
/* resolver_gnome is locked */
if (proxy_user) {
g_free (proxy_user);
proxy_user = NULL;
}
if (proxy_password) {
memset (proxy_password, 0, strlen (proxy_password));
g_free (proxy_password);
proxy_password = NULL;
}
/* Get new settings */
mode = gconf_client_get_string (
gconf_client, SOUP_GCONF_PROXY_MODE, NULL);
if (!mode || !gconf_string_to_enum (proxy_mode_map, mode,
(int *)&proxy_mode))
proxy_mode = SOUP_PROXY_RESOLVER_GNOME_MODE_NONE;
g_free (mode);
if (proxy_mode == SOUP_PROXY_RESOLVER_GNOME_MODE_NONE) {
if (libproxy_factory) {
/* Unset anything we previously set */
g_unsetenv ("PX_CONFIG_ORDER");
g_unsetenv ("http_proxy");
g_unsetenv ("https_proxy");
g_unsetenv ("no_proxy");
}
return;
} else if (proxy_mode == SOUP_PROXY_RESOLVER_GNOME_MODE_AUTO) {
char *autoconfig_url;
autoconfig_url = gconf_client_get_string (
gconf_client, SOUP_GCONF_PROXY_AUTOCONFIG_URL, NULL);
if (autoconfig_url && !strncmp (autoconfig_url, "http", 4))
http_proxy = g_strconcat ("pac+", autoconfig_url, NULL);
else
http_proxy = g_strdup ("wpad://");
g_free (autoconfig_url);
} else /* SOUP_PROXY_RESOLVER_GNOME_MODE_MANUAL */ {
char *host;
guint port;
host = gconf_client_get_string (
gconf_client, SOUP_GCONF_HTTP_PROXY_HOST, NULL);
if (!host || !*host) {
g_free (host);
proxy_mode = SOUP_PROXY_RESOLVER_GNOME_MODE_NONE;
return;
}
port = gconf_client_get_int (
gconf_client, SOUP_GCONF_HTTP_PROXY_PORT, NULL);
if (port) {
http_proxy = g_strdup_printf ("http://%s:%u",
host, port);
} else
http_proxy = g_strdup_printf ("http://%s", host);
g_free (host);
if (!gconf_client_get_bool (gconf_client, SOUP_GCONF_USE_SAME_PROXY, NULL)) {
host = gconf_client_get_string (
gconf_client, SOUP_GCONF_HTTPS_PROXY_HOST, NULL);
port = gconf_client_get_int (
gconf_client, SOUP_GCONF_HTTPS_PROXY_PORT, NULL);
if (host && *host) {
if (port) {
https_proxy = g_strdup_printf (
"http://%s:%u", host, port);
} else {
https_proxy = g_strdup_printf (
"http://%s", host);
}
}
g_free (host);
}
if (gconf_client_get_bool (gconf_client, SOUP_GCONF_HTTP_USE_AUTH, NULL)) {
proxy_user = gconf_client_get_string (
gconf_client, SOUP_GCONF_HTTP_PROXY_USER, NULL);
proxy_password = gconf_client_get_string (
gconf_client, SOUP_GCONF_HTTP_PROXY_PASSWORD, NULL);
}
}
ignore = gconf_client_get_list (
gconf_client, SOUP_GCONF_PROXY_IGNORE_HOSTS,
GCONF_VALUE_STRING, NULL);
if (ignore) {
GString *ignore_list;
GSList *i;
ignore_list = g_string_new (NULL);
for (i = ignore; i; i = i->next) {
if (ignore_list->len)
g_string_append_c (ignore_list, ',');
g_string_append (ignore_list, i->data);
g_free (i->data);
}
g_slist_free (ignore);
no_proxy = g_string_free (ignore_list, FALSE);
}
g_setenv ("PX_CONFIG_ORDER", "envvar", TRUE);
g_setenv ("http_proxy", http_proxy, TRUE);
g_free (http_proxy);
if (https_proxy) {
g_setenv ("https_proxy", https_proxy, TRUE);
g_free (https_proxy);
} else
g_unsetenv ("https_proxy");
if (no_proxy) {
g_setenv ("no_proxy", no_proxy, TRUE);
g_free (no_proxy);
} else
g_unsetenv ("no_proxy");
/* If we haven't created a proxy factory or thread pool yet,
* do so. If we already have one, we don't need to update
* anything, because it rechecks the environment variables
* every time.
*/
if (!libproxy_factory)
libproxy_factory = px_proxy_factory_new ();
if (proxy_mode == SOUP_PROXY_RESOLVER_GNOME_MODE_AUTO &&
!libproxy_threadpool) {
libproxy_threadpool =
g_thread_pool_new (libproxy_threadpool_func,
NULL, -1, FALSE, NULL);
}
}
nsresult
nsUnixSystemProxySettings::GetProxyForURI(nsIURI* aURI, nsACString& aResult)
{
nsresult rv;
if (!mProxyFactory) {
mProxyFactory = px_proxy_factory_new();
}
NS_ENSURE_TRUE(mProxyFactory, NS_ERROR_NOT_AVAILABLE);
nsCOMPtr<nsIIOService> ios = do_GetIOService(&rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCAutoString spec;
rv = aURI->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
char **proxyArray = nsnull;
proxyArray = px_proxy_factory_get_proxies(mProxyFactory, (char*)(spec.get()));
NS_ENSURE_TRUE(proxyArray, NS_ERROR_NOT_AVAILABLE);
// Translate libproxy's output to PAC string as expected
// libproxy returns an array of proxies in the format:
// <procotol>://[username:password@]proxy:port
// or
// direct://
//
// PAC format: "PROXY proxy1.foo.com:8080; PROXY proxy2.foo.com:8080; DIRECT"
int c = 0;
while (proxyArray[c] != NULL) {
if (!aResult.IsEmpty()) {
aResult.AppendLiteral("; ");
}
bool isScheme = false;
nsXPIDLCString schemeString;
nsXPIDLCString hostPortString;
nsCOMPtr<nsIURI> proxyURI;
rv = ios->NewURI(nsDependentCString(proxyArray[c]),
nsnull,
nsnull,
getter_AddRefs(proxyURI));
if (NS_FAILED(rv)) {
c++;
continue;
}
proxyURI->GetScheme(schemeString);
if (NS_SUCCEEDED(proxyURI->SchemeIs("http", &isScheme)) && isScheme) {
schemeString.AssignLiteral("proxy");
}
aResult.Append(schemeString);
if (NS_SUCCEEDED(proxyURI->SchemeIs("direct", &isScheme)) && !isScheme) {
// Add the proxy URI only if it's not DIRECT
proxyURI->GetHostPort(hostPortString);
aResult.AppendLiteral(" ");
aResult.Append(hostPortString);
}
c++;
}
#ifdef DEBUG
printf("returned PAC proxy string: %s\n", PromiseFlatCString(aResult).get());
#endif
PR_Free(proxyArray);
return NS_OK;
}
int
main (int argc, char *argv[])
{
int i;
int ret;
#ifdef WIN32
char hexchat_lang[13]; /* LC_ALL= plus 5 chars of hex_gui_lang and trailing \0 */
#endif
srand (time (0)); /* CL: do this only once! */
/* We must check for the config dir parameter, otherwise load_config() will behave incorrectly.
* load_config() must come before fe_args() because fe_args() calls gtk_init() which needs to
* know the language which is set in the config. The code below is copy-pasted from fe_args()
* for the most part. */
if (argc >= 3)
{
for (i = 1; i < argc - 1; i++)
{
if (strcmp (argv[i], "-d") == 0)
{
if (xdir)
{
g_free (xdir);
}
xdir = strdup (argv[i + 1]);
if (xdir[strlen (xdir) - 1] == G_DIR_SEPARATOR)
{
xdir[strlen (xdir) - 1] = 0;
}
}
}
}
#if ! GLIB_CHECK_VERSION (2, 36, 0)
g_type_init ();
#endif
load_config ();
#ifdef WIN32
/* we MUST do this after load_config () AND before fe_init (thus gtk_init) otherwise it will fail */
strcpy (hexchat_lang, "LC_ALL=");
/* this must be ordered EXACTLY as langsmenu[] */
switch (prefs.hex_gui_lang)
{
case 0:
strcat (hexchat_lang, "af");
break;
case 1:
strcat (hexchat_lang, "sq");
break;
case 2:
strcat (hexchat_lang, "am");
break;
case 3:
strcat (hexchat_lang, "ast");
break;
case 4:
strcat (hexchat_lang, "az");
break;
case 5:
strcat (hexchat_lang, "eu");
break;
case 6:
strcat (hexchat_lang, "be");
break;
case 7:
strcat (hexchat_lang, "bg");
break;
case 8:
strcat (hexchat_lang, "ca");
break;
case 9:
strcat (hexchat_lang, "zh_CN");
break;
case 10:
strcat (hexchat_lang, "zh_TW");
break;
case 11:
strcat (hexchat_lang, "cs");
break;
case 12:
strcat (hexchat_lang, "da");
break;
case 13:
strcat (hexchat_lang, "nl");
break;
case 14:
strcat (hexchat_lang, "en_GB");
break;
case 15:
strcat (hexchat_lang, "en");
break;
case 16:
strcat (hexchat_lang, "et");
break;
case 17:
strcat (hexchat_lang, "fi");
break;
case 18:
strcat (hexchat_lang, "fr");
break;
case 19:
strcat (hexchat_lang, "gl");
break;
case 20:
strcat (hexchat_lang, "de");
break;
case 21:
strcat (hexchat_lang, "el");
break;
case 22:
strcat (hexchat_lang, "gu");
break;
case 23:
strcat (hexchat_lang, "hi");
break;
case 24:
strcat (hexchat_lang, "hu");
break;
case 25:
strcat (hexchat_lang, "id");
break;
case 26:
strcat (hexchat_lang, "it");
break;
case 27:
strcat (hexchat_lang, "ja");
break;
case 28:
strcat (hexchat_lang, "kn");
break;
case 29:
strcat (hexchat_lang, "rw");
break;
case 30:
strcat (hexchat_lang, "ko");
break;
case 31:
strcat (hexchat_lang, "lv");
break;
case 32:
strcat (hexchat_lang, "lt");
break;
case 33:
strcat (hexchat_lang, "mk");
break;
case 34:
strcat (hexchat_lang, "ml");
break;
case 35:
strcat (hexchat_lang, "ms");
break;
case 36:
strcat (hexchat_lang, "nb");
break;
case 37:
strcat (hexchat_lang, "no");
break;
case 38:
strcat (hexchat_lang, "pl");
break;
case 39:
strcat (hexchat_lang, "pt");
break;
case 40:
strcat (hexchat_lang, "pt_BR");
break;
case 41:
strcat (hexchat_lang, "pa");
break;
case 42:
strcat (hexchat_lang, "ru");
break;
case 43:
strcat (hexchat_lang, "sr");
break;
case 44:
strcat (hexchat_lang, "sk");
break;
case 45:
strcat (hexchat_lang, "sl");
break;
case 46:
strcat (hexchat_lang, "es");
break;
case 47:
strcat (hexchat_lang, "sv");
break;
case 48:
strcat (hexchat_lang, "th");
break;
case 49:
strcat (hexchat_lang, "uk");
break;
case 50:
strcat (hexchat_lang, "vi");
break;
case 51:
strcat (hexchat_lang, "wa");
break;
default:
strcat (hexchat_lang, "en");
break;
}
putenv (hexchat_lang);
#endif
#ifdef SOCKS
SOCKSinit (argv[0]);
#endif
ret = fe_args (argc, argv);
if (ret != -1)
return ret;
#ifdef USE_DBUS
hexchat_remote ();
#endif
#ifdef USE_LIBPROXY
libproxy_factory = px_proxy_factory_new();
#endif
fe_init ();
xchat_init ();
fe_main ();
#ifdef USE_LIBPROXY
px_proxy_factory_free(libproxy_factory);
#endif
#ifdef USE_OPENSSL
if (ctx)
_SSL_context_free (ctx);
#endif
#ifdef USE_DEBUG
hexchat_mem_list ();
#endif
#ifdef WIN32
WSACleanup ();
#endif
return 0;
}
static void create_proxy_factory() {
pf = px_proxy_factory_new();
}
int
main (int argc, char *argv[])
{
int ret;
#ifdef WIN32
char hexchat_lang[13]; /* LC_ALL= plus 5 chars of gui_lang and trailing \0 */
HANDLE mutex;
#endif
srand (time (0)); /* CL: do this only once! */
load_config ();
#ifdef WIN32
/* we MUST do this after load_config () AND before fe_init (thus gtk_init) otherwise it will fail */
strcpy (hexchat_lang, "LC_ALL=");
switch (prefs.gui_lang)
{
case 0:
strcat (hexchat_lang, "sq");
break;
case 1:
strcat (hexchat_lang, "am");
break;
case 2:
strcat (hexchat_lang, "az");
break;
case 3:
strcat (hexchat_lang, "eu");
break;
case 4:
strcat (hexchat_lang, "be");
break;
case 5:
strcat (hexchat_lang, "bg");
break;
case 6:
strcat (hexchat_lang, "ca");
break;
case 7:
strcat (hexchat_lang, "zh_CN");
break;
case 8:
strcat (hexchat_lang, "zh_TW");
break;
case 9:
strcat (hexchat_lang, "cs");
break;
case 10:
strcat (hexchat_lang, "nl");
break;
case 11:
strcat (hexchat_lang, "en_GB");
break;
case 12:
strcat (hexchat_lang, "en_US");
break;
case 13:
strcat (hexchat_lang, "et");
break;
case 14:
strcat (hexchat_lang, "fi");
break;
case 15:
strcat (hexchat_lang, "fr");
break;
case 16:
strcat (hexchat_lang, "gl");
break;
case 17:
strcat (hexchat_lang, "de");
break;
case 18:
strcat (hexchat_lang, "el");
break;
case 19:
strcat (hexchat_lang, "hi");
break;
case 20:
strcat (hexchat_lang, "hu_HU");
break;
case 21:
strcat (hexchat_lang, "it");
break;
case 22:
strcat (hexchat_lang, "ja");
break;
case 23:
strcat (hexchat_lang, "kn");
break;
case 24:
strcat (hexchat_lang, "ko");
break;
case 25:
strcat (hexchat_lang, "lv");
break;
case 26:
strcat (hexchat_lang, "lt");
break;
case 27:
strcat (hexchat_lang, "mk");
break;
case 28:
strcat (hexchat_lang, "ms");
break;
case 29:
strcat (hexchat_lang, "nb");
break;
case 30:
strcat (hexchat_lang, "no");
break;
case 31:
strcat (hexchat_lang, "pl");
break;
case 32:
strcat (hexchat_lang, "pt");
break;
case 33:
strcat (hexchat_lang, "pt_BR");
break;
case 34:
strcat (hexchat_lang, "pa");
break;
case 35:
strcat (hexchat_lang, "ru");
break;
case 36:
strcat (hexchat_lang, "sr");
break;
case 37:
strcat (hexchat_lang, "sk");
break;
case 38:
strcat (hexchat_lang, "sl");
break;
case 39:
strcat (hexchat_lang, "es");
break;
case 40:
strcat (hexchat_lang, "sv");
break;
case 41:
strcat (hexchat_lang, "th");
break;
case 42:
strcat (hexchat_lang, "uk");
break;
case 43:
strcat (hexchat_lang, "vi");
break;
case 44:
strcat (hexchat_lang, "wa");
break;
default:
strcat (hexchat_lang, "en_US");
break;
}
putenv (hexchat_lang);
if (prefs.gui_one_instance && !portable_mode ())
{
DWORD error;
mutex = CreateMutex (NULL, TRUE, "Local\\hexchat");
error = GetLastError ();
if (error == ERROR_ALREADY_EXISTS || mutex == NULL)
{
/* restoring the XChat window from the tray via the taskbar icon
* only works correctly when X-Tray is used, but it's not a big deal
* since you can only minimize XChat to tray via the taskbar if you
* use X-Tray*/
if (hextray_mode ())
{
/* FindWindow() doesn't support wildcards so we check all the open windows */
EnumWindows (enum_windows_impl, NULL);
return 0;
}
else
{
return 1;
}
}
}
#endif
#ifdef SOCKS
SOCKSinit (argv[0]);
#endif
ret = fe_args (argc, argv);
if (ret != -1)
return ret;
#ifdef USE_DBUS
xchat_remote ();
#endif
#ifdef USE_LIBPROXY
libproxy_factory = px_proxy_factory_new();
#endif
fe_init ();
xchat_init ();
fe_main ();
#ifdef USE_LIBPROXY
px_proxy_factory_free(libproxy_factory);
#endif
#ifdef USE_OPENSSL
if (ctx)
_SSL_context_free (ctx);
#endif
#ifdef USE_DEBUG
xchat_mem_list ();
#endif
#ifdef WIN32
WSACleanup ();
if (prefs.gui_one_instance && !portable_mode ())
{
ReleaseMutex (mutex);
CloseHandle (mutex);
}
#endif
return 0;
}
